#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 */
unsigned int **alloc_uimatrix(unsigned int, unsigned int);
unsigned int *alloc_uivector(unsigned int);
int /*<<< orphan*/ dealloc_uimatrix(unsigned int **, unsigned int,
                                    unsigned int);
int /*<<< orphan*/ dealloc_uivector(unsigned int *, unsigned int);
double fabs(double);
double sqrt(double);
double getCustomSplitStatisticCompetingRisk(
    unsigned int n, char *membership, double *time, double *event,
    unsigned int eventTypeSize, unsigned int eventTimeSize, double *eventTime,
    double *response, double mean, double variance, unsigned int maxLevel,
    double **feature, unsigned int featureCount) {
  unsigned int *nodeLeftEvent, *nodeParentEvent;
  unsigned int *nodeLeftAtRisk, *nodeParentAtRisk;
  unsigned int **nodeLeftEventCR, **nodeParentEventCR;
  unsigned int **nodeLeftInclusiveAtRisk, **nodeParentInclusiveAtRisk;
  double delta, deltaNum, deltaSubNum, deltaDen, deltaSubDen;
  unsigned int i, j, k, r, s;
  deltaNum = deltaDen = 0.0;
  nodeLeftEvent = alloc_uivector(eventTimeSize);
  nodeParentEvent = alloc_uivector(eventTimeSize);
  nodeLeftAtRisk = alloc_uivector(eventTimeSize);
  nodeParentAtRisk = alloc_uivector(eventTimeSize);
  nodeParentEventCR = alloc_uimatrix(eventTypeSize, eventTimeSize);
  nodeLeftEventCR = alloc_uimatrix(eventTypeSize, eventTimeSize);
  nodeParentInclusiveAtRisk = alloc_uimatrix(eventTypeSize, eventTimeSize);
  nodeLeftInclusiveAtRisk = alloc_uimatrix(eventTypeSize, eventTimeSize);
  for (k = 1; k <= eventTimeSize; k++) {
    nodeParentEvent[k] = 0;
    nodeParentAtRisk[k] = 0;
    nodeLeftEvent[k] = 0;
    nodeLeftAtRisk[k] = 0;
    for (j = 1; j <= eventTypeSize; j++) {
      nodeParentEventCR[j][k] = 0;
      nodeLeftEventCR[j][k] = 0;
      nodeParentInclusiveAtRisk[j][k] = 0;
      nodeLeftInclusiveAtRisk[j][k] = 0;
    }
  }
  k = eventTimeSize;
  i = n;
  while ((i > 0) && (k > 0)) {
    if (eventTime[k] <= time[i]) {
      nodeParentAtRisk[k]++;
      if (membership[i] == 0x01) {
        nodeLeftAtRisk[k]++;
      }
      if (eventTime[k] == time[i]) {
        if (event[i] > 0) {
          nodeParentEventCR[(unsigned int)event[i]][k]++;
          nodeParentEvent[k]++;
          if (membership[i] == 0x01) {
            nodeLeftEventCR[(unsigned int)event[i]][k]++;
          }
        }
      }
      i--;
    } else {
      k--;
    }
  }
  for (k = eventTimeSize; k > 1; k--) {
    nodeParentAtRisk[k - 1] = nodeParentAtRisk[k] + nodeParentAtRisk[k - 1];
    nodeLeftAtRisk[k - 1] = nodeLeftAtRisk[k] + nodeLeftAtRisk[k - 1];
  }
  for (k = 1; k <= eventTimeSize; k++) {
    for (j = 1; j <= eventTypeSize; j++) {
      nodeParentInclusiveAtRisk[j][k] = nodeParentAtRisk[k];
      nodeLeftInclusiveAtRisk[j][k] = nodeLeftAtRisk[k];
      for (s = 1; s < k; s++) {
        for (r = 1; r <= eventTypeSize; r++) {
          if (j != r) {
            nodeParentInclusiveAtRisk[j][k] += nodeParentEventCR[r][s];
            nodeLeftInclusiveAtRisk[j][k] += nodeLeftEventCR[r][s];
          }
        }
      }
    }
  }
  for (j = 1; j <= eventTypeSize; j++) {
    deltaSubNum = 0;
    for (k = 1; k <= eventTimeSize; k++) {
      deltaSubNum =
          deltaSubNum +
          (nodeLeftEventCR[j][k] -
           (nodeParentEventCR[j][k] * ((double)nodeLeftInclusiveAtRisk[j][k] /
                                       nodeParentInclusiveAtRisk[j][k])));
    }
    deltaNum = deltaNum + deltaSubNum;
    deltaSubDen = 0;
    for (k = 1; k <= eventTimeSize; k++) {
      if (nodeParentAtRisk[k] >= 2) {
        deltaSubDen =
            deltaSubDen +
            ((nodeParentEventCR[j][k] * ((double)nodeLeftInclusiveAtRisk[j][k] /
                                         nodeParentInclusiveAtRisk[j][k])) *
             (1.0 - ((double)nodeLeftInclusiveAtRisk[j][k] /
                     nodeParentInclusiveAtRisk[j][k])) *
             ((double)(nodeParentInclusiveAtRisk[j][k] -
                       nodeParentEventCR[j][k]) /
              (nodeParentInclusiveAtRisk[j][k] - 1)));
      }
    }
    deltaDen = deltaDen + deltaSubDen;
  }
  dealloc_uivector(nodeLeftEvent, eventTimeSize);
  dealloc_uivector(nodeParentEvent, eventTimeSize);
  dealloc_uivector(nodeLeftAtRisk, eventTimeSize);
  dealloc_uivector(nodeParentAtRisk, eventTimeSize);
  dealloc_uimatrix(nodeParentEventCR, eventTypeSize, eventTimeSize);
  dealloc_uimatrix(nodeLeftEventCR, eventTypeSize, eventTimeSize);
  dealloc_uimatrix(nodeParentInclusiveAtRisk, eventTypeSize, eventTimeSize);
  dealloc_uimatrix(nodeLeftInclusiveAtRisk, eventTypeSize, eventTimeSize);
  deltaNum = fabs(deltaNum);
  deltaDen = sqrt(deltaDen);
  if (deltaDen <= 1.0e-9) {
    if (deltaNum <= 1.0e-9) {
      delta = 0.0;
    } else {
      delta = deltaNum / deltaDen;
    }
  } else {
    delta = deltaNum / deltaDen;
  }
  return delta;
}


x86 assembly (clang, -O0):
<getCustomSplitStatisticCompetingRisk>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x28(%rbp),%edi
call   1030 <alloc_uivector@plt>
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%edi
call   1030 <alloc_uivector@plt>
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%edi
call   1030 <alloc_uivector@plt>
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%edi
call   1030 <alloc_uivector@plt>
mov    %rax,-0x58(%rbp)
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
call   1070 <alloc_uimatrix@plt>
mov    %rax,-0x68(%rbp)
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
call   1070 <alloc_uimatrix@plt>
mov    %rax,-0x60(%rbp)
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
call   1070 <alloc_uimatrix@plt>
mov    %rax,-0x78(%rbp)
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
call   1070 <alloc_uimatrix@plt>
mov    %rax,-0x70(%rbp)
movl   $0x1,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x28(%rbp),%eax
ja     131f <getCustomSplitStatisticCompetingRisk+0x1cf>
mov    -0x48(%rbp),%rax
mov    -0xac(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
mov    -0xac(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0xac(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0xac(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
movl   $0x1,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x24(%rbp),%eax
ja     1306 <getCustomSplitStatisticCompetingRisk+0x1b6>
mov    -0x68(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1277 <getCustomSplitStatisticCompetingRisk+0x127>
jmp    130b <getCustomSplitStatisticCompetingRisk+0x1bb>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    121a <getCustomSplitStatisticCompetingRisk+0xca>
mov    -0x28(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0xa4(%rbp)
mov    %al,-0xb5(%rbp)
jbe    1356 <getCustomSplitStatisticCompetingRisk+0x206>
cmpl   $0x0,-0xac(%rbp)
seta   %al
mov    %al,-0xb5(%rbp)
mov    -0xb5(%rbp),%al
test   $0x1,%al
jne    1369 <getCustomSplitStatisticCompetingRisk+0x219>
jmp    14c2 <getCustomSplitStatisticCompetingRisk+0x372>
mov    0x10(%rbp),%rax
mov    -0xac(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     14ae <getCustomSplitStatisticCompetingRisk+0x35e>
mov    -0x58(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x1,%eax
jne    13ce <getCustomSplitStatisticCompetingRisk+0x27e>
mov    -0x50(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0xac(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0xa4(%rbp),%ecx
ucomisd (%rax,%rcx,8),%xmm0
jne    149a <getCustomSplitStatisticCompetingRisk+0x34a>
jp     149a <getCustomSplitStatisticCompetingRisk+0x34a>
mov    -0x20(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1495 <getCustomSplitStatisticCompetingRisk+0x345>
mov    -0x68(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0xa4(%rbp),%edx
cvttsd2si (%rcx,%rdx,8),%rcx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0xa4(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x1,%eax
jne    1490 <getCustomSplitStatisticCompetingRisk+0x340>
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0xa4(%rbp),%edx
cvttsd2si (%rcx,%rdx,8),%rcx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1495 <getCustomSplitStatisticCompetingRisk+0x345>
jmp    149a <getCustomSplitStatisticCompetingRisk+0x34a>
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
jmp    14bd <getCustomSplitStatisticCompetingRisk+0x36d>
mov    -0xac(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xac(%rbp)
jmp    1331 <getCustomSplitStatisticCompetingRisk+0x1e1>
mov    -0x28(%rbp),%eax
mov    %eax,-0xac(%rbp)
cmpl   $0x1,-0xac(%rbp)
jbe    154e <getCustomSplitStatisticCompetingRisk+0x3fe>
mov    -0x58(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
mov    -0xac(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
add    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
mov    -0xac(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
mov    -0xac(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
add    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
mov    -0xac(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xac(%rbp)
jmp    14cb <getCustomSplitStatisticCompetingRisk+0x37b>
movl   $0x1,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x28(%rbp),%eax
ja     16d5 <getCustomSplitStatisticCompetingRisk+0x585>
movl   $0x1,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x24(%rbp),%eax
ja     16bc <getCustomSplitStatisticCompetingRisk+0x56c>
mov    -0x58(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x70(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xac(%rbp),%eax
jae    16a3 <getCustomSplitStatisticCompetingRisk+0x553>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x24(%rbp),%eax
ja     168a <getCustomSplitStatisticCompetingRisk+0x53a>
mov    -0xa8(%rbp),%eax
cmp    -0xb0(%rbp),%eax
je     1671 <getCustomSplitStatisticCompetingRisk+0x521>
mov    -0x68(%rbp),%rax
mov    -0xb0(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xb4(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
mov    -0xb0(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xb4(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x70(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0xac(%rbp),%ecx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1676 <getCustomSplitStatisticCompetingRisk+0x526>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    15ee <getCustomSplitStatisticCompetingRisk+0x49e>
jmp    168f <getCustomSplitStatisticCompetingRisk+0x53f>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    15d2 <getCustomSplitStatisticCompetingRisk+0x482>
jmp    16a8 <getCustomSplitStatisticCompetingRisk+0x558>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1571 <getCustomSplitStatisticCompetingRisk+0x421>
jmp    16c1 <getCustomSplitStatisticCompetingRisk+0x571>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1558 <getCustomSplitStatisticCompetingRisk+0x408>
movl   $0x1,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x24(%rbp),%eax
ja     18c9 <getCustomSplitStatisticCompetingRisk+0x779>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x28(%rbp),%eax
ja     17ab <getCustomSplitStatisticCompetingRisk+0x65b>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    %ecx,%edx
mov    (%rax,%rdx,8),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cvtsi2sd %rax,%xmm2
mov    -0x68(%rbp),%rax
mov    (%rax,%rdx,8),%rax
mov    (%rax,%rcx,4),%eax
cvtsi2sd %rax,%xmm1
mov    -0x70(%rbp),%rax
mov    (%rax,%rdx,8),%rax
mov    (%rax,%rcx,4),%eax
cvtsi2sd %rax,%xmm3
mov    -0x78(%rbp),%rax
mov    (%rax,%rdx,8),%rax
mov    (%rax,%rcx,4),%eax
cvtsi2sd %rax,%xmm4
divsd  %xmm4,%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1703 <getCustomSplitStatisticCompetingRisk+0x5b3>
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x1,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x28(%rbp),%eax
ja     189d <getCustomSplitStatisticCompetingRisk+0x74d>
mov    -0x58(%rbp),%rax
mov    -0xac(%rbp),%ecx
cmpl   $0x2,(%rax,%rcx,4)
jb     1884 <getCustomSplitStatisticCompetingRisk+0x734>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x68(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    %ecx,%esi
mov    (%rax,%rsi,8),%rax
mov    -0xac(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,%edx
cvtsi2sd %rax,%xmm0
mov    -0x70(%rbp),%rax
mov    (%rax,%rsi,8),%rax
mov    (%rax,%rcx,4),%eax
cvtsi2sd %rax,%xmm3
mov    -0x78(%rbp),%rax
mov    (%rax,%rsi,8),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,%ecx
mov    %ecx,%eax
cvtsi2sd %rcx,%xmm2
divsd  %xmm2,%xmm3
mulsd  %xmm3,%xmm0
movsd  0x7b1(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    %eax,%ecx
sub    %edx,%ecx
cvtsi2sd %rcx,%xmm2
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1889 <getCustomSplitStatisticCompetingRisk+0x739>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    17d8 <getCustomSplitStatisticCompetingRisk+0x688>
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    16df <getCustomSplitStatisticCompetingRisk+0x58f>
mov    -0x40(%rbp),%rdi
mov    -0x28(%rbp),%esi
call   1050 <dealloc_uivector@plt>
mov    -0x48(%rbp),%rdi
mov    -0x28(%rbp),%esi
call   1050 <dealloc_uivector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x28(%rbp),%esi
call   1050 <dealloc_uivector@plt>
mov    -0x58(%rbp),%rdi
mov    -0x28(%rbp),%esi
call   1050 <dealloc_uivector@plt>
mov    -0x68(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <dealloc_uimatrix@plt>
mov    -0x60(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <dealloc_uimatrix@plt>
mov    -0x78(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <dealloc_uimatrix@plt>
mov    -0x70(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <dealloc_uimatrix@plt>
movsd  -0x88(%rbp),%xmm0
ff
movaps 0x6cc(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1060 <sqrt@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x693(%rip),%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jb     19b8 <getCustomSplitStatisticCompetingRisk+0x868>
movsd  0x67d(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     199e <getCustomSplitStatisticCompetingRisk+0x84e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    19b3 <getCustomSplitStatisticCompetingRisk+0x863>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
jmp    19cd <getCustomSplitStatisticCompetingRisk+0x87d>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getCustomSplitStatisticCompetingRisk>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9d,%ebx
mov    %r8d,%ebp
mov    %rcx,0x50(%rsp)
mov    %rdx,0x48(%rsp)
mov    %rsi,0x10(%rsp)
mov    %edi,0x2c(%rsp)
mov    %r9d,%edi
call   1030 <alloc_uivector@plt>
mov    %rax,0x40(%rsp)
mov    %ebx,%edi
call   1030 <alloc_uivector@plt>
mov    %rax,0x18(%rsp)
mov    %ebx,%edi
call   1030 <alloc_uivector@plt>
mov    %rax,0x20(%rsp)
mov    %ebx,%edi
call   1030 <alloc_uivector@plt>
mov    %rax,(%rsp)
mov    %ebp,%edi
mov    %ebx,%esi
call   1070 <alloc_uimatrix@plt>
mov    %rax,%r15
mov    %ebp,%edi
mov    %ebx,%esi
call   1070 <alloc_uimatrix@plt>
mov    %rax,%r12
mov    %ebp,%edi
mov    %ebx,%esi
call   1070 <alloc_uimatrix@plt>
mov    %rax,%r14
mov    %ebp,%edi
mov    %ebx,%esi
call   1070 <alloc_uimatrix@plt>
mov    %rbp,%r11
mov    %rax,%r13
mov    %rbx,0x8(%rsp)
test   %ebx,%ebx
je     1548 <getCustomSplitStatisticCompetingRisk+0x3f8>
mov    0x90(%rsp),%r8
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x30(%rsp)
mov    %r11d,%edx
mov    %edx,%esi
and    $0xfffffffe,%esi
neg    %rsi
mov    $0x1,%edi
mov    0x40(%rsp),%rbx
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%r10
mov    0x2c(%rsp),%ecx
jmp    123f <getCustomSplitStatisticCompetingRisk+0xef>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    0x30(%rsp),%rdi
je     1335 <getCustomSplitStatisticCompetingRisk+0x1e5>
movl   $0x0,(%r9,%rdi,4)
mov    (%rsp),%rax
movl   $0x0,(%rax,%rdi,4)
movl   $0x0,(%rbx,%rdi,4)
movl   $0x0,(%r10,%rdi,4)
test   %r11d,%r11d
je     1230 <getCustomSplitStatisticCompetingRisk+0xe0>
mov    $0x1,%eax
cmp    $0x1,%r11d
je     12f7 <getCustomSplitStatisticCompetingRisk+0x1a7>
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    (%r12,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    (%r14,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    0x0(%r13,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    0x8(%r15,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    0x8(%r12,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    0x8(%r14,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    0x8(%r13,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
lea    (%rsi,%rax,1),%rbp
add    $0x2,%rbp
add    $0x2,%rax
cmp    $0x1,%rbp
jne    1280 <getCustomSplitStatisticCompetingRisk+0x130>
test   $0x1,%dl
je     1230 <getCustomSplitStatisticCompetingRisk+0xe0>
mov    (%r15,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    (%r12,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    (%r14,%rax,8),%rbp
movl   $0x0,0x0(%rbp,%rdi,4)
mov    0x0(%r13,%rax,8),%rax
movl   $0x0,(%rax,%rdi,4)
jmp    1230 <getCustomSplitStatisticCompetingRisk+0xe0>
test   %ecx,%ecx
mov    0x50(%rsp),%rbx
mov    0x48(%rsp),%rbp
je     140f <getCustomSplitStatisticCompetingRisk+0x2bf>
xorpd  %xmm0,%xmm0
mov    0x8(%rsp),%rax
mov    %eax,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edx,%eax
movsd  (%r8,%rax,8),%xmm1
mov    %ecx,%esi
movsd  0x0(%rbp,%rsi,8),%xmm2
ucomisd %xmm1,%xmm2
jae    1390 <getCustomSplitStatisticCompetingRisk+0x240>
add    $0xffffffff,%edx
test   %ecx,%ecx
jne    1407 <getCustomSplitStatisticCompetingRisk+0x2b7>
jmp    140f <getCustomSplitStatisticCompetingRisk+0x2bf>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsp),%rdi
addl   $0x1,(%rdi,%rax,4)
mov    0x10(%rsp),%rdi
cmpb   $0x1,(%rdi,%rsi,1)
jne    13a8 <getCustomSplitStatisticCompetingRisk+0x258>
addl   $0x1,(%r10,%rax,4)
ucomisd %xmm2,%xmm1
jne    1400 <getCustomSplitStatisticCompetingRisk+0x2b0>
jp     1400 <getCustomSplitStatisticCompetingRisk+0x2b0>
movsd  (%rbx,%rsi,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1400 <getCustomSplitStatisticCompetingRisk+0x2b0>
cvttsd2si %xmm1,%rdi
mov    %edi,%edi
mov    (%r15,%rdi,8),%rbp
addl   $0x1,0x0(%rbp,%rax,4)
mov    0x48(%rsp),%rbp
addl   $0x1,(%r9,%rax,4)
mov    %rbx,%r9
mov    %r8,%rbx
mov    0x10(%rsp),%r8
cmpb   $0x1,(%r8,%rsi,1)
mov    %rbx,%r8
mov    %r9,%rbx
mov    0x18(%rsp),%r9
jne    1400 <getCustomSplitStatisticCompetingRisk+0x2b0>
mov    (%r12,%rdi,8),%rsi
addl   $0x1,(%rsi,%rax,4)
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%ecx
test   %ecx,%ecx
je     140f <getCustomSplitStatisticCompetingRisk+0x2bf>
test   %edx,%edx
jne    1360 <getCustomSplitStatisticCompetingRisk+0x210>
mov    0x8(%rsp),%rsi
cmp    $0x2,%esi
jb     147f <getCustomSplitStatisticCompetingRisk+0x32f>
mov    %esi,%eax
test   $0x1,%sil
jne    1439 <getCustomSplitStatisticCompetingRisk+0x2e9>
mov    (%rsp),%rdx
mov    (%rdx,%rax,4),%ecx
add    %ecx,-0x4(%rdx,%rax,4)
mov    (%r10,%rax,4),%ecx
add    %ecx,-0x4(%r10,%rax,4)
add    $0xffffffffffffffff,%rax
cmp    $0x2,%esi
mov    (%rsp),%rdx
je     147f <getCustomSplitStatisticCompetingRisk+0x32f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdx,%rax,4),%ecx
add    %ecx,-0x4(%rdx,%rax,4)
mov    (%r10,%rax,4),%ecx
add    %ecx,-0x4(%r10,%rax,4)
mov    -0x4(%rdx,%rax,4),%ecx
add    %ecx,-0x8(%rdx,%rax,4)
mov    -0x4(%r10,%rax,4),%ecx
add    %ecx,-0x8(%r10,%rax,4)
lea    -0x2(%rax),%rcx
mov    %rcx,%rax
cmp    $0x1,%rcx
ja     1450 <getCustomSplitStatisticCompetingRisk+0x300>
test   %esi,%esi
je     1548 <getCustomSplitStatisticCompetingRisk+0x3f8>
lea    0x1(%r11),%r9d
lea    -0x1(%r9),%rdx
mov    $0x1,%esi
jmp    14b2 <getCustomSplitStatisticCompetingRisk+0x362>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    0x30(%rsp),%rsi
mov    %r8,%r11
je     1548 <getCustomSplitStatisticCompetingRisk+0x3f8>
mov    %r11,%r8
test   %r11d,%r11d
je     14a0 <getCustomSplitStatisticCompetingRisk+0x350>
mov    $0x1,%r10d
xor    %eax,%eax
jmp    14dd <getCustomSplitStatisticCompetingRisk+0x38d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10
add    $0x1,%rax
cmp    %r9,%r10
je     14a0 <getCustomSplitStatisticCompetingRisk+0x350>
mov    (%rsp),%rcx
mov    (%rcx,%rsi,4),%ecx
mov    (%r14,%r10,8),%r11
mov    %ecx,(%r11,%rsi,4)
mov    0x20(%rsp),%rcx
mov    (%rcx,%rsi,4),%ecx
mov    0x0(%r13,%r10,8),%rbp
mov    %ecx,0x0(%rbp,%rsi,4)
cmp    $0x2,%rsi
jb     14d0 <getCustomSplitStatisticCompetingRisk+0x380>
mov    $0x1,%ecx
jmp    1519 <getCustomSplitStatisticCompetingRisk+0x3c9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rsi,%rcx
je     14d0 <getCustomSplitStatisticCompetingRisk+0x380>
xor    %edi,%edi
jmp    1529 <getCustomSplitStatisticCompetingRisk+0x3d9>
nopl   (%rax)
add    $0x1,%rdi
cmp    %rdi,%rdx
je     1510 <getCustomSplitStatisticCompetingRisk+0x3c0>
cmp    %rdi,%rax
je     1520 <getCustomSplitStatisticCompetingRisk+0x3d0>
mov    0x8(%r15,%rdi,8),%rbx
mov    (%rbx,%rcx,4),%ebx
add    %ebx,(%r11,%rsi,4)
mov    0x8(%r12,%rdi,8),%rbx
mov    (%rbx,%rcx,4),%ebx
add    %ebx,0x0(%rbp,%rsi,4)
jmp    1520 <getCustomSplitStatisticCompetingRisk+0x3d0>
xorpd  %xmm7,%xmm7
xorpd  %xmm0,%xmm0
test   %r11d,%r11d
mov    0x8(%rsp),%rsi
je     1699 <getCustomSplitStatisticCompetingRisk+0x549>
lea    0x1(%rsi),%r10d
lea    0x1(%r11),%r8d
xorpd  %xmm0,%xmm0
mov    $0x1,%r9d
movsd  0xa87(%rip),%xmm8
xorpd  %xmm7,%xmm7
jmp    1595 <getCustomSplitStatisticCompetingRisk+0x445>
nop
addsd  %xmm2,%xmm0
addsd  %xmm1,%xmm7
add    $0x1,%r9
cmp    %r8,%r9
je     1699 <getCustomSplitStatisticCompetingRisk+0x549>
xorpd  %xmm1,%xmm1
xorpd  %xmm2,%xmm2
test   %esi,%esi
je     1580 <getCustomSplitStatisticCompetingRisk+0x430>
mov    (%r12,%r9,8),%rax
mov    (%r15,%r9,8),%rdi
mov    0x0(%r13,%r9,8),%rbp
mov    (%r14,%r9,8),%rbx
xorpd  %xmm1,%xmm1
mov    $0x1,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rcx,4),%edx
xorps  %xmm2,%xmm2
cvtsi2sd %rdx,%xmm2
mov    (%rdi,%rcx,4),%edx
xorps  %xmm3,%xmm3
cvtsi2sd %rdx,%xmm3
mov    0x0(%rbp,%rcx,4),%edx
xorps  %xmm4,%xmm4
cvtsi2sd %rdx,%xmm4
mov    (%rbx,%rcx,4),%edx
xorps  %xmm5,%xmm5
cvtsi2sd %rdx,%xmm5
divsd  %xmm5,%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%r10
jne    15c0 <getCustomSplitStatisticCompetingRisk+0x470>
xorpd  %xmm2,%xmm2
test   %esi,%esi
je     1580 <getCustomSplitStatisticCompetingRisk+0x430>
mov    $0x1,%ebp
mov    (%rsp),%rax
jmp    162d <getCustomSplitStatisticCompetingRisk+0x4dd>
nopl   (%rax)
add    $0x1,%rbp
cmp    %rbp,%r10
je     1580 <getCustomSplitStatisticCompetingRisk+0x430>
cmpl   $0x2,(%rax,%rbp,4)
jb     1620 <getCustomSplitStatisticCompetingRisk+0x4d0>
mov    (%r15,%r9,8),%rcx
mov    (%rcx,%rbp,4),%ecx
xorps  %xmm3,%xmm3
cvtsi2sd %rcx,%xmm3
mov    0x0(%r13,%r9,8),%rdx
mov    (%rdx,%rbp,4),%edx
xorps  %xmm4,%xmm4
cvtsi2sd %rdx,%xmm4
mov    (%r14,%r9,8),%rdx
mov    (%rdx,%rbp,4),%edx
xorps  %xmm5,%xmm5
cvtsi2sd %rdx,%xmm5
divsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm3
movapd %xmm8,%xmm5
subsd  %xmm4,%xmm5
lea    -0x1(%rdx),%edi
sub    %ecx,%edx
xorps  %xmm4,%xmm4
cvtsi2sd %rdx,%xmm4
xorps  %xmm6,%xmm6
cvtsi2sd %rdi,%xmm6
mulsd  %xmm3,%xmm5
divsd  %xmm6,%xmm4
mulsd  %xmm5,%xmm4
addsd  %xmm4,%xmm2
jmp    1620 <getCustomSplitStatisticCompetingRisk+0x4d0>
movsd  %xmm0,0x10(%rsp)
movapd %xmm7,0x30(%rsp)
mov    0x40(%rsp),%rdi
mov    %rsi,%rbx
mov    %r11,%rbp
call   1050 <dealloc_uivector@plt>
mov    0x18(%rsp),%rdi
mov    %ebx,%esi
call   1050 <dealloc_uivector@plt>
mov    0x20(%rsp),%rdi
mov    %ebx,%esi
call   1050 <dealloc_uivector@plt>
mov    (%rsp),%rdi
mov    %ebx,%esi
call   1050 <dealloc_uivector@plt>
mov    %r15,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
call   1040 <dealloc_uimatrix@plt>
mov    %r12,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
call   1040 <dealloc_uimatrix@plt>
mov    %r14,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
call   1040 <dealloc_uimatrix@plt>
mov    %r13,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
call   1040 <dealloc_uimatrix@plt>
movsd  0x10(%rsp),%xmm0
movapd 0x30(%rsp),%xmm3
andpd  0x904(%rip),%xmm3
ucomisd 0x8ec(%rip),%xmm0
jb     172c <getCustomSplitStatisticCompetingRisk+0x5dc>
sqrtsd %xmm0,%xmm0
jmp    173d <getCustomSplitStatisticCompetingRisk+0x5ed>
movapd %xmm3,0x30(%rsp)
call   1060 <sqrt@plt>
movapd 0x30(%rsp),%xmm3
movsd  0x8c3(%rip),%xmm2
ucomisd %xmm0,%xmm2
jb     1755 <getCustomSplitStatisticCompetingRisk+0x605>
xorpd  %xmm1,%xmm1
ucomisd %xmm3,%xmm2
jae    175d <getCustomSplitStatisticCompetingRisk+0x60d>
divsd  %xmm0,%xmm3
movapd %xmm3,%xmm1
movapd %xmm1,%xmm0
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @getCustomSplitStatisticCompetingRisk(i32 %0, i8* nocapture %1, double* nocapture %2, double* nocapture %3, i32 %4, i32 %5, double* nocapture %6, double* nocapture readnone %7, double %8, double %9, i32 %10, double** nocapture readnone %11, i32 %12) {
%14 = tail call i32* @alloc_uivector(i32 %5)
%15 = tail call i32* @alloc_uivector(i32 %5)
%16 = tail call i32* @alloc_uivector(i32 %5)
%17 = tail call i32* @alloc_uivector(i32 %5)
%18 = tail call i32** @alloc_uimatrix(i32 %4, i32 %5)
%19 = tail call i32** @alloc_uimatrix(i32 %4, i32 %5)
%20 = tail call i32** @alloc_uimatrix(i32 %4, i32 %5)
%21 = tail call i32** @alloc_uimatrix(i32 %4, i32 %5)
%22 = icmp eq i32 %5, 0
br i1 %22, label %203, label %23
23: ; preds = %13
%24 = add nuw i32 %5, 1
%25 = zext i32 %24 to i64
%26 = zext i32 %4 to i64
%27 = and i64 %26, 1
%28 = icmp eq i32 %4, 1
%29 = and i64 %26, 4294967294
%30 = icmp eq i64 %27, 0
br label %33
31: ; preds = %85
%32 = icmp eq i32 %0, 0
br i1 %32, label %88, label %109
33: ; preds = %23, %85
%34 = phi i64 [ 1, %23 ], [ %86, %85 ]
%35 = getelementptr inbounds i32, i32* %15, i64 %34
store i32 0, i32* %35
%36 = getelementptr inbounds i32, i32* %17, i64 %34
store i32 0, i32* %36
%37 = getelementptr inbounds i32, i32* %14, i64 %34
store i32 0, i32* %37
%38 = getelementptr inbounds i32, i32* %16, i64 %34
store i32 0, i32* %38
switch i32 %4, label %39 [
i32 0, label %85
i32 1, label %70
]
39: ; preds = %33, %39
%40 = phi i64 [ %67, %39 ], [ 1, %33 ]
%41 = phi i64 [ %68, %39 ], [ 0, %33 ]
%42 = getelementptr inbounds i32*, i32** %18, i64 %40
%43 = load i32*, i32** %42
%44 = getelementptr inbounds i32, i32* %43, i64 %34
store i32 0, i32* %44
%45 = getelementptr inbounds i32*, i32** %19, i64 %40
%46 = load i32*, i32** %45
%47 = getelementptr inbounds i32, i32* %46, i64 %34
store i32 0, i32* %47
%48 = getelementptr inbounds i32*, i32** %20, i64 %40
%49 = load i32*, i32** %48
%50 = getelementptr inbounds i32, i32* %49, i64 %34
store i32 0, i32* %50
%51 = getelementptr inbounds i32*, i32** %21, i64 %40
%52 = load i32*, i32** %51
%53 = getelementptr inbounds i32, i32* %52, i64 %34
store i32 0, i32* %53
%54 = add nuw nsw i64 %40, 1
%55 = getelementptr inbounds i32*, i32** %18, i64 %54
%56 = load i32*, i32** %55
%57 = getelementptr inbounds i32, i32* %56, i64 %34
store i32 0, i32* %57
%58 = getelementptr inbounds i32*, i32** %19, i64 %54
%59 = load i32*, i32** %58
%60 = getelementptr inbounds i32, i32* %59, i64 %34
store i32 0, i32* %60
%61 = getelementptr inbounds i32*, i32** %20, i64 %54
%62 = load i32*, i32** %61
%63 = getelementptr inbounds i32, i32* %62, i64 %34
store i32 0, i32* %63
%64 = getelementptr inbounds i32*, i32** %21, i64 %54
%65 = load i32*, i32** %64
%66 = getelementptr inbounds i32, i32* %65, i64 %34
store i32 0, i32* %66
%67 = add nuw nsw i64 %40, 2
%68 = add i64 %41, 2
%69 = icmp eq i64 %68, %29
br i1 %69, label %70, label %39
70: ; preds = %39, %33
%71 = phi i64 [ 1, %33 ], [ %67, %39 ]
br i1 %30, label %85, label %72
72: ; preds = %70
%73 = getelementptr inbounds i32*, i32** %18, i64 %71
%74 = load i32*, i32** %73
%75 = getelementptr inbounds i32, i32* %74, i64 %34
store i32 0, i32* %75
%76 = getelementptr inbounds i32*, i32** %19, i64 %71
%77 = load i32*, i32** %76
%78 = getelementptr inbounds i32, i32* %77, i64 %34
store i32 0, i32* %78
%79 = getelementptr inbounds i32*, i32** %20, i64 %71
%80 = load i32*, i32** %79
%81 = getelementptr inbounds i32, i32* %80, i64 %34
store i32 0, i32* %81
%82 = getelementptr inbounds i32*, i32** %21, i64 %71
%83 = load i32*, i32** %82
%84 = getelementptr inbounds i32, i32* %83, i64 %34
store i32 0, i32* %84
br label %85
85: ; preds = %72, %70, %33
%86 = add nuw nsw i64 %34, 1
%87 = icmp eq i64 %86, %25
br i1 %87, label %31, label %33
88: ; preds = %159, %31
%89 = icmp ugt i32 %5, 1
br i1 %89, label %90, label %165
90: ; preds = %88
%91 = zext i32 %5 to i64
%92 = and i64 %91, 1
%93 = icmp eq i64 %92, 0
br i1 %93, label %94, label %106
94: ; preds = %90
%95 = getelementptr inbounds i32, i32* %17, i64 %91
%96 = load i32, i32* %95
%97 = add nsw i64 %91, -1
%98 = getelementptr inbounds i32, i32* %17, i64 %97
%99 = load i32, i32* %98
%100 = add i32 %99, %96
store i32 %100, i32* %98
%101 = getelementptr inbounds i32, i32* %16, i64 %91
%102 = load i32, i32* %101
%103 = getelementptr inbounds i32, i32* %16, i64 %97
%104 = load i32, i32* %103
%105 = add i32 %104, %102
store i32 %105, i32* %103
br label %106
106: ; preds = %94, %90
%107 = phi i64 [ %91, %90 ], [ %97, %94 ]
%108 = icmp eq i32 %5, 2
br i1 %108, label %165, label %172
109: ; preds = %31, %159
%110 = phi i32 [ %161, %159 ], [ %5, %31 ]
%111 = phi i32 [ %160, %159 ], [ %0, %31 ]
%112 = zext i32 %110 to i64
%113 = getelementptr inbounds double, double* %6, i64 %112
%114 = load double, double* %113
%115 = zext i32 %111 to i64
%116 = getelementptr inbounds double, double* %2, i64 %115
%117 = load double, double* %116
%118 = fcmp ugt double %114, %117
br i1 %118, label %157, label %119
119: ; preds = %109
%120 = getelementptr inbounds i32, i32* %17, i64 %112
%121 = load i32, i32* %120
%122 = add i32 %121, 1
store i32 %122, i32* %120
%123 = getelementptr inbounds i8, i8* %1, i64 %115
%124 = load i8, i8* %123
%125 = icmp eq i8 %124, 1
br i1 %125, label %126, label %130
126: ; preds = %119
%127 = getelementptr inbounds i32, i32* %16, i64 %112
%128 = load i32, i32* %127
%129 = add i32 %128, 1
store i32 %129, i32* %127
br label %130
130: ; preds = %126, %119
%131 = fcmp oeq double %114, %117
br i1 %131, label %132, label %155
132: ; preds = %130
%133 = getelementptr inbounds double, double* %3, i64 %115
%134 = load double, double* %133
%135 = fcmp ogt double %134, 0.000000e+00
br i1 %135, label %136, label %155
136: ; preds = %132
%137 = fptoui double %134 to i32
%138 = zext i32 %137 to i64
%139 = getelementptr inbounds i32*, i32** %18, i64 %138
%140 = load i32*, i32** %139
%141 = getelementptr inbounds i32, i32* %140, i64 %112
%142 = load i32, i32* %141
%143 = add i32 %142, 1
store i32 %143, i32* %141
%144 = getelementptr inbounds i32, i32* %15, i64 %112
%145 = load i32, i32* %144
%146 = add i32 %145, 1
store i32 %146, i32* %144
%147 = load i8, i8* %123
%148 = icmp eq i8 %147, 1
br i1 %148, label %149, label %155
149: ; preds = %136
%150 = getelementptr inbounds i32*, i32** %19, i64 %138
%151 = load i32*, i32** %150
%152 = getelementptr inbounds i32, i32* %151, i64 %112
%153 = load i32, i32* %152
%154 = add i32 %153, 1
store i32 %154, i32* %152
br label %155
155: ; preds = %132, %149, %136, %130
%156 = add i32 %111, -1
br label %159
157: ; preds = %109
%158 = add i32 %110, -1
br label %159
159: ; preds = %157, %155
%160 = phi i32 [ %156, %155 ], [ %111, %157 ]
%161 = phi i32 [ %110, %155 ], [ %158, %157 ]
%162 = icmp ne i32 %160, 0
%163 = icmp ne i32 %161, 0
%164 = select i1 %162, i1 %163, i1 false
br i1 %164, label %109, label %88
165: ; preds = %106, %172, %88
br i1 %22, label %203, label %166
166: ; preds = %165
%167 = icmp eq i32 %4, 0
%168 = add i32 %4, 1
%169 = add nuw i32 %5, 1
%170 = zext i32 %169 to i64
%171 = zext i32 %168 to i64
br label %197
172: ; preds = %106, %172
%173 = phi i64 [ %187, %172 ], [ %107, %106 ]
%174 = getelementptr inbounds i32, i32* %17, i64 %173
%175 = load i32, i32* %174
%176 = add nsw i64 %173, -1
%177 = getelementptr inbounds i32, i32* %17, i64 %176
%178 = load i32, i32* %177
%179 = add i32 %178, %175
store i32 %179, i32* %177
%180 = getelementptr inbounds i32, i32* %16, i64 %173
%181 = load i32, i32* %180
%182 = getelementptr inbounds i32, i32* %16, i64 %176
%183 = load i32, i32* %182
%184 = add i32 %183, %181
store i32 %184, i32* %182
%185 = getelementptr inbounds i32, i32* %17, i64 %176
%186 = load i32, i32* %185
%187 = add nsw i64 %173, -2
%188 = getelementptr inbounds i32, i32* %17, i64 %187
%189 = load i32, i32* %188
%190 = add i32 %189, %186
store i32 %190, i32* %188
%191 = getelementptr inbounds i32, i32* %16, i64 %176
%192 = load i32, i32* %191
%193 = getelementptr inbounds i32, i32* %16, i64 %187
%194 = load i32, i32* %193
%195 = add i32 %194, %192
store i32 %195, i32* %193
%196 = icmp ugt i64 %187, 1
br i1 %196, label %172, label %165
197: ; preds = %166, %248
%198 = phi i64 [ 1, %166 ], [ %249, %248 ]
br i1 %167, label %248, label %199
199: ; preds = %197
%200 = getelementptr inbounds i32, i32* %17, i64 %198
%201 = getelementptr inbounds i32, i32* %16, i64 %198
%202 = icmp ugt i64 %198, 1
br label %211
203: ; preds = %248, %13, %165
%204 = icmp eq i32 %4, 0
br i1 %204, label %330, label %205
205: ; preds = %203
%206 = add nuw i32 %5, 1
%207 = add nuw i32 %4, 1
%208 = zext i32 %207 to i64
%209 = zext i32 %206 to i64
%210 = zext i32 %206 to i64
br label %251
211: ; preds = %199, %245
%212 = phi i64 [ 1, %199 ], [ %246, %245 ]
%213 = load i32, i32* %200
%214 = getelementptr inbounds i32*, i32** %20, i64 %212
%215 = load i32*, i32** %214
%216 = getelementptr inbounds i32, i32* %215, i64 %198
store i32 %213, i32* %216
%217 = load i32, i32* %201
%218 = getelementptr inbounds i32*, i32** %21, i64 %212
%219 = load i32*, i32** %218
%220 = getelementptr inbounds i32, i32* %219, i64 %198
store i32 %217, i32* %220
br i1 %202, label %221, label %245
221: ; preds = %211, %242
%222 = phi i64 [ %243, %242 ], [ 1, %211 ]
br label %223
223: ; preds = %221, %239
%224 = phi i64 [ 1, %221 ], [ %240, %239 ]
%225 = icmp eq i64 %212, %224
br i1 %225, label %239, label %226
226: ; preds = %223
%227 = getelementptr inbounds i32*, i32** %18, i64 %224
%228 = load i32*, i32** %227
%229 = getelementptr inbounds i32, i32* %228, i64 %222
%230 = load i32, i32* %229
%231 = load i32, i32* %216
%232 = add i32 %231, %230
store i32 %232, i32* %216
%233 = getelementptr inbounds i32*, i32** %19, i64 %224
%234 = load i32*, i32** %233
%235 = getelementptr inbounds i32, i32* %234, i64 %222
%236 = load i32, i32* %235
%237 = load i32, i32* %220
%238 = add i32 %237, %236
store i32 %238, i32* %220
br label %239
239: ; preds = %223, %226
%240 = add nuw nsw i64 %224, 1
%241 = icmp eq i64 %240, %171
br i1 %241, label %242, label %223
242: ; preds = %239
%243 = add nuw nsw i64 %222, 1
%244 = icmp eq i64 %243, %198
br i1 %244, label %245, label %221
245: ; preds = %242, %211
%246 = add nuw nsw i64 %212, 1
%247 = icmp eq i64 %246, %171
br i1 %247, label %248, label %211
248: ; preds = %245, %197
%249 = add nuw nsw i64 %198, 1
%250 = icmp eq i64 %249, %170
br i1 %250, label %203, label %197
251: ; preds = %205, %323
%252 = phi i64 [ 1, %205 ], [ %328, %323 ]
%253 = phi double [ 0.000000e+00, %205 ], [ %327, %323 ]
%254 = phi double [ 0.000000e+00, %205 ], [ %326, %323 ]
br i1 %22, label %323, label %255
255: ; preds = %251
%256 = getelementptr inbounds i32*, i32** %19, i64 %252
%257 = load i32*, i32** %256
%258 = getelementptr inbounds i32*, i32** %18, i64 %252
%259 = load i32*, i32** %258
%260 = getelementptr inbounds i32*, i32** %21, i64 %252
%261 = load i32*, i32** %260
%262 = getelementptr inbounds i32*, i32** %20, i64 %252
%263 = load i32*, i32** %262
br label %264
264: ; preds = %255, %264
%265 = phi i64 [ 1, %255 ], [ %283, %264 ]
%266 = phi double [ 0.000000e+00, %255 ], [ %282, %264 ]
%267 = getelementptr inbounds i32, i32* %257, i64 %265
%268 = load i32, i32* %267
%269 = uitofp i32 %268 to double
%270 = getelementptr inbounds i32, i32* %259, i64 %265
%271 = load i32, i32* %270
%272 = uitofp i32 %271 to double
%273 = getelementptr inbounds i32, i32* %261, i64 %265
%274 = load i32, i32* %273
%275 = uitofp i32 %274 to double
%276 = getelementptr inbounds i32, i32* %263, i64 %265
%277 = load i32, i32* %276
%278 = uitofp i32 %277 to double
%279 = fdiv double %275, %278
%280 = fneg double %272
%281 = tail call double @llvm.fmuladd.f64(double %280, double %279, double %269)
%282 = fadd double %266, %281
%283 = add nuw nsw i64 %265, 1
%284 = icmp eq i64 %283, %209
br i1 %284, label %285, label %264
285: ; preds = %264
br i1 %22, label %323, label %286
286: ; preds = %285
%287 = getelementptr inbounds i32*, i32** %18, i64 %252
%288 = getelementptr inbounds i32*, i32** %21, i64 %252
%289 = getelementptr inbounds i32*, i32** %20, i64 %252
br label %290
290: ; preds = %286, %319
%291 = phi i64 [ 1, %286 ], [ %321, %319 ]
%292 = phi double [ 0.000000e+00, %286 ], [ %320, %319 ]
%293 = getelementptr inbounds i32, i32* %17, i64 %291
%294 = load i32, i32* %293
%295 = icmp ugt i32 %294, 1
br i1 %295, label %296, label %319
296: ; preds = %290
%297 = load i32*, i32** %287
%298 = getelementptr inbounds i32, i32* %297, i64 %291
%299 = load i32, i32* %298
%300 = uitofp i32 %299 to double
%301 = load i32*, i32** %288
%302 = getelementptr inbounds i32, i32* %301, i64 %291
%303 = load i32, i32* %302
%304 = uitofp i32 %303 to double
%305 = load i32*, i32** %289
%306 = getelementptr inbounds i32, i32* %305, i64 %291
%307 = load i32, i32* %306
%308 = uitofp i32 %307 to double
%309 = fdiv double %304, %308
%310 = fmul double %309, %300
%311 = fsub double 1.000000e+00, %309
%312 = fmul double %310, %311
%313 = sub i32 %307, %299
%314 = uitofp i32 %313 to double
%315 = add i32 %307, -1
%316 = uitofp i32 %315 to double
%317 = fdiv double %314, %316
%318 = tail call double @llvm.fmuladd.f64(double %312, double %317, double %292)
br label %319
319: ; preds = %290, %296
%320 = phi double [ %318, %296 ], [ %292, %290 ]
%321 = add nuw nsw i64 %291, 1
%322 = icmp eq i64 %321, %210
br i1 %322, label %323, label %290
323: ; preds = %319, %251, %285
%324 = phi double [ %282, %285 ], [ 0.000000e+00, %251 ], [ %282, %319 ]
%325 = phi double [ 0.000000e+00, %285 ], [ 0.000000e+00, %251 ], [ %320, %319 ]
%326 = fadd double %254, %324
%327 = fadd double %253, %325
%328 = add nuw nsw i64 %252, 1
%329 = icmp eq i64 %328, %208
br i1 %329, label %330, label %251
330: ; preds = %323, %203
%331 = phi double [ 0.000000e+00, %203 ], [ %326, %323 ]
%332 = phi double [ 0.000000e+00, %203 ], [ %327, %323 ]
%333 = tail call i32 @dealloc_uivector(i32* %14, i32 %5)
%334 = tail call i32 @dealloc_uivector(i32* %15, i32 %5)
%335 = tail call i32 @dealloc_uivector(i32* %16, i32 %5)
%336 = tail call i32 @dealloc_uivector(i32* %17, i32 %5)
%337 = tail call i32 @dealloc_uimatrix(i32** %18, i32 %4, i32 %5)
%338 = tail call i32 @dealloc_uimatrix(i32** %19, i32 %4, i32 %5)
%339 = tail call i32 @dealloc_uimatrix(i32** %20, i32 %4, i32 %5)
%340 = tail call i32 @dealloc_uimatrix(i32** %21, i32 %4, i32 %5)
%341 = tail call double @llvm.fabs.f64(double %331)
%342 = tail call double @sqrt(double %332)
%343 = fcmp ugt double %342, 1.000000e-09
br i1 %343, label %348, label %344
344: ; preds = %330
%345 = fcmp ugt double %341, 1.000000e-09
br i1 %345, label %346, label %350
346: ; preds = %344
%347 = fdiv double %341, %342
br label %350
348: ; preds = %330
%349 = fdiv double %341, %342
br label %350
350: ; preds = %344, %346, %348
%351 = phi double [ %347, %346 ], [ %349, %348 ], [ 0.000000e+00, %344 ]
ret double %351
}