#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*/ errno;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char const *, char *);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
scalar_t__ pow(float, int);
int /*<<< orphan*/ printf(char *, ...);
float sqrt(float);
char *strerror(int /*<<< orphan*/);
int main() {
  const char *fLocation = "ucfidol2.txt";
  FILE *ifp = fopen(fLocation, "r");
  if (ifp == NULL) {
    printf("Error opening \"%s\": %s\n", fLocation, strerror(errno));
    return 1;
  }
  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");
  }
  fclose(ifp);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe7b(%rip),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xe79(%rip),%rsi
call   1060 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    11e9 <main+0x79>
mov    -0x10(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    0x2e22(%rip),%rax
mov    (%rax),%edi
call   1090 <strerror@plt>
mov    -0x88(%rbp),%rsi
mov    %rax,%rdx
lea    0xe3d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1a1c <main+0x8ac>
movw   $0x3,-0x1a(%rbp)
movw   $0x2,-0x1c(%rbp)
movw   $0x2,-0x1e(%rbp)
movw   $0x1,-0x20(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xdef(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
lea    0xe0a(%rip),%rsi
lea    -0x1e(%rbp),%rdx
mov    $0x0,%al
call   1050 <fscanf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movw   $0x1,-0x2a(%rbp)
movzwl -0x2a(%rbp),%eax
movzwl -0x1e(%rbp),%ecx
cmp    %ecx,%eax
jg     1a0c <main+0x89c>
movzwl -0x2a(%rbp),%esi
lea    0xdda(%rip),%rdi
xor    %eax,%eax
mov    %al,-0xc9(%rbp)
call   1040 <printf@plt>
mov    -0xc9(%rbp),%al
mov    -0x18(%rbp),%rdi
lea    0xdd0(%rip),%rsi
lea    -0x1c(%rbp),%rdx
lea    -0x1a(%rbp),%rcx
lea    -0x28(%rbp),%r8
call   1050 <fscanf@plt>
movzwl -0x1a(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %rsp,%rcx
mov    %rcx,-0x40(%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,-0xc8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
mov    -0x1a(%rbp),%ax
mov    %ax,-0x30(%rbp)
movzwl -0x1a(%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,-0xc0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
movzwl -0x1c(%rbp),%eax
mov    %eax,%ecx
movzwl -0x1a(%rbp),%eax
mov    %rax,-0xb8(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xb0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x58(%rbp)
mov    %rax,-0x60(%rbp)
movzwl -0x1a(%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,-0x68(%rbp)
movzwl -0x1a(%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,-0xa0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
movzwl -0x1c(%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,-0x98(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x78(%rbp)
movzwl -0x1c(%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,-0x80(%rbp)
movw   $0x0,-0x2c(%rbp)
movzwl -0x2c(%rbp),%eax
movzwl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jge    141c <main+0x2ac>
mov    -0xa8(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movzwl -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movw   $0x0,(%rcx,%rdx,2)
movzwl -0x2c(%rbp),%ecx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    13d1 <main+0x261>
movw   $0x0,-0x2c(%rbp)
movzwl -0x2c(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    14e2 <main+0x372>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzwl -0x2c(%rbp),%edx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rcx,%rdx,4)
movzwl -0x2c(%rbp),%ecx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movw   $0x0,-0x2e(%rbp)
movzwl -0x2e(%rbp),%eax
movzwl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jge    14cc <main+0x35c>
mov    -0xb0(%rbp),%rdx
mov    -0xb8(%rbp),%rcx
mov    -0xa0(%rbp),%rax
movzwl -0x2e(%rbp),%esi
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rsi,4)
mov    -0x18(%rbp),%rdi
movzwl -0x2c(%rbp),%eax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rdx
movzwl -0x2e(%rbp),%eax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xb95(%rip),%rsi
mov    $0x0,%al
call   1050 <fscanf@plt>
mov    -0x2e(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2e(%rbp)
jmp    145e <main+0x2ee>
jmp    14d1 <main+0x361>
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    1422 <main+0x2b2>
movw   $0x0,-0x2c(%rbp)
movzwl -0x2c(%rbp),%eax
movzwl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jge    1676 <main+0x506>
movw   $0x0,-0x2e(%rbp)
movzwl -0x2e(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    155a <main+0x3ea>
mov    -0xa0(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    -0xb8(%rbp),%rsi
movzwl -0x2e(%rbp),%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movzwl -0x2c(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
movzwl -0x2c(%rbp),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2e(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2e(%rbp)
jmp    14fe <main+0x38e>
mov    -0xa8(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movzwl -0x2c(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
movzwl -0x1c(%rbp),%ecx
cvtsi2ss %ecx,%xmm1
divss  %xmm1,%xmm0
movzwl -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movw   $0x0,-0x2e(%rbp)
movzwl -0x2e(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    15fc <main+0x48c>
mov    -0xb0(%rbp),%rax
mov    -0xb8(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
movzwl -0x2c(%rbp),%esi
movss  (%rcx,%rsi,4),%xmm0
movzwl -0x2e(%rbp),%ecx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movzwl -0x2c(%rbp),%ecx
subss  (%rax,%rcx,4),%xmm0
mov    $0x2,%edi
call   1070 <pow@plt>
cvtsi2ss %rax,%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x2e(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2e(%rbp)
jmp    158c <main+0x41c>
movss  -0x34(%rbp),%xmm0
movzwl -0x1c(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
call   1080 <sqrt@plt>
mov    -0xa8(%rbp),%rax
movzwl -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movzwl -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x28(%rbp),%xmm0
jbe    1660 <main+0x4f0>
mov    -0xc8(%rbp),%rax
movzwl -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movw   $0x1,(%rax,%rcx,2)
mov    -0x30(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x30(%rbp)
jmp    1665 <main+0x4f5>
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    14e8 <main+0x378>
movw   $0x0,-0x2c(%rbp)
movzwl -0x2c(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    17a4 <main+0x634>
movw   $0x0,-0x2e(%rbp)
movzwl -0x2e(%rbp),%eax
movzwl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jge    178e <main+0x61e>
mov    -0xc8(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    -0xb0(%rbp),%rdx
mov    -0xb8(%rbp),%rdi
movzwl -0x2c(%rbp),%esi
imul   %rdi,%rsi
shl    $0x2,%rsi
add    %rsi,%rdx
movzwl -0x2e(%rbp),%esi
movss  (%rdx,%rsi,4),%xmm0
movzwl -0x2c(%rbp),%edx
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
movzwl -0x2e(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpw   $0x0,(%rax,%rcx,2)
je     173d <main+0x5cd>
mov    -0x90(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    -0xb8(%rbp),%rsi
movzwl -0x2c(%rbp),%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movzwl -0x2e(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm1
movzwl -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1778 <main+0x608>
mov    -0x90(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    -0xb8(%rbp),%rsi
movzwl -0x2c(%rbp),%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movzwl -0x2e(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
movzwl -0x2c(%rbp),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    177d <main+0x60d>
mov    -0x2e(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2e(%rbp)
jmp    1692 <main+0x522>
jmp    1793 <main+0x623>
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    167c <main+0x50c>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rcx
movss  (%rcx),%xmm0
ucomiss (%rax),%xmm0
jne    17ca <main+0x65a>
jp     17ca <main+0x65a>
jmp    17fc <main+0x68c>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rcx
movss  (%rcx),%xmm0
movss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
ucomiss %xmm1,%xmm0
jne    1860 <main+0x6f0>
jp     1860 <main+0x6f0>
mov    -0xc8(%rbp),%rax
movw   $0x0,(%rax)
movw   $0x0,-0x2c(%rbp)
movzwl -0x2c(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    185b <main+0x6eb>
mov    -0xc0(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzwl -0x2c(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
movzwl -0x1a(%rbp),%ecx
cvtsi2ss %ecx,%xmm1
divss  %xmm1,%xmm0
movzwl -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    180e <main+0x69e>
jmp    18d7 <main+0x767>
mov    -0xc8(%rbp),%rax
movw   $0x1,(%rax)
movw   $0x0,-0x2c(%rbp)
movzwl -0x2c(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    18d2 <main+0x762>
mov    -0xc0(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x98(%rbp),%rdx
movzwl -0x2c(%rbp),%esi
movss  (%rdx,%rsi,4),%xmm0
movzwl -0x2c(%rbp),%edx
addss  (%rcx,%rdx,4),%xmm0
movzwl -0x30(%rbp),%ecx
shl    $0x1,%ecx
cvtsi2ss %ecx,%xmm1
divss  %xmm1,%xmm0
movzwl -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    1872 <main+0x702>
jmp    18d7 <main+0x767>
movw   $0x0,-0x2c(%rbp)
movzwl -0x2c(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    193d <main+0x7cd>
mov    -0xc0(%rbp),%rax
movzwl -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    1927 <main+0x7b7>
mov    -0xc0(%rbp),%rax
movzwl -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movzwl -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %ax,-0x20(%rbp)
jmp    192c <main+0x7bc>
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    18dd <main+0x76d>
movzwl -0x20(%rbp),%esi
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x6fb(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xc8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
cmpw   $0x0,(%rax)
je     19e6 <main+0x876>
lea    0x70d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movw   $0x1,-0x2c(%rbp)
movzwl -0x2c(%rbp),%eax
movzwl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jg     19d3 <main+0x863>
mov    -0xc8(%rbp),%rax
movzwl -0x2c(%rbp),%ecx
cmpw   $0x0,(%rax,%rcx,2)
je     19bd <main+0x84d>
movzwl -0x2c(%rbp),%esi
lea    0x700(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    19c2 <main+0x852>
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    1985 <main+0x815>
lea    0x700(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    19f4 <main+0x884>
lea    0x6ce(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x40(%rbp),%rax
mov    %rax,%rsp
mov    -0x2a(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2a(%rbp)
jmp    123a <main+0xca>
mov    -0x18(%rbp),%rdi
call   1030 <fclose@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
lea    0xe69(%rip),%rdi
lea    0xe6f(%rip),%rsi
call   1080 <fopen@plt>
test   %rax,%rax
je     1b41 <main+0x9b1>
mov    %rax,%r15
movw   $0x3,-0x2a(%rbp)
movw   $0x2,-0x2c(%rbp)
movw   $0x2,-0x2e(%rbp)
movl   $0x40c00000,-0x5c(%rbp)
lea    0xe58(%rip),%rsi
lea    -0x2e(%rbp),%rdx
mov    %rax,%rdi
xor    %eax,%eax
call   1070 <fscanf@plt>
cmpw   $0x0,-0x2e(%rbp)
je     1b35 <main+0x9a5>
mov    $0x1,%ax
mov    %eax,-0x34(%rbp)
mov    $0x1,%ax
mov    %r15,-0x50(%rbp)
jmp    1236 <main+0xa6>
nopl   (%rax)
lea    0xed3(%rip),%rdi
call   1030 <puts@plt>
mov    -0xb8(%rbp),%rsp
mov    -0x94(%rbp),%eax
add    $0x1,%eax
cmp    -0x2e(%rbp),%ax
ja     1b35 <main+0x9a5>
mov    %eax,-0x94(%rbp)
movzwl %ax,%esi
lea    0xdf9(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r15,%rdi
lea    0xdfc(%rip),%rsi
lea    -0x2c(%rbp),%rdx
lea    -0x2a(%rbp),%rcx
lea    -0x5c(%rbp),%r8
xor    %eax,%eax
call   1070 <fscanf@plt>
mov    %rsp,-0xb8(%rbp)
movzwl -0x2a(%rbp),%eax
add    %eax,%eax
add    $0x11,%eax
and    $0xfffffff0,%eax
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
movzwl -0x2a(%rbp),%r15d
lea    0xf(,%r15,4),%eax
and    $0xfffffff0,%eax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
movzwl -0x2c(%rbp),%r11d
mov    %r11,%rcx
imul   %r15,%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,%rbx
sub    %rax,%rbx
mov    %rbx,%rsp
test   %r15d,%r15d
mov    %rsi,-0x78(%rbp)
je     1311 <main+0x181>
lea    0x2(%r12),%rdi
lea    (%r15,%r15,1),%rdx
xor    %esi,%esi
mov    %r11,%r14
call   1060 <memset@plt>
mov    -0x78(%rbp),%rsi
mov    %r14,%r11
test   %r11w,%r11w
mov    %r13,-0xa8(%rbp)
mov    %rbx,-0x58(%rbp)
mov    %r15,-0x70(%rbp)
je     1410 <main+0x280>
lea    0x0(,%r15,4),%rax
mov    %rax,-0x88(%rbp)
mov    -0x68(%rbp),%rdi
mov    %r15d,%eax
mov    %r15d,%ecx
xor    %r14d,%r14d
movaps 0xcb3(%rip),%xmm6
mov    %r12,-0xc0(%rbp)
jmp    137a <main+0x1ea>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
add    $0x1,%r14
movzwl %r11w,%edx
add    -0x88(%rbp),%rdi
cmp    %rdx,%r14
jae    141d <main+0x28d>
movl   $0x0,0x0(%r13,%r14,4)
mov    -0x58(%rbp),%rdx
movl   $0x0,(%rdx,%r14,4)
test   %cx,%cx
je     1360 <main+0x1d0>
mov    %rdi,-0x90(%rbp)
mov    %rdi,%r15
xor    %ebx,%ebx
mov    -0x50(%rbp),%r12
lea    0xcae(%rip),%r13
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rsi,%rbx,4)
mov    %r12,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1070 <fscanf@plt>
mov    -0x78(%rbp),%rsi
add    $0x1,%rbx
movzwl -0x2a(%rbp),%eax
add    $0x4,%r15
cmp    %rax,%rbx
jb     13b0 <main+0x220>
movzwl -0x2c(%rbp),%r11d
mov    %eax,%ecx
movaps 0xc16(%rip),%xmm6
mov    -0xc0(%rbp),%r12
mov    -0xa8(%rbp),%r13
mov    -0x70(%rbp),%r15
mov    -0x90(%rbp),%rdi
jmp    1362 <main+0x1d2>
nopl   0x0(%rax,%rax,1)
xor    %r11d,%r11d
mov    %r15d,%eax
movaps 0xbe3(%rip),%xmm6
test   %ax,%ax
je     15f0 <main+0x460>
mov    %r15,%r14
shl    $0x4,%r14
lea    0x0(,%r15,4),%rbx
lea    (%rbx,%rbx,2),%r9
mov    -0x68(%rbp),%r10
xor    %edx,%edx
mov    %r15d,%eax
mov    %eax,-0x44(%rbp)
mov    %r9,-0xa0(%rbp)
jmp    1466 <main+0x2d6>
xchg   %ax,%ax
movzwl -0x2a(%rbp),%ecx
movzwl -0x2c(%rbp),%r11d
add    $0x4,%r10
cmp    %rcx,%rdx
jae    15f8 <main+0x468>
xorps  %xmm0,%xmm0
test   %r11w,%r11w
mov    %rdx,-0x80(%rbp)
mov    %r10,-0xb0(%rbp)
je     1590 <main+0x400>
movss  (%rsi,%rdx,4),%xmm1
movzwl %r11w,%r8d
lea    -0x1(%r8),%rdx
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    14a0 <main+0x310>
xor    %edx,%edx
jmp    14d2 <main+0x342>
nopl   0x0(%rax,%rax,1)
mov    %r8d,%eax
and    $0xfffffffc,%eax
mov    %r10,%rdi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
addss  (%rdi),%xmm1
addss  (%rdi,%r15,4),%xmm1
addss  (%rdi,%r15,8),%xmm1
addss  (%rdi,%r9,1),%xmm1
add    $0x4,%rdx
add    %r14,%rdi
cmp    %rdx,%rax
jne    14b0 <main+0x320>
test   %rcx,%rcx
je     14ed <main+0x35d>
imul   %r15,%rdx
lea    (%r10,%rdx,4),%rdx
nop
addss  (%rdx),%xmm1
add    %rbx,%rdx
add    $0xffffffffffffffff,%rcx
jne    14e0 <main+0x350>
mov    -0x80(%rbp),%rdx
movss  %xmm1,(%rsi,%rdx,4)
test   %r11w,%r11w
je     1590 <main+0x400>
xorps  %xmm0,%xmm0
cvtsi2ss %r8d,%xmm0
divss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
mov    %r10,%r15
xor    %r13d,%r13d
movss  %xmm1,-0x88(%rbp)
ff
nopl   (%rax)
movss  %xmm0,-0x90(%rbp)
ff
movaps %xmm1,%xmm0
subss  (%r15),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
movss  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
addss  %xmm1,%xmm0
movss  -0x88(%rbp),%xmm1
ff
add    $0x1,%r13
movzwl -0x2c(%rbp),%eax
add    %rbx,%r15
cmp    %rax,%r13
jb     1520 <main+0x390>
movaps 0xa93(%rip),%xmm6
mov    -0xa8(%rbp),%r13
mov    -0x70(%rbp),%r15
mov    -0x78(%rbp),%rsi
mov    -0xa0(%rbp),%r9
mov    -0x80(%rbp),%rdx
jmp    1592 <main+0x402>
nopl   0x0(%rax)
xor    %eax,%eax
movzwl %ax,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
ucomiss 0xa69(%rip),%xmm0
jb     15b0 <main+0x420>
sqrtss %xmm0,%xmm0
jmp    15cb <main+0x43b>
nop
call   10a0 <sqrt@plt>
mov    -0x80(%rbp),%rdx
mov    -0xa0(%rbp),%r9
mov    -0x78(%rbp),%rsi
movaps 0xa35(%rip),%xmm6
mov    -0xb0(%rbp),%r10
add    $0x1,%rdx
ucomiss -0x5c(%rbp),%xmm0
jbe    1450 <main+0x2c0>
movw   $0x1,(%r12,%rdx,2)
addl   $0xffffffff,-0x44(%rbp)
jmp    1450 <main+0x2c0>
xor    %ecx,%ecx
mov    %r15d,%eax
mov    %eax,-0x44(%rbp)
mov    -0x58(%rbp),%r14
movzwl %r11w,%r8d
test   %r11w,%r11w
je     1700 <main+0x570>
movzwl %cx,%r9d
mov    %r9d,%esi
and    $0xfffffffe,%esi
mov    -0x68(%rbp),%rax
lea    0x4(%rax),%rdi
mov    -0x70(%rbp),%rax
lea    0x0(,%rax,4),%r10
xor    %eax,%eax
jmp    1655 <main+0x4c5>
nopl   0x0(%rax)
addss  %xmm3,%xmm1
addss  %xmm2,%xmm0
movss  %xmm1,(%r14,%rax,4)
movss  %xmm0,0x0(%r13,%rax,4)
add    $0x1,%rax
add    %r10,%rdi
cmp    %r8,%rax
je     1700 <main+0x570>
test   %cx,%cx
je     1645 <main+0x4b5>
movss  0x0(%r13,%rax,4),%xmm0
movss  (%r14,%rax,4),%xmm1
cmp    $0x1,%cx
jne    16a0 <main+0x510>
xor    %ebx,%ebx
test   $0x1,%r9b
je     1638 <main+0x4a8>
mov    %rax,%rdx
imul   -0x70(%rbp),%rdx
mov    -0x68(%rbp),%r15
lea    (%r15,%rdx,4),%rdx
movss  (%rdx,%rbx,4),%xmm2
cmpw   $0x0,0x2(%r12,%rbx,2)
movaps %xmm2,%xmm3
je     1630 <main+0x4a0>
movaps %xmm2,%xmm3
xorps  %xmm6,%xmm3
jmp    1630 <main+0x4a0>
xchg   %ax,%ax
xor    %edx,%edx
jmp    16c8 <main+0x538>
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     166f <main+0x4df>
movss  -0x4(%rdi,%rdx,4),%xmm2
cmpw   $0x0,0x2(%r12,%rdx,2)
movaps %xmm2,%xmm3
je     16e0 <main+0x550>
movaps %xmm2,%xmm3
xorps  %xmm6,%xmm3
movss  (%rdi,%rdx,4),%xmm4
lea    0x2(%rdx),%rbx
cmpw   $0x0,0x4(%r12,%rdx,2)
movaps %xmm4,%xmm5
je     16b0 <main+0x520>
movaps %xmm4,%xmm5
xorps  %xmm6,%xmm5
jmp    16b0 <main+0x520>
nopl   (%rax)
movss  0x0(%r13),%xmm1
movss  (%r14),%xmm2
ucomiss %xmm2,%xmm1
setnp  %al
sete   %dl
and    %al,%dl
movaps %xmm2,%xmm0
xorps  %xmm6,%xmm0
ucomiss %xmm1,%xmm0
setnp  %al
sete   %r14b
and    %al,%r14b
or     %dl,%r14b
cmp    $0x1,%r14b
jne    1840 <main+0x6b0>
movw   $0x0,(%r12)
test   %r11w,%r11w
je     1a7b <main+0x8eb>
movzwl %cx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  %xmm0,%xmm1
mov    -0x40(%rbp),%rax
movss  %xmm1,(%rax)
cmp    $0x1,%r11w
mov    -0x34(%rbp),%ebx
je     1970 <main+0x7e0>
lea    -0x1(%r8),%r9
mov    $0x1,%eax
cmp    $0x4,%r9
jb     1811 <main+0x681>
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     1b14 <main+0x984>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
mov    -0x40(%rbp),%rcx
nopw   0x0(%rax,%rax,1)
movups 0x4(%r13,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,0x4(%rcx,%rsi,4)
movups 0x14(%r13,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,0x14(%rcx,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    17c0 <main+0x630>
test   $0x1,%dl
je     1804 <main+0x674>
shl    $0x2,%rsi
or     $0x4,%rsi
movups 0x0(%r13,%rsi,1),%xmm2
divps  %xmm1,%xmm2
mov    -0x40(%rbp),%rcx
movups %xmm2,(%rcx,%rsi,1)
cmp    %rax,%r9
je     1970 <main+0x7e0>
or     $0x1,%rax
mov    -0x40(%rbp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%r13,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r8
jne    1820 <main+0x690>
jmp    1970 <main+0x7e0>
xchg   %ax,%ax
movw   $0x1,(%r12)
test   %r11w,%r11w
je     1aa0 <main+0x910>
movzwl -0x44(%rbp),%eax
add    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm2,%xmm1
divss  %xmm0,%xmm1
mov    -0x40(%rbp),%rax
movss  %xmm1,(%rax)
cmp    $0x1,%r11w
mov    -0x34(%rbp),%ebx
je     1970 <main+0x7e0>
lea    -0x1(%r8),%r9
mov    $0x1,%eax
cmp    $0x4,%r9
jb     1939 <main+0x7a9>
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     1b24 <main+0x994>
mov    %r10,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
xor    %edx,%edx
mov    -0x40(%rbp),%rcx
mov    -0x58(%rbp),%rsi
nop
movups 0x4(%r13,%rdx,4),%xmm2
movups 0x4(%rsi,%rdx,4),%xmm3
addps  %xmm2,%xmm3
divps  %xmm1,%xmm3
movups %xmm3,0x4(%rcx,%rdx,4)
movups 0x14(%r13,%rdx,4),%xmm2
movups 0x14(%rsi,%rdx,4),%xmm3
addps  %xmm2,%xmm3
divps  %xmm1,%xmm3
movups %xmm3,0x14(%rcx,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    18d0 <main+0x740>
test   $0x1,%r10b
je     1930 <main+0x7a0>
shl    $0x2,%rdx
or     $0x4,%rdx
movups 0x0(%r13,%rdx,1),%xmm2
mov    -0x58(%rbp),%rcx
movups (%rcx,%rdx,1),%xmm3
addps  %xmm2,%xmm3
divps  %xmm1,%xmm3
mov    -0x40(%rbp),%rcx
movups %xmm3,(%rcx,%rdx,1)
cmp    %rax,%r9
je     1970 <main+0x7e0>
or     $0x1,%rax
mov    -0x40(%rbp),%rcx
mov    -0x58(%rbp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%rax,4),%xmm1
addss  (%rdx,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r8
jne    1950 <main+0x7c0>
xchg   %ax,%ax
test   %r11w,%r11w
je     19a0 <main+0x810>
lea    -0x1(%r8),%rax
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    19ac <main+0x81c>
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    -0x50(%rbp),%r15
jmp    1a13 <main+0x883>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm1,%xmm1
mov    -0x50(%rbp),%r15
jmp    1a4e <main+0x8be>
and    $0xfffffffc,%r8d
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%r15
nopl   (%rax)
lea    0x1(%rax),%edx
movss  (%rdi,%rax,4),%xmm1
movss  0x4(%rdi,%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(%rdi,%rax,4),%xmm1
lea    0x3(%rax),%esi
ucomiss %xmm2,%xmm1
maxss  %xmm2,%xmm1
cmovbe %edx,%esi
movss  0xc(%rdi,%rax,4),%xmm0
add    $0x4,%rax
ucomiss %xmm1,%xmm0
maxss  %xmm1,%xmm0
mov    %eax,%ebx
cmovbe %esi,%ebx
cmp    %rax,%r8
jne    19c0 <main+0x830>
movaps %xmm0,%xmm1
test   %rcx,%rcx
je     1a4e <main+0x8be>
lea    0x1(%rax),%edx
movzwl %dx,%edx
mov    -0x40(%rbp),%rsi
lea    (%rsi,%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    1a30 <main+0x8a0>
mov    %ebx,-0x34(%rbp)
movzwl %bx,%esi
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
lea    0x5fa(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x65b(%rip),%rdi
test   %r14b,%r14b
jne    1217 <main+0x87>
jmp    1ab9 <main+0x929>
movzwl -0x34(%rbp),%esi
xorps  %xmm0,%xmm0
lea    0x5d3(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x634(%rip),%rdi
mov    -0x50(%rbp),%r15
jmp    1217 <main+0x87>
movzwl -0x34(%rbp),%esi
xorps  %xmm0,%xmm0
lea    0x5ae(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x50(%rbp),%r15
lea    0x5d5(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
movzwl -0x2a(%rbp),%eax
test   %ax,%ax
je     1210 <main+0x80>
mov    $0x1,%r14d
jmp    1af2 <main+0x962>
nopl   0x0(%rax)
add    $0x1,%r14d
movzwl %r14w,%r14d
cmp    %ax,%r14w
ja     1210 <main+0x80>
mov    %r14d,%ecx
cmpw   $0x0,(%r12,%rcx,2)
je     1ae0 <main+0x950>
lea    0x5c2(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
movzwl -0x2a(%rbp),%eax
jmp    1ae0 <main+0x950>
xor    %esi,%esi
test   $0x1,%dl
jne    17eb <main+0x65b>
jmp    1804 <main+0x674>
xor    %edx,%edx
test   $0x1,%r10b
jne    190c <main+0x77c>
jmp    1930 <main+0x7a0>
mov    %r15,%rdi
call   1040 <fclose@plt>
xor    %eax,%eax
jmp    1b6c <main+0x9dc>
mov    0x2498(%rip),%rax
mov    (%rax),%edi
call   10b0 <strerror@plt>
lea    0x4cd(%rip),%rdi
lea    0x4b7(%rip),%rsi
mov    %rax,%rdx
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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