Package compiler #230

MilesCranmer · 2022-11-22T23:29:17Z

This is an early WIP to integrate PackageCompiler.jl into PySR. No more startup time!

mkitti · 2022-11-22T23:39:30Z

Where are you expecting to compile?

Have you tried https://github.com/timholy/SnoopCompile.jl/tree/master/SnoopPrecompile ?

Also see this: https://sciml.ai/news/2022/09/21/compile_time/

MilesCranmer · 2022-11-23T00:33:30Z

The current version of pysr.create_sysimage here runs a single model.fit() with default settings, and saves a sysimage of the Julia runtime. I'm thinking this could be done automatically as part of pysr.install() - it should help startup time quite a bit and be kind of like any C-backed Python library.

I played around with SnoopPrecompile but by itself it didn't seem to boost startup time that much. But I'm assuming that is just for precompilation, rather than building a whole sysimage - the latter of which should help startup time more, right? I was a bit confused where the boundary is between precompilation and sysimages. If I improve precompilation, do I get a better sysimage, than if I just run a full model pass and save the runtime? @ChrisRackauckas? (Great blogpost btw)

PySR might also be a bit different than ODE solvers here in that I don't need to re-compile if the input data/settings change (unless its a new operator or loss function), like I would have to with a new ODE. i.e., since the user provides data in a standard array format, I think a simple sysimage might be good enough...?

mkitti · 2022-11-23T00:41:54Z

A system image refers to native code caching. However, we still need to put work in to figure out which code to compile. Note that we really need to address the compiled_modules=False issue.

MilesCranmer · 2022-11-23T01:14:12Z

A system image refers to native code caching.

Wait, why can't I just do this, and cache the native code for a standard run?

Note that we really need to address the compiled_modules=False issue.

Do you mean make PyJulia do this automatically like PySR does (easy-ish), or actually fix the underlying pre-compilation issue (seems impossibly difficult)?

mkitti · 2022-11-23T15:16:16Z

Think about when native code is generated in Julia. It is not generated from the function definitions alone. Rather it is generated when you call the function.

In order to generate the native code, you need to either run an example workflow or generate precompile statements. SnoopPrecompile helps with both aspects.

One thing that SnoopPrecompile does is figure I out when we are caching type inference or native code to disk. When it detects that, then it executes thr demo workflow and/or precompile statements.

MilesCranmer · 2022-11-23T18:34:49Z

Thanks for trying to explain this. I don't completely follow the underlying reasons why it would improve over simply caching a typical PySR run, but it sounds like SnoopCompile will help with startup time regardless. So I will try setting it up with a @precompile_all_calls in SymbolicRegression.jl. Is there anything I can do to improve the PyCall.jl startup too (specifically for the SymbolicRegression.jl interface?)?

MilesCranmer · 2022-11-28T19:48:57Z

Okay it's actually working now! You can try it out with: python -c 'import pysr; pysr.install()'; python -c 'import pysr; pysr.compile()' (need to be separate sessions for some reasons). There are some tricky things to work out still (the custom DEPOT test is currently failing), but it's cool that it's working. I get about a 33% improved speed overall in running example.py.

By default it tries to create a pysr.so and put it in the pysr-0.11.12 shared project directory. That way it can simply check for the existence of that sysimage at startup, and load it if it's there.

MilesCranmer · 2022-11-29T14:43:16Z

Interesting. It seems like most of the startup time is now due to getting the Julia version and project path, with, e.g.,

cmds = [
    "julia",
    "-e using Pkg; print(Pkg.project().path)",
]
julia_project_dir_str = subprocess.run(
    cmds,
    capture_output=True,
    env=os.environ,
).stdout.decode()

is there a way to get this information much faster? This uses JULIA_PROJECT to set the project, although sometimes it will be, e.g., @pysr-0.11.12, so Python by itself can't figure out the path.

mkitti · 2022-11-29T15:08:00Z

I think we might be able to extract this from pyjulia earlier than we boot up PyCall.jl or even without PyCall.jl.

MilesCranmer · 2022-11-29T15:09:21Z

I got it a bit faster, now it's not so bad:

time julia --startup-file=no --compile=min -O0 -g0 [email protected] -e 'import Pkg: project; print(project().path)'
#    0.15s user 0.21s system 287% cpu 0.128 total

I think it might have just been the startup file to be honest.

MilesCranmer · 2022-11-29T15:15:55Z

It's now down to 13 seconds to run example.py, whereas before it was 32 seconds! Not bad at all. It's still a bit faster to run .fit() the second time though; I wonder what else is missing.

MilesCranmer · 2022-11-29T15:16:29Z

cc @Quarlos

mkitti · 2022-11-29T15:43:44Z

It's still a bit faster to run .fit() the second time though

This suggests there are more precompile statements to generate or write.

One quick way would be to enable trace compile. SnoopCompile.jl also works.

julia --trace-compile=stderr

MilesCranmer · 2022-11-29T15:47:57Z

Good idea.

One interesting thing is that the startup time in pure-Julia is pretty much the same as the second run. But for some reason the Python version experiences extra startup penalty. I wonder how much is due to PyCall.jl compiling interfaces?

MilesCranmer · 2022-11-29T16:37:53Z

For future reference, since I didn't know how to set --trace-compile, you can do it with the low-level interface:

# within `init_julia`, hence `julia_kwargs` is a dict of CLI options:
from julia.api import LibJulia

api = LibJulia.load(julia="julia")
api.sysimage = sysimage_name
cmds = [
    f"--{k}={v}" if v is not None else f"--{k}" for k, v in julia_kwargs.items()
]
cmds += ["--trace-compile=stderr"]
print("Running with", cmds)
api.init_julia(cmds)

I also had to modify example.py with verbosity=0, progress=False, so that the progress bar is muted (otherwise it prints to stderr).

Here is the full output:

precompile(Tuple{Type{REPL.Terminals.TTYTerminal}, String, Base.TTY, Base.TTY, Base.IOStream})
precompile(Tuple{typeof(Base.something), Nothing, Base.IOStream})
precompile(Tuple{Base.var"##parse#477", Nothing, typeof(Base.parse), Type{Bool}, String})
precompile(Tuple{typeof(Base.foreach), typeof(ThreadingUtilities.initialize_task), Base.UnitRange{Int64}})
precompile(Tuple{typeof(Requires.withpath), Any, String})
precompile(Tuple{typeof(Base.task_local_storage)})
precompile(Tuple{typeof(Base.haskey), Base.IdDict{Any, Any}, Symbol})
precompile(Tuple{BangBang.NoBang.var"#7#10"})
precompile(Tuple{typeof(Requires.err), Any, Module, String, String, Any})
precompile(Tuple{BangBang.NoBang.var"#8#11"})
precompile(Tuple{typeof(Requires._include_path), String})
precompile(Tuple{typeof(Base.source_path), Nothing})
precompile(Tuple{typeof(Base.getindex), Base.RefValue{Base.CoreLogging.LogLevel}})
precompile(Tuple{typeof(Base.:(>=)), Base.CoreLogging.LogLevel, Base.CoreLogging.LogLevel})
precompile(Tuple{typeof(Base.isassigned), Base.RefValue{Symbol}})
precompile(Tuple{typeof(Base.setindex!), Base.RefValue{Symbol}, Symbol})
precompile(Tuple{typeof(Base.delete!), Base.IdDict{Any, Any}, Any})
precompile(Tuple{BangBang.var"#24#36"})
precompile(Tuple{BangBang.var"#25#37"})
precompile(Tuple{typeof(Base.getindex), Base.RefValue{Symbol}})
precompile(Tuple{BangBang.var"#27#39"})
precompile(Tuple{BangBang.var"#28#40"})
precompile(Tuple{typeof(JLLWrappers.get_julia_libpaths)})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, PyCall.PyObject})
precompile(Tuple{typeof(Base._append!), Array{PyCall.PyMemberDef, 1}, Base.HasLength, Tuple{PyCall.PyMemberDef, PyCall.PyMemberDef}})
precompile(Tuple{typeof(Base.getproperty), PyCall.PyError, Symbol})
precompile(Tuple{typeof(Base.unsafe_load), Ptr{Ptr{PyCall.PyObject_struct}}})
precompile(Tuple{typeof(PyCall.pyisinstance), PyCall.PyObject, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{typeof(PyCall.current_python)})
precompile(Tuple{typeof(Base.escape_string), String})
precompile(Tuple{typeof(PyCall.pyerror), String, PyCall.PyError})
precompile(Tuple{typeof(Base.get!), PyCall.var"#115#116"{Module}, Base.Dict{Module, PyCall.PyDict{String, PyCall.PyObject, true}}, Module})
precompile(Tuple{Transducers.var"#290#305"})
precompile(Tuple{Transducers.var"#291#306"})
precompile(Tuple{Type{Base.Dict{Int64, Metatheory.EGraphs.EClass}}})
precompile(Tuple{Type{Base.Dict{Metatheory.EGraphs.AbstractENode{T} where T, Int64}}})
precompile(Tuple{Type{Base.Dict{Type{var"#s10"} where var"#s10"<:Metatheory.EGraphs.AbstractAnalysis, Nothing}}})
precompile(Tuple{Type{Base.Dict{Tuple{Any, Int64}, Type}}})
precompile(Tuple{Type{Base.Dict{Metatheory.Patterns.AbstractPat, Int32}}})
precompile(Tuple{Type{Base.Dict{Any, Int32}}, Base.Dict{Metatheory.Patterns.AbstractPat, Int32}})
precompile(Tuple{typeof(Base._unsafe_copyto!), Array{Union{Nothing, Metatheory.EGraphs.ENodeLiteral{T} where T}, 1}, Int64, Array{Nothing, 1}, Int64, Int64})
precompile(Tuple{Zygote.Profile.var"#11#15"})
precompile(Tuple{typeof(Requires.listenpkg), Any, Base.PkgId})
precompile(Tuple{typeof(Requires.loaded), Base.PkgId})
precompile(Tuple{typeof(Requires.callbacks), Base.PkgId})
precompile(Tuple{Zygote.var"#1064#1068"})
precompile(Tuple{Zygote.var"#1076#1080"})
precompile(Tuple{Zygote.var"#1084#1088"})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, Function})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, Bool})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, Nothing})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), Function, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{typeof(PyCall.typetuple), Base.Generator{Base.UnitRange{Int64}, PyCall.var"#36#37"{PyCall.PyObject}}})
precompile(Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, PyCall.var"#36#37"{PyCall.PyObject}}})
precompile(Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, PyCall.var"#36#37"{PyCall.PyObject}}, Int64})
precompile(Tuple{typeof(PyCall.pydecref), PyCall.PyObject})
precompile(Tuple{typeof(PyCall.pydecref), PyCall.PyBuffer})
precompile(Tuple{typeof(Base.convert), Type{Tuple{String}}, PyCall.PyObject})
precompile(Tuple{typeof(PyCall.tuptype), DataType, Bool, Int64})
precompile(Tuple{typeof(Base.MainInclude.include), String})
precompile(Tuple{typeof(PyCall.pyany_toany), Type})
precompile(Tuple{Type{LineNumberNode}, Int64})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{LineNumberNode, 1}}})
precompile(Tuple{DocStringExtensions.var"#35#36"{typeof(DocStringExtensions.template_hook)}, LineNumberNode, Vararg{Any}})
precompile(Tuple{typeof(DocStringExtensions.template_hook), LineNumberNode, Module, String, Expr})
precompile(Tuple{Type{Ref{IO}}})
precompile(Tuple{Type{Ref{Base.PipeEndpoint}}})
precompile(Tuple{typeof(_PyJuliaHelper.IOPiper.__init__)})
precompile(Tuple{typeof(Base.setindex!), Base.RefValue{IO}, Base.TTY})
precompile(Tuple{typeof(Base.setindex!), Base.RefValue{IO}, Base.IOStream})
precompile(Tuple{typeof(PyCall.pyreturn), Module})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, String})
precompile(Tuple{Type{Base.Generator{Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, PyCall.var"#61#62"}}, Function, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})
precompile(Tuple{typeof(PyCall.pyfunctionret), Function, Type, Type})
precompile(Tuple{Type{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#1#2"}}}}, Function, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#1#2"}}}})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#1#2"}}}, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{typeof(PyCall.istuplen), Type, Bool, Int64})
precompile(Tuple{typeof(Base.length), Core.SimpleVector})
precompile(Tuple{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#1#2"}}}, Function})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), Function})
precompile(Tuple{typeof(PyCall.pyreturn), PyCall.PyObject})
precompile(Tuple{Type{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#3#4"}}}}, Function, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#3#4"}}}})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#3#4"}}}, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#3#4"}}}, Function})
precompile(Tuple{Type{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#5#6"}}}}, Function, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#5#6"}}}})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#5#6"}}}, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#5#6"}}}, Function})
precompile(Tuple{Type{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#7#8"}}}}, Function, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#7#8"}}}})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#7#8"}}}, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#7#8"}}}, Function})
precompile(Tuple{Type{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#9#10"}}}}, Function, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#9#10"}}}})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#9#10"}}}, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#9#10"}}}, Function})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, Type})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), Type, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{}}, PyCall.PyObject})
precompile(Tuple{Type{PyCall.PyDict{Symbol, PyCall.PyObject, true}}, PyCall.PyObject})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, PyCall.var"#57#58"{DataType}, PyCall.PyDict{Symbol, PyCall.PyObject, true}})
precompile(Tuple{typeof(Base.collect), Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{DataType}}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ref{Int64}}, Base.RefValue{Int64}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ref{Ptr{PyCall.PyObject_struct}}}, Base.RefValue{Ptr{PyCall.PyObject_struct}}})
precompile(Tuple{typeof(Base.convert), Type{Float64}, PyCall.PyObject})
precompile(Tuple{typeof(Base._array_for), Type{Tuple{Symbol, Float64}}, Base.HasLength, Int64})
precompile(Tuple{typeof(Base.ndims), Array{Tuple{Symbol, Float64}, 1}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Tuple{Symbol, Float64}, 1}, Tuple{Symbol, Float64}, Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{DataType}}, PyCall.PyDict_Iterator})
precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, Array{Tuple{Symbol, Float64}, 1}})
precompile(Tuple{Type{NamedTuple{(:mutate_constant, :mutate_operator, :add_node, :insert_node, :delete_node, :simplify, :randomize, :do_nothing, :optimize), T} where T<:Tuple}, Tuple{Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64}})
precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, NamedTuple{(:mutate_constant, :mutate_operator, :add_node, :insert_node, :delete_node, :simplify, :randomize, :do_nothing, :optimize), Tuple{Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64}}})
precompile(Tuple{typeof(Base.isempty), NamedTuple{(:mutate_constant, :mutate_operator, :add_node, :insert_node, :delete_node, :simplify, :randomize, :do_nothing, :optimize), Tuple{Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64}}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{Base.var"#invokelatest##kw", NamedTuple{(:mutate_constant, :mutate_operator, :add_node, :insert_node, :delete_node, :simplify, :randomize, :do_nothing, :optimize), Tuple{Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64}}, typeof(Base.invokelatest), Any})
precompile(Tuple{Core.var"#Type##kw", NamedTuple{(:mutate_constant, :mutate_operator, :add_node, :insert_node, :delete_node, :simplify, :randomize, :do_nothing, :optimize), Tuple{Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64, Float64}}, Type{SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights}})
precompile(Tuple{typeof(PyCall.pyreturn), SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights})
precompile(Tuple{typeof(Base.promote_type), Type{typeof(Base.:(+))}, Type{typeof(Base.:(*))}})
precompile(Tuple{typeof(Base.copyto!), Array{Function, 1}, Tuple{typeof(Base.:(+)), typeof(Base.:(*))}})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, Array{Function, 1}})
precompile(Tuple{typeof(Base.promote_type), Type{typeof(Base.sin)}, Type{typeof(Main.inv)}})
precompile(Tuple{typeof(Base.promote_type), Type{typeof(Base.exp)}, Type{Function}})
precompile(Tuple{typeof(Base.promote_type), Type{typeof(Base.cos)}, Type{Function}})
precompile(Tuple{typeof(Base.copyto!), Array{Function, 1}, Tuple{typeof(Base.cos), typeof(Base.exp), typeof(Base.sin), typeof(Main.inv)}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, PyCall.var"#57#58"{UnionAll}, PyCall.PyDict{Symbol, PyCall.PyObject, true}})
precompile(Tuple{typeof(Base.collect), Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{UnionAll}}})
precompile(Tuple{typeof(Base.convert), Type{Array{T, N} where N where T}, PyCall.PyObject})
precompile(Tuple{Type{Array{Any, N} where N}, UndefInitializer, Tuple{Int64}})
precompile(Tuple{typeof(PyCall.py2array), Type, Array{Any, 1}, PyCall.PyObject, Int64, Int64})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.identity), Array{Any, 1}})
precompile(Tuple{typeof(Base.collect_similar), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(Base.identity)}})
precompile(Tuple{typeof(Base._similar_for), Array{Any, 1}, Type{typeof(Base.:(+))}, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.ndims), Array{typeof(Base.:(+)), 1}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{typeof(Base.:(+)), 1}, Function, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Int64})
precompile(Tuple{typeof(Base.collect_to!), Array{Function, 1}, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Int64, Int64})
precompile(Tuple{typeof(Base._array_for), Type{Tuple{Symbol, Array{Function, 1}}}, Base.HasLength, Int64})
precompile(Tuple{typeof(Base.ndims), Array{Tuple{Symbol, Array{Function, 1}}, 1}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Tuple{Symbol, Array{Function, 1}}, 1}, Tuple{Symbol, Array{Function, 1}}, Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{UnionAll}}, PyCall.PyDict_Iterator})
precompile(Tuple{typeof(Base._similar_for), Array{Any, 1}, Type{typeof(Base.cos)}, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.ndims), Array{typeof(Base.cos), 1}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{typeof(Base.cos), 1}, Function, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Int64})
precompile(Tuple{typeof(Base.convert), Type{Tuple{Integer, Integer}}, PyCall.PyObject})
precompile(Tuple{typeof(Base.convert), Type{Integer}, PyCall.PyObject})
precompile(Tuple{typeof(Base._similar_for), Array{Any, 1}, Type{Tuple{Int64, Int64}}, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.ndims), Array{Tuple{Int64, Int64}, 1}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Tuple{Int64, Int64}, 1}, Tuple{Int64, Int64}, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Int64})
precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{Tuple{Symbol, Array{Function, 1}}, 1}, Tuple{Symbol, Array{Tuple{Int64, Int64}, 1}}, Int64})
precompile(Tuple{typeof(Base.collect_to!), Array{Tuple{Symbol, Array{T, 1} where T}, 1}, Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{UnionAll}}, Int64, PyCall.PyDict_Iterator})
precompile(Tuple{typeof(Base._similar_for), Array{Any, 1}, Type{Int64}, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Int64, 1}, Int64, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Int64})
precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{Tuple{Symbol, Array{T, 1} where T}, 1}, Tuple{Symbol, Nothing}, Int64})
precompile(Tuple{typeof(Base.collect_to!), Array{Tuple{Symbol, Any}, 1}, Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{UnionAll}}, Int64, PyCall.PyDict_Iterator})
precompile(Tuple{typeof(Base.convert), Type{Bool}, PyCall.PyObject})
precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, Array{Tuple{Symbol, Any}, 1}})
precompile(Tuple{Type{NamedTuple{(:binary_operators, :unary_operators, :bin_constraints, :una_constraints, :complexity_of_operators, :complexity_of_constants, :complexity_of_variables, :nested_constraints, :loss, :maxsize, :output_file, :npopulations, :batching, :batch_size, :mutation_weights, :tournament_selection_p, :tournament_selection_n, :parsimony, :alpha, :maxdepth, :fast_cycle, :turbo, :migration, :hof_migration, :fraction_replaced_hof, :should_optimize_constants, :warmup_maxsize_by, :use_frequency, :use_frequency_in_tournament, :adaptive_parsimony_scaling, :npop, :ncycles_per_iteration, :fraction_replaced, :topn, :verbosity, :optimizer_algorithm, :optimizer_nrestarts, :optimizer_probability, :optimizer_iterations, :perturbation_factor, :annealing, :return_state, :progress, :timeout_in_seconds, :crossover_probability, :skip_mutation_failures, :max_evals, :early_stop_condition, :seed, :deterministic, :define_helper_functions), T} where T<:Tuple}, Tuple{Array{Function, 1}, Array{Function, 1}, Array{Tuple{Int64, Int64}, 1}, Array{Int64, 1}, Nothing, Int64, Int64, Nothing, typeof(Main.loss), Int64, String, Int64, Bool, Int64, SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights, Float64, Int64, Float64, Float64, Int64, Bool, Bool, Bool, Bool, Float64, Bool, Float64, Bool, Bool, Float64, Int64, Int64, Float64, Int64, Int64, String, Int64, Float64, Int64, Float64, Bool, Bool, Bool, Nothing, Float64, Bool, Nothing, Nothing, PyCall.PyObject, Bool, Bool}})
precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, NamedTuple{(:binary_operators, :unary_operators, :bin_constraints, :una_constraints, :complexity_of_operators, :complexity_of_constants, :complexity_of_variables, :nested_constraints, :loss, :maxsize, :output_file, :npopulations, :batching, :batch_size, :mutation_weights, :tournament_selection_p, :tournament_selection_n, :parsimony, :alpha, :maxdepth, :fast_cycle, :turbo, :migration, :hof_migration, :fraction_replaced_hof, :should_optimize_constants, :warmup_maxsize_by, :use_frequency, :use_frequency_in_tournament, :adaptive_parsimony_scaling, :npop, :ncycles_per_iteration, :fraction_replaced, :topn, :verbosity, :optimizer_algorithm, :optimizer_nrestarts, :optimizer_probability, :optimizer_iterations, :perturbation_factor, :annealing, :return_state, :progress, :timeout_in_seconds, :crossover_probability, :skip_mutation_failures, :max_evals, :early_stop_condition, :seed, :deterministic, :define_helper_functions), Tuple{Array{Function, 1}, Array{Function, 1}, Array{Tuple{Int64, Int64}, 1}, Array{Int64, 1}, Nothing, Int64, Int64, Nothing, typeof(Main.loss), Int64, String, Int64, Bool, Int64, SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights, Float64, Int64, Float64, Float64, Int64, Bool, Bool, Bool, Bool, Float64, Bool, Float64, Bool, Bool, Float64, Int64, Int64, Float64, Int64, Int64, String, Int64, Float64, Int64, Float64, Bool, Bool, Bool, Nothing, Float64, Bool, Nothing, Nothing, PyCall.PyObject, Bool, Bool}}})
precompile(Tuple{typeof(Base.isempty), NamedTuple{(:binary_operators, :unary_operators, :bin_constraints, :una_constraints, :complexity_of_operators, :complexity_of_constants, :complexity_of_variables, :nested_constraints, :loss, :maxsize, :output_file, :npopulations, :batching, :batch_size, :mutation_weights, :tournament_selection_p, :tournament_selection_n, :parsimony, :alpha, :maxdepth, :fast_cycle, :turbo, :migration, :hof_migration, :fraction_replaced_hof, :should_optimize_constants, :warmup_maxsize_by, :use_frequency, :use_frequency_in_tournament, :adaptive_parsimony_scaling, :npop, :ncycles_per_iteration, :fraction_replaced, :topn, :verbosity, :optimizer_algorithm, :optimizer_nrestarts, :optimizer_probability, :optimizer_iterations, :perturbation_factor, :annealing, :return_state, :progress, :timeout_in_seconds, :crossover_probability, :skip_mutation_failures, :max_evals, :early_stop_condition, :seed, :deterministic, :define_helper_functions), Tuple{Array{Function, 1}, Array{Function, 1}, Array{Tuple{Int64, Int64}, 1}, Array{Int64, 1}, Nothing, Int64, Int64, Nothing, typeof(Main.loss), Int64, String, Int64, Bool, Int64, SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights, Float64, Int64, Float64, Float64, Int64, Bool, Bool, Bool, Bool, Float64, Bool, Float64, Bool, Bool, Float64, Int64, Int64, Float64, Int64, Int64, String, Int64, Float64, Int64, Float64, Bool, Bool, Bool, Nothing, Float64, Bool, Nothing, Nothing, PyCall.PyObject, Bool, Bool}}})
precompile(Tuple{typeof(Base.afoldl), Base.var"#49#50", Type, Type, Type, Type, Type, Type, Type, Type, Type, Type, Type})
precompile(Tuple{typeof(Base.convert), Type{Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{Base.var"#invokelatest##kw", NamedTuple{(:binary_operators, :unary_operators, :bin_constraints, :una_constraints, :complexity_of_operators, :complexity_of_constants, :complexity_of_variables, :nested_constraints, :loss, :maxsize, :output_file, :npopulations, :batching, :batch_size, :mutation_weights, :tournament_selection_p, :tournament_selection_n, :parsimony, :alpha, :maxdepth, :fast_cycle, :turbo, :migration, :hof_migration, :fraction_replaced_hof, :should_optimize_constants, :warmup_maxsize_by, :use_frequency, :use_frequency_in_tournament, :adaptive_parsimony_scaling, :npop, :ncycles_per_iteration, :fraction_replaced, :topn, :verbosity, :optimizer_algorithm, :optimizer_nrestarts, :optimizer_probability, :optimizer_iterations, :perturbation_factor, :annealing, :return_state, :progress, :timeout_in_seconds, :crossover_probability, :skip_mutation_failures, :max_evals, :early_stop_condition, :seed, :deterministic, :define_helper_functions), Tuple{Array{Function, 1}, Array{Function, 1}, Array{Tuple{Int64, Int64}, 1}, Array{Int64, 1}, Nothing, Int64, Int64, Nothing, typeof(Main.loss), Int64, String, Int64, Bool, Int64, SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights, Float64, Int64, Float64, Float64, Int64, Bool, Bool, Bool, Bool, Float64, Bool, Float64, Bool, Bool, Float64, Int64, Int64, Float64, Int64, Int64, String, Int64, Float64, Int64, Float64, Bool, Bool, Bool, Nothing, Float64, Bool, Nothing, Nothing, PyCall.PyObject, Bool, Bool}}, typeof(Base.invokelatest), Any})
precompile(Tuple{typeof(Base.convert), Type{Float64}, Float32})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{DataType, 1}}})
precompile(Tuple{typeof(Base.promote), Float64, Float64, Float64, Float64, Vararg{Float64}})
precompile(Tuple{Core.var"#Type##kw", NamedTuple{(:binary_operators, :unary_operators, :bin_constraints, :una_constraints, :complexity_of_operators, :complexity_of_constants, :complexity_of_variables, :nested_constraints, :loss, :maxsize, :output_file, :npopulations, :batching, :batch_size, :mutation_weights, :tournament_selection_p, :tournament_selection_n, :parsimony, :alpha, :maxdepth, :fast_cycle, :turbo, :migration, :hof_migration, :fraction_replaced_hof, :should_optimize_constants, :warmup_maxsize_by, :use_frequency, :use_frequency_in_tournament, :adaptive_parsimony_scaling, :npop, :ncycles_per_iteration, :fraction_replaced, :topn, :verbosity, :optimizer_algorithm, :optimizer_nrestarts, :optimizer_probability, :optimizer_iterations, :perturbation_factor, :annealing, :return_state, :progress, :timeout_in_seconds, :crossover_probability, :skip_mutation_failures, :max_evals, :early_stop_condition, :seed, :deterministic, :define_helper_functions), Tuple{Array{Function, 1}, Array{Function, 1}, Array{Tuple{Int64, Int64}, 1}, Array{Int64, 1}, Nothing, Int64, Int64, Nothing, typeof(Main.loss), Int64, String, Int64, Bool, Int64, SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights, Float64, Int64, Float64, Float64, Int64, Bool, Bool, Bool, Bool, Float64, Bool, Float64, Bool, Bool, Float64, Int64, Int64, Float64, Int64, Int64, String, Int64, Float64, Int64, Float64, Bool, Bool, Bool, Nothing, Float64, Bool, Nothing, Nothing, PyCall.PyObject, Bool, Bool}}, Type{SymbolicRegression.CoreModule.OptionsStructModule.Options{CT} where CT}})
precompile(Tuple{typeof(Base._array_for), Type{Int64}, Array{Function, 1}, Base.HasShape{1}})
precompile(Tuple{Type{NamedTuple{(:binop_complexities, :unaop_complexities, :variable_complexity, :constant_complexity), T} where T<:Tuple}, Tuple{Array{Int64, 1}, Array{Int64, 1}, Int64, Int64}})
precompile(Tuple{typeof(Base.promote_type), Type, Type, Type})
precompile(Tuple{typeof(Base.promote_type), Type, Type, Type, Type})
precompile(Tuple{Core.var"#Type##kw", NamedTuple{(:binop_complexities, :unaop_complexities, :variable_complexity, :constant_complexity), Tuple{Array{Int64, 1}, Array{Int64, 1}, Int64, Int64}}, Type{SymbolicRegression.CoreModule.OptionsStructModule.ComplexityMapping{T} where T<:Real}})
precompile(Tuple{Type{NamedTuple{(:binary_operators, :unary_operators, :enable_autodiff, :define_helper_functions), T} where T<:Tuple}, Tuple{Array{Function, 1}, Array{Function, 1}, Bool, Bool}})
precompile(Tuple{Type{SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}}, DynamicExpressions.OperatorEnumModule.OperatorEnum, Array{Tuple{Int64, Int64}, 1}, Array{Int64, 1}, SymbolicRegression.CoreModule.OptionsStructModule.ComplexityMapping{Int64}, Int64, Float64, Float64, Float64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, String, Int64, Float64, Bool, Bool, Int64, SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights, Float64, Float64, Bool, Bool, Float64, Int64, Int64, Float64, Float64, Int64, Int64, Float32, Int64, Int64, PyCall.PyObject, typeof(Main.loss), Bool, Nothing, String, Float64, Int64, Optim.Options{Float64, Nothing}, Bool, String, Float64, Nothing, Bool, Nothing, Nothing, Bool, Nothing, Bool, Bool})
precompile(Tuple{typeof(PyCall.pyreturn), SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}})
precompile(Tuple{Type{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#11#12"}}}}, Function, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#11#12"}}}})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#11#12"}}}, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{String, DataType}, String})
precompile(Tuple{typeof(PyCall.pyo2ptr), Type})
precompile(Tuple{typeof(Base.convert), Type{Array{Float32, N} where N}, PyCall.PyObject})
precompile(Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, PyCall.var"#9#10"{PyCall.PyBuffer}}})
precompile(Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, PyCall.var"#9#10"{PyCall.PyBuffer}}, Int64})
precompile(Tuple{Type{PyCall.PyArray_Info{Float32, 2}}, Bool, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Ptr{Nothing}, Bool, PyCall.PyBuffer})
precompile(Tuple{Type{PyCall.PyArray{Float32, 2}}, PyCall.PyObject, PyCall.PyArray_Info{Float32, 2}})
precompile(Tuple{typeof(PyCall.pyocopy), PyCall.PyArray{Float32, 2}})
precompile(Tuple{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#11#12"}}}, Array{Float32, 2}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), Array{Float32, 2}})
precompile(Tuple{Type{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#13#14"}}}}, Function, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#13#14"}}}})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#13#14"}}}, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{Type{PyCall.PyArray_Info{Float32, 1}}, Bool, Tuple{Int64}, Tuple{Int64}, Ptr{Nothing}, Bool, PyCall.PyBuffer})
precompile(Tuple{Type{PyCall.PyArray{Float32, 1}}, PyCall.PyObject, PyCall.PyArray_Info{Float32, 1}})
precompile(Tuple{typeof(PyCall.pyocopy), PyCall.PyArray{Float32, 1}})
precompile(Tuple{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#13#14"}}}, Array{Float32, 1}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), Array{Float32, 1}})
precompile(Tuple{Type{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#15#16"}}}}, Function, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#15#16"}}}})
precompile(Tuple{typeof(PyCall._pyjlwrap_call), PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#15#16"}}}, Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{PyCall.FuncWrapper{Tuple{PyCall.PyAny}, PyCall.var"#64#70"{PyCall.var"#64#65#71"{Main.var"#15#16"}}}, Nothing})
precompile(Tuple{typeof(PyCall.pyjlwrap_new), Nothing})
precompile(Tuple{typeof(Base.cconvert), Type{Ptr{PyCall.PyObject_struct}}, Ptr{Nothing}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{PyCall.PyObject_struct}}, Ptr{Nothing}})
precompile(Tuple{typeof(Base.cconvert), Type, Base.RefValue{PyCall.PyMethodDef}})
precompile(Tuple{typeof(Base.convert), Type{Ref{PyCall.PyMethodDef}}, Base.RefValue{PyCall.PyMethodDef}})
precompile(Tuple{typeof(PyCall.weakref_callback), Ptr{PyCall.PyObject_struct}, Ptr{PyCall.PyObject_struct}})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, Array{Float32, 2}})
precompile(Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(getfield), Tuple{Base.Broadcast.Extruded{Array{LinearAlgebra.BLAS.LBTLibraryInfo, 1}, Tuple{Bool}, Tuple{Int64}}, Base.RefValue{Symbol}}}, Type{String}})
precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{String, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(getfield), Tuple{Base.Broadcast.Extruded{Array{LinearAlgebra.BLAS.LBTLibraryInfo, 1}, Tuple{Bool}, Tuple{Int64}}, Base.RefValue{Symbol}}}, Base.OneTo{Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.any), Function, Array{String, 1}})
precompile(Tuple{typeof(Base._any), Base.Fix2{typeof(Base.contains), String}, Array{String, 1}, Base.Colon})
precompile(Tuple{typeof(Base.reverse), Tuple{Int64}})
precompile(Tuple{typeof(Base.convert), Type{PyCall.PyObject}, Array{Float32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{Array{Float32, N} where N, Array{Float32, N} where N}}, PyCall.PyObject})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, PyCall.var"#57#58"{typeof(SymbolicRegression.EquationSearch)}, PyCall.PyDict{Symbol, PyCall.PyObject, true}})
precompile(Tuple{typeof(Base.collect), Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{typeof(SymbolicRegression.EquationSearch)}}})
precompile(Tuple{typeof(Base._array_for), Type{Tuple{Symbol, Nothing}}, Base.HasLength, Int64})
precompile(Tuple{typeof(Base.ndims), Array{Tuple{Symbol, Nothing}, 1}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Tuple{Symbol, Nothing}, 1}, Tuple{Symbol, Nothing}, Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{typeof(SymbolicRegression.EquationSearch)}}, PyCall.PyDict_Iterator})
precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{Tuple{Symbol, Nothing}, 1}, Tuple{Symbol, Int64}, Int64})
precompile(Tuple{typeof(Base.collect_to!), Array{Tuple{Symbol, Any}, 1}, Base.Generator{PyCall.PyDict{Symbol, PyCall.PyObject, true}, PyCall.var"#57#58"{typeof(SymbolicRegression.EquationSearch)}}, Int64, PyCall.PyDict_Iterator})
precompile(Tuple{typeof(Base._similar_for), Array{Any, 1}, Type{String}, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{String, 1}, String, Base.Generator{Array{Any, 1}, typeof(Base.identity)}, Int64})
precompile(Tuple{Type{NamedTuple{(:weights, :niterations, :varMap, :options, :numprocs, :parallelism, :saved_state, :addprocs_function), T} where T<:Tuple}, Tuple{Nothing, Int64, Array{String, 1}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}, Nothing, String, Nothing, Nothing}})
precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, NamedTuple{(:weights, :niterations, :varMap, :options, :numprocs, :parallelism, :saved_state, :addprocs_function), Tuple{Nothing, Int64, Array{String, 1}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}, Nothing, String, Nothing, Nothing}}})
precompile(Tuple{typeof(Base.isempty), NamedTuple{(:weights, :niterations, :varMap, :options, :numprocs, :parallelism, :saved_state, :addprocs_function), Tuple{Nothing, Int64, Array{String, 1}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}, Nothing, String, Nothing, Nothing}}})
precompile(Tuple{typeof(Base.afoldl), Base.var"#49#50", Type, Type, Type, Type, Type})
precompile(Tuple{typeof(Base.convert), Type{Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{Base.var"#invokelatest##kw", NamedTuple{(:weights, :niterations, :varMap, :options, :numprocs, :parallelism, :saved_state, :addprocs_function), Tuple{Nothing, Int64, Array{String, 1}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}, Nothing, String, Nothing, Nothing}}, typeof(Base.invokelatest), Any, Any, Vararg{Any}})
precompile(Tuple{Base.var"##invokelatest#2", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}, NamedTuple{(:weights, :niterations, :varMap, :options, :numprocs, :parallelism, :saved_state, :addprocs_function), Tuple{Nothing, Int64, Array{String, 1}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}, Nothing, String, Nothing, Nothing}}}, typeof(Base.invokelatest), Any, Any, Vararg{Any}})
precompile(Tuple{SymbolicRegression.var"#EquationSearch##kw", NamedTuple{(:weights, :niterations, :varMap, :options, :numprocs, :parallelism, :saved_state, :addprocs_function), Tuple{Nothing, Int64, Array{String, 1}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}, Nothing, String, Nothing, Nothing}}, typeof(SymbolicRegression.EquationSearch), Array{Float32, 2}, Array{Float32, 1}})
precompile(Tuple{Type{NamedTuple{(:weights, :varMap), T} where T<:Tuple}, Tuple{Nothing, Array{String, 1}}})
precompile(Tuple{typeof(Base.convert), Type{Float32}, Float32})
precompile(Tuple{Core.var"#Type##kw", NamedTuple{(:weights, :varMap), Tuple{Nothing, Array{String, 1}}}, Type{SymbolicRegression.CoreModule.DatasetModule.Dataset{T} where T<:Real}, Array{Float32, 2}, Array{Float32, 1}})
precompile(Tuple{typeof(SymbolicRegression.SearchUtilsModule.watch_stream), Base.TTY})
precompile(Tuple{typeof(Base.nameof), Function})
precompile(Tuple{typeof(Base.getindex), String, Int64})
precompile(Tuple{typeof(Base.convert), Type{Float32}, Float64})
precompile(Tuple{typeof(Base.getindex), Array{Float32, 1}, Int64})
precompile(Tuple{typeof(Base.iterate), Array{Function, 1}})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), Function, Float32, Float32})
precompile(Tuple{typeof(Base.iterate), Array{Function, 1}, Int64})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), Function, Float32})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.sin), Tuple{Float32}})
precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.sin), Tuple{Float32}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Main.inv), Tuple{Float32}})
precompile(Tuple{typeof(Base.promote_result), Type, Type, Type{Union{}}, Type{Float32}})
precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Main.inv), Tuple{Float32}}})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Function, Nothing}, Nothing, typeof(Base.sin)})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Function, Nothing}, Nothing, typeof(Main.inv)})
precompile(Tuple{typeof(Base.length), Array{Function, 1}})
precompile(Tuple{typeof(Base.size), Array{Float32, 2}, Int64})
precompile(Tuple{typeof(SymbolicRegression.LossFunctionsModule._loss), Array{Float32, 1}, Array{Float32, 1}, Function})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), Function, Array{Float32, 1}, Array{Float32, 1}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Main.loss), Tuple{Array{Float32, 1}, Array{Float32, 1}}})
precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Main.loss), Tuple{Array{Float32, 1}, Array{Float32, 1}}}})
precompile(Tuple{typeof(Base.sum), Array{Float32, 1}})
precompile(Tuple{typeof(Base.getindex), Type{Task}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.eval_tree_array), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}})
precompile(Tuple{HostCPUFeatures.var"##s28#5", Any, Any, Any})
precompile(Tuple{typeof(Static.is_static), Type{var"#s5"} where var"#s5"<:(Union{Static.StaticBool{T}, Static.StaticFloat64{T}, Static.StaticInt{T}, Static.StaticSymbol{T}} where T)})
precompile(Tuple{typeof(Base.ifelse), Static.True, Any, Any})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Int8, Int8, Int8, Bool, UInt64, Int64, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Int8, Int8, Int8, Bool, UInt64, Int64, Bool}, Int64, Int64})
precompile(Tuple{typeof(Base.min), UInt64, UInt64})
precompile(Tuple{typeof(Base.isvarargtype), Any})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, Float32, typeof(Base.:(*))}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, Float32, typeof(Base.:(*))}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Ptr{Float32}}}})
precompile(Tuple{LoopVectorization.var"##s195#85", Any, Any, Any, Any, Any, Any, Any, Any, Any, Type, Type, Type, Type, Type, Any, Any})
precompile(Tuple{typeof(Base._array_for), Type{LoopVectorization.Instruction}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Array{LoopVectorization.Instruction, 1}})
precompile(Tuple{typeof(Base.setindex!), Array{LoopVectorization.Instruction, 1}, LoopVectorization.Instruction, Int64})
precompile(Tuple{typeof(Base._array_for), Type{LoopVectorization.OperationStruct}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Array{LoopVectorization.OperationStruct, 1}})
precompile(Tuple{typeof(Base.setindex!), Array{LoopVectorization.OperationStruct, 1}, LoopVectorization.OperationStruct, Int64})
precompile(Tuple{Type{Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}}, UndefInitializer, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, LoopVectorization.ArrayRefStruct{:cumulator, Symbol("##vptr##_cumulator")}, Int64})
precompile(Tuple{typeof(Base.eachindex), Array{Any, 1}})
precompile(Tuple{typeof(LoopVectorization.create_mrefs!), LoopVectorization.LoopSet, Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{Int64, 1}, Array{Bool, 1}, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}}})
precompile(Tuple{typeof(LoopVectorization.array_and_ptr), LoopVectorization.ArrayRefStruct{:cumulator, Symbol("##vptr##_cumulator")}})
precompile(Tuple{typeof(LoopVectorization.add_mref!), Expr, LoopVectorization.LoopSet, LoopVectorization.ArrayReferenceMeta, Type{Ptr{Float32}}, Int64, Int64, Array{Int64, 1}, Symbol})
precompile(Tuple{typeof(Base.:(>)), UInt64, Int64})
precompile(Tuple{typeof(Base.push!), Array{Any, 1}, Expr, Static.StaticInt{16}})
precompile(Tuple{typeof(Base.push!), Array{Any, 1}, Expr, Expr, Expr, Static.StaticInt{16}})
precompile(Tuple{typeof(LoopVectorization.mulexpr), Symbol, Static.StaticInt{4}})
precompile(Tuple{Type{Static.StaticInt{2}}})
precompile(Tuple{Type{Static.StaticInt{3}}})
precompile(Tuple{typeof(LoopVectorization.mulexpr), Symbol, Static.StaticInt{3}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, Float32, typeof(Base.:(*))}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, Float32, typeof(Base.:(*))}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}}})
precompile(Tuple{VectorizationBase.var"##s38#325", Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any})
precompile(Tuple{VectorizationBase.var"##s38#326", Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type, Type, Any})
precompile(Tuple{typeof(VectorizationBase.should_transpose_memop), Int64, Int64, Int64, Int64, Int64, UInt64})
precompile(Tuple{typeof(VectorizationBase.shuffle_load_quote), Type{Float32}, Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64}, Type{VectorizationBase.LazyMulAdd{4, 0, Int64}}, Bool, Int64, UInt64})
precompile(Tuple{VectorizationBase.var"##s38#231", Any, Any, Any, Any, Any, Any, Any, Any, Any})
precompile(Tuple{typeof(VectorizationBase.gep_quote), Type{Float32}, Symbol, Type{Int64}, Int64, Int64, Int64, Int64, Int64})
precompile(Tuple{typeof(Base.isone), Int64})
precompile(Tuple{typeof(Base.convert), Type{Static.StaticInt{0}}, Union{Static.StaticBool{N}, Static.StaticFloat64{N}, Static.StaticInt{N}} where N})
precompile(Tuple{typeof(Base.convert), Type{Static.StaticInt{4}}, Union{Static.StaticBool{N}, Static.StaticFloat64{N}, Static.StaticInt{N}} where N})
precompile(Tuple{typeof(Base.convert), Type{Static.StaticInt{8}}, Union{Static.StaticBool{N}, Static.StaticFloat64{N}, Static.StaticInt{N}} where N})
precompile(Tuple{typeof(Base.convert), Type{Static.StaticInt{12}}, Union{Static.StaticBool{N}, Static.StaticFloat64{N}, Static.StaticInt{N}} where N})
precompile(Tuple{VectorizationBase.var"##s1#45", Any, Any, Any, Any})
precompile(Tuple{typeof(VectorizationBase.assume), Bool})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Ptr{Float32}, Ptr{Float32}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Static.StaticInt{4}, Int64}}})
precompile(Tuple{typeof(Base.setindex!), Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, LoopVectorization.ArrayRefStruct{:cX, Symbol("##vptr##_cX_##subset##_1_##with##_feature_##")}, Int64})
precompile(Tuple{typeof(LoopVectorization.create_mrefs!), LoopVectorization.LoopSet, Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{Int64, 1}, Array{Bool, 1}, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}}})
precompile(Tuple{typeof(LoopVectorization.array_and_ptr), LoopVectorization.ArrayRefStruct{:cX, Symbol("##vptr##_cX_##subset##_1_##with##_feature_##")}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Static.StaticInt{4}, Int64}}})
precompile(Tuple{LayoutPointers.var"##s30#13", Any, Any, Any, Any, Any, Any, Any, Any, Any, Any})
precompile(Tuple{typeof(Base.eachindex), Tuple{Tuple{Int64}, Tuple{Int64}}})
precompile(Tuple{VectorizationBase.var"##s30#59", Any, Any, Any, Any})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg2_r0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 1}, Array{Float32, 2}, typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}})
precompile(Tuple{typeof(Base.setindex!), Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, LoopVectorization.ArrayRefStruct{:cumulator_l, Symbol("##vptr##_cumulator_l")}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, LoopVectorization.ArrayRefStruct{:cumulator_r, Symbol("##vptr##_cumulator_r")}, Int64})
precompile(Tuple{typeof(LoopVectorization.create_mrefs!), LoopVectorization.LoopSet, Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{Int64, 1}, Array{Bool, 1}, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}}})
precompile(Tuple{typeof(LoopVectorization.array_and_ptr), LoopVectorization.ArrayRefStruct{:cumulator_l, Symbol("##vptr##_cumulator_l")}})
precompile(Tuple{typeof(LoopVectorization.array_and_ptr), LoopVectorization.ArrayRefStruct{:cumulator_r, Symbol("##vptr##_cumulator_r")}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg2_eval), Array{Float32, 1}, Array{Float32, 1}, typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, Float32, typeof(Base.:(+))}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, Float32, typeof(Base.:(+))}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, Float32, typeof(Base.:(+))}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, Float32, typeof(Base.:(+))}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+))}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+))}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Int64, Static.StaticInt{4}}}})
precompile(Tuple{typeof(LoopVectorization.create_mrefs!), LoopVectorization.LoopSet, Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{Int64, 1}, Array{Bool, 1}, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+))}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+))}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Int64, Static.StaticInt{4}}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg2_l0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 1}, Array{Float32, 2}, typeof(Base.:(+)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+))}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+))}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+))}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (1, -1), (0, 0), ((1,), (2,)), ((1,), (2,)), Tuple{Static.StaticInt{4}, Int64}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+))}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg2_r0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 1}, Array{Float32, 2}, typeof(Base.:(+)), Base.Val{true}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_eval_constant), DynamicExpressions.EquationModule.Node{Float32}, typeof(Main.inv), DynamicExpressions.OperatorEnumModule.OperatorEnum})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*))}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg2_l0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 1}, Array{Float32, 2}, typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Base.exp)}}})
precompile(Tuple{typeof(Base.setindex!), Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, LoopVectorization.ArrayRefStruct{:cX, Symbol("##vptr##_cX_##subset##_1_##with##_feature_lr_##")}, Int64})
precompile(Tuple{typeof(LoopVectorization.array_and_ptr), LoopVectorization.ArrayRefStruct{:cX, Symbol("##vptr##_cX_##subset##_1_##with##_feature_lr_##")}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Base.exp)}}})
precompile(Tuple{typeof(Base.setindex!), Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, LoopVectorization.ArrayRefStruct{:cX, Symbol("##vptr##_cX_##subset##_1_##with##_feature_ll_##")}, Int64})
precompile(Tuple{typeof(LoopVectorization.array_and_ptr), LoopVectorization.ArrayRefStruct{:cX, Symbol("##vptr##_cX_##subset##_1_##with##_feature_ll_##")}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Base.exp)}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Int64, Int64, Static.StaticInt{4}}}})
precompile(Tuple{typeof(LoopVectorization.create_mrefs!), LoopVectorization.LoopSet, Array{LoopVectorization.ArrayRefStruct{array, ptr} where ptr where array, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{Int64, 1}, Array{Bool, 1}, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Base.exp)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Int64, Int64, Static.StaticInt{4}}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.exp), typeof(Base.:(+)), Base.Val{true}})
precompile(Tuple{typeof(Base.div), Int64, Int64, Base.Rounding.RoundingMode{:ToZero}})
precompile(Tuple{typeof(Base.promote_result), Type, Type, Type{Union{}}, Type{VectorizationBase.Vec{2, Int64}}})
precompile(Tuple{VectorizationBase.var"##s38#268", Any, Any, Any, Any, Type, Any, Any})
precompile(Tuple{VectorizationBase.var"##s3#3", Any, Any, Any, Any})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}}, (1,), (0,), ((1,),), ((1,),), Tuple{Static.StaticInt{4}}, Tuple{Static.StaticInt{0}}}, typeof(Main.inv)}}})
precompile(Tuple{Type{VectorizationBase.MM{W, X, I} where I<:Union{Float32, Float64, Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N} where X where W}, Static.StaticInt{4}, Int64, Static.StaticInt{1}})
precompile(Tuple{VectorizationBase.var"##s38#238", Any, Any, Any, Any, Any, Any, Any, Type, Any})
precompile(Tuple{typeof(VectorizationBase.index_summary), Type{VectorizationBase.MM{4, 4, Int64}}})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{DataType, Symbol, Int64, Int64, Int64, Int64}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{DataType, Symbol, Int64, Int64, Int64, Int64}, Int64, Int64})
precompile(Tuple{typeof(VectorizationBase.vload_quote), Type{Float32}, Type{Int64}, Symbol, Int64, Int64, Int64, Int64, Bool, Bool, Int64})
precompile(Tuple{typeof(Base.Iterators.only), Tuple{VectorizationBase.MM{4, 1, Int64}}})
precompile(Tuple{typeof(VectorizationBase.vsub_nsw), VectorizationBase.MM{4, 1, Int64}, Static.StaticInt{0}})
precompile(Tuple{typeof(Base.first), Tuple{VectorizationBase.MM{4, 1, Int64}}})
precompile(Tuple{typeof(VectorizationBase.data), VectorizationBase.MM{4, 1, Int64}})
precompile(Tuple{typeof(Base.promote_result), Type, Type, Type{Union{}}, Type{VectorizationBase.Vec{4, Float32}}})
precompile(Tuple{VectorizationBase.var"##s38#245", Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type, Type, Type, Any})
precompile(Tuple{typeof(VectorizationBase.vstore_quote), Type{Float32}, Type{Int64}, Symbol, Int64, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Int64})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_eval), Array{Float32, 1}, typeof(Main.inv), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.cos), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.cos), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.cos), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.cos), typeof(Main.inv)}}})
precompile(Tuple{VectorizationBase.var"##s38#94", Any, Any, Any, Any, Any, Any, Type, Any, Type, Type, Any})
precompile(Tuple{typeof(VectorizationBase.vtype), Int64, String})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, VectorizationBase.var"#95#96"{Int64, Int64, String}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.join), Base.Generator{Base.UnitRange{Int64}, VectorizationBase.var"#95#96"{Int64, Int64, String}}, String})
precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Generator{Base.UnitRange{Int64}, VectorizationBase.var"#95#96"{Int64, Int64, String}}, String})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Main.inv), typeof(Base.cos), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.exp), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.exp), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.exp), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.exp), typeof(Main.inv)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Main.inv), typeof(Base.exp), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Main.inv)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Main.inv), typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Main.inv)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Main.inv), typeof(Main.inv), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.exp)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.exp)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.exp), typeof(Main.inv), Base.Val{true}})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Function})
precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Function})
precompile(Tuple{typeof(Base.sizeof), SymbolicRegression.CoreModule.OptionsStructModule.MutationWeights})
precompile(Tuple{typeof(Base.push!), Array{Task, 1}, Task})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.exp)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.exp)}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.exp)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.exp)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.exp)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.exp), typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.exp), typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.sin), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.sin), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.sin), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.sin), typeof(Main.inv)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Main.inv), typeof(Base.sin), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.sin)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.sin)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.sin)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.sin)}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.sin)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.sin)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.sin)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.sin)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.sin), typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.sin), typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.cos)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(*)), typeof(Base.cos)}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.cos)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(*)), typeof(Base.cos)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.cos), typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Main.inv)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Main.inv)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Main.inv)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Main.inv), typeof(Base.:(+)), Base.Val{true}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.cos), typeof(Base.:(*)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.cos)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.cos)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.cos), typeof(Main.inv), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.sin)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.sin)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.sin)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Main.inv), typeof(Base.sin)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.sin), typeof(Main.inv), Base.Val{true}})
precompile(Tuple{typeof(Base.isready), Base.Channel{Any}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Main.inv), typeof(Base.:(+)), Base.Val{true}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Base.cos)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}}, (-1, 1), (0, 0), ((2,), (1,)), ((1,), (2,)), Tuple{Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}}}, Float32, typeof(Base.:(+)), typeof(Base.cos)}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization._append_fields!), Expr, Expr, Symbol, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Base.cos)}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{Tuple{CloseOpenIntervals.CloseOpen{Static.StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Base.cos)}}}})
precompile(Tuple{typeof(LoopVectorization.rebuild_fields), Int64, Type{Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float32}, Ptr{Float32}, Ptr{Float32}}, (-1, -1, 1), (0, 0, 0), ((2,), (2,), (1,)), ((1,), (2,), (3,)), Tuple{Int64, Int64, Static.StaticInt{4}}, Tuple{Static.StaticInt{0}, Static.StaticInt{0}, Static.StaticInt{0}}}, typeof(Base.:(+)), typeof(Base.cos)}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.cos), typeof(Base.:(+)), Base.Val{true}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.sin), typeof(Main.inv), Base.Val{true}})
precompile(Tuple{Type{Base.Val{0.86f}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l1_ll0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.cos), typeof(Main.inv), Base.Val{true}})
precompile(Tuple{Type{Base.Val{0.86f}}})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.cos), typeof(Base.:(+)), Base.Val{true}})
precompile(Tuple{Type{Base.Val{0.86f}}})
precompile(Tuple{typeof(Base.collect), Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), Function, Float32, Array{Int64, 1}})
precompile(Tuple{typeof(SymbolicRegression.PopulationModule.sample_tournament), Base.Val{0.86f}, Base.Val{10}})
precompile(Tuple{typeof(SymbolicRegression.PopulationModule.sample_tournament), Base.Val{0.86f}, Base.Val{10}})
precompile(Tuple{typeof(SymbolicRegression.PopulationModule.sample_tournament), Base.Val{0.86f}, Base.Val{10}})
precompile(Tuple{typeof(SymbolicRegression.PopulationModule.sample_tournament), Base.Val{0.86f}, Base.Val{10}})
precompile(Tuple{Type{Base.Val{0.86f}}})
precompile(Tuple{typeof(SymbolicRegression.PopulationModule.sample_tournament), Base.Val{0.86f}, Base.Val{10}})
precompile(Tuple{typeof(SymbolicRegression.PopulationModule.sample_tournament), Base.Val{0.86f}, Base.Val{10}})
precompile(Tuple{typeof(DynamicExpressions.UtilsModule.isbad), Float32})
precompile(Tuple{typeof(DynamicExpressions.EvaluateEquationModule.deg1_l2_ll0_lr0_eval), DynamicExpressions.EquationModule.Node{Float32}, Array{Float32, 2}, typeof(Base.cos), typeof(Base.:(+)), Base.Val{true}})
precompile(Tuple{Type{NamedTuple{(:val,), T} where T<:Tuple}, Tuple{Float32}})
precompile(Tuple{Type{NamedTuple{(:val,), T} where T<:Tuple}, Tuple{Float32}})
precompile(Tuple{Type{NamedTuple{(:val,), T} where T<:Tuple}, Tuple{Float32}})
precompile(Tuple{typeof(Base.getindex), Array{Function, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Function, 1}, Int64})
precompile(Tuple{typeof(Main.inv), Float32})
precompile(Tuple{typeof(Main.inv), Float32})
precompile(Tuple{typeof(Main.inv), Float32})
precompile(Tuple{typeof(Base.:(==)), Function, Function})
precompile(Tuple{typeof(Base.:(==)), Function, Function})
precompile(Tuple{typeof(Base.:(==)), Function, Function})
precompile(Tuple{typeof(Base.:(==)), Function, Function})
precompile(Tuple{typeof(Base.:(==)), Function, Function})
precompile(Tuple{typeof(Base.:(==)), Function, Function})
precompile(Tuple{typeof(Base.convert), Type{Union{Nothing, Float32}}, Float32})
precompile(Tuple{typeof(SymbolicRegression.SearchUtilsModule.check_for_user_quit), SymbolicRegression.SearchUtilsModule.StdinReader{Base.TTY}})
precompile(Tuple{typeof(Base.setindex!), Array{Float64, 1}, Float64, Int64})
precompile(Tuple{typeof(Base.:(<)), Float32, Float32})
precompile(Tuple{Type{Pair{A, B} where B where A}, Array{SymbolicRegression.PopMemberModule.PopMember{Float32}, 1}, SymbolicRegression.PopulationModule.Population{Float32}})
precompile(Tuple{typeof(Base.setindex!), Array{Task, 1}, Task, Int64})
precompile(Tuple{Type{NamedTuple{(:verbosity, :options, :record), T} where T<:Tuple}, Tuple{Int64, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}, Base.Dict{String, Any}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.:(*)), Tuple{Float32, Base.Complex{Bool}}}}, Function, Tuple{Float32, Base.Complex{Bool}}, Nothing})
precompile(Tuple{ForwardDiff.var"##s24#79", Any, Any, Any, Any})
precompile(Tuple{ForwardDiff.var"##s24#87", Any, Any, Any, Any})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, ForwardDiff.var"#88#89", Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.collect), Base.Generator{Base.UnitRange{Int64}, ForwardDiff.var"#88#89"}})
precompile(Tuple{ForwardDiff.var"##s1#11", Any, Any, Any, Any, Type, Any})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, ForwardDiff.var"#12#13"{Int64}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.collect), Base.Generator{Base.UnitRange{Int64}, ForwardDiff.var"#12#13"{Int64}}})
precompile(Tuple{Type{ForwardDiff.Partials{N, V} where V where N}, Tuple{Float32, Float32, Float32, Float32}})
precompile(Tuple{NLSolversBase.var"##OnceDifferentiable#11", Bool, Symbol, ForwardDiff.Chunk{4}, Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, Function, Array{Float32, 1}, Float32, Array{Float32, 1}})
precompile(Tuple{NLSolversBase.var"##OnceDifferentiable#11", Bool, Symbol, ForwardDiff.Chunk{4}, Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, Function, Array{Float32, 1}, Float32, Array{Float32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{ForwardDiff.Partials{4, Float32}, ForwardDiff.Partials{4, Float32}, ForwardDiff.Partials{4, Float32}, ForwardDiff.Partials{4, Float32}}}, Tuple{ForwardDiff.Partials{4, Float32}, ForwardDiff.Partials{4, Float32}, ForwardDiff.Partials{4, Float32}, ForwardDiff.Partials{4, Float32}}})
precompile(Tuple{Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, SymbolicRegression.ConstantOptimizationModule.var"#f#1"{Float32, SymbolicRegression.CoreModule.DatasetModule.Dataset{Float32}, SymbolicRegression.PopMemberModule.PopMember{Float32}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}}, Array{Float32, 1}, Float32, Array{Float32, 1}, Symbol, ForwardDiff.Chunk{4}})
precompile(Tuple{NLSolversBase.var"##OnceDifferentiable#11", Bool, Symbol, ForwardDiff.Chunk{4}, Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, Function, Array{Float32, 1}, Float32, Array{Float32, 1}})
precompile(Tuple{Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, SymbolicRegression.ConstantOptimizationModule.var"#f#1"{Float32, SymbolicRegression.CoreModule.DatasetModule.Dataset{Float32}, SymbolicRegression.PopMemberModule.PopMember{Float32}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}}, Array{Float32, 1}, Float32, Array{Float32, 1}, Symbol, ForwardDiff.Chunk{4}})
precompile(Tuple{Type{NamedTuple{(:verbosity, :options, :record), T} where T<:Tuple}, Tuple{Int64, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}, Base.Dict{String, Any}}})
precompile(Tuple{Type{ForwardDiff.Partials{N, V} where V where N}, Tuple{Float32, Float32, Float32, Float32, Float32}})
precompile(Tuple{NLSolversBase.var"##OnceDifferentiable#11", Bool, Symbol, ForwardDiff.Chunk{5}, Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, Function, Array{Float32, 1}, Float32, Array{Float32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{ForwardDiff.Partials{5, Float32}, ForwardDiff.Partials{5, Float32}, ForwardDiff.Partials{5, Float32}, ForwardDiff.Partials{5, Float32}, ForwardDiff.Partials{5, Float32}}}, Tuple{ForwardDiff.Partials{5, Float32}, ForwardDiff.Partials{5, Float32}, ForwardDiff.Partials{5, Float32}, ForwardDiff.Partials{5, Float32}, ForwardDiff.Partials{5, Float32}}})
precompile(Tuple{Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, SymbolicRegression.ConstantOptimizationModule.var"#f#1"{Float32, SymbolicRegression.CoreModule.DatasetModule.Dataset{Float32}, SymbolicRegression.PopMemberModule.PopMember{Float32}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}}, Array{Float32, 1}, Float32, Array{Float32, 1}, Symbol, ForwardDiff.Chunk{5}})
precompile(Tuple{Type{LineSearches.LineSearchException{T} where T<:Real}, String, Float64})
precompile(Tuple{Type{ForwardDiff.Partials{N, V} where V where N}, Tuple{Float32, Float32, Float32, Float32, Float32, Float32}})
precompile(Tuple{NLSolversBase.var"##OnceDifferentiable#11", Bool, Symbol, ForwardDiff.Chunk{6}, Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, Function, Array{Float32, 1}, Float32, Array{Float32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}}}, Tuple{ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}, ForwardDiff.Partials{6, Float32}}})
precompile(Tuple{Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, SymbolicRegression.ConstantOptimizationModule.var"#f#1"{Float32, SymbolicRegression.CoreModule.DatasetModule.Dataset{Float32}, SymbolicRegression.PopMemberModule.PopMember{Float32}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}}, Array{Float32, 1}, Float32, Array{Float32, 1}, Symbol, ForwardDiff.Chunk{6}})
precompile(Tuple{Type{ForwardDiff.Partials{N, V} where V where N}, Tuple{Float32, Float32, Float32, Float32, Float32, Float32, Float32}})
precompile(Tuple{NLSolversBase.var"##OnceDifferentiable#11", Bool, Symbol, ForwardDiff.Chunk{7}, Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, Function, Array{Float32, 1}, Float32, Array{Float32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}}}, Tuple{ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}, ForwardDiff.Partials{7, Float32}}})
precompile(Tuple{Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, SymbolicRegression.ConstantOptimizationModule.var"#f#1"{Float32, SymbolicRegression.CoreModule.DatasetModule.Dataset{Float32}, SymbolicRegression.PopMemberModule.PopMember{Float32}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}}, Array{Float32, 1}, Float32, Array{Float32, 1}, Symbol, ForwardDiff.Chunk{7}})
precompile(Tuple{Type{ForwardDiff.Partials{N, V} where V where N}, Tuple{Float32, Float32, Float32, Float32, Float32, Float32, Float32, Float32}})
precompile(Tuple{NLSolversBase.var"##OnceDifferentiable#11", Bool, Symbol, ForwardDiff.Chunk{8}, Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, Function, Array{Float32, 1}, Float32, Array{Float32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}}}, Tuple{ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}, ForwardDiff.Partials{8, Float32}}})
precompile(Tuple{Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, SymbolicRegression.ConstantOptimizationModule.var"#f#1"{Float32, SymbolicRegression.CoreModule.DatasetModule.Dataset{Float32}, SymbolicRegression.PopMemberModule.PopMember{Float32}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}}, Array{Float32, 1}, Float32, Array{Float32, 1}, Symbol, ForwardDiff.Chunk{8}})
precompile(Tuple{Type{ForwardDiff.Partials{N, V} where V where N}, Tuple{Float32, Float32, Float32, Float32, Float32, Float32, Float32, Float32, Float32}})
precompile(Tuple{typeof(ForwardDiff.construct_seeds), Type{ForwardDiff.Partials{9, Float32}}})
precompile(Tuple{NLSolversBase.var"##OnceDifferentiable#11", Bool, Symbol, ForwardDiff.Chunk{9}, Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, Function, Array{Float32, 1}, Float32, Array{Float32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Tuple{ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}}}, Tuple{ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}, ForwardDiff.Partials{9, Float32}}})
precompile(Tuple{Type{NLSolversBase.OnceDifferentiable{TF, TDF, TX} where TX where TDF where TF}, SymbolicRegression.ConstantOptimizationModule.var"#f#1"{Float32, SymbolicRegression.CoreModule.DatasetModule.Dataset{Float32}, SymbolicRegression.PopMemberModule.PopMember{Float32}, SymbolicRegression.CoreModule.OptionsStructModule.Options{Int64}}, Array{Float32, 1}, Float32, Array{Float32, 1}, Symbol, ForwardDiff.Chunk{9}})
precompile(Tuple{typeof(SymbolicRegression.SearchUtilsModule.close_reader!), SymbolicRegression.SearchUtilsModule.StdinReader{Base.TTY}})
precompile(Tuple{typeof(PyCall.pyreturn), Tuple{Array{Array{SymbolicRegression.PopulationModule.Population{Float32}, 1}, 1}, SymbolicRegression.HallOfFameModule.HallOfFame{Float32}}})
precompile(Tuple{typeof(PyCall._set_finalized)})

MilesCranmer · 2022-11-29T16:40:45Z

Looks like most of the calls are PyCall.jl - I guess it needs better precompilation. Some of the LoopVectorization.jl and DynamicExpressions.jl are minor but I should be able to hit them with a modified precompilation in SymbolicRegression.jl

mkitti · 2022-11-29T17:04:46Z

We're currently running with compiled-modules=no. That's a problem. We are not caching code that we could be caching.

MilesCranmer · 2022-11-29T17:07:00Z

That's only for conda installs, though. The paste I sent above is with compiled_modules=True.

mkitti · 2022-11-29T17:25:49Z

When building the system image, you could also exercise PyCall

MilesCranmer · 2022-11-29T19:40:30Z

Do you mean call PySRRegressor().fit() on some example data, before saving the sysimage? Maybe I'm doing something wrong but it didn't seem to help much, for whatever reason. I wonder if much of PyCall.jl is unable to be cached, since it can't tell if the Python function calling it is the same or not?

mkitti · 2022-11-29T23:29:22Z

Part of the initial latency might simply be resolving pointers to symbols within libpython. That unfortunately cannot be cached.

MilesCranmer · 2022-11-30T16:23:10Z

Thanks for the note, that makes sense to me. I guess that few seconds isn't a major deal anyways.

Btw, I made a PR to PyCall.jl here: JuliaPy/PyCall.jl#1015 which addresses some of the missed precompiles. I think it would be better to use SnoopCompile.jl, but it seems to not play well with Python. So I think manual precompile is good enough for now.

MilesCranmer · 2023-02-22T20:19:27Z

I think this would be good to try merging under the heading that this is very experimental feature, and is only available opt-in. I'd personally be interested in using it, and I probably know of some others. One other idea would also be to hash the Manifest.toml file in the env, and throw an error loading the sys image if the hash does not match.

MilesCranmer · 2023-02-22T20:24:38Z

pysr/package_compiler.py

+    sysimage_path = str(Path(cur_project_dir) / sysimage_name)
+    from julia import PackageCompiler
+
+    Main.eval("using SymbolicRegression")


Could add a call here:

from . import PySRRegressor PySRRegressor(verbosity=0, progress=False, temp_equation_file=True).fit([[1]], [1])

just so that the PyCall interface specific to PySR gets compiled too.

mkitti · 2023-02-22T21:08:05Z

We probably should see if we can fix the issue in PyCall... this is going to be a real problem when Julia 1.9 lands.

MilesCranmer · 2023-02-22T21:12:52Z

Do you mean the static libpython issue?

mkitti · 2023-02-22T21:26:03Z

I mean the compiled_modules=False thing

MilesCranmer · 2023-02-22T23:55:26Z

What is the main thread for that again? I see there is JuliaPy/PyCall.jl#945 and JuliaPy/pyjulia#496

MilesCranmer · 2023-02-23T20:32:06Z

Also, do you mean it is a problem for speed? Or would it e.g., cause crashes on Julia 1.9?

MilesCranmer · 2023-02-27T01:34:06Z

I'm going to close this for now. It just doesn't get much of a performance improvement, because the precompilation is already good enough, especially on the latest Julia versions. The increased dev complexity wouldn't justify a ~3% improvement in startup time.

MilesCranmer mentioned this pull request Nov 29, 2022

Expand precompilation JuliaPy/PyCall.jl#1015

Merged

MilesCranmer commented Feb 22, 2023

View reviewed changes

MilesCranmer and others added 18 commits February 23, 2023 15:41

Add PackageCompiler.jl to PySR project

0fddf6f

Add function to create simple sysimage

c865ccb

Add create_sysimage to __init__

bc50655

Put pysr.so into correct directory

9124934

Add option to create sysimage to install()

f7a8f6c

Clean up sysimage creation

0e57673

Move installation utilities to compilation module

494d282

Separate install and compile steps

8616793

Working precompilation

b2d5380

Only try loading sysimage if Julia uninitialized

65f77f7

Clean up sysimage check

2e22926

Ensure that we compile an optimized image

a3be3c1

Format code with black

f8c0522

Improve time to check project dir

3cb46f0

Ensure that compiling twice works

b438421

Allow forced init without sysimage

ded8eb0

Fix re-install

6dbda5c

Compile all packages into sysimage

f183a23

MilesCranmer force-pushed the package-compiler branch from 3b47cd8 to f183a23 Compare February 23, 2023 20:53

Format code with black

b348287

MilesCranmer closed this Feb 27, 2023

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Package compiler #230

Package compiler #230

MilesCranmer commented Nov 22, 2022

mkitti commented Nov 22, 2022

MilesCranmer commented Nov 23, 2022

mkitti commented Nov 23, 2022 •

edited

Loading

MilesCranmer commented Nov 23, 2022

mkitti commented Nov 23, 2022

MilesCranmer commented Nov 23, 2022

MilesCranmer commented Nov 28, 2022 •

edited

Loading

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022 •

edited

Loading

MilesCranmer commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022 •

edited

Loading

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 30, 2022

MilesCranmer commented Feb 22, 2023

MilesCranmer Feb 22, 2023

mkitti commented Feb 22, 2023

MilesCranmer commented Feb 22, 2023 •

edited

Loading

mkitti commented Feb 22, 2023

MilesCranmer commented Feb 22, 2023

MilesCranmer commented Feb 23, 2023

MilesCranmer commented Feb 27, 2023 •

edited

Loading

Package compiler #230

Package compiler #230

Conversation

MilesCranmer commented Nov 22, 2022

mkitti commented Nov 22, 2022

MilesCranmer commented Nov 23, 2022

mkitti commented Nov 23, 2022 • edited Loading

MilesCranmer commented Nov 23, 2022

mkitti commented Nov 23, 2022

MilesCranmer commented Nov 23, 2022

MilesCranmer commented Nov 28, 2022 • edited Loading

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022 • edited Loading

MilesCranmer commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022 • edited Loading

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 29, 2022

mkitti commented Nov 29, 2022

MilesCranmer commented Nov 30, 2022

MilesCranmer commented Feb 22, 2023

MilesCranmer Feb 22, 2023

Choose a reason for hiding this comment

mkitti commented Feb 22, 2023

MilesCranmer commented Feb 22, 2023 • edited Loading

mkitti commented Feb 22, 2023

MilesCranmer commented Feb 22, 2023

MilesCranmer commented Feb 23, 2023

MilesCranmer commented Feb 27, 2023 • edited Loading

mkitti commented Nov 23, 2022 •

edited

Loading

MilesCranmer commented Nov 28, 2022 •

edited

Loading

MilesCranmer commented Nov 29, 2022 •

edited

Loading

MilesCranmer commented Nov 29, 2022 •

edited

Loading

MilesCranmer commented Feb 22, 2023 •

edited

Loading

MilesCranmer commented Feb 27, 2023 •

edited

Loading