void aan_ondas_un_canal(float *canal_input, float *canal_output,
                        float *canal_anterior, int width, int height,
                        float dt) {
  int i, j, k, l;
  float tmp;
  float **area;
  {
    int ml;
    area = (float **)malloc(sizeof(float *) * (3));
    area[0] = (float *)malloc(sizeof(float) * (3) * (3));
    for (ml = 0; ml < (3); ml++)
      area[ml] = &(area[0][ml * (3)]);
  };
  for (j = 0; j < height; j++) {
    for (i = 0; i < width; i++) {
      if (i == 0 && j == 0) {
        area[0][0] = canal_input[0];
        area[0][1] = canal_input[0];
        area[0][2] = canal_input[1];
        area[1][0] = canal_input[0];
        area[2][0] = canal_input[width];
        for (k = 1; k < 3; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1) && j == 0) {
        area[0][2] = canal_input[width - 1];
        area[0][1] = canal_input[width - 1];
        area[0][0] = canal_input[width - 2];
        area[1][2] = canal_input[width - 1];
        area[2][2] = canal_input[width * 2 - 1];
        for (k = 1; k < 3; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == 0 && j == (height - 1)) {
        area[0][2] = canal_input[width * (j - 1)];
        area[0][1] = canal_input[width * (j - 1)];
        area[1][2] = canal_input[width * (j - 1)];
        area[0][0] = canal_input[width * (j - 2)];
        area[2][2] = canal_input[(width * (j - 1)) + 1];
        for (k = 0; k < 2; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1) && j == (height - 1)) {
        area[2][2] = canal_input[width * height - 1];
        area[1][2] = canal_input[width * height - 1];
        area[0][2] = canal_input[width * (height - 1) - 1];
        area[2][1] = canal_input[width * height - 1];
        area[2][0] = canal_input[width * height - 2];
        for (k = 0; k < 2; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == 0) {
        area[0][0] = canal_input[(width * (j - 1 + 0)) + i];
        area[1][0] = canal_input[(width * (j - 1 + 1)) + i];
        area[2][0] = canal_input[(width * (j - 1 + 2)) + i];
        for (k = 0; k < 3; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1)) {
        area[0][2] = canal_input[(width * (j - 1 + 0)) + i];
        area[1][2] = canal_input[(width * (j - 1 + 1)) + i];
        area[2][2] = canal_input[(width * (j - 1 + 2)) + i];
        for (k = 0; k < 3; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (j == 0) {
        area[0][0] = canal_input[(width * j) + (i - 1 + 0)];
        area[0][1] = canal_input[(width * j) + (i - 1 + 1)];
        area[0][2] = canal_input[(width * j) + (i - 1 + 2)];
        for (k = 1; k < 3; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (j == (height - 1)) {
        area[2][0] = canal_input[(width * j) + (i - 1 + 0)];
        area[2][1] = canal_input[(width * j) + (i - 1 + 1)];
        area[2][2] = canal_input[(width * j) + (i - 1 + 2)];
        for (k = 0; k < 2; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else {
        for (k = 0; k < 3; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[width * (j - 1 + k) + (i - 1 + l)];
      }
      tmp = 0;
      for (k = 0; k < 3; k++) {
        for (l = 0; l < 3; l++) {
          if (k == 1 && l == 1)
            tmp = tmp + (-8.0 * area[1][1]);
          else
            tmp = tmp + area[k][l];
        }
      }
      canal_output[width * j + i] =
          2.0 * area[1][1] - canal_anterior[width * j + i] + dt * dt * tmp;
      if (canal_output[width * j + i] > 1.0)
        canal_output[width * j + i] = 1.0;
      else if (canal_output[width * j + i] < 0.0)
        canal_output[width * j + i] = 0.0;
    }
  }
  {
    free(area[0]);
    free(area);
  };
}


x86 assembly (clang, -O0):
<aan_ondas_un_canal>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
mov    $0x18,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    $0x24,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    11a1 <aan_ondas_un_canal+0x81>
mov    -0x40(%rbp),%rax
mov    (%rax),%rdx
imul   $0x3,-0x44(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1169 <aan_ondas_un_canal+0x49>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1d7e <aan_ondas_un_canal+0xc5e>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1d6b <aan_ondas_un_canal+0xc4b>
cmpl   $0x0,-0x28(%rbp)
jne    12c7 <aan_ondas_un_canal+0x1a7>
cmpl   $0x0,-0x2c(%rbp)
jne    12c7 <aan_ondas_un_canal+0x1a7>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    12c2 <aan_ondas_un_canal+0x1a2>
movl   $0x1,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    12af <aan_ondas_un_canal+0x18f>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    125c <aan_ondas_un_canal+0x13c>
jmp    12b4 <aan_ondas_un_canal+0x194>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    124b <aan_ondas_un_canal+0x12b>
jmp    1b8e <aan_ondas_un_canal+0xa6e>
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    13ff <aan_ondas_un_canal+0x2df>
cmpl   $0x0,-0x2c(%rbp)
jne    13ff <aan_ondas_un_canal+0x2df>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    13fa <aan_ondas_un_canal+0x2da>
movl   $0x0,-0x34(%rbp)
cmpl   $0x2,-0x34(%rbp)
jge    13e7 <aan_ondas_un_canal+0x2c7>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1394 <aan_ondas_un_canal+0x274>
jmp    13ec <aan_ondas_un_canal+0x2cc>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1383 <aan_ondas_un_canal+0x263>
jmp    1b89 <aan_ondas_un_canal+0xa69>
cmpl   $0x0,-0x28(%rbp)
jne    1555 <aan_ondas_un_canal+0x435>
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1555 <aan_ondas_un_canal+0x435>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x2,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    1550 <aan_ondas_un_canal+0x430>
movl   $0x1,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    153d <aan_ondas_un_canal+0x41d>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14ea <aan_ondas_un_canal+0x3ca>
jmp    1542 <aan_ondas_un_canal+0x422>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14d9 <aan_ondas_un_canal+0x3b9>
jmp    1b84 <aan_ondas_un_canal+0xa64>
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16ac <aan_ondas_un_canal+0x58c>
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16ac <aan_ondas_un_canal+0x58c>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    16a7 <aan_ondas_un_canal+0x587>
movl   $0x0,-0x34(%rbp)
cmpl   $0x2,-0x34(%rbp)
jge    1694 <aan_ondas_un_canal+0x574>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1641 <aan_ondas_un_canal+0x521>
jmp    1699 <aan_ondas_un_canal+0x579>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1630 <aan_ondas_un_canal+0x510>
jmp    1b7f <aan_ondas_un_canal+0xa5f>
cmpl   $0x0,-0x28(%rbp)
jne    17b6 <aan_ondas_un_canal+0x696>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    17b1 <aan_ondas_un_canal+0x691>
movl   $0x1,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    179e <aan_ondas_un_canal+0x67e>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    174b <aan_ondas_un_canal+0x62b>
jmp    17a3 <aan_ondas_un_canal+0x683>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    173a <aan_ondas_un_canal+0x61a>
jmp    1b7a <aan_ondas_un_canal+0xa5a>
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    18ca <aan_ondas_un_canal+0x7aa>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    18c5 <aan_ondas_un_canal+0x7a5>
movl   $0x0,-0x34(%rbp)
cmpl   $0x2,-0x34(%rbp)
jge    18b2 <aan_ondas_un_canal+0x792>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    185f <aan_ondas_un_canal+0x73f>
jmp    18b7 <aan_ondas_un_canal+0x797>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    184e <aan_ondas_un_canal+0x72e>
jmp    1b75 <aan_ondas_un_canal+0xa55>
cmpl   $0x0,-0x2c(%rbp)
jne    19d4 <aan_ondas_un_canal+0x8b4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    19cf <aan_ondas_un_canal+0x8af>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    19bc <aan_ondas_un_canal+0x89c>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1969 <aan_ondas_un_canal+0x849>
jmp    19c1 <aan_ondas_un_canal+0x8a1>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1958 <aan_ondas_un_canal+0x838>
jmp    1b70 <aan_ondas_un_canal+0xa50>
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1ae8 <aan_ondas_un_canal+0x9c8>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    1ae3 <aan_ondas_un_canal+0x9c3>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    1ad0 <aan_ondas_un_canal+0x9b0>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a7d <aan_ondas_un_canal+0x95d>
jmp    1ad5 <aan_ondas_un_canal+0x9b5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a6c <aan_ondas_un_canal+0x94c>
jmp    1b6b <aan_ondas_un_canal+0xa4b>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1b66 <aan_ondas_un_canal+0xa46>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    1b53 <aan_ondas_un_canal+0xa33>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
imul   %edx,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b00 <aan_ondas_un_canal+0x9e0>
jmp    1b58 <aan_ondas_un_canal+0xa38>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1aef <aan_ondas_un_canal+0x9cf>
jmp    1b6b <aan_ondas_un_canal+0xa4b>
jmp    1b70 <aan_ondas_un_canal+0xa50>
jmp    1b75 <aan_ondas_un_canal+0xa55>
jmp    1b7a <aan_ondas_un_canal+0xa5a>
jmp    1b7f <aan_ondas_un_canal+0xa5f>
jmp    1b84 <aan_ondas_un_canal+0xa64>
jmp    1b89 <aan_ondas_un_canal+0xa69>
jmp    1b8e <aan_ondas_un_canal+0xa6e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1c49 <aan_ondas_un_canal+0xb29>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    1c36 <aan_ondas_un_canal+0xb16>
cmpl   $0x1,-0x30(%rbp)
jne    1c04 <aan_ondas_un_canal+0xae4>
cmpl   $0x1,-0x34(%rbp)
jne    1c04 <aan_ondas_un_canal+0xae4>
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x41a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    1c23 <aan_ondas_un_canal+0xb03>
movss  -0x38(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    1c28 <aan_ondas_un_canal+0xb08>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1bae <aan_ondas_un_canal+0xa8e>
jmp    1c3b <aan_ondas_un_canal+0xb1b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b9d <aan_ondas_un_canal+0xa7d>
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  -0x24(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x31a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1d13 <aan_ondas_un_canal+0xbf3>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  0x307(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1d58 <aan_ondas_un_canal+0xc38>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1d53 <aan_ondas_un_canal+0xc33>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1d58 <aan_ondas_un_canal+0xc38>
jmp    1d5d <aan_ondas_un_canal+0xc3d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11bb <aan_ondas_un_canal+0x9b>
jmp    1d70 <aan_ondas_un_canal+0xc50>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a8 <aan_ondas_un_canal+0x88>
mov    -0x40(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<aan_ondas_un_canal>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
movss  %xmm0,0x8(%rsp)
mov    %r8d,%r13d
mov    %ecx,%ebp
mov    %rdx,0xb0(%rsp)
mov    %rsi,0xa8(%rsp)
mov    %rdi,%rbx
mov    $0x24,%edi
call   1040 <malloc@plt>
movss  0x8(%rsp),%xmm12
test   %r13d,%r13d
jle    1a45 <aan_ondas_un_canal+0x925>
movabs $0x100000000,%r12
lea    -0x1(%rbp),%edx
lea    -0x1(%r13),%r8d
mov    %r8,0x10(%rsp)
mov    %r13d,%esi
imul   %ebp,%esi
lea    -0x1(%rsi),%edi
movslq %edi,%rdi
mov    %rdi,0xa0(%rsp)
mov    %r8d,%edi
imul   %ebp,%edi
add    $0xffffffff,%edi
movslq %edi,%rdi
mov    %rdi,0x98(%rsp)
add    $0xfffffffe,%esi
movslq %esi,%rsi
mov    %rsi,0x90(%rsp)
mov    %rdx,%rcx
mov    %rdx,(%rsp)
movslq %edx,%rcx
mov    %rcx,0x150(%rsp)
lea    -0x2(%rbp),%esi
mov    %rsi,0x80(%rsp)
movslq %esi,%rsi
mov    %rsi,0x68(%rsp)
lea    -0x1(%rbp,%rbp,1),%esi
movslq %esi,%rsi
mov    %rsi,0x148(%rsp)
movslq %ebp,%rdi
mulss  %xmm12,%xmm12
mov    %r13d,%esi
mov    %rsi,0x108(%rsp)
lea    -0x2(%rbp,%rbp,1),%esi
movslq %esi,%rsi
mov    %rsi,0x140(%rsp)
lea    0x1(%rdi),%esi
movslq %esi,%r15
mov    %rdi,%rcx
shl    $0x20,%rcx
mov    %rcx,0x78(%rsp)
xorps  %xmm8,%xmm8
movsd  0xdd6(%rip),%xmm9
movss  0xdd5(%rip),%xmm10
mov    %rdi,%rsi
mov    %rdi,0x8(%rsp)
mov    %edi,%r13d
lea    0x4(%rbx),%rcx
mov    %rcx,0x70(%rsp)
xor    %r10d,%r10d
mov    %rbp,0x88(%rsp)
jmp    1281 <aan_ondas_un_canal+0x161>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x110(%rsp),%rcx
mov    %rcx,%r10
mov    0x88(%rsp),%rbp
cmp    0x108(%rsp),%rcx
je     1a45 <aan_ondas_un_canal+0x925>
test   %ebp,%ebp
jle    1a30 <aan_ondas_un_canal+0x910>
lea    -0x1(%r10),%r11
mov    %r10,%rdx
mov    0x8(%rsp),%rsi
imul   %rsi,%rdx
mov    %r11,%r8
imul   %rsi,%r8
lea    0x1(%r10),%rcx
mov    %rcx,0x110(%rsp)
mov    %rcx,%r9
imul   %rsi,%r9
lea    -0x2(%r10),%rcx
imul   %rsi,%rcx
mov    %rcx,0x138(%rsp)
lea    0x1(%r10),%r14d
imul   %ebp,%r14d
mov    0x80(%rsp),%rbp
lea    (%r8,%rbp,1),%esi
movslq %esi,%rcx
mov    %rcx,0x40(%rsp)
mov    0x68(%rsp),%rdi
lea    0x1(%rdi,%r8,1),%esi
movslq %esi,%rcx
mov    %rcx,0x100(%rsp)
lea    0x0(%rbp,%rdx,1),%esi
movslq %esi,%rcx
mov    %rcx,0x38(%rsp)
lea    0x1(%rdi,%rdx,1),%esi
movslq %esi,%rcx
mov    %rcx,0xf8(%rsp)
lea    0x0(%rbp,%r14,1),%esi
movslq %esi,%rcx
mov    %rcx,0xf0(%rsp)
lea    0x1(%rdi,%r14,1),%esi
movslq %esi,%rcx
mov    %rcx,0xe8(%rsp)
mov    %r8,%rcx
shl    $0x20,%rcx
add    %r12,%rcx
sar    $0x20,%rcx
mov    %rcx,0x50(%rsp)
mov    %rdx,%rcx
shl    $0x20,%rcx
add    %r12,%rcx
sar    $0x20,%rcx
mov    %rcx,0x48(%rsp)
mov    %r9,%rcx
shl    $0x20,%rcx
add    %r12,%rcx
sar    $0x20,%rcx
mov    %rcx,0x128(%rsp)
lea    (%rdi,%r8,1),%esi
add    $0x1,%esi
movslq %esi,%rcx
mov    %rcx,0x120(%rsp)
lea    0x1(%rdi,%rdx,1),%esi
movslq %esi,%rcx
mov    %rcx,0x118(%rsp)
movss  0xc(%rax),%xmm1
movss  0x18(%rax),%xmm11
movss  0x1c(%rax),%xmm5
mov    0x78(%rsp),%rcx
mov    %rcx,%rbp
imul   %r10,%rbp
imul   %rcx,%r11
mov    %r14,0xc8(%rsp)
add    $0xffffffff,%r14d
mov    %r14,0xc0(%rsp)
mov    (%rsp),%rcx
lea    (%r8,%rcx,1),%rsi
mov    %rsi,0xe0(%rsp)
lea    (%rdx,%rcx,1),%rsi
mov    %rsi,0xd8(%rsp)
mov    %r9,0x130(%rsp)
add    %r9,%rcx
mov    %rcx,0xd0(%rsp)
lea    -0x1(%r8),%ecx
mov    %rcx,0x30(%rsp)
mov    %r8,0x58(%rsp)
mov    %r8d,%ecx
mov    %rcx,0x28(%rsp)
mov    %edx,%ecx
mov    %rcx,0x20(%rsp)
lea    -0x1(%rdx),%ecx
mov    %rcx,0x18(%rsp)
mov    0xb0(%rsp),%rsi
lea    (%rsi,%rdx,4),%r8
mov    0xa8(%rsp),%rsi
lea    (%rsi,%rdx,4),%rsi
mov    0x70(%rsp),%rcx
mov    %rdx,0x60(%rsp)
lea    (%rcx,%rdx,4),%rcx
mov    %rcx,0xb8(%rsp)
xor    %r9d,%r9d
jmp    1469 <aan_ondas_un_canal+0x349>
nopw   0x0(%rax,%rax,1)
movss  %xmm0,(%rsi,%r9,4)
add    $0x1,%r9
add    %r12,%rbp
add    %r12,%r11
cmp    %r9,%r13
je     1260 <aan_ondas_un_canal+0x140>
mov    %r9,%r14
or     %r10,%r14
jne    14d0 <aan_ondas_un_canal+0x3b0>
movsd  (%rbx),%xmm0
movaps %xmm0,%xmm1
shufps $0x10,%xmm0,%xmm1
movups %xmm1,(%rax)
mov    0x8(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm5
movss  %xmm5,0x18(%rax)
movss  %xmm0,0x10(%rax)
movaps %xmm0,%xmm6
shufps $0x55,%xmm0,%xmm6
movss  %xmm6,0x14(%rax)
movss  %xmm5,0x1c(%rax)
movss  (%rbx,%r15,4),%xmm7
movss  %xmm7,0x20(%rax)
movaps %xmm5,%xmm11
movaps %xmm0,%xmm1
movaps %xmm6,%xmm2
movaps %xmm0,%xmm4
movaps %xmm0,%xmm3
jmp    19a0 <aan_ondas_un_canal+0x880>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r9,(%rsp)
jne    1560 <aan_ondas_un_canal+0x440>
test   %r10,%r10
jne    1560 <aan_ondas_un_canal+0x440>
mov    0x150(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm6
movss  %xmm6,0x8(%rax)
movss  %xmm6,0x4(%rax)
mov    0x68(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm3
movss  %xmm3,(%rax)
mov    0x148(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm7
movss  %xmm7,0x20(%rax)
mov    (%rsp),%rcx
movsd  -0x4(%rbx,%rcx,4),%xmm1
mov    0x140(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm11
movaps %xmm11,%xmm0
movlhps %xmm6,%xmm0
movaps %xmm1,%xmm2
shufps $0x24,%xmm0,%xmm2
movups %xmm2,0xc(%rax)
movss  (%rbx,%rdi,4),%xmm5
movss  %xmm5,0x1c(%rax)
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
movaps %xmm6,%xmm2
movaps %xmm6,%xmm4
jmp    19a0 <aan_ondas_un_canal+0x880>
test   %r9,%r9
jne    15c9 <aan_ondas_un_canal+0x4a9>
cmp    0x10(%rsp),%r10
jne    15c9 <aan_ondas_un_canal+0x4a9>
mov    0x138(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm3
movss  %xmm3,(%rax)
mov    0x58(%rsp),%rcx
movss  0x4(%rbx,%rcx,4),%xmm7
movss  %xmm7,0x20(%rax)
movss  (%rbx,%rcx,4),%xmm4
movss  %xmm4,0x4(%rax)
mov    0x50(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm2
movss  %xmm2,0x8(%rax)
mov    0x60(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,0x10(%rax)
mov    0x48(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm6
movss  %xmm6,0x14(%rax)
jmp    19a0 <aan_ondas_un_canal+0x880>
cmp    %r9,(%rsp)
jne    1666 <aan_ondas_un_canal+0x546>
cmp    0x10(%rsp),%r10
jne    1726 <aan_ondas_un_canal+0x606>
mov    0xa0(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm7
mov    0x98(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm2
movss  %xmm2,0x8(%rax)
mov    0x90(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm11
movaps %xmm7,%xmm0
unpcklps %xmm11,%xmm0
shufps $0x4,%xmm0,%xmm0
movups %xmm0,0x14(%rax)
mov    0x40(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm3
movss  %xmm3,(%rax)
mov    0x120(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm4
movss  %xmm4,0x4(%rax)
mov    0x38(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm1
movss  %xmm1,0xc(%rax)
mov    0x118(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,0x10(%rax)
movaps %xmm7,%xmm5
movaps %xmm7,%xmm6
jmp    19a0 <aan_ondas_un_canal+0x880>
test   %r9,%r9
je     17d1 <aan_ondas_un_canal+0x6b1>
test   %r10,%r10
je     1853 <aan_ondas_un_canal+0x733>
cmp    0x10(%rsp),%r10
jne    18d0 <aan_ondas_un_canal+0x7b0>
mov    0xb8(%rsp),%rcx
movsd  -0x8(%rcx,%r9,4),%xmm11
movss  (%rcx,%r9,4),%xmm7
movss  %xmm7,0x20(%rax)
mov    0x30(%rsp),%rcx
lea    (%rcx,%r9,1),%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm3
movss  %xmm3,(%rax)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r9,1),%rdi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm4
movss  %xmm4,0x4(%rax)
add    $0x1,%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm2
movss  %xmm2,0x8(%rax)
mov    0x18(%rsp),%rcx
lea    (%rcx,%r9,1),%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm1
movss  %xmm1,0xc(%rax)
mov    0x20(%rsp),%rcx
lea    (%rcx,%r9,1),%rdi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm0
add    $0x1,%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm6
movaps %xmm0,%xmm5
unpcklps %xmm6,%xmm5
movlhps %xmm11,%xmm5
movups %xmm5,0x10(%rax)
movaps %xmm11,%xmm5
shufps $0x55,%xmm11,%xmm5
jmp    19a0 <aan_ondas_un_canal+0x880>
test   %r9,%r9
je     17d1 <aan_ondas_un_canal+0x6b1>
mov    0xe0(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm2
movss  %xmm2,0x8(%rax)
mov    0xd8(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm6
movss  %xmm6,0x14(%rax)
mov    0xd0(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm7
movss  %xmm7,0x20(%rax)
mov    0x40(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm3
movss  %xmm3,(%rax)
mov    0x100(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm4
movss  %xmm4,0x4(%rax)
mov    0x38(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm1
movss  %xmm1,0xc(%rax)
mov    0xf8(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,0x10(%rax)
mov    0xf0(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm11
movss  %xmm11,0x18(%rax)
mov    0xe8(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm5
movss  %xmm5,0x1c(%rax)
jmp    19a0 <aan_ondas_un_canal+0x880>
mov    0x58(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm4
movss  %xmm4,(%rax)
mov    0x60(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm1
movss  %xmm1,0xc(%rax)
mov    0x130(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm11
movss  %xmm11,0x18(%rax)
movss  %xmm4,0x4(%rax)
mov    0x50(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm2
movss  %xmm2,0x8(%rax)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,0x10(%rax)
mov    0x48(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm6
movss  %xmm6,0x14(%rax)
movss  (%rbx,%rdx,4),%xmm5
movss  %xmm5,0x1c(%rax)
mov    0x128(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm7
movss  %xmm7,0x20(%rax)
movaps %xmm4,%xmm3
jmp    19a0 <aan_ondas_un_canal+0x880>
movss  -0x4(%rbx,%r9,4),%xmm1
movsd  (%rbx,%r9,4),%xmm4
movaps %xmm1,%xmm0
movlhps %xmm4,%xmm0
movaps %xmm1,%xmm2
shufps $0xd4,%xmm4,%xmm2
shufps $0x28,%xmm2,%xmm0
movups %xmm0,(%rax)
movsd  (%rbx,%r9,4),%xmm0
mov    (%rsp),%rcx
lea    (%rcx,%r9,1),%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm11
lea    0x0(%r13,%r9,1),%rdi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm5
movaps %xmm5,%xmm2
movlhps %xmm11,%xmm2
movaps %xmm0,%xmm3
shufps $0x24,%xmm2,%xmm3
movups %xmm3,0x10(%rax)
add    $0x1,%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm7
movss  %xmm7,0x20(%rax)
movaps %xmm4,%xmm2
shufps $0x55,%xmm4,%xmm2
movaps %xmm0,%xmm6
shufps $0x55,%xmm0,%xmm6
movaps %xmm1,%xmm3
jmp    19a0 <aan_ondas_un_canal+0x880>
mov    0x30(%rsp),%rcx
lea    (%rcx,%r9,1),%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm3
movss  %xmm3,(%rax)
mov    %r11,%rdi
sar    $0x1e,%rdi
movss  (%rbx,%rdi,1),%xmm4
movss  %xmm4,0x4(%rax)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r9,1),%edi
add    $0x1,%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm2
movss  %xmm2,0x8(%rax)
mov    0x18(%rsp),%rcx
lea    (%rcx,%r9,1),%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm1
movss  %xmm1,0xc(%rax)
mov    %rbp,%rdi
sar    $0x1e,%rdi
movss  (%rbx,%rdi,1),%xmm0
movss  %xmm0,0x10(%rax)
mov    0x20(%rsp),%rcx
lea    (%rcx,%r9,1),%edi
add    $0x1,%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm6
movss  %xmm6,0x14(%rax)
mov    0xc0(%rsp),%rcx
lea    (%rcx,%r9,1),%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm11
movss  %xmm11,0x18(%rax)
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r9,1),%rdi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm5
movss  %xmm5,0x1c(%rax)
add    $0x1,%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm7
movss  %xmm7,0x20(%rax)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  %xmm8,%xmm3
addss  %xmm4,%xmm3
addss  %xmm2,%xmm3
addss  %xmm1,%xmm3
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
cvtss2sd %xmm0,%xmm0
movaps %xmm0,%xmm3
mulsd  %xmm9,%xmm3
addsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
addss  %xmm6,%xmm2
addss  %xmm11,%xmm2
addss  %xmm5,%xmm2
addss  %xmm7,%xmm2
mulss  %xmm12,%xmm2
movss  (%r8,%r9,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm0,%xmm0
subsd  %xmm3,%xmm0
cvtss2sd %xmm2,%xmm2
addsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%rsi,%r9,4)
ucomiss %xmm10,%xmm2
movaps %xmm10,%xmm0
ja     1450 <aan_ondas_un_canal+0x330>
xorps  %xmm0,%xmm0
ucomiss %xmm2,%xmm0
ja     1450 <aan_ondas_un_canal+0x330>
jmp    1456 <aan_ondas_un_canal+0x336>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
mov    %r10,%rcx
cmp    0x108(%rsp),%rcx
jne    1281 <aan_ondas_un_canal+0x161>
mov    %rax,%rdi
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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