#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 */
int /*<<< orphan*/ fklt(double *, double *, double *, int);
int /*<<< orphan*/ flap_2d(double **, double **, int const *);
void b_analysis_2d(
    double *_out, int _out_stride_i, int _out_stride_j, const double *_in,
    int _in_stride_i, int _in_stride_j, const int *_f,
    double _klt[(1 << (4)) * (1 << (4))][(1 << (4)) * (1 << (4))]) {
  double lap[((1 << (4)) * 2)][((1 << (4)) * 2)];
  double work[(1 << (4))][(1 << (4))];
  double temp[(1 << (4))][(1 << (4))];
  int i, j;
  for (i = 0; i < ((1 << (4)) * 2); i++)
    for (j = 0; j < ((1 << (4)) * 2); j++)
      lap[i][j] = *(_in + i * _in_stride_i + j * _in_stride_j);
  flap_2d(work, lap, _f);
  fklt(&temp[0][0], &work[0][0], &_klt[0][0], (1 << (4)) * (1 << (4)));
  for (i = 0; i < (1 << (4)); i++)
    for (j = 0; j < (1 << (4)); j++)
      *(_out + i * _out_stride_i + j * _out_stride_j) = temp[i][j];
}


x86 assembly (clang, -O0):
<b_analysis_2d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3030,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movl   $0x0,-0x3024(%rbp)
cmpl   $0x20,-0x3024(%rbp)
jge    11ef <b_analysis_2d+0xcf>
movl   $0x0,-0x3028(%rbp)
cmpl   $0x20,-0x3028(%rbp)
jge    11d6 <b_analysis_2d+0xb6>
mov    -0x18(%rbp),%rax
mov    -0x3024(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x3028(%rbp),%ecx
imul   -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x3024(%rbp),%rcx
lea    -0x2020(%rbp),%rax
shl    $0x8,%rcx
add    %rcx,%rax
movslq -0x3028(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3028(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3028(%rbp)
jmp    116a <b_analysis_2d+0x4a>
jmp    11db <b_analysis_2d+0xbb>
mov    -0x3024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3024(%rbp)
jmp    1153 <b_analysis_2d+0x33>
lea    -0x2820(%rbp),%rdi
lea    -0x2020(%rbp),%rsi
mov    0x10(%rbp),%rdx
call   1040 <flap_2d@plt>
lea    -0x3020(%rbp),%rdi
lea    -0x2820(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    $0x100,%ecx
call   1030 <fklt@plt>
movl   $0x0,-0x3024(%rbp)
cmpl   $0x10,-0x3024(%rbp)
jge    12c8 <b_analysis_2d+0x1a8>
movl   $0x0,-0x3028(%rbp)
cmpl   $0x10,-0x3028(%rbp)
jge    12af <b_analysis_2d+0x18f>
movslq -0x3024(%rbp),%rcx
lea    -0x3020(%rbp),%rax
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x3028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3024(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x3028(%rbp),%ecx
imul   -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3028(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3028(%rbp)
jmp    1243 <b_analysis_2d+0x123>
jmp    12b4 <b_analysis_2d+0x194>
mov    -0x3024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3024(%rbp)
jmp    122c <b_analysis_2d+0x10c>
add    $0x3030,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<b_analysis_2d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3078,%rsp
mov    %rcx,%r13
mov    %edx,(%rsp)
mov    %esi,0x4(%rsp)
mov    %rdi,%r12
movslq %r9d,%rbp
movslq %r8d,%rdx
mov    %rbp,%rdi
shl    $0x4,%rdi
mov    %rdi,%rax
sub    %rbp,%rax
sub    %rbp,%rax
mov    %rax,0x58(%rsp)
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    0x0(,%rax,4),%rcx
add    %rbp,%rcx
add    %rbp,%rcx
mov    %rcx,0x50(%rsp)
lea    (%rax,%rax,4),%rax
add    %rbp,%rax
mov    %rax,0x48(%rsp)
lea    0x0(,%rbp,8),%rax
add    %rbp,%rax
lea    (%rax,%rax,2),%rax
add    %rbp,%rax
mov    %rax,0x40(%rsp)
mov    %rbp,%rax
shl    $0x5,%rax
mov    %rax,%r15
sub    %rbp,%r15
sub    %rbp,%r15
mov    %rbp,%r14
add    %rbp,%r14
lea    0x0(,%rbp,4),%rcx
lea    (%r14,%r14,2),%rsi
mov    %rsi,0x30(%rsp)
lea    0x0(,%rbp,8),%rsi
lea    (%r14,%r14,4),%rbx
mov    %rbx,0x20(%rsp)
lea    (%rcx,%rcx,2),%rbx
mov    %rbx,0x18(%rsp)
lea    (%r14,%r14,8),%rbx
mov    %rbx,0x10(%rsp)
mov    %rcx,0x38(%rsp)
lea    (%rcx,%rcx,4),%rcx
mov    %rcx,0x8(%rsp)
mov    %rsi,0x28(%rsp)
lea    (%rsi,%rsi,2),%rcx
mov    %rdx,0x60(%rsp)
lea    0x0(,%rdx,8),%r10
lea    0x888(%rsp),%r8
xor    %edx,%edx
mov    %r13,0x68(%rsp)
jmp    1355 <b_analysis_2d+0x235>
nopl   0x0(%rax)
mov    %rdx,%rsi
imul   0x60(%rsp),%rsi
mov    0x68(%rsp),%rbx
lea    (%rbx,%rsi,8),%rsi
movups (%rsi),%xmm0
mov    %rdx,%r11
shl    $0x8,%r11
movaps %xmm0,0x870(%rsp,%r11,1)
movups (%rsi,%r14,8),%xmm0
movaps %xmm0,0x880(%rsp,%r11,1)
mov    0x38(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x890(%rsp,%r11,1)
mov    0x30(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x8a0(%rsp,%r11,1)
mov    0x28(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x8b0(%rsp,%r11,1)
mov    0x20(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x8c0(%rsp,%r11,1)
mov    0x18(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x8d0(%rsp,%r11,1)
mov    0x58(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x8e0(%rsp,%r11,1)
movups (%rsi,%rdi,8),%xmm0
movaps %xmm0,0x8f0(%rsp,%r11,1)
mov    0x10(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x900(%rsp,%r11,1)
mov    0x8(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x910(%rsp,%r11,1)
mov    0x50(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x920(%rsp,%r11,1)
movups (%rsi,%rcx,8),%xmm0
movaps %xmm0,0x930(%rsp,%r11,1)
mov    0x48(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x940(%rsp,%r11,1)
mov    0x40(%rsp),%rbx
movups (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x950(%rsp,%r11,1)
movups (%rsi,%r15,8),%xmm0
movaps %xmm0,0x960(%rsp,%r11,1)
add    $0x1,%rdx
add    %r10,%r13
add    $0x100,%r8
cmp    $0x20,%rdx
je     13ad <b_analysis_2d+0x28d>
cmp    $0x1,%r9d
je     1220 <b_analysis_2d+0x100>
mov    %r13,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsi),%xmm0
movsd  %xmm0,-0x18(%r8,%rbx,8)
movsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,-0x10(%r8,%rbx,8)
movsd  (%rsi,%rdi,1),%xmm0
movsd  %xmm0,-0x8(%r8,%rbx,8)
movsd  (%rsi,%rcx,1),%xmm0
movsd  %xmm0,(%r8,%rbx,8)
add    $0x4,%rbx
add    %rax,%rsi
cmp    $0x20,%rbx
jne    1370 <b_analysis_2d+0x250>
jmp    1341 <b_analysis_2d+0x221>
lea    0x2870(%rsp),%rbp
lea    0x870(%rsp),%rsi
mov    %rbp,%rdi
mov    0x30b0(%rsp),%rdx
call   1040 <flap_2d@plt>
lea    0x70(%rsp),%rdi
mov    %rbp,%rsi
mov    0x30b8(%rsp),%rdx
mov    $0x100,%ecx
call   1030 <fklt@plt>
movslq (%rsp),%rax
movslq 0x4(%rsp),%rcx
lea    0x0(,%rax,8),%rdx
shl    $0x3,%rcx
xor    %esi,%esi
xchg   %ax,%ax
movsd  0x70(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%r12)
movsd  0x78(%rsp,%rsi,1),%xmm0
lea    (%r12,%rdx,1),%rdi
movsd  %xmm0,(%r12,%rax,8)
movsd  0x80(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0x88(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0x90(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0x98(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xa0(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xa8(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xb0(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xb8(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xc0(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xc8(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xd0(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xd8(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xe0(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rdx,%rdi
movsd  0xe8(%rsp,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    %rcx,%r12
sub    $0xffffffffffffff80,%rsi
cmp    $0x800,%rsi
jne    1400 <b_analysis_2d+0x2e0>
add    $0x3078,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @b_analysis_2d(double* %0, i32 %1, i32 %2, double* %3, i32 %4, i32 %5, i32* %6, [256 x double]* %7) {
%9 = alloca double*
%10 = alloca i32
%11 = alloca i32
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32*
%16 = alloca [256 x double]*
%17 = alloca [32 x [32 x double]]
%18 = alloca [16 x [16 x double]]
%19 = alloca [16 x [16 x double]]
%20 = alloca i32
%21 = alloca i32
store double* %0, double** %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store double* %3, double** %12
store i32 %4, i32* %13
store i32 %5, i32* %14
store i32* %6, i32** %15
store [256 x double]* %7, [256 x double]** %16
store i32 0, i32* %20
br label %22
22: ; preds = %52, %8
%23 = load i32, i32* %20
%24 = icmp slt i32 %23, 32
br i1 %24, label %25, label %55
25: ; preds = %22
store i32 0, i32* %21
br label %26
26: ; preds = %48, %25
%27 = load i32, i32* %21
%28 = icmp slt i32 %27, 32
br i1 %28, label %29, label %51
29: ; preds = %26
%30 = load double*, double** %12
%31 = load i32, i32* %20
%32 = load i32, i32* %13
%33 = mul nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds double, double* %30, i64 %34
%36 = load i32, i32* %21
%37 = load i32, i32* %14
%38 = mul nsw i32 %36, %37
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %35, i64 %39
%41 = load double, double* %40
%42 = load i32, i32* %20
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [32 x [32 x double]], [32 x [32 x double]]* %17, i64 0, i64 %43
%45 = load i32, i32* %21
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [32 x double], [32 x double]* %44, i64 0, i64 %46
store double %41, double* %47
br label %48
48: ; preds = %29
%49 = load i32, i32* %21
%50 = add nsw i32 %49, 1
store i32 %50, i32* %21
br label %26
51: ; preds = %26
br label %52
52: ; preds = %51
%53 = load i32, i32* %20
%54 = add nsw i32 %53, 1
store i32 %54, i32* %20
br label %22
55: ; preds = %22
%56 = getelementptr inbounds [16 x [16 x double]], [16 x [16 x double]]* %18, i64 0, i64 0
%57 = bitcast [16 x double]* %56 to double**
%58 = getelementptr inbounds [32 x [32 x double]], [32 x [32 x double]]* %17, i64 0, i64 0
%59 = bitcast [32 x double]* %58 to double**
%60 = load i32*, i32** %15
%61 = call i32 @flap_2d(double** %57, double** %59, i32* %60)
%62 = getelementptr inbounds [16 x [16 x double]], [16 x [16 x double]]* %19, i64 0, i64 0
%63 = getelementptr inbounds [16 x double], [16 x double]* %62, i64 0, i64 0
%64 = getelementptr inbounds [16 x [16 x double]], [16 x [16 x double]]* %18, i64 0, i64 0
%65 = getelementptr inbounds [16 x double], [16 x double]* %64, i64 0, i64 0
%66 = load [256 x double]*, [256 x double]** %16
%67 = getelementptr inbounds [256 x double], [256 x double]* %66, i64 0
%68 = getelementptr inbounds [256 x double], [256 x double]* %67, i64 0, i64 0
%69 = call i32 @fklt(double* %63, double* %65, double* %68, i32 256)
store i32 0, i32* %20
br label %70
70: ; preds = %100, %55
%71 = load i32, i32* %20
%72 = icmp slt i32 %71, 16
br i1 %72, label %73, label %103
73: ; preds = %70
store i32 0, i32* %21
br label %74
74: ; preds = %96, %73
%75 = load i32, i32* %21
%76 = icmp slt i32 %75, 16
br i1 %76, label %77, label %99
77: ; preds = %74
%78 = load i32, i32* %20
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [16 x [16 x double]], [16 x [16 x double]]* %19, i64 0, i64 %79
%81 = load i32, i32* %21
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [16 x double], [16 x double]* %80, i64 0, i64 %82
%84 = load double, double* %83
%85 = load double*, double** %9
%86 = load i32, i32* %20
%87 = load i32, i32* %10
%88 = mul nsw i32 %86, %87
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %85, i64 %89
%91 = load i32, i32* %21
%92 = load i32, i32* %11
%93 = mul nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double, double* %90, i64 %94
store double %84, double* %95
br label %96
96: ; preds = %77
%97 = load i32, i32* %21
%98 = add nsw i32 %97, 1
store i32 %98, i32* %21
br label %74
99: ; preds = %74
br label %100
100: ; preds = %99
%101 = load i32, i32* %20
%102 = add nsw i32 %101, 1
store i32 %102, i32* %20
br label %70
103: ; preds = %70
ret void
}

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