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

/* Forward declarations */

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

/* Variables and functions */
int UINT_MAX;
int floor(float);
int /*<<< orphan*/ halveImage_uint(int, int, int, int const *, int *, int, int,
                                   int, int);
void scale_internal_uint(GLint components, GLint widthin, GLint heightin,
                         const GLuint *datain, GLint widthout, GLint heightout,
                         GLuint *dataout, GLint element_size, GLint ysize,
                         GLint group_size, GLint myswap_bytes) {
  float convx;
  float convy;
  float percent;
  float totals[4];
  float area;
  int i, j, k, xindex;
  const char *temp, *temp0;
  const char *temp_index;
  int outindex;
  int lowx_int, highx_int, lowy_int, highy_int;
  float x_percent, y_percent;
  float lowx_float, highx_float, lowy_float, highy_float;
  float convy_float, convx_float;
  int convy_int, convx_int;
  int l, m;
  const char *left, *right;
  if (widthin == widthout * 2 && heightin == heightout * 2) {
    halveImage_uint(components, widthin, heightin, (const GLuint *)datain,
                    (GLuint *)dataout, element_size, ysize, group_size,
                    myswap_bytes);
    return;
  }
  convy = (float)heightin / heightout;
  convx = (float)widthin / widthout;
  convy_int = floor(convy);
  convy_float = convy - convy_int;
  convx_int = floor(convx);
  convx_float = convx - convx_int;
  area = convx * convy;
  lowy_int = 0;
  lowy_float = 0;
  highy_int = convy_int;
  highy_float = convy_float;
  for (i = 0; i < heightout; i++) {
    if (highy_int >= heightin)
      highy_int = heightin - 1;
    lowx_int = 0;
    lowx_float = 0;
    highx_int = convx_int;
    highx_float = convx_float;
    for (j = 0; j < widthout; j++) {
      totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
      xindex = lowx_int * group_size;
      if ((highy_int > lowy_int) && (highx_int > lowx_int)) {
        y_percent = 1 - lowy_float;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        percent = y_percent * (1 - lowx_float);
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
        left = temp;
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              totals[k] +=
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                  y_percent;
            } else {
              totals[k] += *(const GLuint *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        right = temp;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
        y_percent = highy_float;
        percent = y_percent * (1 - lowx_float);
        temp = (const char *)datain + xindex + highy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              totals[k] +=
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                  y_percent;
            } else {
              totals[k] += *(const GLuint *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
        for (m = lowy_int + 1; m < highy_int; m++) {
          left += ysize;
          right += ysize;
          for (k = 0; k < components;
               k++, left += element_size, right += element_size) {
            if (myswap_bytes) {
              totals[k] +=
                  (GLuint)(((GLuint)((const GLubyte *)(left))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(left))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(left))[1]) << 8 |
                           ((const GLubyte *)(left))[0]) *
                      (1 - lowx_float) +
                  (GLuint)(((GLuint)((const GLubyte *)(right))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(right))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(right))[1]) << 8 |
                           ((const GLubyte *)(right))[0]) *
                      highx_float;
            } else {
              totals[k] += *(const GLuint *)left * (1 - lowx_float) +
                           *(const GLuint *)right * highx_float;
            }
          }
        }
      } else if (highy_int > lowy_int) {
        x_percent = highx_float - lowx_float;
        percent = (1 - lowy_float) * x_percent;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
        for (m = lowy_int + 1; m < highy_int; m++) {
          temp += ysize;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              totals[k] +=
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                  x_percent;
            } else {
              totals[k] += *(const GLuint *)temp_index * x_percent;
            }
          }
        }
        percent = x_percent * highy_float;
        temp += ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
      } else if (highx_int > lowx_int) {
        y_percent = highy_float - lowy_float;
        percent = (1 - lowx_float) * y_percent;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              totals[k] +=
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]) *
                  y_percent;
            } else {
              totals[k] += *(const GLuint *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
      } else {
        percent = (highy_float - lowy_float) * (highx_float - lowx_float);
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          if (myswap_bytes) {
            totals[k] +=
                (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                         ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                         ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                         ((const GLubyte *)(temp_index))[0]) *
                percent;
          } else {
            totals[k] += *(const GLuint *)temp_index * percent;
          }
        }
      }
      temp0 =
          (const char *)datain + xindex + group_size + (lowy_int + 1) * ysize;
      for (m = lowy_int + 1; m < highy_int; m++) {
        temp = temp0;
        for (l = lowx_int + 1; l < highx_int; l++) {
          for (k = 0, temp_index = temp; k < components;
               k++, temp_index += element_size) {
            if (myswap_bytes) {
              totals[k] +=
                  (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 |
                           ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 |
                           ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 |
                           ((const GLubyte *)(temp_index))[0]);
            } else {
              totals[k] += *(const GLuint *)temp_index;
            }
          }
          temp += group_size;
        }
        temp0 += ysize;
      }
      outindex = (j + (i * widthout)) * components;
      for (k = 0; k < components; k++) {
        float value = totals[k] / area;
        if (value >= (float)UINT_MAX) {
          dataout[outindex + k] = UINT_MAX;
        } else
          dataout[outindex + k] = value;
      }
      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_uint>:
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_uint+0x89>
mov    -0xc(%rbp),%eax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    11a9 <scale_internal_uint+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_uint@plt>
jmp    2515 <scale_internal_uint+0x13f5>
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    2515 <scale_internal_uint+0x13f5>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     128c <scale_internal_uint+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    2473 <scale_internal_uint+0x1353>
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    1ac7 <scale_internal_uint+0x9a7>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    1ac7 <scale_internal_uint+0x9a7>
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    1420 <scale_internal_uint+0x300>
cmpl   $0x0,0x30(%rbp)
je     13d7 <scale_internal_uint+0x2b7>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    13fc <scale_internal_uint+0x2dc>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1401 <scale_internal_uint+0x2e1>
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_uint+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    1532 <scale_internal_uint+0x412>
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    1519 <scale_internal_uint+0x3f9>
cmpl   $0x0,0x30(%rbp)
je     14cd <scale_internal_uint+0x3ad>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    14f5 <scale_internal_uint+0x3d5>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    14fa <scale_internal_uint+0x3da>
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    1466 <scale_internal_uint+0x346>
jmp    151e <scale_internal_uint+0x3fe>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1437 <scale_internal_uint+0x317>
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    161f <scale_internal_uint+0x4ff>
cmpl   $0x0,0x30(%rbp)
je     15d6 <scale_internal_uint+0x4b6>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    15fb <scale_internal_uint+0x4db>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1600 <scale_internal_uint+0x4e0>
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    1572 <scale_internal_uint+0x452>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  0x19c1(%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    172b <scale_internal_uint+0x60b>
cmpl   $0x0,0x30(%rbp)
je     16e2 <scale_internal_uint+0x5c2>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1707 <scale_internal_uint+0x5e7>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    170c <scale_internal_uint+0x5ec>
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    167e <scale_internal_uint+0x55e>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1832 <scale_internal_uint+0x712>
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    1819 <scale_internal_uint+0x6f9>
cmpl   $0x0,0x30(%rbp)
je     17cd <scale_internal_uint+0x6ad>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    17f5 <scale_internal_uint+0x6d5>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    17fa <scale_internal_uint+0x6da>
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    1766 <scale_internal_uint+0x646>
jmp    181e <scale_internal_uint+0x6fe>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1737 <scale_internal_uint+0x617>
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    1914 <scale_internal_uint+0x7f4>
cmpl   $0x0,0x30(%rbp)
je     18cb <scale_internal_uint+0x7ab>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    18f0 <scale_internal_uint+0x7d0>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    18f5 <scale_internal_uint+0x7d5>
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    1867 <scale_internal_uint+0x747>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1ac2 <scale_internal_uint+0x9a2>
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    1aa9 <scale_internal_uint+0x989>
cmpl   $0x0,0x30(%rbp)
je     1a22 <scale_internal_uint+0x902>
mov    -0xc0(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0xc0(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0xc0(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0xc0(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  0x1643(%rip),%xmm2
subss  -0x90(%rbp),%xmm2
ff
mov    -0xc8(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0xc8(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0xc8(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0xc8(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm1
mulss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1a68 <scale_internal_uint+0x948>
mov    -0xc0(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  0x15cb(%rip),%xmm2
subss  -0x90(%rbp),%xmm2
ff
mov    -0xc8(%rbp),%rax
cvtsi2ssl (%rax),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1a6d <scale_internal_uint+0x94d>
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    1967 <scale_internal_uint+0x847>
jmp    1aae <scale_internal_uint+0x98e>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1920 <scale_internal_uint+0x800>
jmp    21eb <scale_internal_uint+0x10cb>
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jle    1dd4 <scale_internal_uint+0xcb4>
movss  -0x94(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  0x150a(%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    1be3 <scale_internal_uint+0xac3>
cmpl   $0x0,0x30(%rbp)
je     1b9a <scale_internal_uint+0xa7a>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1bbf <scale_internal_uint+0xa9f>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1bc4 <scale_internal_uint+0xaa4>
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    1b36 <scale_internal_uint+0xa16>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1ced <scale_internal_uint+0xbcd>
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    1cd4 <scale_internal_uint+0xbb4>
cmpl   $0x0,0x30(%rbp)
je     1c88 <scale_internal_uint+0xb68>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x88(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1cb0 <scale_internal_uint+0xb90>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1cb5 <scale_internal_uint+0xb95>
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    1c21 <scale_internal_uint+0xb01>
jmp    1cd9 <scale_internal_uint+0xbb9>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1bef <scale_internal_uint+0xacf>
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    1dcf <scale_internal_uint+0xcaf>
cmpl   $0x0,0x30(%rbp)
je     1d86 <scale_internal_uint+0xc66>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1dab <scale_internal_uint+0xc8b>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1db0 <scale_internal_uint+0xc90>
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    1d22 <scale_internal_uint+0xc02>
jmp    21e6 <scale_internal_uint+0x10c6>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    20db <scale_internal_uint+0xfbb>
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  0x1200(%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    1eed <scale_internal_uint+0xdcd>
cmpl   $0x0,0x30(%rbp)
je     1ea4 <scale_internal_uint+0xd84>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1ec9 <scale_internal_uint+0xda9>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1ece <scale_internal_uint+0xdae>
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    1e40 <scale_internal_uint+0xd20>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1ff4 <scale_internal_uint+0xed4>
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    1fdb <scale_internal_uint+0xebb>
cmpl   $0x0,0x30(%rbp)
je     1f8f <scale_internal_uint+0xe6f>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1fb7 <scale_internal_uint+0xe97>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    1fbc <scale_internal_uint+0xe9c>
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    1f28 <scale_internal_uint+0xe08>
jmp    1fe0 <scale_internal_uint+0xec0>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1ef9 <scale_internal_uint+0xdd9>
mov    0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movss  -0x8c(%rbp),%xmm0
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    20d6 <scale_internal_uint+0xfb6>
cmpl   $0x0,0x30(%rbp)
je     208d <scale_internal_uint+0xf6d>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    20b2 <scale_internal_uint+0xf92>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    20b7 <scale_internal_uint+0xf97>
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    2029 <scale_internal_uint+0xf09>
jmp    21e1 <scale_internal_uint+0x10c1>
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    21dc <scale_internal_uint+0x10bc>
cmpl   $0x0,0x30(%rbp)
je     2193 <scale_internal_uint+0x1073>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    21b8 <scale_internal_uint+0x1098>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    21bd <scale_internal_uint+0x109d>
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    212f <scale_internal_uint+0x100f>
jmp    21e1 <scale_internal_uint+0x10c1>
jmp    21e6 <scale_internal_uint+0x10c6>
jmp    21eb <scale_internal_uint+0x10cb>
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    233e <scale_internal_uint+0x121e>
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    2319 <scale_internal_uint+0x11f9>
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    22f4 <scale_internal_uint+0x11d4>
cmpl   $0x0,0x30(%rbp)
je     22b8 <scale_internal_uint+0x1198>
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x70(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%rcx
or     (%rcx),%eax
cvtsi2ss %eax,%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    22d0 <scale_internal_uint+0x11b0>
mov    -0x70(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
jmp    22d5 <scale_internal_uint+0x11b5>
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    2261 <scale_internal_uint+0x1141>
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    2243 <scale_internal_uint+0x1123>
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    221d <scale_internal_uint+0x10fd>
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    23e0 <scale_internal_uint+0x12c0>
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
mov    0x2c5e(%rip),%rax
cvtsi2ssl (%rax),%xmm1
ucomiss %xmm1,%xmm0
jb     23b5 <scale_internal_uint+0x1295>
mov    0x2c4a(%rip),%rax
mov    (%rax),%edx
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    23cd <scale_internal_uint+0x12ad>
cvttss2si -0xcc(%rbp),%edx
ff
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    23d2 <scale_internal_uint+0x12b2>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2358 <scale_internal_uint+0x1238>
mov    -0x7c(%rbp),%eax
mov    %eax,-0x78(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
mov    -0xac(%rbp),%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movss  0xbd6(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    2460 <scale_internal_uint+0x1340>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xbc1(%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    2465 <scale_internal_uint+0x1345>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12be <scale_internal_uint+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  0xb3a(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    2502 <scale_internal_uint+0x13e2>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xb25(%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    2507 <scale_internal_uint+0x13e7>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1265 <scale_internal_uint+0x145>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_internal_uint>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9d,%ebp
mov    %rcx,0x50(%rsp)
mov    %edi,0xc(%rsp)
mov    0x180(%rsp),%r14d
mov    0x168(%rsp),%ebx
mov    %r8,0x68(%rsp)
lea    (%r8,%r8,1),%eax
cmp    %esi,%eax
jne    119c <scale_internal_uint+0x7c>
lea    0x0(%rbp,%rbp,1),%eax
cmp    %edx,%eax
jne    119c <scale_internal_uint+0x7c>
sub    $0x8,%rsp
mov    0x14(%rsp),%edi
mov    0x58(%rsp),%rcx
mov    0x168(%rsp),%r8
mov    %ebx,%r9d
push   %r14
mov    0x188(%rsp),%eax
push   %rax
mov    0x188(%rsp),%eax
push   %rax
call   1030 <halveImage_uint@plt>
add    $0x148,%rsp
jmp    1e3b <scale_internal_uint+0xd1b>
cvtsi2ss %edx,%xmm0
cvtsi2ss %ebp,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,0x20(%rsp)
cvtsi2ss %esi,%xmm2
xorps  %xmm1,%xmm1
cvtsi2ssl 0x68(%rsp),%xmm1
divss  %xmm1,%xmm2
movaps %xmm2,0x40(%rsp)
mov    %rdx,0xa0(%rsp)
call   1040 <floor@plt>
mov    %rax,0x98(%rsp)
movaps 0x40(%rsp),%xmm0
call   1040 <floor@plt>
movaps 0x40(%rsp),%xmm14
movss  0x20(%rsp),%xmm13
mov    0xa0(%rsp),%rcx
mov    %rax,0x88(%rsp)
test   %ebp,%ebp
jle    1e34 <scale_internal_uint+0xd14>
mov    0x98(%rsp),%r8
xorps  %xmm1,%xmm1
cvtsi2ss %r8d,%xmm1
xorps  %xmm2,%xmm2
cvtsi2ssl 0x88(%rsp),%xmm2
movaps %xmm14,%xmm11
subss  %xmm2,%xmm11
mulss  %xmm13,%xmm14
subss  %xmm1,%xmm13
lea    -0x1(%rcx),%eax
mov    %eax,0x94(%rsp)
movslq %ebx,%r10
mov    0x178(%rsp),%eax
movslq %eax,%r13
mov    0x170(%rsp),%eax
cltq
mov    %rax,0x60(%rsp)
movslq 0xc(%rsp),%rdi
mov    0x68(%rsp),%rax
movslq %eax,%rsi
mov    %ebp,%ebp
mov    %rbp,0xc8(%rsp)
mov    %eax,%eax
mov    %rax,0x110(%rsp)
mov    %edi,%r12d
mov    0x50(%rsp),%rax
add    %r13,%rax
mov    %rax,0xb0(%rsp)
imul   %rdi,%rsi
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xd8(%rsp)
movaps %xmm14,%xmm12
shufps $0x0,%xmm14,%xmm12
mov    %rsi,0xb8(%rsp)
lea    0x0(,%rsi,4),%rax
mov    %rax,0xc0(%rsp)
mov    %rdi,0xe8(%rsp)
lea    0x0(,%rdi,4),%rax
mov    %rax,0x108(%rsp)
lea    0x0(,%r12,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,0xd0(%rsp)
xor    %eax,%eax
mov    %rax,0x78(%rsp)
xorps  %xmm2,%xmm2
movss  0xcfe(%rip),%xmm10
xorps  %xmm8,%xmm8
movss  0xcf5(%rip),%xmm9
movaps %xmm13,%xmm3
mov    0x160(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    %r8d,%eax
xor    %esi,%esi
mov    %rsi,0x58(%rsp)
mov    %r13,0x20(%rsp)
jmp    1389 <scale_internal_uint+0x269>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %sil,%cl
add    %ecx,%eax
mov    0x78(%rsp),%rsi
add    $0x1,%rsi
mov    0x70(%rsp),%rcx
add    0xc0(%rsp),%rcx
mov    %rcx,0x70(%rsp)
movaps %xmm5,%xmm2
mov    %r11d,%ebx
mov    %rbx,0x58(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x78(%rsp)
cmp    0xc8(%rsp),%rsi
mov    0xa0(%rsp),%rcx
je     1e34 <scale_internal_uint+0xd14>
movaps %xmm3,%xmm5
cmp    %ecx,%eax
mov    %eax,%r11d
cmovge 0x94(%rsp),%r11d
cmpl   $0x0,0x68(%rsp)
jle    1e00 <scale_internal_uint+0xce0>
mov    0xb8(%rsp),%rax
imul   0x78(%rsp),%rax
mov    %rax,0xf0(%rsp)
add    %r12,%rax
mov    %rax,0xe0(%rsp)
movaps %xmm5,%xmm6
subss  %xmm2,%xmm6
mov    0x58(%rsp),%rsi
mov    %esi,%eax
mov    0x170(%rsp),%ecx
imul   %ecx,%eax
movslq %eax,%rdi
movaps %xmm10,%xmm7
subss  %xmm2,%xmm7
add    $0x1,%esi
mov    %r11d,%eax
imul   %ecx,%eax
cltq
mov    %rax,0xa8(%rsp)
mov    %esi,0x2c(%rsp)
mov    %esi,%eax
imul   %ecx,%eax
cltq
add    0xb0(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0x50(%rsp),%rax
mov    %rdi,0x100(%rsp)
add    %rdi,%rax
mov    %rax,0x80(%rsp)
xor    %ebp,%ebp
xorps  %xmm4,%xmm4
mov    0x70(%rsp),%rbx
movaps %xmm11,%xmm2
mov    0x88(%rsp),%rax
xor    %edx,%edx
mov    %r11,0x30(%rsp)
jmp    147a <scale_internal_uint+0x35a>
xchg   %ax,%ax
mov    %sil,%cl
add    %ecx,%eax
add    $0x1,%rbp
add    0x108(%rsp),%rbx
movaps %xmm3,%xmm4
mov    %r8d,%edx
cmp    0x110(%rsp),%rbp
mov    0x20(%rsp),%r13
je     1e00 <scale_internal_uint+0xce0>
mov    %eax,%r15d
movaps %xmm2,%xmm3
mov    %edx,%ecx
mov    0x178(%rsp),%eax
imul   %eax,%ecx
movaps %xmm8,0x10(%rsp)
cmp    0x58(%rsp),%r11d
mov    %r15,0x40(%rsp)
mov    %rbp,0x120(%rsp)
mov    %rbx,0x118(%rsp)
mov    %rdx,0x38(%rsp)
jle    1550 <scale_internal_uint+0x430>
cmp    %edx,%r15d
jle    1550 <scale_internal_uint+0x430>
mov    %ecx,%ebx
movslq %ecx,%r9
add    0x50(%rsp),%r9
mov    0x100(%rsp),%rax
lea    (%r9,%rax,1),%r8
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
cmpl   $0x0,0xc(%rsp)
jle    15e0 <scale_internal_uint+0x4c0>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %ecx,%ecx
mov    %r8,%rsi
jmp    1529 <scale_internal_uint+0x409>
nopw   0x0(%rax,%rax,1)
mov    (%rsi),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%rsi
cmp    %rcx,%r12
je     15e0 <scale_internal_uint+0x4c0>
test   %r14d,%r14d
je     1500 <scale_internal_uint+0x3e0>
mov    0xc(%rsi),%ebp
shl    $0x18,%ebp
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%eax
shl    $0x10,%eax
or     %ebp,%eax
shl    $0x8,%edi
or     %eax,%edi
or     (%rsi),%edi
jmp    1502 <scale_internal_uint+0x3e2>
nopl   0x0(%rax,%rax,1)
cmp    0x58(%rsp),%r11d
jle    1760 <scale_internal_uint+0x640>
mov    %ecx,%ebx
movslq %ecx,%r8
add    0x80(%rsp),%r8
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
cmpl   $0x0,0xc(%rsp)
jle    17f0 <scale_internal_uint+0x6d0>
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
xor    %ecx,%ecx
mov    %r8,%rsi
jmp    15b9 <scale_internal_uint+0x499>
nopl   0x0(%rax,%rax,1)
mov    (%rsi),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%rsi
cmp    %rcx,%r12
je     17f0 <scale_internal_uint+0x6d0>
test   %r14d,%r14d
je     1590 <scale_internal_uint+0x470>
mov    0xc(%rsi),%ebp
shl    $0x18,%ebp
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%eax
shl    $0x10,%eax
or     %ebp,%eax
shl    $0x8,%edi
or     %eax,%edi
or     (%rsi),%edi
jmp    1592 <scale_internal_uint+0x472>
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
lea    0x1(%rax),%r15d
mov    %r8,%r13
cmp    0x40(%rsp),%r15d
jge    1670 <scale_internal_uint+0x550>
mov    %r15d,%ecx
mov    %r8,%r13
jmp    1609 <scale_internal_uint+0x4e9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ecx
cmp    0x40(%rsp),%ecx
je     1670 <scale_internal_uint+0x550>
add    0x20(%rsp),%r13
cmpl   $0x0,0xc(%rsp)
jle    1600 <scale_internal_uint+0x4e0>
xor    %esi,%esi
mov    %r13,%rdi
jmp    1645 <scale_internal_uint+0x525>
nopl   0x0(%rax)
mov    (%rdi),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  %xmm7,%xmm0
addss  0x10(%rsp,%rsi,4),%xmm0
movss  %xmm0,0x10(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r10,%rdi
cmp    %rsi,%r12
je     1600 <scale_internal_uint+0x4e0>
test   %r14d,%r14d
je     1620 <scale_internal_uint+0x500>
mov    0xc(%rdi),%eax
shl    $0x18,%eax
mov    0x4(%rdi),%ebp
mov    0x8(%rdi),%r11d
shl    $0x10,%r11d
or     %eax,%r11d
shl    $0x8,%ebp
or     %r11d,%ebp
or     (%rdi),%ebp
jmp    1622 <scale_internal_uint+0x502>
nopl   0x0(%rax,%rax,1)
add    0x20(%rsp),%r13
cmpl   $0x0,0xc(%rsp)
jle    18dd <scale_internal_uint+0x7bd>
movaps %xmm7,%xmm4
mulss  %xmm3,%xmm4
xor    %ecx,%ecx
mov    %r13,%rsi
jmp    16b5 <scale_internal_uint+0x595>
xchg   %ax,%ax
mov    (%rsi),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%rsi
cmp    %rcx,%r12
je     16e0 <scale_internal_uint+0x5c0>
test   %r14d,%r14d
je     1690 <scale_internal_uint+0x570>
mov    0xc(%rsi),%eax
shl    $0x18,%eax
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%ebp
shl    $0x10,%ebp
or     %eax,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%rsi),%edi
jmp    1692 <scale_internal_uint+0x572>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    0xa8(%rsp),%r9
cmpl   $0x0,0xc(%rsp)
jle    18e5 <scale_internal_uint+0x7c5>
movaps %xmm5,%xmm4
mulss  %xmm2,%xmm4
xor    %ecx,%ecx
mov    %r9,%rsi
jmp    1739 <scale_internal_uint+0x619>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%rsi
cmp    %rcx,%r12
je     18e5 <scale_internal_uint+0x7c5>
test   %r14d,%r14d
je     1710 <scale_internal_uint+0x5f0>
mov    0xc(%rsi),%eax
shl    $0x18,%eax
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%ebp
shl    $0x10,%ebp
or     %eax,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%rsi),%edi
jmp    1712 <scale_internal_uint+0x5f2>
nopl   0x0(%rax,%rax,1)
cmp    %edx,%r15d
jle    1a8c <scale_internal_uint+0x96c>
mov    %ecx,%ebx
movslq %ecx,%r8
add    0x80(%rsp),%r8
cmpl   $0x0,0xc(%rsp)
jle    1b08 <scale_internal_uint+0x9e8>
movaps %xmm10,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
xor    %ecx,%ecx
mov    %r8,%rsi
jmp    17c9 <scale_internal_uint+0x6a9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%rsi
cmp    %rcx,%r12
je     1b08 <scale_internal_uint+0x9e8>
test   %r14d,%r14d
je     17a0 <scale_internal_uint+0x680>
mov    0xc(%rsi),%ebp
shl    $0x18,%ebp
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%eax
shl    $0x10,%eax
or     %ebp,%eax
shl    $0x8,%edi
or     %eax,%edi
or     (%rsi),%edi
jmp    17a2 <scale_internal_uint+0x682>
nopl   0x0(%rax,%rax,1)
mov    0x2c(%rsp),%eax
mov    %eax,%r9d
cmp    %r11d,%eax
mov    0xc(%rsp),%edx
jl     1829 <scale_internal_uint+0x709>
test   %edx,%edx
jle    1bf0 <scale_internal_uint+0xad0>
mulss  %xmm5,%xmm2
add    0x60(%rsp),%r8
xor    %ecx,%ecx
jmp    18ba <scale_internal_uint+0x79a>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9d
cmp    %r11d,%r9d
je     1800 <scale_internal_uint+0x6e0>
add    0x60(%rsp),%r8
test   %edx,%edx
jle    1820 <scale_internal_uint+0x700>
xor    %esi,%esi
mov    %r8,%rdi
jmp    1865 <scale_internal_uint+0x745>
nopl   0x0(%rax)
mov    (%rdi),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rsi,4),%xmm0
movss  %xmm0,0x10(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r10,%rdi
cmp    %rsi,%r12
je     1820 <scale_internal_uint+0x700>
test   %r14d,%r14d
je     1840 <scale_internal_uint+0x720>
mov    0xc(%rdi),%eax
shl    $0x18,%eax
mov    0x4(%rdi),%ebp
mov    0x8(%rdi),%ecx
shl    $0x10,%ecx
or     %eax,%ecx
shl    $0x8,%ebp
or     %ecx,%ebp
or     (%rdi),%ebp
jmp    1842 <scale_internal_uint+0x722>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r8),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%r8
cmp    %rcx,%r12
je     1bf0 <scale_internal_uint+0xad0>
test   %r14d,%r14d
je     1890 <scale_internal_uint+0x770>
mov    0xc(%r8),%eax
shl    $0x18,%eax
mov    0x4(%r8),%esi
mov    0x8(%r8),%edi
shl    $0x10,%edi
or     %eax,%edi
shl    $0x8,%esi
or     %edi,%esi
or     (%r8),%esi
jmp    1893 <scale_internal_uint+0x773>
add    0xa8(%rsp),%r9
cmp    0x40(%rsp),%r15d
jl     191b <scale_internal_uint+0x7fb>
cmpl   $0x0,0xc(%rsp)
mov    0x30(%rsp),%rdx
jle    19d0 <scale_internal_uint+0x8b0>
movaps %xmm5,%xmm4
mulss  %xmm3,%xmm4
add    0x20(%rsp),%r9
xor    %ecx,%ecx
jmp    19a6 <scale_internal_uint+0x886>
nop
add    $0x1,%r15d
cmp    0x40(%rsp),%r15d
je     18ec <scale_internal_uint+0x7cc>
add    0x20(%rsp),%r9
cmpl   $0x0,0xc(%rsp)
jle    1910 <scale_internal_uint+0x7f0>
xor    %ecx,%ecx
mov    %r9,%rsi
jmp    1955 <scale_internal_uint+0x835>
xchg   %ax,%ax
mov    (%rsi),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
mulss  %xmm5,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%rsi
cmp    %rcx,%r12
je     1910 <scale_internal_uint+0x7f0>
test   %r14d,%r14d
je     1930 <scale_internal_uint+0x810>
mov    0xc(%rsi),%eax
shl    $0x18,%eax
mov    0x4(%rsi),%edi
mov    0x8(%rsi),%ebp
shl    $0x10,%ebp
or     %eax,%ebp
shl    $0x8,%edi
or     %ebp,%edi
or     (%rsi),%edi
jmp    1932 <scale_internal_uint+0x812>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r9),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm4,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%r9
cmp    %rcx,%r12
je     19d0 <scale_internal_uint+0x8b0>
test   %r14d,%r14d
je     1980 <scale_internal_uint+0x860>
mov    0xc(%r9),%eax
shl    $0x18,%eax
mov    0x4(%r9),%esi
mov    0x8(%r9),%edi
shl    $0x10,%edi
or     %eax,%edi
shl    $0x8,%esi
or     %edi,%esi
or     (%r9),%esi
jmp    1983 <scale_internal_uint+0x863>
nopl   0x0(%rax)
mov    0x2c(%rsp),%eax
mov    %eax,%r9d
cmp    %edx,%eax
jl     19f2 <scale_internal_uint+0x8d2>
jmp    1cc0 <scale_internal_uint+0xba0>
mov    0x30(%rsp),%rdx
add    $0x1,%r9d
cmp    %edx,%r9d
je     1bf0 <scale_internal_uint+0xad0>
mov    0x60(%rsp),%rax
add    %rax,%r8
add    %rax,%r13
cmpl   $0x0,0xc(%rsp)
jle    19e0 <scale_internal_uint+0x8c0>
xor    %ecx,%ecx
mov    0x30(%rsp),%rdx
jmp    1a4c <scale_internal_uint+0x92c>
nopl   (%rax)
mov    (%r8),%esi
mov    0x0(%r13),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
xorps  %xmm4,%xmm4
cvtsi2ss %edi,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm2,%xmm0
addss  %xmm4,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%r8
add    %r10,%r13
cmp    %rcx,%r12
je     19e5 <scale_internal_uint+0x8c5>
test   %r14d,%r14d
je     1a10 <scale_internal_uint+0x8f0>
mov    0xc(%r8),%edi
shl    $0x18,%edi
mov    0x4(%r8),%esi
mov    0x8(%r8),%ebp
shl    $0x10,%ebp
or     %edi,%ebp
shl    $0x8,%esi
or     %ebp,%esi
or     (%r8),%esi
mov    0xc(%r13),%ebp
shl    $0x18,%ebp
mov    0x4(%r13),%edi
mov    0x8(%r13),%eax
shl    $0x10,%eax
or     %ebp,%eax
shl    $0x8,%edi
or     %eax,%edi
or     0x0(%r13),%edi
jmp    1a17 <scale_internal_uint+0x8f7>
mov    %ecx,%ebx
cmpl   $0x0,0xc(%rsp)
jle    1bf0 <scale_internal_uint+0xad0>
movaps %xmm3,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm6,%xmm2
movslq %ebx,%rax
add    0x80(%rsp),%rax
xor    %ecx,%ecx
jmp    1ae9 <scale_internal_uint+0x9c9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%rax
cmp    %rcx,%r12
je     1bf0 <scale_internal_uint+0xad0>
test   %r14d,%r14d
je     1ac0 <scale_internal_uint+0x9a0>
mov    0xc(%rax),%edi
shl    $0x18,%edi
mov    0x4(%rax),%esi
mov    0x8(%rax),%ebp
shl    $0x10,%ebp
or     %edi,%ebp
shl    $0x8,%esi
or     %ebp,%esi
or     (%rax),%esi
jmp    1ac2 <scale_internal_uint+0x9a2>
lea    0x1(%rdx),%r9d
cmp    %r15d,%r9d
mov    0xc(%rsp),%edx
jl     1b39 <scale_internal_uint+0xa19>
test   %edx,%edx
jle    1bf0 <scale_internal_uint+0xad0>
movaps %xmm6,%xmm2
mulss  %xmm3,%xmm2
add    0x20(%rsp),%r8
xor    %ecx,%ecx
jmp    1bc6 <scale_internal_uint+0xaa6>
add    $0x1,%r9d
cmp    %r15d,%r9d
je     1b15 <scale_internal_uint+0x9f5>
add    %r13,%r8
test   %edx,%edx
jle    1b30 <scale_internal_uint+0xa10>
xor    %esi,%esi
mov    %r8,%rdi
jmp    1b75 <scale_internal_uint+0xa55>
nopw   0x0(%rax,%rax,1)
mov    (%rdi),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  %xmm6,%xmm0
addss  0x10(%rsp,%rsi,4),%xmm0
movss  %xmm0,0x10(%rsp,%rsi,4)
add    $0x1,%rsi
add    %r10,%rdi
cmp    %rsi,%r12
je     1b30 <scale_internal_uint+0xa10>
test   %r14d,%r14d
je     1b50 <scale_internal_uint+0xa30>
mov    0xc(%rdi),%eax
shl    $0x18,%eax
mov    0x4(%rdi),%ebp
mov    0x8(%rdi),%ecx
shl    $0x10,%ecx
or     %eax,%ecx
shl    $0x8,%ebp
or     %ecx,%ebp
or     (%rdi),%ebp
jmp    1b52 <scale_internal_uint+0xa32>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r8),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm2,%xmm0
addss  0x10(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
add    %r10,%r8
cmp    %rcx,%r12
je     1bf0 <scale_internal_uint+0xad0>
test   %r14d,%r14d
je     1ba0 <scale_internal_uint+0xa80>
mov    0xc(%r8),%eax
shl    $0x18,%eax
mov    0x4(%r8),%esi
mov    0x8(%r8),%edi
shl    $0x10,%edi
or     %eax,%edi
shl    $0x8,%esi
or     %edi,%esi
or     (%r8),%esi
jmp    1ba3 <scale_internal_uint+0xa83>
nopl   0x0(%rax)
mov    0x2c(%rsp),%eax
cmp    0x30(%rsp),%eax
jge    1cc0 <scale_internal_uint+0xba0>
movslq %ebx,%r8
add    0xf8(%rsp),%r8
mov    0x38(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
mov    0x2c(%rsp),%r15d
jmp    1c34 <scale_internal_uint+0xb14>
nopl   (%rax)
add    0x60(%rsp),%r8
add    $0x1,%r15d
cmp    0x30(%rsp),%r15d
je     1cc0 <scale_internal_uint+0xba0>
mov    0x40(%rsp),%r13
cmp    %r13d,0x38(%rsp)
mov    0xc(%rsp),%r9d
mov    0x20(%rsp),%r11
jge    1c20 <scale_internal_uint+0xb00>
mov    0x38(%rsp),%rax
mov    %eax,%edi
mov    %r8,%rsi
jmp    1c6b <scale_internal_uint+0xb4b>
cs nopw 0x0(%rax,%rax,1)
add    %r11,%rsi
add    $0x1,%edi
cmp    %r13d,%edi
je     1c20 <scale_internal_uint+0xb00>
test   %r9d,%r9d
jle    1c60 <scale_internal_uint+0xb40>
xor    %ebp,%ebp
mov    %rsi,%rax
jmp    1ca1 <scale_internal_uint+0xb81>
nopw   0x0(%rax,%rax,1)
mov    (%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
addss  0x10(%rsp,%rbp,4),%xmm0
movss  %xmm0,0x10(%rsp,%rbp,4)
add    $0x1,%rbp
add    %r10,%rax
cmp    %rbp,%r12
je     1c60 <scale_internal_uint+0xb40>
test   %r14d,%r14d
je     1c80 <scale_internal_uint+0xb60>
mov    0xc(%rax),%ebx
shl    $0x18,%ebx
mov    0x4(%rax),%ecx
mov    0x8(%rax),%edx
shl    $0x10,%edx
or     %ebx,%edx
shl    $0x8,%ecx
or     %edx,%ecx
or     (%rax),%ecx
jmp    1c82 <scale_internal_uint+0xb62>
cmpl   $0x0,0xc(%rsp)
mov    0x231c(%rip),%rdi
mov    0x30(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%rbx
mov    0x40(%rsp),%r8
jle    1dca <scale_internal_uint+0xcaa>
cmpl   $0x4,0xc(%rsp)
jae    1d00 <scale_internal_uint+0xbe0>
xor    %eax,%eax
jmp    1da0 <scale_internal_uint+0xc80>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rax
imul   0xe8(%rsp),%rax
mov    0xf0(%rsp),%rcx
add    %rax,%rcx
mov    0x160(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
lea    0x4(%rdi),%rdx
cmp    %rdx,%rcx
jae    1d41 <scale_internal_uint+0xc21>
add    0xe0(%rsp),%rax
lea    (%rsi,%rax,4),%rax
cmp    %rdi,%rax
jbe    1d41 <scale_internal_uint+0xc21>
xor    %eax,%eax
jmp    1da0 <scale_internal_uint+0xc80>
movd   (%rdi),%xmm0
pshufd $0x0,%xmm0,%xmm2
cvtdq2ps %xmm2,%xmm1
xor    %eax,%eax
mov    0xd0(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movaps 0x10(%rsp,%rax,1),%xmm0
divps  %xmm12,%xmm0
movaps %xmm1,%xmm4
cmpnleps %xmm0,%xmm4
cvttps2dq %xmm0,%xmm0
andps  %xmm4,%xmm0
andnps %xmm2,%xmm4
orps   %xmm0,%xmm4
movups %xmm4,(%rbx,%rax,1)
add    $0x10,%rax
cmp    %rax,%rcx
jne    1d60 <scale_internal_uint+0xc40>
mov    0xd8(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
je     1dca <scale_internal_uint+0xcaa>
nopw   0x0(%rax,%rax,1)
mov    (%rdi),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movss  0x10(%rsp,%rax,4),%xmm1
divss  %xmm14,%xmm1
ucomiss %xmm0,%xmm1
cvttss2si %xmm1,%edx
cmovae %ecx,%edx
mov    %edx,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r12
jne    1da0 <scale_internal_uint+0xc80>
movaps %xmm11,%xmm4
addss  %xmm3,%xmm4
xor    %ecx,%ecx
ucomiss %xmm10,%xmm4
mov    0x88(%rsp),%rax
lea    (%r8,%rax,1),%eax
seta   %sil
movaps %xmm4,%xmm2
addss  %xmm9,%xmm2
ja     1450 <scale_internal_uint+0x330>
movaps %xmm4,%xmm2
jmp    1450 <scale_internal_uint+0x330>
xchg   %ax,%ax
movaps %xmm13,%xmm2
addss  %xmm5,%xmm2
xor    %ecx,%ecx
ucomiss %xmm10,%xmm2
mov    0x98(%rsp),%rax
lea    (%r11,%rax,1),%eax
seta   %sil
movaps %xmm2,%xmm3
addss  %xmm9,%xmm3
ja     1340 <scale_internal_uint+0x220>
movaps %xmm2,%xmm3
jmp    1340 <scale_internal_uint+0x220>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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