void update_nst(int array[7 + 1][7 + 1][5][5][5][5]) {
  int i, j, k, l, m, n;
  int max, max2, max3, max4, max5, max6;
  for (i = 1; i < 7; i++) {
    for (j = 1; j < 7; j++) {
      for (k = 1; k < 5; k++) {
        for (l = 1; l < 5; l++) {
          for (m = 1; m < 5; m++) {
            max = max2 = max3 = max4 = -10000000;
            for (n = 1; n < 5; n++) {
              max = ((max) > (array[i][j][k][l][m][n])
                         ? (max)
                         : (array[i][j][k][l][m][n]));
              max2 = ((max2) > (array[i][j][k][l][n][m])
                          ? (max2)
                          : (array[i][j][k][l][n][m]));
              max3 = ((max3) > (array[i][j][k][n][l][m])
                          ? (max3)
                          : (array[i][j][k][n][l][m]));
              max4 = ((max4) > (array[i][j][n][k][l][m])
                          ? (max4)
                          : (array[i][j][n][k][l][m]));
            }
            array[i][j][k][l][m][0] = max;
            array[i][j][k][l][0][m] = max2;
            array[i][j][k][0][l][m] = max3;
            array[i][j][0][k][l][m] = max4;
          }
        }
      }
    }
  }
  for (i = 1; i < 7; i++) {
    for (j = 1; j < 7; j++) {
      for (k = 1; k < 5; k++) {
        for (l = 1; l < 5; l++) {
          max = max2 = max3 = max4 = max5 = max6 = -10000000;
          for (m = 1; m < 5; m++) {
            max =
                ((max) > (array[i][j][k][l][m][0]) ? (max)
                                                   : (array[i][j][k][l][m][0]));
            max2 = ((max2) > (array[i][j][k][m][0][l])
                        ? (max2)
                        : (array[i][j][k][m][0][l]));
            max3 = ((max3) > (array[i][j][m][0][k][l])
                        ? (max3)
                        : (array[i][j][m][0][k][l]));
            max4 = ((max4) > (array[i][j][0][k][l][m])
                        ? (max4)
                        : (array[i][j][0][k][l][m]));
            max5 = ((max5) > (array[i][j][0][k][m][l])
                        ? (max5)
                        : (array[i][j][0][k][m][l]));
            max6 = ((max6) > (array[i][j][k][0][l][m])
                        ? (max6)
                        : (array[i][j][k][0][l][m]));
          }
          array[i][j][k][l][0][0] = max;
          array[i][j][k][0][0][l] = max2;
          array[i][j][0][0][k][l] = max3;
          array[i][j][k][0][l][0] = max6;
          array[i][j][0][k][0][l] = max5;
          array[i][j][0][k][l][0] = max4;
        }
      }
    }
  }
  for (i = 1; i < 7; i++) {
    for (j = 1; j < 7; j++) {
      for (k = 1; k < 5; k++) {
        max = max2 = max3 = max4 = -10000000;
        for (l = 1; l < 5; l++) {
          max = ((max) > (array[i][j][k][l][0][0]) ? (max)
                                                   : (array[i][j][k][l][0][0]));
          max2 =
              ((max2) > (array[i][j][0][k][l][0]) ? (max2)
                                                  : (array[i][j][0][k][l][0]));
          max3 =
              ((max3) > (array[i][j][0][0][k][l]) ? (max3)
                                                  : (array[i][j][0][0][k][l]));
          max4 =
              ((max4) > (array[i][j][0][0][l][k]) ? (max4)
                                                  : (array[i][j][0][0][l][k]));
        }
        array[i][j][k][0][0][0] = max;
        array[i][j][0][k][0][0] = max2;
        array[i][j][0][0][k][0] = max3;
        array[i][j][0][0][0][k] = max4;
      }
    }
  }
  for (i = 1; i < 7; i++) {
    for (j = 1; j < 7; j++) {
      max = -10000000;
      for (k = 1; k < 5; k++) {
        max = ((max) > (array[i][j][k][0][0][0]) ? (max)
                                                 : (array[i][j][k][0][0][0]));
      }
      array[i][j][0][0][0][0] = max;
    }
  }
  for (i = 1; i < 7; i++) {
    for (k = 0; k < 5; k++) {
      for (l = 0; l < 5; l++) {
        for (m = 0; m < 5; m++) {
          for (n = 0; n < 5; n++) {
            max = max2 = -10000000;
            for (j = 1; j < 7; j++) {
              max = ((max) > (array[i][j][k][l][m][n])
                         ? (max)
                         : (array[i][j][k][l][m][n]));
              max2 = ((max2) > (array[j][i][k][l][m][n])
                          ? (max2)
                          : (array[j][i][k][l][m][n]));
            }
            array[i][7][k][l][m][n] = max;
            array[7][i][k][l][m][n] = max2;
          }
        }
      }
    }
  }
  for (k = 0; k < 5; k++) {
    for (l = 0; l < 5; l++) {
      for (m = 0; m < 5; m++) {
        for (n = 0; n < 5; n++) {
          max = -10000000;
          for (j = 1; j < 7; j++) {
            max =
                ((max) > (array[7][j][k][l][m][n]) ? (max)
                                                   : (array[7][j][k][l][m][n]));
          }
          array[7][7][k][l][m][n] = max;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<update_nst>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x1,-0xc(%rbp)
cmpl   $0x7,-0xc(%rbp)
jge    15cd <update_nst+0x4cd>
movl   $0x1,-0x10(%rbp)
cmpl   $0x7,-0x10(%rbp)
jge    15ba <update_nst+0x4ba>
movl   $0x1,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    15a7 <update_nst+0x4a7>
movl   $0x1,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jge    1594 <update_nst+0x494>
movl   $0x1,-0x1c(%rbp)
cmpl   $0x5,-0x1c(%rbp)
jge    1581 <update_nst+0x481>
movl   $0xff676980,-0x30(%rbp)
movl   $0xff676980,-0x2c(%rbp)
movl   $0xff676980,-0x28(%rbp)
movl   $0xff676980,-0x24(%rbp)
movl   $0x1,-0x20(%rbp)
cmpl   $0x5,-0x20(%rbp)
jge    1464 <update_nst+0x364>
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    11e9 <update_nst+0xe9>
mov    -0x24(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1237 <update_nst+0x137>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    129c <update_nst+0x19c>
mov    -0x28(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    12ea <update_nst+0x1ea>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    134f <update_nst+0x24f>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    139d <update_nst+0x29d>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1402 <update_nst+0x302>
mov    -0x30(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1450 <update_nst+0x350>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1180 <update_nst+0x80>
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rax
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rax
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rax
movslq -0x1c(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1153 <update_nst+0x53>
jmp    1586 <update_nst+0x486>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1142 <update_nst+0x42>
jmp    1599 <update_nst+0x499>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1131 <update_nst+0x31>
jmp    15ac <update_nst+0x4ac>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1120 <update_nst+0x20>
jmp    15bf <update_nst+0x4bf>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    110f <update_nst+0xf>
movl   $0x1,-0xc(%rbp)
cmpl   $0x7,-0xc(%rbp)
jge    1ba8 <update_nst+0xaa8>
movl   $0x1,-0x10(%rbp)
cmpl   $0x7,-0x10(%rbp)
jge    1b95 <update_nst+0xa95>
movl   $0x1,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    1b82 <update_nst+0xa82>
movl   $0x1,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jge    1b6f <update_nst+0xa6f>
movl   $0xff676980,-0x38(%rbp)
movl   $0xff676980,-0x34(%rbp)
movl   $0xff676980,-0x30(%rbp)
movl   $0xff676980,-0x2c(%rbp)
movl   $0xff676980,-0x28(%rbp)
movl   $0xff676980,-0x24(%rbp)
movl   $0x1,-0x1c(%rbp)
cmpl   $0x5,-0x1c(%rbp)
jge    1a08 <update_nst+0x908>
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jle    16a6 <update_nst+0x5a6>
mov    -0x24(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    16ef <update_nst+0x5ef>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1749 <update_nst+0x649>
mov    -0x28(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    178c <update_nst+0x68c>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    17e6 <update_nst+0x6e6>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1829 <update_nst+0x729>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1880 <update_nst+0x780>
mov    -0x30(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    18c0 <update_nst+0x7c0>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1917 <update_nst+0x817>
mov    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    1957 <update_nst+0x857>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    19b1 <update_nst+0x8b1>
mov    -0x38(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    19f4 <update_nst+0x8f4>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1642 <update_nst+0x542>
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rax
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rax
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rax
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rax
movslq -0x18(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rax
movslq -0x14(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rax
movslq -0x18(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1607 <update_nst+0x507>
jmp    1b74 <update_nst+0xa74>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15f6 <update_nst+0x4f6>
jmp    1b87 <update_nst+0xa87>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    15e5 <update_nst+0x4e5>
jmp    1b9a <update_nst+0xa9a>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15d4 <update_nst+0x4d4>
movl   $0x1,-0xc(%rbp)
cmpl   $0x7,-0xc(%rbp)
jge    1f29 <update_nst+0xe29>
movl   $0x1,-0x10(%rbp)
cmpl   $0x7,-0x10(%rbp)
jge    1f16 <update_nst+0xe16>
movl   $0x1,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    1f03 <update_nst+0xe03>
movl   $0xff676980,-0x30(%rbp)
movl   $0xff676980,-0x2c(%rbp)
movl   $0xff676980,-0x28(%rbp)
movl   $0xff676980,-0x24(%rbp)
movl   $0x1,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jge    1e38 <update_nst+0xd38>
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jle    1c57 <update_nst+0xb57>
mov    -0x24(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    1c95 <update_nst+0xb95>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jle    1ce7 <update_nst+0xbe7>
mov    -0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    1d22 <update_nst+0xc22>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1d6e <update_nst+0xc6e>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1da3 <update_nst+0xca3>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1def <update_nst+0xcef>
mov    -0x30(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    1e24 <update_nst+0xd24>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1bfe <update_nst+0xafe>
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rax
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rax
movslq -0x14(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rax
movslq -0x14(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1bd1 <update_nst+0xad1>
jmp    1f08 <update_nst+0xe08>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1bc0 <update_nst+0xac0>
jmp    1f1b <update_nst+0xe1b>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1baf <update_nst+0xaaf>
movl   $0x1,-0xc(%rbp)
cmpl   $0x7,-0xc(%rbp)
jge    2034 <update_nst+0xf34>
movl   $0x1,-0x10(%rbp)
cmpl   $0x7,-0x10(%rbp)
jge    2021 <update_nst+0xf21>
movl   $0xff676980,-0x24(%rbp)
movl   $0x1,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    1fee <update_nst+0xeee>
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jle    1fa7 <update_nst+0xea7>
mov    -0x24(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    1fda <update_nst+0xeda>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1f59 <update_nst+0xe59>
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1f41 <update_nst+0xe41>
jmp    2026 <update_nst+0xf26>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1f30 <update_nst+0xe30>
movl   $0x1,-0xc(%rbp)
cmpl   $0x7,-0xc(%rbp)
jge    2302 <update_nst+0x1202>
movl   $0x0,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    22ef <update_nst+0x11ef>
movl   $0x0,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jge    22dc <update_nst+0x11dc>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x5,-0x1c(%rbp)
jge    22c9 <update_nst+0x11c9>
movl   $0x0,-0x20(%rbp)
cmpl   $0x5,-0x20(%rbp)
jge    22b6 <update_nst+0x11b6>
movl   $0xff676980,-0x28(%rbp)
movl   $0xff676980,-0x24(%rbp)
movl   $0x1,-0x10(%rbp)
cmpl   $0x7,-0x10(%rbp)
jge    221c <update_nst+0x111c>
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    2107 <update_nst+0x1007>
mov    -0x24(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    2155 <update_nst+0x1055>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x10(%rbp),%rdx
imul   $0x4e20,%rdx,%rdx
add    %rdx,%rcx
movslq -0xc(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    21ba <update_nst+0x10ba>
mov    -0x28(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    2208 <update_nst+0x1108>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    209e <update_nst+0xf9e>
mov    -0x24(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x4e20,%rcx,%rcx
add    %rcx,%rax
add    $0x445c,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x8(%rbp),%rax
add    $0x222e0,%rax
movslq -0xc(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    207f <update_nst+0xf7f>
jmp    22bb <update_nst+0x11bb>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    206e <update_nst+0xf6e>
jmp    22ce <update_nst+0x11ce>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    205d <update_nst+0xf5d>
jmp    22e1 <update_nst+0x11e1>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    204c <update_nst+0xf4c>
jmp    22f4 <update_nst+0x11f4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    203b <update_nst+0xf3b>
movl   $0x0,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    2495 <update_nst+0x1395>
movl   $0x0,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jge    2482 <update_nst+0x1382>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x5,-0x1c(%rbp)
jge    246f <update_nst+0x136f>
movl   $0x0,-0x20(%rbp)
cmpl   $0x5,-0x20(%rbp)
jge    245c <update_nst+0x135c>
movl   $0xff676980,-0x24(%rbp)
movl   $0x1,-0x10(%rbp)
cmpl   $0x7,-0x10(%rbp)
jge    2410 <update_nst+0x1310>
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%rcx
add    $0x222e0,%rcx
movslq -0x10(%rbp),%rdx
imul   $0x9c4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
imul   $0x1f4,%rdx,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
imul   $0x64,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    23b6 <update_nst+0x12b6>
mov    -0x24(%rbp),%eax
mov    %eax,-0x80(%rbp)
jmp    23fc <update_nst+0x12fc>
mov    -0x8(%rbp),%rax
add    $0x222e0,%rax
movslq -0x10(%rbp),%rcx
imul   $0x9c4,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    2354 <update_nst+0x1254>
mov    -0x24(%rbp),%edx
mov    -0x8(%rbp),%rax
add    $0x222e0,%rax
add    $0x445c,%rax
movslq -0x14(%rbp),%rcx
imul   $0x1f4,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    233c <update_nst+0x123c>
jmp    2461 <update_nst+0x1361>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    232b <update_nst+0x122b>
jmp    2474 <update_nst+0x1374>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    231a <update_nst+0x121a>
jmp    2487 <update_nst+0x1387>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    2309 <update_nst+0x1209>
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_nst>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
lea    0x5a60(%rdi),%r14
lea    0x5a40(%rdi),%r13
lea    0x59f0(%rdi),%rdx
mov    %rdi,-0x78(%rsp)
lea    0x5860(%rdi),%rsi
mov    $0x1,%edi
mov    $0xff676980,%r9d
cs nopw 0x0(%rax,%rax,1)
mov    %rdi,-0x18(%rsp)
mov    %rsi,-0x10(%rsp)
mov    %rdx,-0x8(%rsp)
mov    %r13,-0x28(%rsp)
mov    %r14,-0x20(%rsp)
mov    $0x1,%eax
xchg   %ax,%ax
mov    %rax,-0x58(%rsp)
mov    $0x1,%eax
mov    %rsi,-0x38(%rsp)
mov    %rdx,-0x40(%rsp)
mov    %rdx,%rdi
mov    %r13,-0x48(%rsp)
mov    %r14,-0x50(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,-0x60(%rsp)
mov    %rsi,-0x68(%rsp)
mov    %rsi,%rdx
mov    %rdi,-0x70(%rsp)
mov    %rdi,%rax
mov    %r13,-0x30(%rsp)
mov    %r14,%r8
mov    $0x1,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %r10d,%r10d
mov    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
mov    -0xc(%rbx),%edi
cmp    $0xff676981,%edi
cmovl  %r9d,%edi
mov    0x14(%r13,%r10,1),%esi
cmp    $0xff676981,%esi
cmovl  %r9d,%esi
mov    0x64(%rax,%r10,1),%ebp
cmp    $0xff676981,%ebp
cmovl  %r9d,%ebp
mov    0x1f4(%rdx,%r10,1),%r15d
cmp    $0xff676981,%r15d
cmovl  %r9d,%r15d
mov    -0x8(%rbx),%r12d
cmp    %r12d,%edi
cmovle %r12d,%edi
mov    0x28(%r13,%r10,1),%ecx
cmp    %ecx,%esi
cmovle %ecx,%esi
mov    0xc8(%rax,%r10,1),%ecx
cmp    %ecx,%ebp
cmovle %ecx,%ebp
mov    0x3e8(%rdx,%r10,1),%ecx
cmp    %ecx,%r15d
cmovle %ecx,%r15d
mov    -0x4(%rbx),%ecx
cmp    %ecx,%edi
cmovle %ecx,%edi
mov    0x3c(%r13,%r10,1),%ecx
cmp    %ecx,%esi
cmovle %ecx,%esi
mov    0x12c(%rax,%r10,1),%ecx
cmp    %ecx,%ebp
cmovle %ecx,%ebp
mov    0x5dc(%rdx,%r10,1),%ecx
cmp    %ecx,%r15d
cmovle %ecx,%r15d
mov    (%rbx),%ecx
cmp    %ecx,%edi
cmovle %ecx,%edi
mov    0x50(%r13,%r10,1),%ecx
cmp    %ecx,%esi
cmovle %ecx,%esi
mov    0x190(%rax,%r10,1),%ecx
cmp    %ecx,%ebp
cmovle %ecx,%ebp
mov    0x7d0(%rdx,%r10,1),%ecx
cmp    %ecx,%r15d
cmovle %ecx,%r15d
mov    %edi,-0x10(%rbx)
mov    %esi,0x0(%r13,%r10,1)
mov    %ebp,(%rax,%r10,1)
mov    %r15d,(%rdx,%r10,1)
add    $0x14,%rbx
add    $0x4,%r10
cmp    $0x10,%r10
jne    11d0 <update_nst+0xd0>
add    $0x1,%r11
add    $0x64,%r8
add    $0x64,%r13
add    $0x14,%rax
add    $0x14,%rdx
cmp    $0x5,%r11
jne    11c0 <update_nst+0xc0>
mov    -0x60(%rsp),%rax
add    $0x1,%rax
add    $0x1f4,%r14
mov    -0x30(%rsp),%r13
add    $0x1f4,%r13
mov    -0x70(%rsp),%rdi
add    $0x1f4,%rdi
mov    -0x68(%rsp),%rsi
add    $0x64,%rsi
cmp    $0x5,%rax
jne    1190 <update_nst+0x90>
mov    -0x58(%rsp),%rax
add    $0x1,%rax
mov    -0x50(%rsp),%r14
add    $0x9c4,%r14
mov    -0x48(%rsp),%r13
add    $0x9c4,%r13
mov    -0x40(%rsp),%rdx
add    $0x9c4,%rdx
mov    -0x38(%rsp),%rsi
add    $0x9c4,%rsi
cmp    $0x7,%rax
jne    1160 <update_nst+0x60>
mov    -0x18(%rsp),%rdi
add    $0x1,%rdi
mov    -0x20(%rsp),%r14
add    $0x4e20,%r14
mov    -0x28(%rsp),%r13
add    $0x4e20,%r13
mov    -0x8(%rsp),%rdx
add    $0x4e20,%rdx
mov    -0x10(%rsp),%rsi
add    $0x4e20,%rsi
cmp    $0x7,%rdi
jne    1140 <update_nst+0x40>
mov    -0x78(%rsp),%rax
lea    0x5a3c(%rax),%r8
lea    0x59dc(%rax),%rbx
lea    0x57fc(%rax),%rdi
add    $0x584c,%rax
mov    $0x1,%ebp
mov    $0xff676980,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,-0x28(%rsp)
mov    %rax,-0x20(%rsp)
mov    %rdi,-0x58(%rsp)
mov    %rdi,%rbp
mov    %rbx,-0x50(%rsp)
mov    %r8,-0x48(%rsp)
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,-0x40(%rsp)
mov    $0x1,%edx
mov    %rax,-0x68(%rsp)
mov    %rax,%rsi
mov    %rbp,-0x70(%rsp)
mov    %rbx,-0x30(%rsp)
mov    %r8,-0x38(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,-0x60(%rsp)
xor    %r10d,%r10d
xor    %r11d,%r11d
mov    %r8,%rax
xchg   %ax,%ax
mov    0x14(%rax),%r15d
mov    0x28(%rax),%edi
cmp    $0xff676981,%r15d
cmovl  %ecx,%r15d
mov    0x64(%rbx,%r11,1),%r12d
cmp    $0xff676981,%r12d
cmovl  %ecx,%r12d
mov    0x1f4(%rbp,%r11,1),%r13d
cmp    $0xff676981,%r13d
cmovl  %ecx,%r13d
mov    0x14(%rsi,%r10,1),%r9d
cmp    $0xff676981,%r9d
cmovl  %ecx,%r9d
mov    0x14(%rsi,%r11,1),%r14d
cmp    $0xff676981,%r14d
cmovl  %ecx,%r14d
mov    0x14(%rbx,%r10,1),%edx
cmp    $0xff676981,%edx
cmovl  %ecx,%edx
cmp    %edi,%r15d
cmovle %edi,%r15d
mov    0xc8(%rbx,%r11,1),%edi
cmp    %edi,%r12d
cmovle %edi,%r12d
mov    0x3e8(%rbp,%r11,1),%edi
cmp    %edi,%r13d
cmovle %edi,%r13d
mov    0x18(%rsi,%r10,1),%edi
cmp    %edi,%r9d
cmovle %edi,%r9d
mov    0x28(%rsi,%r11,1),%edi
cmp    %edi,%r14d
cmovle %edi,%r14d
mov    0x18(%rbx,%r10,1),%edi
cmp    %edi,%edx
cmovle %edi,%edx
mov    0x3c(%rax),%edi
cmp    %edi,%r15d
cmovle %edi,%r15d
mov    0x12c(%rbx,%r11,1),%edi
cmp    %edi,%r12d
cmovle %edi,%r12d
mov    0x5dc(%rbp,%r11,1),%edi
cmp    %edi,%r13d
cmovle %edi,%r13d
mov    0x1c(%rsi,%r10,1),%edi
cmp    %edi,%r9d
cmovle %edi,%r9d
mov    0x3c(%rsi,%r11,1),%edi
cmp    %edi,%r14d
cmovle %edi,%r14d
mov    0x1c(%rbx,%r10,1),%edi
cmp    %edi,%edx
cmovle %edi,%edx
mov    0x50(%rax),%edi
cmp    %edi,%r15d
cmovle %edi,%r15d
mov    0x190(%rbx,%r11,1),%edi
cmp    %edi,%r12d
cmovle %edi,%r12d
mov    0x7d0(%rbp,%r11,1),%edi
cmp    %edi,%r13d
cmovle %edi,%r13d
mov    0x20(%rsi,%r10,1),%edi
cmp    %edi,%r9d
cmovle %edi,%r9d
mov    0x50(%rsi,%r11,1),%edi
cmp    %edi,%r14d
cmovle %edi,%r14d
mov    0x20(%rbx,%r10,1),%edi
cmp    %edi,%edx
cmovle %edi,%edx
mov    %r15d,(%rax)
mov    %r12d,(%rbx,%r11,1)
mov    %r13d,0x0(%rbp,%r11,1)
mov    %edx,0x10(%rbx,%r10,1)
mov    %r14d,(%rsi,%r11,1)
mov    %r9d,0x10(%rsi,%r10,1)
add    $0x64,%rax
add    $0x4,%r11
add    $0x14,%r10
cmp    $0x10,%r11
jne    1440 <update_nst+0x340>
mov    -0x60(%rsp),%rdx
add    $0x1,%rdx
add    $0x1f4,%r8
add    $0x1f4,%rbx
add    $0x14,%rbp
add    $0x64,%rsi
cmp    $0x5,%rdx
jne    1430 <update_nst+0x330>
mov    -0x40(%rsp),%rdx
add    $0x1,%rdx
mov    -0x38(%rsp),%r8
add    $0x9c4,%r8
mov    -0x30(%rsp),%rbx
add    $0x9c4,%rbx
mov    -0x70(%rsp),%rbp
add    $0x9c4,%rbp
mov    -0x68(%rsp),%rax
add    $0x9c4,%rax
cmp    $0x7,%rdx
jne    1400 <update_nst+0x300>
mov    -0x28(%rsp),%rbp
add    $0x1,%rbp
mov    -0x48(%rsp),%r8
add    $0x4e20,%r8
mov    -0x50(%rsp),%rbx
add    $0x4e20,%rbx
mov    -0x58(%rsp),%rdi
add    $0x4e20,%rdi
mov    -0x20(%rsp),%rax
add    $0x4e20,%rax
cmp    $0x7,%rbp
jne    13d0 <update_nst+0x2d0>
mov    $0x1,%ecx
mov    $0x59d8,%r9d
mov    $0x5848,%r13d
mov    $0x5808,%esi
mov    $0x57e8,%edi
mov    $0xff676980,%r10d
mov    -0x78(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rcx,-0x38(%rsp)
mov    %rdi,-0x58(%rsp)
mov    %rsi,-0x50(%rsp)
mov    %rsi,%rcx
mov    %r13,-0x48(%rsp)
mov    %r9,-0x40(%rsp)
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,-0x30(%rsp)
mov    $0x4,%ebx
mov    %rdi,-0x60(%rsp)
mov    %rdi,%rsi
mov    %rcx,-0x68(%rsp)
mov    %rcx,%rdx
mov    %r13,-0x70(%rsp)
mov    %r9,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x64(%rax,%rcx,1),%edi
mov    0xc8(%rax,%rcx,1),%r15d
cmp    $0xff676981,%edi
cmovl  %r10d,%edi
mov    -0x78(%rsp),%rax
mov    0x14(%rax,%r13,1),%r8d
cmp    $0xff676981,%r8d
cmovl  %r10d,%r8d
mov    -0x78(%rsp),%rax
mov    -0xc(%rax,%rdx,1),%r11d
cmp    $0xff676981,%r11d
cmovl  %r10d,%r11d
mov    -0x78(%rsp),%rax
mov    0x14(%rax,%rsi,1),%r14d
cmp    $0xff676981,%r14d
cmovl  %r10d,%r14d
mov    -0x78(%rsp),%rax
mov    0x28(%rax,%r13,1),%r12d
cmp    %r15d,%edi
cmovle %r15d,%edi
mov    -0x78(%rsp),%rax
mov    -0x8(%rax,%rdx,1),%ebp
cmp    %r12d,%r8d
cmovle %r12d,%r8d
mov    -0x78(%rsp),%rax
mov    0x28(%rax,%rsi,1),%eax
cmp    %ebp,%r11d
cmovle %ebp,%r11d
cmp    %eax,%r14d
cmovle %eax,%r14d
mov    -0x78(%rsp),%rax
mov    0x12c(%rax,%rcx,1),%eax
cmp    %eax,%edi
cmovle %eax,%edi
mov    -0x78(%rsp),%rax
mov    0x3c(%rax,%r13,1),%eax
cmp    %eax,%r8d
cmovle %eax,%r8d
mov    -0x78(%rsp),%rax
mov    -0x4(%rax,%rdx,1),%eax
cmp    %eax,%r11d
cmovle %eax,%r11d
mov    -0x78(%rsp),%rax
mov    0x3c(%rax,%rsi,1),%eax
cmp    %eax,%r14d
cmovle %eax,%r14d
mov    -0x78(%rsp),%rax
mov    0x190(%rax,%rcx,1),%eax
cmp    %eax,%edi
cmovle %eax,%edi
mov    -0x78(%rsp),%rax
mov    0x50(%rax,%r13,1),%eax
cmp    %eax,%r8d
cmovle %eax,%r8d
mov    -0x78(%rsp),%rax
mov    (%rax,%rdx,1),%eax
cmp    %eax,%r11d
cmovle %eax,%r11d
mov    -0x78(%rsp),%rax
mov    0x50(%rax,%rsi,1),%eax
cmp    %eax,%r14d
cmovle %eax,%r14d
mov    -0x78(%rsp),%rax
mov    %edi,(%rax,%rcx,1)
mov    -0x78(%rsp),%rax
mov    %r8d,(%rax,%r13,1)
mov    -0x78(%rsp),%rax
mov    %r11d,-0x10(%rax,%rdx,1)
mov    %r14d,(%rax,%rsi,1)
add    $0x1f4,%rcx
add    $0x64,%r13
add    $0x14,%rdx
add    $0x4,%rsi
add    $0xffffffffffffffff,%rbx
jne    16f0 <update_nst+0x5f0>
mov    -0x30(%rsp),%rdx
add    $0x1,%rdx
add    $0x9c4,%r9
mov    -0x70(%rsp),%r13
add    $0x9c4,%r13
mov    -0x68(%rsp),%rcx
add    $0x9c4,%rcx
mov    -0x60(%rsp),%rdi
add    $0x9c4,%rdi
cmp    $0x7,%rdx
jne    16c0 <update_nst+0x5c0>
mov    -0x38(%rsp),%rcx
add    $0x1,%rcx
mov    -0x40(%rsp),%r9
add    $0x4e20,%r9
mov    -0x48(%rsp),%r13
add    $0x4e20,%r13
mov    -0x50(%rsp),%rsi
add    $0x4e20,%rsi
mov    -0x58(%rsp),%rdi
add    $0x4e20,%rdi
cmp    $0x7,%rcx
jne    1690 <update_nst+0x590>
lea    0x57e4(%rax),%r11
xor    %eax,%eax
mov    $0xff676980,%ecx
nopl   0x0(%rax,%rax,1)
mov    0x1f4(%r11,%rax,1),%edx
mov    0x3e8(%r11,%rax,1),%esi
cmp    $0xff676981,%edx
cmovl  %ecx,%edx
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x5dc(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x7d0(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    %edx,(%r11,%rax,1)
mov    0xbb8(%r11,%rax,1),%edx
cmp    $0xff676981,%edx
cmovl  %ecx,%edx
mov    0xdac(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0xfa0(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x1194(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    %edx,0x9c4(%r11,%rax,1)
mov    0x157c(%r11,%rax,1),%edx
cmp    $0xff676981,%edx
cmovl  %ecx,%edx
mov    0x1770(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x1964(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x1b58(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    %edx,0x1388(%r11,%rax,1)
mov    0x1f40(%r11,%rax,1),%edx
cmp    $0xff676981,%edx
cmovl  %ecx,%edx
mov    0x2134(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x2328(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x251c(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    %edx,0x1d4c(%r11,%rax,1)
mov    0x2904(%r11,%rax,1),%edx
mov    0x2af8(%r11,%rax,1),%esi
cmp    $0xff676981,%edx
cmovl  %ecx,%edx
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x2cec(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x2ee0(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    %edx,0x2710(%r11,%rax,1)
mov    0x32c8(%r11,%rax,1),%edx
cmp    $0xff676981,%edx
cmovl  %ecx,%edx
mov    0x34bc(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x36b0(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    0x38a4(%r11,%rax,1),%esi
cmp    %esi,%edx
cmovle %esi,%edx
mov    %edx,0x30d4(%r11,%rax,1)
add    $0x4e20,%rax
cmp    $0x1d4c0,%rax
jne    18d0 <update_nst+0x7d0>
mov    $0x1,%eax
mov    $0xff676980,%edx
mov    %r11,%r10
jmp    1a9b <update_nst+0x99b>
nopl   (%rax)
mov    -0x68(%rsp),%rax
add    $0x1,%rax
mov    -0x70(%rsp),%r10
add    $0x4e20,%r10
mov    -0x60(%rsp),%r11
add    $0x9c4,%r11
cmp    $0x7,%rax
je     1be7 <update_nst+0xae7>
mov    %rax,-0x68(%rsp)
mov    %r11,-0x60(%rsp)
mov    %r10,-0x70(%rsp)
xor    %r14d,%r14d
jmp    1ac8 <update_nst+0x9c8>
nop
add    $0x1,%r14
add    $0x1f4,%r10
add    $0x1f4,%r11
cmp    $0x5,%r14
je     1a70 <update_nst+0x970>
mov    %r11,%r12
mov    %r10,%r15
xor    %r13d,%r13d
jmp    1af2 <update_nst+0x9f2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13
add    $0x64,%r15
add    $0x64,%r12
cmp    $0x5,%r13
je     1ab0 <update_nst+0x9b0>
mov    %r12,%rax
mov    %r15,%rbp
xor    %ecx,%ecx
jmp    1b12 <update_nst+0xa12>
nopl   0x0(%rax)
add    $0x1,%rcx
add    $0x14,%rbp
add    $0x14,%rax
cmp    $0x5,%rcx
je     1ae0 <update_nst+0x9e0>
xor    %esi,%esi
jmp    1b39 <update_nst+0xa39>
cs nopw 0x0(%rax,%rax,1)
mov    %edi,0x3a98(%rbp,%rsi,4)
mov    %r8d,0x1d4c0(%rax,%rsi,4)
add    $0x1,%rsi
cmp    $0x5,%rsi
je     1b00 <update_nst+0xa00>
mov    0x0(%rbp,%rsi,4),%edi
cmp    $0xff676981,%edi
cmovl  %edx,%edi
mov    (%rax,%rsi,4),%r8d
cmp    $0xff676981,%r8d
cmovl  %edx,%r8d
mov    0x9c4(%rbp,%rsi,4),%ebx
cmp    %ebx,%edi
cmovle %ebx,%edi
mov    0x4e20(%rax,%rsi,4),%ebx
cmp    %ebx,%r8d
cmovle %ebx,%r8d
mov    0x1388(%rbp,%rsi,4),%ebx
cmp    %ebx,%edi
cmovle %ebx,%edi
mov    0x9c40(%rax,%rsi,4),%ebx
cmp    %ebx,%r8d
cmovle %ebx,%r8d
mov    0x1d4c(%rbp,%rsi,4),%ebx
cmp    %ebx,%edi
cmovle %ebx,%edi
mov    0xea60(%rax,%rsi,4),%ebx
cmp    %ebx,%r8d
cmovle %ebx,%r8d
mov    0x2710(%rbp,%rsi,4),%r9d
cmp    %r9d,%edi
jg     1bb3 <update_nst+0xab3>
mov    %r9d,%edi
mov    0x13880(%rax,%rsi,4),%ebx
cmp    %ebx,%r8d
jg     1bc2 <update_nst+0xac2>
mov    %ebx,%r8d
mov    0x30d4(%rbp,%rsi,4),%ebx
cmp    %ebx,%edi
jg     1bcf <update_nst+0xacf>
mov    %ebx,%edi
mov    0x186a0(%rax,%rsi,4),%ebx
cmp    %ebx,%r8d
jg     1b20 <update_nst+0xa20>
mov    %ebx,%r8d
jmp    1b20 <update_nst+0xa20>
mov    -0x78(%rsp),%rax
add    $0x2674c,%rax
xor    %r8d,%r8d
movdqa 0x403(%rip),%xmm0
mov    $0xff676980,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x3aa8(%rdx,%rbp,1),%xmm1
ff ff
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movdqu -0x30e4(%rdx,%rbp,1),%xmm1
ff ff
movdqa %xmm2,%xmm3
pcmpgtd %xmm1,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movdqu -0x2720(%rdx,%rbp,1),%xmm1
ff ff
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqu -0x1d5c(%rdx,%rbp,1),%xmm1
ff ff
movdqa %xmm2,%xmm3
pcmpgtd %xmm1,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movdqu -0x1398(%rdx,%rbp,1),%xmm1
ff ff
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqu -0x9d4(%rdx,%rbp,1),%xmm1
ff ff
movdqa %xmm2,%xmm3
pcmpgtd %xmm1,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movdqu %xmm3,-0x10(%rdx,%rbp,1)
mov    -0x3a98(%rdx,%rbp,1),%edi
cmp    $0xff676981,%edi
cmovl  %ecx,%edi
mov    -0x30d4(%rdx,%rbp,1),%ebx
cmp    %ebx,%edi
cmovle %ebx,%edi
mov    -0x2710(%rdx,%rbp,1),%ebx
cmp    %ebx,%edi
cmovle %ebx,%edi
mov    -0x1d4c(%rdx,%rbp,1),%ebx
cmp    %ebx,%edi
cmovle %ebx,%edi
mov    -0x1388(%rdx,%rbp,1),%ebx
cmp    %ebx,%edi
cmovle %ebx,%edi
mov    -0x9c4(%rdx,%rbp,1),%ebx
cmp    %ebx,%edi
cmovle %ebx,%edi
mov    %edi,(%rdx,%rbp,1)
add    $0x14,%rbp
cmp    $0x64,%rbp
jne    1c30 <update_nst+0xb30>
add    $0x1,%rsi
add    $0x64,%rdx
cmp    $0x5,%rsi
jne    1c20 <update_nst+0xb20>
add    $0x1,%r8
add    $0x1f4,%rax
cmp    $0x5,%r8
jne    1c10 <update_nst+0xb10>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @update_nst([8 x [5 x [5 x [5 x [5 x i32]]]]]* %0) {
%2 = alloca [8 x [5 x [5 x [5 x [5 x i32]]]]]*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
store i32 1, i32* %3
br label %15
15: ; preds = %319, %1
%16 = load i32, i32* %3
%17 = icmp slt i32 %16, 7
br i1 %17, label %18, label %322
18: ; preds = %15
store i32 1, i32* %4
br label %19
19: ; preds = %315, %18
%20 = load i32, i32* %4
%21 = icmp slt i32 %20, 7
br i1 %21, label %22, label %318
22: ; preds = %19
store i32 1, i32* %5
br label %23
23: ; preds = %311, %22
%24 = load i32, i32* %5
%25 = icmp slt i32 %24, 5
br i1 %25, label %26, label %314
26: ; preds = %23
store i32 1, i32* %6
br label %27
27: ; preds = %307, %26
%28 = load i32, i32* %6
%29 = icmp slt i32 %28, 5
br i1 %29, label %30, label %310
30: ; preds = %27
store i32 1, i32* %7
br label %31
31: ; preds = %303, %30
%32 = load i32, i32* %7
%33 = icmp slt i32 %32, 5
br i1 %33, label %34, label %306
34: ; preds = %31
store i32 -10000000, i32* %12
store i32 -10000000, i32* %11
store i32 -10000000, i32* %10
store i32 -10000000, i32* %9
store i32 1, i32* %8
br label %35
35: ; preds = %227, %34
%36 = load i32, i32* %8
%37 = icmp slt i32 %36, 5
br i1 %37, label %38, label %230
38: ; preds = %35
%39 = load i32, i32* %9
%40 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%41 = load i32, i32* %3
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %40, i64 %42
%44 = load i32, i32* %4
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %43, i64 0, i64 %45
%47 = load i32, i32* %5
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %46, i64 0, i64 %48
%50 = load i32, i32* %6
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %49, i64 0, i64 %51
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %52, i64 0, i64 %54
%56 = load i32, i32* %8
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [5 x i32], [5 x i32]* %55, i64 0, i64 %57
%59 = load i32, i32* %58
%60 = icmp sgt i32 %39, %59
br i1 %60, label %61, label %63
61: ; preds = %38
%62 = load i32, i32* %9
br label %84
63: ; preds = %38
%64 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%65 = load i32, i32* %3
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %64, i64 %66
%68 = load i32, i32* %4
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %67, i64 0, i64 %69
%71 = load i32, i32* %5
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %70, i64 0, i64 %72
%74 = load i32, i32* %6
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %73, i64 0, i64 %75
%77 = load i32, i32* %7
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %76, i64 0, i64 %78
%80 = load i32, i32* %8
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [5 x i32], [5 x i32]* %79, i64 0, i64 %81
%83 = load i32, i32* %82
br label %84
84: ; preds = %63, %61
%85 = phi i32 [ %62, %61 ], [ %83, %63 ]
store i32 %85, i32* %9
%86 = load i32, i32* %10
%87 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%88 = load i32, i32* %3
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %87, i64 %89
%91 = load i32, i32* %4
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %90, i64 0, i64 %92
%94 = load i32, i32* %5
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %93, i64 0, i64 %95
%97 = load i32, i32* %6
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %96, i64 0, i64 %98
%100 = load i32, i32* %8
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %99, i64 0, i64 %101
%103 = load i32, i32* %7
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [5 x i32], [5 x i32]* %102, i64 0, i64 %104
%106 = load i32, i32* %105
%107 = icmp sgt i32 %86, %106
br i1 %107, label %108, label %110
108: ; preds = %84
%109 = load i32, i32* %10
br label %131
110: ; preds = %84
%111 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%112 = load i32, i32* %3
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %111, i64 %113
%115 = load i32, i32* %4
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %114, i64 0, i64 %116
%118 = load i32, i32* %5
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %117, i64 0, i64 %119
%121 = load i32, i32* %6
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %120, i64 0, i64 %122
%124 = load i32, i32* %8
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %123, i64 0, i64 %125
%127 = load i32, i32* %7
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [5 x i32], [5 x i32]* %126, i64 0, i64 %128
%130 = load i32, i32* %129
br label %131
131: ; preds = %110, %108
%132 = phi i32 [ %109, %108 ], [ %130, %110 ]
store i32 %132, i32* %10
%133 = load i32, i32* %11
%134 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%135 = load i32, i32* %3
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %134, i64 %136
%138 = load i32, i32* %4
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %137, i64 0, i64 %139
%141 = load i32, i32* %5
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %140, i64 0, i64 %142
%144 = load i32, i32* %8
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %143, i64 0, i64 %145
%147 = load i32, i32* %6
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %146, i64 0, i64 %148
%150 = load i32, i32* %7
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [5 x i32], [5 x i32]* %149, i64 0, i64 %151
%153 = load i32, i32* %152
%154 = icmp sgt i32 %133, %153
br i1 %154, label %155, label %157
155: ; preds = %131
%156 = load i32, i32* %11
br label %178
157: ; preds = %131
%158 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%159 = load i32, i32* %3
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %158, i64 %160
%162 = load i32, i32* %4
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %161, i64 0, i64 %163
%165 = load i32, i32* %5
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %164, i64 0, i64 %166
%168 = load i32, i32* %8
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %167, i64 0, i64 %169
%171 = load i32, i32* %6
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %170, i64 0, i64 %172
%174 = load i32, i32* %7
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [5 x i32], [5 x i32]* %173, i64 0, i64 %175
%177 = load i32, i32* %176
br label %178
178: ; preds = %157, %155
%179 = phi i32 [ %156, %155 ], [ %177, %157 ]
store i32 %179, i32* %11
%180 = load i32, i32* %12
%181 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%182 = load i32, i32* %3
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %181, i64 %183
%185 = load i32, i32* %4
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %184, i64 0, i64 %186
%188 = load i32, i32* %8
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %187, i64 0, i64 %189
%191 = load i32, i32* %5
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %190, i64 0, i64 %192
%194 = load i32, i32* %6
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %193, i64 0, i64 %195
%197 = load i32, i32* %7
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [5 x i32], [5 x i32]* %196, i64 0, i64 %198
%200 = load i32, i32* %199
%201 = icmp sgt i32 %180, %200
br i1 %201, label %202, label %204
202: ; preds = %178
%203 = load i32, i32* %12
br label %225
204: ; preds = %178
%205 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%206 = load i32, i32* %3
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %205, i64 %207
%209 = load i32, i32* %4
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %208, i64 0, i64 %210
%212 = load i32, i32* %8
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %211, i64 0, i64 %213
%215 = load i32, i32* %5
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %214, i64 0, i64 %216
%218 = load i32, i32* %6
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %217, i64 0, i64 %219
%221 = load i32, i32* %7
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds [5 x i32], [5 x i32]* %220, i64 0, i64 %222
%224 = load i32, i32* %223
br label %225
225: ; preds = %204, %202
%226 = phi i32 [ %203, %202 ], [ %224, %204 ]
store i32 %226, i32* %12
br label %227
227: ; preds = %225
%228 = load i32, i32* %8
%229 = add nsw i32 %228, 1
store i32 %229, i32* %8
br label %35
230: ; preds = %35
%231 = load i32, i32* %9
%232 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%233 = load i32, i32* %3
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %232, i64 %234
%236 = load i32, i32* %4
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %235, i64 0, i64 %237
%239 = load i32, i32* %5
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %238, i64 0, i64 %240
%242 = load i32, i32* %6
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %241, i64 0, i64 %243
%245 = load i32, i32* %7
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %244, i64 0, i64 %246
%248 = getelementptr inbounds [5 x i32], [5 x i32]* %247, i64 0, i64 0
store i32 %231, i32* %248
%249 = load i32, i32* %10
%250 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%251 = load i32, i32* %3
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %250, i64 %252
%254 = load i32, i32* %4
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %253, i64 0, i64 %255
%257 = load i32, i32* %5
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %256, i64 0, i64 %258
%260 = load i32, i32* %6
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %259, i64 0, i64 %261
%263 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %262, i64 0, i64 0
%264 = load i32, i32* %7
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds [5 x i32], [5 x i32]* %263, i64 0, i64 %265
store i32 %249, i32* %266
%267 = load i32, i32* %11
%268 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%269 = load i32, i32* %3
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %268, i64 %270
%272 = load i32, i32* %4
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %271, i64 0, i64 %273
%275 = load i32, i32* %5
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %274, i64 0, i64 %276
%278 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %277, i64 0, i64 0
%279 = load i32, i32* %6
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %278, i64 0, i64 %280
%282 = load i32, i32* %7
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds [5 x i32], [5 x i32]* %281, i64 0, i64 %283
store i32 %267, i32* %284
%285 = load i32, i32* %12
%286 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%287 = load i32, i32* %3
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %286, i64 %288
%290 = load i32, i32* %4
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %289, i64 0, i64 %291
%293 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %292, i64 0, i64 0
%294 = load i32, i32* %5
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %293, i64 0, i64 %295
%297 = load i32, i32* %6
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %296, i64 0, i64 %298
%300 = load i32, i32* %7
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [5 x i32], [5 x i32]* %299, i64 0, i64 %301
store i32 %285, i32* %302
br label %303
303: ; preds = %230
%304 = load i32, i32* %7
%305 = add nsw i32 %304, 1
store i32 %305, i32* %7
br label %31
306: ; preds = %31
br label %307
307: ; preds = %306
%308 = load i32, i32* %6
%309 = add nsw i32 %308, 1
store i32 %309, i32* %6
br label %27
310: ; preds = %27
br label %311
311: ; preds = %310
%312 = load i32, i32* %5
%313 = add nsw i32 %312, 1
store i32 %313, i32* %5
br label %23
314: ; preds = %23
br label %315
315: ; preds = %314
%316 = load i32, i32* %4
%317 = add nsw i32 %316, 1
store i32 %317, i32* %4
br label %19
318: ; preds = %19
br label %319
319: ; preds = %318
%320 = load i32, i32* %3
%321 = add nsw i32 %320, 1
store i32 %321, i32* %3
br label %15
322: ; preds = %15
store i32 1, i32* %3
br label %323
323: ; preds = %713, %322
%324 = load i32, i32* %3
%325 = icmp slt i32 %324, 7
br i1 %325, label %326, label %716
326: ; preds = %323
store i32 1, i32* %4
br label %327
327: ; preds = %709, %326
%328 = load i32, i32* %4
%329 = icmp slt i32 %328, 7
br i1 %329, label %330, label %712
330: ; preds = %327
store i32 1, i32* %5
br label %331
331: ; preds = %705, %330
%332 = load i32, i32* %5
%333 = icmp slt i32 %332, 5
br i1 %333, label %334, label %708
334: ; preds = %331
store i32 1, i32* %6
br label %335
335: ; preds = %701, %334
%336 = load i32, i32* %6
%337 = icmp slt i32 %336, 5
br i1 %337, label %338, label %704
338: ; preds = %335
store i32 -10000000, i32* %14
store i32 -10000000, i32* %13
store i32 -10000000, i32* %12
store i32 -10000000, i32* %11
store i32 -10000000, i32* %10
store i32 -10000000, i32* %9
store i32 1, i32* %7
br label %339
339: ; preds = %601, %338
%340 = load i32, i32* %7
%341 = icmp slt i32 %340, 5
br i1 %341, label %342, label %604
342: ; preds = %339
%343 = load i32, i32* %9
%344 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%345 = load i32, i32* %3
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %344, i64 %346
%348 = load i32, i32* %4
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %347, i64 0, i64 %349
%351 = load i32, i32* %5
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %350, i64 0, i64 %352
%354 = load i32, i32* %6
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %353, i64 0, i64 %355
%357 = load i32, i32* %7
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %356, i64 0, i64 %358
%360 = getelementptr inbounds [5 x i32], [5 x i32]* %359, i64 0, i64 0
%361 = load i32, i32* %360
%362 = icmp sgt i32 %343, %361
br i1 %362, label %363, label %365
363: ; preds = %342
%364 = load i32, i32* %9
br label %384
365: ; preds = %342
%366 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%367 = load i32, i32* %3
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %366, i64 %368
%370 = load i32, i32* %4
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %369, i64 0, i64 %371
%373 = load i32, i32* %5
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %372, i64 0, i64 %374
%376 = load i32, i32* %6
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %375, i64 0, i64 %377
%379 = load i32, i32* %7
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %378, i64 0, i64 %380
%382 = getelementptr inbounds [5 x i32], [5 x i32]* %381, i64 0, i64 0
%383 = load i32, i32* %382
br label %384
384: ; preds = %365, %363
%385 = phi i32 [ %364, %363 ], [ %383, %365 ]
store i32 %385, i32* %9
%386 = load i32, i32* %10
%387 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%388 = load i32, i32* %3
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %387, i64 %389
%391 = load i32, i32* %4
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %390, i64 0, i64 %392
%394 = load i32, i32* %5
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %393, i64 0, i64 %395
%397 = load i32, i32* %7
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %396, i64 0, i64 %398
%400 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %399, i64 0, i64 0
%401 = load i32, i32* %6
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds [5 x i32], [5 x i32]* %400, i64 0, i64 %402
%404 = load i32, i32* %403
%405 = icmp sgt i32 %386, %404
br i1 %405, label %406, label %408
406: ; preds = %384
%407 = load i32, i32* %10
br label %427
408: ; preds = %384
%409 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%410 = load i32, i32* %3
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %409, i64 %411
%413 = load i32, i32* %4
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %412, i64 0, i64 %414
%416 = load i32, i32* %5
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %415, i64 0, i64 %417
%419 = load i32, i32* %7
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %418, i64 0, i64 %420
%422 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %421, i64 0, i64 0
%423 = load i32, i32* %6
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds [5 x i32], [5 x i32]* %422, i64 0, i64 %424
%426 = load i32, i32* %425
br label %427
427: ; preds = %408, %406
%428 = phi i32 [ %407, %406 ], [ %426, %408 ]
store i32 %428, i32* %10
%429 = load i32, i32* %11
%430 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%431 = load i32, i32* %3
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %430, i64 %432
%434 = load i32, i32* %4
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %433, i64 0, i64 %435
%437 = load i32, i32* %7
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %436, i64 0, i64 %438
%440 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %439, i64 0, i64 0
%441 = load i32, i32* %5
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %440, i64 0, i64 %442
%444 = load i32, i32* %6
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [5 x i32], [5 x i32]* %443, i64 0, i64 %445
%447 = load i32, i32* %446
%448 = icmp sgt i32 %429, %447
br i1 %448, label %449, label %451
449: ; preds = %427
%450 = load i32, i32* %11
br label %470
451: ; preds = %427
%452 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%453 = load i32, i32* %3
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %452, i64 %454
%456 = load i32, i32* %4
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %455, i64 0, i64 %457
%459 = load i32, i32* %7
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %458, i64 0, i64 %460
%462 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %461, i64 0, i64 0
%463 = load i32, i32* %5
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %462, i64 0, i64 %464
%466 = load i32, i32* %6
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds [5 x i32], [5 x i32]* %465, i64 0, i64 %467
%469 = load i32, i32* %468
br label %470
470: ; preds = %451, %449
%471 = phi i32 [ %450, %449 ], [ %469, %451 ]
store i32 %471, i32* %11
%472 = load i32, i32* %12
%473 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%474 = load i32, i32* %3
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %473, i64 %475
%477 = load i32, i32* %4
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %476, i64 0, i64 %478
%480 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %479, i64 0, i64 0
%481 = load i32, i32* %5
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %480, i64 0, i64 %482
%484 = load i32, i32* %6
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %483, i64 0, i64 %485
%487 = load i32, i32* %7
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds [5 x i32], [5 x i32]* %486, i64 0, i64 %488
%490 = load i32, i32* %489
%491 = icmp sgt i32 %472, %490
br i1 %491, label %492, label %494
492: ; preds = %470
%493 = load i32, i32* %12
br label %513
494: ; preds = %470
%495 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%496 = load i32, i32* %3
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %495, i64 %497
%499 = load i32, i32* %4
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %498, i64 0, i64 %500
%502 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %501, i64 0, i64 0
%503 = load i32, i32* %5
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %502, i64 0, i64 %504
%506 = load i32, i32* %6
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %505, i64 0, i64 %507
%509 = load i32, i32* %7
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds [5 x i32], [5 x i32]* %508, i64 0, i64 %510
%512 = load i32, i32* %511
br label %513
513: ; preds = %494, %492
%514 = phi i32 [ %493, %492 ], [ %512, %494 ]
store i32 %514, i32* %12
%515 = load i32, i32* %13
%516 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%517 = load i32, i32* %3
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %516, i64 %518
%520 = load i32, i32* %4
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %519, i64 0, i64 %521
%523 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %522, i64 0, i64 0
%524 = load i32, i32* %5
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %523, i64 0, i64 %525
%527 = load i32, i32* %7
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %526, i64 0, i64 %528
%530 = load i32, i32* %6
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds [5 x i32], [5 x i32]* %529, i64 0, i64 %531
%533 = load i32, i32* %532
%534 = icmp sgt i32 %515, %533
br i1 %534, label %535, label %537
535: ; preds = %513
%536 = load i32, i32* %13
br label %556
537: ; preds = %513
%538 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%539 = load i32, i32* %3
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %538, i64 %540
%542 = load i32, i32* %4
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %541, i64 0, i64 %543
%545 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %544, i64 0, i64 0
%546 = load i32, i32* %5
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %545, i64 0, i64 %547
%549 = load i32, i32* %7
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %548, i64 0, i64 %550
%552 = load i32, i32* %6
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds [5 x i32], [5 x i32]* %551, i64 0, i64 %553
%555 = load i32, i32* %554
br label %556
556: ; preds = %537, %535
%557 = phi i32 [ %536, %535 ], [ %555, %537 ]
store i32 %557, i32* %13
%558 = load i32, i32* %14
%559 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%560 = load i32, i32* %3
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %559, i64 %561
%563 = load i32, i32* %4
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %562, i64 0, i64 %564
%566 = load i32, i32* %5
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %565, i64 0, i64 %567
%569 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %568, i64 0, i64 0
%570 = load i32, i32* %6
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %569, i64 0, i64 %571
%573 = load i32, i32* %7
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds [5 x i32], [5 x i32]* %572, i64 0, i64 %574
%576 = load i32, i32* %575
%577 = icmp sgt i32 %558, %576
br i1 %577, label %578, label %580
578: ; preds = %556
%579 = load i32, i32* %14
br label %599
580: ; preds = %556
%581 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%582 = load i32, i32* %3
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %581, i64 %583
%585 = load i32, i32* %4
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %584, i64 0, i64 %586
%588 = load i32, i32* %5
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %587, i64 0, i64 %589
%591 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %590, i64 0, i64 0
%592 = load i32, i32* %6
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %591, i64 0, i64 %593
%595 = load i32, i32* %7
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds [5 x i32], [5 x i32]* %594, i64 0, i64 %596
%598 = load i32, i32* %597
br label %599
599: ; preds = %580, %578
%600 = phi i32 [ %579, %578 ], [ %598, %580 ]
store i32 %600, i32* %14
br label %601
601: ; preds = %599
%602 = load i32, i32* %7
%603 = add nsw i32 %602, 1
store i32 %603, i32* %7
br label %339
604: ; preds = %339
%605 = load i32, i32* %9
%606 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%607 = load i32, i32* %3
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %606, i64 %608
%610 = load i32, i32* %4
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %609, i64 0, i64 %611
%613 = load i32, i32* %5
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %612, i64 0, i64 %614
%616 = load i32, i32* %6
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %615, i64 0, i64 %617
%619 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %618, i64 0, i64 0
%620 = getelementptr inbounds [5 x i32], [5 x i32]* %619, i64 0, i64 0
store i32 %605, i32* %620
%621 = load i32, i32* %10
%622 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%623 = load i32, i32* %3
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %622, i64 %624
%626 = load i32, i32* %4
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %625, i64 0, i64 %627
%629 = load i32, i32* %5
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %628, i64 0, i64 %630
%632 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %631, i64 0, i64 0
%633 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %632, i64 0, i64 0
%634 = load i32, i32* %6
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds [5 x i32], [5 x i32]* %633, i64 0, i64 %635
store i32 %621, i32* %636
%637 = load i32, i32* %11
%638 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%639 = load i32, i32* %3
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %638, i64 %640
%642 = load i32, i32* %4
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %641, i64 0, i64 %643
%645 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %644, i64 0, i64 0
%646 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %645, i64 0, i64 0
%647 = load i32, i32* %5
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %646, i64 0, i64 %648
%650 = load i32, i32* %6
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds [5 x i32], [5 x i32]* %649, i64 0, i64 %651
store i32 %637, i32* %652
%653 = load i32, i32* %14
%654 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%655 = load i32, i32* %3
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %654, i64 %656
%658 = load i32, i32* %4
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %657, i64 0, i64 %659
%661 = load i32, i32* %5
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %660, i64 0, i64 %662
%664 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %663, i64 0, i64 0
%665 = load i32, i32* %6
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %664, i64 0, i64 %666
%668 = getelementptr inbounds [5 x i32], [5 x i32]* %667, i64 0, i64 0
store i32 %653, i32* %668
%669 = load i32, i32* %13
%670 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%671 = load i32, i32* %3
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %670, i64 %672
%674 = load i32, i32* %4
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %673, i64 0, i64 %675
%677 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %676, i64 0, i64 0
%678 = load i32, i32* %5
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %677, i64 0, i64 %679
%681 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %680, i64 0, i64 0
%682 = load i32, i32* %6
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds [5 x i32], [5 x i32]* %681, i64 0, i64 %683
store i32 %669, i32* %684
%685 = load i32, i32* %12
%686 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%687 = load i32, i32* %3
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %686, i64 %688
%690 = load i32, i32* %4
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %689, i64 0, i64 %691
%693 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %692, i64 0, i64 0
%694 = load i32, i32* %5
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %693, i64 0, i64 %695
%697 = load i32, i32* %6
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %696, i64 0, i64 %698
%700 = getelementptr inbounds [5 x i32], [5 x i32]* %699, i64 0, i64 0
store i32 %685, i32* %700
br label %701
701: ; preds = %604
%702 = load i32, i32* %6
%703 = add nsw i32 %702, 1
store i32 %703, i32* %6
br label %335
704: ; preds = %335
br label %705
705: ; preds = %704
%706 = load i32, i32* %5
%707 = add nsw i32 %706, 1
store i32 %707, i32* %5
br label %331
708: ; preds = %331
br label %709
709: ; preds = %708
%710 = load i32, i32* %4
%711 = add nsw i32 %710, 1
store i32 %711, i32* %4
br label %327
712: ; preds = %327
br label %713
713: ; preds = %712
%714 = load i32, i32* %3
%715 = add nsw i32 %714, 1
store i32 %715, i32* %3
br label %323
716: ; preds = %323
store i32 1, i32* %3
br label %717
717: ; preds = %957, %716
%718 = load i32, i32* %3
%719 = icmp slt i32 %718, 7
br i1 %719, label %720, label %960
720: ; preds = %717
store i32 1, i32* %4
br label %721
721: ; preds = %953, %720
%722 = load i32, i32* %4
%723 = icmp slt i32 %722, 7
br i1 %723, label %724, label %956
724: ; preds = %721
store i32 1, i32* %5
br label %725
725: ; preds = %949, %724
%726 = load i32, i32* %5
%727 = icmp slt i32 %726, 5
br i1 %727, label %728, label %952
728: ; preds = %725
store i32 -10000000, i32* %12
store i32 -10000000, i32* %11
store i32 -10000000, i32* %10
store i32 -10000000, i32* %9
store i32 1, i32* %6
br label %729
729: ; preds = %889, %728
%730 = load i32, i32* %6
%731 = icmp slt i32 %730, 5
br i1 %731, label %732, label %892
732: ; preds = %729
%733 = load i32, i32* %9
%734 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%735 = load i32, i32* %3
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %734, i64 %736
%738 = load i32, i32* %4
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %737, i64 0, i64 %739
%741 = load i32, i32* %5
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %740, i64 0, i64 %742
%744 = load i32, i32* %6
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %743, i64 0, i64 %745
%747 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %746, i64 0, i64 0
%748 = getelementptr inbounds [5 x i32], [5 x i32]* %747, i64 0, i64 0
%749 = load i32, i32* %748
%750 = icmp sgt i32 %733, %749
br i1 %750, label %751, label %753
751: ; preds = %732
%752 = load i32, i32* %9
br label %770
753: ; preds = %732
%754 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%755 = load i32, i32* %3
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %754, i64 %756
%758 = load i32, i32* %4
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %757, i64 0, i64 %759
%761 = load i32, i32* %5
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %760, i64 0, i64 %762
%764 = load i32, i32* %6
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %763, i64 0, i64 %765
%767 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %766, i64 0, i64 0
%768 = getelementptr inbounds [5 x i32], [5 x i32]* %767, i64 0, i64 0
%769 = load i32, i32* %768
br label %770
770: ; preds = %753, %751
%771 = phi i32 [ %752, %751 ], [ %769, %753 ]
store i32 %771, i32* %9
%772 = load i32, i32* %10
%773 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%774 = load i32, i32* %3
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %773, i64 %775
%777 = load i32, i32* %4
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %776, i64 0, i64 %778
%780 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %779, i64 0, i64 0
%781 = load i32, i32* %5
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %780, i64 0, i64 %782
%784 = load i32, i32* %6
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %783, i64 0, i64 %785
%787 = getelementptr inbounds [5 x i32], [5 x i32]* %786, i64 0, i64 0
%788 = load i32, i32* %787
%789 = icmp sgt i32 %772, %788
br i1 %789, label %790, label %792
790: ; preds = %770
%791 = load i32, i32* %10
br label %809
792: ; preds = %770
%793 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%794 = load i32, i32* %3
%795 = sext i32 %794 to i64
%796 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %793, i64 %795
%797 = load i32, i32* %4
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %796, i64 0, i64 %798
%800 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %799, i64 0, i64 0
%801 = load i32, i32* %5
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %800, i64 0, i64 %802
%804 = load i32, i32* %6
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %803, i64 0, i64 %805
%807 = getelementptr inbounds [5 x i32], [5 x i32]* %806, i64 0, i64 0
%808 = load i32, i32* %807
br label %809
809: ; preds = %792, %790
%810 = phi i32 [ %791, %790 ], [ %808, %792 ]
store i32 %810, i32* %10
%811 = load i32, i32* %11
%812 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%813 = load i32, i32* %3
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %812, i64 %814
%816 = load i32, i32* %4
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %815, i64 0, i64 %817
%819 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %818, i64 0, i64 0
%820 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %819, i64 0, i64 0
%821 = load i32, i32* %5
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %820, i64 0, i64 %822
%824 = load i32, i32* %6
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds [5 x i32], [5 x i32]* %823, i64 0, i64 %825
%827 = load i32, i32* %826
%828 = icmp sgt i32 %811, %827
br i1 %828, label %829, label %831
829: ; preds = %809
%830 = load i32, i32* %11
br label %848
831: ; preds = %809
%832 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%833 = load i32, i32* %3
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %832, i64 %834
%836 = load i32, i32* %4
%837 = sext i32 %836 to i64
%838 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %835, i64 0, i64 %837
%839 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %838, i64 0, i64 0
%840 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %839, i64 0, i64 0
%841 = load i32, i32* %5
%842 = sext i32 %841 to i64
%843 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %840, i64 0, i64 %842
%844 = load i32, i32* %6
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds [5 x i32], [5 x i32]* %843, i64 0, i64 %845
%847 = load i32, i32* %846
br label %848
848: ; preds = %831, %829
%849 = phi i32 [ %830, %829 ], [ %847, %831 ]
store i32 %849, i32* %11
%850 = load i32, i32* %12
%851 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%852 = load i32, i32* %3
%853 = sext i32 %852 to i64
%854 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %851, i64 %853
%855 = load i32, i32* %4
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %854, i64 0, i64 %856
%858 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %857, i64 0, i64 0
%859 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %858, i64 0, i64 0
%860 = load i32, i32* %6
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %859, i64 0, i64 %861
%863 = load i32, i32* %5
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds [5 x i32], [5 x i32]* %862, i64 0, i64 %864
%866 = load i32, i32* %865
%867 = icmp sgt i32 %850, %866
br i1 %867, label %868, label %870
868: ; preds = %848
%869 = load i32, i32* %12
br label %887
870: ; preds = %848
%871 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%872 = load i32, i32* %3
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %871, i64 %873
%875 = load i32, i32* %4
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %874, i64 0, i64 %876
%878 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %877, i64 0, i64 0
%879 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %878, i64 0, i64 0
%880 = load i32, i32* %6
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %879, i64 0, i64 %881
%883 = load i32, i32* %5
%884 = sext i32 %883 to i64
%885 = getelementptr inbounds [5 x i32], [5 x i32]* %882, i64 0, i64 %884
%886 = load i32, i32* %885
br label %887
887: ; preds = %870, %868
%888 = phi i32 [ %869, %868 ], [ %886, %870 ]
store i32 %888, i32* %12
br label %889
889: ; preds = %887
%890 = load i32, i32* %6
%891 = add nsw i32 %890, 1
store i32 %891, i32* %6
br label %729
892: ; preds = %729
%893 = load i32, i32* %9
%894 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%895 = load i32, i32* %3
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %894, i64 %896
%898 = load i32, i32* %4
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %897, i64 0, i64 %899
%901 = load i32, i32* %5
%902 = sext i32 %901 to i64
%903 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %900, i64 0, i64 %902
%904 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %903, i64 0, i64 0
%905 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %904, i64 0, i64 0
%906 = getelementptr inbounds [5 x i32], [5 x i32]* %905, i64 0, i64 0
store i32 %893, i32* %906
%907 = load i32, i32* %10
%908 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%909 = load i32, i32* %3
%910 = sext i32 %909 to i64
%911 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %908, i64 %910
%912 = load i32, i32* %4
%913 = sext i32 %912 to i64
%914 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %911, i64 0, i64 %913
%915 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %914, i64 0, i64 0
%916 = load i32, i32* %5
%917 = sext i32 %916 to i64
%918 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %915, i64 0, i64 %917
%919 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %918, i64 0, i64 0
%920 = getelementptr inbounds [5 x i32], [5 x i32]* %919, i64 0, i64 0
store i32 %907, i32* %920
%921 = load i32, i32* %11
%922 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%923 = load i32, i32* %3
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %922, i64 %924
%926 = load i32, i32* %4
%927 = sext i32 %926 to i64
%928 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %925, i64 0, i64 %927
%929 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %928, i64 0, i64 0
%930 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %929, i64 0, i64 0
%931 = load i32, i32* %5
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %930, i64 0, i64 %932
%934 = getelementptr inbounds [5 x i32], [5 x i32]* %933, i64 0, i64 0
store i32 %921, i32* %934
%935 = load i32, i32* %12
%936 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%937 = load i32, i32* %3
%938 = sext i32 %937 to i64
%939 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %936, i64 %938
%940 = load i32, i32* %4
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %939, i64 0, i64 %941
%943 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %942, i64 0, i64 0
%944 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %943, i64 0, i64 0
%945 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %944, i64 0, i64 0
%946 = load i32, i32* %5
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds [5 x i32], [5 x i32]* %945, i64 0, i64 %947
store i32 %935, i32* %948
br label %949
949: ; preds = %892
%950 = load i32, i32* %5
%951 = add nsw i32 %950, 1
store i32 %951, i32* %5
br label %725
952: ; preds = %725
br label %953
953: ; preds = %952
%954 = load i32, i32* %4
%955 = add nsw i32 %954, 1
store i32 %955, i32* %4
br label %721
956: ; preds = %721
br label %957
957: ; preds = %956
%958 = load i32, i32* %3
%959 = add nsw i32 %958, 1
store i32 %959, i32* %3
br label %717
960: ; preds = %717
store i32 1, i32* %3
br label %961
961: ; preds = %1028, %960
%962 = load i32, i32* %3
%963 = icmp slt i32 %962, 7
br i1 %963, label %964, label %1031
964: ; preds = %961
store i32 1, i32* %4
br label %965
965: ; preds = %1024, %964
%966 = load i32, i32* %4
%967 = icmp slt i32 %966, 7
br i1 %967, label %968, label %1027
968: ; preds = %965
store i32 -10000000, i32* %9
store i32 1, i32* %5
br label %969
969: ; preds = %1008, %968
%970 = load i32, i32* %5
%971 = icmp slt i32 %970, 5
br i1 %971, label %972, label %1011
972: ; preds = %969
%973 = load i32, i32* %9
%974 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%975 = load i32, i32* %3
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %974, i64 %976
%978 = load i32, i32* %4
%979 = sext i32 %978 to i64
%980 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %977, i64 0, i64 %979
%981 = load i32, i32* %5
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %980, i64 0, i64 %982
%984 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %983, i64 0, i64 0
%985 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %984, i64 0, i64 0
%986 = getelementptr inbounds [5 x i32], [5 x i32]* %985, i64 0, i64 0
%987 = load i32, i32* %986
%988 = icmp sgt i32 %973, %987
br i1 %988, label %989, label %991
989: ; preds = %972
%990 = load i32, i32* %9
br label %1006
991: ; preds = %972
%992 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%993 = load i32, i32* %3
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %992, i64 %994
%996 = load i32, i32* %4
%997 = sext i32 %996 to i64
%998 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %995, i64 0, i64 %997
%999 = load i32, i32* %5
%1000 = sext i32 %999 to i64
%1001 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %998, i64 0, i64 %1000
%1002 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1001, i64 0, i64 0
%1003 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1002, i64 0, i64 0
%1004 = getelementptr inbounds [5 x i32], [5 x i32]* %1003, i64 0, i64 0
%1005 = load i32, i32* %1004
br label %1006
1006: ; preds = %991, %989
%1007 = phi i32 [ %990, %989 ], [ %1005, %991 ]
store i32 %1007, i32* %9
br label %1008
1008: ; preds = %1006
%1009 = load i32, i32* %5
%1010 = add nsw i32 %1009, 1
store i32 %1010, i32* %5
br label %969
1011: ; preds = %969
%1012 = load i32, i32* %9
%1013 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1014 = load i32, i32* %3
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1013, i64 %1015
%1017 = load i32, i32* %4
%1018 = sext i32 %1017 to i64
%1019 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1016, i64 0, i64 %1018
%1020 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1019, i64 0, i64 0
%1021 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1020, i64 0, i64 0
%1022 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1021, i64 0, i64 0
%1023 = getelementptr inbounds [5 x i32], [5 x i32]* %1022, i64 0, i64 0
store i32 %1012, i32* %1023
br label %1024
1024: ; preds = %1011
%1025 = load i32, i32* %4
%1026 = add nsw i32 %1025, 1
store i32 %1026, i32* %4
br label %965
1027: ; preds = %965
br label %1028
1028: ; preds = %1027
%1029 = load i32, i32* %3
%1030 = add nsw i32 %1029, 1
store i32 %1030, i32* %3
br label %961
1031: ; preds = %961
store i32 1, i32* %3
br label %1032
1032: ; preds = %1206, %1031
%1033 = load i32, i32* %3
%1034 = icmp slt i32 %1033, 7
br i1 %1034, label %1035, label %1209
1035: ; preds = %1032
store i32 0, i32* %5
br label %1036
1036: ; preds = %1202, %1035
%1037 = load i32, i32* %5
%1038 = icmp slt i32 %1037, 5
br i1 %1038, label %1039, label %1205
1039: ; preds = %1036
store i32 0, i32* %6
br label %1040
1040: ; preds = %1198, %1039
%1041 = load i32, i32* %6
%1042 = icmp slt i32 %1041, 5
br i1 %1042, label %1043, label %1201
1043: ; preds = %1040
store i32 0, i32* %7
br label %1044
1044: ; preds = %1194, %1043
%1045 = load i32, i32* %7
%1046 = icmp slt i32 %1045, 5
br i1 %1046, label %1047, label %1197
1047: ; preds = %1044
store i32 0, i32* %8
br label %1048
1048: ; preds = %1190, %1047
%1049 = load i32, i32* %8
%1050 = icmp slt i32 %1049, 5
br i1 %1050, label %1051, label %1193
1051: ; preds = %1048
store i32 -10000000, i32* %10
store i32 -10000000, i32* %9
store i32 1, i32* %4
br label %1052
1052: ; preds = %1150, %1051
%1053 = load i32, i32* %4
%1054 = icmp slt i32 %1053, 7
br i1 %1054, label %1055, label %1153
1055: ; preds = %1052
%1056 = load i32, i32* %9
%1057 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1058 = load i32, i32* %3
%1059 = sext i32 %1058 to i64
%1060 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1057, i64 %1059
%1061 = load i32, i32* %4
%1062 = sext i32 %1061 to i64
%1063 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1060, i64 0, i64 %1062
%1064 = load i32, i32* %5
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1063, i64 0, i64 %1065
%1067 = load i32, i32* %6
%1068 = sext i32 %1067 to i64
%1069 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1066, i64 0, i64 %1068
%1070 = load i32, i32* %7
%1071 = sext i32 %1070 to i64
%1072 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1069, i64 0, i64 %1071
%1073 = load i32, i32* %8
%1074 = sext i32 %1073 to i64
%1075 = getelementptr inbounds [5 x i32], [5 x i32]* %1072, i64 0, i64 %1074
%1076 = load i32, i32* %1075
%1077 = icmp sgt i32 %1056, %1076
br i1 %1077, label %1078, label %1080
1078: ; preds = %1055
%1079 = load i32, i32* %9
br label %1101
1080: ; preds = %1055
%1081 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1082 = load i32, i32* %3
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1081, i64 %1083
%1085 = load i32, i32* %4
%1086 = sext i32 %1085 to i64
%1087 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1084, i64 0, i64 %1086
%1088 = load i32, i32* %5
%1089 = sext i32 %1088 to i64
%1090 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1087, i64 0, i64 %1089
%1091 = load i32, i32* %6
%1092 = sext i32 %1091 to i64
%1093 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1090, i64 0, i64 %1092
%1094 = load i32, i32* %7
%1095 = sext i32 %1094 to i64
%1096 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1093, i64 0, i64 %1095
%1097 = load i32, i32* %8
%1098 = sext i32 %1097 to i64
%1099 = getelementptr inbounds [5 x i32], [5 x i32]* %1096, i64 0, i64 %1098
%1100 = load i32, i32* %1099
br label %1101
1101: ; preds = %1080, %1078
%1102 = phi i32 [ %1079, %1078 ], [ %1100, %1080 ]
store i32 %1102, i32* %9
%1103 = load i32, i32* %10
%1104 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1105 = load i32, i32* %4
%1106 = sext i32 %1105 to i64
%1107 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1104, i64 %1106
%1108 = load i32, i32* %3
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1107, i64 0, i64 %1109
%1111 = load i32, i32* %5
%1112 = sext i32 %1111 to i64
%1113 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1110, i64 0, i64 %1112
%1114 = load i32, i32* %6
%1115 = sext i32 %1114 to i64
%1116 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1113, i64 0, i64 %1115
%1117 = load i32, i32* %7
%1118 = sext i32 %1117 to i64
%1119 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1116, i64 0, i64 %1118
%1120 = load i32, i32* %8
%1121 = sext i32 %1120 to i64
%1122 = getelementptr inbounds [5 x i32], [5 x i32]* %1119, i64 0, i64 %1121
%1123 = load i32, i32* %1122
%1124 = icmp sgt i32 %1103, %1123
br i1 %1124, label %1125, label %1127
1125: ; preds = %1101
%1126 = load i32, i32* %10
br label %1148
1127: ; preds = %1101
%1128 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1129 = load i32, i32* %4
%1130 = sext i32 %1129 to i64
%1131 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1128, i64 %1130
%1132 = load i32, i32* %3
%1133 = sext i32 %1132 to i64
%1134 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1131, i64 0, i64 %1133
%1135 = load i32, i32* %5
%1136 = sext i32 %1135 to i64
%1137 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1134, i64 0, i64 %1136
%1138 = load i32, i32* %6
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1137, i64 0, i64 %1139
%1141 = load i32, i32* %7
%1142 = sext i32 %1141 to i64
%1143 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1140, i64 0, i64 %1142
%1144 = load i32, i32* %8
%1145 = sext i32 %1144 to i64
%1146 = getelementptr inbounds [5 x i32], [5 x i32]* %1143, i64 0, i64 %1145
%1147 = load i32, i32* %1146
br label %1148
1148: ; preds = %1127, %1125
%1149 = phi i32 [ %1126, %1125 ], [ %1147, %1127 ]
store i32 %1149, i32* %10
br label %1150
1150: ; preds = %1148
%1151 = load i32, i32* %4
%1152 = add nsw i32 %1151, 1
store i32 %1152, i32* %4
br label %1052
1153: ; preds = %1052
%1154 = load i32, i32* %9
%1155 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1156 = load i32, i32* %3
%1157 = sext i32 %1156 to i64
%1158 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1155, i64 %1157
%1159 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1158, i64 0, i64 7
%1160 = load i32, i32* %5
%1161 = sext i32 %1160 to i64
%1162 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1159, i64 0, i64 %1161
%1163 = load i32, i32* %6
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1162, i64 0, i64 %1164
%1166 = load i32, i32* %7
%1167 = sext i32 %1166 to i64
%1168 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1165, i64 0, i64 %1167
%1169 = load i32, i32* %8
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds [5 x i32], [5 x i32]* %1168, i64 0, i64 %1170
store i32 %1154, i32* %1171
%1172 = load i32, i32* %10
%1173 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1174 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1173, i64 7
%1175 = load i32, i32* %3
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1174, i64 0, i64 %1176
%1178 = load i32, i32* %5
%1179 = sext i32 %1178 to i64
%1180 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1177, i64 0, i64 %1179
%1181 = load i32, i32* %6
%1182 = sext i32 %1181 to i64
%1183 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1180, i64 0, i64 %1182
%1184 = load i32, i32* %7
%1185 = sext i32 %1184 to i64
%1186 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1183, i64 0, i64 %1185
%1187 = load i32, i32* %8
%1188 = sext i32 %1187 to i64
%1189 = getelementptr inbounds [5 x i32], [5 x i32]* %1186, i64 0, i64 %1188
store i32 %1172, i32* %1189
br label %1190
1190: ; preds = %1153
%1191 = load i32, i32* %8
%1192 = add nsw i32 %1191, 1
store i32 %1192, i32* %8
br label %1048
1193: ; preds = %1048
br label %1194
1194: ; preds = %1193
%1195 = load i32, i32* %7
%1196 = add nsw i32 %1195, 1
store i32 %1196, i32* %7
br label %1044
1197: ; preds = %1044
br label %1198
1198: ; preds = %1197
%1199 = load i32, i32* %6
%1200 = add nsw i32 %1199, 1
store i32 %1200, i32* %6
br label %1040
1201: ; preds = %1040
br label %1202
1202: ; preds = %1201
%1203 = load i32, i32* %5
%1204 = add nsw i32 %1203, 1
store i32 %1204, i32* %5
br label %1036
1205: ; preds = %1036
br label %1206
1206: ; preds = %1205
%1207 = load i32, i32* %3
%1208 = add nsw i32 %1207, 1
store i32 %1208, i32* %3
br label %1032
1209: ; preds = %1032
store i32 0, i32* %5
br label %1210
1210: ; preds = %1305, %1209
%1211 = load i32, i32* %5
%1212 = icmp slt i32 %1211, 5
br i1 %1212, label %1213, label %1308
1213: ; preds = %1210
store i32 0, i32* %6
br label %1214
1214: ; preds = %1301, %1213
%1215 = load i32, i32* %6
%1216 = icmp slt i32 %1215, 5
br i1 %1216, label %1217, label %1304
1217: ; preds = %1214
store i32 0, i32* %7
br label %1218
1218: ; preds = %1297, %1217
%1219 = load i32, i32* %7
%1220 = icmp slt i32 %1219, 5
br i1 %1220, label %1221, label %1300
1221: ; preds = %1218
store i32 0, i32* %8
br label %1222
1222: ; preds = %1293, %1221
%1223 = load i32, i32* %8
%1224 = icmp slt i32 %1223, 5
br i1 %1224, label %1225, label %1296
1225: ; preds = %1222
store i32 -10000000, i32* %9
store i32 1, i32* %4
br label %1226
1226: ; preds = %1273, %1225
%1227 = load i32, i32* %4
%1228 = icmp slt i32 %1227, 7
br i1 %1228, label %1229, label %1276
1229: ; preds = %1226
%1230 = load i32, i32* %9
%1231 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1232 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1231, i64 7
%1233 = load i32, i32* %4
%1234 = sext i32 %1233 to i64
%1235 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1232, i64 0, i64 %1234
%1236 = load i32, i32* %5
%1237 = sext i32 %1236 to i64
%1238 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1235, i64 0, i64 %1237
%1239 = load i32, i32* %6
%1240 = sext i32 %1239 to i64
%1241 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1238, i64 0, i64 %1240
%1242 = load i32, i32* %7
%1243 = sext i32 %1242 to i64
%1244 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1241, i64 0, i64 %1243
%1245 = load i32, i32* %8
%1246 = sext i32 %1245 to i64
%1247 = getelementptr inbounds [5 x i32], [5 x i32]* %1244, i64 0, i64 %1246
%1248 = load i32, i32* %1247
%1249 = icmp sgt i32 %1230, %1248
br i1 %1249, label %1250, label %1252
1250: ; preds = %1229
%1251 = load i32, i32* %9
br label %1271
1252: ; preds = %1229
%1253 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1254 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1253, i64 7
%1255 = load i32, i32* %4
%1256 = sext i32 %1255 to i64
%1257 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1254, i64 0, i64 %1256
%1258 = load i32, i32* %5
%1259 = sext i32 %1258 to i64
%1260 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1257, i64 0, i64 %1259
%1261 = load i32, i32* %6
%1262 = sext i32 %1261 to i64
%1263 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1260, i64 0, i64 %1262
%1264 = load i32, i32* %7
%1265 = sext i32 %1264 to i64
%1266 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1263, i64 0, i64 %1265
%1267 = load i32, i32* %8
%1268 = sext i32 %1267 to i64
%1269 = getelementptr inbounds [5 x i32], [5 x i32]* %1266, i64 0, i64 %1268
%1270 = load i32, i32* %1269
br label %1271
1271: ; preds = %1252, %1250
%1272 = phi i32 [ %1251, %1250 ], [ %1270, %1252 ]
store i32 %1272, i32* %9
br label %1273
1273: ; preds = %1271
%1274 = load i32, i32* %4
%1275 = add nsw i32 %1274, 1
store i32 %1275, i32* %4
br label %1226
1276: ; preds = %1226
%1277 = load i32, i32* %9
%1278 = load [8 x [5 x [5 x [5 x [5 x i32]]]]]*, [8 x [5 x [5 x [5 x [5 x i32]]]]]** %2
%1279 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1278, i64 7
%1280 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %1279, i64 0, i64 7
%1281 = load i32, i32* %5
%1282 = sext i32 %1281 to i64
%1283 = getelementptr inbounds [5 x [5 x [5 x [5 x i32]]]], [5 x [5 x [5 x [5 x i32]]]]* %1280, i64 0, i64 %1282
%1284 = load i32, i32* %6
%1285 = sext i32 %1284 to i64
%1286 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %1283, i64 0, i64 %1285
%1287 = load i32, i32* %7
%1288 = sext i32 %1287 to i64
%1289 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %1286, i64 0, i64 %1288
%1290 = load i32, i32* %8
%1291 = sext i32 %1290 to i64
%1292 = getelementptr inbounds [5 x i32], [5 x i32]* %1289, i64 0, i64 %1291
store i32 %1277, i32* %1292
br label %1293
1293: ; preds = %1276
%1294 = load i32, i32* %8
%1295 = add nsw i32 %1294, 1
store i32 %1295, i32* %8
br label %1222
1296: ; preds = %1222
br label %1297
1297: ; preds = %1296
%1298 = load i32, i32* %7
%1299 = add nsw i32 %1298, 1
store i32 %1299, i32* %7
br label %1218
1300: ; preds = %1218
br label %1301
1301: ; preds = %1300
%1302 = load i32, i32* %6
%1303 = add nsw i32 %1302, 1
store i32 %1303, i32* %6
br label %1214
1304: ; preds = %1214
br label %1305
1305: ; preds = %1304
%1306 = load i32, i32* %5
%1307 = add nsw i32 %1306, 1
store i32 %1307, i32* %5
br label %1210
1308: ; preds = %1210
ret void
}

LLVM IR (-O2):
define void @update_nst([8 x [5 x [5 x [5 x [5 x i32]]]]]* %0) {
br label %2
2: ; preds = %1, %91
%3 = phi i64 [ 1, %1 ], [ %92, %91 ]
br label %4
4: ; preds = %2, %88
%5 = phi i64 [ 1, %2 ], [ %89, %88 ]
br label %6
6: ; preds = %4, %85
%7 = phi i64 [ 1, %4 ], [ %86, %85 ]
br label %8
8: ; preds = %6, %82
%9 = phi i64 [ 1, %6 ], [ %83, %82 ]
br label %10
10: ; preds = %8, %10
%11 = phi i64 [ 1, %8 ], [ %80, %10 ]
%12 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 %11, i64 1
%13 = load i32, i32* %12
%14 = icmp sgt i32 %13, -10000000
%15 = select i1 %14, i32 %13, i32 -10000000
%16 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 1, i64 %11
%17 = load i32, i32* %16
%18 = icmp sgt i32 %17, -10000000
%19 = select i1 %18, i32 %17, i32 -10000000
%20 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 1, i64 %9, i64 %11
%21 = load i32, i32* %20
%22 = icmp sgt i32 %21, -10000000
%23 = select i1 %22, i32 %21, i32 -10000000
%24 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 1, i64 %7, i64 %9, i64 %11
%25 = load i32, i32* %24
%26 = icmp sgt i32 %25, -10000000
%27 = select i1 %26, i32 %25, i32 -10000000
%28 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 %11, i64 2
%29 = load i32, i32* %28
%30 = icmp sgt i32 %15, %29
%31 = select i1 %30, i32 %15, i32 %29
%32 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 2, i64 %11
%33 = load i32, i32* %32
%34 = icmp sgt i32 %19, %33
%35 = select i1 %34, i32 %19, i32 %33
%36 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 2, i64 %9, i64 %11
%37 = load i32, i32* %36
%38 = icmp sgt i32 %23, %37
%39 = select i1 %38, i32 %23, i32 %37
%40 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 2, i64 %7, i64 %9, i64 %11
%41 = load i32, i32* %40
%42 = icmp sgt i32 %27, %41
%43 = select i1 %42, i32 %27, i32 %41
%44 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 %11, i64 3
%45 = load i32, i32* %44
%46 = icmp sgt i32 %31, %45
%47 = select i1 %46, i32 %31, i32 %45
%48 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 3, i64 %11
%49 = load i32, i32* %48
%50 = icmp sgt i32 %35, %49
%51 = select i1 %50, i32 %35, i32 %49
%52 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 3, i64 %9, i64 %11
%53 = load i32, i32* %52
%54 = icmp sgt i32 %39, %53
%55 = select i1 %54, i32 %39, i32 %53
%56 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 3, i64 %7, i64 %9, i64 %11
%57 = load i32, i32* %56
%58 = icmp sgt i32 %43, %57
%59 = select i1 %58, i32 %43, i32 %57
%60 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 %11, i64 4
%61 = load i32, i32* %60
%62 = icmp sgt i32 %47, %61
%63 = select i1 %62, i32 %47, i32 %61
%64 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 4, i64 %11
%65 = load i32, i32* %64
%66 = icmp sgt i32 %51, %65
%67 = select i1 %66, i32 %51, i32 %65
%68 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 4, i64 %9, i64 %11
%69 = load i32, i32* %68
%70 = icmp sgt i32 %55, %69
%71 = select i1 %70, i32 %55, i32 %69
%72 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 4, i64 %7, i64 %9, i64 %11
%73 = load i32, i32* %72
%74 = icmp sgt i32 %59, %73
%75 = select i1 %74, i32 %59, i32 %73
%76 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 %11, i64 0
store i32 %63, i32* %76
%77 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 %9, i64 0, i64 %11
store i32 %67, i32* %77
%78 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 %7, i64 0, i64 %9, i64 %11
store i32 %71, i32* %78
%79 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %3, i64 %5, i64 0, i64 %7, i64 %9, i64 %11
store i32 %75, i32* %79
%80 = add nuw nsw i64 %11, 1
%81 = icmp eq i64 %80, 5
br i1 %81, label %82, label %10
82: ; preds = %10
%83 = add nuw nsw i64 %9, 1
%84 = icmp eq i64 %83, 5
br i1 %84, label %85, label %8
85: ; preds = %82
%86 = add nuw nsw i64 %7, 1
%87 = icmp eq i64 %86, 5
br i1 %87, label %88, label %6
88: ; preds = %85
%89 = add nuw nsw i64 %5, 1
%90 = icmp eq i64 %89, 7
br i1 %90, label %91, label %4
91: ; preds = %88
%92 = add nuw nsw i64 %3, 1
%93 = icmp eq i64 %92, 7
br i1 %93, label %94, label %2
94: ; preds = %91, %212
%95 = phi i64 [ %213, %212 ], [ 1, %91 ]
br label %96
96: ; preds = %94, %209
%97 = phi i64 [ 1, %94 ], [ %210, %209 ]
br label %98
98: ; preds = %96, %206
%99 = phi i64 [ 1, %96 ], [ %207, %206 ]
br label %100
100: ; preds = %98, %100
%101 = phi i64 [ 1, %98 ], [ %204, %100 ]
%102 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 %101, i64 1, i64 0
%103 = load i32, i32* %102
%104 = icmp sgt i32 %103, -10000000
%105 = select i1 %104, i32 %103, i32 -10000000
%106 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 1, i64 0, i64 %101
%107 = load i32, i32* %106
%108 = icmp sgt i32 %107, -10000000
%109 = select i1 %108, i32 %107, i32 -10000000
%110 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 1, i64 0, i64 %99, i64 %101
%111 = load i32, i32* %110
%112 = icmp sgt i32 %111, -10000000
%113 = select i1 %112, i32 %111, i32 -10000000
%114 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 %101, i64 1
%115 = load i32, i32* %114
%116 = icmp sgt i32 %115, -10000000
%117 = select i1 %116, i32 %115, i32 -10000000
%118 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 1, i64 %101
%119 = load i32, i32* %118
%120 = icmp sgt i32 %119, -10000000
%121 = select i1 %120, i32 %119, i32 -10000000
%122 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 0, i64 %101, i64 1
%123 = load i32, i32* %122
%124 = icmp sgt i32 %123, -10000000
%125 = select i1 %124, i32 %123, i32 -10000000
%126 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 %101, i64 2, i64 0
%127 = load i32, i32* %126
%128 = icmp sgt i32 %105, %127
%129 = select i1 %128, i32 %105, i32 %127
%130 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 2, i64 0, i64 %101
%131 = load i32, i32* %130
%132 = icmp sgt i32 %109, %131
%133 = select i1 %132, i32 %109, i32 %131
%134 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 2, i64 0, i64 %99, i64 %101
%135 = load i32, i32* %134
%136 = icmp sgt i32 %113, %135
%137 = select i1 %136, i32 %113, i32 %135
%138 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 %101, i64 2
%139 = load i32, i32* %138
%140 = icmp sgt i32 %117, %139
%141 = select i1 %140, i32 %117, i32 %139
%142 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 2, i64 %101
%143 = load i32, i32* %142
%144 = icmp sgt i32 %121, %143
%145 = select i1 %144, i32 %121, i32 %143
%146 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 0, i64 %101, i64 2
%147 = load i32, i32* %146
%148 = icmp sgt i32 %125, %147
%149 = select i1 %148, i32 %125, i32 %147
%150 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 %101, i64 3, i64 0
%151 = load i32, i32* %150
%152 = icmp sgt i32 %129, %151
%153 = select i1 %152, i32 %129, i32 %151
%154 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 3, i64 0, i64 %101
%155 = load i32, i32* %154
%156 = icmp sgt i32 %133, %155
%157 = select i1 %156, i32 %133, i32 %155
%158 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 3, i64 0, i64 %99, i64 %101
%159 = load i32, i32* %158
%160 = icmp sgt i32 %137, %159
%161 = select i1 %160, i32 %137, i32 %159
%162 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 %101, i64 3
%163 = load i32, i32* %162
%164 = icmp sgt i32 %141, %163
%165 = select i1 %164, i32 %141, i32 %163
%166 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 3, i64 %101
%167 = load i32, i32* %166
%168 = icmp sgt i32 %145, %167
%169 = select i1 %168, i32 %145, i32 %167
%170 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 0, i64 %101, i64 3
%171 = load i32, i32* %170
%172 = icmp sgt i32 %149, %171
%173 = select i1 %172, i32 %149, i32 %171
%174 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 %101, i64 4, i64 0
%175 = load i32, i32* %174
%176 = icmp sgt i32 %153, %175
%177 = select i1 %176, i32 %153, i32 %175
%178 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 4, i64 0, i64 %101
%179 = load i32, i32* %178
%180 = icmp sgt i32 %157, %179
%181 = select i1 %180, i32 %157, i32 %179
%182 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 4, i64 0, i64 %99, i64 %101
%183 = load i32, i32* %182
%184 = icmp sgt i32 %161, %183
%185 = select i1 %184, i32 %161, i32 %183
%186 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 %101, i64 4
%187 = load i32, i32* %186
%188 = icmp sgt i32 %165, %187
%189 = select i1 %188, i32 %165, i32 %187
%190 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 4, i64 %101
%191 = load i32, i32* %190
%192 = icmp sgt i32 %169, %191
%193 = select i1 %192, i32 %169, i32 %191
%194 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 0, i64 %101, i64 4
%195 = load i32, i32* %194
%196 = icmp sgt i32 %173, %195
%197 = select i1 %196, i32 %173, i32 %195
%198 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 %101, i64 0, i64 0
store i32 %177, i32* %198
%199 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 0, i64 0, i64 %101
store i32 %181, i32* %199
%200 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 0, i64 %99, i64 %101
store i32 %185, i32* %200
%201 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 %99, i64 0, i64 %101, i64 0
store i32 %197, i32* %201
%202 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 0, i64 %101
store i32 %193, i32* %202
%203 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %95, i64 %97, i64 0, i64 %99, i64 %101, i64 0
store i32 %189, i32* %203
%204 = add nuw nsw i64 %101, 1
%205 = icmp eq i64 %204, 5
br i1 %205, label %206, label %100
206: ; preds = %100
%207 = add nuw nsw i64 %99, 1
%208 = icmp eq i64 %207, 5
br i1 %208, label %209, label %98
209: ; preds = %206
%210 = add nuw nsw i64 %97, 1
%211 = icmp eq i64 %210, 7
br i1 %211, label %212, label %96
212: ; preds = %209
%213 = add nuw nsw i64 %95, 1
%214 = icmp eq i64 %213, 7
br i1 %214, label %215, label %94
215: ; preds = %212, %294
%216 = phi i64 [ %295, %294 ], [ 1, %212 ]
br label %217
217: ; preds = %215, %291
%218 = phi i64 [ 1, %215 ], [ %292, %291 ]
br label %219
219: ; preds = %217, %219
%220 = phi i64 [ 1, %217 ], [ %289, %219 ]
%221 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 %220, i64 1, i64 0, i64 0
%222 = load i32, i32* %221
%223 = icmp sgt i32 %222, -10000000
%224 = select i1 %223, i32 %222, i32 -10000000
%225 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 %220, i64 1, i64 0
%226 = load i32, i32* %225
%227 = icmp sgt i32 %226, -10000000
%228 = select i1 %227, i32 %226, i32 -10000000
%229 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 %220, i64 1
%230 = load i32, i32* %229
%231 = icmp sgt i32 %230, -10000000
%232 = select i1 %231, i32 %230, i32 -10000000
%233 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 1, i64 %220
%234 = load i32, i32* %233
%235 = icmp sgt i32 %234, -10000000
%236 = select i1 %235, i32 %234, i32 -10000000
%237 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 %220, i64 2, i64 0, i64 0
%238 = load i32, i32* %237
%239 = icmp sgt i32 %224, %238
%240 = select i1 %239, i32 %224, i32 %238
%241 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 %220, i64 2, i64 0
%242 = load i32, i32* %241
%243 = icmp sgt i32 %228, %242
%244 = select i1 %243, i32 %228, i32 %242
%245 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 %220, i64 2
%246 = load i32, i32* %245
%247 = icmp sgt i32 %232, %246
%248 = select i1 %247, i32 %232, i32 %246
%249 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 2, i64 %220
%250 = load i32, i32* %249
%251 = icmp sgt i32 %236, %250
%252 = select i1 %251, i32 %236, i32 %250
%253 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 %220, i64 3, i64 0, i64 0
%254 = load i32, i32* %253
%255 = icmp sgt i32 %240, %254
%256 = select i1 %255, i32 %240, i32 %254
%257 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 %220, i64 3, i64 0
%258 = load i32, i32* %257
%259 = icmp sgt i32 %244, %258
%260 = select i1 %259, i32 %244, i32 %258
%261 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 %220, i64 3
%262 = load i32, i32* %261
%263 = icmp sgt i32 %248, %262
%264 = select i1 %263, i32 %248, i32 %262
%265 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 3, i64 %220
%266 = load i32, i32* %265
%267 = icmp sgt i32 %252, %266
%268 = select i1 %267, i32 %252, i32 %266
%269 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 %220, i64 4, i64 0, i64 0
%270 = load i32, i32* %269
%271 = icmp sgt i32 %256, %270
%272 = select i1 %271, i32 %256, i32 %270
%273 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 %220, i64 4, i64 0
%274 = load i32, i32* %273
%275 = icmp sgt i32 %260, %274
%276 = select i1 %275, i32 %260, i32 %274
%277 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 %220, i64 4
%278 = load i32, i32* %277
%279 = icmp sgt i32 %264, %278
%280 = select i1 %279, i32 %264, i32 %278
%281 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 4, i64 %220
%282 = load i32, i32* %281
%283 = icmp sgt i32 %268, %282
%284 = select i1 %283, i32 %268, i32 %282
%285 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 %220, i64 0, i64 0, i64 0
store i32 %272, i32* %285
%286 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 %220, i64 0, i64 0
store i32 %276, i32* %286
%287 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 %220, i64 0
store i32 %280, i32* %287
%288 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %216, i64 %218, i64 0, i64 0, i64 0, i64 %220
store i32 %284, i32* %288
%289 = add nuw nsw i64 %220, 1
%290 = icmp eq i64 %289, 5
br i1 %290, label %291, label %219
291: ; preds = %219
%292 = add nuw nsw i64 %218, 1
%293 = icmp eq i64 %292, 7
br i1 %293, label %294, label %217
294: ; preds = %291
%295 = add nuw nsw i64 %216, 1
%296 = icmp eq i64 %295, 7
br i1 %296, label %297, label %215
297: ; preds = %294, %297
%298 = phi i64 [ %401, %297 ], [ 1, %294 ]
%299 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 1, i64 1, i64 0, i64 0, i64 0
%300 = load i32, i32* %299
%301 = icmp sgt i32 %300, -10000000
%302 = select i1 %301, i32 %300, i32 -10000000
%303 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 1, i64 2, i64 0, i64 0, i64 0
%304 = load i32, i32* %303
%305 = icmp sgt i32 %302, %304
%306 = select i1 %305, i32 %302, i32 %304
%307 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 1, i64 3, i64 0, i64 0, i64 0
%308 = load i32, i32* %307
%309 = icmp sgt i32 %306, %308
%310 = select i1 %309, i32 %306, i32 %308
%311 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 1, i64 4, i64 0, i64 0, i64 0
%312 = load i32, i32* %311
%313 = icmp sgt i32 %310, %312
%314 = select i1 %313, i32 %310, i32 %312
%315 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 1, i64 0, i64 0, i64 0, i64 0
store i32 %314, i32* %315
%316 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 2, i64 1, i64 0, i64 0, i64 0
%317 = load i32, i32* %316
%318 = icmp sgt i32 %317, -10000000
%319 = select i1 %318, i32 %317, i32 -10000000
%320 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 2, i64 2, i64 0, i64 0, i64 0
%321 = load i32, i32* %320
%322 = icmp sgt i32 %319, %321
%323 = select i1 %322, i32 %319, i32 %321
%324 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 2, i64 3, i64 0, i64 0, i64 0
%325 = load i32, i32* %324
%326 = icmp sgt i32 %323, %325
%327 = select i1 %326, i32 %323, i32 %325
%328 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 2, i64 4, i64 0, i64 0, i64 0
%329 = load i32, i32* %328
%330 = icmp sgt i32 %327, %329
%331 = select i1 %330, i32 %327, i32 %329
%332 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 2, i64 0, i64 0, i64 0, i64 0
store i32 %331, i32* %332
%333 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 3, i64 1, i64 0, i64 0, i64 0
%334 = load i32, i32* %333
%335 = icmp sgt i32 %334, -10000000
%336 = select i1 %335, i32 %334, i32 -10000000
%337 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 3, i64 2, i64 0, i64 0, i64 0
%338 = load i32, i32* %337
%339 = icmp sgt i32 %336, %338
%340 = select i1 %339, i32 %336, i32 %338
%341 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 3, i64 3, i64 0, i64 0, i64 0
%342 = load i32, i32* %341
%343 = icmp sgt i32 %340, %342
%344 = select i1 %343, i32 %340, i32 %342
%345 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 3, i64 4, i64 0, i64 0, i64 0
%346 = load i32, i32* %345
%347 = icmp sgt i32 %344, %346
%348 = select i1 %347, i32 %344, i32 %346
%349 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 3, i64 0, i64 0, i64 0, i64 0
store i32 %348, i32* %349
%350 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 4, i64 1, i64 0, i64 0, i64 0
%351 = load i32, i32* %350
%352 = icmp sgt i32 %351, -10000000
%353 = select i1 %352, i32 %351, i32 -10000000
%354 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 4, i64 2, i64 0, i64 0, i64 0
%355 = load i32, i32* %354
%356 = icmp sgt i32 %353, %355
%357 = select i1 %356, i32 %353, i32 %355
%358 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 4, i64 3, i64 0, i64 0, i64 0
%359 = load i32, i32* %358
%360 = icmp sgt i32 %357, %359
%361 = select i1 %360, i32 %357, i32 %359
%362 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 4, i64 4, i64 0, i64 0, i64 0
%363 = load i32, i32* %362
%364 = icmp sgt i32 %361, %363
%365 = select i1 %364, i32 %361, i32 %363
%366 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 4, i64 0, i64 0, i64 0, i64 0
store i32 %365, i32* %366
%367 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 5, i64 1, i64 0, i64 0, i64 0
%368 = load i32, i32* %367
%369 = icmp sgt i32 %368, -10000000
%370 = select i1 %369, i32 %368, i32 -10000000
%371 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 5, i64 2, i64 0, i64 0, i64 0
%372 = load i32, i32* %371
%373 = icmp sgt i32 %370, %372
%374 = select i1 %373, i32 %370, i32 %372
%375 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 5, i64 3, i64 0, i64 0, i64 0
%376 = load i32, i32* %375
%377 = icmp sgt i32 %374, %376
%378 = select i1 %377, i32 %374, i32 %376
%379 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 5, i64 4, i64 0, i64 0, i64 0
%380 = load i32, i32* %379
%381 = icmp sgt i32 %378, %380
%382 = select i1 %381, i32 %378, i32 %380
%383 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 5, i64 0, i64 0, i64 0, i64 0
store i32 %382, i32* %383
%384 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 6, i64 1, i64 0, i64 0, i64 0
%385 = load i32, i32* %384
%386 = icmp sgt i32 %385, -10000000
%387 = select i1 %386, i32 %385, i32 -10000000
%388 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 6, i64 2, i64 0, i64 0, i64 0
%389 = load i32, i32* %388
%390 = icmp sgt i32 %387, %389
%391 = select i1 %390, i32 %387, i32 %389
%392 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 6, i64 3, i64 0, i64 0, i64 0
%393 = load i32, i32* %392
%394 = icmp sgt i32 %391, %393
%395 = select i1 %394, i32 %391, i32 %393
%396 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 6, i64 4, i64 0, i64 0, i64 0
%397 = load i32, i32* %396
%398 = icmp sgt i32 %395, %397
%399 = select i1 %398, i32 %395, i32 %397
%400 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %298, i64 6, i64 0, i64 0, i64 0, i64 0
store i32 %399, i32* %400
%401 = add nuw nsw i64 %298, 1
%402 = icmp eq i64 %401, 7
br i1 %402, label %403, label %297
403: ; preds = %297, %474
%404 = phi i64 [ %475, %474 ], [ 1, %297 ]
br label %405
405: ; preds = %403, %471
%406 = phi i64 [ 0, %403 ], [ %472, %471 ]
br label %407
407: ; preds = %405, %468
%408 = phi i64 [ 0, %405 ], [ %469, %468 ]
br label %409
409: ; preds = %407, %465
%410 = phi i64 [ 0, %407 ], [ %466, %465 ]
br label %411
411: ; preds = %409, %411
%412 = phi i64 [ 0, %409 ], [ %463, %411 ]
%413 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %404, i64 1, i64 %406, i64 %408, i64 %410, i64 %412
%414 = load i32, i32* %413
%415 = icmp sgt i32 %414, -10000000
%416 = select i1 %415, i32 %414, i32 -10000000
%417 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 1, i64 %404, i64 %406, i64 %408, i64 %410, i64 %412
%418 = load i32, i32* %417
%419 = icmp sgt i32 %418, -10000000
%420 = select i1 %419, i32 %418, i32 -10000000
%421 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %404, i64 2, i64 %406, i64 %408, i64 %410, i64 %412
%422 = load i32, i32* %421
%423 = icmp sgt i32 %416, %422
%424 = select i1 %423, i32 %416, i32 %422
%425 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 2, i64 %404, i64 %406, i64 %408, i64 %410, i64 %412
%426 = load i32, i32* %425
%427 = icmp sgt i32 %420, %426
%428 = select i1 %427, i32 %420, i32 %426
%429 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %404, i64 3, i64 %406, i64 %408, i64 %410, i64 %412
%430 = load i32, i32* %429
%431 = icmp sgt i32 %424, %430
%432 = select i1 %431, i32 %424, i32 %430
%433 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 3, i64 %404, i64 %406, i64 %408, i64 %410, i64 %412
%434 = load i32, i32* %433
%435 = icmp sgt i32 %428, %434
%436 = select i1 %435, i32 %428, i32 %434
%437 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %404, i64 4, i64 %406, i64 %408, i64 %410, i64 %412
%438 = load i32, i32* %437
%439 = icmp sgt i32 %432, %438
%440 = select i1 %439, i32 %432, i32 %438
%441 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 4, i64 %404, i64 %406, i64 %408, i64 %410, i64 %412
%442 = load i32, i32* %441
%443 = icmp sgt i32 %436, %442
%444 = select i1 %443, i32 %436, i32 %442
%445 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %404, i64 5, i64 %406, i64 %408, i64 %410, i64 %412
%446 = load i32, i32* %445
%447 = icmp sgt i32 %440, %446
%448 = select i1 %447, i32 %440, i32 %446
%449 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 5, i64 %404, i64 %406, i64 %408, i64 %410, i64 %412
%450 = load i32, i32* %449
%451 = icmp sgt i32 %444, %450
%452 = select i1 %451, i32 %444, i32 %450
%453 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %404, i64 6, i64 %406, i64 %408, i64 %410, i64 %412
%454 = load i32, i32* %453
%455 = icmp sgt i32 %448, %454
%456 = select i1 %455, i32 %448, i32 %454
%457 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 6, i64 %404, i64 %406, i64 %408, i64 %410, i64 %412
%458 = load i32, i32* %457
%459 = icmp sgt i32 %452, %458
%460 = select i1 %459, i32 %452, i32 %458
%461 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 %404, i64 7, i64 %406, i64 %408, i64 %410, i64 %412
store i32 %456, i32* %461
%462 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 %404, i64 %406, i64 %408, i64 %410, i64 %412
store i32 %460, i32* %462
%463 = add nuw nsw i64 %412, 1
%464 = icmp eq i64 %463, 5
br i1 %464, label %465, label %411
465: ; preds = %411
%466 = add nuw nsw i64 %410, 1
%467 = icmp eq i64 %466, 5
br i1 %467, label %468, label %409
468: ; preds = %465
%469 = add nuw nsw i64 %408, 1
%470 = icmp eq i64 %469, 5
br i1 %470, label %471, label %407
471: ; preds = %468
%472 = add nuw nsw i64 %406, 1
%473 = icmp eq i64 %472, 5
br i1 %473, label %474, label %405
474: ; preds = %471
%475 = add nuw nsw i64 %404, 1
%476 = icmp eq i64 %475, 7
br i1 %476, label %477, label %403
477: ; preds = %474, %545
%478 = phi i64 [ %546, %545 ], [ 0, %474 ]
br label %479
479: ; preds = %477, %542
%480 = phi i64 [ 0, %477 ], [ %543, %542 ]
br label %481
481: ; preds = %479, %481
%482 = phi i64 [ 0, %479 ], [ %540, %481 ]
%483 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 1, i64 %478, i64 %480, i64 %482, i64 0
%484 = bitcast i32* %483 to <4 x i32>*
%485 = load <4 x i32>, <4 x i32>* %484
%486 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 2, i64 %478, i64 %480, i64 %482, i64 0
%487 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 3, i64 %478, i64 %480, i64 %482, i64 0
%488 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 4, i64 %478, i64 %480, i64 %482, i64 0
%489 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 5, i64 %478, i64 %480, i64 %482, i64 0
%490 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 6, i64 %478, i64 %480, i64 %482, i64 0
%491 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 7, i64 %478, i64 %480, i64 %482, i64 0
%492 = icmp sgt <4 x i32> %485, <i32 -10000000, i32 -10000000, i32 -10000000, i32 -10000000>
%493 = select <4 x i1> %492, <4 x i32> %485, <4 x i32> <i32 -10000000, i32 -10000000, i32 -10000000, i32 -10000000>
%494 = bitcast i32* %486 to <4 x i32>*
%495 = load <4 x i32>, <4 x i32>* %494
%496 = icmp sgt <4 x i32> %493, %495
%497 = select <4 x i1> %496, <4 x i32> %493, <4 x i32> %495
%498 = bitcast i32* %487 to <4 x i32>*
%499 = load <4 x i32>, <4 x i32>* %498
%500 = icmp sgt <4 x i32> %497, %499
%501 = select <4 x i1> %500, <4 x i32> %497, <4 x i32> %499
%502 = bitcast i32* %488 to <4 x i32>*
%503 = load <4 x i32>, <4 x i32>* %502
%504 = icmp sgt <4 x i32> %501, %503
%505 = select <4 x i1> %504, <4 x i32> %501, <4 x i32> %503
%506 = bitcast i32* %489 to <4 x i32>*
%507 = load <4 x i32>, <4 x i32>* %506
%508 = icmp sgt <4 x i32> %505, %507
%509 = select <4 x i1> %508, <4 x i32> %505, <4 x i32> %507
%510 = bitcast i32* %490 to <4 x i32>*
%511 = load <4 x i32>, <4 x i32>* %510
%512 = icmp sgt <4 x i32> %509, %511
%513 = select <4 x i1> %512, <4 x i32> %509, <4 x i32> %511
%514 = bitcast i32* %491 to <4 x i32>*
store <4 x i32> %513, <4 x i32>* %514
%515 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 1, i64 %478, i64 %480, i64 %482, i64 4
%516 = load i32, i32* %515
%517 = icmp sgt i32 %516, -10000000
%518 = select i1 %517, i32 %516, i32 -10000000
%519 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 2, i64 %478, i64 %480, i64 %482, i64 4
%520 = load i32, i32* %519
%521 = icmp sgt i32 %518, %520
%522 = select i1 %521, i32 %518, i32 %520
%523 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 3, i64 %478, i64 %480, i64 %482, i64 4
%524 = load i32, i32* %523
%525 = icmp sgt i32 %522, %524
%526 = select i1 %525, i32 %522, i32 %524
%527 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 4, i64 %478, i64 %480, i64 %482, i64 4
%528 = load i32, i32* %527
%529 = icmp sgt i32 %526, %528
%530 = select i1 %529, i32 %526, i32 %528
%531 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 5, i64 %478, i64 %480, i64 %482, i64 4
%532 = load i32, i32* %531
%533 = icmp sgt i32 %530, %532
%534 = select i1 %533, i32 %530, i32 %532
%535 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 6, i64 %478, i64 %480, i64 %482, i64 4
%536 = load i32, i32* %535
%537 = icmp sgt i32 %534, %536
%538 = select i1 %537, i32 %534, i32 %536
%539 = getelementptr inbounds [8 x [5 x [5 x [5 x [5 x i32]]]]], [8 x [5 x [5 x [5 x [5 x i32]]]]]* %0, i64 7, i64 7, i64 %478, i64 %480, i64 %482, i64 4
store i32 %538, i32* %539
%540 = add nuw nsw i64 %482, 1
%541 = icmp eq i64 %540, 5
br i1 %541, label %542, label %481
542: ; preds = %481
%543 = add nuw nsw i64 %480, 1
%544 = icmp eq i64 %543, 5
br i1 %544, label %545, label %479
545: ; preds = %542
%546 = add nuw nsw i64 %478, 1
%547 = icmp eq i64 %546, 5
br i1 %547, label %548, label %477
548: ; preds = %545
ret void
}