float **hallar_gradiente(float *canal_input, int width, int height, int i,
                         int j) {
  int k, l;
  float **area;
  float **grad;
  {
    int ml;
    grad = (float **)malloc(sizeof(float *) * (3));
    grad[0] = (float *)malloc(sizeof(float) * (3) * (3));
    for (ml = 0; ml < (3); ml++)
      grad[ml] = &(grad[0][ml * (3)]);
  };
  {
    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)]);
  };
  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)];
  }
  grad[0][0] = 0.0;
  grad[0][1] = area[1][1] + area[2][1];
  grad[0][2] = 0.0;
  grad[1][0] = area[1][1] + area[1][0];
  grad[1][2] = area[1][1] + area[1][2];
  grad[2][0] = 0.0;
  grad[2][1] = area[1][1] + area[0][1];
  grad[2][2] = 0.0;
  grad[1][1] =
      -area[1][2] - area[1][0] - 4 * area[1][1] - area[2][1] - area[0][1];
  {
    free(area[0]);
    free(area);
  };
  return grad;
}


x86 assembly (clang, -O0):
<hallar_gradiente>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    $0x18,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    $0x24,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    119a <hallar_gradiente+0x7a>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdx
imul   $0x3,-0x34(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1162 <hallar_gradiente+0x42>
mov    $0x18,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    $0x24,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    11fb <hallar_gradiente+0xdb>
mov    -0x28(%rbp),%rax
mov    (%rax),%rdx
imul   $0x3,-0x38(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11c3 <hallar_gradiente+0xa3>
cmpl   $0x0,-0x14(%rbp)
jne    12fb <hallar_gradiente+0x1db>
cmpl   $0x0,-0x18(%rbp)
jne    12fb <hallar_gradiente+0x1db>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    12f6 <hallar_gradiente+0x1d6>
movl   $0x1,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    12e3 <hallar_gradiente+0x1c3>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1290 <hallar_gradiente+0x170>
jmp    12e8 <hallar_gradiente+0x1c8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    127f <hallar_gradiente+0x15f>
jmp    1bc2 <hallar_gradiente+0xaa2>
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1433 <hallar_gradiente+0x313>
cmpl   $0x0,-0x18(%rbp)
jne    1433 <hallar_gradiente+0x313>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%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    -0x28(%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    -0x28(%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    -0x28(%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    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    142e <hallar_gradiente+0x30e>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    141b <hallar_gradiente+0x2fb>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13c8 <hallar_gradiente+0x2a8>
jmp    1420 <hallar_gradiente+0x300>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13b7 <hallar_gradiente+0x297>
jmp    1bbd <hallar_gradiente+0xa9d>
cmpl   $0x0,-0x14(%rbp)
jne    1589 <hallar_gradiente+0x469>
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1589 <hallar_gradiente+0x469>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x2,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jge    1584 <hallar_gradiente+0x464>
movl   $0x1,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1571 <hallar_gradiente+0x451>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    151e <hallar_gradiente+0x3fe>
jmp    1576 <hallar_gradiente+0x456>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    150d <hallar_gradiente+0x3ed>
jmp    1bb8 <hallar_gradiente+0xa98>
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16e0 <hallar_gradiente+0x5c0>
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16e0 <hallar_gradiente+0x5c0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%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    -0x28(%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    -0x28(%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    -0x28(%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    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jge    16db <hallar_gradiente+0x5bb>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    16c8 <hallar_gradiente+0x5a8>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1675 <hallar_gradiente+0x555>
jmp    16cd <hallar_gradiente+0x5ad>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1664 <hallar_gradiente+0x544>
jmp    1bb3 <hallar_gradiente+0xa93>
cmpl   $0x0,-0x14(%rbp)
jne    17ea <hallar_gradiente+0x6ca>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    17e5 <hallar_gradiente+0x6c5>
movl   $0x1,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    17d2 <hallar_gradiente+0x6b2>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    177f <hallar_gradiente+0x65f>
jmp    17d7 <hallar_gradiente+0x6b7>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    176e <hallar_gradiente+0x64e>
jmp    1bae <hallar_gradiente+0xa8e>
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    18fe <hallar_gradiente+0x7de>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    18f9 <hallar_gradiente+0x7d9>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    18e6 <hallar_gradiente+0x7c6>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1893 <hallar_gradiente+0x773>
jmp    18eb <hallar_gradiente+0x7cb>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1882 <hallar_gradiente+0x762>
jmp    1ba9 <hallar_gradiente+0xa89>
cmpl   $0x0,-0x18(%rbp)
jne    1a08 <hallar_gradiente+0x8e8>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1a03 <hallar_gradiente+0x8e3>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    19f0 <hallar_gradiente+0x8d0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    199d <hallar_gradiente+0x87d>
jmp    19f5 <hallar_gradiente+0x8d5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    198c <hallar_gradiente+0x86c>
jmp    1ba4 <hallar_gradiente+0xa84>
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1b1c <hallar_gradiente+0x9fc>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jge    1b17 <hallar_gradiente+0x9f7>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1b04 <hallar_gradiente+0x9e4>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1ab1 <hallar_gradiente+0x991>
jmp    1b09 <hallar_gradiente+0x9e9>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1aa0 <hallar_gradiente+0x980>
jmp    1b9f <hallar_gradiente+0xa7f>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1b9a <hallar_gradiente+0xa7a>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1b87 <hallar_gradiente+0xa67>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    -0x1c(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1b34 <hallar_gradiente+0xa14>
jmp    1b8c <hallar_gradiente+0xa6c>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1b23 <hallar_gradiente+0xa03>
jmp    1b9f <hallar_gradiente+0xa7f>
jmp    1ba4 <hallar_gradiente+0xa84>
jmp    1ba9 <hallar_gradiente+0xa89>
jmp    1bae <hallar_gradiente+0xa8e>
jmp    1bb3 <hallar_gradiente+0xa93>
jmp    1bb8 <hallar_gradiente+0xa98>
jmp    1bbd <hallar_gradiente+0xa9d>
jmp    1bc2 <hallar_gradiente+0xaa2>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
addss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
addss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
addss  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
addss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
subss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
movss  0x32f(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
subss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
subss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hallar_gradiente>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r8d,%r13d
mov    %ecx,%ebx
mov    %edx,%ebp
mov    %esi,%r12d
mov    %rdi,%r15
mov    $0x18,%edi
call   1030 <malloc@plt>
mov    %rax,%r14
mov    $0x24,%edi
call   1030 <malloc@plt>
mov    %rax,(%r14)
lea    0xc(%rax),%rcx
mov    %rcx,0x8(%r14)
mov    %rax,%rcx
add    $0x18,%rcx
mov    %rcx,0x10(%r14)
mov    %r13d,%ecx
or     %ebx,%ecx
je     1191 <hallar_gradiente+0x81>
lea    -0x1(%r12),%edx
cmp    %ebx,%edx
jne    11b0 <hallar_gradiente+0xa0>
test   %r13d,%r13d
jne    11b0 <hallar_gradiente+0xa0>
movslq %ebx,%rcx
movss  -0x4(%r15,%rcx,4),%xmm2
movss  (%r15,%rcx,4),%xmm0
add    %ebx,%r12d
movslq %r12d,%rcx
movss  (%r15,%rcx,4),%xmm3
movaps %xmm0,%xmm1
movaps %xmm0,%xmm4
jmp    13e1 <hallar_gradiente+0x2d1>
movss  (%r15),%xmm0
movss  0x4(%r15),%xmm1
movslq %r12d,%rcx
movss  (%r15,%rcx,4),%xmm3
movaps %xmm0,%xmm2
movaps %xmm0,%xmm4
jmp    13e1 <hallar_gradiente+0x2d1>
lea    -0x1(%rbp),%ecx
test   %ebx,%ebx
jne    11fa <hallar_gradiente+0xea>
cmp    %r13d,%ecx
jne    11fa <hallar_gradiente+0xea>
movslq %r13d,%rcx
lea    -0x1(%rcx),%rdx
movslq %r12d,%rsi
imul   %rsi,%rdx
movss  (%r15,%rdx,4),%xmm0
imul   %rsi,%rcx
movss  (%r15,%rcx,4),%xmm4
shl    $0x20,%rcx
movabs $0x100000000,%rdx
add    %rcx,%rdx
sar    $0x1e,%rdx
movss  (%r15,%rdx,1),%xmm1
jmp    13e1 <hallar_gradiente+0x2d1>
cmp    %ebx,%edx
jne    1250 <hallar_gradiente+0x140>
cmp    %r13d,%ecx
jne    12b5 <hallar_gradiente+0x1a5>
imul   %r12d,%ebp
movslq %ebp,%rcx
movss  -0x4(%r15,%rcx,4),%xmm1
lea    -0x1(%r13),%ecx
imul   %r12d,%ecx
add    %ebx,%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm0
imul   %r12d,%r13d
lea    (%rbx,%r13,1),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm2
add    %ebx,%r13d
movslq %r13d,%rcx
movss  (%r15,%rcx,4),%xmm4
movaps %xmm1,%xmm3
jmp    13e1 <hallar_gradiente+0x2d1>
test   %ebx,%ebx
je     130a <hallar_gradiente+0x1fa>
test   %r13d,%r13d
je     135d <hallar_gradiente+0x24d>
cmp    %r13d,%ecx
jne    138a <hallar_gradiente+0x27a>
mov    %r13d,%ecx
imul   %r12d,%ecx
lea    (%rcx,%rbx,1),%edx
movslq %edx,%rdx
movss  (%r15,%rdx,4),%xmm3
add    $0xffffffff,%r13d
imul   %r12d,%r13d
add    %ebx,%r13d
movslq %r13d,%rdx
movss  (%r15,%rdx,4),%xmm0
lea    (%rcx,%rbx,1),%edx
add    $0xffffffff,%edx
movslq %edx,%rdx
movss  (%r15,%rdx,4),%xmm2
lea    0x1(%rcx,%rbx,1),%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm1
movaps %xmm3,%xmm4
jmp    13e1 <hallar_gradiente+0x2d1>
test   %ebx,%ebx
je     130a <hallar_gradiente+0x1fa>
lea    -0x1(%r13),%ecx
mov    %r13d,%edx
imul   %r12d,%edx
lea    (%rdx,%rbx,1),%esi
movslq %esi,%rsi
movss  (%r15,%rsi,4),%xmm1
imul   %r12d,%ecx
add    %ebx,%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm0
lea    (%rdx,%rbx,1),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm2
add    $0x1,%r13d
imul   %r12d,%r13d
add    %ebx,%r13d
movslq %r13d,%rcx
movss  (%r15,%rcx,4),%xmm3
movaps %xmm1,%xmm4
jmp    13e1 <hallar_gradiente+0x2d1>
movslq %r13d,%rcx
lea    -0x1(%rcx),%rdx
imul   %r12d,%r13d
movslq %r13d,%rsi
movss  (%r15,%rsi,4),%xmm2
movslq %r12d,%rsi
imul   %rsi,%rdx
movss  (%r15,%rdx,4),%xmm0
mov    %rcx,%rdx
imul   %rsi,%rdx
movss  (%r15,%rdx,4),%xmm4
shl    $0x20,%rdx
movabs $0x100000000,%rdi
add    %rdx,%rdi
sar    $0x1e,%rdi
movss  (%r15,%rdi,1),%xmm1
add    $0x1,%rcx
imul   %rsi,%rcx
jmp    13db <hallar_gradiente+0x2cb>
movslq %ebx,%rcx
movss  -0x4(%r15,%rcx,4),%xmm2
movss  (%r15,%rcx,4),%xmm0
lea    0x1(%rbx),%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm1
add    %ebx,%r12d
movslq %r12d,%rcx
movss  (%r15,%rcx,4),%xmm3
movaps %xmm0,%xmm4
jmp    13e1 <hallar_gradiente+0x2d1>
lea    -0x1(%r13),%ecx
imul   %r12d,%ecx
add    %ebx,%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm0
mov    %r13d,%ecx
imul   %r12d,%ecx
lea    (%rcx,%rbx,1),%edx
add    $0xffffffff,%edx
movslq %edx,%rdx
movss  (%r15,%rdx,4),%xmm2
lea    (%rcx,%rbx,1),%edx
add    $0x1,%edx
add    %ebx,%ecx
movslq %ecx,%rcx
movss  (%r15,%rcx,4),%xmm4
movslq %edx,%rcx
movss  (%r15,%rcx,4),%xmm1
add    $0x1,%r13d
imul   %r12d,%r13d
add    %ebx,%r13d
movslq %r13d,%rcx
movss  (%r15,%rcx,4),%xmm3
movl   $0x0,(%rax)
movaps %xmm4,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,0x4(%rax)
movl   $0x0,0x8(%rax)
movaps %xmm4,%xmm5
addss  %xmm2,%xmm5
movss  %xmm5,0xc(%rax)
movaps %xmm4,%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,0x14(%rax)
movl   $0x0,0x18(%rax)
movaps %xmm4,%xmm5
addss  %xmm0,%xmm5
movss  %xmm5,0x1c(%rax)
xorps  0xbd4(%rip),%xmm1
movl   $0x0,0x20(%rax)
subss  %xmm2,%xmm1
mulss  0xbd1(%rip),%xmm4
addss  %xmm1,%xmm4
subss  %xmm3,%xmm4
subss  %xmm0,%xmm4
movss  %xmm4,0x10(%rax)
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define noalias float** @hallar_gradiente(float* %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = tail call dereferenceable_or_null(24) i8* @malloc(i64 24)
%7 = bitcast i8* %6 to float**
%8 = tail call dereferenceable_or_null(36) i8* @malloc(i64 36)
%9 = bitcast i8* %8 to float*
%10 = bitcast i8* %6 to i8**
store i8* %8, i8** %10
%11 = getelementptr inbounds float, float* %9, i64 3
%12 = getelementptr inbounds float*, float** %7, i64 1
store float* %11, float** %12
%13 = getelementptr inbounds float, float* %9, i64 6
%14 = getelementptr inbounds float*, float** %7, i64 2
store float* %13, float** %14
%15 = icmp eq i32 %3, 0
%16 = icmp eq i32 %4, 0
%17 = or i32 %4, %3
%18 = icmp eq i32 %17, 0
br i1 %18, label %19, label %26
19: ; preds = %5
%20 = load float, float* %0
%21 = getelementptr inbounds float, float* %0, i64 1
%22 = load float, float* %21
%23 = sext i32 %1 to i64
%24 = getelementptr inbounds float, float* %0, i64 %23
%25 = load float, float* %24
br label %211
26: ; preds = %5
%27 = add nsw i32 %1, -1
%28 = icmp eq i32 %27, %3
%29 = and i1 %28, %16
br i1 %29, label %30, label %42
30: ; preds = %26
%31 = sext i32 %3 to i64
%32 = getelementptr inbounds float, float* %0, i64 %31
%33 = load float, float* %32
%34 = add nsw i32 %3, -1
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %0, i64 %35
%37 = load float, float* %36
%38 = add i32 %3, %1
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %0, i64 %39
%41 = load float, float* %40
br label %211
42: ; preds = %26
%43 = add nsw i32 %2, -1
%44 = icmp eq i32 %43, %4
%45 = select i1 %15, i1 %44, i1 false
br i1 %45, label %46, label %62
46: ; preds = %42
%47 = add nsw i32 %4, -1
%48 = sext i32 %47 to i64
%49 = sext i32 %1 to i64
%50 = mul nsw i64 %48, %49
%51 = getelementptr inbounds float, float* %0, i64 %50
%52 = load float, float* %51
%53 = add nsw i64 %48, 1
%54 = mul nsw i64 %53, %49
%55 = getelementptr inbounds float, float* %0, i64 %54
%56 = load float, float* %55
%57 = shl i64 %54, 32
%58 = add i64 %57, 4294967296
%59 = ashr exact i64 %58, 32
%60 = getelementptr inbounds float, float* %0, i64 %59
%61 = load float, float* %60
br label %211
62: ; preds = %42
br i1 %28, label %63, label %87
63: ; preds = %62
br i1 %44, label %64, label %86
64: ; preds = %63
%65 = mul nsw i32 %2, %1
%66 = add nsw i32 %65, -1
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %0, i64 %67
%69 = load float, float* %68
%70 = add nsw i32 %4, -1
%71 = add nsw i32 %3, -1
%72 = mul i32 %70, %1
%73 = add i32 %72, %3
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %0, i64 %74
%76 = load float, float* %75
%77 = mul i32 %4, %1
%78 = add i32 %71, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %0, i64 %79
%81 = load float, float* %80
%82 = add i32 %77, %3
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %0, i64 %83
%85 = load float, float* %84
br label %211
86: ; preds = %63
br i1 %15, label %88, label %112
87: ; preds = %62
br i1 %15, label %88, label %140
88: ; preds = %87, %86
%89 = add nsw i32 %4, -1
%90 = mul nsw i32 %4, %1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float, float* %0, i64 %91
%93 = load float, float* %92
%94 = sext i32 %89 to i64
%95 = sext i32 %1 to i64
%96 = mul nsw i64 %94, %95
%97 = getelementptr inbounds float, float* %0, i64 %96
%98 = load float, float* %97
%99 = add nsw i64 %94, 1
%100 = mul nsw i64 %99, %95
%101 = getelementptr inbounds float, float* %0, i64 %100
%102 = load float, float* %101
%103 = shl i64 %100, 32
%104 = add i64 %103, 4294967296
%105 = ashr exact i64 %104, 32
%106 = getelementptr inbounds float, float* %0, i64 %105
%107 = load float, float* %106
%108 = add nsw i64 %94, 2
%109 = mul nsw i64 %108, %95
%110 = getelementptr inbounds float, float* %0, i64 %109
%111 = load float, float* %110
br label %211
112: ; preds = %86
%113 = add nsw i32 %4, -1
%114 = mul nsw i32 %4, %1
%115 = add nsw i32 %114, %3
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %0, i64 %116
%118 = load float, float* %117
%119 = add nsw i32 %3, -1
%120 = mul i32 %113, %1
%121 = add i32 %120, %3
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %0, i64 %122
%124 = load float, float* %123
%125 = mul i32 %4, %1
%126 = add i32 %119, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %0, i64 %127
%129 = load float, float* %128
%130 = add i32 %125, %3
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %0, i64 %131
%133 = load float, float* %132
%134 = add i32 %4, 1
%135 = mul i32 %134, %1
%136 = add i32 %135, %3
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %0, i64 %137
%139 = load float, float* %138
br label %211
140: ; preds = %87
br i1 %16, label %141, label %157
141: ; preds = %140
%142 = add nsw i32 %3, -1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %0, i64 %143
%145 = load float, float* %144
%146 = sext i32 %3 to i64
%147 = getelementptr inbounds float, float* %0, i64 %146
%148 = load float, float* %147
%149 = add i32 %3, 1
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %0, i64 %150
%152 = load float, float* %151
%153 = add i32 %3, %1
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %0, i64 %154
%156 = load float, float* %155
br label %211
157: ; preds = %140
br i1 %44, label %185, label %158
158: ; preds = %157
%159 = add nsw i32 %4, -1
%160 = add nsw i32 %3, -1
%161 = mul i32 %159, %1
%162 = add i32 %161, %3
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %0, i64 %163
%165 = load float, float* %164
%166 = mul i32 %4, %1
%167 = add i32 %160, %166
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %0, i64 %168
%170 = load float, float* %169
%171 = add i32 %166, %3
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %0, i64 %172
%174 = load float, float* %173
%175 = add i32 %167, 2
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds float, float* %0, i64 %176
%178 = load float, float* %177
%179 = add i32 %4, 1
%180 = mul i32 %179, %1
%181 = add i32 %180, %3
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %0, i64 %182
%184 = load float, float* %183
br label %211
185: ; preds = %157
%186 = mul nsw i32 %4, %1
%187 = add nsw i32 %3, -1
%188 = add nsw i32 %186, %3
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float, float* %0, i64 %189
%191 = load float, float* %190
%192 = add nsw i32 %4, -1
%193 = mul i32 %192, %1
%194 = add i32 %193, %3
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %0, i64 %195
%197 = load float, float* %196
%198 = mul i32 %4, %1
%199 = add i32 %198, %187
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %0, i64 %200
%202 = load float, float* %201
%203 = add i32 %198, %3
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds float, float* %0, i64 %204
%206 = load float, float* %205
%207 = add i32 %199, 2
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds float, float* %0, i64 %208
%210 = load float, float* %209
br label %211
211: ; preds = %158, %185, %141, %112, %88, %64, %46, %30, %19
%212 = phi float [ %165, %158 ], [ %197, %185 ], [ %148, %141 ], [ %124, %112 ], [ %98, %88 ], [ %76, %64 ], [ %52, %46 ], [ %33, %30 ], [ %20, %19 ]
%213 = phi float [ %178, %158 ], [ %210, %185 ], [ %152, %141 ], [ %118, %112 ], [ %107, %88 ], [ %69, %64 ], [ %61, %46 ], [ %33, %30 ], [ %22, %19 ]
%214 = phi float [ %170, %158 ], [ %202, %185 ], [ %145, %141 ], [ %129, %112 ], [ %93, %88 ], [ %81, %64 ], [ undef, %46 ], [ %37, %30 ], [ %20, %19 ]
%215 = phi float [ %184, %158 ], [ %191, %185 ], [ %156, %141 ], [ %139, %112 ], [ %111, %88 ], [ %69, %64 ], [ undef, %46 ], [ %41, %30 ], [ %25, %19 ]
%216 = phi float [ %174, %158 ], [ %206, %185 ], [ %148, %141 ], [ %133, %112 ], [ %102, %88 ], [ %85, %64 ], [ %56, %46 ], [ %33, %30 ], [ %20, %19 ]
store float 0.000000e+00, float* %9
%217 = fadd float %216, %215
%218 = getelementptr inbounds float, float* %9, i64 1
store float %217, float* %218
%219 = getelementptr inbounds float, float* %9, i64 2
store float 0.000000e+00, float* %219
%220 = fadd float %216, %214
store float %220, float* %11
%221 = fadd float %216, %213
%222 = getelementptr inbounds float, float* %9, i64 5
store float %221, float* %222
store float 0.000000e+00, float* %13
%223 = fadd float %216, %212
%224 = getelementptr inbounds float, float* %9, i64 7
store float %223, float* %224
%225 = getelementptr inbounds float, float* %9, i64 8
store float 0.000000e+00, float* %225
%226 = fneg float %213
%227 = fsub float %226, %214
%228 = tail call float @llvm.fmuladd.f32(float %216, float -4.000000e+00, float %227)
%229 = fsub float %228, %215
%230 = fsub float %229, %212
%231 = getelementptr inbounds float, float* %9, i64 4
store float %230, float* %231
ret float** %7
}