void aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion(
    float *canal_input, float *canal_output, int width, int height, float dt,
    float a, float t0, float t1, float t2) {
  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 + 0)) + i];
        area[1][0] = canal_input[(width * (j - 1 + 1)) + i];
        area[2][0] = canal_input[(width * (j - 1 + 2)) + 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]);
        }
      }
      canal_output[width * j + i] =
          canal_output[width * j + i] -
          a * dt * (area[1][1] - t0) * (area[1][1] - t1) * (area[1][1] - t2);
    }
  }
  {
    free(area[0]);
    free(area);
  };
}


x86 assembly (clang, -O0):
<aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
movss  %xmm2,-0x24(%rbp)
movss  %xmm3,-0x28(%rbp)
movss  %xmm4,-0x2c(%rbp)
mov    $0x18,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    $0x24,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x3,-0x4c(%rbp)
jge    11b0 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x90>
mov    -0x48(%rbp),%rax
mov    (%rax),%rdx
imul   $0x3,-0x4c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1178 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x58>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1dab <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xc8b>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d98 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xc78>
cmpl   $0x0,-0x30(%rbp)
jne    12d6 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x1b6>
cmpl   $0x0,-0x34(%rbp)
jne    12d6 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x1b6>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    12d1 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x1b1>
movl   $0x1,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    12be <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x19e>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    126b <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x14b>
jmp    12c3 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x1a3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    125a <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x13a>
jmp    1b9d <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa7d>
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    140e <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x2ee>
cmpl   $0x0,-0x34(%rbp)
jne    140e <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x2ee>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%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    -0x48(%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    -0x48(%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    -0x48(%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    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    1409 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x2e9>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x2,-0x3c(%rbp)
jge    13f6 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x2d6>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13a3 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x283>
jmp    13fb <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x2db>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1392 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x272>
jmp    1b98 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa78>
cmpl   $0x0,-0x30(%rbp)
jne    1564 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x444>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1564 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x444>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    155f <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x43f>
movl   $0x1,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    154c <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x42c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14f9 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x3d9>
jmp    1551 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x431>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14e8 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x3c8>
jmp    1b93 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa73>
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16bb <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x59b>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16bb <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x59b>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%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    -0x48(%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    -0x48(%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    -0x48(%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    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    16b6 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x596>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x2,-0x3c(%rbp)
jge    16a3 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x583>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1650 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x530>
jmp    16a8 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x588>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    163f <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x51f>
jmp    1b8e <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa6e>
cmpl   $0x0,-0x30(%rbp)
jne    17c5 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x6a5>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    17c0 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x6a0>
movl   $0x1,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    17ad <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x68d>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    175a <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x63a>
jmp    17b2 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x692>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1749 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x629>
jmp    1b89 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa69>
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    18d9 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x7b9>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    18d4 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x7b4>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x2,-0x3c(%rbp)
jge    18c1 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x7a1>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    186e <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x74e>
jmp    18c6 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x7a6>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    185d <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x73d>
jmp    1b84 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa64>
cmpl   $0x0,-0x34(%rbp)
jne    19e3 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x8c3>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    19de <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x8be>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    19cb <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x8ab>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1978 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x858>
jmp    19d0 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x8b0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1967 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x847>
jmp    1b7f <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa5f>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1af7 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x9d7>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1af2 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x9d2>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    1adf <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x9bf>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a8c <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x96c>
jmp    1ae4 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x9c4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a7b <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x95b>
jmp    1b7a <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa5a>
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    1b75 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa55>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    1b62 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa42>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b0f <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x9ef>
jmp    1b67 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa47>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1afe <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x9de>
jmp    1b7a <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa5a>
jmp    1b7f <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa5f>
jmp    1b84 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa64>
jmp    1b89 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa69>
jmp    1b8e <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa6e>
jmp    1b93 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa73>
jmp    1b98 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa78>
jmp    1b9d <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xa7d>
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    1d01 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xbe1>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    1cee <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xbce>
cmpl   $0x1,-0x3c(%rbp)
jne    1c71 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xb51>
cmpl   $0x1,-0x38(%rbp)
jne    1c71 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xb51>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3df(%rip),%xmm2
divsd  %xmm2,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm3
movsd  0x3c2(%rip),%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1cdb <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xbbb>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x364(%rip),%xmm2
divsd  %xmm2,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%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   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1ce0 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xbc0>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1bd8 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xab8>
jmp    1cf3 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xbd3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bc7 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xaa7>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x20(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm2
subss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm2
subss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm2
subss  -0x2c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ca <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xaa>
jmp    1d9d <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0xc7d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b7 <aan_ecuacion_calor_fuerza_externa_metodo_explicito_una_iteracion+0x97>
mov    -0x48(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

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

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