void aan_ecuacion_calor_metodo_explicito_canal(float *canal_input,
                                               float *canal_output, int width,
                                               int height, float dt) {
  int i, j, k, l;
  float **area;
  {
    int ml;
    area = (float **)malloc(sizeof(float *) * (3));
    area[0] = (float *)malloc(sizeof(float) * (3) * (3));
    for (ml = 0; ml < (3); ml++)
      area[ml] = &(area[0][ml * (3)]);
  };
  for (j = 0; j < height; j++) {
    for (i = 0; i < width; i++) {
      if (i == 0 && j == 0) {
        area[0][0] = canal_input[0];
        area[0][1] = canal_input[0];
        area[0][2] = canal_input[1];
        area[1][0] = canal_input[0];
        area[2][0] = canal_input[width];
        for (k = 1; k < 3; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1) && j == 0) {
        area[0][2] = canal_input[width - 1];
        area[0][1] = canal_input[width - 1];
        area[0][0] = canal_input[width - 2];
        area[1][2] = canal_input[width - 1];
        area[2][2] = canal_input[width * 2 - 1];
        for (k = 1; k < 3; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == 0 && j == (height - 1)) {
        area[0][2] = canal_input[width * (j - 1)];
        area[0][1] = canal_input[width * (j - 1)];
        area[1][2] = canal_input[width * (j - 1)];
        area[0][0] = canal_input[width * (j - 2)];
        area[2][2] = canal_input[(width * (j - 1)) + 1];
        for (k = 0; k < 2; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1) && j == (height - 1)) {
        area[2][2] = canal_input[width * height - 1];
        area[1][2] = canal_input[width * height - 1];
        area[0][2] = canal_input[width * (height - 1) - 1];
        area[2][1] = canal_input[width * height - 1];
        area[2][0] = canal_input[width * height - 2];
        for (k = 0; k < 2; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == 0) {
        area[0][0] = canal_input[(width * (j - 1 + k)) + i];
        area[1][0] = canal_input[(width * (j - 1 + k)) + i];
        area[2][0] = canal_input[(width * (j - 1 + k)) + i];
        for (k = 0; k < 3; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1)) {
        area[0][2] = canal_input[(width * (j - 1 + 0)) + i];
        area[1][2] = canal_input[(width * (j - 1 + 1)) + i];
        area[2][2] = canal_input[(width * (j - 1 + 2)) + i];
        for (k = 0; k < 3; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (j == 0) {
        area[0][0] = canal_input[(width * j) + (i - 1 + 0)];
        area[0][1] = canal_input[(width * j) + (i - 1 + 1)];
        area[0][2] = canal_input[(width * j) + (i - 1 + 2)];
        for (k = 1; k < 3; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (j == (height - 1)) {
        area[2][0] = canal_input[(width * j) + (i - 1 + 0)];
        area[2][1] = canal_input[(width * j) + (i - 1 + 1)];
        area[2][2] = canal_input[(width * j) + (i - 1 + 2)];
        for (k = 0; k < 2; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else {
        for (k = 0; k < 3; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[width * (j - 1 + k) + (i - 1 + l)];
      }
      canal_output[width * j + i] = area[1][1];
      for (k = 0; k < 3; k++) {
        for (l = 0; l < 3; l++) {
          if (l == 1 && k == 1)
            canal_output[width * j + i] = canal_output[width * j + i] +
                                          ((dt / 3.0) * (-8.0 * area[k][l]));
          else
            canal_output[width * j + i] =
                canal_output[width * j + i] + ((dt / 3.0) * area[k][l]);
        }
      }
    }
  }
  {
    free(area[0]);
    free(area);
  };
}


x86 assembly (clang, -O0):
<aan_ecuacion_calor_metodo_explicito_canal>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    $0x18,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    $0x24,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    119c <aan_ecuacion_calor_metodo_explicito_canal+0x7c>
mov    -0x38(%rbp),%rax
mov    (%rax),%rdx
imul   $0x3,-0x3c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1164 <aan_ecuacion_calor_metodo_explicito_canal+0x44>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d13 <aan_ecuacion_calor_metodo_explicito_canal+0xbf3>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d00 <aan_ecuacion_calor_metodo_explicito_canal+0xbe0>
cmpl   $0x0,-0x20(%rbp)
jne    12c2 <aan_ecuacion_calor_metodo_explicito_canal+0x1a2>
cmpl   $0x0,-0x24(%rbp)
jne    12c2 <aan_ecuacion_calor_metodo_explicito_canal+0x1a2>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    12bd <aan_ecuacion_calor_metodo_explicito_canal+0x19d>
movl   $0x1,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    12aa <aan_ecuacion_calor_metodo_explicito_canal+0x18a>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1257 <aan_ecuacion_calor_metodo_explicito_canal+0x137>
jmp    12af <aan_ecuacion_calor_metodo_explicito_canal+0x18f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1246 <aan_ecuacion_calor_metodo_explicito_canal+0x126>
jmp    1b89 <aan_ecuacion_calor_metodo_explicito_canal+0xa69>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    13fa <aan_ecuacion_calor_metodo_explicito_canal+0x2da>
cmpl   $0x0,-0x24(%rbp)
jne    13fa <aan_ecuacion_calor_metodo_explicito_canal+0x2da>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    13f5 <aan_ecuacion_calor_metodo_explicito_canal+0x2d5>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jge    13e2 <aan_ecuacion_calor_metodo_explicito_canal+0x2c2>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    138f <aan_ecuacion_calor_metodo_explicito_canal+0x26f>
jmp    13e7 <aan_ecuacion_calor_metodo_explicito_canal+0x2c7>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    137e <aan_ecuacion_calor_metodo_explicito_canal+0x25e>
jmp    1b84 <aan_ecuacion_calor_metodo_explicito_canal+0xa64>
cmpl   $0x0,-0x20(%rbp)
jne    1550 <aan_ecuacion_calor_metodo_explicito_canal+0x430>
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1550 <aan_ecuacion_calor_metodo_explicito_canal+0x430>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x2,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    154b <aan_ecuacion_calor_metodo_explicito_canal+0x42b>
movl   $0x1,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1538 <aan_ecuacion_calor_metodo_explicito_canal+0x418>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14e5 <aan_ecuacion_calor_metodo_explicito_canal+0x3c5>
jmp    153d <aan_ecuacion_calor_metodo_explicito_canal+0x41d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14d4 <aan_ecuacion_calor_metodo_explicito_canal+0x3b4>
jmp    1b7f <aan_ecuacion_calor_metodo_explicito_canal+0xa5f>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16a7 <aan_ecuacion_calor_metodo_explicito_canal+0x587>
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16a7 <aan_ecuacion_calor_metodo_explicito_canal+0x587>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    16a2 <aan_ecuacion_calor_metodo_explicito_canal+0x582>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jge    168f <aan_ecuacion_calor_metodo_explicito_canal+0x56f>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    163c <aan_ecuacion_calor_metodo_explicito_canal+0x51c>
jmp    1694 <aan_ecuacion_calor_metodo_explicito_canal+0x574>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    162b <aan_ecuacion_calor_metodo_explicito_canal+0x50b>
jmp    1b7a <aan_ecuacion_calor_metodo_explicito_canal+0xa5a>
cmpl   $0x0,-0x20(%rbp)
jne    17b1 <aan_ecuacion_calor_metodo_explicito_canal+0x691>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    17ac <aan_ecuacion_calor_metodo_explicito_canal+0x68c>
movl   $0x1,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1799 <aan_ecuacion_calor_metodo_explicito_canal+0x679>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1746 <aan_ecuacion_calor_metodo_explicito_canal+0x626>
jmp    179e <aan_ecuacion_calor_metodo_explicito_canal+0x67e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1735 <aan_ecuacion_calor_metodo_explicito_canal+0x615>
jmp    1b75 <aan_ecuacion_calor_metodo_explicito_canal+0xa55>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    18c5 <aan_ecuacion_calor_metodo_explicito_canal+0x7a5>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    18c0 <aan_ecuacion_calor_metodo_explicito_canal+0x7a0>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jge    18ad <aan_ecuacion_calor_metodo_explicito_canal+0x78d>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    185a <aan_ecuacion_calor_metodo_explicito_canal+0x73a>
jmp    18b2 <aan_ecuacion_calor_metodo_explicito_canal+0x792>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1849 <aan_ecuacion_calor_metodo_explicito_canal+0x729>
jmp    1b70 <aan_ecuacion_calor_metodo_explicito_canal+0xa50>
cmpl   $0x0,-0x24(%rbp)
jne    19cf <aan_ecuacion_calor_metodo_explicito_canal+0x8af>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    19ca <aan_ecuacion_calor_metodo_explicito_canal+0x8aa>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    19b7 <aan_ecuacion_calor_metodo_explicito_canal+0x897>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1964 <aan_ecuacion_calor_metodo_explicito_canal+0x844>
jmp    19bc <aan_ecuacion_calor_metodo_explicito_canal+0x89c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1953 <aan_ecuacion_calor_metodo_explicito_canal+0x833>
jmp    1b6b <aan_ecuacion_calor_metodo_explicito_canal+0xa4b>
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1ae3 <aan_ecuacion_calor_metodo_explicito_canal+0x9c3>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    1ade <aan_ecuacion_calor_metodo_explicito_canal+0x9be>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1acb <aan_ecuacion_calor_metodo_explicito_canal+0x9ab>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a78 <aan_ecuacion_calor_metodo_explicito_canal+0x958>
jmp    1ad0 <aan_ecuacion_calor_metodo_explicito_canal+0x9b0>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a67 <aan_ecuacion_calor_metodo_explicito_canal+0x947>
jmp    1b66 <aan_ecuacion_calor_metodo_explicito_canal+0xa46>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1b61 <aan_ecuacion_calor_metodo_explicito_canal+0xa41>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1b4e <aan_ecuacion_calor_metodo_explicito_canal+0xa2e>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1afb <aan_ecuacion_calor_metodo_explicito_canal+0x9db>
jmp    1b53 <aan_ecuacion_calor_metodo_explicito_canal+0xa33>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1aea <aan_ecuacion_calor_metodo_explicito_canal+0x9ca>
jmp    1b66 <aan_ecuacion_calor_metodo_explicito_canal+0xa46>
jmp    1b6b <aan_ecuacion_calor_metodo_explicito_canal+0xa4b>
jmp    1b70 <aan_ecuacion_calor_metodo_explicito_canal+0xa50>
jmp    1b75 <aan_ecuacion_calor_metodo_explicito_canal+0xa55>
jmp    1b7a <aan_ecuacion_calor_metodo_explicito_canal+0xa5a>
jmp    1b7f <aan_ecuacion_calor_metodo_explicito_canal+0xa5f>
jmp    1b84 <aan_ecuacion_calor_metodo_explicito_canal+0xa64>
jmp    1b89 <aan_ecuacion_calor_metodo_explicito_canal+0xa69>
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1ced <aan_ecuacion_calor_metodo_explicito_canal+0xbcd>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1cda <aan_ecuacion_calor_metodo_explicito_canal+0xbba>
cmpl   $0x1,-0x2c(%rbp)
jne    1c5d <aan_ecuacion_calor_metodo_explicito_canal+0xb3d>
cmpl   $0x1,-0x28(%rbp)
jne    1c5d <aan_ecuacion_calor_metodo_explicito_canal+0xb3d>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3f3(%rip),%xmm2
divsd  %xmm2,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm3
movsd  0x3d6(%rip),%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1cc7 <aan_ecuacion_calor_metodo_explicito_canal+0xba7>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x378(%rip),%xmm2
divsd  %xmm2,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1ccc <aan_ecuacion_calor_metodo_explicito_canal+0xbac>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1bc4 <aan_ecuacion_calor_metodo_explicito_canal+0xaa4>
jmp    1cdf <aan_ecuacion_calor_metodo_explicito_canal+0xbbf>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1bb3 <aan_ecuacion_calor_metodo_explicito_canal+0xa93>
jmp    1cf2 <aan_ecuacion_calor_metodo_explicito_canal+0xbd2>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11b6 <aan_ecuacion_calor_metodo_explicito_canal+0x96>
jmp    1d05 <aan_ecuacion_calor_metodo_explicito_canal+0xbe5>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a3 <aan_ecuacion_calor_metodo_explicito_canal+0x83>
mov    -0x38(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<aan_ecuacion_calor_metodo_explicito_canal>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
movss  %xmm0,(%rsp)
mov    %ecx,%r12d
mov    %edx,%r14d
mov    %rsi,0x98(%rsp)
mov    %rdi,%rbx
mov    $0x24,%edi
call   1040 <malloc@plt>
test   %r12d,%r12d
jle    1a65 <aan_ecuacion_calor_metodo_explicito_canal+0x945>
movabs $0x100000000,%r9
lea    -0x1(%r14),%r11d
lea    -0x1(%r12),%r8d
mov    %r12d,%esi
imul   %r14d,%esi
lea    -0x1(%rsi),%edi
movslq %edi,%rdi
mov    %rdi,0x90(%rsp)
mov    %r8,0x8(%rsp)
mov    %r8d,%edi
imul   %r14d,%edi
add    $0xffffffff,%edi
movslq %edi,%rdi
mov    %rdi,0x88(%rsp)
add    $0xfffffffe,%esi
movslq %esi,%rsi
mov    %rsi,0x80(%rsp)
movslq %r11d,%rsi
mov    %rsi,0x138(%rsp)
lea    -0x2(%r14),%esi
mov    %rsi,0x70(%rsp)
movslq %esi,%rsi
mov    %rsi,0x50(%rsp)
lea    -0x1(%r14,%r14,1),%esi
movslq %esi,%rsi
mov    %rsi,0x68(%rsp)
movslq %r14d,%rcx
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  0xe19(%rip),%xmm0
mov    %r12d,%esi
mov    %rsi,0xf0(%rsp)
lea    -0x2(%r14,%r14,1),%esi
movslq %esi,%rsi
mov    %rsi,0x130(%rsp)
lea    0x1(%rcx),%esi
movslq %esi,%rsi
mov    %rsi,0x140(%rsp)
mov    %rcx,%rsi
shl    $0x20,%rsi
mov    %rsi,0x60(%rsp)
movsd  0xde3(%rip),%xmm8
mov    %rcx,%rdx
mov    %rcx,(%rsp)
mov    %ecx,%r12d
lea    0x4(%rbx),%rsi
mov    %rsi,0x58(%rsp)
xor    %r10d,%r10d
mov    %r14,0x78(%rsp)
jmp    126e <aan_ecuacion_calor_metodo_explicito_canal+0x14e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xf8(%rsp),%rsi
mov    %rsi,%r10
mov    0x78(%rsp),%r14
cmp    0xf0(%rsp),%rsi
je     1a65 <aan_ecuacion_calor_metodo_explicito_canal+0x945>
test   %r14d,%r14d
jle    1a50 <aan_ecuacion_calor_metodo_explicito_canal+0x930>
lea    -0x1(%r10),%r15
mov    %r10,%rdx
mov    (%rsp),%rdi
imul   %rdi,%rdx
mov    %r15,%r13
imul   %rdi,%r13
lea    0x1(%r10),%rsi
mov    %rsi,0xf8(%rsp)
mov    %rsi,%r8
imul   %rdi,%r8
lea    -0x2(%r10),%rsi
imul   %rdi,%rsi
mov    %rsi,0x128(%rsp)
lea    0x1(%r10),%ecx
imul   %r14d,%ecx
mov    0x70(%rsp),%rdi
lea    (%rdi,%r13,1),%esi
movslq %esi,%rsi
mov    %rsi,0x38(%rsp)
mov    0x50(%rsp),%rbp
lea    0x1(%rbp,%r13,1),%esi
movslq %esi,%rsi
mov    %rsi,0xe8(%rsp)
lea    (%rdi,%rdx,1),%esi
movslq %esi,%rsi
mov    %rsi,0x30(%rsp)
lea    0x1(%rbp,%rdx,1),%esi
movslq %esi,%rsi
mov    %rsi,0xe0(%rsp)
lea    (%rdi,%rcx,1),%esi
movslq %esi,%rsi
mov    %rsi,0xd8(%rsp)
lea    0x1(%rbp,%rcx,1),%esi
movslq %esi,%rsi
mov    %rsi,0xd0(%rsp)
lea    0x3(%r15),%esi
imul   %r14d,%esi
movslq %esi,%rsi
mov    %rsi,0x118(%rsp)
mov    %r13,%rsi
shl    $0x20,%rsi
add    %r9,%rsi
sar    $0x20,%rsi
mov    %rsi,0x48(%rsp)
mov    %rdx,%rsi
shl    $0x20,%rsi
add    %r9,%rsi
sar    $0x20,%rsi
mov    %rsi,0x40(%rsp)
mov    %r8,%rsi
shl    $0x20,%rsi
add    %r9,%rsi
sar    $0x20,%rsi
mov    %rsi,0x110(%rsp)
lea    0x1(%rbp,%r13,1),%esi
movslq %esi,%rsi
mov    %rsi,0x108(%rsp)
lea    0x1(%rbp,%rdx,1),%esi
movslq %esi,%rsi
mov    %rsi,0x100(%rsp)
movss  0xc(%rax),%xmm10
movss  0x18(%rax),%xmm9
movss  0x1c(%rax),%xmm4
mov    0x60(%rsp),%rsi
mov    %rsi,%rdi
imul   %r10,%rdi
imul   %rsi,%r15
mov    %rcx,0xb0(%rsp)
add    $0xffffffff,%ecx
mov    %rcx,0xa8(%rsp)
lea    (%r11,%r13,1),%rcx
mov    %rcx,0xc8(%rsp)
lea    (%rdx,%r11,1),%rcx
mov    %rcx,0xc0(%rsp)
mov    %r8,%rsi
mov    %r8,0x120(%rsp)
lea    (%r8,%r11,1),%rcx
mov    %rcx,0xb8(%rsp)
lea    -0x1(%r13),%ecx
mov    %rcx,0x28(%rsp)
mov    %r13d,%ecx
mov    %rcx,0x20(%rsp)
mov    %edx,%ecx
mov    %rcx,0x18(%rsp)
lea    -0x1(%rdx),%ecx
mov    %rcx,0x10(%rsp)
mov    0x98(%rsp),%rsi
lea    (%rsi,%rdx,4),%r8
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,4),%rcx
mov    %rcx,0xa0(%rsp)
xor    %ebp,%ebp
mov    0x68(%rsp),%r14
jmp    157c <aan_ecuacion_calor_metodo_explicito_canal+0x45c>
nop
movsd  (%rbx),%xmm3
movaps %xmm3,%xmm1
shufps $0x10,%xmm3,%xmm1
movups %xmm1,(%rax)
mov    (%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm4
movss  %xmm4,0x18(%rax)
movss  %xmm3,0x10(%rax)
movaps %xmm3,%xmm7
shufps $0x55,%xmm3,%xmm7
movss  %xmm7,0x14(%rax)
movss  %xmm4,0x1c(%rax)
mov    0x140(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm5
movss  %xmm5,0x20(%rax)
movaps %xmm4,%xmm9
movaps %xmm3,%xmm10
movaps %xmm7,%xmm6
movaps %xmm3,%xmm1
movaps %xmm3,%xmm2
cvtss2sd %xmm3,%xmm3
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm6,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm10,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm8,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm7,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm9,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,(%r8,%rbp,4)
add    $0x1,%rbp
add    %r9,%rdi
add    %r9,%r15
cmp    %rbp,%r12
je     1250 <aan_ecuacion_calor_metodo_explicito_canal+0x130>
mov    %rbp,%rsi
or     %r10,%rsi
je     1430 <aan_ecuacion_calor_metodo_explicito_canal+0x310>
cmp    %rbp,%r11
jne    1610 <aan_ecuacion_calor_metodo_explicito_canal+0x4f0>
test   %r10,%r10
jne    1610 <aan_ecuacion_calor_metodo_explicito_canal+0x4f0>
mov    0x138(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm7
movss  %xmm7,0x8(%rax)
movss  %xmm7,0x4(%rax)
mov    0x50(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm2
movss  %xmm2,(%rax)
movss  (%rbx,%r14,4),%xmm5
movss  %xmm5,0x20(%rax)
movsd  -0x4(%rbx,%r11,4),%xmm10
mov    0x130(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm9
movaps %xmm9,%xmm1
movlhps %xmm7,%xmm1
movaps %xmm10,%xmm3
shufps $0x24,%xmm1,%xmm3
movups %xmm3,0xc(%rax)
movss  (%rbx,%r14,4),%xmm4
movss  %xmm4,0x1c(%rax)
movaps %xmm10,%xmm3
shufps $0x55,%xmm10,%xmm3
movaps %xmm7,%xmm6
movaps %xmm7,%xmm1
jmp    1485 <aan_ecuacion_calor_metodo_explicito_canal+0x365>
nopl   (%rax)
test   %rbp,%rbp
jne    1671 <aan_ecuacion_calor_metodo_explicito_canal+0x551>
cmp    0x8(%rsp),%r10
jne    1671 <aan_ecuacion_calor_metodo_explicito_canal+0x551>
mov    0x128(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm2
movss  %xmm2,(%rax)
movss  0x4(%rbx,%r13,4),%xmm5
movss  %xmm5,0x20(%rax)
movss  (%rbx,%r13,4),%xmm1
movss  %xmm1,0x4(%rax)
mov    0x48(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm6
movss  %xmm6,0x8(%rax)
movss  (%rbx,%rdx,4),%xmm3
movss  %xmm3,0x10(%rax)
mov    0x40(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm7
movss  %xmm7,0x14(%rax)
jmp    1485 <aan_ecuacion_calor_metodo_explicito_canal+0x365>
cmp    %rbp,%r11
jne    170f <aan_ecuacion_calor_metodo_explicito_canal+0x5ef>
cmp    0x8(%rsp),%r10
jne    17ce <aan_ecuacion_calor_metodo_explicito_canal+0x6ae>
mov    0x90(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm5
mov    0x88(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm6
movss  %xmm6,0x8(%rax)
mov    0x80(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm9
movaps %xmm5,%xmm1
unpcklps %xmm9,%xmm1
shufps $0x4,%xmm1,%xmm1
movups %xmm1,0x14(%rax)
mov    0x38(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm2
movss  %xmm2,(%rax)
mov    0x108(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm1
movss  %xmm1,0x4(%rax)
mov    0x30(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm10
movss  %xmm10,0xc(%rax)
mov    0x100(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm3
movss  %xmm3,0x10(%rax)
movaps %xmm5,%xmm4
movaps %xmm5,%xmm7
jmp    1485 <aan_ecuacion_calor_metodo_explicito_canal+0x365>
test   %rbp,%rbp
je     187b <aan_ecuacion_calor_metodo_explicito_canal+0x75b>
test   %r10,%r10
je     1904 <aan_ecuacion_calor_metodo_explicito_canal+0x7e4>
cmp    0x8(%rsp),%r10
jne    197d <aan_ecuacion_calor_metodo_explicito_canal+0x85d>
mov    0xa0(%rsp),%rcx
movsd  -0x8(%rcx,%rbp,4),%xmm9
movss  (%rcx,%rbp,4),%xmm5
movss  %xmm5,0x20(%rax)
mov    0x28(%rsp),%rcx
lea    (%rcx,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm2
movss  %xmm2,(%rax)
mov    0x20(%rsp),%rcx
lea    (%rcx,%rbp,1),%rsi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm1
movss  %xmm1,0x4(%rax)
add    $0x1,%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm6
movss  %xmm6,0x8(%rax)
mov    0x10(%rsp),%rcx
lea    (%rcx,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm10
movss  %xmm10,0xc(%rax)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rbp,1),%rsi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm3
add    $0x1,%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm7
movaps %xmm3,%xmm4
unpcklps %xmm7,%xmm4
movlhps %xmm9,%xmm4
movups %xmm4,0x10(%rax)
movaps %xmm9,%xmm4
shufps $0x55,%xmm9,%xmm4
jmp    1485 <aan_ecuacion_calor_metodo_explicito_canal+0x365>
test   %rbp,%rbp
je     187b <aan_ecuacion_calor_metodo_explicito_canal+0x75b>
mov    0xc8(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm6
movss  %xmm6,0x8(%rax)
mov    0xc0(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm7
movss  %xmm7,0x14(%rax)
mov    0xb8(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm5
movss  %xmm5,0x20(%rax)
mov    0x38(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm2
movss  %xmm2,(%rax)
mov    0xe8(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm1
movss  %xmm1,0x4(%rax)
mov    0x30(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm10
movss  %xmm10,0xc(%rax)
mov    0xe0(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm3
movss  %xmm3,0x10(%rax)
mov    0xd8(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm9
movss  %xmm9,0x18(%rax)
mov    0xd0(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm4
movss  %xmm4,0x1c(%rax)
jmp    1485 <aan_ecuacion_calor_metodo_explicito_canal+0x365>
mov    0x118(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm9
movss  %xmm9,(%rax)
movss  %xmm9,0xc(%rax)
movss  %xmm9,0x18(%rax)
movss  (%rbx,%r13,4),%xmm1
movss  %xmm1,0x4(%rax)
mov    0x48(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm6
movss  %xmm6,0x8(%rax)
movss  (%rbx,%rdx,4),%xmm3
movss  %xmm3,0x10(%rax)
mov    0x40(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm7
movss  %xmm7,0x14(%rax)
mov    %rdx,%rcx
mov    0x120(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm4
mov    %rcx,%rdx
movss  %xmm4,0x1c(%rax)
mov    0x110(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm5
movss  %xmm5,0x20(%rax)
movaps %xmm9,%xmm10
movaps %xmm9,%xmm2
jmp    1485 <aan_ecuacion_calor_metodo_explicito_canal+0x365>
movss  -0x4(%rbx,%rbp,4),%xmm10
movsd  (%rbx,%rbp,4),%xmm1
movaps %xmm10,%xmm2
movlhps %xmm1,%xmm2
movaps %xmm10,%xmm3
shufps $0xd4,%xmm1,%xmm3
shufps $0x28,%xmm3,%xmm2
movups %xmm2,(%rax)
movsd  (%rbx,%rbp,4),%xmm3
lea    (%r11,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm9
lea    (%r12,%rbp,1),%rsi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm4
movaps %xmm4,%xmm2
movlhps %xmm9,%xmm2
movaps %xmm3,%xmm5
shufps $0x24,%xmm2,%xmm5
movups %xmm5,0x10(%rax)
add    $0x1,%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm5
movss  %xmm5,0x20(%rax)
movaps %xmm1,%xmm6
shufps $0x55,%xmm1,%xmm6
movaps %xmm3,%xmm7
shufps $0x55,%xmm3,%xmm7
movaps %xmm10,%xmm2
jmp    1485 <aan_ecuacion_calor_metodo_explicito_canal+0x365>
mov    0x28(%rsp),%rcx
lea    (%rcx,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm2
movss  %xmm2,(%rax)
mov    %r15,%rsi
sar    $0x1e,%rsi
movss  (%rbx,%rsi,1),%xmm1
movss  %xmm1,0x4(%rax)
mov    0x20(%rsp),%rcx
lea    (%rcx,%rbp,1),%esi
add    $0x1,%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm6
movss  %xmm6,0x8(%rax)
mov    0x10(%rsp),%rcx
lea    (%rcx,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm10
movss  %xmm10,0xc(%rax)
mov    %rdi,%rsi
sar    $0x1e,%rsi
movss  (%rbx,%rsi,1),%xmm3
movss  %xmm3,0x10(%rax)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rbp,1),%esi
add    $0x1,%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm7
movss  %xmm7,0x14(%rax)
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm9
movss  %xmm9,0x18(%rax)
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rbp,1),%rsi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm4
movss  %xmm4,0x1c(%rax)
add    $0x1,%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm5
movss  %xmm5,0x20(%rax)
jmp    1485 <aan_ecuacion_calor_metodo_explicito_canal+0x365>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10
mov    %r10,%rsi
cmp    0xf0(%rsp),%rsi
jne    126e <aan_ecuacion_calor_metodo_explicito_canal+0x14e>
mov    %rax,%rdi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @aan_ecuacion_calor_metodo_explicito_canal(float* %0, float* %1, i32 %2, i32 %3, float %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca float
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float**
%16 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store float %4, float* %10
%17 = call i8* @malloc(i64 24)
%18 = bitcast i8* %17 to float**
store float** %18, float*** %15
%19 = call i8* @malloc(i64 36)
%20 = bitcast i8* %19 to float*
%21 = load float**, float*** %15
%22 = getelementptr inbounds float*, float** %21, i64 0
store float* %20, float** %22
store i32 0, i32* %16
br label %23
23: ; preds = %38, %5
%24 = load i32, i32* %16
%25 = icmp slt i32 %24, 3
br i1 %25, label %26, label %41
26: ; preds = %23
%27 = load float**, float*** %15
%28 = getelementptr inbounds float*, float** %27, i64 0
%29 = load float*, float** %28
%30 = load i32, i32* %16
%31 = mul nsw i32 %30, 3
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %29, i64 %32
%34 = load float**, float*** %15
%35 = load i32, i32* %16
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float*, float** %34, i64 %36
store float* %33, float** %37
br label %38
38: ; preds = %26
%39 = load i32, i32* %16
%40 = add nsw i32 %39, 1
store i32 %40, i32* %16
br label %23
41: ; preds = %23
store i32 0, i32* %12
br label %42
42: ; preds = %968, %41
%43 = load i32, i32* %12
%44 = load i32, i32* %9
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %971
46: ; preds = %42
store i32 0, i32* %11
br label %47
47: ; preds = %964, %46
%48 = load i32, i32* %11
%49 = load i32, i32* %8
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %967
51: ; preds = %47
%52 = load i32, i32* %11
%53 = icmp eq i32 %52, 0
br i1 %53, label %54, label %134
54: ; preds = %51
%55 = load i32, i32* %12
%56 = icmp eq i32 %55, 0
br i1 %56, label %57, label %134
57: ; preds = %54
%58 = load float*, float** %6
%59 = getelementptr inbounds float, float* %58, i64 0
%60 = load float, float* %59
%61 = load float**, float*** %15
%62 = getelementptr inbounds float*, float** %61, i64 0
%63 = load float*, float** %62
%64 = getelementptr inbounds float, float* %63, i64 0
store float %60, float* %64
%65 = load float*, float** %6
%66 = getelementptr inbounds float, float* %65, i64 0
%67 = load float, float* %66
%68 = load float**, float*** %15
%69 = getelementptr inbounds float*, float** %68, i64 0
%70 = load float*, float** %69
%71 = getelementptr inbounds float, float* %70, i64 1
store float %67, float* %71
%72 = load float*, float** %6
%73 = getelementptr inbounds float, float* %72, i64 1
%74 = load float, float* %73
%75 = load float**, float*** %15
%76 = getelementptr inbounds float*, float** %75, i64 0
%77 = load float*, float** %76
%78 = getelementptr inbounds float, float* %77, i64 2
store float %74, float* %78
%79 = load float*, float** %6
%80 = getelementptr inbounds float, float* %79, i64 0
%81 = load float, float* %80
%82 = load float**, float*** %15
%83 = getelementptr inbounds float*, float** %82, i64 1
%84 = load float*, float** %83
%85 = getelementptr inbounds float, float* %84, i64 0
store float %81, float* %85
%86 = load float*, float** %6
%87 = load i32, i32* %8
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
%90 = load float, float* %89
%91 = load float**, float*** %15
%92 = getelementptr inbounds float*, float** %91, i64 2
%93 = load float*, float** %92
%94 = getelementptr inbounds float, float* %93, i64 0
store float %90, float* %94
store i32 1, i32* %13
br label %95
95: ; preds = %130, %57
%96 = load i32, i32* %13
%97 = icmp slt i32 %96, 3
br i1 %97, label %98, label %133
98: ; preds = %95
store i32 1, i32* %14
br label %99
99: ; preds = %126, %98
%100 = load i32, i32* %14
%101 = icmp slt i32 %100, 3
br i1 %101, label %102, label %129
102: ; preds = %99
%103 = load float*, float** %6
%104 = load i32, i32* %8
%105 = load i32, i32* %12
%106 = sub nsw i32 %105, 1
%107 = load i32, i32* %13
%108 = add nsw i32 %106, %107
%109 = mul nsw i32 %104, %108
%110 = load i32, i32* %11
%111 = sub nsw i32 %110, 1
%112 = load i32, i32* %14
%113 = add nsw i32 %111, %112
%114 = add nsw i32 %109, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %103, i64 %115
%117 = load float, float* %116
%118 = load float**, float*** %15
%119 = load i32, i32* %13
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float*, float** %118, i64 %120
%122 = load float*, float** %121
%123 = load i32, i32* %14
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float, float* %122, i64 %124
store float %117, float* %125
br label %126
126: ; preds = %102
%127 = load i32, i32* %14
%128 = add nsw i32 %127, 1
store i32 %128, i32* %14
br label %99
129: ; preds = %99
br label %130
130: ; preds = %129
%131 = load i32, i32* %13
%132 = add nsw i32 %131, 1
store i32 %132, i32* %13
br label %95
133: ; preds = %95
br label %859
134: ; preds = %54, %51
%135 = load i32, i32* %11
%136 = load i32, i32* %8
%137 = sub nsw i32 %136, 1
%138 = icmp eq i32 %135, %137
br i1 %138, label %139, label %233
139: ; preds = %134
%140 = load i32, i32* %12
%141 = icmp eq i32 %140, 0
br i1 %141, label %142, label %233
142: ; preds = %139
%143 = load float*, float** %6
%144 = load i32, i32* %8
%145 = sub nsw i32 %144, 1
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %143, i64 %146
%148 = load float, float* %147
%149 = load float**, float*** %15
%150 = getelementptr inbounds float*, float** %149, i64 0
%151 = load float*, float** %150
%152 = getelementptr inbounds float, float* %151, i64 2
store float %148, float* %152
%153 = load float*, float** %6
%154 = load i32, i32* %8
%155 = sub nsw i32 %154, 1
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds float, float* %153, i64 %156
%158 = load float, float* %157
%159 = load float**, float*** %15
%160 = getelementptr inbounds float*, float** %159, i64 0
%161 = load float*, float** %160
%162 = getelementptr inbounds float, float* %161, i64 1
store float %158, float* %162
%163 = load float*, float** %6
%164 = load i32, i32* %8
%165 = sub nsw i32 %164, 2
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %163, i64 %166
%168 = load float, float* %167
%169 = load float**, float*** %15
%170 = getelementptr inbounds float*, float** %169, i64 0
%171 = load float*, float** %170
%172 = getelementptr inbounds float, float* %171, i64 0
store float %168, float* %172
%173 = load float*, float** %6
%174 = load i32, i32* %8
%175 = sub nsw i32 %174, 1
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds float, float* %173, i64 %176
%178 = load float, float* %177
%179 = load float**, float*** %15
%180 = getelementptr inbounds float*, float** %179, i64 1
%181 = load float*, float** %180
%182 = getelementptr inbounds float, float* %181, i64 2
store float %178, float* %182
%183 = load float*, float** %6
%184 = load i32, i32* %8
%185 = mul nsw i32 %184, 2
%186 = sub nsw i32 %185, 1
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds float, float* %183, i64 %187
%189 = load float, float* %188
%190 = load float**, float*** %15
%191 = getelementptr inbounds float*, float** %190, i64 2
%192 = load float*, float** %191
%193 = getelementptr inbounds float, float* %192, i64 2
store float %189, float* %193
store i32 1, i32* %13
br label %194
194: ; preds = %229, %142
%195 = load i32, i32* %13
%196 = icmp slt i32 %195, 3
br i1 %196, label %197, label %232
197: ; preds = %194
store i32 0, i32* %14
br label %198
198: ; preds = %225, %197
%199 = load i32, i32* %14
%200 = icmp slt i32 %199, 2
br i1 %200, label %201, label %228
201: ; preds = %198
%202 = load float*, float** %6
%203 = load i32, i32* %8
%204 = load i32, i32* %12
%205 = sub nsw i32 %204, 1
%206 = load i32, i32* %13
%207 = add nsw i32 %205, %206
%208 = mul nsw i32 %203, %207
%209 = load i32, i32* %11
%210 = sub nsw i32 %209, 1
%211 = load i32, i32* %14
%212 = add nsw i32 %210, %211
%213 = add nsw i32 %208, %212
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds float, float* %202, i64 %214
%216 = load float, float* %215
%217 = load float**, float*** %15
%218 = load i32, i32* %13
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float*, float** %217, i64 %219
%221 = load float*, float** %220
%222 = load i32, i32* %14
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds float, float* %221, i64 %223
store float %216, float* %224
br label %225
225: ; preds = %201
%226 = load i32, i32* %14
%227 = add nsw i32 %226, 1
store i32 %227, i32* %14
br label %198
228: ; preds = %198
br label %229
229: ; preds = %228
%230 = load i32, i32* %13
%231 = add nsw i32 %230, 1
store i32 %231, i32* %13
br label %194
232: ; preds = %194
br label %858
233: ; preds = %139, %134
%234 = load i32, i32* %11
%235 = icmp eq i32 %234, 0
br i1 %235, label %236, label %342
236: ; preds = %233
%237 = load i32, i32* %12
%238 = load i32, i32* %9
%239 = sub nsw i32 %238, 1
%240 = icmp eq i32 %237, %239
br i1 %240, label %241, label %342
241: ; preds = %236
%242 = load float*, float** %6
%243 = load i32, i32* %8
%244 = load i32, i32* %12
%245 = sub nsw i32 %244, 1
%246 = mul nsw i32 %243, %245
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %242, i64 %247
%249 = load float, float* %248
%250 = load float**, float*** %15
%251 = getelementptr inbounds float*, float** %250, i64 0
%252 = load float*, float** %251
%253 = getelementptr inbounds float, float* %252, i64 2
store float %249, float* %253
%254 = load float*, float** %6
%255 = load i32, i32* %8
%256 = load i32, i32* %12
%257 = sub nsw i32 %256, 1
%258 = mul nsw i32 %255, %257
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds float, float* %254, i64 %259
%261 = load float, float* %260
%262 = load float**, float*** %15
%263 = getelementptr inbounds float*, float** %262, i64 0
%264 = load float*, float** %263
%265 = getelementptr inbounds float, float* %264, i64 1
store float %261, float* %265
%266 = load float*, float** %6
%267 = load i32, i32* %8
%268 = load i32, i32* %12
%269 = sub nsw i32 %268, 1
%270 = mul nsw i32 %267, %269
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* %266, i64 %271
%273 = load float, float* %272
%274 = load float**, float*** %15
%275 = getelementptr inbounds float*, float** %274, i64 1
%276 = load float*, float** %275
%277 = getelementptr inbounds float, float* %276, i64 2
store float %273, float* %277
%278 = load float*, float** %6
%279 = load i32, i32* %8
%280 = load i32, i32* %12
%281 = sub nsw i32 %280, 2
%282 = mul nsw i32 %279, %281
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds float, float* %278, i64 %283
%285 = load float, float* %284
%286 = load float**, float*** %15
%287 = getelementptr inbounds float*, float** %286, i64 0
%288 = load float*, float** %287
%289 = getelementptr inbounds float, float* %288, i64 0
store float %285, float* %289
%290 = load float*, float** %6
%291 = load i32, i32* %8
%292 = load i32, i32* %12
%293 = sub nsw i32 %292, 1
%294 = mul nsw i32 %291, %293
%295 = add nsw i32 %294, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %290, i64 %296
%298 = load float, float* %297
%299 = load float**, float*** %15
%300 = getelementptr inbounds float*, float** %299, i64 2
%301 = load float*, float** %300
%302 = getelementptr inbounds float, float* %301, i64 2
store float %298, float* %302
store i32 0, i32* %13
br label %303
303: ; preds = %338, %241
%304 = load i32, i32* %13
%305 = icmp slt i32 %304, 2
br i1 %305, label %306, label %341
306: ; preds = %303
store i32 1, i32* %14
br label %307
307: ; preds = %334, %306
%308 = load i32, i32* %14
%309 = icmp slt i32 %308, 3
br i1 %309, label %310, label %337
310: ; preds = %307
%311 = load float*, float** %6
%312 = load i32, i32* %8
%313 = load i32, i32* %12
%314 = sub nsw i32 %313, 1
%315 = load i32, i32* %13
%316 = add nsw i32 %314, %315
%317 = mul nsw i32 %312, %316
%318 = load i32, i32* %11
%319 = sub nsw i32 %318, 1
%320 = load i32, i32* %14
%321 = add nsw i32 %319, %320
%322 = add nsw i32 %317, %321
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds float, float* %311, i64 %323
%325 = load float, float* %324
%326 = load float**, float*** %15
%327 = load i32, i32* %13
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds float*, float** %326, i64 %328
%330 = load float*, float** %329
%331 = load i32, i32* %14
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float, float* %330, i64 %332
store float %325, float* %333
br label %334
334: ; preds = %310
%335 = load i32, i32* %14
%336 = add nsw i32 %335, 1
store i32 %336, i32* %14
br label %307
337: ; preds = %307
br label %338
338: ; preds = %337
%339 = load i32, i32* %13
%340 = add nsw i32 %339, 1
store i32 %340, i32* %13
br label %303
341: ; preds = %303
br label %857
342: ; preds = %236, %233
%343 = load i32, i32* %11
%344 = load i32, i32* %8
%345 = sub nsw i32 %344, 1
%346 = icmp eq i32 %343, %345
br i1 %346, label %347, label %453
347: ; preds = %342
%348 = load i32, i32* %12
%349 = load i32, i32* %9
%350 = sub nsw i32 %349, 1
%351 = icmp eq i32 %348, %350
br i1 %351, label %352, label %453
352: ; preds = %347
%353 = load float*, float** %6
%354 = load i32, i32* %8
%355 = load i32, i32* %9
%356 = mul nsw i32 %354, %355
%357 = sub nsw i32 %356, 1
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds float, float* %353, i64 %358
%360 = load float, float* %359
%361 = load float**, float*** %15
%362 = getelementptr inbounds float*, float** %361, i64 2
%363 = load float*, float** %362
%364 = getelementptr inbounds float, float* %363, i64 2
store float %360, float* %364
%365 = load float*, float** %6
%366 = load i32, i32* %8
%367 = load i32, i32* %9
%368 = mul nsw i32 %366, %367
%369 = sub nsw i32 %368, 1
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds float, float* %365, i64 %370
%372 = load float, float* %371
%373 = load float**, float*** %15
%374 = getelementptr inbounds float*, float** %373, i64 1
%375 = load float*, float** %374
%376 = getelementptr inbounds float, float* %375, i64 2
store float %372, float* %376
%377 = load float*, float** %6
%378 = load i32, i32* %8
%379 = load i32, i32* %9
%380 = sub nsw i32 %379, 1
%381 = mul nsw i32 %378, %380
%382 = sub nsw i32 %381, 1
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds float, float* %377, i64 %383
%385 = load float, float* %384
%386 = load float**, float*** %15
%387 = getelementptr inbounds float*, float** %386, i64 0
%388 = load float*, float** %387
%389 = getelementptr inbounds float, float* %388, i64 2
store float %385, float* %389
%390 = load float*, float** %6
%391 = load i32, i32* %8
%392 = load i32, i32* %9
%393 = mul nsw i32 %391, %392
%394 = sub nsw i32 %393, 1
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds float, float* %390, i64 %395
%397 = load float, float* %396
%398 = load float**, float*** %15
%399 = getelementptr inbounds float*, float** %398, i64 2
%400 = load float*, float** %399
%401 = getelementptr inbounds float, float* %400, i64 1
store float %397, float* %401
%402 = load float*, float** %6
%403 = load i32, i32* %8
%404 = load i32, i32* %9
%405 = mul nsw i32 %403, %404
%406 = sub nsw i32 %405, 2
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds float, float* %402, i64 %407
%409 = load float, float* %408
%410 = load float**, float*** %15
%411 = getelementptr inbounds float*, float** %410, i64 2
%412 = load float*, float** %411
%413 = getelementptr inbounds float, float* %412, i64 0
store float %409, float* %413
store i32 0, i32* %13
br label %414
414: ; preds = %449, %352
%415 = load i32, i32* %13
%416 = icmp slt i32 %415, 2
br i1 %416, label %417, label %452
417: ; preds = %414
store i32 0, i32* %14
br label %418
418: ; preds = %445, %417
%419 = load i32, i32* %14
%420 = icmp slt i32 %419, 2
br i1 %420, label %421, label %448
421: ; preds = %418
%422 = load float*, float** %6
%423 = load i32, i32* %8
%424 = load i32, i32* %12
%425 = sub nsw i32 %424, 1
%426 = load i32, i32* %13
%427 = add nsw i32 %425, %426
%428 = mul nsw i32 %423, %427
%429 = load i32, i32* %11
%430 = sub nsw i32 %429, 1
%431 = load i32, i32* %14
%432 = add nsw i32 %430, %431
%433 = add nsw i32 %428, %432
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds float, float* %422, i64 %434
%436 = load float, float* %435
%437 = load float**, float*** %15
%438 = load i32, i32* %13
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds float*, float** %437, i64 %439
%441 = load float*, float** %440
%442 = load i32, i32* %14
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds float, float* %441, i64 %443
store float %436, float* %444
br label %445
445: ; preds = %421
%446 = load i32, i32* %14
%447 = add nsw i32 %446, 1
store i32 %447, i32* %14
br label %418
448: ; preds = %418
br label %449
449: ; preds = %448
%450 = load i32, i32* %13
%451 = add nsw i32 %450, 1
store i32 %451, i32* %13
br label %414
452: ; preds = %414
br label %856
453: ; preds = %347, %342
%454 = load i32, i32* %11
%455 = icmp eq i32 %454, 0
br i1 %455, label %456, label %544
456: ; preds = %453
%457 = load float*, float** %6
%458 = load i32, i32* %8
%459 = load i32, i32* %12
%460 = sub nsw i32 %459, 1
%461 = load i32, i32* %13
%462 = add nsw i32 %460, %461
%463 = mul nsw i32 %458, %462
%464 = load i32, i32* %11
%465 = add nsw i32 %463, %464
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds float, float* %457, i64 %466
%468 = load float, float* %467
%469 = load float**, float*** %15
%470 = getelementptr inbounds float*, float** %469, i64 0
%471 = load float*, float** %470
%472 = getelementptr inbounds float, float* %471, i64 0
store float %468, float* %472
%473 = load float*, float** %6
%474 = load i32, i32* %8
%475 = load i32, i32* %12
%476 = sub nsw i32 %475, 1
%477 = load i32, i32* %13
%478 = add nsw i32 %476, %477
%479 = mul nsw i32 %474, %478
%480 = load i32, i32* %11
%481 = add nsw i32 %479, %480
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds float, float* %473, i64 %482
%484 = load float, float* %483
%485 = load float**, float*** %15
%486 = getelementptr inbounds float*, float** %485, i64 1
%487 = load float*, float** %486
%488 = getelementptr inbounds float, float* %487, i64 0
store float %484, float* %488
%489 = load float*, float** %6
%490 = load i32, i32* %8
%491 = load i32, i32* %12
%492 = sub nsw i32 %491, 1
%493 = load i32, i32* %13
%494 = add nsw i32 %492, %493
%495 = mul nsw i32 %490, %494
%496 = load i32, i32* %11
%497 = add nsw i32 %495, %496
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds float, float* %489, i64 %498
%500 = load float, float* %499
%501 = load float**, float*** %15
%502 = getelementptr inbounds float*, float** %501, i64 2
%503 = load float*, float** %502
%504 = getelementptr inbounds float, float* %503, i64 0
store float %500, float* %504
store i32 0, i32* %13
br label %505
505: ; preds = %540, %456
%506 = load i32, i32* %13
%507 = icmp slt i32 %506, 3
br i1 %507, label %508, label %543
508: ; preds = %505
store i32 1, i32* %14
br label %509
509: ; preds = %536, %508
%510 = load i32, i32* %14
%511 = icmp slt i32 %510, 3
br i1 %511, label %512, label %539
512: ; preds = %509
%513 = load float*, float** %6
%514 = load i32, i32* %8
%515 = load i32, i32* %12
%516 = sub nsw i32 %515, 1
%517 = load i32, i32* %13
%518 = add nsw i32 %516, %517
%519 = mul nsw i32 %514, %518
%520 = load i32, i32* %11
%521 = sub nsw i32 %520, 1
%522 = load i32, i32* %14
%523 = add nsw i32 %521, %522
%524 = add nsw i32 %519, %523
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds float, float* %513, i64 %525
%527 = load float, float* %526
%528 = load float**, float*** %15
%529 = load i32, i32* %13
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds float*, float** %528, i64 %530
%532 = load float*, float** %531
%533 = load i32, i32* %14
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds float, float* %532, i64 %534
store float %527, float* %535
br label %536
536: ; preds = %512
%537 = load i32, i32* %14
%538 = add nsw i32 %537, 1
store i32 %538, i32* %14
br label %509
539: ; preds = %509
br label %540
540: ; preds = %539
%541 = load i32, i32* %13
%542 = add nsw i32 %541, 1
store i32 %542, i32* %13
br label %505
543: ; preds = %505
br label %855
544: ; preds = %453
%545 = load i32, i32* %11
%546 = load i32, i32* %8
%547 = sub nsw i32 %546, 1
%548 = icmp eq i32 %545, %547
br i1 %548, label %549, label %634
549: ; preds = %544
%550 = load float*, float** %6
%551 = load i32, i32* %8
%552 = load i32, i32* %12
%553 = sub nsw i32 %552, 1
%554 = add nsw i32 %553, 0
%555 = mul nsw i32 %551, %554
%556 = load i32, i32* %11
%557 = add nsw i32 %555, %556
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds float, float* %550, i64 %558
%560 = load float, float* %559
%561 = load float**, float*** %15
%562 = getelementptr inbounds float*, float** %561, i64 0
%563 = load float*, float** %562
%564 = getelementptr inbounds float, float* %563, i64 2
store float %560, float* %564
%565 = load float*, float** %6
%566 = load i32, i32* %8
%567 = load i32, i32* %12
%568 = sub nsw i32 %567, 1
%569 = add nsw i32 %568, 1
%570 = mul nsw i32 %566, %569
%571 = load i32, i32* %11
%572 = add nsw i32 %570, %571
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds float, float* %565, i64 %573
%575 = load float, float* %574
%576 = load float**, float*** %15
%577 = getelementptr inbounds float*, float** %576, i64 1
%578 = load float*, float** %577
%579 = getelementptr inbounds float, float* %578, i64 2
store float %575, float* %579
%580 = load float*, float** %6
%581 = load i32, i32* %8
%582 = load i32, i32* %12
%583 = sub nsw i32 %582, 1
%584 = add nsw i32 %583, 2
%585 = mul nsw i32 %581, %584
%586 = load i32, i32* %11
%587 = add nsw i32 %585, %586
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds float, float* %580, i64 %588
%590 = load float, float* %589
%591 = load float**, float*** %15
%592 = getelementptr inbounds float*, float** %591, i64 2
%593 = load float*, float** %592
%594 = getelementptr inbounds float, float* %593, i64 2
store float %590, float* %594
store i32 0, i32* %13
br label %595
595: ; preds = %630, %549
%596 = load i32, i32* %13
%597 = icmp slt i32 %596, 3
br i1 %597, label %598, label %633
598: ; preds = %595
store i32 0, i32* %14
br label %599
599: ; preds = %626, %598
%600 = load i32, i32* %14
%601 = icmp slt i32 %600, 2
br i1 %601, label %602, label %629
602: ; preds = %599
%603 = load float*, float** %6
%604 = load i32, i32* %8
%605 = load i32, i32* %12
%606 = sub nsw i32 %605, 1
%607 = load i32, i32* %13
%608 = add nsw i32 %606, %607
%609 = mul nsw i32 %604, %608
%610 = load i32, i32* %11
%611 = sub nsw i32 %610, 1
%612 = load i32, i32* %14
%613 = add nsw i32 %611, %612
%614 = add nsw i32 %609, %613
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds float, float* %603, i64 %615
%617 = load float, float* %616
%618 = load float**, float*** %15
%619 = load i32, i32* %13
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds float*, float** %618, i64 %620
%622 = load float*, float** %621
%623 = load i32, i32* %14
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds float, float* %622, i64 %624
store float %617, float* %625
br label %626
626: ; preds = %602
%627 = load i32, i32* %14
%628 = add nsw i32 %627, 1
store i32 %628, i32* %14
br label %599
629: ; preds = %599
br label %630
630: ; preds = %629
%631 = load i32, i32* %13
%632 = add nsw i32 %631, 1
store i32 %632, i32* %13
br label %595
633: ; preds = %595
br label %854
634: ; preds = %544
%635 = load i32, i32* %12
%636 = icmp eq i32 %635, 0
br i1 %636, label %637, label %722
637: ; preds = %634
%638 = load float*, float** %6
%639 = load i32, i32* %8
%640 = load i32, i32* %12
%641 = mul nsw i32 %639, %640
%642 = load i32, i32* %11
%643 = sub nsw i32 %642, 1
%644 = add nsw i32 %643, 0
%645 = add nsw i32 %641, %644
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds float, float* %638, i64 %646
%648 = load float, float* %647
%649 = load float**, float*** %15
%650 = getelementptr inbounds float*, float** %649, i64 0
%651 = load float*, float** %650
%652 = getelementptr inbounds float, float* %651, i64 0
store float %648, float* %652
%653 = load float*, float** %6
%654 = load i32, i32* %8
%655 = load i32, i32* %12
%656 = mul nsw i32 %654, %655
%657 = load i32, i32* %11
%658 = sub nsw i32 %657, 1
%659 = add nsw i32 %658, 1
%660 = add nsw i32 %656, %659
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds float, float* %653, i64 %661
%663 = load float, float* %662
%664 = load float**, float*** %15
%665 = getelementptr inbounds float*, float** %664, i64 0
%666 = load float*, float** %665
%667 = getelementptr inbounds float, float* %666, i64 1
store float %663, float* %667
%668 = load float*, float** %6
%669 = load i32, i32* %8
%670 = load i32, i32* %12
%671 = mul nsw i32 %669, %670
%672 = load i32, i32* %11
%673 = sub nsw i32 %672, 1
%674 = add nsw i32 %673, 2
%675 = add nsw i32 %671, %674
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds float, float* %668, i64 %676
%678 = load float, float* %677
%679 = load float**, float*** %15
%680 = getelementptr inbounds float*, float** %679, i64 0
%681 = load float*, float** %680
%682 = getelementptr inbounds float, float* %681, i64 2
store float %678, float* %682
store i32 1, i32* %13
br label %683
683: ; preds = %718, %637
%684 = load i32, i32* %13
%685 = icmp slt i32 %684, 3
br i1 %685, label %686, label %721
686: ; preds = %683
store i32 0, i32* %14
br label %687
687: ; preds = %714, %686
%688 = load i32, i32* %14
%689 = icmp slt i32 %688, 3
br i1 %689, label %690, label %717
690: ; preds = %687
%691 = load float*, float** %6
%692 = load i32, i32* %8
%693 = load i32, i32* %12
%694 = sub nsw i32 %693, 1
%695 = load i32, i32* %13
%696 = add nsw i32 %694, %695
%697 = mul nsw i32 %692, %696
%698 = load i32, i32* %11
%699 = sub nsw i32 %698, 1
%700 = load i32, i32* %14
%701 = add nsw i32 %699, %700
%702 = add nsw i32 %697, %701
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds float, float* %691, i64 %703
%705 = load float, float* %704
%706 = load float**, float*** %15
%707 = load i32, i32* %13
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds float*, float** %706, i64 %708
%710 = load float*, float** %709
%711 = load i32, i32* %14
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds float, float* %710, i64 %712
store float %705, float* %713
br label %714
714: ; preds = %690
%715 = load i32, i32* %14
%716 = add nsw i32 %715, 1
store i32 %716, i32* %14
br label %687
717: ; preds = %687
br label %718
718: ; preds = %717
%719 = load i32, i32* %13
%720 = add nsw i32 %719, 1
store i32 %720, i32* %13
br label %683
721: ; preds = %683
br label %853
722: ; preds = %634
%723 = load i32, i32* %12
%724 = load i32, i32* %9
%725 = sub nsw i32 %724, 1
%726 = icmp eq i32 %723, %725
br i1 %726, label %727, label %812
727: ; preds = %722
%728 = load float*, float** %6
%729 = load i32, i32* %8
%730 = load i32, i32* %12
%731 = mul nsw i32 %729, %730
%732 = load i32, i32* %11
%733 = sub nsw i32 %732, 1
%734 = add nsw i32 %733, 0
%735 = add nsw i32 %731, %734
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds float, float* %728, i64 %736
%738 = load float, float* %737
%739 = load float**, float*** %15
%740 = getelementptr inbounds float*, float** %739, i64 2
%741 = load float*, float** %740
%742 = getelementptr inbounds float, float* %741, i64 0
store float %738, float* %742
%743 = load float*, float** %6
%744 = load i32, i32* %8
%745 = load i32, i32* %12
%746 = mul nsw i32 %744, %745
%747 = load i32, i32* %11
%748 = sub nsw i32 %747, 1
%749 = add nsw i32 %748, 1
%750 = add nsw i32 %746, %749
%751 = sext i32 %750 to i64
%752 = getelementptr inbounds float, float* %743, i64 %751
%753 = load float, float* %752
%754 = load float**, float*** %15
%755 = getelementptr inbounds float*, float** %754, i64 2
%756 = load float*, float** %755
%757 = getelementptr inbounds float, float* %756, i64 1
store float %753, float* %757
%758 = load float*, float** %6
%759 = load i32, i32* %8
%760 = load i32, i32* %12
%761 = mul nsw i32 %759, %760
%762 = load i32, i32* %11
%763 = sub nsw i32 %762, 1
%764 = add nsw i32 %763, 2
%765 = add nsw i32 %761, %764
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds float, float* %758, i64 %766
%768 = load float, float* %767
%769 = load float**, float*** %15
%770 = getelementptr inbounds float*, float** %769, i64 2
%771 = load float*, float** %770
%772 = getelementptr inbounds float, float* %771, i64 2
store float %768, float* %772
store i32 0, i32* %13
br label %773
773: ; preds = %808, %727
%774 = load i32, i32* %13
%775 = icmp slt i32 %774, 2
br i1 %775, label %776, label %811
776: ; preds = %773
store i32 0, i32* %14
br label %777
777: ; preds = %804, %776
%778 = load i32, i32* %14
%779 = icmp slt i32 %778, 3
br i1 %779, label %780, label %807
780: ; preds = %777
%781 = load float*, float** %6
%782 = load i32, i32* %8
%783 = load i32, i32* %12
%784 = sub nsw i32 %783, 1
%785 = load i32, i32* %13
%786 = add nsw i32 %784, %785
%787 = mul nsw i32 %782, %786
%788 = load i32, i32* %11
%789 = sub nsw i32 %788, 1
%790 = load i32, i32* %14
%791 = add nsw i32 %789, %790
%792 = add nsw i32 %787, %791
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds float, float* %781, i64 %793
%795 = load float, float* %794
%796 = load float**, float*** %15
%797 = load i32, i32* %13
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds float*, float** %796, i64 %798
%800 = load float*, float** %799
%801 = load i32, i32* %14
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds float, float* %800, i64 %802
store float %795, float* %803
br label %804
804: ; preds = %780
%805 = load i32, i32* %14
%806 = add nsw i32 %805, 1
store i32 %806, i32* %14
br label %777
807: ; preds = %777
br label %808
808: ; preds = %807
%809 = load i32, i32* %13
%810 = add nsw i32 %809, 1
store i32 %810, i32* %13
br label %773
811: ; preds = %773
br label %852
812: ; preds = %722
store i32 0, i32* %13
br label %813
813: ; preds = %848, %812
%814 = load i32, i32* %13
%815 = icmp slt i32 %814, 3
br i1 %815, label %816, label %851
816: ; preds = %813
store i32 0, i32* %14
br label %817
817: ; preds = %844, %816
%818 = load i32, i32* %14
%819 = icmp slt i32 %818, 3
br i1 %819, label %820, label %847
820: ; preds = %817
%821 = load float*, float** %6
%822 = load i32, i32* %8
%823 = load i32, i32* %12
%824 = sub nsw i32 %823, 1
%825 = load i32, i32* %13
%826 = add nsw i32 %824, %825
%827 = mul nsw i32 %822, %826
%828 = load i32, i32* %11
%829 = sub nsw i32 %828, 1
%830 = load i32, i32* %14
%831 = add nsw i32 %829, %830
%832 = add nsw i32 %827, %831
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds float, float* %821, i64 %833
%835 = load float, float* %834
%836 = load float**, float*** %15
%837 = load i32, i32* %13
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds float*, float** %836, i64 %838
%840 = load float*, float** %839
%841 = load i32, i32* %14
%842 = sext i32 %841 to i64
%843 = getelementptr inbounds float, float* %840, i64 %842
store float %835, float* %843
br label %844
844: ; preds = %820
%845 = load i32, i32* %14
%846 = add nsw i32 %845, 1
store i32 %846, i32* %14
br label %817
847: ; preds = %817
br label %848
848: ; preds = %847
%849 = load i32, i32* %13
%850 = add nsw i32 %849, 1
store i32 %850, i32* %13
br label %813
851: ; preds = %813
br label %852
852: ; preds = %851, %811
br label %853
853: ; preds = %852, %721
br label %854
854: ; preds = %853, %633
br label %855
855: ; preds = %854, %543
br label %856
856: ; preds = %855, %452
br label %857
857: ; preds = %856, %341
br label %858
858: ; preds = %857, %232
br label %859
859: ; preds = %858, %133
%860 = load float**, float*** %15
%861 = getelementptr inbounds float*, float** %860, i64 1
%862 = load float*, float** %861
%863 = getelementptr inbounds float, float* %862, i64 1
%864 = load float, float* %863
%865 = load float*, float** %7
%866 = load i32, i32* %8
%867 = load i32, i32* %12
%868 = mul nsw i32 %866, %867
%869 = load i32, i32* %11
%870 = add nsw i32 %868, %869
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds float, float* %865, i64 %871
store float %864, float* %872
store i32 0, i32* %13
br label %873
873: ; preds = %960, %859
%874 = load i32, i32* %13
%875 = icmp slt i32 %874, 3
br i1 %875, label %876, label %963
876: ; preds = %873
store i32 0, i32* %14
br label %877
877: ; preds = %956, %876
%878 = load i32, i32* %14
%879 = icmp slt i32 %878, 3
br i1 %879, label %880, label %959
880: ; preds = %877
%881 = load i32, i32* %14
%882 = icmp eq i32 %881, 1
br i1 %882, label %883, label %921
883: ; preds = %880
%884 = load i32, i32* %13
%885 = icmp eq i32 %884, 1
br i1 %885, label %886, label %921
886: ; preds = %883
%887 = load float*, float** %7
%888 = load i32, i32* %8
%889 = load i32, i32* %12
%890 = mul nsw i32 %888, %889
%891 = load i32, i32* %11
%892 = add nsw i32 %890, %891
%893 = sext i32 %892 to i64
%894 = getelementptr inbounds float, float* %887, i64 %893
%895 = load float, float* %894
%896 = fpext float %895 to double
%897 = load float, float* %10
%898 = fpext float %897 to double
%899 = fdiv double %898, 3.000000e+00
%900 = load float**, float*** %15
%901 = load i32, i32* %13
%902 = sext i32 %901 to i64
%903 = getelementptr inbounds float*, float** %900, i64 %902
%904 = load float*, float** %903
%905 = load i32, i32* %14
%906 = sext i32 %905 to i64
%907 = getelementptr inbounds float, float* %904, i64 %906
%908 = load float, float* %907
%909 = fpext float %908 to double
%910 = fmul double -8.000000e+00, %909
%911 = call double @llvm.fmuladd.f64(double %899, double %910, double %896)
%912 = fptrunc double %911 to float
%913 = load float*, float** %7
%914 = load i32, i32* %8
%915 = load i32, i32* %12
%916 = mul nsw i32 %914, %915
%917 = load i32, i32* %11
%918 = add nsw i32 %916, %917
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds float, float* %913, i64 %919
store float %912, float* %920
br label %955
921: ; preds = %883, %880
%922 = load float*, float** %7
%923 = load i32, i32* %8
%924 = load i32, i32* %12
%925 = mul nsw i32 %923, %924
%926 = load i32, i32* %11
%927 = add nsw i32 %925, %926
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds float, float* %922, i64 %928
%930 = load float, float* %929
%931 = fpext float %930 to double
%932 = load float, float* %10
%933 = fpext float %932 to double
%934 = fdiv double %933, 3.000000e+00
%935 = load float**, float*** %15
%936 = load i32, i32* %13
%937 = sext i32 %936 to i64
%938 = getelementptr inbounds float*, float** %935, i64 %937
%939 = load float*, float** %938
%940 = load i32, i32* %14
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds float, float* %939, i64 %941
%943 = load float, float* %942
%944 = fpext float %943 to double
%945 = call double @llvm.fmuladd.f64(double %934, double %944, double %931)
%946 = fptrunc double %945 to float
%947 = load float*, float** %7
%948 = load i32, i32* %8
%949 = load i32, i32* %12
%950 = mul nsw i32 %948, %949
%951 = load i32, i32* %11
%952 = add nsw i32 %950, %951
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds float, float* %947, i64 %953
store float %946, float* %954
br label %955
955: ; preds = %921, %886
br label %956
956: ; preds = %955
%957 = load i32, i32* %14
%958 = add nsw i32 %957, 1
store i32 %958, i32* %14
br label %877
959: ; preds = %877
br label %960
960: ; preds = %959
%961 = load i32, i32* %13
%962 = add nsw i32 %961, 1
store i32 %962, i32* %13
br label %873
963: ; preds = %873
br label %964
964: ; preds = %963
%965 = load i32, i32* %11
%966 = add nsw i32 %965, 1
store i32 %966, i32* %11
br label %47
967: ; preds = %47
br label %968
968: ; preds = %967
%969 = load i32, i32* %12
%970 = add nsw i32 %969, 1
store i32 %970, i32* %12
br label %42
971: ; preds = %42
%972 = load float**, float*** %15
%973 = getelementptr inbounds float*, float** %972, i64 0
%974 = load float*, float** %973
%975 = bitcast float* %974 to i8*
%976 = load float**, float*** %15
%977 = bitcast float** %976 to i8*
ret void
}

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