#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int GLuint;
typedef int GLubyte;
typedef int GLint;
typedef float GLfloat;

/* Variables and functions */
int floor(float);
int /*<<< orphan*/ halveImage_float(int, int, int, float const *, float *, int,
                                    int, int, int);
void scale_internal_float(GLint components, GLint widthin, GLint heightin,
                          const GLfloat *datain, GLint widthout,
                          GLint heightout, GLfloat *dataout, GLint element_size,
                          GLint ysize, GLint group_size, GLint myswap_bytes) {
  float convx;
  float convy;
  float percent;
  float totals[4];
  float area;
  int i, j, k, xindex;
  const char *temp, *temp0;
  const char *temp_index;
  int outindex;
  int lowx_int, highx_int, lowy_int, highy_int;
  float x_percent, y_percent;
  float lowx_float, highx_float, lowy_float, highy_float;
  float convy_float, convx_float;
  int convy_int, convx_int;
  int l, m;
  const char *left, *right;
  union {
    GLuint b;
    GLfloat f;
  } swapbuf;
  if (widthin == widthout * 2 && heightin == heightout * 2) {
    halveImage_float(components, widthin, heightin, (const GLfloat *)datain,
                     (GLfloat *)dataout, element_size, ysize, group_size,
                     myswap_bytes);
    return;
  }
  convy = (float)heightin / heightout;
  convx = (float)widthin / widthout;
  convy_int = floor(convy);
  convy_float = convy - convy_int;
  convx_int = floor(convx);
  convx_float = convx - convx_int;
  area = convx * convy;
  lowy_int = 0;
  lowy_float = 0;
  highy_int = convy_int;
  highy_float = convy_float;
  for (i = 0; i < heightout; i++) {
    if (highy_int >= heightin)
      highy_int = heightin - 1;
    lowx_int = 0;
    lowx_float = 0;
    highx_int = convx_int;
    highx_float = convx_float;
    for (j = 0; j < widthout; j++) {
      totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
      xindex = lowx_int * group_size;
      if ((highy_int > lowy_int) && (highx_int > lowx_int)) {
        y_percent = 1 - lowy_float;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        percent = y_percent * (1 - lowx_float);
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
        left = temp;
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf.b =
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
              totals[k] += swapbuf.f * y_percent;
            } else {
              totals[k] += *(const GLfloat *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        right = temp;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
        y_percent = highy_float;
        percent = y_percent * (1 - lowx_float);
        temp = (const char *)datain + xindex + highy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf.b =
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
              totals[k] += swapbuf.f * y_percent;
            } else {
              totals[k] += *(const GLfloat *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
        for (m = lowy_int + 1; m < highy_int; m++) {
          left += ysize;
          right += ysize;
          for (k = 0; k < components;
               k++, left += element_size, right += element_size) {
            if (myswap_bytes) {
              swapbuf.b =
                  (GLuint)(((GLuint)((const GLubyte *)(left))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(left))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(left))[1]) << 8 |
                           ((const GLubyte *)(left))[0]);
              totals[k] += swapbuf.f * (1 - lowx_float);
              swapbuf.b =
                  (GLuint)(((GLuint)((const GLubyte *)(right))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(right))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(right))[1]) << 8 |
                           ((const GLubyte *)(right))[0]);
              totals[k] += swapbuf.f * highx_float;
            } else {
              totals[k] += *(const GLfloat *)left * (1 - lowx_float) +
                           *(const GLfloat *)right * highx_float;
            }
          }
        }
      } else if (highy_int > lowy_int) {
        x_percent = highx_float - lowx_float;
        percent = (1 - lowy_float) * x_percent;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
        for (m = lowy_int + 1; m < highy_int; m++) {
          temp += ysize;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf.b =
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
              totals[k] += swapbuf.f * x_percent;
            } else {
              totals[k] += *(const GLfloat *)temp_index * x_percent;
            }
          }
        }
        percent = x_percent * highy_float;
        temp += ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
      } else if (highx_int > lowx_int) {
        y_percent = highy_float - lowy_float;
        percent = (1 - lowx_float) * y_percent;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf.b =
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
              totals[k] += swapbuf.f * y_percent;
            } else {
              totals[k] += *(const GLfloat *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
      } else {
        percent = (highy_float - lowy_float) * (highx_float - lowx_float);
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf.b =
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]);
            totals[k] += swapbuf.f * percent;
          } else {
            totals[k] += *(const GLfloat *)temp_index * percent;
          }
        }
      }
      temp0 =
          (const char *)datain + xindex + group_size + (lowy_int + 1) * ysize;
      for (m = lowy_int + 1; m < highy_int; m++) {
        temp = temp0;
        for (l = lowx_int + 1; l < highx_int; l++) {
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf.b =
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
              totals[k] += swapbuf.f;
            } else {
              totals[k] += *(const GLfloat *)temp_index;
            }
          }
          temp += group_size;
        }
        temp0 += ysize;
      }
      outindex = (j + (i * widthout)) * components;
      for (k = 0; k < components; k++) {
        dataout[outindex + k] = totals[k] / area;
      }
      lowx_int = highx_int;
      lowx_float = highx_float;
      highx_int += convx_int;
      highx_float += convx_float;
      if (highx_float > 1) {
        highx_float -= 1.0;
        highx_int++;
      }
    }
    lowy_int = highy_int;
    lowy_float = highy_float;
    highy_int += convy_int;
    highy_float += convy_float;
    if (highy_float > 1) {
      highy_float -= 1.0;
      highy_int++;
    }
  }
}


x86 assembly (clang, -O0):
<scale_internal_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    11a9 <scale_internal_float+0x89>
mov    -0xc(%rbp),%eax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    11a9 <scale_internal_float+0x89>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    0x10(%rbp),%r8
mov    0x18(%rbp),%r9d
mov    0x20(%rbp),%r11d
mov    0x28(%rbp),%r10d
mov    0x30(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <halveImage_float@plt>
jmp    2580 <scale_internal_float+0x1460>
cvtsi2ssl -0xc(%rbp),%xmm0
cvtsi2ssl -0x20(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
cvtsi2ssl -0x8(%rbp),%xmm0
cvtsi2ssl -0x1c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm0
call   1030 <floor@plt>
mov    %eax,-0xa8(%rbp)
movss  -0x28(%rbp),%xmm0
cvtsi2ssl -0xa8(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x24(%rbp),%xmm0
call   1030 <floor@plt>
mov    %eax,-0xac(%rbp)
movss  -0x24(%rbp),%xmm0
cvtsi2ssl -0xac(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x24(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0xa8(%rbp),%eax
mov    %eax,-0x84(%rbp)
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    2580 <scale_internal_float+0x1460>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     128c <scale_internal_float+0x16c>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0xac(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    24de <scale_internal_float+0x13be>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x78(%rbp),%eax
imul   0x28(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jle    1b2f <scale_internal_float+0xa0f>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    1b2f <scale_internal_float+0xa0f>
movss  0x1ce9(%rip),%xmm0
subss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
add    %rcx,%rax
mov    -0x80(%rbp),%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  0x1cad(%rip),%xmm1
subss  -0x90(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    142a <scale_internal_float+0x30a>
cmpl   $0x0,0x30(%rbp)
je     13e1 <scale_internal_float+0x2c1>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1406 <scale_internal_float+0x2e6>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    140b <scale_internal_float+0x2eb>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1373 <scale_internal_float+0x253>
mov    -0x60(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1546 <scale_internal_float+0x426>
mov    0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    152d <scale_internal_float+0x40d>
cmpl   $0x0,0x30(%rbp)
je     14e1 <scale_internal_float+0x3c1>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1509 <scale_internal_float+0x3e9>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    150e <scale_internal_float+0x3ee>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1470 <scale_internal_float+0x350>
jmp    1532 <scale_internal_float+0x412>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1441 <scale_internal_float+0x321>
mov    0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0xc8(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    163d <scale_internal_float+0x51d>
cmpl   $0x0,0x30(%rbp)
je     15f4 <scale_internal_float+0x4d4>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1619 <scale_internal_float+0x4f9>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    161e <scale_internal_float+0x4fe>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1586 <scale_internal_float+0x466>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  0x19a3(%rip),%xmm1
subss  -0x90(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
add    %rcx,%rax
mov    -0x84(%rbp),%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1753 <scale_internal_float+0x633>
cmpl   $0x0,0x30(%rbp)
je     170a <scale_internal_float+0x5ea>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    172f <scale_internal_float+0x60f>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1734 <scale_internal_float+0x614>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    169c <scale_internal_float+0x57c>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1864 <scale_internal_float+0x744>
mov    0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    184b <scale_internal_float+0x72b>
cmpl   $0x0,0x30(%rbp)
je     17ff <scale_internal_float+0x6df>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1827 <scale_internal_float+0x707>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    182c <scale_internal_float+0x70c>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    178e <scale_internal_float+0x66e>
jmp    1850 <scale_internal_float+0x730>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    175f <scale_internal_float+0x63f>
mov    0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1950 <scale_internal_float+0x830>
cmpl   $0x0,0x30(%rbp)
je     1907 <scale_internal_float+0x7e7>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    192c <scale_internal_float+0x80c>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1931 <scale_internal_float+0x811>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1899 <scale_internal_float+0x779>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1b2a <scale_internal_float+0xa0a>
mov    0x20(%rbp),%ecx
mov    -0xc0(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0xc0(%rbp)
mov    0x20(%rbp),%ecx
mov    -0xc8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b11 <scale_internal_float+0x9f1>
cmpl   $0x0,0x30(%rbp)
je     1a8a <scale_internal_float+0x96a>
mov    -0xc0(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0xc0(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0xc0(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0xc0(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  0x15fd(%rip),%xmm2
subss  -0x90(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
mov    -0xc8(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0xc8(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0xc8(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0xc8(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1ad0 <scale_internal_float+0x9b0>
mov    -0xc0(%rbp),%rax
movss  (%rax),%xmm0
movss  0x1563(%rip),%xmm2
subss  -0x90(%rbp),%xmm2
ff
mov    -0xc8(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1ad5 <scale_internal_float+0x9b5>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0xc0(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0xc0(%rbp)
mov    0x18(%rbp),%ecx
mov    -0xc8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
jmp    19a3 <scale_internal_float+0x883>
jmp    1b16 <scale_internal_float+0x9f6>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    195c <scale_internal_float+0x83c>
jmp    2299 <scale_internal_float+0x1179>
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jle    1e5a <scale_internal_float+0xd3a>
movss  -0x94(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  0x14a2(%rip),%xmm0
subss  -0x98(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
add    %rcx,%rax
mov    -0x80(%rbp),%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c55 <scale_internal_float+0xb35>
cmpl   $0x0,0x30(%rbp)
je     1c0c <scale_internal_float+0xaec>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1c31 <scale_internal_float+0xb11>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1c36 <scale_internal_float+0xb16>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1b9e <scale_internal_float+0xa7e>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1d69 <scale_internal_float+0xc49>
mov    0x20(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1d50 <scale_internal_float+0xc30>
cmpl   $0x0,0x30(%rbp)
je     1d04 <scale_internal_float+0xbe4>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1d2c <scale_internal_float+0xc0c>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1d31 <scale_internal_float+0xc11>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1c93 <scale_internal_float+0xb73>
jmp    1d55 <scale_internal_float+0xc35>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1c61 <scale_internal_float+0xb41>
movss  -0x88(%rbp),%xmm0
ff
mulss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
mov    0x20(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e55 <scale_internal_float+0xd35>
cmpl   $0x0,0x30(%rbp)
je     1e0c <scale_internal_float+0xcec>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1e31 <scale_internal_float+0xd11>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1e36 <scale_internal_float+0xd16>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1d9e <scale_internal_float+0xc7e>
jmp    2294 <scale_internal_float+0x1174>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    217f <scale_internal_float+0x105f>
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  0x117a(%rip),%xmm0
subss  -0x90(%rbp),%xmm0
ff
mulss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
add    %rcx,%rax
mov    -0x80(%rbp),%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1f7d <scale_internal_float+0xe5d>
cmpl   $0x0,0x30(%rbp)
je     1f34 <scale_internal_float+0xe14>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1f59 <scale_internal_float+0xe39>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1f5e <scale_internal_float+0xe3e>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1ec6 <scale_internal_float+0xda6>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    208e <scale_internal_float+0xf6e>
mov    0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2075 <scale_internal_float+0xf55>
cmpl   $0x0,0x30(%rbp)
je     2029 <scale_internal_float+0xf09>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2051 <scale_internal_float+0xf31>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2056 <scale_internal_float+0xf36>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1fb8 <scale_internal_float+0xe98>
jmp    207a <scale_internal_float+0xf5a>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1f89 <scale_internal_float+0xe69>
mov    0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    217a <scale_internal_float+0x105a>
cmpl   $0x0,0x30(%rbp)
je     2131 <scale_internal_float+0x1011>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2156 <scale_internal_float+0x1036>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    215b <scale_internal_float+0x103b>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    20c3 <scale_internal_float+0xfa3>
jmp    228f <scale_internal_float+0x116f>
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm1
ff
subss  -0x90(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
add    %rcx,%rax
mov    -0x80(%rbp),%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    228a <scale_internal_float+0x116a>
cmpl   $0x0,0x30(%rbp)
je     2241 <scale_internal_float+0x1121>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2266 <scale_internal_float+0x1146>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    226b <scale_internal_float+0x114b>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    21d3 <scale_internal_float+0x10b3>
jmp    228f <scale_internal_float+0x116f>
jmp    2294 <scale_internal_float+0x1174>
jmp    2299 <scale_internal_float+0x1179>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
add    %rcx,%rax
movslq 0x28(%rbp),%rcx
add    %rcx,%rax
mov    -0x80(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    23f6 <scale_internal_float+0x12d6>
mov    -0x68(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    23d1 <scale_internal_float+0x12b1>
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    23ac <scale_internal_float+0x128c>
cmpl   $0x0,0x30(%rbp)
je     2370 <scale_internal_float+0x1250>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xd0(%rbp)
movss  -0xd0(%rbp),%xmm0
ff
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2388 <scale_internal_float+0x1268>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    238d <scale_internal_float+0x126d>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    230f <scale_internal_float+0x11ef>
mov    0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    22f1 <scale_internal_float+0x11d1>
mov    0x20(%rbp),%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    22cb <scale_internal_float+0x11ab>
mov    -0x4c(%rbp),%eax
mov    -0x48(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    %ecx,%eax
imul   -0x4(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    244b <scale_internal_float+0x132b>
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
divss  -0x44(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2410 <scale_internal_float+0x12f0>
mov    -0x7c(%rbp),%eax
mov    %eax,-0x78(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
mov    -0xac(%rbp),%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movss  0xb6b(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    24cb <scale_internal_float+0x13ab>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xb56(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    24d0 <scale_internal_float+0x13b0>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12be <scale_internal_float+0x19e>
mov    -0x84(%rbp),%eax
mov    %eax,-0x80(%rbp)
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x98(%rbp)
ff
mov    -0xa8(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
movss  -0xa0(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
movss  0xacf(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    256d <scale_internal_float+0x144d>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xaba(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    2572 <scale_internal_float+0x1452>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1265 <scale_internal_float+0x145>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_internal_float>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9d,%ebx
mov    %rcx,0x58(%rsp)
mov    %edi,0xc(%rsp)
mov    0x1d0(%rsp),%r14d
mov    0x1b8(%rsp),%ebp
mov    %r8,0x68(%rsp)
lea    (%r8,%r8,1),%eax
cmp    %esi,%eax
jne    119b <scale_internal_float+0x7b>
lea    (%rbx,%rbx,1),%eax
cmp    %edx,%eax
jne    119b <scale_internal_float+0x7b>
sub    $0x8,%rsp
mov    0x14(%rsp),%edi
mov    0x60(%rsp),%rcx
mov    0x1b8(%rsp),%r8
mov    %ebp,%r9d
push   %r14
mov    0x1d8(%rsp),%eax
push   %rax
mov    0x1d8(%rsp),%eax
push   %rax
call   1040 <halveImage_float@plt>
add    $0x198,%rsp
jmp    1f0b <scale_internal_float+0xdeb>
cvtsi2ss %edx,%xmm0
cvtsi2ss %ebx,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,0x30(%rsp)
cvtsi2ss %esi,%xmm2
xorps  %xmm1,%xmm1
cvtsi2ssl 0x68(%rsp),%xmm1
divss  %xmm1,%xmm2
movaps %xmm2,0x40(%rsp)
mov    %rdx,0x98(%rsp)
call   1030 <floor@plt>
mov    %rax,0x90(%rsp)
movaps 0x40(%rsp),%xmm0
call   1030 <floor@plt>
movaps 0x40(%rsp),%xmm1
movss  0x30(%rsp),%xmm12
mov    0x98(%rsp),%rcx
mov    %rax,0x80(%rsp)
test   %ebx,%ebx
jle    1f04 <scale_internal_float+0xde4>
mov    0x90(%rsp),%r8
xorps  %xmm0,%xmm0
cvtsi2ss %r8d,%xmm0
xorps  %xmm2,%xmm2
cvtsi2ssl 0x80(%rsp),%xmm2
movaps %xmm1,%xmm11
subss  %xmm2,%xmm11
mulss  %xmm12,%xmm1
subss  %xmm0,%xmm12
lea    -0x1(%rcx),%eax
mov    %eax,0x8c(%rsp)
movslq %ebp,%r15
mov    0x1c8(%rsp),%eax
movslq %eax,%rsi
mov    0x1c0(%rsp),%eax
movslq %eax,%r11
movslq 0xc(%rsp),%rdi
mov    0x68(%rsp),%rax
movslq %eax,%rbp
mov    %ebx,%ebx
mov    %rbx,0xf8(%rsp)
mov    %eax,%eax
mov    %rax,0x150(%rsp)
mov    %edi,%r9d
mov    0x58(%rsp),%r10
lea    (%r10,%rsi,1),%rbx
mov    %rbx,0xe0(%rsp)
mov    %r9d,%ebx
and    $0xfffffffc,%ebx
mov    %rbx,0x128(%rsp)
add    $0xfffffffffffffffc,%rbx
mov    %rbx,0x120(%rsp)
mov    %rbx,%rax
shr    $0x2,%rax
add    $0x1,%rax
movaps %xmm1,%xmm13
shufps $0x0,%xmm1,%xmm13
mov    %rax,%rbx
mov    %rax,0x118(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0x110(%rsp)
mov    %rbp,0xe8(%rsp)
imul   %rdi,%rbp
shl    $0x2,%rbp
mov    %rbp,0xf0(%rsp)
xorps  %xmm2,%xmm2
movss  0xd0c(%rip),%xmm10
xorps  %xmm8,%xmm8
movss  0xd03(%rip),%xmm9
movaps %xmm12,%xmm3
mov    %rsi,0x40(%rsp)
lea    0xc(%r10,%rsi,1),%rax
mov    %rax,0xd8(%rsp)
mov    0x1b0(%rsp),%rax
lea    0x10(%rax),%rsi
mov    %rsi,0xa8(%rsp)
mov    %rdi,0x100(%rsp)
lea    0x0(,%rdi,4),%rsi
mov    %rsi,0x148(%rsp)
xor    %esi,%esi
mov    %rsi,0x70(%rsp)
mov    %rax,0xa0(%rsp)
mov    %r8d,%eax
xor    %esi,%esi
mov    %rsi,0x60(%rsp)
mov    %r11,0xb8(%rsp)
mov    %r9,0xd0(%rsp)
jmp    13bb <scale_internal_float+0x29b>
xchg   %ax,%ax
mov    %bl,%cl
add    %ecx,%eax
mov    0x70(%rsp),%rsi
add    $0x1,%rsi
mov    0xf0(%rsp),%rcx
add    %rcx,0xa8(%rsp)
add    %rcx,0xa0(%rsp)
movaps %xmm5,%xmm2
mov    %r13,0x60(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x70(%rsp)
cmp    0xf8(%rsp),%rsi
mov    0x98(%rsp),%rcx
je     1f04 <scale_internal_float+0xde4>
movaps %xmm3,%xmm5
cmp    %ecx,%eax
mov    %eax,%r13d
cmovge 0x8c(%rsp),%r13d
cmpl   $0x0,0x68(%rsp)
jle    1ed0 <scale_internal_float+0xdb0>
movaps %xmm5,%xmm6
subss  %xmm2,%xmm6
mov    0x60(%rsp),%rsi
mov    %esi,%eax
mov    0x1c0(%rsp),%ecx
imul   %ecx,%eax
movslq %eax,%rdi
movaps %xmm10,%xmm7
subss  %xmm2,%xmm7
add    $0x1,%esi
mov    %r13d,%eax
imul   %ecx,%eax
cltq
mov    %rax,0xb0(%rsp)
mov    %esi,0x2c(%rsp)
mov    %esi,%eax
imul   %ecx,%eax
movslq %eax,%rcx
mov    0x70(%rsp),%rax
imul   0xe8(%rsp),%rax
mov    %rax,0x108(%rsp)
mov    0x58(%rsp),%rax
mov    %rdi,0x140(%rsp)
add    %rdi,%rax
mov    %rax,0x78(%rsp)
mov    0xe0(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x130(%rsp)
add    0xd8(%rsp),%rcx
mov    %rcx,0x138(%rsp)
xor    %r8d,%r8d
xorps  %xmm4,%xmm4
mov    0xa0(%rsp),%r10
mov    0xa8(%rsp),%r12
movaps %xmm11,%xmm2
mov    0x80(%rsp),%rax
xor    %ecx,%ecx
mov    %r13,0x170(%rsp)
jmp    14c9 <scale_internal_float+0x3a9>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %bl,%cl
add    %ecx,%eax
add    $0x1,%r8
mov    0x148(%rsp),%rcx
add    %rcx,%r12
add    %rcx,%r10
movaps %xmm3,%xmm4
mov    %edx,%ecx
cmp    0x150(%rsp),%r8
je     1ed0 <scale_internal_float+0xdb0>
mov    %eax,%edx
movaps %xmm2,%xmm3
mov    %ecx,%esi
mov    0x1c8(%rsp),%eax
imul   %eax,%esi
mov    %esi,0x28(%rsp)
movaps %xmm8,0x10(%rsp)
cmp    0x60(%rsp),%r13d
mov    %rdx,0x30(%rsp)
mov    %rcx,0x38(%rsp)
mov    %r8,0x168(%rsp)
mov    %r10,0x160(%rsp)
mov    %r12,0x158(%rsp)
jle    15a0 <scale_internal_float+0x480>
cmp    %ecx,%edx
jle    15a0 <scale_internal_float+0x480>
movslq 0x28(%rsp),%r11
add    0x58(%rsp),%r11
mov    0x140(%rsp),%rax
lea    (%r11,%rax,1),%r10
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
cmpl   $0x0,0xc(%rsp)
jle    1630 <scale_internal_float+0x510>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %eax,%eax
mov    %r10,%rcx
jmp    1574 <scale_internal_float+0x454>
movd   (%rcx),%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%rcx
cmp    %rax,%r9
je     1630 <scale_internal_float+0x510>
test   %r14d,%r14d
je     1550 <scale_internal_float+0x430>
mov    0xc(%rcx),%esi
shl    $0x18,%esi
mov    0x4(%rcx),%edi
mov    0x8(%rcx),%ebp
shl    $0x10,%ebp
or     %esi,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%rcx),%edi
movd   %edi,%xmm0
jmp    1554 <scale_internal_float+0x434>
nopw   0x0(%rax,%rax,1)
cmp    0x60(%rsp),%r13d
jle    17b0 <scale_internal_float+0x690>
movslq 0x28(%rsp),%r8
add    0x78(%rsp),%r8
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
cmpl   $0x0,0xc(%rsp)
jle    1840 <scale_internal_float+0x720>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %eax,%eax
mov    %r8,%rsi
jmp    1604 <scale_internal_float+0x4e4>
cs nopw 0x0(%rax,%rax,1)
nop
movd   (%rsi),%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%rsi
cmp    %rax,%r9
je     1840 <scale_internal_float+0x720>
test   %r14d,%r14d
je     15e0 <scale_internal_float+0x4c0>
mov    0xc(%rsi),%edi
shl    $0x18,%edi
mov    0x4(%rsi),%ebp
mov    0x8(%rsi),%ebx
shl    $0x10,%ebx
or     %edi,%ebx
shl    $0x8,%ebp
or     %ebx,%ebp
or     (%rsi),%ebp
movd   %ebp,%xmm0
jmp    15e4 <scale_internal_float+0x4c4>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
lea    0x1(%rax),%r8d
mov    %r10,%r12
cmp    0x30(%rsp),%r8d
jge    16c0 <scale_internal_float+0x5a0>
mov    %r8d,%eax
mov    %r10,%r12
jmp    1659 <scale_internal_float+0x539>
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
cmp    0x30(%rsp),%eax
je     16c0 <scale_internal_float+0x5a0>
add    0x40(%rsp),%r12
cmpl   $0x0,0xc(%rsp)
jle    1650 <scale_internal_float+0x530>
xor    %esi,%esi
mov    %r12,%rdi
jmp    1690 <scale_internal_float+0x570>
nopl   0x0(%rax)
movd   (%rdi),%xmm0
mulss  %xmm7,%xmm0
addss  0x10(%rsp,%rsi,4),%xmm0
movss  %xmm0,0x10(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r15,%rdi
cmp    %rsi,%r9
je     1650 <scale_internal_float+0x530>
test   %r14d,%r14d
je     1670 <scale_internal_float+0x550>
mov    0xc(%rdi),%ebp
shl    $0x18,%ebp
mov    0x4(%rdi),%ebx
mov    0x8(%rdi),%ecx
shl    $0x10,%ecx
or     %ebp,%ecx
shl    $0x8,%ebx
or     %ecx,%ebx
or     (%rdi),%ebx
movd   %ebx,%xmm0
jmp    1674 <scale_internal_float+0x554>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0x40(%rsp),%r12
cmpl   $0x0,0xc(%rsp)
jle    192c <scale_internal_float+0x80c>
movaps %xmm7,%xmm4
mulss  %xmm3,%xmm4
xor    %eax,%eax
mov    %r12,%rsi
jmp    1700 <scale_internal_float+0x5e0>
xchg   %ax,%ax
movd   (%rsi),%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%rsi
cmp    %rax,%r9
je     1730 <scale_internal_float+0x610>
test   %r14d,%r14d
je     16e0 <scale_internal_float+0x5c0>
mov    0xc(%rsi),%ecx
shl    $0x18,%ecx
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%ebp
shl    $0x10,%ebp
or     %ecx,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%rsi),%edi
movd   %edi,%xmm0
jmp    16e4 <scale_internal_float+0x5c4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0xb0(%rsp),%r11
cmpl   $0x0,0xc(%rsp)
jle    1934 <scale_internal_float+0x814>
movaps %xmm5,%xmm4
mulss  %xmm2,%xmm4
xor    %eax,%eax
mov    %r11,%rsi
jmp    1784 <scale_internal_float+0x664>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   (%rsi),%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%rsi
cmp    %rax,%r9
je     1934 <scale_internal_float+0x814>
test   %r14d,%r14d
je     1760 <scale_internal_float+0x640>
mov    0xc(%rsi),%ecx
shl    $0x18,%ecx
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%ebp
shl    $0x10,%ebp
or     %ecx,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%rsi),%edi
movd   %edi,%xmm0
jmp    1764 <scale_internal_float+0x644>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
cmp    %ecx,%edx
jle    1aef <scale_internal_float+0x9cf>
movslq 0x28(%rsp),%r8
add    0x78(%rsp),%r8
cmpl   $0x0,0xc(%rsp)
jle    1b67 <scale_internal_float+0xa47>
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
xor    %eax,%eax
mov    %r8,%rsi
jmp    1814 <scale_internal_float+0x6f4>
cs nopw 0x0(%rax,%rax,1)
nop
movd   (%rsi),%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%rsi
cmp    %rax,%r9
je     1b67 <scale_internal_float+0xa47>
test   %r14d,%r14d
je     17f0 <scale_internal_float+0x6d0>
mov    0xc(%rsi),%edi
shl    $0x18,%edi
mov    0x4(%rsi),%ebp
mov    0x8(%rsi),%ebx
shl    $0x10,%ebx
or     %edi,%ebx
shl    $0x8,%ebp
or     %ebx,%ebp
or     (%rsi),%ebp
movd   %ebp,%xmm0
jmp    17f4 <scale_internal_float+0x6d4>
nopw   0x0(%rax,%rax,1)
mov    0x2c(%rsp),%ecx
mov    %ecx,%eax
cmp    %r13d,%ecx
jl     1878 <scale_internal_float+0x758>
cmpl   $0x0,0xc(%rsp)
jle    1c50 <scale_internal_float+0xb30>
mulss  %xmm5,%xmm2
add    %r11,%r8
xor    %eax,%eax
jmp    1905 <scale_internal_float+0x7e5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%eax
cmp    %r13d,%eax
je     184b <scale_internal_float+0x72b>
add    %r11,%r8
cmpl   $0x0,0xc(%rsp)
jle    1870 <scale_internal_float+0x750>
xor    %esi,%esi
mov    %r8,%rdi
jmp    18b0 <scale_internal_float+0x790>
nopl   0x0(%rax)
movd   (%rdi),%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rsi,4),%xmm0
movss  %xmm0,0x10(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r15,%rdi
cmp    %rsi,%r9
je     1870 <scale_internal_float+0x750>
test   %r14d,%r14d
je     1890 <scale_internal_float+0x770>
mov    0xc(%rdi),%ebp
shl    $0x18,%ebp
mov    0x4(%rdi),%ebx
mov    0x8(%rdi),%ecx
shl    $0x10,%ecx
or     %ebp,%ecx
shl    $0x8,%ebx
or     %ecx,%ebx
or     (%rdi),%ebx
movd   %ebx,%xmm0
jmp    1894 <scale_internal_float+0x774>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   (%r8),%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%r8
cmp    %rax,%r9
je     1c50 <scale_internal_float+0xb30>
test   %r14d,%r14d
je     18e0 <scale_internal_float+0x7c0>
mov    0xc(%r8),%ecx
shl    $0x18,%ecx
mov    0x4(%r8),%esi
mov    0x8(%r8),%edi
shl    $0x10,%edi
or     %ecx,%edi
shl    $0x8,%esi
or     %edi,%esi
or     (%r8),%esi
movd   %esi,%xmm0
jmp    18e5 <scale_internal_float+0x7c5>
add    0xb0(%rsp),%r11
cmp    0x30(%rsp),%r8d
jl     196b <scale_internal_float+0x84b>
cmpl   $0x0,0xc(%rsp)
jle    1a20 <scale_internal_float+0x900>
movaps %xmm5,%xmm4
mulss  %xmm3,%xmm4
add    0x40(%rsp),%r11
xor    %eax,%eax
jmp    19f1 <scale_internal_float+0x8d1>
nopl   0x0(%rax)
add    $0x1,%r8d
cmp    0x30(%rsp),%r8d
je     193b <scale_internal_float+0x81b>
add    0x40(%rsp),%r11
cmpl   $0x0,0xc(%rsp)
jle    1960 <scale_internal_float+0x840>
xor    %eax,%eax
mov    %r11,%rsi
jmp    19a0 <scale_internal_float+0x880>
xchg   %ax,%ax
movd   (%rsi),%xmm0
mulss  %xmm5,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%rsi
cmp    %rax,%r9
je     1960 <scale_internal_float+0x840>
test   %r14d,%r14d
je     1980 <scale_internal_float+0x860>
mov    0xc(%rsi),%ecx
shl    $0x18,%ecx
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%ebp
shl    $0x10,%ebp
or     %ecx,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%rsi),%edi
movd   %edi,%xmm0
jmp    1984 <scale_internal_float+0x864>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   (%r11),%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%r11
cmp    %rax,%r9
je     1a20 <scale_internal_float+0x900>
test   %r14d,%r14d
je     19d0 <scale_internal_float+0x8b0>
mov    0xc(%r11),%ecx
shl    $0x18,%ecx
mov    0x4(%r11),%esi
mov    0x8(%r11),%edi
shl    $0x10,%edi
or     %ecx,%edi
shl    $0x8,%esi
or     %edi,%esi
or     (%r11),%esi
movd   %esi,%xmm0
jmp    19d5 <scale_internal_float+0x8b5>
nopl   0x0(%rax,%rax,1)
mov    0x2c(%rsp),%ecx
mov    %ecx,%eax
cmp    %r13d,%ecx
mov    0x30(%rsp),%rdx
mov    0xb8(%rsp),%r11
jl     1a4c <scale_internal_float+0x92c>
jmp    1da0 <scale_internal_float+0xc80>
nopl   (%rax)
add    $0x1,%eax
cmp    %r13d,%eax
je     1c50 <scale_internal_float+0xb30>
add    %r11,%r10
add    %r11,%r12
cmpl   $0x0,0xc(%rsp)
jle    1a40 <scale_internal_float+0x920>
xor    %ecx,%ecx
jmp    1a92 <scale_internal_float+0x972>
nopl   (%rax)
movss  (%r12),%xmm0
mulss  %xmm3,%xmm0
movss  (%r10),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
addss  0x10(%rsp,%rcx,4),%xmm4
movss  %xmm4,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r15,%r10
add    %r15,%r12
cmp    %rcx,%r9
je     1a40 <scale_internal_float+0x920>
test   %r14d,%r14d
je     1a60 <scale_internal_float+0x940>
mov    0xc(%r10),%esi
shl    $0x18,%esi
mov    0x4(%r10),%edi
mov    0x8(%r10),%ebp
shl    $0x10,%ebp
or     %esi,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%r10),%edi
movd   %edi,%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
mov    0xc(%r12),%esi
shl    $0x18,%esi
mov    0x4(%r12),%edi
mov    0x8(%r12),%ebp
shl    $0x10,%ebp
or     %esi,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%r12),%edi
movd   %edi,%xmm4
mulss  %xmm3,%xmm4
addss  %xmm0,%xmm4
jmp    1a7d <scale_internal_float+0x95d>
cmpl   $0x0,0xc(%rsp)
jle    1c50 <scale_internal_float+0xb30>
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
movslq 0x28(%rsp),%rax
add    0x78(%rsp),%rax
xor    %ecx,%ecx
jmp    1b44 <scale_internal_float+0xa24>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   (%rax),%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r15,%rax
cmp    %rcx,%r9
je     1c50 <scale_internal_float+0xb30>
test   %r14d,%r14d
je     1b20 <scale_internal_float+0xa00>
mov    0xc(%rax),%esi
shl    $0x18,%esi
mov    0x4(%rax),%edi
mov    0x8(%rax),%ebp
shl    $0x10,%ebp
or     %esi,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%rax),%edi
movd   %edi,%xmm0
jmp    1b24 <scale_internal_float+0xa04>
lea    0x1(%rcx),%eax
cmp    %edx,%eax
jl     1b97 <scale_internal_float+0xa77>
cmpl   $0x0,0xc(%rsp)
jle    1c50 <scale_internal_float+0xb30>
movaps %xmm6,%xmm2
mulss  %xmm3,%xmm2
add    0x40(%rsp),%r8
xor    %eax,%eax
jmp    1c21 <scale_internal_float+0xb01>
nopl   0x0(%rax)
add    $0x1,%eax
cmp    %edx,%eax
je     1b6e <scale_internal_float+0xa4e>
add    0x40(%rsp),%r8
cmpl   $0x0,0xc(%rsp)
jle    1b90 <scale_internal_float+0xa70>
xor    %esi,%esi
mov    %r8,%rdi
jmp    1bd0 <scale_internal_float+0xab0>
nopw   0x0(%rax,%rax,1)
movd   (%rdi),%xmm0
mulss  %xmm6,%xmm0
addss  0x10(%rsp,%rsi,4),%xmm0
movss  %xmm0,0x10(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r15,%rdi
cmp    %rsi,%r9
je     1b90 <scale_internal_float+0xa70>
test   %r14d,%r14d
je     1bb0 <scale_internal_float+0xa90>
mov    0xc(%rdi),%ebp
shl    $0x18,%ebp
mov    0x4(%rdi),%ebx
mov    0x8(%rdi),%ecx
shl    $0x10,%ecx
or     %ebp,%ecx
shl    $0x8,%ebx
or     %ecx,%ebx
or     (%rdi),%ebx
movd   %ebx,%xmm0
jmp    1bb4 <scale_internal_float+0xa94>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   (%r8),%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp,%rax,4)
add    $0x1,%rax
add    %r15,%r8
cmp    %rax,%r9
je     1c50 <scale_internal_float+0xb30>
test   %r14d,%r14d
je     1c00 <scale_internal_float+0xae0>
mov    0xc(%r8),%ecx
shl    $0x18,%ecx
mov    0x4(%r8),%esi
mov    0x8(%r8),%edi
shl    $0x10,%edi
or     %ecx,%edi
shl    $0x8,%esi
or     %edi,%esi
or     (%r8),%esi
movd   %esi,%xmm0
jmp    1c05 <scale_internal_float+0xae5>
nopl   0x0(%rax,%rax,1)
cmp    %r13d,0x2c(%rsp)
jge    1da0 <scale_internal_float+0xc80>
movslq 0x28(%rsp),%rcx
mov    0x130(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xc0(%rsp)
mov    0x38(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
add    0x138(%rsp),%rcx
mov    %rcx,0xc8(%rsp)
mov    0x2c(%rsp),%eax
jmp    1cd8 <scale_internal_float+0xbb8>
cs nopw 0x0(%rax,%rax,1)
mov    0xb8(%rsp),%r11
add    %r11,0xc0(%rsp)
mov    0x28(%rsp),%eax
add    $0x1,%eax
add    %r11,0xc8(%rsp)
mov    0x170(%rsp),%r13
cmp    %r13d,%eax
mov    0xd0(%rsp),%r9
je     1da0 <scale_internal_float+0xc80>
mov    %eax,0x28(%rsp)
cmp    %edx,0x38(%rsp)
jge    1ca0 <scale_internal_float+0xb80>
mov    0xc8(%rsp),%r9
mov    0x38(%rsp),%rax
mov    %eax,%r12d
mov    0xc0(%rsp),%r10
jmp    1d19 <scale_internal_float+0xbf9>
nopl   0x0(%rax)
mov    0x40(%rsp),%rax
add    %rax,%r10
add    $0x1,%r12d
add    %rax,%r9
mov    0x30(%rsp),%rdx
cmp    %edx,%r12d
je     1ca0 <scale_internal_float+0xb80>
cmpl   $0x0,0xc(%rsp)
jle    1d00 <scale_internal_float+0xbe0>
mov    %r9,%rcx
mov    0xd0(%rsp),%rbx
lea    0x10(%rsp),%rdi
xor    %r13d,%r13d
mov    %r10,%rax
jmp    1d68 <scale_internal_float+0xc48>
nopl   0x0(%rax,%rax,1)
movd   (%rdi),%xmm2
mov    %rax,%r8
mov    %rdi,%r11
addss  (%r8),%xmm2
movss  %xmm2,(%r11)
add    $0x1,%r13
add    %r15,%rax
add    $0x4,%rdi
add    %r15,%rcx
add    $0xffffffffffffffff,%rbx
je     1d00 <scale_internal_float+0xbe0>
test   %r14d,%r14d
je     1d40 <scale_internal_float+0xc20>
mov    (%rcx),%edx
shl    $0x18,%edx
mov    -0x8(%rcx),%ebp
mov    -0x4(%rcx),%esi
shl    $0x10,%esi
or     %edx,%esi
shl    $0x8,%ebp
or     %esi,%ebp
or     -0xc(%rcx),%ebp
movd   %ebp,%xmm2
lea    (%rsp,%r13,4),%r11
add    $0x10,%r11
mov    %rdi,%r8
jmp    1d4a <scale_internal_float+0xc2a>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x0,0xc(%rsp)
mov    0x168(%rsp),%r8
mov    0x160(%rsp),%r10
mov    0x158(%rsp),%r12
jle    1e89 <scale_internal_float+0xd69>
cmpl   $0x4,0xc(%rsp)
jae    1de0 <scale_internal_float+0xcc0>
xor    %eax,%eax
jmp    1e70 <scale_internal_float+0xd50>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x120(%rsp)
je     1ebb <scale_internal_float+0xd9b>
mov    0x110(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movaps 0x10(%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
movups %xmm0,-0x10(%r12,%rax,4)
movaps 0x20(%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
movups %xmm0,(%r12,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1e00 <scale_internal_float+0xce0>
testb  $0x1,0x118(%rsp)
01
je     1e5d <scale_internal_float+0xd3d>
mov    0x108(%rsp),%rcx
add    %r8,%rcx
imul   0x100(%rsp),%rcx
movaps 0x10(%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
add    %rax,%rcx
mov    0x1b0(%rsp),%rax
movups %xmm0,(%rax,%rcx,4)
mov    0x128(%rsp),%rcx
mov    %rcx,%rax
cmp    %r9,%rcx
je     1e89 <scale_internal_float+0xd69>
nopl   (%rax)
movss  0x10(%rsp,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%r10,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    1e70 <scale_internal_float+0xd50>
movaps %xmm11,%xmm0
addss  %xmm3,%xmm0
xor    %ecx,%ecx
ucomiss %xmm10,%xmm0
mov    0x80(%rsp),%rax
lea    (%rdx,%rax,1),%eax
seta   %bl
movaps %xmm0,%xmm2
addss  %xmm9,%xmm2
ja     14a0 <scale_internal_float+0x380>
movaps %xmm0,%xmm2
jmp    14a0 <scale_internal_float+0x380>
xor    %eax,%eax
testb  $0x1,0x118(%rsp)
01
jne    1e31 <scale_internal_float+0xd11>
jmp    1e5d <scale_internal_float+0xd3d>
nopl   (%rax)
movaps %xmm12,%xmm0
addss  %xmm5,%xmm0
xor    %ecx,%ecx
ucomiss %xmm10,%xmm0
mov    0x90(%rsp),%rax
lea    0x0(%r13,%rax,1),%eax
seta   %bl
movaps %xmm0,%xmm3
addss  %xmm9,%xmm3
ja     1370 <scale_internal_float+0x250>
movaps %xmm0,%xmm3
jmp    1370 <scale_internal_float+0x250>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%union.anon = type { i32 }
define void @scale_internal_float(i32 %0, i32 %1, i32 %2, float* %3, i32 %4, i32 %5, float* %6, i32 %7, i32 %8, i32 %9, i32 %10) {
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float*
%16 = alloca i32
%17 = alloca i32
%18 = alloca float*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca [4 x float]
%27 = alloca float
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i8*
%33 = alloca i8*
%34 = alloca i8*
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = alloca float
%47 = alloca float
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
%52 = alloca i8*
%53 = alloca i8*
%54 = alloca %union.anon
store i32 %0, i32* %12
store i32 %1, i32* %13
store i32 %2, i32* %14
store float* %3, float** %15
store i32 %4, i32* %16
store i32 %5, i32* %17
store float* %6, float** %18
store i32 %7, i32* %19
store i32 %8, i32* %20
store i32 %9, i32* %21
store i32 %10, i32* %22
%55 = load i32, i32* %13
%56 = load i32, i32* %16
%57 = mul nsw i32 %56, 2
%58 = icmp eq i32 %55, %57
br i1 %58, label %59, label %75
59: ; preds = %11
%60 = load i32, i32* %14
%61 = load i32, i32* %17
%62 = mul nsw i32 %61, 2
%63 = icmp eq i32 %60, %62
br i1 %63, label %64, label %75
64: ; preds = %59
%65 = load i32, i32* %12
%66 = load i32, i32* %13
%67 = load i32, i32* %14
%68 = load float*, float** %15
%69 = load float*, float** %18
%70 = load i32, i32* %19
%71 = load i32, i32* %20
%72 = load i32, i32* %21
%73 = load i32, i32* %22
%74 = call i32 @halveImage_float(i32 %65, i32 %66, i32 %67, float* %68, float* %69, i32 %70, i32 %71, i32 %72, i32 %73)
br label %1383
75: ; preds = %59, %11
%76 = load i32, i32* %14
%77 = sitofp i32 %76 to float
%78 = load i32, i32* %17
%79 = sitofp i32 %78 to float
%80 = fdiv float %77, %79
store float %80, float* %24
%81 = load i32, i32* %13
%82 = sitofp i32 %81 to float
%83 = load i32, i32* %16
%84 = sitofp i32 %83 to float
%85 = fdiv float %82, %84
store float %85, float* %23
%86 = load float, float* %24
%87 = call i32 @floor(float %86)
store i32 %87, i32* %48
%88 = load float, float* %24
%89 = load i32, i32* %48
%90 = sitofp i32 %89 to float
%91 = fsub float %88, %90
store float %91, float* %46
%92 = load float, float* %23
%93 = call i32 @floor(float %92)
store i32 %93, i32* %49
%94 = load float, float* %23
%95 = load i32, i32* %49
%96 = sitofp i32 %95 to float
%97 = fsub float %94, %96
store float %97, float* %47
%98 = load float, float* %23
%99 = load float, float* %24
%100 = fmul float %98, %99
store float %100, float* %27
store i32 0, i32* %38
store float 0.000000e+00, float* %44
%101 = load i32, i32* %48
store i32 %101, i32* %39
%102 = load float, float* %46
store float %102, float* %45
store i32 0, i32* %28
br label %103
103: ; preds = %1380, %75
%104 = load i32, i32* %28
%105 = load i32, i32* %17
%106 = icmp slt i32 %104, %105
br i1 %106, label %107, label %1383
107: ; preds = %103
%108 = load i32, i32* %39
%109 = load i32, i32* %14
%110 = icmp sge i32 %108, %109
br i1 %110, label %111, label %114
111: ; preds = %107
%112 = load i32, i32* %14
%113 = sub nsw i32 %112, 1
store i32 %113, i32* %39
br label %114
114: ; preds = %111, %107
store i32 0, i32* %36
store float 0.000000e+00, float* %42
%115 = load i32, i32* %49
store i32 %115, i32* %37
%116 = load float, float* %47
store float %116, float* %43
store i32 0, i32* %29
br label %117
117: ; preds = %1358, %114
%118 = load i32, i32* %29
%119 = load i32, i32* %16
%120 = icmp slt i32 %118, %119
br i1 %120, label %121, label %1361
121: ; preds = %117
%122 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 3
store float 0.000000e+00, float* %122
%123 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 2
store float 0.000000e+00, float* %123
%124 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 1
store float 0.000000e+00, float* %124
%125 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 0
store float 0.000000e+00, float* %125
%126 = load i32, i32* %36
%127 = load i32, i32* %21
%128 = mul nsw i32 %126, %127
store i32 %128, i32* %31
%129 = load i32, i32* %39
%130 = load i32, i32* %38
%131 = icmp sgt i32 %129, %130
br i1 %131, label %132, label %688
132: ; preds = %121
%133 = load i32, i32* %37
%134 = load i32, i32* %36
%135 = icmp sgt i32 %133, %134
br i1 %135, label %136, label %688
136: ; preds = %132
%137 = load float, float* %44
%138 = fsub float 1.000000e+00, %137
store float %138, float* %41
%139 = load float*, float** %15
%140 = bitcast float* %139 to i8*
%141 = load i32, i32* %31
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i32, i32* %38
%145 = load i32, i32* %20
%146 = mul nsw i32 %144, %145
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i8, i8* %143, i64 %147
store i8* %148, i8** %32
%149 = load float, float* %41
%150 = load float, float* %42
%151 = fsub float 1.000000e+00, %150
%152 = fmul float %149, %151
store float %152, float* %25
store i32 0, i32* %30
%153 = load i8*, i8** %32
store i8* %153, i8** %34
br label %154
154: ; preds = %204, %136
%155 = load i32, i32* %30
%156 = load i32, i32* %12
%157 = icmp slt i32 %155, %156
br i1 %157, label %158, label %211
158: ; preds = %154
%159 = load i32, i32* %22
%160 = icmp ne i32 %159, 0
br i1 %160, label %161, label %193
161: ; preds = %158
%162 = load i8*, i8** %34
%163 = bitcast i8* %162 to i32*
%164 = getelementptr inbounds i32, i32* %163, i64 3
%165 = load i32, i32* %164
%166 = shl i32 %165, 24
%167 = load i8*, i8** %34
%168 = bitcast i8* %167 to i32*
%169 = getelementptr inbounds i32, i32* %168, i64 2
%170 = load i32, i32* %169
%171 = shl i32 %170, 16
%172 = or i32 %166, %171
%173 = load i8*, i8** %34
%174 = bitcast i8* %173 to i32*
%175 = getelementptr inbounds i32, i32* %174, i64 1
%176 = load i32, i32* %175
%177 = shl i32 %176, 8
%178 = or i32 %172, %177
%179 = load i8*, i8** %34
%180 = bitcast i8* %179 to i32*
%181 = getelementptr inbounds i32, i32* %180, i64 0
%182 = load i32, i32* %181
%183 = or i32 %178, %182
%184 = bitcast %union.anon* %54 to i32*
store i32 %183, i32* %184
%185 = bitcast %union.anon* %54 to float*
%186 = load float, float* %185
%187 = load float, float* %25
%188 = load i32, i32* %30
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %189
%191 = load float, float* %190
%192 = call float @llvm.fmuladd.f32(float %186, float %187, float %191)
store float %192, float* %190
br label %203
193: ; preds = %158
%194 = load i8*, i8** %34
%195 = bitcast i8* %194 to float*
%196 = load float, float* %195
%197 = load float, float* %25
%198 = load i32, i32* %30
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %199
%201 = load float, float* %200
%202 = call float @llvm.fmuladd.f32(float %196, float %197, float %201)
store float %202, float* %200
br label %203
203: ; preds = %193, %161
br label %204
204: ; preds = %203
%205 = load i32, i32* %30
%206 = add nsw i32 %205, 1
store i32 %206, i32* %30
%207 = load i32, i32* %19
%208 = load i8*, i8** %34
%209 = sext i32 %207 to i64
%210 = getelementptr inbounds i8, i8* %208, i64 %209
store i8* %210, i8** %34
br label %154
211: ; preds = %154
%212 = load i8*, i8** %32
store i8* %212, i8** %52
%213 = load i32, i32* %36
%214 = add nsw i32 %213, 1
store i32 %214, i32* %50
br label %215
215: ; preds = %283, %211
%216 = load i32, i32* %50
%217 = load i32, i32* %37
%218 = icmp slt i32 %216, %217
br i1 %218, label %219, label %286
219: ; preds = %215
%220 = load i32, i32* %21
%221 = load i8*, i8** %32
%222 = sext i32 %220 to i64
%223 = getelementptr inbounds i8, i8* %221, i64 %222
store i8* %223, i8** %32
store i32 0, i32* %30
%224 = load i8*, i8** %32
store i8* %224, i8** %34
br label %225
225: ; preds = %275, %219
%226 = load i32, i32* %30
%227 = load i32, i32* %12
%228 = icmp slt i32 %226, %227
br i1 %228, label %229, label %282
229: ; preds = %225
%230 = load i32, i32* %22
%231 = icmp ne i32 %230, 0
br i1 %231, label %232, label %264
232: ; preds = %229
%233 = load i8*, i8** %34
%234 = bitcast i8* %233 to i32*
%235 = getelementptr inbounds i32, i32* %234, i64 3
%236 = load i32, i32* %235
%237 = shl i32 %236, 24
%238 = load i8*, i8** %34
%239 = bitcast i8* %238 to i32*
%240 = getelementptr inbounds i32, i32* %239, i64 2
%241 = load i32, i32* %240
%242 = shl i32 %241, 16
%243 = or i32 %237, %242
%244 = load i8*, i8** %34
%245 = bitcast i8* %244 to i32*
%246 = getelementptr inbounds i32, i32* %245, i64 1
%247 = load i32, i32* %246
%248 = shl i32 %247, 8
%249 = or i32 %243, %248
%250 = load i8*, i8** %34
%251 = bitcast i8* %250 to i32*
%252 = getelementptr inbounds i32, i32* %251, i64 0
%253 = load i32, i32* %252
%254 = or i32 %249, %253
%255 = bitcast %union.anon* %54 to i32*
store i32 %254, i32* %255
%256 = bitcast %union.anon* %54 to float*
%257 = load float, float* %256
%258 = load float, float* %41
%259 = load i32, i32* %30
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %260
%262 = load float, float* %261
%263 = call float @llvm.fmuladd.f32(float %257, float %258, float %262)
store float %263, float* %261
br label %274
264: ; preds = %229
%265 = load i8*, i8** %34
%266 = bitcast i8* %265 to float*
%267 = load float, float* %266
%268 = load float, float* %41
%269 = load i32, i32* %30
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %270
%272 = load float, float* %271
%273 = call float @llvm.fmuladd.f32(float %267, float %268, float %272)
store float %273, float* %271
br label %274
274: ; preds = %264, %232
br label %275
275: ; preds = %274
%276 = load i32, i32* %30
%277 = add nsw i32 %276, 1
store i32 %277, i32* %30
%278 = load i32, i32* %19
%279 = load i8*, i8** %34
%280 = sext i32 %278 to i64
%281 = getelementptr inbounds i8, i8* %279, i64 %280
store i8* %281, i8** %34
br label %225
282: ; preds = %225
br label %283
283: ; preds = %282
%284 = load i32, i32* %50
%285 = add nsw i32 %284, 1
store i32 %285, i32* %50
br label %215
286: ; preds = %215
%287 = load i32, i32* %21
%288 = load i8*, i8** %32
%289 = sext i32 %287 to i64
%290 = getelementptr inbounds i8, i8* %288, i64 %289
store i8* %290, i8** %32
%291 = load i8*, i8** %32
store i8* %291, i8** %53
%292 = load float, float* %41
%293 = load float, float* %43
%294 = fmul float %292, %293
store float %294, float* %25
store i32 0, i32* %30
%295 = load i8*, i8** %32
store i8* %295, i8** %34
br label %296
296: ; preds = %346, %286
%297 = load i32, i32* %30
%298 = load i32, i32* %12
%299 = icmp slt i32 %297, %298
br i1 %299, label %300, label %353
300: ; preds = %296
%301 = load i32, i32* %22
%302 = icmp ne i32 %301, 0
br i1 %302, label %303, label %335
303: ; preds = %300
%304 = load i8*, i8** %34
%305 = bitcast i8* %304 to i32*
%306 = getelementptr inbounds i32, i32* %305, i64 3
%307 = load i32, i32* %306
%308 = shl i32 %307, 24
%309 = load i8*, i8** %34
%310 = bitcast i8* %309 to i32*
%311 = getelementptr inbounds i32, i32* %310, i64 2
%312 = load i32, i32* %311
%313 = shl i32 %312, 16
%314 = or i32 %308, %313
%315 = load i8*, i8** %34
%316 = bitcast i8* %315 to i32*
%317 = getelementptr inbounds i32, i32* %316, i64 1
%318 = load i32, i32* %317
%319 = shl i32 %318, 8
%320 = or i32 %314, %319
%321 = load i8*, i8** %34
%322 = bitcast i8* %321 to i32*
%323 = getelementptr inbounds i32, i32* %322, i64 0
%324 = load i32, i32* %323
%325 = or i32 %320, %324
%326 = bitcast %union.anon* %54 to i32*
store i32 %325, i32* %326
%327 = bitcast %union.anon* %54 to float*
%328 = load float, float* %327
%329 = load float, float* %25
%330 = load i32, i32* %30
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %331
%333 = load float, float* %332
%334 = call float @llvm.fmuladd.f32(float %328, float %329, float %333)
store float %334, float* %332
br label %345
335: ; preds = %300
%336 = load i8*, i8** %34
%337 = bitcast i8* %336 to float*
%338 = load float, float* %337
%339 = load float, float* %25
%340 = load i32, i32* %30
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %341
%343 = load float, float* %342
%344 = call float @llvm.fmuladd.f32(float %338, float %339, float %343)
store float %344, float* %342
br label %345
345: ; preds = %335, %303
br label %346
346: ; preds = %345
%347 = load i32, i32* %30
%348 = add nsw i32 %347, 1
store i32 %348, i32* %30
%349 = load i32, i32* %19
%350 = load i8*, i8** %34
%351 = sext i32 %349 to i64
%352 = getelementptr inbounds i8, i8* %350, i64 %351
store i8* %352, i8** %34
br label %296
353: ; preds = %296
%354 = load float, float* %45
store float %354, float* %41
%355 = load float, float* %41
%356 = load float, float* %42
%357 = fsub float 1.000000e+00, %356
%358 = fmul float %355, %357
store float %358, float* %25
%359 = load float*, float** %15
%360 = bitcast float* %359 to i8*
%361 = load i32, i32* %31
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds i8, i8* %360, i64 %362
%364 = load i32, i32* %39
%365 = load i32, i32* %20
%366 = mul nsw i32 %364, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i8, i8* %363, i64 %367
store i8* %368, i8** %32
store i32 0, i32* %30
%369 = load i8*, i8** %32
store i8* %369, i8** %34
br label %370
370: ; preds = %420, %353
%371 = load i32, i32* %30
%372 = load i32, i32* %12
%373 = icmp slt i32 %371, %372
br i1 %373, label %374, label %427
374: ; preds = %370
%375 = load i32, i32* %22
%376 = icmp ne i32 %375, 0
br i1 %376, label %377, label %409
377: ; preds = %374
%378 = load i8*, i8** %34
%379 = bitcast i8* %378 to i32*
%380 = getelementptr inbounds i32, i32* %379, i64 3
%381 = load i32, i32* %380
%382 = shl i32 %381, 24
%383 = load i8*, i8** %34
%384 = bitcast i8* %383 to i32*
%385 = getelementptr inbounds i32, i32* %384, i64 2
%386 = load i32, i32* %385
%387 = shl i32 %386, 16
%388 = or i32 %382, %387
%389 = load i8*, i8** %34
%390 = bitcast i8* %389 to i32*
%391 = getelementptr inbounds i32, i32* %390, i64 1
%392 = load i32, i32* %391
%393 = shl i32 %392, 8
%394 = or i32 %388, %393
%395 = load i8*, i8** %34
%396 = bitcast i8* %395 to i32*
%397 = getelementptr inbounds i32, i32* %396, i64 0
%398 = load i32, i32* %397
%399 = or i32 %394, %398
%400 = bitcast %union.anon* %54 to i32*
store i32 %399, i32* %400
%401 = bitcast %union.anon* %54 to float*
%402 = load float, float* %401
%403 = load float, float* %25
%404 = load i32, i32* %30
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %405
%407 = load float, float* %406
%408 = call float @llvm.fmuladd.f32(float %402, float %403, float %407)
store float %408, float* %406
br label %419
409: ; preds = %374
%410 = load i8*, i8** %34
%411 = bitcast i8* %410 to float*
%412 = load float, float* %411
%413 = load float, float* %25
%414 = load i32, i32* %30
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %415
%417 = load float, float* %416
%418 = call float @llvm.fmuladd.f32(float %412, float %413, float %417)
store float %418, float* %416
br label %419
419: ; preds = %409, %377
br label %420
420: ; preds = %419
%421 = load i32, i32* %30
%422 = add nsw i32 %421, 1
store i32 %422, i32* %30
%423 = load i32, i32* %19
%424 = load i8*, i8** %34
%425 = sext i32 %423 to i64
%426 = getelementptr inbounds i8, i8* %424, i64 %425
store i8* %426, i8** %34
br label %370
427: ; preds = %370
%428 = load i32, i32* %36
%429 = add nsw i32 %428, 1
store i32 %429, i32* %50
br label %430
430: ; preds = %498, %427
%431 = load i32, i32* %50
%432 = load i32, i32* %37
%433 = icmp slt i32 %431, %432
br i1 %433, label %434, label %501
434: ; preds = %430
%435 = load i32, i32* %21
%436 = load i8*, i8** %32
%437 = sext i32 %435 to i64
%438 = getelementptr inbounds i8, i8* %436, i64 %437
store i8* %438, i8** %32
store i32 0, i32* %30
%439 = load i8*, i8** %32
store i8* %439, i8** %34
br label %440
440: ; preds = %490, %434
%441 = load i32, i32* %30
%442 = load i32, i32* %12
%443 = icmp slt i32 %441, %442
br i1 %443, label %444, label %497
444: ; preds = %440
%445 = load i32, i32* %22
%446 = icmp ne i32 %445, 0
br i1 %446, label %447, label %479
447: ; preds = %444
%448 = load i8*, i8** %34
%449 = bitcast i8* %448 to i32*
%450 = getelementptr inbounds i32, i32* %449, i64 3
%451 = load i32, i32* %450
%452 = shl i32 %451, 24
%453 = load i8*, i8** %34
%454 = bitcast i8* %453 to i32*
%455 = getelementptr inbounds i32, i32* %454, i64 2
%456 = load i32, i32* %455
%457 = shl i32 %456, 16
%458 = or i32 %452, %457
%459 = load i8*, i8** %34
%460 = bitcast i8* %459 to i32*
%461 = getelementptr inbounds i32, i32* %460, i64 1
%462 = load i32, i32* %461
%463 = shl i32 %462, 8
%464 = or i32 %458, %463
%465 = load i8*, i8** %34
%466 = bitcast i8* %465 to i32*
%467 = getelementptr inbounds i32, i32* %466, i64 0
%468 = load i32, i32* %467
%469 = or i32 %464, %468
%470 = bitcast %union.anon* %54 to i32*
store i32 %469, i32* %470
%471 = bitcast %union.anon* %54 to float*
%472 = load float, float* %471
%473 = load float, float* %41
%474 = load i32, i32* %30
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %475
%477 = load float, float* %476
%478 = call float @llvm.fmuladd.f32(float %472, float %473, float %477)
store float %478, float* %476
br label %489
479: ; preds = %444
%480 = load i8*, i8** %34
%481 = bitcast i8* %480 to float*
%482 = load float, float* %481
%483 = load float, float* %41
%484 = load i32, i32* %30
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %485
%487 = load float, float* %486
%488 = call float @llvm.fmuladd.f32(float %482, float %483, float %487)
store float %488, float* %486
br label %489
489: ; preds = %479, %447
br label %490
490: ; preds = %489
%491 = load i32, i32* %30
%492 = add nsw i32 %491, 1
store i32 %492, i32* %30
%493 = load i32, i32* %19
%494 = load i8*, i8** %34
%495 = sext i32 %493 to i64
%496 = getelementptr inbounds i8, i8* %494, i64 %495
store i8* %496, i8** %34
br label %440
497: ; preds = %440
br label %498
498: ; preds = %497
%499 = load i32, i32* %50
%500 = add nsw i32 %499, 1
store i32 %500, i32* %50
br label %430
501: ; preds = %430
%502 = load i32, i32* %21
%503 = load i8*, i8** %32
%504 = sext i32 %502 to i64
%505 = getelementptr inbounds i8, i8* %503, i64 %504
store i8* %505, i8** %32
%506 = load float, float* %41
%507 = load float, float* %43
%508 = fmul float %506, %507
store float %508, float* %25
store i32 0, i32* %30
%509 = load i8*, i8** %32
store i8* %509, i8** %34
br label %510
510: ; preds = %560, %501
%511 = load i32, i32* %30
%512 = load i32, i32* %12
%513 = icmp slt i32 %511, %512
br i1 %513, label %514, label %567
514: ; preds = %510
%515 = load i32, i32* %22
%516 = icmp ne i32 %515, 0
br i1 %516, label %517, label %549
517: ; preds = %514
%518 = load i8*, i8** %34
%519 = bitcast i8* %518 to i32*
%520 = getelementptr inbounds i32, i32* %519, i64 3
%521 = load i32, i32* %520
%522 = shl i32 %521, 24
%523 = load i8*, i8** %34
%524 = bitcast i8* %523 to i32*
%525 = getelementptr inbounds i32, i32* %524, i64 2
%526 = load i32, i32* %525
%527 = shl i32 %526, 16
%528 = or i32 %522, %527
%529 = load i8*, i8** %34
%530 = bitcast i8* %529 to i32*
%531 = getelementptr inbounds i32, i32* %530, i64 1
%532 = load i32, i32* %531
%533 = shl i32 %532, 8
%534 = or i32 %528, %533
%535 = load i8*, i8** %34
%536 = bitcast i8* %535 to i32*
%537 = getelementptr inbounds i32, i32* %536, i64 0
%538 = load i32, i32* %537
%539 = or i32 %534, %538
%540 = bitcast %union.anon* %54 to i32*
store i32 %539, i32* %540
%541 = bitcast %union.anon* %54 to float*
%542 = load float, float* %541
%543 = load float, float* %25
%544 = load i32, i32* %30
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %545
%547 = load float, float* %546
%548 = call float @llvm.fmuladd.f32(float %542, float %543, float %547)
store float %548, float* %546
br label %559
549: ; preds = %514
%550 = load i8*, i8** %34
%551 = bitcast i8* %550 to float*
%552 = load float, float* %551
%553 = load float, float* %25
%554 = load i32, i32* %30
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %555
%557 = load float, float* %556
%558 = call float @llvm.fmuladd.f32(float %552, float %553, float %557)
store float %558, float* %556
br label %559
559: ; preds = %549, %517
br label %560
560: ; preds = %559
%561 = load i32, i32* %30
%562 = add nsw i32 %561, 1
store i32 %562, i32* %30
%563 = load i32, i32* %19
%564 = load i8*, i8** %34
%565 = sext i32 %563 to i64
%566 = getelementptr inbounds i8, i8* %564, i64 %565
store i8* %566, i8** %34
br label %510
567: ; preds = %510
%568 = load i32, i32* %38
%569 = add nsw i32 %568, 1
store i32 %569, i32* %51
br label %570
570: ; preds = %684, %567
%571 = load i32, i32* %51
%572 = load i32, i32* %39
%573 = icmp slt i32 %571, %572
br i1 %573, label %574, label %687
574: ; preds = %570
%575 = load i32, i32* %20
%576 = load i8*, i8** %52
%577 = sext i32 %575 to i64
%578 = getelementptr inbounds i8, i8* %576, i64 %577
store i8* %578, i8** %52
%579 = load i32, i32* %20
%580 = load i8*, i8** %53
%581 = sext i32 %579 to i64
%582 = getelementptr inbounds i8, i8* %580, i64 %581
store i8* %582, i8** %53
store i32 0, i32* %30
br label %583
583: ; preds = %672, %574
%584 = load i32, i32* %30
%585 = load i32, i32* %12
%586 = icmp slt i32 %584, %585
br i1 %586, label %587, label %683
587: ; preds = %583
%588 = load i32, i32* %22
%589 = icmp ne i32 %588, 0
br i1 %589, label %590, label %654
590: ; preds = %587
%591 = load i8*, i8** %52
%592 = bitcast i8* %591 to i32*
%593 = getelementptr inbounds i32, i32* %592, i64 3
%594 = load i32, i32* %593
%595 = shl i32 %594, 24
%596 = load i8*, i8** %52
%597 = bitcast i8* %596 to i32*
%598 = getelementptr inbounds i32, i32* %597, i64 2
%599 = load i32, i32* %598
%600 = shl i32 %599, 16
%601 = or i32 %595, %600
%602 = load i8*, i8** %52
%603 = bitcast i8* %602 to i32*
%604 = getelementptr inbounds i32, i32* %603, i64 1
%605 = load i32, i32* %604
%606 = shl i32 %605, 8
%607 = or i32 %601, %606
%608 = load i8*, i8** %52
%609 = bitcast i8* %608 to i32*
%610 = getelementptr inbounds i32, i32* %609, i64 0
%611 = load i32, i32* %610
%612 = or i32 %607, %611
%613 = bitcast %union.anon* %54 to i32*
store i32 %612, i32* %613
%614 = bitcast %union.anon* %54 to float*
%615 = load float, float* %614
%616 = load float, float* %42
%617 = fsub float 1.000000e+00, %616
%618 = load i32, i32* %30
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %619
%621 = load float, float* %620
%622 = call float @llvm.fmuladd.f32(float %615, float %617, float %621)
store float %622, float* %620
%623 = load i8*, i8** %53
%624 = bitcast i8* %623 to i32*
%625 = getelementptr inbounds i32, i32* %624, i64 3
%626 = load i32, i32* %625
%627 = shl i32 %626, 24
%628 = load i8*, i8** %53
%629 = bitcast i8* %628 to i32*
%630 = getelementptr inbounds i32, i32* %629, i64 2
%631 = load i32, i32* %630
%632 = shl i32 %631, 16
%633 = or i32 %627, %632
%634 = load i8*, i8** %53
%635 = bitcast i8* %634 to i32*
%636 = getelementptr inbounds i32, i32* %635, i64 1
%637 = load i32, i32* %636
%638 = shl i32 %637, 8
%639 = or i32 %633, %638
%640 = load i8*, i8** %53
%641 = bitcast i8* %640 to i32*
%642 = getelementptr inbounds i32, i32* %641, i64 0
%643 = load i32, i32* %642
%644 = or i32 %639, %643
%645 = bitcast %union.anon* %54 to i32*
store i32 %644, i32* %645
%646 = bitcast %union.anon* %54 to float*
%647 = load float, float* %646
%648 = load float, float* %43
%649 = load i32, i32* %30
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %650
%652 = load float, float* %651
%653 = call float @llvm.fmuladd.f32(float %647, float %648, float %652)
store float %653, float* %651
br label %671
654: ; preds = %587
%655 = load i8*, i8** %52
%656 = bitcast i8* %655 to float*
%657 = load float, float* %656
%658 = load float, float* %42
%659 = fsub float 1.000000e+00, %658
%660 = load i8*, i8** %53
%661 = bitcast i8* %660 to float*
%662 = load float, float* %661
%663 = load float, float* %43
%664 = fmul float %662, %663
%665 = call float @llvm.fmuladd.f32(float %657, float %659, float %664)
%666 = load i32, i32* %30
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %667
%669 = load float, float* %668
%670 = fadd float %669, %665
store float %670, float* %668
br label %671
671: ; preds = %654, %590
br label %672
672: ; preds = %671
%673 = load i32, i32* %30
%674 = add nsw i32 %673, 1
store i32 %674, i32* %30
%675 = load i32, i32* %19
%676 = load i8*, i8** %52
%677 = sext i32 %675 to i64
%678 = getelementptr inbounds i8, i8* %676, i64 %677
store i8* %678, i8** %52
%679 = load i32, i32* %19
%680 = load i8*, i8** %53
%681 = sext i32 %679 to i64
%682 = getelementptr inbounds i8, i8* %680, i64 %681
store i8* %682, i8** %53
br label %583
683: ; preds = %583
br label %684
684: ; preds = %683
%685 = load i32, i32* %51
%686 = add nsw i32 %685, 1
store i32 %686, i32* %51
br label %570
687: ; preds = %570
br label %1209
688: ; preds = %132, %121
%689 = load i32, i32* %39
%690 = load i32, i32* %38
%691 = icmp sgt i32 %689, %690
br i1 %691, label %692, label %909
692: ; preds = %688
%693 = load float, float* %43
%694 = load float, float* %42
%695 = fsub float %693, %694
store float %695, float* %40
%696 = load float, float* %44
%697 = fsub float 1.000000e+00, %696
%698 = load float, float* %40
%699 = fmul float %697, %698
store float %699, float* %25
%700 = load float*, float** %15
%701 = bitcast float* %700 to i8*
%702 = load i32, i32* %31
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds i8, i8* %701, i64 %703
%705 = load i32, i32* %38
%706 = load i32, i32* %20
%707 = mul nsw i32 %705, %706
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds i8, i8* %704, i64 %708
store i8* %709, i8** %32
store i32 0, i32* %30
%710 = load i8*, i8** %32
store i8* %710, i8** %34
br label %711
711: ; preds = %761, %692
%712 = load i32, i32* %30
%713 = load i32, i32* %12
%714 = icmp slt i32 %712, %713
br i1 %714, label %715, label %768
715: ; preds = %711
%716 = load i32, i32* %22
%717 = icmp ne i32 %716, 0
br i1 %717, label %718, label %750
718: ; preds = %715
%719 = load i8*, i8** %34
%720 = bitcast i8* %719 to i32*
%721 = getelementptr inbounds i32, i32* %720, i64 3
%722 = load i32, i32* %721
%723 = shl i32 %722, 24
%724 = load i8*, i8** %34
%725 = bitcast i8* %724 to i32*
%726 = getelementptr inbounds i32, i32* %725, i64 2
%727 = load i32, i32* %726
%728 = shl i32 %727, 16
%729 = or i32 %723, %728
%730 = load i8*, i8** %34
%731 = bitcast i8* %730 to i32*
%732 = getelementptr inbounds i32, i32* %731, i64 1
%733 = load i32, i32* %732
%734 = shl i32 %733, 8
%735 = or i32 %729, %734
%736 = load i8*, i8** %34
%737 = bitcast i8* %736 to i32*
%738 = getelementptr inbounds i32, i32* %737, i64 0
%739 = load i32, i32* %738
%740 = or i32 %735, %739
%741 = bitcast %union.anon* %54 to i32*
store i32 %740, i32* %741
%742 = bitcast %union.anon* %54 to float*
%743 = load float, float* %742
%744 = load float, float* %25
%745 = load i32, i32* %30
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %746
%748 = load float, float* %747
%749 = call float @llvm.fmuladd.f32(float %743, float %744, float %748)
store float %749, float* %747
br label %760
750: ; preds = %715
%751 = load i8*, i8** %34
%752 = bitcast i8* %751 to float*
%753 = load float, float* %752
%754 = load float, float* %25
%755 = load i32, i32* %30
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %756
%758 = load float, float* %757
%759 = call float @llvm.fmuladd.f32(float %753, float %754, float %758)
store float %759, float* %757
br label %760
760: ; preds = %750, %718
br label %761
761: ; preds = %760
%762 = load i32, i32* %30
%763 = add nsw i32 %762, 1
store i32 %763, i32* %30
%764 = load i32, i32* %19
%765 = load i8*, i8** %34
%766 = sext i32 %764 to i64
%767 = getelementptr inbounds i8, i8* %765, i64 %766
store i8* %767, i8** %34
br label %711
768: ; preds = %711
%769 = load i32, i32* %38
%770 = add nsw i32 %769, 1
store i32 %770, i32* %51
br label %771
771: ; preds = %839, %768
%772 = load i32, i32* %51
%773 = load i32, i32* %39
%774 = icmp slt i32 %772, %773
br i1 %774, label %775, label %842
775: ; preds = %771
%776 = load i32, i32* %20
%777 = load i8*, i8** %32
%778 = sext i32 %776 to i64
%779 = getelementptr inbounds i8, i8* %777, i64 %778
store i8* %779, i8** %32
store i32 0, i32* %30
%780 = load i8*, i8** %32
store i8* %780, i8** %34
br label %781
781: ; preds = %831, %775
%782 = load i32, i32* %30
%783 = load i32, i32* %12
%784 = icmp slt i32 %782, %783
br i1 %784, label %785, label %838
785: ; preds = %781
%786 = load i32, i32* %22
%787 = icmp ne i32 %786, 0
br i1 %787, label %788, label %820
788: ; preds = %785
%789 = load i8*, i8** %34
%790 = bitcast i8* %789 to i32*
%791 = getelementptr inbounds i32, i32* %790, i64 3
%792 = load i32, i32* %791
%793 = shl i32 %792, 24
%794 = load i8*, i8** %34
%795 = bitcast i8* %794 to i32*
%796 = getelementptr inbounds i32, i32* %795, i64 2
%797 = load i32, i32* %796
%798 = shl i32 %797, 16
%799 = or i32 %793, %798
%800 = load i8*, i8** %34
%801 = bitcast i8* %800 to i32*
%802 = getelementptr inbounds i32, i32* %801, i64 1
%803 = load i32, i32* %802
%804 = shl i32 %803, 8
%805 = or i32 %799, %804
%806 = load i8*, i8** %34
%807 = bitcast i8* %806 to i32*
%808 = getelementptr inbounds i32, i32* %807, i64 0
%809 = load i32, i32* %808
%810 = or i32 %805, %809
%811 = bitcast %union.anon* %54 to i32*
store i32 %810, i32* %811
%812 = bitcast %union.anon* %54 to float*
%813 = load float, float* %812
%814 = load float, float* %40
%815 = load i32, i32* %30
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %816
%818 = load float, float* %817
%819 = call float @llvm.fmuladd.f32(float %813, float %814, float %818)
store float %819, float* %817
br label %830
820: ; preds = %785
%821 = load i8*, i8** %34
%822 = bitcast i8* %821 to float*
%823 = load float, float* %822
%824 = load float, float* %40
%825 = load i32, i32* %30
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %826
%828 = load float, float* %827
%829 = call float @llvm.fmuladd.f32(float %823, float %824, float %828)
store float %829, float* %827
br label %830
830: ; preds = %820, %788
br label %831
831: ; preds = %830
%832 = load i32, i32* %30
%833 = add nsw i32 %832, 1
store i32 %833, i32* %30
%834 = load i32, i32* %19
%835 = load i8*, i8** %34
%836 = sext i32 %834 to i64
%837 = getelementptr inbounds i8, i8* %835, i64 %836
store i8* %837, i8** %34
br label %781
838: ; preds = %781
br label %839
839: ; preds = %838
%840 = load i32, i32* %51
%841 = add nsw i32 %840, 1
store i32 %841, i32* %51
br label %771
842: ; preds = %771
%843 = load float, float* %40
%844 = load float, float* %45
%845 = fmul float %843, %844
store float %845, float* %25
%846 = load i32, i32* %20
%847 = load i8*, i8** %32
%848 = sext i32 %846 to i64
%849 = getelementptr inbounds i8, i8* %847, i64 %848
store i8* %849, i8** %32
store i32 0, i32* %30
%850 = load i8*, i8** %32
store i8* %850, i8** %34
br label %851
851: ; preds = %901, %842
%852 = load i32, i32* %30
%853 = load i32, i32* %12
%854 = icmp slt i32 %852, %853
br i1 %854, label %855, label %908
855: ; preds = %851
%856 = load i32, i32* %22
%857 = icmp ne i32 %856, 0
br i1 %857, label %858, label %890
858: ; preds = %855
%859 = load i8*, i8** %34
%860 = bitcast i8* %859 to i32*
%861 = getelementptr inbounds i32, i32* %860, i64 3
%862 = load i32, i32* %861
%863 = shl i32 %862, 24
%864 = load i8*, i8** %34
%865 = bitcast i8* %864 to i32*
%866 = getelementptr inbounds i32, i32* %865, i64 2
%867 = load i32, i32* %866
%868 = shl i32 %867, 16
%869 = or i32 %863, %868
%870 = load i8*, i8** %34
%871 = bitcast i8* %870 to i32*
%872 = getelementptr inbounds i32, i32* %871, i64 1
%873 = load i32, i32* %872
%874 = shl i32 %873, 8
%875 = or i32 %869, %874
%876 = load i8*, i8** %34
%877 = bitcast i8* %876 to i32*
%878 = getelementptr inbounds i32, i32* %877, i64 0
%879 = load i32, i32* %878
%880 = or i32 %875, %879
%881 = bitcast %union.anon* %54 to i32*
store i32 %880, i32* %881
%882 = bitcast %union.anon* %54 to float*
%883 = load float, float* %882
%884 = load float, float* %25
%885 = load i32, i32* %30
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %886
%888 = load float, float* %887
%889 = call float @llvm.fmuladd.f32(float %883, float %884, float %888)
store float %889, float* %887
br label %900
890: ; preds = %855
%891 = load i8*, i8** %34
%892 = bitcast i8* %891 to float*
%893 = load float, float* %892
%894 = load float, float* %25
%895 = load i32, i32* %30
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %896
%898 = load float, float* %897
%899 = call float @llvm.fmuladd.f32(float %893, float %894, float %898)
store float %899, float* %897
br label %900
900: ; preds = %890, %858
br label %901
901: ; preds = %900
%902 = load i32, i32* %30
%903 = add nsw i32 %902, 1
store i32 %903, i32* %30
%904 = load i32, i32* %19
%905 = load i8*, i8** %34
%906 = sext i32 %904 to i64
%907 = getelementptr inbounds i8, i8* %905, i64 %906
store i8* %907, i8** %34
br label %851
908: ; preds = %851
br label %1208
909: ; preds = %688
%910 = load i32, i32* %37
%911 = load i32, i32* %36
%912 = icmp sgt i32 %910, %911
br i1 %912, label %913, label %1130
913: ; preds = %909
%914 = load float, float* %45
%915 = load float, float* %44
%916 = fsub float %914, %915
store float %916, float* %41
%917 = load float, float* %42
%918 = fsub float 1.000000e+00, %917
%919 = load float, float* %41
%920 = fmul float %918, %919
store float %920, float* %25
%921 = load float*, float** %15
%922 = bitcast float* %921 to i8*
%923 = load i32, i32* %31
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds i8, i8* %922, i64 %924
%926 = load i32, i32* %38
%927 = load i32, i32* %20
%928 = mul nsw i32 %926, %927
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds i8, i8* %925, i64 %929
store i8* %930, i8** %32
store i32 0, i32* %30
%931 = load i8*, i8** %32
store i8* %931, i8** %34
br label %932
932: ; preds = %982, %913
%933 = load i32, i32* %30
%934 = load i32, i32* %12
%935 = icmp slt i32 %933, %934
br i1 %935, label %936, label %989
936: ; preds = %932
%937 = load i32, i32* %22
%938 = icmp ne i32 %937, 0
br i1 %938, label %939, label %971
939: ; preds = %936
%940 = load i8*, i8** %34
%941 = bitcast i8* %940 to i32*
%942 = getelementptr inbounds i32, i32* %941, i64 3
%943 = load i32, i32* %942
%944 = shl i32 %943, 24
%945 = load i8*, i8** %34
%946 = bitcast i8* %945 to i32*
%947 = getelementptr inbounds i32, i32* %946, i64 2
%948 = load i32, i32* %947
%949 = shl i32 %948, 16
%950 = or i32 %944, %949
%951 = load i8*, i8** %34
%952 = bitcast i8* %951 to i32*
%953 = getelementptr inbounds i32, i32* %952, i64 1
%954 = load i32, i32* %953
%955 = shl i32 %954, 8
%956 = or i32 %950, %955
%957 = load i8*, i8** %34
%958 = bitcast i8* %957 to i32*
%959 = getelementptr inbounds i32, i32* %958, i64 0
%960 = load i32, i32* %959
%961 = or i32 %956, %960
%962 = bitcast %union.anon* %54 to i32*
store i32 %961, i32* %962
%963 = bitcast %union.anon* %54 to float*
%964 = load float, float* %963
%965 = load float, float* %25
%966 = load i32, i32* %30
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %967
%969 = load float, float* %968
%970 = call float @llvm.fmuladd.f32(float %964, float %965, float %969)
store float %970, float* %968
br label %981
971: ; preds = %936
%972 = load i8*, i8** %34
%973 = bitcast i8* %972 to float*
%974 = load float, float* %973
%975 = load float, float* %25
%976 = load i32, i32* %30
%977 = sext i32 %976 to i64
%978 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %977
%979 = load float, float* %978
%980 = call float @llvm.fmuladd.f32(float %974, float %975, float %979)
store float %980, float* %978
br label %981
981: ; preds = %971, %939
br label %982
982: ; preds = %981
%983 = load i32, i32* %30
%984 = add nsw i32 %983, 1
store i32 %984, i32* %30
%985 = load i32, i32* %19
%986 = load i8*, i8** %34
%987 = sext i32 %985 to i64
%988 = getelementptr inbounds i8, i8* %986, i64 %987
store i8* %988, i8** %34
br label %932
989: ; preds = %932
%990 = load i32, i32* %36
%991 = add nsw i32 %990, 1
store i32 %991, i32* %50
br label %992
992: ; preds = %1060, %989
%993 = load i32, i32* %50
%994 = load i32, i32* %37
%995 = icmp slt i32 %993, %994
br i1 %995, label %996, label %1063
996: ; preds = %992
%997 = load i32, i32* %21
%998 = load i8*, i8** %32
%999 = sext i32 %997 to i64
%1000 = getelementptr inbounds i8, i8* %998, i64 %999
store i8* %1000, i8** %32
store i32 0, i32* %30
%1001 = load i8*, i8** %32
store i8* %1001, i8** %34
br label %1002
1002: ; preds = %1052, %996
%1003 = load i32, i32* %30
%1004 = load i32, i32* %12
%1005 = icmp slt i32 %1003, %1004
br i1 %1005, label %1006, label %1059
1006: ; preds = %1002
%1007 = load i32, i32* %22
%1008 = icmp ne i32 %1007, 0
br i1 %1008, label %1009, label %1041
1009: ; preds = %1006
%1010 = load i8*, i8** %34
%1011 = bitcast i8* %1010 to i32*
%1012 = getelementptr inbounds i32, i32* %1011, i64 3
%1013 = load i32, i32* %1012
%1014 = shl i32 %1013, 24
%1015 = load i8*, i8** %34
%1016 = bitcast i8* %1015 to i32*
%1017 = getelementptr inbounds i32, i32* %1016, i64 2
%1018 = load i32, i32* %1017
%1019 = shl i32 %1018, 16
%1020 = or i32 %1014, %1019
%1021 = load i8*, i8** %34
%1022 = bitcast i8* %1021 to i32*
%1023 = getelementptr inbounds i32, i32* %1022, i64 1
%1024 = load i32, i32* %1023
%1025 = shl i32 %1024, 8
%1026 = or i32 %1020, %1025
%1027 = load i8*, i8** %34
%1028 = bitcast i8* %1027 to i32*
%1029 = getelementptr inbounds i32, i32* %1028, i64 0
%1030 = load i32, i32* %1029
%1031 = or i32 %1026, %1030
%1032 = bitcast %union.anon* %54 to i32*
store i32 %1031, i32* %1032
%1033 = bitcast %union.anon* %54 to float*
%1034 = load float, float* %1033
%1035 = load float, float* %41
%1036 = load i32, i32* %30
%1037 = sext i32 %1036 to i64
%1038 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1037
%1039 = load float, float* %1038
%1040 = call float @llvm.fmuladd.f32(float %1034, float %1035, float %1039)
store float %1040, float* %1038
br label %1051
1041: ; preds = %1006
%1042 = load i8*, i8** %34
%1043 = bitcast i8* %1042 to float*
%1044 = load float, float* %1043
%1045 = load float, float* %41
%1046 = load i32, i32* %30
%1047 = sext i32 %1046 to i64
%1048 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1047
%1049 = load float, float* %1048
%1050 = call float @llvm.fmuladd.f32(float %1044, float %1045, float %1049)
store float %1050, float* %1048
br label %1051
1051: ; preds = %1041, %1009
br label %1052
1052: ; preds = %1051
%1053 = load i32, i32* %30
%1054 = add nsw i32 %1053, 1
store i32 %1054, i32* %30
%1055 = load i32, i32* %19
%1056 = load i8*, i8** %34
%1057 = sext i32 %1055 to i64
%1058 = getelementptr inbounds i8, i8* %1056, i64 %1057
store i8* %1058, i8** %34
br label %1002
1059: ; preds = %1002
br label %1060
1060: ; preds = %1059
%1061 = load i32, i32* %50
%1062 = add nsw i32 %1061, 1
store i32 %1062, i32* %50
br label %992
1063: ; preds = %992
%1064 = load i32, i32* %21
%1065 = load i8*, i8** %32
%1066 = sext i32 %1064 to i64
%1067 = getelementptr inbounds i8, i8* %1065, i64 %1066
store i8* %1067, i8** %32
%1068 = load float, float* %41
%1069 = load float, float* %43
%1070 = fmul float %1068, %1069
store float %1070, float* %25
store i32 0, i32* %30
%1071 = load i8*, i8** %32
store i8* %1071, i8** %34
br label %1072
1072: ; preds = %1122, %1063
%1073 = load i32, i32* %30
%1074 = load i32, i32* %12
%1075 = icmp slt i32 %1073, %1074
br i1 %1075, label %1076, label %1129
1076: ; preds = %1072
%1077 = load i32, i32* %22
%1078 = icmp ne i32 %1077, 0
br i1 %1078, label %1079, label %1111
1079: ; preds = %1076
%1080 = load i8*, i8** %34
%1081 = bitcast i8* %1080 to i32*
%1082 = getelementptr inbounds i32, i32* %1081, i64 3
%1083 = load i32, i32* %1082
%1084 = shl i32 %1083, 24
%1085 = load i8*, i8** %34
%1086 = bitcast i8* %1085 to i32*
%1087 = getelementptr inbounds i32, i32* %1086, i64 2
%1088 = load i32, i32* %1087
%1089 = shl i32 %1088, 16
%1090 = or i32 %1084, %1089
%1091 = load i8*, i8** %34
%1092 = bitcast i8* %1091 to i32*
%1093 = getelementptr inbounds i32, i32* %1092, i64 1
%1094 = load i32, i32* %1093
%1095 = shl i32 %1094, 8
%1096 = or i32 %1090, %1095
%1097 = load i8*, i8** %34
%1098 = bitcast i8* %1097 to i32*
%1099 = getelementptr inbounds i32, i32* %1098, i64 0
%1100 = load i32, i32* %1099
%1101 = or i32 %1096, %1100
%1102 = bitcast %union.anon* %54 to i32*
store i32 %1101, i32* %1102
%1103 = bitcast %union.anon* %54 to float*
%1104 = load float, float* %1103
%1105 = load float, float* %25
%1106 = load i32, i32* %30
%1107 = sext i32 %1106 to i64
%1108 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1107
%1109 = load float, float* %1108
%1110 = call float @llvm.fmuladd.f32(float %1104, float %1105, float %1109)
store float %1110, float* %1108
br label %1121
1111: ; preds = %1076
%1112 = load i8*, i8** %34
%1113 = bitcast i8* %1112 to float*
%1114 = load float, float* %1113
%1115 = load float, float* %25
%1116 = load i32, i32* %30
%1117 = sext i32 %1116 to i64
%1118 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1117
%1119 = load float, float* %1118
%1120 = call float @llvm.fmuladd.f32(float %1114, float %1115, float %1119)
store float %1120, float* %1118
br label %1121
1121: ; preds = %1111, %1079
br label %1122
1122: ; preds = %1121
%1123 = load i32, i32* %30
%1124 = add nsw i32 %1123, 1
store i32 %1124, i32* %30
%1125 = load i32, i32* %19
%1126 = load i8*, i8** %34
%1127 = sext i32 %1125 to i64
%1128 = getelementptr inbounds i8, i8* %1126, i64 %1127
store i8* %1128, i8** %34
br label %1072
1129: ; preds = %1072
br label %1207
1130: ; preds = %909
%1131 = load float, float* %45
%1132 = load float, float* %44
%1133 = fsub float %1131, %1132
%1134 = load float, float* %43
%1135 = load float, float* %42
%1136 = fsub float %1134, %1135
%1137 = fmul float %1133, %1136
store float %1137, float* %25
%1138 = load float*, float** %15
%1139 = bitcast float* %1138 to i8*
%1140 = load i32, i32* %31
%1141 = sext i32 %1140 to i64
%1142 = getelementptr inbounds i8, i8* %1139, i64 %1141
%1143 = load i32, i32* %38
%1144 = load i32, i32* %20
%1145 = mul nsw i32 %1143, %1144
%1146 = sext i32 %1145 to i64
%1147 = getelementptr inbounds i8, i8* %1142, i64 %1146
store i8* %1147, i8** %32
store i32 0, i32* %30
%1148 = load i8*, i8** %32
store i8* %1148, i8** %34
br label %1149
1149: ; preds = %1199, %1130
%1150 = load i32, i32* %30
%1151 = load i32, i32* %12
%1152 = icmp slt i32 %1150, %1151
br i1 %1152, label %1153, label %1206
1153: ; preds = %1149
%1154 = load i32, i32* %22
%1155 = icmp ne i32 %1154, 0
br i1 %1155, label %1156, label %1188
1156: ; preds = %1153
%1157 = load i8*, i8** %34
%1158 = bitcast i8* %1157 to i32*
%1159 = getelementptr inbounds i32, i32* %1158, i64 3
%1160 = load i32, i32* %1159
%1161 = shl i32 %1160, 24
%1162 = load i8*, i8** %34
%1163 = bitcast i8* %1162 to i32*
%1164 = getelementptr inbounds i32, i32* %1163, i64 2
%1165 = load i32, i32* %1164
%1166 = shl i32 %1165, 16
%1167 = or i32 %1161, %1166
%1168 = load i8*, i8** %34
%1169 = bitcast i8* %1168 to i32*
%1170 = getelementptr inbounds i32, i32* %1169, i64 1
%1171 = load i32, i32* %1170
%1172 = shl i32 %1171, 8
%1173 = or i32 %1167, %1172
%1174 = load i8*, i8** %34
%1175 = bitcast i8* %1174 to i32*
%1176 = getelementptr inbounds i32, i32* %1175, i64 0
%1177 = load i32, i32* %1176
%1178 = or i32 %1173, %1177
%1179 = bitcast %union.anon* %54 to i32*
store i32 %1178, i32* %1179
%1180 = bitcast %union.anon* %54 to float*
%1181 = load float, float* %1180
%1182 = load float, float* %25
%1183 = load i32, i32* %30
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1184
%1186 = load float, float* %1185
%1187 = call float @llvm.fmuladd.f32(float %1181, float %1182, float %1186)
store float %1187, float* %1185
br label %1198
1188: ; preds = %1153
%1189 = load i8*, i8** %34
%1190 = bitcast i8* %1189 to float*
%1191 = load float, float* %1190
%1192 = load float, float* %25
%1193 = load i32, i32* %30
%1194 = sext i32 %1193 to i64
%1195 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1194
%1196 = load float, float* %1195
%1197 = call float @llvm.fmuladd.f32(float %1191, float %1192, float %1196)
store float %1197, float* %1195
br label %1198
1198: ; preds = %1188, %1156
br label %1199
1199: ; preds = %1198
%1200 = load i32, i32* %30
%1201 = add nsw i32 %1200, 1
store i32 %1201, i32* %30
%1202 = load i32, i32* %19
%1203 = load i8*, i8** %34
%1204 = sext i32 %1202 to i64
%1205 = getelementptr inbounds i8, i8* %1203, i64 %1204
store i8* %1205, i8** %34
br label %1149
1206: ; preds = %1149
br label %1207
1207: ; preds = %1206, %1129
br label %1208
1208: ; preds = %1207, %908
br label %1209
1209: ; preds = %1208, %687
%1210 = load float*, float** %15
%1211 = bitcast float* %1210 to i8*
%1212 = load i32, i32* %31
%1213 = sext i32 %1212 to i64
%1214 = getelementptr inbounds i8, i8* %1211, i64 %1213
%1215 = load i32, i32* %21
%1216 = sext i32 %1215 to i64
%1217 = getelementptr inbounds i8, i8* %1214, i64 %1216
%1218 = load i32, i32* %38
%1219 = add nsw i32 %1218, 1
%1220 = load i32, i32* %20
%1221 = mul nsw i32 %1219, %1220
%1222 = sext i32 %1221 to i64
%1223 = getelementptr inbounds i8, i8* %1217, i64 %1222
store i8* %1223, i8** %33
%1224 = load i32, i32* %38
%1225 = add nsw i32 %1224, 1
store i32 %1225, i32* %51
br label %1226
1226: ; preds = %1308, %1209
%1227 = load i32, i32* %51
%1228 = load i32, i32* %39
%1229 = icmp slt i32 %1227, %1228
br i1 %1229, label %1230, label %1311
1230: ; preds = %1226
%1231 = load i8*, i8** %33
store i8* %1231, i8** %32
%1232 = load i32, i32* %36
%1233 = add nsw i32 %1232, 1
store i32 %1233, i32* %50
br label %1234
1234: ; preds = %1300, %1230
%1235 = load i32, i32* %50
%1236 = load i32, i32* %37
%1237 = icmp slt i32 %1235, %1236
br i1 %1237, label %1238, label %1303
1238: ; preds = %1234
store i32 0, i32* %30
%1239 = load i8*, i8** %32
store i8* %1239, i8** %34
br label %1240
1240: ; preds = %1288, %1238
%1241 = load i32, i32* %30
%1242 = load i32, i32* %12
%1243 = icmp slt i32 %1241, %1242
br i1 %1243, label %1244, label %1295
1244: ; preds = %1240
%1245 = load i32, i32* %22
%1246 = icmp ne i32 %1245, 0
br i1 %1246, label %1247, label %1278
1247: ; preds = %1244
%1248 = load i8*, i8** %34
%1249 = bitcast i8* %1248 to i32*
%1250 = getelementptr inbounds i32, i32* %1249, i64 3
%1251 = load i32, i32* %1250
%1252 = shl i32 %1251, 24
%1253 = load i8*, i8** %34
%1254 = bitcast i8* %1253 to i32*
%1255 = getelementptr inbounds i32, i32* %1254, i64 2
%1256 = load i32, i32* %1255
%1257 = shl i32 %1256, 16
%1258 = or i32 %1252, %1257
%1259 = load i8*, i8** %34
%1260 = bitcast i8* %1259 to i32*
%1261 = getelementptr inbounds i32, i32* %1260, i64 1
%1262 = load i32, i32* %1261
%1263 = shl i32 %1262, 8
%1264 = or i32 %1258, %1263
%1265 = load i8*, i8** %34
%1266 = bitcast i8* %1265 to i32*
%1267 = getelementptr inbounds i32, i32* %1266, i64 0
%1268 = load i32, i32* %1267
%1269 = or i32 %1264, %1268
%1270 = bitcast %union.anon* %54 to i32*
store i32 %1269, i32* %1270
%1271 = bitcast %union.anon* %54 to float*
%1272 = load float, float* %1271
%1273 = load i32, i32* %30
%1274 = sext i32 %1273 to i64
%1275 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1274
%1276 = load float, float* %1275
%1277 = fadd float %1276, %1272
store float %1277, float* %1275
br label %1287
1278: ; preds = %1244
%1279 = load i8*, i8** %34
%1280 = bitcast i8* %1279 to float*
%1281 = load float, float* %1280
%1282 = load i32, i32* %30
%1283 = sext i32 %1282 to i64
%1284 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1283
%1285 = load float, float* %1284
%1286 = fadd float %1285, %1281
store float %1286, float* %1284
br label %1287
1287: ; preds = %1278, %1247
br label %1288
1288: ; preds = %1287
%1289 = load i32, i32* %30
%1290 = add nsw i32 %1289, 1
store i32 %1290, i32* %30
%1291 = load i32, i32* %19
%1292 = load i8*, i8** %34
%1293 = sext i32 %1291 to i64
%1294 = getelementptr inbounds i8, i8* %1292, i64 %1293
store i8* %1294, i8** %34
br label %1240
1295: ; preds = %1240
%1296 = load i32, i32* %21
%1297 = load i8*, i8** %32
%1298 = sext i32 %1296 to i64
%1299 = getelementptr inbounds i8, i8* %1297, i64 %1298
store i8* %1299, i8** %32
br label %1300
1300: ; preds = %1295
%1301 = load i32, i32* %50
%1302 = add nsw i32 %1301, 1
store i32 %1302, i32* %50
br label %1234
1303: ; preds = %1234
%1304 = load i32, i32* %20
%1305 = load i8*, i8** %33
%1306 = sext i32 %1304 to i64
%1307 = getelementptr inbounds i8, i8* %1305, i64 %1306
store i8* %1307, i8** %33
br label %1308
1308: ; preds = %1303
%1309 = load i32, i32* %51
%1310 = add nsw i32 %1309, 1
store i32 %1310, i32* %51
br label %1226
1311: ; preds = %1226
%1312 = load i32, i32* %29
%1313 = load i32, i32* %28
%1314 = load i32, i32* %16
%1315 = mul nsw i32 %1313, %1314
%1316 = add nsw i32 %1312, %1315
%1317 = load i32, i32* %12
%1318 = mul nsw i32 %1316, %1317
store i32 %1318, i32* %35
store i32 0, i32* %30
br label %1319
1319: ; preds = %1336, %1311
%1320 = load i32, i32* %30
%1321 = load i32, i32* %12
%1322 = icmp slt i32 %1320, %1321
br i1 %1322, label %1323, label %1339
1323: ; preds = %1319
%1324 = load i32, i32* %30
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1325
%1327 = load float, float* %1326
%1328 = load float, float* %27
%1329 = fdiv float %1327, %1328
%1330 = load float*, float** %18
%1331 = load i32, i32* %35
%1332 = load i32, i32* %30
%1333 = add nsw i32 %1331, %1332
%1334 = sext i32 %1333 to i64
%1335 = getelementptr inbounds float, float* %1330, i64 %1334
store float %1329, float* %1335
br label %1336
1336: ; preds = %1323
%1337 = load i32, i32* %30
%1338 = add nsw i32 %1337, 1
store i32 %1338, i32* %30
br label %1319
1339: ; preds = %1319
%1340 = load i32, i32* %37
store i32 %1340, i32* %36
%1341 = load float, float* %43
store float %1341, float* %42
%1342 = load i32, i32* %49
%1343 = load i32, i32* %37
%1344 = add nsw i32 %1343, %1342
store i32 %1344, i32* %37
%1345 = load float, float* %47
%1346 = load float, float* %43
%1347 = fadd float %1346, %1345
store float %1347, float* %43
%1348 = load float, float* %43
%1349 = fcmp ogt float %1348, 1.000000e+00
br i1 %1349, label %1350, label %1357
1350: ; preds = %1339
%1351 = load float, float* %43
%1352 = fpext float %1351 to double
%1353 = fsub double %1352, 1.000000e+00
%1354 = fptrunc double %1353 to float
store float %1354, float* %43
%1355 = load i32, i32* %37
%1356 = add nsw i32 %1355, 1
store i32 %1356, i32* %37
br label %1357
1357: ; preds = %1350, %1339
br label %1358
1358: ; preds = %1357
%1359 = load i32, i32* %29
%1360 = add nsw i32 %1359, 1
store i32 %1360, i32* %29
br label %117
1361: ; preds = %117
%1362 = load i32, i32* %39
store i32 %1362, i32* %38
%1363 = load float, float* %45
store float %1363, float* %44
%1364 = load i32, i32* %48
%1365 = load i32, i32* %39
%1366 = add nsw i32 %1365, %1364
store i32 %1366, i32* %39
%1367 = load float, float* %46
%1368 = load float, float* %45
%1369 = fadd float %1368, %1367
store float %1369, float* %45
%1370 = load float, float* %45
%1371 = fcmp ogt float %1370, 1.000000e+00
br i1 %1371, label %1372, label %1379
1372: ; preds = %1361
%1373 = load float, float* %45
%1374 = fpext float %1373 to double
%1375 = fsub double %1374, 1.000000e+00
%1376 = fptrunc double %1375 to float
store float %1376, float* %45
%1377 = load i32, i32* %39
%1378 = add nsw i32 %1377, 1
store i32 %1378, i32* %39
br label %1379
1379: ; preds = %1372, %1361
br label %1380
1380: ; preds = %1379
%1381 = load i32, i32* %28
%1382 = add nsw i32 %1381, 1
store i32 %1382, i32* %28
br label %103
1383: ; preds = %64, %103
ret void
}

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