#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 */
float sqrt(float);
float average(unsigned int *psrc, unsigned char N, unsigned char *err) {
  unsigned int Mem_Comm[8];
  unsigned char n = N;
  unsigned char i = 0;
  unsigned int elem_max = 0;
  unsigned int elem_min = 0;
  unsigned char pos_max = 0;
  unsigned char pos_min = 0;
  float sum_avg = 0;
  float sum_sqr = 0;
  unsigned int *pdata_curr;
  unsigned int *pdata_next;
  float toler_std = 0;
  unsigned int *pdata = Mem_Comm;
  unsigned int *pdst = Mem_Comm;
  for (i = 0; i < n; i++) {
    *pdata = *psrc;
    pdata++;
    psrc++;
  }
  while (1) {
    if (n == 0) {
      *err = 0xff;
      sum_avg = 0;
      break;
    } else {
      pdata = pdst;
      sum_avg = 0;
      for (i = 0; i < n; i++) {
        sum_avg += (float)((float)(*pdata) / (float)n);
        pdata++;
      }
      pdata = pdst;
      sum_sqr = 0;
      for (i = 0; i < n; i++) {
        sum_sqr +=
            ((float)(*pdata) - (sum_avg)) * ((float)(*pdata) - (sum_avg));
        pdata++;
      }
      toler_std = sqrt(sum_sqr / (n - 1));
      if (((float)toler_std / (float)sum_avg) <= 0.1) {
        *err = 0;
        break;
      }
      pdata = pdst;
      elem_max = pdata[0];
      elem_min = pdata[0];
      for (i = 0; i < n; i++) {
        if (elem_max <= pdata[i]) {
          elem_max = pdata[i];
          pos_max = i;
        } else if (elem_min >= pdata[i]) {
          elem_min = pdata[i];
          pos_min = i;
        }
        pdata++;
      }
      pdata = pdst;
      pdata_curr = &pdata[pos_max];
      pdata_next = &pdata[pos_max + 1];
      for (i = 0; i < n - pos_max - 1; i++) {
        *pdata_curr = *pdata_next;
        pdata_curr++;
        pdata_next++;
      }
      n--;
      pdata_curr = &pdata[pos_min];
      pdata_next = &pdata[pos_min + 1];
      for (i = 0; i < n - pos_min - 1; i++) {
        *pdata_curr = *pdata_next;
        pdata_curr++;
        pdata_next++;
      }
      n--;
      if ((float)((float)(N - n) / (float)N) > 0.5) {
        *err = 0xff;
        sum_avg = 0;
        break;
      }
    }
  }
  return (float)(sum_avg);
}


x86 assembly (clang, -O0):
<average>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %sil,%al
mov    %rdi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0x41(%rbp)
movb   $0x0,-0x42(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movb   $0x0,-0x4d(%rbp)
movb   $0x0,-0x4e(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
lea    -0x40(%rbp),%rax
mov    %rax,-0x78(%rbp)
lea    -0x40(%rbp),%rax
mov    %rax,-0x80(%rbp)
movb   $0x0,-0x42(%rbp)
movzbl -0x42(%rbp),%eax
movzbl -0x41(%rbp),%ecx
cmp    %ecx,%eax
jge    11b6 <average+0xa6>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x42(%rbp),%al
add    $0x1,%al
mov    %al,-0x42(%rbp)
jmp    1175 <average+0x65>
jmp    11bb <average+0xab>
movzbl -0x41(%rbp),%eax
cmp    $0x0,%eax
jne    11dc <average+0xcc>
mov    -0x18(%rbp),%rax
movb   $0xff,(%rax)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    14e8 <average+0x3d8>
mov    -0x80(%rbp),%rax
mov    %rax,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movb   $0x0,-0x42(%rbp)
movzbl -0x42(%rbp),%eax
movzbl -0x41(%rbp),%ecx
cmp    %ecx,%eax
jge    123a <average+0x12a>
mov    -0x78(%rbp),%rax
mov    (%rax),%eax
cvtsi2ss %rax,%xmm0
movzbl -0x41(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0x42(%rbp),%al
add    $0x1,%al
mov    %al,-0x42(%rbp)
jmp    11f0 <average+0xe0>
mov    -0x80(%rbp),%rax
mov    %rax,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movb   $0x0,-0x42(%rbp)
movzbl -0x42(%rbp),%eax
movzbl -0x41(%rbp),%ecx
cmp    %ecx,%eax
jge    12a5 <average+0x195>
mov    -0x78(%rbp),%rax
mov    (%rax),%eax
cvtsi2ss %rax,%xmm2
movss  -0x54(%rbp),%xmm1
movaps %xmm2,%xmm0
subss  %xmm1,%xmm0
subss  -0x54(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0x42(%rbp),%al
add    $0x1,%al
mov    %al,-0x42(%rbp)
jmp    124e <average+0x13e>
movss  -0x58(%rbp),%xmm0
movzbl -0x41(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd27(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     12ef <average+0x1df>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
jmp    14e8 <average+0x3d8>
mov    -0x80(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x48(%rbp)
mov    -0x78(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
movb   $0x0,-0x42(%rbp)
movzbl -0x42(%rbp),%eax
movzbl -0x41(%rbp),%ecx
cmp    %ecx,%eax
jge    1390 <average+0x280>
mov    -0x48(%rbp),%eax
mov    -0x78(%rbp),%rcx
movzbl -0x42(%rbp),%edx
cmp    (%rcx,%rdx,4),%eax
ja     134a <average+0x23a>
mov    -0x78(%rbp),%rax
movzbl -0x42(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x42(%rbp),%al
mov    %al,-0x4d(%rbp)
jmp    1377 <average+0x267>
mov    -0x4c(%rbp),%eax
mov    -0x78(%rbp),%rcx
movzbl -0x42(%rbp),%edx
cmp    (%rcx,%rdx,4),%eax
jb     1372 <average+0x262>
mov    -0x78(%rbp),%rax
movzbl -0x42(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x42(%rbp),%al
mov    %al,-0x4e(%rbp)
jmp    1377 <average+0x267>
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0x42(%rbp),%al
add    $0x1,%al
mov    %al,-0x42(%rbp)
jmp    130d <average+0x1fd>
mov    -0x80(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movzbl -0x4d(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x78(%rbp),%rax
movzbl -0x4d(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
movb   $0x0,-0x42(%rbp)
movzbl -0x42(%rbp),%eax
movzbl -0x41(%rbp),%ecx
movzbl -0x4d(%rbp),%edx
sub    %edx,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1412 <average+0x302>
mov    -0x68(%rbp),%rax
mov    (%rax),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x60(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x42(%rbp),%al
add    $0x1,%al
mov    %al,-0x42(%rbp)
jmp    13c8 <average+0x2b8>
mov    -0x41(%rbp),%al
add    $0xff,%al
mov    %al,-0x41(%rbp)
mov    -0x78(%rbp),%rax
movzbl -0x4e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x78(%rbp),%rax
movzbl -0x4e(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
movb   $0x0,-0x42(%rbp)
movzbl -0x42(%rbp),%eax
movzbl -0x41(%rbp),%ecx
movzbl -0x4e(%rbp),%edx
sub    %edx,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1494 <average+0x384>
mov    -0x68(%rbp),%rax
mov    (%rax),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x60(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x42(%rbp),%al
add    $0x1,%al
mov    %al,-0x42(%rbp)
jmp    144a <average+0x33a>
mov    -0x41(%rbp),%al
add    $0xff,%al
mov    %al,-0x41(%rbp)
movzbl -0x9(%rbp),%eax
movzbl -0x41(%rbp),%edx
mov    %eax,%ecx
sub    %edx,%ecx
cvtsi2ss %ecx,%xmm0
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb48(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    14de <average+0x3ce>
mov    -0x18(%rbp),%rax
movb   $0xff,(%rax)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    14e8 <average+0x3d8>
jmp    14e3 <average+0x3d3>
jmp    11bb <average+0xab>
movss  -0x54(%rbp),%xmm0
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<average>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdx,0x48(%rsp)
mov    %esi,%ebp
movzbl %bpl,%ebx
test   %esi,%esi
je     1152 <average+0x32>
mov    %rdi,%rsi
lea    0x0(,%rbx,4),%rdx
lea    0x20(%rsp),%rdi
call   1030 <memcpy@plt>
cvtsi2ss %ebx,%xmm4
lea    -0x1(%rbx),%r10d
xor    %eax,%eax
mov    %rbx,%rcx
lea    0x20(%rsp),%rbx
xorps  %xmm5,%xmm5
movsd  0xe91(%rip),%xmm6
movss  0xe91(%rip),%xmm7
mov    %r10d,%r8d
xor    %r13d,%r13d
xor    %r12d,%r12d
mov    %rcx,%r15
mov    %rcx,0x10(%rsp)
mov    %r10d,0xc(%rsp)
movss  %xmm4,0x18(%rsp)
jmp    11d3 <average+0xb3>
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x2(%r15),%ebp
movzbl %bpl,%eax
mov    %rbx,%r15
mov    %ebx,%ecx
sub    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
divss  %xmm4,%xmm0
mov    0x50(%rsp),%rax
add    $0x1,%al
add    $0xfffffffe,%r8d
ucomiss %xmm7,%xmm0
lea    0x20(%rsp),%rbx
ja     176c <average+0x64c>
mov    $0xff,%cl
test   %bpl,%bpl
je     1773 <average+0x653>
movzbl %bpl,%r9d
xorps  %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
mov    %rax,0x50(%rsp)
add    %eax,%eax
xorps  %xmm3,%xmm3
mov    %rbx,%rcx
cmp    %al,%r10b
je     123e <average+0x11e>
mov    %ebp,%edx
and    $0xfe,%dl
xorps  %xmm3,%xmm3
mov    %rbx,%rcx
nopw   0x0(%rax,%rax,1)
mov    (%rcx),%esi
mov    0x4(%rcx),%edi
xorps  %xmm1,%xmm1
cvtsi2ss %rsi,%xmm1
divss  %xmm0,%xmm1
addss  %xmm3,%xmm1
xorps  %xmm3,%xmm3
cvtsi2ss %rdi,%xmm3
divss  %xmm0,%xmm3
addss  %xmm1,%xmm3
add    $0x8,%rcx
add    $0xfe,%dl
jne    1210 <average+0xf0>
mov    %r10d,%r14d
sub    %al,%r14b
test   $0x1,%r9b
je     125c <average+0x13c>
mov    (%rcx),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
divss  %xmm0,%xmm1
addss  %xmm1,%xmm3
xorps  %xmm0,%xmm0
mov    %rbx,%rax
cmp    $0x3,%r14b
jb     12e5 <average+0x1c5>
and    $0xfc,%bpl
xorps  %xmm0,%xmm0
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rax),%ecx
mov    0x4(%rax),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %rcx,%xmm1
subss  %xmm3,%xmm1
mulss  %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %rdx,%xmm2
addss  %xmm0,%xmm1
subss  %xmm3,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
mov    0x8(%rax),%ecx
xorps  %xmm1,%xmm1
cvtsi2ss %rcx,%xmm1
subss  %xmm3,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
mov    0xc(%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %rcx,%xmm0
subss  %xmm3,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x10,%rax
add    $0xfc,%bpl
jne    1280 <average+0x160>
test   $0x3,%r9b
je     131f <average+0x1ff>
mov    %r9d,%ecx
and    $0x3,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax,%rdx,4),%esi
xorps  %xmm1,%xmm1
cvtsi2ss %rsi,%xmm1
subss  %xmm3,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %dl,%cl
jne    1300 <average+0x1e0>
lea    -0x1(%r9),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
ucomiss %xmm5,%xmm0
jb     1340 <average+0x220>
sqrtss %xmm0,%xmm0
jmp    137b <average+0x25b>
nopl   0x0(%rax)
mov    %r9,%rbx
mov    %r8d,%ebp
movss  %xmm3,0x1c(%rsp)
call   1040 <sqrt@plt>
movss  0x1c(%rsp),%xmm3
mov    %ebp,%r8d
mov    %rbx,%r9
movss  0xca3(%rip),%xmm7
movsd  0xc93(%rip),%xmm6
xorps  %xmm5,%xmm5
mov    0xc(%rsp),%r10d
movss  0x18(%rsp),%xmm4
mov    %r15,%rbx
divss  %xmm3,%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm0,%xmm6
jae    1778 <average+0x658>
movzbl %r8b,%r8d
lea    -0x1(%r9),%rax
movzbl %r14b,%r11d
mov    0x20(%rsp),%edi
xor    %edx,%edx
mov    %edi,%esi
mov    %edi,%ecx
cmp    %edi,%ecx
ja     13c0 <average+0x2a0>
nopw   0x0(%rax,%rax,1)
mov    %edi,%ecx
mov    %edx,%r13d
cmp    %rdx,%rax
jne    13d2 <average+0x2b2>
jmp    13e0 <average+0x2c0>
nopl   0x0(%rax)
cmp    %edi,%esi
cmovae %edi,%esi
movzbl %r12b,%r12d
cmovae %edx,%r12d
cmp    %rdx,%rax
je     13e0 <average+0x2c0>
mov    0x28(%rsp,%rdx,8),%edi
add    $0x1,%rdx
cmp    %edi,%ecx
jbe    13b0 <average+0x290>
jmp    13c0 <average+0x2a0>
movzbl %r13b,%ecx
mov    %ecx,%edx
not    %edx
add    %r9d,%edx
jle    1445 <average+0x325>
mov    %ecx,%eax
lea    (%rsp,%rax,4),%rsi
add    $0x24,%rsi
lea    (%rsp,%rcx,4),%rdi
add    $0x20,%rdi
mov    %r9d,%ebx
sub    %ecx,%ebx
add    $0xfffffffe,%ebx
xor    %r14d,%r14d
cmp    $0x7,%ebx
jae    14b0 <average+0x390>
mov    0x10(%rsp),%rbx
movzbl %r14b,%eax
add    $0x1,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rcx,4),%ebp
mov    %ebp,(%rdi,%rcx,4)
lea    (%rax,%rcx,1),%ebp
movzbl %bpl,%ebp
add    $0x1,%rcx
cmp    %ebp,%edx
jg     1430 <average+0x310>
mov    %r9,%r15
lea    -0x1(%r9),%eax
movzbl %r12b,%ebp
movzbl %al,%edx
mov    %ebp,%eax
not    %eax
add    %eax,%edx
jle    11a0 <average+0x80>
mov    %ebp,%r14d
lea    (%rsp,%r14,4),%rsi
add    $0x24,%rsi
lea    (%rsp,%rbp,4),%rdi
add    $0x20,%rdi
sub    %ebp,%r11d
add    $0xfffffffe,%r11d
xor    %r9d,%r9d
cmp    $0x7,%r11d
jae    1500 <average+0x3e0>
movzbl %r9b,%eax
add    $0x1,%rax
xor    %ecx,%ecx
mov    (%rsi,%rcx,4),%ebp
mov    %ebp,(%rdi,%rcx,4)
lea    (%rax,%rcx,1),%ebp
movzbl %bpl,%ebp
add    $0x1,%rcx
cmp    %ebp,%edx
jg     1490 <average+0x370>
jmp    11a0 <average+0x80>
nopw   0x0(%rax,%rax,1)
cmp    $0xff,%bl
je     1413 <average+0x2f3>
cmp    $0xff,%ebx
ja     1413 <average+0x2f3>
mov    %r9,%r15
add    $0x1,%rax
lea    0x1(%rbx),%r9
mov    %r9,%r14
movabs $0x1fffffff8,%rcx
and    %rcx,%r14
lea    -0x8(%r14),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
cmp    $0x18,%rcx
jae    154f <average+0x42f>
xor    %ebp,%ebp
jmp    15d9 <average+0x4b9>
nopl   0x0(%rax)
cmp    $0xff,%r11b
je     1486 <average+0x366>
cmp    $0xff,%r11d
ja     1486 <average+0x366>
add    $0x1,%r14
add    $0x1,%r11
mov    %r11,%r9
movabs $0x1fffffff8,%rcx
and    %rcx,%r9
lea    -0x8(%r9),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
cmp    $0x18,%rcx
jae    165f <average+0x53f>
xor    %ebp,%ebp
jmp    16f9 <average+0x5d9>
lea    0x94(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
add    $0xfffffffffffffffc,%rcx
add    $0x1,%rbx
and    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffff8,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffc,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x70(%rcx,%rbp,4),%xmm0
movups -0x60(%rcx,%rbp,4),%xmm1
movups -0x50(%rcx,%rbp,4),%xmm2
movups -0x40(%rcx,%rbp,4),%xmm3
movups %xmm0,-0x74(%rcx,%rbp,4)
movups %xmm1,-0x64(%rcx,%rbp,4)
movups %xmm2,-0x54(%rcx,%rbp,4)
movups %xmm3,-0x44(%rcx,%rbp,4)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,-0x34(%rcx,%rbp,4)
movups %xmm1,-0x24(%rcx,%rbp,4)
movups -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movups %xmm0,-0x14(%rcx,%rbp,4)
movups %xmm1,-0x4(%rcx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rbx
jne    1580 <average+0x460>
test   $0x3,%r10b
je     163c <average+0x51c>
lea    0x94(%rsp),%rcx
lea    (%rcx,%rbp,4),%rcx
add    $0xffffffffffffffa0,%rcx
lea    (%rcx,%rax,4),%rax
add    $0xfffffffffffffffc,%rax
mov    %edx,%ecx
and    $0x18,%cl
add    $0xf8,%cl
shr    $0x3,%cl
add    $0x1,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
shl    $0x5,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x10(%rax,%rbp,1),%xmm0
movups (%rax,%rbp,1),%xmm1
movups %xmm0,-0x14(%rax,%rbp,1)
movups %xmm1,-0x4(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1620 <average+0x500>
cmp    %r14,%r9
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%r10d
mov    %r15,%r9
je     1445 <average+0x325>
lea    (%rsi,%r14,4),%rsi
lea    (%rdi,%r14,4),%rdi
jmp    1418 <average+0x2f8>
lea    0x94(%rsp),%rcx
lea    (%rcx,%r14,4),%rbx
add    $0xfffffffffffffffc,%rbx
mov    %r8d,%ecx
sub    %ebp,%ecx
add    $0xfffffffe,%ecx
add    $0x1,%rcx
and    $0xfffffffffffffff8,%rcx
add    $0xfffffffffffffff8,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffc,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x70(%rbx,%rbp,4),%xmm0
movups -0x60(%rbx,%rbp,4),%xmm1
movups -0x50(%rbx,%rbp,4),%xmm2
movups -0x40(%rbx,%rbp,4),%xmm3
movups %xmm0,-0x74(%rbx,%rbp,4)
movups %xmm1,-0x64(%rbx,%rbp,4)
movups %xmm2,-0x54(%rbx,%rbp,4)
movups %xmm3,-0x44(%rbx,%rbp,4)
movups -0x30(%rbx,%rbp,4),%xmm0
movups -0x20(%rbx,%rbp,4),%xmm1
movups %xmm0,-0x34(%rbx,%rbp,4)
movups %xmm1,-0x24(%rbx,%rbp,4)
movups -0x10(%rbx,%rbp,4),%xmm0
movups (%rbx,%rbp,4),%xmm1
movups %xmm0,-0x14(%rbx,%rbp,4)
movups %xmm1,-0x4(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rcx
jne    16a0 <average+0x580>
test   $0x3,%r10b
je     174c <average+0x62c>
lea    0x94(%rsp),%rcx
lea    (%rcx,%rbp,4),%rcx
add    $0xffffffffffffffa0,%rcx
lea    (%rcx,%r14,4),%rcx
add    $0xfffffffffffffffc,%rcx
add    %r8d,%eax
and    $0x18,%al
add    $0xf8,%al
shr    $0x3,%al
add    $0x1,%al
movzbl %al,%eax
and    $0x3,%eax
shl    $0x5,%rax
xor    %ebp,%ebp
nop
movups -0x10(%rcx,%rbp,1),%xmm0
movups (%rcx,%rbp,1),%xmm1
movups %xmm0,-0x14(%rcx,%rbp,1)
movups %xmm1,-0x4(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rax
jne    1730 <average+0x610>
cmp    %r9,%r11
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%r10d
je     11a0 <average+0x80>
lea    (%rsi,%r9,4),%rsi
lea    (%rdi,%r9,4),%rdi
jmp    1486 <average+0x366>
xorps  %xmm3,%xmm3
mov    $0xff,%cl
jmp    177a <average+0x65a>
xorps  %xmm3,%xmm3
jmp    177a <average+0x65a>
xor    %ecx,%ecx
mov    0x48(%rsp),%rax
mov    %cl,(%rax)
movaps %xmm3,%xmm0
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define float @average(i32* %0, i8 zeroext %1, i8* %2) {
%4 = alloca i32*
%5 = alloca i8
%6 = alloca i8*
%7 = alloca [8 x i32]
%8 = alloca i8
%9 = alloca i8
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8
%13 = alloca i8
%14 = alloca float
%15 = alloca float
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca float
%19 = alloca i32*
%20 = alloca i32*
store i32* %0, i32** %4
store i8 %1, i8* %5
store i8* %2, i8** %6
%21 = load i8, i8* %5
store i8 %21, i8* %8
store i8 0, i8* %9
store i32 0, i32* %10
store i32 0, i32* %11
store i8 0, i8* %12
store i8 0, i8* %13
store float 0.000000e+00, float* %14
store float 0.000000e+00, float* %15
store float 0.000000e+00, float* %18
%22 = getelementptr inbounds [8 x i32], [8 x i32]* %7, i64 0, i64 0
store i32* %22, i32** %19
%23 = getelementptr inbounds [8 x i32], [8 x i32]* %7, i64 0, i64 0
store i32* %23, i32** %20
store i8 0, i8* %9
br label %24
24: ; preds = %38, %3
%25 = load i8, i8* %9
%26 = zext i8 %25 to i32
%27 = load i8, i8* %8
%28 = zext i8 %27 to i32
%29 = icmp slt i32 %26, %28
br i1 %29, label %30, label %41
30: ; preds = %24
%31 = load i32*, i32** %4
%32 = load i32, i32* %31
%33 = load i32*, i32** %19
store i32 %32, i32* %33
%34 = load i32*, i32** %19
%35 = getelementptr inbounds i32, i32* %34, i32 1
store i32* %35, i32** %19
%36 = load i32*, i32** %4
%37 = getelementptr inbounds i32, i32* %36, i32 1
store i32* %37, i32** %4
br label %38
38: ; preds = %30
%39 = load i8, i8* %9
%40 = add i8 %39, 1
store i8 %40, i8* %9
br label %24
41: ; preds = %24
br label %42
42: ; preds = %41, %246
%43 = load i8, i8* %8
%44 = zext i8 %43 to i32
%45 = icmp eq i32 %44, 0
br i1 %45, label %46, label %48
46: ; preds = %42
%47 = load i8*, i8** %6
store i8 -1, i8* %47
store float 0.000000e+00, float* %14
br label %247
48: ; preds = %42
%49 = load i32*, i32** %20
store i32* %49, i32** %19
store float 0.000000e+00, float* %14
store i8 0, i8* %9
br label %50
50: ; preds = %67, %48
%51 = load i8, i8* %9
%52 = zext i8 %51 to i32
%53 = load i8, i8* %8
%54 = zext i8 %53 to i32
%55 = icmp slt i32 %52, %54
br i1 %55, label %56, label %70
56: ; preds = %50
%57 = load i32*, i32** %19
%58 = load i32, i32* %57
%59 = uitofp i32 %58 to float
%60 = load i8, i8* %8
%61 = uitofp i8 %60 to float
%62 = fdiv float %59, %61
%63 = load float, float* %14
%64 = fadd float %63, %62
store float %64, float* %14
%65 = load i32*, i32** %19
%66 = getelementptr inbounds i32, i32* %65, i32 1
store i32* %66, i32** %19
br label %67
67: ; preds = %56
%68 = load i8, i8* %9
%69 = add i8 %68, 1
store i8 %69, i8* %9
br label %50
70: ; preds = %50
%71 = load i32*, i32** %20
store i32* %71, i32** %19
store float 0.000000e+00, float* %15
store i8 0, i8* %9
br label %72
72: ; preds = %93, %70
%73 = load i8, i8* %9
%74 = zext i8 %73 to i32
%75 = load i8, i8* %8
%76 = zext i8 %75 to i32
%77 = icmp slt i32 %74, %76
br i1 %77, label %78, label %96
78: ; preds = %72
%79 = load i32*, i32** %19
%80 = load i32, i32* %79
%81 = uitofp i32 %80 to float
%82 = load float, float* %14
%83 = fsub float %81, %82
%84 = load i32*, i32** %19
%85 = load i32, i32* %84
%86 = uitofp i32 %85 to float
%87 = load float, float* %14
%88 = fsub float %86, %87
%89 = load float, float* %15
%90 = call float @llvm.fmuladd.f32(float %83, float %88, float %89)
store float %90, float* %15
%91 = load i32*, i32** %19
%92 = getelementptr inbounds i32, i32* %91, i32 1
store i32* %92, i32** %19
br label %93
93: ; preds = %78
%94 = load i8, i8* %9
%95 = add i8 %94, 1
store i8 %95, i8* %9
br label %72
96: ; preds = %72
%97 = load float, float* %15
%98 = load i8, i8* %8
%99 = zext i8 %98 to i32
%100 = sub nsw i32 %99, 1
%101 = sitofp i32 %100 to float
%102 = fdiv float %97, %101
%103 = call float @sqrt(float %102)
store float %103, float* %18
%104 = load float, float* %18
%105 = load float, float* %14
%106 = fdiv float %104, %105
%107 = fpext float %106 to double
%108 = fcmp ole double %107, 1.000000e-01
br i1 %108, label %109, label %111
109: ; preds = %96
%110 = load i8*, i8** %6
store i8 0, i8* %110
br label %247
111: ; preds = %96
%112 = load i32*, i32** %20
store i32* %112, i32** %19
%113 = load i32*, i32** %19
%114 = getelementptr inbounds i32, i32* %113, i64 0
%115 = load i32, i32* %114
store i32 %115, i32* %10
%116 = load i32*, i32** %19
%117 = getelementptr inbounds i32, i32* %116, i64 0
%118 = load i32, i32* %117
store i32 %118, i32* %11
store i8 0, i8* %9
br label %119
119: ; preds = %159, %111
%120 = load i8, i8* %9
%121 = zext i8 %120 to i32
%122 = load i8, i8* %8
%123 = zext i8 %122 to i32
%124 = icmp slt i32 %121, %123
br i1 %124, label %125, label %162
125: ; preds = %119
%126 = load i32, i32* %10
%127 = load i32*, i32** %19
%128 = load i8, i8* %9
%129 = zext i8 %128 to i64
%130 = getelementptr inbounds i32, i32* %127, i64 %129
%131 = load i32, i32* %130
%132 = icmp ule i32 %126, %131
br i1 %132, label %133, label %140
133: ; preds = %125
%134 = load i32*, i32** %19
%135 = load i8, i8* %9
%136 = zext i8 %135 to i64
%137 = getelementptr inbounds i32, i32* %134, i64 %136
%138 = load i32, i32* %137
store i32 %138, i32* %10
%139 = load i8, i8* %9
store i8 %139, i8* %12
br label %156
140: ; preds = %125
%141 = load i32, i32* %11
%142 = load i32*, i32** %19
%143 = load i8, i8* %9
%144 = zext i8 %143 to i64
%145 = getelementptr inbounds i32, i32* %142, i64 %144
%146 = load i32, i32* %145
%147 = icmp uge i32 %141, %146
br i1 %147, label %148, label %155
148: ; preds = %140
%149 = load i32*, i32** %19
%150 = load i8, i8* %9
%151 = zext i8 %150 to i64
%152 = getelementptr inbounds i32, i32* %149, i64 %151
%153 = load i32, i32* %152
store i32 %153, i32* %11
%154 = load i8, i8* %9
store i8 %154, i8* %13
br label %155
155: ; preds = %148, %140
br label %156
156: ; preds = %155, %133
%157 = load i32*, i32** %19
%158 = getelementptr inbounds i32, i32* %157, i32 1
store i32* %158, i32** %19
br label %159
159: ; preds = %156
%160 = load i8, i8* %9
%161 = add i8 %160, 1
store i8 %161, i8* %9
br label %119
162: ; preds = %119
%163 = load i32*, i32** %20
store i32* %163, i32** %19
%164 = load i32*, i32** %19
%165 = load i8, i8* %12
%166 = zext i8 %165 to i64
%167 = getelementptr inbounds i32, i32* %164, i64 %166
store i32* %167, i32** %16
%168 = load i32*, i32** %19
%169 = load i8, i8* %12
%170 = zext i8 %169 to i32
%171 = add nsw i32 %170, 1
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %168, i64 %172
store i32* %173, i32** %17
store i8 0, i8* %9
br label %174
174: ; preds = %192, %162
%175 = load i8, i8* %9
%176 = zext i8 %175 to i32
%177 = load i8, i8* %8
%178 = zext i8 %177 to i32
%179 = load i8, i8* %12
%180 = zext i8 %179 to i32
%181 = sub nsw i32 %178, %180
%182 = sub nsw i32 %181, 1
%183 = icmp slt i32 %176, %182
br i1 %183, label %184, label %195
184: ; preds = %174
%185 = load i32*, i32** %17
%186 = load i32, i32* %185
%187 = load i32*, i32** %16
store i32 %186, i32* %187
%188 = load i32*, i32** %16
%189 = getelementptr inbounds i32, i32* %188, i32 1
store i32* %189, i32** %16
%190 = load i32*, i32** %17
%191 = getelementptr inbounds i32, i32* %190, i32 1
store i32* %191, i32** %17
br label %192
192: ; preds = %184
%193 = load i8, i8* %9
%194 = add i8 %193, 1
store i8 %194, i8* %9
br label %174
195: ; preds = %174
%196 = load i8, i8* %8
%197 = add i8 %196, -1
store i8 %197, i8* %8
%198 = load i32*, i32** %19
%199 = load i8, i8* %13
%200 = zext i8 %199 to i64
%201 = getelementptr inbounds i32, i32* %198, i64 %200
store i32* %201, i32** %16
%202 = load i32*, i32** %19
%203 = load i8, i8* %13
%204 = zext i8 %203 to i32
%205 = add nsw i32 %204, 1
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %202, i64 %206
store i32* %207, i32** %17
store i8 0, i8* %9
br label %208
208: ; preds = %226, %195
%209 = load i8, i8* %9
%210 = zext i8 %209 to i32
%211 = load i8, i8* %8
%212 = zext i8 %211 to i32
%213 = load i8, i8* %13
%214 = zext i8 %213 to i32
%215 = sub nsw i32 %212, %214
%216 = sub nsw i32 %215, 1
%217 = icmp slt i32 %210, %216
br i1 %217, label %218, label %229
218: ; preds = %208
%219 = load i32*, i32** %17
%220 = load i32, i32* %219
%221 = load i32*, i32** %16
store i32 %220, i32* %221
%222 = load i32*, i32** %16
%223 = getelementptr inbounds i32, i32* %222, i32 1
store i32* %223, i32** %16
%224 = load i32*, i32** %17
%225 = getelementptr inbounds i32, i32* %224, i32 1
store i32* %225, i32** %17
br label %226
226: ; preds = %218
%227 = load i8, i8* %9
%228 = add i8 %227, 1
store i8 %228, i8* %9
br label %208
229: ; preds = %208
%230 = load i8, i8* %8
%231 = add i8 %230, -1
store i8 %231, i8* %8
%232 = load i8, i8* %5
%233 = zext i8 %232 to i32
%234 = load i8, i8* %8
%235 = zext i8 %234 to i32
%236 = sub nsw i32 %233, %235
%237 = sitofp i32 %236 to float
%238 = load i8, i8* %5
%239 = uitofp i8 %238 to float
%240 = fdiv float %237, %239
%241 = fpext float %240 to double
%242 = fcmp ogt double %241, 5.000000e-01
br i1 %242, label %243, label %245
243: ; preds = %229
%244 = load i8*, i8** %6
store i8 -1, i8* %244
store float 0.000000e+00, float* %14
br label %247
245: ; preds = %229
br label %246
246: ; preds = %245
br label %42
247: ; preds = %243, %109, %46
%248 = load float, float* %14
ret float %248
}

LLVM IR (-O2):
define float @average(i32* nocapture %0, i8 zeroext %1, i8* nocapture writeonly %2) {
%4 = alloca [8 x i32]
%5 = bitcast [8 x i32]* %4 to i8*
%6 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 0
%7 = icmp eq i8 %1, 0
br i1 %7, label %12, label %8
8: ; preds = %3
%9 = bitcast i32* %0 to i8*
%10 = zext i8 %1 to i64
%11 = shl nuw nsw i64 %10, 2
br label %12
12: ; preds = %8, %3
%13 = zext i8 %1 to i32
%14 = uitofp i8 %1 to float
%15 = add i8 %1, -1
br label %16
16: ; preds = %12, %391
%17 = phi i8 [ 0, %12 ], [ %398, %391 ]
%18 = phi i8 [ %1, %12 ], [ %392, %391 ]
%19 = phi i8 [ 0, %12 ], [ %143, %391 ]
%20 = phi i8 [ 0, %12 ], [ %144, %391 ]
%21 = mul i8 %17, -2
%22 = add i8 %15, %21
%23 = zext i8 %18 to i32
%24 = zext i8 %18 to i32
%25 = mul i8 %17, -2
%26 = add i8 %15, %25
%27 = zext i8 %26 to i32
%28 = mul i8 %17, -2
%29 = add i8 %15, %28
%30 = zext i8 %29 to i32
%31 = zext i8 %18 to i32
%32 = icmp eq i8 %18, 0
br i1 %32, label %399, label %33
33: ; preds = %16
%34 = shl i8 %17, 1
%35 = uitofp i8 %18 to float
%36 = and i8 %18, 1
%37 = icmp eq i8 %15, %34
br i1 %37, label %56, label %38
38: ; preds = %33
%39 = and i8 %18, -2
br label %40
40: ; preds = %40, %38
%41 = phi i32* [ %6, %38 ], [ %53, %40 ]
%42 = phi float [ 0.000000e+00, %38 ], [ %52, %40 ]
%43 = phi i8 [ 0, %38 ], [ %54, %40 ]
%44 = load i32, i32* %41
%45 = uitofp i32 %44 to float
%46 = fdiv float %45, %35
%47 = fadd float %42, %46
%48 = getelementptr inbounds i32, i32* %41, i64 1
%49 = load i32, i32* %48
%50 = uitofp i32 %49 to float
%51 = fdiv float %50, %35
%52 = fadd float %47, %51
%53 = getelementptr inbounds i32, i32* %41, i64 2
%54 = add i8 %43, 2
%55 = icmp eq i8 %54, %39
br i1 %55, label %56, label %40
56: ; preds = %40, %33
%57 = phi float [ undef, %33 ], [ %52, %40 ]
%58 = phi i32* [ %6, %33 ], [ %53, %40 ]
%59 = phi float [ 0.000000e+00, %33 ], [ %52, %40 ]
%60 = icmp eq i8 %36, 0
br i1 %60, label %66, label %61
61: ; preds = %56
%62 = load i32, i32* %58
%63 = uitofp i32 %62 to float
%64 = fdiv float %63, %35
%65 = fadd float %59, %64
br label %66
66: ; preds = %56, %61
%67 = phi float [ %57, %56 ], [ %65, %61 ]
%68 = and i8 %18, 3
%69 = icmp ult i8 %22, 3
br i1 %69, label %98, label %70
70: ; preds = %66
%71 = and i8 %18, -4
br label %72
72: ; preds = %72, %70
%73 = phi i32* [ %6, %70 ], [ %95, %72 ]
%74 = phi float [ 0.000000e+00, %70 ], [ %94, %72 ]
%75 = phi i8 [ 0, %70 ], [ %96, %72 ]
%76 = load i32, i32* %73
%77 = uitofp i32 %76 to float
%78 = fsub float %77, %67
%79 = tail call float @llvm.fmuladd.f32(float %78, float %78, float %74)
%80 = getelementptr inbounds i32, i32* %73, i64 1
%81 = load i32, i32* %80
%82 = uitofp i32 %81 to float
%83 = fsub float %82, %67
%84 = tail call float @llvm.fmuladd.f32(float %83, float %83, float %79)
%85 = getelementptr inbounds i32, i32* %73, i64 2
%86 = load i32, i32* %85
%87 = uitofp i32 %86 to float
%88 = fsub float %87, %67
%89 = tail call float @llvm.fmuladd.f32(float %88, float %88, float %84)
%90 = getelementptr inbounds i32, i32* %73, i64 3
%91 = load i32, i32* %90
%92 = uitofp i32 %91 to float
%93 = fsub float %92, %67
%94 = tail call float @llvm.fmuladd.f32(float %93, float %93, float %89)
%95 = getelementptr inbounds i32, i32* %73, i64 4
%96 = add i8 %75, 4
%97 = icmp eq i8 %96, %71
br i1 %97, label %98, label %72
98: ; preds = %72, %66
%99 = phi float [ undef, %66 ], [ %94, %72 ]
%100 = phi i32* [ %6, %66 ], [ %95, %72 ]
%101 = phi float [ 0.000000e+00, %66 ], [ %94, %72 ]
%102 = icmp eq i8 %68, 0
br i1 %102, label %114, label %103
103: ; preds = %98, %103
%104 = phi i32* [ %111, %103 ], [ %100, %98 ]
%105 = phi float [ %110, %103 ], [ %101, %98 ]
%106 = phi i8 [ %112, %103 ], [ 0, %98 ]
%107 = load i32, i32* %104
%108 = uitofp i32 %107 to float
%109 = fsub float %108, %67
%110 = tail call float @llvm.fmuladd.f32(float %109, float %109, float %105)
%111 = getelementptr inbounds i32, i32* %104, i64 1
%112 = add i8 %106, 1
%113 = icmp eq i8 %112, %68
br i1 %113, label %114, label %103
114: ; preds = %103, %98
%115 = phi float [ %99, %98 ], [ %110, %103 ]
%116 = add nsw i32 %31, -1
%117 = sitofp i32 %116 to float
%118 = fdiv float %115, %117
%119 = tail call float @sqrt(float %118)
%120 = fdiv float %119, %67
%121 = fpext float %120 to double
%122 = fcmp ugt double %121, 1.000000e-01
br i1 %122, label %123, label %399
123: ; preds = %114
%124 = load i32, i32* %6
%125 = zext i8 %18 to i64
br label %126
126: ; preds = %148, %123
%127 = phi i32 [ %124, %123 ], [ %150, %148 ]
%128 = phi i64 [ 0, %123 ], [ %146, %148 ]
%129 = phi i32* [ %6, %123 ], [ %145, %148 ]
%130 = phi i8 [ %20, %123 ], [ %144, %148 ]
%131 = phi i8 [ %19, %123 ], [ %143, %148 ]
%132 = phi i32 [ %124, %123 ], [ %142, %148 ]
%133 = phi i32 [ %124, %123 ], [ %141, %148 ]
%134 = icmp ugt i32 %133, %127
%135 = trunc i64 %128 to i8
br i1 %134, label %136, label %140
136: ; preds = %126
%137 = icmp ult i32 %132, %127
%138 = select i1 %137, i32 %132, i32 %127
%139 = select i1 %137, i8 %130, i8 %135
br label %140
140: ; preds = %136, %126
%141 = phi i32 [ %127, %126 ], [ %133, %136 ]
%142 = phi i32 [ %132, %126 ], [ %138, %136 ]
%143 = phi i8 [ %135, %126 ], [ %131, %136 ]
%144 = phi i8 [ %130, %126 ], [ %139, %136 ]
%145 = getelementptr inbounds i32, i32* %129, i64 1
%146 = add nuw nsw i64 %128, 1
%147 = icmp eq i64 %146, %125
br i1 %147, label %151, label %148
148: ; preds = %140
%149 = getelementptr inbounds i32, i32* %145, i64 %146
%150 = load i32, i32* %149
br label %126
151: ; preds = %140
%152 = zext i8 %143 to i32
%153 = xor i32 %152, -1
%154 = add nsw i32 %153, %31
%155 = icmp sgt i32 %154, 0
br i1 %155, label %156, label %270
156: ; preds = %151
%157 = add nuw nsw i32 %152, 1
%158 = zext i32 %157 to i64
%159 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 %158
%160 = zext i8 %143 to i64
%161 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 %160
%162 = add nsw i32 %23, -2
%163 = sub nsw i32 %162, %152
%164 = zext i32 %163 to i64
%165 = add nuw nsw i64 %164, 1
%166 = icmp ult i32 %163, 7
br i1 %166, label %256, label %167
167: ; preds = %156
%168 = add nsw i32 %24, -2
%169 = sub nsw i32 %168, %152
%170 = trunc i32 %169 to i8
%171 = icmp eq i8 %170, -1
%172 = icmp ugt i32 %169, 255
%173 = or i1 %171, %172
br i1 %173, label %256, label %174
174: ; preds = %167
%175 = and i64 %165, 8589934584
%176 = getelementptr i32, i32* %159, i64 %175
%177 = getelementptr i32, i32* %161, i64 %175
%178 = trunc i64 %175 to i8
%179 = add nsw i64 %175, -8
%180 = lshr exact i64 %179, 3
%181 = add nuw nsw i64 %180, 1
%182 = and i64 %181, 3
%183 = icmp ult i64 %179, 24
br i1 %183, label %235, label %184
184: ; preds = %174
%185 = and i64 %181, 4611686018427387900
br label %186
186: ; preds = %186, %184
%187 = phi i64 [ 0, %184 ], [ %232, %186 ]
%188 = phi i64 [ 0, %184 ], [ %233, %186 ]
%189 = getelementptr i32, i32* %159, i64 %187
%190 = getelementptr i32, i32* %161, i64 %187
%191 = bitcast i32* %189 to <4 x i32>*
%192 = load <4 x i32>, <4 x i32>* %191
%193 = getelementptr i32, i32* %189, i64 4
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = bitcast i32* %190 to <4 x i32>*
store <4 x i32> %192, <4 x i32>* %196
%197 = getelementptr i32, i32* %190, i64 4
%198 = bitcast i32* %197 to <4 x i32>*
store <4 x i32> %195, <4 x i32>* %198
%199 = or i64 %187, 8
%200 = getelementptr i32, i32* %159, i64 %199
%201 = getelementptr i32, i32* %161, i64 %199
%202 = bitcast i32* %200 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = getelementptr i32, i32* %200, i64 4
%205 = bitcast i32* %204 to <4 x i32>*
%206 = load <4 x i32>, <4 x i32>* %205
%207 = bitcast i32* %201 to <4 x i32>*
store <4 x i32> %203, <4 x i32>* %207
%208 = getelementptr i32, i32* %201, i64 4
%209 = bitcast i32* %208 to <4 x i32>*
store <4 x i32> %206, <4 x i32>* %209
%210 = or i64 %187, 16
%211 = getelementptr i32, i32* %159, i64 %210
%212 = getelementptr i32, i32* %161, i64 %210
%213 = bitcast i32* %211 to <4 x i32>*
%214 = load <4 x i32>, <4 x i32>* %213
%215 = getelementptr i32, i32* %211, i64 4
%216 = bitcast i32* %215 to <4 x i32>*
%217 = load <4 x i32>, <4 x i32>* %216
%218 = bitcast i32* %212 to <4 x i32>*
store <4 x i32> %214, <4 x i32>* %218
%219 = getelementptr i32, i32* %212, i64 4
%220 = bitcast i32* %219 to <4 x i32>*
store <4 x i32> %217, <4 x i32>* %220
%221 = or i64 %187, 24
%222 = getelementptr i32, i32* %159, i64 %221
%223 = getelementptr i32, i32* %161, i64 %221
%224 = bitcast i32* %222 to <4 x i32>*
%225 = load <4 x i32>, <4 x i32>* %224
%226 = getelementptr i32, i32* %222, i64 4
%227 = bitcast i32* %226 to <4 x i32>*
%228 = load <4 x i32>, <4 x i32>* %227
%229 = bitcast i32* %223 to <4 x i32>*
store <4 x i32> %225, <4 x i32>* %229
%230 = getelementptr i32, i32* %223, i64 4
%231 = bitcast i32* %230 to <4 x i32>*
store <4 x i32> %228, <4 x i32>* %231
%232 = add nuw i64 %187, 32
%233 = add i64 %188, 4
%234 = icmp eq i64 %233, %185
br i1 %234, label %235, label %186
235: ; preds = %186, %174
%236 = phi i64 [ 0, %174 ], [ %232, %186 ]
%237 = icmp eq i64 %182, 0
br i1 %237, label %254, label %238
238: ; preds = %235, %238
%239 = phi i64 [ %251, %238 ], [ %236, %235 ]
%240 = phi i64 [ %252, %238 ], [ 0, %235 ]
%241 = getelementptr i32, i32* %159, i64 %239
%242 = getelementptr i32, i32* %161, i64 %239
%243 = bitcast i32* %241 to <4 x i32>*
%244 = load <4 x i32>, <4 x i32>* %243
%245 = getelementptr i32, i32* %241, i64 4
%246 = bitcast i32* %245 to <4 x i32>*
%247 = load <4 x i32>, <4 x i32>* %246
%248 = bitcast i32* %242 to <4 x i32>*
store <4 x i32> %244, <4 x i32>* %248
%249 = getelementptr i32, i32* %242, i64 4
%250 = bitcast i32* %249 to <4 x i32>*
store <4 x i32> %247, <4 x i32>* %250
%251 = add nuw i64 %239, 8
%252 = add i64 %240, 1
%253 = icmp eq i64 %252, %182
br i1 %253, label %254, label %238
254: ; preds = %238, %235
%255 = icmp eq i64 %165, %175
br i1 %255, label %270, label %256
256: ; preds = %167, %156, %254
%257 = phi i32* [ %159, %167 ], [ %159, %156 ], [ %176, %254 ]
%258 = phi i32* [ %161, %167 ], [ %161, %156 ], [ %177, %254 ]
%259 = phi i8 [ 0, %167 ], [ 0, %156 ], [ %178, %254 ]
br label %260
260: ; preds = %256, %260
%261 = phi i32* [ %266, %260 ], [ %257, %256 ]
%262 = phi i32* [ %265, %260 ], [ %258, %256 ]
%263 = phi i8 [ %267, %260 ], [ %259, %256 ]
%264 = load i32, i32* %261
store i32 %264, i32* %262
%265 = getelementptr inbounds i32, i32* %262, i64 1
%266 = getelementptr inbounds i32, i32* %261, i64 1
%267 = add i8 %263, 1
%268 = zext i8 %267 to i32
%269 = icmp sgt i32 %154, %268
br i1 %269, label %260, label %270
270: ; preds = %260, %254, %151
%271 = add i8 %18, -1
%272 = zext i8 %144 to i32
%273 = zext i8 %271 to i32
%274 = xor i32 %272, -1
%275 = add nsw i32 %274, %273
%276 = icmp sgt i32 %275, 0
br i1 %276, label %277, label %391
277: ; preds = %270
%278 = add nuw nsw i32 %272, 1
%279 = zext i32 %278 to i64
%280 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 %279
%281 = zext i8 %144 to i64
%282 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 %281
%283 = add nsw i32 %27, -2
%284 = sub nsw i32 %283, %272
%285 = zext i32 %284 to i64
%286 = add nuw nsw i64 %285, 1
%287 = icmp ult i32 %284, 7
br i1 %287, label %377, label %288
288: ; preds = %277
%289 = add nsw i32 %30, -2
%290 = sub nsw i32 %289, %272
%291 = trunc i32 %290 to i8
%292 = icmp eq i8 %291, -1
%293 = icmp ugt i32 %290, 255
%294 = or i1 %292, %293
br i1 %294, label %377, label %295
295: ; preds = %288
%296 = and i64 %286, 8589934584
%297 = getelementptr i32, i32* %280, i64 %296
%298 = getelementptr i32, i32* %282, i64 %296
%299 = trunc i64 %296 to i8
%300 = add nsw i64 %296, -8
%301 = lshr exact i64 %300, 3
%302 = add nuw nsw i64 %301, 1
%303 = and i64 %302, 3
%304 = icmp ult i64 %300, 24
br i1 %304, label %356, label %305
305: ; preds = %295
%306 = and i64 %302, 4611686018427387900
br label %307
307: ; preds = %307, %305
%308 = phi i64 [ 0, %305 ], [ %353, %307 ]
%309 = phi i64 [ 0, %305 ], [ %354, %307 ]
%310 = getelementptr i32, i32* %280, i64 %308
%311 = getelementptr i32, i32* %282, i64 %308
%312 = bitcast i32* %310 to <4 x i32>*
%313 = load <4 x i32>, <4 x i32>* %312
%314 = getelementptr i32, i32* %310, i64 4
%315 = bitcast i32* %314 to <4 x i32>*
%316 = load <4 x i32>, <4 x i32>* %315
%317 = bitcast i32* %311 to <4 x i32>*
store <4 x i32> %313, <4 x i32>* %317
%318 = getelementptr i32, i32* %311, i64 4
%319 = bitcast i32* %318 to <4 x i32>*
store <4 x i32> %316, <4 x i32>* %319
%320 = or i64 %308, 8
%321 = getelementptr i32, i32* %280, i64 %320
%322 = getelementptr i32, i32* %282, i64 %320
%323 = bitcast i32* %321 to <4 x i32>*
%324 = load <4 x i32>, <4 x i32>* %323
%325 = getelementptr i32, i32* %321, i64 4
%326 = bitcast i32* %325 to <4 x i32>*
%327 = load <4 x i32>, <4 x i32>* %326
%328 = bitcast i32* %322 to <4 x i32>*
store <4 x i32> %324, <4 x i32>* %328
%329 = getelementptr i32, i32* %322, i64 4
%330 = bitcast i32* %329 to <4 x i32>*
store <4 x i32> %327, <4 x i32>* %330
%331 = or i64 %308, 16
%332 = getelementptr i32, i32* %280, i64 %331
%333 = getelementptr i32, i32* %282, i64 %331
%334 = bitcast i32* %332 to <4 x i32>*
%335 = load <4 x i32>, <4 x i32>* %334
%336 = getelementptr i32, i32* %332, i64 4
%337 = bitcast i32* %336 to <4 x i32>*
%338 = load <4 x i32>, <4 x i32>* %337
%339 = bitcast i32* %333 to <4 x i32>*
store <4 x i32> %335, <4 x i32>* %339
%340 = getelementptr i32, i32* %333, i64 4
%341 = bitcast i32* %340 to <4 x i32>*
store <4 x i32> %338, <4 x i32>* %341
%342 = or i64 %308, 24
%343 = getelementptr i32, i32* %280, i64 %342
%344 = getelementptr i32, i32* %282, i64 %342
%345 = bitcast i32* %343 to <4 x i32>*
%346 = load <4 x i32>, <4 x i32>* %345
%347 = getelementptr i32, i32* %343, i64 4
%348 = bitcast i32* %347 to <4 x i32>*
%349 = load <4 x i32>, <4 x i32>* %348
%350 = bitcast i32* %344 to <4 x i32>*
store <4 x i32> %346, <4 x i32>* %350
%351 = getelementptr i32, i32* %344, i64 4
%352 = bitcast i32* %351 to <4 x i32>*
store <4 x i32> %349, <4 x i32>* %352
%353 = add nuw i64 %308, 32
%354 = add i64 %309, 4
%355 = icmp eq i64 %354, %306
br i1 %355, label %356, label %307
356: ; preds = %307, %295
%357 = phi i64 [ 0, %295 ], [ %353, %307 ]
%358 = icmp eq i64 %303, 0
br i1 %358, label %375, label %359
359: ; preds = %356, %359
%360 = phi i64 [ %372, %359 ], [ %357, %356 ]
%361 = phi i64 [ %373, %359 ], [ 0, %356 ]
%362 = getelementptr i32, i32* %280, i64 %360
%363 = getelementptr i32, i32* %282, i64 %360
%364 = bitcast i32* %362 to <4 x i32>*
%365 = load <4 x i32>, <4 x i32>* %364
%366 = getelementptr i32, i32* %362, i64 4
%367 = bitcast i32* %366 to <4 x i32>*
%368 = load <4 x i32>, <4 x i32>* %367
%369 = bitcast i32* %363 to <4 x i32>*
store <4 x i32> %365, <4 x i32>* %369
%370 = getelementptr i32, i32* %363, i64 4
%371 = bitcast i32* %370 to <4 x i32>*
store <4 x i32> %368, <4 x i32>* %371
%372 = add nuw i64 %360, 8
%373 = add i64 %361, 1
%374 = icmp eq i64 %373, %303
br i1 %374, label %375, label %359
375: ; preds = %359, %356
%376 = icmp eq i64 %286, %296
br i1 %376, label %391, label %377
377: ; preds = %288, %277, %375
%378 = phi i32* [ %280, %288 ], [ %280, %277 ], [ %297, %375 ]
%379 = phi i32* [ %282, %288 ], [ %282, %277 ], [ %298, %375 ]
%380 = phi i8 [ 0, %288 ], [ 0, %277 ], [ %299, %375 ]
br label %381
381: ; preds = %377, %381
%382 = phi i32* [ %387, %381 ], [ %378, %377 ]
%383 = phi i32* [ %386, %381 ], [ %379, %377 ]
%384 = phi i8 [ %388, %381 ], [ %380, %377 ]
%385 = load i32, i32* %382
store i32 %385, i32* %383
%386 = getelementptr inbounds i32, i32* %383, i64 1
%387 = getelementptr inbounds i32, i32* %382, i64 1
%388 = add i8 %384, 1
%389 = zext i8 %388 to i32
%390 = icmp sgt i32 %275, %389
br i1 %390, label %381, label %391
391: ; preds = %381, %375, %270
%392 = add i8 %18, -2
%393 = zext i8 %392 to i32
%394 = sub nsw i32 %13, %393
%395 = sitofp i32 %394 to float
%396 = fdiv float %395, %14
%397 = fcmp ogt float %396, 5.000000e-01
%398 = add i8 %17, 1
br i1 %397, label %399, label %16
399: ; preds = %391, %114, %16
%400 = phi i8 [ -1, %16 ], [ 0, %114 ], [ -1, %391 ]
%401 = phi float [ 0.000000e+00, %16 ], [ %67, %114 ], [ 0.000000e+00, %391 ]
store i8 %400, i8* %2
ret float %401
}