void aan_mascara_canal(float *canal_input, float *canal_output, int width,
                       int height, float **m) {
  int i, j, k, l;
  float **area;
  {
    int ml;
    area = (float **)malloc(sizeof(float *) * (3));
    area[0] = (float *)malloc(sizeof(float) * (3) * (3));
    for (ml = 0; ml < (3); ml++)
      area[ml] = &(area[0][ml * (3)]);
  };
  for (j = 0; j < height; j++) {
    for (i = 0; i < width; i++) {
      if (i == 0 && j == 0) {
        area[0][0] = canal_input[0];
        area[0][1] = canal_input[0];
        area[0][2] = canal_input[1];
        area[1][0] = canal_input[0];
        area[2][0] = canal_input[width];
        for (k = 1; k < 3; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1) && j == 0) {
        area[0][2] = canal_input[width - 1];
        area[0][1] = canal_input[width - 1];
        area[0][0] = canal_input[width - 2];
        area[1][2] = canal_input[width - 1];
        area[2][2] = canal_input[width * 2 - 1];
        for (k = 1; k < 3; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == 0 && j == (height - 1)) {
        area[0][2] = canal_input[width * (j - 1)];
        area[0][1] = canal_input[width * (j - 1)];
        area[1][2] = canal_input[width * (j - 1)];
        area[0][0] = canal_input[width * (j - 2)];
        area[2][2] = canal_input[(width * (j - 1)) + 1];
        for (k = 0; k < 2; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1) && j == (height - 1)) {
        area[2][2] = canal_input[width * height - 1];
        area[1][2] = canal_input[width * height - 1];
        area[0][2] = canal_input[width * (height - 1) - 1];
        area[2][1] = canal_input[width * height - 1];
        area[2][0] = canal_input[width * height - 2];
        for (k = 0; k < 2; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == 0) {
        area[0][0] = canal_input[(width * (j - 1 + 0)) + i];
        area[1][0] = canal_input[(width * (j - 1 + 1)) + i];
        area[2][0] = canal_input[(width * (j - 1 + 2)) + i];
        for (k = 0; k < 3; k++)
          for (l = 1; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (i == (width - 1)) {
        area[0][2] = canal_input[(width * (j - 1 + 0)) + i];
        area[1][2] = canal_input[(width * (j - 1 + 1)) + i];
        area[2][2] = canal_input[(width * (j - 1 + 2)) + i];
        for (k = 0; k < 3; k++)
          for (l = 0; l < 2; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (j == 0) {
        area[0][0] = canal_input[(width * j) + (i - 1 + 0)];
        area[0][1] = canal_input[(width * j) + (i - 1 + 1)];
        area[0][2] = canal_input[(width * j) + (i - 1 + 2)];
        for (k = 1; k < 3; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else if (j == (height - 1)) {
        area[2][0] = canal_input[(width * j) + (i - 1 + 0)];
        area[2][1] = canal_input[(width * j) + (i - 1 + 1)];
        area[2][2] = canal_input[(width * j) + (i - 1 + 2)];
        for (k = 0; k < 2; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[(width * (j - 1 + k)) + (i - 1 + l)];
      } else {
        for (k = 0; k < 3; k++)
          for (l = 0; l < 3; l++)
            area[k][l] = canal_input[width * (j - 1 + k) + (i - 1 + l)];
      }
      canal_output[width * j + i] = pixel_resultante(m, area);
      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_mascara_canal>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    $0x18,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    $0x24,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    11ab <aan_mascara_canal+0x7b>
mov    -0x38(%rbp),%rax
mov    (%rax),%rdx
imul   $0x3,-0x3c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1173 <aan_mascara_canal+0x43>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1c7b <aan_mascara_canal+0xb4b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c68 <aan_mascara_canal+0xb38>
cmpl   $0x0,-0x24(%rbp)
jne    12d1 <aan_mascara_canal+0x1a1>
cmpl   $0x0,-0x28(%rbp)
jne    12d1 <aan_mascara_canal+0x1a1>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    12cc <aan_mascara_canal+0x19c>
movl   $0x1,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    12b9 <aan_mascara_canal+0x189>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1266 <aan_mascara_canal+0x136>
jmp    12be <aan_mascara_canal+0x18e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1255 <aan_mascara_canal+0x125>
jmp    1b98 <aan_mascara_canal+0xa68>
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1409 <aan_mascara_canal+0x2d9>
cmpl   $0x0,-0x28(%rbp)
jne    1409 <aan_mascara_canal+0x2d9>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1404 <aan_mascara_canal+0x2d4>
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    13f1 <aan_mascara_canal+0x2c1>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    139e <aan_mascara_canal+0x26e>
jmp    13f6 <aan_mascara_canal+0x2c6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    138d <aan_mascara_canal+0x25d>
jmp    1b93 <aan_mascara_canal+0xa63>
cmpl   $0x0,-0x24(%rbp)
jne    155f <aan_mascara_canal+0x42f>
mov    -0x28(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    155f <aan_mascara_canal+0x42f>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x2,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jge    155a <aan_mascara_canal+0x42a>
movl   $0x1,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1547 <aan_mascara_canal+0x417>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14f4 <aan_mascara_canal+0x3c4>
jmp    154c <aan_mascara_canal+0x41c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14e3 <aan_mascara_canal+0x3b3>
jmp    1b8e <aan_mascara_canal+0xa5e>
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16b6 <aan_mascara_canal+0x586>
mov    -0x28(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16b6 <aan_mascara_canal+0x586>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jge    16b1 <aan_mascara_canal+0x581>
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    169e <aan_mascara_canal+0x56e>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    164b <aan_mascara_canal+0x51b>
jmp    16a3 <aan_mascara_canal+0x573>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    163a <aan_mascara_canal+0x50a>
jmp    1b89 <aan_mascara_canal+0xa59>
cmpl   $0x0,-0x24(%rbp)
jne    17c0 <aan_mascara_canal+0x690>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    17bb <aan_mascara_canal+0x68b>
movl   $0x1,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    17a8 <aan_mascara_canal+0x678>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1755 <aan_mascara_canal+0x625>
jmp    17ad <aan_mascara_canal+0x67d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1744 <aan_mascara_canal+0x614>
jmp    1b84 <aan_mascara_canal+0xa54>
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    18d4 <aan_mascara_canal+0x7a4>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
imul   %edx,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    18cf <aan_mascara_canal+0x79f>
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    18bc <aan_mascara_canal+0x78c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1869 <aan_mascara_canal+0x739>
jmp    18c1 <aan_mascara_canal+0x791>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1858 <aan_mascara_canal+0x728>
jmp    1b7f <aan_mascara_canal+0xa4f>
cmpl   $0x0,-0x28(%rbp)
jne    19de <aan_mascara_canal+0x8ae>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x1,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    19d9 <aan_mascara_canal+0x8a9>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    19c6 <aan_mascara_canal+0x896>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1973 <aan_mascara_canal+0x843>
jmp    19cb <aan_mascara_canal+0x89b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1962 <aan_mascara_canal+0x832>
jmp    1b7a <aan_mascara_canal+0xa4a>
mov    -0x28(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1af2 <aan_mascara_canal+0x9c2>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jge    1aed <aan_mascara_canal+0x9bd>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1ada <aan_mascara_canal+0x9aa>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a87 <aan_mascara_canal+0x957>
jmp    1adf <aan_mascara_canal+0x9af>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a76 <aan_mascara_canal+0x946>
jmp    1b75 <aan_mascara_canal+0xa45>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1b70 <aan_mascara_canal+0xa40>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1b5d <aan_mascara_canal+0xa2d>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b0a <aan_mascara_canal+0x9da>
jmp    1b62 <aan_mascara_canal+0xa32>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1af9 <aan_mascara_canal+0x9c9>
jmp    1b75 <aan_mascara_canal+0xa45>
jmp    1b7a <aan_mascara_canal+0xa4a>
jmp    1b7f <aan_mascara_canal+0xa4f>
jmp    1b84 <aan_mascara_canal+0xa54>
jmp    1b89 <aan_mascara_canal+0xa59>
jmp    1b8e <aan_mascara_canal+0xa5e>
jmp    1b93 <aan_mascara_canal+0xa63>
jmp    1b98 <aan_mascara_canal+0xa68>
mov    -0x20(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    $0x0,%al
call   1050 <pixel_resultante@plt>
cvtsi2ss %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x41d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1c10 <aan_mascara_canal+0xae0>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  0x402(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1c55 <aan_mascara_canal+0xb25>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1c50 <aan_mascara_canal+0xb20>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1c55 <aan_mascara_canal+0xb25>
jmp    1c5a <aan_mascara_canal+0xb2a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c5 <aan_mascara_canal+0x95>
jmp    1c6d <aan_mascara_canal+0xb3d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b2 <aan_mascara_canal+0x82>
mov    -0x38(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<aan_mascara_canal>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r8,0x158(%rsp)
mov    %ecx,%ebp
mov    %edx,%r15d
mov    %rsi,0xa8(%rsp)
mov    %rdi,%rbx
mov    $0x18,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    $0x24,%edi
call   1040 <malloc@plt>
mov    %rax,0x0(%r13)
movq   %rax,%xmm0
pshufd $0x44,%xmm0,%xmm0
paddq  0xe7a(%rip),%xmm0
movdqu %xmm0,0x8(%r13)
test   %ebp,%ebp
jle    1a39 <aan_mascara_canal+0x909>
lea    -0x1(%r15),%edx
lea    -0x1(%rbp),%esi
mov    %ebp,%eax
imul   %r15d,%eax
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
mov    %rcx,0x98(%rsp)
mov    %rsi,0x8(%rsp)
mov    %esi,%ecx
imul   %r15d,%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
mov    %rcx,0x90(%rsp)
add    $0xfffffffe,%eax
cltq
mov    %rax,0x88(%rsp)
mov    %rdx,(%rsp)
movslq %edx,%rax
mov    %rax,0x148(%rsp)
lea    -0x2(%r15),%eax
mov    %rax,0x80(%rsp)
cltq
mov    %rax,0x60(%rsp)
lea    -0x1(%r15,%r15,1),%eax
cltq
mov    %rax,0x140(%rsp)
movslq %r15d,%rcx
mov    %ebp,%eax
mov    %rax,0x100(%rsp)
lea    -0x2(%r15,%r15,1),%eax
cltq
mov    %rax,0x138(%rsp)
lea    0x1(%rcx),%eax
cltq
mov    %rax,0x150(%rsp)
mov    %rcx,%rax
shl    $0x20,%rax
mov    %rax,0x78(%rsp)
mov    %rcx,0x68(%rsp)
mov    %ecx,%eax
mov    %rax,0x70(%rsp)
xor    %esi,%esi
mov    %r15,0xa0(%rsp)
jmp    1281 <aan_mascara_canal+0x151>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x118(%rsp),%rax
mov    %rax,%rsi
mov    0xa0(%rsp),%r15
cmp    0x100(%rsp),%rax
je     1a35 <aan_mascara_canal+0x905>
test   %r15d,%r15d
jle    1a20 <aan_mascara_canal+0x8f0>
lea    -0x1(%rsi),%r14
mov    %rsi,%rdi
mov    0x68(%rsp),%rax
imul   %rax,%rdi
mov    %r14,%rbp
imul   %rax,%rbp
lea    0x1(%rsi),%rcx
mov    %rcx,0x118(%rsp)
mov    %rcx,%r8
imul   %rax,%r8
lea    -0x2(%rsi),%rcx
imul   %rax,%rcx
mov    %rcx,0x130(%rsp)
lea    0x1(%rsi),%r9d
imul   %r15d,%r9d
mov    0x80(%rsp),%rcx
lea    (%rcx,%rbp,1),%eax
cltq
mov    %rax,0x38(%rsp)
mov    0x60(%rsp),%rdx
lea    0x1(%rdx,%rbp,1),%eax
cltq
mov    %rax,0xf8(%rsp)
lea    (%rcx,%rdi,1),%eax
cltq
mov    %rax,0x30(%rsp)
lea    0x1(%rdx,%rdi,1),%eax
cltq
mov    %rax,0xf0(%rsp)
lea    (%rcx,%r9,1),%eax
cltq
mov    %rax,0xe8(%rsp)
lea    0x1(%rdx,%r9,1),%eax
cltq
mov    %rax,0xe0(%rsp)
mov    %rbp,%rcx
shl    $0x20,%rcx
movabs $0x100000000,%rax
add    %rax,%rcx
sar    $0x20,%rcx
mov    %rcx,0x48(%rsp)
mov    %rdi,%rcx
shl    $0x20,%rcx
add    %rax,%rcx
sar    $0x20,%rcx
mov    %rcx,0x40(%rsp)
mov    %r8,%rcx
shl    $0x20,%rcx
add    %rax,%rcx
sar    $0x20,%rcx
mov    %rcx,0x120(%rsp)
lea    (%rdx,%rbp,1),%eax
add    $0x1,%eax
cltq
mov    %rax,0x110(%rsp)
lea    0x1(%rdx,%rdi,1),%eax
cltq
mov    %rax,0x108(%rsp)
mov    0x78(%rsp),%rax
mov    %rax,%r15
imul   %rsi,%r15
imul   %rax,%r14
mov    %r9,0xc0(%rsp)
add    $0xffffffff,%r9d
mov    %r9,0xb8(%rsp)
mov    (%rsp),%rax
lea    (%rax,%rbp,1),%rcx
mov    %rcx,0xd8(%rsp)
lea    (%rdi,%rax,1),%rcx
mov    %rcx,0xd0(%rsp)
mov    %r8,0x128(%rsp)
add    %r8,%rax
mov    %rax,0xc8(%rsp)
lea    -0x1(%rbp),%eax
mov    %rax,0x28(%rsp)
mov    %rbp,0x50(%rsp)
mov    %ebp,%eax
mov    %rax,0x20(%rsp)
mov    %edi,%eax
mov    %rax,0x18(%rsp)
lea    -0x1(%rdi),%eax
mov    %rax,0x10(%rsp)
mov    0xa8(%rsp),%rax
lea    (%rax,%rdi,4),%rbp
mov    %rdi,0x58(%rsp)
lea    (%rbx,%rdi,4),%rax
mov    %rax,0xb0(%rsp)
xor    %r12d,%r12d
mov    %rsi,0x160(%rsp)
jmp    1456 <aan_mascara_canal+0x326>
nopw   0x0(%rax,%rax,1)
movd   %xmm0,0x0(%rbp,%r12,4)
add    $0x1,%r12
movabs $0x100000000,%rax
add    %rax,%r15
add    %rax,%r14
cmp    %r12,0x70(%rsp)
je     1260 <aan_mascara_canal+0x130>
mov    %r12,%rax
or     %rsi,%rax
jne    14d0 <aan_mascara_canal+0x3a0>
movss  (%rbx),%xmm0
mov    0x0(%r13),%rax
movss  %xmm0,(%rax)
movss  (%rbx),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x4(%rbx),%xmm0
movss  %xmm0,0x8(%rax)
movss  (%rbx),%xmm0
mov    0x8(%r13),%rax
movss  %xmm0,(%rax)
mov    0x68(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm0
mov    0x10(%r13),%rcx
movss  %xmm0,(%rcx)
movss  (%rbx),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x4(%rbx),%xmm0
movss  %xmm0,0x8(%rax)
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rcx)
mov    0x150(%rsp),%rax
jmp    19c0 <aan_mascara_canal+0x890>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r12,(%rsp)
jne    1570 <aan_mascara_canal+0x440>
test   %rsi,%rsi
jne    1570 <aan_mascara_canal+0x440>
mov    0x148(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm0
mov    0x0(%r13),%rax
movss  %xmm0,0x8(%rax)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax)
mov    0x60(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%rax)
movss  (%rbx,%rcx,4),%xmm0
mov    0x8(%r13),%rax
movss  %xmm0,0x8(%rax)
mov    0x140(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm0
mov    0x10(%r13),%rcx
movss  %xmm0,0x8(%rcx)
mov    (%rsp),%rdx
movss  -0x4(%rbx,%rdx,4),%xmm0
movss  %xmm0,(%rax)
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rax)
mov    0x138(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rcx)
jmp    19ca <aan_mascara_canal+0x89a>
nopl   (%rax)
test   %r12,%r12
jne    15fd <aan_mascara_canal+0x4cd>
cmp    0x8(%rsp),%rsi
jne    15fd <aan_mascara_canal+0x4cd>
mov    0x50(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm0
mov    0x0(%r13),%rax
movss  %xmm0,0x8(%rax)
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rax)
movss  (%rbx,%rsi,4),%xmm0
mov    0x8(%r13),%rcx
movss  %xmm0,0x8(%rcx)
mov    0x130(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%rax)
movss  0x4(%rbx,%rsi,4),%xmm0
mov    0x10(%r13),%rdx
movss  %xmm0,0x8(%rdx)
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rax)
mov    0x48(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,0x8(%rax)
mov    0x58(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx)
mov    0x40(%rsp),%rax
jmp    19c0 <aan_mascara_canal+0x890>
cmp    %r12,(%rsp)
jne    16ac <aan_mascara_canal+0x57c>
cmp    0x8(%rsp),%rsi
jne    1752 <aan_mascara_canal+0x622>
mov    0x98(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm0
mov    0x10(%r13),%rax
movss  %xmm0,0x8(%rax)
movss  (%rbx,%rsi,4),%xmm0
mov    0x8(%r13),%rcx
movss  %xmm0,0x8(%rcx)
mov    0x90(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm0
mov    0x0(%r13),%rdx
movss  %xmm0,0x8(%rdx)
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rax)
mov    0x88(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,(%rax)
mov    0x38(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rdx)
mov    0x110(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rdx)
mov    0x30(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
mov    0x108(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx)
jmp    19ca <aan_mascara_canal+0x89a>
test   %r12,%r12
je     1805 <aan_mascara_canal+0x6d5>
test   %rsi,%rsi
je     1893 <aan_mascara_canal+0x763>
cmp    0x8(%rsp),%rsi
jne    18ff <aan_mascara_canal+0x7cf>
mov    0xb0(%rsp),%rcx
movss  -0x4(%rcx,%r12,4),%xmm0
mov    0x10(%r13),%rax
movss  %xmm0,(%rax)
movss  (%rcx,%r12,4),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x4(%rcx,%r12,4),%xmm0
movss  %xmm0,0x8(%rax)
mov    0x28(%rsp),%rax
add    %r12d,%eax
mov    0x0(%r13),%rcx
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
mov    0x20(%rsp),%rax
add    %r12,%rax
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx)
add    $0x1,%eax
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rcx)
mov    0x10(%rsp),%rax
add    %r12d,%eax
mov    0x8(%r13),%rcx
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
mov    0x18(%rsp),%rax
jmp    199f <aan_mascara_canal+0x86f>
test   %r12,%r12
je     1805 <aan_mascara_canal+0x6d5>
mov    0xd8(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
mov    0x0(%r13),%rax
movss  %xmm0,0x8(%rax)
mov    0xd0(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm0
mov    0x8(%r13),%rcx
movss  %xmm0,0x8(%rcx)
mov    0xc8(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm0
mov    0x10(%r13),%rdx
movss  %xmm0,0x8(%rdx)
mov    0x38(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,(%rax)
mov    0xf8(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rax)
mov    0x30(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
mov    0xf0(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx)
mov    0xe8(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rdx)
mov    0xe0(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rdx)
jmp    19ca <aan_mascara_canal+0x89a>
mov    0x50(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm0
mov    0x0(%r13),%rax
movss  %xmm0,(%rax)
mov    0x58(%rsp),%rsi
movss  (%rbx,%rsi,4),%xmm0
mov    0x8(%r13),%rcx
movss  %xmm0,(%rcx)
mov    0x128(%rsp),%r8
movss  (%rbx,%r8,4),%xmm0
mov    0x10(%r13),%rdx
movss  %xmm0,(%rdx)
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rax)
mov    0x48(%rsp),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0x8(%rax)
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rcx)
mov    0x40(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rcx)
movss  (%rbx,%r8,4),%xmm0
movss  %xmm0,0x4(%rdx)
mov    0x120(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rdx)
jmp    19ca <aan_mascara_canal+0x89a>
movss  -0x4(%rbx,%r12,4),%xmm0
mov    0x0(%r13),%rax
movss  %xmm0,(%rax)
movss  (%rbx,%r12,4),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x4(%rbx,%r12,4),%xmm0
movss  %xmm0,0x8(%rax)
mov    0x8(%r13),%rax
movss  -0x4(%rbx,%r12,4),%xmm0
movss  %xmm0,(%rax)
movss  (%rbx,%r12,4),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x4(%rbx,%r12,4),%xmm0
movss  %xmm0,0x8(%rax)
mov    (%rsp),%rax
add    %r12d,%eax
mov    0x10(%r13),%rcx
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
mov    0x70(%rsp),%rax
jmp    199f <aan_mascara_canal+0x86f>
mov    0x28(%rsp),%rax
add    %r12d,%eax
mov    0x0(%r13),%rcx
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
mov    %r14,%rax
sar    $0x1e,%rax
movss  (%rbx,%rax,1),%xmm0
movss  %xmm0,0x4(%rcx)
mov    0x20(%rsp),%rax
add    %r12d,%eax
add    $0x1,%eax
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rcx)
mov    0x10(%rsp),%rax
add    %r12d,%eax
mov    0x8(%r13),%rcx
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
mov    %r15,%rax
sar    $0x1e,%rax
movss  (%rbx,%rax,1),%xmm0
movss  %xmm0,0x4(%rcx)
mov    0x18(%rsp),%rax
add    %r12d,%eax
add    $0x1,%eax
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rcx)
mov    0xb8(%rsp),%rax
add    %r12d,%eax
mov    0x10(%r13),%rcx
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
mov    0xc0(%rsp),%rax
add    %r12,%rax
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx)
add    $0x1,%eax
cltq
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rcx)
mov    0x158(%rsp),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1050 <pixel_resultante@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x0(%rbp,%r12,4)
movd   0x61e(%rip),%xmm0
cmp    $0x1,%eax
mov    0x160(%rsp),%rsi
jg     1430 <aan_mascara_canal+0x300>
test   %eax,%eax
jns    1437 <aan_mascara_canal+0x307>
pxor   %xmm0,%xmm0
jmp    1430 <aan_mascara_canal+0x300>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rsi
mov    %rsi,%rax
cmp    0x100(%rsp),%rax
jne    1281 <aan_mascara_canal+0x151>
mov    0x0(%r13),%rax
mov    %rax,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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