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

/* Variables and functions */
int floor(float);
int /*<<< orphan*/ halveImage_ubyte(int, int, int, float const *, float *, int,
                                    int, int);
void scale_internal_ubyte(GLint components, GLint widthin, GLint heightin,
                          const GLubyte *datain, GLint widthout,
                          GLint heightout, GLubyte *dataout, GLint element_size,
                          GLint ysize, GLint group_size) {
  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_ubyte(components, widthin, heightin, (const GLubyte *)datain,
                     (GLubyte *)dataout, element_size, ysize, group_size);
    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) {
          totals[k] += (GLubyte)(*(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) {
            totals[k] += (GLubyte)(*(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) {
          totals[k] += (GLubyte)(*(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) {
          totals[k] += (GLubyte)(*(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) {
            totals[k] += (GLubyte)(*(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) {
          totals[k] += (GLubyte)(*(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) {
            totals[k] += (GLubyte)(*(left)) * (1 - lowx_float) +
                         (GLubyte)(*(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) {
          totals[k] += (GLubyte)(*(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) {
            totals[k] += (GLubyte)(*(temp_index)) * x_percent;
          }
        }
        percent = x_percent * highy_float;
        temp += ysize;
        for (k = 0, temp_index = temp; k < components;
             k++, temp_index += element_size) {
          totals[k] += (GLubyte)(*(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) {
          totals[k] += (GLubyte)(*(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) {
            totals[k] += (GLubyte)(*(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) {
          totals[k] += (GLubyte)(*(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) {
          totals[k] += (GLubyte)(*(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) {
            totals[k] += (GLubyte)(*(temp_index));
          }
          temp += group_size;
        }
        temp0 += ysize;
      }
      outindex = (j + (i * widthout)) * components;
      for (k = 0; k < components; k++) {
        dataout[outindex + k] = totals[k] / area;
      }
      lowx_int = highx_int;
      lowx_float = highx_float;
      highx_int += convx_int;
      highx_float += convx_float;
      if (highx_float > 1) {
        highx_float -= 1.0;
        highx_int++;
      }
    }
    lowy_int = highy_int;
    lowy_float = highy_float;
    highy_int += convy_int;
    highy_float += convy_float;
    if (highy_float > 1) {
      highy_float -= 1.0;
      highy_int++;
    }
  }
}


x86 assembly (clang, -O0):
<scale_internal_ubyte>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
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    119d <scale_internal_ubyte+0x7d>
mov    -0xc(%rbp),%eax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    119d <scale_internal_ubyte+0x7d>
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),%r10d
mov    0x28(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <halveImage_ubyte@plt>
jmp    1f27 <scale_internal_ubyte+0xe07>
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    1f27 <scale_internal_ubyte+0xe07>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1280 <scale_internal_ubyte+0x160>
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    1e85 <scale_internal_ubyte+0xd65>
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    17ef <scale_internal_ubyte+0x6cf>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    17ef <scale_internal_ubyte+0x6cf>
movss  0xcf5(%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  0xcb9(%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    13ba <scale_internal_ubyte+0x29a>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1367 <scale_internal_ubyte+0x247>
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    146f <scale_internal_ubyte+0x34f>
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    1456 <scale_internal_ubyte+0x336>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1400 <scale_internal_ubyte+0x2e0>
jmp    145b <scale_internal_ubyte+0x33b>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    13d1 <scale_internal_ubyte+0x2b1>
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    1502 <scale_internal_ubyte+0x3e2>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    14af <scale_internal_ubyte+0x38f>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  0xade(%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    15b4 <scale_internal_ubyte+0x494>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1561 <scale_internal_ubyte+0x441>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    165e <scale_internal_ubyte+0x53e>
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    1645 <scale_internal_ubyte+0x525>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    15ef <scale_internal_ubyte+0x4cf>
jmp    164a <scale_internal_ubyte+0x52a>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    15c0 <scale_internal_ubyte+0x4a0>
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    16e6 <scale_internal_ubyte+0x5c6>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1693 <scale_internal_ubyte+0x573>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    17ea <scale_internal_ubyte+0x6ca>
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    17d1 <scale_internal_ubyte+0x6b1>
mov    -0xc0(%rbp),%rax
movsbl (%rax),%eax
cvtsi2ss %eax,%xmm0
movss  -0x90(%rbp),%xmm1
ff
movss  0x89d(%rip),%xmm2
subss  %xmm1,%xmm2
mov    -0xc8(%rbp),%rax
movsbl (%rax),%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)
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    1739 <scale_internal_ubyte+0x619>
jmp    17d6 <scale_internal_ubyte+0x6b6>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    16f2 <scale_internal_ubyte+0x5d2>
jmp    1c97 <scale_internal_ubyte+0xb77>
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jle    19eb <scale_internal_ubyte+0x8cb>
movss  -0x94(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  0x7e2(%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    18b1 <scale_internal_ubyte+0x791>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    185e <scale_internal_ubyte+0x73e>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    195e <scale_internal_ubyte+0x83e>
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    1945 <scale_internal_ubyte+0x825>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    18ef <scale_internal_ubyte+0x7cf>
jmp    194a <scale_internal_ubyte+0x82a>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    18bd <scale_internal_ubyte+0x79d>
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    19e6 <scale_internal_ubyte+0x8c6>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1993 <scale_internal_ubyte+0x873>
jmp    1c92 <scale_internal_ubyte+0xb72>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    1be1 <scale_internal_ubyte+0xac1>
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  0x5e9(%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    1aaa <scale_internal_ubyte+0x98a>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1a57 <scale_internal_ubyte+0x937>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1b54 <scale_internal_ubyte+0xa34>
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    1b3b <scale_internal_ubyte+0xa1b>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1ae5 <scale_internal_ubyte+0x9c5>
jmp    1b40 <scale_internal_ubyte+0xa20>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1ab6 <scale_internal_ubyte+0x996>
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    1bdc <scale_internal_ubyte+0xabc>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1b89 <scale_internal_ubyte+0xa69>
jmp    1c8d <scale_internal_ubyte+0xb6d>
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm1
ff
subss  -0x90(%rbp),%xmm1
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    1c88 <scale_internal_ubyte+0xb68>
mov    -0x70(%rbp),%rax
movsbl (%rax),%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)
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    1c35 <scale_internal_ubyte+0xb15>
jmp    1c8d <scale_internal_ubyte+0xb6d>
jmp    1c92 <scale_internal_ubyte+0xb72>
jmp    1c97 <scale_internal_ubyte+0xb77>
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    1d9d <scale_internal_ubyte+0xc7d>
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    1d78 <scale_internal_ubyte+0xc58>
movl   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1d53 <scale_internal_ubyte+0xc33>
mov    -0x70(%rbp),%rax
movsbl (%rax),%eax
cvtsi2ss %eax,%xmm0
movslq -0x50(%rbp),%rax
addss  -0x40(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
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    1d0d <scale_internal_ubyte+0xbed>
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    1cef <scale_internal_ubyte+0xbcf>
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    1cc9 <scale_internal_ubyte+0xba9>
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    1df2 <scale_internal_ubyte+0xcd2>
movslq -0x50(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
divss  -0x44(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1db7 <scale_internal_ubyte+0xc97>
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  0x1c4(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    1e72 <scale_internal_ubyte+0xd52>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1af(%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    1e77 <scale_internal_ubyte+0xd57>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12b2 <scale_internal_ubyte+0x192>
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  0x128(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    1f14 <scale_internal_ubyte+0xdf4>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x113(%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    1f19 <scale_internal_ubyte+0xdf9>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1259 <scale_internal_ubyte+0x139>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_internal_ubyte>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9d,%ebx
mov    %rcx,0x60(%rsp)
mov    %edi,0x18(%rsp)
mov    0x198(%rsp),%r14d
mov    %r8,0x70(%rsp)
lea    (%r8,%r8,1),%eax
cmp    %esi,%eax
jne    118e <scale_internal_ubyte+0x6e>
lea    (%rbx,%rbx,1),%eax
cmp    %edx,%eax
jne    118e <scale_internal_ubyte+0x6e>
mov    0x18(%rsp),%edi
mov    0x60(%rsp),%rcx
mov    0x190(%rsp),%r8
mov    %r14d,%r9d
mov    0x1a8(%rsp),%eax
push   %rax
mov    0x1a8(%rsp),%eax
push   %rax
call   1030 <halveImage_ubyte@plt>
add    $0x168,%rsp
jmp    230a <scale_internal_ubyte+0x11ea>
cvtsi2ss %edx,%xmm0
cvtsi2ss %ebx,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,0x10(%rsp)
cvtsi2ss %esi,%xmm2
xorps  %xmm1,%xmm1
cvtsi2ssl 0x70(%rsp),%xmm1
divss  %xmm1,%xmm2
movaps %xmm2,0x20(%rsp)
mov    %rdx,0x98(%rsp)
call   1040 <floor@plt>
mov    %rax,0x90(%rsp)
movaps 0x20(%rsp),%xmm0
call   1040 <floor@plt>
movaps 0x20(%rsp),%xmm1
movss  0x10(%rsp),%xmm13
mov    0x98(%rsp),%rdx
mov    %rax,0x80(%rsp)
test   %ebx,%ebx
jle    2303 <scale_internal_ubyte+0x11e3>
mov    0x90(%rsp),%r8
xorps  %xmm0,%xmm0
cvtsi2ss %r8d,%xmm0
xorps  %xmm2,%xmm2
cvtsi2ssl 0x80(%rsp),%xmm2
movaps %xmm1,%xmm12
subss  %xmm2,%xmm12
mulss  %xmm13,%xmm1
subss  %xmm0,%xmm13
movslq %r14d,%r15
mov    0x1a8(%rsp),%eax
movslq %eax,%r13
movslq 0x18(%rsp),%rbp
mov    0x70(%rsp),%r9
movslq %r9d,%r10
mov    %ebx,%ecx
mov    %rcx,0xe0(%rsp)
mov    %ebp,%ebx
mov    %rbx,0x10(%rsp)
lea    -0x1(%rbx),%rsi
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x110(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x108(%rsp)
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %ebx,%edi
and    $0xfffffffe,%edi
movaps %xmm1,%xmm14
shufps $0x0,%xmm1,%xmm14
mov    %rax,%rcx
mov    %rax,0x100(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0xf8(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x20(%rsp)
and    $0xfffffffffffffffe,%rsi
neg    %rsi
lea    (%r15,%r13,1),%rax
mov    0x60(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0xc8(%rsp)
mov    %r10,0xd0(%rsp)
imul   %rbp,%r10
shl    $0x2,%r10
mov    %r10,0xd8(%rsp)
xorps  %xmm8,%xmm8
movss  0x1d18(%rip),%xmm11
xorps  %xmm9,%xmm9
movss  0x1d0f(%rip),%xmm10
movaps %xmm13,%xmm2
xorps  %xmm4,%xmm4
lea    -0x1(%rdx),%eax
mov    %eax,0x8c(%rsp)
mov    0x1a0(%rsp),%eax
movslq %eax,%r10
mov    %r9d,%eax
mov    %rax,0x138(%rsp)
mov    %rsi,%r9
lea    (%rcx,%r13,1),%rax
mov    %rax,0xc0(%rsp)
lea    -0x2(%rbx),%rax
mov    %rax,0x50(%rsp)
lea    (%r15,%r15,1),%r11
mov    0x190(%rsp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,0xa8(%rsp)
mov    %rbp,0xe8(%rsp)
lea    0x0(,%rbp,4),%rcx
mov    %rcx,0x130(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x78(%rsp)
mov    %rax,0xa0(%rsp)
mov    %r8d,%eax
xor    %ecx,%ecx
mov    %rcx,0x68(%rsp)
mov    %rsi,0xb8(%rsp)
jmp    13db <scale_internal_ubyte+0x2bb>
cs nopw 0x0(%rax,%rax,1)
mov    %dl,%cl
add    %ecx,%eax
mov    0x78(%rsp),%rdx
add    $0x1,%rdx
mov    0xd8(%rsp),%rcx
add    %rcx,0xa8(%rsp)
add    %rcx,0xa0(%rsp)
movaps %xmm6,%xmm4
mov    %r8,0x68(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x78(%rsp)
cmp    0xe0(%rsp),%rdx
mov    0x98(%rsp),%rdx
je     2303 <scale_internal_ubyte+0x11e3>
movaps %xmm2,%xmm6
cmp    %edx,%eax
mov    %eax,%r8d
cmovge 0x8c(%rsp),%r8d
cmpl   $0x0,0x70(%rsp)
mov    0x18(%rsp),%r14d
jle    22d0 <scale_internal_ubyte+0x11b0>
movaps %xmm6,%xmm7
subss  %xmm4,%xmm7
mov    0x68(%rsp),%rdx
mov    %edx,%eax
mov    0x1a0(%rsp),%ecx
imul   %ecx,%eax
movslq %eax,%rsi
movaps %xmm11,%xmm3
subss  %xmm4,%xmm3
add    $0x1,%edx
mov    %r8d,%eax
imul   %ecx,%eax
cltq
mov    %rax,0xb0(%rsp)
mov    %edx,0x1c(%rsp)
mov    %edx,%eax
imul   %ecx,%eax
movslq %eax,%rcx
mov    0x78(%rsp),%rax
imul   0xd0(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    0x60(%rsp),%rax
mov    %rsi,0x128(%rsp)
add    %rsi,%rax
mov    %rax,0x58(%rsp)
mov    0xc0(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x118(%rsp)
add    0xc8(%rsp),%rcx
mov    %rcx,0x120(%rsp)
xor    %r12d,%r12d
xorps  %xmm5,%xmm5
mov    0xa0(%rsp),%rsi
mov    0xa8(%rsp),%rbx
movaps %xmm12,%xmm2
mov    0x80(%rsp),%rax
xor    %ebp,%ebp
mov    %r8,0x38(%rsp)
jmp    14ef <scale_internal_ubyte+0x3cf>
nopw   0x0(%rax,%rax,1)
mov    %dl,%cl
add    %ecx,%eax
add    $0x1,%r12
mov    0x130(%rsp),%rcx
add    %rcx,%rbx
add    %rcx,%rsi
movaps %xmm4,%xmm5
cmp    0x138(%rsp),%r12
mov    0xb8(%rsp),%r9
je     22d0 <scale_internal_ubyte+0x11b0>
mov    %eax,%ecx
movaps %xmm2,%xmm4
mov    %ebp,%edx
mov    0x1a8(%rsp),%eax
imul   %eax,%edx
movaps %xmm9,(%rsp)
cmp    0x68(%rsp),%r8d
mov    %rcx,0x30(%rsp)
mov    %r12,0x150(%rsp)
mov    %rsi,0x148(%rsp)
mov    %rbx,0x140(%rsp)
mov    %rbp,0x40(%rsp)
mov    %edx,0x4c(%rsp)
jle    1700 <scale_internal_ubyte+0x5e0>
cmp    %ebp,%ecx
jle    1700 <scale_internal_ubyte+0x5e0>
movslq %edx,%r12
add    0x60(%rsp),%r12
mov    0x128(%rsp),%rax
lea    (%r12,%rax,1),%r8
movaps %xmm11,%xmm2
subss  %xmm5,%xmm2
test   %r14d,%r14d
mov    %rcx,%rbx
jle    1630 <scale_internal_ubyte+0x510>
movaps %xmm3,%xmm5
mulss  %xmm2,%xmm5
movsbl (%r8),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm8,%xmm0
movss  %xmm0,(%rsp)
cmp    $0x1,%r14d
je     1630 <scale_internal_ubyte+0x510>
cmpq   $0x0,0x50(%rsp)
je     2265 <scale_internal_ubyte+0x1145>
mov    $0x1,%eax
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdx,%r15,1),%rcx
movsbl (%rdx,%r15,1),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rax,4),%xmm0
movss  %xmm0,(%rsp,%rax,4)
movsbl (%rdx,%r15,2),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
add    %r15,%rcx
mulss  %xmm5,%xmm0
addss  0x4(%rsp,%rax,4),%xmm0
movss  %xmm0,0x4(%rsp,%rax,4)
lea    (%r9,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
mov    %rcx,%rdx
cmp    $0x1,%rsi
jne    15b0 <scale_internal_ubyte+0x490>
testb  $0x1,0x20(%rsp)
je     1630 <scale_internal_ubyte+0x510>
movsbl (%rcx,%r15,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rax,4),%xmm0
movss  %xmm0,(%rsp,%rax,4)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rbp),%eax
mov    %r8,%r9
cmp    %ebx,%eax
mov    0x10(%rsp),%rbp
jge    1920 <scale_internal_ubyte+0x800>
mov    %eax,%esi
mov    %r8,%r9
jmp    165b <scale_internal_ubyte+0x53b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%esi
cmp    %ebx,%esi
je     1920 <scale_internal_ubyte+0x800>
add    %r13,%r9
test   %r14d,%r14d
jle    1650 <scale_internal_ubyte+0x530>
cmpq   $0x0,0x20(%rsp)
je     16c0 <scale_internal_ubyte+0x5a0>
xor    %ecx,%ecx
mov    %r9,%rdx
movsbl (%rdx),%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  %xmm3,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rdx,%r15,1),%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
add    %r15,%rdx
mulss  %xmm3,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r15,%rdx
cmp    %rcx,%rdi
jne    1670 <scale_internal_ubyte+0x550>
jmp    16c5 <scale_internal_ubyte+0x5a5>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ecx,%ecx
mov    %r9,%rdx
test   $0x1,%bpl
mov    0x18(%rsp),%r14d
mov    0x30(%rsp),%rbx
je     1650 <scale_internal_ubyte+0x530>
movsbl (%rdx),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm3,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
jmp    1650 <scale_internal_ubyte+0x530>
cs nopw 0x0(%rax,%rax,1)
cmp    0x68(%rsp),%r8d
jle    1a40 <scale_internal_ubyte+0x920>
movslq %edx,%rax
add    0x58(%rsp),%rax
movaps %xmm4,%xmm2
subss  %xmm5,%xmm2
test   %r14d,%r14d
jle    17e0 <scale_internal_ubyte+0x6c0>
movaps %xmm3,%xmm5
mulss  %xmm2,%xmm5
movsbl (%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm8,%xmm0
movss  %xmm0,(%rsp)
cmp    $0x1,%r14d
je     17e0 <scale_internal_ubyte+0x6c0>
cmpq   $0x0,0x50(%rsp)
je     227d <scale_internal_ubyte+0x115d>
mov    $0x1,%ecx
mov    %rax,%rsi
lea    (%rsi,%r15,1),%rdx
movsbl (%rsi,%r15,1),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rsi,%r15,2),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
add    %r15,%rdx
mulss  %xmm5,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
lea    (%r9,%rcx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rcx
mov    %rdx,%rsi
cmp    $0x1,%rbp
jne    1760 <scale_internal_ubyte+0x640>
testb  $0x1,0x20(%rsp)
je     17e0 <scale_internal_ubyte+0x6c0>
movsbl (%rdx,%r15,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x1c(%rsp),%ecx
mov    %ecx,%esi
cmp    %r8d,%ecx
jl     187c <scale_internal_ubyte+0x75c>
test   %r14d,%r14d
mov    0x30(%rsp),%rbx
jle    1d70 <scale_internal_ubyte+0xc50>
mulss  %xmm6,%xmm2
add    %r10,%rax
cmpq   $0x0,0x20(%rsp)
je     1d42 <scale_internal_ubyte+0xc22>
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movsbl (%rax),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rax,%r15,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
add    %r15,%rax
mulss  %xmm2,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r15,%rax
cmp    %rcx,%rdi
jne    1820 <scale_internal_ubyte+0x700>
jmp    1ba3 <scale_internal_ubyte+0xa83>
nopl   0x0(%rax,%rax,1)
add    $0x1,%esi
cmp    %r8d,%esi
je     17ef <scale_internal_ubyte+0x6cf>
add    %r10,%rax
test   %r14d,%r14d
jle    1870 <scale_internal_ubyte+0x750>
cmpq   $0x0,0x20(%rsp)
je     18f0 <scale_internal_ubyte+0x7d0>
xor    %ecx,%ecx
mov    %rax,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbl (%rdx),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rdx,%r15,1),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
add    %r15,%rdx
mulss  %xmm2,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r15,%rdx
cmp    %rcx,%rdi
jne    18a0 <scale_internal_ubyte+0x780>
testb  $0x1,0x10(%rsp)
je     1870 <scale_internal_ubyte+0x750>
jmp    1900 <scale_internal_ubyte+0x7e0>
nopl   0x0(%rax)
xor    %ecx,%ecx
mov    %rax,%rdx
testb  $0x1,0x10(%rsp)
je     1870 <scale_internal_ubyte+0x750>
movsbl (%rdx),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
jmp    1870 <scale_internal_ubyte+0x750>
nopl   (%rax)
add    %r13,%r9
test   %r14d,%r14d
jle    1c59 <scale_internal_ubyte+0xb39>
movaps %xmm3,%xmm5
mulss  %xmm4,%xmm5
cmpq   $0x0,0x20(%rsp)
je     1d2e <scale_internal_ubyte+0xc0e>
xor    %ecx,%ecx
mov    %r9,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl (%rdx),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rdx,%r15,1),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
add    %r15,%rdx
mulss  %xmm5,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r15,%rdx
cmp    %rcx,%rdi
jne    1950 <scale_internal_ubyte+0x830>
test   $0x1,%bpl
je     19b1 <scale_internal_ubyte+0x891>
movsbl (%rdx),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
add    0xb0(%rsp),%r12
test   %r14d,%r14d
jle    1ea0 <scale_internal_ubyte+0xd80>
movaps %xmm6,%xmm5
mulss  %xmm2,%xmm5
cmpq   $0x0,0x20(%rsp)
je     1e75 <scale_internal_ubyte+0xd55>
xor    %ecx,%ecx
mov    %r12,%rdx
nopw   0x0(%rax,%rax,1)
movsbl (%rdx),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rdx,%r15,1),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
add    %r15,%rdx
mulss  %xmm5,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r15,%rdx
cmp    %rcx,%rdi
jne    19e0 <scale_internal_ubyte+0x8c0>
test   $0x1,%bpl
jne    1e80 <scale_internal_ubyte+0xd60>
jmp    1ea0 <scale_internal_ubyte+0xd80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %ebp,0x30(%rsp)
jle    1c66 <scale_internal_ubyte+0xb46>
movslq %edx,%rax
add    0x58(%rsp),%rax
test   %r14d,%r14d
mov    0x30(%rsp),%rbx
jle    1b23 <scale_internal_ubyte+0xa03>
movaps %xmm11,%xmm2
subss  %xmm5,%xmm2
mulss  %xmm7,%xmm2
movsbl (%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm8,%xmm0
movss  %xmm0,(%rsp)
cmp    $0x1,%r14d
je     1b23 <scale_internal_ubyte+0xa03>
cmpq   $0x0,0x50(%rsp)
je     2295 <scale_internal_ubyte+0x1175>
mov    $0x1,%ecx
mov    %rax,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rsi,%r15,1),%rdx
movsbl (%rsi,%r15,1),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rsi,%r15,2),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
add    %r15,%rdx
mulss  %xmm2,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
lea    (%r9,%rcx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rcx
mov    %rdx,%rsi
cmp    $0x1,%rbp
jne    1ab0 <scale_internal_ubyte+0x990>
testb  $0x1,0x20(%rsp)
je     1b23 <scale_internal_ubyte+0xa03>
movsbl (%rdx,%r15,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
mov    0x40(%rsp),%rcx
lea    0x1(%rcx),%esi
cmp    %ebx,%esi
jl     1bcb <scale_internal_ubyte+0xaab>
test   %r14d,%r14d
jle    1d70 <scale_internal_ubyte+0xc50>
movaps %xmm7,%xmm2
mulss  %xmm4,%xmm2
add    %r13,%rax
cmpq   $0x0,0x20(%rsp)
je     1d42 <scale_internal_ubyte+0xc22>
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
nopl   0x0(%rax)
movsbl (%rax),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rax,%r15,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
add    %r15,%rax
mulss  %xmm2,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r15,%rax
cmp    %rcx,%rdi
jne    1b60 <scale_internal_ubyte+0xa40>
test   $0x1,%sil
jne    1d4f <scale_internal_ubyte+0xc2f>
jmp    1d70 <scale_internal_ubyte+0xc50>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%esi
cmp    %ebx,%esi
je     1b33 <scale_internal_ubyte+0xa13>
add    %r13,%rax
test   %r14d,%r14d
jle    1bc0 <scale_internal_ubyte+0xaa0>
cmpq   $0x0,0x20(%rsp)
je     1c30 <scale_internal_ubyte+0xb10>
xor    %ecx,%ecx
mov    %rax,%rdx
movsbl (%rdx),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  %xmm7,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rdx,%r15,1),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
add    %r15,%rdx
mulss  %xmm7,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r15,%rdx
cmp    %rcx,%rdi
jne    1be0 <scale_internal_ubyte+0xac0>
testb  $0x1,0x10(%rsp)
je     1bc0 <scale_internal_ubyte+0xaa0>
jmp    1c3c <scale_internal_ubyte+0xb1c>
nopl   0x0(%rax)
xor    %ecx,%ecx
mov    %rax,%rdx
testb  $0x1,0x10(%rsp)
je     1bc0 <scale_internal_ubyte+0xaa0>
movsbl (%rdx),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm7,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
jmp    1bc0 <scale_internal_ubyte+0xaa0>
add    0xb0(%rsp),%r12
jmp    1ea0 <scale_internal_ubyte+0xd80>
test   %r14d,%r14d
mov    0x30(%rsp),%rbx
jle    1d70 <scale_internal_ubyte+0xc50>
movaps %xmm4,%xmm2
subss  %xmm5,%xmm2
mulss  %xmm7,%xmm2
movslq 0x4c(%rsp),%rax
mov    0x58(%rsp),%rcx
movsbl (%rcx,%rax,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm8,%xmm0
movss  %xmm0,(%rsp)
cmp    $0x1,%r14d
je     1d70 <scale_internal_ubyte+0xc50>
add    0x58(%rsp),%rax
cmpq   $0x0,0x50(%rsp)
je     22ad <scale_internal_ubyte+0x118d>
mov    $0x1,%ecx
mov    %rax,%rdx
mov    0xb8(%rsp),%rbp
nopl   (%rax)
lea    (%rdx,%r15,1),%rax
movsbl (%rdx,%r15,1),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rdx,%r15,2),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
add    %r15,%rax
mulss  %xmm2,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
lea    (%rcx,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
mov    %rax,%rdx
cmp    $0x1,%rsi
jne    1cd0 <scale_internal_ubyte+0xbb0>
testb  $0x1,0x20(%rsp)
je     1d70 <scale_internal_ubyte+0xc50>
jmp    22bd <scale_internal_ubyte+0x119d>
xor    %ecx,%ecx
mov    %r9,%rdx
test   $0x1,%bpl
jne    1999 <scale_internal_ubyte+0x879>
jmp    19b1 <scale_internal_ubyte+0x891>
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
test   $0x1,%sil
je     1d70 <scale_internal_ubyte+0xc50>
movsbl (%rax),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm2,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
nopw   0x0(%rax,%rax,1)
mov    0x1c(%rsp),%eax
cmp    0x38(%rsp),%eax
jge    1f45 <scale_internal_ubyte+0xe25>
movslq 0x4c(%rsp),%r9
mov    0x118(%rsp),%rax
lea    (%rax,%r9,1),%r8
mov    0x40(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x40(%rsp)
add    0x120(%rsp),%r9
mov    0x1c(%rsp),%r12d
jmp    1dc5 <scale_internal_ubyte+0xca5>
nopl   0x0(%rax,%rax,1)
add    %r10,%r8
add    $0x1,%r12d
add    %r10,%r9
cmp    0x38(%rsp),%r12d
je     1f45 <scale_internal_ubyte+0xe25>
cmp    %ebx,0x40(%rsp)
jge    1db0 <scale_internal_ubyte+0xc90>
mov    %r9,%rax
mov    0x40(%rsp),%rcx
mov    %ecx,%edx
mov    %r8,%rbp
jmp    1ded <scale_internal_ubyte+0xccd>
nopw   0x0(%rax,%rax,1)
add    %r13,%rbp
add    $0x1,%edx
add    %r13,%rax
cmp    %ebx,%edx
je     1db0 <scale_internal_ubyte+0xc90>
test   %r14d,%r14d
jle    1de0 <scale_internal_ubyte+0xcc0>
cmpq   $0x0,0x20(%rsp)
je     1e50 <scale_internal_ubyte+0xd30>
xor    %esi,%esi
xor    %ecx,%ecx
xchg   %ax,%ax
movsbl 0x0(%rbp,%rsi,1),%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rax,%rsi,1),%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r11,%rsi
cmp    %rcx,%rdi
jne    1e00 <scale_internal_ubyte+0xce0>
add    %rbp,%rsi
mov    0x18(%rsp),%r14d
mov    0x30(%rsp),%rbx
testb  $0x1,0x10(%rsp)
je     1de0 <scale_internal_ubyte+0xcc0>
jmp    1e5c <scale_internal_ubyte+0xd3c>
nop
xor    %ecx,%ecx
mov    %rbp,%rsi
testb  $0x1,0x10(%rsp)
je     1de0 <scale_internal_ubyte+0xcc0>
movsbl (%rsi),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
jmp    1de0 <scale_internal_ubyte+0xcc0>
xor    %ecx,%ecx
mov    %r12,%rdx
test   $0x1,%bpl
je     1ea0 <scale_internal_ubyte+0xd80>
movsbl (%rdx),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
nopl   0x0(%rax,%rax,1)
cmp    %ebx,%eax
jl     1f9b <scale_internal_ubyte+0xe7b>
test   %r14d,%r14d
jle    1f35 <scale_internal_ubyte+0xe15>
movaps %xmm6,%xmm5
mulss  %xmm4,%xmm5
add    %r13,%r12
cmpq   $0x0,0x20(%rsp)
je     223f <scale_internal_ubyte+0x111f>
xor    %eax,%eax
nopl   0x0(%rax)
movsbl (%r12),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rax,4),%xmm0
movss  %xmm0,(%rsp,%rax,4)
movsbl (%r12,%r15,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
add    %r15,%r12
mulss  %xmm5,%xmm0
addss  0x4(%rsp,%rax,4),%xmm0
movss  %xmm0,0x4(%rsp,%rax,4)
add    $0x2,%rax
add    %r15,%r12
cmp    %rax,%rdi
jne    1ed0 <scale_internal_ubyte+0xdb0>
test   $0x1,%bpl
je     1f35 <scale_internal_ubyte+0xe15>
movsbl (%r12),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm5,%xmm0
addss  (%rsp,%rax,4),%xmm0
movss  %xmm0,(%rsp,%rax,4)
mov    0x1c(%rsp),%ecx
mov    %ecx,%eax
cmp    0x38(%rsp),%ecx
jl     204b <scale_internal_ubyte+0xf2b>
test   %r14d,%r14d
mov    0x10(%rsp),%rdx
mov    0x38(%rsp),%r8
mov    0x150(%rsp),%r12
mov    0x148(%rsp),%rsi
mov    0x140(%rsp),%rbx
jle    2207 <scale_internal_ubyte+0x10e7>
cmp    $0x4,%r14d
jae    2160 <scale_internal_ubyte+0x1040>
xor    %eax,%eax
jmp    21f0 <scale_internal_ubyte+0x10d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
cmp    %ebx,%eax
je     1ea8 <scale_internal_ubyte+0xd88>
add    %r13,%r12
test   %r14d,%r14d
jle    1f90 <scale_internal_ubyte+0xe70>
cmpq   $0x0,0x20(%rsp)
je     2000 <scale_internal_ubyte+0xee0>
xor    %ecx,%ecx
mov    %r12,%rdx
movsbl (%rdx),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm6,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
movsbl (%rdx,%r15,1),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
add    %r15,%rdx
mulss  %xmm6,%xmm0
addss  0x4(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsp,%rcx,4)
add    $0x2,%rcx
add    %r15,%rdx
cmp    %rcx,%rdi
jne    1fb0 <scale_internal_ubyte+0xe90>
test   $0x1,%bpl
je     1f90 <scale_internal_ubyte+0xe70>
jmp    200b <scale_internal_ubyte+0xeeb>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %r12,%rdx
test   $0x1,%bpl
je     1f90 <scale_internal_ubyte+0xe70>
movsbl (%rdx),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm6,%xmm0
addss  (%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
jmp    1f90 <scale_internal_ubyte+0xe70>
nopl   0x0(%rax,%rax,1)
mov    %rdx,%r8
mov    %rcx,%r9
mov    0x38(%rsp),%rbx
add    $0x1,%eax
cmp    %ebx,%eax
mov    0x30(%rsp),%rbx
je     1d70 <scale_internal_ubyte+0xc50>
lea    (%r8,%r10,1),%rdx
lea    (%r9,%r10,1),%rcx
test   %r14d,%r14d
jle    2030 <scale_internal_ubyte+0xf10>
cmpq   $0x0,0x20(%rsp)
je     2100 <scale_internal_ubyte+0xfe0>
lea    (%r9,%r15,1),%rcx
lea    (%r8,%r15,1),%rdx
xor    %esi,%esi
xchg   %ax,%ax
movsbl (%r8,%r10,1),%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
movsbl (%r9,%r10,1),%ebx
xorps  %xmm5,%xmm5
cvtsi2ss %ebx,%xmm5
mulss  %xmm4,%xmm5
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
movsbl (%rdx,%r10,1),%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
movsbl (%rcx,%r10,1),%ebx
xorps  %xmm5,%xmm5
cvtsi2ss %ebx,%xmm5
mulss  %xmm4,%xmm5
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
addss  0x4(%rsp,%rsi,4),%xmm0
movss  %xmm0,0x4(%rsp,%rsi,4)
add    $0x2,%rsi
add    %r11,%r9
add    %r11,%rcx
add    %r11,%r8
add    %r11,%rdx
cmp    %rsi,%rdi
jne    2070 <scale_internal_ubyte+0xf50>
add    %r10,%r9
add    %r10,%r8
mov    %r9,%rcx
mov    %r8,%rdx
mov    0x18(%rsp),%r14d
jmp    2102 <scale_internal_ubyte+0xfe2>
cs nopw 0x0(%rax,%rax,1)
xor    %esi,%esi
mov    0x10(%rsp),%rbp
mov    0x38(%rsp),%rbx
test   $0x1,%bpl
je     203b <scale_internal_ubyte+0xf1b>
movsbl (%rdx),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
movsbl (%rcx),%ebp
xorps  %xmm5,%xmm5
cvtsi2ss %ebp,%xmm5
mulss  %xmm4,%xmm5
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
addss  (%rsp,%rsi,4),%xmm0
movss  %xmm0,(%rsp,%rsi,4)
add    %r15,%rdx
add    %r15,%rcx
mov    %rdx,%r8
mov    %rcx,%r9
jmp    203b <scale_internal_ubyte+0xf1b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x108(%rsp)
je     2250 <scale_internal_ubyte+0x1130>
mov    0xf8(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movaps (%rsp,%rax,4),%xmm0
divps  %xmm14,%xmm0
movups %xmm0,-0x10(%rbx,%rax,4)
movaps 0x10(%rsp,%rax,4),%xmm0
divps  %xmm14,%xmm0
movups %xmm0,(%rbx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2180 <scale_internal_ubyte+0x1060>
testb  $0x1,0x100(%rsp)
01
je     21d9 <scale_internal_ubyte+0x10b9>
mov    0xf0(%rsp),%rcx
add    %r12,%rcx
imul   0xe8(%rsp),%rcx
movaps (%rsp,%rax,4),%xmm0
divps  %xmm14,%xmm0
add    %rax,%rcx
mov    0x190(%rsp),%rax
movups %xmm0,(%rax,%rcx,4)
mov    0x110(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdx,%rcx
je     2207 <scale_internal_ubyte+0x10e7>
nopl   0x0(%rax)
movss  (%rsp,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdx
jne    21f0 <scale_internal_ubyte+0x10d0>
movaps %xmm12,%xmm5
addss  %xmm4,%xmm5
xor    %ecx,%ecx
ucomiss %xmm11,%xmm5
mov    0x80(%rsp),%rax
mov    0x30(%rsp),%rbp
lea    0x0(%rbp,%rax,1),%eax
seta   %dl
movaps %xmm5,%xmm2
addss  %xmm10,%xmm2
ja     14c0 <scale_internal_ubyte+0x3a0>
movaps %xmm5,%xmm2
jmp    14c0 <scale_internal_ubyte+0x3a0>
xor    %eax,%eax
test   $0x1,%bpl
jne    1f1b <scale_internal_ubyte+0xdfb>
jmp    1f35 <scale_internal_ubyte+0xe15>
xor    %eax,%eax
testb  $0x1,0x100(%rsp)
01
jne    21ae <scale_internal_ubyte+0x108e>
jmp    21d9 <scale_internal_ubyte+0x10b9>
mov    $0x1,%eax
mov    %r8,%rcx
testb  $0x1,0x20(%rsp)
jne    1609 <scale_internal_ubyte+0x4e9>
jmp    1630 <scale_internal_ubyte+0x510>
mov    $0x1,%ecx
mov    %rax,%rdx
testb  $0x1,0x20(%rsp)
jne    17b9 <scale_internal_ubyte+0x699>
jmp    17e0 <scale_internal_ubyte+0x6c0>
mov    $0x1,%ecx
mov    %rax,%rdx
testb  $0x1,0x20(%rsp)
jne    1b09 <scale_internal_ubyte+0x9e9>
jmp    1b23 <scale_internal_ubyte+0xa03>
mov    $0x1,%ecx
testb  $0x1,0x20(%rsp)
je     1d70 <scale_internal_ubyte+0xc50>
movsbl (%rax,%r15,1),%eax
jmp    1d52 <scale_internal_ubyte+0xc32>
nopw   0x0(%rax,%rax,1)
movaps %xmm13,%xmm3
addss  %xmm6,%xmm3
xor    %ecx,%ecx
ucomiss %xmm11,%xmm3
mov    0x90(%rsp),%rax
lea    (%r8,%rax,1),%eax
seta   %dl
movaps %xmm3,%xmm2
addss  %xmm10,%xmm2
ja     1390 <scale_internal_ubyte+0x270>
movaps %xmm3,%xmm2
jmp    1390 <scale_internal_ubyte+0x270>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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