#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;

/* Variables and functions */
int floor(float);
int /*<<< orphan*/ halveImage_int(int, int, int, int const *, int *, int, int,
                                  int, int);
void scale_internal_int(GLint components, GLint widthin, GLint heightin,
                        const GLint *datain, GLint widthout, GLint heightout,
                        GLint *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;
  GLuint swapbuf;
  if (widthin == widthout * 2 && heightin == heightout * 2) {
    halveImage_int(components, widthin, heightin, (const GLint *)datain,
                   (GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 =
                  (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] += *(const GLint *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 =
                  (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] += *(const GLint *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 = (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] += *(const GLint *)&swapbuf * (1 - lowx_float);
              swapbuf = (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] += *(const GLint *)&swapbuf * highx_float;
            } else {
              totals[k] += *(const GLint *)left * (1 - lowx_float) +
                           *(const GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 =
                  (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] += *(const GLint *)&swapbuf * x_percent;
            } else {
              totals[k] += *(const GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 =
                  (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] += *(const GLint *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 =
                (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] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)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 =
                  (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] += *(const GLint *)&swapbuf;
            } else {
              totals[k] += *(const GLint *)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_int>:
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_int+0x89>
mov    -0xc(%rbp),%eax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    11a9 <scale_internal_int+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   1030 <halveImage_int@plt>
jmp    2582 <scale_internal_int+0x1462>
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   1040 <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   1040 <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    2582 <scale_internal_int+0x1462>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     128c <scale_internal_int+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    24e0 <scale_internal_int+0x13c0>
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_int+0xa0f>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    1b2f <scale_internal_int+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_int+0x30a>
cmpl   $0x0,0x30(%rbp)
je     13e1 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x2e6>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+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_int+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_int+0x40d>
cmpl   $0x0,0x30(%rbp)
je     14e1 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x3e9>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0x350>
jmp    1532 <scale_internal_int+0x412>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1441 <scale_internal_int+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_int+0x51d>
cmpl   $0x0,0x30(%rbp)
je     15f4 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x4f9>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+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_int+0x633>
cmpl   $0x0,0x30(%rbp)
je     170a <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x60f>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0x57c>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1864 <scale_internal_int+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_int+0x72b>
cmpl   $0x0,0x30(%rbp)
je     17ff <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x707>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0x66e>
jmp    1850 <scale_internal_int+0x730>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    175f <scale_internal_int+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_int+0x830>
cmpl   $0x0,0x30(%rbp)
je     1907 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x80c>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0x779>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1b2a <scale_internal_int+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_int+0x9f1>
cmpl   $0x0,0x30(%rbp)
je     1a8a <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x9b0>
mov    -0xc0(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  0x1563(%rip),%xmm2
subss  -0x90(%rbp),%xmm2
ff
mov    -0xc8(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0x883>
jmp    1b16 <scale_internal_int+0x9f6>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    195c <scale_internal_int+0x83c>
jmp    2299 <scale_internal_int+0x1179>
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jle    1e5a <scale_internal_int+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_int+0xb35>
cmpl   $0x0,0x30(%rbp)
je     1c0c <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0xb11>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0xa7e>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1d69 <scale_internal_int+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_int+0xc30>
cmpl   $0x0,0x30(%rbp)
je     1d04 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0xc0c>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0xb73>
jmp    1d55 <scale_internal_int+0xc35>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1c61 <scale_internal_int+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_int+0xd35>
cmpl   $0x0,0x30(%rbp)
je     1e0c <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0xd11>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0xc7e>
jmp    2294 <scale_internal_int+0x1174>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    217f <scale_internal_int+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_int+0xe5d>
cmpl   $0x0,0x30(%rbp)
je     1f34 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0xe39>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0xda6>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    208e <scale_internal_int+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_int+0xf55>
cmpl   $0x0,0x30(%rbp)
je     2029 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0xf31>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0xe98>
jmp    207a <scale_internal_int+0xf5a>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1f89 <scale_internal_int+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_int+0x105a>
cmpl   $0x0,0x30(%rbp)
je     2131 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x1036>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0xfa3>
jmp    228f <scale_internal_int+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_int+0x116a>
cmpl   $0x0,0x30(%rbp)
je     2241 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%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_int+0x1146>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%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_int+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_int+0x10b3>
jmp    228f <scale_internal_int+0x116f>
jmp    2294 <scale_internal_int+0x1174>
jmp    2299 <scale_internal_int+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_int+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_int+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_int+0x128c>
cmpl   $0x0,0x30(%rbp)
je     2370 <scale_internal_int+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,-0xcc(%rbp)
cvtsi2ssl -0xcc(%rbp),%xmm0
ff
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2388 <scale_internal_int+0x1268>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    238d <scale_internal_int+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_int+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_int+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_int+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    244d <scale_internal_int+0x132d>
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
divss  -0x44(%rbp),%xmm0
cvttss2si %xmm0,%edx
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2410 <scale_internal_int+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  0xb69(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    24cd <scale_internal_int+0x13ad>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xb54(%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    24d2 <scale_internal_int+0x13b2>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12be <scale_internal_int+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  0xacd(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    256f <scale_internal_int+0x144f>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xab8(%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    2574 <scale_internal_int+0x1454>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1265 <scale_internal_int+0x145>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_internal_int>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9d,%ebx
mov    %rcx,0x58(%rsp)
mov    0x1a0(%rsp),%r14d
mov    0x188(%rsp),%ebp
mov    %r8,0x70(%rsp)
lea    (%r8,%r8,1),%eax
cmp    %esi,%eax
jne    1193 <scale_internal_int+0x73>
lea    (%rbx,%rbx,1),%eax
cmp    %edx,%eax
jne    1193 <scale_internal_int+0x73>
sub    $0x8,%rsp
mov    0x60(%rsp),%rcx
mov    0x188(%rsp),%r8
mov    %ebp,%r9d
push   %r14
mov    0x1a8(%rsp),%eax
push   %rax
mov    0x1a8(%rsp),%eax
push   %rax
call   1030 <halveImage_int@plt>
add    $0x168,%rsp
jmp    1e8b <scale_internal_int+0xd6b>
cvtsi2ss %edx,%xmm0
cvtsi2ss %ebx,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,0x20(%rsp)
cvtsi2ss %esi,%xmm2
xorps  %xmm1,%xmm1
cvtsi2ssl 0x70(%rsp),%xmm1
divss  %xmm1,%xmm2
movaps %xmm2,0x40(%rsp)
mov    %rdx,0xa0(%rsp)
mov    %edi,0x18(%rsp)
call   1040 <floor@plt>
mov    %rax,0x98(%rsp)
movaps 0x40(%rsp),%xmm0
call   1040 <floor@plt>
movaps 0x40(%rsp),%xmm1
movss  0x20(%rsp),%xmm12
mov    0x18(%rsp),%r11d
mov    0xa0(%rsp),%rcx
mov    %rax,0x88(%rsp)
test   %ebx,%ebx
jle    1e84 <scale_internal_int+0xd64>
mov    0x98(%rsp),%rdx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
xorps  %xmm2,%xmm2
cvtsi2ssl 0x88(%rsp),%xmm2
movaps %xmm1,%xmm11
subss  %xmm2,%xmm11
mulss  %xmm12,%xmm1
subss  %xmm0,%xmm12
lea    -0x1(%rcx),%eax
mov    %eax,0x94(%rsp)
movslq %ebp,%r9
mov    0x198(%rsp),%eax
movslq %eax,%rsi
mov    0x190(%rsp),%eax
cltq
mov    %rax,0x68(%rsp)
movslq %r11d,%rdi
mov    0x70(%rsp),%rax
movslq %eax,%rbp
mov    %ebx,%ebx
mov    %rbx,0xd8(%rsp)
mov    %eax,%eax
mov    %rax,0x128(%rsp)
mov    %edi,%r13d
mov    0x58(%rsp),%rax
mov    %rsi,0x40(%rsp)
add    %rsi,%rax
mov    %rax,0xc0(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x108(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x100(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
movaps %xmm1,%xmm13
shufps $0x0,%xmm1,%xmm13
mov    %rsi,%rax
mov    %rsi,0xf8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xf0(%rsp)
mov    %rbp,0xc8(%rsp)
imul   %rdi,%rbp
shl    $0x2,%rbp
mov    %rbp,0xd0(%rsp)
xorps  %xmm2,%xmm2
movss  0xd06(%rip),%xmm10
xorps  %xmm8,%xmm8
movss  0xcfd(%rip),%xmm9
movaps %xmm12,%xmm3
mov    0x180(%rsp),%rax
lea    0x10(%rax),%rsi
mov    %rsi,0xb0(%rsp)
mov    %rdi,0xe0(%rsp)
lea    0x0(,%rdi,4),%rsi
mov    %rsi,0x120(%rsp)
xor    %esi,%esi
mov    %rsi,0x78(%rsp)
mov    %rax,0xa8(%rsp)
mov    %edx,%eax
xor    %edx,%edx
mov    %rdx,0x60(%rsp)
jmp    13af <scale_internal_int+0x28f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %sil,%cl
add    %ecx,%eax
mov    0x78(%rsp),%rdx
add    $0x1,%rdx
mov    0xd0(%rsp),%rcx
add    %rcx,0xb0(%rsp)
add    %rcx,0xa8(%rsp)
movaps %xmm5,%xmm2
mov    %r15d,%ebx
mov    %rbx,0x60(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x78(%rsp)
cmp    0xd8(%rsp),%rdx
mov    0xa0(%rsp),%rcx
je     1e84 <scale_internal_int+0xd64>
movaps %xmm3,%xmm5
cmp    %ecx,%eax
mov    %eax,%r15d
cmovge 0x94(%rsp),%r15d
cmpl   $0x0,0x70(%rsp)
jle    1e50 <scale_internal_int+0xd30>
movaps %xmm5,%xmm6
subss  %xmm2,%xmm6
mov    0x60(%rsp),%rdx
mov    %edx,%eax
mov    0x190(%rsp),%ecx
imul   %ecx,%eax
movslq %eax,%rsi
movaps %xmm10,%xmm7
subss  %xmm2,%xmm7
add    $0x1,%edx
mov    %r15d,%eax
imul   %ecx,%eax
cltq
mov    %rax,0xb8(%rsp)
mov    %edx,0x1c(%rsp)
mov    %edx,%eax
imul   %ecx,%eax
cltq
add    0xc0(%rsp),%rax
mov    %rax,0x110(%rsp)
mov    0x78(%rsp),%rax
imul   0xc8(%rsp),%rax
mov    %rax,0xe8(%rsp)
mov    0x58(%rsp),%rax
mov    %rsi,0x118(%rsp)
add    %rsi,%rax
mov    %rax,0x80(%rsp)
xor    %r10d,%r10d
xorps  %xmm4,%xmm4
mov    0xa8(%rsp),%rbx
mov    0xb0(%rsp),%r12
movaps %xmm11,%xmm2
mov    0x88(%rsp),%rax
xor    %ecx,%ecx
mov    %r15,0x30(%rsp)
jmp    14aa <scale_internal_int+0x38a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %sil,%cl
add    %ecx,%eax
add    $0x1,%r10
mov    0x120(%rsp),%rcx
add    %rcx,%r12
add    %rcx,%rbx
movaps %xmm3,%xmm4
mov    %edx,%ecx
cmp    0x128(%rsp),%r10
je     1e50 <scale_internal_int+0xd30>
mov    %eax,%edx
movaps %xmm2,%xmm3
mov    %ecx,%esi
mov    0x198(%rsp),%eax
imul   %eax,%esi
movaps %xmm8,(%rsp)
cmp    0x60(%rsp),%r15d
mov    %rdx,0x20(%rsp)
mov    %r10,0x140(%rsp)
mov    %rbx,0x138(%rsp)
mov    %r12,0x130(%rsp)
mov    %rcx,0x28(%rsp)
mov    %esi,0x3c(%rsp)
jle    1580 <scale_internal_int+0x460>
cmp    %ecx,%edx
jle    1580 <scale_internal_int+0x460>
mov    %r11d,%eax
movslq %esi,%r11
add    0x58(%rsp),%r11
mov    0x118(%rsp),%rcx
lea    (%r11,%rcx,1),%r15
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
test   %eax,%eax
jle    1610 <scale_internal_int+0x4f0>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %r15,%rdi
jmp    1557 <scale_internal_int+0x437>
xchg   %ax,%ax
mov    (%rdi),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rdi
cmp    %rsi,%r13
je     1610 <scale_internal_int+0x4f0>
test   %r14d,%r14d
je     1530 <scale_internal_int+0x410>
mov    0xc(%rdi),%ebp
shl    $0x18,%ebp
mov    0x4(%rdi),%ecx
mov    0x8(%rdi),%eax
shl    $0x10,%eax
or     %ebp,%eax
shl    $0x8,%ecx
or     %eax,%ecx
or     (%rdi),%ecx
jmp    1532 <scale_internal_int+0x412>
cs nopw 0x0(%rax,%rax,1)
cmp    0x60(%rsp),%r15d
jle    1790 <scale_internal_int+0x670>
movslq %esi,%r8
add    0x80(%rsp),%r8
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
test   %r11d,%r11d
jle    1820 <scale_internal_int+0x700>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %r8,%rdi
jmp    15e7 <scale_internal_int+0x4c7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rdi
cmp    %rsi,%r13
je     1820 <scale_internal_int+0x700>
test   %r14d,%r14d
je     15c0 <scale_internal_int+0x4a0>
mov    0xc(%rdi),%ecx
shl    $0x18,%ecx
mov    0x4(%rdi),%eax
mov    0x8(%rdi),%ebp
shl    $0x10,%ebp
or     %ecx,%ebp
shl    $0x8,%eax
or     %ebp,%eax
or     (%rdi),%eax
jmp    15c2 <scale_internal_int+0x4a2>
cs nopw 0x0(%rax,%rax,1)
mov    0x28(%rsp),%rax
lea    0x1(%rax),%r12d
mov    %r15,%r10
cmp    %edx,%r12d
jge    16a0 <scale_internal_int+0x580>
mov    %r12d,%edi
mov    %r15,%r10
jmp    1637 <scale_internal_int+0x517>
nopl   0x0(%rax)
add    $0x1,%edi
cmp    %edx,%edi
je     16a0 <scale_internal_int+0x580>
add    0x40(%rsp),%r10
cmpl   $0x0,0x18(%rsp)
jle    1630 <scale_internal_int+0x510>
xor    %esi,%esi
mov    %r10,%rbp
jmp    1674 <scale_internal_int+0x554>
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm7,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rbp
cmp    %rsi,%r13
je     1630 <scale_internal_int+0x510>
test   %r14d,%r14d
je     1650 <scale_internal_int+0x530>
mov    0xc(%rbp),%eax
shl    $0x18,%eax
mov    0x4(%rbp),%ecx
mov    0x8(%rbp),%r8d
shl    $0x10,%r8d
or     %eax,%r8d
shl    $0x8,%ecx
or     %r8d,%ecx
mov    0x20(%rsp),%rdx
or     0x0(%rbp),%ecx
jmp    1653 <scale_internal_int+0x533>
nopl   (%rax)
add    0x40(%rsp),%r10
cmpl   $0x0,0x18(%rsp)
jle    190b <scale_internal_int+0x7eb>
movaps %xmm7,%xmm4
mulss  %xmm3,%xmm4
xor    %esi,%esi
mov    %r10,%rdi
jmp    16e3 <scale_internal_int+0x5c3>
xchg   %ax,%ax
mov    (%rdi),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rdi
cmp    %rsi,%r13
je     1710 <scale_internal_int+0x5f0>
test   %r14d,%r14d
je     16c0 <scale_internal_int+0x5a0>
mov    0xc(%rdi),%eax
shl    $0x18,%eax
mov    0x4(%rdi),%ecx
mov    0x8(%rdi),%ebp
shl    $0x10,%ebp
or     %eax,%ebp
shl    $0x8,%ecx
or     %ebp,%ecx
or     (%rdi),%ecx
jmp    16c2 <scale_internal_int+0x5a2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    0xb8(%rsp),%r11
cmpl   $0x0,0x18(%rsp)
jle    1913 <scale_internal_int+0x7f3>
movaps %xmm5,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %r11,%rdi
jmp    1767 <scale_internal_int+0x647>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdi),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rdi
cmp    %rsi,%r13
je     1913 <scale_internal_int+0x7f3>
test   %r14d,%r14d
je     1740 <scale_internal_int+0x620>
mov    0xc(%rdi),%eax
shl    $0x18,%eax
mov    0x4(%rdi),%ecx
mov    0x8(%rdi),%ebp
shl    $0x10,%ebp
or     %eax,%ebp
shl    $0x8,%ecx
or     %ebp,%ecx
or     (%rdi),%ecx
jmp    1742 <scale_internal_int+0x622>
cs nopw 0x0(%rax,%rax,1)
cmp    0x28(%rsp),%edx
jle    1ae8 <scale_internal_int+0x9c8>
movslq %esi,%r8
add    0x80(%rsp),%r8
test   %r11d,%r11d
mov    0x28(%rsp),%r12
jle    1b66 <scale_internal_int+0xa46>
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
xor    %esi,%esi
mov    %r8,%rdi
jmp    17f7 <scale_internal_int+0x6d7>
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rdi
cmp    %rsi,%r13
je     1b66 <scale_internal_int+0xa46>
test   %r14d,%r14d
je     17d0 <scale_internal_int+0x6b0>
mov    0xc(%rdi),%ecx
shl    $0x18,%ecx
mov    0x4(%rdi),%eax
mov    0x8(%rdi),%ebp
shl    $0x10,%ebp
or     %ecx,%ebp
shl    $0x8,%eax
or     %ebp,%eax
or     (%rdi),%eax
jmp    17d2 <scale_internal_int+0x6b2>
cs nopw 0x0(%rax,%rax,1)
mov    0x1c(%rsp),%eax
mov    %eax,%r10d
cmp    %r15d,%eax
jl     1859 <scale_internal_int+0x739>
test   %r11d,%r11d
mov    0x28(%rsp),%r12
jle    1c50 <scale_internal_int+0xb30>
mulss  %xmm5,%xmm2
add    0x68(%rsp),%r8
xor    %esi,%esi
jmp    18e8 <scale_internal_int+0x7c8>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10d
cmp    %r15d,%r10d
je     182c <scale_internal_int+0x70c>
add    0x68(%rsp),%r8
test   %r11d,%r11d
jle    1850 <scale_internal_int+0x730>
xor    %esi,%esi
mov    %r8,%rax
jmp    1893 <scale_internal_int+0x773>
nopw   0x0(%rax,%rax,1)
mov    (%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rax
cmp    %rsi,%r13
je     1850 <scale_internal_int+0x730>
test   %r14d,%r14d
je     1870 <scale_internal_int+0x750>
mov    0xc(%rax),%ebp
shl    $0x18,%ebp
mov    0x4(%rax),%ecx
mov    0x8(%rax),%edi
shl    $0x10,%edi
or     %ebp,%edi
shl    $0x8,%ecx
or     %edi,%ecx
or     (%rax),%ecx
jmp    1872 <scale_internal_int+0x752>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r8),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%r8
cmp    %rsi,%r13
je     1c50 <scale_internal_int+0xb30>
test   %r14d,%r14d
je     18c0 <scale_internal_int+0x7a0>
mov    0xc(%r8),%ecx
shl    $0x18,%ecx
mov    0x4(%r8),%eax
mov    0x8(%r8),%edi
shl    $0x10,%edi
or     %ecx,%edi
shl    $0x8,%eax
or     %edi,%eax
or     (%r8),%eax
jmp    18c3 <scale_internal_int+0x7a3>
add    0xb8(%rsp),%r11
cmp    %edx,%r12d
jl     1949 <scale_internal_int+0x829>
cmpl   $0x0,0x18(%rsp)
mov    0x28(%rsp),%r12
jle    1a00 <scale_internal_int+0x8e0>
movaps %xmm5,%xmm4
mulss  %xmm3,%xmm4
add    0x40(%rsp),%r11
xor    %esi,%esi
jmp    19d4 <scale_internal_int+0x8b4>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12d
cmp    %edx,%r12d
je     1918 <scale_internal_int+0x7f8>
add    0x40(%rsp),%r11
cmpl   $0x0,0x18(%rsp)
jle    1940 <scale_internal_int+0x820>
xor    %esi,%esi
mov    %r11,%rdi
jmp    1983 <scale_internal_int+0x863>
nopl   0x0(%rax)
mov    (%rdi),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rdi
cmp    %rsi,%r13
je     1940 <scale_internal_int+0x820>
test   %r14d,%r14d
je     1960 <scale_internal_int+0x840>
mov    0xc(%rdi),%eax
shl    $0x18,%eax
mov    0x4(%rdi),%ecx
mov    0x8(%rdi),%ebp
shl    $0x10,%ebp
or     %eax,%ebp
shl    $0x8,%ecx
or     %ebp,%ecx
or     (%rdi),%ecx
jmp    1962 <scale_internal_int+0x842>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r11),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%r11
cmp    %rsi,%r13
je     1a00 <scale_internal_int+0x8e0>
test   %r14d,%r14d
je     19b0 <scale_internal_int+0x890>
mov    0xc(%r11),%eax
shl    $0x18,%eax
mov    0x4(%r11),%ecx
mov    0x8(%r11),%edi
shl    $0x10,%edi
or     %eax,%edi
shl    $0x8,%ecx
or     %edi,%ecx
or     (%r11),%ecx
jmp    19b3 <scale_internal_int+0x893>
nopw   0x0(%rax,%rax,1)
mov    0x1c(%rsp),%ecx
mov    %ecx,%eax
cmp    0x30(%rsp),%ecx
mov    0x18(%rsp),%r11d
jl     1a2d <scale_internal_int+0x90d>
jmp    1d10 <scale_internal_int+0xbf0>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%eax
cmp    0x30(%rsp),%eax
je     1c50 <scale_internal_int+0xb30>
mov    0x68(%rsp),%rcx
add    %rcx,%r15
add    %rcx,%r10
test   %r11d,%r11d
jle    1a20 <scale_internal_int+0x900>
xor    %edi,%edi
jmp    1a85 <scale_internal_int+0x965>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ssl (%r15),%xmm0
xorps  %xmm4,%xmm4
cvtsi2ssl (%r10),%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm2,%xmm0
addss  %xmm4,%xmm0
addss  (%rsp,%rdi,4),%xmm0
movss  %xmm0,(%rsp,%rdi,4)
add    $0x1,%rdi
add    %r9,%r15
add    %r9,%r10
cmp    %rdi,%r13
je     1a20 <scale_internal_int+0x900>
test   %r14d,%r14d
je     1a50 <scale_internal_int+0x930>
mov    0xc(%r15),%ecx
shl    $0x18,%ecx
mov    0x4(%r15),%esi
mov    0x8(%r15),%ebp
shl    $0x10,%ebp
or     %ecx,%ebp
shl    $0x8,%esi
or     %ebp,%esi
or     (%r15),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rdi,4),%xmm0
mov    0xc(%r10),%ecx
shl    $0x18,%ecx
mov    0x4(%r10),%esi
mov    0x8(%r10),%ebp
shl    $0x10,%ebp
or     %ecx,%ebp
shl    $0x8,%esi
or     %ebp,%esi
or     (%r10),%esi
xorps  %xmm4,%xmm4
cvtsi2ss %esi,%xmm4
mulss  %xmm3,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rsp,%rdi,4)
jmp    1a76 <scale_internal_int+0x956>
test   %r11d,%r11d
mov    0x28(%rsp),%r12
jle    1c50 <scale_internal_int+0xb30>
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
movslq 0x3c(%rsp),%rax
add    0x80(%rsp),%rax
xor    %esi,%esi
jmp    1b47 <scale_internal_int+0xa27>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rax
cmp    %rsi,%r13
je     1c50 <scale_internal_int+0xb30>
test   %r14d,%r14d
je     1b20 <scale_internal_int+0xa00>
mov    0xc(%rax),%edi
shl    $0x18,%edi
mov    0x4(%rax),%ecx
mov    0x8(%rax),%ebp
shl    $0x10,%ebp
or     %edi,%ebp
shl    $0x8,%ecx
or     %ebp,%ecx
or     (%rax),%ecx
jmp    1b22 <scale_internal_int+0xa02>
lea    0x1(%r12),%r10d
cmp    0x20(%rsp),%r10d
jl     1b9b <scale_internal_int+0xa7b>
test   %r11d,%r11d
jle    1c50 <scale_internal_int+0xb30>
movaps %xmm6,%xmm2
mulss  %xmm3,%xmm2
add    0x40(%rsp),%r8
xor    %esi,%esi
jmp    1c24 <scale_internal_int+0xb04>
xchg   %ax,%ax
add    $0x1,%r10d
cmp    0x20(%rsp),%r10d
je     1b72 <scale_internal_int+0xa52>
add    0x40(%rsp),%r8
test   %r11d,%r11d
jle    1b90 <scale_internal_int+0xa70>
xor    %esi,%esi
mov    %r8,%rax
jmp    1bd3 <scale_internal_int+0xab3>
nopl   0x0(%rax)
mov    (%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm6,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%rax
cmp    %rsi,%r13
je     1b90 <scale_internal_int+0xa70>
test   %r14d,%r14d
je     1bb0 <scale_internal_int+0xa90>
mov    0xc(%rax),%ebp
shl    $0x18,%ebp
mov    0x4(%rax),%ecx
mov    0x8(%rax),%edi
shl    $0x10,%edi
or     %ebp,%edi
shl    $0x8,%ecx
or     %edi,%ecx
or     (%rax),%ecx
jmp    1bb2 <scale_internal_int+0xa92>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r8),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r9,%r8
cmp    %rsi,%r13
je     1c50 <scale_internal_int+0xb30>
test   %r14d,%r14d
je     1c00 <scale_internal_int+0xae0>
mov    0xc(%r8),%ecx
shl    $0x18,%ecx
mov    0x4(%r8),%eax
mov    0x8(%r8),%edi
shl    $0x10,%edi
or     %ecx,%edi
shl    $0x8,%eax
or     %edi,%eax
or     (%r8),%eax
jmp    1c03 <scale_internal_int+0xae3>
nopw   0x0(%rax,%rax,1)
mov    0x1c(%rsp),%eax
cmp    0x30(%rsp),%eax
jge    1d10 <scale_internal_int+0xbf0>
movslq 0x3c(%rsp),%r10
add    0x110(%rsp),%r10
add    $0x1,%r12d
mov    0x1c(%rsp),%r15d
jmp    1c94 <scale_internal_int+0xb74>
cs nopw 0x0(%rax,%rax,1)
add    0x68(%rsp),%r10
add    $0x1,%r15d
cmp    0x30(%rsp),%r15d
je     1d10 <scale_internal_int+0xbf0>
mov    0x20(%rsp),%r8
cmp    %r8d,%r12d
jge    1c80 <scale_internal_int+0xb60>
mov    %r12d,%esi
mov    %r10,%rbp
jmp    1cbd <scale_internal_int+0xb9d>
cs nopw 0x0(%rax,%rax,1)
add    0x40(%rsp),%rbp
add    $0x1,%esi
cmp    %r8d,%esi
je     1c80 <scale_internal_int+0xb60>
test   %r11d,%r11d
jle    1cb0 <scale_internal_int+0xb90>
xor    %ecx,%ecx
mov    %rbp,%rax
jmp    1cef <scale_internal_int+0xbcf>
nopl   0x0(%rax)
mov    (%rax),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r9,%rax
cmp    %rcx,%r13
je     1cb0 <scale_internal_int+0xb90>
test   %r14d,%r14d
je     1cd0 <scale_internal_int+0xbb0>
mov    0xc(%rax),%ebx
shl    $0x18,%ebx
mov    0x4(%rax),%edi
mov    0x8(%rax),%edx
shl    $0x10,%edx
or     %ebx,%edx
shl    $0x8,%edi
or     %edx,%edi
or     (%rax),%edi
jmp    1cd2 <scale_internal_int+0xbb2>
xchg   %ax,%ax
test   %r11d,%r11d
mov    0x30(%rsp),%r15
mov    0x140(%rsp),%r10
mov    0x138(%rsp),%rbx
mov    0x130(%rsp),%r12
mov    0x20(%rsp),%rdx
jle    1e09 <scale_internal_int+0xce9>
cmp    $0x4,%r11d
jae    1d50 <scale_internal_int+0xc30>
xor    %eax,%eax
jmp    1df0 <scale_internal_int+0xcd0>
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x100(%rsp)
je     1e3c <scale_internal_int+0xd1c>
mov    0xf0(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movaps (%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
cvttps2dq %xmm0,%xmm0
movups %xmm0,-0x10(%r12,%rax,4)
movaps 0x10(%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
cvttps2dq %xmm0,%xmm0
movups %xmm0,(%r12,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1d70 <scale_internal_int+0xc50>
testb  $0x1,0xf8(%rsp)
01
je     1dd7 <scale_internal_int+0xcb7>
mov    0xe8(%rsp),%rcx
add    %r10,%rcx
imul   0xe0(%rsp),%rcx
movaps (%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
cvttps2dq %xmm0,%xmm0
add    %rax,%rcx
mov    0x180(%rsp),%rax
movups %xmm0,(%rax,%rcx,4)
mov    0x108(%rsp),%rcx
mov    %rcx,%rax
cmp    %r13,%rcx
je     1e09 <scale_internal_int+0xce9>
nopw   0x0(%rax,%rax,1)
movss  (%rsp,%rax,4),%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
mov    %ecx,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r13
jne    1df0 <scale_internal_int+0xcd0>
movaps %xmm11,%xmm4
addss  %xmm3,%xmm4
xor    %ecx,%ecx
ucomiss %xmm10,%xmm4
mov    0x88(%rsp),%rax
lea    (%rdx,%rax,1),%eax
seta   %sil
movaps %xmm4,%xmm2
addss  %xmm9,%xmm2
ja     1480 <scale_internal_int+0x360>
movaps %xmm4,%xmm2
jmp    1480 <scale_internal_int+0x360>
xor    %eax,%eax
testb  $0x1,0xf8(%rsp)
01
jne    1da8 <scale_internal_int+0xc88>
jmp    1dd7 <scale_internal_int+0xcb7>
xchg   %ax,%ax
movaps %xmm12,%xmm2
addss  %xmm5,%xmm2
xor    %ecx,%ecx
ucomiss %xmm10,%xmm2
mov    0x98(%rsp),%rax
lea    (%r15,%rax,1),%eax
seta   %sil
movaps %xmm2,%xmm3
addss  %xmm9,%xmm3
ja     1360 <scale_internal_int+0x240>
movaps %xmm2,%xmm3
jmp    1360 <scale_internal_int+0x240>
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @scale_internal_int(i32 %0, i32 %1, i32 %2, i32* %3, i32 %4, i32 %5, i32* %6, i32 %7, i32 %8, i32 %9, i32 %10) {
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32*
%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 i32
store i32 %0, i32* %12
store i32 %1, i32* %13
store i32 %2, i32* %14
store i32* %3, i32** %15
store i32 %4, i32* %16
store i32 %5, i32* %17
store i32* %6, i32** %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 i32*, i32** %15
%69 = load i32*, i32** %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_int(i32 %65, i32 %66, i32 %67, i32* %68, i32* %69, i32 %70, i32 %71, i32 %72, i32 %73)
br label %1384
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 = %1381, %75
%104 = load i32, i32* %28
%105 = load i32, i32* %17
%106 = icmp slt i32 %104, %105
br i1 %106, label %107, label %1384
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 = %1359, %114
%118 = load i32, i32* %29
%119 = load i32, i32* %16
%120 = icmp slt i32 %118, %119
br i1 %120, label %121, label %1362
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 i32*, i32** %15
%140 = bitcast i32* %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 %192
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
store i32 %183, i32* %54
%184 = load i32, i32* %54
%185 = sitofp i32 %184 to float
%186 = load float, float* %25
%187 = load i32, i32* %30
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %188
%190 = load float, float* %189
%191 = call float @llvm.fmuladd.f32(float %185, float %186, float %190)
store float %191, float* %189
br label %203
192: ; preds = %158
%193 = load i8*, i8** %34
%194 = bitcast i8* %193 to i32*
%195 = load i32, i32* %194
%196 = sitofp i32 %195 to float
%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 = %192, %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 %263
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
store i32 %254, i32* %54
%255 = load i32, i32* %54
%256 = sitofp i32 %255 to float
%257 = load float, float* %41
%258 = load i32, i32* %30
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %259
%261 = load float, float* %260
%262 = call float @llvm.fmuladd.f32(float %256, float %257, float %261)
store float %262, float* %260
br label %274
263: ; preds = %229
%264 = load i8*, i8** %34
%265 = bitcast i8* %264 to i32*
%266 = load i32, i32* %265
%267 = sitofp i32 %266 to float
%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 = %263, %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 %334
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
store i32 %325, i32* %54
%326 = load i32, i32* %54
%327 = sitofp i32 %326 to float
%328 = load float, float* %25
%329 = load i32, i32* %30
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %330
%332 = load float, float* %331
%333 = call float @llvm.fmuladd.f32(float %327, float %328, float %332)
store float %333, float* %331
br label %345
334: ; preds = %300
%335 = load i8*, i8** %34
%336 = bitcast i8* %335 to i32*
%337 = load i32, i32* %336
%338 = sitofp i32 %337 to float
%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 = %334, %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 i32*, i32** %15
%360 = bitcast i32* %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 %408
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
store i32 %399, i32* %54
%400 = load i32, i32* %54
%401 = sitofp i32 %400 to float
%402 = load float, float* %25
%403 = load i32, i32* %30
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %404
%406 = load float, float* %405
%407 = call float @llvm.fmuladd.f32(float %401, float %402, float %406)
store float %407, float* %405
br label %419
408: ; preds = %374
%409 = load i8*, i8** %34
%410 = bitcast i8* %409 to i32*
%411 = load i32, i32* %410
%412 = sitofp i32 %411 to float
%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 = %408, %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 %478
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
store i32 %469, i32* %54
%470 = load i32, i32* %54
%471 = sitofp i32 %470 to float
%472 = load float, float* %41
%473 = load i32, i32* %30
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %474
%476 = load float, float* %475
%477 = call float @llvm.fmuladd.f32(float %471, float %472, float %476)
store float %477, float* %475
br label %489
478: ; preds = %444
%479 = load i8*, i8** %34
%480 = bitcast i8* %479 to i32*
%481 = load i32, i32* %480
%482 = sitofp i32 %481 to float
%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 = %478, %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 %548
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
store i32 %539, i32* %54
%540 = load i32, i32* %54
%541 = sitofp i32 %540 to float
%542 = load float, float* %25
%543 = load i32, i32* %30
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %544
%546 = load float, float* %545
%547 = call float @llvm.fmuladd.f32(float %541, float %542, float %546)
store float %547, float* %545
br label %559
548: ; preds = %514
%549 = load i8*, i8** %34
%550 = bitcast i8* %549 to i32*
%551 = load i32, i32* %550
%552 = sitofp i32 %551 to float
%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 = %548, %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 %652
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
store i32 %612, i32* %54
%613 = load i32, i32* %54
%614 = sitofp i32 %613 to float
%615 = load float, float* %42
%616 = fsub float 1.000000e+00, %615
%617 = load i32, i32* %30
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %618
%620 = load float, float* %619
%621 = call float @llvm.fmuladd.f32(float %614, float %616, float %620)
store float %621, float* %619
%622 = load i8*, i8** %53
%623 = bitcast i8* %622 to i32*
%624 = getelementptr inbounds i32, i32* %623, i64 3
%625 = load i32, i32* %624
%626 = shl i32 %625, 24
%627 = load i8*, i8** %53
%628 = bitcast i8* %627 to i32*
%629 = getelementptr inbounds i32, i32* %628, i64 2
%630 = load i32, i32* %629
%631 = shl i32 %630, 16
%632 = or i32 %626, %631
%633 = load i8*, i8** %53
%634 = bitcast i8* %633 to i32*
%635 = getelementptr inbounds i32, i32* %634, i64 1
%636 = load i32, i32* %635
%637 = shl i32 %636, 8
%638 = or i32 %632, %637
%639 = load i8*, i8** %53
%640 = bitcast i8* %639 to i32*
%641 = getelementptr inbounds i32, i32* %640, i64 0
%642 = load i32, i32* %641
%643 = or i32 %638, %642
store i32 %643, i32* %54
%644 = load i32, i32* %54
%645 = sitofp i32 %644 to float
%646 = load float, float* %43
%647 = load i32, i32* %30
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %648
%650 = load float, float* %649
%651 = call float @llvm.fmuladd.f32(float %645, float %646, float %650)
store float %651, float* %649
br label %671
652: ; preds = %587
%653 = load i8*, i8** %52
%654 = bitcast i8* %653 to i32*
%655 = load i32, i32* %654
%656 = sitofp i32 %655 to float
%657 = load float, float* %42
%658 = fsub float 1.000000e+00, %657
%659 = load i8*, i8** %53
%660 = bitcast i8* %659 to i32*
%661 = load i32, i32* %660
%662 = sitofp i32 %661 to float
%663 = load float, float* %43
%664 = fmul float %662, %663
%665 = call float @llvm.fmuladd.f32(float %656, float %658, 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 = %652, %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 i32*, i32** %15
%701 = bitcast i32* %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 %749
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
store i32 %740, i32* %54
%741 = load i32, i32* %54
%742 = sitofp i32 %741 to float
%743 = load float, float* %25
%744 = load i32, i32* %30
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %745
%747 = load float, float* %746
%748 = call float @llvm.fmuladd.f32(float %742, float %743, float %747)
store float %748, float* %746
br label %760
749: ; preds = %715
%750 = load i8*, i8** %34
%751 = bitcast i8* %750 to i32*
%752 = load i32, i32* %751
%753 = sitofp i32 %752 to float
%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 = %749, %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 %819
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
store i32 %810, i32* %54
%811 = load i32, i32* %54
%812 = sitofp i32 %811 to float
%813 = load float, float* %40
%814 = load i32, i32* %30
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %815
%817 = load float, float* %816
%818 = call float @llvm.fmuladd.f32(float %812, float %813, float %817)
store float %818, float* %816
br label %830
819: ; preds = %785
%820 = load i8*, i8** %34
%821 = bitcast i8* %820 to i32*
%822 = load i32, i32* %821
%823 = sitofp i32 %822 to float
%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 = %819, %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 %889
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
store i32 %880, i32* %54
%881 = load i32, i32* %54
%882 = sitofp i32 %881 to float
%883 = load float, float* %25
%884 = load i32, i32* %30
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %885
%887 = load float, float* %886
%888 = call float @llvm.fmuladd.f32(float %882, float %883, float %887)
store float %888, float* %886
br label %900
889: ; preds = %855
%890 = load i8*, i8** %34
%891 = bitcast i8* %890 to i32*
%892 = load i32, i32* %891
%893 = sitofp i32 %892 to float
%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 = %889, %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 i32*, i32** %15
%922 = bitcast i32* %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 %970
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
store i32 %961, i32* %54
%962 = load i32, i32* %54
%963 = sitofp i32 %962 to float
%964 = load float, float* %25
%965 = load i32, i32* %30
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %966
%968 = load float, float* %967
%969 = call float @llvm.fmuladd.f32(float %963, float %964, float %968)
store float %969, float* %967
br label %981
970: ; preds = %936
%971 = load i8*, i8** %34
%972 = bitcast i8* %971 to i32*
%973 = load i32, i32* %972
%974 = sitofp i32 %973 to float
%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 = %970, %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 %1040
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
store i32 %1031, i32* %54
%1032 = load i32, i32* %54
%1033 = sitofp i32 %1032 to float
%1034 = load float, float* %41
%1035 = load i32, i32* %30
%1036 = sext i32 %1035 to i64
%1037 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1036
%1038 = load float, float* %1037
%1039 = call float @llvm.fmuladd.f32(float %1033, float %1034, float %1038)
store float %1039, float* %1037
br label %1051
1040: ; preds = %1006
%1041 = load i8*, i8** %34
%1042 = bitcast i8* %1041 to i32*
%1043 = load i32, i32* %1042
%1044 = sitofp i32 %1043 to float
%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 = %1040, %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 %1110
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
store i32 %1101, i32* %54
%1102 = load i32, i32* %54
%1103 = sitofp i32 %1102 to float
%1104 = load float, float* %25
%1105 = load i32, i32* %30
%1106 = sext i32 %1105 to i64
%1107 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1106
%1108 = load float, float* %1107
%1109 = call float @llvm.fmuladd.f32(float %1103, float %1104, float %1108)
store float %1109, float* %1107
br label %1121
1110: ; preds = %1076
%1111 = load i8*, i8** %34
%1112 = bitcast i8* %1111 to i32*
%1113 = load i32, i32* %1112
%1114 = sitofp i32 %1113 to float
%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 = %1110, %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 i32*, i32** %15
%1139 = bitcast i32* %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 %1187
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
store i32 %1178, i32* %54
%1179 = load i32, i32* %54
%1180 = sitofp i32 %1179 to float
%1181 = load float, float* %25
%1182 = load i32, i32* %30
%1183 = sext i32 %1182 to i64
%1184 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1183
%1185 = load float, float* %1184
%1186 = call float @llvm.fmuladd.f32(float %1180, float %1181, float %1185)
store float %1186, float* %1184
br label %1198
1187: ; preds = %1153
%1188 = load i8*, i8** %34
%1189 = bitcast i8* %1188 to i32*
%1190 = load i32, i32* %1189
%1191 = sitofp i32 %1190 to float
%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 = %1187, %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 i32*, i32** %15
%1211 = bitcast i32* %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 %1277
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
store i32 %1269, i32* %54
%1270 = load i32, i32* %54
%1271 = sitofp i32 %1270 to float
%1272 = load i32, i32* %30
%1273 = sext i32 %1272 to i64
%1274 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %1273
%1275 = load float, float* %1274
%1276 = fadd float %1275, %1271
store float %1276, float* %1274
br label %1287
1277: ; preds = %1244
%1278 = load i8*, i8** %34
%1279 = bitcast i8* %1278 to i32*
%1280 = load i32, i32* %1279
%1281 = sitofp i32 %1280 to float
%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 = %1277, %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 = %1337, %1311
%1320 = load i32, i32* %30
%1321 = load i32, i32* %12
%1322 = icmp slt i32 %1320, %1321
br i1 %1322, label %1323, label %1340
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 = fptosi float %1329 to i32
%1331 = load i32*, i32** %18
%1332 = load i32, i32* %35
%1333 = load i32, i32* %30
%1334 = add nsw i32 %1332, %1333
%1335 = sext i32 %1334 to i64
%1336 = getelementptr inbounds i32, i32* %1331, i64 %1335
store i32 %1330, i32* %1336
br label %1337
1337: ; preds = %1323
%1338 = load i32, i32* %30
%1339 = add nsw i32 %1338, 1
store i32 %1339, i32* %30
br label %1319
1340: ; preds = %1319
%1341 = load i32, i32* %37
store i32 %1341, i32* %36
%1342 = load float, float* %43
store float %1342, float* %42
%1343 = load i32, i32* %49
%1344 = load i32, i32* %37
%1345 = add nsw i32 %1344, %1343
store i32 %1345, i32* %37
%1346 = load float, float* %47
%1347 = load float, float* %43
%1348 = fadd float %1347, %1346
store float %1348, float* %43
%1349 = load float, float* %43
%1350 = fcmp ogt float %1349, 1.000000e+00
br i1 %1350, label %1351, label %1358
1351: ; preds = %1340
%1352 = load float, float* %43
%1353 = fpext float %1352 to double
%1354 = fsub double %1353, 1.000000e+00
%1355 = fptrunc double %1354 to float
store float %1355, float* %43
%1356 = load i32, i32* %37
%1357 = add nsw i32 %1356, 1
store i32 %1357, i32* %37
br label %1358
1358: ; preds = %1351, %1340
br label %1359
1359: ; preds = %1358
%1360 = load i32, i32* %29
%1361 = add nsw i32 %1360, 1
store i32 %1361, i32* %29
br label %117
1362: ; preds = %117
%1363 = load i32, i32* %39
store i32 %1363, i32* %38
%1364 = load float, float* %45
store float %1364, float* %44
%1365 = load i32, i32* %48
%1366 = load i32, i32* %39
%1367 = add nsw i32 %1366, %1365
store i32 %1367, i32* %39
%1368 = load float, float* %46
%1369 = load float, float* %45
%1370 = fadd float %1369, %1368
store float %1370, float* %45
%1371 = load float, float* %45
%1372 = fcmp ogt float %1371, 1.000000e+00
br i1 %1372, label %1373, label %1380
1373: ; preds = %1362
%1374 = load float, float* %45
%1375 = fpext float %1374 to double
%1376 = fsub double %1375, 1.000000e+00
%1377 = fptrunc double %1376 to float
store float %1377, float* %45
%1378 = load i32, i32* %39
%1379 = add nsw i32 %1378, 1
store i32 %1379, i32* %39
br label %1380
1380: ; preds = %1373, %1362
br label %1381
1381: ; preds = %1380
%1382 = load i32, i32* %28
%1383 = add nsw i32 %1382, 1
store i32 %1383, i32* %28
br label %103
1384: ; preds = %64, %103
ret void
}

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