#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*/ h264(float **, float **, float **, float **, float **);
int /*<<< orphan*/ h264_sc(float **, float **, float **, float **, float **);
int /*<<< orphan*/ printf(char *, int, int, float, float);
int main() {
  float __attribute__((aligned(64))) X[26][28];
  float __attribute__((aligned(64))) H[16][28];
  float __attribute__((aligned(64))) K[16][16];
  float __attribute__((aligned(64))) Y[16][16];
  float __attribute__((aligned(64))) output[16][16];
  float __attribute__((aligned(64))) X_sc[26][28];
  float __attribute__((aligned(64))) H_sc[16][28];
  float __attribute__((aligned(64))) K_sc[16][16];
  float __attribute__((aligned(64))) Y_sc[16][16];
  float __attribute__((aligned(64))) output_sc[16][16];
  int i, j, k;
  for (i = 0; i < 26; i++) {
    for (j = 0; j < 28; j++) {
      X[i][j] = 0.0f;
      X_sc[i][j] = 0.0f;
    }
  }
  for (i = 0; i < 16; i++) {
    for (j = 0; j < 28; j++) {
      H[i][j] = 0.0f;
      H_sc[i][j] = 0.0f;
    }
  }
  for (i = 0; i < 16; i++) {
    for (j = 0; j < 16; j++) {
      output[i][j] = 0.0f;
      output_sc[i][j] = 0.0f;
      K[i][j] = 0.0f;
      K_sc[i][j] = 0.0f;
      Y[i][j] = 0.0f;
      Y_sc[i][j] = 0.0f;
    }
  }
  h264(X, H, K, Y, output);
  h264_sc(X_sc, H_sc, K_sc, Y_sc, output_sc);
  for (i = 0; i < 26; i++) {
    for (j = 0; j < 28; j++) {
      if (X[i][j] != X_sc[i][j]) {
        printf("ERROR X[%d][%d] %f != %f\n", i, j, X[i][j], X_sc[i][j]);
        return 1;
      }
    }
  }
  for (i = 0; i < 16; i++) {
    for (j = 0; j < 28; j++) {
      if (H[i][j] - H_sc[i][j]) {
        printf("ERROR H[%d][%d] %f != %f\n", i, j, H[i][j], H_sc[i][j]);
        return 1;
      }
    }
  }
  for (i = 0; i < 16; i++) {
    for (j = 0; j < 16; j++) {
      if (K[i][j] != K_sc[i][j]) {
        printf("ERROR K[%d][%d] %f != %f\n", i, j, K[i][j], K_sc[i][j]);
        return 1;
      }
      if (Y[i][j] != Y_sc[i][j]) {
        printf("ERROR Y[%d][%d] %f != %f\n", i, j, Y[i][j], Y_sc[i][j]);
        return 1;
      }
      if (output[i][j] != output_sc[i][j]) {
        printf("ERROR output[%d][%d] %f != %f\n", i, j, output[i][j],
               output_sc[i][j]);
        return 1;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
and    $0xffffffffffffffc0,%rsp
sub    $0x3d40,%rsp
movl   $0x0,0x3d2c(%rsp)
movl   $0x0,0x3c(%rsp)
cmpl   $0x1a,0x3c(%rsp)
jge    11d7 <main+0xa7>
movl   $0x0,0x38(%rsp)
cmpl   $0x1c,0x38(%rsp)
jge    11c2 <main+0x92>
movslq 0x3c(%rsp),%rcx
lea    0x31c0(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq 0x3c(%rsp),%rcx
lea    0x1340(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x38(%rsp)
jmp    1165 <main+0x35>
jmp    11c7 <main+0x97>
mov    0x3c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x3c(%rsp)
jmp    1152 <main+0x22>
movl   $0x0,0x3c(%rsp)
cmpl   $0x10,0x3c(%rsp)
jge    1264 <main+0x134>
movl   $0x0,0x38(%rsp)
cmpl   $0x1c,0x38(%rsp)
jge    124f <main+0x11f>
movslq 0x3c(%rsp),%rcx
lea    0x2ac0(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq 0x3c(%rsp),%rcx
lea    0xc40(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x38(%rsp)
jmp    11f2 <main+0xc2>
jmp    1254 <main+0x124>
mov    0x3c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x3c(%rsp)
jmp    11df <main+0xaf>
movl   $0x0,0x3c(%rsp)
cmpl   $0x10,0x3c(%rsp)
jge    1372 <main+0x242>
movl   $0x0,0x38(%rsp)
cmpl   $0x10,0x38(%rsp)
jge    135d <main+0x22d>
movslq 0x3c(%rsp),%rcx
lea    0x1ec0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq 0x3c(%rsp),%rcx
lea    0x40(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq 0x3c(%rsp),%rcx
lea    0x26c0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq 0x3c(%rsp),%rcx
lea    0x840(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq 0x3c(%rsp),%rcx
lea    0x22c0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq 0x3c(%rsp),%rcx
lea    0x440(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x38(%rsp)
jmp    127f <main+0x14f>
jmp    1362 <main+0x232>
mov    0x3c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x3c(%rsp)
jmp    126c <main+0x13c>
lea    0x31c0(%rsp),%rdi
lea    0x2ac0(%rsp),%rsi
lea    0x26c0(%rsp),%rdx
lea    0x22c0(%rsp),%rcx
lea    0x1ec0(%rsp),%r8
call   1050 <h264@plt>
lea    0x1340(%rsp),%rdi
lea    0xc40(%rsp),%rsi
lea    0x840(%rsp),%rdx
lea    0x440(%rsp),%rcx
lea    0x40(%rsp),%r8
call   1030 <h264_sc@plt>
movl   $0x0,0x3c(%rsp)
cmpl   $0x1a,0x3c(%rsp)
jge    14c5 <main+0x395>
movl   $0x0,0x38(%rsp)
cmpl   $0x1c,0x38(%rsp)
jge    14b0 <main+0x380>
movslq 0x3c(%rsp),%rcx
lea    0x31c0(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0x1340(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    143b <main+0x30b>
jp     143b <main+0x30b>
jmp    149b <main+0x36b>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
movslq 0x3c(%rsp),%rcx
lea    0x31c0(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0x1340(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm1
lea    0xb7a(%rip),%rdi
call   1040 <printf@plt>
movl   $0x1,0x3d2c(%rsp)
jmp    1821 <main+0x6f1>
jmp    14a0 <main+0x370>
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x38(%rsp)
jmp    13e4 <main+0x2b4>
jmp    14b5 <main+0x385>
mov    0x3c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x3c(%rsp)
jmp    13d1 <main+0x2a1>
movl   $0x0,0x3c(%rsp)
cmpl   $0x10,0x3c(%rsp)
jge    15c8 <main+0x498>
movl   $0x0,0x38(%rsp)
cmpl   $0x1c,0x38(%rsp)
jge    15b3 <main+0x483>
movslq 0x3c(%rsp),%rcx
lea    0x2ac0(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0xc40(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
subss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    153e <main+0x40e>
jp     153e <main+0x40e>
jmp    159e <main+0x46e>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
movslq 0x3c(%rsp),%rcx
lea    0x2ac0(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0xc40(%rsp),%rax
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm1
lea    0xa91(%rip),%rdi
call   1040 <printf@plt>
movl   $0x1,0x3d2c(%rsp)
jmp    1821 <main+0x6f1>
jmp    15a3 <main+0x473>
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x38(%rsp)
jmp    14e0 <main+0x3b0>
jmp    15b8 <main+0x488>
mov    0x3c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x3c(%rsp)
jmp    14cd <main+0x39d>
movl   $0x0,0x3c(%rsp)
cmpl   $0x10,0x3c(%rsp)
jge    1816 <main+0x6e6>
movl   $0x0,0x38(%rsp)
cmpl   $0x10,0x38(%rsp)
jge    1801 <main+0x6d1>
movslq 0x3c(%rsp),%rcx
lea    0x26c0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0x840(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    163a <main+0x50a>
jp     163a <main+0x50a>
jmp    169a <main+0x56a>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
movslq 0x3c(%rsp),%rcx
lea    0x26c0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0x840(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm1
lea    0x9af(%rip),%rdi
call   1040 <printf@plt>
movl   $0x1,0x3d2c(%rsp)
jmp    1821 <main+0x6f1>
movslq 0x3c(%rsp),%rcx
lea    0x22c0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0x440(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    16e6 <main+0x5b6>
jp     16e6 <main+0x5b6>
jmp    1746 <main+0x616>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
movslq 0x3c(%rsp),%rcx
lea    0x22c0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0x440(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm1
lea    0x91d(%rip),%rdi
call   1040 <printf@plt>
movl   $0x1,0x3d2c(%rsp)
jmp    1821 <main+0x6f1>
movslq 0x3c(%rsp),%rcx
lea    0x1ec0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0x40(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    178f <main+0x65f>
jp     178f <main+0x65f>
jmp    17ec <main+0x6bc>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
movslq 0x3c(%rsp),%rcx
lea    0x1ec0(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3c(%rsp),%rcx
lea    0x40(%rsp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq 0x38(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm1
lea    0x891(%rip),%rdi
call   1040 <printf@plt>
movl   $0x1,0x3d2c(%rsp)
jmp    1821 <main+0x6f1>
jmp    17f1 <main+0x6c1>
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x38(%rsp)
jmp    15e3 <main+0x4b3>
jmp    1806 <main+0x6d6>
mov    0x3c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x3c(%rsp)
jmp    15d0 <main+0x4a0>
movl   $0x0,0x3d2c(%rsp)
mov    0x3d2c(%rsp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
and    $0xffffffffffffffc0,%rsp
sub    $0x3d80,%rsp
lea    0x31c0(%rsp),%rbx
mov    $0xb60,%edx
mov    %rbx,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x2640(%rsp),%r14
mov    $0xb60,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x1340(%rsp),%rdi
mov    $0x700,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0xc40(%rsp),%rdi
mov    $0x700,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x40(%rsp),%rdi
mov    $0x400,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x440(%rsp),%rdi
mov    $0x400,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x2240(%rsp),%r12
mov    $0x400,%edx
mov    %r12,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x840(%rsp),%rdi
mov    $0x400,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x1e40(%rsp),%r13
mov    $0x400,%edx
mov    %r13,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x1a40(%rsp),%r15
mov    $0x400,%edx
mov    %r15,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    %rbx,%rdi
lea    0x1340(%rsp),%rsi
mov    %r12,0x30(%rsp)
mov    %r12,%rdx
lea    0x840(%rsp),%r12
mov    %r13,0x38(%rsp)
mov    %r13,%rcx
mov    %r15,%r13
lea    0x40(%rsp),%r8
lea    0x440(%rsp),%r15
call   1060 <h264@plt>
mov    %r14,%rdi
lea    0xc40(%rsp),%rsi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %r15,%r8
call   1030 <h264_sc@plt>
xor    %esi,%esi
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%rbx,%rdx,4),%xmm0
movss  -0x4(%r14,%rdx,4),%xmm1
ucomiss %xmm1,%xmm0
jne    13f7 <main+0x2b7>
jp     13f7 <main+0x2b7>
movss  (%rbx,%rdx,4),%xmm0
movss  (%r14,%rdx,4),%xmm1
ucomiss %xmm1,%xmm0
jne    13fb <main+0x2bb>
jp     13fb <main+0x2bb>
add    $0x2,%rdx
cmp    $0x1d,%rdx
jne    1290 <main+0x150>
add    $0x1,%rsi
add    $0x70,%rbx
add    $0x70,%r14
cmp    $0x1a,%rsi
jne    127f <main+0x13f>
xor    %esi,%esi
xorps  %xmm2,%xmm2
lea    0x1340(%rsp),%rax
lea    0xc40(%rsp),%rcx
mov    $0x1,%edx
nopl   0x0(%rax)
movss  -0x4(%rax,%rdx,4),%xmm0
movss  -0x4(%rcx,%rdx,4),%xmm1
movaps %xmm0,%xmm3
subss  %xmm1,%xmm3
ucomiss %xmm2,%xmm3
jne    141b <main+0x2db>
jp     141b <main+0x2db>
movss  (%rax,%rdx,4),%xmm0
movss  (%rcx,%rdx,4),%xmm1
movaps %xmm0,%xmm3
subss  %xmm1,%xmm3
ucomiss %xmm2,%xmm3
jne    141f <main+0x2df>
jp     141f <main+0x2df>
add    $0x2,%rdx
cmp    $0x1d,%rdx
jne    1300 <main+0x1c0>
add    $0x1,%rsi
add    $0x70,%rax
add    $0x70,%rcx
cmp    $0x10,%rsi
jne    12f7 <main+0x1b7>
xor    %esi,%esi
lea    0x40(%rsp),%rcx
xor    %edx,%edx
mov    0x30(%rsp),%rax
movss  (%rax,%rdx,4),%xmm0
movss  (%r12,%rdx,4),%xmm1
ucomiss %xmm1,%xmm0
jne    1428 <main+0x2e8>
jp     1428 <main+0x2e8>
mov    0x38(%rsp),%rdi
movss  (%rdi,%rdx,4),%xmm0
movss  0x0(%r13,%rdx,4),%xmm1
ucomiss %xmm1,%xmm0
jne    1431 <main+0x2f1>
jp     1431 <main+0x2f1>
movss  (%rcx,%rdx,4),%xmm0
movss  (%r15,%rdx,4),%xmm1
ucomiss %xmm1,%xmm0
jne    143a <main+0x2fa>
jp     143a <main+0x2fa>
add    $0x1,%rdx
cmp    $0x10,%rdx
jne    136c <main+0x22c>
add    $0x1,%rsi
add    $0x40,%rax
mov    %rax,0x30(%rsp)
add    $0x40,%r12
addq   $0x40,0x38(%rsp)
add    $0x40,%r13
add    $0x40,%rcx
add    $0x40,%r15
xor    %eax,%eax
cmp    $0x10,%rsi
jne    1365 <main+0x225>
jmp    140c <main+0x2cc>
add    $0xffffffffffffffff,%rdx
lea    0xbfe(%rip),%rdi
call   1040 <printf@plt>
mov    $0x1,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0xffffffffffffffff,%rdx
lea    0xbf4(%rip),%rdi
jmp    1402 <main+0x2c2>
lea    0xc05(%rip),%rdi
jmp    1402 <main+0x2c2>
lea    0xc16(%rip),%rdi
jmp    1402 <main+0x2c2>
lea    0xc27(%rip),%rdi
jmp    1402 <main+0x2c2>

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

LLVM IR (-O2):
@.str = [26 x i8] c"ERROR X[%d][%d] %f != %f\0A\00"
@.str.1 = [26 x i8] c"ERROR H[%d][%d] %f != %f\0A\00"
@.str.2 = [26 x i8] c"ERROR K[%d][%d] %f != %f\0A\00"
@.str.3 = [26 x i8] c"ERROR Y[%d][%d] %f != %f\0A\00"
@.str.4 = [31 x i8] c"ERROR output[%d][%d] %f != %f\0A\00"
define i32 @main() {
%1 = alloca [26 x [28 x float]]
%2 = bitcast [26 x [28 x float]]* %1 to i8*
%3 = alloca [16 x [28 x float]]
%4 = bitcast [16 x [28 x float]]* %3 to i8*
%5 = alloca [16 x [16 x float]]
%6 = bitcast [16 x [16 x float]]* %5 to i8*
%7 = alloca [16 x [16 x float]]
%8 = bitcast [16 x [16 x float]]* %7 to i8*
%9 = alloca [16 x [16 x float]]
%10 = bitcast [16 x [16 x float]]* %9 to i8*
%11 = alloca [26 x [28 x float]]
%12 = bitcast [26 x [28 x float]]* %11 to i8*
%13 = alloca [16 x [28 x float]]
%14 = bitcast [16 x [28 x float]]* %13 to i8*
%15 = alloca [16 x [16 x float]]
%16 = bitcast [16 x [16 x float]]* %15 to i8*
%17 = alloca [16 x [16 x float]]
%18 = bitcast [16 x [16 x float]]* %17 to i8*
%19 = alloca [16 x [16 x float]]
%20 = bitcast [16 x [16 x float]]* %19 to i8*
%21 = bitcast [26 x [28 x float]]* %1 to float**
%22 = bitcast [16 x [28 x float]]* %3 to float**
%23 = bitcast [16 x [16 x float]]* %5 to float**
%24 = bitcast [16 x [16 x float]]* %7 to float**
%25 = bitcast [16 x [16 x float]]* %9 to float**
%26 = call i32 @h264(float** %21, float** %22, float** %23, float** %24, float** %25)
%27 = bitcast [26 x [28 x float]]* %11 to float**
%28 = bitcast [16 x [28 x float]]* %13 to float**
%29 = bitcast [16 x [16 x float]]* %15 to float**
%30 = bitcast [16 x [16 x float]]* %17 to float**
%31 = bitcast [16 x [16 x float]]* %19 to float**
%32 = call i32 @h264_sc(float** %27, float** %28, float** %29, float** %30, float** %31)
br label %33
33: ; preds = %0, %59
%34 = phi i64 [ 0, %0 ], [ %60, %59 ]
br label %35
35: ; preds = %56, %33
%36 = phi i64 [ 0, %33 ], [ %57, %56 ]
%37 = getelementptr inbounds [26 x [28 x float]], [26 x [28 x float]]* %1, i64 0, i64 %34, i64 %36
%38 = load float, float* %37
%39 = getelementptr inbounds [26 x [28 x float]], [26 x [28 x float]]* %11, i64 0, i64 %34, i64 %36
%40 = load float, float* %39
%41 = fcmp une float %38, %40
br i1 %41, label %42, label %49
42: ; preds = %49, %35
%43 = phi i64 [ %36, %35 ], [ %50, %49 ]
%44 = phi float [ %38, %35 ], [ %52, %49 ]
%45 = phi float [ %40, %35 ], [ %54, %49 ]
%46 = trunc i64 %34 to i32
%47 = trunc i64 %43 to i32
%48 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i32 %46, i32 %47, float %44, float %45)
br label %132
49: ; preds = %35
%50 = or i64 %36, 1
%51 = getelementptr inbounds [26 x [28 x float]], [26 x [28 x float]]* %1, i64 0, i64 %34, i64 %50
%52 = load float, float* %51
%53 = getelementptr inbounds [26 x [28 x float]], [26 x [28 x float]]* %11, i64 0, i64 %34, i64 %50
%54 = load float, float* %53
%55 = fcmp une float %52, %54
br i1 %55, label %42, label %56
56: ; preds = %49
%57 = add nuw nsw i64 %36, 2
%58 = icmp eq i64 %57, 28
br i1 %58, label %59, label %35
59: ; preds = %56
%60 = add nuw nsw i64 %34, 1
%61 = icmp eq i64 %60, 26
br i1 %61, label %62, label %33
62: ; preds = %59, %90
%63 = phi i64 [ %91, %90 ], [ 0, %59 ]
br label %64
64: ; preds = %87, %62
%65 = phi i64 [ 0, %62 ], [ %88, %87 ]
%66 = getelementptr inbounds [16 x [28 x float]], [16 x [28 x float]]* %3, i64 0, i64 %63, i64 %65
%67 = load float, float* %66
%68 = getelementptr inbounds [16 x [28 x float]], [16 x [28 x float]]* %13, i64 0, i64 %63, i64 %65
%69 = load float, float* %68
%70 = fsub float %67, %69
%71 = fcmp une float %70, 0.000000e+00
br i1 %71, label %72, label %79
72: ; preds = %79, %64
%73 = phi i64 [ %65, %64 ], [ %80, %79 ]
%74 = phi float [ %67, %64 ], [ %82, %79 ]
%75 = phi float [ %69, %64 ], [ %84, %79 ]
%76 = trunc i64 %63 to i32
%77 = trunc i64 %73 to i32
%78 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0), i32 %76, i32 %77, float %74, float %75)
br label %132
79: ; preds = %64
%80 = or i64 %65, 1
%81 = getelementptr inbounds [16 x [28 x float]], [16 x [28 x float]]* %3, i64 0, i64 %63, i64 %80
%82 = load float, float* %81
%83 = getelementptr inbounds [16 x [28 x float]], [16 x [28 x float]]* %13, i64 0, i64 %63, i64 %80
%84 = load float, float* %83
%85 = fsub float %82, %84
%86 = fcmp une float %85, 0.000000e+00
br i1 %86, label %72, label %87
87: ; preds = %79
%88 = add nuw nsw i64 %65, 2
%89 = icmp eq i64 %88, 28
br i1 %89, label %90, label %64
90: ; preds = %87
%91 = add nuw nsw i64 %63, 1
%92 = icmp eq i64 %91, 16
br i1 %92, label %93, label %62
93: ; preds = %90, %129
%94 = phi i64 [ %130, %129 ], [ 0, %90 ]
br label %95
95: ; preds = %93, %126
%96 = phi i64 [ 0, %93 ], [ %127, %126 ]
%97 = getelementptr inbounds [16 x [16 x float]], [16 x [16 x float]]* %5, i64 0, i64 %94, i64 %96
%98 = load float, float* %97
%99 = getelementptr inbounds [16 x [16 x float]], [16 x [16 x float]]* %15, i64 0, i64 %94, i64 %96
%100 = load float, float* %99
%101 = fcmp une float %98, %100
br i1 %101, label %102, label %106
102: ; preds = %95
%103 = trunc i64 %94 to i32
%104 = trunc i64 %96 to i32
%105 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), i32 %103, i32 %104, float %98, float %100)
br label %132
106: ; preds = %95
%107 = getelementptr inbounds [16 x [16 x float]], [16 x [16 x float]]* %7, i64 0, i64 %94, i64 %96
%108 = load float, float* %107
%109 = getelementptr inbounds [16 x [16 x float]], [16 x [16 x float]]* %17, i64 0, i64 %94, i64 %96
%110 = load float, float* %109
%111 = fcmp une float %108, %110
br i1 %111, label %112, label %116
112: ; preds = %106
%113 = trunc i64 %94 to i32
%114 = trunc i64 %96 to i32
%115 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0), i32 %113, i32 %114, float %108, float %110)
br label %132
116: ; preds = %106
%117 = getelementptr inbounds [16 x [16 x float]], [16 x [16 x float]]* %9, i64 0, i64 %94, i64 %96
%118 = load float, float* %117
%119 = getelementptr inbounds [16 x [16 x float]], [16 x [16 x float]]* %19, i64 0, i64 %94, i64 %96
%120 = load float, float* %119
%121 = fcmp une float %118, %120
br i1 %121, label %122, label %126
122: ; preds = %116
%123 = trunc i64 %94 to i32
%124 = trunc i64 %96 to i32
%125 = call i32 @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.4, i64 0, i64 0), i32 %123, i32 %124, float %118, float %120)
br label %132
126: ; preds = %116
%127 = add nuw nsw i64 %96, 1
%128 = icmp eq i64 %127, 16
br i1 %128, label %129, label %95
129: ; preds = %126
%130 = add nuw nsw i64 %94, 1
%131 = icmp eq i64 %130, 16
br i1 %131, label %132, label %93
132: ; preds = %129, %122, %112, %102, %72, %42
%133 = phi i32 [ 1, %42 ], [ 1, %72 ], [ 1, %102 ], [ 1, %112 ], [ 1, %122 ], [ 0, %129 ]
ret i32 %133
}