#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 GLushort;
typedef int GLubyte;
typedef int GLint;

/* Variables and functions */
int floor(float);
int /*<<< orphan*/ halveImage_ushort(int, int, int, int const *, int *, int,
                                     int, int, int);
void scale_internal_ushort(GLint components, GLint widthin, GLint heightin,
                           const GLushort *datain, GLint widthout,
                           GLint heightout, GLushort *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;
  if (widthin == widthout * 2 && heightin == heightout * 2) {
    halveImage_ushort(components, widthin, heightin, (const GLushort *)datain,
                      (GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
              totals[k] +=
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]) *
                  y_percent;
            } else {
              totals[k] += *(const GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
              totals[k] +=
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]) *
                  y_percent;
            } else {
              totals[k] += *(const GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
              totals[k] +=
                  (GLushort)(((GLushort)((const GLubyte *)(left))[1]) << 8 |
                             ((const GLubyte *)(left))[0]) *
                      (1 - lowx_float) +
                  (GLushort)(((GLushort)((const GLubyte *)(right))[1]) << 8 |
                             ((const GLubyte *)(right))[0]) *
                      highx_float;
            } else {
              totals[k] += *(const GLushort *)left * (1 - lowx_float) +
                           *(const GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
              totals[k] +=
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]) *
                  x_percent;
            } else {
              totals[k] += *(const GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
              totals[k] +=
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]) *
                  y_percent;
            } else {
              totals[k] += *(const GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
            totals[k] +=
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLushort *)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) {
              totals[k] +=
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]);
            } else {
              totals[k] += *(const GLushort *)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_ushort>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%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_ushort+0x89>
mov    -0xc(%rbp),%eax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    11a9 <scale_internal_ushort+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_ushort@plt>
jmp    233e <scale_internal_ushort+0x121e>
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    233e <scale_internal_ushort+0x121e>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     128c <scale_internal_ushort+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    229c <scale_internal_ushort+0x117c>
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    19fb <scale_internal_ushort+0x8db>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    19fb <scale_internal_ushort+0x8db>
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    1408 <scale_internal_ushort+0x2e8>
cmpl   $0x0,0x30(%rbp)
je     13bf <scale_internal_ushort+0x29f>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    13e4 <scale_internal_ushort+0x2c4>
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    13e9 <scale_internal_ushort+0x2c9>
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_ushort+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    1502 <scale_internal_ushort+0x3e2>
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    14e9 <scale_internal_ushort+0x3c9>
cmpl   $0x0,0x30(%rbp)
je     149d <scale_internal_ushort+0x37d>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    14c5 <scale_internal_ushort+0x3a5>
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    14ca <scale_internal_ushort+0x3aa>
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    144e <scale_internal_ushort+0x32e>
jmp    14ee <scale_internal_ushort+0x3ce>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    141f <scale_internal_ushort+0x2ff>
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    15d7 <scale_internal_ushort+0x4b7>
cmpl   $0x0,0x30(%rbp)
je     158e <scale_internal_ushort+0x46e>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    15b3 <scale_internal_ushort+0x493>
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    15b8 <scale_internal_ushort+0x498>
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    1542 <scale_internal_ushort+0x422>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  0x1a09(%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    16cb <scale_internal_ushort+0x5ab>
cmpl   $0x0,0x30(%rbp)
je     1682 <scale_internal_ushort+0x562>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    16a7 <scale_internal_ushort+0x587>
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    16ac <scale_internal_ushort+0x58c>
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    1636 <scale_internal_ushort+0x516>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    17ba <scale_internal_ushort+0x69a>
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    17a1 <scale_internal_ushort+0x681>
cmpl   $0x0,0x30(%rbp)
je     1755 <scale_internal_ushort+0x635>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    177d <scale_internal_ushort+0x65d>
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    1782 <scale_internal_ushort+0x662>
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    1706 <scale_internal_ushort+0x5e6>
jmp    17a6 <scale_internal_ushort+0x686>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    16d7 <scale_internal_ushort+0x5b7>
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    1884 <scale_internal_ushort+0x764>
cmpl   $0x0,0x30(%rbp)
je     183b <scale_internal_ushort+0x71b>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    1860 <scale_internal_ushort+0x740>
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    1865 <scale_internal_ushort+0x745>
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    17ef <scale_internal_ushort+0x6cf>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    19f6 <scale_internal_ushort+0x8d6>
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    19dd <scale_internal_ushort+0x8bd>
cmpl   $0x0,0x30(%rbp)
je     1956 <scale_internal_ushort+0x836>
mov    -0xc0(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0xc0(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  0x16f1(%rip),%xmm2
subss  -0x90(%rbp),%xmm2
ff
mov    -0xc8(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0xc8(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    199c <scale_internal_ushort+0x87c>
mov    -0xc0(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  0x1697(%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    19a1 <scale_internal_ushort+0x881>
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    18d7 <scale_internal_ushort+0x7b7>
jmp    19e2 <scale_internal_ushort+0x8c2>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1890 <scale_internal_ushort+0x770>
jmp    2077 <scale_internal_ushort+0xf57>
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jle    1cc0 <scale_internal_ushort+0xba0>
movss  -0x94(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  0x15d6(%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    1aff <scale_internal_ushort+0x9df>
cmpl   $0x0,0x30(%rbp)
je     1ab6 <scale_internal_ushort+0x996>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    1adb <scale_internal_ushort+0x9bb>
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    1ae0 <scale_internal_ushort+0x9c0>
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    1a6a <scale_internal_ushort+0x94a>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1bf1 <scale_internal_ushort+0xad1>
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    1bd8 <scale_internal_ushort+0xab8>
cmpl   $0x0,0x30(%rbp)
je     1b8c <scale_internal_ushort+0xa6c>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    1bb4 <scale_internal_ushort+0xa94>
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    1bb9 <scale_internal_ushort+0xa99>
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    1b3d <scale_internal_ushort+0xa1d>
jmp    1bdd <scale_internal_ushort+0xabd>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1b0b <scale_internal_ushort+0x9eb>
movss  -0x88(%rbp),%xmm0
ff
mulss  -0x9c(%rbp),%xmm0
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    1cbb <scale_internal_ushort+0xb9b>
cmpl   $0x0,0x30(%rbp)
je     1c72 <scale_internal_ushort+0xb52>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    1c97 <scale_internal_ushort+0xb77>
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    1c9c <scale_internal_ushort+0xb7c>
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    1c26 <scale_internal_ushort+0xb06>
jmp    2072 <scale_internal_ushort+0xf52>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    1f7f <scale_internal_ushort+0xe5f>
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  0x1314(%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    1dc1 <scale_internal_ushort+0xca1>
cmpl   $0x0,0x30(%rbp)
je     1d78 <scale_internal_ushort+0xc58>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    1d9d <scale_internal_ushort+0xc7d>
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    1da2 <scale_internal_ushort+0xc82>
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    1d2c <scale_internal_ushort+0xc0c>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1eb0 <scale_internal_ushort+0xd90>
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    1e97 <scale_internal_ushort+0xd77>
cmpl   $0x0,0x30(%rbp)
je     1e4b <scale_internal_ushort+0xd2b>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    1e73 <scale_internal_ushort+0xd53>
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    1e78 <scale_internal_ushort+0xd58>
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    1dfc <scale_internal_ushort+0xcdc>
jmp    1e9c <scale_internal_ushort+0xd7c>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1dcd <scale_internal_ushort+0xcad>
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    1f7a <scale_internal_ushort+0xe5a>
cmpl   $0x0,0x30(%rbp)
je     1f31 <scale_internal_ushort+0xe11>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    1f56 <scale_internal_ushort+0xe36>
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    1f5b <scale_internal_ushort+0xe3b>
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    1ee5 <scale_internal_ushort+0xdc5>
jmp    206d <scale_internal_ushort+0xf4d>
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    2068 <scale_internal_ushort+0xf48>
cmpl   $0x0,0x30(%rbp)
je     201f <scale_internal_ushort+0xeff>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%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    2044 <scale_internal_ushort+0xf24>
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    2049 <scale_internal_ushort+0xf29>
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    1fd3 <scale_internal_ushort+0xeb3>
jmp    206d <scale_internal_ushort+0xf4d>
jmp    2072 <scale_internal_ushort+0xf52>
jmp    2077 <scale_internal_ushort+0xf57>
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    21b2 <scale_internal_ushort+0x1092>
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    218d <scale_internal_ushort+0x106d>
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2168 <scale_internal_ushort+0x1048>
cmpl   $0x0,0x30(%rbp)
je     212c <scale_internal_ushort+0x100c>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2144 <scale_internal_ushort+0x1024>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2149 <scale_internal_ushort+0x1029>
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    20ed <scale_internal_ushort+0xfcd>
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    20cf <scale_internal_ushort+0xfaf>
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    20a9 <scale_internal_ushort+0xf89>
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    2209 <scale_internal_ushort+0x10e9>
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    21cc <scale_internal_ushort+0x10ac>
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  0xdad(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    2289 <scale_internal_ushort+0x1169>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xd98(%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    228e <scale_internal_ushort+0x116e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12be <scale_internal_ushort+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  0xd11(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    232b <scale_internal_ushort+0x120b>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xcfc(%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    2330 <scale_internal_ushort+0x1210>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1265 <scale_internal_ushort+0x145>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_internal_ushort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9d,%ebx
mov    %rcx,0x30(%rsp)
mov    %edi,%r13d
mov    0x180(%rsp),%r14d
mov    0x178(%rsp),%r12d
mov    0x168(%rsp),%ebp
mov    %r8,0x50(%rsp)
lea    (%r8,%r8,1),%eax
cmp    %esi,%eax
jne    119b <scale_internal_ushort+0x7b>
lea    (%rbx,%rbx,1),%eax
cmp    %edx,%eax
jne    119b <scale_internal_ushort+0x7b>
sub    $0x8,%rsp
mov    %r13d,%edi
mov    0x38(%rsp),%rcx
mov    0x168(%rsp),%r8
mov    %ebp,%r9d
push   %r14
push   %r12
mov    0x188(%rsp),%eax
push   %rax
call   1030 <halveImage_ushort@plt>
add    $0x148,%rsp
jmp    1cf8 <scale_internal_ushort+0xbd8>
cvtsi2ss %edx,%xmm0
cvtsi2ss %ebx,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,0x20(%rsp)
cvtsi2ss %esi,%xmm2
xorps  %xmm1,%xmm1
cvtsi2ssl 0x50(%rsp),%xmm1
divss  %xmm1,%xmm2
movaps %xmm2,0x40(%rsp)
mov    %rdx,0x80(%rsp)
call   1040 <floor@plt>
mov    %rax,0x78(%rsp)
movaps 0x40(%rsp),%xmm0
call   1040 <floor@plt>
movaps 0x40(%rsp),%xmm1
movss  0x20(%rsp),%xmm12
mov    0x80(%rsp),%rcx
mov    %rax,0x68(%rsp)
test   %ebx,%ebx
jle    1cf1 <scale_internal_ushort+0xbd1>
mov    0x78(%rsp),%r9
xorps  %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
xorps  %xmm2,%xmm2
cvtsi2ssl 0x68(%rsp),%xmm2
movaps %xmm1,%xmm11
subss  %xmm2,%xmm11
mulss  %xmm12,%xmm1
subss  %xmm0,%xmm12
lea    -0x1(%rcx),%eax
mov    %eax,0x74(%rsp)
movslq %ebp,%rdx
movslq %r12d,%r8
mov    0x170(%rsp),%eax
movslq %eax,%r11
movslq %r13d,%rdi
mov    0x50(%rsp),%rax
movslq %eax,%rbp
mov    %ebx,%ebx
mov    %rbx,0xc0(%rsp)
mov    %eax,%eax
mov    %rax,0x110(%rsp)
mov    %edi,%ebx
mov    0x30(%rsp),%rax
add    %r8,%rax
mov    %rax,0xa8(%rsp)
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,0xf0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xe8(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
movaps %xmm1,%xmm13
shufps $0x0,%xmm1,%xmm13
mov    %rsi,%rax
mov    %rsi,0xe0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xd8(%rsp)
mov    %rbp,0xb0(%rsp)
imul   %rdi,%rbp
shl    $0x2,%rbp
mov    %rbp,0xb8(%rsp)
xorps  %xmm2,%xmm2
movss  0xd27(%rip),%xmm10
xorps  %xmm8,%xmm8
movss  0xd1e(%rip),%xmm9
movaps %xmm12,%xmm3
mov    0x160(%rsp),%rax
lea    0x10(%rax),%rsi
mov    %rsi,0x90(%rsp)
mov    %rdi,0xc8(%rsp)
lea    0x0(,%rdi,4),%rsi
mov    %rsi,0x108(%rsp)
xor    %esi,%esi
mov    %rsi,0x58(%rsp)
mov    %rax,0x88(%rsp)
mov    %r9d,%eax
xor    %esi,%esi
mov    %rsi,0x38(%rsp)
jmp    138c <scale_internal_ushort+0x26c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %sil,%cl
add    %ecx,%eax
mov    0x58(%rsp),%rsi
add    $0x1,%rsi
mov    0xb8(%rsp),%rcx
add    %rcx,0x90(%rsp)
add    %rcx,0x88(%rsp)
movaps %xmm5,%xmm2
mov    %r10,0x38(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x58(%rsp)
cmp    0xc0(%rsp),%rsi
mov    0x80(%rsp),%rcx
je     1cf1 <scale_internal_ushort+0xbd1>
movaps %xmm3,%xmm5
cmp    %ecx,%eax
mov    %eax,%r10d
cmovge 0x74(%rsp),%r10d
cmpl   $0x0,0x50(%rsp)
jle    1cc0 <scale_internal_ushort+0xba0>
movaps %xmm5,%xmm6
subss  %xmm2,%xmm6
mov    0x38(%rsp),%rsi
mov    %esi,%eax
mov    0x170(%rsp),%ecx
imul   %ecx,%eax
movslq %eax,%rdi
movaps %xmm10,%xmm7
subss  %xmm2,%xmm7
add    $0x1,%esi
mov    %r10d,%eax
imul   %ecx,%eax
cltq
mov    %rax,0x98(%rsp)
mov    %esi,0x1c(%rsp)
mov    %esi,%eax
imul   %ecx,%eax
cltq
add    0xa8(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0x58(%rsp),%rax
imul   0xb0(%rsp),%rax
mov    %rax,0xd0(%rsp)
mov    0x30(%rsp),%rax
mov    %rdi,0x100(%rsp)
add    %rdi,%rax
mov    %rax,0x60(%rsp)
xor    %r15d,%r15d
xorps  %xmm4,%xmm4
mov    0x88(%rsp),%rbp
mov    0x90(%rsp),%rsi
movaps %xmm11,%xmm2
mov    0x68(%rsp),%rax
xor    %ecx,%ecx
mov    %r10,0x40(%rsp)
jmp    1483 <scale_internal_ushort+0x363>
nopl   0x0(%rax)
mov    %sil,%cl
add    %ecx,%eax
add    $0x1,%r15
mov    0x108(%rsp),%rcx
mov    0xa0(%rsp),%rsi
add    %rcx,%rsi
add    %rcx,%rbp
movaps %xmm3,%xmm4
mov    %r9d,%ecx
cmp    0x110(%rsp),%r15
je     1cc0 <scale_internal_ushort+0xba0>
mov    %rsi,0xa0(%rsp)
mov    %eax,%r9d
movaps %xmm2,%xmm3
mov    %ecx,%eax
imul   %r12d,%eax
movaps %xmm8,(%rsp)
cmp    0x38(%rsp),%r10d
mov    %r15,0x120(%rsp)
mov    %rbp,0x118(%rsp)
mov    %rcx,0x20(%rsp)
mov    %eax,0x2c(%rsp)
jle    1540 <scale_internal_ushort+0x420>
cmp    %ecx,%r9d
jle    1540 <scale_internal_ushort+0x420>
cltq
add    0x30(%rsp),%rax
mov    0x100(%rsp),%rcx
lea    (%rax,%rcx,1),%r15
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
test   %r13d,%r13d
jle    15c0 <scale_internal_ushort+0x4a0>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %r15,%rdi
jmp    1527 <scale_internal_ushort+0x407>
nopw   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    %rdx,%rdi
cmp    %rsi,%rbx
je     15c0 <scale_internal_ushort+0x4a0>
test   %r14d,%r14d
je     1500 <scale_internal_ushort+0x3e0>
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
or     (%rdi),%ecx
jmp    1502 <scale_internal_ushort+0x3e2>
cs nopw 0x0(%rax,%rax,1)
cmp    0x38(%rsp),%r10d
jle    1700 <scale_internal_ushort+0x5e0>
movslq %eax,%rbp
add    0x60(%rsp),%rbp
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
test   %r13d,%r13d
jle    1770 <scale_internal_ushort+0x650>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %rbp,%rdi
jmp    15a7 <scale_internal_ushort+0x487>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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    %rdx,%rdi
cmp    %rsi,%rbx
je     1770 <scale_internal_ushort+0x650>
test   %r14d,%r14d
je     1580 <scale_internal_ushort+0x460>
mov    0x4(%rdi),%eax
shl    $0x8,%eax
or     (%rdi),%eax
jmp    1582 <scale_internal_ushort+0x462>
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
lea    0x1(%rcx),%r12d
mov    %r15,%r10
cmp    %r9d,%r12d
jge    1640 <scale_internal_ushort+0x520>
mov    %r12d,%edi
mov    %r15,%r10
jmp    15e8 <scale_internal_ushort+0x4c8>
nopl   0x0(%rax)
add    $0x1,%edi
cmp    %r9d,%edi
je     1640 <scale_internal_ushort+0x520>
add    %r8,%r10
test   %r13d,%r13d
jle    15e0 <scale_internal_ushort+0x4c0>
xor    %esi,%esi
mov    %r10,%rbp
jmp    1624 <scale_internal_ushort+0x504>
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    %rdx,%rbp
cmp    %rsi,%rbx
je     15e0 <scale_internal_ushort+0x4c0>
test   %r14d,%r14d
je     1600 <scale_internal_ushort+0x4e0>
mov    0x4(%rbp),%ecx
shl    $0x8,%ecx
or     0x0(%rbp),%ecx
jmp    1603 <scale_internal_ushort+0x4e3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %r8,%r10
test   %r13d,%r13d
jle    1838 <scale_internal_ushort+0x718>
movaps %xmm7,%xmm4
mulss  %xmm3,%xmm4
xor    %esi,%esi
mov    %r10,%rdi
jmp    1683 <scale_internal_ushort+0x563>
nopw   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    %rdx,%rdi
cmp    %rsi,%rbx
je     16a0 <scale_internal_ushort+0x580>
test   %r14d,%r14d
je     1660 <scale_internal_ushort+0x540>
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
or     (%rdi),%ecx
jmp    1662 <scale_internal_ushort+0x542>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    0x98(%rsp),%rax
test   %r13d,%r13d
jle    1840 <scale_internal_ushort+0x720>
movaps %xmm5,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %rax,%rdi
jmp    16e7 <scale_internal_ushort+0x5c7>
nop
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    %rdx,%rdi
cmp    %rsi,%rbx
je     1840 <scale_internal_ushort+0x720>
test   %r14d,%r14d
je     16c0 <scale_internal_ushort+0x5a0>
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
or     (%rdi),%ecx
jmp    16c2 <scale_internal_ushort+0x5a2>
cs nopw 0x0(%rax,%rax,1)
cmp    %ecx,%r9d
jle    19a4 <scale_internal_ushort+0x884>
movslq %eax,%rbp
add    0x60(%rsp),%rbp
test   %r13d,%r13d
jle    1a06 <scale_internal_ushort+0x8e6>
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
xor    %esi,%esi
mov    %rbp,%rdi
jmp    1757 <scale_internal_ushort+0x637>
nopl   (%rax)
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    %rdx,%rdi
cmp    %rsi,%rbx
je     1a06 <scale_internal_ushort+0x8e6>
test   %r14d,%r14d
je     1730 <scale_internal_ushort+0x610>
mov    0x4(%rdi),%eax
shl    $0x8,%eax
or     (%rdi),%eax
jmp    1732 <scale_internal_ushort+0x612>
cs nopw 0x0(%rax,%rax,1)
mov    0x1c(%rsp),%eax
mov    %eax,%edi
cmp    %r10d,%eax
jl     17a8 <scale_internal_ushort+0x688>
test   %r13d,%r13d
jle    1ad0 <scale_internal_ushort+0x9b0>
mulss  %xmm5,%xmm2
add    %r11,%rbp
xor    %esi,%esi
jmp    1828 <scale_internal_ushort+0x708>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%edi
cmp    %r10d,%edi
je     177b <scale_internal_ushort+0x65b>
add    %r11,%rbp
test   %r13d,%r13d
jle    17a0 <scale_internal_ushort+0x680>
xor    %esi,%esi
mov    %rbp,%rax
jmp    17e3 <scale_internal_ushort+0x6c3>
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    %rdx,%rax
cmp    %rsi,%rbx
je     17a0 <scale_internal_ushort+0x680>
test   %r14d,%r14d
je     17c0 <scale_internal_ushort+0x6a0>
mov    0x4(%rax),%ecx
shl    $0x8,%ecx
or     (%rax),%ecx
jmp    17c2 <scale_internal_ushort+0x6a2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rbp
cmp    %rsi,%rbx
je     1ad0 <scale_internal_ushort+0x9b0>
test   %r14d,%r14d
je     1800 <scale_internal_ushort+0x6e0>
mov    0x4(%rbp),%eax
shl    $0x8,%eax
or     0x0(%rbp),%eax
jmp    1803 <scale_internal_ushort+0x6e3>
add    0x98(%rsp),%rax
cmp    %r9d,%r12d
jl     1879 <scale_internal_ushort+0x759>
test   %r13d,%r13d
mov    0x178(%rsp),%r12d
jle    1910 <scale_internal_ushort+0x7f0>
movaps %xmm5,%xmm4
mulss  %xmm3,%xmm4
add    %r8,%rax
xor    %esi,%esi
jmp    18f3 <scale_internal_ushort+0x7d3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12d
cmp    %r9d,%r12d
je     1845 <scale_internal_ushort+0x725>
add    %r8,%rax
test   %r13d,%r13d
jle    1870 <scale_internal_ushort+0x750>
xor    %esi,%esi
mov    %rax,%rdi
jmp    18b3 <scale_internal_ushort+0x793>
nopl   0x0(%rax,%rax,1)
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    %rdx,%rdi
cmp    %rsi,%rbx
je     1870 <scale_internal_ushort+0x750>
test   %r14d,%r14d
je     1890 <scale_internal_ushort+0x770>
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
or     (%rdi),%ecx
jmp    1892 <scale_internal_ushort+0x772>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rax
cmp    %rsi,%rbx
je     1910 <scale_internal_ushort+0x7f0>
test   %r14d,%r14d
je     18d0 <scale_internal_ushort+0x7b0>
mov    0x4(%rax),%ecx
shl    $0x8,%ecx
or     (%rax),%ecx
jmp    18d2 <scale_internal_ushort+0x7b2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x1c(%rsp),%ecx
mov    %ecx,%eax
cmp    0x40(%rsp),%ecx
jl     193d <scale_internal_ushort+0x81d>
jmp    1b80 <scale_internal_ushort+0xa60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
cmp    0x40(%rsp),%eax
je     1ad0 <scale_internal_ushort+0x9b0>
add    %r11,%r15
add    %r11,%r10
test   %r13d,%r13d
jle    1930 <scale_internal_ushort+0x810>
xor    %edi,%edi
jmp    1989 <scale_internal_ushort+0x869>
nopl   0x0(%rax)
mov    (%r15),%ecx
mov    (%r10),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
xorps  %xmm4,%xmm4
cvtsi2ss %esi,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm2,%xmm0
addss  %xmm4,%xmm0
addss  (%rsp,%rdi,4),%xmm0
movss  %xmm0,(%rsp,%rdi,4)
add    $0x1,%rdi
add    %rdx,%r15
add    %rdx,%r10
cmp    %rdi,%rbx
je     1930 <scale_internal_ushort+0x810>
test   %r14d,%r14d
je     1950 <scale_internal_ushort+0x830>
mov    0x4(%r15),%ecx
shl    $0x8,%ecx
or     (%r15),%ecx
mov    0x4(%r10),%esi
shl    $0x8,%esi
or     (%r10),%esi
jmp    1956 <scale_internal_ushort+0x836>
test   %r13d,%r13d
jle    1ad0 <scale_internal_ushort+0x9b0>
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
movslq 0x2c(%rsp),%rax
add    0x60(%rsp),%rax
xor    %esi,%esi
jmp    19f7 <scale_internal_ushort+0x8d7>
cs 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    %rdx,%rax
cmp    %rsi,%rbx
je     1ad0 <scale_internal_ushort+0x9b0>
test   %r14d,%r14d
je     19d0 <scale_internal_ushort+0x8b0>
mov    0x4(%rax),%ecx
shl    $0x8,%ecx
or     (%rax),%ecx
jmp    19d2 <scale_internal_ushort+0x8b2>
mov    0x20(%rsp),%rax
lea    0x1(%rax),%edi
cmp    %r9d,%edi
jl     1a38 <scale_internal_ushort+0x918>
test   %r13d,%r13d
jle    1ad0 <scale_internal_ushort+0x9b0>
movaps %xmm6,%xmm2
mulss  %xmm3,%xmm2
add    %r8,%rbp
xor    %esi,%esi
jmp    1ab4 <scale_internal_ushort+0x994>
nopl   (%rax)
add    $0x1,%edi
cmp    %r9d,%edi
je     1a13 <scale_internal_ushort+0x8f3>
add    %r8,%rbp
test   %r13d,%r13d
jle    1a30 <scale_internal_ushort+0x910>
xor    %esi,%esi
mov    %rbp,%rax
jmp    1a73 <scale_internal_ushort+0x953>
nopw   0x0(%rax,%rax,1)
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    %rdx,%rax
cmp    %rsi,%rbx
je     1a30 <scale_internal_ushort+0x910>
test   %r14d,%r14d
je     1a50 <scale_internal_ushort+0x930>
mov    0x4(%rax),%ecx
shl    $0x8,%ecx
or     (%rax),%ecx
jmp    1a52 <scale_internal_ushort+0x932>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rbp
cmp    %rsi,%rbx
je     1ad0 <scale_internal_ushort+0x9b0>
test   %r14d,%r14d
je     1a90 <scale_internal_ushort+0x970>
mov    0x4(%rbp),%eax
shl    $0x8,%eax
or     0x0(%rbp),%eax
jmp    1a93 <scale_internal_ushort+0x973>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x1c(%rsp),%eax
cmp    0x40(%rsp),%eax
jge    1b80 <scale_internal_ushort+0xa60>
movslq 0x2c(%rsp),%r10
add    0xf8(%rsp),%r10
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
mov    0x1c(%rsp),%r15d
jmp    1b0e <scale_internal_ushort+0x9ee>
nop
add    %r11,%r10
add    $0x1,%r15d
cmp    0x40(%rsp),%r15d
je     1b80 <scale_internal_ushort+0xa60>
cmp    %r9d,0x20(%rsp)
jge    1b00 <scale_internal_ushort+0x9e0>
mov    0x20(%rsp),%rax
mov    %eax,%esi
mov    %r10,%rbp
jmp    1b3b <scale_internal_ushort+0xa1b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %r8,%rbp
add    $0x1,%esi
cmp    %r9d,%esi
je     1b00 <scale_internal_ushort+0x9e0>
test   %r13d,%r13d
jle    1b30 <scale_internal_ushort+0xa10>
xor    %ecx,%ecx
mov    %rbp,%rax
jmp    1b6f <scale_internal_ushort+0xa4f>
nopw   0x0(%rax,%rax,1)
mov    (%rax),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
add    $0x1,%rcx
add    %rdx,%rax
cmp    %rcx,%rbx
je     1b30 <scale_internal_ushort+0xa10>
test   %r14d,%r14d
je     1b50 <scale_internal_ushort+0xa30>
mov    0x4(%rax),%edi
shl    $0x8,%edi
or     (%rax),%edi
jmp    1b52 <scale_internal_ushort+0xa32>
xchg   %ax,%ax
test   %r13d,%r13d
mov    0x40(%rsp),%r10
mov    0x120(%rsp),%r15
mov    0x118(%rsp),%rbp
jle    1c7a <scale_internal_ushort+0xb5a>
cmp    $0x4,%r13d
jae    1bb0 <scale_internal_ushort+0xa90>
xor    %eax,%eax
jmp    1c60 <scale_internal_ushort+0xb40>
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0xe8(%rsp)
je     1cab <scale_internal_ushort+0xb8b>
mov    0xd8(%rsp),%rcx
xor    %eax,%eax
mov    0xa0(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps (%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
cvttps2dq %xmm0,%xmm0
movups %xmm0,-0x10(%rsi,%rax,4)
movaps 0x10(%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
cvttps2dq %xmm0,%xmm0
movups %xmm0,(%rsi,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1be0 <scale_internal_ushort+0xac0>
testb  $0x1,0xe0(%rsp)
01
je     1c45 <scale_internal_ushort+0xb25>
mov    0xd0(%rsp),%rcx
add    %r15,%rcx
imul   0xc8(%rsp),%rcx
movaps (%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
cvttps2dq %xmm0,%xmm0
add    %rax,%rcx
mov    0x160(%rsp),%rax
movups %xmm0,(%rax,%rcx,4)
mov    0xf0(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     1c7a <scale_internal_ushort+0xb5a>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rsp,%rax,4),%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%ecx
mov    %ecx,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1c60 <scale_internal_ushort+0xb40>
movaps %xmm11,%xmm4
addss  %xmm3,%xmm4
xor    %ecx,%ecx
ucomiss %xmm10,%xmm4
mov    0x68(%rsp),%rax
lea    (%r9,%rax,1),%eax
seta   %sil
movaps %xmm4,%xmm2
addss  %xmm9,%xmm2
ja     1450 <scale_internal_ushort+0x330>
movaps %xmm4,%xmm2
jmp    1450 <scale_internal_ushort+0x330>
xor    %eax,%eax
testb  $0x1,0xe0(%rsp)
01
jne    1c16 <scale_internal_ushort+0xaf6>
jmp    1c45 <scale_internal_ushort+0xb25>
nopl   (%rax)
movaps %xmm12,%xmm2
addss  %xmm5,%xmm2
xor    %ecx,%ecx
ucomiss %xmm10,%xmm2
mov    0x78(%rsp),%rax
lea    (%r10,%rax,1),%eax
seta   %sil
movaps %xmm2,%xmm3
addss  %xmm9,%xmm3
ja     1340 <scale_internal_ushort+0x220>
movaps %xmm2,%xmm3
jmp    1340 <scale_internal_ushort+0x220>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @scale_internal_ushort(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_ushort(i32 %0, i32 %1, i32 %2, i32* %3, i32* %6, i32 %7, i32 %8, i32 %9, i32 %10)
br label %648
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 %648
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 %63, 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, %638
%81 = phi i64 [ 0, %36 ], [ %646, %638 ]
%82 = phi float [ %30, %36 ], [ %645, %638 ]
%83 = phi float [ 0.000000e+00, %36 ], [ %82, %638 ]
%84 = phi i32 [ %28, %36 ], [ %644, %638 ]
%85 = phi i32 [ 0, %36 ], [ %87, %638 ]
%86 = icmp slt i32 %84, %2
%87 = select i1 %86, i32 %84, i32 %37
br i1 %38, label %88, label %638
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, %628
%106 = phi i64 [ 0, %88 ], [ %636, %628 ]
%107 = phi float [ %33, %88 ], [ %635, %628 ]
%108 = phi float [ 0.000000e+00, %88 ], [ %107, %628 ]
%109 = phi i32 [ %31, %88 ], [ %634, %628 ]
%110 = phi i32 [ 0, %88 ], [ %109, %628 ]
%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 %334
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 %142
120: ; preds = %114, %133
%121 = phi i64 [ %139, %133 ], [ 0, %114 ]
%122 = phi i8* [ %140, %133 ], [ %117, %114 ]
%123 = bitcast i8* %122 to i32*
br i1 %41, label %131, label %124
124: ; preds = %120
%125 = getelementptr inbounds i8, i8* %122, i64 4
%126 = bitcast i8* %125 to i32*
%127 = load i32, i32* %126
%128 = shl i32 %127, 8
%129 = load i32, i32* %123
%130 = or i32 %128, %129
br label %133
131: ; preds = %120
%132 = load i32, i32* %123
br label %133
133: ; preds = %124, %131
%134 = phi i32 [ %130, %124 ], [ %132, %131 ]
%135 = sitofp i32 %134 to float
%136 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %121
%137 = load float, float* %136
%138 = tail call float @llvm.fmuladd.f32(float %135, float %119, float %137)
store float %138, float* %136
%139 = add nuw nsw i64 %121, 1
%140 = getelementptr inbounds i8, i8* %122, i64 %42
%141 = icmp eq i64 %139, %57
br i1 %141, label %142, label %120
142: ; preds = %133, %114
%143 = add nsw i32 %110, 1
%144 = icmp slt i32 %143, %109
br i1 %144, label %145, label %174
145: ; preds = %142, %171
%146 = phi i32 [ %172, %171 ], [ %143, %142 ]
%147 = phi i8* [ %148, %171 ], [ %117, %142 ]
%148 = getelementptr inbounds i8, i8* %147, i64 %43
br i1 %40, label %149, label %171
149: ; preds = %145, %162
%150 = phi i64 [ %168, %162 ], [ 0, %145 ]
%151 = phi i8* [ %169, %162 ], [ %148, %145 ]
%152 = bitcast i8* %151 to i32*
br i1 %41, label %160, label %153
153: ; preds = %149
%154 = getelementptr inbounds i8, i8* %151, i64 4
%155 = bitcast i8* %154 to i32*
%156 = load i32, i32* %155
%157 = shl i32 %156, 8
%158 = load i32, i32* %152
%159 = or i32 %157, %158
br label %162
160: ; preds = %149
%161 = load i32, i32* %152
br label %162
162: ; preds = %153, %160
%163 = phi i32 [ %159, %153 ], [ %161, %160 ]
%164 = sitofp i32 %163 to float
%165 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %150
%166 = load float, float* %165
%167 = tail call float @llvm.fmuladd.f32(float %164, float %93, float %166)
store float %167, float* %165
%168 = add nuw nsw i64 %150, 1
%169 = getelementptr inbounds i8, i8* %151, i64 %42
%170 = icmp eq i64 %168, %58
br i1 %170, label %171, label %149
171: ; preds = %162, %145
%172 = add nsw i32 %146, 1
%173 = icmp eq i32 %172, %109
br i1 %173, label %174, label %145
174: ; preds = %171, %142
%175 = phi i8* [ %117, %142 ], [ %148, %171 ]
%176 = getelementptr inbounds i8, i8* %175, i64 %43
%177 = fmul float %93, %107
br i1 %40, label %180, label %178
178: ; preds = %174
%179 = getelementptr inbounds i8, i8* %116, i64 %97
br label %205
180: ; preds = %174, %193
%181 = phi i64 [ %199, %193 ], [ 0, %174 ]
%182 = phi i8* [ %200, %193 ], [ %176, %174 ]
%183 = bitcast i8* %182 to i32*
br i1 %41, label %191, label %184
184: ; preds = %180
%185 = getelementptr inbounds i8, i8* %182, i64 4
%186 = bitcast i8* %185 to i32*
%187 = load i32, i32* %186
%188 = shl i32 %187, 8
%189 = load i32, i32* %183
%190 = or i32 %188, %189
br label %193
191: ; preds = %180
%192 = load i32, i32* %183
br label %193
193: ; preds = %184, %191
%194 = phi i32 [ %190, %184 ], [ %192, %191 ]
%195 = sitofp i32 %194 to float
%196 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %181
%197 = load float, float* %196
%198 = tail call float @llvm.fmuladd.f32(float %195, float %177, float %197)
store float %198, float* %196
%199 = add nuw nsw i64 %181, 1
%200 = getelementptr inbounds i8, i8* %182, i64 %42
%201 = icmp eq i64 %199, %59
br i1 %201, label %202, label %180
202: ; preds = %193
%203 = fmul float %82, %118
%204 = getelementptr inbounds i8, i8* %116, i64 %97
br i1 %40, label %207, label %205
205: ; preds = %220, %178, %202
%206 = phi i8* [ %179, %178 ], [ %204, %202 ], [ %204, %220 ]
br i1 %144, label %229, label %258
207: ; preds = %202, %220
%208 = phi i64 [ %226, %220 ], [ 0, %202 ]
%209 = phi i8* [ %227, %220 ], [ %204, %202 ]
%210 = bitcast i8* %209 to i32*
br i1 %41, label %218, label %211
211: ; preds = %207
%212 = getelementptr inbounds i8, i8* %209, i64 4
%213 = bitcast i8* %212 to i32*
%214 = load i32, i32* %213
%215 = shl i32 %214, 8
%216 = load i32, i32* %210
%217 = or i32 %215, %216
br label %220
218: ; preds = %207
%219 = load i32, i32* %210
br label %220
220: ; preds = %211, %218
%221 = phi i32 [ %217, %211 ], [ %219, %218 ]
%222 = sitofp i32 %221 to float
%223 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %208
%224 = load float, float* %223
%225 = tail call float @llvm.fmuladd.f32(float %222, float %203, float %224)
store float %225, float* %223
%226 = add nuw nsw i64 %208, 1
%227 = getelementptr inbounds i8, i8* %209, i64 %42
%228 = icmp eq i64 %226, %60
br i1 %228, label %205, label %207
229: ; preds = %205, %255
%230 = phi i32 [ %256, %255 ], [ %143, %205 ]
%231 = phi i8* [ %232, %255 ], [ %206, %205 ]
%232 = getelementptr inbounds i8, i8* %231, i64 %43
br i1 %40, label %233, label %255
233: ; preds = %229, %246
%234 = phi i64 [ %252, %246 ], [ 0, %229 ]
%235 = phi i8* [ %253, %246 ], [ %232, %229 ]
%236 = bitcast i8* %235 to i32*
br i1 %41, label %244, label %237
237: ; preds = %233
%238 = getelementptr inbounds i8, i8* %235, i64 4
%239 = bitcast i8* %238 to i32*
%240 = load i32, i32* %239
%241 = shl i32 %240, 8
%242 = load i32, i32* %236
%243 = or i32 %241, %242
br label %246
244: ; preds = %233
%245 = load i32, i32* %236
br label %246
246: ; preds = %237, %244
%247 = phi i32 [ %243, %237 ], [ %245, %244 ]
%248 = sitofp i32 %247 to float
%249 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %234
%250 = load float, float* %249
%251 = tail call float @llvm.fmuladd.f32(float %248, float %82, float %250)
store float %251, float* %249
%252 = add nuw nsw i64 %234, 1
%253 = getelementptr inbounds i8, i8* %235, i64 %42
%254 = icmp eq i64 %252, %61
br i1 %254, label %255, label %233
255: ; preds = %246, %229
%256 = add nsw i32 %230, 1
%257 = icmp eq i32 %256, %109
br i1 %257, label %258, label %229
258: ; preds = %255, %205
%259 = phi i8* [ %206, %205 ], [ %232, %255 ]
%260 = fmul float %82, %107
br i1 %40, label %261, label %263
261: ; preds = %258
%262 = getelementptr inbounds i8, i8* %259, i64 %43
br label %264
263: ; preds = %277, %258
br i1 %95, label %291, label %576
264: ; preds = %261, %277
%265 = phi i64 [ 0, %261 ], [ %283, %277 ]
%266 = phi i8* [ %262, %261 ], [ %284, %277 ]
%267 = bitcast i8* %266 to i32*
br i1 %41, label %275, label %268
268: ; preds = %264
%269 = getelementptr inbounds i8, i8* %266, i64 4
%270 = bitcast i8* %269 to i32*
%271 = load i32, i32* %270
%272 = shl i32 %271, 8
%273 = load i32, i32* %267
%274 = or i32 %272, %273
br label %277
275: ; preds = %264
%276 = load i32, i32* %267
br label %277
277: ; preds = %268, %275
%278 = phi i32 [ %274, %268 ], [ %276, %275 ]
%279 = sitofp i32 %278 to float
%280 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %265
%281 = load float, float* %280
%282 = tail call float @llvm.fmuladd.f32(float %279, float %260, float %281)
store float %282, float* %280
%283 = add nuw nsw i64 %265, 1
%284 = getelementptr inbounds i8, i8* %266, i64 %42
%285 = icmp eq i64 %283, %62
br i1 %285, label %263, label %264
286: ; preds = %320, %291
%287 = phi i8* [ %295, %291 ], [ %331, %320 ]
%288 = phi i8* [ %296, %291 ], [ %332, %320 ]
%289 = add nsw i32 %292, 1
%290 = icmp eq i32 %289, %87
br i1 %290, label %534, label %291
291: ; preds = %263, %286
%292 = phi i32 [ %289, %286 ], [ %94, %263 ]
%293 = phi i8* [ %288, %286 ], [ %176, %263 ]
%294 = phi i8* [ %287, %286 ], [ %117, %263 ]
%295 = getelementptr inbounds i8, i8* %294, i64 %44
%296 = getelementptr inbounds i8, i8* %293, i64 %44
br i1 %40, label %297, label %286
297: ; preds = %291, %320
%298 = phi i64 [ %330, %320 ], [ 0, %291 ]
%299 = phi i8* [ %332, %320 ], [ %296, %291 ]
%300 = phi i8* [ %331, %320 ], [ %295, %291 ]
%301 = bitcast i8* %300 to i32*
br i1 %41, label %316, label %302
302: ; preds = %297
%303 = getelementptr inbounds i8, i8* %300, i64 4
%304 = bitcast i8* %303 to i32*
%305 = load i32, i32* %304
%306 = shl i32 %305, 8
%307 = load i32, i32* %301
%308 = or i32 %306, %307
%309 = bitcast i8* %299 to i32*
%310 = getelementptr inbounds i8, i8* %299, i64 4
%311 = bitcast i8* %310 to i32*
%312 = load i32, i32* %311
%313 = shl i32 %312, 8
%314 = load i32, i32* %309
%315 = or i32 %313, %314
br label %320
316: ; preds = %297
%317 = load i32, i32* %301
%318 = bitcast i8* %299 to i32*
%319 = load i32, i32* %318
br label %320
320: ; preds = %302, %316
%321 = phi i32 [ %315, %302 ], [ %319, %316 ]
%322 = phi i32 [ %308, %302 ], [ %317, %316 ]
%323 = sitofp i32 %322 to float
%324 = sitofp i32 %321 to float
%325 = fmul float %107, %324
%326 = tail call float @llvm.fmuladd.f32(float %323, float %118, float %325)
%327 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %298
%328 = load float, float* %327
%329 = fadd float %328, %326
store float %329, float* %327
%330 = add nuw nsw i64 %298, 1
%331 = getelementptr inbounds i8, i8* %300, i64 %42
%332 = getelementptr inbounds i8, i8* %299, i64 %42
%333 = icmp eq i64 %330, %63
br i1 %333, label %286, label %297
334: ; preds = %105
br i1 %89, label %335, label %419
335: ; preds = %334
%336 = fsub float %107, %108
%337 = fmul float %93, %336
%338 = sext i32 %111 to i64
%339 = getelementptr inbounds i8, i8* %103, i64 %338
br i1 %40, label %341, label %340
340: ; preds = %354, %335
br i1 %95, label %366, label %392
341: ; preds = %335, %354
%342 = phi i64 [ %360, %354 ], [ 0, %335 ]
%343 = phi i8* [ %361, %354 ], [ %339, %335 ]
%344 = bitcast i8* %343 to i32*
br i1 %41, label %352, label %345
345: ; preds = %341
%346 = getelementptr inbounds i8, i8* %343, i64 4
%347 = bitcast i8* %346 to i32*
%348 = load i32, i32* %347
%349 = shl i32 %348, 8
%350 = load i32, i32* %344
%351 = or i32 %349, %350
br label %354
352: ; preds = %341
%353 = load i32, i32* %344
br label %354
354: ; preds = %345, %352
%355 = phi i32 [ %351, %345 ], [ %353, %352 ]
%356 = sitofp i32 %355 to float
%357 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %342
%358 = load float, float* %357
%359 = tail call float @llvm.fmuladd.f32(float %356, float %337, float %358)
store float %359, float* %357
%360 = add nuw nsw i64 %342, 1
%361 = getelementptr inbounds i8, i8* %343, i64 %42
%362 = icmp eq i64 %360, %54
br i1 %362, label %340, label %341
363: ; preds = %383, %366
%364 = add nsw i32 %367, 1
%365 = icmp eq i32 %364, %87
br i1 %365, label %392, label %366
366: ; preds = %340, %363
%367 = phi i32 [ %364, %363 ], [ %94, %340 ]
%368 = phi i8* [ %369, %363 ], [ %339, %340 ]
%369 = getelementptr inbounds i8, i8* %368, i64 %44
br i1 %40, label %370, label %363
370: ; preds = %366, %383
%371 = phi i64 [ %389, %383 ], [ 0, %366 ]
%372 = phi i8* [ %390, %383 ], [ %369, %366 ]
%373 = bitcast i8* %372 to i32*
br i1 %41, label %381, label %374
374: ; preds = %370
%375 = getelementptr inbounds i8, i8* %372, i64 4
%376 = bitcast i8* %375 to i32*
%377 = load i32, i32* %376
%378 = shl i32 %377, 8
%379 = load i32, i32* %373
%380 = or i32 %378, %379
br label %383
381: ; preds = %370
%382 = load i32, i32* %373
br label %383
383: ; preds = %374, %381
%384 = phi i32 [ %380, %374 ], [ %382, %381 ]
%385 = sitofp i32 %384 to float
%386 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %371
%387 = load float, float* %386
%388 = tail call float @llvm.fmuladd.f32(float %385, float %336, float %387)
store float %388, float* %386
%389 = add nuw nsw i64 %371, 1
%390 = getelementptr inbounds i8, i8* %372, i64 %42
%391 = icmp eq i64 %389, %55
br i1 %391, label %363, label %370
392: ; preds = %363, %340
%393 = phi i8* [ %339, %340 ], [ %369, %363 ]
%394 = fmul float %82, %336
br i1 %40, label %395, label %534
395: ; preds = %392
%396 = getelementptr inbounds i8, i8* %393, i64 %44
br label %397
397: ; preds = %395, %410
%398 = phi i64 [ 0, %395 ], [ %416, %410 ]
%399 = phi i8* [ %396, %395 ], [ %417, %410 ]
%400 = bitcast i8* %399 to i32*
br i1 %41, label %408, label %401
401: ; preds = %397
%402 = getelementptr inbounds i8, i8* %399, i64 4
%403 = bitcast i8* %402 to i32*
%404 = load i32, i32* %403
%405 = shl i32 %404, 8
%406 = load i32, i32* %400
%407 = or i32 %405, %406
br label %410
408: ; preds = %397
%409 = load i32, i32* %400
br label %410
410: ; preds = %401, %408
%411 = phi i32 [ %407, %401 ], [ %409, %408 ]
%412 = sitofp i32 %411 to float
%413 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %398
%414 = load float, float* %413
%415 = tail call float @llvm.fmuladd.f32(float %412, float %394, float %414)
store float %415, float* %413
%416 = add nuw nsw i64 %398, 1
%417 = getelementptr inbounds i8, i8* %399, i64 %42
%418 = icmp eq i64 %416, %56
br i1 %418, label %534, label %397
419: ; preds = %334
br i1 %112, label %420, label %506
420: ; preds = %419
%421 = fsub float 1.000000e+00, %108
%422 = fmul float %90, %421
%423 = sext i32 %111 to i64
%424 = getelementptr inbounds i8, i8* %102, i64 %423
br i1 %40, label %428, label %425
425: ; preds = %441, %420
%426 = add nsw i32 %110, 1
%427 = icmp slt i32 %426, %109
br i1 %427, label %453, label %479
428: ; preds = %420, %441
%429 = phi i64 [ %447, %441 ], [ 0, %420 ]
%430 = phi i8* [ %448, %441 ], [ %424, %420 ]
%431 = bitcast i8* %430 to i32*
br i1 %41, label %439, label %432
432: ; preds = %428
%433 = getelementptr inbounds i8, i8* %430, i64 4
%434 = bitcast i8* %433 to i32*
%435 = load i32, i32* %434
%436 = shl i32 %435, 8
%437 = load i32, i32* %431
%438 = or i32 %436, %437
br label %441
439: ; preds = %428
%440 = load i32, i32* %431
br label %441
441: ; preds = %432, %439
%442 = phi i32 [ %438, %432 ], [ %440, %439 ]
%443 = sitofp i32 %442 to float
%444 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %429
%445 = load float, float* %444
%446 = tail call float @llvm.fmuladd.f32(float %443, float %422, float %445)
store float %446, float* %444
%447 = add nuw nsw i64 %429, 1
%448 = getelementptr inbounds i8, i8* %430, i64 %42
%449 = icmp eq i64 %447, %51
br i1 %449, label %425, label %428
450: ; preds = %470, %453
%451 = add nsw i32 %454, 1
%452 = icmp eq i32 %451, %109
br i1 %452, label %479, label %453
453: ; preds = %425, %450
%454 = phi i32 [ %451, %450 ], [ %426, %425 ]
%455 = phi i8* [ %456, %450 ], [ %424, %425 ]
%456 = getelementptr inbounds i8, i8* %455, i64 %43
br i1 %40, label %457, label %450
457: ; preds = %453, %470
%458 = phi i64 [ %476, %470 ], [ 0, %453 ]
%459 = phi i8* [ %477, %470 ], [ %456, %453 ]
%460 = bitcast i8* %459 to i32*
br i1 %41, label %468, label %461
461: ; preds = %457
%462 = getelementptr inbounds i8, i8* %459, i64 4
%463 = bitcast i8* %462 to i32*
%464 = load i32, i32* %463
%465 = shl i32 %464, 8
%466 = load i32, i32* %460
%467 = or i32 %465, %466
br label %470
468: ; preds = %457
%469 = load i32, i32* %460
br label %470
470: ; preds = %461, %468
%471 = phi i32 [ %467, %461 ], [ %469, %468 ]
%472 = sitofp i32 %471 to float
%473 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %458
%474 = load float, float* %473
%475 = tail call float @llvm.fmuladd.f32(float %472, float %90, float %474)
store float %475, float* %473
%476 = add nuw nsw i64 %458, 1
%477 = getelementptr inbounds i8, i8* %459, i64 %42
%478 = icmp eq i64 %476, %52
br i1 %478, label %450, label %457
479: ; preds = %450, %425
%480 = phi i8* [ %424, %425 ], [ %456, %450 ]
%481 = fmul float %90, %107
br i1 %40, label %482, label %534
482: ; preds = %479
%483 = getelementptr inbounds i8, i8* %480, i64 %43
br label %484
484: ; preds = %482, %497
%485 = phi i64 [ 0, %482 ], [ %503, %497 ]
%486 = phi i8* [ %483, %482 ], [ %504, %497 ]
%487 = bitcast i8* %486 to i32*
br i1 %41, label %495, label %488
488: ; preds = %484
%489 = getelementptr inbounds i8, i8* %486, i64 4
%490 = bitcast i8* %489 to i32*
%491 = load i32, i32* %490
%492 = shl i32 %491, 8
%493 = load i32, i32* %487
%494 = or i32 %492, %493
br label %497
495: ; preds = %484
%496 = load i32, i32* %487
br label %497
497: ; preds = %488, %495
%498 = phi i32 [ %494, %488 ], [ %496, %495 ]
%499 = sitofp i32 %498 to float
%500 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %485
%501 = load float, float* %500
%502 = tail call float @llvm.fmuladd.f32(float %499, float %481, float %501)
store float %502, float* %500
%503 = add nuw nsw i64 %485, 1
%504 = getelementptr inbounds i8, i8* %486, i64 %42
%505 = icmp eq i64 %503, %53
br i1 %505, label %534, label %484
506: ; preds = %419
%507 = fsub float %107, %108
%508 = fmul float %90, %507
br i1 %40, label %509, label %534
509: ; preds = %506
%510 = sext i32 %111 to i64
%511 = getelementptr inbounds i8, i8* %101, i64 %510
br label %512
512: ; preds = %509, %525
%513 = phi i64 [ 0, %509 ], [ %531, %525 ]
%514 = phi i8* [ %511, %509 ], [ %532, %525 ]
%515 = bitcast i8* %514 to i32*
br i1 %41, label %523, label %516
516: ; preds = %512
%517 = getelementptr inbounds i8, i8* %514, i64 4
%518 = bitcast i8* %517 to i32*
%519 = load i32, i32* %518
%520 = shl i32 %519, 8
%521 = load i32, i32* %515
%522 = or i32 %520, %521
br label %525
523: ; preds = %512
%524 = load i32, i32* %515
br label %525
525: ; preds = %516, %523
%526 = phi i32 [ %522, %516 ], [ %524, %523 ]
%527 = sitofp i32 %526 to float
%528 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %513
%529 = load float, float* %528
%530 = tail call float @llvm.fmuladd.f32(float %527, float %508, float %529)
store float %530, float* %528
%531 = add nuw nsw i64 %513, 1
%532 = getelementptr inbounds i8, i8* %514, i64 %42
%533 = icmp eq i64 %531, %50
br i1 %533, label %534, label %512
534: ; preds = %525, %497, %410, %286, %506, %479, %392
br i1 %95, label %535, label %576
535: ; preds = %534
%536 = sext i32 %111 to i64
%537 = getelementptr inbounds i8, i8* %104, i64 %536
%538 = add nsw i32 %110, 1
%539 = icmp slt i32 %538, %109
br label %540
540: ; preds = %535, %572
%541 = phi i32 [ %94, %535 ], [ %574, %572 ]
%542 = phi i8* [ %537, %535 ], [ %573, %572 ]
br i1 %539, label %543, label %572
543: ; preds = %540, %568
%544 = phi i32 [ %570, %568 ], [ %538, %540 ]
%545 = phi i8* [ %569, %568 ], [ %542, %540 ]
br i1 %40, label %546, label %568
546: ; preds = %543, %559
%547 = phi i64 [ %565, %559 ], [ 0, %543 ]
%548 = phi i8* [ %566, %559 ], [ %545, %543 ]
%549 = bitcast i8* %548 to i32*
br i1 %41, label %557, label %550
550: ; preds = %546
%551 = getelementptr inbounds i8, i8* %548, i64 4
%552 = bitcast i8* %551 to i32*
%553 = load i32, i32* %552
%554 = shl i32 %553, 8
%555 = load i32, i32* %549
%556 = or i32 %554, %555
br label %559
557: ; preds = %546
%558 = load i32, i32* %549
br label %559
559: ; preds = %550, %557
%560 = phi i32 [ %556, %550 ], [ %558, %557 ]
%561 = sitofp i32 %560 to float
%562 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %547
%563 = load float, float* %562
%564 = fadd float %563, %561
store float %564, float* %562
%565 = add nuw nsw i64 %547, 1
%566 = getelementptr inbounds i8, i8* %548, i64 %42
%567 = icmp eq i64 %565, %65
br i1 %567, label %568, label %546
568: ; preds = %559, %543
%569 = getelementptr inbounds i8, i8* %545, i64 %43
%570 = add nsw i32 %544, 1
%571 = icmp eq i32 %570, %109
br i1 %571, label %572, label %543
572: ; preds = %568, %540
%573 = getelementptr inbounds i8, i8* %542, i64 %44
%574 = add nsw i32 %541, 1
%575 = icmp eq i32 %574, %87
br i1 %575, label %576, label %540
576: ; preds = %572, %263, %534
%577 = add nsw i64 %106, %100
%578 = mul nsw i64 %577, %45
br i1 %40, label %579, label %628
579: ; preds = %576
br i1 %71, label %616, label %580
580: ; preds = %579
br i1 %76, label %604, label %581
581: ; preds = %580, %581
%582 = phi i64 [ %601, %581 ], [ 0, %580 ]
%583 = phi i64 [ %602, %581 ], [ 0, %580 ]
%584 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %582
%585 = bitcast float* %584 to <4 x float>*
%586 = load <4 x float>, <4 x float>* %585
%587 = fdiv <4 x float> %586, %74
%588 = fptosi <4 x float> %587 to <4 x i32>
%589 = add nsw i64 %582, %578
%590 = getelementptr inbounds i32, i32* %6, i64 %589
%591 = bitcast i32* %590 to <4 x i32>*
store <4 x i32> %588, <4 x i32>* %591
%592 = or i64 %582, 4
%593 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %592
%594 = bitcast float* %593 to <4 x float>*
%595 = load <4 x float>, <4 x float>* %594
%596 = fdiv <4 x float> %595, %74
%597 = fptosi <4 x float> %596 to <4 x i32>
%598 = add nsw i64 %592, %578
%599 = getelementptr inbounds i32, i32* %6, i64 %598
%600 = bitcast i32* %599 to <4 x i32>*
store <4 x i32> %597, <4 x i32>* %600
%601 = add nuw i64 %582, 8
%602 = add i64 %583, 2
%603 = icmp eq i64 %602, %77
br i1 %603, label %604, label %581
604: ; preds = %581, %580
%605 = phi i64 [ 0, %580 ], [ %601, %581 ]
br i1 %78, label %615, label %606
606: ; preds = %604
%607 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %605
%608 = bitcast float* %607 to <4 x float>*
%609 = load <4 x float>, <4 x float>* %608
%610 = fdiv <4 x float> %609, %74
%611 = fptosi <4 x float> %610 to <4 x i32>
%612 = add nsw i64 %605, %578
%613 = getelementptr inbounds i32, i32* %6, i64 %612
%614 = bitcast i32* %613 to <4 x i32>*
store <4 x i32> %611, <4 x i32>* %614
br label %615
615: ; preds = %604, %606
br i1 %79, label %628, label %616
616: ; preds = %579, %615
%617 = phi i64 [ 0, %579 ], [ %72, %615 ]
br label %618
618: ; preds = %616, %618
%619 = phi i64 [ %626, %618 ], [ %617, %616 ]
%620 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0, i64 %619
%621 = load float, float* %620
%622 = fdiv float %621, %34
%623 = fptosi float %622 to i32
%624 = add nsw i64 %619, %578
%625 = getelementptr inbounds i32, i32* %6, i64 %624
store i32 %623, i32* %625
%626 = add nuw nsw i64 %619, 1
%627 = icmp eq i64 %626, %66
br i1 %627, label %628, label %618
628: ; preds = %618, %615, %576
%629 = add nsw i32 %109, %31
%630 = fadd float %33, %107
%631 = fcmp ogt float %630, 1.000000e+00
%632 = fadd float %630, -1.000000e+00
%633 = zext i1 %631 to i32
%634 = add nsw i32 %629, %633
%635 = select i1 %631, float %632, float %630
%636 = add nuw nsw i64 %106, 1
%637 = icmp eq i64 %636, %48
br i1 %637, label %638, label %105
638: ; preds = %628, %80
%639 = add nsw i32 %87, %28
%640 = fadd float %30, %82
%641 = fcmp ogt float %640, 1.000000e+00
%642 = fadd float %640, -1.000000e+00
%643 = zext i1 %641 to i32
%644 = add nsw i32 %639, %643
%645 = select i1 %641, float %642, float %640
%646 = add nuw nsw i64 %81, 1
%647 = icmp eq i64 %646, %47
br i1 %647, label %648, label %80
648: ; preds = %638, %21, %19
ret void
}