#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*/ convolution2d(double **, double **, int);
void convolutionOfMatrix(double arr[][20], double conv[][20], int size) {
  int i = 0;
  int j = 0;
  int m = 0;
  int n = 0;
  double arr1[10][20];
  double convolution[20][20];
  if (size == 2) {
    for (i = 0; i < size; i++) {
      for (j = 0; j < size; j++)
        conv[i][j] == arr[i][j];
    }
  } else {
    m = 0;
    for (i = 0; i < size / 2; i++) {
      n = 0;
      for (j = 0; j < size / 2; j++) {
        arr1[m][n] = arr[i][j];
        n++;
      }
      m++;
    }
    convolution2d(arr1, convolution, size / 2);
    m = 0;
    for (i = 0; i < size / 2; i++) {
      n = 0;
      for (j = 0; j < size / 2; j++) {
        conv[i][j] = convolution[m][n];
        n++;
      }
      m++;
    }
    m = 0;
    for (i = 0; i < size / 2; i++) {
      n = 0;
      for (j = size / 2; j < size; j++) {
        arr1[m][n] = arr[i][j];
        n++;
      }
      m++;
    }
    convolution2d(arr1, convolution, size / 2);
    m = 0;
    for (i = 0; i < size / 2; i++) {
      n = 0;
      for (j = size / 2; j < size; j++) {
        conv[i][j] = convolution[m][n];
        n++;
      }
      m++;
    }
    m = 0;
    for (i = size / 2; i < size; i++) {
      n = 0;
      for (j = 0; j < size / 2; j++) {
        arr1[m][n] = arr[i][j];
        n++;
      }
      m++;
    }
    convolution2d(arr1, convolution, size / 2);
    m = 0;
    for (i = size / 2; i < size; i++) {
      n = 0;
      for (j = 0; j < size / 2; j++) {
        conv[i][j] = convolution[m][n];
        n++;
      }
      m++;
    }
    m = 0;
    for (i = size / 2; i < size; i++) {
      n = 0;
      for (j = size / 2; j < size; j++) {
        arr1[m][n] = arr[i][j];
        n++;
      }
      m++;
    }
    convolution2d(arr1, convolution, size / 2);
    m = 0;
    for (i = size / 2; i < size; i++) {
      n = 0;
      for (j = size / 2; j < size; j++) {
        conv[i][j] = convolution[m][n];
        n++;
      }
      m++;
    }
  }
}


x86 assembly (clang, -O0):
<convolutionOfMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1310,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x2,-0x14(%rbp)
jne    1198 <convolutionOfMatrix+0x88>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1193 <convolutionOfMatrix+0x83>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1180 <convolutionOfMatrix+0x70>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1166 <convolutionOfMatrix+0x56>
jmp    1185 <convolutionOfMatrix+0x75>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1153 <convolutionOfMatrix+0x43>
jmp    17ed <convolutionOfMatrix+0x6dd>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x12f4(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x12f4(%rbp),%eax
cmp    %ecx,%eax
jge    1263 <convolutionOfMatrix+0x153>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x12f8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x12f8(%rbp),%eax
cmp    %ecx,%eax
jge    124c <convolutionOfMatrix+0x13c>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11d8 <convolutionOfMatrix+0xc8>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11a6 <convolutionOfMatrix+0x96>
lea    -0x670(%rbp),%rdi
lea    -0x12f0(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <convolution2d@plt>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x12fc(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x12fc(%rbp),%eax
cmp    %ecx,%eax
jge    134e <convolutionOfMatrix+0x23e>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x1300(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1300(%rbp),%eax
cmp    %ecx,%eax
jge    1337 <convolutionOfMatrix+0x227>
movslq -0x20(%rbp),%rcx
lea    -0x12f0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12c3 <convolutionOfMatrix+0x1b3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1291 <convolutionOfMatrix+0x181>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1304(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1304(%rbp),%eax
cmp    %ecx,%eax
jge    1408 <convolutionOfMatrix+0x2f8>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13f1 <convolutionOfMatrix+0x2e1>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1395 <convolutionOfMatrix+0x285>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    135c <convolutionOfMatrix+0x24c>
lea    -0x670(%rbp),%rdi
lea    -0x12f0(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <convolution2d@plt>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1308(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1308(%rbp),%eax
cmp    %ecx,%eax
jge    14e2 <convolutionOfMatrix+0x3d2>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14cb <convolutionOfMatrix+0x3bb>
movslq -0x20(%rbp),%rcx
lea    -0x12f0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    146f <convolutionOfMatrix+0x35f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1436 <convolutionOfMatrix+0x326>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    159c <convolutionOfMatrix+0x48c>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x130c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x130c(%rbp),%eax
cmp    %ecx,%eax
jge    1585 <convolutionOfMatrix+0x475>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1511 <convolutionOfMatrix+0x401>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14f7 <convolutionOfMatrix+0x3e7>
lea    -0x670(%rbp),%rdi
lea    -0x12f0(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <convolution2d@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1676 <convolutionOfMatrix+0x566>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x1310(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1310(%rbp),%eax
cmp    %ecx,%eax
jge    165f <convolutionOfMatrix+0x54f>
movslq -0x20(%rbp),%rcx
lea    -0x12f0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15eb <convolutionOfMatrix+0x4db>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    15d1 <convolutionOfMatrix+0x4c1>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    171f <convolutionOfMatrix+0x60f>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1708 <convolutionOfMatrix+0x5f8>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16ac <convolutionOfMatrix+0x59c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    168b <convolutionOfMatrix+0x57b>
lea    -0x670(%rbp),%rdi
lea    -0x12f0(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <convolution2d@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17e8 <convolutionOfMatrix+0x6d8>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17d1 <convolutionOfMatrix+0x6c1>
movslq -0x20(%rbp),%rcx
lea    -0x12f0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1775 <convolutionOfMatrix+0x665>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1754 <convolutionOfMatrix+0x644>
jmp    17ed <convolutionOfMatrix+0x6dd>
add    $0x1310,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convolutionOfMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1318,%rsp
cmp    $0x2,%edx
je     1672 <convolutionOfMatrix+0x552>
mov    %edx,%r12d
mov    %rdi,0x28(%rsp)
mov    %edx,%ebp
shr    $0x1f,%ebp
add    %edx,%ebp
sar    %ebp
cmp    $0x1,%edx
mov    %rsi,0x30(%rsp)
mov    %rbp,0x18(%rsp)
jle    11d4 <convolutionOfMatrix+0xb4>
lea    -0x1(%rbp),%ecx
lea    0x8(,%rcx,8),%r15
mov    %ebp,%r14d
mov    %r14,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x20(%rsp)
mov    %r14,0x10(%rsp)
mov    %rcx,0x8(%rsp)
je     11ed <convolutionOfMatrix+0xcd>
and    $0xfffffffe,%r14d
xor    %ebx,%ebx
xor    %ebp,%ebp
mov    0x28(%rsp),%r13
nopl   (%rax)
lea    (%rbx,%r13,1),%rsi
lea    (%rsp,%rbx,1),%rdi
add    $0x50,%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
lea    (%rbx,%r13,1),%rsi
add    $0xa0,%rsi
lea    (%rsp,%rbx,1),%rdi
add    $0xf0,%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
add    $0x2,%rbp
add    $0x140,%rbx
cmp    %rbp,%r14
jne    1190 <convolutionOfMatrix+0x70>
jmp    11ef <convolutionOfMatrix+0xcf>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1040 <convolution2d@plt>
jmp    13a3 <convolutionOfMatrix+0x283>
xor    %ebp,%ebp
mov    0x10(%rsp),%r14
test   $0x1,%r14b
je     1222 <convolutionOfMatrix+0x102>
shl    $0x5,%rbp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,1),%rsi
lea    (%rsp,%rax,1),%rdi
add    $0x50,%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    0x18(%rsp),%rbp
mov    %ebp,%edx
call   1040 <convolution2d@plt>
cmp    $0x2,%r12d
jl     13a3 <convolutionOfMatrix+0x283>
mov    0x8(%rsp),%rax
lea    0x8(,%rax,8),%r15
cmpq   $0x0,0x20(%rsp)
je     12b7 <convolutionOfMatrix+0x197>
and    $0xfffffffe,%r14d
xor    %ebx,%ebx
xor    %ebp,%ebp
mov    0x30(%rsp),%r13
nopw   0x0(%rax,%rax,1)
lea    (%rsp,%rbx,1),%rsi
add    $0x690,%rsi
lea    (%rbx,%r13,1),%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
lea    (%rsp,%rbx,1),%rsi
add    $0x730,%rsi
lea    (%rbx,%r13,1),%rdi
add    $0xa0,%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
add    $0x2,%rbp
add    $0x140,%rbx
cmp    %rbp,%r14
jne    1270 <convolutionOfMatrix+0x150>
jmp    12be <convolutionOfMatrix+0x19e>
xor    %ebp,%ebp
mov    0x30(%rsp),%r13
mov    0x10(%rsp),%rbx
test   $0x1,%bl
je     12ed <convolutionOfMatrix+0x1cd>
shl    $0x5,%rbp
lea    0x0(,%rbp,4),%rdi
add    %rbp,%rdi
lea    (%rsp,%rdi,1),%rsi
add    $0x690,%rsi
add    %r13,%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
cmp    $0x2,%r12d
mov    0x18(%rsp),%rbp
jl     13a3 <convolutionOfMatrix+0x283>
movslq %ebp,%rcx
not    %ebp
add    %r12d,%ebp
lea    0x8(,%rbp,8),%rax
mov    %rax,0x8(%rsp)
cmpq   $0x0,0x20(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rbp,0x40(%rsp)
je     1767 <convolutionOfMatrix+0x647>
mov    %ebx,%r15d
and    $0xfffffffe,%r15d
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%rbp
mov    $0xa0,%r14d
xor    %ebx,%ebx
mov    0x18(%rsp),%r13
jmp    1364 <convolutionOfMatrix+0x244>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%rbx
add    $0x140,%r14
cmp    %rbx,%r15
je     1769 <convolutionOfMatrix+0x649>
cmp    %r12d,%r13d
jge    1386 <convolutionOfMatrix+0x266>
lea    (%r14,%rbp,1),%rsi
add    $0xffffffffffffff60,%rsi
lea    (%rsp,%r14,1),%rdi
add    $0xffffffffffffffb0,%rdi
mov    0x8(%rsp),%rdx
call   1030 <memcpy@plt>
cmp    %r12d,%r13d
jge    1350 <convolutionOfMatrix+0x230>
lea    (%r14,%rbp,1),%rsi
lea    (%rsp,%r14,1),%rdi
add    $0x50,%rdi
mov    0x8(%rsp),%rdx
call   1030 <memcpy@plt>
jmp    1350 <convolutionOfMatrix+0x230>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1040 <convolution2d@plt>
cmp    %r12d,%ebp
jge    164a <convolutionOfMatrix+0x52a>
movslq %ebp,%rax
lea    -0x1(%rbp),%ecx
mov    %rcx,0x20(%rsp)
lea    0x8(,%rcx,8),%rbx
mov    %r12d,%r13d
sub    %ebp,%r13d
cmp    $0x1,%r13d
mov    %r13,0x10(%rsp)
mov    %rax,0x8(%rsp)
jne    1684 <convolutionOfMatrix+0x564>
xor    %r14d,%r14d
mov    0x10(%rsp),%r13
test   $0x1,%r13b
je     142e <convolutionOfMatrix+0x30e>
cmp    $0x2,%r12d
jl     142e <convolutionOfMatrix+0x30e>
mov    0x8(%rsp),%rax
add    %r14,%rax
lea    (%rax,%rax,4),%rsi
shl    $0x5,%rsi
add    0x28(%rsp),%rsi
lea    (%r14,%r14,4),%rax
shl    $0x5,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x50,%rdi
mov    %rbx,%rdx
call   1030 <memcpy@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    0x18(%rsp),%rbp
mov    %ebp,%edx
call   1040 <convolution2d@plt>
cmp    %r12d,%ebp
mov    0x30(%rsp),%rax
jge    165e <convolutionOfMatrix+0x53e>
mov    0x20(%rsp),%rcx
lea    0x8(,%rcx,8),%r14
cmp    $0x1,%r13d
jne    16f1 <convolutionOfMatrix+0x5d1>
xor    %ebx,%ebx
mov    0x10(%rsp),%r15
test   $0x1,%r15b
mov    0x30(%rsp),%rcx
je     14af <convolutionOfMatrix+0x38f>
cmp    $0x2,%r12d
jl     14af <convolutionOfMatrix+0x38f>
lea    (%rbx,%rbx,4),%rax
shl    $0x5,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x690,%rsi
add    0x8(%rsp),%rbx
lea    (%rbx,%rbx,4),%rdi
shl    $0x5,%rdi
add    %rcx,%rdi
mov    %r14,%rdx
call   1030 <memcpy@plt>
mov    0x18(%rsp),%rbp
cmp    %r12d,%ebp
jge    165e <convolutionOfMatrix+0x53e>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,4),%rax
lea    (%rcx,%rax,4),%rcx
not    %ebp
mov    %r12d,0x38(%rsp)
add    %r12d,%ebp
lea    0x8(,%rbp,8),%r12
mov    %r15,%rax
add    $0xffffffffffffffff,%rax
mov    %rcx,0x20(%rsp)
mov    %rbp,0x40(%rsp)
mov    %rax,0x48(%rsp)
je     1859 <convolutionOfMatrix+0x739>
and    $0xfffffffe,%r15d
mov    %r15,0x8(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%r15
mov    $0xa0,%r13d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r15,%r13,1),%rbx
lea    (%r15,%r13,1),%rsi
add    $0xffffffffffffff60,%rsi
lea    (%rsp,%r13,1),%r14
add    $0x50,%r14
lea    (%rsp,%r13,1),%rdi
add    $0xffffffffffffffb0,%rdi
mov    %r12,%rdx
call   1030 <memcpy@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1030 <memcpy@plt>
add    $0x2,%rbp
add    $0x140,%r13
cmp    %rbp,0x8(%rsp)
jne    1520 <convolutionOfMatrix+0x400>
testb  $0x1,0x10(%rsp)
je     159e <convolutionOfMatrix+0x47e>
shl    $0x5,%rbp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
mov    0x28(%rsp),%rcx
add    %rax,%rcx
mov    0x20(%rsp),%rdx
lea    (%rcx,%rdx,8),%rsi
lea    (%rsp,%rax,1),%rdi
add    $0x50,%rdi
mov    %r12,%rdx
call   1030 <memcpy@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    0x18(%rsp),%rbx
mov    %ebx,%edx
call   1040 <convolution2d@plt>
cmp    0x38(%rsp),%ebx
mov    0x30(%rsp),%r13
jge    1672 <convolutionOfMatrix+0x552>
mov    0x40(%rsp),%rax
lea    0x8(,%rax,8),%r15
cmpq   $0x0,0x48(%rsp)
je     186b <convolutionOfMatrix+0x74b>
mov    0x10(%rsp),%r14
and    $0xfffffffe,%r14d
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%r12
add    %r13,%r12
xor    %ebx,%ebx
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    (%rsp,%rbx,1),%rsi
add    $0x690,%rsi
lea    (%r12,%rbx,1),%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
lea    (%rsp,%rbx,1),%rsi
add    $0x730,%rsi
lea    (%r12,%rbx,1),%rdi
add    $0xa0,%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
add    $0x2,%rbp
add    $0x140,%rbx
cmp    %rbp,%r14
jne    1600 <convolutionOfMatrix+0x4e0>
jmp    186d <convolutionOfMatrix+0x74d>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1040 <convolution2d@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1040 <convolution2d@plt>
add    $0x1318,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffe,%r13d
lea    (%rax,%rax,4),%r15
shl    $0x5,%r15
add    0x28(%rsp),%r15
mov    $0xa0,%ebp
xor    %r14d,%r14d
jmp    16b4 <convolutionOfMatrix+0x594>
nop
add    $0x2,%r14
add    $0x140,%rbp
cmp    %r14,%r13
je     13f0 <convolutionOfMatrix+0x2d0>
cmp    $0x2,%r12d
jl     16d5 <convolutionOfMatrix+0x5b5>
lea    (%r15,%rbp,1),%rsi
add    $0xffffffffffffff60,%rsi
lea    (%rsp,%rbp,1),%rdi
add    $0xffffffffffffffb0,%rdi
mov    %rbx,%rdx
call   1030 <memcpy@plt>
cmp    $0x2,%r12d
jl     16a0 <convolutionOfMatrix+0x580>
lea    (%r15,%rbp,1),%rsi
lea    (%rsp,%rbp,1),%rdi
add    $0x50,%rdi
mov    %rbx,%rdx
call   1030 <memcpy@plt>
jmp    16a0 <convolutionOfMatrix+0x580>
and    $0xfffffffe,%r13d
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,4),%r15
shl    $0x5,%r15
add    %rax,%r15
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    1724 <convolutionOfMatrix+0x604>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbx
add    $0x140,%rbp
cmp    %rbx,%r13
je     146e <convolutionOfMatrix+0x34e>
cmp    $0x2,%r12d
jl     1741 <convolutionOfMatrix+0x621>
lea    (%rsp,%rbp,1),%rsi
add    $0x690,%rsi
lea    (%r15,%rbp,1),%rdi
mov    %r14,%rdx
call   1030 <memcpy@plt>
cmp    $0x2,%r12d
jl     1710 <convolutionOfMatrix+0x5f0>
lea    (%rsp,%rbp,1),%rsi
add    $0x730,%rsi
lea    (%r15,%rbp,1),%rdi
add    $0xa0,%rdi
mov    %r14,%rdx
call   1030 <memcpy@plt>
jmp    1710 <convolutionOfMatrix+0x5f0>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
test   $0x1,%r14b
mov    0x18(%rsp),%rbp
je     17a9 <convolutionOfMatrix+0x689>
cmp    %r12d,%ebp
jge    17a9 <convolutionOfMatrix+0x689>
shl    $0x5,%rbx
lea    (%rbx,%rbx,4),%rax
mov    0x28(%rsp),%rcx
add    %rax,%rcx
mov    0x38(%rsp),%rdx
lea    (%rcx,%rdx,8),%rsi
lea    (%rsp,%rax,1),%rdi
add    $0x50,%rdi
mov    0x8(%rsp),%rdx
call   1030 <memcpy@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1040 <convolution2d@plt>
cmp    $0x2,%r12d
jl     13b7 <convolutionOfMatrix+0x297>
mov    0x40(%rsp),%rax
lea    0x8(,%rax,8),%r13
cmpq   $0x0,0x20(%rsp)
je     18b2 <convolutionOfMatrix+0x792>
and    $0xfffffffe,%r14d
mov    0x30(%rsp),%rax
mov    0x38(%rsp),%rcx
lea    (%rax,%rcx,8),%r15
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    1814 <convolutionOfMatrix+0x6f4>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbx
add    $0x140,%rbp
cmp    %rbx,%r14
je     18b4 <convolutionOfMatrix+0x794>
cmp    %r12d,0x18(%rsp)
jge    1832 <convolutionOfMatrix+0x712>
lea    (%rsp,%rbp,1),%rsi
add    $0x690,%rsi
lea    (%r15,%rbp,1),%rdi
mov    %r13,%rdx
call   1030 <memcpy@plt>
cmp    %r12d,0x18(%rsp)
jge    1800 <convolutionOfMatrix+0x6e0>
lea    (%rsp,%rbp,1),%rsi
add    $0x730,%rsi
lea    (%r15,%rbp,1),%rdi
add    $0xa0,%rdi
mov    %r13,%rdx
call   1030 <memcpy@plt>
jmp    1800 <convolutionOfMatrix+0x6e0>
xor    %ebp,%ebp
testb  $0x1,0x10(%rsp)
jne    156e <convolutionOfMatrix+0x44e>
jmp    159e <convolutionOfMatrix+0x47e>
xor    %ebp,%ebp
testb  $0x1,0x10(%rsp)
je     1672 <convolutionOfMatrix+0x552>
shl    $0x5,%rbp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x690,%rsi
add    %rax,%r13
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
jmp    1672 <convolutionOfMatrix+0x552>
xor    %ebx,%ebx
testb  $0x1,0x10(%rsp)
mov    0x18(%rsp),%rbp
je     13b7 <convolutionOfMatrix+0x297>
cmp    %r12d,%ebp
jge    13b7 <convolutionOfMatrix+0x297>
shl    $0x5,%rbx
lea    (%rbx,%rbx,4),%rax
lea    (%rsp,%rax,1),%rsi
add    $0x690,%rsi
add    0x30(%rsp),%rax
mov    0x38(%rsp),%rcx
lea    (%rax,%rcx,8),%rdi
mov    %r13,%rdx
call   1030 <memcpy@plt>
jmp    13b7 <convolutionOfMatrix+0x297>

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

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