#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_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
float **matrix(int, int, int, int);
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ spear(float *, float *, int, float *, float *, float *,
                         float *, float *);
float *vector(int, int);
int main(void) {
  int i, j;
  float d, probd, probrs, rs, zd, *ave, *data1, *data2, *zlat, **rays;
  char dummy[80], txt[80], city[20 + 1][17], mon[12 + 1][5];
  FILE *fp;
  ave = vector(1, 20);
  data1 = vector(1, 20);
  data2 = vector(1, 20);
  zlat = vector(1, 20);
  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]);
    fscanf(fp, "%f %f ", &ave[i], &zlat[i]);
  }
  fclose(fp);
  printf("%s\n", txt);
  printf("%16s", " ");
  for (i = 1; i <= 12; i++)
    printf("%4s", 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("\nAre sunny summer places also sunny winter places?\n");
  printf("Check correlation of sampled U.S. solar radiation\n");
  printf("(july with other months)\n\n");
  printf("%s %9s %14s %11s %15s %10s\n", "month", "d", "st. dev.", "probd",
         "spearman-r", "probrs");
  for (i = 1; i <= 20; i++)
    data1[i] = rays[i][1];
  for (j = 1; j <= 12; j++) {
    for (i = 1; i <= 20; i++)
      data2[i] = rays[i][j];
    spear(data1, data2, 20, &d, &zd, &probd, &rs, &probrs);
    printf("%4s %12.2f %12.6f %12.6f %13.6f %12.6f\n", mon[j], d, zd, probd, rs,
           probrs);
  }
  free_matrix(rays, 1, 20, 1, 12);
  free_vector(zlat, 1, 20);
  free_vector(data2, 1, 20);
  free_vector(data1, 1, 20);
  free_vector(ave, 1, 20);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2d0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10b0 <vector@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10b0 <vector@plt>
mov    %rax,-0x30(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10b0 <vector@plt>
mov    %rax,-0x38(%rbp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10b0 <vector@plt>
mov    %rax,-0x40(%rbp)
mov    $0x1,%edx
mov    $0x14,%esi
mov    $0xc,%ecx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0x48(%rbp)
lea    0xdd9(%rip),%rdi
lea    0xeed(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x2b8(%rbp)
cmp    $0x0,%rax
jne    1258 <main+0xa8>
lea    0xdc0(%rip),%rdi
call   1040 <nrerror@plt>
lea    -0xa0(%rbp),%rdi
mov    -0x2b8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
lea    -0xf0(%rbp),%rdi
mov    -0x2b8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
mov    -0x2b8(%rbp),%rdi
lea    0xd9d(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0xc,-0x8(%rbp)
jg     12e3 <main+0x133>
mov    -0x2b8(%rbp),%rdi
movslq -0x8(%rbp),%rax
lea    -0x2b0(%rbp),%rdx
imul   $0x5,%rax,%rax
add    %rax,%rdx
lea    0xd6b(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12a4 <main+0xf4>
lea    -0xa0(%rbp),%rdi
mov    -0x2b8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
lea    -0xa0(%rbp),%rdi
mov    -0x2b8(%rbp),%rdx
mov    $0x50,%esi
call   1090 <fgets@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     13ed <main+0x23d>
mov    -0x2b8(%rbp),%rdi
movslq -0x8(%rbp),%rax
lea    -0x260(%rbp),%rdx
imul   $0x11,%rax,%rax
add    %rax,%rdx
lea    0xcf9(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
movslq -0x8(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0x11,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x10(%rax)
movl   $0x1,-0xc(%rbp)
cmpl   $0xc,-0xc(%rbp)
jg     13ac <main+0x1fc>
mov    -0x2b8(%rbp),%rdi
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xcb5(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1368 <main+0x1b8>
mov    -0x2b8(%rbp),%rdi
mov    -0x28(%rbp),%rdx
movslq -0x8(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x40(%rbp),%rcx
movslq -0x8(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
lea    0xc77(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    131a <main+0x16a>
mov    -0x2b8(%rbp),%rdi
call   1050 <fclose@plt>
lea    -0xf0(%rbp),%rsi
lea    0xc4f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xc45(%rip),%rdi
lea    0xc38(%rip),%rsi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0xc,-0x8(%rbp)
jg     1462 <main+0x2b2>
movslq -0x8(%rbp),%rax
lea    -0x2b0(%rbp),%rsi
imul   $0x5,%rax,%rax
add    %rax,%rsi
lea    0xc12(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    142a <main+0x27a>
lea    0xc7e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     1513 <main+0x363>
movslq -0x8(%rbp),%rax
lea    -0x260(%rbp),%rsi
imul   $0x11,%rax,%rax
add    %rax,%rsi
lea    0xba0(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0xc(%rbp)
cmpl   $0xc,-0xc(%rbp)
jg     14f7 <main+0x347>
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb2d(%rip),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
lea    0xb81(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14a8 <main+0x2f8>
lea    0xbe9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1477 <main+0x2c7>
lea    0xb4d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xb73(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xb98(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xba5(%rip),%rdi
lea    0xbba(%rip),%rsi
lea    0xb13(%rip),%rdx
lea    0xbb2(%rip),%rcx
lea    0xbb4(%rip),%r8
lea    0xbb3(%rip),%r9
lea    0xbb7(%rip),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     15b6 <main+0x406>
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1580 <main+0x3d0>
movl   $0x1,-0xc(%rbp)
cmpl   $0xc,-0xc(%rbp)
jg     1692 <main+0x4e2>
movl   $0x1,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jg     1608 <main+0x458>
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    15ce <main+0x41e>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    $0x14,%edx
lea    -0x10(%rbp),%rcx
lea    -0x20(%rbp),%r8
lea    -0x14(%rbp),%r9
lea    -0x1c(%rbp),%r10
lea    -0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   10d0 <spear@plt>
movslq -0xc(%rbp),%rax
lea    -0x2b0(%rbp),%rsi
imul   $0x5,%rax,%rax
add    %rax,%rsi
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x14(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x1c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  -0x18(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
lea    0xaaf(%rip),%rdi
mov    $0x5,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15bd <main+0x40d>
mov    -0x48(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x14,%edx
mov    $0xc,%r8d
mov    %ecx,%esi
call   1030 <free_matrix@plt>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1070 <free_vector@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1070 <free_vector@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1070 <free_vector@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1070 <free_vector@plt>
xor    %eax,%eax
add    $0x2d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2b8,%rsp
mov    $0x1,%edi
mov    $0x14,%esi
call   10d0 <vector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    $0x14,%esi
call   10d0 <vector@plt>
mov    %rax,0x10(%rsp)
mov    $0x1,%edi
mov    $0x14,%esi
call   10d0 <vector@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    $0x14,%esi
call   10d0 <vector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    $0x14,%esi
mov    $0x1,%edx
mov    $0xc,%ecx
call   10c0 <matrix@plt>
mov    %rax,%rbx
lea    0xdba(%rip),%rdi
lea    0xe48(%rip),%rsi
call   10e0 <fopen@plt>
mov    %rax,%r14
test   %rax,%rax
jne    126e <main+0x9e>
lea    0xdaa(%rip),%rdi
call   1060 <nrerror@plt>
lea    0x100(%rsp),%rdi
mov    $0x50,%esi
mov    %r14,%rdx
call   10b0 <fgets@plt>
lea    0xb0(%rsp),%rdi
mov    $0x50,%esi
mov    %r14,%rdx
call   10b0 <fgets@plt>
lea    0xd94(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x35(%rsp),%rdx
lea    0xd84(%rip),%rbp
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x3a(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x3f(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x44(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x49(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x4e(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x53(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x58(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x5d(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x62(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x67(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x6c(%rsp),%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
lea    0x100(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x50,%esi
mov    %r14,%rdx
call   10b0 <fgets@plt>
mov    %rbp,%rdi
mov    $0x50,%esi
mov    %r14,%rdx
call   10b0 <fgets@plt>
mov    %r15,0xa0(%rsp)
add    $0x4,%r15
mov    %r15,0x8(%rsp)
mov    %r12,0xa8(%rsp)
add    $0x4,%r12
mov    %r12,(%rsp)
lea    0x161(%rsp),%rbp
lea    0xc6c(%rip),%r15
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14,%rdi
lea    0xc43(%rip),%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   10a0 <fscanf@plt>
movb   $0x0,0x10(%rbp)
mov    0x8(%rbx,%r12,2),%rdx
add    $0x4,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x8,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0xc,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x10,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x14,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x18,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x1c,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x20,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x24,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x28,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x2c,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    0x8(%rbx,%r12,2),%rdx
add    $0x30,%rdx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
mov    (%rsp),%rax
lea    (%rax,%r12,1),%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%r12,1),%rcx
mov    %r14,%rdi
lea    0xb24(%rip),%rsi
xor    %eax,%eax
call   10a0 <fscanf@plt>
add    $0x4,%r12
add    $0x11,%rbp
cmp    $0x50,%r12
jne    13f0 <main+0x220>
mov    %r14,%rdi
call   1070 <fclose@plt>
lea    0xb0(%rsp),%rdi
call   1040 <puts@plt>
lea    0xaf6(%rip),%rdi
lea    0xaed(%rip),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0xae6(%rip),%rbp
mov    %rbp,%rdi
lea    0x35(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x3a(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x3f(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x44(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x49(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x4e(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x53(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x58(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x5d(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x62(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x67(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %rbp,%rdi
lea    0x6c(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x161(%rsp),%rbp
mov    $0x1,%r14d
lea    0x9f2(%rip),%r12
lea    0xa10(%rip),%r15
nop
mov    %r12,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x98e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x967(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x944(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x921(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x8fe(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x18(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x8db(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x1c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x8b8(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x20(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x895(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x872(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x28(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x84f(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x2c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x82c(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    (%rbx,%r14,8),%rax
movss  0x30(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x809(%rip),%xmm0
cvttsd2si %xmm0,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
add    $0x11,%rbp
cmp    $0x15,%r14
jne    1650 <main+0x480>
lea    0x8a6(%rip),%rdi
call   1040 <puts@plt>
lea    0x8cd(%rip),%rdi
call   1040 <puts@plt>
lea    0x8f3(%rip),%rdi
call   1040 <puts@plt>
sub    $0x8,%rsp
lea    0x84f(%rip),%rbp
lea    0x80c(%rip),%rdi
lea    0x821(%rip),%rsi
lea    0x7fc(%rip),%rdx
lea    0x819(%rip),%rcx
lea    0x81b(%rip),%r8
lea    0x81a(%rip),%r9
xor    %r15d,%r15d
xor    %eax,%eax
push   %rbp
call   1080 <printf@plt>
add    $0x10,%rsp
mov    0x8(%rbx),%rax
movss  0x4(%rax),%xmm0
mov    0x10(%rsp),%rdi
movss  %xmm0,0x4(%rdi)
mov    0x10(%rbx),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,0x8(%rdi)
mov    0x18(%rbx),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,0xc(%rdi)
mov    0x20(%rbx),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,0x10(%rdi)
mov    0x28(%rbx),%rax
mov    %rax,0x8(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x14(%rdi)
mov    0x30(%rbx),%rax
mov    %rax,(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x18(%rdi)
mov    0x38(%rbx),%rax
mov    %rax,0x98(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x1c(%rdi)
mov    0x40(%rbx),%rax
mov    %rax,0x90(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x20(%rdi)
mov    0x48(%rbx),%rax
mov    %rax,0x88(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x24(%rdi)
mov    0x50(%rbx),%rax
mov    %rax,0x80(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x28(%rdi)
mov    0x58(%rbx),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,0x2c(%rdi)
mov    0x60(%rbx),%rcx
movss  0x4(%rcx),%xmm0
movss  %xmm0,0x30(%rdi)
mov    0x68(%rbx),%rdx
movss  0x4(%rdx),%xmm0
movss  %xmm0,0x34(%rdi)
mov    0x70(%rbx),%rsi
movss  0x4(%rsi),%xmm0
movss  %xmm0,0x38(%rdi)
mov    0x78(%rbx),%r12
movss  0x4(%r12),%xmm0
movss  %xmm0,0x3c(%rdi)
mov    0x80(%rbx),%r14
movss  0x4(%r14),%xmm0
movss  %xmm0,0x40(%rdi)
mov    0x88(%rbx),%r8
movss  0x4(%r8),%xmm0
movss  %xmm0,0x44(%rdi)
mov    0x90(%rbx),%r9
movss  0x4(%r9),%xmm0
movss  %xmm0,0x48(%rdi)
mov    0x98(%rbx),%r10
movss  0x4(%r10),%xmm0
movss  %xmm0,0x4c(%rdi)
mov    0xa0(%rbx),%r11
movss  0x4(%r11),%xmm0
movss  %xmm0,0x50(%rdi)
lea    0x35(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
mov    0x8(%rbx),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x4(%r13)
mov    0x10(%rbx),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x8(%r13)
mov    0x18(%rbx),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0xc(%r13)
mov    0x20(%rbx),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x10(%r13)
mov    0x8(%rsp),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x14(%r13)
mov    (%rsp),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x18(%r13)
mov    0x98(%rsp),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x1c(%r13)
mov    0x90(%rsp),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x20(%r13)
mov    0x88(%rsp),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x24(%r13)
mov    0x80(%rsp),%rdi
movss  0x4(%rdi,%r15,1),%xmm0
movss  %xmm0,0x28(%r13)
movss  0x4(%rax,%r15,1),%xmm0
movss  %xmm0,0x2c(%r13)
movss  0x4(%rcx,%r15,1),%xmm0
movss  %xmm0,0x30(%r13)
movss  0x4(%rdx,%r15,1),%xmm0
movss  %xmm0,0x34(%r13)
movss  0x4(%rsi,%r15,1),%xmm0
movss  %xmm0,0x38(%r13)
movss  0x4(%r12,%r15,1),%xmm0
movss  %xmm0,0x3c(%r13)
movss  0x4(%r14,%r15,1),%xmm0
movss  %xmm0,0x40(%r13)
movss  0x4(%r8,%r15,1),%xmm0
movss  %xmm0,0x44(%r13)
movss  0x4(%r9,%r15,1),%xmm0
movss  %xmm0,0x48(%r13)
movss  0x4(%r10,%r15,1),%xmm0
movss  %xmm0,0x4c(%r13)
movss  0x4(%r11,%r15,1),%xmm0
movss  %xmm0,0x50(%r13)
mov    0x10(%rsp),%rdi
mov    %r13,%rsi
mov    $0x14,%edx
lea    0x2c(%rsp),%rcx
lea    0x1c(%rsp),%r8
lea    0x28(%rsp),%r9
lea    0x24(%rsp),%rax
push   %rax
lea    0x28(%rsp),%rax
push   %rax
call   10f0 <spear@plt>
add    $0x10,%rsp
movss  0x2c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x1c(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x28(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x20(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x24(%rsp),%xmm4
cvtss2sd %xmm4,%xmm4
lea    0x50f(%rip),%rdi
mov    %rbp,%rsi
mov    $0x5,%al
call   1080 <printf@plt>
cmp    $0x2c,%r15
je     1c30 <main+0xa60>
mov    0x28(%rbx),%rax
mov    %rax,0x8(%rsp)
mov    0x30(%rbx),%rax
mov    %rax,(%rsp)
mov    0x38(%rbx),%rax
mov    %rax,0x98(%rsp)
mov    0x40(%rbx),%rax
mov    %rax,0x90(%rsp)
mov    0x48(%rbx),%rax
mov    %rax,0x88(%rsp)
mov    0x50(%rbx),%rax
mov    %rax,0x80(%rsp)
mov    0x58(%rbx),%rax
mov    0x60(%rbx),%rcx
mov    0x68(%rbx),%rdx
mov    0x70(%rbx),%rsi
mov    0x78(%rbx),%r12
mov    0x80(%rbx),%r14
mov    0x88(%rbx),%r8
mov    0x90(%rbx),%r9
mov    0x98(%rbx),%r10
add    $0x5,%rbp
add    $0x4,%r15
mov    0xa0(%rbx),%r11
jmp    19f0 <main+0x820>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
mov    $0x1,%ecx
mov    $0xc,%r8d
call   1050 <free_matrix@plt>
mov    0xa0(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1090 <free_vector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1090 <free_vector@plt>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1090 <free_vector@plt>
mov    0xa8(%rsp),%rdi
mov    $0x1,%esi
mov    $0x14,%edx
call   1090 <free_vector@plt>
xor    %eax,%eax
add    $0x2b8,%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 = [7 x i8] c"%f %f \00"
@.str.8 = [4 x i8] c"%s\0A\00"
@.str.9 = [5 x i8] c"%16s\00"
@.str.10 = [2 x i8] c" \00"
@.str.11 = [4 x i8] c"%4s\00"
@.str.12 = [2 x i8] c"\0A\00"
@.str.13 = [3 x i8] c"%s\00"
@.str.14 = [4 x i8] c"%4d\00"
@.str.15 = [52 x i8] c"\0AAre sunny summer places also sunny winter places?\0A\00"
@.str.16 = [51 x i8] c"Check correlation of sampled U.S. solar radiation\0A\00"
@.str.17 = [27 x i8] c"(july with other months)\0A\0A\00"
@.str.18 = [28 x i8] c"%s %9s %14s %11s %15s %10s\0A\00"
@.str.19 = [6 x i8] c"month\00"
@.str.20 = [2 x i8] c"d\00"
@.str.21 = [9 x i8] c"st. dev.\00"
@.str.22 = [6 x i8] c"probd\00"
@.str.23 = [11 x i8] c"spearman-r\00"
@.str.24 = [7 x i8] c"probrs\00"
@.str.25 = [40 x i8] c"%4s %12.2f %12.6f %12.6f %13.6f %12.6f\0A\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 float
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca float**
%14 = alloca [80 x i8]
%15 = alloca [80 x i8]
%16 = alloca [21 x [17 x i8]]
%17 = alloca [13 x [5 x i8]]
%18 = alloca i32*
store i32 0, i32* %1
%19 = call float* @vector(i32 1, i32 20)
store float* %19, float** %9
%20 = call float* @vector(i32 1, i32 20)
store float* %20, float** %10
%21 = call float* @vector(i32 1, i32 20)
store float* %21, float** %11
%22 = call float* @vector(i32 1, i32 20)
store float* %22, float** %12
%23 = call float** @matrix(i32 1, i32 20, i32 1, i32 12)
store float** %23, float*** %13
%24 = 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* %24, i32** %18
%25 = icmp eq i32* %24, null
br i1 %25, label %26, label %28
26: ; preds = %0
%27 = call i32 @nrerror(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
br label %28
28: ; preds = %26, %0
%29 = getelementptr inbounds [80 x i8], [80 x i8]* %14, i64 0, i64 0
%30 = load i32*, i32** %18
%31 = call i32 @fgets(i8* %29, i32 80, i32* %30)
%32 = getelementptr inbounds [80 x i8], [80 x i8]* %15, i64 0, i64 0
%33 = load i32*, i32** %18
%34 = call i32 @fgets(i8* %32, i32 80, i32* %33)
%35 = load i32*, i32** %18
%36 = call i32 (i32*, i8*, ...) @fscanf(i32* %35, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %2
br label %37
37: ; preds = %47, %28
%38 = load i32, i32* %2
%39 = icmp sle i32 %38, 12
br i1 %39, label %40, label %50
40: ; preds = %37
%41 = load i32*, i32** %18
%42 = load i32, i32* %2
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %17, i64 0, i64 %43
%45 = getelementptr inbounds [5 x i8], [5 x i8]* %44, i64 0, i64 0
%46 = call i32 (i32*, i8*, ...) @fscanf(i32* %41, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %45)
br label %47
47: ; preds = %40
%48 = load i32, i32* %2
%49 = add nsw i32 %48, 1
store i32 %49, i32* %2
br label %37
50: ; preds = %37
%51 = getelementptr inbounds [80 x i8], [80 x i8]* %14, i64 0, i64 0
%52 = load i32*, i32** %18
%53 = call i32 @fgets(i8* %51, i32 80, i32* %52)
%54 = getelementptr inbounds [80 x i8], [80 x i8]* %14, i64 0, i64 0
%55 = load i32*, i32** %18
%56 = call i32 @fgets(i8* %54, i32 80, i32* %55)
store i32 1, i32* %2
br label %57
57: ; preds = %99, %50
%58 = load i32, i32* %2
%59 = icmp sle i32 %58, 20
br i1 %59, label %60, label %102
60: ; preds = %57
%61 = load i32*, i32** %18
%62 = load i32, i32* %2
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %16, i64 0, i64 %63
%65 = getelementptr inbounds [17 x i8], [17 x i8]* %64, i64 0, i64 0
%66 = call i32 (i32*, i8*, ...) @fscanf(i32* %61, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), i8* %65)
%67 = load i32, i32* %2
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %16, i64 0, i64 %68
%70 = getelementptr inbounds [17 x i8], [17 x i8]* %69, i64 0, i64 16
store i8 0, i8* %70
store i32 1, i32* %3
br label %71
71: ; preds = %85, %60
%72 = load i32, i32* %3
%73 = icmp sle i32 %72, 12
br i1 %73, label %74, label %88
74: ; preds = %71
%75 = load i32*, i32** %18
%76 = load float**, float*** %13
%77 = load i32, i32* %2
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float*, float** %76, i64 %78
%80 = load float*, float** %79
%81 = load i32, i32* %3
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %80, i64 %82
%84 = call i32 (i32*, i8*, ...) @fscanf(i32* %75, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %83)
br label %85
85: ; preds = %74
%86 = load i32, i32* %3
%87 = add nsw i32 %86, 1
store i32 %87, i32* %3
br label %71
88: ; preds = %71
%89 = load i32*, i32** %18
%90 = load float*, float** %9
%91 = load i32, i32* %2
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %90, i64 %92
%94 = load float*, float** %12
%95 = load i32, i32* %2
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %94, i64 %96
%98 = call i32 (i32*, i8*, ...) @fscanf(i32* %89, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), float* %93, float* %97)
br label %99
99: ; preds = %88
%100 = load i32, i32* %2
%101 = add nsw i32 %100, 1
store i32 %101, i32* %2
br label %57
102: ; preds = %57
%103 = load i32*, i32** %18
%104 = call i32 @fclose(i32* %103)
%105 = getelementptr inbounds [80 x i8], [80 x i8]* %15, i64 0, i64 0
%106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i8* %105)
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
store i32 1, i32* %2
br label %108
108: ; preds = %117, %102
%109 = load i32, i32* %2
%110 = icmp sle i32 %109, 12
br i1 %110, label %111, label %120
111: ; preds = %108
%112 = load i32, i32* %2
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %17, i64 0, i64 %113
%115 = getelementptr inbounds [5 x i8], [5 x i8]* %114, i64 0, i64 0
%116 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %115)
br label %117
117: ; preds = %111
%118 = load i32, i32* %2
%119 = add nsw i32 %118, 1
store i32 %119, i32* %2
br label %108
120: ; preds = %108
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0))
store i32 1, i32* %2
br label %122
122: ; preds = %153, %120
%123 = load i32, i32* %2
%124 = icmp sle i32 %123, 20
br i1 %124, label %125, label %156
125: ; preds = %122
%126 = load i32, i32* %2
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %16, i64 0, i64 %127
%129 = getelementptr inbounds [17 x i8], [17 x i8]* %128, i64 0, i64 0
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* %129)
store i32 1, i32* %3
br label %131
131: ; preds = %148, %125
%132 = load i32, i32* %3
%133 = icmp sle i32 %132, 12
br i1 %133, label %134, label %151
134: ; preds = %131
%135 = load float**, float*** %13
%136 = load i32, i32* %2
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float*, float** %135, i64 %137
%139 = load float*, float** %138
%140 = load i32, i32* %3
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds float, float* %139, i64 %141
%143 = load float, float* %142
%144 = fpext float %143 to double
%145 = fadd double 5.000000e-01, %144
%146 = fptosi double %145 to i32
%147 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %146)
br label %148
148: ; preds = %134
%149 = load i32, i32* %3
%150 = add nsw i32 %149, 1
store i32 %150, i32* %3
br label %131
151: ; preds = %131
%152 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0))
br label %153
153: ; preds = %151
%154 = load i32, i32* %2
%155 = add nsw i32 %154, 1
store i32 %155, i32* %2
br label %122
156: ; preds = %122
%157 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.15, i64 0, i64 0))
%158 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.16, i64 0, i64 0))
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.17, i64 0, i64 0))
%160 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.23, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0))
store i32 1, i32* %2
br label %161
161: ; preds = %176, %156
%162 = load i32, i32* %2
%163 = icmp sle i32 %162, 20
br i1 %163, label %164, label %179
164: ; preds = %161
%165 = load float**, float*** %13
%166 = load i32, i32* %2
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float*, float** %165, i64 %167
%169 = load float*, float** %168
%170 = getelementptr inbounds float, float* %169, i64 1
%171 = load float, float* %170
%172 = load float*, float** %10
%173 = load i32, i32* %2
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %172, i64 %174
store float %171, float* %175
br label %176
176: ; preds = %164
%177 = load i32, i32* %2
%178 = add nsw i32 %177, 1
store i32 %178, i32* %2
br label %161
179: ; preds = %161
store i32 1, i32* %3
br label %180
180: ; preds = %223, %179
%181 = load i32, i32* %3
%182 = icmp sle i32 %181, 12
br i1 %182, label %183, label %226
183: ; preds = %180
store i32 1, i32* %2
br label %184
184: ; preds = %201, %183
%185 = load i32, i32* %2
%186 = icmp sle i32 %185, 20
br i1 %186, label %187, label %204
187: ; preds = %184
%188 = load float**, float*** %13
%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 i32, i32* %3
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds float, float* %192, i64 %194
%196 = load float, float* %195
%197 = load float*, float** %11
%198 = load i32, i32* %2
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds float, float* %197, i64 %199
store float %196, float* %200
br label %201
201: ; preds = %187
%202 = load i32, i32* %2
%203 = add nsw i32 %202, 1
store i32 %203, i32* %2
br label %184
204: ; preds = %184
%205 = load float*, float** %10
%206 = load float*, float** %11
%207 = call i32 @spear(float* %205, float* %206, i32 20, float* %4, float* %8, float* %5, float* %7, float* %6)
%208 = load i32, i32* %3
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %17, i64 0, i64 %209
%211 = getelementptr inbounds [5 x i8], [5 x i8]* %210, i64 0, i64 0
%212 = load float, float* %4
%213 = fpext float %212 to double
%214 = load float, float* %8
%215 = fpext float %214 to double
%216 = load float, float* %5
%217 = fpext float %216 to double
%218 = load float, float* %7
%219 = fpext float %218 to double
%220 = load float, float* %6
%221 = fpext float %220 to double
%222 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.25, i64 0, i64 0), i8* %211, double %213, double %215, double %217, double %219, double %221)
br label %223
223: ; preds = %204
%224 = load i32, i32* %3
%225 = add nsw i32 %224, 1
store i32 %225, i32* %3
br label %180
226: ; preds = %180
%227 = load float**, float*** %13
%228 = call i32 @free_matrix(float** %227, i32 1, i32 20, i32 1, i32 12)
%229 = load float*, float** %12
%230 = call i32 @free_vector(float* %229, i32 1, i32 20)
%231 = load float*, float** %11
%232 = call i32 @free_vector(float* %231, i32 1, i32 20)
%233 = load float*, float** %10
%234 = call i32 @free_vector(float* %233, i32 1, i32 20)
%235 = load float*, float** %9
%236 = call i32 @free_vector(float* %235, 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 = [7 x i8] c"%f %f \00"
@.str.9 = [5 x i8] c"%16s\00"
@.str.10 = [2 x i8] c" \00"
@.str.11 = [4 x i8] c"%4s\00"
@.str.13 = [3 x i8] c"%s\00"
@.str.14 = [4 x i8] c"%4d\00"
@.str.18 = [28 x i8] c"%s %9s %14s %11s %15s %10s\0A\00"
@.str.19 = [6 x i8] c"month\00"
@.str.20 = [2 x i8] c"d\00"
@.str.21 = [9 x i8] c"st. dev.\00"
@.str.22 = [6 x i8] c"probd\00"
@.str.23 = [11 x i8] c"spearman-r\00"
@.str.24 = [7 x i8] c"probrs\00"
@.str.25 = [40 x i8] c"%4s %12.2f %12.6f %12.6f %13.6f %12.6f\0A\00"
@str = [51 x i8] c"\0AAre sunny summer places also sunny winter places?\00"
@str.26 = [50 x i8] c"Check correlation of sampled U.S. solar radiation\00"
@str.27 = [26 x i8] c"(july with other months)\0A\00"
define i32 @main() {
%1 = alloca float
%2 = alloca float
%3 = alloca float
%4 = alloca float
%5 = alloca float
%6 = alloca [80 x i8]
%7 = alloca [80 x i8]
%8 = alloca [21 x [17 x i8]]
%9 = alloca [13 x [5 x i8]]
%10 = bitcast float* %1 to i8*
%11 = bitcast float* %2 to i8*
%12 = bitcast float* %3 to i8*
%13 = bitcast float* %4 to i8*
%14 = bitcast float* %5 to i8*
%15 = getelementptr inbounds [80 x i8], [80 x i8]* %6, i64 0, i64 0
%16 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 0
%17 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %8, i64 0, i64 0, i64 0
%18 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 0, i64 0
%19 = tail call float* @vector(i32 1, i32 20)
%20 = tail call float* @vector(i32 1, i32 20)
%21 = tail call float* @vector(i32 1, i32 20)
%22 = tail call float* @vector(i32 1, i32 20)
%23 = tail call float** @matrix(i32 1, i32 20, i32 1, i32 12)
%24 = 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))
%25 = icmp eq i32* %24, null
br i1 %25, label %26, label %28
26: ; preds = %0
%27 = tail call i32 @nrerror(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
br label %28
28: ; preds = %26, %0
%29 = call i32 @fgets(i8* %15, i32 80, i32* %24)
%30 = call i32 @fgets(i8* %16, i32 80, i32* %24)
%31 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
%32 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 1, i64 0
%33 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %32)
%34 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 2, i64 0
%35 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %34)
%36 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 3, i64 0
%37 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %36)
%38 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 4, i64 0
%39 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %38)
%40 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 5, i64 0
%41 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %40)
%42 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 6, i64 0
%43 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %42)
%44 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 7, i64 0
%45 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %44)
%46 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 8, i64 0
%47 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %46)
%48 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 9, i64 0
%49 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %48)
%50 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 10, i64 0
%51 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %50)
%52 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 11, i64 0
%53 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %52)
%54 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 12, i64 0
%55 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %54)
%56 = call i32 @fgets(i8* %15, i32 80, i32* %24)
%57 = call i32 @fgets(i8* %15, i32 80, i32* %24)
br label %58
58: ; preds = %28, %58
%59 = phi i64 [ 1, %28 ], [ %103, %58 ]
%60 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %8, i64 0, i64 %59, i64 0
%61 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), i8* %60)
%62 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %8, i64 0, i64 %59, i64 16
store i8 0, i8* %62
%63 = getelementptr inbounds float*, float** %23, i64 %59
%64 = load float*, float** %63
%65 = getelementptr inbounds float, float* %64, i64 1
%66 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %65)
%67 = load float*, float** %63
%68 = getelementptr inbounds float, float* %67, i64 2
%69 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %68)
%70 = load float*, float** %63
%71 = getelementptr inbounds float, float* %70, i64 3
%72 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %71)
%73 = load float*, float** %63
%74 = getelementptr inbounds float, float* %73, i64 4
%75 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %74)
%76 = load float*, float** %63
%77 = getelementptr inbounds float, float* %76, i64 5
%78 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %77)
%79 = load float*, float** %63
%80 = getelementptr inbounds float, float* %79, i64 6
%81 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %80)
%82 = load float*, float** %63
%83 = getelementptr inbounds float, float* %82, i64 7
%84 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %83)
%85 = load float*, float** %63
%86 = getelementptr inbounds float, float* %85, i64 8
%87 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %86)
%88 = load float*, float** %63
%89 = getelementptr inbounds float, float* %88, i64 9
%90 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %89)
%91 = load float*, float** %63
%92 = getelementptr inbounds float, float* %91, i64 10
%93 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %92)
%94 = load float*, float** %63
%95 = getelementptr inbounds float, float* %94, i64 11
%96 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %95)
%97 = load float*, float** %63
%98 = getelementptr inbounds float, float* %97, i64 12
%99 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), float* %98)
%100 = getelementptr inbounds float, float* %19, i64 %59
%101 = getelementptr inbounds float, float* %22, i64 %59
%102 = call i32 (i32*, i8*, ...) @fscanf(i32* %24, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), float* %100, float* %101)
%103 = add nuw nsw i64 %59, 1
%104 = icmp eq i64 %103, 21
br i1 %104, label %105, label %58
105: ; preds = %58
%106 = call i32 @fclose(i32* %24)
%107 = call i32 @puts(i8* %16)
%108 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
%109 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %32)
%110 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %34)
%111 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %36)
%112 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %38)
%113 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %40)
%114 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %42)
%115 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %44)
%116 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %46)
%117 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %48)
%118 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %50)
%119 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %52)
%120 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %54)
%121 = call i32 @putchar(i32 10)
br label %122
122: ; preds = %105, %122
%123 = phi i64 [ 1, %105 ], [ %212, %122 ]
%124 = getelementptr inbounds [21 x [17 x i8]], [21 x [17 x i8]]* %8, i64 0, i64 %123, i64 0
%125 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* %124)
%126 = getelementptr inbounds float*, float** %23, i64 %123
%127 = load float*, float** %126
%128 = getelementptr inbounds float, float* %127, i64 1
%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.14, i64 0, i64 0), i32 %132)
%134 = load float*, float** %126
%135 = getelementptr inbounds float, float* %134, i64 2
%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.14, i64 0, i64 0), i32 %139)
%141 = load float*, float** %126
%142 = getelementptr inbounds float, float* %141, i64 3
%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.14, i64 0, i64 0), i32 %146)
%148 = load float*, float** %126
%149 = getelementptr inbounds float, float* %148, i64 4
%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.14, i64 0, i64 0), i32 %153)
%155 = load float*, float** %126
%156 = getelementptr inbounds float, float* %155, i64 5
%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.14, i64 0, i64 0), i32 %160)
%162 = load float*, float** %126
%163 = getelementptr inbounds float, float* %162, i64 6
%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.14, i64 0, i64 0), i32 %167)
%169 = load float*, float** %126
%170 = getelementptr inbounds float, float* %169, i64 7
%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.14, i64 0, i64 0), i32 %174)
%176 = load float*, float** %126
%177 = getelementptr inbounds float, float* %176, i64 8
%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.14, i64 0, i64 0), i32 %181)
%183 = load float*, float** %126
%184 = getelementptr inbounds float, float* %183, i64 9
%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.14, i64 0, i64 0), i32 %188)
%190 = load float*, float** %126
%191 = getelementptr inbounds float, float* %190, i64 10
%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.14, i64 0, i64 0), i32 %195)
%197 = load float*, float** %126
%198 = getelementptr inbounds float, float* %197, i64 11
%199 = load float, float* %198
%200 = fpext float %199 to double
%201 = fadd double %200, 5.000000e-01
%202 = fptosi double %201 to i32
%203 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %202)
%204 = load float*, float** %126
%205 = getelementptr inbounds float, float* %204, i64 12
%206 = load float, float* %205
%207 = fpext float %206 to double
%208 = fadd double %207, 5.000000e-01
%209 = fptosi double %208 to i32
%210 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %209)
%211 = call i32 @putchar(i32 10)
%212 = add nuw nsw i64 %123, 1
%213 = icmp eq i64 %212, 21
br i1 %213, label %214, label %122
214: ; preds = %122
%215 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str, i64 0, i64 0))
%216 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @str.26, i64 0, i64 0))
%217 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.27, i64 0, i64 0))
%218 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.23, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0))
%219 = getelementptr inbounds float*, float** %23, i64 1
%220 = load float*, float** %219
%221 = getelementptr inbounds float, float* %220, i64 1
%222 = load float, float* %221
%223 = getelementptr inbounds float, float* %20, i64 1
store float %222, float* %223
%224 = getelementptr inbounds float*, float** %23, i64 2
%225 = load float*, float** %224
%226 = getelementptr inbounds float, float* %225, i64 1
%227 = load float, float* %226
%228 = getelementptr inbounds float, float* %20, i64 2
store float %227, float* %228
%229 = getelementptr inbounds float*, float** %23, i64 3
%230 = load float*, float** %229
%231 = getelementptr inbounds float, float* %230, i64 1
%232 = load float, float* %231
%233 = getelementptr inbounds float, float* %20, i64 3
store float %232, float* %233
%234 = getelementptr inbounds float*, float** %23, i64 4
%235 = load float*, float** %234
%236 = getelementptr inbounds float, float* %235, i64 1
%237 = load float, float* %236
%238 = getelementptr inbounds float, float* %20, i64 4
store float %237, float* %238
%239 = getelementptr inbounds float*, float** %23, i64 5
%240 = load float*, float** %239
%241 = getelementptr inbounds float, float* %240, i64 1
%242 = load float, float* %241
%243 = getelementptr inbounds float, float* %20, i64 5
store float %242, float* %243
%244 = getelementptr inbounds float*, float** %23, i64 6
%245 = load float*, float** %244
%246 = getelementptr inbounds float, float* %245, i64 1
%247 = load float, float* %246
%248 = getelementptr inbounds float, float* %20, i64 6
store float %247, float* %248
%249 = getelementptr inbounds float*, float** %23, i64 7
%250 = load float*, float** %249
%251 = getelementptr inbounds float, float* %250, i64 1
%252 = load float, float* %251
%253 = getelementptr inbounds float, float* %20, i64 7
store float %252, float* %253
%254 = getelementptr inbounds float*, float** %23, i64 8
%255 = load float*, float** %254
%256 = getelementptr inbounds float, float* %255, i64 1
%257 = load float, float* %256
%258 = getelementptr inbounds float, float* %20, i64 8
store float %257, float* %258
%259 = getelementptr inbounds float*, float** %23, i64 9
%260 = load float*, float** %259
%261 = getelementptr inbounds float, float* %260, i64 1
%262 = load float, float* %261
%263 = getelementptr inbounds float, float* %20, i64 9
store float %262, float* %263
%264 = getelementptr inbounds float*, float** %23, i64 10
%265 = load float*, float** %264
%266 = getelementptr inbounds float, float* %265, i64 1
%267 = load float, float* %266
%268 = getelementptr inbounds float, float* %20, i64 10
store float %267, float* %268
%269 = getelementptr inbounds float*, float** %23, i64 11
%270 = load float*, float** %269
%271 = getelementptr inbounds float, float* %270, i64 1
%272 = load float, float* %271
%273 = getelementptr inbounds float, float* %20, i64 11
store float %272, float* %273
%274 = getelementptr inbounds float*, float** %23, i64 12
%275 = load float*, float** %274
%276 = getelementptr inbounds float, float* %275, i64 1
%277 = load float, float* %276
%278 = getelementptr inbounds float, float* %20, i64 12
store float %277, float* %278
%279 = getelementptr inbounds float*, float** %23, i64 13
%280 = load float*, float** %279
%281 = getelementptr inbounds float, float* %280, i64 1
%282 = load float, float* %281
%283 = getelementptr inbounds float, float* %20, i64 13
store float %282, float* %283
%284 = getelementptr inbounds float*, float** %23, i64 14
%285 = load float*, float** %284
%286 = getelementptr inbounds float, float* %285, i64 1
%287 = load float, float* %286
%288 = getelementptr inbounds float, float* %20, i64 14
store float %287, float* %288
%289 = getelementptr inbounds float*, float** %23, i64 15
%290 = load float*, float** %289
%291 = getelementptr inbounds float, float* %290, i64 1
%292 = load float, float* %291
%293 = getelementptr inbounds float, float* %20, i64 15
store float %292, float* %293
%294 = getelementptr inbounds float*, float** %23, i64 16
%295 = load float*, float** %294
%296 = getelementptr inbounds float, float* %295, i64 1
%297 = load float, float* %296
%298 = getelementptr inbounds float, float* %20, i64 16
store float %297, float* %298
%299 = getelementptr inbounds float*, float** %23, i64 17
%300 = load float*, float** %299
%301 = getelementptr inbounds float, float* %300, i64 1
%302 = load float, float* %301
%303 = getelementptr inbounds float, float* %20, i64 17
store float %302, float* %303
%304 = getelementptr inbounds float*, float** %23, i64 18
%305 = load float*, float** %304
%306 = getelementptr inbounds float, float* %305, i64 1
%307 = load float, float* %306
%308 = getelementptr inbounds float, float* %20, i64 18
store float %307, float* %308
%309 = getelementptr inbounds float*, float** %23, i64 19
%310 = load float*, float** %309
%311 = getelementptr inbounds float, float* %310, i64 1
%312 = load float, float* %311
%313 = getelementptr inbounds float, float* %20, i64 19
store float %312, float* %313
%314 = getelementptr inbounds float*, float** %23, i64 20
%315 = load float*, float** %314
%316 = getelementptr inbounds float, float* %315, i64 1
%317 = load float, float* %316
%318 = getelementptr inbounds float, float* %20, i64 20
store float %317, float* %318
%319 = getelementptr inbounds float, float* %21, i64 1
%320 = getelementptr inbounds float, float* %21, i64 2
%321 = getelementptr inbounds float, float* %21, i64 3
%322 = getelementptr inbounds float, float* %21, i64 4
%323 = getelementptr inbounds float, float* %21, i64 5
%324 = getelementptr inbounds float, float* %21, i64 6
%325 = getelementptr inbounds float, float* %21, i64 7
%326 = getelementptr inbounds float, float* %21, i64 8
%327 = getelementptr inbounds float, float* %21, i64 9
%328 = getelementptr inbounds float, float* %21, i64 10
%329 = getelementptr inbounds float, float* %21, i64 11
%330 = getelementptr inbounds float, float* %21, i64 12
%331 = getelementptr inbounds float, float* %21, i64 13
%332 = getelementptr inbounds float, float* %21, i64 14
%333 = getelementptr inbounds float, float* %21, i64 15
%334 = getelementptr inbounds float, float* %21, i64 16
%335 = getelementptr inbounds float, float* %21, i64 17
%336 = getelementptr inbounds float, float* %21, i64 18
%337 = getelementptr inbounds float, float* %21, i64 19
%338 = getelementptr inbounds float, float* %21, i64 20
br label %339
339: ; preds = %416, %214
%340 = phi float* [ %315, %214 ], [ %432, %416 ]
%341 = phi float* [ %310, %214 ], [ %431, %416 ]
%342 = phi float* [ %305, %214 ], [ %430, %416 ]
%343 = phi float* [ %300, %214 ], [ %429, %416 ]
%344 = phi float* [ %295, %214 ], [ %428, %416 ]
%345 = phi float* [ %290, %214 ], [ %427, %416 ]
%346 = phi float* [ %285, %214 ], [ %426, %416 ]
%347 = phi float* [ %280, %214 ], [ %425, %416 ]
%348 = phi float* [ %275, %214 ], [ %424, %416 ]
%349 = phi float* [ %270, %214 ], [ %423, %416 ]
%350 = phi float* [ %265, %214 ], [ %422, %416 ]
%351 = phi float* [ %260, %214 ], [ %421, %416 ]
%352 = phi float* [ %255, %214 ], [ %420, %416 ]
%353 = phi float* [ %250, %214 ], [ %419, %416 ]
%354 = phi float* [ %245, %214 ], [ %418, %416 ]
%355 = phi float* [ %240, %214 ], [ %417, %416 ]
%356 = phi i64 [ 1, %214 ], [ %414, %416 ]
%357 = load float*, float** %219
%358 = getelementptr inbounds float, float* %357, i64 %356
%359 = load float, float* %358
store float %359, float* %319
%360 = load float*, float** %224
%361 = getelementptr inbounds float, float* %360, i64 %356
%362 = load float, float* %361
store float %362, float* %320
%363 = load float*, float** %229
%364 = getelementptr inbounds float, float* %363, i64 %356
%365 = load float, float* %364
store float %365, float* %321
%366 = load float*, float** %234
%367 = getelementptr inbounds float, float* %366, i64 %356
%368 = load float, float* %367
store float %368, float* %322
%369 = getelementptr inbounds float, float* %355, i64 %356
%370 = load float, float* %369
store float %370, float* %323
%371 = getelementptr inbounds float, float* %354, i64 %356
%372 = load float, float* %371
store float %372, float* %324
%373 = getelementptr inbounds float, float* %353, i64 %356
%374 = load float, float* %373
store float %374, float* %325
%375 = getelementptr inbounds float, float* %352, i64 %356
%376 = load float, float* %375
store float %376, float* %326
%377 = getelementptr inbounds float, float* %351, i64 %356
%378 = load float, float* %377
store float %378, float* %327
%379 = getelementptr inbounds float, float* %350, i64 %356
%380 = load float, float* %379
store float %380, float* %328
%381 = getelementptr inbounds float, float* %349, i64 %356
%382 = load float, float* %381
store float %382, float* %329
%383 = getelementptr inbounds float, float* %348, i64 %356
%384 = load float, float* %383
store float %384, float* %330
%385 = getelementptr inbounds float, float* %347, i64 %356
%386 = load float, float* %385
store float %386, float* %331
%387 = getelementptr inbounds float, float* %346, i64 %356
%388 = load float, float* %387
store float %388, float* %332
%389 = getelementptr inbounds float, float* %345, i64 %356
%390 = load float, float* %389
store float %390, float* %333
%391 = getelementptr inbounds float, float* %344, i64 %356
%392 = load float, float* %391
store float %392, float* %334
%393 = getelementptr inbounds float, float* %343, i64 %356
%394 = load float, float* %393
store float %394, float* %335
%395 = getelementptr inbounds float, float* %342, i64 %356
%396 = load float, float* %395
store float %396, float* %336
%397 = getelementptr inbounds float, float* %341, i64 %356
%398 = load float, float* %397
store float %398, float* %337
%399 = getelementptr inbounds float, float* %340, i64 %356
%400 = load float, float* %399
store float %400, float* %338
%401 = call i32 @spear(float* %20, float* %21, i32 20, float* %1, float* %5, float* %2, float* %4, float* %3)
%402 = getelementptr inbounds [13 x [5 x i8]], [13 x [5 x i8]]* %9, i64 0, i64 %356, i64 0
%403 = load float, float* %1
%404 = fpext float %403 to double
%405 = load float, float* %5
%406 = fpext float %405 to double
%407 = load float, float* %2
%408 = fpext float %407 to double
%409 = load float, float* %4
%410 = fpext float %409 to double
%411 = load float, float* %3
%412 = fpext float %411 to double
%413 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.25, i64 0, i64 0), i8* %402, double %404, double %406, double %408, double %410, double %412)
%414 = add nuw nsw i64 %356, 1
%415 = icmp eq i64 %414, 13
br i1 %415, label %433, label %416
416: ; preds = %339
%417 = load float*, float** %239
%418 = load float*, float** %244
%419 = load float*, float** %249
%420 = load float*, float** %254
%421 = load float*, float** %259
%422 = load float*, float** %264
%423 = load float*, float** %269
%424 = load float*, float** %274
%425 = load float*, float** %279
%426 = load float*, float** %284
%427 = load float*, float** %289
%428 = load float*, float** %294
%429 = load float*, float** %299
%430 = load float*, float** %304
%431 = load float*, float** %309
%432 = load float*, float** %314
br label %339
433: ; preds = %339
%434 = call i32 @free_matrix(float** %23, i32 1, i32 20, i32 1, i32 12)
%435 = call i32 @free_vector(float* %22, i32 1, i32 20)
%436 = call i32 @free_vector(float* %21, i32 1, i32 20)
%437 = call i32 @free_vector(float* %20, i32 1, i32 20)
%438 = call i32 @free_vector(float* %19, i32 1, i32 20)
ret i32 0
}