#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*/ Expand_2D(float *, long, long, float *, double *, long,
                             short);
int GetPyramidFilter(char *, int, double *, long *, double *, long *, short *);
int /*<<< orphan*/ Reduce_2D(float *, long, long, float *, double *, long,
                             short);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  float InputSignal[4L * 4L];
  float ReducedSignal[4L / 2L * 4L / 2L];
  float ExpandedSignal[4L * 4L];
  double g[200L];
  long ng;
  double h[200L];
  long nh;
  long i, j;
  short IsCentered;
  printf("Filter: "
         "Spline"
         "\n");
  if (GetPyramidFilter("Spline", 3, g, &ng, h, &nh, &IsCentered) ==
      (!((int)(0 != 0)))) {
    printf("Unable to load the filter coeffiients");
    return 1;
  }
  printf("Size of the reduce filter: %ld\n", ng);
  printf("Size of the expand filter: %ld\n", nh);
  InputSignal[0] = 0.0;
  InputSignal[1] = 1.0;
  InputSignal[2] = 2.0;
  InputSignal[3] = 3.0;
  InputSignal[4] = 1.0;
  InputSignal[5] = 2.0;
  InputSignal[6] = 3.0;
  InputSignal[7] = 4.0;
  InputSignal[8] = 2.0;
  InputSignal[9] = 3.0;
  InputSignal[10] = 4.0;
  InputSignal[11] = 5.0;
  InputSignal[12] = 3.0;
  InputSignal[13] = 4.0;
  InputSignal[14] = 3.0;
  InputSignal[15] = 2.0;
  printf("Input : \n");
  for (j = 0L; j < 4L; j++) {
    for (i = 0L; i < 4L; i++)
      printf("%2.3f ", InputSignal[i + j * 4L]);
    printf("\n");
  }
  Reduce_2D(InputSignal, 4L, 4L, ReducedSignal, g, ng, IsCentered);
  printf("Reduced: \n");
  for (j = 0L; j < 4L / 2L; j++) {
    for (i = 0L; i < 4L / 2L; i++)
      printf("%2.3f ", ReducedSignal[i + j * 4L / 2L]);
    printf("\n");
  }
  Expand_2D(ReducedSignal, 4L / 2L, 4L / 2L, ExpandedSignal, h, nh, IsCentered);
  printf("Expanded : \n");
  for (j = 0L; j < 4L; j++) {
    for (i = 0L; i < 4L; i++)
      printf("%2.3f ", ExpandedSignal[i + j * 4L]);
    printf("\n");
  }
  Expand_2D(ReducedSignal, 4L / 2L, 4L / 2L, ExpandedSignal, h, nh, IsCentered);
  printf("Error : \n");
  for (j = 0L; j < 4L; j++) {
    for (i = 0L; i < 4L; i++)
      printf("%2.3f ", ExpandedSignal[i + j * 4L] - InputSignal[i + j * 4L]);
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd60,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xebb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x6e0(%rbp),%rdx
lea    -0xd30(%rbp),%r8
lea    0xeaf(%rip),%rdi
mov    $0x3,%esi
lea    -0x6e8(%rbp),%rcx
lea    -0xd38(%rbp),%r9
lea    -0xd4a(%rbp),%rax
mov    %rax,(%rsp)
call   1060 <GetPyramidFilter@plt>
cmp    $0x1,%eax
jne    11bb <main+0x7b>
lea    0xe83(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1624 <main+0x4e4>
mov    -0x6e8(%rbp),%rsi
lea    0xe88(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xd38(%rbp),%rsi
lea    0xe93(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0xe1b(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0xdfe(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xdf5(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xdf4(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xdd7(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xdce(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xdc5(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xdb0(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  0xda7(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  0xd9e(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  0xd95(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xd80(%rip),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  0xd77(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  0xd66(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xd55(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
lea    0xdda(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0xd48(%rbp)
cmpq   $0x4,-0xd48(%rbp)
04
jge    1359 <main+0x219>
movq   $0x0,-0xd40(%rbp)
cmpq   $0x4,-0xd40(%rbp)
04
jge    1334 <main+0x1f4>
mov    -0xd40(%rbp),%rax
mov    -0xd48(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movss  -0x50(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd85(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xd40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd40(%rbp)
jmp    12e2 <main+0x1a2>
lea    0xd7d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xd48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd48(%rbp)
jmp    12c9 <main+0x189>
lea    -0x50(%rbp),%rdi
lea    -0x60(%rbp),%rcx
lea    -0x6e0(%rbp),%r8
mov    -0x6e8(%rbp),%r9
mov    $0x4,%edx
mov    %rdx,%rsi
movswl -0xd4a(%rbp),%eax
mov    %eax,(%rsp)
call   1050 <Reduce_2D@plt>
lea    0xd15(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0xd48(%rbp)
cmpq   $0x2,-0xd48(%rbp)
02
jge    144a <main+0x30a>
movq   $0x0,-0xd40(%rbp)
cmpq   $0x2,-0xd40(%rbp)
02
jge    1425 <main+0x2e5>
mov    -0xd40(%rbp),%rax
mov    %rax,-0xd58(%rbp)
mov    -0xd48(%rbp),%rax
shl    $0x2,%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0xd58(%rbp),%rax
add    %rcx,%rax
movss  -0x60(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc94(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xd40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd40(%rbp)
jmp    13b8 <main+0x278>
lea    0xc8c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xd48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd48(%rbp)
jmp    139f <main+0x25f>
lea    -0x60(%rbp),%rdi
lea    -0xa0(%rbp),%rcx
lea    -0xd30(%rbp),%r8
mov    -0xd38(%rbp),%r9
mov    $0x2,%edx
mov    %rdx,%rsi
movswl -0xd4a(%rbp),%eax
mov    %eax,(%rsp)
call   1030 <Expand_2D@plt>
lea    0xc2c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0xd48(%rbp)
cmpq   $0x4,-0xd48(%rbp)
04
jge    1526 <main+0x3e6>
movq   $0x0,-0xd40(%rbp)
cmpq   $0x4,-0xd40(%rbp)
04
jge    1501 <main+0x3c1>
mov    -0xd40(%rbp),%rax
mov    -0xd48(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0xbb8(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xd40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd40(%rbp)
jmp    14ac <main+0x36c>
lea    0xbb0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xd48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd48(%rbp)
jmp    1493 <main+0x353>
lea    -0x60(%rbp),%rdi
lea    -0xa0(%rbp),%rcx
lea    -0xd30(%rbp),%r8
mov    -0xd38(%rbp),%r9
mov    $0x2,%edx
mov    %rdx,%rsi
movswl -0xd4a(%rbp),%eax
mov    %eax,(%rsp)
call   1030 <Expand_2D@plt>
lea    0xb5d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0xd48(%rbp)
cmpq   $0x4,-0xd48(%rbp)
04
jge    161d <main+0x4dd>
movq   $0x0,-0xd40(%rbp)
cmpq   $0x4,-0xd40(%rbp)
04
jge    15f8 <main+0x4b8>
mov    -0xd40(%rbp),%rax
mov    -0xd48(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
mov    -0xd40(%rbp),%rax
mov    -0xd48(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
subss  -0x50(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xac1(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xd40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd40(%rbp)
jmp    1588 <main+0x448>
lea    0xab9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xd48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd48(%rbp)
jmp    156f <main+0x42f>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xd60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0xd30,%rsp
lea    0xf37(%rip),%rdi
call   1040 <puts@plt>
lea    0xe(%rsp),%rax
mov    %rax,(%rsp)
lea    0xf2a(%rip),%rdi
lea    0x6f0(%rsp),%rdx
lea    0x98(%rsp),%rcx
lea    0xb0(%rsp),%r8
lea    0x90(%rsp),%r9
mov    $0x3,%esi
call   1080 <GetPyramidFilter@plt>
cmp    $0x1,%eax
jne    11d3 <main+0x73>
lea    0xe7f(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x1,%r14d
jmp    181d <main+0x6bd>
mov    0x98(%rsp),%rsi
lea    0xe84(%rip),%rdi
xor    %r14d,%r14d
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x90(%rsp),%rsi
lea    0xe8b(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movaps 0xdf7(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xdfb(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xdff(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xe03(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
lea    0xe83(%rip),%rdi
call   1040 <puts@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe57(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x2c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x30(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x34(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x38(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x3c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x40(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x44(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x48(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x4c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x98(%rsp),%r9
movswl 0xe(%rsp),%eax
mov    %eax,(%rsp)
lea    0x10(%rsp),%rdi
lea    0xa0(%rsp),%rbp
lea    0x6f0(%rsp),%r8
mov    $0x4,%esi
mov    $0x4,%edx
mov    %rbp,%rcx
call   1070 <Reduce_2D@plt>
lea    0xcda(%rip),%rdi
call   1040 <puts@plt>
movss  0xa0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0xa4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0xa8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0xac(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x90(%rsp),%r9
movswl 0xe(%rsp),%eax
mov    %eax,(%rsp)
lea    0x50(%rsp),%r15
lea    0xb0(%rsp),%r12
mov    $0x2,%esi
mov    $0x2,%edx
mov    %rbp,%rdi
mov    %r15,%rcx
mov    %r12,%r8
call   1050 <Expand_2D@plt>
lea    0xc33(%rip),%rdi
call   1040 <puts@plt>
movss  0x50(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x54(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x58(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x5c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x60(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x64(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x68(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x6c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x70(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x74(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x78(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x7c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x80(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x84(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x88(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x8c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x90(%rsp),%r9
movswl 0xe(%rsp),%eax
mov    %eax,(%rsp)
mov    $0x2,%esi
mov    $0x2,%edx
mov    %rbp,%rdi
mov    %r15,%rcx
mov    %r12,%r8
call   1050 <Expand_2D@plt>
lea    0xa97(%rip),%rdi
call   1040 <puts@plt>
movss  0x50(%rsp),%xmm0
subss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x54(%rsp),%xmm0
subss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x58(%rsp),%xmm0
subss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x5c(%rsp),%xmm0
subss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x60(%rsp),%xmm0
subss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x64(%rsp),%xmm0
subss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x68(%rsp),%xmm0
subss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x6c(%rsp),%xmm0
subss  0x2c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x70(%rsp),%xmm0
subss  0x30(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x74(%rsp),%xmm0
subss  0x34(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x78(%rsp),%xmm0
subss  0x38(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x7c(%rsp),%xmm0
subss  0x3c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x80(%rsp),%xmm0
subss  0x40(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x84(%rsp),%xmm0
subss  0x44(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x88(%rsp),%xmm0
subss  0x48(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x8c(%rsp),%xmm0
subss  0x4c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r14d,%eax
add    $0xd30,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [16 x i8] c"Filter: Spline\0A\00"
@.str.1 = [7 x i8] c"Spline\00"
@.str.2 = [38 x i8] c"Unable to load the filter coeffiients\00"
@.str.3 = [32 x i8] c"Size of the reduce filter: %ld\0A\00"
@.str.4 = [32 x i8] c"Size of the expand filter: %ld\0A\00"
@.str.5 = [10 x i8] c"Input : \0A\00"
@.str.6 = [7 x i8] c"%2.3f \00"
@.str.7 = [2 x i8] c"\0A\00"
@.str.8 = [11 x i8] c"Reduced: \0A\00"
@.str.9 = [13 x i8] c"Expanded : \0A\00"
@.str.10 = [10 x i8] c"Error : \0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [16 x float]
%3 = alloca [4 x float]
%4 = alloca [16 x float]
%5 = alloca [200 x double]
%6 = alloca i64
%7 = alloca [200 x double]
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i16
store i32 0, i32* %1
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0))
%13 = getelementptr inbounds [200 x double], [200 x double]* %5, i64 0, i64 0
%14 = getelementptr inbounds [200 x double], [200 x double]* %7, i64 0, i64 0
%15 = call i32 @GetPyramidFilter(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 3, double* %13, i64* %6, double* %14, i64* %8, i16* %11)
%16 = icmp eq i32 %15, 1
br i1 %16, label %17, label %19
17: ; preds = %0
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0))
store i32 1, i32* %1
br label %170
19: ; preds = %0
%20 = load i64, i64* %6
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0), i64 %20)
%22 = load i64, i64* %8
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), i64 %22)
%24 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 0
store float 0.000000e+00, float* %24
%25 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 1
store float 1.000000e+00, float* %25
%26 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 2
store float 2.000000e+00, float* %26
%27 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 3
store float 3.000000e+00, float* %27
%28 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 4
store float 1.000000e+00, float* %28
%29 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 5
store float 2.000000e+00, float* %29
%30 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 6
store float 3.000000e+00, float* %30
%31 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 7
store float 4.000000e+00, float* %31
%32 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 8
store float 2.000000e+00, float* %32
%33 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 9
store float 3.000000e+00, float* %33
%34 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 10
store float 4.000000e+00, float* %34
%35 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 11
store float 5.000000e+00, float* %35
%36 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 12
store float 3.000000e+00, float* %36
%37 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 13
store float 4.000000e+00, float* %37
%38 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 14
store float 3.000000e+00, float* %38
%39 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 15
store float 2.000000e+00, float* %39
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i64 0, i64 0))
store i64 0, i64* %10
br label %41
41: ; preds = %62, %19
%42 = load i64, i64* %10
%43 = icmp slt i64 %42, 4
br i1 %43, label %44, label %65
44: ; preds = %41
store i64 0, i64* %9
br label %45
45: ; preds = %57, %44
%46 = load i64, i64* %9
%47 = icmp slt i64 %46, 4
br i1 %47, label %48, label %60
48: ; preds = %45
%49 = load i64, i64* %9
%50 = load i64, i64* %10
%51 = mul nsw i64 %50, 4
%52 = add nsw i64 %49, %51
%53 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 %52
%54 = load float, float* %53
%55 = fpext float %54 to double
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %55)
br label %57
57: ; preds = %48
%58 = load i64, i64* %9
%59 = add nsw i64 %58, 1
store i64 %59, i64* %9
br label %45
60: ; preds = %45
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %62
62: ; preds = %60
%63 = load i64, i64* %10
%64 = add nsw i64 %63, 1
store i64 %64, i64* %10
br label %41
65: ; preds = %41
%66 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 0
%67 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 0
%68 = getelementptr inbounds [200 x double], [200 x double]* %5, i64 0, i64 0
%69 = load i64, i64* %6
%70 = load i16, i16* %11
%71 = call i32 @Reduce_2D(float* %66, i64 4, i64 4, float* %67, double* %68, i64 %69, i16 signext %70)
%72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0))
store i64 0, i64* %10
br label %73
73: ; preds = %95, %65
%74 = load i64, i64* %10
%75 = icmp slt i64 %74, 2
br i1 %75, label %76, label %98
76: ; preds = %73
store i64 0, i64* %9
br label %77
77: ; preds = %90, %76
%78 = load i64, i64* %9
%79 = icmp slt i64 %78, 2
br i1 %79, label %80, label %93
80: ; preds = %77
%81 = load i64, i64* %9
%82 = load i64, i64* %10
%83 = mul nsw i64 %82, 4
%84 = sdiv i64 %83, 2
%85 = add nsw i64 %81, %84
%86 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 %85
%87 = load float, float* %86
%88 = fpext float %87 to double
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %88)
br label %90
90: ; preds = %80
%91 = load i64, i64* %9
%92 = add nsw i64 %91, 1
store i64 %92, i64* %9
br label %77
93: ; preds = %77
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %95
95: ; preds = %93
%96 = load i64, i64* %10
%97 = add nsw i64 %96, 1
store i64 %97, i64* %10
br label %73
98: ; preds = %73
%99 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 0
%100 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 0
%101 = getelementptr inbounds [200 x double], [200 x double]* %7, i64 0, i64 0
%102 = load i64, i64* %8
%103 = load i16, i16* %11
%104 = call i32 @Expand_2D(float* %99, i64 2, i64 2, float* %100, double* %101, i64 %102, i16 signext %103)
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.9, i64 0, i64 0))
store i64 0, i64* %10
br label %106
106: ; preds = %127, %98
%107 = load i64, i64* %10
%108 = icmp slt i64 %107, 4
br i1 %108, label %109, label %130
109: ; preds = %106
store i64 0, i64* %9
br label %110
110: ; preds = %122, %109
%111 = load i64, i64* %9
%112 = icmp slt i64 %111, 4
br i1 %112, label %113, label %125
113: ; preds = %110
%114 = load i64, i64* %9
%115 = load i64, i64* %10
%116 = mul nsw i64 %115, 4
%117 = add nsw i64 %114, %116
%118 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 %117
%119 = load float, float* %118
%120 = fpext float %119 to double
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %120)
br label %122
122: ; preds = %113
%123 = load i64, i64* %9
%124 = add nsw i64 %123, 1
store i64 %124, i64* %9
br label %110
125: ; preds = %110
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %127
127: ; preds = %125
%128 = load i64, i64* %10
%129 = add nsw i64 %128, 1
store i64 %129, i64* %10
br label %106
130: ; preds = %106
%131 = getelementptr inbounds [4 x float], [4 x float]* %3, i64 0, i64 0
%132 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 0
%133 = getelementptr inbounds [200 x double], [200 x double]* %7, i64 0, i64 0
%134 = load i64, i64* %8
%135 = load i16, i16* %11
%136 = call i32 @Expand_2D(float* %131, i64 2, i64 2, float* %132, double* %133, i64 %134, i16 signext %135)
%137 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
store i64 0, i64* %10
br label %138
138: ; preds = %166, %130
%139 = load i64, i64* %10
%140 = icmp slt i64 %139, 4
br i1 %140, label %141, label %169
141: ; preds = %138
store i64 0, i64* %9
br label %142
142: ; preds = %161, %141
%143 = load i64, i64* %9
%144 = icmp slt i64 %143, 4
br i1 %144, label %145, label %164
145: ; preds = %142
%146 = load i64, i64* %9
%147 = load i64, i64* %10
%148 = mul nsw i64 %147, 4
%149 = add nsw i64 %146, %148
%150 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 %149
%151 = load float, float* %150
%152 = load i64, i64* %9
%153 = load i64, i64* %10
%154 = mul nsw i64 %153, 4
%155 = add nsw i64 %152, %154
%156 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 %155
%157 = load float, float* %156
%158 = fsub float %151, %157
%159 = fpext float %158 to double
%160 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %159)
br label %161
161: ; preds = %145
%162 = load i64, i64* %9
%163 = add nsw i64 %162, 1
store i64 %163, i64* %9
br label %142
164: ; preds = %142
%165 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %166
166: ; preds = %164
%167 = load i64, i64* %10
%168 = add nsw i64 %167, 1
store i64 %168, i64* %10
br label %138
169: ; preds = %138
store i32 0, i32* %1
br label %170
170: ; preds = %169, %17
%171 = load i32, i32* %1
ret i32 %171
}

LLVM IR (-O2):
@.str.1 = [7 x i8] c"Spline\00"
@.str.2 = [38 x i8] c"Unable to load the filter coeffiients\00"
@.str.3 = [32 x i8] c"Size of the reduce filter: %ld\0A\00"
@.str.4 = [32 x i8] c"Size of the expand filter: %ld\0A\00"
@.str.6 = [7 x i8] c"%2.3f \00"
@str = [15 x i8] c"Filter: Spline\00"
@str.11 = [9 x i8] c"Input : \00"
@str.12 = [10 x i8] c"Reduced: \00"
@str.13 = [12 x i8] c"Expanded : \00"
@str.14 = [9 x i8] c"Error : \00"
define i32 @main() {
%1 = alloca [16 x float]
%2 = alloca [4 x float]
%3 = alloca [16 x float]
%4 = alloca [200 x double]
%5 = alloca i64
%6 = alloca [200 x double]
%7 = alloca i64
%8 = alloca i16
%9 = bitcast [16 x float]* %1 to i8*
%10 = bitcast [4 x float]* %2 to i8*
%11 = bitcast [16 x float]* %3 to i8*
%12 = bitcast [200 x double]* %4 to i8*
%13 = bitcast i64* %5 to i8*
%14 = bitcast [200 x double]* %6 to i8*
%15 = bitcast i64* %7 to i8*
%16 = bitcast i16* %8 to i8*
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str, i64 0, i64 0))
%18 = getelementptr inbounds [200 x double], [200 x double]* %4, i64 0, i64 0
%19 = getelementptr inbounds [200 x double], [200 x double]* %6, i64 0, i64 0
%20 = call i32 @GetPyramidFilter(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 3, double* %18, i64* %5, double* %19, i64* %7, i16* %8)
%21 = icmp eq i32 %20, 1
br i1 %21, label %22, label %24
22: ; preds = %0
%23 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0))
br label %284
24: ; preds = %0
%25 = load i64, i64* %5
%26 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0), i64 %25)
%27 = load i64, i64* %7
%28 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), i64 %27)
%29 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 0
%30 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 1
%31 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 2
%32 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 3
%33 = bitcast [16 x float]* %1 to <4 x float>*
store <4 x float> <float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>, <4 x float>* %33
%34 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 4
%35 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 5
%36 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 6
%37 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 7
%38 = bitcast float* %34 to <4 x float>*
store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, <4 x float>* %38
%39 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 8
%40 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 9
%41 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 10
%42 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 11
%43 = bitcast float* %39 to <4 x float>*
store <4 x float> <float 2.000000e+00, float 3.000000e+00, float 4.000000e+00, float 5.000000e+00>, <4 x float>* %43
%44 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 12
%45 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 13
%46 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 14
%47 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 15
%48 = bitcast float* %44 to <4 x float>*
store <4 x float> <float 3.000000e+00, float 4.000000e+00, float 3.000000e+00, float 2.000000e+00>, <4 x float>* %48
%49 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.11, i64 0, i64 0))
%50 = load float, float* %29
%51 = fpext float %50 to double
%52 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %51)
%53 = load float, float* %30
%54 = fpext float %53 to double
%55 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %54)
%56 = load float, float* %31
%57 = fpext float %56 to double
%58 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %57)
%59 = load float, float* %32
%60 = fpext float %59 to double
%61 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %60)
%62 = call i32 @putchar(i32 10)
%63 = load float, float* %34
%64 = fpext float %63 to double
%65 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %64)
%66 = load float, float* %35
%67 = fpext float %66 to double
%68 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %67)
%69 = load float, float* %36
%70 = fpext float %69 to double
%71 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %70)
%72 = load float, float* %37
%73 = fpext float %72 to double
%74 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %73)
%75 = call i32 @putchar(i32 10)
%76 = load float, float* %39
%77 = fpext float %76 to double
%78 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %77)
%79 = load float, float* %40
%80 = fpext float %79 to double
%81 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %80)
%82 = load float, float* %41
%83 = fpext float %82 to double
%84 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %83)
%85 = load float, float* %42
%86 = fpext float %85 to double
%87 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %86)
%88 = call i32 @putchar(i32 10)
%89 = load float, float* %44
%90 = fpext float %89 to double
%91 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %90)
%92 = load float, float* %45
%93 = fpext float %92 to double
%94 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %93)
%95 = load float, float* %46
%96 = fpext float %95 to double
%97 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %96)
%98 = load float, float* %47
%99 = fpext float %98 to double
%100 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %99)
%101 = call i32 @putchar(i32 10)
%102 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 0
%103 = load i64, i64* %5
%104 = load i16, i16* %8
%105 = call i32 @Reduce_2D(float* %29, i64 4, i64 4, float* %102, double* %18, i64 %103, i16 signext %104)
%106 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.12, i64 0, i64 0))
%107 = load float, float* %102
%108 = fpext float %107 to double
%109 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %108)
%110 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 1
%111 = load float, float* %110
%112 = fpext float %111 to double
%113 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %112)
%114 = call i32 @putchar(i32 10)
%115 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 2
%116 = load float, float* %115
%117 = fpext float %116 to double
%118 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %117)
%119 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 3
%120 = load float, float* %119
%121 = fpext float %120 to double
%122 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %121)
%123 = call i32 @putchar(i32 10)
%124 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 0
%125 = load i64, i64* %7
%126 = load i16, i16* %8
%127 = call i32 @Expand_2D(float* %102, i64 2, i64 2, float* %124, double* %19, i64 %125, i16 signext %126)
%128 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.13, i64 0, i64 0))
%129 = load float, float* %124
%130 = fpext float %129 to double
%131 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %130)
%132 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 1
%133 = load float, float* %132
%134 = fpext float %133 to double
%135 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %134)
%136 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 2
%137 = load float, float* %136
%138 = fpext float %137 to double
%139 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %138)
%140 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 3
%141 = load float, float* %140
%142 = fpext float %141 to double
%143 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %142)
%144 = call i32 @putchar(i32 10)
%145 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 4
%146 = load float, float* %145
%147 = fpext float %146 to double
%148 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %147)
%149 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 5
%150 = load float, float* %149
%151 = fpext float %150 to double
%152 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %151)
%153 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 6
%154 = load float, float* %153
%155 = fpext float %154 to double
%156 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %155)
%157 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 7
%158 = load float, float* %157
%159 = fpext float %158 to double
%160 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %159)
%161 = call i32 @putchar(i32 10)
%162 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 8
%163 = load float, float* %162
%164 = fpext float %163 to double
%165 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %164)
%166 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 9
%167 = load float, float* %166
%168 = fpext float %167 to double
%169 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %168)
%170 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 10
%171 = load float, float* %170
%172 = fpext float %171 to double
%173 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %172)
%174 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 11
%175 = load float, float* %174
%176 = fpext float %175 to double
%177 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %176)
%178 = call i32 @putchar(i32 10)
%179 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 12
%180 = load float, float* %179
%181 = fpext float %180 to double
%182 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %181)
%183 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 13
%184 = load float, float* %183
%185 = fpext float %184 to double
%186 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %185)
%187 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 14
%188 = load float, float* %187
%189 = fpext float %188 to double
%190 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %189)
%191 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 15
%192 = load float, float* %191
%193 = fpext float %192 to double
%194 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %193)
%195 = call i32 @putchar(i32 10)
%196 = load i64, i64* %7
%197 = load i16, i16* %8
%198 = call i32 @Expand_2D(float* %102, i64 2, i64 2, float* %124, double* %19, i64 %196, i16 signext %197)
%199 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.14, i64 0, i64 0))
%200 = load float, float* %124
%201 = load float, float* %29
%202 = fsub float %200, %201
%203 = fpext float %202 to double
%204 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %203)
%205 = load float, float* %132
%206 = load float, float* %30
%207 = fsub float %205, %206
%208 = fpext float %207 to double
%209 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %208)
%210 = load float, float* %136
%211 = load float, float* %31
%212 = fsub float %210, %211
%213 = fpext float %212 to double
%214 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %213)
%215 = load float, float* %140
%216 = load float, float* %32
%217 = fsub float %215, %216
%218 = fpext float %217 to double
%219 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %218)
%220 = call i32 @putchar(i32 10)
%221 = load float, float* %145
%222 = load float, float* %34
%223 = fsub float %221, %222
%224 = fpext float %223 to double
%225 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %224)
%226 = load float, float* %149
%227 = load float, float* %35
%228 = fsub float %226, %227
%229 = fpext float %228 to double
%230 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %229)
%231 = load float, float* %153
%232 = load float, float* %36
%233 = fsub float %231, %232
%234 = fpext float %233 to double
%235 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %234)
%236 = load float, float* %157
%237 = load float, float* %37
%238 = fsub float %236, %237
%239 = fpext float %238 to double
%240 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %239)
%241 = call i32 @putchar(i32 10)
%242 = load float, float* %162
%243 = load float, float* %39
%244 = fsub float %242, %243
%245 = fpext float %244 to double
%246 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %245)
%247 = load float, float* %166
%248 = load float, float* %40
%249 = fsub float %247, %248
%250 = fpext float %249 to double
%251 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %250)
%252 = load float, float* %170
%253 = load float, float* %41
%254 = fsub float %252, %253
%255 = fpext float %254 to double
%256 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %255)
%257 = load float, float* %174
%258 = load float, float* %42
%259 = fsub float %257, %258
%260 = fpext float %259 to double
%261 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %260)
%262 = call i32 @putchar(i32 10)
%263 = load float, float* %179
%264 = load float, float* %44
%265 = fsub float %263, %264
%266 = fpext float %265 to double
%267 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %266)
%268 = load float, float* %183
%269 = load float, float* %45
%270 = fsub float %268, %269
%271 = fpext float %270 to double
%272 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %271)
%273 = load float, float* %187
%274 = load float, float* %46
%275 = fsub float %273, %274
%276 = fpext float %275 to double
%277 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %276)
%278 = load float, float* %191
%279 = load float, float* %47
%280 = fsub float %278, %279
%281 = fpext float %280 to double
%282 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %281)
%283 = call i32 @putchar(i32 10)
br label %284
284: ; preds = %24, %22
%285 = phi i32 [ 1, %22 ], [ 0, %24 ]
ret i32 %285
}