#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 */

/* Variables and functions */
float log(float);
int /*<<< orphan*/ printf(char *, ...);
main() {
  int i;
  float RA = 5000, RB = 4000, R0[10], T0[10], X[10], Y[10], Xaver = 0,
        Yaver = 0, b = 0, xxyaver = 0, xxxaver = 0, a, lnR[10];
  float RS[10] = {4690, 4100, 3700, 3240, 2900, 2580, 2390, 2130, 1930, 1730},
        C0[10] = {21.3, 24.8, 27.2, 30.1, 33.1, 36.8, 39.3, 42.3, 45.2, 48.1};
  for (i = 0; i < 10; i++) {
    R0[i] = RS[i] * RA / RB;
    Y[i] = log(R0[i]);
    T0[i] = C0[i] + 273.15;
    X[i] = 1 / T0[i] - 1 / T0[0];
    lnR[i] = log(R0[i]);
  }
  for (i = 0; i < 10; i++) {
    xxxaver += X[i] * X[i];
    xxyaver += X[i] * Y[i];
    Xaver += X[i];
    Yaver += Y[i];
  }
  xxxaver /= 10;
  xxyaver /= 10;
  Xaver /= 10;
  Yaver /= 10;
  b = (Xaver * Yaver - xxyaver) / (Xaver * Xaver - xxxaver);
  a = -b / (T0[0] * T0[0]);
  printf("b:%f   a:%f\n", b, a);
  printf("RT:\n");
  for (i = 0; i < 10; i++)
    printf("%.2f\n", R0[i]);
  printf("lnR:\n");
  for (i = 0; i < 10; i++)
    printf("%.2f\n", lnR[i]);
  printf("T:\n");
  for (i = 0; i < 10; i++)
    printf("%.1f\n", T0[i]);
  printf("1000/T:\n");
  for (i = 0; i < 10; i++)
    printf("%.2f\n", 1000 / T0[i]);
  printf("(1/T-1/T0)*1000:\n");
  for (i = 0; i < 10; i++)
    printf("%.2f\n", 1000 * X[i]);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
movl   $0x0,-0x4(%rbp)
movss  0xeba(%rip),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  0xea9(%rip),%xmm0
movss  %xmm0,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
lea    -0x140(%rbp),%rdi
lea    0xe7f(%rip),%rsi
mov    $0x28,%edx
call   1040 <memcpy@plt>
lea    -0x170(%rbp),%rdi
lea    0xe97(%rip),%rsi
mov    $0x28,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jge    1296 <main+0x166>
movslq -0x8(%rbp),%rax
movss  -0x140(%rbp,%rax,4),%xmm0
ff ff
mulss  -0xc(%rbp),%xmm0
divss  -0x10(%rbp),%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x40(%rbp,%rax,4)
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
call   1050 <log@plt>
movslq -0x8(%rbp),%rax
movss  %xmm0,-0xd0(%rbp,%rax,4)
ff ff
movslq -0x8(%rbp),%rax
movss  -0x170(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
movsd  0xdee(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
movslq -0x8(%rbp),%rax
movss  0xdc8(%rip),%xmm0
divss  -0x70(%rbp,%rax,4),%xmm0
movss  0xdba(%rip),%xmm1
divss  -0x70(%rbp),%xmm1
subss  %xmm1,%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0xa0(%rbp,%rax,4)
ff ff
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
call   1050 <log@plt>
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11ca <main+0x9a>
movl   $0x0,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jge    1353 <main+0x223>
movslq -0x8(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x8(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm2
ff ff
movss  -0xe4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x8(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
movss  -0xe0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
addss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xd4(%rbp)
ff
movslq -0x8(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
addss  -0xd8(%rbp),%xmm0
ff
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    129d <main+0x16d>
movss  -0xe4(%rbp),%xmm0
ff
movss  0xca5(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  0xc89(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  0xc6d(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  0xc51(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xd8(%rbp),%xmm2
ff
movss  -0xe0(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xd4(%rbp),%xmm1
ff
movss  -0xd4(%rbp),%xmm3
ff
movss  -0xe4(%rbp),%xmm2
ff
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x70(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0xe8(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0xc05(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
lea    0xc04(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jge    14c3 <main+0x393>
movslq -0x8(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbdc(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    148f <main+0x35f>
lea    0xbc6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jge    150f <main+0x3df>
movslq -0x8(%rbp),%rax
movss  -0x110(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0xb90(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    14d8 <main+0x3a8>
lea    0xb8b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jge    1558 <main+0x428>
movslq -0x8(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb53(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1524 <main+0x3f4>
lea    0xb3d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jge    15a9 <main+0x479>
movslq -0x8(%rbp),%rax
movss  0xa89(%rip),%xmm0
divss  -0x70(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xaf6(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    156d <main+0x43d>
lea    0xaf5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jge    15fd <main+0x4cd>
movslq -0x8(%rbp),%rax
movss  0xa38(%rip),%xmm0
mulss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0xaa2(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    15be <main+0x48e>
mov    -0x4(%rbp),%eax
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %rbx
sub    $0x120,%rsp
xor    %ebx,%ebx
lea    0xf0b(%rip),%r14
lea    0xf34(%rip),%r15
nopl   0x0(%rax)
movss  (%rbx,%r14,1),%xmm0
mulss  0xea2(%rip),%xmm0
divss  0xe9e(%rip),%xmm0
movss  %xmm0,0xc(%rsp)
movss  %xmm0,0xf0(%rsp,%rbx,1)
call   1050 <log@plt>
movss  %xmm0,0xc0(%rsp,%rbx,1)
movss  (%rbx,%r15,1),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xe7b(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x60(%rsp,%rbx,1)
movss  0xe61(%rip),%xmm3
movaps %xmm3,%xmm1
divss  %xmm0,%xmm1
movss  0x60(%rsp),%xmm2
movaps %xmm3,%xmm0
movss  %xmm2,0x8(%rsp)
divss  %xmm2,%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,0x10(%rsp,%rbx,1)
movss  0xc(%rsp),%xmm0
call   1050 <log@plt>
movss  %xmm0,0x90(%rsp,%rbx,1)
add    $0x4,%rbx
cmp    $0x28,%rbx
jne    1150 <main+0x20>
movaps 0xc0(%rsp),%xmm3
movss  0x10(%rsp),%xmm4
movss  0x14(%rsp),%xmm2
movss  0x18(%rsp),%xmm1
movss  0x1c(%rsp),%xmm0
movaps %xmm4,%xmm5
shufps $0x0,%xmm4,%xmm5
movlhps %xmm3,%xmm4
shufps $0xe2,%xmm3,%xmm4
mulps  %xmm4,%xmm5
xorps  %xmm3,%xmm3
addps  %xmm3,%xmm5
addps  %xmm3,%xmm4
movups 0xc4(%rsp),%xmm3
movaps %xmm2,%xmm6
shufps $0x0,%xmm2,%xmm6
movlhps %xmm3,%xmm2
shufps $0xe2,%xmm3,%xmm2
mulps  %xmm2,%xmm6
addps  %xmm5,%xmm6
addps  %xmm4,%xmm2
movups 0xc8(%rsp),%xmm3
movaps %xmm1,%xmm4
shufps $0x0,%xmm1,%xmm4
movlhps %xmm3,%xmm1
shufps $0xe2,%xmm3,%xmm1
mulps  %xmm1,%xmm4
addps  %xmm6,%xmm4
addps  %xmm2,%xmm1
movups 0xcc(%rsp),%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
movlhps %xmm2,%xmm0
shufps $0xe2,%xmm2,%xmm0
mulps  %xmm0,%xmm3
addps  %xmm4,%xmm3
addps  %xmm1,%xmm0
movaps 0xd0(%rsp),%xmm1
movss  0x20(%rsp),%xmm2
movaps %xmm2,%xmm4
shufps $0x0,%xmm2,%xmm4
movlhps %xmm1,%xmm2
shufps $0xe2,%xmm1,%xmm2
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
addps  %xmm0,%xmm2
movups 0xd4(%rsp),%xmm0
movss  0x24(%rsp),%xmm1
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movlhps %xmm0,%xmm1
shufps $0xe2,%xmm0,%xmm1
mulps  %xmm1,%xmm3
addps  %xmm4,%xmm3
addps  %xmm2,%xmm1
movups 0xd8(%rsp),%xmm0
movss  0x28(%rsp),%xmm2
movaps %xmm2,%xmm4
shufps $0x0,%xmm2,%xmm4
movlhps %xmm0,%xmm2
shufps $0xe2,%xmm0,%xmm2
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
addps  %xmm1,%xmm2
movss  0x2c(%rsp),%xmm0
movss  0xdc(%rsp),%xmm1
unpcklps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm4,%xmm0
addps  %xmm2,%xmm1
movss  0x30(%rsp),%xmm2
movss  0xe0(%rsp),%xmm3
unpcklps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm3
movss  0x34(%rsp),%xmm0
movss  0xe4(%rsp),%xmm1
unpcklps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm2,%xmm0
addps  %xmm3,%xmm1
divps  0xcc9(%rip),%xmm1
divps  0xcd2(%rip),%xmm0
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm0,%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
divss  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  0xcbc(%rip),%xmm2
movss  0x8(%rsp),%xmm1
mulss  %xmm1,%xmm1
divss  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
lea    0xd08(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xd13(%rip),%rdi
call   1030 <puts@plt>
movss  0xf0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcee(%rip),%r14
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xf4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xf8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xfc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x100(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x104(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x108(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x10c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x110(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x114(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xc1e(%rip),%rdi
call   1030 <puts@plt>
movss  0x90(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x94(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x98(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x9c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xa0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xa4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xa8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xac(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xb0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0xb4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xb36(%rip),%rdi
call   1030 <puts@plt>
movss  0x60(%rsp),%xmm0
movss  %xmm0,0x44(%rsp)
cvtss2sd %xmm0,%xmm0
lea    0xb06(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x64(%rsp),%xmm0
movss  %xmm0,0x40(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x68(%rsp),%xmm0
movss  %xmm0,0x48(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x6c(%rsp),%xmm0
movss  %xmm0,0x4c(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x70(%rsp),%xmm0
movss  %xmm0,0x50(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x74(%rsp),%xmm0
movss  %xmm0,0x54(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x78(%rsp),%xmm0
movss  %xmm0,0x58(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x7c(%rsp),%xmm0
movss  %xmm0,0x5c(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x80(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x84(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xa14(%rip),%rdi
call   1030 <puts@plt>
movss  0x949(%rip),%xmm0
divss  0x44(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x92d(%rip),%xmm0
divss  0x40(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x911(%rip),%xmm0
divss  0x48(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x8f5(%rip),%xmm0
divss  0x4c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x8d9(%rip),%xmm0
divss  0x50(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x8bd(%rip),%xmm0
divss  0x54(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x8a1(%rip),%xmm0
divss  0x58(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x885(%rip),%xmm0
divss  0x5c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x869(%rip),%xmm0
divss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x84d(%rip),%xmm0
divss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0x8f8(%rip),%rdi
call   1030 <puts@plt>
movss  0x10(%rsp),%xmm0
mulss  0x81f(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x14(%rsp),%xmm0
mulss  0x803(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x18(%rsp),%xmm0
mulss  0x7e7(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x1c(%rsp),%xmm0
mulss  0x7cb(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x20(%rsp),%xmm0
mulss  0x7af(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x24(%rsp),%xmm0
mulss  0x793(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x28(%rsp),%xmm0
mulss  0x777(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x2c(%rsp),%xmm0
mulss  0x75b(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x30(%rsp),%xmm0
mulss  0x73f(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x729(%rip),%xmm0
mulss  0x34(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x120,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@__const.main.RS = [10 x float] [float 4.690000e+03, float 4.100000e+03, float 3.700000e+03, float 3.240000e+03, float 2.900000e+03, float 2.580000e+03, float 2.390000e+03, float 2.130000e+03, float 1.930000e+03, float 1.730000e+03]
@__const.main.C0 = [10 x float] [float 0x40354CCCC0000000, float 0x4038CCCCC0000000, float 0x403B333340000000, float 0x403E1999A0000000, float 0x40408CCCC0000000, float 0x4042666660000000, float 0x4043A66660000000, float 0x4045266660000000, float 0x40469999A0000000, float 0x40480CCCC0000000]
@.str = [13 x i8] c"b:%f a:%f\0A\00"
@.str.1 = [5 x i8] c"RT:\0A\00"
@.str.2 = [6 x i8] c"%.2f\0A\00"
@.str.3 = [6 x i8] c"lnR:\0A\00"
@.str.4 = [4 x i8] c"T:\0A\00"
@.str.5 = [6 x i8] c"%.1f\0A\00"
@.str.6 = [9 x i8] c"1000/T:\0A\00"
@.str.7 = [18 x i8] c"(1/T-1/T0)*1000:\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca float
%4 = alloca float
%5 = alloca [10 x float]
%6 = alloca [10 x float]
%7 = alloca [10 x float]
%8 = alloca [10 x float]
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca [10 x float]
%16 = alloca [10 x float]
%17 = alloca [10 x float]
store i32 0, i32* %1
store float 5.000000e+03, float* %3
store float 4.000000e+03, float* %4
store float 0.000000e+00, float* %9
store float 0.000000e+00, float* %10
store float 0.000000e+00, float* %11
store float 0.000000e+00, float* %12
store float 0.000000e+00, float* %13
%18 = bitcast [10 x float]* %16 to i8*
%19 = bitcast [10 x float]* %17 to i8*
store i32 0, i32* %2
br label %20
20: ; preds = %73, %0
%21 = load i32, i32* %2
%22 = icmp slt i32 %21, 10
br i1 %22, label %23, label %76
23: ; preds = %20
%24 = load i32, i32* %2
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [10 x float], [10 x float]* %16, i64 0, i64 %25
%27 = load float, float* %26
%28 = load float, float* %3
%29 = fmul float %27, %28
%30 = load float, float* %4
%31 = fdiv float %29, %30
%32 = load i32, i32* %2
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %33
store float %31, float* %34
%35 = load i32, i32* %2
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %36
%38 = load float, float* %37
%39 = call float @log(float %38)
%40 = load i32, i32* %2
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [10 x float], [10 x float]* %8, i64 0, i64 %41
store float %39, float* %42
%43 = load i32, i32* %2
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [10 x float], [10 x float]* %17, i64 0, i64 %44
%46 = load float, float* %45
%47 = fpext float %46 to double
%48 = fadd double %47, 2.731500e+02
%49 = fptrunc double %48 to float
%50 = load i32, i32* %2
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 %51
store float %49, float* %52
%53 = load i32, i32* %2
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 %54
%56 = load float, float* %55
%57 = fdiv float 1.000000e+00, %56
%58 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 0
%59 = load float, float* %58
%60 = fdiv float 1.000000e+00, %59
%61 = fsub float %57, %60
%62 = load i32, i32* %2
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 %63
store float %61, float* %64
%65 = load i32, i32* %2
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %66
%68 = load float, float* %67
%69 = call float @log(float %68)
%70 = load i32, i32* %2
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [10 x float], [10 x float]* %15, i64 0, i64 %71
store float %69, float* %72
br label %73
73: ; preds = %23
%74 = load i32, i32* %2
%75 = add nsw i32 %74, 1
store i32 %75, i32* %2
br label %20
76: ; preds = %20
store i32 0, i32* %2
br label %77
77: ; preds = %113, %76
%78 = load i32, i32* %2
%79 = icmp slt i32 %78, 10
br i1 %79, label %80, label %116
80: ; preds = %77
%81 = load i32, i32* %2
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 %82
%84 = load float, float* %83
%85 = load i32, i32* %2
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 %86
%88 = load float, float* %87
%89 = load float, float* %13
%90 = call float @llvm.fmuladd.f32(float %84, float %88, float %89)
store float %90, float* %13
%91 = load i32, i32* %2
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 %92
%94 = load float, float* %93
%95 = load i32, i32* %2
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [10 x float], [10 x float]* %8, i64 0, i64 %96
%98 = load float, float* %97
%99 = load float, float* %12
%100 = call float @llvm.fmuladd.f32(float %94, float %98, float %99)
store float %100, float* %12
%101 = load i32, i32* %2
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 %102
%104 = load float, float* %103
%105 = load float, float* %9
%106 = fadd float %105, %104
store float %106, float* %9
%107 = load i32, i32* %2
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [10 x float], [10 x float]* %8, i64 0, i64 %108
%110 = load float, float* %109
%111 = load float, float* %10
%112 = fadd float %111, %110
store float %112, float* %10
br label %113
113: ; preds = %80
%114 = load i32, i32* %2
%115 = add nsw i32 %114, 1
store i32 %115, i32* %2
br label %77
116: ; preds = %77
%117 = load float, float* %13
%118 = fdiv float %117, 1.000000e+01
store float %118, float* %13
%119 = load float, float* %12
%120 = fdiv float %119, 1.000000e+01
store float %120, float* %12
%121 = load float, float* %9
%122 = fdiv float %121, 1.000000e+01
store float %122, float* %9
%123 = load float, float* %10
%124 = fdiv float %123, 1.000000e+01
store float %124, float* %10
%125 = load float, float* %9
%126 = load float, float* %10
%127 = load float, float* %12
%128 = fneg float %127
%129 = call float @llvm.fmuladd.f32(float %125, float %126, float %128)
%130 = load float, float* %9
%131 = load float, float* %9
%132 = load float, float* %13
%133 = fneg float %132
%134 = call float @llvm.fmuladd.f32(float %130, float %131, float %133)
%135 = fdiv float %129, %134
store float %135, float* %11
%136 = load float, float* %11
%137 = fneg float %136
%138 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 0
%139 = load float, float* %138
%140 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 0
%141 = load float, float* %140
%142 = fmul float %139, %141
%143 = fdiv float %137, %142
store float %143, float* %14
%144 = load float, float* %11
%145 = fpext float %144 to double
%146 = load float, float* %14
%147 = fpext float %146 to double
%148 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), double %145, double %147)
%149 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %2
br label %150
150: ; preds = %160, %116
%151 = load i32, i32* %2
%152 = icmp slt i32 %151, 10
br i1 %152, label %153, label %163
153: ; preds = %150
%154 = load i32, i32* %2
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %155
%157 = load float, float* %156
%158 = fpext float %157 to double
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %158)
br label %160
160: ; preds = %153
%161 = load i32, i32* %2
%162 = add nsw i32 %161, 1
store i32 %162, i32* %2
br label %150
163: ; preds = %150
%164 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %2
br label %165
165: ; preds = %175, %163
%166 = load i32, i32* %2
%167 = icmp slt i32 %166, 10
br i1 %167, label %168, label %178
168: ; preds = %165
%169 = load i32, i32* %2
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [10 x float], [10 x float]* %15, i64 0, i64 %170
%172 = load float, float* %171
%173 = fpext float %172 to double
%174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %173)
br label %175
175: ; preds = %168
%176 = load i32, i32* %2
%177 = add nsw i32 %176, 1
store i32 %177, i32* %2
br label %165
178: ; preds = %165
%179 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %2
br label %180
180: ; preds = %190, %178
%181 = load i32, i32* %2
%182 = icmp slt i32 %181, 10
br i1 %182, label %183, label %193
183: ; preds = %180
%184 = load i32, i32* %2
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 %185
%187 = load float, float* %186
%188 = fpext float %187 to double
%189 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %188)
br label %190
190: ; preds = %183
%191 = load i32, i32* %2
%192 = add nsw i32 %191, 1
store i32 %192, i32* %2
br label %180
193: ; preds = %180
%194 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %2
br label %195
195: ; preds = %206, %193
%196 = load i32, i32* %2
%197 = icmp slt i32 %196, 10
br i1 %197, label %198, label %209
198: ; preds = %195
%199 = load i32, i32* %2
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 %200
%202 = load float, float* %201
%203 = fdiv float 1.000000e+03, %202
%204 = fpext float %203 to double
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %204)
br label %206
206: ; preds = %198
%207 = load i32, i32* %2
%208 = add nsw i32 %207, 1
store i32 %208, i32* %2
br label %195
209: ; preds = %195
%210 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %2
br label %211
211: ; preds = %222, %209
%212 = load i32, i32* %2
%213 = icmp slt i32 %212, 10
br i1 %213, label %214, label %225
214: ; preds = %211
%215 = load i32, i32* %2
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [10 x float], [10 x float]* %7, i64 0, i64 %216
%218 = load float, float* %217
%219 = fmul float 1.000000e+03, %218
%220 = fpext float %219 to double
%221 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %220)
br label %222
222: ; preds = %214
%223 = load i32, i32* %2
%224 = add nsw i32 %223, 1
store i32 %224, i32* %2
br label %211
225: ; preds = %211
%226 = load i32, i32* %1
ret i32 %226
}

LLVM IR (-O2):
@__const.main.RS = [10 x float] [float 4.690000e+03, float 4.100000e+03, float 3.700000e+03, float 3.240000e+03, float 2.900000e+03, float 2.580000e+03, float 2.390000e+03, float 2.130000e+03, float 1.930000e+03, float 1.730000e+03]
@__const.main.C0 = [10 x float] [float 0x40354CCCC0000000, float 0x4038CCCCC0000000, float 0x403B333340000000, float 0x403E1999A0000000, float 0x40408CCCC0000000, float 0x4042666660000000, float 0x4043A66660000000, float 0x4045266660000000, float 0x40469999A0000000, float 0x40480CCCC0000000]
@.str = [13 x i8] c"b:%f a:%f\0A\00"
@.str.2 = [6 x i8] c"%.2f\0A\00"
@.str.5 = [6 x i8] c"%.1f\0A\00"
@str = [4 x i8] c"RT:\00"
@str.8 = [5 x i8] c"lnR:\00"
@str.9 = [3 x i8] c"T:\00"
@str.10 = [8 x i8] c"1000/T:\00"
@str.11 = [17 x i8] c"(1/T-1/T0)*1000:\00"
define i32 @main() {
%1 = alloca [10 x float]
%2 = alloca [10 x float]
%3 = alloca [10 x float]
%4 = alloca [10 x float]
%5 = alloca [10 x float]
%6 = bitcast [10 x float]* %1 to i8*
%7 = bitcast [10 x float]* %2 to i8*
%8 = bitcast [10 x float]* %3 to i8*
%9 = bitcast [10 x float]* %4 to i8*
%10 = bitcast [10 x float]* %5 to i8*
%11 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 0
br label %12
12: ; preds = %0, %12
%13 = phi i64 [ 0, %0 ], [ %34, %12 ]
%14 = getelementptr inbounds [10 x float], [10 x float]* @__const.main.RS, i64 0, i64 %13
%15 = load float, float* %14
%16 = fmul float %15, 5.000000e+03
%17 = fdiv float %16, 4.000000e+03
%18 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 %13
store float %17, float* %18
%19 = tail call float @log(float %17)
%20 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 %13
store float %19, float* %20
%21 = getelementptr inbounds [10 x float], [10 x float]* @__const.main.C0, i64 0, i64 %13
%22 = load float, float* %21
%23 = fpext float %22 to double
%24 = fadd double %23, 2.731500e+02
%25 = fptrunc double %24 to float
%26 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 %13
store float %25, float* %26
%27 = fdiv float 1.000000e+00, %25
%28 = load float, float* %11
%29 = fdiv float 1.000000e+00, %28
%30 = fsub float %27, %29
%31 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 %13
store float %30, float* %31
%32 = tail call float @log(float %17)
%33 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %13
store float %32, float* %33
%34 = add nuw nsw i64 %13, 1
%35 = icmp eq i64 %34, 10
br i1 %35, label %36, label %12
36: ; preds = %12
%37 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 0
%38 = load float, float* %37
%39 = bitcast [10 x float]* %4 to <4 x float>*
%40 = load <4 x float>, <4 x float>* %39
%41 = shufflevector <4 x float> %40, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%42 = insertelement <2 x float> poison, float %38, i64 0
%43 = shufflevector <2 x float> %42, <2 x float> poison, <2 x i32> zeroinitializer
%44 = insertelement <2 x float> %41, float %38, i64 1
%45 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %43, <2 x float> %44, <2 x float> zeroinitializer)
%46 = fadd <2 x float> %44, zeroinitializer
%47 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 1
%48 = load float, float* %47
%49 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 1
%50 = bitcast float* %49 to <4 x float>*
%51 = load <4 x float>, <4 x float>* %50
%52 = shufflevector <4 x float> %51, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%53 = insertelement <2 x float> poison, float %48, i64 0
%54 = shufflevector <2 x float> %53, <2 x float> poison, <2 x i32> zeroinitializer
%55 = insertelement <2 x float> %52, float %48, i64 1
%56 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %54, <2 x float> %55, <2 x float> %45)
%57 = fadd <2 x float> %46, %55
%58 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 2
%59 = load float, float* %58
%60 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 2
%61 = bitcast float* %60 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = shufflevector <4 x float> %62, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%64 = insertelement <2 x float> poison, float %59, i64 0
%65 = shufflevector <2 x float> %64, <2 x float> poison, <2 x i32> zeroinitializer
%66 = insertelement <2 x float> %63, float %59, i64 1
%67 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %65, <2 x float> %66, <2 x float> %56)
%68 = fadd <2 x float> %57, %66
%69 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 3
%70 = load float, float* %69
%71 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 3
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = shufflevector <4 x float> %73, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%75 = insertelement <2 x float> poison, float %70, i64 0
%76 = shufflevector <2 x float> %75, <2 x float> poison, <2 x i32> zeroinitializer
%77 = insertelement <2 x float> %74, float %70, i64 1
%78 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %76, <2 x float> %77, <2 x float> %67)
%79 = fadd <2 x float> %68, %77
%80 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 4
%81 = load float, float* %80
%82 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 4
%83 = bitcast float* %82 to <4 x float>*
%84 = load <4 x float>, <4 x float>* %83
%85 = shufflevector <4 x float> %84, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%86 = insertelement <2 x float> poison, float %81, i64 0
%87 = shufflevector <2 x float> %86, <2 x float> poison, <2 x i32> zeroinitializer
%88 = insertelement <2 x float> %85, float %81, i64 1
%89 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %87, <2 x float> %88, <2 x float> %78)
%90 = fadd <2 x float> %79, %88
%91 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 5
%92 = load float, float* %91
%93 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 5
%94 = bitcast float* %93 to <4 x float>*
%95 = load <4 x float>, <4 x float>* %94
%96 = shufflevector <4 x float> %95, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%97 = insertelement <2 x float> poison, float %92, i64 0
%98 = shufflevector <2 x float> %97, <2 x float> poison, <2 x i32> zeroinitializer
%99 = insertelement <2 x float> %96, float %92, i64 1
%100 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %98, <2 x float> %99, <2 x float> %89)
%101 = fadd <2 x float> %90, %99
%102 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 6
%103 = load float, float* %102
%104 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 6
%105 = bitcast float* %104 to <4 x float>*
%106 = load <4 x float>, <4 x float>* %105
%107 = shufflevector <4 x float> %106, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%108 = insertelement <2 x float> poison, float %103, i64 0
%109 = shufflevector <2 x float> %108, <2 x float> poison, <2 x i32> zeroinitializer
%110 = insertelement <2 x float> %107, float %103, i64 1
%111 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %109, <2 x float> %110, <2 x float> %100)
%112 = fadd <2 x float> %101, %110
%113 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 7
%114 = load float, float* %113
%115 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 7
%116 = load float, float* %115
%117 = insertelement <2 x float> poison, float %114, i64 0
%118 = shufflevector <2 x float> %117, <2 x float> poison, <2 x i32> zeroinitializer
%119 = insertelement <2 x float> poison, float %116, i64 0
%120 = insertelement <2 x float> %119, float %114, i64 1
%121 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %118, <2 x float> %120, <2 x float> %111)
%122 = fadd <2 x float> %112, %120
%123 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 8
%124 = load float, float* %123
%125 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 8
%126 = load float, float* %125
%127 = insertelement <2 x float> poison, float %124, i64 0
%128 = shufflevector <2 x float> %127, <2 x float> poison, <2 x i32> zeroinitializer
%129 = insertelement <2 x float> poison, float %126, i64 0
%130 = insertelement <2 x float> %129, float %124, i64 1
%131 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %128, <2 x float> %130, <2 x float> %121)
%132 = fadd <2 x float> %122, %130
%133 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 0, i64 9
%134 = load float, float* %133
%135 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 9
%136 = load float, float* %135
%137 = insertelement <2 x float> poison, float %134, i64 0
%138 = shufflevector <2 x float> %137, <2 x float> poison, <2 x i32> zeroinitializer
%139 = insertelement <2 x float> poison, float %136, i64 0
%140 = insertelement <2 x float> %139, float %134, i64 1
%141 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %138, <2 x float> %140, <2 x float> %131)
%142 = fadd <2 x float> %132, %140
%143 = fdiv <2 x float> %142, <float 1.000000e+01, float 1.000000e+01>
%144 = fdiv <2 x float> %141, <float -1.000000e+01, float -1.000000e+01>
%145 = shufflevector <2 x float> %143, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%146 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %145, <2 x float> %143, <2 x float> %144)
%147 = extractelement <2 x float> %146, i64 0
%148 = extractelement <2 x float> %146, i64 1
%149 = fdiv float %147, %148
%150 = fneg float %149
%151 = fmul float %28, %28
%152 = fdiv float %150, %151
%153 = fpext float %149 to double
%154 = fpext float %152 to double
%155 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), double %153, double %154)
%156 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str, i64 0, i64 0))
%157 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 0
%158 = load float, float* %157
%159 = fpext float %158 to double
%160 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %159)
%161 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 1
%162 = load float, float* %161
%163 = fpext float %162 to double
%164 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %163)
%165 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 2
%166 = load float, float* %165
%167 = fpext float %166 to double
%168 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %167)
%169 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 3
%170 = load float, float* %169
%171 = fpext float %170 to double
%172 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %171)
%173 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 4
%174 = load float, float* %173
%175 = fpext float %174 to double
%176 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %175)
%177 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 5
%178 = load float, float* %177
%179 = fpext float %178 to double
%180 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %179)
%181 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 6
%182 = load float, float* %181
%183 = fpext float %182 to double
%184 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %183)
%185 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 7
%186 = load float, float* %185
%187 = fpext float %186 to double
%188 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %187)
%189 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 8
%190 = load float, float* %189
%191 = fpext float %190 to double
%192 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %191)
%193 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 9
%194 = load float, float* %193
%195 = fpext float %194 to double
%196 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %195)
%197 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @str.8, i64 0, i64 0))
%198 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 0
%199 = load float, float* %198
%200 = fpext float %199 to double
%201 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %200)
%202 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 1
%203 = load float, float* %202
%204 = fpext float %203 to double
%205 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %204)
%206 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 2
%207 = load float, float* %206
%208 = fpext float %207 to double
%209 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %208)
%210 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 3
%211 = load float, float* %210
%212 = fpext float %211 to double
%213 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %212)
%214 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 4
%215 = load float, float* %214
%216 = fpext float %215 to double
%217 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %216)
%218 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 5
%219 = load float, float* %218
%220 = fpext float %219 to double
%221 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %220)
%222 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 6
%223 = load float, float* %222
%224 = fpext float %223 to double
%225 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %224)
%226 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 7
%227 = load float, float* %226
%228 = fpext float %227 to double
%229 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %228)
%230 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 8
%231 = load float, float* %230
%232 = fpext float %231 to double
%233 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %232)
%234 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 9
%235 = load float, float* %234
%236 = fpext float %235 to double
%237 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %236)
%238 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.9, i64 0, i64 0))
%239 = load float, float* %11
%240 = fpext float %239 to double
%241 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %240)
%242 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 1
%243 = load float, float* %242
%244 = fpext float %243 to double
%245 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %244)
%246 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 2
%247 = load float, float* %246
%248 = fpext float %247 to double
%249 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %248)
%250 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 3
%251 = load float, float* %250
%252 = fpext float %251 to double
%253 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %252)
%254 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 4
%255 = load float, float* %254
%256 = fpext float %255 to double
%257 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %256)
%258 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 5
%259 = load float, float* %258
%260 = fpext float %259 to double
%261 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %260)
%262 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 6
%263 = load float, float* %262
%264 = fpext float %263 to double
%265 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %264)
%266 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 7
%267 = load float, float* %266
%268 = fpext float %267 to double
%269 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %268)
%270 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 8
%271 = load float, float* %270
%272 = fpext float %271 to double
%273 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %272)
%274 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 9
%275 = load float, float* %274
%276 = fpext float %275 to double
%277 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), double %276)
%278 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.10, i64 0, i64 0))
%279 = fdiv float 1.000000e+03, %239
%280 = fpext float %279 to double
%281 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %280)
%282 = fdiv float 1.000000e+03, %243
%283 = fpext float %282 to double
%284 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %283)
%285 = fdiv float 1.000000e+03, %247
%286 = fpext float %285 to double
%287 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %286)
%288 = fdiv float 1.000000e+03, %251
%289 = fpext float %288 to double
%290 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %289)
%291 = fdiv float 1.000000e+03, %255
%292 = fpext float %291 to double
%293 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %292)
%294 = fdiv float 1.000000e+03, %259
%295 = fpext float %294 to double
%296 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %295)
%297 = fdiv float 1.000000e+03, %263
%298 = fpext float %297 to double
%299 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %298)
%300 = fdiv float 1.000000e+03, %267
%301 = fpext float %300 to double
%302 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %301)
%303 = fdiv float 1.000000e+03, %271
%304 = fpext float %303 to double
%305 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %304)
%306 = fdiv float 1.000000e+03, %275
%307 = fpext float %306 to double
%308 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %307)
%309 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.11, i64 0, i64 0))
%310 = load float, float* %37
%311 = fmul float %310, 1.000000e+03
%312 = fpext float %311 to double
%313 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %312)
%314 = load float, float* %47
%315 = fmul float %314, 1.000000e+03
%316 = fpext float %315 to double
%317 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %316)
%318 = load float, float* %58
%319 = fmul float %318, 1.000000e+03
%320 = fpext float %319 to double
%321 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %320)
%322 = load float, float* %69
%323 = fmul float %322, 1.000000e+03
%324 = fpext float %323 to double
%325 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %324)
%326 = load float, float* %80
%327 = fmul float %326, 1.000000e+03
%328 = fpext float %327 to double
%329 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %328)
%330 = load float, float* %91
%331 = fmul float %330, 1.000000e+03
%332 = fpext float %331 to double
%333 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %332)
%334 = load float, float* %102
%335 = fmul float %334, 1.000000e+03
%336 = fpext float %335 to double
%337 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %336)
%338 = load float, float* %113
%339 = fmul float %338, 1.000000e+03
%340 = fpext float %339 to double
%341 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %340)
%342 = load float, float* %123
%343 = fmul float %342, 1.000000e+03
%344 = fpext float %343 to double
%345 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %344)
%346 = load float, float* %133
%347 = fmul float %346, 1.000000e+03
%348 = fpext float %347 to double
%349 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), double %348)
ret i32 0
}