#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 */

/* Variables and functions */
int gamma_correct(int, float);
int icerp(int, int, int, int, int);
void scale_volume_image_cubic(unsigned char *dst, int dw, int dh, int dd,
                              unsigned char *src, int sw, int sh, int sd,
                              int bpp, int gc, float gamma) {
  int n, x, y, z;
  int ix, iy, iz;
  int wx, wy, wz;
  int a, b, c, d;
  int val, v0, v1, v2, v3;
  int dstride = dw * bpp;
  int sslice = sw * sh * bpp;
  int dslice = dw * dh * bpp;
  unsigned char *s0, *s1, *s2, *s3;
  float invgamma;
  if (gc) {
    invgamma = 1.0 / gamma;
    for (z = 0; z < dd; ++z) {
      if (dd > 1) {
        iz = (((sd - 1) * z) << 7) / (dd - 1);
        if (z == dd - 1)
          --iz;
        wz = iz & 0x7f;
        iz >>= 7;
      } else
        iz = wz = 0;
      for (y = 0; y < dh; ++y) {
        if (dh > 1) {
          iy = (((sh - 1) * y) << 7) / (dh - 1);
          if (y == dh - 1)
            --iy;
          wy = iy & 0x7f;
          iy >>= 7;
        } else
          iy = wy = 0;
        for (x = 0; x < dw; ++x) {
          if (dw > 1) {
            ix = (((sw - 1) * x) << 7) / (dw - 1);
            if (x == dw - 1)
              --ix;
            wx = ix & 0x7f;
            ix >>= 7;
          } else
            ix = wx = 0;
          s0 =
              src + (((iz - 1) * (sw * sh)) + ((iy - 1) * sw) + (ix - 1)) * bpp;
          s1 = s0 + sslice;
          s2 = s1 + sslice;
          s3 = s2 + sslice;
          for (n = 0; n < bpp; ++n) {
            b = icerp(gamma_correct(s1[(sw + 0) * bpp], gamma),
                      gamma_correct(s1[(sw + 1) * bpp], gamma),
                      gamma_correct(s1[(sw + 2) * bpp], gamma),
                      gamma_correct(s1[(sw + 3) * bpp], gamma), wx);
            if (iy > 0) {
              a = icerp(gamma_correct(s1[0], gamma),
                        gamma_correct(s1[bpp], gamma),
                        gamma_correct(s1[2 * bpp], gamma),
                        gamma_correct(s1[3 * bpp], gamma), wx);
            } else
              a = b;
            c = icerp(gamma_correct(s1[(2 * sw + 0) * bpp], gamma),
                      gamma_correct(s1[(2 * sw + 1) * bpp], gamma),
                      gamma_correct(s1[(2 * sw + 2) * bpp], gamma),
                      gamma_correct(s1[(2 * sw + 3) * bpp], gamma), wx);
            if (iy < dh - 1) {
              d = icerp(gamma_correct(s1[(3 * sw + 0) * bpp], gamma),
                        gamma_correct(s1[(3 * sw + 1) * bpp], gamma),
                        gamma_correct(s1[(3 * sw + 2) * bpp], gamma),
                        gamma_correct(s1[(3 * sw + 3) * bpp], gamma), wx);
            } else
              d = c;
            v1 = icerp(a, b, c, d, wy);
            if (iz > 0) {
              b = icerp(gamma_correct(s0[(sw + 0) * bpp], gamma),
                        gamma_correct(s0[(sw + 1) * bpp], gamma),
                        gamma_correct(s0[(sw + 2) * bpp], gamma),
                        gamma_correct(s0[(sw + 3) * bpp], gamma), wx);
              if (iy > 0) {
                a = icerp(gamma_correct(s0[0], gamma),
                          gamma_correct(s0[bpp], gamma),
                          gamma_correct(s0[2 * bpp], gamma),
                          gamma_correct(s0[3 * bpp], gamma), wx);
              } else
                a = b;
              c = icerp(gamma_correct(s0[(2 * sw + 0) * bpp], gamma),
                        gamma_correct(s0[(2 * sw + 1) * bpp], gamma),
                        gamma_correct(s0[(2 * sw + 2) * bpp], gamma),
                        gamma_correct(s0[(2 * sw + 3) * bpp], gamma), wx);
              if (iy < dh - 1) {
                d = icerp(gamma_correct(s0[(3 * sw + 0) * bpp], gamma),
                          gamma_correct(s0[(3 * sw + 1) * bpp], gamma),
                          gamma_correct(s0[(3 * sw + 2) * bpp], gamma),
                          gamma_correct(s0[(3 * sw + 3) * bpp], gamma), wx);
              } else
                d = c;
              v0 = icerp(a, b, c, d, wy);
            } else
              v0 = v1;
            b = icerp(gamma_correct(s2[(sw + 0) * bpp], gamma),
                      gamma_correct(s2[(sw + 1) * bpp], gamma),
                      gamma_correct(s2[(sw + 2) * bpp], gamma),
                      gamma_correct(s2[(sw + 3) * bpp], gamma), wx);
            if (iy > 0) {
              a = icerp(gamma_correct(s2[0], gamma),
                        gamma_correct(s2[bpp], gamma),
                        gamma_correct(s2[2 * bpp], gamma),
                        gamma_correct(s2[3 * bpp], gamma), wx);
            } else
              a = b;
            c = icerp(gamma_correct(s2[(2 * sw + 0) * bpp], gamma),
                      gamma_correct(s2[(2 * sw + 1) * bpp], gamma),
                      gamma_correct(s2[(2 * sw + 2) * bpp], gamma),
                      gamma_correct(s2[(2 * sw + 3) * bpp], gamma), wx);
            if (iy < dh - 1) {
              d = icerp(gamma_correct(s2[(3 * sw + 0) * bpp], gamma),
                        gamma_correct(s2[(3 * sw + 1) * bpp], gamma),
                        gamma_correct(s2[(3 * sw + 2) * bpp], gamma),
                        gamma_correct(s2[(3 * sw + 3) * bpp], gamma), wx);
            } else
              d = c;
            v2 = icerp(a, b, c, d, wy);
            if (iz < dd - 1) {
              b = icerp(gamma_correct(s3[(sw + 0) * bpp], gamma),
                        gamma_correct(s3[(sw + 1) * bpp], gamma),
                        gamma_correct(s3[(sw + 2) * bpp], gamma),
                        gamma_correct(s3[(sw + 3) * bpp], gamma), wx);
              if (iy > 0) {
                a = icerp(gamma_correct(s3[0], gamma),
                          gamma_correct(s3[bpp], gamma),
                          gamma_correct(s3[2 * bpp], gamma),
                          gamma_correct(s3[3 * bpp], gamma), wx);
              } else
                a = b;
              c = icerp(gamma_correct(s3[(2 * sw + 0) * bpp], gamma),
                        gamma_correct(s3[(2 * sw + 1) * bpp], gamma),
                        gamma_correct(s3[(2 * sw + 2) * bpp], gamma),
                        gamma_correct(s3[(2 * sw + 3) * bpp], gamma), wx);
              if (iy < dh - 1) {
                d = icerp(gamma_correct(s3[(3 * sw + 0) * bpp], gamma),
                          gamma_correct(s3[(3 * sw + 1) * bpp], gamma),
                          gamma_correct(s3[(3 * sw + 2) * bpp], gamma),
                          gamma_correct(s3[(3 * sw + 3) * bpp], gamma), wx);
              } else
                d = c;
              v3 = icerp(a, b, c, d, wy);
            } else
              v3 = v2;
            val = icerp(v0, v1, v2, v3, wz);
            if (val < 0)
              val = 0;
            if (val > 255)
              val = 255;
            dst[(z * dslice) + (y * dstride) + (x * bpp) + n] =
                gamma_correct(val, invgamma);
            ++s0;
            ++s1;
            ++s2;
            ++s3;
          }
        }
      }
    }
  } else {
    for (z = 0; z < dd; ++z) {
      if (dd > 1) {
        iz = (((sd - 1) * z) << 7) / (dd - 1);
        if (z == dd - 1)
          --iz;
        wz = iz & 0x7f;
        iz >>= 7;
      } else
        iz = wz = 0;
      for (y = 0; y < dh; ++y) {
        if (dh > 1) {
          iy = (((sh - 1) * y) << 7) / (dh - 1);
          if (y == dh - 1)
            --iy;
          wy = iy & 0x7f;
          iy >>= 7;
        } else
          iy = wy = 0;
        for (x = 0; x < dw; ++x) {
          if (dw > 1) {
            ix = (((sw - 1) * x) << 7) / (dw - 1);
            if (x == dw - 1)
              --ix;
            wx = ix & 0x7f;
            ix >>= 7;
          } else
            ix = wx = 0;
          s0 =
              src + (((iz - 1) * (sw * sh)) + ((iy - 1) * sw) + (ix - 1)) * bpp;
          s1 = s0 + sslice;
          s2 = s1 + sslice;
          s3 = s2 + sslice;
          for (n = 0; n < bpp; ++n) {
            b = icerp(s1[(sw + 0) * bpp], s1[(sw + 1) * bpp],
                      s1[(sw + 2) * bpp], s1[(sw + 3) * bpp], wx);
            if (iy > 0) {
              a = icerp(s1[0], s1[bpp], s1[2 * bpp], s1[3 * bpp], wx);
            } else
              a = b;
            c = icerp(s1[(2 * sw + 0) * bpp], s1[(2 * sw + 1) * bpp],
                      s1[(2 * sw + 2) * bpp], s1[(2 * sw + 3) * bpp], wx);
            if (iy < dh - 1) {
              d = icerp(s1[(3 * sw + 0) * bpp], s1[(3 * sw + 1) * bpp],
                        s1[(3 * sw + 2) * bpp], s1[(3 * sw + 3) * bpp], wx);
            } else
              d = c;
            v1 = icerp(a, b, c, d, wy);
            if (iz > 0) {
              b = icerp(s0[(sw + 0) * bpp], s0[(sw + 1) * bpp],
                        s0[(sw + 2) * bpp], s0[(sw + 3) * bpp], wx);
              if (iy > 0) {
                a = icerp(s0[0], s0[bpp], s0[2 * bpp], s0[3 * bpp], wx);
              } else
                a = b;
              c = icerp(s0[(2 * sw + 0) * bpp], s0[(2 * sw + 1) * bpp],
                        s0[(2 * sw + 2) * bpp], s0[(2 * sw + 3) * bpp], wx);
              if (iy < dh - 1) {
                d = icerp(s0[(3 * sw + 0) * bpp], s0[(3 * sw + 1) * bpp],
                          s0[(3 * sw + 2) * bpp], s0[(3 * sw + 3) * bpp], wx);
              } else
                d = c;
              v0 = icerp(a, b, c, d, wy);
            } else
              v0 = v1;
            b = icerp(s2[(sw + 0) * bpp], s2[(sw + 1) * bpp],
                      s2[(sw + 2) * bpp], s2[(sw + 3) * bpp], wx);
            if (iy > 0) {
              a = icerp(s2[0], s2[bpp], s2[2 * bpp], s2[3 * bpp], wx);
            } else
              a = b;
            c = icerp(s2[(2 * sw + 0) * bpp], s2[(2 * sw + 1) * bpp],
                      s2[(2 * sw + 2) * bpp], s2[(2 * sw + 3) * bpp], wx);
            if (iy < dh - 1) {
              d = icerp(s2[(3 * sw + 0) * bpp], s2[(3 * sw + 1) * bpp],
                        s2[(3 * sw + 2) * bpp], s2[(3 * sw + 3) * bpp], wx);
            } else
              d = c;
            v2 = icerp(a, b, c, d, wy);
            if (iz < dd - 1) {
              b = icerp(s3[(sw + 0) * bpp], s3[(sw + 1) * bpp],
                        s3[(sw + 2) * bpp], s3[(sw + 3) * bpp], wx);
              if (iy > 0) {
                a = icerp(s3[0], s3[bpp], s3[2 * bpp], s3[3 * bpp], wx);
              } else
                a = b;
              c = icerp(s3[(2 * sw + 0) * bpp], s3[(2 * sw + 1) * bpp],
                        s3[(2 * sw + 2) * bpp], s3[(2 * sw + 3) * bpp], wx);
              if (iy < dh - 1) {
                d = icerp(s3[(3 * sw + 0) * bpp], s3[(3 * sw + 1) * bpp],
                          s3[(3 * sw + 2) * bpp], s3[(3 * sw + 3) * bpp], wx);
              } else
                d = c;
              v3 = icerp(a, b, c, d, wy);
            } else
              v3 = v2;
            val = icerp(v0, v1, v2, v3, wz);
            if (val < 0)
              val = 0;
            if (val > 255)
              val = 255;
            dst[(z * dslice) + (y * dstride) + (x * bpp) + n] = val;
            ++s0;
            ++s1;
            ++s2;
            ++s3;
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<scale_volume_image_cubic>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movss  %xmm0,-0x28(%rbp)
mov    -0xc(%rbp),%eax
imul   0x20(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x24(%rbp),%eax
imul   0x10(%rbp),%eax
imul   0x20(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
imul   0x20(%rbp),%eax
mov    %eax,-0x80(%rbp)
cmpl   $0x0,0x28(%rbp)
je     2146 <scale_volume_image_cubic+0x1026>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1e6e(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2141 <scale_volume_image_cubic+0x1021>
cmpl   $0x1,-0x14(%rbp)
jle    1209 <scale_volume_image_cubic+0xe9>
mov    0x18(%rbp),%eax
sub    $0x1,%eax
imul   -0x38(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    11f2 <scale_volume_image_cubic+0xd2>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
sar    $0x7,%eax
mov    %eax,-0x44(%rbp)
jmp    1217 <scale_volume_image_cubic+0xf7>
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    212e <scale_volume_image_cubic+0x100e>
cmpl   $0x1,-0x10(%rbp)
jle    127e <scale_volume_image_cubic+0x15e>
mov    0x10(%rbp),%eax
sub    $0x1,%eax
imul   -0x34(%rbp),%eax
shl    $0x7,%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1267 <scale_volume_image_cubic+0x147>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%eax
sar    $0x7,%eax
mov    %eax,-0x40(%rbp)
jmp    128c <scale_volume_image_cubic+0x16c>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    211b <scale_volume_image_cubic+0xffb>
cmpl   $0x1,-0xc(%rbp)
jle    12f3 <scale_volume_image_cubic+0x1d3>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
imul   -0x30(%rbp),%eax
shl    $0x7,%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    12dc <scale_volume_image_cubic+0x1bc>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
sar    $0x7,%eax
mov    %eax,-0x3c(%rbp)
jmp    1301 <scale_volume_image_cubic+0x1e1>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
imul   0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x7c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x7c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x7c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2108 <scale_volume_image_cubic+0xfe8>
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xb0(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xac(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xa8(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0xb0(%rbp),%edi
mov    -0xac(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    14ee <scale_volume_image_cubic+0x3ce>
mov    -0x90(%rbp),%rax
movzbl (%rax),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xbc(%rbp)
mov    -0x90(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xb8(%rbp)
mov    -0x90(%rbp),%rax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xb4(%rbp)
mov    -0x90(%rbp),%rax
imul   $0x3,0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0xbc(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0xb4(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x54(%rbp)
jmp    14f4 <scale_volume_image_cubic+0x3d4>
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xc4(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xc0(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0xc8(%rbp),%edi
mov    -0xc4(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    168e <scale_volume_image_cubic+0x56e>
mov    -0x90(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xd4(%rbp)
mov    -0x90(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xd0(%rbp)
mov    -0x90(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xcc(%rbp)
mov    -0x90(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0xd4(%rbp),%edi
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x60(%rbp)
jmp    1694 <scale_volume_image_cubic+0x574>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    19db <scale_volume_image_cubic+0x8bb>
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xe0(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xdc(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xd8(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0xe0(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    1818 <scale_volume_image_cubic+0x6f8>
mov    -0x88(%rbp),%rax
movzbl (%rax),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xec(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xe8(%rbp)
mov    -0x88(%rbp),%rax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xe4(%rbp)
mov    -0x88(%rbp),%rax
imul   $0x3,0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0xec(%rbp),%edi
mov    -0xe8(%rbp),%esi
mov    -0xe4(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x54(%rbp)
jmp    181e <scale_volume_image_cubic+0x6fe>
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xf4(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xf0(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0xf8(%rbp),%edi
mov    -0xf4(%rbp),%esi
mov    -0xf0(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    19b8 <scale_volume_image_cubic+0x898>
mov    -0x88(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x104(%rbp)
mov    -0x88(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x100(%rbp)
mov    -0x88(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0xfc(%rbp)
mov    -0x88(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x104(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0xfc(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x60(%rbp)
jmp    19be <scale_volume_image_cubic+0x89e>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x68(%rbp)
jmp    19e1 <scale_volume_image_cubic+0x8c1>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x110(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x10c(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x108(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x110(%rbp),%edi
mov    -0x10c(%rbp),%esi
mov    -0x108(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    1b43 <scale_volume_image_cubic+0xa23>
mov    -0x98(%rbp),%rax
movzbl (%rax),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x11c(%rbp)
mov    -0x98(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x118(%rbp)
mov    -0x98(%rbp),%rax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x114(%rbp)
mov    -0x98(%rbp),%rax
imul   $0x3,0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x11c(%rbp),%edi
mov    -0x118(%rbp),%esi
mov    -0x114(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x54(%rbp)
jmp    1b49 <scale_volume_image_cubic+0xa29>
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x128(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x124(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x120(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x128(%rbp),%edi
mov    -0x124(%rbp),%esi
mov    -0x120(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1ce3 <scale_volume_image_cubic+0xbc3>
mov    -0x98(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x134(%rbp)
mov    -0x98(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x130(%rbp)
mov    -0x98(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x12c(%rbp)
mov    -0x98(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x134(%rbp),%edi
mov    -0x130(%rbp),%esi
mov    -0x12c(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x60(%rbp)
jmp    1ce9 <scale_volume_image_cubic+0xbc9>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2037 <scale_volume_image_cubic+0xf17>
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x140(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x13c(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x138(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x140(%rbp),%edi
mov    -0x13c(%rbp),%esi
mov    -0x138(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    1e74 <scale_volume_image_cubic+0xd54>
mov    -0xa0(%rbp),%rax
movzbl (%rax),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x14c(%rbp)
mov    -0xa0(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x148(%rbp)
mov    -0xa0(%rbp),%rax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x144(%rbp)
mov    -0xa0(%rbp),%rax
imul   $0x3,0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x14c(%rbp),%edi
mov    -0x148(%rbp),%esi
mov    -0x144(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x54(%rbp)
jmp    1e7a <scale_volume_image_cubic+0xd5a>
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x158(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x154(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x150(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x158(%rbp),%edi
mov    -0x154(%rbp),%esi
mov    -0x150(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2014 <scale_volume_image_cubic+0xef4>
mov    -0xa0(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x164(%rbp)
mov    -0xa0(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x160(%rbp)
mov    -0xa0(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,-0x15c(%rbp)
mov    -0xa0(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
movss  -0x28(%rbp),%xmm0
call   1030 <gamma_correct@plt>
mov    -0x164(%rbp),%edi
mov    -0x160(%rbp),%esi
mov    -0x15c(%rbp),%edx
mov    %eax,%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x60(%rbp)
jmp    201a <scale_volume_image_cubic+0xefa>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x74(%rbp)
jmp    203d <scale_volume_image_cubic+0xf1d>
mov    -0x70(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x68(%rbp),%edi
mov    -0x6c(%rbp),%esi
mov    -0x70(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x50(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jge    2066 <scale_volume_image_cubic+0xf46>
movl   $0x0,-0x64(%rbp)
cmpl   $0xff,-0x64(%rbp)
jle    207a <scale_volume_image_cubic+0xf5a>
movl   $0xff,-0x64(%rbp)
mov    -0x64(%rbp),%edi
movss  -0xa4(%rbp),%xmm0
ff
call   1030 <gamma_correct@plt>
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x80(%rbp),%ecx
mov    -0x34(%rbp),%esi
imul   -0x78(%rbp),%esi
add    %esi,%ecx
mov    -0x30(%rbp),%esi
imul   0x20(%rbp),%esi
add    %esi,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1380 <scale_volume_image_cubic+0x260>
jmp    210d <scale_volume_image_cubic+0xfed>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1293 <scale_volume_image_cubic+0x173>
jmp    2120 <scale_volume_image_cubic+0x1000>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121e <scale_volume_image_cubic+0xfe>
jmp    2133 <scale_volume_image_cubic+0x1013>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11a9 <scale_volume_image_cubic+0x89>
jmp    2bfd <scale_volume_image_cubic+0x1add>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2bf8 <scale_volume_image_cubic+0x1ad8>
cmpl   $0x1,-0x14(%rbp)
jle    21ad <scale_volume_image_cubic+0x108d>
mov    0x18(%rbp),%eax
sub    $0x1,%eax
imul   -0x38(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    2196 <scale_volume_image_cubic+0x1076>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
sar    $0x7,%eax
mov    %eax,-0x44(%rbp)
jmp    21bb <scale_volume_image_cubic+0x109b>
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2be5 <scale_volume_image_cubic+0x1ac5>
cmpl   $0x1,-0x10(%rbp)
jle    2222 <scale_volume_image_cubic+0x1102>
mov    0x10(%rbp),%eax
sub    $0x1,%eax
imul   -0x34(%rbp),%eax
shl    $0x7,%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    220b <scale_volume_image_cubic+0x10eb>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%eax
sar    $0x7,%eax
mov    %eax,-0x40(%rbp)
jmp    2230 <scale_volume_image_cubic+0x1110>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2bd2 <scale_volume_image_cubic+0x1ab2>
cmpl   $0x1,-0xc(%rbp)
jle    2297 <scale_volume_image_cubic+0x1177>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
imul   -0x30(%rbp),%eax
shl    $0x7,%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    2280 <scale_volume_image_cubic+0x1160>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
sar    $0x7,%eax
mov    %eax,-0x3c(%rbp)
jmp    22a5 <scale_volume_image_cubic+0x1185>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
imul   0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x7c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x7c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x7c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2bbf <scale_volume_image_cubic+0x1a9f>
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    23f6 <scale_volume_image_cubic+0x12d6>
mov    -0x90(%rbp),%rax
movzbl (%rax),%edi
mov    -0x90(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x90(%rbp),%rax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x90(%rbp),%rax
imul   $0x3,0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x54(%rbp)
jmp    23fc <scale_volume_image_cubic+0x12dc>
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x90(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    24fa <scale_volume_image_cubic+0x13da>
mov    -0x90(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x90(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x90(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x90(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x60(%rbp)
jmp    2500 <scale_volume_image_cubic+0x13e0>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    270f <scale_volume_image_cubic+0x15ef>
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    25e8 <scale_volume_image_cubic+0x14c8>
mov    -0x88(%rbp),%rax
movzbl (%rax),%edi
mov    -0x88(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x88(%rbp),%rax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x88(%rbp),%rax
imul   $0x3,0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x54(%rbp)
jmp    25ee <scale_volume_image_cubic+0x14ce>
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x88(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    26ec <scale_volume_image_cubic+0x15cc>
mov    -0x88(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x88(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x88(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x88(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x60(%rbp)
jmp    26f2 <scale_volume_image_cubic+0x15d2>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x68(%rbp)
jmp    2715 <scale_volume_image_cubic+0x15f5>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    27db <scale_volume_image_cubic+0x16bb>
mov    -0x98(%rbp),%rax
movzbl (%rax),%edi
mov    -0x98(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x98(%rbp),%rax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x98(%rbp),%rax
imul   $0x3,0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x54(%rbp)
jmp    27e1 <scale_volume_image_cubic+0x16c1>
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x98(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    28df <scale_volume_image_cubic+0x17bf>
mov    -0x98(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x98(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x98(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x98(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x60(%rbp)
jmp    28e5 <scale_volume_image_cubic+0x17c5>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2afb <scale_volume_image_cubic+0x19db>
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    29d4 <scale_volume_image_cubic+0x18b4>
mov    -0xa0(%rbp),%rax
movzbl (%rax),%edi
mov    -0xa0(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0xa0(%rbp),%rax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0xa0(%rbp),%rax
imul   $0x3,0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x54(%rbp)
jmp    29da <scale_volume_image_cubic+0x18ba>
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0xa0(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2ad8 <scale_volume_image_cubic+0x19b8>
mov    -0xa0(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0xa0(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0xa0(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0xa0(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x3,%ecx
imul   0x20(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x60(%rbp)
jmp    2ade <scale_volume_image_cubic+0x19be>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x74(%rbp)
jmp    2b01 <scale_volume_image_cubic+0x19e1>
mov    -0x70(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x68(%rbp),%edi
mov    -0x6c(%rbp),%esi
mov    -0x70(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x50(%rbp),%r8d
call   1040 <icerp@plt>
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jge    2b2a <scale_volume_image_cubic+0x1a0a>
movl   $0x0,-0x64(%rbp)
cmpl   $0xff,-0x64(%rbp)
jle    2b3e <scale_volume_image_cubic+0x1a1e>
movl   $0xff,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x80(%rbp),%ecx
mov    -0x34(%rbp),%esi
imul   -0x78(%rbp),%esi
add    %esi,%ecx
mov    -0x30(%rbp),%esi
imul   0x20(%rbp),%esi
add    %esi,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2324 <scale_volume_image_cubic+0x1204>
jmp    2bc4 <scale_volume_image_cubic+0x1aa4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2237 <scale_volume_image_cubic+0x1117>
jmp    2bd7 <scale_volume_image_cubic+0x1ab7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    21c2 <scale_volume_image_cubic+0x10a2>
jmp    2bea <scale_volume_image_cubic+0x1aca>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    214d <scale_volume_image_cubic+0x102d>
jmp    2bfd <scale_volume_image_cubic+0x1add>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_volume_image_cubic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x518,%rsp
mov    %r8,0x120(%rsp)
mov    %rdi,0x108(%rsp)
mov    0x560(%rsp),%edi
mov    0x558(%rsp),%ebx
mov    0x550(%rsp),%ebp
mov    %edi,%eax
mov    %rsi,0x90(%rsp)
imul   %esi,%eax
mov    %ebp,%esi
mov    %r9,0x110(%rsp)
imul   %r9d,%ebp
mov    %ebp,0x104(%rsp)
imul   %edi,%ebp
mov    %eax,%edi
mov    %rdx,0x78(%rsp)
imul   %edx,%edi
cmpl   $0x0,0x568(%rsp)
mov    %rcx,0x4f0(%rsp)
je     2742 <scale_volume_image_cubic+0x1622>
test   %ecx,%ecx
jle    388e <scale_volume_image_cubic+0x276e>
movss  0x2e55(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x468(%rsp)
shl    $0x7,%ebx
add    $0xffffff80,%ebx
mov    %ebx,0x70(%rsp)
shl    $0x7,%esi
add    $0xffffff80,%esi
mov    %esi,0x74(%rsp)
mov    0x110(%rsp),%rsi
mov    %esi,%edx
shl    $0x7,%edx
add    $0xffffff80,%edx
mov    %edx,0x158(%rsp)
movslq %ebp,%rbx
mov    0x560(%rsp),%ebp
mov    %ebp,%edx
imul   %esi,%edx
movslq %edx,%r14
mov    %r14,0x58(%rsp)
lea    0x1(%rsi),%edx
imul   %ebp,%edx
movslq %edx,%r11
mov    %r11,0x50(%rsp)
lea    0x2(%rsi),%edx
imul   %ebp,%edx
movslq %edx,%r13
lea    0x3(%rsi),%edx
imul   %ebp,%edx
movslq %edx,%r9
lea    (%rsi,%rsi,1),%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0xd8(%rsp)
lea    (%rsi,%rsi,1),%edx
add    $0x1,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0xd0(%rsp)
lea    (%rsi,%rsi,1),%edx
add    $0x2,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0x38(%rsp)
lea    (%rsi,%rsi,1),%edx
add    $0x3,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0xc8(%rsp)
lea    (%rsi,%rsi,2),%edx
imul   %ebp,%edx
movslq %edx,%r8
lea    (%rsi,%rsi,2),%edx
add    $0x1,%edx
imul   %ebp,%edx
movslq %edx,%r15
mov    %r15,0x30(%rsp)
lea    (%rsi,%rsi,2),%edx
add    $0x2,%edx
imul   %ebp,%edx
movslq %edx,%r12
lea    (%rsi,%rsi,2),%edx
add    $0x3,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0x28(%rsp)
cltq
mov    %rax,0x140(%rsp)
movslq %edi,%rax
mov    %rax,0x500(%rsp)
lea    (%rbx,%rbx,2),%rax
lea    (%rax,%rdx,1),%rdi
mov    0x120(%rsp),%rdx
add    %rdx,%rdi
mov    %rdi,0x2c8(%rsp)
lea    (%rax,%r12,1),%rdi
add    %rdx,%rdi
mov    %rdi,0x2c0(%rsp)
lea    (%rax,%r15,1),%rdi
add    %rdx,%rdi
mov    %rdi,0x2b8(%rsp)
lea    (%rax,%r8,1),%rdi
mov    %r8,0xc0(%rsp)
add    %rdx,%rdi
mov    %rdi,0x2b0(%rsp)
lea    (%rax,%r14,1),%rdi
add    %rdx,%rdi
mov    %rdi,0x2a8(%rsp)
lea    (%rax,%r11,1),%rdi
add    %rdx,%rdi
mov    %rdi,0x2a0(%rsp)
lea    (%rax,%r13,1),%rdi
mov    %r13,0x48(%rsp)
add    %rdx,%rdi
mov    %rdi,0x298(%rsp)
lea    (%rax,%r9,1),%rdi
mov    %r9,0x80(%rsp)
add    %rdx,%rdi
mov    %rdi,0x290(%rsp)
movslq %ebp,%rdi
lea    (%rax,%rdi,1),%rbp
add    %rdx,%rbp
mov    %rbp,0x288(%rsp)
lea    (%rax,%rdi,2),%rbp
add    %rdx,%rbp
mov    %rbp,0x280(%rsp)
lea    (%rdi,%rdi,2),%rbp
lea    (%rax,%rbp,1),%r11
add    %rdx,%r11
mov    %r11,0x270(%rsp)
mov    0xd8(%rsp),%r11
lea    (%rax,%r11,1),%rsi
add    %rdx,%rsi
mov    %rsi,0x268(%rsp)
mov    0xd0(%rsp),%r15
lea    (%rax,%r15,1),%rsi
add    %rdx,%rsi
mov    %rsi,0x260(%rsp)
mov    0x38(%rsp),%r10
lea    (%rax,%r10,1),%rsi
add    %rdx,%rsi
mov    %rsi,0x258(%rsp)
mov    0xc8(%rsp),%r14
add    %r14,%rax
add    %rdx,%rax
mov    %rax,0x2d0(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x250(%rsp)
mov    %r12,0x118(%rsp)
lea    (%r12,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x248(%rsp)
mov    0x30(%rsp),%rax
lea    (%rax,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x240(%rsp)
lea    (%r8,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x238(%rsp)
mov    0x58(%rsp),%rsi
lea    (%rsi,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x230(%rsp)
mov    0x50(%rsp),%r8
lea    (%r8,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x228(%rsp)
lea    0x0(,%rbx,2),%rax
add    %r13,%rax
add    %rdx,%rax
mov    %rax,0x220(%rsp)
lea    (%r9,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x218(%rsp)
lea    (%rdi,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x210(%rsp)
lea    (%rdi,%rdi,1),%rax
lea    (%rax,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x208(%rsp)
lea    0x0(,%rbx,2),%rax
add    %rbp,%rax
add    %rdx,%rax
mov    %rax,0x200(%rsp)
lea    (%r11,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x1f8(%rsp)
mov    %r15,%r9
lea    (%r15,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x1f0(%rsp)
lea    (%r10,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x1e8(%rsp)
mov    %r14,%r10
lea    (%r14,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x1e0(%rsp)
mov    0x28(%rsp),%r13
lea    (%rbx,%r13,1),%rax
add    %rdx,%rax
mov    %rax,0x1d8(%rsp)
lea    (%rbx,%r12,1),%rax
add    %rdx,%rax
mov    %rax,0x1d0(%rsp)
mov    0x30(%rsp),%r15
lea    (%rbx,%r15,1),%rax
add    %rdx,%rax
mov    %rax,0x1c8(%rsp)
mov    0xc0(%rsp),%r14
lea    (%rbx,%r14,1),%rax
add    %rdx,%rax
mov    %rax,0x1c0(%rsp)
lea    (%rbx,%rsi,1),%rax
add    %rdx,%rax
mov    %rax,0x1b8(%rsp)
lea    (%rbx,%r8,1),%rax
add    %rdx,%rax
mov    %rax,0x1b0(%rsp)
mov    0x48(%rsp),%r8
lea    (%rbx,%r8,1),%rax
add    %rdx,%rax
mov    %rax,0x1a8(%rsp)
mov    0x80(%rsp),%rsi
lea    (%rbx,%rsi,1),%rax
add    %rdx,%rax
mov    %rax,0x1a0(%rsp)
lea    (%rdi,%rbx,1),%rax
add    %rdx,%rax
mov    %rax,0x198(%rsp)
lea    (%rbx,%rdi,2),%rax
add    %rdx,%rax
mov    %rax,0x190(%rsp)
lea    (%rbx,%rbp,1),%rax
add    %rdx,%rax
mov    %rax,0x188(%rsp)
lea    (%rbx,%r11,1),%rax
mov    %r11,%r12
add    %rdx,%rax
mov    %rax,0x180(%rsp)
lea    (%rbx,%r9,1),%rax
mov    %r9,%r11
add    %rdx,%rax
mov    %rax,0x178(%rsp)
mov    0x38(%rsp),%r9
lea    (%rbx,%r9,1),%rax
add    %rdx,%rax
mov    %rax,0x170(%rsp)
mov    %rbx,0x2d8(%rsp)
lea    (%rbx,%r10,1),%rax
mov    %r10,%rbx
add    %rdx,%rax
mov    %rax,0xb8(%rsp)
mov    %r13,%rax
add    %rdx,%rax
mov    %rax,0x28(%rsp)
add    %rdx,0x118(%rsp)
mov    %r15,%rax
add    %rdx,%rax
mov    %rax,0x30(%rsp)
mov    %r14,%rax
add    %rdx,%rax
mov    %rax,0xc0(%rsp)
add    %rdx,0x58(%rsp)
add    %rdx,0x50(%rsp)
add    %rdx,%r8
mov    %r8,0x48(%rsp)
add    %rdx,%rsi
mov    %rsi,0x80(%rsp)
add    %rdx,%rbp
mov    %rbp,0x278(%rsp)
add    %rdx,%r12
mov    %r12,0xd8(%rsp)
add    %rdx,%r11
mov    %r11,0xd0(%rsp)
mov    %r9,%rax
add    %rdx,%rax
mov    %rax,0x38(%rsp)
mov    %r10,%rax
add    %rdx,%rax
mov    %rax,0xc8(%rsp)
lea    -0x1(%rcx),%eax
mov    %rax,0x128(%rsp)
mov    0x78(%rsp),%rax
lea    -0x1(%rax),%esi
mov    %rsi,0x20(%rsp)
mov    0x90(%rsp),%rsi
lea    -0x1(%rsi),%ebp
mov    %rbp,0x150(%rsp)
mov    %ecx,%ebp
mov    %rbp,0x4f8(%rsp)
mov    %eax,%eax
mov    %rax,0x510(%rsp)
mov    %esi,%eax
mov    %rax,0xe8(%rsp)
mov    %edi,%eax
mov    %rax,0x460(%rsp)
lea    (%rdx,%rdi,1),%rax
mov    %rax,0x168(%rsp)
mov    %rdi,0x88(%rsp)
lea    (%rdx,%rdi,2),%rax
mov    %rax,0x160(%rsp)
xor    %esi,%esi
movss  %xmm0,0x8(%rsp)
jmp    1732 <scale_volume_image_cubic+0x612>
mov    0x508(%rsp),%rsi
add    $0x1,%rsi
mov    0x500(%rsp),%rax
add    %rax,0x108(%rsp)
cmp    0x4f8(%rsp),%rsi
mov    0x4f0(%rsp),%rcx
je     388e <scale_volume_image_cubic+0x276e>
mov    $0x0,%eax
mov    %rax,0xa8(%rsp)
movl   $0x0,0x130(%rsp)
cmp    $0x1,%ecx
je     1782 <scale_volume_image_cubic+0x662>
mov    0x70(%rsp),%eax
imul   %esi,%eax
cltd
mov    0x128(%rsp),%rcx
idiv   %ecx
xor    %edx,%edx
cmp    %rcx,%rsi
sete   %dl
sub    %edx,%eax
mov    %eax,%ecx
and    $0x7f,%ecx
mov    %ecx,0x130(%rsp)
sar    $0x7,%eax
mov    %rax,0xa8(%rsp)
mov    %rsi,0x508(%rsp)
cmpl   $0x0,0x78(%rsp)
jle    1700 <scale_volume_image_cubic+0x5e0>
mov    0xa8(%rsp),%rax
add    $0xffffffff,%eax
imul   0x104(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4ec(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0xb0(%rsp)
xor    %esi,%esi
jmp    1802 <scale_volume_image_cubic+0x6e2>
cs nopw 0x0(%rax,%rax,1)
mov    0x148(%rsp),%rsi
add    $0x1,%rsi
mov    0xb0(%rsp),%rax
add    0x140(%rsp),%rax
mov    %rax,0xb0(%rsp)
cmp    0x510(%rsp),%rsi
je     1700 <scale_volume_image_cubic+0x5e0>
xor    %eax,%eax
movl   $0x0,0x18(%rsp)
cmpl   $0x2,0x78(%rsp)
jl     1838 <scale_volume_image_cubic+0x718>
mov    0x74(%rsp),%eax
imul   %esi,%eax
cltd
mov    0x20(%rsp),%rcx
idiv   %ecx
xor    %edx,%edx
cmp    %rcx,%rsi
sete   %dl
sub    %edx,%eax
mov    %eax,%ecx
and    $0x7f,%ecx
mov    %ecx,0x18(%rsp)
sar    $0x7,%eax
mov    %rax,0x40(%rsp)
mov    %rsi,0x148(%rsp)
cmpl   $0x0,0x90(%rsp)
jle    17d0 <scale_volume_image_cubic+0x6b0>
mov    0x40(%rsp),%rax
add    $0xffffffff,%eax
imul   0x110(%rsp),%eax
add    0x4ec(%rsp),%eax
mov    %eax,0xe0(%rsp)
mov    0xb0(%rsp),%rax
mov    %rax,0xf0(%rsp)
xor    %edi,%edi
jmp    18c2 <scale_volume_image_cubic+0x7a2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x98(%rsp),%rdi
add    $0x1,%rdi
mov    0xf0(%rsp),%rax
add    0x88(%rsp),%rax
mov    %rax,0xf0(%rsp)
cmp    0xe8(%rsp),%rdi
je     17d0 <scale_volume_image_cubic+0x6b0>
xor    %eax,%eax
mov    $0x0,%r12d
cmpl   $0x2,0x90(%rsp)
02
jl     18fd <scale_volume_image_cubic+0x7dd>
mov    0x158(%rsp),%eax
imul   %edi,%eax
cltd
mov    0x150(%rsp),%rsi
idiv   %esi
xor    %ecx,%ecx
cmp    %rsi,%rdi
sete   %cl
sub    %ecx,%eax
mov    %eax,%r12d
and    $0x7f,%r12d
sar    $0x7,%eax
mov    %rdi,0x98(%rsp)
cmpl   $0x0,0x560(%rsp)
jle    1890 <scale_volume_image_cubic+0x770>
add    0xe0(%rsp),%eax
imul   0x560(%rsp),%eax
movslq %eax,%rcx
mov    0x120(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
mov    0x2c8(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x2f0(%rsp)
mov    0x2c0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x2e8(%rsp)
mov    0x2b8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x2e0(%rsp)
mov    0x2b0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0xa0(%rsp)
mov    0x2a8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3d0(%rsp)
mov    0x2a0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3c8(%rsp)
mov    0x298(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3c0(%rsp)
mov    0x290(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3b8(%rsp)
mov    0x288(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x330(%rsp)
mov    0x280(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x328(%rsp)
mov    0x270(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x320(%rsp)
mov    0x268(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3b0(%rsp)
mov    0x260(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3a8(%rsp)
mov    0x258(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3a0(%rsp)
mov    0x2d0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x398(%rsp)
mov    0x250(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x390(%rsp)
mov    0x248(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x388(%rsp)
mov    0x240(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x380(%rsp)
mov    0x238(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x378(%rsp)
mov    0x230(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4e0(%rsp)
mov    0x228(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4d8(%rsp)
mov    0x220(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4d0(%rsp)
mov    0x218(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4c8(%rsp)
mov    0x210(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x448(%rsp)
mov    0x208(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x440(%rsp)
mov    0x200(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x438(%rsp)
mov    0x1f8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4c0(%rsp)
mov    0x1f0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4b8(%rsp)
mov    0x1e8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4b0(%rsp)
mov    0x1e0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4a8(%rsp)
mov    0x1d8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x370(%rsp)
mov    0x1d0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x368(%rsp)
mov    0x1c8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x360(%rsp)
mov    0x1c0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x358(%rsp)
mov    0x1b8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4a0(%rsp)
mov    0x1b0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x498(%rsp)
mov    0x1a8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x490(%rsp)
mov    0x1a0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x488(%rsp)
mov    0x198(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x430(%rsp)
mov    0x190(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x428(%rsp)
mov    0x188(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x420(%rsp)
mov    0x180(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x480(%rsp)
mov    0x178(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x138(%rsp)
mov    0x170(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x478(%rsp)
mov    0xb8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x470(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x318(%rsp)
mov    0x118(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x310(%rsp)
mov    0x30(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x308(%rsp)
mov    0xc0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x300(%rsp)
mov    0x58(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x418(%rsp)
mov    0x50(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x410(%rsp)
mov    0x48(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x408(%rsp)
mov    0x80(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x400(%rsp)
mov    0x168(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x348(%rsp)
mov    0x160(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x340(%rsp)
mov    0x278(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x338(%rsp)
mov    0xd8(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x3f8(%rsp)
mov    0xd0(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x3f0(%rsp)
mov    0x38(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x3e8(%rsp)
add    0xc8(%rsp),%rcx
mov    %rcx,0x450(%rsp)
mov    0x2d8(%rsp),%rax
mov    %rdx,0x350(%rsp)
lea    (%rdx,%rax,1),%rcx
mov    %rcx,0x3e0(%rsp)
add    %rax,%rcx
mov    %rcx,0x3d8(%rsp)
add    %rcx,%rax
mov    %rax,0x2f8(%rsp)
xor    %r13d,%r13d
mov    %r12d,0x14(%rsp)
jmp    1e95 <scale_volume_image_cubic+0xd75>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x458(%rsp),%edi
mov    0xf8(%rsp),%esi
mov    %r12d,%edx
mov    0x18(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    0x14(%rsp),%r12d
mov    0x60(%rsp),%edi
mov    0x68(%rsp),%esi
mov    %r15d,%edx
mov    0x130(%rsp),%r8d
call   1040 <icerp@plt>
test   %eax,%eax
mov    $0x0,%ecx
cmovs  %ecx,%eax
cmp    $0xff,%eax
mov    $0xff,%ecx
cmovae %ecx,%eax
mov    %eax,%edi
movss  0x468(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    0xf0(%rsp),%rcx
mov    %al,(%rcx,%r13,1)
add    $0x1,%r13
cmp    %r13,0x460(%rsp)
movss  0x8(%rsp),%xmm0
je     1890 <scale_volume_image_cubic+0x770>
mov    0x4a0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
call   1030 <gamma_correct@plt>
mov    %eax,%r15d
mov    0x498(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x490(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x488(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r15d,%edi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,0x68(%rsp)
mov    0x40(%rsp),%r15
test   %r15d,%r15d
jle    1f8d <scale_volume_image_cubic+0xe6d>
mov    0x3e0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x430(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x428(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x420(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,0x60(%rsp)
mov    0x480(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x138(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x478(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x470(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %ebx,%edi
mov    %ebp,%esi
mov    %r14d,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebx
mov    %eax,%ecx
cmp    0x20(%rsp),%r15d
jge    209b <scale_volume_image_cubic+0xf7b>
mov    0x358(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x360(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x368(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r15d
mov    0x370(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    0x40(%rsp),%r15
mov    %eax,%ecx
mov    0x14(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    0x60(%rsp),%edi
mov    0x68(%rsp),%esi
mov    %ebx,%edx
mov    0x18(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,0x68(%rsp)
cmpl   $0x0,0xa8(%rsp)
mov    0x14(%rsp),%r12d
jle    22ea <scale_volume_image_cubic+0x11ca>
mov    0x418(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x410(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x408(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x400(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r14d
mov    %eax,0x60(%rsp)
test   %r15d,%r15d
jle    21c5 <scale_volume_image_cubic+0x10a5>
mov    0x350(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x348(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x340(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x338(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r14d
mov    0x3f8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r12d
mov    0x3f0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x3e8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x450(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r12d,%edi
mov    0x14(%rsp),%r12d
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebx
mov    %eax,%ecx
cmp    0x20(%rsp),%r15d
jge    22d7 <scale_volume_image_cubic+0x11b7>
mov    0x300(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r12d
mov    0x308(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r15d
mov    0x310(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x318(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r12d,%edi
mov    0x14(%rsp),%r12d
mov    %r15d,%esi
mov    0x40(%rsp),%r15
mov    %ebp,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    %r14d,%edi
mov    0x60(%rsp),%esi
mov    %ebx,%edx
mov    0x18(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,0x60(%rsp)
mov    0x4e0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x4d8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x4d0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x4c8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r14d
mov    %eax,0xf8(%rsp)
test   %r15d,%r15d
jle    23f0 <scale_volume_image_cubic+0x12d0>
mov    0x3d8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x448(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x440(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x438(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r14d
mov    0x4c0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r12d
mov    0x4b8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x4b0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x4a8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r12d,%edi
mov    0x14(%rsp),%r12d
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebx
mov    %eax,%ecx
cmp    0x20(%rsp),%r15d
jge    24fd <scale_volume_image_cubic+0x13dd>
mov    0x378(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r12d
mov    0x380(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r15d
mov    0x388(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x390(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r12d,%edi
mov    0x14(%rsp),%r12d
mov    %r15d,%esi
mov    %ebp,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    %r14d,%edi
mov    0xf8(%rsp),%esi
mov    %ebx,%edx
mov    0x18(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,%r15d
mov    %eax,%ecx
mov    0xa8(%rsp),%rax
cmp    0x128(%rsp),%eax
jge    1e32 <scale_volume_image_cubic+0xd12>
mov    0x3d0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x3c8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x3c0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x3b8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12d,%r8d
call   1040 <icerp@plt>
mov    %eax,0xf8(%rsp)
cmpl   $0x0,0x40(%rsp)
mov    %r12d,%r14d
jle    262e <scale_volume_image_cubic+0x150e>
mov    0x2f8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r12d
mov    0x330(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x328(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x320(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r12d,%edi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,0x458(%rsp)
mov    0x3b0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r12d
mov    0x3a8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x3a0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x398(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %r12d,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    %eax,%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r12d
mov    %eax,%ecx
mov    0x40(%rsp),%rax
cmp    0x20(%rsp),%eax
jge    1e10 <scale_volume_image_cubic+0xcf0>
mov    0xa0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebx
mov    0x2e0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%ebp
mov    0x2e8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %eax,%r14d
mov    0x2f0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
movss  0x8(%rsp),%xmm0
call   1030 <gamma_correct@plt>
mov    %ebx,%edi
mov    %ebp,%esi
mov    %r14d,%edx
mov    %eax,%ecx
mov    0x14(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
jmp    1e10 <scale_volume_image_cubic+0xcf0>
test   %ecx,%ecx
jle    388e <scale_volume_image_cubic+0x276e>
shl    $0x7,%ebx
add    $0xffffff80,%ebx
mov    %ebx,0x70(%rsp)
shl    $0x7,%esi
add    $0xffffff80,%esi
mov    %esi,0x74(%rsp)
mov    0x110(%rsp),%rsi
mov    %esi,%edx
shl    $0x7,%edx
add    $0xffffff80,%edx
mov    %edx,0x178(%rsp)
movslq %ebp,%rbx
mov    0x560(%rsp),%ebp
mov    %ebp,%edx
imul   %esi,%edx
movslq %edx,%r14
mov    %r14,0xe8(%rsp)
lea    0x1(%rsi),%edx
imul   %ebp,%edx
movslq %edx,%r11
mov    %r11,0xe0(%rsp)
lea    0x2(%rsi),%edx
imul   %ebp,%edx
movslq %edx,%r13
lea    0x3(%rsi),%edx
imul   %ebp,%edx
movslq %edx,%r9
lea    (%rsi,%rsi,1),%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0x28(%rsp)
lea    (%rsi,%rsi,1),%edx
add    $0x1,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0x58(%rsp)
lea    (%rsi,%rsi,1),%edx
add    $0x2,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0xa0(%rsp)
lea    (%rsi,%rsi,1),%edx
add    $0x3,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0x50(%rsp)
lea    (%rsi,%rsi,2),%edx
imul   %ebp,%edx
movslq %edx,%r8
lea    (%rsi,%rsi,2),%edx
add    $0x1,%edx
imul   %ebp,%edx
movslq %edx,%r15
mov    %r15,0x98(%rsp)
lea    (%rsi,%rsi,2),%edx
add    $0x2,%edx
imul   %ebp,%edx
movslq %edx,%r12
lea    (%rsi,%rsi,2),%edx
add    $0x3,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdx,0x88(%rsp)
cltq
mov    %rax,0x160(%rsp)
movslq %edi,%rax
mov    %rax,0x148(%rsp)
lea    (%rbx,%rbx,2),%rax
lea    (%rax,%rdx,1),%rdi
mov    0x120(%rsp),%rdx
add    %rdx,%rdi
mov    %rdi,0xc8(%rsp)
lea    (%rax,%r12,1),%rdi
add    %rdx,%rdi
mov    %rdi,0xc0(%rsp)
lea    (%rax,%r15,1),%rdi
add    %rdx,%rdi
mov    %rdi,0x118(%rsp)
lea    (%rax,%r8,1),%rdi
mov    %r8,0x48(%rsp)
add    %rdx,%rdi
mov    %rdi,0x2d8(%rsp)
lea    (%rax,%r14,1),%rdi
add    %rdx,%rdi
mov    %rdi,0x2d0(%rsp)
lea    (%rax,%r11,1),%rdi
add    %rdx,%rdi
mov    %rdi,0x2c8(%rsp)
lea    (%rax,%r13,1),%rdi
mov    %r13,0x38(%rsp)
add    %rdx,%rdi
mov    %rdi,0x2c0(%rsp)
lea    (%rax,%r9,1),%rdi
mov    %r9,0x30(%rsp)
add    %rdx,%rdi
mov    %rdi,0x2b8(%rsp)
movslq %ebp,%rdi
lea    (%rax,%rdi,1),%r11
add    %rdx,%r11
mov    %r11,0x2b0(%rsp)
lea    (%rax,%rdi,2),%rbp
add    %rdx,%rbp
mov    %rbp,0x2a8(%rsp)
lea    (%rdi,%rdi,2),%rbp
lea    (%rax,%rbp,1),%rsi
add    %rdx,%rsi
mov    %rsi,0x298(%rsp)
mov    0x28(%rsp),%r11
lea    (%rax,%r11,1),%rsi
add    %rdx,%rsi
mov    %rsi,0x290(%rsp)
mov    0x58(%rsp),%r15
lea    (%rax,%r15,1),%rsi
add    %rdx,%rsi
mov    %rsi,0x288(%rsp)
mov    0xa0(%rsp),%r10
lea    (%rax,%r10,1),%rsi
add    %rdx,%rsi
mov    %rsi,0x280(%rsp)
mov    0x50(%rsp),%r14
add    %r14,%rax
add    %rdx,%rax
mov    %rax,0xd0(%rsp)
mov    0x88(%rsp),%rax
lea    (%rax,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x278(%rsp)
mov    %r12,0x80(%rsp)
lea    (%r12,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x270(%rsp)
mov    0x98(%rsp),%rax
lea    (%rax,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x268(%rsp)
lea    (%r8,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x260(%rsp)
mov    0xe8(%rsp),%rsi
lea    (%rsi,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x258(%rsp)
mov    0xe0(%rsp),%r8
lea    (%r8,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x250(%rsp)
lea    0x0(,%rbx,2),%rax
add    %r13,%rax
add    %rdx,%rax
mov    %rax,0x248(%rsp)
lea    (%r9,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x240(%rsp)
lea    (%rdi,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x238(%rsp)
lea    (%rdi,%rdi,1),%rax
lea    (%rax,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x230(%rsp)
lea    0x0(,%rbx,2),%rax
add    %rbp,%rax
add    %rdx,%rax
mov    %rax,0x228(%rsp)
lea    (%r11,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x220(%rsp)
mov    %r15,%r9
lea    (%r15,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x218(%rsp)
lea    (%r10,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x210(%rsp)
mov    %r14,%r10
lea    (%r14,%rbx,2),%rax
add    %rdx,%rax
mov    %rax,0x208(%rsp)
mov    0x88(%rsp),%r13
lea    (%rbx,%r13,1),%rax
add    %rdx,%rax
mov    %rax,0x200(%rsp)
lea    (%rbx,%r12,1),%rax
add    %rdx,%rax
mov    %rax,0x1f8(%rsp)
mov    0x98(%rsp),%r15
lea    (%rbx,%r15,1),%rax
add    %rdx,%rax
mov    %rax,0x1f0(%rsp)
mov    0x48(%rsp),%r14
lea    (%rbx,%r14,1),%rax
add    %rdx,%rax
mov    %rax,0x1e8(%rsp)
lea    (%rbx,%rsi,1),%rax
add    %rdx,%rax
mov    %rax,0x1e0(%rsp)
lea    (%rbx,%r8,1),%rax
add    %rdx,%rax
mov    %rax,0x1d8(%rsp)
mov    0x38(%rsp),%r8
lea    (%rbx,%r8,1),%rax
add    %rdx,%rax
mov    %rax,0x1d0(%rsp)
mov    0x30(%rsp),%rsi
lea    (%rbx,%rsi,1),%rax
add    %rdx,%rax
mov    %rax,0x1c8(%rsp)
lea    (%rdi,%rbx,1),%rax
add    %rdx,%rax
mov    %rax,0x1c0(%rsp)
lea    (%rbx,%rdi,2),%rax
add    %rdx,%rax
mov    %rax,0x1b8(%rsp)
lea    (%rbx,%rbp,1),%rax
add    %rdx,%rax
mov    %rax,0x1b0(%rsp)
lea    (%rbx,%r11,1),%rax
mov    %r11,%r12
add    %rdx,%rax
mov    %rax,0x1a8(%rsp)
lea    (%rbx,%r9,1),%rax
mov    %r9,%r11
add    %rdx,%rax
mov    %rax,0x1a0(%rsp)
mov    0xa0(%rsp),%r9
lea    (%rbx,%r9,1),%rax
add    %rdx,%rax
mov    %rax,0x198(%rsp)
mov    %rbx,0xd8(%rsp)
lea    (%rbx,%r10,1),%rax
mov    %r10,%rbx
add    %rdx,%rax
mov    %rax,0x190(%rsp)
mov    %r13,%rax
add    %rdx,%rax
mov    %rax,0x88(%rsp)
add    %rdx,0x80(%rsp)
mov    %r15,%rax
add    %rdx,%rax
mov    %rax,0x98(%rsp)
mov    %r14,%rax
add    %rdx,%rax
mov    %rax,0x48(%rsp)
add    %rdx,0xe8(%rsp)
add    %rdx,0xe0(%rsp)
add    %rdx,%r8
mov    %r8,0x38(%rsp)
add    %rdx,%rsi
mov    %rsi,0x30(%rsp)
add    %rdx,%rbp
mov    %rbp,0x2a0(%rsp)
add    %rdx,%r12
mov    %r12,0x28(%rsp)
add    %rdx,%r11
mov    %r11,0x58(%rsp)
mov    %r9,%rax
add    %rdx,%rax
mov    %rax,0xa0(%rsp)
mov    %r10,%rax
add    %rdx,%rax
mov    %rax,0x50(%rsp)
lea    -0x1(%rcx),%r12d
mov    0x78(%rsp),%rax
lea    -0x1(%rax),%esi
mov    %rsi,0x18(%rsp)
mov    0x90(%rsp),%rsi
lea    -0x1(%rsi),%ebp
mov    %rbp,0x170(%rsp)
mov    %ecx,%ebp
mov    %rbp,0x140(%rsp)
mov    %eax,%eax
mov    %rax,0x158(%rsp)
mov    %esi,%eax
mov    %rax,0x2e8(%rsp)
mov    0x560(%rsp),%eax
mov    %rax,0x478(%rsp)
lea    (%rdx,%rdi,1),%rax
mov    %rax,0x188(%rsp)
mov    %rdi,0x2f0(%rsp)
lea    (%rdx,%rdi,2),%rax
mov    %rax,0x180(%rsp)
xor    %esi,%esi
mov    %r12,0x380(%rsp)
jmp    2cd2 <scale_volume_image_cubic+0x1bb2>
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rsi
add    $0x1,%rsi
mov    0x148(%rsp),%rax
add    %rax,0x108(%rsp)
cmp    0x140(%rsp),%rsi
mov    0x4f0(%rsp),%rcx
je     388e <scale_volume_image_cubic+0x276e>
mov    $0x0,%eax
mov    %rax,0x20(%rsp)
movl   $0x0,0x138(%rsp)
cmp    $0x1,%ecx
je     2d15 <scale_volume_image_cubic+0x1bf5>
mov    0x70(%rsp),%eax
imul   %esi,%eax
cltd
idiv   %r12d
xor    %ecx,%ecx
cmp    %r12,%rsi
sete   %cl
sub    %ecx,%eax
mov    %eax,%ecx
and    $0x7f,%ecx
mov    %ecx,0x138(%rsp)
sar    $0x7,%eax
mov    %rax,0x20(%rsp)
mov    %rsi,0xb0(%rsp)
cmpl   $0x0,0x78(%rsp)
jle    2ca0 <scale_volume_image_cubic+0x1b80>
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
imul   0x104(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x150(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0xb8(%rsp)
xor    %esi,%esi
jmp    2d92 <scale_volume_image_cubic+0x1c72>
cs nopw 0x0(%rax,%rax,1)
mov    0x168(%rsp),%rsi
add    $0x1,%rsi
mov    0xb8(%rsp),%rax
add    0x160(%rsp),%rax
mov    %rax,0xb8(%rsp)
cmp    0x158(%rsp),%rsi
je     2ca0 <scale_volume_image_cubic+0x1b80>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
movl   $0x0,0x14(%rsp)
cmpl   $0x2,0x78(%rsp)
jl     2dd2 <scale_volume_image_cubic+0x1cb2>
mov    0x74(%rsp),%eax
imul   %esi,%eax
cltd
mov    0x18(%rsp),%rcx
idiv   %ecx
xor    %edx,%edx
cmp    %rcx,%rsi
sete   %dl
sub    %edx,%eax
mov    %eax,%ecx
and    $0x7f,%ecx
mov    %ecx,0x14(%rsp)
sar    $0x7,%eax
mov    %rax,0x8(%rsp)
mov    %rsi,0x168(%rsp)
cmpl   $0x0,0x90(%rsp)
jle    2d60 <scale_volume_image_cubic+0x1c40>
mov    0x8(%rsp),%rax
add    $0xffffffff,%eax
imul   0x110(%rsp),%eax
add    0x150(%rsp),%eax
mov    %eax,0x2e0(%rsp)
mov    0xb8(%rsp),%rax
mov    %rax,0x68(%rsp)
xor    %edi,%edi
jmp    2e4c <scale_volume_image_cubic+0x1d2c>
nopw   0x0(%rax,%rax,1)
mov    0x2f8(%rsp),%rdi
add    $0x1,%rdi
mov    0x68(%rsp),%rax
add    0x2f0(%rsp),%rax
mov    %rax,0x68(%rsp)
cmp    0x2e8(%rsp),%rdi
je     2d60 <scale_volume_image_cubic+0x1c40>
xor    %eax,%eax
mov    $0x0,%r14d
cmpl   $0x2,0x90(%rsp)
02
jl     2e87 <scale_volume_image_cubic+0x1d67>
mov    0x178(%rsp),%eax
imul   %edi,%eax
cltd
mov    0x170(%rsp),%rsi
idiv   %esi
xor    %ecx,%ecx
cmp    %rsi,%rdi
sete   %cl
sub    %ecx,%eax
mov    %eax,%r14d
and    $0x7f,%r14d
sar    $0x7,%eax
mov    %rdi,0x2f8(%rsp)
cmpl   $0x0,0x560(%rsp)
jle    2e20 <scale_volume_image_cubic+0x1d00>
add    0x2e0(%rsp),%eax
imul   0x560(%rsp),%eax
movslq %eax,%rcx
mov    0x120(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
mov    0xc8(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x318(%rsp)
mov    0xc0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x310(%rsp)
mov    0x118(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x308(%rsp)
mov    0x2d8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x300(%rsp)
mov    0x2d0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x400(%rsp)
mov    0x2c8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3f8(%rsp)
mov    0x2c0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3f0(%rsp)
mov    0x2b8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3e8(%rsp)
mov    0x2b0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x358(%rsp)
mov    0x2a8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x350(%rsp)
mov    0x298(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x348(%rsp)
mov    0x290(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3e0(%rsp)
mov    0x288(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3d8(%rsp)
mov    0x280(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3d0(%rsp)
mov    0xd0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3c8(%rsp)
mov    0x278(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3c0(%rsp)
mov    0x270(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3b8(%rsp)
mov    0x268(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3b0(%rsp)
mov    0x260(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3a8(%rsp)
mov    0x258(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x60(%rsp)
mov    0x250(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0xf8(%rsp)
mov    0x248(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0xf0(%rsp)
mov    0x240(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4e0(%rsp)
mov    0x238(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x130(%rsp)
mov    0x230(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x128(%rsp)
mov    0x228(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x468(%rsp)
mov    0x220(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4d8(%rsp)
mov    0x218(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4d0(%rsp)
mov    0x210(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4c8(%rsp)
mov    0x208(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4c0(%rsp)
mov    0x200(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x3a0(%rsp)
mov    0x1f8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x398(%rsp)
mov    0x1f0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x390(%rsp)
mov    0x1e8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x388(%rsp)
mov    0x1e0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4b8(%rsp)
mov    0x1d8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4b0(%rsp)
mov    0x1d0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4a8(%rsp)
mov    0x1c8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x4a0(%rsp)
mov    0x1c0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x460(%rsp)
mov    0x1b8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x458(%rsp)
mov    0x1b0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x450(%rsp)
mov    0x1a8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x498(%rsp)
mov    0x1a0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x490(%rsp)
mov    0x198(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x488(%rsp)
mov    0x190(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x480(%rsp)
mov    0x88(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x340(%rsp)
mov    0x80(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x338(%rsp)
mov    0x98(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x330(%rsp)
mov    0x48(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x328(%rsp)
mov    0xe8(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x448(%rsp)
mov    0xe0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x440(%rsp)
mov    0x38(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x438(%rsp)
mov    0x30(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x430(%rsp)
mov    0x188(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x370(%rsp)
mov    0x180(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x368(%rsp)
mov    0x2a0(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x360(%rsp)
mov    0x28(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x428(%rsp)
mov    0x58(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x420(%rsp)
mov    0xa0(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x418(%rsp)
add    0x50(%rsp),%rcx
mov    %rcx,0x470(%rsp)
mov    0xd8(%rsp),%rax
mov    %rdx,0x378(%rsp)
lea    (%rdx,%rax,1),%rcx
mov    %rcx,0x410(%rsp)
add    %rax,%rcx
mov    %rcx,0x408(%rsp)
add    %rcx,%rax
mov    %rax,0x320(%rsp)
xor    %r13d,%r13d
jmp    33ab <scale_volume_image_cubic+0x228b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x68(%rsp),%rcx
mov    %al,(%rcx,%r13,1)
add    $0x1,%r13
cmp    %r13,0x478(%rsp)
je     2e20 <scale_volume_image_cubic+0x1d00>
mov    0x4b8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x4b0(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x4a8(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x4a0(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r15d
mov    %eax,%ebx
cmpl   $0x0,0x8(%rsp)
jle    3431 <scale_volume_image_cubic+0x2311>
mov    0x410(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x460(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x458(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x450(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebx
mov    0x498(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x490(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x488(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x480(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebp
mov    %eax,%ecx
mov    0x8(%rsp),%rax
cmp    0x18(%rsp),%eax
jge    34ba <scale_volume_image_cubic+0x239a>
mov    0x388(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x390(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x398(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x3a0(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    %ebx,%edi
mov    %r15d,%esi
mov    %ebp,%edx
mov    0x14(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,0x40(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    35fa <scale_volume_image_cubic+0x24da>
mov    0x448(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x440(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x438(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x430(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r15d
mov    %eax,%ebx
cmpl   $0x0,0x8(%rsp)
jle    3560 <scale_volume_image_cubic+0x2440>
mov    0x378(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x370(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x368(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x360(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebx
mov    0x428(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x420(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x418(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x470(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebp
mov    %eax,%ecx
mov    0x8(%rsp),%rax
cmp    0x18(%rsp),%eax
jge    35e9 <scale_volume_image_cubic+0x24c9>
mov    0x328(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x330(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x338(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x340(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    %ebx,%edi
mov    %r15d,%esi
mov    %ebp,%edx
mov    0x14(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,0xa8(%rsp)
mov    0x60(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0xf8(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0xf0(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x4e0(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r15d
mov    %eax,%ebp
cmpl   $0x0,0x8(%rsp)
jle    3684 <scale_volume_image_cubic+0x2564>
mov    0x408(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x130(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x128(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x468(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebp
mov    0x4d8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x4d0(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x4c8(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x4c0(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebx
mov    %eax,%ecx
mov    0x8(%rsp),%rax
cmp    0x18(%rsp),%eax
jge    370d <scale_volume_image_cubic+0x25ed>
mov    0x3a8(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x3b0(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x3b8(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x3c0(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    %ebp,%edi
mov    %r15d,%esi
mov    %ebx,%edx
mov    0x14(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,%r15d
mov    %eax,%ecx
cmp    %r12d,0x20(%rsp)
jge    3858 <scale_volume_image_cubic+0x2738>
mov    0x400(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x3f8(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x3f0(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x3e8(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebx
mov    %eax,%ebp
cmpl   $0x0,0x8(%rsp)
jle    37b3 <scale_volume_image_cubic+0x2693>
mov    0x320(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x358(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x350(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x348(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ebp
mov    0x3e0(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x3d8(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x3d0(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x3c8(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%r12d
mov    %eax,%ecx
mov    0x8(%rsp),%rax
cmp    0x18(%rsp),%eax
jge    383d <scale_volume_image_cubic+0x271d>
mov    0x300(%rsp),%rax
movzbl (%rax,%r13,1),%edi
mov    0x308(%rsp),%rax
movzbl (%rax,%r13,1),%esi
mov    0x310(%rsp),%rax
movzbl (%rax,%r13,1),%edx
mov    0x318(%rsp),%rax
movzbl (%rax,%r13,1),%ecx
mov    %r14d,%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r12d,%edx
mov    0x14(%rsp),%r8d
call   1040 <icerp@plt>
mov    %eax,%ecx
mov    0x380(%rsp),%r12
mov    0xa8(%rsp),%edi
mov    0x40(%rsp),%esi
mov    %r15d,%edx
mov    0x138(%rsp),%r8d
call   1040 <icerp@plt>
test   %eax,%eax
jns    3879 <scale_volume_image_cubic+0x2759>
xor    %eax,%eax
cmp    $0xff,%eax
jb     3390 <scale_volume_image_cubic+0x2270>
mov    $0xff,%eax
jmp    3390 <scale_volume_image_cubic+0x2270>
add    $0x518,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @scale_volume_image_cubic(i8* %0, i32 %1, i32 %2, i32 %3, i8* %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, float %10) {
%12 = alloca i8*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i8*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca float
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i8*
%46 = alloca i8*
%47 = alloca i8*
%48 = alloca i8*
%49 = alloca float
store i8* %0, i8** %12
store i32 %1, i32* %13
store i32 %2, i32* %14
store i32 %3, i32* %15
store i8* %4, i8** %16
store i32 %5, i32* %17
store i32 %6, i32* %18
store i32 %7, i32* %19
store i32 %8, i32* %20
store i32 %9, i32* %21
store float %10, float* %22
%50 = load i32, i32* %13
%51 = load i32, i32* %20
%52 = mul nsw i32 %50, %51
store i32 %52, i32* %42
%53 = load i32, i32* %17
%54 = load i32, i32* %18
%55 = mul nsw i32 %53, %54
%56 = load i32, i32* %20
%57 = mul nsw i32 %55, %56
store i32 %57, i32* %43
%58 = load i32, i32* %13
%59 = load i32, i32* %14
%60 = mul nsw i32 %58, %59
%61 = load i32, i32* %20
%62 = mul nsw i32 %60, %61
store i32 %62, i32* %44
%63 = load i32, i32* %21
%64 = icmp ne i32 %63, 0
br i1 %64, label %65, label %1068
65: ; preds = %11
%66 = load float, float* %22
%67 = fpext float %66 to double
%68 = fdiv double 1.000000e+00, %67
%69 = fptrunc double %68 to float
store float %69, float* %49
store i32 0, i32* %26
br label %70
70: ; preds = %1064, %65
%71 = load i32, i32* %26
%72 = load i32, i32* %15
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %1067
74: ; preds = %70
%75 = load i32, i32* %15
%76 = icmp sgt i32 %75, 1
br i1 %76, label %77, label %98
77: ; preds = %74
%78 = load i32, i32* %19
%79 = sub nsw i32 %78, 1
%80 = load i32, i32* %26
%81 = mul nsw i32 %79, %80
%82 = shl i32 %81, 7
%83 = load i32, i32* %15
%84 = sub nsw i32 %83, 1
%85 = sdiv i32 %82, %84
store i32 %85, i32* %29
%86 = load i32, i32* %26
%87 = load i32, i32* %15
%88 = sub nsw i32 %87, 1
%89 = icmp eq i32 %86, %88
br i1 %89, label %90, label %93
90: ; preds = %77
%91 = load i32, i32* %29
%92 = add nsw i32 %91, -1
store i32 %92, i32* %29
br label %93
93: ; preds = %90, %77
%94 = load i32, i32* %29
%95 = and i32 %94, 127
store i32 %95, i32* %32
%96 = load i32, i32* %29
%97 = ashr i32 %96, 7
store i32 %97, i32* %29
br label %99
98: ; preds = %74
store i32 0, i32* %32
store i32 0, i32* %29
br label %99
99: ; preds = %98, %93
store i32 0, i32* %25
br label %100
100: ; preds = %1060, %99
%101 = load i32, i32* %25
%102 = load i32, i32* %14
%103 = icmp slt i32 %101, %102
br i1 %103, label %104, label %1063
104: ; preds = %100
%105 = load i32, i32* %14
%106 = icmp sgt i32 %105, 1
br i1 %106, label %107, label %128
107: ; preds = %104
%108 = load i32, i32* %18
%109 = sub nsw i32 %108, 1
%110 = load i32, i32* %25
%111 = mul nsw i32 %109, %110
%112 = shl i32 %111, 7
%113 = load i32, i32* %14
%114 = sub nsw i32 %113, 1
%115 = sdiv i32 %112, %114
store i32 %115, i32* %28
%116 = load i32, i32* %25
%117 = load i32, i32* %14
%118 = sub nsw i32 %117, 1
%119 = icmp eq i32 %116, %118
br i1 %119, label %120, label %123
120: ; preds = %107
%121 = load i32, i32* %28
%122 = add nsw i32 %121, -1
store i32 %122, i32* %28
br label %123
123: ; preds = %120, %107
%124 = load i32, i32* %28
%125 = and i32 %124, 127
store i32 %125, i32* %31
%126 = load i32, i32* %28
%127 = ashr i32 %126, 7
store i32 %127, i32* %28
br label %129
128: ; preds = %104
store i32 0, i32* %31
store i32 0, i32* %28
br label %129
129: ; preds = %128, %123
store i32 0, i32* %24
br label %130
130: ; preds = %1056, %129
%131 = load i32, i32* %24
%132 = load i32, i32* %13
%133 = icmp slt i32 %131, %132
br i1 %133, label %134, label %1059
134: ; preds = %130
%135 = load i32, i32* %13
%136 = icmp sgt i32 %135, 1
br i1 %136, label %137, label %158
137: ; preds = %134
%138 = load i32, i32* %17
%139 = sub nsw i32 %138, 1
%140 = load i32, i32* %24
%141 = mul nsw i32 %139, %140
%142 = shl i32 %141, 7
%143 = load i32, i32* %13
%144 = sub nsw i32 %143, 1
%145 = sdiv i32 %142, %144
store i32 %145, i32* %27
%146 = load i32, i32* %24
%147 = load i32, i32* %13
%148 = sub nsw i32 %147, 1
%149 = icmp eq i32 %146, %148
br i1 %149, label %150, label %153
150: ; preds = %137
%151 = load i32, i32* %27
%152 = add nsw i32 %151, -1
store i32 %152, i32* %27
br label %153
153: ; preds = %150, %137
%154 = load i32, i32* %27
%155 = and i32 %154, 127
store i32 %155, i32* %30
%156 = load i32, i32* %27
%157 = ashr i32 %156, 7
store i32 %157, i32* %27
br label %159
158: ; preds = %134
store i32 0, i32* %30
store i32 0, i32* %27
br label %159
159: ; preds = %158, %153
%160 = load i8*, i8** %16
%161 = load i32, i32* %29
%162 = sub nsw i32 %161, 1
%163 = load i32, i32* %17
%164 = load i32, i32* %18
%165 = mul nsw i32 %163, %164
%166 = mul nsw i32 %162, %165
%167 = load i32, i32* %28
%168 = sub nsw i32 %167, 1
%169 = load i32, i32* %17
%170 = mul nsw i32 %168, %169
%171 = add nsw i32 %166, %170
%172 = load i32, i32* %27
%173 = sub nsw i32 %172, 1
%174 = add nsw i32 %171, %173
%175 = load i32, i32* %20
%176 = mul nsw i32 %174, %175
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %160, i64 %177
store i8* %178, i8** %45
%179 = load i8*, i8** %45
%180 = load i32, i32* %43
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %179, i64 %181
store i8* %182, i8** %46
%183 = load i8*, i8** %46
%184 = load i32, i32* %43
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i8, i8* %183, i64 %185
store i8* %186, i8** %47
%187 = load i8*, i8** %47
%188 = load i32, i32* %43
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds i8, i8* %187, i64 %189
store i8* %190, i8** %48
store i32 0, i32* %23
br label %191
191: ; preds = %1052, %159
%192 = load i32, i32* %23
%193 = load i32, i32* %20
%194 = icmp slt i32 %192, %193
br i1 %194, label %195, label %1055
195: ; preds = %191
%196 = load i8*, i8** %46
%197 = load i32, i32* %17
%198 = add nsw i32 %197, 0
%199 = load i32, i32* %20
%200 = mul nsw i32 %198, %199
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i8, i8* %196, i64 %201
%203 = load i8, i8* %202
%204 = zext i8 %203 to i32
%205 = load float, float* %22
%206 = call i32 @gamma_correct(i32 %204, float %205)
%207 = load i8*, i8** %46
%208 = load i32, i32* %17
%209 = add nsw i32 %208, 1
%210 = load i32, i32* %20
%211 = mul nsw i32 %209, %210
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i8, i8* %207, i64 %212
%214 = load i8, i8* %213
%215 = zext i8 %214 to i32
%216 = load float, float* %22
%217 = call i32 @gamma_correct(i32 %215, float %216)
%218 = load i8*, i8** %46
%219 = load i32, i32* %17
%220 = add nsw i32 %219, 2
%221 = load i32, i32* %20
%222 = mul nsw i32 %220, %221
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8, i8* %218, i64 %223
%225 = load i8, i8* %224
%226 = zext i8 %225 to i32
%227 = load float, float* %22
%228 = call i32 @gamma_correct(i32 %226, float %227)
%229 = load i8*, i8** %46
%230 = load i32, i32* %17
%231 = add nsw i32 %230, 3
%232 = load i32, i32* %20
%233 = mul nsw i32 %231, %232
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i8, i8* %229, i64 %234
%236 = load i8, i8* %235
%237 = zext i8 %236 to i32
%238 = load float, float* %22
%239 = call i32 @gamma_correct(i32 %237, float %238)
%240 = load i32, i32* %30
%241 = call i32 @icerp(i32 %206, i32 %217, i32 %228, i32 %239, i32 %240)
store i32 %241, i32* %34
%242 = load i32, i32* %28
%243 = icmp sgt i32 %242, 0
br i1 %243, label %244, label %279
244: ; preds = %195
%245 = load i8*, i8** %46
%246 = getelementptr inbounds i8, i8* %245, i64 0
%247 = load i8, i8* %246
%248 = zext i8 %247 to i32
%249 = load float, float* %22
%250 = call i32 @gamma_correct(i32 %248, float %249)
%251 = load i8*, i8** %46
%252 = load i32, i32* %20
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds i8, i8* %251, i64 %253
%255 = load i8, i8* %254
%256 = zext i8 %255 to i32
%257 = load float, float* %22
%258 = call i32 @gamma_correct(i32 %256, float %257)
%259 = load i8*, i8** %46
%260 = load i32, i32* %20
%261 = mul nsw i32 2, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i8, i8* %259, i64 %262
%264 = load i8, i8* %263
%265 = zext i8 %264 to i32
%266 = load float, float* %22
%267 = call i32 @gamma_correct(i32 %265, float %266)
%268 = load i8*, i8** %46
%269 = load i32, i32* %20
%270 = mul nsw i32 3, %269
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i8, i8* %268, i64 %271
%273 = load i8, i8* %272
%274 = zext i8 %273 to i32
%275 = load float, float* %22
%276 = call i32 @gamma_correct(i32 %274, float %275)
%277 = load i32, i32* %30
%278 = call i32 @icerp(i32 %250, i32 %258, i32 %267, i32 %276, i32 %277)
store i32 %278, i32* %33
br label %281
279: ; preds = %195
%280 = load i32, i32* %34
store i32 %280, i32* %33
br label %281
281: ; preds = %279, %244
%282 = load i8*, i8** %46
%283 = load i32, i32* %17
%284 = mul nsw i32 2, %283
%285 = add nsw i32 %284, 0
%286 = load i32, i32* %20
%287 = mul nsw i32 %285, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i8, i8* %282, i64 %288
%290 = load i8, i8* %289
%291 = zext i8 %290 to i32
%292 = load float, float* %22
%293 = call i32 @gamma_correct(i32 %291, float %292)
%294 = load i8*, i8** %46
%295 = load i32, i32* %17
%296 = mul nsw i32 2, %295
%297 = add nsw i32 %296, 1
%298 = load i32, i32* %20
%299 = mul nsw i32 %297, %298
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i8, i8* %294, i64 %300
%302 = load i8, i8* %301
%303 = zext i8 %302 to i32
%304 = load float, float* %22
%305 = call i32 @gamma_correct(i32 %303, float %304)
%306 = load i8*, i8** %46
%307 = load i32, i32* %17
%308 = mul nsw i32 2, %307
%309 = add nsw i32 %308, 2
%310 = load i32, i32* %20
%311 = mul nsw i32 %309, %310
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds i8, i8* %306, i64 %312
%314 = load i8, i8* %313
%315 = zext i8 %314 to i32
%316 = load float, float* %22
%317 = call i32 @gamma_correct(i32 %315, float %316)
%318 = load i8*, i8** %46
%319 = load i32, i32* %17
%320 = mul nsw i32 2, %319
%321 = add nsw i32 %320, 3
%322 = load i32, i32* %20
%323 = mul nsw i32 %321, %322
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i8, i8* %318, i64 %324
%326 = load i8, i8* %325
%327 = zext i8 %326 to i32
%328 = load float, float* %22
%329 = call i32 @gamma_correct(i32 %327, float %328)
%330 = load i32, i32* %30
%331 = call i32 @icerp(i32 %293, i32 %305, i32 %317, i32 %329, i32 %330)
store i32 %331, i32* %35
%332 = load i32, i32* %28
%333 = load i32, i32* %14
%334 = sub nsw i32 %333, 1
%335 = icmp slt i32 %332, %334
br i1 %335, label %336, label %387
336: ; preds = %281
%337 = load i8*, i8** %46
%338 = load i32, i32* %17
%339 = mul nsw i32 3, %338
%340 = add nsw i32 %339, 0
%341 = load i32, i32* %20
%342 = mul nsw i32 %340, %341
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds i8, i8* %337, i64 %343
%345 = load i8, i8* %344
%346 = zext i8 %345 to i32
%347 = load float, float* %22
%348 = call i32 @gamma_correct(i32 %346, float %347)
%349 = load i8*, i8** %46
%350 = load i32, i32* %17
%351 = mul nsw i32 3, %350
%352 = add nsw i32 %351, 1
%353 = load i32, i32* %20
%354 = mul nsw i32 %352, %353
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds i8, i8* %349, i64 %355
%357 = load i8, i8* %356
%358 = zext i8 %357 to i32
%359 = load float, float* %22
%360 = call i32 @gamma_correct(i32 %358, float %359)
%361 = load i8*, i8** %46
%362 = load i32, i32* %17
%363 = mul nsw i32 3, %362
%364 = add nsw i32 %363, 2
%365 = load i32, i32* %20
%366 = mul nsw i32 %364, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i8, i8* %361, i64 %367
%369 = load i8, i8* %368
%370 = zext i8 %369 to i32
%371 = load float, float* %22
%372 = call i32 @gamma_correct(i32 %370, float %371)
%373 = load i8*, i8** %46
%374 = load i32, i32* %17
%375 = mul nsw i32 3, %374
%376 = add nsw i32 %375, 3
%377 = load i32, i32* %20
%378 = mul nsw i32 %376, %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i8, i8* %373, i64 %379
%381 = load i8, i8* %380
%382 = zext i8 %381 to i32
%383 = load float, float* %22
%384 = call i32 @gamma_correct(i32 %382, float %383)
%385 = load i32, i32* %30
%386 = call i32 @icerp(i32 %348, i32 %360, i32 %372, i32 %384, i32 %385)
store i32 %386, i32* %36
br label %389
387: ; preds = %281
%388 = load i32, i32* %35
store i32 %388, i32* %36
br label %389
389: ; preds = %387, %336
%390 = load i32, i32* %33
%391 = load i32, i32* %34
%392 = load i32, i32* %35
%393 = load i32, i32* %36
%394 = load i32, i32* %31
%395 = call i32 @icerp(i32 %390, i32 %391, i32 %392, i32 %393, i32 %394)
store i32 %395, i32* %39
%396 = load i32, i32* %29
%397 = icmp sgt i32 %396, 0
br i1 %397, label %398, label %599
398: ; preds = %389
%399 = load i8*, i8** %45
%400 = load i32, i32* %17
%401 = add nsw i32 %400, 0
%402 = load i32, i32* %20
%403 = mul nsw i32 %401, %402
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds i8, i8* %399, i64 %404
%406 = load i8, i8* %405
%407 = zext i8 %406 to i32
%408 = load float, float* %22
%409 = call i32 @gamma_correct(i32 %407, float %408)
%410 = load i8*, i8** %45
%411 = load i32, i32* %17
%412 = add nsw i32 %411, 1
%413 = load i32, i32* %20
%414 = mul nsw i32 %412, %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i8, i8* %410, i64 %415
%417 = load i8, i8* %416
%418 = zext i8 %417 to i32
%419 = load float, float* %22
%420 = call i32 @gamma_correct(i32 %418, float %419)
%421 = load i8*, i8** %45
%422 = load i32, i32* %17
%423 = add nsw i32 %422, 2
%424 = load i32, i32* %20
%425 = mul nsw i32 %423, %424
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds i8, i8* %421, i64 %426
%428 = load i8, i8* %427
%429 = zext i8 %428 to i32
%430 = load float, float* %22
%431 = call i32 @gamma_correct(i32 %429, float %430)
%432 = load i8*, i8** %45
%433 = load i32, i32* %17
%434 = add nsw i32 %433, 3
%435 = load i32, i32* %20
%436 = mul nsw i32 %434, %435
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds i8, i8* %432, i64 %437
%439 = load i8, i8* %438
%440 = zext i8 %439 to i32
%441 = load float, float* %22
%442 = call i32 @gamma_correct(i32 %440, float %441)
%443 = load i32, i32* %30
%444 = call i32 @icerp(i32 %409, i32 %420, i32 %431, i32 %442, i32 %443)
store i32 %444, i32* %34
%445 = load i32, i32* %28
%446 = icmp sgt i32 %445, 0
br i1 %446, label %447, label %482
447: ; preds = %398
%448 = load i8*, i8** %45
%449 = getelementptr inbounds i8, i8* %448, i64 0
%450 = load i8, i8* %449
%451 = zext i8 %450 to i32
%452 = load float, float* %22
%453 = call i32 @gamma_correct(i32 %451, float %452)
%454 = load i8*, i8** %45
%455 = load i32, i32* %20
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i8, i8* %454, i64 %456
%458 = load i8, i8* %457
%459 = zext i8 %458 to i32
%460 = load float, float* %22
%461 = call i32 @gamma_correct(i32 %459, float %460)
%462 = load i8*, i8** %45
%463 = load i32, i32* %20
%464 = mul nsw i32 2, %463
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds i8, i8* %462, i64 %465
%467 = load i8, i8* %466
%468 = zext i8 %467 to i32
%469 = load float, float* %22
%470 = call i32 @gamma_correct(i32 %468, float %469)
%471 = load i8*, i8** %45
%472 = load i32, i32* %20
%473 = mul nsw i32 3, %472
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i8, i8* %471, i64 %474
%476 = load i8, i8* %475
%477 = zext i8 %476 to i32
%478 = load float, float* %22
%479 = call i32 @gamma_correct(i32 %477, float %478)
%480 = load i32, i32* %30
%481 = call i32 @icerp(i32 %453, i32 %461, i32 %470, i32 %479, i32 %480)
store i32 %481, i32* %33
br label %484
482: ; preds = %398
%483 = load i32, i32* %34
store i32 %483, i32* %33
br label %484
484: ; preds = %482, %447
%485 = load i8*, i8** %45
%486 = load i32, i32* %17
%487 = mul nsw i32 2, %486
%488 = add nsw i32 %487, 0
%489 = load i32, i32* %20
%490 = mul nsw i32 %488, %489
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds i8, i8* %485, i64 %491
%493 = load i8, i8* %492
%494 = zext i8 %493 to i32
%495 = load float, float* %22
%496 = call i32 @gamma_correct(i32 %494, float %495)
%497 = load i8*, i8** %45
%498 = load i32, i32* %17
%499 = mul nsw i32 2, %498
%500 = add nsw i32 %499, 1
%501 = load i32, i32* %20
%502 = mul nsw i32 %500, %501
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i8, i8* %497, i64 %503
%505 = load i8, i8* %504
%506 = zext i8 %505 to i32
%507 = load float, float* %22
%508 = call i32 @gamma_correct(i32 %506, float %507)
%509 = load i8*, i8** %45
%510 = load i32, i32* %17
%511 = mul nsw i32 2, %510
%512 = add nsw i32 %511, 2
%513 = load i32, i32* %20
%514 = mul nsw i32 %512, %513
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds i8, i8* %509, i64 %515
%517 = load i8, i8* %516
%518 = zext i8 %517 to i32
%519 = load float, float* %22
%520 = call i32 @gamma_correct(i32 %518, float %519)
%521 = load i8*, i8** %45
%522 = load i32, i32* %17
%523 = mul nsw i32 2, %522
%524 = add nsw i32 %523, 3
%525 = load i32, i32* %20
%526 = mul nsw i32 %524, %525
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds i8, i8* %521, i64 %527
%529 = load i8, i8* %528
%530 = zext i8 %529 to i32
%531 = load float, float* %22
%532 = call i32 @gamma_correct(i32 %530, float %531)
%533 = load i32, i32* %30
%534 = call i32 @icerp(i32 %496, i32 %508, i32 %520, i32 %532, i32 %533)
store i32 %534, i32* %35
%535 = load i32, i32* %28
%536 = load i32, i32* %14
%537 = sub nsw i32 %536, 1
%538 = icmp slt i32 %535, %537
br i1 %538, label %539, label %590
539: ; preds = %484
%540 = load i8*, i8** %45
%541 = load i32, i32* %17
%542 = mul nsw i32 3, %541
%543 = add nsw i32 %542, 0
%544 = load i32, i32* %20
%545 = mul nsw i32 %543, %544
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds i8, i8* %540, i64 %546
%548 = load i8, i8* %547
%549 = zext i8 %548 to i32
%550 = load float, float* %22
%551 = call i32 @gamma_correct(i32 %549, float %550)
%552 = load i8*, i8** %45
%553 = load i32, i32* %17
%554 = mul nsw i32 3, %553
%555 = add nsw i32 %554, 1
%556 = load i32, i32* %20
%557 = mul nsw i32 %555, %556
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds i8, i8* %552, i64 %558
%560 = load i8, i8* %559
%561 = zext i8 %560 to i32
%562 = load float, float* %22
%563 = call i32 @gamma_correct(i32 %561, float %562)
%564 = load i8*, i8** %45
%565 = load i32, i32* %17
%566 = mul nsw i32 3, %565
%567 = add nsw i32 %566, 2
%568 = load i32, i32* %20
%569 = mul nsw i32 %567, %568
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds i8, i8* %564, i64 %570
%572 = load i8, i8* %571
%573 = zext i8 %572 to i32
%574 = load float, float* %22
%575 = call i32 @gamma_correct(i32 %573, float %574)
%576 = load i8*, i8** %45
%577 = load i32, i32* %17
%578 = mul nsw i32 3, %577
%579 = add nsw i32 %578, 3
%580 = load i32, i32* %20
%581 = mul nsw i32 %579, %580
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds i8, i8* %576, i64 %582
%584 = load i8, i8* %583
%585 = zext i8 %584 to i32
%586 = load float, float* %22
%587 = call i32 @gamma_correct(i32 %585, float %586)
%588 = load i32, i32* %30
%589 = call i32 @icerp(i32 %551, i32 %563, i32 %575, i32 %587, i32 %588)
store i32 %589, i32* %36
br label %592
590: ; preds = %484
%591 = load i32, i32* %35
store i32 %591, i32* %36
br label %592
592: ; preds = %590, %539
%593 = load i32, i32* %33
%594 = load i32, i32* %34
%595 = load i32, i32* %35
%596 = load i32, i32* %36
%597 = load i32, i32* %31
%598 = call i32 @icerp(i32 %593, i32 %594, i32 %595, i32 %596, i32 %597)
store i32 %598, i32* %38
br label %601
599: ; preds = %389
%600 = load i32, i32* %39
store i32 %600, i32* %38
br label %601
601: ; preds = %599, %592
%602 = load i8*, i8** %47
%603 = load i32, i32* %17
%604 = add nsw i32 %603, 0
%605 = load i32, i32* %20
%606 = mul nsw i32 %604, %605
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds i8, i8* %602, i64 %607
%609 = load i8, i8* %608
%610 = zext i8 %609 to i32
%611 = load float, float* %22
%612 = call i32 @gamma_correct(i32 %610, float %611)
%613 = load i8*, i8** %47
%614 = load i32, i32* %17
%615 = add nsw i32 %614, 1
%616 = load i32, i32* %20
%617 = mul nsw i32 %615, %616
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds i8, i8* %613, i64 %618
%620 = load i8, i8* %619
%621 = zext i8 %620 to i32
%622 = load float, float* %22
%623 = call i32 @gamma_correct(i32 %621, float %622)
%624 = load i8*, i8** %47
%625 = load i32, i32* %17
%626 = add nsw i32 %625, 2
%627 = load i32, i32* %20
%628 = mul nsw i32 %626, %627
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds i8, i8* %624, i64 %629
%631 = load i8, i8* %630
%632 = zext i8 %631 to i32
%633 = load float, float* %22
%634 = call i32 @gamma_correct(i32 %632, float %633)
%635 = load i8*, i8** %47
%636 = load i32, i32* %17
%637 = add nsw i32 %636, 3
%638 = load i32, i32* %20
%639 = mul nsw i32 %637, %638
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds i8, i8* %635, i64 %640
%642 = load i8, i8* %641
%643 = zext i8 %642 to i32
%644 = load float, float* %22
%645 = call i32 @gamma_correct(i32 %643, float %644)
%646 = load i32, i32* %30
%647 = call i32 @icerp(i32 %612, i32 %623, i32 %634, i32 %645, i32 %646)
store i32 %647, i32* %34
%648 = load i32, i32* %28
%649 = icmp sgt i32 %648, 0
br i1 %649, label %650, label %685
650: ; preds = %601
%651 = load i8*, i8** %47
%652 = getelementptr inbounds i8, i8* %651, i64 0
%653 = load i8, i8* %652
%654 = zext i8 %653 to i32
%655 = load float, float* %22
%656 = call i32 @gamma_correct(i32 %654, float %655)
%657 = load i8*, i8** %47
%658 = load i32, i32* %20
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds i8, i8* %657, i64 %659
%661 = load i8, i8* %660
%662 = zext i8 %661 to i32
%663 = load float, float* %22
%664 = call i32 @gamma_correct(i32 %662, float %663)
%665 = load i8*, i8** %47
%666 = load i32, i32* %20
%667 = mul nsw i32 2, %666
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds i8, i8* %665, i64 %668
%670 = load i8, i8* %669
%671 = zext i8 %670 to i32
%672 = load float, float* %22
%673 = call i32 @gamma_correct(i32 %671, float %672)
%674 = load i8*, i8** %47
%675 = load i32, i32* %20
%676 = mul nsw i32 3, %675
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds i8, i8* %674, i64 %677
%679 = load i8, i8* %678
%680 = zext i8 %679 to i32
%681 = load float, float* %22
%682 = call i32 @gamma_correct(i32 %680, float %681)
%683 = load i32, i32* %30
%684 = call i32 @icerp(i32 %656, i32 %664, i32 %673, i32 %682, i32 %683)
store i32 %684, i32* %33
br label %687
685: ; preds = %601
%686 = load i32, i32* %34
store i32 %686, i32* %33
br label %687
687: ; preds = %685, %650
%688 = load i8*, i8** %47
%689 = load i32, i32* %17
%690 = mul nsw i32 2, %689
%691 = add nsw i32 %690, 0
%692 = load i32, i32* %20
%693 = mul nsw i32 %691, %692
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds i8, i8* %688, i64 %694
%696 = load i8, i8* %695
%697 = zext i8 %696 to i32
%698 = load float, float* %22
%699 = call i32 @gamma_correct(i32 %697, float %698)
%700 = load i8*, i8** %47
%701 = load i32, i32* %17
%702 = mul nsw i32 2, %701
%703 = add nsw i32 %702, 1
%704 = load i32, i32* %20
%705 = mul nsw i32 %703, %704
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds i8, i8* %700, i64 %706
%708 = load i8, i8* %707
%709 = zext i8 %708 to i32
%710 = load float, float* %22
%711 = call i32 @gamma_correct(i32 %709, float %710)
%712 = load i8*, i8** %47
%713 = load i32, i32* %17
%714 = mul nsw i32 2, %713
%715 = add nsw i32 %714, 2
%716 = load i32, i32* %20
%717 = mul nsw i32 %715, %716
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds i8, i8* %712, i64 %718
%720 = load i8, i8* %719
%721 = zext i8 %720 to i32
%722 = load float, float* %22
%723 = call i32 @gamma_correct(i32 %721, float %722)
%724 = load i8*, i8** %47
%725 = load i32, i32* %17
%726 = mul nsw i32 2, %725
%727 = add nsw i32 %726, 3
%728 = load i32, i32* %20
%729 = mul nsw i32 %727, %728
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds i8, i8* %724, i64 %730
%732 = load i8, i8* %731
%733 = zext i8 %732 to i32
%734 = load float, float* %22
%735 = call i32 @gamma_correct(i32 %733, float %734)
%736 = load i32, i32* %30
%737 = call i32 @icerp(i32 %699, i32 %711, i32 %723, i32 %735, i32 %736)
store i32 %737, i32* %35
%738 = load i32, i32* %28
%739 = load i32, i32* %14
%740 = sub nsw i32 %739, 1
%741 = icmp slt i32 %738, %740
br i1 %741, label %742, label %793
742: ; preds = %687
%743 = load i8*, i8** %47
%744 = load i32, i32* %17
%745 = mul nsw i32 3, %744
%746 = add nsw i32 %745, 0
%747 = load i32, i32* %20
%748 = mul nsw i32 %746, %747
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds i8, i8* %743, i64 %749
%751 = load i8, i8* %750
%752 = zext i8 %751 to i32
%753 = load float, float* %22
%754 = call i32 @gamma_correct(i32 %752, float %753)
%755 = load i8*, i8** %47
%756 = load i32, i32* %17
%757 = mul nsw i32 3, %756
%758 = add nsw i32 %757, 1
%759 = load i32, i32* %20
%760 = mul nsw i32 %758, %759
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds i8, i8* %755, i64 %761
%763 = load i8, i8* %762
%764 = zext i8 %763 to i32
%765 = load float, float* %22
%766 = call i32 @gamma_correct(i32 %764, float %765)
%767 = load i8*, i8** %47
%768 = load i32, i32* %17
%769 = mul nsw i32 3, %768
%770 = add nsw i32 %769, 2
%771 = load i32, i32* %20
%772 = mul nsw i32 %770, %771
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds i8, i8* %767, i64 %773
%775 = load i8, i8* %774
%776 = zext i8 %775 to i32
%777 = load float, float* %22
%778 = call i32 @gamma_correct(i32 %776, float %777)
%779 = load i8*, i8** %47
%780 = load i32, i32* %17
%781 = mul nsw i32 3, %780
%782 = add nsw i32 %781, 3
%783 = load i32, i32* %20
%784 = mul nsw i32 %782, %783
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds i8, i8* %779, i64 %785
%787 = load i8, i8* %786
%788 = zext i8 %787 to i32
%789 = load float, float* %22
%790 = call i32 @gamma_correct(i32 %788, float %789)
%791 = load i32, i32* %30
%792 = call i32 @icerp(i32 %754, i32 %766, i32 %778, i32 %790, i32 %791)
store i32 %792, i32* %36
br label %795
793: ; preds = %687
%794 = load i32, i32* %35
store i32 %794, i32* %36
br label %795
795: ; preds = %793, %742
%796 = load i32, i32* %33
%797 = load i32, i32* %34
%798 = load i32, i32* %35
%799 = load i32, i32* %36
%800 = load i32, i32* %31
%801 = call i32 @icerp(i32 %796, i32 %797, i32 %798, i32 %799, i32 %800)
store i32 %801, i32* %40
%802 = load i32, i32* %29
%803 = load i32, i32* %15
%804 = sub nsw i32 %803, 1
%805 = icmp slt i32 %802, %804
br i1 %805, label %806, label %1007
806: ; preds = %795
%807 = load i8*, i8** %48
%808 = load i32, i32* %17
%809 = add nsw i32 %808, 0
%810 = load i32, i32* %20
%811 = mul nsw i32 %809, %810
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds i8, i8* %807, i64 %812
%814 = load i8, i8* %813
%815 = zext i8 %814 to i32
%816 = load float, float* %22
%817 = call i32 @gamma_correct(i32 %815, float %816)
%818 = load i8*, i8** %48
%819 = load i32, i32* %17
%820 = add nsw i32 %819, 1
%821 = load i32, i32* %20
%822 = mul nsw i32 %820, %821
%823 = sext i32 %822 to i64
%824 = getelementptr inbounds i8, i8* %818, i64 %823
%825 = load i8, i8* %824
%826 = zext i8 %825 to i32
%827 = load float, float* %22
%828 = call i32 @gamma_correct(i32 %826, float %827)
%829 = load i8*, i8** %48
%830 = load i32, i32* %17
%831 = add nsw i32 %830, 2
%832 = load i32, i32* %20
%833 = mul nsw i32 %831, %832
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds i8, i8* %829, i64 %834
%836 = load i8, i8* %835
%837 = zext i8 %836 to i32
%838 = load float, float* %22
%839 = call i32 @gamma_correct(i32 %837, float %838)
%840 = load i8*, i8** %48
%841 = load i32, i32* %17
%842 = add nsw i32 %841, 3
%843 = load i32, i32* %20
%844 = mul nsw i32 %842, %843
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds i8, i8* %840, i64 %845
%847 = load i8, i8* %846
%848 = zext i8 %847 to i32
%849 = load float, float* %22
%850 = call i32 @gamma_correct(i32 %848, float %849)
%851 = load i32, i32* %30
%852 = call i32 @icerp(i32 %817, i32 %828, i32 %839, i32 %850, i32 %851)
store i32 %852, i32* %34
%853 = load i32, i32* %28
%854 = icmp sgt i32 %853, 0
br i1 %854, label %855, label %890
855: ; preds = %806
%856 = load i8*, i8** %48
%857 = getelementptr inbounds i8, i8* %856, i64 0
%858 = load i8, i8* %857
%859 = zext i8 %858 to i32
%860 = load float, float* %22
%861 = call i32 @gamma_correct(i32 %859, float %860)
%862 = load i8*, i8** %48
%863 = load i32, i32* %20
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds i8, i8* %862, i64 %864
%866 = load i8, i8* %865
%867 = zext i8 %866 to i32
%868 = load float, float* %22
%869 = call i32 @gamma_correct(i32 %867, float %868)
%870 = load i8*, i8** %48
%871 = load i32, i32* %20
%872 = mul nsw i32 2, %871
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds i8, i8* %870, i64 %873
%875 = load i8, i8* %874
%876 = zext i8 %875 to i32
%877 = load float, float* %22
%878 = call i32 @gamma_correct(i32 %876, float %877)
%879 = load i8*, i8** %48
%880 = load i32, i32* %20
%881 = mul nsw i32 3, %880
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds i8, i8* %879, i64 %882
%884 = load i8, i8* %883
%885 = zext i8 %884 to i32
%886 = load float, float* %22
%887 = call i32 @gamma_correct(i32 %885, float %886)
%888 = load i32, i32* %30
%889 = call i32 @icerp(i32 %861, i32 %869, i32 %878, i32 %887, i32 %888)
store i32 %889, i32* %33
br label %892
890: ; preds = %806
%891 = load i32, i32* %34
store i32 %891, i32* %33
br label %892
892: ; preds = %890, %855
%893 = load i8*, i8** %48
%894 = load i32, i32* %17
%895 = mul nsw i32 2, %894
%896 = add nsw i32 %895, 0
%897 = load i32, i32* %20
%898 = mul nsw i32 %896, %897
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds i8, i8* %893, i64 %899
%901 = load i8, i8* %900
%902 = zext i8 %901 to i32
%903 = load float, float* %22
%904 = call i32 @gamma_correct(i32 %902, float %903)
%905 = load i8*, i8** %48
%906 = load i32, i32* %17
%907 = mul nsw i32 2, %906
%908 = add nsw i32 %907, 1
%909 = load i32, i32* %20
%910 = mul nsw i32 %908, %909
%911 = sext i32 %910 to i64
%912 = getelementptr inbounds i8, i8* %905, i64 %911
%913 = load i8, i8* %912
%914 = zext i8 %913 to i32
%915 = load float, float* %22
%916 = call i32 @gamma_correct(i32 %914, float %915)
%917 = load i8*, i8** %48
%918 = load i32, i32* %17
%919 = mul nsw i32 2, %918
%920 = add nsw i32 %919, 2
%921 = load i32, i32* %20
%922 = mul nsw i32 %920, %921
%923 = sext i32 %922 to i64
%924 = getelementptr inbounds i8, i8* %917, i64 %923
%925 = load i8, i8* %924
%926 = zext i8 %925 to i32
%927 = load float, float* %22
%928 = call i32 @gamma_correct(i32 %926, float %927)
%929 = load i8*, i8** %48
%930 = load i32, i32* %17
%931 = mul nsw i32 2, %930
%932 = add nsw i32 %931, 3
%933 = load i32, i32* %20
%934 = mul nsw i32 %932, %933
%935 = sext i32 %934 to i64
%936 = getelementptr inbounds i8, i8* %929, i64 %935
%937 = load i8, i8* %936
%938 = zext i8 %937 to i32
%939 = load float, float* %22
%940 = call i32 @gamma_correct(i32 %938, float %939)
%941 = load i32, i32* %30
%942 = call i32 @icerp(i32 %904, i32 %916, i32 %928, i32 %940, i32 %941)
store i32 %942, i32* %35
%943 = load i32, i32* %28
%944 = load i32, i32* %14
%945 = sub nsw i32 %944, 1
%946 = icmp slt i32 %943, %945
br i1 %946, label %947, label %998
947: ; preds = %892
%948 = load i8*, i8** %48
%949 = load i32, i32* %17
%950 = mul nsw i32 3, %949
%951 = add nsw i32 %950, 0
%952 = load i32, i32* %20
%953 = mul nsw i32 %951, %952
%954 = sext i32 %953 to i64
%955 = getelementptr inbounds i8, i8* %948, i64 %954
%956 = load i8, i8* %955
%957 = zext i8 %956 to i32
%958 = load float, float* %22
%959 = call i32 @gamma_correct(i32 %957, float %958)
%960 = load i8*, i8** %48
%961 = load i32, i32* %17
%962 = mul nsw i32 3, %961
%963 = add nsw i32 %962, 1
%964 = load i32, i32* %20
%965 = mul nsw i32 %963, %964
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds i8, i8* %960, i64 %966
%968 = load i8, i8* %967
%969 = zext i8 %968 to i32
%970 = load float, float* %22
%971 = call i32 @gamma_correct(i32 %969, float %970)
%972 = load i8*, i8** %48
%973 = load i32, i32* %17
%974 = mul nsw i32 3, %973
%975 = add nsw i32 %974, 2
%976 = load i32, i32* %20
%977 = mul nsw i32 %975, %976
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds i8, i8* %972, i64 %978
%980 = load i8, i8* %979
%981 = zext i8 %980 to i32
%982 = load float, float* %22
%983 = call i32 @gamma_correct(i32 %981, float %982)
%984 = load i8*, i8** %48
%985 = load i32, i32* %17
%986 = mul nsw i32 3, %985
%987 = add nsw i32 %986, 3
%988 = load i32, i32* %20
%989 = mul nsw i32 %987, %988
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds i8, i8* %984, i64 %990
%992 = load i8, i8* %991
%993 = zext i8 %992 to i32
%994 = load float, float* %22
%995 = call i32 @gamma_correct(i32 %993, float %994)
%996 = load i32, i32* %30
%997 = call i32 @icerp(i32 %959, i32 %971, i32 %983, i32 %995, i32 %996)
store i32 %997, i32* %36
br label %1000
998: ; preds = %892
%999 = load i32, i32* %35
store i32 %999, i32* %36
br label %1000
1000: ; preds = %998, %947
%1001 = load i32, i32* %33
%1002 = load i32, i32* %34
%1003 = load i32, i32* %35
%1004 = load i32, i32* %36
%1005 = load i32, i32* %31
%1006 = call i32 @icerp(i32 %1001, i32 %1002, i32 %1003, i32 %1004, i32 %1005)
store i32 %1006, i32* %41
br label %1009
1007: ; preds = %795
%1008 = load i32, i32* %40
store i32 %1008, i32* %41
br label %1009
1009: ; preds = %1007, %1000
%1010 = load i32, i32* %38
%1011 = load i32, i32* %39
%1012 = load i32, i32* %40
%1013 = load i32, i32* %41
%1014 = load i32, i32* %32
%1015 = call i32 @icerp(i32 %1010, i32 %1011, i32 %1012, i32 %1013, i32 %1014)
store i32 %1015, i32* %37
%1016 = load i32, i32* %37
%1017 = icmp slt i32 %1016, 0
br i1 %1017, label %1018, label %1019
1018: ; preds = %1009
store i32 0, i32* %37
br label %1019
1019: ; preds = %1018, %1009
%1020 = load i32, i32* %37
%1021 = icmp sgt i32 %1020, 255
br i1 %1021, label %1022, label %1023
1022: ; preds = %1019
store i32 255, i32* %37
br label %1023
1023: ; preds = %1022, %1019
%1024 = load i32, i32* %37
%1025 = load float, float* %49
%1026 = call i32 @gamma_correct(i32 %1024, float %1025)
%1027 = trunc i32 %1026 to i8
%1028 = load i8*, i8** %12
%1029 = load i32, i32* %26
%1030 = load i32, i32* %44
%1031 = mul nsw i32 %1029, %1030
%1032 = load i32, i32* %25
%1033 = load i32, i32* %42
%1034 = mul nsw i32 %1032, %1033
%1035 = add nsw i32 %1031, %1034
%1036 = load i32, i32* %24
%1037 = load i32, i32* %20
%1038 = mul nsw i32 %1036, %1037
%1039 = add nsw i32 %1035, %1038
%1040 = load i32, i32* %23
%1041 = add nsw i32 %1039, %1040
%1042 = sext i32 %1041 to i64
%1043 = getelementptr inbounds i8, i8* %1028, i64 %1042
store i8 %1027, i8* %1043
%1044 = load i8*, i8** %45
%1045 = getelementptr inbounds i8, i8* %1044, i32 1
store i8* %1045, i8** %45
%1046 = load i8*, i8** %46
%1047 = getelementptr inbounds i8, i8* %1046, i32 1
store i8* %1047, i8** %46
%1048 = load i8*, i8** %47
%1049 = getelementptr inbounds i8, i8* %1048, i32 1
store i8* %1049, i8** %47
%1050 = load i8*, i8** %48
%1051 = getelementptr inbounds i8, i8* %1050, i32 1
store i8* %1051, i8** %48
br label %1052
1052: ; preds = %1023
%1053 = load i32, i32* %23
%1054 = add nsw i32 %1053, 1
store i32 %1054, i32* %23
br label %191
1055: ; preds = %191
br label %1056
1056: ; preds = %1055
%1057 = load i32, i32* %24
%1058 = add nsw i32 %1057, 1
store i32 %1058, i32* %24
br label %130
1059: ; preds = %130
br label %1060
1060: ; preds = %1059
%1061 = load i32, i32* %25
%1062 = add nsw i32 %1061, 1
store i32 %1062, i32* %25
br label %100
1063: ; preds = %100
br label %1064
1064: ; preds = %1063
%1065 = load i32, i32* %26
%1066 = add nsw i32 %1065, 1
store i32 %1066, i32* %26
br label %70
1067: ; preds = %70
br label %1937
1068: ; preds = %11
store i32 0, i32* %26
br label %1069
1069: ; preds = %1933, %1068
%1070 = load i32, i32* %26
%1071 = load i32, i32* %15
%1072 = icmp slt i32 %1070, %1071
br i1 %1072, label %1073, label %1936
1073: ; preds = %1069
%1074 = load i32, i32* %15
%1075 = icmp sgt i32 %1074, 1
br i1 %1075, label %1076, label %1097
1076: ; preds = %1073
%1077 = load i32, i32* %19
%1078 = sub nsw i32 %1077, 1
%1079 = load i32, i32* %26
%1080 = mul nsw i32 %1078, %1079
%1081 = shl i32 %1080, 7
%1082 = load i32, i32* %15
%1083 = sub nsw i32 %1082, 1
%1084 = sdiv i32 %1081, %1083
store i32 %1084, i32* %29
%1085 = load i32, i32* %26
%1086 = load i32, i32* %15
%1087 = sub nsw i32 %1086, 1
%1088 = icmp eq i32 %1085, %1087
br i1 %1088, label %1089, label %1092
1089: ; preds = %1076
%1090 = load i32, i32* %29
%1091 = add nsw i32 %1090, -1
store i32 %1091, i32* %29
br label %1092
1092: ; preds = %1089, %1076
%1093 = load i32, i32* %29
%1094 = and i32 %1093, 127
store i32 %1094, i32* %32
%1095 = load i32, i32* %29
%1096 = ashr i32 %1095, 7
store i32 %1096, i32* %29
br label %1098
1097: ; preds = %1073
store i32 0, i32* %32
store i32 0, i32* %29
br label %1098
1098: ; preds = %1097, %1092
store i32 0, i32* %25
br label %1099
1099: ; preds = %1929, %1098
%1100 = load i32, i32* %25
%1101 = load i32, i32* %14
%1102 = icmp slt i32 %1100, %1101
br i1 %1102, label %1103, label %1932
1103: ; preds = %1099
%1104 = load i32, i32* %14
%1105 = icmp sgt i32 %1104, 1
br i1 %1105, label %1106, label %1127
1106: ; preds = %1103
%1107 = load i32, i32* %18
%1108 = sub nsw i32 %1107, 1
%1109 = load i32, i32* %25
%1110 = mul nsw i32 %1108, %1109
%1111 = shl i32 %1110, 7
%1112 = load i32, i32* %14
%1113 = sub nsw i32 %1112, 1
%1114 = sdiv i32 %1111, %1113
store i32 %1114, i32* %28
%1115 = load i32, i32* %25
%1116 = load i32, i32* %14
%1117 = sub nsw i32 %1116, 1
%1118 = icmp eq i32 %1115, %1117
br i1 %1118, label %1119, label %1122
1119: ; preds = %1106
%1120 = load i32, i32* %28
%1121 = add nsw i32 %1120, -1
store i32 %1121, i32* %28
br label %1122
1122: ; preds = %1119, %1106
%1123 = load i32, i32* %28
%1124 = and i32 %1123, 127
store i32 %1124, i32* %31
%1125 = load i32, i32* %28
%1126 = ashr i32 %1125, 7
store i32 %1126, i32* %28
br label %1128
1127: ; preds = %1103
store i32 0, i32* %31
store i32 0, i32* %28
br label %1128
1128: ; preds = %1127, %1122
store i32 0, i32* %24
br label %1129
1129: ; preds = %1925, %1128
%1130 = load i32, i32* %24
%1131 = load i32, i32* %13
%1132 = icmp slt i32 %1130, %1131
br i1 %1132, label %1133, label %1928
1133: ; preds = %1129
%1134 = load i32, i32* %13
%1135 = icmp sgt i32 %1134, 1
br i1 %1135, label %1136, label %1157
1136: ; preds = %1133
%1137 = load i32, i32* %17
%1138 = sub nsw i32 %1137, 1
%1139 = load i32, i32* %24
%1140 = mul nsw i32 %1138, %1139
%1141 = shl i32 %1140, 7
%1142 = load i32, i32* %13
%1143 = sub nsw i32 %1142, 1
%1144 = sdiv i32 %1141, %1143
store i32 %1144, i32* %27
%1145 = load i32, i32* %24
%1146 = load i32, i32* %13
%1147 = sub nsw i32 %1146, 1
%1148 = icmp eq i32 %1145, %1147
br i1 %1148, label %1149, label %1152
1149: ; preds = %1136
%1150 = load i32, i32* %27
%1151 = add nsw i32 %1150, -1
store i32 %1151, i32* %27
br label %1152
1152: ; preds = %1149, %1136
%1153 = load i32, i32* %27
%1154 = and i32 %1153, 127
store i32 %1154, i32* %30
%1155 = load i32, i32* %27
%1156 = ashr i32 %1155, 7
store i32 %1156, i32* %27
br label %1158
1157: ; preds = %1133
store i32 0, i32* %30
store i32 0, i32* %27
br label %1158
1158: ; preds = %1157, %1152
%1159 = load i8*, i8** %16
%1160 = load i32, i32* %29
%1161 = sub nsw i32 %1160, 1
%1162 = load i32, i32* %17
%1163 = load i32, i32* %18
%1164 = mul nsw i32 %1162, %1163
%1165 = mul nsw i32 %1161, %1164
%1166 = load i32, i32* %28
%1167 = sub nsw i32 %1166, 1
%1168 = load i32, i32* %17
%1169 = mul nsw i32 %1167, %1168
%1170 = add nsw i32 %1165, %1169
%1171 = load i32, i32* %27
%1172 = sub nsw i32 %1171, 1
%1173 = add nsw i32 %1170, %1172
%1174 = load i32, i32* %20
%1175 = mul nsw i32 %1173, %1174
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds i8, i8* %1159, i64 %1176
store i8* %1177, i8** %45
%1178 = load i8*, i8** %45
%1179 = load i32, i32* %43
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds i8, i8* %1178, i64 %1180
store i8* %1181, i8** %46
%1182 = load i8*, i8** %46
%1183 = load i32, i32* %43
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds i8, i8* %1182, i64 %1184
store i8* %1185, i8** %47
%1186 = load i8*, i8** %47
%1187 = load i32, i32* %43
%1188 = sext i32 %1187 to i64
%1189 = getelementptr inbounds i8, i8* %1186, i64 %1188
store i8* %1189, i8** %48
store i32 0, i32* %23
br label %1190
1190: ; preds = %1921, %1158
%1191 = load i32, i32* %23
%1192 = load i32, i32* %20
%1193 = icmp slt i32 %1191, %1192
br i1 %1193, label %1194, label %1924
1194: ; preds = %1190
%1195 = load i8*, i8** %46
%1196 = load i32, i32* %17
%1197 = add nsw i32 %1196, 0
%1198 = load i32, i32* %20
%1199 = mul nsw i32 %1197, %1198
%1200 = sext i32 %1199 to i64
%1201 = getelementptr inbounds i8, i8* %1195, i64 %1200
%1202 = load i8, i8* %1201
%1203 = zext i8 %1202 to i32
%1204 = load i8*, i8** %46
%1205 = load i32, i32* %17
%1206 = add nsw i32 %1205, 1
%1207 = load i32, i32* %20
%1208 = mul nsw i32 %1206, %1207
%1209 = sext i32 %1208 to i64
%1210 = getelementptr inbounds i8, i8* %1204, i64 %1209
%1211 = load i8, i8* %1210
%1212 = zext i8 %1211 to i32
%1213 = load i8*, i8** %46
%1214 = load i32, i32* %17
%1215 = add nsw i32 %1214, 2
%1216 = load i32, i32* %20
%1217 = mul nsw i32 %1215, %1216
%1218 = sext i32 %1217 to i64
%1219 = getelementptr inbounds i8, i8* %1213, i64 %1218
%1220 = load i8, i8* %1219
%1221 = zext i8 %1220 to i32
%1222 = load i8*, i8** %46
%1223 = load i32, i32* %17
%1224 = add nsw i32 %1223, 3
%1225 = load i32, i32* %20
%1226 = mul nsw i32 %1224, %1225
%1227 = sext i32 %1226 to i64
%1228 = getelementptr inbounds i8, i8* %1222, i64 %1227
%1229 = load i8, i8* %1228
%1230 = zext i8 %1229 to i32
%1231 = load i32, i32* %30
%1232 = call i32 @icerp(i32 %1203, i32 %1212, i32 %1221, i32 %1230, i32 %1231)
store i32 %1232, i32* %34
%1233 = load i32, i32* %28
%1234 = icmp sgt i32 %1233, 0
br i1 %1234, label %1235, label %1262
1235: ; preds = %1194
%1236 = load i8*, i8** %46
%1237 = getelementptr inbounds i8, i8* %1236, i64 0
%1238 = load i8, i8* %1237
%1239 = zext i8 %1238 to i32
%1240 = load i8*, i8** %46
%1241 = load i32, i32* %20
%1242 = sext i32 %1241 to i64
%1243 = getelementptr inbounds i8, i8* %1240, i64 %1242
%1244 = load i8, i8* %1243
%1245 = zext i8 %1244 to i32
%1246 = load i8*, i8** %46
%1247 = load i32, i32* %20
%1248 = mul nsw i32 2, %1247
%1249 = sext i32 %1248 to i64
%1250 = getelementptr inbounds i8, i8* %1246, i64 %1249
%1251 = load i8, i8* %1250
%1252 = zext i8 %1251 to i32
%1253 = load i8*, i8** %46
%1254 = load i32, i32* %20
%1255 = mul nsw i32 3, %1254
%1256 = sext i32 %1255 to i64
%1257 = getelementptr inbounds i8, i8* %1253, i64 %1256
%1258 = load i8, i8* %1257
%1259 = zext i8 %1258 to i32
%1260 = load i32, i32* %30
%1261 = call i32 @icerp(i32 %1239, i32 %1245, i32 %1252, i32 %1259, i32 %1260)
store i32 %1261, i32* %33
br label %1264
1262: ; preds = %1194
%1263 = load i32, i32* %34
store i32 %1263, i32* %33
br label %1264
1264: ; preds = %1262, %1235
%1265 = load i8*, i8** %46
%1266 = load i32, i32* %17
%1267 = mul nsw i32 2, %1266
%1268 = add nsw i32 %1267, 0
%1269 = load i32, i32* %20
%1270 = mul nsw i32 %1268, %1269
%1271 = sext i32 %1270 to i64
%1272 = getelementptr inbounds i8, i8* %1265, i64 %1271
%1273 = load i8, i8* %1272
%1274 = zext i8 %1273 to i32
%1275 = load i8*, i8** %46
%1276 = load i32, i32* %17
%1277 = mul nsw i32 2, %1276
%1278 = add nsw i32 %1277, 1
%1279 = load i32, i32* %20
%1280 = mul nsw i32 %1278, %1279
%1281 = sext i32 %1280 to i64
%1282 = getelementptr inbounds i8, i8* %1275, i64 %1281
%1283 = load i8, i8* %1282
%1284 = zext i8 %1283 to i32
%1285 = load i8*, i8** %46
%1286 = load i32, i32* %17
%1287 = mul nsw i32 2, %1286
%1288 = add nsw i32 %1287, 2
%1289 = load i32, i32* %20
%1290 = mul nsw i32 %1288, %1289
%1291 = sext i32 %1290 to i64
%1292 = getelementptr inbounds i8, i8* %1285, i64 %1291
%1293 = load i8, i8* %1292
%1294 = zext i8 %1293 to i32
%1295 = load i8*, i8** %46
%1296 = load i32, i32* %17
%1297 = mul nsw i32 2, %1296
%1298 = add nsw i32 %1297, 3
%1299 = load i32, i32* %20
%1300 = mul nsw i32 %1298, %1299
%1301 = sext i32 %1300 to i64
%1302 = getelementptr inbounds i8, i8* %1295, i64 %1301
%1303 = load i8, i8* %1302
%1304 = zext i8 %1303 to i32
%1305 = load i32, i32* %30
%1306 = call i32 @icerp(i32 %1274, i32 %1284, i32 %1294, i32 %1304, i32 %1305)
store i32 %1306, i32* %35
%1307 = load i32, i32* %28
%1308 = load i32, i32* %14
%1309 = sub nsw i32 %1308, 1
%1310 = icmp slt i32 %1307, %1309
br i1 %1310, label %1311, label %1354
1311: ; preds = %1264
%1312 = load i8*, i8** %46
%1313 = load i32, i32* %17
%1314 = mul nsw i32 3, %1313
%1315 = add nsw i32 %1314, 0
%1316 = load i32, i32* %20
%1317 = mul nsw i32 %1315, %1316
%1318 = sext i32 %1317 to i64
%1319 = getelementptr inbounds i8, i8* %1312, i64 %1318
%1320 = load i8, i8* %1319
%1321 = zext i8 %1320 to i32
%1322 = load i8*, i8** %46
%1323 = load i32, i32* %17
%1324 = mul nsw i32 3, %1323
%1325 = add nsw i32 %1324, 1
%1326 = load i32, i32* %20
%1327 = mul nsw i32 %1325, %1326
%1328 = sext i32 %1327 to i64
%1329 = getelementptr inbounds i8, i8* %1322, i64 %1328
%1330 = load i8, i8* %1329
%1331 = zext i8 %1330 to i32
%1332 = load i8*, i8** %46
%1333 = load i32, i32* %17
%1334 = mul nsw i32 3, %1333
%1335 = add nsw i32 %1334, 2
%1336 = load i32, i32* %20
%1337 = mul nsw i32 %1335, %1336
%1338 = sext i32 %1337 to i64
%1339 = getelementptr inbounds i8, i8* %1332, i64 %1338
%1340 = load i8, i8* %1339
%1341 = zext i8 %1340 to i32
%1342 = load i8*, i8** %46
%1343 = load i32, i32* %17
%1344 = mul nsw i32 3, %1343
%1345 = add nsw i32 %1344, 3
%1346 = load i32, i32* %20
%1347 = mul nsw i32 %1345, %1346
%1348 = sext i32 %1347 to i64
%1349 = getelementptr inbounds i8, i8* %1342, i64 %1348
%1350 = load i8, i8* %1349
%1351 = zext i8 %1350 to i32
%1352 = load i32, i32* %30
%1353 = call i32 @icerp(i32 %1321, i32 %1331, i32 %1341, i32 %1351, i32 %1352)
store i32 %1353, i32* %36
br label %1356
1354: ; preds = %1264
%1355 = load i32, i32* %35
store i32 %1355, i32* %36
br label %1356
1356: ; preds = %1354, %1311
%1357 = load i32, i32* %33
%1358 = load i32, i32* %34
%1359 = load i32, i32* %35
%1360 = load i32, i32* %36
%1361 = load i32, i32* %31
%1362 = call i32 @icerp(i32 %1357, i32 %1358, i32 %1359, i32 %1360, i32 %1361)
store i32 %1362, i32* %39
%1363 = load i32, i32* %29
%1364 = icmp sgt i32 %1363, 0
br i1 %1364, label %1365, label %1534
1365: ; preds = %1356
%1366 = load i8*, i8** %45
%1367 = load i32, i32* %17
%1368 = add nsw i32 %1367, 0
%1369 = load i32, i32* %20
%1370 = mul nsw i32 %1368, %1369
%1371 = sext i32 %1370 to i64
%1372 = getelementptr inbounds i8, i8* %1366, i64 %1371
%1373 = load i8, i8* %1372
%1374 = zext i8 %1373 to i32
%1375 = load i8*, i8** %45
%1376 = load i32, i32* %17
%1377 = add nsw i32 %1376, 1
%1378 = load i32, i32* %20
%1379 = mul nsw i32 %1377, %1378
%1380 = sext i32 %1379 to i64
%1381 = getelementptr inbounds i8, i8* %1375, i64 %1380
%1382 = load i8, i8* %1381
%1383 = zext i8 %1382 to i32
%1384 = load i8*, i8** %45
%1385 = load i32, i32* %17
%1386 = add nsw i32 %1385, 2
%1387 = load i32, i32* %20
%1388 = mul nsw i32 %1386, %1387
%1389 = sext i32 %1388 to i64
%1390 = getelementptr inbounds i8, i8* %1384, i64 %1389
%1391 = load i8, i8* %1390
%1392 = zext i8 %1391 to i32
%1393 = load i8*, i8** %45
%1394 = load i32, i32* %17
%1395 = add nsw i32 %1394, 3
%1396 = load i32, i32* %20
%1397 = mul nsw i32 %1395, %1396
%1398 = sext i32 %1397 to i64
%1399 = getelementptr inbounds i8, i8* %1393, i64 %1398
%1400 = load i8, i8* %1399
%1401 = zext i8 %1400 to i32
%1402 = load i32, i32* %30
%1403 = call i32 @icerp(i32 %1374, i32 %1383, i32 %1392, i32 %1401, i32 %1402)
store i32 %1403, i32* %34
%1404 = load i32, i32* %28
%1405 = icmp sgt i32 %1404, 0
br i1 %1405, label %1406, label %1433
1406: ; preds = %1365
%1407 = load i8*, i8** %45
%1408 = getelementptr inbounds i8, i8* %1407, i64 0
%1409 = load i8, i8* %1408
%1410 = zext i8 %1409 to i32
%1411 = load i8*, i8** %45
%1412 = load i32, i32* %20
%1413 = sext i32 %1412 to i64
%1414 = getelementptr inbounds i8, i8* %1411, i64 %1413
%1415 = load i8, i8* %1414
%1416 = zext i8 %1415 to i32
%1417 = load i8*, i8** %45
%1418 = load i32, i32* %20
%1419 = mul nsw i32 2, %1418
%1420 = sext i32 %1419 to i64
%1421 = getelementptr inbounds i8, i8* %1417, i64 %1420
%1422 = load i8, i8* %1421
%1423 = zext i8 %1422 to i32
%1424 = load i8*, i8** %45
%1425 = load i32, i32* %20
%1426 = mul nsw i32 3, %1425
%1427 = sext i32 %1426 to i64
%1428 = getelementptr inbounds i8, i8* %1424, i64 %1427
%1429 = load i8, i8* %1428
%1430 = zext i8 %1429 to i32
%1431 = load i32, i32* %30
%1432 = call i32 @icerp(i32 %1410, i32 %1416, i32 %1423, i32 %1430, i32 %1431)
store i32 %1432, i32* %33
br label %1435
1433: ; preds = %1365
%1434 = load i32, i32* %34
store i32 %1434, i32* %33
br label %1435
1435: ; preds = %1433, %1406
%1436 = load i8*, i8** %45
%1437 = load i32, i32* %17
%1438 = mul nsw i32 2, %1437
%1439 = add nsw i32 %1438, 0
%1440 = load i32, i32* %20
%1441 = mul nsw i32 %1439, %1440
%1442 = sext i32 %1441 to i64
%1443 = getelementptr inbounds i8, i8* %1436, i64 %1442
%1444 = load i8, i8* %1443
%1445 = zext i8 %1444 to i32
%1446 = load i8*, i8** %45
%1447 = load i32, i32* %17
%1448 = mul nsw i32 2, %1447
%1449 = add nsw i32 %1448, 1
%1450 = load i32, i32* %20
%1451 = mul nsw i32 %1449, %1450
%1452 = sext i32 %1451 to i64
%1453 = getelementptr inbounds i8, i8* %1446, i64 %1452
%1454 = load i8, i8* %1453
%1455 = zext i8 %1454 to i32
%1456 = load i8*, i8** %45
%1457 = load i32, i32* %17
%1458 = mul nsw i32 2, %1457
%1459 = add nsw i32 %1458, 2
%1460 = load i32, i32* %20
%1461 = mul nsw i32 %1459, %1460
%1462 = sext i32 %1461 to i64
%1463 = getelementptr inbounds i8, i8* %1456, i64 %1462
%1464 = load i8, i8* %1463
%1465 = zext i8 %1464 to i32
%1466 = load i8*, i8** %45
%1467 = load i32, i32* %17
%1468 = mul nsw i32 2, %1467
%1469 = add nsw i32 %1468, 3
%1470 = load i32, i32* %20
%1471 = mul nsw i32 %1469, %1470
%1472 = sext i32 %1471 to i64
%1473 = getelementptr inbounds i8, i8* %1466, i64 %1472
%1474 = load i8, i8* %1473
%1475 = zext i8 %1474 to i32
%1476 = load i32, i32* %30
%1477 = call i32 @icerp(i32 %1445, i32 %1455, i32 %1465, i32 %1475, i32 %1476)
store i32 %1477, i32* %35
%1478 = load i32, i32* %28
%1479 = load i32, i32* %14
%1480 = sub nsw i32 %1479, 1
%1481 = icmp slt i32 %1478, %1480
br i1 %1481, label %1482, label %1525
1482: ; preds = %1435
%1483 = load i8*, i8** %45
%1484 = load i32, i32* %17
%1485 = mul nsw i32 3, %1484
%1486 = add nsw i32 %1485, 0
%1487 = load i32, i32* %20
%1488 = mul nsw i32 %1486, %1487
%1489 = sext i32 %1488 to i64
%1490 = getelementptr inbounds i8, i8* %1483, i64 %1489
%1491 = load i8, i8* %1490
%1492 = zext i8 %1491 to i32
%1493 = load i8*, i8** %45
%1494 = load i32, i32* %17
%1495 = mul nsw i32 3, %1494
%1496 = add nsw i32 %1495, 1
%1497 = load i32, i32* %20
%1498 = mul nsw i32 %1496, %1497
%1499 = sext i32 %1498 to i64
%1500 = getelementptr inbounds i8, i8* %1493, i64 %1499
%1501 = load i8, i8* %1500
%1502 = zext i8 %1501 to i32
%1503 = load i8*, i8** %45
%1504 = load i32, i32* %17
%1505 = mul nsw i32 3, %1504
%1506 = add nsw i32 %1505, 2
%1507 = load i32, i32* %20
%1508 = mul nsw i32 %1506, %1507
%1509 = sext i32 %1508 to i64
%1510 = getelementptr inbounds i8, i8* %1503, i64 %1509
%1511 = load i8, i8* %1510
%1512 = zext i8 %1511 to i32
%1513 = load i8*, i8** %45
%1514 = load i32, i32* %17
%1515 = mul nsw i32 3, %1514
%1516 = add nsw i32 %1515, 3
%1517 = load i32, i32* %20
%1518 = mul nsw i32 %1516, %1517
%1519 = sext i32 %1518 to i64
%1520 = getelementptr inbounds i8, i8* %1513, i64 %1519
%1521 = load i8, i8* %1520
%1522 = zext i8 %1521 to i32
%1523 = load i32, i32* %30
%1524 = call i32 @icerp(i32 %1492, i32 %1502, i32 %1512, i32 %1522, i32 %1523)
store i32 %1524, i32* %36
br label %1527
1525: ; preds = %1435
%1526 = load i32, i32* %35
store i32 %1526, i32* %36
br label %1527
1527: ; preds = %1525, %1482
%1528 = load i32, i32* %33
%1529 = load i32, i32* %34
%1530 = load i32, i32* %35
%1531 = load i32, i32* %36
%1532 = load i32, i32* %31
%1533 = call i32 @icerp(i32 %1528, i32 %1529, i32 %1530, i32 %1531, i32 %1532)
store i32 %1533, i32* %38
br label %1536
1534: ; preds = %1356
%1535 = load i32, i32* %39
store i32 %1535, i32* %38
br label %1536
1536: ; preds = %1534, %1527
%1537 = load i8*, i8** %47
%1538 = load i32, i32* %17
%1539 = add nsw i32 %1538, 0
%1540 = load i32, i32* %20
%1541 = mul nsw i32 %1539, %1540
%1542 = sext i32 %1541 to i64
%1543 = getelementptr inbounds i8, i8* %1537, i64 %1542
%1544 = load i8, i8* %1543
%1545 = zext i8 %1544 to i32
%1546 = load i8*, i8** %47
%1547 = load i32, i32* %17
%1548 = add nsw i32 %1547, 1
%1549 = load i32, i32* %20
%1550 = mul nsw i32 %1548, %1549
%1551 = sext i32 %1550 to i64
%1552 = getelementptr inbounds i8, i8* %1546, i64 %1551
%1553 = load i8, i8* %1552
%1554 = zext i8 %1553 to i32
%1555 = load i8*, i8** %47
%1556 = load i32, i32* %17
%1557 = add nsw i32 %1556, 2
%1558 = load i32, i32* %20
%1559 = mul nsw i32 %1557, %1558
%1560 = sext i32 %1559 to i64
%1561 = getelementptr inbounds i8, i8* %1555, i64 %1560
%1562 = load i8, i8* %1561
%1563 = zext i8 %1562 to i32
%1564 = load i8*, i8** %47
%1565 = load i32, i32* %17
%1566 = add nsw i32 %1565, 3
%1567 = load i32, i32* %20
%1568 = mul nsw i32 %1566, %1567
%1569 = sext i32 %1568 to i64
%1570 = getelementptr inbounds i8, i8* %1564, i64 %1569
%1571 = load i8, i8* %1570
%1572 = zext i8 %1571 to i32
%1573 = load i32, i32* %30
%1574 = call i32 @icerp(i32 %1545, i32 %1554, i32 %1563, i32 %1572, i32 %1573)
store i32 %1574, i32* %34
%1575 = load i32, i32* %28
%1576 = icmp sgt i32 %1575, 0
br i1 %1576, label %1577, label %1604
1577: ; preds = %1536
%1578 = load i8*, i8** %47
%1579 = getelementptr inbounds i8, i8* %1578, i64 0
%1580 = load i8, i8* %1579
%1581 = zext i8 %1580 to i32
%1582 = load i8*, i8** %47
%1583 = load i32, i32* %20
%1584 = sext i32 %1583 to i64
%1585 = getelementptr inbounds i8, i8* %1582, i64 %1584
%1586 = load i8, i8* %1585
%1587 = zext i8 %1586 to i32
%1588 = load i8*, i8** %47
%1589 = load i32, i32* %20
%1590 = mul nsw i32 2, %1589
%1591 = sext i32 %1590 to i64
%1592 = getelementptr inbounds i8, i8* %1588, i64 %1591
%1593 = load i8, i8* %1592
%1594 = zext i8 %1593 to i32
%1595 = load i8*, i8** %47
%1596 = load i32, i32* %20
%1597 = mul nsw i32 3, %1596
%1598 = sext i32 %1597 to i64
%1599 = getelementptr inbounds i8, i8* %1595, i64 %1598
%1600 = load i8, i8* %1599
%1601 = zext i8 %1600 to i32
%1602 = load i32, i32* %30
%1603 = call i32 @icerp(i32 %1581, i32 %1587, i32 %1594, i32 %1601, i32 %1602)
store i32 %1603, i32* %33
br label %1606
1604: ; preds = %1536
%1605 = load i32, i32* %34
store i32 %1605, i32* %33
br label %1606
1606: ; preds = %1604, %1577
%1607 = load i8*, i8** %47
%1608 = load i32, i32* %17
%1609 = mul nsw i32 2, %1608
%1610 = add nsw i32 %1609, 0
%1611 = load i32, i32* %20
%1612 = mul nsw i32 %1610, %1611
%1613 = sext i32 %1612 to i64
%1614 = getelementptr inbounds i8, i8* %1607, i64 %1613
%1615 = load i8, i8* %1614
%1616 = zext i8 %1615 to i32
%1617 = load i8*, i8** %47
%1618 = load i32, i32* %17
%1619 = mul nsw i32 2, %1618
%1620 = add nsw i32 %1619, 1
%1621 = load i32, i32* %20
%1622 = mul nsw i32 %1620, %1621
%1623 = sext i32 %1622 to i64
%1624 = getelementptr inbounds i8, i8* %1617, i64 %1623
%1625 = load i8, i8* %1624
%1626 = zext i8 %1625 to i32
%1627 = load i8*, i8** %47
%1628 = load i32, i32* %17
%1629 = mul nsw i32 2, %1628
%1630 = add nsw i32 %1629, 2
%1631 = load i32, i32* %20
%1632 = mul nsw i32 %1630, %1631
%1633 = sext i32 %1632 to i64
%1634 = getelementptr inbounds i8, i8* %1627, i64 %1633
%1635 = load i8, i8* %1634
%1636 = zext i8 %1635 to i32
%1637 = load i8*, i8** %47
%1638 = load i32, i32* %17
%1639 = mul nsw i32 2, %1638
%1640 = add nsw i32 %1639, 3
%1641 = load i32, i32* %20
%1642 = mul nsw i32 %1640, %1641
%1643 = sext i32 %1642 to i64
%1644 = getelementptr inbounds i8, i8* %1637, i64 %1643
%1645 = load i8, i8* %1644
%1646 = zext i8 %1645 to i32
%1647 = load i32, i32* %30
%1648 = call i32 @icerp(i32 %1616, i32 %1626, i32 %1636, i32 %1646, i32 %1647)
store i32 %1648, i32* %35
%1649 = load i32, i32* %28
%1650 = load i32, i32* %14
%1651 = sub nsw i32 %1650, 1
%1652 = icmp slt i32 %1649, %1651
br i1 %1652, label %1653, label %1696
1653: ; preds = %1606
%1654 = load i8*, i8** %47
%1655 = load i32, i32* %17
%1656 = mul nsw i32 3, %1655
%1657 = add nsw i32 %1656, 0
%1658 = load i32, i32* %20
%1659 = mul nsw i32 %1657, %1658
%1660 = sext i32 %1659 to i64
%1661 = getelementptr inbounds i8, i8* %1654, i64 %1660
%1662 = load i8, i8* %1661
%1663 = zext i8 %1662 to i32
%1664 = load i8*, i8** %47
%1665 = load i32, i32* %17
%1666 = mul nsw i32 3, %1665
%1667 = add nsw i32 %1666, 1
%1668 = load i32, i32* %20
%1669 = mul nsw i32 %1667, %1668
%1670 = sext i32 %1669 to i64
%1671 = getelementptr inbounds i8, i8* %1664, i64 %1670
%1672 = load i8, i8* %1671
%1673 = zext i8 %1672 to i32
%1674 = load i8*, i8** %47
%1675 = load i32, i32* %17
%1676 = mul nsw i32 3, %1675
%1677 = add nsw i32 %1676, 2
%1678 = load i32, i32* %20
%1679 = mul nsw i32 %1677, %1678
%1680 = sext i32 %1679 to i64
%1681 = getelementptr inbounds i8, i8* %1674, i64 %1680
%1682 = load i8, i8* %1681
%1683 = zext i8 %1682 to i32
%1684 = load i8*, i8** %47
%1685 = load i32, i32* %17
%1686 = mul nsw i32 3, %1685
%1687 = add nsw i32 %1686, 3
%1688 = load i32, i32* %20
%1689 = mul nsw i32 %1687, %1688
%1690 = sext i32 %1689 to i64
%1691 = getelementptr inbounds i8, i8* %1684, i64 %1690
%1692 = load i8, i8* %1691
%1693 = zext i8 %1692 to i32
%1694 = load i32, i32* %30
%1695 = call i32 @icerp(i32 %1663, i32 %1673, i32 %1683, i32 %1693, i32 %1694)
store i32 %1695, i32* %36
br label %1698
1696: ; preds = %1606
%1697 = load i32, i32* %35
store i32 %1697, i32* %36
br label %1698
1698: ; preds = %1696, %1653
%1699 = load i32, i32* %33
%1700 = load i32, i32* %34
%1701 = load i32, i32* %35
%1702 = load i32, i32* %36
%1703 = load i32, i32* %31
%1704 = call i32 @icerp(i32 %1699, i32 %1700, i32 %1701, i32 %1702, i32 %1703)
store i32 %1704, i32* %40
%1705 = load i32, i32* %29
%1706 = load i32, i32* %15
%1707 = sub nsw i32 %1706, 1
%1708 = icmp slt i32 %1705, %1707
br i1 %1708, label %1709, label %1878
1709: ; preds = %1698
%1710 = load i8*, i8** %48
%1711 = load i32, i32* %17
%1712 = add nsw i32 %1711, 0
%1713 = load i32, i32* %20
%1714 = mul nsw i32 %1712, %1713
%1715 = sext i32 %1714 to i64
%1716 = getelementptr inbounds i8, i8* %1710, i64 %1715
%1717 = load i8, i8* %1716
%1718 = zext i8 %1717 to i32
%1719 = load i8*, i8** %48
%1720 = load i32, i32* %17
%1721 = add nsw i32 %1720, 1
%1722 = load i32, i32* %20
%1723 = mul nsw i32 %1721, %1722
%1724 = sext i32 %1723 to i64
%1725 = getelementptr inbounds i8, i8* %1719, i64 %1724
%1726 = load i8, i8* %1725
%1727 = zext i8 %1726 to i32
%1728 = load i8*, i8** %48
%1729 = load i32, i32* %17
%1730 = add nsw i32 %1729, 2
%1731 = load i32, i32* %20
%1732 = mul nsw i32 %1730, %1731
%1733 = sext i32 %1732 to i64
%1734 = getelementptr inbounds i8, i8* %1728, i64 %1733
%1735 = load i8, i8* %1734
%1736 = zext i8 %1735 to i32
%1737 = load i8*, i8** %48
%1738 = load i32, i32* %17
%1739 = add nsw i32 %1738, 3
%1740 = load i32, i32* %20
%1741 = mul nsw i32 %1739, %1740
%1742 = sext i32 %1741 to i64
%1743 = getelementptr inbounds i8, i8* %1737, i64 %1742
%1744 = load i8, i8* %1743
%1745 = zext i8 %1744 to i32
%1746 = load i32, i32* %30
%1747 = call i32 @icerp(i32 %1718, i32 %1727, i32 %1736, i32 %1745, i32 %1746)
store i32 %1747, i32* %34
%1748 = load i32, i32* %28
%1749 = icmp sgt i32 %1748, 0
br i1 %1749, label %1750, label %1777
1750: ; preds = %1709
%1751 = load i8*, i8** %48
%1752 = getelementptr inbounds i8, i8* %1751, i64 0
%1753 = load i8, i8* %1752
%1754 = zext i8 %1753 to i32
%1755 = load i8*, i8** %48
%1756 = load i32, i32* %20
%1757 = sext i32 %1756 to i64
%1758 = getelementptr inbounds i8, i8* %1755, i64 %1757
%1759 = load i8, i8* %1758
%1760 = zext i8 %1759 to i32
%1761 = load i8*, i8** %48
%1762 = load i32, i32* %20
%1763 = mul nsw i32 2, %1762
%1764 = sext i32 %1763 to i64
%1765 = getelementptr inbounds i8, i8* %1761, i64 %1764
%1766 = load i8, i8* %1765
%1767 = zext i8 %1766 to i32
%1768 = load i8*, i8** %48
%1769 = load i32, i32* %20
%1770 = mul nsw i32 3, %1769
%1771 = sext i32 %1770 to i64
%1772 = getelementptr inbounds i8, i8* %1768, i64 %1771
%1773 = load i8, i8* %1772
%1774 = zext i8 %1773 to i32
%1775 = load i32, i32* %30
%1776 = call i32 @icerp(i32 %1754, i32 %1760, i32 %1767, i32 %1774, i32 %1775)
store i32 %1776, i32* %33
br label %1779
1777: ; preds = %1709
%1778 = load i32, i32* %34
store i32 %1778, i32* %33
br label %1779
1779: ; preds = %1777, %1750
%1780 = load i8*, i8** %48
%1781 = load i32, i32* %17
%1782 = mul nsw i32 2, %1781
%1783 = add nsw i32 %1782, 0
%1784 = load i32, i32* %20
%1785 = mul nsw i32 %1783, %1784
%1786 = sext i32 %1785 to i64
%1787 = getelementptr inbounds i8, i8* %1780, i64 %1786
%1788 = load i8, i8* %1787
%1789 = zext i8 %1788 to i32
%1790 = load i8*, i8** %48
%1791 = load i32, i32* %17
%1792 = mul nsw i32 2, %1791
%1793 = add nsw i32 %1792, 1
%1794 = load i32, i32* %20
%1795 = mul nsw i32 %1793, %1794
%1796 = sext i32 %1795 to i64
%1797 = getelementptr inbounds i8, i8* %1790, i64 %1796
%1798 = load i8, i8* %1797
%1799 = zext i8 %1798 to i32
%1800 = load i8*, i8** %48
%1801 = load i32, i32* %17
%1802 = mul nsw i32 2, %1801
%1803 = add nsw i32 %1802, 2
%1804 = load i32, i32* %20
%1805 = mul nsw i32 %1803, %1804
%1806 = sext i32 %1805 to i64
%1807 = getelementptr inbounds i8, i8* %1800, i64 %1806
%1808 = load i8, i8* %1807
%1809 = zext i8 %1808 to i32
%1810 = load i8*, i8** %48
%1811 = load i32, i32* %17
%1812 = mul nsw i32 2, %1811
%1813 = add nsw i32 %1812, 3
%1814 = load i32, i32* %20
%1815 = mul nsw i32 %1813, %1814
%1816 = sext i32 %1815 to i64
%1817 = getelementptr inbounds i8, i8* %1810, i64 %1816
%1818 = load i8, i8* %1817
%1819 = zext i8 %1818 to i32
%1820 = load i32, i32* %30
%1821 = call i32 @icerp(i32 %1789, i32 %1799, i32 %1809, i32 %1819, i32 %1820)
store i32 %1821, i32* %35
%1822 = load i32, i32* %28
%1823 = load i32, i32* %14
%1824 = sub nsw i32 %1823, 1
%1825 = icmp slt i32 %1822, %1824
br i1 %1825, label %1826, label %1869
1826: ; preds = %1779
%1827 = load i8*, i8** %48
%1828 = load i32, i32* %17
%1829 = mul nsw i32 3, %1828
%1830 = add nsw i32 %1829, 0
%1831 = load i32, i32* %20
%1832 = mul nsw i32 %1830, %1831
%1833 = sext i32 %1832 to i64
%1834 = getelementptr inbounds i8, i8* %1827, i64 %1833
%1835 = load i8, i8* %1834
%1836 = zext i8 %1835 to i32
%1837 = load i8*, i8** %48
%1838 = load i32, i32* %17
%1839 = mul nsw i32 3, %1838
%1840 = add nsw i32 %1839, 1
%1841 = load i32, i32* %20
%1842 = mul nsw i32 %1840, %1841
%1843 = sext i32 %1842 to i64
%1844 = getelementptr inbounds i8, i8* %1837, i64 %1843
%1845 = load i8, i8* %1844
%1846 = zext i8 %1845 to i32
%1847 = load i8*, i8** %48
%1848 = load i32, i32* %17
%1849 = mul nsw i32 3, %1848
%1850 = add nsw i32 %1849, 2
%1851 = load i32, i32* %20
%1852 = mul nsw i32 %1850, %1851
%1853 = sext i32 %1852 to i64
%1854 = getelementptr inbounds i8, i8* %1847, i64 %1853
%1855 = load i8, i8* %1854
%1856 = zext i8 %1855 to i32
%1857 = load i8*, i8** %48
%1858 = load i32, i32* %17
%1859 = mul nsw i32 3, %1858
%1860 = add nsw i32 %1859, 3
%1861 = load i32, i32* %20
%1862 = mul nsw i32 %1860, %1861
%1863 = sext i32 %1862 to i64
%1864 = getelementptr inbounds i8, i8* %1857, i64 %1863
%1865 = load i8, i8* %1864
%1866 = zext i8 %1865 to i32
%1867 = load i32, i32* %30
%1868 = call i32 @icerp(i32 %1836, i32 %1846, i32 %1856, i32 %1866, i32 %1867)
store i32 %1868, i32* %36
br label %1871
1869: ; preds = %1779
%1870 = load i32, i32* %35
store i32 %1870, i32* %36
br label %1871
1871: ; preds = %1869, %1826
%1872 = load i32, i32* %33
%1873 = load i32, i32* %34
%1874 = load i32, i32* %35
%1875 = load i32, i32* %36
%1876 = load i32, i32* %31
%1877 = call i32 @icerp(i32 %1872, i32 %1873, i32 %1874, i32 %1875, i32 %1876)
store i32 %1877, i32* %41
br label %1880
1878: ; preds = %1698
%1879 = load i32, i32* %40
store i32 %1879, i32* %41
br label %1880
1880: ; preds = %1878, %1871
%1881 = load i32, i32* %38
%1882 = load i32, i32* %39
%1883 = load i32, i32* %40
%1884 = load i32, i32* %41
%1885 = load i32, i32* %32
%1886 = call i32 @icerp(i32 %1881, i32 %1882, i32 %1883, i32 %1884, i32 %1885)
store i32 %1886, i32* %37
%1887 = load i32, i32* %37
%1888 = icmp slt i32 %1887, 0
br i1 %1888, label %1889, label %1890
1889: ; preds = %1880
store i32 0, i32* %37
br label %1890
1890: ; preds = %1889, %1880
%1891 = load i32, i32* %37
%1892 = icmp sgt i32 %1891, 255
br i1 %1892, label %1893, label %1894
1893: ; preds = %1890
store i32 255, i32* %37
br label %1894
1894: ; preds = %1893, %1890
%1895 = load i32, i32* %37
%1896 = trunc i32 %1895 to i8
%1897 = load i8*, i8** %12
%1898 = load i32, i32* %26
%1899 = load i32, i32* %44
%1900 = mul nsw i32 %1898, %1899
%1901 = load i32, i32* %25
%1902 = load i32, i32* %42
%1903 = mul nsw i32 %1901, %1902
%1904 = add nsw i32 %1900, %1903
%1905 = load i32, i32* %24
%1906 = load i32, i32* %20
%1907 = mul nsw i32 %1905, %1906
%1908 = add nsw i32 %1904, %1907
%1909 = load i32, i32* %23
%1910 = add nsw i32 %1908, %1909
%1911 = sext i32 %1910 to i64
%1912 = getelementptr inbounds i8, i8* %1897, i64 %1911
store i8 %1896, i8* %1912
%1913 = load i8*, i8** %45
%1914 = getelementptr inbounds i8, i8* %1913, i32 1
store i8* %1914, i8** %45
%1915 = load i8*, i8** %46
%1916 = getelementptr inbounds i8, i8* %1915, i32 1
store i8* %1916, i8** %46
%1917 = load i8*, i8** %47
%1918 = getelementptr inbounds i8, i8* %1917, i32 1
store i8* %1918, i8** %47
%1919 = load i8*, i8** %48
%1920 = getelementptr inbounds i8, i8* %1919, i32 1
store i8* %1920, i8** %48
br label %1921
1921: ; preds = %1894
%1922 = load i32, i32* %23
%1923 = add nsw i32 %1922, 1
store i32 %1923, i32* %23
br label %1190
1924: ; preds = %1190
br label %1925
1925: ; preds = %1924
%1926 = load i32, i32* %24
%1927 = add nsw i32 %1926, 1
store i32 %1927, i32* %24
br label %1129
1928: ; preds = %1129
br label %1929
1929: ; preds = %1928
%1930 = load i32, i32* %25
%1931 = add nsw i32 %1930, 1
store i32 %1931, i32* %25
br label %1099
1932: ; preds = %1099
br label %1933
1933: ; preds = %1932
%1934 = load i32, i32* %26
%1935 = add nsw i32 %1934, 1
store i32 %1935, i32* %26
br label %1069
1936: ; preds = %1069
br label %1937
1937: ; preds = %1936, %1067
ret void
}

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