#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 atof(char *);
double cosh(float);
int /*<<< orphan*/ exit(int);
float fabs(scalar_t__);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
scalar_t__ pow(float, double);
double sqrt(double);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdout;
int main(int argc, char **argv) {
  float tau;
  float temperature;
  float x_arr[10000];
  float neufeld_arr[10000];
  float min_x, max_x, delta_x;
  int i;
  float Lya_nu_line_width_CGS = 9.936E7;
  float nu_doppler;
  float a;
  float x_in;
  float tmp;
  float total;
  if (argc != 4) {
    fprintf(stderr, "%s\n", "./dijkstra.x tau temperature x_in");
    exit(1);
  }
  tau = atof(argv[1]);
  temperature = atof(argv[2]);
  x_in = atof(argv[3]);
  nu_doppler = 1.057E11 * sqrt(temperature / 10000.0);
  a = Lya_nu_line_width_CGS / (2.0 * nu_doppler);
  min_x = -150.0;
  max_x = 150.0;
  delta_x = (max_x - min_x) / 10000;
  for (i = 0; i < 10000; i++) {
    x_arr[i] = min_x + i * delta_x;
  }
  fprintf(stdout, "# %d\n", 10000);
  total = 0.0;
  for (i = 0; i < 10000; i++) {
    neufeld_arr[i] = x_arr[i] * x_arr[i];
    neufeld_arr[i] *= sqrt(3.14159) / (4.0 * sqrt(6) * a * tau);
    tmp = sqrt(2.0 * 3.14159 * 3.14159 * 3.14159 / 27.0);
    tmp *= (fabs(pow(x_arr[i], 3.0) - pow(x_in, 3.0)) / (a * tau));
    neufeld_arr[i] *= 1.0 / (1.0 + cosh(tmp));
    total += neufeld_arr[i] * delta_x;
  }
  for (i = 0; i < 10000; i++) {
    neufeld_arr[i] *= 1.0 / (total * 4.0 * 3.14159);
  }
  fprintf(stderr, "# total %e [1/(4pi) =%e]\n", total, 1.0 / (4.0 * 3.14159));
  total = 0.0;
  for (i = 0; i < 10000; i++) {
    total += neufeld_arr[i] * delta_x;
    fprintf(stdout, "%e %e\n", x_arr[i], neufeld_arr[i]);
  }
  fprintf(stderr, "# new total %e [1/(4pi) =%e]\n", total,
          1.0 / (4.0 * 3.14159));
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x138e0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  0xe6f(%rip),%xmm0
movss  %xmm0,-0x138b4(%rbp)
ff
cmpl   $0x4,-0x8(%rbp)
je     11cb <main+0x5b>
mov    0x2e36(%rip),%rax
mov    (%rax),%edi
lea    0xead(%rip),%rsi
lea    0xeaa(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1030 <atof@plt>
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1030 <atof@plt>
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   1030 <atof@plt>
movss  %xmm0,-0x138c0(%rbp)
ff
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe0b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xdef(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138b8(%rbp)
ff
movss  -0x138b4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x138b8(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm2
movsd  0xdb7(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138bc(%rbp)
ff
movss  0xd97(%rip),%xmm0
movss  %xmm0,-0x138a4(%rbp)
ff
movss  0xd83(%rip),%xmm0
movss  %xmm0,-0x138a8(%rbp)
ff
movss  -0x138a8(%rbp),%xmm0
ff
subss  -0x138a4(%rbp),%xmm0
ff
movss  0xd5f(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x138ac(%rbp)
ff
movl   $0x0,-0x138b0(%rbp)
cmpl   $0x2710,-0x138b0(%rbp)
jge    130f <main+0x19f>
movss  -0x138a4(%rbp),%xmm1
ff
cvtsi2ssl -0x138b0(%rbp),%xmm0
ff
movss  -0x138ac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x138b0(%rbp),%rax
movss  %xmm0,-0x9c60(%rbp,%rax,4)
ff ff
mov    -0x138b0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138b0(%rbp)
jmp    12bb <main+0x14b>
mov    0x2cc2(%rip),%rax
mov    (%rax),%edi
lea    0xd67(%rip),%rsi
mov    $0x2710,%edx
mov    $0x0,%al
call   1060 <fprintf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x138c8(%rbp)
ff
movl   $0x0,-0x138b0(%rbp)
cmpl   $0x2710,-0x138b0(%rbp)
jge    1512 <main+0x3a2>
movslq -0x138b0(%rbp),%rax
movss  -0x9c60(%rbp,%rax,4),%xmm0
ff ff
movslq -0x138b0(%rbp),%rax
mulss  -0x9c60(%rbp,%rax,4),%xmm0
ff ff
movslq -0x138b0(%rbp),%rax
movss  %xmm0,-0x138a0(%rbp,%rax,4)
fe ff
movsd  0xcb0(%rip),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x138d8(%rbp)
ff
movsd  0xcbb(%rip),%xmm0
call   1080 <sqrt@plt>
movsd  -0x138d8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0xc8b(%rip),%xmm0
mulsd  %xmm2,%xmm0
movss  -0x138bc(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
movss  -0x14(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
movslq -0x138b0(%rbp),%rax
movss  -0x138a0(%rbp,%rax,4),%xmm0
fe ff
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138a0(%rbp,%rax,4)
fe ff
movsd  0xc49(%rip),%xmm0
call   1080 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138c4(%rbp)
ff
movslq -0x138b0(%rbp),%rax
movss  -0x9c60(%rbp,%rax,4),%xmm0
ff ff
movsd  0xc18(%rip),%xmm1
call   1070 <pow@plt>
mov    %rax,-0x138d0(%rbp)
movss  -0x138c0(%rbp),%xmm0
ff
movsd  0xbfc(%rip),%xmm1
call   1070 <pow@plt>
mov    -0x138d0(%rbp),%rdi
sub    %rax,%rdi
call   1050 <fabs@plt>
movss  -0x138bc(%rbp),%xmm1
ff
mulss  -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mulss  -0x138c4(%rbp),%xmm0
ff
movss  %xmm0,-0x138c4(%rbp)
ff
movss  -0x138c4(%rbp),%xmm0
ff
call   1040 <cosh@plt>
movaps %xmm0,%xmm1
movsd  0xb97(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0xb8b(%rip),%xmm1
divsd  %xmm0,%xmm1
movslq -0x138b0(%rbp),%rax
movss  -0x138a0(%rbp,%rax,4),%xmm0
fe ff
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138a0(%rbp,%rax,4)
fe ff
movslq -0x138b0(%rbp),%rax
movss  -0x138a0(%rbp,%rax,4),%xmm0
fe ff
movss  -0x138ac(%rbp),%xmm2
ff
movss  -0x138c8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x138c8(%rbp)
ff
mov    -0x138b0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138b0(%rbp)
jmp    1340 <main+0x1d0>
movl   $0x0,-0x138b0(%rbp)
cmpl   $0x2710,-0x138b0(%rbp)
jge    1595 <main+0x425>
movss  -0x138c8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xb00(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xaec(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xad8(%rip),%xmm1
divsd  %xmm0,%xmm1
movslq -0x138b0(%rbp),%rax
movss  -0x138a0(%rbp,%rax,4),%xmm0
fe ff
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138a0(%rbp,%rax,4)
fe ff
mov    -0x138b0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138b0(%rbp)
jmp    151c <main+0x3ac>
mov    0x2a44(%rip),%rax
mov    (%rax),%edi
movss  -0x138c8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xadb(%rip),%rsi
movsd  0xa6f(%rip),%xmm1
mov    $0x2,%al
call   1060 <fprintf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x138c8(%rbp)
ff
movl   $0x0,-0x138b0(%rbp)
cmpl   $0x2710,-0x138b0(%rbp)
jge    1668 <main+0x4f8>
movslq -0x138b0(%rbp),%rax
movss  -0x138a0(%rbp,%rax,4),%xmm0
fe ff
movss  -0x138ac(%rbp),%xmm2
ff
movss  -0x138c8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x138c8(%rbp)
ff
mov    0x29bc(%rip),%rax
mov    (%rax),%edi
movslq -0x138b0(%rbp),%rax
movss  -0x9c60(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
movslq -0x138b0(%rbp),%rax
movss  -0x138a0(%rbp,%rax,4),%xmm1
fe ff
cvtss2sd %xmm1,%xmm1
lea    0xa59(%rip),%rsi
mov    $0x2,%al
call   1060 <fprintf@plt>
mov    -0x138b0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138b0(%rbp)
jmp    15d5 <main+0x465>
mov    0x2971(%rip),%rax
mov    (%rax),%edi
movss  -0x138c8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xa29(%rip),%rsi
movsd  0x99c(%rip),%xmm1
mov    $0x2,%al
call   1060 <fprintf@plt>
xor    %eax,%eax
add    $0x138e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x138a8,%rsp
cmp    $0x4,%edi
jne    158d <main+0x41d>
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
call   1030 <atof@plt>
movss  %xmm0,0xc(%rsp)
mov    0x10(%rbx),%rdi
call   1030 <atof@plt>
movss  %xmm0,0x8(%rsp)
mov    0x18(%rbx),%rdi
call   1030 <atof@plt>
movss  0x8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  0xe3d(%rip),%xmm1
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm1
movss  %xmm0,0x10(%rsp)
jb     11dc <main+0x6c>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    11e5 <main+0x75>
movapd %xmm1,%xmm0
call   1080 <sqrt@plt>
mulsd  0xe1b(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
addsd  %xmm1,%xmm1
movsd  0xe0b(%rip),%xmm8
divsd  %xmm1,%xmm8
movdqa 0xe3e(%rip),%xmm0
mov    $0xc,%eax
movdqa 0xe40(%rip),%xmm9
movaps 0xe49(%rip),%xmm3
movaps 0xe52(%rip),%xmm4
movdqa 0xe5a(%rip),%xmm5
movdqa 0xe62(%rip),%xmm6
movdqa 0xe6a(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddd  %xmm9,%xmm1
cvtdq2ps %xmm0,%xmm2
cvtdq2ps %xmm1,%xmm1
mulps  %xmm3,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm3,%xmm1
addps  %xmm4,%xmm1
movaps %xmm2,0x9c30(%rsp,%rax,4)
movaps %xmm1,0x9c40(%rsp,%rax,4)
movdqa %xmm0,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
cvtdq2ps %xmm1,%xmm1
cvtdq2ps %xmm2,%xmm2
mulps  %xmm3,%xmm1
addps  %xmm4,%xmm1
mulps  %xmm3,%xmm2
addps  %xmm4,%xmm2
movaps %xmm1,0x9c50(%rsp,%rax,4)
movaps %xmm2,0x9c60(%rsp,%rax,4)
paddd  %xmm7,%xmm0
add    $0x10,%rax
cmp    $0x271c,%rax
jne    1250 <main+0xe0>
xorps  %xmm0,%xmm0
cvtsd2ss %xmm8,%xmm0
movss  %xmm0,0x8(%rsp)
mov    0x2d06(%rip),%r14
mov    (%r14),%edi
lea    0xe12(%rip),%rsi
xor    %r15d,%r15d
mov    $0x2710,%edx
xor    %eax,%eax
call   1060 <fprintf@plt>
movss  0x8(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
mulsd  0xd18(%rip),%xmm0
movss  0xc(%rsp),%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
mulsd  %xmm0,%xmm1
movsd  0xd07(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rsp)
mulss  %xmm3,%xmm2
movss  %xmm2,0xc(%rsp)
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  %xmm0,0x8(%rsp)
movss  0x9c60(%rsp,%r15,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  0x18(%rsp),%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x14(%rsp)
movsd  0xcb5(%rip),%xmm1
call   1070 <pow@plt>
mov    %rax,%rbx
movss  0x10(%rsp),%xmm0
movsd  0xc9f(%rip),%xmm1
call   1070 <pow@plt>
sub    %rax,%rbx
mov    %rbx,%rdi
call   1050 <fabs@plt>
divss  0xc(%rsp),%xmm0
mulss  0xd19(%rip),%xmm0
call   1040 <cosh@plt>
movsd  0xc7c(%rip),%xmm5
movss  0xd08(%rip),%xmm2
addsd  %xmm5,%xmm0
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x20(%rsp,%r15,4)
mulss  %xmm2,%xmm0
movss  0x8(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rsp)
movss  0x8(%rsp),%xmm0
add    $0x1,%r15
cmp    $0x2710,%r15
jne    1340 <main+0x1d0>
cvtss2sd %xmm0,%xmm0
movsd  0xc20(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0xc1c(%rip),%xmm1
divsd  %xmm1,%xmm5
unpcklpd %xmm5,%xmm5
mov    $0xc,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtps2pd -0x8(%rsp,%rax,4),%xmm1
cvtps2pd -0x10(%rsp,%rax,4),%xmm2
cvtps2pd 0x8(%rsp,%rax,4),%xmm3
cvtps2pd (%rsp,%rax,4),%xmm4
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm1
mulpd  %xmm5,%xmm4
mulpd  %xmm5,%xmm3
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm1,%xmm2
cvtpd2ps %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
movapd %xmm2,-0x10(%rsp,%rax,4)
movapd %xmm1,(%rsp,%rax,4)
cvtps2pd 0x18(%rsp,%rax,4),%xmm1
cvtps2pd 0x10(%rsp,%rax,4),%xmm2
cvtps2pd 0x28(%rsp,%rax,4),%xmm3
cvtps2pd 0x20(%rsp,%rax,4),%xmm4
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm1
mulpd  %xmm5,%xmm4
mulpd  %xmm5,%xmm3
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm1,%xmm2
cvtpd2ps %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
movapd %xmm2,0x10(%rsp,%rax,4)
movapd %xmm1,0x20(%rsp,%rax,4)
add    $0x10,%rax
cmp    $0x271c,%rax
jne    1440 <main+0x2d0>
mov    0x2afb(%rip),%r15
mov    (%r15),%edi
lea    0xc05(%rip),%rsi
movsd  0xb51(%rip),%xmm1
mov    $0x2,%al
call   1060 <fprintf@plt>
xorps  %xmm2,%xmm2
xor    %ebx,%ebx
lea    0xc04(%rip),%r12
nopw   0x0(%rax,%rax,1)
movss  0x20(%rsp,%rbx,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulss  0xb9f(%rip),%xmm0
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%rsp)
mov    (%r14),%edi
movss  0x9c60(%rsp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rsi
mov    $0x2,%al
call   1060 <fprintf@plt>
movss  0x8(%rsp),%xmm2
add    $0x1,%rbx
cmp    $0x2710,%rbx
jne    1510 <main+0x3a0>
mov    (%r15),%edi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
lea    0xba8(%rip),%rsi
movsd  0xad3(%rip),%xmm1
mov    $0x2,%al
call   1060 <fprintf@plt>
xor    %eax,%eax
add    $0x138a8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    0x2a4c(%rip),%rax
mov    (%rax),%edi
lea    0xb2b(%rip),%rsi
lea    0xb28(%rip),%rdx
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [4 x i8] c"%s\0A\00"
@.str.1 = [34 x i8] c"./dijkstra.x tau temperature x_in\00"
@stdout = global i32 0
@.str.2 = [6 x i8] c"# %d\0A\00"
@.str.3 = [26 x i8] c"# total %e [1/(4pi) =%e]\0A\00"
@.str.4 = [7 x i8] c"%e %e\0A\00"
@.str.5 = [30 x i8] c"# new total %e [1/(4pi) =%e]\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca float
%7 = alloca float
%8 = alloca [10000 x float]
%9 = alloca [10000 x float]
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store float 9.936000e+07, float* %14
%20 = load i32, i32* %4
%21 = icmp ne i32 %20, 4
br i1 %21, label %22, label %26
22: ; preds = %2
%23 = load i32, i32* @stderr
%24 = call i32 (i32, i8*, ...) @fprintf(i32 %23, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
%25 = call i32 @exit(i32 1)
unreachable
26: ; preds = %2
%27 = load i8**, i8*** %5
%28 = getelementptr inbounds i8*, i8** %27, i64 1
%29 = load i8*, i8** %28
%30 = call float @atof(i8* %29)
store float %30, float* %6
%31 = load i8**, i8*** %5
%32 = getelementptr inbounds i8*, i8** %31, i64 2
%33 = load i8*, i8** %32
%34 = call float @atof(i8* %33)
store float %34, float* %7
%35 = load i8**, i8*** %5
%36 = getelementptr inbounds i8*, i8** %35, i64 3
%37 = load i8*, i8** %36
%38 = call float @atof(i8* %37)
store float %38, float* %17
%39 = load float, float* %7
%40 = fpext float %39 to double
%41 = fdiv double %40, 1.000000e+04
%42 = call double @sqrt(double %41)
%43 = fmul double 1.057000e+11, %42
%44 = fptrunc double %43 to float
store float %44, float* %15
%45 = load float, float* %14
%46 = fpext float %45 to double
%47 = load float, float* %15
%48 = fpext float %47 to double
%49 = fmul double 2.000000e+00, %48
%50 = fdiv double %46, %49
%51 = fptrunc double %50 to float
store float %51, float* %16
store float -1.500000e+02, float* %10
store float 1.500000e+02, float* %11
%52 = load float, float* %11
%53 = load float, float* %10
%54 = fsub float %52, %53
%55 = fdiv float %54, 1.000000e+04
store float %55, float* %12
store i32 0, i32* %13
br label %56
56: ; preds = %68, %26
%57 = load i32, i32* %13
%58 = icmp slt i32 %57, 10000
br i1 %58, label %59, label %71
59: ; preds = %56
%60 = load float, float* %10
%61 = load i32, i32* %13
%62 = sitofp i32 %61 to float
%63 = load float, float* %12
%64 = call float @llvm.fmuladd.f32(float %62, float %63, float %60)
%65 = load i32, i32* %13
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %66
store float %64, float* %67
br label %68
68: ; preds = %59
%69 = load i32, i32* %13
%70 = add nsw i32 %69, 1
store i32 %70, i32* %13
br label %56
71: ; preds = %56
%72 = load i32, i32* @stdout
%73 = call i32 (i32, i8*, ...) @fprintf(i32 %72, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 10000)
store float 0.000000e+00, float* %19
store i32 0, i32* %13
br label %74
74: ; preds = %142, %71
%75 = load i32, i32* %13
%76 = icmp slt i32 %75, 10000
br i1 %76, label %77, label %145
77: ; preds = %74
%78 = load i32, i32* %13
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %79
%81 = load float, float* %80
%82 = load i32, i32* %13
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %83
%85 = load float, float* %84
%86 = fmul float %81, %85
%87 = load i32, i32* %13
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %88
store float %86, float* %89
%90 = call double @sqrt(double 3.141590e+00)
%91 = call double @sqrt(double 6.000000e+00)
%92 = fmul double 4.000000e+00, %91
%93 = load float, float* %16
%94 = fpext float %93 to double
%95 = fmul double %92, %94
%96 = load float, float* %6
%97 = fpext float %96 to double
%98 = fmul double %95, %97
%99 = fdiv double %90, %98
%100 = load i32, i32* %13
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %101
%103 = load float, float* %102
%104 = fpext float %103 to double
%105 = fmul double %104, %99
%106 = fptrunc double %105 to float
store float %106, float* %102
%107 = call double @sqrt(double 0x40025FC14DA79CE0)
%108 = fptrunc double %107 to float
store float %108, float* %18
%109 = load i32, i32* %13
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %110
%112 = load float, float* %111
%113 = call i64 @pow(float %112, double 3.000000e+00)
%114 = load float, float* %17
%115 = call i64 @pow(float %114, double 3.000000e+00)
%116 = sub nsw i64 %113, %115
%117 = call float @fabs(i64 %116)
%118 = load float, float* %16
%119 = load float, float* %6
%120 = fmul float %118, %119
%121 = fdiv float %117, %120
%122 = load float, float* %18
%123 = fmul float %122, %121
store float %123, float* %18
%124 = load float, float* %18
%125 = call double @cosh(float %124)
%126 = fadd double 1.000000e+00, %125
%127 = fdiv double 1.000000e+00, %126
%128 = load i32, i32* %13
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %129
%131 = load float, float* %130
%132 = fpext float %131 to double
%133 = fmul double %132, %127
%134 = fptrunc double %133 to float
store float %134, float* %130
%135 = load i32, i32* %13
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %136
%138 = load float, float* %137
%139 = load float, float* %12
%140 = load float, float* %19
%141 = call float @llvm.fmuladd.f32(float %138, float %139, float %140)
store float %141, float* %19
br label %142
142: ; preds = %77
%143 = load i32, i32* %13
%144 = add nsw i32 %143, 1
store i32 %144, i32* %13
br label %74
145: ; preds = %74
store i32 0, i32* %13
br label %146
146: ; preds = %162, %145
%147 = load i32, i32* %13
%148 = icmp slt i32 %147, 10000
br i1 %148, label %149, label %165
149: ; preds = %146
%150 = load float, float* %19
%151 = fpext float %150 to double
%152 = fmul double %151, 4.000000e+00
%153 = fmul double %152, 3.141590e+00
%154 = fdiv double 1.000000e+00, %153
%155 = load i32, i32* %13
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %156
%158 = load float, float* %157
%159 = fpext float %158 to double
%160 = fmul double %159, %154
%161 = fptrunc double %160 to float
store float %161, float* %157
br label %162
162: ; preds = %149
%163 = load i32, i32* %13
%164 = add nsw i32 %163, 1
store i32 %164, i32* %13
br label %146
165: ; preds = %146
%166 = load i32, i32* @stderr
%167 = load float, float* %19
%168 = fpext float %167 to double
%169 = call i32 (i32, i8*, ...) @fprintf(i32 %166, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0), double %168, double 0x3FB45F318E7ADAF5)
store float 0.000000e+00, float* %19
store i32 0, i32* %13
br label %170
170: ; preds = %193, %165
%171 = load i32, i32* %13
%172 = icmp slt i32 %171, 10000
br i1 %172, label %173, label %196
173: ; preds = %170
%174 = load i32, i32* %13
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %175
%177 = load float, float* %176
%178 = load float, float* %12
%179 = load float, float* %19
%180 = call float @llvm.fmuladd.f32(float %177, float %178, float %179)
store float %180, float* %19
%181 = load i32, i32* @stdout
%182 = load i32, i32* %13
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %183
%185 = load float, float* %184
%186 = fpext float %185 to double
%187 = load i32, i32* %13
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %188
%190 = load float, float* %189
%191 = fpext float %190 to double
%192 = call i32 (i32, i8*, ...) @fprintf(i32 %181, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), double %186, double %191)
br label %193
193: ; preds = %173
%194 = load i32, i32* %13
%195 = add nsw i32 %194, 1
store i32 %195, i32* %13
br label %170
196: ; preds = %170
%197 = load i32, i32* @stderr
%198 = load float, float* %19
%199 = fpext float %198 to double
%200 = call i32 (i32, i8*, ...) @fprintf(i32 %197, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.5, i64 0, i64 0), double %199, double 0x3FB45F318E7ADAF5)
ret i32 0
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [4 x i8] c"%s\0A\00"
@.str.1 = [34 x i8] c"./dijkstra.x tau temperature x_in\00"
@stdout = global i32 0
@.str.2 = [6 x i8] c"# %d\0A\00"
@.str.3 = [26 x i8] c"# total %e [1/(4pi) =%e]\0A\00"
@.str.4 = [7 x i8] c"%e %e\0A\00"
@.str.5 = [30 x i8] c"# new total %e [1/(4pi) =%e]\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [10000 x float]
%4 = alloca [10000 x float]
%5 = bitcast [10000 x float]* %3 to i8*
%6 = bitcast [10000 x float]* %4 to i8*
%7 = icmp eq i32 %0, 4
br i1 %7, label %12, label %8
8: ; preds = %2
%9 = load i32, i32* @stderr
%10 = tail call i32 (i32, i8*, ...) @fprintf(i32 %9, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
%11 = tail call i32 @exit(i32 1)
unreachable
12: ; preds = %2
%13 = getelementptr inbounds i8*, i8** %1, i64 1
%14 = load i8*, i8** %13
%15 = tail call float @atof(i8* %14)
%16 = getelementptr inbounds i8*, i8** %1, i64 2
%17 = load i8*, i8** %16
%18 = tail call float @atof(i8* %17)
%19 = getelementptr inbounds i8*, i8** %1, i64 3
%20 = load i8*, i8** %19
%21 = tail call float @atof(i8* %20)
%22 = fpext float %18 to double
%23 = fdiv double %22, 1.000000e+04
%24 = tail call double @sqrt(double %23)
%25 = fmul double %24, 1.057000e+11
%26 = fptrunc double %25 to float
%27 = fpext float %26 to double
%28 = fmul double %27, 2.000000e+00
%29 = fdiv double 9.936000e+07, %28
br label %30
30: ; preds = %30, %12
%31 = phi i64 [ 0, %12 ], [ %53, %30 ]
%32 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %12 ], [ %54, %30 ]
%33 = add <4 x i32> %32, <i32 4, i32 4, i32 4, i32 4>
%34 = sitofp <4 x i32> %32 to <4 x float>
%35 = sitofp <4 x i32> %33 to <4 x float>
%36 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %34, <4 x float> <float 0x3F9EB851E0000000, float 0x3F9EB851E0000000, float 0x3F9EB851E0000000, float 0x3F9EB851E0000000>, <4 x float> <float -1.500000e+02, float -1.500000e+02, float -1.500000e+02, float -1.500000e+02>)
%37 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %35, <4 x float> <float 0x3F9EB851E0000000, float 0x3F9EB851E0000000, float 0x3F9EB851E0000000, float 0x3F9EB851E0000000>, <4 x float> <float -1.500000e+02, float -1.500000e+02, float -1.500000e+02, float -1.500000e+02>)
%38 = getelementptr inbounds [10000 x float], [10000 x float]* %3, i64 0, i64 %31
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %36, <4 x float>* %39
%40 = getelementptr inbounds float, float* %38, i64 4
%41 = bitcast float* %40 to <4 x float>*
store <4 x float> %37, <4 x float>* %41
%42 = or i64 %31, 8
%43 = add <4 x i32> %32, <i32 8, i32 8, i32 8, i32 8>
%44 = add <4 x i32> %32, <i32 12, i32 12, i32 12, i32 12>
%45 = sitofp <4 x i32> %43 to <4 x float>
%46 = sitofp <4 x i32> %44 to <4 x float>
%47 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %45, <4 x float> <float 0x3F9EB851E0000000, float 0x3F9EB851E0000000, float 0x3F9EB851E0000000, float 0x3F9EB851E0000000>, <4 x float> <float -1.500000e+02, float -1.500000e+02, float -1.500000e+02, float -1.500000e+02>)
%48 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %46, <4 x float> <float 0x3F9EB851E0000000, float 0x3F9EB851E0000000, float 0x3F9EB851E0000000, float 0x3F9EB851E0000000>, <4 x float> <float -1.500000e+02, float -1.500000e+02, float -1.500000e+02, float -1.500000e+02>)
%49 = getelementptr inbounds [10000 x float], [10000 x float]* %3, i64 0, i64 %42
%50 = bitcast float* %49 to <4 x float>*
store <4 x float> %47, <4 x float>* %50
%51 = getelementptr inbounds float, float* %49, i64 4
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %48, <4 x float>* %52
%53 = add nuw nsw i64 %31, 16
%54 = add <4 x i32> %32, <i32 16, i32 16, i32 16, i32 16>
%55 = icmp eq i64 %53, 10000
br i1 %55, label %56, label %30
56: ; preds = %30
%57 = fptrunc double %29 to float
%58 = load i32, i32* @stdout
%59 = tail call i32 (i32, i8*, ...) @fprintf(i32 %58, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 10000)
%60 = fpext float %57 to double
%61 = fmul double %60, 0x4023988E1409212E
%62 = fpext float %15 to double
%63 = fmul double %61, %62
%64 = fdiv double 0x3FFC5BF7C8C401F1, %63
%65 = fmul float %15, %57
br label %108
66: ; preds = %108
%67 = fpext float %130 to double
%68 = fmul double %67, 4.000000e+00
%69 = fmul double %68, 3.141590e+00
%70 = fdiv double 1.000000e+00, %69
%71 = insertelement <4 x double> poison, double %70, i64 0
%72 = shufflevector <4 x double> %71, <4 x double> poison, <4 x i32> zeroinitializer
%73 = insertelement <4 x double> poison, double %70, i64 0
%74 = shufflevector <4 x double> %73, <4 x double> poison, <4 x i32> zeroinitializer
br label %75
75: ; preds = %75, %66
%76 = phi i64 [ 0, %66 ], [ %106, %75 ]
%77 = getelementptr inbounds [10000 x float], [10000 x float]* %4, i64 0, i64 %76
%78 = bitcast float* %77 to <4 x float>*
%79 = load <4 x float>, <4 x float>* %78
%80 = getelementptr inbounds float, float* %77, i64 4
%81 = bitcast float* %80 to <4 x float>*
%82 = load <4 x float>, <4 x float>* %81
%83 = fpext <4 x float> %79 to <4 x double>
%84 = fpext <4 x float> %82 to <4 x double>
%85 = fmul <4 x double> %72, %83
%86 = fmul <4 x double> %74, %84
%87 = fptrunc <4 x double> %85 to <4 x float>
%88 = fptrunc <4 x double> %86 to <4 x float>
%89 = bitcast float* %77 to <4 x float>*
store <4 x float> %87, <4 x float>* %89
%90 = bitcast float* %80 to <4 x float>*
store <4 x float> %88, <4 x float>* %90
%91 = or i64 %76, 8
%92 = getelementptr inbounds [10000 x float], [10000 x float]* %4, i64 0, i64 %91
%93 = bitcast float* %92 to <4 x float>*
%94 = load <4 x float>, <4 x float>* %93
%95 = getelementptr inbounds float, float* %92, i64 4
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = fpext <4 x float> %94 to <4 x double>
%99 = fpext <4 x float> %97 to <4 x double>
%100 = fmul <4 x double> %72, %98
%101 = fmul <4 x double> %74, %99
%102 = fptrunc <4 x double> %100 to <4 x float>
%103 = fptrunc <4 x double> %101 to <4 x float>
%104 = bitcast float* %92 to <4 x float>*
store <4 x float> %102, <4 x float>* %104
%105 = bitcast float* %95 to <4 x float>*
store <4 x float> %103, <4 x float>* %105
%106 = add nuw nsw i64 %76, 16
%107 = icmp eq i64 %106, 10000
br i1 %107, label %133, label %75
108: ; preds = %56, %108
%109 = phi i64 [ 0, %56 ], [ %131, %108 ]
%110 = phi float [ 0.000000e+00, %56 ], [ %130, %108 ]
%111 = getelementptr inbounds [10000 x float], [10000 x float]* %3, i64 0, i64 %109
%112 = load float, float* %111
%113 = fmul float %112, %112
%114 = getelementptr inbounds [10000 x float], [10000 x float]* %4, i64 0, i64 %109
%115 = fpext float %113 to double
%116 = fmul double %64, %115
%117 = fptrunc double %116 to float
%118 = tail call i64 @pow(float %112, double 3.000000e+00)
%119 = tail call i64 @pow(float %21, double 3.000000e+00)
%120 = sub nsw i64 %118, %119
%121 = tail call float @fabs(i64 %120)
%122 = fdiv float %121, %65
%123 = fmul float %122, 0x3FF83F8220000000
%124 = tail call double @cosh(float %123)
%125 = fadd double %124, 1.000000e+00
%126 = fdiv double 1.000000e+00, %125
%127 = fpext float %117 to double
%128 = fmul double %126, %127
%129 = fptrunc double %128 to float
store float %129, float* %114
%130 = tail call float @llvm.fmuladd.f32(float %129, float 0x3F9EB851E0000000, float %110)
%131 = add nuw nsw i64 %109, 1
%132 = icmp eq i64 %131, 10000
br i1 %132, label %66, label %108
133: ; preds = %75
%134 = load i32, i32* @stderr
%135 = tail call i32 (i32, i8*, ...) @fprintf(i32 %134, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0), double %67, double 0x3FB45F318E7ADAF5)
br label %136
136: ; preds = %133, %136
%137 = phi i64 [ 0, %133 ], [ %148, %136 ]
%138 = phi float [ 0.000000e+00, %133 ], [ %141, %136 ]
%139 = getelementptr inbounds [10000 x float], [10000 x float]* %4, i64 0, i64 %137
%140 = load float, float* %139
%141 = tail call float @llvm.fmuladd.f32(float %140, float 0x3F9EB851E0000000, float %138)
%142 = load i32, i32* @stdout
%143 = getelementptr inbounds [10000 x float], [10000 x float]* %3, i64 0, i64 %137
%144 = load float, float* %143
%145 = fpext float %144 to double
%146 = fpext float %140 to double
%147 = tail call i32 (i32, i8*, ...) @fprintf(i32 %142, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), double %145, double %146)
%148 = add nuw nsw i64 %137, 1
%149 = icmp eq i64 %148, 10000
br i1 %149, label %150, label %136
150: ; preds = %136
%151 = load i32, i32* @stderr
%152 = fpext float %141 to double
%153 = tail call i32 (i32, i8*, ...) @fprintf(i32 %151, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.5, i64 0, i64 0), double %152, double 0x3FB45F318E7ADAF5)
ret i32 0
}