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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
scalar_t__ pow(float, int);
int /*<<< orphan*/ printf(char *, ...);
float sqrt(float);
void ucfidol(FILE *ifp) {
  unsigned short audienceSize = 3, numContestants = 2, numShows = 2, winner = 1;
  float bestAverage = 0, threshold = 6;
  fscanf(ifp, "%hd", &numShows);
  unsigned short i, j, k, delta;
  float temp = 0;
  for (i = 1; i <= numShows; i++) {
    printf("UCF IDOL SHOW #%hd\n", i);
    fscanf(ifp, "%hd%hd%f", &numContestants, &audienceSize, &threshold);
    unsigned short reject[audienceSize + 1];
    delta = audienceSize;
    float average[audienceSize], scores[numContestants][audienceSize],
        standDev[audienceSize], sum[audienceSize], rowSum[numContestants],
        rowSum2[numContestants];
    for (j = 0; j < audienceSize; j++) {
      reject[j + 1] = 0;
      standDev[j] = 0;
    }
    for (j = 0; j < numContestants; j++) {
      rowSum[j] = 0;
      rowSum2[j] = 0;
      for (k = 0; k < audienceSize; k++) {
        sum[k] = 0;
        fscanf(ifp, "%f", &scores[j][k]);
      }
    }
    for (j = 0; j < audienceSize; j++) {
      for (k = 0; k < numContestants; k++)
        sum[j] += scores[k][j];
      standDev[j] = sum[j] / numContestants;
      for (k = 0; k < numContestants; k++)
        temp += pow(standDev[j] - scores[k][j], 2);
      standDev[j] = sqrt(temp / numContestants);
      temp = 0;
      if (standDev[j] > threshold) {
        reject[j + 1] = 1;
        delta--;
      }
    }
    for (j = 0; j < numContestants; j++) {
      for (k = 0; k < audienceSize; k++) {
        rowSum[j] += scores[j][k];
        if (reject[k + 1]) {
          rowSum2[j] -= scores[j][k];
        } else
          rowSum2[j] += scores[j][k];
      }
    }
    if ((rowSum[0] == rowSum2[0]) || (rowSum[0] == -rowSum2[0])) {
      reject[0] = 0;
      for (j = 0; j < numContestants; j++)
        average[j] = rowSum[j] / audienceSize;
    } else {
      reject[0] = 1;
      for (j = 0; j < numContestants; j++)
        average[j] = (rowSum[j] + rowSum2[j]) / (2 * delta);
    }
    for (j = 0; j < numContestants; j++)
      if (average[j] > bestAverage) {
        bestAverage = average[j];
        winner = j + 1;
      }
    printf("Contestant #%hd, you win with an average score of %.2f.\n", winner,
           bestAverage);
    bestAverage = 0;
    if (reject[0]) {
      printf("The following judges’ scores were thrown out: ");
      for (j = 1; j <= audienceSize; j++)
        if (reject[j])
          printf("%hd ", j);
      printf("\n\n");
    } else
      printf("All judges’ scores were used.\n\n");
  }
}


x86 assembly (clang, -O0):
<ucfidol>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
movw   $0x3,-0xa(%rbp)
movw   $0x2,-0xc(%rbp)
movw   $0x2,-0xe(%rbp)
movw   $0x1,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  0xe89(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe7d(%rip),%rsi
lea    -0xe(%rbp),%rdx
mov    $0x0,%al
call   1040 <fscanf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movw   $0x1,-0x1a(%rbp)
movzwl -0x1a(%rbp),%eax
movzwl -0xe(%rbp),%ecx
cmp    %ecx,%eax
jg     1948 <ucfidol+0x808>
movzwl -0x1a(%rbp),%esi
lea    0xe4d(%rip),%rdi
xor    %eax,%eax
mov    %al,-0xb1(%rbp)
call   1030 <printf@plt>
mov    -0xb1(%rbp),%al
mov    -0x8(%rbp),%rdi
lea    0xe43(%rip),%rsi
lea    -0xc(%rbp),%rdx
lea    -0xa(%rbp),%rcx
lea    -0x18(%rbp),%r8
call   1040 <fscanf@plt>
movzwl -0xa(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
mov    %edx,%ecx
lea    0x11(%rcx,%rcx,1),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
mov    -0xa(%rbp),%ax
mov    %ax,-0x20(%rbp)
movzwl -0xa(%rbp),%edx
mov    %edx,%eax
mov    %edx,%ecx
lea    0xf(,%rcx,4),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xa8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
movzwl -0xc(%rbp),%eax
mov    %eax,%ecx
movzwl -0xa(%rbp),%eax
mov    %rax,-0xa0(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x98(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x48(%rbp)
mov    %rax,-0x50(%rbp)
movzwl -0xa(%rbp),%edx
mov    %edx,%eax
mov    %edx,%ecx
lea    0xf(,%rcx,4),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x90(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
movzwl -0xa(%rbp),%edx
mov    %edx,%eax
mov    %edx,%ecx
lea    0xf(,%rcx,4),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x88(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
movzwl -0xc(%rbp),%edx
mov    %edx,%eax
mov    %edx,%ecx
lea    0xf(,%rcx,4),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x80(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x68(%rbp)
movzwl -0xc(%rbp),%edx
mov    %edx,%eax
mov    %edx,%ecx
lea    0xf(,%rcx,4),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
movw   $0x0,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
movzwl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    137c <ucfidol+0x23c>
mov    -0x90(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movzwl -0x1c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movw   $0x0,(%rcx,%rdx,2)
movzwl -0x1c(%rbp),%ecx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1c(%rbp)
jmp    1331 <ucfidol+0x1f1>
movw   $0x0,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
movzwl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    143c <ucfidol+0x2fc>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rcx
movzwl -0x1c(%rbp),%edx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rcx,%rdx,4)
movzwl -0x1c(%rbp),%ecx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movw   $0x0,-0x1e(%rbp)
movzwl -0x1e(%rbp),%eax
movzwl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    1426 <ucfidol+0x2e6>
mov    -0x98(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
mov    -0x88(%rbp),%rax
movzwl -0x1e(%rbp),%esi
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rsi,4)
mov    -0x8(%rbp),%rdi
movzwl -0x1c(%rbp),%eax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rdx
movzwl -0x1e(%rbp),%eax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xc14(%rip),%rsi
mov    $0x0,%al
call   1040 <fscanf@plt>
mov    -0x1e(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1e(%rbp)
jmp    13b8 <ucfidol+0x278>
jmp    142b <ucfidol+0x2eb>
mov    -0x1c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1c(%rbp)
jmp    1382 <ucfidol+0x242>
movw   $0x0,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
movzwl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    15d0 <ucfidol+0x490>
movw   $0x0,-0x1e(%rbp)
movzwl -0x1e(%rbp),%eax
movzwl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    14b4 <ucfidol+0x374>
mov    -0x88(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%rsi
movzwl -0x1e(%rbp),%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movzwl -0x1c(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
movzwl -0x1c(%rbp),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1e(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1e(%rbp)
jmp    1458 <ucfidol+0x318>
mov    -0x90(%rbp),%rax
mov    -0x88(%rbp),%rcx
movzwl -0x1c(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
movzwl -0xc(%rbp),%ecx
cvtsi2ss %ecx,%xmm1
divss  %xmm1,%xmm0
movzwl -0x1c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movw   $0x0,-0x1e(%rbp)
movzwl -0x1e(%rbp),%eax
movzwl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1556 <ucfidol+0x416>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
mov    -0x90(%rbp),%rcx
movzwl -0x1c(%rbp),%esi
movss  (%rcx,%rsi,4),%xmm0
movzwl -0x1e(%rbp),%ecx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movzwl -0x1c(%rbp),%ecx
subss  (%rax,%rcx,4),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
cvtsi2ss %rax,%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x1e(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1e(%rbp)
jmp    14e6 <ucfidol+0x3a6>
movss  -0x24(%rbp),%xmm0
movzwl -0xc(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
call   1060 <sqrt@plt>
mov    -0x90(%rbp),%rax
movzwl -0x1c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movzwl -0x1c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x18(%rbp),%xmm0
jbe    15ba <ucfidol+0x47a>
mov    -0xb0(%rbp),%rax
movzwl -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movw   $0x1,(%rax,%rcx,2)
mov    -0x20(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x20(%rbp)
jmp    15bf <ucfidol+0x47f>
mov    -0x1c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1c(%rbp)
jmp    1442 <ucfidol+0x302>
movw   $0x0,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
movzwl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    16f5 <ucfidol+0x5b5>
movw   $0x0,-0x1e(%rbp)
movzwl -0x1e(%rbp),%eax
movzwl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    16df <ucfidol+0x59f>
mov    -0xb0(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    -0x98(%rbp),%rdx
mov    -0xa0(%rbp),%rdi
movzwl -0x1c(%rbp),%esi
imul   %rdi,%rsi
shl    $0x2,%rsi
add    %rsi,%rdx
movzwl -0x1e(%rbp),%esi
movss  (%rdx,%rsi,4),%xmm0
movzwl -0x1c(%rbp),%edx
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
movzwl -0x1e(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpw   $0x0,(%rax,%rcx,2)
je     1691 <ucfidol+0x551>
mov    -0x78(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%rsi
movzwl -0x1c(%rbp),%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movzwl -0x1e(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm1
movzwl -0x1c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    16c9 <ucfidol+0x589>
mov    -0x78(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%rsi
movzwl -0x1c(%rbp),%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movzwl -0x1e(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
movzwl -0x1c(%rbp),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    16ce <ucfidol+0x58e>
mov    -0x1e(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1e(%rbp)
jmp    15ec <ucfidol+0x4ac>
jmp    16e4 <ucfidol+0x5a4>
mov    -0x1c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1c(%rbp)
jmp    15d6 <ucfidol+0x496>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rcx),%xmm0
ucomiss (%rax),%xmm0
jne    1715 <ucfidol+0x5d5>
jp     1715 <ucfidol+0x5d5>
jmp    1741 <ucfidol+0x601>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rcx),%xmm0
movss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
ucomiss %xmm1,%xmm0
jne    17a2 <ucfidol+0x662>
jp     17a2 <ucfidol+0x662>
mov    -0xb0(%rbp),%rax
movw   $0x0,(%rax)
movw   $0x0,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
movzwl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    179d <ucfidol+0x65d>
mov    -0xa8(%rbp),%rax
mov    -0x80(%rbp),%rcx
movzwl -0x1c(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
movzwl -0xa(%rbp),%ecx
cvtsi2ss %ecx,%xmm1
divss  %xmm1,%xmm0
movzwl -0x1c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1c(%rbp)
jmp    1753 <ucfidol+0x613>
jmp    1813 <ucfidol+0x6d3>
mov    -0xb0(%rbp),%rax
movw   $0x1,(%rax)
movw   $0x0,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
movzwl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    180e <ucfidol+0x6ce>
mov    -0xa8(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    -0x80(%rbp),%rdx
movzwl -0x1c(%rbp),%esi
movss  (%rdx,%rsi,4),%xmm0
movzwl -0x1c(%rbp),%edx
addss  (%rcx,%rdx,4),%xmm0
movzwl -0x20(%rbp),%ecx
shl    $0x1,%ecx
cvtsi2ss %ecx,%xmm1
divss  %xmm1,%xmm0
movzwl -0x1c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1c(%rbp)
jmp    17b4 <ucfidol+0x674>
jmp    1813 <ucfidol+0x6d3>
movw   $0x0,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
movzwl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1879 <ucfidol+0x739>
mov    -0xa8(%rbp),%rax
movzwl -0x1c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x14(%rbp),%xmm0
jbe    1863 <ucfidol+0x723>
mov    -0xa8(%rbp),%rax
movzwl -0x1c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x14(%rbp)
movzwl -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %ax,-0x10(%rbp)
jmp    1868 <ucfidol+0x728>
mov    -0x1c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1c(%rbp)
jmp    1819 <ucfidol+0x6d9>
movzwl -0x10(%rbp),%esi
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x798(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xb0(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
cmpw   $0x0,(%rax)
je     1922 <ucfidol+0x7e2>
lea    0x7aa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movw   $0x1,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
movzwl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jg     190f <ucfidol+0x7cf>
mov    -0xb0(%rbp),%rax
movzwl -0x1c(%rbp),%ecx
cmpw   $0x0,(%rax,%rcx,2)
je     18f9 <ucfidol+0x7b9>
movzwl -0x1c(%rbp),%esi
lea    0x79d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    18fe <ucfidol+0x7be>
mov    -0x1c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1c(%rbp)
jmp    18c1 <ucfidol+0x781>
lea    0x79d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1930 <ucfidol+0x7f0>
lea    0x76b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    -0x1a(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x1a(%rbp)
jmp    11a0 <ucfidol+0x60>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ucfidol>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rdi,%rbx
movw   $0x3,-0x2a(%rbp)
movw   $0x2,-0x2c(%rbp)
movw   $0x2,-0x2e(%rbp)
movl   $0x40c00000,-0x5c(%rbp)
lea    0xe7d(%rip),%rsi
lea    -0x2e(%rbp),%rdx
xor    %eax,%eax
call   1060 <fscanf@plt>
cmpw   $0x0,-0x2e(%rbp)
je     1b15 <ucfidol+0x9b5>
mov    $0x1,%ax
mov    %eax,-0x34(%rbp)
mov    $0x1,%ax
mov    %rbx,-0x70(%rbp)
jmp    11e6 <ucfidol+0x86>
xchg   %ax,%ax
lea    0xefc(%rip),%rdi
call   1030 <puts@plt>
mov    -0xc0(%rbp),%rsp
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
cmp    -0x2e(%rbp),%ax
ja     1b15 <ucfidol+0x9b5>
mov    %eax,-0xa4(%rbp)
movzwl %ax,%esi
lea    0xe22(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
lea    0xe25(%rip),%rsi
lea    -0x2c(%rbp),%rdx
lea    -0x2a(%rbp),%rcx
lea    -0x5c(%rbp),%r8
xor    %eax,%eax
call   1060 <fscanf@plt>
mov    %rsp,-0xc0(%rbp)
movzwl -0x2a(%rbp),%eax
add    %eax,%eax
add    $0x11,%eax
and    $0xfffffff0,%eax
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
movzwl -0x2a(%rbp),%ebx
lea    0xf(,%rbx,4),%eax
and    $0xfffffff0,%eax
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
movzwl -0x2c(%rbp),%r11d
mov    %r11,%rcx
imul   %rbx,%rcx
lea    0xf(,%rcx,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x68(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rsi
sub    %rax,%rsi
mov    %rsi,%rsp
lea    0xf(,%r11,4),%eax
and    $0xfffffff0,%eax
mov    %rsp,%r13
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
test   %ebx,%ebx
mov    %rsi,-0x78(%rbp)
je     12bd <ucfidol+0x15d>
lea    0x2(%r14),%rdi
lea    (%rbx,%rbx,1),%rdx
xor    %esi,%esi
mov    %r11,%r15
call   1050 <memset@plt>
mov    -0x78(%rbp),%rsi
mov    %r15,%r11
mov    %rbx,-0x58(%rbp)
test   %r11w,%r11w
mov    %r14,-0x88(%rbp)
mov    %r12,-0x80(%rbp)
mov    %r13,-0x40(%rbp)
je     13c0 <ucfidol+0x260>
mov    -0x58(%rbp),%r14
lea    0x0(,%r14,4),%rax
mov    %rax,-0x98(%rbp)
mov    -0x68(%rbp),%rdi
mov    %r14d,%eax
mov    %r14d,%ecx
xor    %r12d,%r12d
movaps 0xcff(%rip),%xmm6
mov    -0x48(%rbp),%rbx
jmp    132a <ucfidol+0x1ca>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
add    $0x1,%r12
movzwl %r11w,%edx
add    -0x98(%rbp),%rdi
cmp    %rdx,%r12
jae    13d5 <ucfidol+0x275>
movl   $0x0,0x0(%r13,%r12,4)
movl   $0x0,(%rbx,%r12,4)
test   %cx,%cx
je     1310 <ucfidol+0x1b0>
mov    %rdi,-0xa0(%rbp)
mov    %rdi,%r14
xor    %ebx,%ebx
mov    -0x70(%rbp),%r15
lea    0xcdb(%rip),%r13
nopw   0x0(%rax,%rax,1)
movl   $0x0,(%rsi,%rbx,4)
mov    %r15,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1060 <fscanf@plt>
mov    -0x78(%rbp),%rsi
add    $0x1,%rbx
movzwl -0x2a(%rbp),%eax
add    $0x4,%r14
cmp    %rax,%rbx
jb     1360 <ucfidol+0x200>
movzwl -0x2c(%rbp),%r11d
mov    %eax,%ecx
movaps 0xc66(%rip),%xmm6
mov    -0x40(%rbp),%r13
mov    -0x48(%rbp),%rbx
mov    -0x58(%rbp),%r14
mov    -0xa0(%rbp),%rdi
jmp    1312 <ucfidol+0x1b2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %r11d,%r11d
mov    -0x58(%rbp),%r14
mov    %r14d,%eax
movaps 0xc2f(%rip),%xmm6
mov    -0x48(%rbp),%rbx
test   %ax,%ax
je     15e0 <ucfidol+0x480>
mov    %r14,%r13
shl    $0x4,%r13
lea    0x0(,%r14,4),%rbx
lea    (%rbx,%rbx,2),%r9
mov    -0x68(%rbp),%r10
xor    %edx,%edx
mov    %r14d,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x88(%rbp),%r15
mov    -0x80(%rbp),%r12
mov    %r9,-0xb0(%rbp)
jmp    1436 <ucfidol+0x2d6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzwl -0x2a(%rbp),%ecx
movzwl -0x2c(%rbp),%r11d
add    $0x4,%r10
cmp    %rcx,%rdx
jae    15d0 <ucfidol+0x470>
xorps  %xmm0,%xmm0
test   %r11w,%r11w
mov    %rdx,-0x90(%rbp)
mov    %r10,-0xb8(%rbp)
je     1560 <ucfidol+0x400>
movss  (%rsi,%rdx,4),%xmm1
movzwl %r11w,%r8d
lea    -0x1(%r8),%rdx
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    1470 <ucfidol+0x310>
xor    %edx,%edx
jmp    14a2 <ucfidol+0x342>
xchg   %ax,%ax
mov    %r8d,%eax
and    $0xfffffffc,%eax
mov    %r10,%rdi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
addss  (%rdi),%xmm1
addss  (%rdi,%r14,4),%xmm1
addss  (%rdi,%r14,8),%xmm1
addss  (%rdi,%r9,1),%xmm1
add    $0x4,%rdx
add    %r13,%rdi
cmp    %rdx,%rax
jne    1480 <ucfidol+0x320>
test   %rcx,%rcx
je     14bd <ucfidol+0x35d>
imul   %r14,%rdx
lea    (%r10,%rdx,4),%rdx
nop
addss  (%rdx),%xmm1
add    %rbx,%rdx
add    $0xffffffffffffffff,%rcx
jne    14b0 <ucfidol+0x350>
mov    -0x90(%rbp),%rdx
movss  %xmm1,(%rsi,%rdx,4)
test   %r11w,%r11w
je     1560 <ucfidol+0x400>
xorps  %xmm0,%xmm0
cvtsi2ss %r8d,%xmm0
divss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
mov    %r10,%r14
xor    %r12d,%r12d
movss  %xmm1,-0x98(%rbp)
ff
movss  %xmm0,-0xa0(%rbp)
ff
movaps %xmm1,%xmm0
subss  (%r14),%xmm0
mov    $0x2,%edi
call   1070 <pow@plt>
movss  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
addss  %xmm1,%xmm0
movss  -0x98(%rbp),%xmm1
ff
add    $0x1,%r12
movzwl -0x2c(%rbp),%eax
add    %rbx,%r14
cmp    %rax,%r12
jb     14f0 <ucfidol+0x390>
movaps 0xac3(%rip),%xmm6
mov    -0x88(%rbp),%r15
mov    -0x80(%rbp),%r12
mov    -0x58(%rbp),%r14
mov    -0x78(%rbp),%rsi
mov    -0xb0(%rbp),%r9
mov    -0x90(%rbp),%rdx
jmp    1562 <ucfidol+0x402>
xor    %eax,%eax
movzwl %ax,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
ucomiss 0xa99(%rip),%xmm0
jb     1580 <ucfidol+0x420>
sqrtss %xmm0,%xmm0
jmp    159e <ucfidol+0x43e>
nop
call   1080 <sqrt@plt>
mov    -0x90(%rbp),%rdx
mov    -0xb0(%rbp),%r9
mov    -0x78(%rbp),%rsi
movaps 0xa62(%rip),%xmm6
mov    -0xb8(%rbp),%r10
add    $0x1,%rdx
ucomiss -0x5c(%rbp),%xmm0
jbe    1420 <ucfidol+0x2c0>
movw   $0x1,(%r15,%rdx,2)
addl   $0xffffffff,-0x4c(%rbp)
jmp    1420 <ucfidol+0x2c0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x40(%rbp),%r13
mov    -0x48(%rbp),%rbx
jmp    15f3 <ucfidol+0x493>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %r14d,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x88(%rbp),%r15
mov    -0x80(%rbp),%r12
movzwl %r11w,%r8d
test   %r11w,%r11w
je     1700 <ucfidol+0x5a0>
movzwl %cx,%r9d
mov    %r9d,%esi
and    $0xfffffffe,%esi
mov    -0x68(%rbp),%rax
lea    0x4(%rax),%rdi
mov    -0x58(%rbp),%rax
lea    0x0(,%rax,4),%r10
xor    %eax,%eax
jmp    1658 <ucfidol+0x4f8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  %xmm3,%xmm1
addss  %xmm2,%xmm0
mov    -0x48(%rbp),%rbx
movss  %xmm1,(%rbx,%rax,4)
movss  %xmm0,0x0(%r13,%rax,4)
add    $0x1,%rax
add    %r10,%rdi
cmp    %r8,%rax
je     1700 <ucfidol+0x5a0>
test   %cx,%cx
je     1648 <ucfidol+0x4e8>
movss  0x0(%r13,%rax,4),%xmm0
movss  (%rbx,%rax,4),%xmm1
cmp    $0x1,%cx
jne    16a0 <ucfidol+0x540>
xor    %ebx,%ebx
test   $0x1,%r9b
je     1638 <ucfidol+0x4d8>
mov    %rax,%rdx
imul   -0x58(%rbp),%rdx
mov    -0x68(%rbp),%r14
lea    (%r14,%rdx,4),%rdx
movss  (%rdx,%rbx,4),%xmm2
cmpw   $0x0,0x2(%r15,%rbx,2)
movaps %xmm2,%xmm3
je     1630 <ucfidol+0x4d0>
movaps %xmm2,%xmm3
xorps  %xmm6,%xmm3
jmp    1630 <ucfidol+0x4d0>
xor    %edx,%edx
jmp    16c8 <ucfidol+0x568>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addss  %xmm2,%xmm0
addss  %xmm3,%xmm1
addss  %xmm5,%xmm1
addss  %xmm4,%xmm0
mov    %rbx,%rdx
cmp    %rbx,%rsi
je     1671 <ucfidol+0x511>
movss  -0x4(%rdi,%rdx,4),%xmm2
cmpw   $0x0,0x2(%r15,%rdx,2)
movaps %xmm2,%xmm3
je     16e0 <ucfidol+0x580>
movaps %xmm2,%xmm3
xorps  %xmm6,%xmm3
movss  (%rdi,%rdx,4),%xmm4
lea    0x2(%rdx),%rbx
cmpw   $0x0,0x4(%r15,%rdx,2)
movaps %xmm4,%xmm5
je     16b0 <ucfidol+0x550>
movaps %xmm4,%xmm5
xorps  %xmm6,%xmm5
jmp    16b0 <ucfidol+0x550>
nopl   (%rax)
movss  0x0(%r13),%xmm1
movss  (%rbx),%xmm2
ucomiss %xmm2,%xmm1
setnp  %al
sete   %dl
and    %al,%dl
movaps %xmm2,%xmm0
xorps  %xmm6,%xmm0
ucomiss %xmm1,%xmm0
setnp  %al
sete   %r13b
and    %al,%r13b
or     %dl,%r13b
cmp    $0x1,%r13b
jne    1840 <ucfidol+0x6e0>
movw   $0x0,(%r15)
test   %r11w,%r11w
je     1a5f <ucfidol+0x8ff>
movzwl %cx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,(%r12)
cmp    $0x1,%r11w
mov    -0x34(%rbp),%ebx
je     1960 <ucfidol+0x800>
lea    -0x1(%r8),%r9
mov    $0x1,%eax
cmp    $0x4,%r9
jb     1810 <ucfidol+0x6b0>
mov    %r9,%rax
and    $0xfffffffffffffffc,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1af4 <ucfidol+0x994>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
mov    -0x40(%rbp),%rcx
cs nopw 0x0(%rax,%rax,1)
movups 0x4(%rcx,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,0x4(%r12,%rsi,4)
movups 0x14(%rcx,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,0x14(%r12,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    17c0 <ucfidol+0x660>
test   $0x1,%dl
je     1803 <ucfidol+0x6a3>
shl    $0x2,%rsi
or     $0x4,%rsi
mov    -0x40(%rbp),%rcx
movups (%rcx,%rsi,1),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%r12,%rsi,1)
cmp    %rax,%r9
je     1960 <ucfidol+0x800>
or     $0x1,%rax
mov    -0x40(%rbp),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%r8
jne    1820 <ucfidol+0x6c0>
jmp    1960 <ucfidol+0x800>
nopl   (%rax)
movw   $0x1,(%r15)
test   %r11w,%r11w
je     1a84 <ucfidol+0x924>
movzwl -0x4c(%rbp),%eax
add    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12)
cmp    $0x1,%r11w
mov    -0x34(%rbp),%ebx
je     1960 <ucfidol+0x800>
lea    -0x1(%r8),%r9
mov    $0x1,%eax
cmp    $0x4,%r9
jb     1938 <ucfidol+0x7d8>
mov    %r9,%rax
and    $0xfffffffffffffffc,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rax),%rdx
mov    %rdx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rdx,%rdx
je     1b04 <ucfidol+0x9a4>
mov    %r10,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
xor    %edx,%edx
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%rsi
nopl   0x0(%rax)
movups 0x4(%rcx,%rdx,4),%xmm2
movups 0x4(%rsi,%rdx,4),%xmm3
addps  %xmm2,%xmm3
divps  %xmm1,%xmm3
movups %xmm3,0x4(%r12,%rdx,4)
movups 0x14(%rcx,%rdx,4),%xmm2
movups 0x14(%rsi,%rdx,4),%xmm3
addps  %xmm2,%xmm3
divps  %xmm1,%xmm3
movups %xmm3,0x14(%r12,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    18d0 <ucfidol+0x770>
test   $0x1,%r10b
je     192f <ucfidol+0x7cf>
shl    $0x2,%rdx
or     $0x4,%rdx
mov    -0x40(%rbp),%rcx
movups (%rcx,%rdx,1),%xmm2
mov    -0x48(%rbp),%rcx
movups (%rcx,%rdx,1),%xmm3
addps  %xmm2,%xmm3
divps  %xmm1,%xmm3
movups %xmm3,(%r12,%rdx,1)
cmp    %rax,%r9
je     1960 <ucfidol+0x800>
or     $0x1,%rax
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%rdx
movss  (%rcx,%rax,4),%xmm1
addss  (%rdx,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%r8
jne    1940 <ucfidol+0x7e0>
nopl   (%rax)
test   %r11w,%r11w
je     1980 <ucfidol+0x820>
lea    -0x1(%r8),%rax
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    1988 <ucfidol+0x828>
xorps  %xmm0,%xmm0
xor    %eax,%eax
jmp    19f7 <ucfidol+0x897>
nopl   (%rax)
xorps  %xmm1,%xmm1
jmp    1a2e <ucfidol+0x8ce>
and    $0xfffffffc,%r8d
xorps  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%rax),%edx
movss  (%r12,%rax,4),%xmm1
movss  0x4(%r12,%rax,4),%xmm2
ucomiss %xmm0,%xmm1
maxss  %xmm0,%xmm1
cmova  %edx,%ebx
lea    0x2(%rax),%edx
ucomiss %xmm1,%xmm2
maxss  %xmm1,%xmm2
cmovbe %ebx,%edx
movss  0x8(%r12,%rax,4),%xmm1
lea    0x3(%rax),%esi
ucomiss %xmm2,%xmm1
maxss  %xmm2,%xmm1
cmovbe %edx,%esi
movss  0xc(%r12,%rax,4),%xmm0
add    $0x4,%rax
ucomiss %xmm1,%xmm0
maxss  %xmm1,%xmm0
mov    %eax,%ebx
cmovbe %esi,%ebx
cmp    %rax,%r8
jne    19a0 <ucfidol+0x840>
movaps %xmm0,%xmm1
test   %rcx,%rcx
je     1a2e <ucfidol+0x8ce>
lea    0x1(%rax),%edx
movzwl %dx,%edx
lea    (%r12,%rax,4),%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm1
ucomiss %xmm0,%xmm1
lea    (%rdx,%rsi,1),%edi
cmova  %edi,%ebx
maxss  %xmm0,%xmm1
add    $0x1,%rsi
movaps %xmm1,%xmm0
cmp    %rsi,%rcx
jne    1a10 <ucfidol+0x8b0>
mov    %ebx,-0x34(%rbp)
movzwl %bx,%esi
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
lea    0x5f3(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0x654(%rip),%rdi
test   %r13b,%r13b
mov    -0x70(%rbp),%rbx
jne    11c7 <ucfidol+0x67>
jmp    1a9d <ucfidol+0x93d>
movzwl -0x34(%rbp),%esi
xorps  %xmm0,%xmm0
lea    0x5c8(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0x629(%rip),%rdi
mov    -0x70(%rbp),%rbx
jmp    11c7 <ucfidol+0x67>
movzwl -0x34(%rbp),%esi
xorps  %xmm0,%xmm0
lea    0x5a3(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x70(%rbp),%rbx
lea    0x5ca(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzwl -0x2a(%rbp),%eax
test   %ax,%ax
je     11c0 <ucfidol+0x60>
mov    $0x1,%r13d
jmp    1ad2 <ucfidol+0x972>
add    $0x1,%r13d
movzwl %r13w,%r13d
cmp    %ax,%r13w
ja     11c0 <ucfidol+0x60>
mov    %r13d,%ecx
cmpw   $0x0,(%r15,%rcx,2)
je     1ac0 <ucfidol+0x960>
lea    0x5bb(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
movzwl -0x2a(%rbp),%eax
jmp    1ac0 <ucfidol+0x960>
xor    %esi,%esi
test   $0x1,%dl
jne    17eb <ucfidol+0x68b>
jmp    1803 <ucfidol+0x6a3>
xor    %edx,%edx
test   $0x1,%r10b
jne    190c <ucfidol+0x7ac>
jmp    192f <ucfidol+0x7cf>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [4 x i8] c"%hd\00"
@.str.1 = [20 x i8] c"UCF IDOL SHOW #%hd\0A\00"
@.str.2 = [9 x i8] c"%hd%hd%f\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [57 x i8] c"Contestant #%hd, you win with an average score of %.2f.\0A\00"
@.str.5 = [49 x i8] c"The following judges\E2\80\99 scores were thrown out: \00"
@.str.6 = [5 x i8] c"%hd \00"
@str = [33 x i8] c"All judges\E2\80\99 scores were used.\0A\00"
@str.9 = [2 x i8] c"\0A\00"
define void @ucfidol(i32* nocapture %0) {
%2 = alloca i16
%3 = alloca i16
%4 = alloca i16
%5 = alloca float
%6 = bitcast i16* %2 to i8*
store i16 3, i16* %2
%7 = bitcast i16* %3 to i8*
store i16 2, i16* %3
%8 = bitcast i16* %4 to i8*
store i16 2, i16* %4
%9 = bitcast float* %5 to i8*
store float 6.000000e+00, float* %5
%10 = call i32 (i32*, i8*, ...) @fscanf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i16* %4)
%11 = load i16, i16* %4
%12 = icmp eq i16 %11, 0
br i1 %12, label %498, label %13
13: ; preds = %1, %491
%14 = phi i16 [ %493, %491 ], [ 1, %1 ]
%15 = phi i16 [ %495, %491 ], [ 1, %1 ]
%16 = zext i16 %15 to i32
%17 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.1, i64 0, i64 0), i32 %16)
%18 = call i32 (i32*, i8*, ...) @fscanf(i32* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i16* %3, i16* %2, float* %5)
%19 = load i16, i16* %2
%20 = zext i16 %19 to i64
%21 = add nuw nsw i64 %20, 1
%22 = call i8* @llvm.stacksave()
%23 = alloca i16, i64 %21
%24 = load i16, i16* %2
%25 = zext i16 %24 to i64
%26 = alloca float, i64 %25
%27 = load i16, i16* %3
%28 = zext i16 %27 to i64
%29 = mul nuw nsw i64 %28, %25
%30 = alloca float, i64 %29
%31 = alloca float, i64 %25
%32 = alloca float, i64 %28
%33 = alloca float, i64 %28
%34 = icmp eq i16 %24, 0
br i1 %34, label %39, label %35
35: ; preds = %13
%36 = getelementptr inbounds i16, i16* %23, i64 1
%37 = bitcast i16* %36 to i8*
%38 = shl nuw nsw i64 %25, 1
br label %39
39: ; preds = %35, %13
%40 = icmp eq i16 %27, 0
br i1 %40, label %41, label %45
41: ; preds = %67, %39
%42 = phi i16 [ 0, %39 ], [ %69, %67 ]
%43 = phi i16 [ %24, %39 ], [ %68, %67 ]
%44 = icmp eq i16 %43, 0
br i1 %44, label %74, label %87
45: ; preds = %39, %67
%46 = phi i16 [ %68, %67 ], [ %24, %39 ]
%47 = phi i16 [ %69, %67 ], [ %27, %39 ]
%48 = phi i16 [ %70, %67 ], [ %24, %39 ]
%49 = phi i64 [ %71, %67 ], [ 0, %39 ]
%50 = getelementptr inbounds float, float* %32, i64 %49
store float 0.000000e+00, float* %50
%51 = getelementptr inbounds float, float* %33, i64 %49
store float 0.000000e+00, float* %51
%52 = icmp eq i16 %48, 0
br i1 %52, label %67, label %53
53: ; preds = %45
%54 = mul nuw nsw i64 %49, %25
%55 = getelementptr inbounds float, float* %30, i64 %54
br label %56
56: ; preds = %53, %56
%57 = phi i64 [ 0, %53 ], [ %61, %56 ]
%58 = getelementptr inbounds float, float* %31, i64 %57
store float 0.000000e+00, float* %58
%59 = getelementptr inbounds float, float* %55, i64 %57
%60 = call i32 (i32*, i8*, ...) @fscanf(i32* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %59)
%61 = add nuw nsw i64 %57, 1
%62 = load i16, i16* %2
%63 = zext i16 %62 to i64
%64 = icmp ult i64 %61, %63
br i1 %64, label %56, label %65
65: ; preds = %56
%66 = load i16, i16* %3
br label %67
67: ; preds = %65, %45
%68 = phi i16 [ %62, %65 ], [ %46, %45 ]
%69 = phi i16 [ %66, %65 ], [ %47, %45 ]
%70 = phi i16 [ %62, %65 ], [ 0, %45 ]
%71 = add nuw nsw i64 %49, 1
%72 = zext i16 %69 to i64
%73 = icmp ult i64 %71, %72
br i1 %73, label %45, label %41
74: ; preds = %176, %41
%75 = phi i16 [ %42, %41 ], [ %181, %176 ]
%76 = phi i16 [ %24, %41 ], [ %177, %176 ]
%77 = phi i16 [ 0, %41 ], [ %178, %176 ]
%78 = icmp eq i16 %75, 0
br i1 %78, label %241, label %79
79: ; preds = %74
%80 = icmp eq i16 %77, 0
%81 = zext i16 %75 to i64
%82 = zext i16 %77 to i64
%83 = and i64 %82, 1
%84 = icmp eq i16 %77, 1
%85 = and i64 %82, 65534
%86 = icmp eq i64 %83, 0
br label %182
87: ; preds = %41, %176
%88 = phi i16 [ %181, %176 ], [ %42, %41 ]
%89 = phi i64 [ %172, %176 ], [ 0, %41 ]
%90 = phi i16 [ %177, %176 ], [ %24, %41 ]
%91 = icmp eq i16 %88, 0
br i1 %91, label %164, label %92
92: ; preds = %87
%93 = getelementptr inbounds float, float* %31, i64 %89
%94 = load float, float* %93
%95 = zext i16 %88 to i64
%96 = getelementptr inbounds float, float* %30, i64 %89
%97 = add nsw i64 %95, -1
%98 = and i64 %95, 3
%99 = icmp ult i64 %97, 3
br i1 %99, label %128, label %100
100: ; preds = %92
%101 = and i64 %95, 65532
br label %102
102: ; preds = %102, %100
%103 = phi i64 [ 0, %100 ], [ %125, %102 ]
%104 = phi float [ %94, %100 ], [ %124, %102 ]
%105 = phi i64 [ 0, %100 ], [ %126, %102 ]
%106 = mul nuw nsw i64 %103, %25
%107 = getelementptr inbounds float, float* %96, i64 %106
%108 = load float, float* %107
%109 = fadd float %108, %104
%110 = or i64 %103, 1
%111 = mul nuw nsw i64 %110, %25
%112 = getelementptr inbounds float, float* %96, i64 %111
%113 = load float, float* %112
%114 = fadd float %113, %109
%115 = or i64 %103, 2
%116 = mul nuw nsw i64 %115, %25
%117 = getelementptr inbounds float, float* %96, i64 %116
%118 = load float, float* %117
%119 = fadd float %118, %114
%120 = or i64 %103, 3
%121 = mul nuw nsw i64 %120, %25
%122 = getelementptr inbounds float, float* %96, i64 %121
%123 = load float, float* %122
%124 = fadd float %123, %119
%125 = add nuw nsw i64 %103, 4
%126 = add i64 %105, 4
%127 = icmp eq i64 %126, %101
br i1 %127, label %128, label %102
128: ; preds = %102, %92
%129 = phi float [ undef, %92 ], [ %124, %102 ]
%130 = phi i64 [ 0, %92 ], [ %125, %102 ]
%131 = phi float [ %94, %92 ], [ %124, %102 ]
%132 = icmp eq i64 %98, 0
br i1 %132, label %144, label %133
133: ; preds = %128, %133
%134 = phi i64 [ %141, %133 ], [ %130, %128 ]
%135 = phi float [ %140, %133 ], [ %131, %128 ]
%136 = phi i64 [ %142, %133 ], [ 0, %128 ]
%137 = mul nuw nsw i64 %134, %25
%138 = getelementptr inbounds float, float* %96, i64 %137
%139 = load float, float* %138
%140 = fadd float %139, %135
%141 = add nuw nsw i64 %134, 1
%142 = add i64 %136, 1
%143 = icmp eq i64 %142, %98
br i1 %143, label %144, label %133
144: ; preds = %133, %128
%145 = phi float [ %129, %128 ], [ %140, %133 ]
store float %145, float* %93
%146 = uitofp i16 %88 to float
%147 = fdiv float %145, %146
br i1 %91, label %164, label %148
148: ; preds = %144
%149 = getelementptr inbounds float, float* %30, i64 %89
br label %150
150: ; preds = %148, %150
%151 = phi i64 [ 0, %148 ], [ %160, %150 ]
%152 = phi float [ 0.000000e+00, %148 ], [ %159, %150 ]
%153 = mul nuw nsw i64 %151, %25
%154 = getelementptr inbounds float, float* %149, i64 %153
%155 = load float, float* %154
%156 = fsub float %147, %155
%157 = call i64 @pow(float %156, i32 2)
%158 = sitofp i64 %157 to float
%159 = fadd float %152, %158
%160 = add nuw nsw i64 %151, 1
%161 = load i16, i16* %3
%162 = zext i16 %161 to i64
%163 = icmp ult i64 %160, %162
br i1 %163, label %150, label %164
164: ; preds = %150, %87, %144
%165 = phi float [ 0.000000e+00, %144 ], [ 0.000000e+00, %87 ], [ %159, %150 ]
%166 = phi i16 [ 0, %144 ], [ 0, %87 ], [ %161, %150 ]
%167 = uitofp i16 %166 to float
%168 = fdiv float %165, %167
%169 = call float @sqrt(float %168)
%170 = load float, float* %5
%171 = fcmp ogt float %169, %170
%172 = add nuw nsw i64 %89, 1
br i1 %171, label %173, label %176
173: ; preds = %164
%174 = getelementptr inbounds i16, i16* %23, i64 %172
store i16 1, i16* %174
%175 = add i16 %90, -1
br label %176
176: ; preds = %164, %173
%177 = phi i16 [ %175, %173 ], [ %90, %164 ]
%178 = load i16, i16* %2
%179 = zext i16 %178 to i64
%180 = icmp ult i64 %172, %179
%181 = load i16, i16* %3
br i1 %180, label %87, label %74
182: ; preds = %79, %238
%183 = phi i64 [ 0, %79 ], [ %239, %238 ]
br i1 %80, label %238, label %184
184: ; preds = %182
%185 = mul nuw nsw i64 %183, %25
%186 = getelementptr inbounds float, float* %30, i64 %185
%187 = getelementptr inbounds float, float* %32, i64 %183
%188 = getelementptr inbounds float, float* %33, i64 %183
%189 = load float, float* %187
%190 = load float, float* %188
br i1 %84, label %218, label %191
191: ; preds = %184, %191
%192 = phi float [ %215, %191 ], [ %190, %184 ]
%193 = phi i64 [ %209, %191 ], [ 0, %184 ]
%194 = phi float [ %208, %191 ], [ %189, %184 ]
%195 = phi i64 [ %216, %191 ], [ 0, %184 ]
%196 = getelementptr inbounds float, float* %186, i64 %193
%197 = load float, float* %196
%198 = fadd float %197, %194
%199 = or i64 %193, 1
%200 = getelementptr inbounds i16, i16* %23, i64 %199
%201 = load i16, i16* %200
%202 = icmp eq i16 %201, 0
%203 = fneg float %197
%204 = select i1 %202, float %197, float %203
%205 = fadd float %192, %204
%206 = getelementptr inbounds float, float* %186, i64 %199
%207 = load float, float* %206
%208 = fadd float %207, %198
%209 = add nuw nsw i64 %193, 2
%210 = getelementptr inbounds i16, i16* %23, i64 %209
%211 = load i16, i16* %210
%212 = icmp eq i16 %211, 0
%213 = fneg float %207
%214 = select i1 %212, float %207, float %213
%215 = fadd float %205, %214
%216 = add i64 %195, 2
%217 = icmp eq i64 %216, %85
br i1 %217, label %218, label %191
218: ; preds = %191, %184
%219 = phi float [ undef, %184 ], [ %208, %191 ]
%220 = phi float [ undef, %184 ], [ %215, %191 ]
%221 = phi float [ %190, %184 ], [ %215, %191 ]
%222 = phi i64 [ 0, %184 ], [ %209, %191 ]
%223 = phi float [ %189, %184 ], [ %208, %191 ]
br i1 %86, label %235, label %224
224: ; preds = %218
%225 = getelementptr inbounds float, float* %186, i64 %222
%226 = load float, float* %225
%227 = fadd float %226, %223
%228 = add nuw nsw i64 %222, 1
%229 = getelementptr inbounds i16, i16* %23, i64 %228
%230 = load i16, i16* %229
%231 = icmp eq i16 %230, 0
%232 = fneg float %226
%233 = select i1 %231, float %226, float %232
%234 = fadd float %221, %233
br label %235
235: ; preds = %218, %224
%236 = phi float [ %219, %218 ], [ %227, %224 ]
%237 = phi float [ %220, %218 ], [ %234, %224 ]
store float %237, float* %188
store float %236, float* %187
br label %238
238: ; preds = %235, %182
%239 = add nuw nsw i64 %183, 1
%240 = icmp eq i64 %239, %81
br i1 %240, label %241, label %182
241: ; preds = %238, %74
%242 = load float, float* %32
%243 = load float, float* %33
%244 = fcmp oeq float %242, %243
%245 = fneg float %243
%246 = fcmp oeq float %242, %245
%247 = or i1 %244, %246
br i1 %247, label %248, label %315
248: ; preds = %241
store i16 0, i16* %23
br i1 %78, label %249, label %252
249: ; preds = %248
%250 = zext i16 %14 to i32
%251 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @.str.4, i64 0, i64 0), i32 %250, double 0.000000e+00)
br label %491
252: ; preds = %248
%253 = uitofp i16 %77 to float
%254 = zext i16 %75 to i64
%255 = fdiv float %242, %253
store float %255, float* %26
%256 = icmp eq i16 %75, 1
br i1 %256, label %400, label %257
257: ; preds = %252
%258 = add nsw i64 %254, -1
%259 = icmp ult i64 %258, 4
br i1 %259, label %305, label %260
260: ; preds = %257
%261 = and i64 %258, -4
%262 = or i64 %261, 1
%263 = insertelement <4 x float> poison, float %253, i64 0
%264 = shufflevector <4 x float> %263, <4 x float> poison, <4 x i32> zeroinitializer
%265 = add nsw i64 %261, -4
%266 = lshr exact i64 %265, 2
%267 = add nuw nsw i64 %266, 1
%268 = and i64 %267, 1
%269 = icmp eq i64 %265, 0
br i1 %269, label %292, label %270
270: ; preds = %260
%271 = and i64 %267, 9223372036854775806
br label %272
272: ; preds = %272, %270
%273 = phi i64 [ 0, %270 ], [ %289, %272 ]
%274 = phi i64 [ 0, %270 ], [ %290, %272 ]
%275 = or i64 %273, 1
%276 = getelementptr inbounds float, float* %32, i64 %275
%277 = bitcast float* %276 to <4 x float>*
%278 = load <4 x float>, <4 x float>* %277
%279 = fdiv <4 x float> %278, %264
%280 = getelementptr inbounds float, float* %26, i64 %275
%281 = bitcast float* %280 to <4 x float>*
store <4 x float> %279, <4 x float>* %281
%282 = or i64 %273, 5
%283 = getelementptr inbounds float, float* %32, i64 %282
%284 = bitcast float* %283 to <4 x float>*
%285 = load <4 x float>, <4 x float>* %284
%286 = fdiv <4 x float> %285, %264
%287 = getelementptr inbounds float, float* %26, i64 %282
%288 = bitcast float* %287 to <4 x float>*
store <4 x float> %286, <4 x float>* %288
%289 = add nuw i64 %273, 8
%290 = add i64 %274, 2
%291 = icmp eq i64 %290, %271
br i1 %291, label %292, label %272
292: ; preds = %272, %260
%293 = phi i64 [ 0, %260 ], [ %289, %272 ]
%294 = icmp eq i64 %268, 0
br i1 %294, label %303, label %295
295: ; preds = %292
%296 = or i64 %293, 1
%297 = getelementptr inbounds float, float* %32, i64 %296
%298 = bitcast float* %297 to <4 x float>*
%299 = load <4 x float>, <4 x float>* %298
%300 = fdiv <4 x float> %299, %264
%301 = getelementptr inbounds float, float* %26, i64 %296
%302 = bitcast float* %301 to <4 x float>*
store <4 x float> %300, <4 x float>* %302
br label %303
303: ; preds = %292, %295
%304 = icmp eq i64 %258, %261
br i1 %304, label %400, label %305
305: ; preds = %257, %303
%306 = phi i64 [ 1, %257 ], [ %262, %303 ]
br label %307
307: ; preds = %305, %307
%308 = phi i64 [ %313, %307 ], [ %306, %305 ]
%309 = getelementptr inbounds float, float* %32, i64 %308
%310 = load float, float* %309
%311 = fdiv float %310, %253
%312 = getelementptr inbounds float, float* %26, i64 %308
store float %311, float* %312
%313 = add nuw nsw i64 %308, 1
%314 = icmp eq i64 %313, %254
br i1 %314, label %400, label %307
315: ; preds = %241
store i16 1, i16* %23
br i1 %78, label %397, label %316
316: ; preds = %315
%317 = zext i16 %76 to i32
%318 = shl nuw nsw i32 %317, 1
%319 = sitofp i32 %318 to float
%320 = zext i16 %75 to i64
%321 = fadd float %242, %243
%322 = fdiv float %321, %319
store float %322, float* %26
%323 = icmp eq i16 %75, 1
br i1 %323, label %400, label %324
324: ; preds = %316
%325 = add nsw i64 %320, -1
%326 = icmp ult i64 %325, 4
br i1 %326, label %384, label %327
327: ; preds = %324
%328 = and i64 %325, -4
%329 = or i64 %328, 1
%330 = insertelement <4 x float> poison, float %319, i64 0
%331 = shufflevector <4 x float> %330, <4 x float> poison, <4 x i32> zeroinitializer
%332 = add nsw i64 %328, -4
%333 = lshr exact i64 %332, 2
%334 = add nuw nsw i64 %333, 1
%335 = and i64 %334, 1
%336 = icmp eq i64 %332, 0
br i1 %336, label %367, label %337
337: ; preds = %327
%338 = and i64 %334, 9223372036854775806
br label %339
339: ; preds = %339, %337
%340 = phi i64 [ 0, %337 ], [ %364, %339 ]
%341 = phi i64 [ 0, %337 ], [ %365, %339 ]
%342 = or i64 %340, 1
%343 = getelementptr inbounds float, float* %32, i64 %342
%344 = bitcast float* %343 to <4 x float>*
%345 = load <4 x float>, <4 x float>* %344
%346 = getelementptr inbounds float, float* %33, i64 %342
%347 = bitcast float* %346 to <4 x float>*
%348 = load <4 x float>, <4 x float>* %347
%349 = fadd <4 x float> %345, %348
%350 = fdiv <4 x float> %349, %331
%351 = getelementptr inbounds float, float* %26, i64 %342
%352 = bitcast float* %351 to <4 x float>*
store <4 x float> %350, <4 x float>* %352
%353 = or i64 %340, 5
%354 = getelementptr inbounds float, float* %32, i64 %353
%355 = bitcast float* %354 to <4 x float>*
%356 = load <4 x float>, <4 x float>* %355
%357 = getelementptr inbounds float, float* %33, i64 %353
%358 = bitcast float* %357 to <4 x float>*
%359 = load <4 x float>, <4 x float>* %358
%360 = fadd <4 x float> %356, %359
%361 = fdiv <4 x float> %360, %331
%362 = getelementptr inbounds float, float* %26, i64 %353
%363 = bitcast float* %362 to <4 x float>*
store <4 x float> %361, <4 x float>* %363
%364 = add nuw i64 %340, 8
%365 = add i64 %341, 2
%366 = icmp eq i64 %365, %338
br i1 %366, label %367, label %339
367: ; preds = %339, %327
%368 = phi i64 [ 0, %327 ], [ %364, %339 ]
%369 = icmp eq i64 %335, 0
br i1 %369, label %382, label %370
370: ; preds = %367
%371 = or i64 %368, 1
%372 = getelementptr inbounds float, float* %32, i64 %371
%373 = bitcast float* %372 to <4 x float>*
%374 = load <4 x float>, <4 x float>* %373
%375 = getelementptr inbounds float, float* %33, i64 %371
%376 = bitcast float* %375 to <4 x float>*
%377 = load <4 x float>, <4 x float>* %376
%378 = fadd <4 x float> %374, %377
%379 = fdiv <4 x float> %378, %331
%380 = getelementptr inbounds float, float* %26, i64 %371
%381 = bitcast float* %380 to <4 x float>*
store <4 x float> %379, <4 x float>* %381
br label %382
382: ; preds = %367, %370
%383 = icmp eq i64 %325, %328
br i1 %383, label %400, label %384
384: ; preds = %324, %382
%385 = phi i64 [ 1, %324 ], [ %329, %382 ]
br label %386
386: ; preds = %384, %386
%387 = phi i64 [ %395, %386 ], [ %385, %384 ]
%388 = getelementptr inbounds float, float* %32, i64 %387
%389 = load float, float* %388
%390 = getelementptr inbounds float, float* %33, i64 %387
%391 = load float, float* %390
%392 = fadd float %389, %391
%393 = fdiv float %392, %319
%394 = getelementptr inbounds float, float* %26, i64 %387
store float %393, float* %394
%395 = add nuw nsw i64 %387, 1
%396 = icmp eq i64 %395, %320
br i1 %396, label %400, label %386
397: ; preds = %315
%398 = zext i16 %14 to i32
%399 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @.str.4, i64 0, i64 0), i32 %398, double 0.000000e+00)
br label %470
400: ; preds = %386, %307, %316, %382, %252, %303
br i1 %78, label %464, label %401
401: ; preds = %400
%402 = zext i16 %75 to i64
%403 = add nsw i64 %402, -1
%404 = and i64 %402, 3
%405 = icmp ult i64 %403, 3
br i1 %405, label %443, label %406
406: ; preds = %401
%407 = and i64 %402, 65532
br label %408
408: ; preds = %408, %406
%409 = phi i64 [ 0, %406 ], [ %437, %408 ]
%410 = phi i16 [ %14, %406 ], [ %440, %408 ]
%411 = phi float [ 0.000000e+00, %406 ], [ %438, %408 ]
%412 = phi i64 [ 0, %406 ], [ %441, %408 ]
%413 = getelementptr inbounds float, float* %26, i64 %409
%414 = load float, float* %413
%415 = fcmp ogt float %414, %411
%416 = or i64 %409, 1
%417 = select i1 %415, float %414, float %411
%418 = trunc i64 %416 to i16
%419 = select i1 %415, i16 %418, i16 %410
%420 = getelementptr inbounds float, float* %26, i64 %416
%421 = load float, float* %420
%422 = fcmp ogt float %421, %417
%423 = or i64 %409, 2
%424 = select i1 %422, float %421, float %417
%425 = trunc i64 %423 to i16
%426 = select i1 %422, i16 %425, i16 %419
%427 = getelementptr inbounds float, float* %26, i64 %423
%428 = load float, float* %427
%429 = fcmp ogt float %428, %424
%430 = or i64 %409, 3
%431 = select i1 %429, float %428, float %424
%432 = trunc i64 %430 to i16
%433 = select i1 %429, i16 %432, i16 %426
%434 = getelementptr inbounds float, float* %26, i64 %430
%435 = load float, float* %434
%436 = fcmp ogt float %435, %431
%437 = add nuw nsw i64 %409, 4
%438 = select i1 %436, float %435, float %431
%439 = trunc i64 %437 to i16
%440 = select i1 %436, i16 %439, i16 %433
%441 = add i64 %412, 4
%442 = icmp eq i64 %441, %407
br i1 %442, label %443, label %408
443: ; preds = %408, %401
%444 = phi float [ undef, %401 ], [ %438, %408 ]
%445 = phi i16 [ undef, %401 ], [ %440, %408 ]
%446 = phi i64 [ 0, %401 ], [ %437, %408 ]
%447 = phi i16 [ %14, %401 ], [ %440, %408 ]
%448 = phi float [ 0.000000e+00, %401 ], [ %438, %408 ]
%449 = icmp eq i64 %404, 0
br i1 %449, label %464, label %450
450: ; preds = %443, %450
%451 = phi i64 [ %458, %450 ], [ %446, %443 ]
%452 = phi i16 [ %461, %450 ], [ %447, %443 ]
%453 = phi float [ %459, %450 ], [ %448, %443 ]
%454 = phi i64 [ %462, %450 ], [ 0, %443 ]
%455 = getelementptr inbounds float, float* %26, i64 %451
%456 = load float, float* %455
%457 = fcmp ogt float %456, %453
%458 = add nuw nsw i64 %451, 1
%459 = select i1 %457, float %456, float %453
%460 = trunc i64 %458 to i16
%461 = select i1 %457, i16 %460, i16 %452
%462 = add i64 %454, 1
%463 = icmp eq i64 %462, %404
br i1 %463, label %464, label %450
464: ; preds = %443, %450, %400
%465 = phi float [ 0.000000e+00, %400 ], [ %444, %443 ], [ %459, %450 ]
%466 = phi i16 [ %14, %400 ], [ %445, %443 ], [ %461, %450 ]
%467 = zext i16 %466 to i32
%468 = fpext float %465 to double
%469 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @.str.4, i64 0, i64 0), i32 %467, double %468)
br i1 %247, label %491, label %470
470: ; preds = %397, %464
%471 = phi i16 [ %14, %397 ], [ %466, %464 ]
%472 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.5, i64 0, i64 0))
%473 = load i16, i16* %2
%474 = icmp eq i16 %473, 0
br i1 %474, label %491, label %475
475: ; preds = %470, %486
%476 = phi i16 [ %487, %486 ], [ %473, %470 ]
%477 = phi i32 [ %489, %486 ], [ 1, %470 ]
%478 = trunc i32 %477 to i16
%479 = zext i32 %477 to i64
%480 = getelementptr inbounds i16, i16* %23, i64 %479
%481 = load i16, i16* %480
%482 = icmp eq i16 %481, 0
br i1 %482, label %486, label %483
483: ; preds = %475
%484 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i32 %477)
%485 = load i16, i16* %2
br label %486
486: ; preds = %475, %483
%487 = phi i16 [ %476, %475 ], [ %485, %483 ]
%488 = add i16 %478, 1
%489 = zext i16 %488 to i32
%490 = icmp ugt i16 %488, %487
br i1 %490, label %491, label %475
491: ; preds = %486, %464, %249, %470
%492 = phi i8* [ getelementptr inbounds ([2 x i8], [2 x i8]* @str.9, i64 0, i64 0), %470 ], [ getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0), %249 ], [ getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0), %464 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @str.9, i64 0, i64 0), %486 ]
%493 = phi i16 [ %471, %470 ], [ %14, %249 ], [ %466, %464 ], [ %471, %486 ]
%494 = call i32 @puts(i8* dereferenceable(1) %492)
%495 = add i16 %15, 1
%496 = load i16, i16* %4
%497 = icmp ugt i16 %495, %496
br i1 %497, label %498, label %13
498: ; preds = %491, %1
ret void
}