float *canal_a_m(float *canal_input, int width, int height, float lambda) {
  int i, j, k, l;
  float **area;
  float *canal_k = canal_a_k(canal_input, width, height, lambda);
  float *output = (float *)malloc(sizeof(float) * width * height);
  {
    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++) {
      int x, y;
      float **grad;
      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)];
      }
      output[width * j + i] = 0.0;
      grad = hallar_gradiente(canal_k, width, height, i, j);
      for (y = 0; y < 3; y++)
        for (x = 0; x < 3; x++)
          output[width * j + i] =
              output[width * j + i] + (area[y][x] * grad[y][x]);
      if (output[width * j + i] < 0.0)
        output[width * j + i] = 0.0;
      else if (output[width * j + i] > 1.0)
        output[width * j + i] = 1.0;
      {
        free(grad[0]);
        free(grad);
      };
    }
  }
  {
    free(area[0]);
    free(area);
  };
  free(canal_k);
  return output;
}


x86 assembly (clang, -O0):
<canal_a_m>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1040 <canal_a_k@plt>
cltq
mov    %rax,-0x38(%rbp)
movslq -0xc(%rbp),%rdi
shl    $0x2,%rdi
movslq -0x10(%rbp),%rax
imul   %rax,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    $0x18,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    $0x24,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    11f1 <canal_a_m+0xb1>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdx
imul   $0x3,-0x44(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11b9 <canal_a_m+0x79>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d80 <canal_a_m+0xc40>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d6d <canal_a_m+0xc2d>
cmpl   $0x0,-0x18(%rbp)
jne    1317 <canal_a_m+0x1d7>
cmpl   $0x0,-0x1c(%rbp)
jne    1317 <canal_a_m+0x1d7>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1312 <canal_a_m+0x1d2>
movl   $0x1,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    12ff <canal_a_m+0x1bf>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12ac <canal_a_m+0x16c>
jmp    1304 <canal_a_m+0x1c4>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    129b <canal_a_m+0x15b>
jmp    1bde <canal_a_m+0xa9e>
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    144f <canal_a_m+0x30f>
cmpl   $0x0,-0x1c(%rbp)
jne    144f <canal_a_m+0x30f>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    144a <canal_a_m+0x30a>
movl   $0x0,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jge    1437 <canal_a_m+0x2f7>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13e4 <canal_a_m+0x2a4>
jmp    143c <canal_a_m+0x2fc>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13d3 <canal_a_m+0x293>
jmp    1bd9 <canal_a_m+0xa99>
cmpl   $0x0,-0x18(%rbp)
jne    15a5 <canal_a_m+0x465>
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    15a5 <canal_a_m+0x465>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x2,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    15a0 <canal_a_m+0x460>
movl   $0x1,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    158d <canal_a_m+0x44d>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    153a <canal_a_m+0x3fa>
jmp    1592 <canal_a_m+0x452>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1529 <canal_a_m+0x3e9>
jmp    1bd4 <canal_a_m+0xa94>
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16fc <canal_a_m+0x5bc>
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16fc <canal_a_m+0x5bc>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    16f7 <canal_a_m+0x5b7>
movl   $0x0,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jge    16e4 <canal_a_m+0x5a4>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1691 <canal_a_m+0x551>
jmp    16e9 <canal_a_m+0x5a9>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1680 <canal_a_m+0x540>
jmp    1bcf <canal_a_m+0xa8f>
cmpl   $0x0,-0x18(%rbp)
jne    1806 <canal_a_m+0x6c6>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1801 <canal_a_m+0x6c1>
movl   $0x1,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    17ee <canal_a_m+0x6ae>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    179b <canal_a_m+0x65b>
jmp    17f3 <canal_a_m+0x6b3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    178a <canal_a_m+0x64a>
jmp    1bca <canal_a_m+0xa8a>
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    191a <canal_a_m+0x7da>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1915 <canal_a_m+0x7d5>
movl   $0x0,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jge    1902 <canal_a_m+0x7c2>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    18af <canal_a_m+0x76f>
jmp    1907 <canal_a_m+0x7c7>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    189e <canal_a_m+0x75e>
jmp    1bc5 <canal_a_m+0xa85>
cmpl   $0x0,-0x1c(%rbp)
jne    1a24 <canal_a_m+0x8e4>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1a1f <canal_a_m+0x8df>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    1a0c <canal_a_m+0x8cc>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    19b9 <canal_a_m+0x879>
jmp    1a11 <canal_a_m+0x8d1>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    19a8 <canal_a_m+0x868>
jmp    1bc0 <canal_a_m+0xa80>
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1b38 <canal_a_m+0x9f8>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    1b33 <canal_a_m+0x9f3>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    1b20 <canal_a_m+0x9e0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1acd <canal_a_m+0x98d>
jmp    1b25 <canal_a_m+0x9e5>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1abc <canal_a_m+0x97c>
jmp    1bbb <canal_a_m+0xa7b>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1bb6 <canal_a_m+0xa76>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    1ba3 <canal_a_m+0xa63>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1b50 <canal_a_m+0xa10>
jmp    1ba8 <canal_a_m+0xa68>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1b3f <canal_a_m+0x9ff>
jmp    1bbb <canal_a_m+0xa7b>
jmp    1bc0 <canal_a_m+0xa80>
jmp    1bc5 <canal_a_m+0xa85>
jmp    1bca <canal_a_m+0xa8a>
jmp    1bcf <canal_a_m+0xa8f>
jmp    1bd4 <canal_a_m+0xa94>
jmp    1bd9 <canal_a_m+0xa99>
jmp    1bde <canal_a_m+0xa9e>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    $0x0,%al
call   1060 <hallar_gradiente@plt>
cltq
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x3,-0x4c(%rbp)
jge    1cb6 <canal_a_m+0xb76>
movl   $0x0,-0x48(%rbp)
cmpl   $0x3,-0x48(%rbp)
jge    1ca3 <canal_a_m+0xb63>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1c2d <canal_a_m+0xaed>
jmp    1ca8 <canal_a_m+0xb68>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1c1c <canal_a_m+0xadc>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1cfb <canal_a_m+0xbbb>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1d4a <canal_a_m+0xc0a>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2e3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1d45 <canal_a_m+0xc05>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  0x2c8(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1d4a <canal_a_m+0xc0a>
mov    -0x58(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    120b <canal_a_m+0xcb>
jmp    1d72 <canal_a_m+0xc32>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11f8 <canal_a_m+0xb8>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<canal_a_m>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
mov    %edx,%r15d
mov    %esi,%ebp
cvtss2sd %xmm0,%xmm0
mov    %rdi,0x98(%rsp)
mov    $0x1,%al
call   1040 <canal_a_k@plt>
cltq
mov    %rax,0xa0(%rsp)
movslq %ebp,%r12
movslq %r15d,%r14
mov    %r12,%rdi
imul   %r14,%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    $0x18,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    $0x24,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %rax,0x0(%r13)
add    $0xc,%rax
mov    %rax,0x8(%r13)
lea    0x18(%rbx),%rax
mov    %r13,(%rsp)
mov    %rax,0x10(%r13)
test   %r14d,%r14d
jle    1c07 <canal_a_m+0xac7>
mov    %r12d,%esi
lea    -0x1(%r12),%edx
lea    -0x1(%r15),%edi
mov    %r15d,%eax
imul   %ebp,%eax
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
mov    %rcx,0xf0(%rsp)
mov    %rdi,0x18(%rsp)
mov    %edi,%ecx
imul   %ebp,%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
mov    %rcx,0xe8(%rsp)
add    $0xfffffffe,%eax
cltq
mov    %rax,0xe0(%rsp)
mov    %rdx,%rax
mov    %rdx,0x8(%rsp)
movslq %edx,%rax
mov    %rax,0x1a8(%rsp)
lea    -0x2(%r12),%eax
mov    %rax,0xd8(%rsp)
cltq
mov    %rax,0x88(%rsp)
lea    (%r12,%r12,1),%eax
add    $0xffffffff,%eax
movslq %eax,%rcx
mov    %rbx,%rax
add    $0x10,%rax
mov    %rax,0xd0(%rsp)
lea    (%r12,%r12,1),%eax
add    $0xfffffffe,%eax
cltq
mov    %rax,0x198(%rsp)
lea    0x1(%r12),%eax
cltq
mov    0x98(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
mov    %rax,0x1b0(%rsp)
mov    %r12,%rax
shl    $0x20,%rax
mov    %rax,0xc8(%rsp)
mov    %r15d,%eax
mov    %rax,0x148(%rsp)
lea    0x20(%rbx),%rax
mov    %rax,0x10(%rsp)
lea    0x14(%rbx),%rax
mov    %rax,0x60(%rsp)
lea    0x1c(%rbx),%rax
mov    %rax,0x80(%rsp)
mov    %rcx,0x1a0(%rsp)
lea    (%rdx,%rcx,4),%rax
mov    %rax,0x190(%rsp)
mov    %r12,0x90(%rsp)
lea    0x0(,%r12,4),%rax
mov    %rax,0xc0(%rsp)
mov    %rbx,%r12
xor    %r8d,%r8d
mov    %rdx,%rcx
mov    %ebp,0x24(%rsp)
mov    %r15,0x1b8(%rsp)
jmp    131d <canal_a_m+0x1dd>
nopl   0x0(%rax,%rax,1)
mov    0x160(%rsp),%rax
mov    %rax,%r8
mov    0x24(%rsp),%ebp
cmp    0x148(%rsp),%rax
je     1c0a <canal_a_m+0xaca>
test   %ebp,%ebp
jle    1bf0 <canal_a_m+0xab0>
lea    -0x1(%r8),%rdx
mov    %r8,%r9
mov    0x90(%rsp),%rax
imul   %rax,%r9
mov    %rdx,%r10
imul   %rax,%r10
lea    0x1(%r8),%rdi
mov    %rdi,0x160(%rsp)
mov    %rdi,%r11
imul   %rax,%r11
lea    -0x2(%r8),%rdi
imul   %rax,%rdi
mov    %rdi,0x188(%rsp)
lea    0x1(%r8),%r14d
imul   %ebp,%r14d
mov    0xd8(%rsp),%rbp
lea    (%r10,%rbp,1),%eax
cltq
mov    %rax,0x58(%rsp)
mov    0x88(%rsp),%rdi
lea    0x1(%rdi,%r10,1),%eax
cltq
mov    %rax,0x140(%rsp)
lea    0x0(%rbp,%r9,1),%eax
cltq
mov    %rax,0x50(%rsp)
lea    0x1(%rdi,%r9,1),%eax
cltq
mov    %rax,0x138(%rsp)
lea    0x0(%rbp,%r14,1),%eax
cltq
mov    %rax,0x130(%rsp)
lea    0x1(%rdi,%r14,1),%eax
cltq
lea    (%rcx,%rax,4),%rax
mov    %rax,0x128(%rsp)
mov    %r10,%rbp
shl    $0x20,%rbp
movabs $0x100000000,%r12
add    %r12,%rbp
sar    $0x20,%rbp
mov    %rbp,0x68(%rsp)
mov    %r9,%rbp
shl    $0x20,%rbp
add    %r12,%rbp
mov    %rbp,%rax
sar    $0x20,%rax
mov    %rax,0x170(%rsp)
mov    %r11,%rax
shl    $0x20,%rax
add    %r12,%rax
sar    $0x1e,%rax
add    %rcx,%rax
mov    %rax,0x168(%rsp)
lea    (%rdi,%r10,1),%eax
add    $0x1,%eax
cltq
mov    %rax,0x158(%rsp)
lea    0x1(%rdi,%r9,1),%eax
cltq
lea    (%rcx,%rax,4),%rax
mov    %rax,0x150(%rsp)
sar    $0x1e,%rbp
add    %rcx,%rbp
mov    %rbp,0x180(%rsp)
mov    0xc8(%rsp),%rax
mov    %rax,%rdi
imul   %r8,%rdi
imul   %rax,%rdx
mov    %r14,0x108(%rsp)
add    $0xffffffff,%r14d
mov    %r14,0x100(%rsp)
mov    0xc0(%rsp),%rax
imul   %r8,%rax
add    0x28(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    0x8(%rsp),%rax
lea    (%r10,%rax,1),%rbp
mov    %rbp,0x120(%rsp)
lea    (%r9,%rax,1),%rbp
mov    %rbp,0x118(%rsp)
mov    %r11,0x178(%rsp)
add    %r11,%rax
mov    %rax,0x110(%rsp)
lea    -0x1(%r10),%eax
mov    %rax,0x48(%rsp)
mov    %r10,0x70(%rsp)
mov    %r10d,%eax
mov    %rax,0x40(%rsp)
mov    %r9d,%eax
mov    %rax,0x38(%rsp)
lea    -0x1(%r9),%eax
mov    %rax,0x30(%rsp)
mov    %r9,0x78(%rsp)
lea    (%rcx,%r9,4),%rax
mov    %rax,0xf8(%rsp)
xor    %r13d,%r13d
mov    %r8,0x1c0(%rsp)
jmp    1579 <canal_a_m+0x439>
nopl   0x0(%rax,%rax,1)
mov    0xa8(%rsp),%rax
movss  %xmm0,(%rax,%r13,4)
mov    (%r15),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
add    $0x1,%r13
movabs $0x100000000,%rax
mov    0xb0(%rsp),%rdi
add    %rax,%rdi
mov    0xb8(%rsp),%rdx
add    %rax,%rdx
mov    %rbp,%rsi
cmp    %r13,%rbp
mov    0x1b8(%rsp),%r15
mov    0x98(%rsp),%rcx
mov    0x1c0(%rsp),%r8
mov    %r14,%rbx
je     1300 <canal_a_m+0x1c0>
mov    %r13,%rax
or     %r8,%rax
mov    %rdx,0xb8(%rsp)
mov    %rdi,0xb0(%rsp)
jne    1600 <canal_a_m+0x4c0>
movss  (%rcx),%xmm0
mov    (%rsp),%rax
mov    (%rax),%r12
movss  %xmm0,(%r12)
movss  (%rcx),%xmm0
movss  %xmm0,0x4(%r12)
movss  0x4(%rcx),%xmm0
movss  %xmm0,0x8(%r12)
movss  (%rcx),%xmm0
movss  %xmm0,0xc(%rbx)
mov    0x90(%rsp),%rax
movss  (%rcx,%rax,4),%xmm1
movss  %xmm1,0x18(%rbx)
movss  %xmm0,0x10(%rbx)
movss  0x4(%rcx),%xmm0
movss  %xmm0,0x14(%rbx)
movss  %xmm1,0x1c(%rbx)
mov    0x1b0(%rsp),%rax
mov    0x10(%rsp),%rcx
jmp    1730 <canal_a_m+0x5f0>
nopw   0x0(%rax,%rax,1)
cmp    %r13,0x8(%rsp)
jne    16a0 <canal_a_m+0x560>
test   %r8,%r8
jne    16a0 <canal_a_m+0x560>
mov    0x1a8(%rsp),%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    (%rsp),%rax
mov    (%rax),%r12
movss  %xmm0,0x8(%r12)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%r12)
mov    0x88(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%r12)
mov    0x1a0(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  (%rcx,%rdx,4),%xmm1
movss  %xmm0,0x20(%rbx)
mov    0x8(%rsp),%rax
movsd  -0x4(%rcx,%rax,4),%xmm0
mov    0x198(%rsp),%rax
movss  (%rcx,%rax,4),%xmm2
movlhps %xmm1,%xmm2
shufps $0x24,%xmm2,%xmm0
movups %xmm0,0xc(%rbx)
mov    0x190(%rsp),%rax
mov    0x80(%rsp),%rcx
jmp    1730 <canal_a_m+0x5f0>
nopl   (%rax)
test   %r13,%r13
jne    1811 <canal_a_m+0x6d1>
cmp    0x18(%rsp),%r8
jne    1811 <canal_a_m+0x6d1>
mov    0x70(%rsp),%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    (%rsp),%rax
mov    (%rax),%r12
movss  %xmm0,0x8(%r12)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%r12)
mov    0x188(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%r12)
movss  0x4(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x20(%rbx)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%r12)
mov    0x68(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x8(%r12)
mov    0x78(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x10(%rbx)
mov    0x180(%rsp),%rax
mov    0x60(%rsp),%rcx
nop
movss  (%rax),%xmm0
movss  %xmm0,(%rcx)
mov    0xa0(%rsp),%rdi
mov    %rsi,%rbp
mov    %r15d,%edx
mov    %r13d,%ecx
xor    %eax,%eax
call   1060 <hallar_gradiente@plt>
movslq %eax,%r15
movss  (%r12),%xmm1
movss  0x4(%r12),%xmm2
mov    (%r15),%rax
mov    0x8(%r15),%rcx
mulss  (%rax),%xmm1
xorps  %xmm0,%xmm0
addss  %xmm0,%xmm1
mulss  0x4(%rax),%xmm2
addss  %xmm1,%xmm2
movss  0x8(%r12),%xmm1
mulss  0x8(%rax),%xmm1
addss  %xmm2,%xmm1
movss  0xc(%rbx),%xmm2
movss  0x10(%rbx),%xmm3
mulss  (%rcx),%xmm2
addss  %xmm1,%xmm2
mulss  0x4(%rcx),%xmm3
addss  %xmm2,%xmm3
movss  0x14(%rbx),%xmm1
mulss  0x8(%rcx),%xmm1
addss  %xmm3,%xmm1
mov    0x10(%r15),%rax
movss  0x18(%rbx),%xmm2
mulss  (%rax),%xmm2
addss  %xmm1,%xmm2
movss  0x1c(%rbx),%xmm3
mulss  0x4(%rax),%xmm3
addss  %xmm2,%xmm3
mov    %rbx,%r14
movss  0x20(%rbx),%xmm1
mulss  0x8(%rax),%xmm1
addss  %xmm3,%xmm1
mov    0xa8(%rsp),%rax
movss  %xmm1,(%rax,%r13,4)
ucomiss %xmm1,%xmm0
ja     1510 <canal_a_m+0x3d0>
movss  0x7fd(%rip),%xmm0
ucomiss %xmm0,%xmm1
ja     1510 <canal_a_m+0x3d0>
jmp    151e <canal_a_m+0x3de>
cmp    %r13,0x8(%rsp)
jne    18bd <canal_a_m+0x77d>
cmp    0x18(%rsp),%r8
jne    197e <canal_a_m+0x83e>
mov    0xf0(%rsp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x20(%rbx)
movss  %xmm0,0x14(%rbx)
mov    0xe8(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
mov    (%rsp),%rax
mov    (%rax),%r12
movss  %xmm0,0x8(%r12)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x1c(%rbx)
mov    0xe0(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x18(%rbx)
mov    0x58(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%r12)
mov    0x158(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%r12)
mov    0x50(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx)
mov    0x150(%rsp),%rax
mov    0xd0(%rsp),%rcx
jmp    1730 <canal_a_m+0x5f0>
test   %r13,%r13
je     1a32 <canal_a_m+0x8f2>
test   %r8,%r8
je     1aba <canal_a_m+0x97a>
cmp    0x18(%rsp),%r8
jne    1b1d <canal_a_m+0x9dd>
mov    0xf8(%rsp),%rax
movss  -0x4(%rax,%r13,4),%xmm0
movss  %xmm0,0x18(%rbx)
movss  (%rax,%r13,4),%xmm0
movss  %xmm0,0x1c(%rbx)
movss  0x4(%rax,%r13,4),%xmm0
movss  %xmm0,0x20(%rbx)
mov    0x48(%rsp),%rax
add    %r13d,%eax
mov    (%rsp),%rdx
mov    (%rdx),%r12
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%r12)
mov    0x40(%rsp),%rax
add    %r13,%rax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%r12)
add    $0x1,%eax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x8(%r12)
mov    0x30(%rsp),%rax
add    %r13d,%eax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx)
mov    0x38(%rsp),%rax
add    %r13,%rax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x10(%rbx)
add    $0x1,%eax
cltq
lea    (%rcx,%rax,4),%rax
jmp    172a <canal_a_m+0x5ea>
test   %r13,%r13
je     1a32 <canal_a_m+0x8f2>
mov    0x120(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
mov    (%rsp),%rax
mov    (%rax),%r12
movss  %xmm0,0x8(%r12)
mov    0x118(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x14(%rbx)
mov    0x110(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x20(%rbx)
mov    0x58(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%r12)
mov    0x140(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%r12)
mov    0x50(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx)
mov    0x138(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x10(%rbx)
mov    0x130(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x18(%rbx)
mov    0x128(%rsp),%rax
mov    0x80(%rsp),%rcx
jmp    1730 <canal_a_m+0x5f0>
mov    0x70(%rsp),%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    (%rsp),%rax
mov    (%rax),%r12
movss  %xmm0,(%r12)
mov    0x78(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx)
mov    0x178(%rsp),%rdi
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0x18(%rbx)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%r12)
mov    0x68(%rsp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x8(%r12)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x10(%rbx)
mov    0x170(%rsp),%rax
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x14(%rbx)
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0x1c(%rbx)
mov    0x168(%rsp),%rax
jmp    15f0 <canal_a_m+0x4b0>
movss  -0x4(%rcx,%r13,4),%xmm0
mov    (%rsp),%rax
mov    (%rax),%r12
movss  %xmm0,(%r12)
movss  (%rcx,%r13,4),%xmm0
movss  %xmm0,0x4(%r12)
movss  0x4(%rcx,%r13,4),%xmm0
movss  %xmm0,0x8(%r12)
movsd  (%rcx,%r13,4),%xmm0
mov    0x8(%rsp),%rax
add    %r13d,%eax
cltq
movss  -0x4(%rcx,%r13,4),%xmm1
movlhps %xmm0,%xmm1
movss  (%rcx,%rax,4),%xmm2
shufps $0xd4,%xmm0,%xmm2
shufps $0x28,%xmm2,%xmm1
movups %xmm1,0xc(%rbx)
lea    (%rsi,%r13,1),%rax
jmp    1bcd <canal_a_m+0xa8d>
mov    0x48(%rsp),%rax
add    %r13d,%eax
mov    (%rsp),%rdx
mov    (%rdx),%r12
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%r12)
mov    0xb8(%rsp),%rax
sar    $0x1e,%rax
movss  (%rcx,%rax,1),%xmm0
movss  %xmm0,0x4(%r12)
mov    0x40(%rsp),%rax
add    %r13d,%eax
add    $0x1,%eax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x8(%r12)
mov    0x30(%rsp),%rax
add    %r13d,%eax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx)
mov    0xb0(%rsp),%rax
sar    $0x1e,%rax
movss  (%rcx,%rax,1),%xmm0
movss  %xmm0,0x10(%rbx)
mov    0x38(%rsp),%rax
add    %r13d,%eax
add    $0x1,%eax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x14(%rbx)
mov    0x100(%rsp),%rax
add    %r13d,%eax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x18(%rbx)
mov    0x108(%rsp),%rax
add    %r13,%rax
cltq
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x1c(%rbx)
add    $0x1,%eax
cltq
lea    (%rcx,%rax,4),%rax
jmp    15f0 <canal_a_m+0x4b0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
mov    %r8,%rax
cmp    0x148(%rsp),%rax
jne    131d <canal_a_m+0x1dd>
jmp    1c0a <canal_a_m+0xaca>
mov    %rbx,%r12
mov    %r12,%rdi
call   1030 <free@plt>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rax
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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