#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);
float 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", "./neufeld.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(6.0) / 24.0) * (1.0 / (sqrt(3.14159) * a * tau));
    tmp = sqrt(3.14159 * 3.14159 * 3.14159 / 54.0);
    tmp *= (fabs(pow(x_arr[i], 3.0) - pow(x_in, 3.0)) / (a * tau));
    neufeld_arr[i] *= 1.0 / (cosh(tmp));
    fprintf(stdout, "%e %e\n", x_arr[i], neufeld_arr[i]);
    total += neufeld_arr[i] * delta_x;
  }
  fprintf(stderr, "# 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>
cvtss2sd %xmm0,%xmm1
movsd  0xdee(%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  0xdb6(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138bc(%rbp)
ff
movss  0xd96(%rip),%xmm0
movss  %xmm0,-0x138a4(%rbp)
ff
movss  0xd82(%rip),%xmm0
movss  %xmm0,-0x138a8(%rbp)
ff
movss  -0x138a8(%rbp),%xmm0
ff
subss  -0x138a4(%rbp),%xmm0
ff
movss  0xd5e(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x138ac(%rbp)
ff
movl   $0x0,-0x138b0(%rbp)
cmpl   $0x2710,-0x138b0(%rbp)
jge    1310 <main+0x1a0>
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    12bc <main+0x14c>
mov    0x2cc1(%rip),%rax
mov    (%rax),%edi
lea    0xd65(%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    1540 <main+0x3d0>
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  0xccf(%rip),%xmm0
call   1080 <sqrt@plt>
cvtss2sd %xmm0,%xmm0
movsd  0xcb6(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x138d8(%rbp)
ff
movsd  0xc9a(%rip),%xmm0
call   1080 <sqrt@plt>
movsd  -0x138d8(%rbp),%xmm1
ff
mulss  -0x138bc(%rbp),%xmm0
ff
mulss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xc5c(%rip),%xmm0
divsd  %xmm2,%xmm0
mulsd  %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  0xc37(%rip),%xmm0
call   1080 <sqrt@plt>
movss  %xmm0,-0x138c4(%rbp)
ff
movslq -0x138b0(%rbp),%rax
movss  -0x9c60(%rbp,%rax,4),%xmm0
ff ff
movsd  0xc0a(%rip),%xmm1
call   1070 <pow@plt>
mov    %rax,-0x138d0(%rbp)
movss  -0x138c0(%rbp),%xmm0
ff
movsd  0xbee(%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>
movsd  0xb9c(%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    0x2b14(%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    0xb96(%rip),%rsi
mov    $0x2,%al
call   1060 <fprintf@plt>
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    1341 <main+0x1d1>
mov    0x2a99(%rip),%rax
mov    (%rax),%edi
movss  -0x138c8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb36(%rip),%rsi
movsd  0xac4(%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    $0x9c78,%rsp
cmp    $0x4,%edi
jne    146c <main+0x2fc>
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
call   1030 <atof@plt>
movss  %xmm0,0x10(%rsp)
mov    0x10(%rbx),%rdi
call   1030 <atof@plt>
movss  %xmm0,0x8(%rsp)
mov    0x18(%rbx),%rdi
call   1030 <atof@plt>
movss  %xmm0,0x18(%rsp)
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  0xe37(%rip),%xmm0
call   1080 <sqrt@plt>
cvtss2sd %xmm0,%xmm0
mulsd  0xe2e(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm1
addsd  %xmm1,%xmm1
movsd  0xe21(%rip),%xmm8
divsd  %xmm1,%xmm8
movdqa 0xe54(%rip),%xmm0
mov    $0xc,%eax
movdqa 0xe56(%rip),%xmm9
movaps 0xe5f(%rip),%xmm3
movaps 0xe68(%rip),%xmm4
movdqa 0xe70(%rip),%xmm5
movdqa 0xe78(%rip),%xmm6
movdqa 0xe80(%rip),%xmm7
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,(%rsp,%rax,4)
movaps %xmm1,0x10(%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,0x20(%rsp,%rax,4)
movaps %xmm2,0x30(%rsp,%rax,4)
paddd  %xmm7,%xmm0
add    $0x10,%rax
cmp    $0x271c,%rax
jne    1230 <main+0xc0>
xorps  %xmm0,%xmm0
cvtsd2ss %xmm8,%xmm0
movss  %xmm0,0xc(%rsp)
mov    0x2d33(%rip),%r15
mov    (%r15),%edi
lea    0xe5a(%rip),%rsi
xor    %r12d,%r12d
mov    $0x2710,%edx
xor    %eax,%eax
call   1060 <fprintf@plt>
movss  0x10(%rsp),%xmm0
mulss  0xc(%rsp),%xmm0
movss  %xmm0,0x14(%rsp)
xorps  %xmm0,%xmm0
lea    0xe35(%rip),%r14
nopw   0x0(%rax,%rax,1)
movss  %xmm0,0x1c(%rsp)
movss  0x30(%rsp,%r12,4),%xmm0
movss  %xmm0,0x8(%rsp)
mulss  %xmm0,%xmm0
movss  %xmm0,0x4(%rsp)
movsd  0xd13(%rip),%xmm0
call   1080 <sqrt@plt>
cvtss2sd %xmm0,%xmm0
shufpd $0x2,0xda9(%rip),%xmm0
movapd %xmm0,0x20(%rsp)
movsd  0xcfb(%rip),%xmm0
call   1080 <sqrt@plt>
mulss  0xc(%rsp),%xmm0
mulss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xd8f(%rip),%xmm1
movlhps %xmm0,%xmm1
movapd 0x20(%rsp),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
movss  0x4(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x4(%rsp)
movsd  0xcab(%rip),%xmm0
call   1080 <sqrt@plt>
movss  %xmm0,0x20(%rsp)
movss  0x8(%rsp),%xmm0
movsd  0xc9a(%rip),%xmm1
call   1070 <pow@plt>
mov    %rax,%rbx
movss  0x18(%rsp),%xmm0
movsd  0xc84(%rip),%xmm1
call   1070 <pow@plt>
sub    %rax,%rbx
mov    %rbx,%rdi
call   1050 <fabs@plt>
divss  0x14(%rsp),%xmm0
mulss  0x20(%rsp),%xmm0
call   1040 <cosh@plt>
movsd  0xc63(%rip),%xmm1
divsd  %xmm0,%xmm1
movss  0x4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
movss  %xmm1,0x4(%rsp)
mov    (%r15),%edi
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mov    %r14,%rsi
mov    $0x2,%al
call   1060 <fprintf@plt>
movss  0x1c(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
mulss  0xcbd(%rip),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%r12
cmp    $0x2710,%r12
jne    12e0 <main+0x170>
mov    0x2ba1(%rip),%rax
mov    (%rax),%edi
cvtss2sd %xmm0,%xmm0
lea    0xcca(%rip),%rsi
movsd  0xbec(%rip),%xmm1
mov    $0x2,%al
call   1060 <fprintf@plt>
xor    %eax,%eax
add    $0x9c78,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    0x2b6d(%rip),%rax
mov    (%rax),%edi
lea    0xc68(%rip),%rsi
lea    0xc65(%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 = [33 x i8] c"./neufeld.x tau temperature x_in\00"
@stdout = global i32 0
@.str.2 = [6 x i8] c"# %d\0A\00"
@.str.3 = [7 x i8] c"%e %e\0A\00"
@.str.4 = [26 x i8] c"# 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 ([33 x i8], [33 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 float @sqrt(double %41)
%43 = fpext float %42 to double
%44 = fmul double 1.057000e+11, %43
%45 = fptrunc double %44 to float
store float %45, float* %15
%46 = load float, float* %14
%47 = fpext float %46 to double
%48 = load float, float* %15
%49 = fpext float %48 to double
%50 = fmul double 2.000000e+00, %49
%51 = fdiv double %47, %50
%52 = fptrunc double %51 to float
store float %52, float* %16
store float -1.500000e+02, float* %10
store float 1.500000e+02, float* %11
%53 = load float, float* %11
%54 = load float, float* %10
%55 = fsub float %53, %54
%56 = fdiv float %55, 1.000000e+04
store float %56, float* %12
store i32 0, i32* %13
br label %57
57: ; preds = %69, %26
%58 = load i32, i32* %13
%59 = icmp slt i32 %58, 10000
br i1 %59, label %60, label %72
60: ; preds = %57
%61 = load float, float* %10
%62 = load i32, i32* %13
%63 = sitofp i32 %62 to float
%64 = load float, float* %12
%65 = call float @llvm.fmuladd.f32(float %63, float %64, float %61)
%66 = load i32, i32* %13
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %67
store float %65, float* %68
br label %69
69: ; preds = %60
%70 = load i32, i32* %13
%71 = add nsw i32 %70, 1
store i32 %71, i32* %13
br label %57
72: ; preds = %57
%73 = load i32, i32* @stdout
%74 = call i32 (i32, i8*, ...) @fprintf(i32 %73, 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 %75
75: ; preds = %154, %72
%76 = load i32, i32* %13
%77 = icmp slt i32 %76, 10000
br i1 %77, label %78, label %157
78: ; preds = %75
%79 = load i32, i32* %13
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %80
%82 = load float, float* %81
%83 = load i32, i32* %13
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %84
%86 = load float, float* %85
%87 = fmul float %82, %86
%88 = load i32, i32* %13
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %89
store float %87, float* %90
%91 = call float @sqrt(double 6.000000e+00)
%92 = fpext float %91 to double
%93 = fdiv double %92, 2.400000e+01
%94 = call float @sqrt(double 3.141590e+00)
%95 = load float, float* %16
%96 = fmul float %94, %95
%97 = load float, float* %6
%98 = fmul float %96, %97
%99 = fpext float %98 to double
%100 = fdiv double 1.000000e+00, %99
%101 = fmul double %93, %100
%102 = load i32, i32* %13
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %103
%105 = load float, float* %104
%106 = fpext float %105 to double
%107 = fmul double %106, %101
%108 = fptrunc double %107 to float
store float %108, float* %104
%109 = call float @sqrt(double 0x3FE25FC14DA79CE0)
store float %109, float* %18
%110 = load i32, i32* %13
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %111
%113 = load float, float* %112
%114 = call i64 @pow(float %113, double 3.000000e+00)
%115 = load float, float* %17
%116 = call i64 @pow(float %115, double 3.000000e+00)
%117 = sub nsw i64 %114, %116
%118 = call float @fabs(i64 %117)
%119 = load float, float* %16
%120 = load float, float* %6
%121 = fmul float %119, %120
%122 = fdiv float %118, %121
%123 = load float, float* %18
%124 = fmul float %123, %122
store float %124, float* %18
%125 = load float, float* %18
%126 = call double @cosh(float %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* @stdout
%136 = load i32, i32* %13
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [10000 x float], [10000 x float]* %8, i64 0, i64 %137
%139 = load float, float* %138
%140 = fpext float %139 to double
%141 = load i32, i32* %13
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %142
%144 = load float, float* %143
%145 = fpext float %144 to double
%146 = call i32 (i32, i8*, ...) @fprintf(i32 %135, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), double %140, double %145)
%147 = load i32, i32* %13
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [10000 x float], [10000 x float]* %9, i64 0, i64 %148
%150 = load float, float* %149
%151 = load float, float* %12
%152 = load float, float* %19
%153 = call float @llvm.fmuladd.f32(float %150, float %151, float %152)
store float %153, float* %19
br label %154
154: ; preds = %78
%155 = load i32, i32* %13
%156 = add nsw i32 %155, 1
store i32 %156, i32* %13
br label %75
157: ; preds = %75
%158 = load i32, i32* @stderr
%159 = load float, float* %19
%160 = fpext float %159 to double
%161 = call i32 (i32, i8*, ...) @fprintf(i32 %158, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.4, i64 0, i64 0), double %160, double 0x3FB45F318E7ADAF5)
ret i32 0
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [4 x i8] c"%s\0A\00"
@.str.1 = [33 x i8] c"./neufeld.x tau temperature x_in\00"
@stdout = global i32 0
@.str.2 = [6 x i8] c"# %d\0A\00"
@.str.3 = [7 x i8] c"%e %e\0A\00"
@.str.4 = [26 x i8] c"# total %e [1/(4pi) =%e]\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [10000 x float]
%4 = bitcast [10000 x float]* %3 to i8*
%5 = icmp eq i32 %0, 4
br i1 %5, label %10, label %6
6: ; preds = %2
%7 = load i32, i32* @stderr
%8 = tail call i32 (i32, i8*, ...) @fprintf(i32 %7, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0))
%9 = tail call i32 @exit(i32 1)
unreachable
10: ; preds = %2
%11 = getelementptr inbounds i8*, i8** %1, i64 1
%12 = load i8*, i8** %11
%13 = tail call float @atof(i8* %12)
%14 = getelementptr inbounds i8*, i8** %1, i64 2
%15 = load i8*, i8** %14
%16 = tail call float @atof(i8* %15)
%17 = getelementptr inbounds i8*, i8** %1, i64 3
%18 = load i8*, i8** %17
%19 = tail call float @atof(i8* %18)
%20 = fpext float %16 to double
%21 = fdiv double %20, 1.000000e+04
%22 = tail call float @sqrt(double %21)
%23 = fpext float %22 to double
%24 = fmul double %23, 1.057000e+11
%25 = fptrunc double %24 to float
%26 = fpext float %25 to double
%27 = fmul double %26, 2.000000e+00
%28 = fdiv double 9.936000e+07, %27
br label %29
29: ; preds = %29, %10
%30 = phi i64 [ 0, %10 ], [ %52, %29 ]
%31 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %10 ], [ %53, %29 ]
%32 = add <4 x i32> %31, <i32 4, i32 4, i32 4, i32 4>
%33 = sitofp <4 x i32> %31 to <4 x float>
%34 = sitofp <4 x i32> %32 to <4 x float>
%35 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %33, <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>)
%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 = getelementptr inbounds [10000 x float], [10000 x float]* %3, i64 0, i64 %30
%38 = bitcast float* %37 to <4 x float>*
store <4 x float> %35, <4 x float>* %38
%39 = getelementptr inbounds float, float* %37, i64 4
%40 = bitcast float* %39 to <4 x float>*
store <4 x float> %36, <4 x float>* %40
%41 = or i64 %30, 8
%42 = add <4 x i32> %31, <i32 8, i32 8, i32 8, i32 8>
%43 = add <4 x i32> %31, <i32 12, i32 12, i32 12, i32 12>
%44 = sitofp <4 x i32> %42 to <4 x float>
%45 = sitofp <4 x i32> %43 to <4 x float>
%46 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %44, <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>)
%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 = getelementptr inbounds [10000 x float], [10000 x float]* %3, i64 0, i64 %41
%49 = bitcast float* %48 to <4 x float>*
store <4 x float> %46, <4 x float>* %49
%50 = getelementptr inbounds float, float* %48, i64 4
%51 = bitcast float* %50 to <4 x float>*
store <4 x float> %47, <4 x float>* %51
%52 = add nuw nsw i64 %30, 16
%53 = add <4 x i32> %31, <i32 16, i32 16, i32 16, i32 16>
%54 = icmp eq i64 %52, 10000
br i1 %54, label %55, label %29
55: ; preds = %29
%56 = fptrunc double %28 to float
%57 = load i32, i32* @stdout
%58 = tail call i32 (i32, i8*, ...) @fprintf(i32 %57, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 10000)
%59 = fmul float %13, %56
br label %60
60: ; preds = %55, %60
%61 = phi i64 [ 0, %55 ], [ %98, %60 ]
%62 = phi float [ 0.000000e+00, %55 ], [ %97, %60 ]
%63 = getelementptr inbounds [10000 x float], [10000 x float]* %3, i64 0, i64 %61
%64 = load float, float* %63
%65 = fmul float %64, %64
%66 = tail call float @sqrt(double 6.000000e+00)
%67 = fpext float %66 to double
%68 = tail call float @sqrt(double 3.141590e+00)
%69 = fmul float %68, %56
%70 = fmul float %13, %69
%71 = fpext float %70 to double
%72 = insertelement <2 x double> <double poison, double 1.000000e+00>, double %67, i64 0
%73 = insertelement <2 x double> <double 2.400000e+01, double poison>, double %71, i64 1
%74 = fdiv <2 x double> %72, %73
%75 = shufflevector <2 x double> %74, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%76 = fmul <2 x double> %74, %75
%77 = extractelement <2 x double> %76, i64 0
%78 = fpext float %65 to double
%79 = fmul double %77, %78
%80 = fptrunc double %79 to float
%81 = tail call float @sqrt(double 0x3FE25FC14DA79CE0)
%82 = tail call i64 @pow(float %64, double 3.000000e+00)
%83 = tail call i64 @pow(float %19, double 3.000000e+00)
%84 = sub nsw i64 %82, %83
%85 = tail call float @fabs(i64 %84)
%86 = fdiv float %85, %59
%87 = fmul float %81, %86
%88 = tail call double @cosh(float %87)
%89 = fdiv double 1.000000e+00, %88
%90 = fpext float %80 to double
%91 = fmul double %89, %90
%92 = fptrunc double %91 to float
%93 = load i32, i32* @stdout
%94 = fpext float %64 to double
%95 = fpext float %92 to double
%96 = tail call i32 (i32, i8*, ...) @fprintf(i32 %93, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), double %94, double %95)
%97 = tail call float @llvm.fmuladd.f32(float %92, float 0x3F9EB851E0000000, float %62)
%98 = add nuw nsw i64 %61, 1
%99 = icmp eq i64 %98, 10000
br i1 %99, label %100, label %60
100: ; preds = %60
%101 = load i32, i32* @stderr
%102 = fpext float %97 to double
%103 = tail call i32 (i32, i8*, ...) @fprintf(i32 %101, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.4, i64 0, i64 0), double %102, double 0x3FB45F318E7ADAF5)
ret i32 0
}