#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*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ free_lvector(unsigned long *, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, float *);
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ indexx(int, float *, unsigned long *);
unsigned long *lvector(int, int);
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ rank(int, unsigned long *, unsigned long *);
float *vector(int, int);
int main(void) {
  char txt[80];
  unsigned long i, j, k, l, *indx, *irank;
  float *a, b[11];
  FILE *fp;
  indx = lvector(1, 100);
  irank = lvector(1, 100);
  a = vector(1, 100);
  if ((fp = fopen("tarray.dat", "r")) == NULL)
    nrerror("Data file tarray.dat not found\n");
  fgets(txt, 80, fp);
  for (i = 1; i <= 100; i++)
    fscanf(fp, "%f", &a[i]);
  fclose(fp);
  indexx(100, a, indx);
  rank(100, indx, irank);
  printf("original array is:\n");
  for (i = 0; i <= 9; i++) {
    for (j = 1; j <= 10; j++)
      printf("%7.2f", a[10 * i + j]);
    printf("\n");
  }
  printf("table of ranks is:\n");
  for (i = 0; i <= 9; i++) {
    for (j = 1; j <= 10; j++)
      printf("%7d", irank[10 * i + j]);
    printf("\n");
  }
  printf("press return to continue...\n");
  (void)getchar();
  printf("array sorted according to rank table:\n");
  for (i = 0; i <= 9; i++) {
    for (j = 1; j <= 10; j++) {
      k = 10 * i + j;
      for (l = 1; l <= 100; l++)
        if (irank[l] == k)
          b[j] = a[l];
    }
    for (j = 1; j <= 10; j++)
      printf("%7.2f", b[j]);
    printf("\n");
  }
  free_vector(a, 1, 100);
  free_lvector(irank, 1, 100);
  free_lvector(indx, 1, 100);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edi
mov    $0x64,%esi
call   10f0 <lvector@plt>
mov    %rax,-0x88(%rbp)
mov    $0x1,%edi
mov    $0x64,%esi
call   10f0 <lvector@plt>
mov    %rax,-0x90(%rbp)
mov    $0x1,%edi
mov    $0x64,%esi
call   10d0 <vector@plt>
mov    %rax,-0x98(%rbp)
lea    0xdd5(%rip),%rdi
lea    0xdd9(%rip),%rsi
call   10e0 <fopen@plt>
mov    %rax,-0xd8(%rbp)
cmp    $0x0,%rax
jne    1254 <main+0x84>
lea    0xdbe(%rip),%rdi
call   1040 <nrerror@plt>
lea    -0x60(%rbp),%rdi
mov    -0xd8(%rbp),%rdx
mov    $0x50,%esi
call   10b0 <fgets@plt>
movq   $0x1,-0x68(%rbp)
cmpq   $0x64,-0x68(%rbp)
ja     12b2 <main+0xe2>
mov    -0xd8(%rbp),%rdi
mov    -0x98(%rbp),%rdx
mov    -0x68(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xd91(%rip),%rsi
call   10a0 <fscanf@plt>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1271 <main+0xa1>
mov    -0xd8(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x98(%rbp),%rsi
mov    -0x88(%rbp),%rdx
mov    $0x64,%edi
call   1060 <indexx@plt>
mov    -0x88(%rbp),%rsi
mov    -0x90(%rbp),%rdx
mov    $0x64,%edi
call   1030 <rank@plt>
lea    0xd3b(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movq   $0x0,-0x68(%rbp)
cmpq   $0x9,-0x68(%rbp)
ja     1379 <main+0x1a9>
movq   $0x1,-0x70(%rbp)
cmpq   $0xa,-0x70(%rbp)
ja     135a <main+0x18a>
mov    -0x98(%rbp),%rax
imul   $0xa,-0x68(%rbp),%rcx
add    -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd02(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1317 <main+0x147>
lea    0xd1c(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1304 <main+0x134>
lea    0xcca(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movq   $0x0,-0x68(%rbp)
cmpq   $0x9,-0x68(%rbp)
ja     13ff <main+0x22f>
movq   $0x1,-0x70(%rbp)
cmpq   $0xa,-0x70(%rbp)
ja     13e0 <main+0x210>
mov    -0x90(%rbp),%rax
imul   $0xa,-0x68(%rbp),%rcx
add    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0xc96(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    13a2 <main+0x1d2>
lea    0xc96(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    138f <main+0x1bf>
lea    0xc5c(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    $0x0,%al
call   10c0 <getchar@plt>
lea    0xc64(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movq   $0x0,-0x68(%rbp)
cmpq   $0x9,-0x68(%rbp)
ja     152c <main+0x35c>
movq   $0x1,-0x70(%rbp)
cmpq   $0xa,-0x70(%rbp)
ja     14ca <main+0x2fa>
imul   $0xa,-0x68(%rbp),%rax
add    -0x70(%rbp),%rax
mov    %rax,-0x78(%rbp)
movq   $0x1,-0x80(%rbp)
cmpq   $0x64,-0x80(%rbp)
ja     14b4 <main+0x2e4>
mov    -0x90(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x78(%rbp),%rax
jne    149e <main+0x2ce>
mov    -0x98(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,-0xd0(%rbp,%rax,4)
ff ff
jmp    14a3 <main+0x2d3>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    145d <main+0x28d>
jmp    14b9 <main+0x2e9>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    143d <main+0x26d>
movq   $0x1,-0x70(%rbp)
cmpq   $0xa,-0x70(%rbp)
ja     150d <main+0x33d>
mov    -0x70(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0xb4f(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    14d2 <main+0x302>
lea    0xb69(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    142a <main+0x25a>
mov    -0x98(%rbp),%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1090 <free_vector@plt>
mov    -0x90(%rbp),%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1070 <free_lvector@plt>
mov    -0x88(%rbp),%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1070 <free_lvector@plt>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    $0x1,%edi
mov    $0x64,%esi
call   1110 <lvector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x64,%esi
call   1110 <lvector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    $0x64,%esi
call   10f0 <vector@plt>
mov    %rax,%r15
lea    0xdc2(%rip),%rdi
lea    0xdc6(%rip),%rsi
call   1100 <fopen@plt>
mov    %rax,%r12
test   %rax,%rax
jne    125e <main+0x6e>
lea    0xdb4(%rip),%rdi
call   1060 <nrerror@plt>
lea    0x30(%rsp),%rdi
mov    $0x50,%esi
mov    %r12,%rdx
call   10d0 <fgets@plt>
mov    $0x4,%ebp
lea    0xdb1(%rip),%r13
nopl   0x0(%rax)
lea    (%r15,%rbp,1),%rdx
mov    %r12,%rdi
mov    %r13,%rsi
call   10c0 <fscanf@plt>
add    $0x4,%rbp
cmp    $0x194,%rbp
jne    1280 <main+0x90>
mov    %r12,%rdi
call   1070 <fclose@plt>
mov    $0x64,%edi
mov    %r15,%rsi
mov    %r14,%rdx
call   1080 <indexx@plt>
mov    $0x64,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1050 <rank@plt>
lea    0xd6f(%rip),%rdi
call   1040 <puts@plt>
mov    $0x28,%r13d
lea    0xd53(%rip),%r12
nopl   (%rax)
movss  -0x24(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0x20(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0x1c(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0x18(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0x14(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0x10(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0xc(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0x8(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0x4(%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  (%r15,%r13,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x28,%r13
cmp    $0x1b8,%r13
jne    12e0 <main+0xf0>
lea    0xc7a(%rip),%rdi
call   1040 <puts@plt>
mov    $0x50,%r13d
lea    0xc51(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x48(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    -0x40(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    -0x38(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    -0x30(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    -0x28(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    -0x20(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    -0x18(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    -0x10(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    -0x8(%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    (%rbx,%r13,1),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x50,%r13
cmp    $0x370,%r13
jne    13f0 <main+0x200>
lea    0xbb9(%rip),%rdi
call   1040 <puts@plt>
xor    %r13d,%r13d
xor    %eax,%eax
call   10e0 <getchar@plt>
lea    0xbbf(%rip),%rdi
call   1040 <puts@plt>
lea    0xb67(%rip),%r12
jmp    15bb <main+0x3cb>
xchg   %ax,%ax
movss  %xmm8,0x2c(%rsp)
movss  %xmm0,0x8(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm8,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r13
cmp    $0xa,%r13
je     1b31 <main+0x941>
mov    %r13,%rax
add    %r13,%rax
lea    (%rax,%rax,4),%rax
mov    %rax,%rcx
or     $0x1,%rcx
mov    $0x4,%edx
movss  0x28(%rsp),%xmm0
movss  0x24(%rsp),%xmm1
movss  0x20(%rsp),%xmm2
movss  0x1c(%rsp),%xmm3
movss  0x18(%rsp),%xmm4
movss  0x14(%rsp),%xmm5
movss  0x10(%rsp),%xmm6
movss  0xc(%rsp),%xmm7
movss  0x2c(%rsp),%xmm8
jmp    161a <main+0x42a>
nopw   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1680 <main+0x490>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     1640 <main+0x450>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     164e <main+0x45e>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     165c <main+0x46c>
cmp    %rcx,(%rbx,%rdx,8)
jne    1610 <main+0x420>
jmp    1669 <main+0x479>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm8
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    1628 <main+0x438>
movss  -0x8(%r15,%rdx,4),%xmm8
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    162f <main+0x43f>
movss  -0x4(%r15,%rdx,4),%xmm8
cmp    %rcx,(%rbx,%rdx,8)
jne    1610 <main+0x420>
movss  (%r15,%rdx,4),%xmm8
jmp    1610 <main+0x420>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x2(%rax),%rcx
mov    $0x4,%edx
jmp    169a <main+0x4aa>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1700 <main+0x510>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     16c0 <main+0x4d0>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     16ce <main+0x4de>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     16dc <main+0x4ec>
cmp    %rcx,(%rbx,%rdx,8)
jne    1690 <main+0x4a0>
jmp    16e9 <main+0x4f9>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm7
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    16a8 <main+0x4b8>
movss  -0x8(%r15,%rdx,4),%xmm7
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    16af <main+0x4bf>
movss  -0x4(%r15,%rdx,4),%xmm7
cmp    %rcx,(%rbx,%rdx,8)
jne    1690 <main+0x4a0>
movss  (%r15,%rdx,4),%xmm7
jmp    1690 <main+0x4a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x3(%rax),%rcx
mov    $0x4,%edx
jmp    171a <main+0x52a>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1780 <main+0x590>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     1740 <main+0x550>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     174e <main+0x55e>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     175c <main+0x56c>
cmp    %rcx,(%rbx,%rdx,8)
jne    1710 <main+0x520>
jmp    1769 <main+0x579>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm6
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    1728 <main+0x538>
movss  -0x8(%r15,%rdx,4),%xmm6
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    172f <main+0x53f>
movss  -0x4(%r15,%rdx,4),%xmm6
cmp    %rcx,(%rbx,%rdx,8)
jne    1710 <main+0x520>
movss  (%r15,%rdx,4),%xmm6
jmp    1710 <main+0x520>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x4(%rax),%rcx
mov    $0x4,%edx
jmp    179a <main+0x5aa>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1800 <main+0x610>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     17c0 <main+0x5d0>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     17ce <main+0x5de>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     17dc <main+0x5ec>
cmp    %rcx,(%rbx,%rdx,8)
jne    1790 <main+0x5a0>
jmp    17e9 <main+0x5f9>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm5
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    17a8 <main+0x5b8>
movss  -0x8(%r15,%rdx,4),%xmm5
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    17af <main+0x5bf>
movss  -0x4(%r15,%rdx,4),%xmm5
cmp    %rcx,(%rbx,%rdx,8)
jne    1790 <main+0x5a0>
movss  (%r15,%rdx,4),%xmm5
jmp    1790 <main+0x5a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x5(%rax),%rcx
mov    $0x4,%edx
jmp    181a <main+0x62a>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1880 <main+0x690>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     1840 <main+0x650>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     184e <main+0x65e>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     185c <main+0x66c>
cmp    %rcx,(%rbx,%rdx,8)
jne    1810 <main+0x620>
jmp    1869 <main+0x679>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm4
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    1828 <main+0x638>
movss  -0x8(%r15,%rdx,4),%xmm4
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    182f <main+0x63f>
movss  -0x4(%r15,%rdx,4),%xmm4
cmp    %rcx,(%rbx,%rdx,8)
jne    1810 <main+0x620>
movss  (%r15,%rdx,4),%xmm4
jmp    1810 <main+0x620>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x6(%rax),%rcx
mov    $0x4,%edx
jmp    189a <main+0x6aa>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1900 <main+0x710>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     18c0 <main+0x6d0>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     18ce <main+0x6de>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     18dc <main+0x6ec>
cmp    %rcx,(%rbx,%rdx,8)
jne    1890 <main+0x6a0>
jmp    18e9 <main+0x6f9>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm3
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    18a8 <main+0x6b8>
movss  -0x8(%r15,%rdx,4),%xmm3
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    18af <main+0x6bf>
movss  -0x4(%r15,%rdx,4),%xmm3
cmp    %rcx,(%rbx,%rdx,8)
jne    1890 <main+0x6a0>
movss  (%r15,%rdx,4),%xmm3
jmp    1890 <main+0x6a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x7(%rax),%rcx
mov    $0x4,%edx
jmp    191a <main+0x72a>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1980 <main+0x790>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     1940 <main+0x750>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     194e <main+0x75e>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     195c <main+0x76c>
cmp    %rcx,(%rbx,%rdx,8)
jne    1910 <main+0x720>
jmp    1969 <main+0x779>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm2
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    1928 <main+0x738>
movss  -0x8(%r15,%rdx,4),%xmm2
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    192f <main+0x73f>
movss  -0x4(%r15,%rdx,4),%xmm2
cmp    %rcx,(%rbx,%rdx,8)
jne    1910 <main+0x720>
movss  (%r15,%rdx,4),%xmm2
jmp    1910 <main+0x720>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x8(%rax),%rcx
mov    $0x4,%edx
jmp    199a <main+0x7aa>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1a00 <main+0x810>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     19c0 <main+0x7d0>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     19ce <main+0x7de>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     19dc <main+0x7ec>
cmp    %rcx,(%rbx,%rdx,8)
jne    1990 <main+0x7a0>
jmp    19e9 <main+0x7f9>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm1
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    19a8 <main+0x7b8>
movss  -0x8(%r15,%rdx,4),%xmm1
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    19af <main+0x7bf>
movss  -0x4(%r15,%rdx,4),%xmm1
cmp    %rcx,(%rbx,%rdx,8)
jne    1990 <main+0x7a0>
movss  (%r15,%rdx,4),%xmm1
jmp    1990 <main+0x7a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x9(%rax),%rcx
mov    $0x4,%edx
jmp    1a1a <main+0x82a>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    $0x68,%rdx
je     1a80 <main+0x890>
cmp    %rcx,-0x18(%rbx,%rdx,8)
je     1a40 <main+0x850>
cmp    %rcx,-0x10(%rbx,%rdx,8)
je     1a4e <main+0x85e>
cmp    %rcx,-0x8(%rbx,%rdx,8)
je     1a5c <main+0x86c>
cmp    %rcx,(%rbx,%rdx,8)
jne    1a10 <main+0x820>
jmp    1a69 <main+0x879>
nopw   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rdx,4),%xmm0
cmp    %rcx,-0x10(%rbx,%rdx,8)
jne    1a28 <main+0x838>
movss  -0x8(%r15,%rdx,4),%xmm0
cmp    %rcx,-0x8(%rbx,%rdx,8)
jne    1a2f <main+0x83f>
movss  -0x4(%r15,%rdx,4),%xmm0
cmp    %rcx,(%rbx,%rdx,8)
jne    1a10 <main+0x820>
movss  (%r15,%rdx,4),%xmm0
jmp    1a10 <main+0x820>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  %xmm7,0xc(%rsp)
movss  %xmm6,0x10(%rsp)
movss  %xmm5,0x14(%rsp)
movss  %xmm4,0x18(%rsp)
movss  %xmm3,0x1c(%rsp)
movss  %xmm2,0x20(%rsp)
movss  %xmm1,0x24(%rsp)
movss  %xmm0,0x28(%rsp)
add    $0xa,%rax
mov    $0x4,%ecx
movss  0x8(%rsp),%xmm0
jmp    1ade <main+0x8ee>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x4,%rcx
cmp    $0x68,%rcx
je     14d0 <main+0x2e0>
cmp    %rax,-0x18(%rbx,%rcx,8)
je     1b00 <main+0x910>
cmp    %rax,-0x10(%rbx,%rcx,8)
je     1b0e <main+0x91e>
cmp    %rax,-0x8(%rbx,%rcx,8)
je     1b1c <main+0x92c>
cmp    %rax,(%rbx,%rcx,8)
jne    1ad0 <main+0x8e0>
jmp    1b29 <main+0x939>
nopl   0x0(%rax,%rax,1)
movss  -0xc(%r15,%rcx,4),%xmm0
cmp    %rax,-0x10(%rbx,%rcx,8)
jne    1aec <main+0x8fc>
movss  -0x8(%r15,%rcx,4),%xmm0
cmp    %rax,-0x8(%rbx,%rcx,8)
jne    1af3 <main+0x903>
movss  -0x4(%r15,%rcx,4),%xmm0
cmp    %rax,(%rbx,%rcx,8)
jne    1ad0 <main+0x8e0>
movss  (%r15,%rcx,4),%xmm0
jmp    1ad0 <main+0x8e0>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   10b0 <free_vector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1090 <free_lvector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1090 <free_lvector@plt>
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [11 x i8] c"tarray.dat\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [32 x i8] c"Data file tarray.dat not found\0A\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [20 x i8] c"original array is:\0A\00"
@.str.5 = [6 x i8] c"%7.2f\00"
@.str.6 = [2 x i8] c"\0A\00"
@.str.7 = [20 x i8] c"table of ranks is:\0A\00"
@.str.8 = [4 x i8] c"%7d\00"
@.str.9 = [29 x i8] c"press return to continue...\0A\00"
@.str.10 = [39 x i8] c"array sorted according to rank table:\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [80 x i8]
%3 = alloca i64
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64*
%8 = alloca i64*
%9 = alloca float*
%10 = alloca [11 x float]
%11 = alloca i32*
store i32 0, i32* %1
%12 = call i64* @lvector(i32 1, i32 100)
store i64* %12, i64** %7
%13 = call i64* @lvector(i32 1, i32 100)
store i64* %13, i64** %8
%14 = call float* @vector(i32 1, i32 100)
store float* %14, float** %9
%15 = call i32* @fopen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %15, i32** %11
%16 = icmp eq i32* %15, null
br i1 %16, label %17, label %19
17: ; preds = %0
%18 = call i32 @nrerror(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
br label %19
19: ; preds = %17, %0
%20 = getelementptr inbounds [80 x i8], [80 x i8]* %2, i64 0, i64 0
%21 = load i32*, i32** %11
%22 = call i32 @fgets(i8* %20, i32 80, i32* %21)
store i64 1, i64* %3
br label %23
23: ; preds = %32, %19
%24 = load i64, i64* %3
%25 = icmp ule i64 %24, 100
br i1 %25, label %26, label %35
26: ; preds = %23
%27 = load i32*, i32** %11
%28 = load float*, float** %9
%29 = load i64, i64* %3
%30 = getelementptr inbounds float, float* %28, i64 %29
%31 = call i32 @fscanf(i32* %27, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %30)
br label %32
32: ; preds = %26
%33 = load i64, i64* %3
%34 = add i64 %33, 1
store i64 %34, i64* %3
br label %23
35: ; preds = %23
%36 = load i32*, i32** %11
%37 = call i32 @fclose(i32* %36)
%38 = load float*, float** %9
%39 = load i64*, i64** %7
%40 = call i32 @indexx(i32 100, float* %38, i64* %39)
%41 = load i64*, i64** %7
%42 = load i64*, i64** %8
%43 = call i32 @rank(i32 100, i64* %41, i64* %42)
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0))
store i64 0, i64* %3
br label %45
45: ; preds = %67, %35
%46 = load i64, i64* %3
%47 = icmp ule i64 %46, 9
br i1 %47, label %48, label %70
48: ; preds = %45
store i64 1, i64* %4
br label %49
49: ; preds = %62, %48
%50 = load i64, i64* %4
%51 = icmp ule i64 %50, 10
br i1 %51, label %52, label %65
52: ; preds = %49
%53 = load float*, float** %9
%54 = load i64, i64* %3
%55 = mul i64 10, %54
%56 = load i64, i64* %4
%57 = add i64 %55, %56
%58 = getelementptr inbounds float, float* %53, i64 %57
%59 = load float, float* %58
%60 = fpext float %59 to double
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %60)
br label %62
62: ; preds = %52
%63 = load i64, i64* %4
%64 = add i64 %63, 1
store i64 %64, i64* %4
br label %49
65: ; preds = %49
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %67
67: ; preds = %65
%68 = load i64, i64* %3
%69 = add i64 %68, 1
store i64 %69, i64* %3
br label %45
70: ; preds = %45
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.7, i64 0, i64 0))
store i64 0, i64* %3
br label %72
72: ; preds = %93, %70
%73 = load i64, i64* %3
%74 = icmp ule i64 %73, 9
br i1 %74, label %75, label %96
75: ; preds = %72
store i64 1, i64* %4
br label %76
76: ; preds = %88, %75
%77 = load i64, i64* %4
%78 = icmp ule i64 %77, 10
br i1 %78, label %79, label %91
79: ; preds = %76
%80 = load i64*, i64** %8
%81 = load i64, i64* %3
%82 = mul i64 10, %81
%83 = load i64, i64* %4
%84 = add i64 %82, %83
%85 = getelementptr inbounds i64, i64* %80, i64 %84
%86 = load i64, i64* %85
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %86)
br label %88
88: ; preds = %79
%89 = load i64, i64* %4
%90 = add i64 %89, 1
store i64 %90, i64* %4
br label %76
91: ; preds = %76
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %93
93: ; preds = %91
%94 = load i64, i64* %3
%95 = add i64 %94, 1
store i64 %95, i64* %3
br label %72
96: ; preds = %72
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.9, i64 0, i64 0))
%98 = call i32 (...) @getchar()
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.10, i64 0, i64 0))
store i64 0, i64* %3
br label %100
100: ; preds = %152, %96
%101 = load i64, i64* %3
%102 = icmp ule i64 %101, 9
br i1 %102, label %103, label %155
103: ; preds = %100
store i64 1, i64* %4
br label %104
104: ; preds = %134, %103
%105 = load i64, i64* %4
%106 = icmp ule i64 %105, 10
br i1 %106, label %107, label %137
107: ; preds = %104
%108 = load i64, i64* %3
%109 = mul i64 10, %108
%110 = load i64, i64* %4
%111 = add i64 %109, %110
store i64 %111, i64* %5
store i64 1, i64* %6
br label %112
112: ; preds = %130, %107
%113 = load i64, i64* %6
%114 = icmp ule i64 %113, 100
br i1 %114, label %115, label %133
115: ; preds = %112
%116 = load i64*, i64** %8
%117 = load i64, i64* %6
%118 = getelementptr inbounds i64, i64* %116, i64 %117
%119 = load i64, i64* %118
%120 = load i64, i64* %5
%121 = icmp eq i64 %119, %120
br i1 %121, label %122, label %129
122: ; preds = %115
%123 = load float*, float** %9
%124 = load i64, i64* %6
%125 = getelementptr inbounds float, float* %123, i64 %124
%126 = load float, float* %125
%127 = load i64, i64* %4
%128 = getelementptr inbounds [11 x float], [11 x float]* %10, i64 0, i64 %127
store float %126, float* %128
br label %129
129: ; preds = %122, %115
br label %130
130: ; preds = %129
%131 = load i64, i64* %6
%132 = add i64 %131, 1
store i64 %132, i64* %6
br label %112
133: ; preds = %112
br label %134
134: ; preds = %133
%135 = load i64, i64* %4
%136 = add i64 %135, 1
store i64 %136, i64* %4
br label %104
137: ; preds = %104
store i64 1, i64* %4
br label %138
138: ; preds = %147, %137
%139 = load i64, i64* %4
%140 = icmp ule i64 %139, 10
br i1 %140, label %141, label %150
141: ; preds = %138
%142 = load i64, i64* %4
%143 = getelementptr inbounds [11 x float], [11 x float]* %10, i64 0, i64 %142
%144 = load float, float* %143
%145 = fpext float %144 to double
%146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %145)
br label %147
147: ; preds = %141
%148 = load i64, i64* %4
%149 = add i64 %148, 1
store i64 %149, i64* %4
br label %138
150: ; preds = %138
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %152
152: ; preds = %150
%153 = load i64, i64* %3
%154 = add i64 %153, 1
store i64 %154, i64* %3
br label %100
155: ; preds = %100
%156 = load float*, float** %9
%157 = call i32 @free_vector(float* %156, i32 1, i32 100)
%158 = load i64*, i64** %8
%159 = call i32 @free_lvector(i64* %158, i32 1, i32 100)
%160 = load i64*, i64** %7
%161 = call i32 @free_lvector(i64* %160, i32 1, i32 100)
ret i32 0
}

LLVM IR (-O2):
@.str = [11 x i8] c"tarray.dat\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [32 x i8] c"Data file tarray.dat not found\0A\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.5 = [6 x i8] c"%7.2f\00"
@.str.8 = [4 x i8] c"%7d\00"
@str = [19 x i8] c"original array is:\00"
@str.11 = [19 x i8] c"table of ranks is:\00"
@str.12 = [28 x i8] c"press return to continue...\00"
@str.13 = [38 x i8] c"array sorted according to rank table:\00"
define i32 @main() {
%1 = alloca [80 x i8]
%2 = getelementptr inbounds [80 x i8], [80 x i8]* %1, i64 0, i64 0
%3 = tail call i64* @lvector(i32 1, i32 100)
%4 = tail call i64* @lvector(i32 1, i32 100)
%5 = tail call float* @vector(i32 1, i32 100)
%6 = tail call i32* @fopen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%7 = icmp eq i32* %6, null
br i1 %7, label %8, label %10
8: ; preds = %0
%9 = tail call i32 @nrerror(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
br label %10
10: ; preds = %8, %0
%11 = call i32 @fgets(i8* %2, i32 80, i32* %6)
br label %12
12: ; preds = %10, %12
%13 = phi i64 [ 1, %10 ], [ %16, %12 ]
%14 = getelementptr inbounds float, float* %5, i64 %13
%15 = call i32 @fscanf(i32* %6, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %14)
%16 = add nuw nsw i64 %13, 1
%17 = icmp eq i64 %16, 101
br i1 %17, label %18, label %12
18: ; preds = %12
%19 = call i32 @fclose(i32* %6)
%20 = call i32 @indexx(i32 100, float* %5, i64* %3)
%21 = call i32 @rank(i32 100, i64* %3, i64* %4)
%22 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str, i64 0, i64 0))
br label %23
23: ; preds = %18, %23
%24 = phi i64 [ 0, %18 ], [ %77, %23 ]
%25 = mul nuw nsw i64 %24, 10
%26 = or i64 %25, 1
%27 = getelementptr inbounds float, float* %5, i64 %26
%28 = load float, float* %27
%29 = fpext float %28 to double
%30 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %29)
%31 = add nuw nsw i64 %25, 2
%32 = getelementptr inbounds float, float* %5, i64 %31
%33 = load float, float* %32
%34 = fpext float %33 to double
%35 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %34)
%36 = add nuw nsw i64 %25, 3
%37 = getelementptr inbounds float, float* %5, i64 %36
%38 = load float, float* %37
%39 = fpext float %38 to double
%40 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %39)
%41 = add nuw nsw i64 %25, 4
%42 = getelementptr inbounds float, float* %5, i64 %41
%43 = load float, float* %42
%44 = fpext float %43 to double
%45 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %44)
%46 = add nuw nsw i64 %25, 5
%47 = getelementptr inbounds float, float* %5, i64 %46
%48 = load float, float* %47
%49 = fpext float %48 to double
%50 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %49)
%51 = add nuw nsw i64 %25, 6
%52 = getelementptr inbounds float, float* %5, i64 %51
%53 = load float, float* %52
%54 = fpext float %53 to double
%55 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %54)
%56 = add nuw nsw i64 %25, 7
%57 = getelementptr inbounds float, float* %5, i64 %56
%58 = load float, float* %57
%59 = fpext float %58 to double
%60 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %59)
%61 = add nuw nsw i64 %25, 8
%62 = getelementptr inbounds float, float* %5, i64 %61
%63 = load float, float* %62
%64 = fpext float %63 to double
%65 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %64)
%66 = add nuw nsw i64 %25, 9
%67 = getelementptr inbounds float, float* %5, i64 %66
%68 = load float, float* %67
%69 = fpext float %68 to double
%70 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %69)
%71 = add nuw nsw i64 %25, 10
%72 = getelementptr inbounds float, float* %5, i64 %71
%73 = load float, float* %72
%74 = fpext float %73 to double
%75 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %74)
%76 = call i32 @putchar(i32 10)
%77 = add nuw nsw i64 %24, 1
%78 = icmp eq i64 %77, 10
br i1 %78, label %79, label %23
79: ; preds = %23
%80 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.11, i64 0, i64 0))
br label %81
81: ; preds = %79, %81
%82 = phi i64 [ 0, %79 ], [ %125, %81 ]
%83 = mul nuw nsw i64 %82, 10
%84 = or i64 %83, 1
%85 = getelementptr inbounds i64, i64* %4, i64 %84
%86 = load i64, i64* %85
%87 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %86)
%88 = add nuw nsw i64 %83, 2
%89 = getelementptr inbounds i64, i64* %4, i64 %88
%90 = load i64, i64* %89
%91 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %90)
%92 = add nuw nsw i64 %83, 3
%93 = getelementptr inbounds i64, i64* %4, i64 %92
%94 = load i64, i64* %93
%95 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %94)
%96 = add nuw nsw i64 %83, 4
%97 = getelementptr inbounds i64, i64* %4, i64 %96
%98 = load i64, i64* %97
%99 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %98)
%100 = add nuw nsw i64 %83, 5
%101 = getelementptr inbounds i64, i64* %4, i64 %100
%102 = load i64, i64* %101
%103 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %102)
%104 = add nuw nsw i64 %83, 6
%105 = getelementptr inbounds i64, i64* %4, i64 %104
%106 = load i64, i64* %105
%107 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %106)
%108 = add nuw nsw i64 %83, 7
%109 = getelementptr inbounds i64, i64* %4, i64 %108
%110 = load i64, i64* %109
%111 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %110)
%112 = add nuw nsw i64 %83, 8
%113 = getelementptr inbounds i64, i64* %4, i64 %112
%114 = load i64, i64* %113
%115 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %114)
%116 = add nuw nsw i64 %83, 9
%117 = getelementptr inbounds i64, i64* %4, i64 %116
%118 = load i64, i64* %117
%119 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %118)
%120 = add nuw nsw i64 %83, 10
%121 = getelementptr inbounds i64, i64* %4, i64 %120
%122 = load i64, i64* %121
%123 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %122)
%124 = call i32 @putchar(i32 10)
%125 = add nuw nsw i64 %82, 1
%126 = icmp eq i64 %125, 10
br i1 %126, label %127, label %81
127: ; preds = %81
%128 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.12, i64 0, i64 0))
%129 = call i32 (...) @getchar()
%130 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.13, i64 0, i64 0))
br label %131
131: ; preds = %127, %563
%132 = phi float [ undef, %127 ], [ %518, %563 ]
%133 = phi float [ undef, %127 ], [ %476, %563 ]
%134 = phi float [ undef, %127 ], [ %434, %563 ]
%135 = phi float [ undef, %127 ], [ %392, %563 ]
%136 = phi float [ undef, %127 ], [ %350, %563 ]
%137 = phi float [ undef, %127 ], [ %308, %563 ]
%138 = phi float [ undef, %127 ], [ %266, %563 ]
%139 = phi float [ undef, %127 ], [ %224, %563 ]
%140 = phi float [ undef, %127 ], [ %182, %563 ]
%141 = phi float [ undef, %127 ], [ %560, %563 ]
%142 = phi i64 [ 0, %127 ], [ %585, %563 ]
%143 = mul nuw nsw i64 %142, 10
%144 = or i64 %143, 1
br label %145
145: ; preds = %181, %131
%146 = phi float [ %140, %131 ], [ %182, %181 ]
%147 = phi i64 [ 1, %131 ], [ %183, %181 ]
%148 = getelementptr inbounds i64, i64* %4, i64 %147
%149 = load i64, i64* %148
%150 = icmp eq i64 %149, %144
br i1 %150, label %151, label %154
151: ; preds = %145
%152 = getelementptr inbounds float, float* %5, i64 %147
%153 = load float, float* %152
br label %154
154: ; preds = %145, %151
%155 = phi float [ %153, %151 ], [ %146, %145 ]
%156 = add nuw nsw i64 %147, 1
%157 = getelementptr inbounds i64, i64* %4, i64 %156
%158 = load i64, i64* %157
%159 = icmp eq i64 %158, %144
br i1 %159, label %160, label %163
160: ; preds = %154
%161 = getelementptr inbounds float, float* %5, i64 %156
%162 = load float, float* %161
br label %163
163: ; preds = %160, %154
%164 = phi float [ %162, %160 ], [ %155, %154 ]
%165 = add nuw nsw i64 %147, 2
%166 = getelementptr inbounds i64, i64* %4, i64 %165
%167 = load i64, i64* %166
%168 = icmp eq i64 %167, %144
br i1 %168, label %169, label %172
169: ; preds = %163
%170 = getelementptr inbounds float, float* %5, i64 %165
%171 = load float, float* %170
br label %172
172: ; preds = %169, %163
%173 = phi float [ %171, %169 ], [ %164, %163 ]
%174 = add nuw nsw i64 %147, 3
%175 = getelementptr inbounds i64, i64* %4, i64 %174
%176 = load i64, i64* %175
%177 = icmp eq i64 %176, %144
br i1 %177, label %178, label %181
178: ; preds = %172
%179 = getelementptr inbounds float, float* %5, i64 %174
%180 = load float, float* %179
br label %181
181: ; preds = %178, %172
%182 = phi float [ %180, %178 ], [ %173, %172 ]
%183 = add nuw nsw i64 %147, 4
%184 = icmp eq i64 %183, 101
br i1 %184, label %185, label %145
185: ; preds = %181
%186 = add nuw nsw i64 %143, 2
br label %187
187: ; preds = %223, %185
%188 = phi float [ %139, %185 ], [ %224, %223 ]
%189 = phi i64 [ 1, %185 ], [ %225, %223 ]
%190 = getelementptr inbounds i64, i64* %4, i64 %189
%191 = load i64, i64* %190
%192 = icmp eq i64 %191, %186
br i1 %192, label %193, label %196
193: ; preds = %187
%194 = getelementptr inbounds float, float* %5, i64 %189
%195 = load float, float* %194
br label %196
196: ; preds = %193, %187
%197 = phi float [ %195, %193 ], [ %188, %187 ]
%198 = add nuw nsw i64 %189, 1
%199 = getelementptr inbounds i64, i64* %4, i64 %198
%200 = load i64, i64* %199
%201 = icmp eq i64 %200, %186
br i1 %201, label %202, label %205
202: ; preds = %196
%203 = getelementptr inbounds float, float* %5, i64 %198
%204 = load float, float* %203
br label %205
205: ; preds = %202, %196
%206 = phi float [ %204, %202 ], [ %197, %196 ]
%207 = add nuw nsw i64 %189, 2
%208 = getelementptr inbounds i64, i64* %4, i64 %207
%209 = load i64, i64* %208
%210 = icmp eq i64 %209, %186
br i1 %210, label %211, label %214
211: ; preds = %205
%212 = getelementptr inbounds float, float* %5, i64 %207
%213 = load float, float* %212
br label %214
214: ; preds = %211, %205
%215 = phi float [ %213, %211 ], [ %206, %205 ]
%216 = add nuw nsw i64 %189, 3
%217 = getelementptr inbounds i64, i64* %4, i64 %216
%218 = load i64, i64* %217
%219 = icmp eq i64 %218, %186
br i1 %219, label %220, label %223
220: ; preds = %214
%221 = getelementptr inbounds float, float* %5, i64 %216
%222 = load float, float* %221
br label %223
223: ; preds = %220, %214
%224 = phi float [ %222, %220 ], [ %215, %214 ]
%225 = add nuw nsw i64 %189, 4
%226 = icmp eq i64 %225, 101
br i1 %226, label %227, label %187
227: ; preds = %223
%228 = add nuw nsw i64 %143, 3
br label %229
229: ; preds = %265, %227
%230 = phi float [ %138, %227 ], [ %266, %265 ]
%231 = phi i64 [ 1, %227 ], [ %267, %265 ]
%232 = getelementptr inbounds i64, i64* %4, i64 %231
%233 = load i64, i64* %232
%234 = icmp eq i64 %233, %228
br i1 %234, label %235, label %238
235: ; preds = %229
%236 = getelementptr inbounds float, float* %5, i64 %231
%237 = load float, float* %236
br label %238
238: ; preds = %235, %229
%239 = phi float [ %237, %235 ], [ %230, %229 ]
%240 = add nuw nsw i64 %231, 1
%241 = getelementptr inbounds i64, i64* %4, i64 %240
%242 = load i64, i64* %241
%243 = icmp eq i64 %242, %228
br i1 %243, label %244, label %247
244: ; preds = %238
%245 = getelementptr inbounds float, float* %5, i64 %240
%246 = load float, float* %245
br label %247
247: ; preds = %244, %238
%248 = phi float [ %246, %244 ], [ %239, %238 ]
%249 = add nuw nsw i64 %231, 2
%250 = getelementptr inbounds i64, i64* %4, i64 %249
%251 = load i64, i64* %250
%252 = icmp eq i64 %251, %228
br i1 %252, label %253, label %256
253: ; preds = %247
%254 = getelementptr inbounds float, float* %5, i64 %249
%255 = load float, float* %254
br label %256
256: ; preds = %253, %247
%257 = phi float [ %255, %253 ], [ %248, %247 ]
%258 = add nuw nsw i64 %231, 3
%259 = getelementptr inbounds i64, i64* %4, i64 %258
%260 = load i64, i64* %259
%261 = icmp eq i64 %260, %228
br i1 %261, label %262, label %265
262: ; preds = %256
%263 = getelementptr inbounds float, float* %5, i64 %258
%264 = load float, float* %263
br label %265
265: ; preds = %262, %256
%266 = phi float [ %264, %262 ], [ %257, %256 ]
%267 = add nuw nsw i64 %231, 4
%268 = icmp eq i64 %267, 101
br i1 %268, label %269, label %229
269: ; preds = %265
%270 = add nuw nsw i64 %143, 4
br label %271
271: ; preds = %307, %269
%272 = phi float [ %137, %269 ], [ %308, %307 ]
%273 = phi i64 [ 1, %269 ], [ %309, %307 ]
%274 = getelementptr inbounds i64, i64* %4, i64 %273
%275 = load i64, i64* %274
%276 = icmp eq i64 %275, %270
br i1 %276, label %277, label %280
277: ; preds = %271
%278 = getelementptr inbounds float, float* %5, i64 %273
%279 = load float, float* %278
br label %280
280: ; preds = %277, %271
%281 = phi float [ %279, %277 ], [ %272, %271 ]
%282 = add nuw nsw i64 %273, 1
%283 = getelementptr inbounds i64, i64* %4, i64 %282
%284 = load i64, i64* %283
%285 = icmp eq i64 %284, %270
br i1 %285, label %286, label %289
286: ; preds = %280
%287 = getelementptr inbounds float, float* %5, i64 %282
%288 = load float, float* %287
br label %289
289: ; preds = %286, %280
%290 = phi float [ %288, %286 ], [ %281, %280 ]
%291 = add nuw nsw i64 %273, 2
%292 = getelementptr inbounds i64, i64* %4, i64 %291
%293 = load i64, i64* %292
%294 = icmp eq i64 %293, %270
br i1 %294, label %295, label %298
295: ; preds = %289
%296 = getelementptr inbounds float, float* %5, i64 %291
%297 = load float, float* %296
br label %298
298: ; preds = %295, %289
%299 = phi float [ %297, %295 ], [ %290, %289 ]
%300 = add nuw nsw i64 %273, 3
%301 = getelementptr inbounds i64, i64* %4, i64 %300
%302 = load i64, i64* %301
%303 = icmp eq i64 %302, %270
br i1 %303, label %304, label %307
304: ; preds = %298
%305 = getelementptr inbounds float, float* %5, i64 %300
%306 = load float, float* %305
br label %307
307: ; preds = %304, %298
%308 = phi float [ %306, %304 ], [ %299, %298 ]
%309 = add nuw nsw i64 %273, 4
%310 = icmp eq i64 %309, 101
br i1 %310, label %311, label %271
311: ; preds = %307
%312 = add nuw nsw i64 %143, 5
br label %313
313: ; preds = %349, %311
%314 = phi float [ %136, %311 ], [ %350, %349 ]
%315 = phi i64 [ 1, %311 ], [ %351, %349 ]
%316 = getelementptr inbounds i64, i64* %4, i64 %315
%317 = load i64, i64* %316
%318 = icmp eq i64 %317, %312
br i1 %318, label %319, label %322
319: ; preds = %313
%320 = getelementptr inbounds float, float* %5, i64 %315
%321 = load float, float* %320
br label %322
322: ; preds = %319, %313
%323 = phi float [ %321, %319 ], [ %314, %313 ]
%324 = add nuw nsw i64 %315, 1
%325 = getelementptr inbounds i64, i64* %4, i64 %324
%326 = load i64, i64* %325
%327 = icmp eq i64 %326, %312
br i1 %327, label %328, label %331
328: ; preds = %322
%329 = getelementptr inbounds float, float* %5, i64 %324
%330 = load float, float* %329
br label %331
331: ; preds = %328, %322
%332 = phi float [ %330, %328 ], [ %323, %322 ]
%333 = add nuw nsw i64 %315, 2
%334 = getelementptr inbounds i64, i64* %4, i64 %333
%335 = load i64, i64* %334
%336 = icmp eq i64 %335, %312
br i1 %336, label %337, label %340
337: ; preds = %331
%338 = getelementptr inbounds float, float* %5, i64 %333
%339 = load float, float* %338
br label %340
340: ; preds = %337, %331
%341 = phi float [ %339, %337 ], [ %332, %331 ]
%342 = add nuw nsw i64 %315, 3
%343 = getelementptr inbounds i64, i64* %4, i64 %342
%344 = load i64, i64* %343
%345 = icmp eq i64 %344, %312
br i1 %345, label %346, label %349
346: ; preds = %340
%347 = getelementptr inbounds float, float* %5, i64 %342
%348 = load float, float* %347
br label %349
349: ; preds = %346, %340
%350 = phi float [ %348, %346 ], [ %341, %340 ]
%351 = add nuw nsw i64 %315, 4
%352 = icmp eq i64 %351, 101
br i1 %352, label %353, label %313
353: ; preds = %349
%354 = add nuw nsw i64 %143, 6
br label %355
355: ; preds = %391, %353
%356 = phi float [ %135, %353 ], [ %392, %391 ]
%357 = phi i64 [ 1, %353 ], [ %393, %391 ]
%358 = getelementptr inbounds i64, i64* %4, i64 %357
%359 = load i64, i64* %358
%360 = icmp eq i64 %359, %354
br i1 %360, label %361, label %364
361: ; preds = %355
%362 = getelementptr inbounds float, float* %5, i64 %357
%363 = load float, float* %362
br label %364
364: ; preds = %361, %355
%365 = phi float [ %363, %361 ], [ %356, %355 ]
%366 = add nuw nsw i64 %357, 1
%367 = getelementptr inbounds i64, i64* %4, i64 %366
%368 = load i64, i64* %367
%369 = icmp eq i64 %368, %354
br i1 %369, label %370, label %373
370: ; preds = %364
%371 = getelementptr inbounds float, float* %5, i64 %366
%372 = load float, float* %371
br label %373
373: ; preds = %370, %364
%374 = phi float [ %372, %370 ], [ %365, %364 ]
%375 = add nuw nsw i64 %357, 2
%376 = getelementptr inbounds i64, i64* %4, i64 %375
%377 = load i64, i64* %376
%378 = icmp eq i64 %377, %354
br i1 %378, label %379, label %382
379: ; preds = %373
%380 = getelementptr inbounds float, float* %5, i64 %375
%381 = load float, float* %380
br label %382
382: ; preds = %379, %373
%383 = phi float [ %381, %379 ], [ %374, %373 ]
%384 = add nuw nsw i64 %357, 3
%385 = getelementptr inbounds i64, i64* %4, i64 %384
%386 = load i64, i64* %385
%387 = icmp eq i64 %386, %354
br i1 %387, label %388, label %391
388: ; preds = %382
%389 = getelementptr inbounds float, float* %5, i64 %384
%390 = load float, float* %389
br label %391
391: ; preds = %388, %382
%392 = phi float [ %390, %388 ], [ %383, %382 ]
%393 = add nuw nsw i64 %357, 4
%394 = icmp eq i64 %393, 101
br i1 %394, label %395, label %355
395: ; preds = %391
%396 = add nuw nsw i64 %143, 7
br label %397
397: ; preds = %433, %395
%398 = phi float [ %134, %395 ], [ %434, %433 ]
%399 = phi i64 [ 1, %395 ], [ %435, %433 ]
%400 = getelementptr inbounds i64, i64* %4, i64 %399
%401 = load i64, i64* %400
%402 = icmp eq i64 %401, %396
br i1 %402, label %403, label %406
403: ; preds = %397
%404 = getelementptr inbounds float, float* %5, i64 %399
%405 = load float, float* %404
br label %406
406: ; preds = %403, %397
%407 = phi float [ %405, %403 ], [ %398, %397 ]
%408 = add nuw nsw i64 %399, 1
%409 = getelementptr inbounds i64, i64* %4, i64 %408
%410 = load i64, i64* %409
%411 = icmp eq i64 %410, %396
br i1 %411, label %412, label %415
412: ; preds = %406
%413 = getelementptr inbounds float, float* %5, i64 %408
%414 = load float, float* %413
br label %415
415: ; preds = %412, %406
%416 = phi float [ %414, %412 ], [ %407, %406 ]
%417 = add nuw nsw i64 %399, 2
%418 = getelementptr inbounds i64, i64* %4, i64 %417
%419 = load i64, i64* %418
%420 = icmp eq i64 %419, %396
br i1 %420, label %421, label %424
421: ; preds = %415
%422 = getelementptr inbounds float, float* %5, i64 %417
%423 = load float, float* %422
br label %424
424: ; preds = %421, %415
%425 = phi float [ %423, %421 ], [ %416, %415 ]
%426 = add nuw nsw i64 %399, 3
%427 = getelementptr inbounds i64, i64* %4, i64 %426
%428 = load i64, i64* %427
%429 = icmp eq i64 %428, %396
br i1 %429, label %430, label %433
430: ; preds = %424
%431 = getelementptr inbounds float, float* %5, i64 %426
%432 = load float, float* %431
br label %433
433: ; preds = %430, %424
%434 = phi float [ %432, %430 ], [ %425, %424 ]
%435 = add nuw nsw i64 %399, 4
%436 = icmp eq i64 %435, 101
br i1 %436, label %437, label %397
437: ; preds = %433
%438 = add nuw nsw i64 %143, 8
br label %439
439: ; preds = %475, %437
%440 = phi float [ %133, %437 ], [ %476, %475 ]
%441 = phi i64 [ 1, %437 ], [ %477, %475 ]
%442 = getelementptr inbounds i64, i64* %4, i64 %441
%443 = load i64, i64* %442
%444 = icmp eq i64 %443, %438
br i1 %444, label %445, label %448
445: ; preds = %439
%446 = getelementptr inbounds float, float* %5, i64 %441
%447 = load float, float* %446
br label %448
448: ; preds = %445, %439
%449 = phi float [ %447, %445 ], [ %440, %439 ]
%450 = add nuw nsw i64 %441, 1
%451 = getelementptr inbounds i64, i64* %4, i64 %450
%452 = load i64, i64* %451
%453 = icmp eq i64 %452, %438
br i1 %453, label %454, label %457
454: ; preds = %448
%455 = getelementptr inbounds float, float* %5, i64 %450
%456 = load float, float* %455
br label %457
457: ; preds = %454, %448
%458 = phi float [ %456, %454 ], [ %449, %448 ]
%459 = add nuw nsw i64 %441, 2
%460 = getelementptr inbounds i64, i64* %4, i64 %459
%461 = load i64, i64* %460
%462 = icmp eq i64 %461, %438
br i1 %462, label %463, label %466
463: ; preds = %457
%464 = getelementptr inbounds float, float* %5, i64 %459
%465 = load float, float* %464
br label %466
466: ; preds = %463, %457
%467 = phi float [ %465, %463 ], [ %458, %457 ]
%468 = add nuw nsw i64 %441, 3
%469 = getelementptr inbounds i64, i64* %4, i64 %468
%470 = load i64, i64* %469
%471 = icmp eq i64 %470, %438
br i1 %471, label %472, label %475
472: ; preds = %466
%473 = getelementptr inbounds float, float* %5, i64 %468
%474 = load float, float* %473
br label %475
475: ; preds = %472, %466
%476 = phi float [ %474, %472 ], [ %467, %466 ]
%477 = add nuw nsw i64 %441, 4
%478 = icmp eq i64 %477, 101
br i1 %478, label %479, label %439
479: ; preds = %475
%480 = add nuw nsw i64 %143, 9
br label %481
481: ; preds = %517, %479
%482 = phi float [ %132, %479 ], [ %518, %517 ]
%483 = phi i64 [ 1, %479 ], [ %519, %517 ]
%484 = getelementptr inbounds i64, i64* %4, i64 %483
%485 = load i64, i64* %484
%486 = icmp eq i64 %485, %480
br i1 %486, label %487, label %490
487: ; preds = %481
%488 = getelementptr inbounds float, float* %5, i64 %483
%489 = load float, float* %488
br label %490
490: ; preds = %487, %481
%491 = phi float [ %489, %487 ], [ %482, %481 ]
%492 = add nuw nsw i64 %483, 1
%493 = getelementptr inbounds i64, i64* %4, i64 %492
%494 = load i64, i64* %493
%495 = icmp eq i64 %494, %480
br i1 %495, label %496, label %499
496: ; preds = %490
%497 = getelementptr inbounds float, float* %5, i64 %492
%498 = load float, float* %497
br label %499
499: ; preds = %496, %490
%500 = phi float [ %498, %496 ], [ %491, %490 ]
%501 = add nuw nsw i64 %483, 2
%502 = getelementptr inbounds i64, i64* %4, i64 %501
%503 = load i64, i64* %502
%504 = icmp eq i64 %503, %480
br i1 %504, label %505, label %508
505: ; preds = %499
%506 = getelementptr inbounds float, float* %5, i64 %501
%507 = load float, float* %506
br label %508
508: ; preds = %505, %499
%509 = phi float [ %507, %505 ], [ %500, %499 ]
%510 = add nuw nsw i64 %483, 3
%511 = getelementptr inbounds i64, i64* %4, i64 %510
%512 = load i64, i64* %511
%513 = icmp eq i64 %512, %480
br i1 %513, label %514, label %517
514: ; preds = %508
%515 = getelementptr inbounds float, float* %5, i64 %510
%516 = load float, float* %515
br label %517
517: ; preds = %514, %508
%518 = phi float [ %516, %514 ], [ %509, %508 ]
%519 = add nuw nsw i64 %483, 4
%520 = icmp eq i64 %519, 101
br i1 %520, label %521, label %481
521: ; preds = %517
%522 = add nuw nsw i64 %143, 10
br label %523
523: ; preds = %559, %521
%524 = phi float [ %141, %521 ], [ %560, %559 ]
%525 = phi i64 [ 1, %521 ], [ %561, %559 ]
%526 = getelementptr inbounds i64, i64* %4, i64 %525
%527 = load i64, i64* %526
%528 = icmp eq i64 %527, %522
br i1 %528, label %529, label %532
529: ; preds = %523
%530 = getelementptr inbounds float, float* %5, i64 %525
%531 = load float, float* %530
br label %532
532: ; preds = %529, %523
%533 = phi float [ %531, %529 ], [ %524, %523 ]
%534 = add nuw nsw i64 %525, 1
%535 = getelementptr inbounds i64, i64* %4, i64 %534
%536 = load i64, i64* %535
%537 = icmp eq i64 %536, %522
br i1 %537, label %538, label %541
538: ; preds = %532
%539 = getelementptr inbounds float, float* %5, i64 %534
%540 = load float, float* %539
br label %541
541: ; preds = %538, %532
%542 = phi float [ %540, %538 ], [ %533, %532 ]
%543 = add nuw nsw i64 %525, 2
%544 = getelementptr inbounds i64, i64* %4, i64 %543
%545 = load i64, i64* %544
%546 = icmp eq i64 %545, %522
br i1 %546, label %547, label %550
547: ; preds = %541
%548 = getelementptr inbounds float, float* %5, i64 %543
%549 = load float, float* %548
br label %550
550: ; preds = %547, %541
%551 = phi float [ %549, %547 ], [ %542, %541 ]
%552 = add nuw nsw i64 %525, 3
%553 = getelementptr inbounds i64, i64* %4, i64 %552
%554 = load i64, i64* %553
%555 = icmp eq i64 %554, %522
br i1 %555, label %556, label %559
556: ; preds = %550
%557 = getelementptr inbounds float, float* %5, i64 %552
%558 = load float, float* %557
br label %559
559: ; preds = %556, %550
%560 = phi float [ %558, %556 ], [ %551, %550 ]
%561 = add nuw nsw i64 %525, 4
%562 = icmp eq i64 %561, 101
br i1 %562, label %563, label %523
563: ; preds = %559
%564 = fpext float %182 to double
%565 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %564)
%566 = fpext float %224 to double
%567 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %566)
%568 = fpext float %266 to double
%569 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %568)
%570 = fpext float %308 to double
%571 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %570)
%572 = fpext float %350 to double
%573 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %572)
%574 = fpext float %392 to double
%575 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %574)
%576 = fpext float %434 to double
%577 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %576)
%578 = fpext float %476 to double
%579 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %578)
%580 = fpext float %518 to double
%581 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %580)
%582 = fpext float %560 to double
%583 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %582)
%584 = call i32 @putchar(i32 10)
%585 = add nuw nsw i64 %142, 1
%586 = icmp eq i64 %585, 10
br i1 %586, label %587, label %131
587: ; preds = %563
%588 = call i32 @free_vector(float* %5, i32 1, i32 100)
%589 = call i32 @free_lvector(i64* %4, i32 1, i32 100)
%590 = call i32 @free_lvector(i64* %3, i32 1, i32 100)
ret i32 0
}