#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 M_PI;
double acos(double);
int /*<<< orphan*/ ellipseangle(double *, double, double, int, double *);
int /*<<< orphan*/ free(double *);
double *malloc(int);
double pow(double, double);
double sqrt(double);
void integratetransit(int m, int n, int k, double *planetx, double *planety,
                      double *z, double p, double *r, double *f, double *spotx,
                      double *spoty, double *spotradius, double *spotcontrast,
                      double *planetangle, double *answer) {
  int M, N, K;
  double ootflux;
  double trapeze;
  double spotcenterdistancesquared;
  double *spotcenterdistance, *spotangle;
  double *values;
  double d, planetspotangle;
  if (k == 0) {
    ootflux = 0.0;
    for (N = 0; N < n; N++) {
      ootflux += M_PI * *(r + N) * *(f + N);
    }
    for (M = 0; M < m; M++) {
      if (*(z + M) < 1.0 + p) {
        *answer = 0.0;
        for (N = 0; N < n; N++) {
          *answer += *(r + N) * (M_PI - *(planetangle + n * M + N)) * *(f + N);
        }
        *answer /= ootflux;
      } else {
        *answer = 1.0;
      }
      answer++;
    }
    answer -= m;
  } else {
    spotcenterdistance = malloc((k + k * n + n) * sizeof(double));
    spotangle = spotcenterdistance + k;
    values = spotcenterdistance + k * (n + 1);
    for (K = 0; K < k; K++) {
      spotcenterdistancesquared =
          (*(spotx + K) * *(spotx + K) + *(spoty + K) * *(spoty + K)) *
          (1.0 - *(spotradius + K) * *(spotradius + K));
      *(spotcenterdistance + K) = sqrt(spotcenterdistancesquared);
      ellipseangle(r, *(spotradius + K), *(spotcenterdistance + K), n,
                   spotangle + K * n);
    }
    ootflux = 0.0;
    for (N = 0; N < n; N++) {
      trapeze = M_PI;
      for (K = 0; K < k; K++) {
        trapeze += (*(spotcontrast + K) - 1.0) * *(spotangle + K * n + N);
      }
      ootflux += trapeze * *(r + N) * *(f + N);
    }
    for (M = 0; M < m; M++) {
      if (*(z + M) < 1.0 + p) {
        for (N = 0; N < n; N++) {
          *(values + N) = M_PI - *(planetangle + n * M + N);
        }
        for (K = 0; K < k; K++) {
          d = sqrt(pow(*(planetx + M) -
                           *(spotx + K) * sqrt(1.0 - *(spotradius + K) *
                                                         *(spotradius + K)),
                       2.0) +
                   pow(*(planety + M) -
                           *(spoty + K) * sqrt(1.0 - *(spotradius + K) *
                                                         *(spotradius + K)),
                       2.0));
          if ((*(spotcenterdistance + K) == 0) || (*(z + M) == 0)) {
            planetspotangle = 0.0;
          } else {
            planetspotangle =
                acos((pow(*(z + M), 2.0) + pow(*(spotcenterdistance + K), 2.0) -
                      d * d) /
                     (2.0 * *(z + M) * *(spotcenterdistance + K)));
          }
          for (N = 0; N < n; N++) {
            if (planetspotangle >
                *(planetangle + M * n + N) + *(spotangle + K * n + N)) {
              *(values + N) +=
                  (*(spotcontrast + K) - 1.0) * *(spotangle + K * n + N);
            } else if (*(spotangle + K * n + N) >
                       planetspotangle + *(planetangle + n * M + N)) {
              *(values + N) +=
                  (*(spotcontrast + K) - 1.0) *
                  (*(spotangle + K * n + N) - *(planetangle + n * M + N));
            } else if (*(planetangle + n * M + N) <=
                       planetspotangle + *(spotangle + K * n + N)) {
              if (2 * M_PI - planetspotangle >=
                  *(planetangle + n * M + N) + *(spotangle + K * n + N)) {
                *(values + N) += 0.5 * (*(spotcontrast + K) - 1.0) *
                                 (*(spotangle + K * n + N) + planetspotangle -
                                  *(planetangle + n * M + N));
              } else {
                *(values + N) += (*(spotcontrast + K) - 1.0) *
                                 (M_PI - *(planetangle + n * M + N));
              }
            }
          }
        }
        *answer = 0.0;
        for (N = 0; N < n; N++) {
          *answer += *(r + N) * *(f + N) * *(values + N);
        }
        *answer /= ootflux;
      } else {
        *answer = 1.0;
      }
      answer++;
    }
    answer -= m;
    free(spotcenterdistance);
  }
  return;
}


x86 assembly (clang, -O0):
<integratetransit>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    1330 <integratetransit+0x1d0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    120f <integratetransit+0xaf>
mov    0x2e17(%rip),%rax
movsd  (%rax),%xmm0
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%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    11be <integratetransit+0x5e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1311 <integratetransit+0x1b1>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xdc9(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12e7 <integratetransit+0x187>
mov    0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12cd <integratetransit+0x16d>
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2d70(%rip),%rax
movsd  (%rax),%xmm1
mov    0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1258 <integratetransit+0xf8>
movsd  -0x48(%rbp),%xmm1
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    12f7 <integratetransit+0x197>
mov    0x48(%rbp),%rax
movsd  0xd0d(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1216 <integratetransit+0xb6>
mov    -0x4(%rbp),%ecx
mov    0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x48(%rbp)
jmp    1c77 <integratetransit+0xb17>
mov    -0xc(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    %ecx,%eax
add    -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1479 <integratetransit+0x319>
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
movsd  0xbf3(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
call   1080 <sqrt@plt>
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rdi
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x3c(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
call   1060 <ellipseangle@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1388 <integratetransit+0x228>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    154d <integratetransit+0x3ed>
mov    0x2b4d(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    150e <integratetransit+0x3ae>
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb34(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ab <integratetransit+0x34b>
movsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%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    1488 <integratetransit+0x328>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c54 <integratetransit+0xaf4>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xa8b(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c2a <integratetransit+0xaca>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15db <integratetransit+0x47b>
mov    0x2a4a(%rip),%rax
movsd  (%rax),%xmm0
mov    0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    158b <integratetransit+0x42b>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ba9 <integratetransit+0xa49>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x9ab(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  -0xa8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x970(%rip),%xmm1
call   1070 <pow@plt>
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x8f4(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  -0x98(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x8b9(%rip),%xmm1
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1792 <integratetransit+0x632>
jp     1792 <integratetransit+0x632>
jmp    17b2 <integratetransit+0x652>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17bf <integratetransit+0x65f>
jp     17bf <integratetransit+0x65f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1860 <integratetransit+0x700>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x834(%rip),%xmm1
call   1070 <pow@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x812(%rip),%xmm1
call   1070 <pow@plt>
movsd  -0xb0(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  0x7c8(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
call   1040 <acos@plt>
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1b96 <integratetransit+0xa36>
movsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    1914 <integratetransit+0x7b4>
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x72d(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b83 <integratetransit+0xa23>
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%xmm1
mov    0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    19d3 <integratetransit+0x873>
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x68c(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b7e <integratetransit+0xa1e>
mov    0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1b79 <integratetransit+0xa19>
mov    0x25c3(%rip),%rax
movsd  (%rax),%xmm0
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jb     1b18 <integratetransit+0x9b8>
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x558(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x55c(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
addsd  -0x80(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b74 <integratetransit+0xa14>
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x4d3(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    0x24b0(%rip),%rax
movsd  (%rax),%xmm2
mov    0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b79 <integratetransit+0xa19>
jmp    1b7e <integratetransit+0xa1e>
jmp    1b83 <integratetransit+0xa23>
jmp    1b88 <integratetransit+0xa28>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1867 <integratetransit+0x707>
jmp    1b9b <integratetransit+0xa3b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15e2 <integratetransit+0x482>
mov    0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c10 <integratetransit+0xab0>
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bbb <integratetransit+0xa5b>
movsd  -0x48(%rbp),%xmm1
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    1c3a <integratetransit+0xada>
mov    0x48(%rbp),%rax
movsd  0x3ca(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1554 <integratetransit+0x3f4>
mov    -0x4(%rbp),%ecx
mov    0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x48(%rbp)
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<integratetransit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
movsd  %xmm0,0x18(%rsp)
mov    %r9,0x80(%rsp)
mov    %r8,0x100(%rsp)
mov    %rcx,0xf8(%rsp)
mov    %esi,%r15d
mov    0x178(%rsp),%rbp
mov    0x170(%rsp),%r14
mov    0x148(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0x140(%rsp),%rax
mov    %rax,0x8(%rsp)
test   %edx,%edx
je     1414 <integratetransit+0x2c4>
mov    %edx,%ebx
mov    %edi,0x30(%rsp)
mov    %r14,0x88(%rsp)
mov    %rbp,0x48(%rsp)
mov    0x168(%rsp),%r13
mov    0x160(%rsp),%r12
mov    0x158(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    0x150(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    %edx,%edi
imul   %r15d,%edi
add    %ebx,%edi
add    %r15d,%edi
shl    $0x3,%edi
call   1050 <malloc@plt>
movslq %ebx,%rcx
mov    %rax,0x58(%rsp)
lea    (%rax,%rcx,8),%rax
mov    %rax,0x40(%rsp)
movslq %r15d,%rax
mov    %rax,0x68(%rsp)
mov    %ebx,%eax
mov    %rax,0x60(%rsp)
mov    %rbx,0x38(%rsp)
test   %ebx,%ebx
mov    %r12,0x20(%rsp)
jle    12f6 <integratetransit+0x1a6>
mov    0x68(%rsp),%rax
lea    0x0(,%rax,8),%rbx
xor    %ebp,%ebp
mov    0x40(%rsp),%r14
jmp    129c <integratetransit+0x14c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   1070 <sqrt@plt>
mov    0x20(%rsp),%r12
movapd %xmm0,%xmm1
mov    0x58(%rsp),%rax
movsd  %xmm1,(%rax,%rbp,8)
movsd  (%r12,%rbp,8),%xmm0
mov    0x8(%rsp),%rdi
mov    %r15d,%esi
mov    %r14,%rdx
call   1060 <ellipseangle@plt>
add    $0x1,%rbp
add    %rbx,%r14
cmp    %rbp,0x60(%rsp)
je     12f6 <integratetransit+0x1a6>
mov    0xa0(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm1
mov    0xa8(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r12,%rbp,8),%xmm2
mulsd  %xmm2,%xmm2
movsd  0xd2c(%rip),%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
ucomisd 0xd34(%rip),%xmm0
jb     1260 <integratetransit+0x110>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    126e <integratetransit+0x11e>
mov    %r15d,%ebx
test   %r15d,%r15d
jle    1449 <integratetransit+0x2f9>
mov    0x2cdf(%rip),%rax
movsd  (%rax),%xmm0
mov    0x60(%rsp),%rax
and    $0xfffffffe,%eax
mov    %rbx,%rcx
shl    $0x4,%rcx
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x50(%rsp)
xor    %edx,%edx
movsd  0xcd8(%rip),%xmm1
mov    0x40(%rsp),%rbp
mov    0x48(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%r10
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%r14d
jmp    137d <integratetransit+0x22d>
mulsd  (%r10,%rdx,8),%xmm2
mulsd  (%r9,%rdx,8),%xmm2
movsd  0x50(%rsp),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x50(%rsp)
add    $0x1,%rdx
add    $0x8,%rbp
cmp    %rbx,%rdx
je     1462 <integratetransit+0x312>
movapd %xmm0,%xmm2
test   %r11d,%r11d
jle    1350 <integratetransit+0x200>
cmp    $0x1,%r11d
jne    13a0 <integratetransit+0x250>
xor    %edi,%edi
movapd %xmm0,%xmm2
jmp    13e3 <integratetransit+0x293>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rsi
xor    %edi,%edi
movapd %xmm0,%xmm2
nopl   0x0(%rax)
movsd  0x0(%r13,%rdi,8),%xmm3
addsd  %xmm1,%xmm3
mulsd  (%rsi),%xmm3
addsd  %xmm2,%xmm3
movsd  0x8(%r13,%rdi,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rsi,%rbx,8),%xmm2
addsd  %xmm3,%xmm2
add    $0x2,%rdi
add    %rcx,%rsi
cmp    %rdi,%rax
jne    13b0 <integratetransit+0x260>
testb  $0x1,0x60(%rsp)
je     1350 <integratetransit+0x200>
mov    0x40(%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
movsd  0x0(%r13,%rdi,8),%xmm3
addsd  %xmm1,%xmm3
imul   %rbx,%rdi
mulsd  (%rsi,%rdi,8),%xmm3
addsd  %xmm3,%xmm2
jmp    1350 <integratetransit+0x200>
test   %r15d,%r15d
jle    1a99 <integratetransit+0x949>
mov    0x2bc4(%rip),%rax
movsd  (%rax),%xmm1
mov    %r15d,%edx
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1aa2 <integratetransit+0x952>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1b17 <integratetransit+0x9c7>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x50(%rsp)
mov    0x48(%rsp),%r8
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%r14d
test   %r14d,%r14d
mov    0x20(%rsp),%rsi
jle    1a7e <integratetransit+0x92e>
mov    0x68(%rsp),%rdx
lea    0x1(%rdx),%eax
imul   %r11d,%eax
cltq
movsd  0x18(%rsp),%xmm0
addsd  0xb74(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
mov    %r14d,%r9d
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,0xd8(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xd0(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0xc8(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xb8(%rsp)
mov    %ebx,%r10d
and    $0xfffffffe,%r10d
mov    0x88(%rsp),%r12
lea    0x30(%r12),%rdi
lea    0x0(,%rdx,8),%rax
mov    %rax,0x98(%rsp)
xor    %edx,%edx
mov    %r15,0x90(%rsp)
mov    %r9,0x70(%rsp)
mov    %r10,0xc0(%rsp)
jmp    1554 <integratetransit+0x404>
mov    0x38(%rsp),%r11
mov    0x70(%rsp),%r9
mov    0x78(%rsp),%rdi
divsd  0x50(%rsp),%xmm0
mov    0x28(%rsp),%rdx
movsd  %xmm0,(%r8)
add    $0x8,%r8
add    $0x1,%rdx
mov    0x98(%rsp),%rax
add    %rax,%rdi
add    %rax,%r12
cmp    %r9,%rdx
je     1a7e <integratetransit+0x92e>
movsd  0x18(%rsp),%xmm0
mov    0x80(%rsp),%rax
ucomisd (%rax,%rdx,8),%xmm0
movsd  0xa91(%rip),%xmm0
jbe    1530 <integratetransit+0x3e0>
mov    %r8,0x48(%rsp)
test   %r15d,%r15d
mov    %rdx,0x28(%rsp)
jle    1689 <integratetransit+0x539>
mov    0x2a5d(%rip),%rax
movsd  (%rax),%xmm0
cmp    $0x4,%r15d
jae    159c <integratetransit+0x44c>
xor    %eax,%eax
jmp    1670 <integratetransit+0x520>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xd0(%rsp)
je     1a69 <integratetransit+0x919>
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movupd -0x30(%rdi,%rax,8),%xmm2
movupd -0x20(%rdi,%rax,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
movupd %xmm4,0x0(%rbp,%rax,8)
movupd %xmm2,0x10(%rbp,%rax,8)
movupd -0x10(%rdi,%rax,8),%xmm2
movupd (%rdi,%rax,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
movupd %xmm4,0x20(%rbp,%rax,8)
movupd %xmm2,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    15c0 <integratetransit+0x470>
testb  $0x1,0xc8(%rsp)
01
je     1660 <integratetransit+0x510>
mov    %rdx,%rcx
imul   0x68(%rsp),%rcx
mov    0x88(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    0x28(%rsp),%rdx
movupd (%rcx,%rax,8),%xmm2
movupd 0x10(%rcx,%rax,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
subpd  %xmm3,%xmm1
movupd %xmm4,0x0(%rbp,%rax,8)
movupd %xmm1,0x10(%rbp,%rax,8)
mov    0xd8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     1689 <integratetransit+0x539>
movapd %xmm0,%xmm1
subsd  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1670 <integratetransit+0x520>
mov    %rdi,0x78(%rsp)
test   %r11d,%r11d
jle    19a0 <integratetransit+0x850>
mov    0x40(%rsp),%r14
xor    %r15d,%r15d
jmp    16c7 <integratetransit+0x577>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
add    0x98(%rsp),%r14
cmp    0x60(%rsp),%r15
je     19a0 <integratetransit+0x850>
mov    0xf8(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm2
mov    0xa0(%rsp),%rax
movsd  (%rax,%r15,8),%xmm3
movsd  (%rsi,%r15,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  0x90c(%rip),%xmm0
subsd  %xmm1,%xmm0
ucomisd 0x918(%rip),%xmm0
movsd  %xmm2,0x30(%rsp)
movsd  %xmm3,0xb0(%rsp)
jb     1720 <integratetransit+0x5d0>
xorps  %xmm4,%xmm4
sqrtsd %xmm0,%xmm4
jmp    1733 <integratetransit+0x5e3>
nopw   0x0(%rax,%rax,1)
call   1070 <sqrt@plt>
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rsi
movapd %xmm0,%xmm4
mov    0x100(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm3
mov    0xa8(%rsp),%rax
movsd  (%rax,%r15,8),%xmm5
movsd  (%rsi,%r15,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  0x8a0(%rip),%xmm0
subsd  %xmm1,%xmm0
ucomisd 0x8ac(%rip),%xmm0
jb     1780 <integratetransit+0x630>
sqrtsd %xmm0,%xmm0
jmp    17bb <integratetransit+0x66b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm3,0xf0(%rsp)
movsd  %xmm4,0xe8(%rsp)
movsd  %xmm5,0xe0(%rsp)
call   1070 <sqrt@plt>
movsd  0xe0(%rsp),%xmm5
movsd  0xe8(%rsp),%xmm4
movsd  0xf0(%rsp),%xmm3
movsd  0x30(%rsp),%xmm1
movsd  0xb0(%rsp),%xmm2
mulsd  %xmm0,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm4,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
ucomisd 0x82a(%rip),%xmm3
jb     1800 <integratetransit+0x6b0>
xorps  %xmm1,%xmm1
sqrtsd %xmm3,%xmm1
jmp    180d <integratetransit+0x6bd>
nopl   0x0(%rax)
movapd %xmm3,%xmm0
call   1070 <sqrt@plt>
movapd %xmm0,%xmm1
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
movsd  0x7e9(%rip),%xmm7
mov    0x58(%rsp),%rax
movsd  (%rax,%r15,8),%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1836 <integratetransit+0x6e6>
jnp    1857 <integratetransit+0x707>
mov    0x80(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm3
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jne    1942 <integratetransit+0x7f2>
jp     1942 <integratetransit+0x7f2>
cmpl   $0x0,0x90(%rsp)
jle    16b0 <integratetransit+0x560>
mov    0x277c(%rip),%rax
movsd  (%rax),%xmm1
movapd %xmm1,%xmm2
addsd  %xmm1,%xmm2
subsd  %xmm0,%xmm2
xor    %eax,%eax
jmp    18a8 <integratetransit+0x758>
movsd  0x0(%r13,%r15,8),%xmm4
addsd  %xmm7,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x0(%rbp,%rax,8),%xmm4
movsd  %xmm4,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
je     16b0 <integratetransit+0x560>
movsd  (%r12,%rax,8),%xmm4
movsd  (%r14,%rax,8),%xmm3
movapd %xmm4,%xmm5
addsd  %xmm3,%xmm5
ucomisd %xmm5,%xmm0
ja     1880 <integratetransit+0x730>
movapd %xmm0,%xmm6
addsd  %xmm4,%xmm6
ucomisd %xmm6,%xmm3
jbe    1900 <integratetransit+0x7b0>
movsd  0x0(%r13,%r15,8),%xmm5
addsd  %xmm7,%xmm5
subsd  %xmm4,%xmm3
mulsd  %xmm5,%xmm3
addsd  0x0(%rbp,%rax,8),%xmm3
movsd  %xmm3,0x0(%rbp,%rax,8)
jmp    189b <integratetransit+0x74b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  %xmm0,%xmm3
ucomisd %xmm4,%xmm3
jb     189b <integratetransit+0x74b>
ucomisd %xmm5,%xmm2
movsd  0x0(%r13,%r15,8),%xmm5
addsd  %xmm7,%xmm5
jae    1938 <integratetransit+0x7e8>
movapd %xmm1,%xmm3
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm5
addsd  0x0(%rbp,%rax,8),%xmm5
movsd  %xmm5,0x0(%rbp,%rax,8)
jmp    189b <integratetransit+0x74b>
mulsd  0x6d0(%rip),%xmm5
jmp    18db <integratetransit+0x78b>
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
addsd  %xmm3,%xmm3
mulsd  %xmm2,%xmm3
divsd  %xmm3,%xmm0
call   1040 <acos@plt>
movsd  0x691(%rip),%xmm7
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rsi
cmpl   $0x0,0x90(%rsp)
jg     1865 <integratetransit+0x715>
jmp    16b0 <integratetransit+0x560>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x48(%rsp),%r8
movq   $0x0,(%r8)
mov    0x90(%rsp),%r15
xorpd  %xmm0,%xmm0
test   %r15d,%r15d
jle    1516 <integratetransit+0x3c6>
xor    %eax,%eax
cmp    $0x1,%r15d
jne    19df <integratetransit+0x88f>
mov    0x10(%rsp),%rcx
mov    0x8(%rsp),%rdx
mov    0x70(%rsp),%r9
mov    0x78(%rsp),%rdi
jmp    1a3d <integratetransit+0x8ed>
mov    0x10(%rsp),%rcx
mov    0x8(%rsp),%rdx
mov    0x70(%rsp),%r9
mov    0xc0(%rsp),%r10
mov    0x78(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm1
mulsd  (%rcx,%rax,8),%xmm1
mulsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r8)
movsd  0x8(%rdx,%rax,8),%xmm0
mulsd  0x8(%rcx,%rax,8),%xmm0
mulsd  0x8(%rbp,%rax,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1a00 <integratetransit+0x8b0>
test   $0x1,%bl
mov    0x38(%rsp),%r11
je     1525 <integratetransit+0x3d5>
movsd  (%rdx,%rax,8),%xmm1
mulsd  (%rcx,%rax,8),%xmm1
mulsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r8)
jmp    1525 <integratetransit+0x3d5>
xor    %eax,%eax
testb  $0x1,0xc8(%rsp)
01
jne    1623 <integratetransit+0x4d3>
jmp    1660 <integratetransit+0x510>
mov    0x58(%rsp),%rdi
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xorpd  %xmm0,%xmm0
jmp    1b4b <integratetransit+0x9fb>
and    $0xfffffffc,%edx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
mov    0x8(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  (%rsi,%rcx,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%rbx,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
mulsd  0x8(%rsi,%rcx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rbx,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x10(%rsi,%rcx,8),%xmm2
movsd  0x18(%rbx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x18(%rsi,%rcx,8),%xmm0
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1ac0 <integratetransit+0x970>
test   %rax,%rax
je     1b4b <integratetransit+0x9fb>
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0x8(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  (%rdx,%rsi,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1b30 <integratetransit+0x9e0>
test   %edi,%edi
jle    1c84 <integratetransit+0xb34>
movsd  0x18(%rsp),%xmm1
addsd  0x49f(%rip),%xmm1
movsd  %xmm1,0x18(%rsp)
movslq %r15d,%r8
mov    %edi,%r10d
mov    %r15d,%r9d
mov    %r9d,%r12d
and    $0xfffffffe,%r12d
lea    0x8(%r14),%rdi
lea    0x0(,%r8,8),%r11
xor    %ecx,%ecx
movsd  0x473(%rip),%xmm1
mov    0x2454(%rip),%rax
jmp    1bbd <integratetransit+0xa6d>
cs nopw 0x0(%rax,%rax,1)
divsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%rbp)
add    $0x8,%rbp
add    $0x1,%rcx
add    %r11,%rdi
cmp    %r10,%rcx
je     1c84 <integratetransit+0xb34>
movsd  0x18(%rsp),%xmm2
mov    0x80(%rsp),%rdx
ucomisd (%rdx,%rcx,8),%xmm2
movapd %xmm1,%xmm2
jbe    1ba4 <integratetransit+0xa54>
movq   $0x0,0x0(%rbp)
xorpd  %xmm2,%xmm2
test   %r15d,%r15d
jle    1ba0 <integratetransit+0xa50>
xor    %edx,%edx
cmp    $0x1,%r15d
je     1c44 <integratetransit+0xaf4>
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%rsi
nopl   0x0(%rax)
movsd  (%rax),%xmm3
subsd  -0x8(%rdi,%rdx,8),%xmm3
mulsd  (%rsi,%rdx,8),%xmm3
mulsd  (%rbx,%rdx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%rbp)
movsd  (%rax),%xmm2
subsd  (%rdi,%rdx,8),%xmm2
mulsd  0x8(%rsi,%rdx,8),%xmm2
mulsd  0x8(%rbx,%rdx,8),%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp)
add    $0x2,%rdx
cmp    %rdx,%r12
jne    1c00 <integratetransit+0xab0>
test   $0x1,%r9b
je     1ba0 <integratetransit+0xa50>
mov    %rcx,%rbx
imul   %r8,%rbx
lea    (%r14,%rbx,8),%rbx
movsd  (%rax),%xmm3
subsd  (%rbx,%rdx,8),%xmm3
mov    0x8(%rsp),%rsi
mulsd  (%rsi,%rdx,8),%xmm3
mov    0x10(%rsp),%rbx
mulsd  (%rbx,%rdx,8),%xmm3
addsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp)
jmp    1ba0 <integratetransit+0xa50>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@M_PI = global double 0.000000e+00
define void @integratetransit(i32 %0, i32 %1, i32 %2, double* %3, double* %4, double* %5, double %6, double* %7, double* %8, double* %9, double* %10, double* %11, double* %12, double* %13, double* %14) {
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%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 double*
%30 = alloca double*
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double*
%38 = alloca double*
%39 = alloca double*
%40 = alloca double
%41 = alloca double
store i32 %0, i32* %16
store i32 %1, i32* %17
store i32 %2, i32* %18
store double* %3, double** %19
store double* %4, double** %20
store double* %5, double** %21
store double %6, double* %22
store double* %7, double** %23
store double* %8, double** %24
store double* %9, double** %25
store double* %10, double** %26
store double* %11, double** %27
store double* %12, double** %28
store double* %13, double** %29
store double* %14, double** %30
%42 = load i32, i32* %18
%43 = icmp eq i32 %42, 0
br i1 %43, label %44, label %136
44: ; preds = %15
store double 0.000000e+00, double* %34
store i32 0, i32* %32
br label %45
45: ; preds = %64, %44
%46 = load i32, i32* %32
%47 = load i32, i32* %17
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %67
49: ; preds = %45
%50 = load double, double* @M_PI
%51 = load double*, double** %23
%52 = load i32, i32* %32
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double, double* %51, i64 %53
%55 = load double, double* %54
%56 = fmul double %50, %55
%57 = load double*, double** %24
%58 = load i32, i32* %32
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = load double, double* %34
%63 = call double @llvm.fmuladd.f64(double %56, double %61, double %62)
store double %63, double* %34
br label %64
64: ; preds = %49
%65 = load i32, i32* %32
%66 = add nsw i32 %65, 1
store i32 %66, i32* %32
br label %45
67: ; preds = %45
store i32 0, i32* %31
br label %68
68: ; preds = %127, %67
%69 = load i32, i32* %31
%70 = load i32, i32* %16
%71 = icmp slt i32 %69, %70
br i1 %71, label %72, label %130
72: ; preds = %68
%73 = load double*, double** %21
%74 = load i32, i32* %31
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds double, double* %73, i64 %75
%77 = load double, double* %76
%78 = load double, double* %22
%79 = fadd double 1.000000e+00, %78
%80 = fcmp olt double %77, %79
br i1 %80, label %81, label %122
81: ; preds = %72
%82 = load double*, double** %30
store double 0.000000e+00, double* %82
store i32 0, i32* %32
br label %83
83: ; preds = %114, %81
%84 = load i32, i32* %32
%85 = load i32, i32* %17
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %117
87: ; preds = %83
%88 = load double*, double** %23
%89 = load i32, i32* %32
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %88, i64 %90
%92 = load double, double* %91
%93 = load double, double* @M_PI
%94 = load double*, double** %29
%95 = load i32, i32* %17
%96 = load i32, i32* %31
%97 = mul nsw i32 %95, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %94, i64 %98
%100 = load i32, i32* %32
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double, double* %99, i64 %101
%103 = load double, double* %102
%104 = fsub double %93, %103
%105 = fmul double %92, %104
%106 = load double*, double** %24
%107 = load i32, i32* %32
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %106, i64 %108
%110 = load double, double* %109
%111 = load double*, double** %30
%112 = load double, double* %111
%113 = call double @llvm.fmuladd.f64(double %105, double %110, double %112)
store double %113, double* %111
br label %114
114: ; preds = %87
%115 = load i32, i32* %32
%116 = add nsw i32 %115, 1
store i32 %116, i32* %32
br label %83
117: ; preds = %83
%118 = load double, double* %34
%119 = load double*, double** %30
%120 = load double, double* %119
%121 = fdiv double %120, %118
store double %121, double* %119
br label %124
122: ; preds = %72
%123 = load double*, double** %30
store double 1.000000e+00, double* %123
br label %124
124: ; preds = %122, %117
%125 = load double*, double** %30
%126 = getelementptr inbounds double, double* %125, i32 1
store double* %126, double** %30
br label %127
127: ; preds = %124
%128 = load i32, i32* %31
%129 = add nsw i32 %128, 1
store i32 %129, i32* %31
br label %68
130: ; preds = %68
%131 = load i32, i32* %16
%132 = load double*, double** %30
%133 = sext i32 %131 to i64
%134 = sub i64 0, %133
%135 = getelementptr inbounds double, double* %132, i64 %134
store double* %135, double** %30
br label %707
136: ; preds = %15
%137 = load i32, i32* %18
%138 = load i32, i32* %18
%139 = load i32, i32* %17
%140 = mul nsw i32 %138, %139
%141 = add nsw i32 %137, %140
%142 = load i32, i32* %17
%143 = add nsw i32 %141, %142
%144 = sext i32 %143 to i64
%145 = mul i64 %144, 8
%146 = trunc i64 %145 to i32
%147 = call double* @malloc(i32 %146)
store double* %147, double** %37
%148 = load double*, double** %37
%149 = load i32, i32* %18
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %148, i64 %150
store double* %151, double** %38
%152 = load double*, double** %37
%153 = load i32, i32* %18
%154 = load i32, i32* %17
%155 = add nsw i32 %154, 1
%156 = mul nsw i32 %153, %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %152, i64 %157
store double* %158, double** %39
store i32 0, i32* %33
br label %159
159: ; preds = %224, %136
%160 = load i32, i32* %33
%161 = load i32, i32* %18
%162 = icmp slt i32 %160, %161
br i1 %162, label %163, label %227
163: ; preds = %159
%164 = load double*, double** %25
%165 = load i32, i32* %33
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds double, double* %164, i64 %166
%168 = load double, double* %167
%169 = load double*, double** %25
%170 = load i32, i32* %33
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %169, i64 %171
%173 = load double, double* %172
%174 = load double*, double** %26
%175 = load i32, i32* %33
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %174, i64 %176
%178 = load double, double* %177
%179 = load double*, double** %26
%180 = load i32, i32* %33
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %179, i64 %181
%183 = load double, double* %182
%184 = fmul double %178, %183
%185 = call double @llvm.fmuladd.f64(double %168, double %173, double %184)
%186 = load double*, double** %27
%187 = load i32, i32* %33
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %186, i64 %188
%190 = load double, double* %189
%191 = load double*, double** %27
%192 = load i32, i32* %33
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
%195 = load double, double* %194
%196 = fneg double %190
%197 = call double @llvm.fmuladd.f64(double %196, double %195, double 1.000000e+00)
%198 = fmul double %185, %197
store double %198, double* %36
%199 = load double, double* %36
%200 = call double @sqrt(double %199)
%201 = load double*, double** %37
%202 = load i32, i32* %33
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %201, i64 %203
store double %200, double* %204
%205 = load double*, double** %23
%206 = load double*, double** %27
%207 = load i32, i32* %33
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds double, double* %206, i64 %208
%210 = load double, double* %209
%211 = load double*, double** %37
%212 = load i32, i32* %33
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %211, i64 %213
%215 = load double, double* %214
%216 = load i32, i32* %17
%217 = load double*, double** %38
%218 = load i32, i32* %33
%219 = load i32, i32* %17
%220 = mul nsw i32 %218, %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %217, i64 %221
%223 = call i32 @ellipseangle(double* %205, double %210, double %215, i32 %216, double* %222)
br label %224
224: ; preds = %163
%225 = load i32, i32* %33
%226 = add nsw i32 %225, 1
store i32 %226, i32* %33
br label %159
227: ; preds = %159
store double 0.000000e+00, double* %34
store i32 0, i32* %32
br label %228
228: ; preds = %275, %227
%229 = load i32, i32* %32
%230 = load i32, i32* %17
%231 = icmp slt i32 %229, %230
br i1 %231, label %232, label %278
232: ; preds = %228
%233 = load double, double* @M_PI
store double %233, double* %35
store i32 0, i32* %33
br label %234
234: ; preds = %257, %232
%235 = load i32, i32* %33
%236 = load i32, i32* %18
%237 = icmp slt i32 %235, %236
br i1 %237, label %238, label %260
238: ; preds = %234
%239 = load double*, double** %28
%240 = load i32, i32* %33
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds double, double* %239, i64 %241
%243 = load double, double* %242
%244 = fsub double %243, 1.000000e+00
%245 = load double*, double** %38
%246 = load i32, i32* %33
%247 = load i32, i32* %17
%248 = mul nsw i32 %246, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %245, i64 %249
%251 = load i32, i32* %32
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = load double, double* %35
%256 = call double @llvm.fmuladd.f64(double %244, double %254, double %255)
store double %256, double* %35
br label %257
257: ; preds = %238
%258 = load i32, i32* %33
%259 = add nsw i32 %258, 1
store i32 %259, i32* %33
br label %234
260: ; preds = %234
%261 = load double, double* %35
%262 = load double*, double** %23
%263 = load i32, i32* %32
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds double, double* %262, i64 %264
%266 = load double, double* %265
%267 = fmul double %261, %266
%268 = load double*, double** %24
%269 = load i32, i32* %32
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %268, i64 %270
%272 = load double, double* %271
%273 = load double, double* %34
%274 = call double @llvm.fmuladd.f64(double %267, double %272, double %273)
store double %274, double* %34
br label %275
275: ; preds = %260
%276 = load i32, i32* %32
%277 = add nsw i32 %276, 1
store i32 %277, i32* %32
br label %228
278: ; preds = %228
store i32 0, i32* %31
br label %279
279: ; preds = %696, %278
%280 = load i32, i32* %31
%281 = load i32, i32* %16
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %699
283: ; preds = %279
%284 = load double*, double** %21
%285 = load i32, i32* %31
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double, double* %284, i64 %286
%288 = load double, double* %287
%289 = load double, double* %22
%290 = fadd double 1.000000e+00, %289
%291 = fcmp olt double %288, %290
br i1 %291, label %292, label %691
292: ; preds = %283
store i32 0, i32* %32
br label %293
293: ; preds = %314, %292
%294 = load i32, i32* %32
%295 = load i32, i32* %17
%296 = icmp slt i32 %294, %295
br i1 %296, label %297, label %317
297: ; preds = %293
%298 = load double, double* @M_PI
%299 = load double*, double** %29
%300 = load i32, i32* %17
%301 = load i32, i32* %31
%302 = mul nsw i32 %300, %301
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %299, i64 %303
%305 = load i32, i32* %32
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %304, i64 %306
%308 = load double, double* %307
%309 = fsub double %298, %308
%310 = load double*, double** %39
%311 = load i32, i32* %32
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds double, double* %310, i64 %312
store double %309, double* %313
br label %314
314: ; preds = %297
%315 = load i32, i32* %32
%316 = add nsw i32 %315, 1
store i32 %316, i32* %32
br label %293
317: ; preds = %293
store i32 0, i32* %33
br label %318
318: ; preds = %654, %317
%319 = load i32, i32* %33
%320 = load i32, i32* %18
%321 = icmp slt i32 %319, %320
br i1 %321, label %322, label %657
322: ; preds = %318
%323 = load double*, double** %19
%324 = load i32, i32* %31
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %323, i64 %325
%327 = load double, double* %326
%328 = load double*, double** %25
%329 = load i32, i32* %33
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %328, i64 %330
%332 = load double, double* %331
%333 = load double*, double** %27
%334 = load i32, i32* %33
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds double, double* %333, i64 %335
%337 = load double, double* %336
%338 = load double*, double** %27
%339 = load i32, i32* %33
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds double, double* %338, i64 %340
%342 = load double, double* %341
%343 = fneg double %337
%344 = call double @llvm.fmuladd.f64(double %343, double %342, double 1.000000e+00)
%345 = call double @sqrt(double %344)
%346 = fneg double %332
%347 = call double @llvm.fmuladd.f64(double %346, double %345, double %327)
%348 = call double @pow(double %347, double 2.000000e+00)
%349 = load double*, double** %20
%350 = load i32, i32* %31
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %349, i64 %351
%353 = load double, double* %352
%354 = load double*, double** %26
%355 = load i32, i32* %33
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds double, double* %354, i64 %356
%358 = load double, double* %357
%359 = load double*, double** %27
%360 = load i32, i32* %33
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %359, i64 %361
%363 = load double, double* %362
%364 = load double*, double** %27
%365 = load i32, i32* %33
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %364, i64 %366
%368 = load double, double* %367
%369 = fneg double %363
%370 = call double @llvm.fmuladd.f64(double %369, double %368, double 1.000000e+00)
%371 = call double @sqrt(double %370)
%372 = fneg double %358
%373 = call double @llvm.fmuladd.f64(double %372, double %371, double %353)
%374 = call double @pow(double %373, double 2.000000e+00)
%375 = fadd double %348, %374
%376 = call double @sqrt(double %375)
store double %376, double* %40
%377 = load double*, double** %37
%378 = load i32, i32* %33
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %377, i64 %379
%381 = load double, double* %380
%382 = fcmp oeq double %381, 0.000000e+00
br i1 %382, label %390, label %383
383: ; preds = %322
%384 = load double*, double** %21
%385 = load i32, i32* %31
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %384, i64 %386
%388 = load double, double* %387
%389 = fcmp oeq double %388, 0.000000e+00
br i1 %389, label %390, label %391
390: ; preds = %383, %322
store double 0.000000e+00, double* %41
br label %423
391: ; preds = %383
%392 = load double*, double** %21
%393 = load i32, i32* %31
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double, double* %392, i64 %394
%396 = load double, double* %395
%397 = call double @pow(double %396, double 2.000000e+00)
%398 = load double*, double** %37
%399 = load i32, i32* %33
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %398, i64 %400
%402 = load double, double* %401
%403 = call double @pow(double %402, double 2.000000e+00)
%404 = fadd double %397, %403
%405 = load double, double* %40
%406 = load double, double* %40
%407 = fneg double %405
%408 = call double @llvm.fmuladd.f64(double %407, double %406, double %404)
%409 = load double*, double** %21
%410 = load i32, i32* %31
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double, double* %409, i64 %411
%413 = load double, double* %412
%414 = fmul double 2.000000e+00, %413
%415 = load double*, double** %37
%416 = load i32, i32* %33
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds double, double* %415, i64 %417
%419 = load double, double* %418
%420 = fmul double %414, %419
%421 = fdiv double %408, %420
%422 = call double @acos(double %421)
store double %422, double* %41
br label %423
423: ; preds = %391, %390
store i32 0, i32* %32
br label %424
424: ; preds = %650, %423
%425 = load i32, i32* %32
%426 = load i32, i32* %17
%427 = icmp slt i32 %425, %426
br i1 %427, label %428, label %653
428: ; preds = %424
%429 = load double, double* %41
%430 = load double*, double** %29
%431 = load i32, i32* %31
%432 = load i32, i32* %17
%433 = mul nsw i32 %431, %432
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds double, double* %430, i64 %434
%436 = load i32, i32* %32
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds double, double* %435, i64 %437
%439 = load double, double* %438
%440 = load double*, double** %38
%441 = load i32, i32* %33
%442 = load i32, i32* %17
%443 = mul nsw i32 %441, %442
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %440, i64 %444
%446 = load i32, i32* %32
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %445, i64 %447
%449 = load double, double* %448
%450 = fadd double %439, %449
%451 = fcmp ogt double %429, %450
br i1 %451, label %452, label %475
452: ; preds = %428
%453 = load double*, double** %28
%454 = load i32, i32* %33
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %453, i64 %455
%457 = load double, double* %456
%458 = fsub double %457, 1.000000e+00
%459 = load double*, double** %38
%460 = load i32, i32* %33
%461 = load i32, i32* %17
%462 = mul nsw i32 %460, %461
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds double, double* %459, i64 %463
%465 = load i32, i32* %32
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds double, double* %464, i64 %466
%468 = load double, double* %467
%469 = load double*, double** %39
%470 = load i32, i32* %32
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds double, double* %469, i64 %471
%473 = load double, double* %472
%474 = call double @llvm.fmuladd.f64(double %458, double %468, double %473)
store double %474, double* %472
br label %649
475: ; preds = %428
%476 = load double*, double** %38
%477 = load i32, i32* %33
%478 = load i32, i32* %17
%479 = mul nsw i32 %477, %478
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %476, i64 %480
%482 = load i32, i32* %32
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %481, i64 %483
%485 = load double, double* %484
%486 = load double, double* %41
%487 = load double*, double** %29
%488 = load i32, i32* %17
%489 = load i32, i32* %31
%490 = mul nsw i32 %488, %489
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds double, double* %487, i64 %491
%493 = load i32, i32* %32
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds double, double* %492, i64 %494
%496 = load double, double* %495
%497 = fadd double %486, %496
%498 = fcmp ogt double %485, %497
br i1 %498, label %499, label %533
499: ; preds = %475
%500 = load double*, double** %28
%501 = load i32, i32* %33
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds double, double* %500, i64 %502
%504 = load double, double* %503
%505 = fsub double %504, 1.000000e+00
%506 = load double*, double** %38
%507 = load i32, i32* %33
%508 = load i32, i32* %17
%509 = mul nsw i32 %507, %508
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds double, double* %506, i64 %510
%512 = load i32, i32* %32
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds double, double* %511, i64 %513
%515 = load double, double* %514
%516 = load double*, double** %29
%517 = load i32, i32* %17
%518 = load i32, i32* %31
%519 = mul nsw i32 %517, %518
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds double, double* %516, i64 %520
%522 = load i32, i32* %32
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds double, double* %521, i64 %523
%525 = load double, double* %524
%526 = fsub double %515, %525
%527 = load double*, double** %39
%528 = load i32, i32* %32
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds double, double* %527, i64 %529
%531 = load double, double* %530
%532 = call double @llvm.fmuladd.f64(double %505, double %526, double %531)
store double %532, double* %530
br label %648
533: ; preds = %475
%534 = load double*, double** %29
%535 = load i32, i32* %17
%536 = load i32, i32* %31
%537 = mul nsw i32 %535, %536
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds double, double* %534, i64 %538
%540 = load i32, i32* %32
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds double, double* %539, i64 %541
%543 = load double, double* %542
%544 = load double, double* %41
%545 = load double*, double** %38
%546 = load i32, i32* %33
%547 = load i32, i32* %17
%548 = mul nsw i32 %546, %547
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds double, double* %545, i64 %549
%551 = load i32, i32* %32
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds double, double* %550, i64 %552
%554 = load double, double* %553
%555 = fadd double %544, %554
%556 = fcmp ole double %543, %555
br i1 %556, label %557, label %647
557: ; preds = %533
%558 = load double, double* @M_PI
%559 = load double, double* %41
%560 = fneg double %559
%561 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %558, double %560)
%562 = load double*, double** %29
%563 = load i32, i32* %17
%564 = load i32, i32* %31
%565 = mul nsw i32 %563, %564
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %562, i64 %566
%568 = load i32, i32* %32
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds double, double* %567, i64 %569
%571 = load double, double* %570
%572 = load double*, double** %38
%573 = load i32, i32* %33
%574 = load i32, i32* %17
%575 = mul nsw i32 %573, %574
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds double, double* %572, i64 %576
%578 = load i32, i32* %32
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds double, double* %577, i64 %579
%581 = load double, double* %580
%582 = fadd double %571, %581
%583 = fcmp oge double %561, %582
br i1 %583, label %584, label %621
584: ; preds = %557
%585 = load double*, double** %28
%586 = load i32, i32* %33
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds double, double* %585, i64 %587
%589 = load double, double* %588
%590 = fsub double %589, 1.000000e+00
%591 = fmul double 5.000000e-01, %590
%592 = load double*, double** %38
%593 = load i32, i32* %33
%594 = load i32, i32* %17
%595 = mul nsw i32 %593, %594
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds double, double* %592, i64 %596
%598 = load i32, i32* %32
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds double, double* %597, i64 %599
%601 = load double, double* %600
%602 = load double, double* %41
%603 = fadd double %601, %602
%604 = load double*, double** %29
%605 = load i32, i32* %17
%606 = load i32, i32* %31
%607 = mul nsw i32 %605, %606
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds double, double* %604, i64 %608
%610 = load i32, i32* %32
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %609, i64 %611
%613 = load double, double* %612
%614 = fsub double %603, %613
%615 = load double*, double** %39
%616 = load i32, i32* %32
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds double, double* %615, i64 %617
%619 = load double, double* %618
%620 = call double @llvm.fmuladd.f64(double %591, double %614, double %619)
store double %620, double* %618
br label %646
621: ; preds = %557
%622 = load double*, double** %28
%623 = load i32, i32* %33
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %622, i64 %624
%626 = load double, double* %625
%627 = fsub double %626, 1.000000e+00
%628 = load double, double* @M_PI
%629 = load double*, double** %29
%630 = load i32, i32* %17
%631 = load i32, i32* %31
%632 = mul nsw i32 %630, %631
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds double, double* %629, i64 %633
%635 = load i32, i32* %32
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds double, double* %634, i64 %636
%638 = load double, double* %637
%639 = fsub double %628, %638
%640 = load double*, double** %39
%641 = load i32, i32* %32
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds double, double* %640, i64 %642
%644 = load double, double* %643
%645 = call double @llvm.fmuladd.f64(double %627, double %639, double %644)
store double %645, double* %643
br label %646
646: ; preds = %621, %584
br label %647
647: ; preds = %646, %533
br label %648
648: ; preds = %647, %499
br label %649
649: ; preds = %648, %452
br label %650
650: ; preds = %649
%651 = load i32, i32* %32
%652 = add nsw i32 %651, 1
store i32 %652, i32* %32
br label %424
653: ; preds = %424
br label %654
654: ; preds = %653
%655 = load i32, i32* %33
%656 = add nsw i32 %655, 1
store i32 %656, i32* %33
br label %318
657: ; preds = %318
%658 = load double*, double** %30
store double 0.000000e+00, double* %658
store i32 0, i32* %32
br label %659
659: ; preds = %683, %657
%660 = load i32, i32* %32
%661 = load i32, i32* %17
%662 = icmp slt i32 %660, %661
br i1 %662, label %663, label %686
663: ; preds = %659
%664 = load double*, double** %23
%665 = load i32, i32* %32
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds double, double* %664, i64 %666
%668 = load double, double* %667
%669 = load double*, double** %24
%670 = load i32, i32* %32
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double, double* %669, i64 %671
%673 = load double, double* %672
%674 = fmul double %668, %673
%675 = load double*, double** %39
%676 = load i32, i32* %32
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds double, double* %675, i64 %677
%679 = load double, double* %678
%680 = load double*, double** %30
%681 = load double, double* %680
%682 = call double @llvm.fmuladd.f64(double %674, double %679, double %681)
store double %682, double* %680
br label %683
683: ; preds = %663
%684 = load i32, i32* %32
%685 = add nsw i32 %684, 1
store i32 %685, i32* %32
br label %659
686: ; preds = %659
%687 = load double, double* %34
%688 = load double*, double** %30
%689 = load double, double* %688
%690 = fdiv double %689, %687
store double %690, double* %688
br label %693
691: ; preds = %283
%692 = load double*, double** %30
store double 1.000000e+00, double* %692
br label %693
693: ; preds = %691, %686
%694 = load double*, double** %30
%695 = getelementptr inbounds double, double* %694, i32 1
store double* %695, double** %30
br label %696
696: ; preds = %693
%697 = load i32, i32* %31
%698 = add nsw i32 %697, 1
store i32 %698, i32* %31
br label %279
699: ; preds = %279
%700 = load i32, i32* %16
%701 = load double*, double** %30
%702 = sext i32 %700 to i64
%703 = sub i64 0, %702
%704 = getelementptr inbounds double, double* %701, i64 %703
store double* %704, double** %30
%705 = load double*, double** %37
%706 = call i32 @free(double* %705)
br label %707
707: ; preds = %699, %130
ret void
}

LLVM IR (-O2):
@M_PI = global double 0.000000e+00
define void @integratetransit(i32 %0, i32 %1, i32 %2, double* nocapture %3, double* nocapture %4, double* nocapture %5, double %6, double* %7, double* nocapture %8, double* nocapture %9, double* nocapture %10, double* nocapture %11, double* nocapture %12, double* nocapture %13, double* nocapture %14) {
%16 = icmp eq i32 %2, 0
br i1 %16, label %17, label %152
17: ; preds = %15
%18 = icmp sgt i32 %1, 0
br i1 %18, label %19, label %45
19: ; preds = %17
%20 = load double, double* @M_PI
%21 = zext i32 %1 to i64
%22 = add nsw i64 %21, -1
%23 = and i64 %21, 3
%24 = icmp ult i64 %22, 3
br i1 %24, label %27, label %25
25: ; preds = %19
%26 = and i64 %21, 4294967292
br label %57
27: ; preds = %57, %19
%28 = phi double [ undef, %19 ], [ %87, %57 ]
%29 = phi i64 [ 0, %19 ], [ %88, %57 ]
%30 = phi double [ 0.000000e+00, %19 ], [ %87, %57 ]
%31 = icmp eq i64 %23, 0
br i1 %31, label %45, label %32
32: ; preds = %27, %32
%33 = phi i64 [ %42, %32 ], [ %29, %27 ]
%34 = phi double [ %41, %32 ], [ %30, %27 ]
%35 = phi i64 [ %43, %32 ], [ 0, %27 ]
%36 = getelementptr inbounds double, double* %7, i64 %33
%37 = load double, double* %36
%38 = fmul double %20, %37
%39 = getelementptr inbounds double, double* %8, i64 %33
%40 = load double, double* %39
%41 = tail call double @llvm.fmuladd.f64(double %38, double %40, double %34)
%42 = add nuw nsw i64 %33, 1
%43 = add i64 %35, 1
%44 = icmp eq i64 %43, %23
br i1 %44, label %45, label %32
45: ; preds = %27, %32, %17
%46 = phi double [ 0.000000e+00, %17 ], [ %28, %27 ], [ %41, %32 ]
%47 = icmp sgt i32 %0, 0
br i1 %47, label %48, label %501
48: ; preds = %45
%49 = fadd double %6, 1.000000e+00
%50 = sext i32 %1 to i64
%51 = zext i32 %0 to i64
%52 = zext i32 %1 to i64
%53 = and i64 %52, 1
%54 = icmp eq i32 %1, 1
%55 = and i64 %52, 4294967294
%56 = icmp eq i64 %53, 0
br label %91
57: ; preds = %57, %25
%58 = phi i64 [ 0, %25 ], [ %88, %57 ]
%59 = phi double [ 0.000000e+00, %25 ], [ %87, %57 ]
%60 = phi i64 [ 0, %25 ], [ %89, %57 ]
%61 = getelementptr inbounds double, double* %7, i64 %58
%62 = load double, double* %61
%63 = fmul double %20, %62
%64 = getelementptr inbounds double, double* %8, i64 %58
%65 = load double, double* %64
%66 = tail call double @llvm.fmuladd.f64(double %63, double %65, double %59)
%67 = or i64 %58, 1
%68 = getelementptr inbounds double, double* %7, i64 %67
%69 = load double, double* %68
%70 = fmul double %20, %69
%71 = getelementptr inbounds double, double* %8, i64 %67
%72 = load double, double* %71
%73 = tail call double @llvm.fmuladd.f64(double %70, double %72, double %66)
%74 = or i64 %58, 2
%75 = getelementptr inbounds double, double* %7, i64 %74
%76 = load double, double* %75
%77 = fmul double %20, %76
%78 = getelementptr inbounds double, double* %8, i64 %74
%79 = load double, double* %78
%80 = tail call double @llvm.fmuladd.f64(double %77, double %79, double %73)
%81 = or i64 %58, 3
%82 = getelementptr inbounds double, double* %7, i64 %81
%83 = load double, double* %82
%84 = fmul double %20, %83
%85 = getelementptr inbounds double, double* %8, i64 %81
%86 = load double, double* %85
%87 = tail call double @llvm.fmuladd.f64(double %84, double %86, double %80)
%88 = add nuw nsw i64 %58, 4
%89 = add i64 %60, 4
%90 = icmp eq i64 %89, %26
br i1 %90, label %27, label %57
91: ; preds = %48, %147
%92 = phi i64 [ 0, %48 ], [ %150, %147 ]
%93 = phi double* [ %14, %48 ], [ %149, %147 ]
%94 = getelementptr inbounds double, double* %5, i64 %92
%95 = load double, double* %94
%96 = fcmp olt double %95, %49
br i1 %96, label %97, label %147
97: ; preds = %91
store double 0.000000e+00, double* %93
br i1 %18, label %98, label %144
98: ; preds = %97
%99 = mul nsw i64 %92, %50
%100 = getelementptr inbounds double, double* %13, i64 %99
br i1 %54, label %129, label %101
101: ; preds = %98, %101
%102 = phi double [ %125, %101 ], [ 0.000000e+00, %98 ]
%103 = phi i64 [ %126, %101 ], [ 0, %98 ]
%104 = phi i64 [ %127, %101 ], [ 0, %98 ]
%105 = getelementptr inbounds double, double* %7, i64 %103
%106 = load double, double* %105
%107 = load double, double* @M_PI
%108 = getelementptr inbounds double, double* %100, i64 %103
%109 = load double, double* %108
%110 = fsub double %107, %109
%111 = fmul double %106, %110
%112 = getelementptr inbounds double, double* %8, i64 %103
%113 = load double, double* %112
%114 = tail call double @llvm.fmuladd.f64(double %111, double %113, double %102)
store double %114, double* %93
%115 = or i64 %103, 1
%116 = getelementptr inbounds double, double* %7, i64 %115
%117 = load double, double* %116
%118 = load double, double* @M_PI
%119 = getelementptr inbounds double, double* %100, i64 %115
%120 = load double, double* %119
%121 = fsub double %118, %120
%122 = fmul double %117, %121
%123 = getelementptr inbounds double, double* %8, i64 %115
%124 = load double, double* %123
%125 = tail call double @llvm.fmuladd.f64(double %122, double %124, double %114)
store double %125, double* %93
%126 = add nuw nsw i64 %103, 2
%127 = add i64 %104, 2
%128 = icmp eq i64 %127, %55
br i1 %128, label %129, label %101
129: ; preds = %101, %98
%130 = phi double [ undef, %98 ], [ %125, %101 ]
%131 = phi double [ 0.000000e+00, %98 ], [ %125, %101 ]
%132 = phi i64 [ 0, %98 ], [ %126, %101 ]
br i1 %56, label %144, label %133
133: ; preds = %129
%134 = getelementptr inbounds double, double* %7, i64 %132
%135 = load double, double* %134
%136 = load double, double* @M_PI
%137 = getelementptr inbounds double, double* %100, i64 %132
%138 = load double, double* %137
%139 = fsub double %136, %138
%140 = fmul double %135, %139
%141 = getelementptr inbounds double, double* %8, i64 %132
%142 = load double, double* %141
%143 = tail call double @llvm.fmuladd.f64(double %140, double %142, double %131)
store double %143, double* %93
br label %144
144: ; preds = %133, %129, %97
%145 = phi double [ 0.000000e+00, %97 ], [ %130, %129 ], [ %143, %133 ]
%146 = fdiv double %145, %46
br label %147
147: ; preds = %91, %144
%148 = phi double [ %146, %144 ], [ 1.000000e+00, %91 ]
store double %148, double* %93
%149 = getelementptr inbounds double, double* %93, i64 1
%150 = add nuw nsw i64 %92, 1
%151 = icmp eq i64 %150, %51
br i1 %151, label %501, label %91
152: ; preds = %15
%153 = mul nsw i32 %2, %1
%154 = add i32 %2, %1
%155 = add i32 %154, %153
%156 = shl i32 %155, 3
%157 = tail call double* @malloc(i32 %156)
%158 = sext i32 %2 to i64
%159 = getelementptr inbounds double, double* %157, i64 %158
%160 = add nsw i32 %1, 1
%161 = mul nsw i32 %160, %2
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %157, i64 %162
%164 = icmp sgt i32 %2, 0
br i1 %164, label %165, label %168
165: ; preds = %152
%166 = sext i32 %1 to i64
%167 = zext i32 %2 to i64
br label %179
168: ; preds = %179, %152
%169 = icmp sgt i32 %1, 0
br i1 %169, label %170, label %200
170: ; preds = %168
%171 = load double, double* @M_PI
%172 = zext i32 %1 to i64
%173 = zext i32 %1 to i64
%174 = zext i32 %2 to i64
%175 = and i64 %174, 1
%176 = icmp eq i32 %2, 1
%177 = and i64 %174, 4294967294
%178 = icmp eq i64 %175, 0
br label %226
179: ; preds = %165, %179
%180 = phi i64 [ 0, %165 ], [ %198, %179 ]
%181 = getelementptr inbounds double, double* %9, i64 %180
%182 = load double, double* %181
%183 = getelementptr inbounds double, double* %10, i64 %180
%184 = load double, double* %183
%185 = fmul double %184, %184
%186 = tail call double @llvm.fmuladd.f64(double %182, double %182, double %185)
%187 = getelementptr inbounds double, double* %11, i64 %180
%188 = load double, double* %187
%189 = fneg double %188
%190 = tail call double @llvm.fmuladd.f64(double %189, double %188, double 1.000000e+00)
%191 = fmul double %186, %190
%192 = tail call double @sqrt(double %191)
%193 = getelementptr inbounds double, double* %157, i64 %180
store double %192, double* %193
%194 = load double, double* %187
%195 = mul nsw i64 %180, %166
%196 = getelementptr inbounds double, double* %159, i64 %195
%197 = tail call i32 @ellipseangle(double* %7, double %194, double %192, i32 %1, double* %196)
%198 = add nuw nsw i64 %180, 1
%199 = icmp eq i64 %198, %167
br i1 %199, label %168, label %179
200: ; preds = %265, %168
%201 = phi double [ 0.000000e+00, %168 ], [ %272, %265 ]
%202 = icmp sgt i32 %0, 0
br i1 %202, label %203, label %499
203: ; preds = %200
%204 = fadd double %6, 1.000000e+00
%205 = sext i32 %1 to i64
%206 = zext i32 %0 to i64
%207 = zext i32 %1 to i64
%208 = zext i32 %2 to i64
%209 = zext i32 %1 to i64
%210 = zext i32 %1 to i64
%211 = and i64 %210, 4294967292
%212 = add nsw i64 %211, -4
%213 = lshr exact i64 %212, 2
%214 = add nuw nsw i64 %213, 1
%215 = icmp ult i32 %1, 4
%216 = and i64 %207, 4294967292
%217 = and i64 %214, 1
%218 = icmp eq i64 %212, 0
%219 = and i64 %214, 9223372036854775806
%220 = icmp eq i64 %217, 0
%221 = icmp eq i64 %216, %207
%222 = and i64 %210, 1
%223 = icmp eq i32 %1, 1
%224 = and i64 %210, 4294967294
%225 = icmp eq i64 %222, 0
br label %275
226: ; preds = %170, %265
%227 = phi i64 [ 0, %170 ], [ %273, %265 ]
%228 = phi double [ 0.000000e+00, %170 ], [ %272, %265 ]
br i1 %164, label %229, label %265
229: ; preds = %226
%230 = getelementptr inbounds double, double* %159, i64 %227
br i1 %176, label %253, label %231
231: ; preds = %229, %231
%232 = phi i64 [ %250, %231 ], [ 0, %229 ]
%233 = phi double [ %249, %231 ], [ %171, %229 ]
%234 = phi i64 [ %251, %231 ], [ 0, %229 ]
%235 = getelementptr inbounds double, double* %12, i64 %232
%236 = load double, double* %235
%237 = fadd double %236, -1.000000e+00
%238 = mul nsw i64 %232, %172
%239 = getelementptr inbounds double, double* %230, i64 %238
%240 = load double, double* %239
%241 = tail call double @llvm.fmuladd.f64(double %237, double %240, double %233)
%242 = or i64 %232, 1
%243 = getelementptr inbounds double, double* %12, i64 %242
%244 = load double, double* %243
%245 = fadd double %244, -1.000000e+00
%246 = mul nsw i64 %242, %172
%247 = getelementptr inbounds double, double* %230, i64 %246
%248 = load double, double* %247
%249 = tail call double @llvm.fmuladd.f64(double %245, double %248, double %241)
%250 = add nuw nsw i64 %232, 2
%251 = add i64 %234, 2
%252 = icmp eq i64 %251, %177
br i1 %252, label %253, label %231
253: ; preds = %231, %229
%254 = phi double [ undef, %229 ], [ %249, %231 ]
%255 = phi i64 [ 0, %229 ], [ %250, %231 ]
%256 = phi double [ %171, %229 ], [ %249, %231 ]
br i1 %178, label %265, label %257
257: ; preds = %253
%258 = getelementptr inbounds double, double* %12, i64 %255
%259 = load double, double* %258
%260 = fadd double %259, -1.000000e+00
%261 = mul nsw i64 %255, %172
%262 = getelementptr inbounds double, double* %230, i64 %261
%263 = load double, double* %262
%264 = tail call double @llvm.fmuladd.f64(double %260, double %263, double %256)
br label %265
265: ; preds = %257, %253, %226
%266 = phi double [ %171, %226 ], [ %254, %253 ], [ %264, %257 ]
%267 = getelementptr inbounds double, double* %7, i64 %227
%268 = load double, double* %267
%269 = fmul double %266, %268
%270 = getelementptr inbounds double, double* %8, i64 %227
%271 = load double, double* %270
%272 = tail call double @llvm.fmuladd.f64(double %269, double %271, double %228)
%273 = add nuw nsw i64 %227, 1
%274 = icmp eq i64 %273, %173
br i1 %274, label %200, label %226
275: ; preds = %203, %494
%276 = phi i64 [ 0, %203 ], [ %497, %494 ]
%277 = phi double* [ %14, %203 ], [ %496, %494 ]
%278 = getelementptr inbounds double, double* %5, i64 %276
%279 = load double, double* %278
%280 = fcmp olt double %279, %204
br i1 %280, label %281, label %494
281: ; preds = %275
br i1 %169, label %282, label %340
282: ; preds = %281
%283 = load double, double* @M_PI
%284 = mul nsw i64 %276, %205
%285 = getelementptr inbounds double, double* %13, i64 %284
br i1 %215, label %338, label %286
286: ; preds = %282
%287 = insertelement <2 x double> poison, double %283, i64 0
%288 = shufflevector <2 x double> %287, <2 x double> poison, <2 x i32> zeroinitializer
%289 = insertelement <2 x double> poison, double %283, i64 0
%290 = shufflevector <2 x double> %289, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %218, label %322, label %291
291: ; preds = %286, %291
%292 = phi i64 [ %319, %291 ], [ 0, %286 ]
%293 = phi i64 [ %320, %291 ], [ 0, %286 ]
%294 = getelementptr inbounds double, double* %285, i64 %292
%295 = bitcast double* %294 to <2 x double>*
%296 = load <2 x double>, <2 x double>* %295
%297 = getelementptr inbounds double, double* %294, i64 2
%298 = bitcast double* %297 to <2 x double>*
%299 = load <2 x double>, <2 x double>* %298
%300 = fsub <2 x double> %288, %296
%301 = fsub <2 x double> %290, %299
%302 = getelementptr inbounds double, double* %163, i64 %292
%303 = bitcast double* %302 to <2 x double>*
store <2 x double> %300, <2 x double>* %303
%304 = getelementptr inbounds double, double* %302, i64 2
%305 = bitcast double* %304 to <2 x double>*
store <2 x double> %301, <2 x double>* %305
%306 = or i64 %292, 4
%307 = getelementptr inbounds double, double* %285, i64 %306
%308 = bitcast double* %307 to <2 x double>*
%309 = load <2 x double>, <2 x double>* %308
%310 = getelementptr inbounds double, double* %307, i64 2
%311 = bitcast double* %310 to <2 x double>*
%312 = load <2 x double>, <2 x double>* %311
%313 = fsub <2 x double> %288, %309
%314 = fsub <2 x double> %290, %312
%315 = getelementptr inbounds double, double* %163, i64 %306
%316 = bitcast double* %315 to <2 x double>*
store <2 x double> %313, <2 x double>* %316
%317 = getelementptr inbounds double, double* %315, i64 2
%318 = bitcast double* %317 to <2 x double>*
store <2 x double> %314, <2 x double>* %318
%319 = add nuw i64 %292, 8
%320 = add i64 %293, 2
%321 = icmp eq i64 %320, %219
br i1 %321, label %322, label %291
322: ; preds = %291, %286
%323 = phi i64 [ 0, %286 ], [ %319, %291 ]
br i1 %220, label %337, label %324
324: ; preds = %322
%325 = getelementptr inbounds double, double* %285, i64 %323
%326 = bitcast double* %325 to <2 x double>*
%327 = load <2 x double>, <2 x double>* %326
%328 = getelementptr inbounds double, double* %325, i64 2
%329 = bitcast double* %328 to <2 x double>*
%330 = load <2 x double>, <2 x double>* %329
%331 = fsub <2 x double> %288, %327
%332 = fsub <2 x double> %290, %330
%333 = getelementptr inbounds double, double* %163, i64 %323
%334 = bitcast double* %333 to <2 x double>*
store <2 x double> %331, <2 x double>* %334
%335 = getelementptr inbounds double, double* %333, i64 2
%336 = bitcast double* %335 to <2 x double>*
store <2 x double> %332, <2 x double>* %336
br label %337
337: ; preds = %322, %324
br i1 %221, label %340, label %338
338: ; preds = %282, %337
%339 = phi i64 [ 0, %282 ], [ %216, %337 ]
br label %346
340: ; preds = %346, %337, %281
br i1 %164, label %341, label %452
341: ; preds = %340
%342 = getelementptr inbounds double, double* %3, i64 %276
%343 = getelementptr inbounds double, double* %4, i64 %276
%344 = mul nsw i64 %276, %205
%345 = getelementptr inbounds double, double* %13, i64 %344
br label %354
346: ; preds = %338, %346
%347 = phi i64 [ %352, %346 ], [ %339, %338 ]
%348 = getelementptr inbounds double, double* %285, i64 %347
%349 = load double, double* %348
%350 = fsub double %283, %349
%351 = getelementptr inbounds double, double* %163, i64 %347
store double %350, double* %351
%352 = add nuw nsw i64 %347, 1
%353 = icmp eq i64 %352, %207
br i1 %353, label %340, label %346
354: ; preds = %341, %449
%355 = phi i64 [ 0, %341 ], [ %450, %449 ]
%356 = load double, double* %342
%357 = getelementptr inbounds double, double* %9, i64 %355
%358 = load double, double* %357
%359 = getelementptr inbounds double, double* %11, i64 %355
%360 = load double, double* %359
%361 = fneg double %360
%362 = tail call double @llvm.fmuladd.f64(double %361, double %360, double 1.000000e+00)
%363 = tail call double @sqrt(double %362)
%364 = fneg double %358
%365 = tail call double @llvm.fmuladd.f64(double %364, double %363, double %356)
%366 = fmul double %365, %365
%367 = load double, double* %343
%368 = getelementptr inbounds double, double* %10, i64 %355
%369 = load double, double* %368
%370 = load double, double* %359
%371 = fneg double %370
%372 = tail call double @llvm.fmuladd.f64(double %371, double %370, double 1.000000e+00)
%373 = tail call double @sqrt(double %372)
%374 = fneg double %369
%375 = tail call double @llvm.fmuladd.f64(double %374, double %373, double %367)
%376 = fmul double %375, %375
%377 = fadd double %366, %376
%378 = tail call double @sqrt(double %377)
%379 = getelementptr inbounds double, double* %157, i64 %355
%380 = load double, double* %379
%381 = fcmp oeq double %380, 0.000000e+00
br i1 %381, label %395, label %382
382: ; preds = %354
%383 = load double, double* %278
%384 = fcmp oeq double %383, 0.000000e+00
br i1 %384, label %395, label %385
385: ; preds = %382
%386 = fmul double %383, %383
%387 = fmul double %380, %380
%388 = fadd double %387, %386
%389 = fneg double %378
%390 = tail call double @llvm.fmuladd.f64(double %389, double %378, double %388)
%391 = fmul double %383, 2.000000e+00
%392 = fmul double %380, %391
%393 = fdiv double %390, %392
%394 = tail call double @acos(double %393)
br label %395
395: ; preds = %354, %382, %385
%396 = phi double [ %394, %385 ], [ 0.000000e+00, %382 ], [ 0.000000e+00, %354 ]
br i1 %169, label %397, label %449
397: ; preds = %395
%398 = mul nsw i64 %355, %205
%399 = getelementptr inbounds double, double* %159, i64 %398
%400 = load double, double* @M_PI
%401 = fneg double %396
%402 = tail call double @llvm.fmuladd.f64(double %400, double 2.000000e+00, double %401)
%403 = getelementptr inbounds double, double* %12, i64 %355
br label %404
404: ; preds = %397, %446
%405 = phi i64 [ 0, %397 ], [ %447, %446 ]
%406 = getelementptr inbounds double, double* %345, i64 %405
%407 = load double, double* %406
%408 = getelementptr inbounds double, double* %399, i64 %405
%409 = load double, double* %408
%410 = fadd double %407, %409
%411 = fcmp ogt double %396, %410
br i1 %411, label %412, label %418
412: ; preds = %404
%413 = load double, double* %403
%414 = fadd double %413, -1.000000e+00
%415 = getelementptr inbounds double, double* %163, i64 %405
%416 = load double, double* %415
%417 = tail call double @llvm.fmuladd.f64(double %414, double %409, double %416)
store double %417, double* %415
br label %446
418: ; preds = %404
%419 = fadd double %396, %407
%420 = fcmp ogt double %409, %419
br i1 %420, label %421, label %428
421: ; preds = %418
%422 = load double, double* %403
%423 = fadd double %422, -1.000000e+00
%424 = fsub double %409, %407
%425 = getelementptr inbounds double, double* %163, i64 %405
%426 = load double, double* %425
%427 = tail call double @llvm.fmuladd.f64(double %423, double %424, double %426)
store double %427, double* %425
br label %446
428: ; preds = %418
%429 = fadd double %396, %409
%430 = fcmp ugt double %407, %429
br i1 %430, label %446, label %431
431: ; preds = %428
%432 = fcmp ult double %402, %410
%433 = load double, double* %403
%434 = fadd double %433, -1.000000e+00
br i1 %432, label %441, label %435
435: ; preds = %431
%436 = fmul double %434, 5.000000e-01
%437 = fsub double %429, %407
%438 = getelementptr inbounds double, double* %163, i64 %405
%439 = load double, double* %438
%440 = tail call double @llvm.fmuladd.f64(double %436, double %437, double %439)
store double %440, double* %438
br label %446
441: ; preds = %431
%442 = fsub double %400, %407
%443 = getelementptr inbounds double, double* %163, i64 %405
%444 = load double, double* %443
%445 = tail call double @llvm.fmuladd.f64(double %434, double %442, double %444)
store double %445, double* %443
br label %446
446: ; preds = %412, %428, %441, %435, %421
%447 = add nuw nsw i64 %405, 1
%448 = icmp eq i64 %447, %209
br i1 %448, label %449, label %404
449: ; preds = %446, %395
%450 = add nuw nsw i64 %355, 1
%451 = icmp eq i64 %450, %208
br i1 %451, label %452, label %354
452: ; preds = %449, %340
store double 0.000000e+00, double* %277
br i1 %169, label %453, label %491
453: ; preds = %452
br i1 %223, label %478, label %454
454: ; preds = %453, %454
%455 = phi double [ %474, %454 ], [ 0.000000e+00, %453 ]
%456 = phi i64 [ %475, %454 ], [ 0, %453 ]
%457 = phi i64 [ %476, %454 ], [ 0, %453 ]
%458 = getelementptr inbounds double, double* %7, i64 %456
%459 = load double, double* %458
%460 = getelementptr inbounds double, double* %8, i64 %456
%461 = load double, double* %460
%462 = fmul double %459, %461
%463 = getelementptr inbounds double, double* %163, i64 %456
%464 = load double, double* %463
%465 = tail call double @llvm.fmuladd.f64(double %462, double %464, double %455)
store double %465, double* %277
%466 = or i64 %456, 1
%467 = getelementptr inbounds double, double* %7, i64 %466
%468 = load double, double* %467
%469 = getelementptr inbounds double, double* %8, i64 %466
%470 = load double, double* %469
%471 = fmul double %468, %470
%472 = getelementptr inbounds double, double* %163, i64 %466
%473 = load double, double* %472
%474 = tail call double @llvm.fmuladd.f64(double %471, double %473, double %465)
store double %474, double* %277
%475 = add nuw nsw i64 %456, 2
%476 = add i64 %457, 2
%477 = icmp eq i64 %476, %224
br i1 %477, label %478, label %454
478: ; preds = %454, %453
%479 = phi double [ undef, %453 ], [ %474, %454 ]
%480 = phi double [ 0.000000e+00, %453 ], [ %474, %454 ]
%481 = phi i64 [ 0, %453 ], [ %475, %454 ]
br i1 %225, label %491, label %482
482: ; preds = %478
%483 = getelementptr inbounds double, double* %7, i64 %481
%484 = load double, double* %483
%485 = getelementptr inbounds double, double* %8, i64 %481
%486 = load double, double* %485
%487 = fmul double %484, %486
%488 = getelementptr inbounds double, double* %163, i64 %481
%489 = load double, double* %488
%490 = tail call double @llvm.fmuladd.f64(double %487, double %489, double %480)
store double %490, double* %277
br label %491
491: ; preds = %482, %478, %452
%492 = phi double [ 0.000000e+00, %452 ], [ %479, %478 ], [ %490, %482 ]
%493 = fdiv double %492, %201
br label %494
494: ; preds = %275, %491
%495 = phi double [ %493, %491 ], [ 1.000000e+00, %275 ]
store double %495, double* %277
%496 = getelementptr inbounds double, double* %277, i64 1
%497 = add nuw nsw i64 %276, 1
%498 = icmp eq i64 %497, %206
br i1 %498, label %499, label %275
499: ; preds = %494, %200
%500 = tail call i32 @free(double* %157)
br label %501
501: ; preds = %147, %45, %499
ret void
}