In [1]:
versioninfo()
Julia Version 0.6.1
Commit 0d7248e2ff* (2017-10-24 22:15 UTC)
Platform Info:
  OS: Windows (x86_64-w64-mingw32)
  CPU: Intel(R) Core(TM) i3-3240 CPU @ 3.40GHz
  WORD_SIZE: 64
  BLAS: libopenblas (USE64BITINT DYNAMIC_ARCH NO_AFFINITY Sandybridge)
  LAPACK: libopenblas64_
  LIBM: libopenlibm
  LLVM: libLLVM-3.9.1 (ORCJIT, ivybridge)
In [2]:
run(`python --version`)
Python 3.6.0 :: Anaconda 4.3.0 (64-bit)
In [3]:
run(`node --version`)
v8.9.4
In [4]:
nprocs()
Out[4]:
1
In [5]:
tic()
run(`python ./Python/lorenz.py`)
toc()
elapsed time: 0.911084809 seconds
Out[5]:
0.911084809
In [6]:
tic()
run(`julia ./julia/lorenz.jl`)
toc()
elapsed time: 0.352471908 seconds
Out[6]:
0.352471908
In [7]:
tic()
run(`python ./Python/lorenz.numba.py`)
toc()
elapsed time: 0.901488656 seconds
Out[7]:
0.901488656
In [8]:
tic()
run(`python ./Python/lorenz.swig.py`)
toc()
elapsed time: 0.272157333 seconds
Out[8]:
0.272157333
In [9]:
tic()
run(`node ./JS/lorenz.js`)
toc()
elapsed time: 0.186117365 seconds
Out[9]:
0.186117365
In [10]:
function lorenz()
    dt = 0.01
    n  = 200000

    a = 10.
    b = 28.
    c = 8/3

    x = zeros(n)
    y = zeros(n)
    z = zeros(n)

    x[1] = 0
    y[1] = 1.
    z[1] = 1.05

    for i = 1:n-1
        x[i+1] = x[i] + dt * (- a    * x[i] + a * y[i])
        y[i+1] = y[i] + dt * (- x[i] * z[i] + b * x[i] - y[i])
        z[i+1] = z[i] + dt * ( x[i]  * y[i] - c * z[i] )
    end
    return x,y,z
end
gx,gy,gz = lorenz()
Out[10]:
([0.0, 0.1, 0.189, 0.270808, 0.348532, 0.424755, 0.501673, 0.581205, 0.665079, 0.754902  …  0.148903, 0.0770094, 0.0142008, -0.0410513, -0.0900992, -0.134137, -0.174219, -0.211276, -0.246131, -0.279516], [1.0, 0.99, 1.00708, 1.04805, 1.11076, 1.19394, 1.29699, 1.41994, 1.56331, 1.72809  …  -0.570029, -0.551077, -0.53832, -0.53153, -0.530479, -0.534958, -0.544785, -0.559823, -0.579982, -0.605222], [1.05, 1.022, 0.995737, 0.971087, 0.94803, 0.92662, 0.906982, 0.889302, 0.87384, 0.860935  …  19.1004, 18.5902, 18.0941, 17.6115, 17.1421, 16.6854, 16.2412, 15.8091, 15.3887, 14.9797])
In [11]:
tic()
gx,gy,gz = lorenz()
toc()
elapsed time: 0.005422626 seconds
Out[11]:
0.005422626
In [12]:
using PyCall
unshift!(PyVector(pyimport("sys")["path"]), "")
@pyimport _SwigMod as SwigMod
In [13]:
tic()
dt = 0.01
n  = 200000

a = 10.
b = 28.
c = 8/3

x = zeros(n)
y = zeros(n)
z = zeros(n)

x[1] = 0
y[1] = 1.
z[1] = 1.05

SwigMod.Swig_Lorenz(x, y, z, a, b, c, dt, n)
toc()
elapsed time: 0.526467148 seconds
Out[13]:
0.526467148
In [14]:
tic()
dt = 0.01
n  = 200000

a = 10.
b = 28.
c = 8/3

x = zeros(n)
y = zeros(n)
z = zeros(n)

x[1] = 0
y[1] = 1.
z[1] = 1.05

SwigMod.Swig_Lorenz(x, y, z, a, b, c, dt, n)
toc()
elapsed time: 0.006806054 seconds
Out[14]:
0.006806054
In [15]:
code_native(lorenz,())
	.text
Filename: In[10]
	pushq	%rbp
	movq	%rsp, %rbp
	pushq	%r15
	pushq	%r14
	pushq	%r12
	pushq	%rsi
	pushq	%rdi
	pushq	%rbx
	subq	$256, %rsp              # imm = 0x100
	movapd	%xmm6, -64(%rbp)
	subq	$32, %rsp
	movabsq	$jl_get_ptls_states, %rax
	callq	*%rax
	addq	$32, %rsp
	movq	%rax, %r14
	xorps	%xmm0, %xmm0
	movups	%xmm0, -80(%rbp)
	movups	%xmm0, -96(%rbp)
	movups	%xmm0, -112(%rbp)
	movups	%xmm0, -128(%rbp)
	movups	%xmm0, -144(%rbp)
	movups	%xmm0, -160(%rbp)
	movups	%xmm0, -176(%rbp)
	movups	%xmm0, -192(%rbp)
	movups	%xmm0, -208(%rbp)
	movups	%xmm0, -224(%rbp)
	movups	%xmm0, -240(%rbp)
	movups	%xmm0, -256(%rbp)
	movups	%xmm0, -272(%rbp)
	movups	%xmm0, -288(%rbp)
	movq	$56, -304(%rbp)
	movq	(%r14), %rax
	movq	%rax, -296(%rbp)
	leaq	-304(%rbp), %rax
	movq	%rax, (%r14)
Source line: 9
	subq	$32, %rsp
	movl	$jl_alloc_array_1d, %esi
	movl	$112845264, %ecx        # imm = 0x6B9E1D0
	movl	$200000, %edx           # imm = 0x30D40
	callq	*%rsi
	addq	$32, %rsp
	movq	%rax, -288(%rbp)
	subq	$32, %rsp
	movabsq	$"fill!", %rdi
	xorps	%xmm1, %xmm1
	movq	%rax, %rcx
	callq	*%rdi
	addq	$32, %rsp
	movq	%rax, %r12
	movq	%r12, -280(%rbp)
Source line: 10
	subq	$32, %rsp
	movl	$112845264, %ecx        # imm = 0x6B9E1D0
	movl	$200000, %edx           # imm = 0x30D40
	callq	*%rsi
	addq	$32, %rsp
	movq	%rax, -272(%rbp)
	subq	$32, %rsp
	xorps	%xmm1, %xmm1
	movq	%rax, %rcx
	callq	*%rdi
	addq	$32, %rsp
	movq	%rax, %rbx
	movq	%rbx, -264(%rbp)
Source line: 11
	subq	$32, %rsp
	movl	$112845264, %ecx        # imm = 0x6B9E1D0
	movl	$200000, %edx           # imm = 0x30D40
	callq	*%rsi
	addq	$32, %rsp
	movq	%rax, -256(%rbp)
	subq	$32, %rsp
	xorps	%xmm1, %xmm1
	movq	%rax, %rcx
	callq	*%rdi
	addq	$32, %rsp
	movq	%rax, %r15
	movq	%r15, -248(%rbp)
Source line: 13
	movq	%r12, -240(%rbp)
Source line: 18
	movq	24(%r12), %r8
Source line: 13
	testq	%r8, %r8
	je	L1296
	movq	(%r12), %r11
	movq	$0, (%r11)
Source line: 14
	movq	%rbx, -232(%rbp)
	movq	24(%rbx), %r9
	testq	%r9, %r9
	je	L1358
	movq	(%rbx), %rax
	movabsq	$4607182418800017408, %rcx # imm = 0x3FF0000000000000
	movq	%rcx, (%rax)
Source line: 15
	movq	%r15, -224(%rbp)
	movq	24(%r15), %r10
	testq	%r10, %r10
	je	L1420
	movq	(%r15), %rdi
	movabsq	$4607407598781385933, %rcx # imm = 0x3FF0CCCCCCCCCCCD
	movq	%rcx, (%rdi)
	movl	$2, %ecx
	movabsq	$391948536, %rdx        # imm = 0x175CA8F8
Source line: 18
	movsd	(%rdx), %xmm0           # xmm0 = mem[0],zero
	movabsq	$391948544, %rdx        # imm = 0x175CA900
	movsd	(%rdx), %xmm1           # xmm1 = mem[0],zero
	movabsq	$391948552, %rdx        # imm = 0x175CA908
	movsd	(%rdx), %xmm2           # xmm2 = mem[0],zero
	movabsq	$391948560, %rdx        # imm = 0x175CA910
	movsd	(%rdx), %xmm3           # xmm3 = mem[0],zero
	nopl	(%rax,%rax)
L512:
	leaq	-1(%rcx), %rsi
	leaq	-2(%rcx), %rdx
	cmpq	%r8, %rdx
	jae	L906
	movq	%r12, -208(%rbp)
	movq	%rbx, -200(%rbp)
	cmpq	%r9, %rdx
	jae	L971
	movq	%r12, -192(%rbp)
	cmpq	%r8, %rsi
	jae	L1036
Source line: 19
	movsd	-16(%r11,%rcx,8), %xmm4 # xmm4 = mem[0],zero
Source line: 18
	movapd	%xmm4, %xmm5
	mulsd	%xmm0, %xmm5
	movsd	-16(%rax,%rcx,8), %xmm6 # xmm6 = mem[0],zero
	mulsd	%xmm0, %xmm6
	subsd	%xmm5, %xmm6
	mulsd	%xmm1, %xmm6
	addsd	%xmm4, %xmm6
	movsd	%xmm6, -8(%r11,%rcx,8)
Source line: 19
	movq	%rbx, -184(%rbp)
	movq	%r12, -176(%rbp)
	movq	%r15, -168(%rbp)
	cmpq	%r10, %rdx
	jae	L1101
	movq	%r12, -160(%rbp)
	movq	%rbx, -152(%rbp)
	movq	%rbx, -144(%rbp)
	cmpq	%r9, %rsi
	jae	L1166
Source line: 20
	movsd	-16(%rax,%rcx,8), %xmm5 # xmm5 = mem[0],zero
Source line: 19
	movapd	%xmm4, %xmm6
	mulsd	%xmm2, %xmm6
	mulsd	-16(%rdi,%rcx,8), %xmm4
	subsd	%xmm4, %xmm6
	subsd	%xmm5, %xmm6
	mulsd	%xmm1, %xmm6
	addsd	%xmm5, %xmm6
	movsd	%xmm6, -8(%rax,%rcx,8)
Source line: 20
	movq	%r15, -136(%rbp)
	movq	%r12, -128(%rbp)
	movq	%rbx, -120(%rbp)
	movq	%r15, -112(%rbp)
	movq	%r15, -104(%rbp)
	cmpq	%r10, %rsi
	jae	L1231
	movsd	-16(%rdi,%rcx,8), %xmm4 # xmm4 = mem[0],zero
	mulsd	-16(%r11,%rcx,8), %xmm5
	movapd	%xmm4, %xmm6
	mulsd	%xmm3, %xmm6
	addsd	%xmm5, %xmm6
	mulsd	%xmm1, %xmm6
	addsd	%xmm4, %xmm6
	movsd	%xmm6, -8(%rdi,%rcx,8)
Source line: 17
	incq	%rcx
	cmpq	$200001, %rcx           # imm = 0x30D41
	jne	L512
Source line: 18
	movq	%r12, -216(%rbp)
Source line: 22
	subq	$32, %rsp
	movabsq	$jl_gc_pool_alloc, %rax
	movl	$1512, %edx             # imm = 0x5E8
	movl	$32, %r8d
	movq	%r14, %rcx
	callq	*%rax
	addq	$32, %rsp
	movq	$424107824, -8(%rax)    # imm = 0x19475F30
	movq	%rax, -96(%rbp)
	movq	%r12, -88(%rbp)
	movq	%r12, (%rax)
	movq	%rbx, -80(%rbp)
	movq	%rbx, 8(%rax)
	movq	%r15, -72(%rbp)
	movq	%r15, 16(%rax)
	movq	-296(%rbp), %rcx
	movq	%rcx, sbdsvdx64_(%r14)
	movaps	-64(%rbp), %xmm6
	leaq	-48(%rbp), %rsp
	popq	%rbx
	popq	%rdi
	popq	%rsi
	popq	%r12
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
Source line: 18
L906:
	movq	%r12, -216(%rbp)
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	%rsi, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%r12, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
L971:
	movq	%r12, -216(%rbp)
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	%rsi, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%rbx, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
L1036:
	movq	%r12, -216(%rbp)
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	%rcx, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%r12, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
L1101:
	movq	%r12, -216(%rbp)
Source line: 19
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	%rsi, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%r15, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
Source line: 18
L1166:
	movq	%r12, -216(%rbp)
Source line: 19
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	%rcx, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%rbx, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
Source line: 18
L1231:
	movq	%r12, -216(%rbp)
Source line: 20
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	%rcx, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%r15, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
Source line: 13
L1296:
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	$1, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%r12, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
Source line: 14
L1358:
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	$1, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%rbx, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
Source line: 15
L1420:
	movl	$16, %eax
	movabsq	$1896134096, %r11       # imm = 0x7104B5D0
	callq	*%r11
	subq	%rax, %rsp
	movq	%rsp, %rdx
	movq	$1, (%rdx)
	subq	$32, %rsp
	movabsq	$jl_bounds_error_ints, %rax
	movl	$1, %r8d
	movq	%r15, %rcx
	callq	*%rax
	addq	$32, %rsp
	ud2
	nopw	(%rax,%rax)
In [16]:
code_llvm(lorenz,())
; Function Attrs: uwtable
define i8** @julia_lorenz_63943() #0 !dbg !5 {
top:
  %0 = call i8**** @jl_get_ptls_states() #5
  %1 = alloca [30 x i8**], align 8
  %.sub = getelementptr inbounds [30 x i8**], [30 x i8**]* %1, i64 0, i64 0
  %2 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 2
  %3 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 3
  %4 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 4
  %5 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 5
  %6 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 6
  %7 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 7
  %8 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 8
  %9 = bitcast [30 x i8**]* %1 to i64*
  %10 = bitcast i8*** %2 to i8*
  call void @llvm.memset.p0i8.i64(i8* %10, i8 0, i64 224, i32 8, i1 false)
  store i64 56, i64* %9, align 8
  %11 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 1
  %12 = bitcast i8**** %0 to i64*
  %13 = load i64, i64* %12, align 8
  %14 = bitcast i8*** %11 to i64*
  store i64 %13, i64* %14, align 8
  store i8*** %.sub, i8**** %0, align 8
  %15 = call i8** inttoptr (i64 1693642832 to i8** (i8**, i64)*)(i8** inttoptr (i64 112845264 to i8**), i64 200000)
  store i8** %15, i8*** %2, align 8
  %16 = call i8** @"jlsys_fill!_58919"(i8** %15, double 0.000000e+00)
  store i8** %16, i8*** %3, align 8
  %17 = call i8** inttoptr (i64 1693642832 to i8** (i8**, i64)*)(i8** inttoptr (i64 112845264 to i8**), i64 200000)
  store i8** %17, i8*** %4, align 8
  %18 = call i8** @"jlsys_fill!_58919"(i8** %17, double 0.000000e+00)
  store i8** %18, i8*** %5, align 8
  %19 = call i8** inttoptr (i64 1693642832 to i8** (i8**, i64)*)(i8** inttoptr (i64 112845264 to i8**), i64 200000)
  store i8** %19, i8*** %6, align 8
  %20 = call i8** @"jlsys_fill!_58919"(i8** %19, double 0.000000e+00)
  store i8** %20, i8*** %7, align 8
  store i8** %16, i8*** %8, align 8
  %21 = getelementptr i8*, i8** %16, i64 3
  %22 = bitcast i8** %21 to i64*
  %23 = load i64, i64* %22, align 8
  %24 = icmp eq i64 %23, 0
  br i1 %24, label %oob, label %idxend

oob:                                              ; preds = %top
  %25 = alloca i64, align 8
  store i64 1, i64* %25, align 8
  call void @jl_bounds_error_ints(i8** %16, i64* nonnull %25, i64 1)
  unreachable

idxend:                                           ; preds = %top
  %26 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 9
  %27 = bitcast i8** %16 to double**
  %28 = load double*, double** %27, align 8
  store double 0.000000e+00, double* %28, align 8
  store i8** %18, i8*** %26, align 8
  %29 = getelementptr i8*, i8** %18, i64 3
  %30 = bitcast i8** %29 to i64*
  %31 = load i64, i64* %30, align 8
  %32 = icmp eq i64 %31, 0
  br i1 %32, label %oob1, label %idxend2

oob1:                                             ; preds = %idxend
  %33 = alloca i64, align 8
  store i64 1, i64* %33, align 8
  call void @jl_bounds_error_ints(i8** %18, i64* nonnull %33, i64 1)
  unreachable

idxend2:                                          ; preds = %idxend
  %34 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 10
  %35 = bitcast i8** %18 to double**
  %36 = load double*, double** %35, align 8
  store double 1.000000e+00, double* %36, align 8
  store i8** %20, i8*** %34, align 8
  %37 = getelementptr i8*, i8** %20, i64 3
  %38 = bitcast i8** %37 to i64*
  %39 = load i64, i64* %38, align 8
  %40 = icmp eq i64 %39, 0
  br i1 %40, label %oob3, label %idxend4

oob3:                                             ; preds = %idxend2
  %41 = alloca i64, align 8
  store i64 1, i64* %41, align 8
  call void @jl_bounds_error_ints(i8** %20, i64* nonnull %41, i64 1)
  unreachable

idxend4:                                          ; preds = %idxend2
  %42 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 11
  %43 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 12
  %44 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 13
  %45 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 14
  %46 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 15
  %47 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 16
  %48 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 17
  %49 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 18
  %50 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 19
  %51 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 20
  %52 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 21
  %53 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 22
  %54 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 23
  %55 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 24
  %56 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 25
  %57 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 26
  %58 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 27
  %59 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 28
  %60 = getelementptr [30 x i8**], [30 x i8**]* %1, i64 0, i64 29
  %61 = bitcast i8** %20 to double**
  %62 = load double*, double** %61, align 8
  store double 1.050000e+00, double* %62, align 8
  br label %if

if:                                               ; preds = %idxend4, %idxend34
  %"#temp#.078" = phi i64 [ 1, %idxend4 ], [ %78, %idxend34 ]
  %63 = add nsw i64 %"#temp#.078", -1
  %64 = icmp ult i64 %63, %23
  br i1 %64, label %idxend8, label %oob5

L36:                                              ; preds = %idxend34
  store i8** %16, i8*** %42, align 8
  %65 = bitcast i8**** %0 to i8*
  %66 = call i8** @jl_gc_pool_alloc(i8* %65, i32 1512, i32 32)
  %67 = getelementptr i8*, i8** %66, i64 -1
  %68 = bitcast i8** %67 to i8***
  store i8** inttoptr (i64 424107824 to i8**), i8*** %68, align 8
  store i8** %66, i8*** %57, align 8
  %69 = bitcast i8** %66 to i8***
  %70 = getelementptr i8*, i8** %66, i64 1
  %71 = bitcast i8** %70 to i8***
  %72 = getelementptr i8*, i8** %66, i64 2
  %73 = bitcast i8** %72 to i8***
  store i8** %16, i8*** %58, align 8
  store i8** %16, i8*** %69, align 8
  store i8** %18, i8*** %59, align 8
  store i8** %18, i8*** %71, align 8
  store i8** %20, i8*** %60, align 8
  store i8** %20, i8*** %73, align 8
  %74 = load i64, i64* %14, align 8
  store i64 %74, i64* %12, align 8
  ret i8** %66

oob5:                                             ; preds = %if
  store i8** %16, i8*** %42, align 8
  %75 = alloca i64, align 8
  store i64 %"#temp#.078", i64* %75, align 8
  call void @jl_bounds_error_ints(i8** %16, i64* nonnull %75, i64 1)
  unreachable

idxend8:                                          ; preds = %if
  store i8** %16, i8*** %43, align 8
  store i8** %18, i8*** %44, align 8
  %76 = icmp ult i64 %63, %31
  br i1 %76, label %idxend10, label %oob9

oob9:                                             ; preds = %idxend8
  store i8** %16, i8*** %42, align 8
  %77 = alloca i64, align 8
  store i64 %"#temp#.078", i64* %77, align 8
  call void @jl_bounds_error_ints(i8** %18, i64* nonnull %77, i64 1)
  unreachable

idxend10:                                         ; preds = %idxend8
  %78 = add nuw nsw i64 %"#temp#.078", 1
  store i8** %16, i8*** %45, align 8
  %79 = icmp ult i64 %"#temp#.078", %23
  br i1 %79, label %idxend16, label %oob11

oob11:                                            ; preds = %idxend10
  store i8** %16, i8*** %42, align 8
  %80 = alloca i64, align 8
  store i64 %78, i64* %80, align 8
  call void @jl_bounds_error_ints(i8** %16, i64* nonnull %80, i64 1)
  unreachable

idxend16:                                         ; preds = %idxend10
  %81 = getelementptr double, double* %28, i64 %63
  %82 = load double, double* %81, align 8
  %83 = getelementptr double, double* %36, i64 %63
  %84 = load double, double* %83, align 8
  %85 = fmul double %82, 1.000000e+01
  %86 = fmul double %84, 1.000000e+01
  %87 = fsub double %86, %85
  %88 = fmul double %87, 1.000000e-02
  %89 = fadd double %82, %88
  %90 = getelementptr double, double* %28, i64 %"#temp#.078"
  store double %89, double* %90, align 8
  store i8** %18, i8*** %46, align 8
  store i8** %16, i8*** %47, align 8
  store i8** %20, i8*** %48, align 8
  %91 = icmp ult i64 %63, %39
  br i1 %91, label %idxend22, label %oob17

oob17:                                            ; preds = %idxend16
  store i8** %16, i8*** %42, align 8
  %92 = alloca i64, align 8
  store i64 %"#temp#.078", i64* %92, align 8
  call void @jl_bounds_error_ints(i8** %20, i64* nonnull %92, i64 1)
  unreachable

idxend22:                                         ; preds = %idxend16
  store i8** %16, i8*** %49, align 8
  store i8** %18, i8*** %50, align 8
  store i8** %18, i8*** %51, align 8
  %93 = icmp ult i64 %"#temp#.078", %31
  br i1 %93, label %idxend32, label %oob23

oob23:                                            ; preds = %idxend22
  store i8** %16, i8*** %42, align 8
  %94 = alloca i64, align 8
  store i64 %78, i64* %94, align 8
  call void @jl_bounds_error_ints(i8** %18, i64* nonnull %94, i64 1)
  unreachable

idxend32:                                         ; preds = %idxend22
  %95 = load double, double* %83, align 8
  %96 = getelementptr double, double* %62, i64 %63
  %97 = load double, double* %96, align 8
  %98 = fmul double %82, 2.800000e+01
  %99 = fmul double %82, %97
  %100 = fsub double %98, %99
  %101 = fsub double %100, %95
  %102 = fmul double %101, 1.000000e-02
  %103 = fadd double %95, %102
  %104 = getelementptr double, double* %36, i64 %"#temp#.078"
  store double %103, double* %104, align 8
  store i8** %20, i8*** %52, align 8
  store i8** %16, i8*** %53, align 8
  store i8** %18, i8*** %54, align 8
  store i8** %20, i8*** %55, align 8
  store i8** %20, i8*** %56, align 8
  %105 = icmp ult i64 %"#temp#.078", %39
  br i1 %105, label %idxend34, label %oob33

oob33:                                            ; preds = %idxend32
  store i8** %16, i8*** %42, align 8
  %106 = alloca i64, align 8
  store i64 %78, i64* %106, align 8
  call void @jl_bounds_error_ints(i8** %20, i64* nonnull %106, i64 1)
  unreachable

idxend34:                                         ; preds = %idxend32
  %107 = load double, double* %96, align 8
  %108 = load double, double* %81, align 8
  %109 = fmul double %108, %95
  %110 = fmul double %107, 0x4005555555555555
  %111 = fsub double %109, %110
  %112 = fmul double %111, 1.000000e-02
  %113 = fadd double %107, %112
  %114 = getelementptr double, double* %62, i64 %"#temp#.078"
  store double %113, double* %114, align 8
  %115 = icmp eq i64 %78, 200000
  br i1 %115, label %L36, label %if
}