#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_vector(float *, int, int);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, float *);
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sort2(int, float *, float *);
float *vector(int, int);
int main(void) {
  char txt[80];
  int i, j;
  float *a, *b;
  FILE *fp;
  a = vector(1, 100);
  b = 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);
  for (i = 1; i <= 100; i++)
    b[i] = i;
  sort2(100, a, b);
  printf("\nAfter sorting a and mixing b, array a is:\n");
  for (i = 0; i <= 9; i++) {
    for (j = 1; j <= 10; j++)
      printf("%7.2f", a[10 * i + j]);
    printf("\n");
  }
  printf("\n... and array b is:\n");
  for (i = 0; i <= 9; i++) {
    for (j = 1; j <= 10; j++)
      printf("%7.2f", b[10 * i + j]);
    printf("\n");
  }
  printf("press return to continue...\n");
  (void)getchar();
  sort2(100, b, a);
  printf("\nAfter sorting b and mixing a, array a is:\n");
  for (i = 0; i <= 9; i++) {
    for (j = 1; j <= 10; j++)
      printf("%7.2f", a[10 * i + j]);
    printf("\n");
  }
  printf("\n... and array b is:\n");
  for (i = 0; i <= 9; i++) {
    for (j = 1; j <= 10; j++)
      printf("%7.2f", b[10 * i + j]);
    printf("\n");
  }
  free_vector(b, 1, 100);
  free_vector(a, 1, 100);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edi
mov    $0x64,%esi
call   10b0 <vector@plt>
mov    %rax,-0x70(%rbp)
mov    $0x1,%edi
mov    $0x64,%esi
call   10b0 <vector@plt>
mov    %rax,-0x78(%rbp)
lea    0xe21(%rip),%rdi
lea    0xe25(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x80(%rbp)
cmp    $0x0,%rax
jne    1205 <main+0x65>
lea    0xe0d(%rip),%rdi
call   1030 <nrerror@plt>
lea    -0x60(%rbp),%rdi
mov    -0x80(%rbp),%rdx
mov    $0x50,%esi
call   1080 <fgets@plt>
movl   $0x1,-0x64(%rbp)
cmpl   $0x64,-0x64(%rbp)
jg     1255 <main+0xb5>
mov    -0x80(%rbp),%rdi
mov    -0x70(%rbp),%rdx
movslq -0x64(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xdeb(%rip),%rsi
call   1070 <fscanf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    121e <main+0x7e>
mov    -0x80(%rbp),%rdi
call   1040 <fclose@plt>
movl   $0x1,-0x64(%rbp)
cmpl   $0x64,-0x64(%rbp)
jg     128f <main+0xef>
cvtsi2ssl -0x64(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1265 <main+0xc5>
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    $0x64,%edi
call   10a0 <sort2@plt>
lea    0xd88(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x64(%rbp)
cmpl   $0x9,-0x64(%rbp)
jg     1320 <main+0x180>
movl   $0x1,-0x68(%rbp)
cmpl   $0xa,-0x68(%rbp)
jg     1304 <main+0x164>
mov    -0x70(%rbp),%rax
imul   $0xa,-0x64(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd6d(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    12c7 <main+0x127>
lea    0xd88(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12b6 <main+0x116>
lea    0xd3b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x64(%rbp)
cmpl   $0x9,-0x64(%rbp)
jg     139f <main+0x1ff>
movl   $0x1,-0x68(%rbp)
cmpl   $0xa,-0x68(%rbp)
jg     1383 <main+0x1e3>
mov    -0x78(%rbp),%rax
imul   $0xa,-0x64(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcee(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1346 <main+0x1a6>
lea    0xd09(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1335 <main+0x195>
lea    0xcd2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x0,%al
call   1090 <getchar@plt>
mov    -0x78(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    $0x64,%edi
call   10a0 <sort2@plt>
lea    0xcc8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x64(%rbp)
cmpl   $0x9,-0x64(%rbp)
jg     1445 <main+0x2a5>
movl   $0x1,-0x68(%rbp)
cmpl   $0xa,-0x68(%rbp)
jg     1429 <main+0x289>
mov    -0x70(%rbp),%rax
imul   $0xa,-0x64(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc48(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13ec <main+0x24c>
lea    0xc63(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13db <main+0x23b>
lea    0xc16(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x64(%rbp)
cmpl   $0x9,-0x64(%rbp)
jg     14c4 <main+0x324>
movl   $0x1,-0x68(%rbp)
cmpl   $0xa,-0x68(%rbp)
jg     14a8 <main+0x308>
mov    -0x78(%rbp),%rax
imul   $0xa,-0x64(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbc9(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    146b <main+0x2cb>
lea    0xbe4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    145a <main+0x2ba>
mov    -0x78(%rbp),%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1060 <free_vector@plt>
mov    -0x70(%rbp),%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1060 <free_vector@plt>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x50,%rsp
mov    $0x1,%edi
mov    $0x64,%esi
call   10d0 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x64,%esi
call   10d0 <vector@plt>
mov    %rax,%r15
lea    0xf98(%rip),%rdi
lea    0xf9c(%rip),%rsi
call   10e0 <fopen@plt>
mov    %rax,%r13
test   %rax,%rax
jne    1218 <main+0x58>
lea    0xf8a(%rip),%rdi
call   1050 <nrerror@plt>
mov    %rsp,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10a0 <fgets@plt>
mov    $0x4,%ebx
lea    0xf89(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r14,%rbx,1),%rdx
mov    %r13,%rdi
mov    %r12,%rsi
call   1090 <fscanf@plt>
add    $0x4,%rbx
cmp    $0x194,%rbx
jne    1240 <main+0x80>
mov    %r13,%rdi
call   1060 <fclose@plt>
movaps 0xd95(%rip),%xmm0
movups %xmm0,0x4(%r15)
movaps 0xd99(%rip),%xmm0
movups %xmm0,0x14(%r15)
movaps 0xd9d(%rip),%xmm0
movups %xmm0,0x24(%r15)
movaps 0xda1(%rip),%xmm0
movups %xmm0,0x34(%r15)
movaps 0xda5(%rip),%xmm0
movups %xmm0,0x44(%r15)
movaps 0xda9(%rip),%xmm0
movups %xmm0,0x54(%r15)
movaps 0xdad(%rip),%xmm0
movups %xmm0,0x64(%r15)
movaps 0xdb1(%rip),%xmm0
movups %xmm0,0x74(%r15)
movaps 0xdb5(%rip),%xmm0
movups %xmm0,0x84(%r15)
movaps 0xdb6(%rip),%xmm0
movups %xmm0,0x94(%r15)
movaps 0xdb7(%rip),%xmm0
movups %xmm0,0xa4(%r15)
movaps 0xdb8(%rip),%xmm0
movups %xmm0,0xb4(%r15)
movaps 0xdb9(%rip),%xmm0
movups %xmm0,0xc4(%r15)
movaps 0xdba(%rip),%xmm0
movups %xmm0,0xd4(%r15)
movaps 0xdbb(%rip),%xmm0
movups %xmm0,0xe4(%r15)
movaps 0xdbc(%rip),%xmm0
movups %xmm0,0xf4(%r15)
movaps 0xdbd(%rip),%xmm0
movups %xmm0,0x104(%r15)
movaps 0xdbe(%rip),%xmm0
movups %xmm0,0x114(%r15)
movaps 0xdbf(%rip),%xmm0
movups %xmm0,0x124(%r15)
movaps 0xdc0(%rip),%xmm0
movups %xmm0,0x134(%r15)
movaps 0xdc1(%rip),%xmm0
movups %xmm0,0x144(%r15)
movaps 0xdc2(%rip),%xmm0
movups %xmm0,0x154(%r15)
movaps 0xdc3(%rip),%xmm0
movups %xmm0,0x164(%r15)
movaps 0xdc4(%rip),%xmm0
movups %xmm0,0x174(%r15)
movaps 0xdc5(%rip),%xmm0
movups %xmm0,0x184(%r15)
mov    $0x64,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   10c0 <sort2@plt>
lea    0xdec(%rip),%rdi
call   1040 <puts@plt>
mov    $0x28,%ebx
lea    0xdd5(%rip),%r12
nopl   0x0(%rax,%rax,1)
movss  -0x24(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x20(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x1c(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x18(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x14(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x10(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0xc(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x8(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x4(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  (%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x28,%rbx
cmp    $0x1b8,%rbx
jne    13f0 <main+0x230>
lea    0xd55(%rip),%rdi
call   1040 <puts@plt>
mov    $0x28,%ebx
lea    0xccc(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x24(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x20(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x1c(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x18(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x14(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x10(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0xc(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x8(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x4(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  (%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x28,%rbx
cmp    $0x1b8,%rbx
jne    1500 <main+0x340>
lea    0xbfe(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   10b0 <getchar@plt>
mov    $0x64,%edi
mov    %r15,%rsi
mov    %r14,%rdx
call   10c0 <sort2@plt>
lea    0xbf7(%rip),%rdi
call   1040 <puts@plt>
mov    $0x28,%ebx
lea    0xb99(%rip),%r12
nopw   0x0(%rax,%rax,1)
movss  -0x24(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x20(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x1c(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x18(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x14(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x10(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0xc(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x8(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x4(%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  (%r14,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x28,%rbx
cmp    $0x1b8,%rbx
jne    1630 <main+0x470>
lea    0xb15(%rip),%rdi
call   1040 <puts@plt>
mov    $0x28,%ebx
lea    0xa8c(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x24(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x20(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x1c(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x18(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x14(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x10(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0xc(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x8(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x4(%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  (%r15,%rbx,1),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x28,%rbx
cmp    $0x1b8,%rbx
jne    1740 <main+0x580>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1080 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x64,%edx
call   1080 <free_vector@plt>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
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 = [44 x i8] c"\0AAfter sorting a and mixing b, array a is:\0A\00"
@.str.5 = [6 x i8] c"%7.2f\00"
@.str.6 = [2 x i8] c"\0A\00"
@.str.7 = [22 x i8] c"\0A... and array b is:\0A\00"
@.str.8 = [29 x i8] c"press return to continue...\0A\00"
@.str.9 = [44 x i8] c"\0AAfter sorting b and mixing a, array a is:\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [80 x i8]
%3 = alloca i32
%4 = alloca i32
%5 = alloca float*
%6 = alloca float*
%7 = alloca i32*
store i32 0, i32* %1
%8 = call float* @vector(i32 1, i32 100)
store float* %8, float** %5
%9 = call float* @vector(i32 1, i32 100)
store float* %9, float** %6
%10 = 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* %10, i32** %7
%11 = icmp eq i32* %10, null
br i1 %11, label %12, label %14
12: ; preds = %0
%13 = call i32 @nrerror(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
br label %14
14: ; preds = %12, %0
%15 = getelementptr inbounds [80 x i8], [80 x i8]* %2, i64 0, i64 0
%16 = load i32*, i32** %7
%17 = call i32 @fgets(i8* %15, i32 80, i32* %16)
store i32 1, i32* %3
br label %18
18: ; preds = %28, %14
%19 = load i32, i32* %3
%20 = icmp sle i32 %19, 100
br i1 %20, label %21, label %31
21: ; preds = %18
%22 = load i32*, i32** %7
%23 = load float*, float** %5
%24 = load i32, i32* %3
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds float, float* %23, i64 %25
%27 = call i32 @fscanf(i32* %22, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %26)
br label %28
28: ; preds = %21
%29 = load i32, i32* %3
%30 = add nsw i32 %29, 1
store i32 %30, i32* %3
br label %18
31: ; preds = %18
%32 = load i32*, i32** %7
%33 = call i32 @fclose(i32* %32)
store i32 1, i32* %3
br label %34
34: ; preds = %44, %31
%35 = load i32, i32* %3
%36 = icmp sle i32 %35, 100
br i1 %36, label %37, label %47
37: ; preds = %34
%38 = load i32, i32* %3
%39 = sitofp i32 %38 to float
%40 = load float*, float** %6
%41 = load i32, i32* %3
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
store float %39, float* %43
br label %44
44: ; preds = %37
%45 = load i32, i32* %3
%46 = add nsw i32 %45, 1
store i32 %46, i32* %3
br label %34
47: ; preds = %34
%48 = load float*, float** %5
%49 = load float*, float** %6
%50 = call i32 @sort2(i32 100, float* %48, float* %49)
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %3
br label %52
52: ; preds = %75, %47
%53 = load i32, i32* %3
%54 = icmp sle i32 %53, 9
br i1 %54, label %55, label %78
55: ; preds = %52
store i32 1, i32* %4
br label %56
56: ; preds = %70, %55
%57 = load i32, i32* %4
%58 = icmp sle i32 %57, 10
br i1 %58, label %59, label %73
59: ; preds = %56
%60 = load float*, float** %5
%61 = load i32, i32* %3
%62 = mul nsw i32 10, %61
%63 = load i32, i32* %4
%64 = add nsw i32 %62, %63
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float, float* %60, i64 %65
%67 = load float, float* %66
%68 = fpext float %67 to double
%69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %68)
br label %70
70: ; preds = %59
%71 = load i32, i32* %4
%72 = add nsw i32 %71, 1
store i32 %72, i32* %4
br label %56
73: ; preds = %56
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %75
75: ; preds = %73
%76 = load i32, i32* %3
%77 = add nsw i32 %76, 1
store i32 %77, i32* %3
br label %52
78: ; preds = %52
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %3
br label %80
80: ; preds = %103, %78
%81 = load i32, i32* %3
%82 = icmp sle i32 %81, 9
br i1 %82, label %83, label %106
83: ; preds = %80
store i32 1, i32* %4
br label %84
84: ; preds = %98, %83
%85 = load i32, i32* %4
%86 = icmp sle i32 %85, 10
br i1 %86, label %87, label %101
87: ; preds = %84
%88 = load float*, float** %6
%89 = load i32, i32* %3
%90 = mul nsw i32 10, %89
%91 = load i32, i32* %4
%92 = add nsw i32 %90, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %88, i64 %93
%95 = load float, float* %94
%96 = fpext float %95 to double
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %96)
br label %98
98: ; preds = %87
%99 = load i32, i32* %4
%100 = add nsw i32 %99, 1
store i32 %100, i32* %4
br label %84
101: ; preds = %84
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %103
103: ; preds = %101
%104 = load i32, i32* %3
%105 = add nsw i32 %104, 1
store i32 %105, i32* %3
br label %80
106: ; preds = %80
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.8, i64 0, i64 0))
%108 = call i32 (...) @getchar()
%109 = load float*, float** %6
%110 = load float*, float** %5
%111 = call i32 @sort2(i32 100, float* %109, float* %110)
%112 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %3
br label %113
113: ; preds = %136, %106
%114 = load i32, i32* %3
%115 = icmp sle i32 %114, 9
br i1 %115, label %116, label %139
116: ; preds = %113
store i32 1, i32* %4
br label %117
117: ; preds = %131, %116
%118 = load i32, i32* %4
%119 = icmp sle i32 %118, 10
br i1 %119, label %120, label %134
120: ; preds = %117
%121 = load float*, float** %5
%122 = load i32, i32* %3
%123 = mul nsw i32 10, %122
%124 = load i32, i32* %4
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %121, i64 %126
%128 = load float, float* %127
%129 = fpext float %128 to double
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %129)
br label %131
131: ; preds = %120
%132 = load i32, i32* %4
%133 = add nsw i32 %132, 1
store i32 %133, i32* %4
br label %117
134: ; preds = %117
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %136
136: ; preds = %134
%137 = load i32, i32* %3
%138 = add nsw i32 %137, 1
store i32 %138, i32* %3
br label %113
139: ; preds = %113
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %3
br label %141
141: ; preds = %164, %139
%142 = load i32, i32* %3
%143 = icmp sle i32 %142, 9
br i1 %143, label %144, label %167
144: ; preds = %141
store i32 1, i32* %4
br label %145
145: ; preds = %159, %144
%146 = load i32, i32* %4
%147 = icmp sle i32 %146, 10
br i1 %147, label %148, label %162
148: ; preds = %145
%149 = load float*, float** %6
%150 = load i32, i32* %3
%151 = mul nsw i32 10, %150
%152 = load i32, i32* %4
%153 = add nsw i32 %151, %152
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %149, i64 %154
%156 = load float, float* %155
%157 = fpext float %156 to double
%158 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %157)
br label %159
159: ; preds = %148
%160 = load i32, i32* %4
%161 = add nsw i32 %160, 1
store i32 %161, i32* %4
br label %145
162: ; preds = %145
%163 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %164
164: ; preds = %162
%165 = load i32, i32* %3
%166 = add nsw i32 %165, 1
store i32 %166, i32* %3
br label %141
167: ; preds = %141
%168 = load float*, float** %6
%169 = call i32 @free_vector(float* %168, i32 1, i32 100)
%170 = load float*, float** %5
%171 = call i32 @free_vector(float* %170, 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 = [43 x i8] c"\0AAfter sorting a and mixing b, array a is:\00"
@str.11 = [28 x i8] c"press return to continue...\00"
@str.12 = [43 x i8] c"\0AAfter sorting b and mixing a, array a is:\00"
@str.13 = [21 x i8] c"\0A... and array b is:\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 float* @vector(i32 1, i32 100)
%4 = tail call float* @vector(i32 1, i32 100)
%5 = 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))
%6 = icmp eq i32* %5, null
br i1 %6, label %7, label %9
7: ; preds = %0
%8 = tail call i32 @nrerror(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
br label %9
9: ; preds = %7, %0
%10 = call i32 @fgets(i8* %2, i32 80, i32* %5)
br label %11
11: ; preds = %9, %11
%12 = phi i64 [ 1, %9 ], [ %15, %11 ]
%13 = getelementptr inbounds float, float* %3, i64 %12
%14 = call i32 @fscanf(i32* %5, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %13)
%15 = add nuw nsw i64 %12, 1
%16 = icmp eq i64 %15, 101
br i1 %16, label %17, label %11
17: ; preds = %11
%18 = call i32 @fclose(i32* %5)
%19 = getelementptr inbounds float, float* %4, i64 1
%20 = bitcast float* %19 to <4 x float>*
store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, <4 x float>* %20
%21 = getelementptr inbounds float, float* %4, i64 5
%22 = bitcast float* %21 to <4 x float>*
store <4 x float> <float 5.000000e+00, float 6.000000e+00, float 7.000000e+00, float 8.000000e+00>, <4 x float>* %22
%23 = getelementptr inbounds float, float* %4, i64 9
%24 = bitcast float* %23 to <4 x float>*
store <4 x float> <float 9.000000e+00, float 1.000000e+01, float 1.100000e+01, float 1.200000e+01>, <4 x float>* %24
%25 = getelementptr inbounds float, float* %4, i64 13
%26 = bitcast float* %25 to <4 x float>*
store <4 x float> <float 1.300000e+01, float 1.400000e+01, float 1.500000e+01, float 1.600000e+01>, <4 x float>* %26
%27 = getelementptr inbounds float, float* %4, i64 17
%28 = bitcast float* %27 to <4 x float>*
store <4 x float> <float 1.700000e+01, float 1.800000e+01, float 1.900000e+01, float 2.000000e+01>, <4 x float>* %28
%29 = getelementptr inbounds float, float* %4, i64 21
%30 = bitcast float* %29 to <4 x float>*
store <4 x float> <float 2.100000e+01, float 2.200000e+01, float 2.300000e+01, float 2.400000e+01>, <4 x float>* %30
%31 = getelementptr inbounds float, float* %4, i64 25
%32 = bitcast float* %31 to <4 x float>*
store <4 x float> <float 2.500000e+01, float 2.600000e+01, float 2.700000e+01, float 2.800000e+01>, <4 x float>* %32
%33 = getelementptr inbounds float, float* %4, i64 29
%34 = bitcast float* %33 to <4 x float>*
store <4 x float> <float 2.900000e+01, float 3.000000e+01, float 3.100000e+01, float 3.200000e+01>, <4 x float>* %34
%35 = getelementptr inbounds float, float* %4, i64 33
%36 = bitcast float* %35 to <4 x float>*
store <4 x float> <float 3.300000e+01, float 3.400000e+01, float 3.500000e+01, float 3.600000e+01>, <4 x float>* %36
%37 = getelementptr inbounds float, float* %4, i64 37
%38 = bitcast float* %37 to <4 x float>*
store <4 x float> <float 3.700000e+01, float 3.800000e+01, float 3.900000e+01, float 4.000000e+01>, <4 x float>* %38
%39 = getelementptr inbounds float, float* %4, i64 41
%40 = bitcast float* %39 to <4 x float>*
store <4 x float> <float 4.100000e+01, float 4.200000e+01, float 4.300000e+01, float 4.400000e+01>, <4 x float>* %40
%41 = getelementptr inbounds float, float* %4, i64 45
%42 = bitcast float* %41 to <4 x float>*
store <4 x float> <float 4.500000e+01, float 4.600000e+01, float 4.700000e+01, float 4.800000e+01>, <4 x float>* %42
%43 = getelementptr inbounds float, float* %4, i64 49
%44 = bitcast float* %43 to <4 x float>*
store <4 x float> <float 4.900000e+01, float 5.000000e+01, float 5.100000e+01, float 5.200000e+01>, <4 x float>* %44
%45 = getelementptr inbounds float, float* %4, i64 53
%46 = bitcast float* %45 to <4 x float>*
store <4 x float> <float 5.300000e+01, float 5.400000e+01, float 5.500000e+01, float 5.600000e+01>, <4 x float>* %46
%47 = getelementptr inbounds float, float* %4, i64 57
%48 = bitcast float* %47 to <4 x float>*
store <4 x float> <float 5.700000e+01, float 5.800000e+01, float 5.900000e+01, float 6.000000e+01>, <4 x float>* %48
%49 = getelementptr inbounds float, float* %4, i64 61
%50 = bitcast float* %49 to <4 x float>*
store <4 x float> <float 6.100000e+01, float 6.200000e+01, float 6.300000e+01, float 6.400000e+01>, <4 x float>* %50
%51 = getelementptr inbounds float, float* %4, i64 65
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> <float 6.500000e+01, float 6.600000e+01, float 6.700000e+01, float 6.800000e+01>, <4 x float>* %52
%53 = getelementptr inbounds float, float* %4, i64 69
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> <float 6.900000e+01, float 7.000000e+01, float 7.100000e+01, float 7.200000e+01>, <4 x float>* %54
%55 = getelementptr inbounds float, float* %4, i64 73
%56 = bitcast float* %55 to <4 x float>*
store <4 x float> <float 7.300000e+01, float 7.400000e+01, float 7.500000e+01, float 7.600000e+01>, <4 x float>* %56
%57 = getelementptr inbounds float, float* %4, i64 77
%58 = bitcast float* %57 to <4 x float>*
store <4 x float> <float 7.700000e+01, float 7.800000e+01, float 7.900000e+01, float 8.000000e+01>, <4 x float>* %58
%59 = getelementptr inbounds float, float* %4, i64 81
%60 = bitcast float* %59 to <4 x float>*
store <4 x float> <float 8.100000e+01, float 8.200000e+01, float 8.300000e+01, float 8.400000e+01>, <4 x float>* %60
%61 = getelementptr inbounds float, float* %4, i64 85
%62 = bitcast float* %61 to <4 x float>*
store <4 x float> <float 8.500000e+01, float 8.600000e+01, float 8.700000e+01, float 8.800000e+01>, <4 x float>* %62
%63 = getelementptr inbounds float, float* %4, i64 89
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> <float 8.900000e+01, float 9.000000e+01, float 9.100000e+01, float 9.200000e+01>, <4 x float>* %64
%65 = getelementptr inbounds float, float* %4, i64 93
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> <float 9.300000e+01, float 9.400000e+01, float 9.500000e+01, float 9.600000e+01>, <4 x float>* %66
%67 = getelementptr inbounds float, float* %4, i64 97
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> <float 9.700000e+01, float 9.800000e+01, float 9.900000e+01, float 1.000000e+02>, <4 x float>* %68
%69 = call i32 @sort2(i32 100, float* %3, float* %4)
%70 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @str, i64 0, i64 0))
br label %71
71: ; preds = %17, %71
%72 = phi i64 [ 0, %17 ], [ %125, %71 ]
%73 = mul nuw nsw i64 %72, 10
%74 = or i64 %73, 1
%75 = getelementptr inbounds float, float* %3, i64 %74
%76 = load float, float* %75
%77 = fpext float %76 to double
%78 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %77)
%79 = add nuw nsw i64 %73, 2
%80 = getelementptr inbounds float, float* %3, i64 %79
%81 = load float, float* %80
%82 = fpext float %81 to double
%83 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %82)
%84 = add nuw nsw i64 %73, 3
%85 = getelementptr inbounds float, float* %3, i64 %84
%86 = load float, float* %85
%87 = fpext float %86 to double
%88 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %87)
%89 = add nuw nsw i64 %73, 4
%90 = getelementptr inbounds float, float* %3, i64 %89
%91 = load float, float* %90
%92 = fpext float %91 to double
%93 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %92)
%94 = add nuw nsw i64 %73, 5
%95 = getelementptr inbounds float, float* %3, i64 %94
%96 = load float, float* %95
%97 = fpext float %96 to double
%98 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %97)
%99 = add nuw nsw i64 %73, 6
%100 = getelementptr inbounds float, float* %3, i64 %99
%101 = load float, float* %100
%102 = fpext float %101 to double
%103 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %102)
%104 = add nuw nsw i64 %73, 7
%105 = getelementptr inbounds float, float* %3, i64 %104
%106 = load float, float* %105
%107 = fpext float %106 to double
%108 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %107)
%109 = add nuw nsw i64 %73, 8
%110 = getelementptr inbounds float, float* %3, i64 %109
%111 = load float, float* %110
%112 = fpext float %111 to double
%113 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %112)
%114 = add nuw nsw i64 %73, 9
%115 = getelementptr inbounds float, float* %3, i64 %114
%116 = load float, float* %115
%117 = fpext float %116 to double
%118 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %117)
%119 = add nuw nsw i64 %73, 10
%120 = getelementptr inbounds float, float* %3, i64 %119
%121 = load float, float* %120
%122 = fpext float %121 to double
%123 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %122)
%124 = call i32 @putchar(i32 10)
%125 = add nuw nsw i64 %72, 1
%126 = icmp eq i64 %125, 10
br i1 %126, label %127, label %71
127: ; preds = %71
%128 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.13, i64 0, i64 0))
br label %129
129: ; preds = %127, %129
%130 = phi i64 [ 0, %127 ], [ %183, %129 ]
%131 = mul nuw nsw i64 %130, 10
%132 = or i64 %131, 1
%133 = getelementptr inbounds float, float* %4, i64 %132
%134 = load float, float* %133
%135 = fpext float %134 to double
%136 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %135)
%137 = add nuw nsw i64 %131, 2
%138 = getelementptr inbounds float, float* %4, i64 %137
%139 = load float, float* %138
%140 = fpext float %139 to double
%141 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %140)
%142 = add nuw nsw i64 %131, 3
%143 = getelementptr inbounds float, float* %4, i64 %142
%144 = load float, float* %143
%145 = fpext float %144 to double
%146 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %145)
%147 = add nuw nsw i64 %131, 4
%148 = getelementptr inbounds float, float* %4, i64 %147
%149 = load float, float* %148
%150 = fpext float %149 to double
%151 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %150)
%152 = add nuw nsw i64 %131, 5
%153 = getelementptr inbounds float, float* %4, i64 %152
%154 = load float, float* %153
%155 = fpext float %154 to double
%156 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %155)
%157 = add nuw nsw i64 %131, 6
%158 = getelementptr inbounds float, float* %4, i64 %157
%159 = load float, float* %158
%160 = fpext float %159 to double
%161 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %160)
%162 = add nuw nsw i64 %131, 7
%163 = getelementptr inbounds float, float* %4, i64 %162
%164 = load float, float* %163
%165 = fpext float %164 to double
%166 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %165)
%167 = add nuw nsw i64 %131, 8
%168 = getelementptr inbounds float, float* %4, i64 %167
%169 = load float, float* %168
%170 = fpext float %169 to double
%171 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %170)
%172 = add nuw nsw i64 %131, 9
%173 = getelementptr inbounds float, float* %4, i64 %172
%174 = load float, float* %173
%175 = fpext float %174 to double
%176 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %175)
%177 = add nuw nsw i64 %131, 10
%178 = getelementptr inbounds float, float* %4, i64 %177
%179 = load float, float* %178
%180 = fpext float %179 to double
%181 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %180)
%182 = call i32 @putchar(i32 10)
%183 = add nuw nsw i64 %130, 1
%184 = icmp eq i64 %183, 10
br i1 %184, label %185, label %129
185: ; preds = %129
%186 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.11, i64 0, i64 0))
%187 = call i32 (...) @getchar()
%188 = call i32 @sort2(i32 100, float* %4, float* %3)
%189 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @str.12, i64 0, i64 0))
br label %190
190: ; preds = %185, %190
%191 = phi i64 [ 0, %185 ], [ %244, %190 ]
%192 = mul nuw nsw i64 %191, 10
%193 = or i64 %192, 1
%194 = getelementptr inbounds float, float* %3, i64 %193
%195 = load float, float* %194
%196 = fpext float %195 to double
%197 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %196)
%198 = add nuw nsw i64 %192, 2
%199 = getelementptr inbounds float, float* %3, i64 %198
%200 = load float, float* %199
%201 = fpext float %200 to double
%202 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %201)
%203 = add nuw nsw i64 %192, 3
%204 = getelementptr inbounds float, float* %3, i64 %203
%205 = load float, float* %204
%206 = fpext float %205 to double
%207 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %206)
%208 = add nuw nsw i64 %192, 4
%209 = getelementptr inbounds float, float* %3, i64 %208
%210 = load float, float* %209
%211 = fpext float %210 to double
%212 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %211)
%213 = add nuw nsw i64 %192, 5
%214 = getelementptr inbounds float, float* %3, i64 %213
%215 = load float, float* %214
%216 = fpext float %215 to double
%217 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %216)
%218 = add nuw nsw i64 %192, 6
%219 = getelementptr inbounds float, float* %3, i64 %218
%220 = load float, float* %219
%221 = fpext float %220 to double
%222 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %221)
%223 = add nuw nsw i64 %192, 7
%224 = getelementptr inbounds float, float* %3, i64 %223
%225 = load float, float* %224
%226 = fpext float %225 to double
%227 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %226)
%228 = add nuw nsw i64 %192, 8
%229 = getelementptr inbounds float, float* %3, i64 %228
%230 = load float, float* %229
%231 = fpext float %230 to double
%232 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %231)
%233 = add nuw nsw i64 %192, 9
%234 = getelementptr inbounds float, float* %3, i64 %233
%235 = load float, float* %234
%236 = fpext float %235 to double
%237 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %236)
%238 = add nuw nsw i64 %192, 10
%239 = getelementptr inbounds float, float* %3, i64 %238
%240 = load float, float* %239
%241 = fpext float %240 to double
%242 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %241)
%243 = call i32 @putchar(i32 10)
%244 = add nuw nsw i64 %191, 1
%245 = icmp eq i64 %244, 10
br i1 %245, label %246, label %190
246: ; preds = %190
%247 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.13, i64 0, i64 0))
br label %248
248: ; preds = %246, %248
%249 = phi i64 [ 0, %246 ], [ %302, %248 ]
%250 = mul nuw nsw i64 %249, 10
%251 = or i64 %250, 1
%252 = getelementptr inbounds float, float* %4, i64 %251
%253 = load float, float* %252
%254 = fpext float %253 to double
%255 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %254)
%256 = add nuw nsw i64 %250, 2
%257 = getelementptr inbounds float, float* %4, i64 %256
%258 = load float, float* %257
%259 = fpext float %258 to double
%260 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %259)
%261 = add nuw nsw i64 %250, 3
%262 = getelementptr inbounds float, float* %4, i64 %261
%263 = load float, float* %262
%264 = fpext float %263 to double
%265 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %264)
%266 = add nuw nsw i64 %250, 4
%267 = getelementptr inbounds float, float* %4, i64 %266
%268 = load float, float* %267
%269 = fpext float %268 to double
%270 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %269)
%271 = add nuw nsw i64 %250, 5
%272 = getelementptr inbounds float, float* %4, i64 %271
%273 = load float, float* %272
%274 = fpext float %273 to double
%275 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %274)
%276 = add nuw nsw i64 %250, 6
%277 = getelementptr inbounds float, float* %4, i64 %276
%278 = load float, float* %277
%279 = fpext float %278 to double
%280 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %279)
%281 = add nuw nsw i64 %250, 7
%282 = getelementptr inbounds float, float* %4, i64 %281
%283 = load float, float* %282
%284 = fpext float %283 to double
%285 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %284)
%286 = add nuw nsw i64 %250, 8
%287 = getelementptr inbounds float, float* %4, i64 %286
%288 = load float, float* %287
%289 = fpext float %288 to double
%290 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %289)
%291 = add nuw nsw i64 %250, 9
%292 = getelementptr inbounds float, float* %4, i64 %291
%293 = load float, float* %292
%294 = fpext float %293 to double
%295 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %294)
%296 = add nuw nsw i64 %250, 10
%297 = getelementptr inbounds float, float* %4, i64 %296
%298 = load float, float* %297
%299 = fpext float %298 to double
%300 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %299)
%301 = call i32 @putchar(i32 10)
%302 = add nuw nsw i64 %249, 1
%303 = icmp eq i64 %302, 10
br i1 %303, label %304, label %248
304: ; preds = %248
%305 = call i32 @free_vector(float* %4, i32 1, i32 100)
%306 = call i32 @free_vector(float* %3, i32 1, i32 100)
ret i32 0
}