#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 */
float abs(int);
scalar_t__ ceilf(float);
int /*<<< orphan*/ cumsum_square_data(float *, int, float *, int, int,
                                      double *);
int /*<<< orphan*/ free(double *);
double *malloc(int);
int /*<<< orphan*/ memset(double *, int, int);
float network_corr(float *, float *, int *, float *, double *, float *, int,
                   int, int, int);
void matched_filter(float *templates, float *sum_square_templates,
                    int *moveouts, float *data, float *weights, int step,
                    int n_samples_template, int n_samples_data, int n_templates,
                    int n_stations, int n_components, int n_corr,
                    float *cc_sum) {
  int t, ch, i;
  int start_i, stop_i, cc_i;
  int min_moveout, max_moveout;
  int network_offset, station_offset, cc_sum_offset;
  int *moveouts_t = NULL;
  float *templates_t = NULL, *sum_square_templates_t = NULL, *weights_t = NULL;
  double *csum_square_data = NULL;
  csum_square_data = malloc(((n_samples_data + 1) * n_stations * n_components) *
                            sizeof(double));
  memset(csum_square_data, 0.,
         ((n_samples_data + 1) * n_stations * n_components) * sizeof(double));
  cumsum_square_data(data, n_samples_data, weights, n_stations, n_components,
                     csum_square_data);
  for (t = 0; t < n_templates; t++) {
    network_offset = t * n_stations * n_components;
    station_offset = t * n_stations;
    cc_sum_offset = t * n_corr;
    min_moveout = 0;
    max_moveout = 0;
    for (ch = 0; ch < (n_stations * n_components); ch++) {
      if (moveouts[network_offset + ch] < min_moveout)
        min_moveout = moveouts[network_offset + ch];
      if (moveouts[network_offset + ch] > max_moveout)
        max_moveout = moveouts[network_offset + ch];
    }
    templates_t = templates + network_offset * n_samples_template;
    moveouts_t = moveouts + network_offset;
    weights_t = weights + network_offset;
    sum_square_templates_t = sum_square_templates + network_offset;
    start_i = (int)(ceilf(abs(min_moveout) / (float)step)) * step;
    stop_i = 1 + (n_samples_data - n_samples_template - max_moveout);
#pragma omp parallel for private(i, cc_i)
    for (i = start_i; i < stop_i; i += step) {
      cc_i = i / step;
      cc_sum[cc_sum_offset + cc_i] = network_corr(
          templates_t, sum_square_templates_t, moveouts_t, data + i,
          csum_square_data + i + 1, weights_t, n_samples_template,
          n_samples_data, n_stations, n_components);
    }
  }
  free(csum_square_data);
}


x86 assembly (clang, -O0):
<matched_filter>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0xa8,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movq   $0x0,-0x68(%rbp)
movq   $0x0,-0x70(%rbp)
movq   $0x0,-0x78(%rbp)
movq   $0x0,-0x80(%rbp)
movq   $0x0,-0x88(%rbp)
mov    0x18(%rbp),%eax
add    $0x1,%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rdi
mov    0x18(%rbp),%eax
add    $0x1,%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0x28(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x30(%rbp),%rdx
mov    0x28(%rbp),%ecx
mov    0x30(%rbp),%r8d
mov    -0x88(%rbp),%r9
call   1070 <cumsum_square_data@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1426 <matched_filter+0x2b6>
mov    -0x38(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x38(%rbp),%eax
imul   0x28(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x38(%rbp),%eax
imul   0x38(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x28(%rbp),%ecx
imul   0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    1300 <matched_filter+0x190>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x50(%rbp),%eax
jge    12c1 <matched_filter+0x151>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
jle    12ed <matched_filter+0x17d>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
jmp    12f2 <matched_filter+0x182>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1283 <matched_filter+0x113>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   0x10(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x50(%rbp),%edi
call   1040 <abs@plt>
cvtsi2ssl -0x34(%rbp),%xmm1
divss  %xmm1,%xmm0
call   1090 <ceilf@plt>
imul   -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    0x18(%rbp),%eax
sub    0x10(%rbp),%eax
sub    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1413 <matched_filter+0x2a3>
mov    -0x40(%rbp),%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0x4c(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x68(%rbp),%rdx
mov    -0x28(%rbp),%rcx
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x88(%rbp),%r8
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
add    %rax,%r8
add    $0x8,%r8
mov    -0x80(%rbp),%r9
mov    0x10(%rbp),%ebx
mov    0x18(%rbp),%r11d
mov    0x28(%rbp),%r10d
mov    0x30(%rbp),%eax
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1080 <network_corr@plt>
mov    0x40(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    1384 <matched_filter+0x214>
jmp    1418 <matched_filter+0x2a8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1240 <matched_filter+0xd0>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
add    $0xa8,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<matched_filter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r9d,0x4(%rsp)
mov    %r8,0x38(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,0x10(%rsp)
mov    %rsi,0x90(%rsp)
mov    %rdi,0x88(%rsp)
mov    0x170(%rsp),%rax
mov    %rax,0xd8(%rsp)
mov    0x168(%rsp),%eax
mov    %eax,0x18(%rsp)
mov    0x160(%rsp),%r13d
mov    0x158(%rsp),%ebp
mov    0x150(%rsp),%eax
mov    %eax,(%rsp)
mov    0x148(%rsp),%r15d
mov    0x140(%rsp),%eax
mov    %rax,0x48(%rsp)
lea    0x1(%r15),%ebx
mov    %r13d,%r12d
imul   %ebp,%r12d
imul   %r12d,%ebx
shl    $0x3,%ebx
mov    %ebx,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1050 <memset@plt>
mov    0x30(%rsp),%rdi
mov    %r15,0x8(%rsp)
mov    %r15d,%esi
mov    0x38(%rsp),%rdx
mov    %rbp,%r15
mov    %r15d,%ecx
mov    %r13d,%r8d
mov    %r14,0x28(%rsp)
mov    %r14,%r9
call   1070 <cumsum_square_data@plt>
mov    (%rsp),%edi
xor    %esi,%esi
test   %edi,%edi
jle    176a <matched_filter+0x5fa>
mov    %r12d,%edx
mov    0x4(%rsp),%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x20(%rsp)
movslq %eax,%r12
movslq 0x18(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    %edi,%eax
mov    %rax,0xa0(%rsp)
mov    %edx,%ebp
mov    %ebp,%eax
and    $0xfffffff8,%eax
mov    %rax,0x70(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x68(%rsp)
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,0x60(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x58(%rsp)
mov    0x10(%rsp),%rax
add    $0x30,%rax
mov    %rax,0x50(%rsp)
mov    0x28(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x78(%rsp)
lea    0x0(,%r12,8),%rax
mov    %rax,0xd0(%rsp)
lea    0x0(,%r12,4),%rax
mov    %rax,0xc8(%rsp)
xor    %edi,%edi
mov    %r13,0xb0(%rsp)
mov    %r15,0xa8(%rsp)
mov    %edx,0x24(%rsp)
mov    %rbp,0x98(%rsp)
mov    %r12,0xc0(%rsp)
jmp    133d <matched_filter+0x1cd>
nopw   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rdi
add    $0x1,%rdi
mov    0x24(%rsp),%edx
mov    0xb8(%rsp),%rsi
add    %edx,%esi
cmp    0xa0(%rsp),%rdi
mov    0x98(%rsp),%rbp
je     176a <matched_filter+0x5fa>
mov    %edx,%eax
imul   %edi,%eax
movslq %eax,%r14
test   %edx,%edx
mov    %rsi,0xb8(%rsp)
mov    %rdi,0x40(%rsp)
jle    1370 <matched_filter+0x200>
movslq %esi,%rax
cmp    $0x8,%edx
jae    1380 <matched_filter+0x210>
xor    %ecx,%ecx
xor    %ebx,%ebx
xor    %edi,%edi
mov    0x8(%rsp),%r15
jmp    15c4 <matched_filter+0x454>
xchg   %ax,%ax
xor    %edi,%edi
xor    %ebx,%ebx
mov    0x8(%rsp),%r15
jmp    15e6 <matched_filter+0x476>
xchg   %ax,%ax
cmpq   $0x0,0x68(%rsp)
je     1744 <matched_filter+0x5d4>
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,4),%rdx
xorps  %xmm0,%xmm0
mov    0x58(%rsp),%rsi
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
pxor   %xmm3,%xmm3
pxor   %xmm2,%xmm2
mov    0x8(%rsp),%r15
movdqu -0x30(%rdx,%rcx,4),%xmm5
movdqu -0x20(%rdx,%rcx,4),%xmm10
movdqu -0x10(%rdx,%rcx,4),%xmm9
movdqu (%rdx,%rcx,4),%xmm8
movdqa %xmm3,%xmm6
pcmpgtd %xmm5,%xmm6
movdqa %xmm5,%xmm4
pand   %xmm6,%xmm4
pandn  %xmm3,%xmm6
por    %xmm4,%xmm6
movdqa %xmm2,%xmm7
pcmpgtd %xmm10,%xmm7
movdqa %xmm10,%xmm3
pand   %xmm7,%xmm3
pandn  %xmm2,%xmm7
por    %xmm3,%xmm7
movdqa %xmm5,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm5
pandn  %xmm0,%xmm4
por    %xmm5,%xmm4
movdqa %xmm10,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm5,%xmm10
pandn  %xmm1,%xmm5
por    %xmm10,%xmm5
movdqa %xmm6,%xmm3
pcmpgtd %xmm9,%xmm3
movdqa %xmm9,%xmm0
pand   %xmm3,%xmm0
pandn  %xmm6,%xmm3
por    %xmm0,%xmm3
movdqa %xmm7,%xmm2
pcmpgtd %xmm8,%xmm2
movdqa %xmm8,%xmm0
pand   %xmm2,%xmm0
pandn  %xmm7,%xmm2
por    %xmm0,%xmm2
movdqa %xmm9,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm9
pandn  %xmm4,%xmm0
por    %xmm9,%xmm0
movdqa %xmm8,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm8
pandn  %xmm5,%xmm1
por    %xmm8,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13b0 <matched_filter+0x240>
testb  $0x1,0x60(%rsp)
je     1523 <matched_filter+0x3b3>
add    %r14,%rcx
mov    0x10(%rsp),%rdx
movdqu (%rdx,%rcx,4),%xmm5
movdqu 0x10(%rdx,%rcx,4),%xmm8
movdqa %xmm3,%xmm6
pcmpgtd %xmm5,%xmm6
movdqa %xmm5,%xmm7
pand   %xmm6,%xmm7
pandn  %xmm3,%xmm6
por    %xmm7,%xmm6
movdqa %xmm2,%xmm7
pcmpgtd %xmm8,%xmm7
movdqa %xmm8,%xmm3
pand   %xmm7,%xmm3
pandn  %xmm2,%xmm7
por    %xmm3,%xmm7
movdqa %xmm5,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm5
pandn  %xmm0,%xmm4
por    %xmm5,%xmm4
movdqa %xmm8,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm5,%xmm8
pandn  %xmm1,%xmm5
por    %xmm8,%xmm5
movdqa %xmm6,%xmm3
movdqa %xmm7,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm5,%xmm1
movdqa %xmm2,%xmm4
pcmpgtd %xmm3,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm2,%xmm4
por    %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm4,%xmm3
pand   %xmm3,%xmm4
pandn  %xmm2,%xmm3
por    %xmm4,%xmm3
pshufd $0x55,%xmm3,%xmm2
movdqa %xmm2,%xmm4
pcmpgtd %xmm3,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm2,%xmm4
por    %xmm3,%xmm4
movd   %xmm4,%edi
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%ebx
mov    0x70(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbp,%rdx
je     15e6 <matched_filter+0x476>
mov    0x10(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
nopl   (%rax)
mov    (%rax,%rcx,4),%edx
cmp    %edi,%edx
cmovl  %edx,%edi
cmp    %ebx,%edx
cmovg  %edx,%ebx
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    15d0 <matched_filter+0x460>
call   1040 <abs@plt>
divss  0x20(%rsp),%xmm0
call   1090 <ceilf@plt>
imul   0x4(%rsp),%eax
mov    0x48(%rsp),%r10
add    %r10d,%ebx
mov    %r15d,%r8d
sub    %ebx,%r8d
cmp    %r8d,%eax
mov    0xb0(%rsp),%rbp
mov    0xa8(%rsp),%rbx
jg     1310 <matched_filter+0x1a0>
mov    %r15,%r11
mov    0x40(%rsp),%rdx
imul   0x80(%rsp),%rdx
mov    %rdx,0x18(%rsp)
mov    %r14d,%edx
imul   %r10d,%edx
movslq %edx,%rdx
mov    0x88(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
mov    %rdx,0x100(%rsp)
mov    0x10(%rsp),%rdx
lea    (%rdx,%r14,4),%rdx
mov    %rdx,0xf8(%rsp)
mov    0x38(%rsp),%rdx
lea    (%rdx,%r14,4),%rdx
mov    %rdx,0xf0(%rsp)
mov    0x90(%rsp),%rdx
lea    (%rdx,%r14,4),%rdx
mov    %rdx,0xe8(%rsp)
movslq %eax,%r13
movslq %r8d,%rax
mov    %rax,0xe0(%rsp)
mov    0x78(%rsp),%rax
lea    (%rax,%r13,8),%r14
mov    0x30(%rsp),%rax
lea    (%rax,%r13,4),%r15
nopl   0x0(%rax)
mov    %r13d,%eax
cltd
idiv   %r12d
mov    %eax,(%rsp)
mov    0x100(%rsp),%rdi
mov    0xe8(%rsp),%rsi
mov    0xf8(%rsp),%rdx
mov    %r15,%rcx
mov    %r14,%r8
mov    0xf0(%rsp),%r9
push   %rbp
push   %rbx
push   %r11
push   %r10
mov    %r11,%r12
call   1080 <network_corr@plt>
mov    0xe8(%rsp),%r9
mov    0xf0(%rsp),%rcx
mov    %r12,%r11
mov    0xf8(%rsp),%rdi
mov    0x68(%rsp),%r10
add    $0x20,%rsp
movslq (%rsp),%rax
mov    0xc0(%rsp),%r12
add    0x18(%rsp),%rax
movss  %xmm0,(%rdi,%rax,4)
add    %r12,%r13
add    %rcx,%r14
add    %r9,%r15
cmp    0xe0(%rsp),%r13
jle    16b0 <matched_filter+0x540>
jmp    1310 <matched_filter+0x1a0>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
pxor   %xmm3,%xmm3
pxor   %xmm2,%xmm2
mov    0x8(%rsp),%r15
testb  $0x1,0x60(%rsp)
jne    14a2 <matched_filter+0x332>
jmp    1523 <matched_filter+0x3b3>
mov    0x28(%rsp),%rdi
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @matched_filter(float* %0, float* %1, i32* %2, float* %3, float* %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, float* %12) {
%14 = alloca float*
%15 = alloca float*
%16 = alloca i32*
%17 = alloca float*
%18 = alloca float*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca float*
%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 i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32*
%39 = alloca float*
%40 = alloca float*
%41 = alloca float*
%42 = alloca double*
store float* %0, float** %14
store float* %1, float** %15
store i32* %2, i32** %16
store float* %3, float** %17
store float* %4, float** %18
store i32 %5, i32* %19
store i32 %6, i32* %20
store i32 %7, i32* %21
store i32 %8, i32* %22
store i32 %9, i32* %23
store i32 %10, i32* %24
store i32 %11, i32* %25
store float* %12, float** %26
store i32* null, i32** %38
store float* null, float** %39
store float* null, float** %40
store float* null, float** %41
store double* null, double** %42
%43 = load i32, i32* %21
%44 = add nsw i32 %43, 1
%45 = load i32, i32* %23
%46 = mul nsw i32 %44, %45
%47 = load i32, i32* %24
%48 = mul nsw i32 %46, %47
%49 = sext i32 %48 to i64
%50 = mul i64 %49, 8
%51 = trunc i64 %50 to i32
%52 = call double* @malloc(i32 %51)
store double* %52, double** %42
%53 = load double*, double** %42
%54 = load i32, i32* %21
%55 = add nsw i32 %54, 1
%56 = load i32, i32* %23
%57 = mul nsw i32 %55, %56
%58 = load i32, i32* %24
%59 = mul nsw i32 %57, %58
%60 = sext i32 %59 to i64
%61 = mul i64 %60, 8
%62 = trunc i64 %61 to i32
%63 = call i32 @memset(double* %53, i32 0, i32 %62)
%64 = load float*, float** %17
%65 = load i32, i32* %21
%66 = load float*, float** %18
%67 = load i32, i32* %23
%68 = load i32, i32* %24
%69 = load double*, double** %42
%70 = call i32 @cumsum_square_data(float* %64, i32 %65, float* %66, i32 %67, i32 %68, double* %69)
store i32 0, i32* %27
br label %71
71: ; preds = %205, %13
%72 = load i32, i32* %27
%73 = load i32, i32* %22
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %208
75: ; preds = %71
%76 = load i32, i32* %27
%77 = load i32, i32* %23
%78 = mul nsw i32 %76, %77
%79 = load i32, i32* %24
%80 = mul nsw i32 %78, %79
store i32 %80, i32* %35
%81 = load i32, i32* %27
%82 = load i32, i32* %23
%83 = mul nsw i32 %81, %82
store i32 %83, i32* %36
%84 = load i32, i32* %27
%85 = load i32, i32* %25
%86 = mul nsw i32 %84, %85
store i32 %86, i32* %37
store i32 0, i32* %33
store i32 0, i32* %34
store i32 0, i32* %28
br label %87
87: ; preds = %130, %75
%88 = load i32, i32* %28
%89 = load i32, i32* %23
%90 = load i32, i32* %24
%91 = mul nsw i32 %89, %90
%92 = icmp slt i32 %88, %91
br i1 %92, label %93, label %133
93: ; preds = %87
%94 = load i32*, i32** %16
%95 = load i32, i32* %35
%96 = load i32, i32* %28
%97 = add nsw i32 %95, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32, i32* %94, i64 %98
%100 = load i32, i32* %99
%101 = load i32, i32* %33
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %111
103: ; preds = %93
%104 = load i32*, i32** %16
%105 = load i32, i32* %35
%106 = load i32, i32* %28
%107 = add nsw i32 %105, %106
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %104, i64 %108
%110 = load i32, i32* %109
store i32 %110, i32* %33
br label %111
111: ; preds = %103, %93
%112 = load i32*, i32** %16
%113 = load i32, i32* %35
%114 = load i32, i32* %28
%115 = add nsw i32 %113, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %112, i64 %116
%118 = load i32, i32* %117
%119 = load i32, i32* %34
%120 = icmp sgt i32 %118, %119
br i1 %120, label %121, label %129
121: ; preds = %111
%122 = load i32*, i32** %16
%123 = load i32, i32* %35
%124 = load i32, i32* %28
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %122, i64 %126
%128 = load i32, i32* %127
store i32 %128, i32* %34
br label %129
129: ; preds = %121, %111
br label %130
130: ; preds = %129
%131 = load i32, i32* %28
%132 = add nsw i32 %131, 1
store i32 %132, i32* %28
br label %87
133: ; preds = %87
%134 = load float*, float** %14
%135 = load i32, i32* %35
%136 = load i32, i32* %20
%137 = mul nsw i32 %135, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %134, i64 %138
store float* %139, float** %39
%140 = load i32*, i32** %16
%141 = load i32, i32* %35
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %140, i64 %142
store i32* %143, i32** %38
%144 = load float*, float** %18
%145 = load i32, i32* %35
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
store float* %147, float** %41
%148 = load float*, float** %15
%149 = load i32, i32* %35
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %148, i64 %150
store float* %151, float** %40
%152 = load i32, i32* %33
%153 = call float @abs(i32 %152)
%154 = load i32, i32* %19
%155 = sitofp i32 %154 to float
%156 = fdiv float %153, %155
%157 = call i64 @ceilf(float %156)
%158 = trunc i64 %157 to i32
%159 = load i32, i32* %19
%160 = mul nsw i32 %158, %159
store i32 %160, i32* %30
%161 = load i32, i32* %21
%162 = load i32, i32* %20
%163 = sub nsw i32 %161, %162
%164 = load i32, i32* %34
%165 = sub nsw i32 %163, %164
%166 = add nsw i32 1, %165
store i32 %166, i32* %31
%167 = load i32, i32* %30
store i32 %167, i32* %29
br label %168
168: ; preds = %200, %133
%169 = load i32, i32* %29
%170 = load i32, i32* %31
%171 = icmp slt i32 %169, %170
br i1 %171, label %172, label %204
172: ; preds = %168
%173 = load i32, i32* %29
%174 = load i32, i32* %19
%175 = sdiv i32 %173, %174
store i32 %175, i32* %32
%176 = load float*, float** %39
%177 = load float*, float** %40
%178 = load i32*, i32** %38
%179 = load float*, float** %17
%180 = load i32, i32* %29
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
%183 = load double*, double** %42
%184 = load i32, i32* %29
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
%187 = getelementptr inbounds double, double* %186, i64 1
%188 = load float*, float** %41
%189 = load i32, i32* %20
%190 = load i32, i32* %21
%191 = load i32, i32* %23
%192 = load i32, i32* %24
%193 = call float @network_corr(float* %176, float* %177, i32* %178, float* %182, double* %187, float* %188, i32 %189, i32 %190, i32 %191, i32 %192)
%194 = load float*, float** %26
%195 = load i32, i32* %37
%196 = load i32, i32* %32
%197 = add nsw i32 %195, %196
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %194, i64 %198
store float %193, float* %199
br label %200
200: ; preds = %172
%201 = load i32, i32* %19
%202 = load i32, i32* %29
%203 = add nsw i32 %202, %201
store i32 %203, i32* %29
br label %168
204: ; preds = %168
br label %205
205: ; preds = %204
%206 = load i32, i32* %27
%207 = add nsw i32 %206, 1
store i32 %207, i32* %27
br label %71
208: ; preds = %71
%209 = load double*, double** %42
%210 = call i32 @free(double* %209)
ret void
}

LLVM IR (-O2):
define void @matched_filter(float* %0, float* %1, i32* %2, float* %3, float* %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, float* nocapture writeonly %12) {
%14 = add nsw i32 %7, 1
%15 = mul i32 %10, %9
%16 = shl i32 %15, 3
%17 = mul i32 %16, %14
%18 = tail call double* @malloc(i32 %17)
%19 = tail call i32 @memset(double* %18, i32 0, i32 %17)
%20 = tail call i32 @cumsum_square_data(float* %3, i32 %7, float* %4, i32 %9, i32 %10, double* %18)
%21 = icmp sgt i32 %8, 0
br i1 %21, label %22, label %179
22: ; preds = %13
%23 = icmp sgt i32 %15, 0
%24 = sitofp i32 %5 to float
%25 = sext i32 %5 to i64
%26 = sext i32 %11 to i64
%27 = zext i32 %8 to i64
%28 = zext i32 %15 to i64
%29 = getelementptr inbounds double, double* %18, i64 1
%30 = and i64 %28, 4294967288
%31 = add nsw i64 %30, -8
%32 = lshr exact i64 %31, 3
%33 = add nuw nsw i64 %32, 1
%34 = icmp ult i32 %15, 8
%35 = and i64 %28, 4294967288
%36 = and i64 %33, 1
%37 = icmp eq i64 %31, 0
%38 = and i64 %33, 4611686018427387902
%39 = icmp eq i64 %36, 0
%40 = icmp eq i64 %35, %28
br label %41
41: ; preds = %22, %176
%42 = phi i64 [ 0, %22 ], [ %177, %176 ]
%43 = trunc i64 %42 to i32
%44 = mul i32 %15, %43
%45 = mul nsw i64 %42, %26
%46 = sext i32 %44 to i64
br i1 %23, label %47, label %144
47: ; preds = %41
br i1 %34, label %127, label %48
48: ; preds = %47
br i1 %37, label %90, label %49
49: ; preds = %48, %49
%50 = phi i64 [ %87, %49 ], [ 0, %48 ]
%51 = phi <4 x i32> [ %85, %49 ], [ zeroinitializer, %48 ]
%52 = phi <4 x i32> [ %86, %49 ], [ zeroinitializer, %48 ]
%53 = phi <4 x i32> [ %81, %49 ], [ zeroinitializer, %48 ]
%54 = phi <4 x i32> [ %82, %49 ], [ zeroinitializer, %48 ]
%55 = phi i64 [ %88, %49 ], [ 0, %48 ]
%56 = add nsw i64 %50, %46
%57 = getelementptr inbounds i32, i32* %2, i64 %56
%58 = bitcast i32* %57 to <4 x i32>*
%59 = load <4 x i32>, <4 x i32>* %58
%60 = getelementptr inbounds i32, i32* %57, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = icmp slt <4 x i32> %59, %53
%64 = icmp slt <4 x i32> %62, %54
%65 = select <4 x i1> %63, <4 x i32> %59, <4 x i32> %53
%66 = select <4 x i1> %64, <4 x i32> %62, <4 x i32> %54
%67 = icmp sgt <4 x i32> %59, %51
%68 = icmp sgt <4 x i32> %62, %52
%69 = select <4 x i1> %67, <4 x i32> %59, <4 x i32> %51
%70 = select <4 x i1> %68, <4 x i32> %62, <4 x i32> %52
%71 = or i64 %50, 8
%72 = add nsw i64 %71, %46
%73 = getelementptr inbounds i32, i32* %2, i64 %72
%74 = bitcast i32* %73 to <4 x i32>*
%75 = load <4 x i32>, <4 x i32>* %74
%76 = getelementptr inbounds i32, i32* %73, i64 4
%77 = bitcast i32* %76 to <4 x i32>*
%78 = load <4 x i32>, <4 x i32>* %77
%79 = icmp slt <4 x i32> %75, %65
%80 = icmp slt <4 x i32> %78, %66
%81 = select <4 x i1> %79, <4 x i32> %75, <4 x i32> %65
%82 = select <4 x i1> %80, <4 x i32> %78, <4 x i32> %66
%83 = icmp sgt <4 x i32> %75, %69
%84 = icmp sgt <4 x i32> %78, %70
%85 = select <4 x i1> %83, <4 x i32> %75, <4 x i32> %69
%86 = select <4 x i1> %84, <4 x i32> %78, <4 x i32> %70
%87 = add nuw i64 %50, 16
%88 = add i64 %55, 2
%89 = icmp eq i64 %88, %38
br i1 %89, label %90, label %49
90: ; preds = %49, %48
%91 = phi <4 x i32> [ undef, %48 ], [ %81, %49 ]
%92 = phi <4 x i32> [ undef, %48 ], [ %82, %49 ]
%93 = phi <4 x i32> [ undef, %48 ], [ %85, %49 ]
%94 = phi <4 x i32> [ undef, %48 ], [ %86, %49 ]
%95 = phi i64 [ 0, %48 ], [ %87, %49 ]
%96 = phi <4 x i32> [ zeroinitializer, %48 ], [ %85, %49 ]
%97 = phi <4 x i32> [ zeroinitializer, %48 ], [ %86, %49 ]
%98 = phi <4 x i32> [ zeroinitializer, %48 ], [ %81, %49 ]
%99 = phi <4 x i32> [ zeroinitializer, %48 ], [ %82, %49 ]
br i1 %39, label %116, label %100
100: ; preds = %90
%101 = add nsw i64 %95, %46
%102 = getelementptr inbounds i32, i32* %2, i64 %101
%103 = bitcast i32* %102 to <4 x i32>*
%104 = load <4 x i32>, <4 x i32>* %103
%105 = getelementptr inbounds i32, i32* %102, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = icmp slt <4 x i32> %104, %98
%109 = icmp slt <4 x i32> %107, %99
%110 = select <4 x i1> %108, <4 x i32> %104, <4 x i32> %98
%111 = select <4 x i1> %109, <4 x i32> %107, <4 x i32> %99
%112 = icmp sgt <4 x i32> %104, %96
%113 = icmp sgt <4 x i32> %107, %97
%114 = select <4 x i1> %112, <4 x i32> %104, <4 x i32> %96
%115 = select <4 x i1> %113, <4 x i32> %107, <4 x i32> %97
br label %116
116: ; preds = %90, %100
%117 = phi <4 x i32> [ %91, %90 ], [ %110, %100 ]
%118 = phi <4 x i32> [ %92, %90 ], [ %111, %100 ]
%119 = phi <4 x i32> [ %93, %90 ], [ %114, %100 ]
%120 = phi <4 x i32> [ %94, %90 ], [ %115, %100 ]
%121 = icmp slt <4 x i32> %117, %118
%122 = select <4 x i1> %121, <4 x i32> %117, <4 x i32> %118
%123 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %122)
%124 = icmp sgt <4 x i32> %119, %120
%125 = select <4 x i1> %124, <4 x i32> %119, <4 x i32> %120
%126 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %125)
br i1 %40, label %144, label %127
127: ; preds = %47, %116
%128 = phi i64 [ 0, %47 ], [ %35, %116 ]
%129 = phi i32 [ 0, %47 ], [ %126, %116 ]
%130 = phi i32 [ 0, %47 ], [ %123, %116 ]
br label %131
131: ; preds = %127, %131
%132 = phi i64 [ %142, %131 ], [ %128, %127 ]
%133 = phi i32 [ %141, %131 ], [ %129, %127 ]
%134 = phi i32 [ %139, %131 ], [ %130, %127 ]
%135 = add nsw i64 %132, %46
%136 = getelementptr inbounds i32, i32* %2, i64 %135
%137 = load i32, i32* %136
%138 = icmp slt i32 %137, %134
%139 = select i1 %138, i32 %137, i32 %134
%140 = icmp sgt i32 %137, %133
%141 = select i1 %140, i32 %137, i32 %133
%142 = add nuw nsw i64 %132, 1
%143 = icmp eq i64 %142, %28
br i1 %143, label %144, label %131
144: ; preds = %131, %116, %41
%145 = phi i32 [ 0, %41 ], [ %123, %116 ], [ %139, %131 ]
%146 = phi i32 [ 0, %41 ], [ %126, %116 ], [ %141, %131 ]
%147 = mul nsw i32 %44, %6
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %0, i64 %148
%150 = getelementptr inbounds i32, i32* %2, i64 %46
%151 = getelementptr inbounds float, float* %4, i64 %46
%152 = getelementptr inbounds float, float* %1, i64 %46
%153 = tail call float @abs(i32 %145)
%154 = fdiv float %153, %24
%155 = tail call i64 @ceilf(float %154)
%156 = trunc i64 %155 to i32
%157 = mul i32 %156, %5
%158 = add i32 %146, %6
%159 = sub i32 %7, %158
%160 = icmp sgt i32 %157, %159
br i1 %160, label %176, label %161
161: ; preds = %144
%162 = sext i32 %157 to i64
%163 = sext i32 %159 to i64
br label %164
164: ; preds = %161, %164
%165 = phi i64 [ %162, %161 ], [ %174, %164 ]
%166 = trunc i64 %165 to i32
%167 = sdiv i32 %166, %5
%168 = getelementptr inbounds float, float* %3, i64 %165
%169 = getelementptr inbounds double, double* %29, i64 %165
%170 = tail call float @network_corr(float* %149, float* %152, i32* %150, float* %168, double* %169, float* %151, i32 %6, i32 %7, i32 %9, i32 %10)
%171 = sext i32 %167 to i64
%172 = add nsw i64 %45, %171
%173 = getelementptr inbounds float, float* %12, i64 %172
store float %170, float* %173
%174 = add i64 %165, %25
%175 = icmp sgt i64 %174, %163
br i1 %175, label %176, label %164
176: ; preds = %164, %144
%177 = add nuw nsw i64 %42, 1
%178 = icmp eq i64 %177, %27
br i1 %178, label %179, label %41
179: ; preds = %176, %13
%180 = tail call i32 @free(double* %18)
ret void
}