#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*/ crank(int, float *, float *);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ getchar();
float **matrix(int, int, int, int);
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sort2(int, float *, float *);
float *vector(int, int);
int main(void) {
  int i, j;
  float *data, *order, *s, **rays;
  char dummy[80], txt[80], city[20 + 1][17], mon[12 + 1][5];
  FILE *fp;
  data = vector(1, 20);
  order = vector(1, 20);
  s = vector(1, 12);
  rays = matrix(1, 20, 1, 12);
  if ((fp = fopen("table2.dat", "r")) == NULL)
    nrerror("Data file table2.dat not found\n");
  fgets(dummy, 80, fp);
  fgets(txt, 80, fp);
  fscanf(fp, "%*15c");
  for (i = 1; i <= 12; i++)
    fscanf(fp, " %s", mon[i]);
  fgets(dummy, 80, fp);
  fgets(dummy, 80, fp);
  for (i = 1; i <= 20; i++) {
    fscanf(fp, "%[^0123456789]", city[i]);
    city[i][16] = '\0';
    for (j = 1; j <= 12; j++)
      fscanf(fp, "%f", &rays[i][j]);
    fgets(dummy, 80, fp);
  }
  fclose(fp);
  printf("%s\n%16s", txt, " ");
  for (i = 1; i <= 12; i++)
    printf(" %s", mon[i]);
  printf("\n");
  for (i = 1; i <= 20; i++) {
    printf("%s", city[i]);
    for (j = 1; j <= 12; j++)
      printf("%4d", (int)(0.5 + rays[i][j]));
    printf("\n");
  }
  printf(" press return to continue ...\n");
  getchar();
  for (j = 1; j <= 12; j++) {
    for (i = 1; i <= 20; i++) {
      data[i] = rays[i][j];
      order[i] = i;
    }
    sort2(20, data, order);
    crank(20, data, &s[j]);
    for (i = 1; i <= 20; i++)
      rays[(int)(0.5 + order[i])][j] = data[i];
  }
  printf("%16s", " ");
  for (i = 1; i <= 12; i++)
    printf(" %s", mon[i]);
  printf("\n");
  for (i = 1; i <= 20; i++) {
    printf("%s", city[i]);
    for (j = 1; j <= 12; j++)
      printf("%4d", (int)(0.5 + rays[i][j]));
    printf("\n");
  }
  free_matrix(rays, 1, 20, 1, 12);
  free_vector(s, 1, 12);
  free_vector(order, 1, 20);
  free_vector(data, 1, 20);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2a0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10d0 <vector@plt>
mov    %rax,-0x18(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10d0 <vector@plt>
mov    %rax,-0x20(%rbp)
mov    $0x1,%edi
mov    $0xc,%esi
call   10d0 <vector@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edx
mov    $0x14,%esi
mov    $0xc,%ecx
mov    %edx,%edi
call   10c0 <matrix@plt>
mov    %rax,-0x30(%rbp)
lea    0xdcc(%rip),%rdi
lea    0xdd0(%rip),%rsi
call   10f0 <fopen@plt>
mov    %rax,-0x298(%rbp)
cmp    $0x0,%rax
jne    1265 <main+0x95>
lea    0xdb5(%rip),%rdi
call   1040 <nrerror@plt>
lea    -0x80(%rbp),%rdi
mov    -0x298(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
lea    -0xd0(%rbp),%rdi
mov    -0x298(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
mov    -0x298(%rbp),%rdi
lea    0xd95(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0xc,-0x8(%rbp)
jg     12ed <main+0x11d>
mov    -0x298(%rbp),%rdi
movslq -0x8(%rbp),%rax
lea    -0x290(%rbp),%rdx
imul   $0x5,%rax,%rax
add    %rax,%rdx
lea    0xd63(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12ae <main+0xde>
lea    -0x80(%rbp),%rdi
mov    -0x298(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
lea    -0x80(%rbp),%rdi
mov    -0x298(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     13d3 <main+0x203>
mov    -0x298(%rbp),%rdi
movslq -0x8(%rbp),%rax
lea    -0x240(%rbp),%rdx
imul   $0x11,%rax,%rax
add    %rax,%rdx
lea    0xcf7(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
movslq -0x8(%rbp),%rcx
lea    -0x240(%rbp),%rax
imul   $0x11,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x10(%rax)
movl   $0x1,-0xc(%rbp)
cmpl   $0xc,-0xc(%rbp)
jg     13b0 <main+0x1e0>
mov    -0x298(%rbp),%rdi
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xcb3(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    136c <main+0x19c>
lea    -0x80(%rbp),%rdi
mov    -0x298(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    131e <main+0x14e>
mov    -0x298(%rbp),%rdi
call   1050 <fclose@plt>
lea    -0xd0(%rbp),%rsi
lea    0xc64(%rip),%rdi
lea    0xc65(%rip),%rdx
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0xc,-0x8(%rbp)
jg     143a <main+0x26a>
movslq -0x8(%rbp),%rax
lea    -0x290(%rbp),%rsi
imul   $0x5,%rax,%rax
add    %rax,%rsi
lea    0xc16(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1402 <main+0x232>
lea    0xc3b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     14eb <main+0x31b>
movslq -0x8(%rbp),%rax
lea    -0x240(%rbp),%rsi
imul   $0x11,%rax,%rax
add    %rax,%rsi
lea    0xbca(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0xc(%rbp)
cmpl   $0xc,-0xc(%rbp)
jg     14cf <main+0x2ff>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb55(%rip),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
lea    0xba1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1480 <main+0x2b0>
lea    0xba6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    144f <main+0x27f>
lea    0xb6d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   10a0 <getchar@plt>
movl   $0x1,-0xc(%rbp)
cmpl   $0xc,-0xc(%rbp)
jg     1607 <main+0x437>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     1564 <main+0x394>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl -0x8(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1518 <main+0x348>
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    $0x14,%edi
call   10b0 <sort2@plt>
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    $0x14,%edi
call   10e0 <crank@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     15f4 <main+0x424>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x8(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xa32(%rip),%xmm1
addsd  %xmm2,%xmm1
cvttsd2si %xmm1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    159a <main+0x3ca>
jmp    15f9 <main+0x429>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1507 <main+0x337>
lea    0xa46(%rip),%rdi
lea    0xa44(%rip),%rsi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0xc,-0x8(%rbp)
jg     165b <main+0x48b>
movslq -0x8(%rbp),%rax
lea    -0x290(%rbp),%rsi
imul   $0x5,%rax,%rax
add    %rax,%rsi
lea    0x9f5(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1623 <main+0x453>
lea    0xa1a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     170c <main+0x53c>
movslq -0x8(%rbp),%rax
lea    -0x240(%rbp),%rsi
imul   $0x11,%rax,%rax
add    %rax,%rsi
lea    0x9a9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0xc(%rbp)
cmpl   $0xc,-0xc(%rbp)
jg     16f0 <main+0x520>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x934(%rip),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
lea    0x980(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    16a1 <main+0x4d1>
lea    0x985(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1670 <main+0x4a0>
mov    -0x30(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%edx
mov    $0xc,%r8d
mov    %ecx,%esi
call   1030 <free_matrix@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
mov    $0xc,%edx
call   1070 <free_vector@plt>
mov    -0x20(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1070 <free_vector@plt>
mov    -0x18(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1070 <free_vector@plt>
xor    %eax,%eax
add    $0x2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x268,%rsp
mov    $0x1,%edi
mov    $0x14,%esi
call   10f0 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x14,%esi
call   10f0 <vector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    $0xc,%esi
call   10f0 <vector@plt>
mov    %rax,0x58(%rsp)
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0xc,%ecx
call   10e0 <matrix@plt>
mov    %rax,%rbx
lea    0xdac(%rip),%rdi
lea    0xdb0(%rip),%rsi
call   1110 <fopen@plt>
mov    %rax,%r13
test   %rax,%rax
jne    127c <main+0x8c>
lea    0xd9e(%rip),%rdi
call   1060 <nrerror@plt>
lea    0xb0(%rsp),%r15
mov    %r15,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10b0 <fgets@plt>
lea    0x60(%rsp),%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10b0 <fgets@plt>
lea    0xd88(%rip),%rsi
mov    %r13,%rdi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x5(%rsp),%rdx
lea    0xd78(%rip),%rbp
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0xa(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0xf(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x14(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x19(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x1e(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x23(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x28(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x2d(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x32(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x37(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x3c(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    %r15,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10b0 <fgets@plt>
mov    %r15,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   10b0 <fgets@plt>
lea    0x111(%rsp),%rax
mov    $0x1,%r15d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,0x50(%rsp)
mov    %r13,%rdi
lea    0xc60(%rip),%rsi
mov    0x50(%rsp),%rdx
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x50(%rsp),%rax
movb   $0x0,0x10(%rax)
mov    (%rbx,%r15,8),%rdx
add    $0x4,%rdx
mov    %r13,%rdi
mov    %r13,%rbp
lea    0xc45(%rip),%r13
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x8,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0xc,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x10,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x14,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x18,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x1c,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x20,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x24,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x28,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x2c,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rbx,%r15,8),%rdx
add    $0x30,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
mov    %rbp,%r13
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0xb0(%rsp),%rdi
mov    $0x50,%esi
mov    %rbp,%rdx
call   10b0 <fgets@plt>
mov    0x50(%rsp),%rax
add    $0x1,%r15
add    $0x11,%rax
cmp    $0x15,%r15
jne    13d0 <main+0x1e0>
mov    %r13,%rdi
call   1070 <fclose@plt>
lea    0xb19(%rip),%rdi
lea    0xb1a(%rip),%rdx
lea    0x60(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0xae9(%rip),%rbp
mov    %rbp,%rdi
lea    0x5(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0xa(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0xf(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x14(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x19(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x1e(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x23(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x28(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x2d(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x32(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x37(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x3c(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x111(%rsp),%rbp
mov    $0x1,%r13d
lea    0xa36(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nop
lea    0xa05(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9aa(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x983(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x960(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x93d(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x91a(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x18(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x8f7(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x1c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x8d4(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x20(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x8b1(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x88e(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x28(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x86b(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x2c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x848(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x30(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x825(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r13
add    $0x11,%rbp
cmp    $0x15,%r13
jne    1630 <main+0x440>
lea    0x853(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   10c0 <getchar@plt>
mov    $0x1,%ebp
mov    0x58(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rbx,%rax,8),%rcx
lea    0x1(%rax),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  (%rcx,%rbp,4),%xmm1
movss  %xmm1,0x4(%r14,%rax,4)
movss  %xmm0,0x4(%r12,%rax,4)
mov    0x10(%rbx,%rax,8),%rcx
lea    0x2(%rax),%rdx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  (%rcx,%rbp,4),%xmm1
movss  %xmm1,0x8(%r14,%rax,4)
movss  %xmm0,0x8(%r12,%rax,4)
mov    %rdx,%rax
cmp    $0x14,%rdx
jne    1840 <main+0x650>
mov    $0x14,%edi
mov    %r14,%rsi
mov    %r12,%rdx
call   10d0 <sort2@plt>
lea    (%r15,%rbp,4),%rdx
mov    $0x14,%edi
mov    %r14,%rsi
call   1100 <crank@plt>
mov    $0x2,%eax
movsd  0x744(%rip),%xmm2
nopl   0x0(%rax)
movss  -0x4(%r14,%rax,4),%xmm0
movss  -0x4(%r12,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvttsd2si %xmm1,%ecx
movslq %ecx,%rcx
mov    (%rbx,%rcx,8),%rcx
movss  %xmm0,(%rcx,%rbp,4)
movss  (%r14,%rax,4),%xmm0
movss  (%r12,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvttsd2si %xmm1,%ecx
movslq %ecx,%rcx
mov    (%rbx,%rcx,8),%rcx
movss  %xmm0,(%rcx,%rbp,4)
add    $0x2,%rax
cmp    $0x16,%rax
jne    18c0 <main+0x6d0>
add    $0x1,%rbp
cmp    $0xd,%rbp
jne    1830 <main+0x640>
lea    0x72b(%rip),%rdi
lea    0x729(%rip),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0x6fd(%rip),%rbp
mov    %rbp,%rdi
lea    0x5(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0xa(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0xf(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x14(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x19(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x1e(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x23(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x28(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x2d(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x32(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x37(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x3c(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x111(%rsp),%rbp
mov    $0x1,%r13d
lea    0x64a(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x615(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5ba(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x593(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x570(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x54d(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x52a(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x18(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x507(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x1c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x4e4(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x20(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x4c1(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x49e(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x28(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x47b(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x2c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x458(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r13,8),%rax
movss  0x30(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x435(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r13
add    $0x11,%rbp
cmp    $0x15,%r13
jne    1a20 <main+0x830>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0xc,%r8d
call   1050 <free_matrix@plt>
mov    0x58(%rsp),%rdi
mov    $0x1,%esi
mov    $0xc,%edx
call   1090 <free_vector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1090 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1090 <free_vector@plt>
xor    %eax,%eax
add    $0x268,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [11 x i8] c"table2.dat\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [32 x i8] c"Data file table2.dat not found\0A\00"
@.str.3 = [6 x i8] c"%*15c\00"
@.str.4 = [4 x i8] c" %s\00"
@.str.5 = [15 x i8] c"%[^0123456789]\00"
@.str.6 = [3 x i8] c"%f\00"
@.str.7 = [8 x i8] c"%s\0A%16s\00"
@.str.8 = [2 x i8] c" \00"
@.str.9 = [2 x i8] c"\0A\00"
@.str.10 = [3 x i8] c"%s\00"
@.str.11 = [4 x i8] c"%4d\00"
@.str.12 = [31 x i8] c" press return to continue ...\0A\00"
@.str.13 = [5 x i8] c"%16s\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca float*
%5 = alloca float*
%6 = alloca float*
%7 = alloca float**
%8 = alloca [80 x i8]
%9 = alloca [80 x i8]
%10 = alloca [21 x [17 x i8]]
%11 = alloca [13 x [5 x i8]]
%12 = alloca i32*
store i32 0, i32* %1
%13 = call float* @vector(i32 1, i32 20)
store float* %13, float** %4
%14 = call float* @vector(i32 1, i32 20)
store float* %14, float** %5
%15 = call float* @vector(i32 1, i32 12)
store float* %15, float** %6
%16 = call float** @matrix(i32 1, i32 20, i32 1, i32 12)
store float** %16, float*** %7
%17 = 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* %17, i32** %12
%18 = icmp eq i32* %17, null
br i1 %18, label %19, label %21
19: ; preds = %0
%20 = call i32 @nrerror(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
br label %21
21: ; preds = %19, %0
%22 = getelementptr inbounds [80 x i8], [80 x i8]* %8, i64 0, i64 0
%23 = load i32*, i32** %12
%24 = call i32 @fgets(i8* %22, i32 80, i32* %23)
%25 = getelementptr inbounds [80 x i8], [80 x i8]* %9, i64 0, i64 0
%26 = load i32*, i32** %12
%27 = call i32 @fgets(i8* %25, i32 80, i32* %26)
%28 = load i32*, i32** %12
%29 = call i32 (i32*, i8*, ...) @fscanf(i32* %28, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %2
br label %30
30: ; preds = %40, %21
%31 = load i32, i32* %2
%32 = icmp sle i32 %31, 12
br i1 %32, label %33, label %43
33: ; preds = %30
%34 = load i32*, i32** %12
%35 = load i32, i32* %2
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %11, i64 0, i64 %36
%38 = getelementptr inbounds [5 x i8], [5 x i8]* %37, i64 0, i64 0
%39 = call i32 (i32*, i8*, ...) @fscanf(i32* %34, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %38)
br label %40
40: ; preds = %33
%41 = load i32, i32* %2
%42 = add nsw i32 %41, 1
store i32 %42, i32* %2
br label %30
43: ; preds = %30
%44 = getelementptr inbounds [80 x i8], [80 x i8]* %8, i64 0, i64 0
%45 = load i32*, i32** %12
%46 = call i32 @fgets(i8* %44, i32 80, i32* %45)
%47 = getelementptr inbounds [80 x i8], [80 x i8]* %8, i64 0, i64 0
%48 = load i32*, i32** %12
%49 = call i32 @fgets(i8* %47, i32 80, i32* %48)
store i32 1, i32* %2
br label %50
50: ; preds = %85, %43
%51 = load i32, i32* %2
%52 = icmp sle i32 %51, 20
br i1 %52, label %53, label %88
53: ; preds = %50
%54 = load i32*, i32** %12
%55 = load i32, i32* %2
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %10, i64 0, i64 %56
%58 = getelementptr inbounds [17 x i8], [17 x i8]* %57, i64 0, i64 0
%59 = call i32 (i32*, i8*, ...) @fscanf(i32* %54, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), i8* %58)
%60 = load i32, i32* %2
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %10, i64 0, i64 %61
%63 = getelementptr inbounds [17 x i8], [17 x i8]* %62, i64 0, i64 16
store i8 0, i8* %63
store i32 1, i32* %3
br label %64
64: ; preds = %78, %53
%65 = load i32, i32* %3
%66 = icmp sle i32 %65, 12
br i1 %66, label %67, label %81
67: ; preds = %64
%68 = load i32*, i32** %12
%69 = load float**, float*** %7
%70 = load i32, i32* %2
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float*, float** %69, i64 %71
%73 = load float*, float** %72
%74 = load i32, i32* %3
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float, float* %73, i64 %75
%77 = call i32 (i32*, i8*, ...) @fscanf(i32* %68, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %76)
br label %78
78: ; preds = %67
%79 = load i32, i32* %3
%80 = add nsw i32 %79, 1
store i32 %80, i32* %3
br label %64
81: ; preds = %64
%82 = getelementptr inbounds [80 x i8], [80 x i8]* %8, i64 0, i64 0
%83 = load i32*, i32** %12
%84 = call i32 @fgets(i8* %82, i32 80, i32* %83)
br label %85
85: ; preds = %81
%86 = load i32, i32* %2
%87 = add nsw i32 %86, 1
store i32 %87, i32* %2
br label %50
88: ; preds = %50
%89 = load i32*, i32** %12
%90 = call i32 @fclose(i32* %89)
%91 = getelementptr inbounds [80 x i8], [80 x i8]* %9, i64 0, i64 0
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), i8* %91, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
store i32 1, i32* %2
br label %93
93: ; preds = %102, %88
%94 = load i32, i32* %2
%95 = icmp sle i32 %94, 12
br i1 %95, label %96, label %105
96: ; preds = %93
%97 = load i32, i32* %2
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %11, i64 0, i64 %98
%100 = getelementptr inbounds [5 x i8], [5 x i8]* %99, i64 0, i64 0
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %100)
br label %102
102: ; preds = %96
%103 = load i32, i32* %2
%104 = add nsw i32 %103, 1
store i32 %104, i32* %2
br label %93
105: ; preds = %93
%106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
store i32 1, i32* %2
br label %107
107: ; preds = %138, %105
%108 = load i32, i32* %2
%109 = icmp sle i32 %108, 20
br i1 %109, label %110, label %141
110: ; preds = %107
%111 = load i32, i32* %2
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %10, i64 0, i64 %112
%114 = getelementptr inbounds [17 x i8], [17 x i8]* %113, i64 0, i64 0
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* %114)
store i32 1, i32* %3
br label %116
116: ; preds = %133, %110
%117 = load i32, i32* %3
%118 = icmp sle i32 %117, 12
br i1 %118, label %119, label %136
119: ; preds = %116
%120 = load float**, float*** %7
%121 = load i32, i32* %2
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float*, float** %120, i64 %122
%124 = load float*, float** %123
%125 = load i32, i32* %3
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %124, i64 %126
%128 = load float, float* %127
%129 = fpext float %128 to double
%130 = fadd double 5.000000e-01, %129
%131 = fptosi double %130 to i32
%132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 %131)
br label %133
133: ; preds = %119
%134 = load i32, i32* %3
%135 = add nsw i32 %134, 1
store i32 %135, i32* %3
br label %116
136: ; preds = %116
%137 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
br label %138
138: ; preds = %136
%139 = load i32, i32* %2
%140 = add nsw i32 %139, 1
store i32 %140, i32* %2
br label %107
141: ; preds = %107
%142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.12, i64 0, i64 0))
%143 = call i32 (...) @getchar()
store i32 1, i32* %3
br label %144
144: ; preds = %212, %141
%145 = load i32, i32* %3
%146 = icmp sle i32 %145, 12
br i1 %146, label %147, label %215
147: ; preds = %144
store i32 1, i32* %2
br label %148
148: ; preds = %171, %147
%149 = load i32, i32* %2
%150 = icmp sle i32 %149, 20
br i1 %150, label %151, label %174
151: ; preds = %148
%152 = load float**, float*** %7
%153 = load i32, i32* %2
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float*, float** %152, i64 %154
%156 = load float*, float** %155
%157 = load i32, i32* %3
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds float, float* %156, i64 %158
%160 = load float, float* %159
%161 = load float*, float** %4
%162 = load i32, i32* %2
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %161, i64 %163
store float %160, float* %164
%165 = load i32, i32* %2
%166 = sitofp i32 %165 to float
%167 = load float*, float** %5
%168 = load i32, i32* %2
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %167, i64 %169
store float %166, float* %170
br label %171
171: ; preds = %151
%172 = load i32, i32* %2
%173 = add nsw i32 %172, 1
store i32 %173, i32* %2
br label %148
174: ; preds = %148
%175 = load float*, float** %4
%176 = load float*, float** %5
%177 = call i32 @sort2(i32 20, float* %175, float* %176)
%178 = load float*, float** %4
%179 = load float*, float** %6
%180 = load i32, i32* %3
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
%183 = call i32 @crank(i32 20, float* %178, float* %182)
store i32 1, i32* %2
br label %184
184: ; preds = %208, %174
%185 = load i32, i32* %2
%186 = icmp sle i32 %185, 20
br i1 %186, label %187, label %211
187: ; preds = %184
%188 = load float*, float** %4
%189 = load i32, i32* %2
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %188, i64 %190
%192 = load float, float* %191
%193 = load float**, float*** %7
%194 = load float*, float** %5
%195 = load i32, i32* %2
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %194, i64 %196
%198 = load float, float* %197
%199 = fpext float %198 to double
%200 = fadd double 5.000000e-01, %199
%201 = fptosi double %200 to i32
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float*, float** %193, i64 %202
%204 = load float*, float** %203
%205 = load i32, i32* %3
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
store float %192, float* %207
br label %208
208: ; preds = %187
%209 = load i32, i32* %2
%210 = add nsw i32 %209, 1
store i32 %210, i32* %2
br label %184
211: ; preds = %184
br label %212
212: ; preds = %211
%213 = load i32, i32* %3
%214 = add nsw i32 %213, 1
store i32 %214, i32* %3
br label %144
215: ; preds = %144
%216 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
store i32 1, i32* %2
br label %217
217: ; preds = %226, %215
%218 = load i32, i32* %2
%219 = icmp sle i32 %218, 12
br i1 %219, label %220, label %229
220: ; preds = %217
%221 = load i32, i32* %2
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %11, i64 0, i64 %222
%224 = getelementptr inbounds [5 x i8], [5 x i8]* %223, i64 0, i64 0
%225 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %224)
br label %226
226: ; preds = %220
%227 = load i32, i32* %2
%228 = add nsw i32 %227, 1
store i32 %228, i32* %2
br label %217
229: ; preds = %217
%230 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
store i32 1, i32* %2
br label %231
231: ; preds = %262, %229
%232 = load i32, i32* %2
%233 = icmp sle i32 %232, 20
br i1 %233, label %234, label %265
234: ; preds = %231
%235 = load i32, i32* %2
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %10, i64 0, i64 %236
%238 = getelementptr inbounds [17 x i8], [17 x i8]* %237, i64 0, i64 0
%239 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* %238)
store i32 1, i32* %3
br label %240
240: ; preds = %257, %234
%241 = load i32, i32* %3
%242 = icmp sle i32 %241, 12
br i1 %242, label %243, label %260
243: ; preds = %240
%244 = load float**, float*** %7
%245 = load i32, i32* %2
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float*, float** %244, i64 %246
%248 = load float*, float** %247
%249 = load i32, i32* %3
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %248, i64 %250
%252 = load float, float* %251
%253 = fpext float %252 to double
%254 = fadd double 5.000000e-01, %253
%255 = fptosi double %254 to i32
%256 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 %255)
br label %257
257: ; preds = %243
%258 = load i32, i32* %3
%259 = add nsw i32 %258, 1
store i32 %259, i32* %3
br label %240
260: ; preds = %240
%261 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
br label %262
262: ; preds = %260
%263 = load i32, i32* %2
%264 = add nsw i32 %263, 1
store i32 %264, i32* %2
br label %231
265: ; preds = %231
%266 = load float**, float*** %7
%267 = call i32 @free_matrix(float** %266, i32 1, i32 20, i32 1, i32 12)
%268 = load float*, float** %6
%269 = call i32 @free_vector(float* %268, i32 1, i32 12)
%270 = load float*, float** %5
%271 = call i32 @free_vector(float* %270, i32 1, i32 20)
%272 = load float*, float** %4
%273 = call i32 @free_vector(float* %272, i32 1, i32 20)
ret i32 0
}

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