#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 float GLshort;
typedef int GLint;

/* Variables and functions */
int floor(float);
int /*<<< orphan*/ halveImage_short(int, int, int, float const *, float *, int,
                                    int, int, int);
void scale_internal_short(GLint components, GLint widthin, GLint heightin,
                          const GLshort *datain, GLint widthout,
                          GLint heightout, GLshort *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;
  GLushort swapbuf;
  if (widthin == widthout * 2 && heightin == heightout * 2) {
    halveImage_short(components, widthin, heightin, (const GLshort *)datain,
                     (GLshort *)dataout, element_size, ysize, group_size,
                     myswap_bytes);
    return;
  }
  convy = (float)heightin / heightout;
  convx = (float)widthin / widthout;
  convy_int = floor(convy);
  convy_float = convy - convy_int;
  convx_int = floor(convx);
  convx_float = convx - convx_int;
  area = convx * convy;
  lowy_int = 0;
  lowy_float = 0;
  highy_int = convy_int;
  highy_float = convy_float;
  for (i = 0; i < heightout; i++) {
    if (highy_int >= heightin)
      highy_int = heightin - 1;
    lowx_int = 0;
    lowx_float = 0;
    highx_int = convx_int;
    highx_float = convx_float;
    for (j = 0; j < widthout; j++) {
      totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
      xindex = lowx_int * group_size;
      if ((highy_int > lowy_int) && (highx_int > lowx_int)) {
        y_percent = 1 - lowy_float;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        percent = y_percent * (1 - lowx_float);
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
        left = temp;
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf =
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLshort *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLshort *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        right = temp;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
        y_percent = highy_float;
        percent = y_percent * (1 - lowx_float);
        temp = (const char *)datain + xindex + highy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf =
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLshort *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLshort *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
        for (m = lowy_int + 1; m < highy_int; m++) {
          left += ysize;
          right += ysize;
          for (k = 0; k < components;
               k++, left += element_size, right += element_size) {
            if (myswap_bytes) {
              swapbuf =
                  (GLushort)(((GLushort)((const GLubyte *)(left))[1]) << 8 |
                             ((const GLubyte *)(left))[0]);
              totals[k] += *(const GLshort *)&swapbuf * (1 - lowx_float);
              swapbuf =
                  (GLushort)(((GLushort)((const GLubyte *)(right))[1]) << 8 |
                             ((const GLubyte *)(right))[0]);
              totals[k] += *(const GLshort *)&swapbuf * highx_float;
            } else {
              totals[k] += *(const GLshort *)left * (1 - lowx_float) +
                           *(const GLshort *)right * highx_float;
            }
          }
        }
      } else if (highy_int > lowy_int) {
        x_percent = highx_float - lowx_float;
        percent = (1 - lowy_float) * x_percent;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
        for (m = lowy_int + 1; m < highy_int; m++) {
          temp += ysize;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf =
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLshort *)&swapbuf * x_percent;
            } else {
              totals[k] += *(const GLshort *)temp_index * x_percent;
            }
          }
        }
        percent = x_percent * highy_float;
        temp += ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
      } else if (highx_int > lowx_int) {
        y_percent = highy_float - lowy_float;
        percent = (1 - lowx_float) * y_percent;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf =
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLshort *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLshort *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
      } else {
        percent = (highy_float - lowy_float) * (highx_float - lowx_float);
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf =
                (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLshort *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLshort *)temp_index * percent;
          }
        }
      }
      temp0 =
          (const char *)datain + xindex + group_size + (lowy_int + 1) * ysize;
      for (m = lowy_int + 1; m < highy_int; m++) {
        temp = temp0;
        for (l = lowx_int + 1; l < highx_int; l++) {
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf =
                  (GLushort)(((GLushort)((const GLubyte *)(temp_index))[1])
                                 << 8 |
                             ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLshort *)&swapbuf;
            } else {
              totals[k] += *(const GLshort *)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_short>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    11a9 <scale_internal_short+0x89>
mov    -0xc(%rbp),%eax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    11a9 <scale_internal_short+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_short@plt>
jmp    23f4 <scale_internal_short+0x12d4>
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    23f4 <scale_internal_short+0x12d4>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     128c <scale_internal_short+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    2352 <scale_internal_short+0x1232>
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    1a63 <scale_internal_short+0x943>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    1a63 <scale_internal_short+0x943>
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    1412 <scale_internal_short+0x2f2>
cmpl   $0x0,0x30(%rbp)
je     13c9 <scale_internal_short+0x2a9>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    13ee <scale_internal_short+0x2ce>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    13f3 <scale_internal_short+0x2d3>
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_short+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    1516 <scale_internal_short+0x3f6>
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    14fd <scale_internal_short+0x3dd>
cmpl   $0x0,0x30(%rbp)
je     14b1 <scale_internal_short+0x391>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    14d9 <scale_internal_short+0x3b9>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    14de <scale_internal_short+0x3be>
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    1458 <scale_internal_short+0x338>
jmp    1502 <scale_internal_short+0x3e2>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1429 <scale_internal_short+0x309>
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    15f5 <scale_internal_short+0x4d5>
cmpl   $0x0,0x30(%rbp)
je     15ac <scale_internal_short+0x48c>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    15d1 <scale_internal_short+0x4b1>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    15d6 <scale_internal_short+0x4b6>
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    1556 <scale_internal_short+0x436>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  0x19eb(%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    16f3 <scale_internal_short+0x5d3>
cmpl   $0x0,0x30(%rbp)
je     16aa <scale_internal_short+0x58a>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    16cf <scale_internal_short+0x5af>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    16d4 <scale_internal_short+0x5b4>
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    1654 <scale_internal_short+0x534>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    17ec <scale_internal_short+0x6cc>
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    17d3 <scale_internal_short+0x6b3>
cmpl   $0x0,0x30(%rbp)
je     1787 <scale_internal_short+0x667>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    17af <scale_internal_short+0x68f>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    17b4 <scale_internal_short+0x694>
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    172e <scale_internal_short+0x60e>
jmp    17d8 <scale_internal_short+0x6b8>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    16ff <scale_internal_short+0x5df>
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    18c0 <scale_internal_short+0x7a0>
cmpl   $0x0,0x30(%rbp)
je     1877 <scale_internal_short+0x757>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    189c <scale_internal_short+0x77c>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    18a1 <scale_internal_short+0x781>
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    1821 <scale_internal_short+0x701>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1a5e <scale_internal_short+0x93e>
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    1a45 <scale_internal_short+0x925>
cmpl   $0x0,0x30(%rbp)
je     19be <scale_internal_short+0x89e>
mov    -0xc0(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0xc0(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  0x16ab(%rip),%xmm2
subss  -0x90(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
mov    -0xc8(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0xc8(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1a04 <scale_internal_short+0x8e4>
mov    -0xc0(%rbp),%rax
movss  (%rax),%xmm0
movss  0x162f(%rip),%xmm2
subss  -0x90(%rbp),%xmm2
ff
mov    -0xc8(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1a09 <scale_internal_short+0x8e9>
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    1913 <scale_internal_short+0x7f3>
jmp    1a4a <scale_internal_short+0x92a>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    18cc <scale_internal_short+0x7ac>
jmp    2125 <scale_internal_short+0x1005>
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jle    1d46 <scale_internal_short+0xc26>
movss  -0x94(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  0x156e(%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    1b71 <scale_internal_short+0xa51>
cmpl   $0x0,0x30(%rbp)
je     1b28 <scale_internal_short+0xa08>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1b4d <scale_internal_short+0xa2d>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1b52 <scale_internal_short+0xa32>
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    1ad2 <scale_internal_short+0x9b2>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1c6d <scale_internal_short+0xb4d>
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    1c54 <scale_internal_short+0xb34>
cmpl   $0x0,0x30(%rbp)
je     1c08 <scale_internal_short+0xae8>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1c30 <scale_internal_short+0xb10>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1c35 <scale_internal_short+0xb15>
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    1baf <scale_internal_short+0xa8f>
jmp    1c59 <scale_internal_short+0xb39>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1b7d <scale_internal_short+0xa5d>
movss  -0x88(%rbp),%xmm0
ff
mulss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
mov    0x20(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1d41 <scale_internal_short+0xc21>
cmpl   $0x0,0x30(%rbp)
je     1cf8 <scale_internal_short+0xbd8>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1d1d <scale_internal_short+0xbfd>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1d22 <scale_internal_short+0xc02>
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    1ca2 <scale_internal_short+0xb82>
jmp    2120 <scale_internal_short+0x1000>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    2023 <scale_internal_short+0xf03>
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  0x128e(%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    1e51 <scale_internal_short+0xd31>
cmpl   $0x0,0x30(%rbp)
je     1e08 <scale_internal_short+0xce8>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1e2d <scale_internal_short+0xd0d>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1e32 <scale_internal_short+0xd12>
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    1db2 <scale_internal_short+0xc92>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1f4a <scale_internal_short+0xe2a>
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    1f31 <scale_internal_short+0xe11>
cmpl   $0x0,0x30(%rbp)
je     1ee5 <scale_internal_short+0xdc5>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1f0d <scale_internal_short+0xded>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1f12 <scale_internal_short+0xdf2>
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    1e8c <scale_internal_short+0xd6c>
jmp    1f36 <scale_internal_short+0xe16>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1e5d <scale_internal_short+0xd3d>
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    201e <scale_internal_short+0xefe>
cmpl   $0x0,0x30(%rbp)
je     1fd5 <scale_internal_short+0xeb5>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1ffa <scale_internal_short+0xeda>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1fff <scale_internal_short+0xedf>
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    1f7f <scale_internal_short+0xe5f>
jmp    211b <scale_internal_short+0xffb>
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    2116 <scale_internal_short+0xff6>
cmpl   $0x0,0x30(%rbp)
je     20cd <scale_internal_short+0xfad>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    20f2 <scale_internal_short+0xfd2>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    20f7 <scale_internal_short+0xfd7>
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    2077 <scale_internal_short+0xf57>
jmp    211b <scale_internal_short+0xffb>
jmp    2120 <scale_internal_short+0x1000>
jmp    2125 <scale_internal_short+0x1005>
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    226a <scale_internal_short+0x114a>
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    2245 <scale_internal_short+0x1125>
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2220 <scale_internal_short+0x1100>
cmpl   $0x0,0x30(%rbp)
je     21e4 <scale_internal_short+0x10c4>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0xcc(%rbp)
movss  -0xcc(%rbp),%xmm0
ff
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    21fc <scale_internal_short+0x10dc>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    2201 <scale_internal_short+0x10e1>
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    219b <scale_internal_short+0x107b>
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    217d <scale_internal_short+0x105d>
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    2157 <scale_internal_short+0x1037>
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    22bf <scale_internal_short+0x119f>
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
divss  -0x44(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2284 <scale_internal_short+0x1164>
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
movss  0xcf7(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    233f <scale_internal_short+0x121f>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xce2(%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    2344 <scale_internal_short+0x1224>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12be <scale_internal_short+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  0xc5b(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    23e1 <scale_internal_short+0x12c1>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xc46(%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    23e6 <scale_internal_short+0x12c6>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1265 <scale_internal_short+0x145>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_internal_short>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9d,%ebp
mov    %rcx,0x38(%rsp)
mov    0x1d0(%rsp),%r14d
mov    0x1b8(%rsp),%ebx
mov    %r8,0x50(%rsp)
lea    (%r8,%r8,1),%eax
cmp    %esi,%eax
jne    1194 <scale_internal_short+0x74>
lea    0x0(%rbp,%rbp,1),%eax
cmp    %edx,%eax
jne    1194 <scale_internal_short+0x74>
sub    $0x8,%rsp
mov    0x40(%rsp),%rcx
mov    0x1b8(%rsp),%r8
mov    %ebx,%r9d
push   %r14
mov    0x1d8(%rsp),%eax
push   %rax
mov    0x1d8(%rsp),%eax
push   %rax
call   1030 <halveImage_short@plt>
add    $0x198,%rsp
jmp    1e77 <scale_internal_short+0xd57>
mov    %rdx,0x80(%rsp)
cvtsi2ss %edx,%xmm0
cvtsi2ss %ebp,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,0x48(%rsp)
cvtsi2ss %esi,%xmm2
xorps  %xmm1,%xmm1
cvtsi2ssl 0x50(%rsp),%xmm1
divss  %xmm1,%xmm2
movaps %xmm2,0xc0(%rsp)
mov    %edi,0x34(%rsp)
call   1040 <floor@plt>
mov    %rax,0x78(%rsp)
movaps 0xc0(%rsp),%xmm0
call   1040 <floor@plt>
movaps 0xc0(%rsp),%xmm1
movss  0x48(%rsp),%xmm12
mov    0x34(%rsp),%r10d
mov    %rax,0x68(%rsp)
test   %ebp,%ebp
jle    1e70 <scale_internal_short+0xd50>
mov    0x78(%rsp),%r11
xorps  %xmm0,%xmm0
cvtsi2ss %r11d,%xmm0
xorps  %xmm2,%xmm2
cvtsi2ssl 0x68(%rsp),%xmm2
movaps %xmm1,%xmm11
subss  %xmm2,%xmm11
mulss  %xmm12,%xmm1
subss  %xmm0,%xmm12
mov    0x80(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x74(%rsp)
movslq %ebx,%rdx
mov    0x1c8(%rsp),%eax
movslq %eax,%r8
mov    0x1c0(%rsp),%eax
movslq %eax,%r13
movslq %r10d,%rdi
mov    0x50(%rsp),%r9
movslq %r9d,%rsi
mov    %ebp,%eax
mov    %rax,0xf8(%rsp)
mov    %edi,%ebx
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x128(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x120(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ebx,%eax
and    $0xfffffffe,%eax
mov    %rax,0xc0(%rsp)
movaps %xmm1,%xmm13
shufps $0x0,%xmm1,%xmm13
mov    %rcx,%rax
mov    %rcx,0x118(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x110(%rsp)
lea    (%r8,%rdx,1),%rax
mov    0x38(%rsp),%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    %rax,0xe0(%rsp)
mov    %rsi,0xe8(%rsp)
imul   %rdi,%rsi
shl    $0x2,%rsi
mov    %rsi,0xf0(%rsp)
xorps  %xmm2,%xmm2
movss  0xd0a(%rip),%xmm10
xorps  %xmm8,%xmm8
movss  0xd01(%rip),%xmm9
movaps %xmm12,%xmm3
mov    %r9d,%eax
mov    %rax,0x150(%rsp)
lea    (%rcx,%r8,1),%rax
mov    %rax,0xd8(%rsp)
lea    (%rdx,%rdx,1),%r9
mov    0x1b0(%rsp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,0x90(%rsp)
mov    %rdi,0x100(%rsp)
lea    0x0(,%rdi,4),%rcx
mov    %rcx,0x148(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x58(%rsp)
mov    %rax,0x88(%rsp)
mov    %r11d,%eax
xor    %ecx,%ecx
mov    %rcx,0x40(%rsp)
mov    %r8,0x28(%rsp)
mov    %r13,0x170(%rsp)
mov    %rbx,0x48(%rsp)
jmp    13c4 <scale_internal_short+0x2a4>
nopl   0x0(%rax,%rax,1)
mov    %cl,%sil
add    %esi,%eax
mov    0x58(%rsp),%rsi
add    $0x1,%rsi
mov    0xf0(%rsp),%rcx
add    %rcx,0x90(%rsp)
add    %rcx,0x88(%rsp)
movaps %xmm5,%xmm2
mov    %r15,0x40(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x58(%rsp)
cmp    0xf8(%rsp),%rsi
je     1e70 <scale_internal_short+0xd50>
movaps %xmm3,%xmm5
cmp    0x80(%rsp),%eax
mov    %eax,%r15d
cmovge 0x74(%rsp),%r15d
cmpl   $0x0,0x50(%rsp)
jle    1e40 <scale_internal_short+0xd20>
movaps %xmm5,%xmm6
subss  %xmm2,%xmm6
mov    0x40(%rsp),%rsi
mov    %esi,%eax
mov    0x1c0(%rsp),%ecx
imul   %ecx,%eax
movslq %eax,%rdi
movaps %xmm10,%xmm7
subss  %xmm2,%xmm7
add    $0x1,%esi
mov    %r15d,%eax
imul   %ecx,%eax
cltq
mov    %rax,0x98(%rsp)
mov    %esi,0x20(%rsp)
mov    %esi,%eax
imul   %ecx,%eax
movslq %eax,%rcx
mov    0x58(%rsp),%rax
imul   0xe8(%rsp),%rax
mov    %rax,0x108(%rsp)
mov    0x38(%rsp),%rax
mov    %rdi,0x140(%rsp)
add    %rdi,%rax
mov    %rax,0x60(%rsp)
mov    0xd8(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x130(%rsp)
add    0xe0(%rsp),%rcx
mov    %rcx,0x138(%rsp)
xor    %r11d,%r11d
xorps  %xmm4,%xmm4
mov    0x88(%rsp),%r12
mov    0x90(%rsp),%rbp
movaps %xmm11,%xmm2
mov    0x68(%rsp),%rax
xor    %edi,%edi
mov    %r15,0xa0(%rsp)
jmp    14cd <scale_internal_short+0x3ad>
nopl   (%rax)
mov    %cl,%sil
add    %esi,%eax
add    $0x1,%r11
mov    0x148(%rsp),%rcx
add    %rcx,%rbp
add    %rcx,%r12
movaps %xmm3,%xmm4
cmp    0x150(%rsp),%r11
mov    0x28(%rsp),%r8
je     1e40 <scale_internal_short+0xd20>
mov    %eax,%ecx
movaps %xmm2,%xmm3
mov    %edi,%esi
mov    0x1c8(%rsp),%eax
imul   %eax,%esi
movaps %xmm8,(%rsp)
cmp    0x40(%rsp),%r15d
mov    %rcx,0x18(%rsp)
mov    %r11,0x168(%rsp)
mov    %r12,0x160(%rsp)
mov    %rbp,0x158(%rsp)
mov    %esi,0x24(%rsp)
jle    1590 <scale_internal_short+0x470>
cmp    %edi,%ecx
jle    1590 <scale_internal_short+0x470>
mov    %rdi,%r8
movslq %esi,%rax
add    0x38(%rsp),%rax
mov    0x140(%rsp),%rcx
lea    (%rax,%rcx,1),%r12
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
test   %r10d,%r10d
jle    1610 <scale_internal_short+0x4f0>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %r12,%rdi
jmp    1572 <scale_internal_short+0x452>
nopl   (%rax)
movd   (%rdi),%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rdi
cmp    %rsi,%rbx
je     1610 <scale_internal_short+0x4f0>
test   %r14d,%r14d
je     1550 <scale_internal_short+0x430>
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
or     (%rdi),%ecx
movd   %ecx,%xmm0
jmp    1554 <scale_internal_short+0x434>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    0x40(%rsp),%r15d
jle    1750 <scale_internal_short+0x630>
mov    %rdi,%r8
movslq %esi,%rbp
add    0x60(%rsp),%rbp
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
test   %r10d,%r10d
jle    17d0 <scale_internal_short+0x6b0>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %rbp,%rdi
jmp    15f2 <scale_internal_short+0x4d2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   (%rdi),%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rdi
cmp    %rsi,%rbx
je     17d0 <scale_internal_short+0x6b0>
test   %r14d,%r14d
je     15d0 <scale_internal_short+0x4b0>
mov    0x4(%rdi),%eax
shl    $0x8,%eax
or     (%rdi),%eax
movd   %eax,%xmm0
jmp    15d4 <scale_internal_short+0x4b4>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%r8),%r15d
mov    %r12,%r11
cmp    0x18(%rsp),%r15d
jge    1690 <scale_internal_short+0x570>
mov    %r15d,%esi
mov    %r12,%r11
jmp    1639 <scale_internal_short+0x519>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%esi
cmp    0x18(%rsp),%esi
je     1690 <scale_internal_short+0x570>
add    0x28(%rsp),%r11
test   %r10d,%r10d
jle    1630 <scale_internal_short+0x510>
xor    %edi,%edi
mov    %r11,%rbp
jmp    166f <scale_internal_short+0x54f>
nopw   0x0(%rax,%rax,1)
movd   0x0(%rbp),%xmm0
mulss  %xmm7,%xmm0
addss  (%rsp,%rdi,4),%xmm0
movss  %xmm0,(%rsp,%rdi,4)
add    $0x1,%rdi
add    %rdx,%rbp
cmp    %rdi,%rbx
je     1630 <scale_internal_short+0x510>
test   %r14d,%r14d
je     1650 <scale_internal_short+0x530>
mov    0x4(%rbp),%ecx
shl    $0x8,%ecx
or     0x0(%rbp),%ecx
movd   %ecx,%xmm0
jmp    1655 <scale_internal_short+0x535>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0x28(%rsp),%r11
test   %r10d,%r10d
jle    1897 <scale_internal_short+0x777>
movaps %xmm7,%xmm4
mulss  %xmm3,%xmm4
xor    %esi,%esi
mov    %r11,%rdi
jmp    16ce <scale_internal_short+0x5ae>
nopl   0x0(%rax)
movd   (%rdi),%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rdi
cmp    %rsi,%rbx
je     16f0 <scale_internal_short+0x5d0>
test   %r14d,%r14d
je     16b0 <scale_internal_short+0x590>
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
or     (%rdi),%ecx
movd   %ecx,%xmm0
jmp    16b4 <scale_internal_short+0x594>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    0x98(%rsp),%rax
test   %r10d,%r10d
jle    189f <scale_internal_short+0x77f>
movaps %xmm5,%xmm4
mulss  %xmm2,%xmm4
xor    %esi,%esi
mov    %rax,%rdi
jmp    1732 <scale_internal_short+0x612>
nop
movd   (%rdi),%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rdi
cmp    %rsi,%rbx
je     189f <scale_internal_short+0x77f>
test   %r14d,%r14d
je     1710 <scale_internal_short+0x5f0>
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
or     (%rdi),%ecx
movd   %ecx,%xmm0
jmp    1714 <scale_internal_short+0x5f4>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %edi,0x18(%rsp)
jle    1a06 <scale_internal_short+0x8e6>
mov    %rdi,%r12
movslq %esi,%rbp
add    0x60(%rsp),%rbp
test   %r10d,%r10d
mov    0x18(%rsp),%r11
jle    1a65 <scale_internal_short+0x945>
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
xor    %esi,%esi
mov    %rbp,%rdi
jmp    17b2 <scale_internal_short+0x692>
cs nopw 0x0(%rax,%rax,1)
movd   (%rdi),%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rdi
cmp    %rsi,%rbx
je     1a65 <scale_internal_short+0x945>
test   %r14d,%r14d
je     1790 <scale_internal_short+0x670>
mov    0x4(%rdi),%eax
shl    $0x8,%eax
or     (%rdi),%eax
movd   %eax,%xmm0
jmp    1794 <scale_internal_short+0x674>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%eax
mov    %eax,%esi
cmp    %r15d,%eax
jl     1808 <scale_internal_short+0x6e8>
test   %r10d,%r10d
mov    %r8,%rdi
jle    1b30 <scale_internal_short+0xa10>
mulss  %xmm5,%xmm2
add    %r13,%rbp
xor    %esi,%esi
jmp    1883 <scale_internal_short+0x763>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%esi
cmp    %r15d,%esi
je     17db <scale_internal_short+0x6bb>
add    %r13,%rbp
test   %r10d,%r10d
jle    1800 <scale_internal_short+0x6e0>
xor    %edi,%edi
mov    %rbp,%rax
jmp    183e <scale_internal_short+0x71e>
nopw   0x0(%rax,%rax,1)
movd   (%rax),%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rdi,4),%xmm0
movss  %xmm0,(%rsp,%rdi,4)
add    $0x1,%rdi
add    %rdx,%rax
cmp    %rdi,%rbx
je     1800 <scale_internal_short+0x6e0>
test   %r14d,%r14d
je     1820 <scale_internal_short+0x700>
mov    0x4(%rax),%ecx
shl    $0x8,%ecx
or     (%rax),%ecx
movd   %ecx,%xmm0
jmp    1824 <scale_internal_short+0x704>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   0x0(%rbp),%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rbp
cmp    %rsi,%rbx
je     1b30 <scale_internal_short+0xa10>
test   %r14d,%r14d
je     1860 <scale_internal_short+0x740>
mov    0x4(%rbp),%eax
shl    $0x8,%eax
or     0x0(%rbp),%eax
movd   %eax,%xmm0
jmp    1865 <scale_internal_short+0x745>
add    0x98(%rsp),%rax
cmp    0x18(%rsp),%r15d
jl     18db <scale_internal_short+0x7bb>
test   %r10d,%r10d
mov    0xa0(%rsp),%r15
mov    %r8,%rdi
jle    1970 <scale_internal_short+0x850>
movaps %xmm5,%xmm4
mulss  %xmm3,%xmm4
add    0x28(%rsp),%rax
xor    %esi,%esi
jmp    194e <scale_internal_short+0x82e>
nopl   (%rax)
add    $0x1,%r15d
cmp    0x18(%rsp),%r15d
je     18a6 <scale_internal_short+0x786>
add    0x28(%rsp),%rax
test   %r10d,%r10d
jle    18d0 <scale_internal_short+0x7b0>
xor    %esi,%esi
mov    %rax,%rdi
jmp    190e <scale_internal_short+0x7ee>
nopl   0x0(%rax)
movd   (%rdi),%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rdi
cmp    %rsi,%rbx
je     18d0 <scale_internal_short+0x7b0>
test   %r14d,%r14d
je     18f0 <scale_internal_short+0x7d0>
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
or     (%rdi),%ecx
movd   %ecx,%xmm0
jmp    18f4 <scale_internal_short+0x7d4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   (%rax),%xmm0
mulss  %xmm4,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rax
cmp    %rsi,%rbx
je     1970 <scale_internal_short+0x850>
test   %r14d,%r14d
je     1930 <scale_internal_short+0x810>
mov    0x4(%rax),%ecx
shl    $0x8,%ecx
or     (%rax),%ecx
movd   %ecx,%xmm0
jmp    1934 <scale_internal_short+0x814>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%ecx
mov    %ecx,%eax
cmp    %r15d,%ecx
jl     198c <scale_internal_short+0x86c>
jmp    1d20 <scale_internal_short+0xc00>
add    $0x1,%eax
cmp    %r15d,%eax
je     1b30 <scale_internal_short+0xa10>
add    %r13,%r12
add    %r13,%r11
test   %r10d,%r10d
jle    1980 <scale_internal_short+0x860>
xor    %esi,%esi
jmp    19d0 <scale_internal_short+0x8b0>
nopl   0x0(%rax,%rax,1)
movss  (%r11),%xmm0
mulss  %xmm3,%xmm0
movss  (%r12),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
addss  (%rsp,%rsi,4),%xmm4
movss  %xmm4,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%r12
add    %rdx,%r11
cmp    %rsi,%rbx
je     1980 <scale_internal_short+0x860>
test   %r14d,%r14d
je     19a0 <scale_internal_short+0x880>
mov    0x4(%r12),%ecx
shl    $0x8,%ecx
or     (%r12),%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
mov    0x4(%r11),%ecx
shl    $0x8,%ecx
or     (%r11),%ecx
movd   %ecx,%xmm4
mulss  %xmm3,%xmm4
addss  %xmm0,%xmm4
jmp    19bc <scale_internal_short+0x89c>
test   %r10d,%r10d
jle    1b30 <scale_internal_short+0xa10>
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
movslq 0x24(%rsp),%rax
add    0x60(%rsp),%rax
xor    %esi,%esi
jmp    1a52 <scale_internal_short+0x932>
nopl   0x0(%rax,%rax,1)
movd   (%rax),%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rax
cmp    %rsi,%rbx
je     1b30 <scale_internal_short+0xa10>
test   %r14d,%r14d
je     1a30 <scale_internal_short+0x910>
mov    0x4(%rax),%ecx
shl    $0x8,%ecx
or     (%rax),%ecx
movd   %ecx,%xmm0
jmp    1a34 <scale_internal_short+0x914>
lea    0x1(%r12),%esi
cmp    %r11d,%esi
jl     1a98 <scale_internal_short+0x978>
test   %r10d,%r10d
mov    %r12,%rdi
jle    1b30 <scale_internal_short+0xa10>
movaps %xmm6,%xmm2
mulss  %xmm3,%xmm2
add    0x28(%rsp),%rbp
xor    %esi,%esi
jmp    1b0f <scale_internal_short+0x9ef>
xchg   %ax,%ax
add    $0x1,%esi
cmp    %r11d,%esi
je     1a6f <scale_internal_short+0x94f>
add    %r8,%rbp
test   %r10d,%r10d
jle    1a90 <scale_internal_short+0x970>
xor    %edi,%edi
mov    %rbp,%rax
jmp    1ace <scale_internal_short+0x9ae>
nopw   0x0(%rax,%rax,1)
movd   (%rax),%xmm0
mulss  %xmm6,%xmm0
addss  (%rsp,%rdi,4),%xmm0
movss  %xmm0,(%rsp,%rdi,4)
add    $0x1,%rdi
add    %rdx,%rax
cmp    %rdi,%rbx
je     1a90 <scale_internal_short+0x970>
test   %r14d,%r14d
je     1ab0 <scale_internal_short+0x990>
mov    0x4(%rax),%ecx
shl    $0x8,%ecx
or     (%rax),%ecx
movd   %ecx,%xmm0
jmp    1ab4 <scale_internal_short+0x994>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   0x0(%rbp),%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    $0x1,%rsi
add    %rdx,%rbp
cmp    %rsi,%rbx
je     1b30 <scale_internal_short+0xa10>
test   %r14d,%r14d
je     1af0 <scale_internal_short+0x9d0>
mov    0x4(%rbp),%eax
shl    $0x8,%eax
or     0x0(%rbp),%eax
movd   %eax,%xmm0
jmp    1af5 <scale_internal_short+0x9d5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %r15d,0x20(%rsp)
jge    1d20 <scale_internal_short+0xc00>
movslq 0x24(%rsp),%rax
mov    0x130(%rsp),%rcx
lea    (%rcx,%rax,1),%rsi
mov    %rsi,0xb0(%rsp)
add    $0x1,%edi
lea    (%rcx,%rax,1),%rbp
add    0x138(%rsp),%rax
xor    %ecx,%ecx
mov    %rcx,0xa8(%rsp)
mov    0x20(%rsp),%ecx
mov    %rdi,0xb8(%rsp)
jmp    1bbd <scale_internal_short+0xa9d>
nopl   0x0(%rax,%rax,1)
mov    0x170(%rsp),%r13
add    %r13,0xb0(%rsp)
mov    0x24(%rsp),%ecx
add    $0x1,%ecx
add    %r13,0xa8(%rsp)
mov    0xa0(%rsp),%r15
cmp    %r15d,%ecx
mov    0x48(%rsp),%rbx
mov    0xb8(%rsp),%rdi
je     1d20 <scale_internal_short+0xc00>
mov    %ecx,0x24(%rsp)
mov    0x18(%rsp),%r11
cmp    %r11d,%edi
mov    0x28(%rsp),%rbx
jge    1b80 <scale_internal_short+0xa60>
mov    0xa8(%rsp),%r15
mov    0xb8(%rsp),%rcx
mov    %ecx,%edi
mov    0xb0(%rsp),%r13
jmp    1c10 <scale_internal_short+0xaf0>
lea    (%rsp,%r8,4),%rcx
movd   (%rsp,%r8,4),%xmm2
addss  (%rsi),%xmm2
movss  %xmm2,(%rcx)
add    %rbx,%r13
add    $0x1,%edi
add    %rbx,%r15
cmp    %r11d,%edi
je     1b80 <scale_internal_short+0xa60>
test   %r10d,%r10d
jle    1bfe <scale_internal_short+0xade>
cmp    $0x1,%r10d
jne    1c30 <scale_internal_short+0xb10>
xor    %r8d,%r8d
mov    %r13,%rsi
testb  $0x1,0x48(%rsp)
je     1bfe <scale_internal_short+0xade>
jmp    1cfd <scale_internal_short+0xbdd>
nopl   (%rax)
mov    %r15,%rsi
lea    0x4(%rsp),%r10
xor    %r8d,%r8d
mov    %r13,%r11
jmp    1c73 <scale_internal_short+0xb53>
mov    %r8,%rcx
or     $0x1,%rcx
lea    (%rsp,%rcx,4),%rbx
movd   (%r10),%xmm2
mov    %r11,%rcx
addss  (%rcx),%xmm2
movss  %xmm2,(%rbx)
add    $0x2,%r8
add    %rdx,%r11
add    $0x8,%r10
add    %r9,%rsi
cmp    %r8,0xc0(%rsp)
je     1ce0 <scale_internal_short+0xbc0>
test   %r14d,%r14d
je     1ca0 <scale_internal_short+0xb80>
mov    0x4(%rbp,%rsi,1),%ecx
shl    $0x8,%ecx
or     0x0(%rbp,%rsi,1),%ecx
movd   %ecx,%xmm2
lea    (%rsp,%r8,4),%r12
lea    -0x4(%r10),%rbx
jmp    1cad <scale_internal_short+0xb8d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x4(%r10),%r12
movd   -0x4(%r10),%xmm2
mov    %r11,%rbx
add    %rdx,%r11
addss  (%rbx),%xmm2
movss  %xmm2,(%r12)
test   %r14d,%r14d
je     1c40 <scale_internal_short+0xb20>
mov    (%rax,%rsi,1),%ecx
shl    $0x8,%ecx
or     -0x4(%rax,%rsi,1),%ecx
movd   %ecx,%xmm2
mov    %r10,%rcx
mov    %r10,%rbx
jmp    1c53 <scale_internal_short+0xb33>
nopl   0x0(%rax,%rax,1)
add    %rbp,%rsi
mov    0x34(%rsp),%r10d
mov    0x28(%rsp),%rbx
mov    0x18(%rsp),%r11
testb  $0x1,0x48(%rsp)
je     1bfe <scale_internal_short+0xade>
test   %r14d,%r14d
je     1bec <scale_internal_short+0xacc>
mov    0x4(%rsi),%ecx
shl    $0x8,%ecx
or     (%rsi),%ecx
movd   %ecx,%xmm2
lea    (%rsp,%r8,4),%rsi
mov    %rsi,%rcx
jmp    1bf6 <scale_internal_short+0xad6>
xchg   %ax,%ax
test   %r10d,%r10d
mov    0x168(%rsp),%r11
mov    0x160(%rsp),%r12
mov    0x158(%rsp),%rbp
jle    1df8 <scale_internal_short+0xcd8>
cmp    $0x4,%r10d
jae    1d50 <scale_internal_short+0xc30>
xor    %eax,%eax
jmp    1de0 <scale_internal_short+0xcc0>
xchg   %ax,%ax
cmpq   $0x0,0x120(%rsp)
je     1e2c <scale_internal_short+0xd0c>
mov    0x110(%rsp),%rsi
xor    %eax,%eax
nopl   0x0(%rax)
movaps (%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
movups %xmm0,-0x10(%rbp,%rax,4)
movaps 0x10(%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
movups %xmm0,0x0(%rbp,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rsi
jne    1d70 <scale_internal_short+0xc50>
testb  $0x1,0x118(%rsp)
01
je     1dca <scale_internal_short+0xcaa>
mov    0x108(%rsp),%rcx
add    %r11,%rcx
imul   0x100(%rsp),%rcx
movaps (%rsp,%rax,4),%xmm0
divps  %xmm13,%xmm0
add    %rax,%rcx
mov    0x1b0(%rsp),%rax
movups %xmm0,(%rax,%rcx,4)
mov    0x128(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     1df8 <scale_internal_short+0xcd8>
nopw   0x0(%rax,%rax,1)
movss  (%rsp,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1de0 <scale_internal_short+0xcc0>
movaps %xmm11,%xmm0
addss  %xmm3,%xmm0
xor    %esi,%esi
ucomiss %xmm10,%xmm0
mov    0x68(%rsp),%rax
mov    0x18(%rsp),%rdi
lea    (%rdi,%rax,1),%eax
seta   %cl
movaps %xmm0,%xmm2
addss  %xmm9,%xmm2
ja     14a0 <scale_internal_short+0x380>
movaps %xmm0,%xmm2
jmp    14a0 <scale_internal_short+0x380>
xor    %eax,%eax
testb  $0x1,0x118(%rsp)
01
jne    1d9f <scale_internal_short+0xc7f>
jmp    1dca <scale_internal_short+0xcaa>
xchg   %ax,%ax
movaps %xmm12,%xmm0
addss  %xmm5,%xmm0
xor    %esi,%esi
ucomiss %xmm10,%xmm0
mov    0x78(%rsp),%rax
lea    (%r15,%rax,1),%eax
seta   %cl
movaps %xmm0,%xmm3
addss  %xmm9,%xmm3
ja     1380 <scale_internal_short+0x260>
movaps %xmm0,%xmm3
jmp    1380 <scale_internal_short+0x260>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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