Trial at skipping read-only packages (packages in .julia/packages) #457

IanButterworth · 2020-04-17T01:16:07Z

I'm sure there's a better implementation of this, but I was intrigued about how it would affect my experience, related to #456

timholy · 2020-04-17T10:47:08Z

In a sense, Revise already skips read-only packages, see

Revise.jl/src/pkgs.jl

Lines 407 to 409 in 99c2955

 if has_writable_paths(pkgdata) 

 init_watching(pkgdata, files) 

 end

just a little bit below the line where you added this. However, it first determines which files constitute the package, i.e., it populates the pkgdata structure.

My suspicion is that this will break the ability to switch between add and dev for a package. The fact that the A2D tests pass here is either encouraging or dismaying, depending on whether the tests are just failing to catch a problem. In my local test I fall on the side of "dismay":

dev Revise and make this change
add Example
dev Example. Make a change to dev/Example/src/Example.jl like adding f() = π
free Example so that you start out with the released version of the package
start a fresh session if necessary and load Revise
using Example. Verify that Example.f() throws a MethodError, since you're using the released version of the Example package
dev Example in the same session
Example.f() still throws a MethodError, which is bad

If instead you use the released version of Revise, you can toggle between free and dev all day and it works properly (https://timholy.github.io/Revise.jl/stable/#Other-key-features-of-Revise-1).

So clearly 3000 lines of tests still aren't enough 😢.

Can you give me some details about your system? I'd love to be able to replicate the big hit you get from Revise, so that I can poke at this a bit more.

IanButterworth · 2020-04-17T12:23:08Z

Very interesting. My system is MacOS Catalina, Julia 1.4.0 (I can try 1.4.1 now it’s released).

Those tests were done in fresh instances, with only the startup.jl revise loader script (or without).

It seems to me that the precomp isn’t effectively successful on my system. I did check that the precompile statements were being run with a print.

timholy · 2020-04-17T13:13:34Z

It seems to me that the precomp isn’t effectively successful on my system. I did check that the precompile statements were being run with a print.

Do you mean mostly the setindex! functions for Dict?

julia> using SnoopCompile

julia> tinf = @snoopi tmin=0.01 using Revise
8-element Array{Tuple{Float64,Core.MethodInstance},1}:
 (0.012274980545043945, MethodInstance for setindex!(::Dict{String,Base.PkgId}, ::Base.PkgId, ::String))
 (0.01402592658996582, MethodInstance for setindex!(::Dict{Base.PkgId,Revise.PkgData}, ::Revise.PkgData, ::Base.PkgId))
 (0.015115976333618164, MethodInstance for setindex!(::Dict{Base.PkgId,CodeTracking.PkgFiles}, ::CodeTracking.PkgFiles, ::Base.PkgId))
 (0.015180110931396484, MethodInstance for setindex!(::Dict{Method,Nothing}, ::Nothing, ::Method))
 (0.017015933990478516, MethodInstance for setindex!(::Dict{Module,Nothing}, ::Nothing, ::Module))
 (0.021701812744140625, MethodInstance for setindex!(::OrderedCollections.OrderedDict{Module,OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}}}, ::OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}}, ::Module))
 (0.023787975311279297, MethodInstance for setindex!(::Dict{String,Revise.WatchList}, ::Revise.WatchList, ::String))
 (0.08140301704406738, MethodInstance for stale_cachefile(::String, ::String))

Those aren't precompilable, grrrr, JuliaLang/julia#32705. We should ensure that native-compiled stale_cachefile(::String, ::String) makes it into the Julia image, though. I'm not immediately certain how to guarantee that, perhaps @KristofferC knows?

KristofferC · 2020-04-17T13:25:49Z

Could try with https://github.com/JuliaLang/julia/tree/kc/stale_precompile.

timholy · 2020-04-17T13:25:52Z

Or do you mean precompile in general? Like, for all packages? If Revise has to defensively parse all packages, yikes, that will be a huge slowdown. This is a little complicated, so hold on to your hat, but it's not too horrible:

This runs whenever you load a package. If it's successfully using a precompile file, it fills the cachefile field of FileInfo. It does not call parse_source; that only happens if a watched file gets modified.
Conversely, for non-precompiled packages it defers to queue_includes! which does call parse_source when the package is loaded.

So you could probably put a @show filename in parse_source and snoop on when it does the parsing.

IanButterworth · 2020-04-17T14:14:35Z

I had thought that it only affects the first using in a session, hence some missing precomp issue with the methods that Revise uses to track new packages, but it seems I'm wrong.
However, the test I did to determine that I was wrong showed that the order of loading these example packages is important (VideoIO was a random choice, but I had seen the issue with LsqFit)

With Revise

Starting Julia...
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.4.1 (2020-04-14)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> @time @time using LsqFit
  7.278131 seconds (12.62 M allocations: 639.299 MiB, 2.72% gc time)
 17.122437 seconds (26.46 M allocations: 1.288 GiB, 3.56% gc time)

julia> @time @time using VideoIO
  2.687323 seconds (2.85 M allocations: 148.652 MiB, 2.48% gc time)
  2.720171 seconds (2.96 M allocations: 154.203 MiB, 2.45% gc time)

julia> 
Julia has exited.
Press Enter to start a new session.
Starting Julia...
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.4.1 (2020-04-14)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> @time @time using VideoIO
  6.349637 seconds (11.62 M allocations: 578.136 MiB, 3.08% gc time)
  6.420673 seconds (11.77 M allocations: 585.936 MiB, 3.04% gc time)

julia> @time @time using LsqFit
  5.597908 seconds (7.41 M allocations: 383.306 MiB, 3.01% gc time)
  5.968189 seconds (8.52 M allocations: 439.222 MiB, 3.12% gc time)

julia> 
Julia has exited.
Press Enter to start a new session.
Starting Julia...
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.4.1 (2020-04-14)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> @time @time using LsqFit
  7.790797 seconds (12.62 M allocations: 638.795 MiB, 2.56% gc time)
 17.978947 seconds (26.47 M allocations: 1.288 GiB, 3.70% gc time)

julia> @time @time using VideoIO
  2.776532 seconds (2.85 M allocations: 148.651 MiB, 2.52% gc time)
  2.809502 seconds (2.96 M allocations: 154.203 MiB, 2.49% gc time)

Without Revise:

               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.4.1 (2020-04-14)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> @time @time using LsqFit
  6.934945 seconds (12.25 M allocations: 620.384 MiB, 2.51% gc time)
  6.974660 seconds (12.29 M allocations: 622.639 MiB, 2.49% gc time)

julia> @time @time using VideoIO
  2.753921 seconds (2.44 M allocations: 127.965 MiB, 3.35% gc time)
  2.754564 seconds (2.44 M allocations: 127.968 MiB, 3.35% gc time)

julia> 
Julia has exited.
Press Enter to start a new session.
Starting Julia...
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.4.1 (2020-04-14)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> @time @time using VideoIO
  5.387644 seconds (9.80 M allocations: 489.330 MiB, 2.69% gc time)
  5.424854 seconds (9.84 M allocations: 491.581 MiB, 2.67% gc time)

julia> @time @time using LsqFit
  6.099585 seconds (7.57 M allocations: 390.686 MiB, 4.15% gc time)
  6.100420 seconds (7.57 M allocations: 390.688 MiB, 4.15% gc time)

timholy · 2020-04-17T14:30:04Z

Weird...if you @profile @time instead of @time @time what do you see?

IanButterworth · 2020-04-17T15:15:08Z

I'm not sure what the best way to answer that is.. @profile @time using LsqFit has 65k snapshots without revise, and the juno flame graph (@profiler) is dominated by type inference.
It's a bit of a firehose

timholy · 2020-04-17T17:34:05Z

It may be that Revise & LsqFit "content" for priority in the same method tables...i.e., a general precompile problem and not something Revise specific. But if your change fixes the problem, it might be limited to the parsing.

It's really frustrating I can't reproduce this. Can you specify all the package versions too? (st LsqFit etc.)

IanButterworth · 2020-04-17T19:34:18Z

I've been trying to dial in on this, and noticed that the @time @time approach might be missing the issue in some cases.
See here where there is an additional delay after the return

Notice the slow startup too..

So far I've dialed in on:

(@v1.4) pkg> st
Status `~/.julia/environments/v1.4/Project.toml`
  [c52e3926] Atom v0.12.10
  [e5e0dc1b] Juno v0.8.1
  [2fda8390] LsqFit v0.10.0
  [23227f5d] PackageA v0.1.0 [`~/Documents/GitHub/PackageA.jl`]
  [58ca60b1] PackageB v0.1.0 [`~/Documents/GitHub/PackageB.jl`]
  [295af30f] Revise v2.6.1

Where PackageA deps on one large private package and PackageB only deps on LsqFit. If I remove either the lag goes away.

Considering that neither package is being loaded, how can they be interfering?

I'm going to try to further reduce PackageA's dep tree

btw, PackageA and B are actually stripped out packages (not just renamed in the example). No code, just Project.toml's with deps

IanButterworth · 2020-04-18T00:34:13Z

Unfortunately that smaller test case is no longer causing it.. ???

Also, back in my full environment I tried this, with the intention of @snoopi-ing the 2nd instruction, but the lag isn't present.. doing another using before seems to make the lag not occur.
And using SnoopCompile isn't itself laggy.

julia> using SnoopCompile

julia> @time @time using LsqFit
  4.875044 seconds (12.23 M allocations: 620.447 MiB, 2.86% gc time)
  5.536558 seconds (14.09 M allocations: 713.159 MiB, 4.74% gc time)

If it's at all insightful, @snoopi on the 2nd line gives the following (but as I mentioned above, doesn't suffer the lag)

6-element Array{Tuple{Float64,Core.MethodInstance},1}:
 (0.037760019302368164, MethodInstance for __init__())
 (0.04393196105957031, MethodInstance for err(::Any, ::Module, ::String))
 (0.06105494499206543, MethodInstance for (::Revise.var"#34#35"{Base.PkgId})())
 (0.11073589324951172, MethodInstance for (::Revise.var"#32#33"{String,Module,String,Base.PkgId})())
 (0.13067913055419922, MethodInstance for do_artifact_str(::String, ::Dict{String,Any}, ::String, ::Module))
 (0.16010618209838867, MethodInstance for require(::Base.PkgId))

IanButterworth · 2020-04-19T19:55:57Z

I've not been able to nail this down to a single cause, but one thing I can do to switch this on and off is the following

I had these Juno startup args set in Julia Client > Julia options > Arguments

SSH_PUB_KEY_PATH=~/.ssh/id_rsa.pub, SSH_KEY_PATH=~/.ssh/id_rsa

which are actually redundant, as those are the default values anyway.

Removing those args removes the lag, with this setup:

(@v1.4) pkg> st
Status `~/.julia/environments/v1.4/Project.toml`
  [c52e3926] Atom v0.12.10
  [e5e0dc1b] Juno v0.8.1
  [2fda8390] LsqFit v0.10.0
  [295af30f] Revise v2.6.1

So in that setup, in Juno I see a 6 second lag after loading LsqFit:

Revise auto-loaded, ssh keys in startup args: Lag
Revise not installed, ssh keys in startup args: No lag
Revise auto-loaded, no ssh args: No lag

In basic REPL, outside of Juno, with no ssh args, there's a smaller lag of about 2-3 seconds after LsqFit load if Revise is autoloaded.

Unless some potential source jumps out from any of this, I'm going to try to forget about/ignore it and see if any other reports of the issue come up

KristofferC · 2020-04-19T20:22:32Z

If you start julia with --trace-compile=stderr does it spew out a bunch of methods when the lag happens?

IanButterworth · 2020-04-19T20:37:06Z

@KristofferC yeah there's a bunch:

Startup to REPL entry

precompile(Tuple{typeof(Base.similar), Array{Base.Grisu.Bignums.Bignum, 1}})
precompile(Tuple{typeof(Base.length), Array{Base.Grisu.Bignums.Bignum, 1}})
precompile(Tuple{typeof(Base.deepcopy_internal), Any, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.deepcopy_internal), Array{UInt32, 1}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.atreplinit), Function})
precompile(Tuple{typeof(Base.:(>)), Base.VersionNumber, Base.VersionNumber})
precompile(Tuple{typeof(Base.popfirst!), Array{String, 1}})
precompile(Tuple{typeof(Base.haskey), Base.EnvDict, String})
precompile(Tuple{typeof(Base.find_package), String})
precompile(Tuple{typeof(Pkg.devdir)})
precompile(Tuple{typeof(Base.occursin), String, String})
precompile(Tuple{typeof(Pkg.TOML.parsefile), String})
precompile(Tuple{typeof(Base.println), Base.TTY, String})
Starting Julia...
precompile(Tuple{typeof(Requires.__init__)})
precompile(Tuple{typeof(Requires.loadpkg), Base.PkgId})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Base.PkgId, Array{Function, 1}}, Base.PkgId})
precompile(Tuple{typeof(MacroTools.__init__)})
precompile(Tuple{typeof(Random.make_seed)})
precompile(Tuple{Type{Random.MersenneTwister}, Nothing})
precompile(Tuple{typeof(Random.default_rng), Int64})
precompile(Tuple{typeof(Base.nextpow), Int64, Int64})
precompile(Tuple{typeof(Random.shuffle!), Random.MersenneTwister, Array{Symbol, 1}})
precompile(Tuple{typeof(Media.__init__)})
precompile(Tuple{typeof(Parsers.__init__)})
precompile(Tuple{typeof(Base.GMP.MPZ.set), Base.GMP.BigInt})
precompile(Tuple{typeof(Base.deepcopy), Base.GMP.BigInt})
precompile(Tuple{typeof(Base.Threads.resize_nthreads!), Array{Base.GMP.BigInt, 1}, Base.GMP.BigInt})
precompile(Tuple{typeof(Base.foreach), getfield(Parsers, Symbol("#25#30")), Array{Base.GMP.BigInt, 1}})
precompile(Tuple{typeof(Base.foreach), getfield(Parsers, Symbol("#26#31")), Array{Base.GMP.BigInt, 1}})
precompile(Tuple{typeof(Base.foreach), getfield(Parsers, Symbol("#27#32")), Array{Base.GMP.BigInt, 1}})
precompile(Tuple{typeof(Base.foreach), getfield(Parsers, Symbol("#28#33")), Array{Base.GMP.BigInt, 1}})
precompile(Tuple{typeof(Base.foreach), getfield(Parsers, Symbol("#29#34")), Array{Base.GMP.BigInt, 1}})
precompile(Tuple{typeof(ColorTypes.__init__)})
precompile(Tuple{typeof(JuliaInterpreter.set_compiled_methods)})
precompile(Tuple{typeof(JuliaInterpreter.__init__)})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Method, Nothing}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Method, Nothing}, Method})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Method, Nothing}, Nothing, Method})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Module, Nothing}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Module, Nothing}, Module})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Module, Nothing}, Nothing, Module})
precompile(Tuple{typeof(Base.filter!), getfield(Base, Symbol("#66#67")){typeof(Base.isempty)}, Array{String, 1}})
precompile(Tuple{typeof(MbedTLS_jll.__init__)})
precompile(Tuple{typeof(Pkg.Artifacts.do_artifact_str), String, Base.Dict{String, Any}, String, Module})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Symbol, Base.Dict{K, V} where V where K}, Symbol})
precompile(Tuple{typeof(Base.haskey), Base.Dict{Base.UUID, Base.Dict{String, Union{Base.SHA1, String}}}, Base.UUID})
precompile(Tuple{typeof(Pkg.Artifacts.unpack_platform), Base.Dict{String, Any}, String, String})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("#21#22")){String, String}, Base.Dict{String, Any}})
precompile(Tuple{Type{Base.Dict{Pkg.BinaryPlatforms.Platform, Base.Dict{String, Any}}}, Base.Generator{Array{Base.Dict{String, Any}, 1}, getfield(Pkg.Artifacts, Symbol("#21#22")){String, String}}})
precompile(Tuple{getfield(Pkg.BinaryPlatforms, Symbol("#FreeBSD#19#20")), Nothing, Nothing, Pkg.BinaryPlatforms.CompilerABI, Type{Pkg.BinaryPlatforms.FreeBSD}, Symbol})
precompile(Tuple{getfield(Core, Symbol("#Type##kw")), NamedTuple{(:libc, :compiler_abi), Tuple{Nothing, Pkg.BinaryPlatforms.CompilerABI}}, Type{Pkg.BinaryPlatforms.FreeBSD}, Symbol})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Pkg.BinaryPlatforms.FreeBSD, Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Pkg.BinaryPlatforms.Platform, Base.Dict{String, Any}}, Pkg.BinaryPlatforms.FreeBSD})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Pkg.BinaryPlatforms.Platform, Base.Dict{String, Any}}, Base.Dict{String, Any}, Pkg.BinaryPlatforms.FreeBSD})
precompile(Tuple{getfield(Pkg.BinaryPlatforms, Symbol("#39#41")){Pkg.BinaryPlatforms.MacOS}, Pkg.BinaryPlatforms.FreeBSD})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("#ensure_artifact_installed##kw")), NamedTuple{(:platform,), Tuple{Pkg.BinaryPlatforms.MacOS}}, typeof(Pkg.Artifacts.ensure_artifact_installed), String, Base.Dict{String, Any}, String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("#78#79")), Base.IOStream})
precompile(Tuple{getfield(Base, Symbol("##open#270")), Base.Iterators.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:write,), Tuple{Bool}}}, typeof(Base.open), getfield(Pkg.PlatformEngines, Symbol("#78#79")), String})
precompile(Tuple{typeof(Pkg.PlatformEngines.get_server_dir), String, Base.SubString{String}})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##get_auth_header#77")), Bool, typeof(Pkg.PlatformEngines.get_auth_header), String})
precompile(Tuple{typeof(UUIDs.uuid4)})
precompile(Tuple{typeof(Random.randstring), Int64})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("#81#86")), Base.IOStream})
precompile(Tuple{getfield(Base, Symbol("##open#270")), Base.Iterators.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:write,), Tuple{Bool}}}, typeof(Base.open), getfield(Pkg.PlatformEngines, Symbol("#81#86")), String})
precompile(Tuple{typeof(Pkg.PlatformEngines.load_telemetry_file), String})
precompile(Tuple{typeof(Pkg.PlatformEngines.get_telemetry_headers), String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download#87")), Bool, Nothing, typeof(Pkg.PlatformEngines.download), String, String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download_verify#88")), Bool, Bool, Bool, typeof(Pkg.PlatformEngines.download_verify), String, Nothing, String})
precompile(Tuple{typeof(Base.convert), Type{Nothing}, Base.SubString{String}})
precompile(Tuple{typeof(Base.convert), Type{Base.Pair{Nothing, String}}, Base.Pair{Base.SubString{String}, String}})
precompile(Tuple{typeof(Base.setindex!), Array{Base.Pair{Nothing, String}, 1}, Base.Pair{Base.SubString{String}, String}, Int64})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Base.Pair{Nothing, String}, 1}, Base.Pair{Base.SubString{String}, String}, Base.Generator{Array{Array{Union{Nothing, Base.SubString{String}}, 1}, 1}, getfield(Pkg.PlatformEngines, Symbol("#93#95"))}, Int64})
precompile(Tuple{typeof(Base.collect), Base.Generator{Array{Array{Union{Nothing, Base.SubString{String}}, 1}, 1}, getfield(Pkg.PlatformEngines, Symbol("#93#95"))}})
precompile(Tuple{typeof(Pkg.PlatformEngines.list_tarball_symlinks), String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##unpack#96")), Bool, typeof(Pkg.PlatformEngines.unpack), String, String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download_verify_unpack#101")), Nothing, Bool, Bool, Bool, Bool, typeof(Pkg.PlatformEngines.download_verify_unpack), String, Nothing, String})
precompile(Tuple{typeof(Pkg.set_readonly), String})
precompile(Tuple{typeof(Pkg.Artifacts.create_artifact), getfield(Pkg.Artifacts, Symbol("#39#40")){Bool, String, Nothing}})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("##download_artifact#38")), Bool, Bool, typeof(Pkg.Artifacts.download_artifact), Base.SHA1, String, Nothing})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("#43#45")){Bool, Bool, Base.SHA1}})
precompile(Tuple{typeof(Pkg.Artifacts.with_show_download_info), getfield(Pkg.Artifacts, Symbol("#43#45")){Bool, Bool, Base.SHA1}, String, Bool})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("##ensure_artifact_installed#42")), Pkg.BinaryPlatforms.Platform, Bool, Bool, typeof(Pkg.Artifacts.ensure_artifact_installed), String, Base.Dict{String, Any}, String})
precompile(Tuple{typeof(Libdl.dlopen), String})
precompile(Tuple{typeof(MbedTLS.f_send), Ptr{Nothing}, Ptr{UInt8}, UInt64})
precompile(Tuple{typeof(MbedTLS.f_recv), Ptr{Nothing}, Ptr{UInt8}, UInt64})
precompile(Tuple{typeof(MbedTLS.__init__)})
precompile(Tuple{typeof(HTTP.URIs.__init__)})
precompile(Tuple{typeof(Base.Threads.resize_nthreads!), Array{HTTP.URIs.RegexAndMatchData, 1}, HTTP.URIs.RegexAndMatchData})
precompile(Tuple{typeof(Base.deepcopy_internal), Base.Regex, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(HTTP.Parsers.__init__)})
precompile(Tuple{typeof(Base.Threads.resize_nthreads!), Array{HTTP.Parsers.RegexAndMatchData, 1}, HTTP.Parsers.RegexAndMatchData})
precompile(Tuple{typeof(HTTP.CookieRequest.__init__)})
precompile(Tuple{Type{Base.Dict{String, Base.Set{HTTP.Cookies.Cookie}}}})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{String, Base.Set{HTTP.Cookies.Cookie}}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{String, Base.Set{HTTP.Cookies.Cookie}}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Base.Set{HTTP.Cookies.Cookie}}, Base.Set{HTTP.Cookies.Cookie}, String})
precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{String, Base.Set{HTTP.Cookies.Cookie}}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.Threads.resize_nthreads!), Array{Base.Dict{String, Base.Set{HTTP.Cookies.Cookie}}, 1}, Base.Dict{String, Base.Set{HTTP.Cookies.Cookie}}})
precompile(Tuple{typeof(HTTP.ConnectionRequest.__init__)})
precompile(Tuple{typeof(HTTP.Servers.__init__)})
precompile(Tuple{Type{Base.Dict{Sockets.IPAddr, HTTP.Servers.RateLimit}}})
precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{Sockets.IPAddr, HTTP.Servers.RateLimit}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.Threads.resize_nthreads!), Array{Base.Dict{Sockets.IPAddr, HTTP.Servers.RateLimit}, 1}, Base.Dict{Sockets.IPAddr, HTTP.Servers.RateLimit}})
precompile(Tuple{typeof(Requires.listenpkg), Any, Base.PkgId})
precompile(Tuple{typeof(Atom.__init__)})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{String, Function}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{String, Function}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Function}, Function, String})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Base.PkgId, Array{Function, 1}}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Base.PkgId, Array{Function, 1}}, Base.PkgId})
precompile(Tuple{typeof(Base.throw_boundserror), Array{Function, 1}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.copyto!), Array{Function, 1}, Array{Any, 1}})
precompile(Tuple{typeof(Base.get!), getfield(Requires, Symbol("#1#2")), Base.Dict{Base.PkgId, Array{Function, 1}}, Base.PkgId})
precompile(Tuple{typeof(Base.push!), Array{Function, 1}, Function})
precompile(Tuple{getfield(Base, Symbol("#683#684")){Base.UUID, String}, Base.IOStream})
precompile(Tuple{getfield(Base, Symbol("##open#270")), Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), getfield(Base, Symbol("#683#684")){Base.UUID, String}, String})
precompile(Tuple{typeof(Base.manifest_deps_get), String, Base.PkgId, String})
precompile(Tuple{typeof(Base.identify_package), Base.PkgId, String})
precompile(Tuple{typeof(Base.stale_cachefile), String, String})
precompile(Tuple{typeof(Base.register_root_module), Module})
precompile(Tuple{typeof(Base._include_from_serialized), String, Array{Any, 1}})
precompile(Tuple{typeof(Base._tryrequire_from_serialized), Base.PkgId, UInt64, String})
precompile(Tuple{typeof(Base._require_search_from_serialized), Base.PkgId, String})
precompile(Tuple{typeof(Base.create_expr_cache), String, String, Array{Base.Pair{Base.PkgId, UInt64}, 1}, Nothing})
precompile(Tuple{typeof(Base.compilecache), Base.PkgId, String})
precompile(Tuple{typeof(Base._tryrequire_from_serialized), Base.PkgId, UInt64, Nothing})
precompile(Tuple{typeof(Base._require_from_serialized), String})
precompile(Tuple{typeof(Base._require), Base.PkgId})
precompile(Tuple{typeof(Base.require), Base.PkgId})
precompile(Tuple{typeof(Base.require), Module, Symbol})
precompile(Tuple{typeof(Atom.handle), Function, String})
precompile(Tuple{typeof(Sockets.connect!), Sockets.TCPSocket, Sockets.IPv4, Int64})
precompile(Tuple{getfield(Atom, Symbol("##connect#17")), Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Atom.connect), Sockets.IPv4, Int64})
precompile(Tuple{typeof(Atom.connect), Int64})
precompile(Tuple{getfield(Atom, Symbol("#172#173"))})
precompile(Tuple{getfield(Base, Symbol("#764#766")){Bool, Bool, Bool, Bool}, Module})
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.4.1 (2020-04-14)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

precompile(Tuple{typeof(Base.typeintersect), Any, Any})
precompile(Tuple{typeof(Core.Compiler.zero), Type{Int128}})
precompile(Tuple{typeof(Base._compute_eltype), Type{Tuple{Base.Pair{Symbol, String}, Base.Pair{Symbol, String}, Base.Pair{Symbol, Bool}}}})
precompile(Tuple{typeof(Base.grow_to!), Base.Dict{Any, Any}, Tuple{Base.Pair{Symbol, String}, Base.Pair{Symbol, String}, Base.Pair{Symbol, Bool}}})
precompile(Tuple{Type{Base.Dict{K, V} where V where K}, Tuple{Base.Pair{Symbol, String}, Base.Pair{Symbol, String}, Base.Pair{Symbol, Bool}}})
precompile(Tuple{getfield(Atom, Symbol("#18#20"))})
precompile(Tuple{typeof(Base.isopen), Sockets.TCPSocket})
precompile(Tuple{typeof(JSON.Parser.parse), Sockets.TCPSocket})
precompile(Tuple{getfield(JSON.Parser, Symbol("##parse#2")), Type{T} where T, Type{Int64}, Bool, Nothing, typeof(JSON.Parser.parse), Sockets.TCPSocket})
precompile(Tuple{typeof(JSON.Parser.current), JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser._error), String, JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser.byteat), JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser.read_four_hex_digits!), JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser._error_expected_char), UInt8, JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser.read_unicode_escape!), JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{UInt8, UInt8}, UInt8})
precompile(Tuple{typeof(JSON.Parser.parse_string), JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser.skip!), JSON.Parser.StreamingParserState{Sockets.TCPSocket}, UInt8, UInt8})
precompile(Tuple{typeof(JSON.Parser.parse_jsconstant), JSON.Parser.ParserContext{Base.Dict{String, Any}, Int64, true, nothing}, JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(Base.throw_boundserror), JSON.Parser.PushVector{UInt8, Array{UInt8, 1}}, Tuple{Int64}})
precompile(Tuple{Type{Float64}, Base.GMP.BigInt, Base.Rounding.RoundingMode{:Nearest}})
precompile(Tuple{typeof(Parsers.roundQuotient), Base.GMP.BigInt, Base.GMP.BigInt})
precompile(Tuple{typeof(Base.Math.ldexp), Base.MPFR.BigFloat, Int64})
precompile(Tuple{typeof(Parsers.scale), Type{Float64}, Int64, Int64})
precompile(Tuple{typeof(Core.throw_inexacterror), Symbol, Type{Int32}, Int128})
precompile(Tuple{typeof(Parsers.BigInt!), Base.GMP.BigInt, Int128})
precompile(Tuple{typeof(Parsers.scale), Type{Float64}, Int128, Int64})
precompile(Tuple{typeof(Base.Math.ldexp), Float64, Int128})
precompile(Tuple{typeof(Base.GMP.MPZ.set_ui), UInt64})
precompile(Tuple{typeof(Base.GMP.MPZ.realloc2), Int64})
precompile(Tuple{Type{Base.GMP.BigInt}, Int128})
precompile(Tuple{typeof(Base.exp2), Base.MPFR.BigFloat})
precompile(Tuple{typeof(Base.:(*)), Base.MPFR.BigFloat, Base.MPFR.BigFloat})
julia> Type{Float64}, Int128, Int128})
precompile(Tuple{typeof(Base.GMP.MPZ.add_ui), Base.GMP.BigInt, UInt8})
precompile(Tuple{typeof(Parsers.scale), Type{Float64}, Base.GMP.BigInt, Int64})
precompile(Tuple{typeof(Parsers.pow10), Type{Float64}, Base.GMP.BigInt})
precompile(Tuple{typeof(Base.Math.ldexp), Float64, Base.GMP.BigInt})
precompile(Tuple{typeof(Parsers.scale), Type{Float64}, Base.GMP.BigInt, Base.GMP.BigInt})
precompile(Tuple{typeof(Parsers._typeparser), Type{Float64}, Array{UInt8, 1}, Int64, Int64, UInt8, Int16, Parsers.Options{false, false, false, false, Nothing, Nothing, Nothing}, Type{Base.GMP.BigInt}})
precompile(Tuple{typeof(Parsers._typeparser), Type{Float64}, Array{UInt8, 1}, Int64, Int64, UInt8, Int16, Parsers.Options{false, false, false, false, Nothing, Nothing, Nothing}, Type{Int128}})
precompile(Tuple{typeof(JSON.Parser._float_from_bytes), Array{UInt8, 1}, Int64, Int64})
precompile(Tuple{typeof(JSON.Parser.number_from_bytes), JSON.Parser.ParserContext{Base.Dict{String, Any}, Int64, true, nothing}, JSON.Parser.StreamingParserState{Sockets.TCPSocket}, Bool, JSON.Parser.PushVector{UInt8, Array{UInt8, 1}}, Int64, Int64})
precompile(Tuple{typeof(JSON.Parser.parse_number), JSON.Parser.ParserContext{Base.Dict{String, Any}, Int64, true, nothing}, JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser.parse_object), JSON.Parser.ParserContext{Base.Dict{String, Any}, Int64, true, nothing}, JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser.parse_array), JSON.Parser.ParserContext{Base.Dict{String, Any}, Int64, true, nothing}, JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(JSON.Parser.parse_value), JSON.Parser.ParserContext{Base.Dict{String, Any}, Int64, true, nothing}, JSON.Parser.StreamingParserState{Sockets.TCPSocket}})
precompile(Tuple{typeof(Atom.instantiate_repl_keybindings), REPL.LineEditREPL})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Base.Dict{Any, Any}, 1}, Base.Dict{Any, Any}, Base.Generator{Array{Base.Dict{Any, Any}, 1}, typeof(REPL.LineEdit.normalize_keys)}, Int64})
precompile(Tuple{typeof(Base._collect), Array{Base.Dict{Any, Any}, 1}, Base.Generator{Array{Base.Dict{Any, Any}, 1}, typeof(REPL.LineEdit.normalize_keys)}, Base.EltypeUnknown, Base.HasShape{1}})
precompile(Tuple{typeof(REPL.setup_interface), REPL.LineEditREPL, Bool, Any})
precompile(Tuple{Type{Base.Dict{Symbol, Any}}, Base.Pair{Symbol, REPL.LineEdit.Prompt}, Vararg{Base.Pair{Symbol, REPL.LineEdit.Prompt}, N} where N})
precompile(Tuple{typeof(REPL.hist_getline), Any})
precompile(Tuple{typeof(REPL.hist_from_file), Any, Any, Any})
precompile(Tuple{typeof(Base.peek), Base.IOStream})
precompile(Tuple{Type{Char}, Int32})
precompile(Tuple{typeof(Base.seekend), Base.IOStream})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Pair{String, getfield(REPL.LineEdit, Symbol("#45#76"))}, Vararg{Base.Pair{A, B} where B where A, N} where N})
precompile(Tuple{typeof(REPL.LineEdit.normalize_keys), Base.Dict{K, V} where V where K})
precompile(Tuple{typeof(REPL.LineEdit.normalize_key), AbstractString})
precompile(Tuple{typeof(REPL.LineEdit.keymap_unify), Any})
precompile(Tuple{typeof(REPL.LineEdit.keymap_merge), Any, Any})
precompile(Tuple{typeof(Base.filter), getfield(REPL.LineEdit, Symbol("#30#31")), Base.Dict{Any, Any}})
precompile(Tuple{getfield(REPL.LineEdit, Symbol("##add_nested_key!#21")), Any, typeof(REPL.LineEdit.add_nested_key!), Base.Dict{K, V} where V where K, Any, Any})
precompile(Tuple{getfield(REPL.LineEdit, Symbol("#add_nested_key!##kw")), Any, typeof(REPL.LineEdit.add_nested_key!), Base.Dict{K, V} where V where K, Any, Any})
precompile(Tuple{typeof(REPL.LineEdit.fixup_keymaps!), Base.Dict{K, V} where V where K, Any, Any, Any})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Pair{String, getfield(REPL.LineEdit, Symbol("#74#105")){REPL.LineEdit.HistoryPrompt}}, Vararg{Base.Pair{A, B} where B where A, N} where N})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Pair{Char, getfield(REPL, Symbol("#49#58")){REPL.LineEdit.Prompt}}, Vararg{Base.Pair{A, B} where B where A, N} where N})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Pair{String, getfield(REPL.LineEdit, Symbol("#251#255")){REPL.LineEdit.PrefixHistoryPrompt}}, Vararg{Base.Pair{A, B} where B where A, N} where N})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Pair{Char, getfield(REPL, Symbol("#39#42")){REPL.LineEdit.Prompt}}, Vararg{Base.Pair{A, B} where B where A, N} where N})
precompile(Tuple{getfield(Atom, Symbol("##isREPL#210")), Bool, typeof(Atom.isREPL)})
precompile(Tuple{typeof(Atom.fixjunodisplays)})
precompile(Tuple{getfield(Atom, Symbol("#1#6")), REPL.LineEditREPL})
precompile(Tuple{getfield(Main, Symbol("#3#5")), REPL.LineEditREPL})
precompile(Tuple{typeof(Revise.setup_atom), Module})
precompile(Tuple{typeof(Revise.filter_valid_cachefiles), Nothing, Array{String, 1}})
precompile(Tuple{typeof(Revise.parse_cache_header), Base.IOStream})
precompile(Tuple{typeof(Revise.parse_cache_header), String})
precompile(Tuple{typeof(Revise.filter_valid_cachefiles), String, Array{String, 1}})
precompile(Tuple{typeof(Revise.pkg_fileinfo), Base.PkgId})
precompile(Tuple{typeof(Base.Filesystem.relpath), String, Revise.PkgData})
precompile(Tuple{Type{OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}}, Module})
precompile(Tuple{typeof(Revise.first_bad_position), String})
precompile(Tuple{typeof(Revise.unwrap), Expr})
precompile(Tuple{typeof(Revise.parse_source!), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, String, String, Module})
precompile(Tuple{typeof(Revise.parse_source!), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, String, Module})
precompile(Tuple{Type{Revise.CodeTrackingMethodInfo}, Expr})
precompile(Tuple{typeof(Revise.storedeps), Base.Set{Union{GlobalRef, Symbol}}, Nothing, Module})
precompile(Tuple{typeof(Revise.storedeps), Base.Set{Union{GlobalRef, Symbol}}, Array{Any, 1}, Module})
precompile(Tuple{typeof(Revise.storedeps), Base.Set{Union{GlobalRef, Symbol}}, Revise.RelocatableExpr, Module})
precompile(Tuple{getfield(Revise, Symbol("##instantiate_sigs!#71")), Bool, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Revise.instantiate_sigs!), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}})
precompile(Tuple{typeof(Revise.queue_includes!), Revise.PkgData, Base.PkgId})
precompile(Tuple{typeof(Revise.parse_pkg_files), Base.PkgId})
precompile(Tuple{Type{Revise.WatchList}})
precompile(Tuple{typeof(Revise.init_watching), Revise.PkgData, Array{String, 1}})
precompile(Tuple{typeof(Revise.__init__)})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{String, Function}, String})
precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Function}, String})
precompile(Tuple{typeof(Base.getindex), Base.Dict{String, Function}, String})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Base.PkgId, Revise.PkgData}, Base.PkgId})
precompile(Tuple{typeof(CodeTracking.basepath), Base.PkgId})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Base.PkgId, Revise.PkgData}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Base.PkgId, Revise.PkgData}, Base.PkgId})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Base.PkgId, Revise.PkgData}, Revise.PkgData, Base.PkgId})
precompile(Tuple{typeof(Base.push!), Array{Tuple{Module, String, Float64}, 1}, Tuple{Module, String, Float64}})
precompile(Tuple{typeof(Base._deleteat!), Array{Tuple{Module, String, Float64}, 1}, Array{Int64, 1}})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{String, Array{Tuple{Module, String, Float64}, 1}}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{String, Array{Tuple{Module, String, Float64}, 1}}, Int64, Int64})
precompile(Tuple{typeof(Base.fill!), Array{Int32, 1}, Int64})
precompile(Tuple{typeof(OrderedCollections.rehash!), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, Int64})
precompile(Tuple{typeof(OrderedCollections.ht_keyindex2), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, Module})
precompile(Tuple{typeof(OrderedCollections._setindex!), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Module, Int64})
precompile(Tuple{typeof(Base.setindex!), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Module})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Base.PkgId, CodeTracking.PkgFiles}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Base.PkgId, CodeTracking.PkgFiles}, Base.PkgId})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Base.PkgId, CodeTracking.PkgFiles}, CodeTracking.PkgFiles, Base.PkgId})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{String, Revise.WatchList}, String})
precompile(Tuple{Type{Base.Dict{String, Base.PkgId}}})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{String, Revise.WatchList}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{String, Revise.WatchList}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Revise.WatchList}, Revise.WatchList, String})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{String, Base.PkgId}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{String, Base.PkgId}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Base.PkgId}, Base.PkgId, String})
precompile(Tuple{typeof(Revise.watch_package), Base.PkgId})
precompile(Tuple{typeof(Pkg.REPLMode.repl_init), REPL.LineEditREPL})
precompile(Tuple{getfield(Pkg, Symbol("#1#2")), REPL.LineEditREPL})
precompile(Tuple{typeof(Pkg.REPLMode.create_mode), REPL.LineEditREPL, REPL.LineEdit.Prompt})
precompile(Tuple{typeof(REPL.run_frontend), REPL.StreamREPL, REPL.REPLBackendRef})
precompile(Tuple{typeof(REPL.run_frontend), REPL.LineEditREPL, REPL.REPLBackendRef})
precompile(Tuple{typeof(REPL.run_frontend), REPL.BasicREPL, REPL.REPLBackendRef})
precompile(Tuple{typeof(REPL.run_repl), REPL.AbstractREPL, Any})
precompile(Tuple{typeof(Base.:(==)), Media.DisplayHook, REPL.REPLDisplay{REPL.LineEditREPL}})
precompile(Tuple{typeof(REPL.LineEdit.prompt!), REPL.Terminals.TextTerminal, REPL.LineEdit.ModalInterface, REPL.LineEdit.MIState})
precompile(Tuple{typeof(REPL.LineEdit.run_interface), REPL.Terminals.TextTerminal, REPL.LineEdit.ModalInterface, REPL.LineEdit.MIState})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Int64, String})
precompile(Tuple{typeof(JSON.Parser.skip!), JSON.Parser.StreamingParserState{Sockets.TCPSocket}, UInt8, UInt8, Vararg{UInt8, N} where N})
precompile(Tuple{typeof(Revise.wait_changed), String})
precompile(Tuple{typeof(Revise.watch_files_via_dir), String})
precompile(Tuple{typeof(Revise.hasfile), Revise.PkgData, String})
precompile(Tuple{typeof(Revise.revise_dir_queued), String})
precompile(Tuple{Revise.Rescheduler{typeof(Revise.revise_dir_queued), Tuple{String}}})
precompile(Tuple{Type{FileWatching.FileMonitor}, String})
precompile(Tuple{typeof(Base.preserve_handle), FileWatching.FileMonitor})
precompile(Tuple{typeof(FileWatching.start_watching), FileWatching.FileMonitor})
precompile(Tuple{typeof(Base.unpreserve_handle), FileWatching.FileMonitor})
precompile(Tuple{typeof(FileWatching.stop_watching), FileWatching.FileMonitor})
precompile(Tuple{typeof(Base.wait), FileWatching.FileMonitor})
precompile(Tuple{typeof(FileWatching.watch_file), String, Int64})
precompile(Tuple{typeof(Revise.watch_manifest), String})
precompile(Tuple{Revise.Rescheduler{typeof(Revise.watch_manifest), Tuple{String}}})
precompile(Tuple{typeof(Revise.remove_from_included_files), Symbol})
precompile(Tuple{typeof(Revise.has_writable_paths), Revise.PkgData})
precompile(Tuple{typeof(Revise._watch_package), Base.PkgId})
precompile(Tuple{getfield(Revise, Symbol("#34#35")){Base.PkgId}})
precompile(Tuple{getfield(Main, Symbol("#4#6"))})
precompile(Tuple{typeof(REPL.LineEdit.activate), REPL.LineEdit.TextInterface, REPL.LineEdit.ModeState, Any, REPL.Terminals.TextTerminal})
precompile(Tuple{typeof(REPL.LineEdit.refresh_line), Any, Any})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.UnixTerminal, Any})
precompile(Tuple{getfield(REPL.LineEdit, Symbol("##refresh_multi_line#16")), Any, typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.UnixTerminal, Any})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, REPL.Terminals.UnixTerminal, Union{REPL.LineEdit.PrefixSearchState, REPL.LineEdit.PromptState}})
precompile(Tuple{getfield(REPL.LineEdit, Symbol("##refresh_multi_line#38")), Any, typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, REPL.Terminals.UnixTerminal, Union{REPL.LineEdit.PrefixSearchState, REPL.LineEdit.PromptState}})
precompile(Tuple{getfield(Atom, Symbol("#19#21")){Array{Any, 1}}})
precompile(Tuple{typeof(Atom.handlemsg), String, Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{String, Any}, Symbol})
precompile(Tuple{typeof(MacroTools.get′), Base.Dict{String, Any}, Symbol, String})
precompile(Tuple{getfield(Atom, Symbol("#213#214")), Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.split), String, Char})
precompile(Tuple{typeof(Atom.get_main_mode)})
precompile(Tuple{typeof(Atom.changeREPLmodule), String})
precompile(Tuple{typeof(Atom.getmodule), String})
precompile(Tuple{typeof(Base.copyto!), Array{Base.PkgId, 1}, Base.KeySet{Base.PkgId, Base.Dict{Base.PkgId, Module}}})
precompile(Tuple{typeof(Base.filter), getfield(CodeTools, Symbol("#7#8")){String}, Array{Base.PkgId, 1}})
precompile(Tuple{typeof(CodeTools.getpackage), String})
precompile(Tuple{typeof(Base.getindex), Array{REPL.LineEdit.TextInterface, 1}, Int64})
precompile(Tuple{typeof(Atom.handlemsg), Base.Dict{String, Any}})
precompile(Tuple{getfield(Atom, Symbol("#27#28"))})
precompile(Tuple{typeof(Atom.msg), String, Int64, Vararg{Any, N} where N})
precompile(Tuple{typeof(Atom.isactive), Sockets.TCPSocket})
precompile(Tuple{typeof(Lazy.c), String, Vararg{Any, N} where N})
precompile(Tuple{getfield(Base, Symbol("##sprint#338")), Nothing, Int64, typeof(Base.sprint), Function, Array{Any, 1}})
precompile(Tuple{typeof(JSON.Writer.show_json), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Array{Any, 1}})
precompile(Tuple{typeof(JSON.Writer.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{Any, 1}})
precompile(Tuple{typeof(Base.unsafe_write), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Ptr{UInt8}, UInt64})
precompile(Tuple{typeof(Base.unsafe_write), JSON.Writer.StringContext{JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}}, Ptr{UInt8}, UInt64})
precompile(Tuple{typeof(JSON.Writer.show_string), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String})
precompile(Tuple{typeof(JSON.Writer.show_json), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, String})
precompile(Tuple{typeof(JSON.Writer.show_element), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, String})
precompile(Tuple{typeof(Base.print), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Int64})
precompile(Tuple{typeof(JSON.Writer.show_element), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Int64})
precompile(Tuple{typeof(Base.print), Sockets.TCPSocket, String, Char})
precompile(Tuple{typeof(Base.println), Sockets.TCPSocket, String})
precompile(Tuple{typeof(Atom.handlemsg), String, String})
precompile(Tuple{getfield(Main, Symbol("#9#12")), String})
precompile(Tuple{typeof(Base.Filesystem.ispath), String})
precompile(Tuple{typeof(Base.:(!=)), Bool, Bool})
precompile(Tuple{getfield(Atom, Symbol("##changeREPLprompt#223")), Symbol, Bool, typeof(Atom.changeREPLprompt), String})
precompile(Tuple{getfield(Atom, Symbol("#211#212")), String})
precompile(Tuple{typeof(Atom.reset_repl_history)})
precompile(Tuple{getfield(Atom, Symbol("#2#7"))})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Any, Any}, Type{T} where T})
precompile(Tuple{typeof(Base.reverse), Array{Base.Multimedia.AbstractDisplay, 1}, Int64, Int64})
precompile(Tuple{typeof(JSON.Writer.show_element), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Nothing})
precompile(Tuple{typeof(Atom.handlemsg), Base.Dict{String, Any}, Array{Any, 1}})
precompile(Tuple{typeof(Base.filter!), getfield(Base, Symbol("#66#67")){typeof(Base.isempty)}, Array{Any, 1}})
precompile(Tuple{getfield(Atom, Symbol("#29#30")), Array{Any, 1}})
precompile(Tuple{getfield(Base, Symbol("#66#67")){typeof(Base.isempty)}, String})
precompile(Tuple{typeof(JSON.Writer.show_json), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Array{String, 1}})
precompile(Tuple{typeof(JSON.Writer.show_element), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Array{String, 1}})
precompile(Tuple{typeof(Atom.handlemsg), Base.Dict{String, Any}, Bool})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Juno.PlotPane, Type{Media.Graphical}})
precompile(Tuple{getfield(Atom, Symbol("#55#56")), Bool})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Any, Any}, Type{T} where T})
precompile(Tuple{typeof(Atom.handlemsg), Base.Dict{String, Any}, String})
precompile(Tuple{typeof(Base.collect_to!), Array{Symbol, 1}, Base.Generator{Array{Base.SubString{String}, 1}, Type{Symbol}}, Int64, Int64})
precompile(Tuple{typeof(Base._collect), Array{Base.SubString{String}, 1}, Base.Generator{Array{Base.SubString{String}, 1}, Type{Symbol}}, Base.EltypeUnknown, Base.HasShape{1}})
precompile(Tuple{typeof(CodeTools.getthing), Module, String, Nothing})
precompile(Tuple{typeof(CodeTools.getthing), String})
precompile(Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.string), Tuple{Base.Broadcast.Extruded{Array{Module, 1}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}})
precompile(Tuple{getfield(Atom, Symbol("#170#171")), String})
precompile(Tuple{typeof(Base.print), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Bool})
precompile(Tuple{typeof(JSON.Writer.show_element), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Bool})
precompile(Tuple{getfield(Revise, Symbol("#84#85")){REPL.REPLBackend}})
precompile(Tuple{typeof(Revise.add_definitions_from_repl), String})
precompile(Tuple{typeof(Revise.read_from_cache), Revise.PkgData, String})
precompile(Tuple{typeof(Revise.maybe_parse_from_cache!), Revise.PkgData, String})
precompile(Tuple{typeof(Revise.delete_missing!), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}})
precompile(Tuple{typeof(Revise.handle_deletions), Revise.PkgData, String})
precompile(Tuple{typeof(Revise.init_watching), Revise.PkgData, Tuple{String}})
precompile(Tuple{typeof(Revise.maybe_add_includes_to_pkgdata!), Revise.PkgData, String, Array{Base.Pair{Module, Array{String, 1}}, 1}})
precompile(Tuple{typeof(Revise.errors), Array{Any, 1}})
precompile(Tuple{typeof(Revise.queue_includes), Module})
precompile(Tuple{typeof(Revise.revise)})
precompile(Tuple{typeof(Revise.run_backend), REPL.REPLBackend})

Statements that printed after the print from `@time @time using LsqFit` finished

precompile(Tuple{typeof(Base.write), Base.GenericIOBuffer{Array{UInt8, 1}}, String, String, String})
precompile(Tuple{typeof(HTTP.Cookies.isIP), String})
precompile(Tuple{Type{String}, HTTP.Cookies.Cookie, Bool})
precompile(Tuple{typeof(Base.string), String, Array{HTTP.Cookies.Cookie, 1}, Bool})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##probe_platform_engines!#14")), Bool, typeof(Pkg.PlatformEngines.probe_platform_engines!)})
precompile(Tuple{getfield(Base.Filesystem, Symbol("##mktempdir#19")), String, Bool, typeof(Base.Filesystem.mktempdir), String})
precompile(Tuple{getfield(Base.Filesystem, Symbol("##tempname#17")), Bool, typeof(Base.Filesystem.tempname), String})
precompile(Tuple{typeof(Pkg.PlatformEngines.get_server_dir), String, Base.SubString{String}})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##get_auth_header#77")), Bool, typeof(Pkg.PlatformEngines.get_auth_header), String})
precompile(Tuple{typeof(Pkg.PlatformEngines.load_telemetry_file), String})
precompile(Tuple{typeof(Pkg.PlatformEngines.get_telemetry_headers), String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download#87")), Bool, Nothing, typeof(Pkg.PlatformEngines.download), String, String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download_verify#88")), Bool, Bool, Bool, typeof(Pkg.PlatformEngines.download_verify), String, Nothing, String})
precompile(Tuple{typeof(Pkg.PlatformEngines.probe_symlink_creation), String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##unpack#96")), Bool, typeof(Pkg.PlatformEngines.unpack), String, String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download_verify_unpack#101")), Nothing, Bool, Bool, Bool, Bool, typeof(Pkg.PlatformEngines.download_verify_unpack), String, Nothing, String})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("#artifact_paths##kw")), NamedTuple{(:honor_overrides,), Tuple{Bool}}, typeof(Pkg.Artifacts.artifact_paths), Base.SHA1})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("##artifact_path#10")), Bool, typeof(Pkg.Artifacts.artifact_path), Base.SHA1})
precompile(Tuple{typeof(Pkg.Artifacts.create_artifact), getfield(Pkg.Artifacts, Symbol("#39#40")){Bool, String, Nothing}})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("##download_artifact#38")), Bool, Bool, typeof(Pkg.Artifacts.download_artifact), Base.SHA1, String, Nothing})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("#43#45")){Bool, Bool, Base.SHA1}})
precompile(Tuple{typeof(Pkg.Artifacts.with_show_download_info), getfield(Pkg.Artifacts, Symbol("#43#45")){Bool, Bool, Base.SHA1}, String, Bool})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("##ensure_artifact_installed#42")), Pkg.BinaryPlatforms.Platform, Bool, Bool, typeof(Pkg.Artifacts.ensure_artifact_installed), String, Base.Dict{String, Any}, String})
precompile(Tuple{typeof(Pkg.Artifacts.artifact_path), Base.SHA1})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("##query_override#7")), Base.Dict{Symbol, Base.Dict{K, V} where V where K}, typeof(Pkg.Artifacts.query_override), Base.SHA1})
precompile(Tuple{typeof(Base.foreach), getfield(OpenBLAS_jll, Symbol("#7#9")), Tuple{Array{String, 1}}})
precompile(Tuple{typeof(Base.foreach), getfield(OpenBLAS_jll, Symbol("#8#10")), Tuple{Array{String, 1}}})
precompile(Tuple{typeof(OpenBLAS_jll.__init__)})
precompile(Tuple{typeof(Base.foreach), getfield(Arpack_jll, Symbol("#7#9")), Tuple{Array{String, 1}}})
precompile(Tuple{typeof(Base.foreach), getfield(Arpack_jll, Symbol("#8#10")), Tuple{Array{String, 1}}})
precompile(Tuple{typeof(Arpack_jll.__init__)})
precompile(Tuple{typeof(Rmath_jll.__init__)})
precompile(Tuple{typeof(Pkg.Artifacts.do_artifact_str), String, Base.Dict{String, Any}, String, Module})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("#ensure_artifact_installed##kw")), NamedTuple{(:platform,), Tuple{Pkg.BinaryPlatforms.MacOS}}, typeof(Pkg.Artifacts.ensure_artifact_installed), String, Base.Dict{String, Any}, String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("#78#79")), Base.IOStream})
precompile(Tuple{getfield(Base, Symbol("##open#270")), Base.Iterators.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:write,), Tuple{Bool}}}, typeof(Base.open), getfield(Pkg.PlatformEngines, Symbol("#78#79")), String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##get_auth_header#77")), Bool, typeof(Pkg.PlatformEngines.get_auth_header), String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("#81#86")), Base.IOStream})
precompile(Tuple{getfield(Base, Symbol("##open#270")), Base.Iterators.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:write,), Tuple{Bool}}}, typeof(Base.open), getfield(Pkg.PlatformEngines, Symbol("#81#86")), String})
precompile(Tuple{typeof(Pkg.PlatformEngines.load_telemetry_file), String})
precompile(Tuple{typeof(Pkg.PlatformEngines.get_telemetry_headers), String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download#87")), Bool, Nothing, typeof(Pkg.PlatformEngines.download), String, String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download_verify#88")), Bool, Bool, Bool, typeof(Pkg.PlatformEngines.download_verify), String, Nothing, String})
precompile(Tuple{getfield(Pkg.PlatformEngines, Symbol("##download_verify_unpack#101")), Nothing, Bool, Bool, Bool, Bool, typeof(Pkg.PlatformEngines.download_verify_unpack), String, Nothing, String})
precompile(Tuple{typeof(Pkg.Artifacts.create_artifact), getfield(Pkg.Artifacts, Symbol("#39#40")){Bool, String, Nothing}})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("##download_artifact#38")), Bool, Bool, typeof(Pkg.Artifacts.download_artifact), Base.SHA1, String, Nothing})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("#43#45")){Bool, Bool, Base.SHA1}})
precompile(Tuple{typeof(Pkg.Artifacts.with_show_download_info), getfield(Pkg.Artifacts, Symbol("#43#45")){Bool, Bool, Base.SHA1}, String, Bool})
precompile(Tuple{getfield(Pkg.Artifacts, Symbol("##ensure_artifact_installed#42")), Pkg.BinaryPlatforms.Platform, Bool, Bool, typeof(Pkg.Artifacts.ensure_artifact_installed), String, Base.Dict{String, Any}, String})
precompile(Tuple{typeof(Base.rand)})
precompile(Tuple{typeof(Base.exp), Float64})
precompile(Tuple{typeof(Base.randn), Random.MersenneTwister})
precompile(Tuple{typeof(Random.randn_unlikely), Random.MersenneTwister, Int64, Int64, Float64})
precompile(Tuple{typeof(Base.randn)})
precompile(Tuple{typeof(Random.randexp), Random.MersenneTwister})
precompile(Tuple{typeof(Random.randexp_unlikely), Random.MersenneTwister, UInt64, Float64})
precompile(Tuple{typeof(Random.randexp)})
precompile(Tuple{typeof(Rmath.__init__)})
precompile(Tuple{typeof(Base.foreach), getfield(OpenSpecFun_jll, Symbol("#7#9")), Tuple{Array{String, 1}}})
precompile(Tuple{typeof(Base.foreach), getfield(OpenSpecFun_jll, Symbol("#8#10")), Tuple{Array{String, 1}}})
precompile(Tuple{typeof(OpenSpecFun_jll.__init__)})
precompile(Tuple{typeof(ArrayInterface.__init__)})
precompile(Tuple{typeof(Requires.withpath), Any, String})
precompile(Tuple{getfield(ArrayInterface, Symbol("#15#36"))})
precompile(Tuple{typeof(Requires.withnotifications), String, Vararg{Any, N} where N})
precompile(Tuple{typeof(Revise.add_require), String, Module, String, String, Expr})
precompile(Tuple{getfield(ArrayInterface, Symbol("#16#37"))})
precompile(Tuple{typeof(Requires.err), Any, Module, String})
precompile(Tuple{getfield(ArrayInterface, Symbol("#17#38"))})
precompile(Tuple{typeof(Base.stat), Base.Libc.RawFD})
precompile(Tuple{typeof(Base.isvalid_file_crc), Base.IOStream})
precompile(Tuple{typeof(Base.stale_cachefile), String, String})
precompile(Tuple{typeof(Base._include_from_serialized), String, Array{Any, 1}})
precompile(Tuple{typeof(Base._tryrequire_from_serialized), Base.PkgId, UInt64, String})
precompile(Tuple{typeof(Base._require_search_from_serialized), Base.PkgId, String})
precompile(Tuple{typeof(Base.create_expr_cache), String, String, Array{Base.Pair{Base.PkgId, UInt64}, 1}, Nothing})
precompile(Tuple{typeof(Base.compilecache), Base.PkgId, String})
precompile(Tuple{typeof(Base._tryrequire_from_serialized), Base.PkgId, UInt64, Nothing})
precompile(Tuple{typeof(Base._require_from_serialized), String})
precompile(Tuple{typeof(Base._require), Base.PkgId})
precompile(Tuple{typeof(Base.require), Base.PkgId})
precompile(Tuple{getfield(ArrayInterface, Symbol("#18#39"))})
precompile(Tuple{getfield(ArrayInterface, Symbol("#19#40"))})
precompile(Tuple{getfield(ArrayInterface, Symbol("#20#41"))})
precompile(Tuple{getfield(Requires, Symbol("#@require")), LineNumberNode, Module, Any, Any})
precompile(Tuple{typeof(Requires.parsepkg), Expr})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{String, String}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{String, String}, Int64, Int64})
precompile(Tuple{typeof(Requires.isprecompiling)})
precompile(Tuple{typeof(FiniteDiff.__init__)})
precompile(Tuple{Type{Base.GC_Diff}, Base.GC_Num, Base.GC_Num})
precompile(Tuple{typeof(Base.getproperty), Base.GC_Diff, Symbol})
precompile(Tuple{typeof(Base.gc_alloc_count), Base.GC_Diff})
precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Int64, Int64, Base.Sort.InsertionSortAlg, Base.Order.By{getfield(Revise, Symbol("#23#24"))}})
precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Int64, Int64, Base.Sort.MergeSortAlg, Base.Order.By{getfield(Revise, Symbol("#23#24"))}, Array{String, 1}})
precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Int64, Int64, Base.Sort.InsertionSortAlg, Base.Order.ReverseOrdering{Base.Order.By{getfield(Revise, Symbol("#23#24"))}}})
precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Int64, Int64, Base.Sort.MergeSortAlg, Base.Order.ReverseOrdering{Base.Order.By{getfield(Revise, Symbol("#23#24"))}}, Array{String, 1}})
precompile(Tuple{typeof(Revise.filter_valid_cachefiles), String, Array{String, 1}})
precompile(Tuple{typeof(Revise.pkg_fileinfo), Base.PkgId})
precompile(Tuple{typeof(Base.read), Base.IOStream})
precompile(Tuple{getfield(Base, Symbol("##open#270")), Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), getfield(Base, Symbol("#279#280")){String}, String})
precompile(Tuple{typeof(Revise.parse_source!), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, String, Module})
precompile(Tuple{typeof(Base._deleteat!), Array{Tuple{Module, String}, 1}, Array{Int64, 1}})
precompile(Tuple{typeof(Revise.queue_includes!), Revise.PkgData, Base.PkgId})
precompile(Tuple{typeof(Revise.parse_pkg_files), Base.PkgId})
precompile(Tuple{typeof(Revise._watch_package), Base.PkgId})
precompile(Tuple{getfield(Revise, Symbol("#34#35")){Base.PkgId}})
precompile(Tuple{typeof(Revise.maybe_add_includes_to_pkgdata!), Revise.PkgData, String, Array{Base.Pair{Module, Array{String, 1}}, 1}})
precompile(Tuple{getfield(Revise, Symbol("#32#33")){String, Module, String, Base.PkgId}})
precompile(Tuple{typeof(Revise.skip_to_nonline), Array{Any, 1}, Int64})
precompile(Tuple{typeof(Base.isequal), Revise.LineSkippingIterator, Revise.LineSkippingIterator})
precompile(Tuple{typeof(Base.:(==)), Revise.RelocatableExpr, Revise.RelocatableExpr})
precompile(Tuple{typeof(Base.hash), Revise.LineSkippingIterator, UInt64})
precompile(Tuple{typeof(Base.hash), Revise.RelocatableExpr, UInt64})
precompile(Tuple{typeof(OrderedCollections.hashindex), Revise.RelocatableExpr, Int64})
precompile(Tuple{typeof(OrderedCollections.rehash!), OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Int64})
precompile(Tuple{typeof(OrderedCollections.ht_keyindex2), OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Revise.RelocatableExpr})
precompile(Tuple{typeof(Base.setindex!), OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Nothing, Revise.RelocatableExpr})
precompile(Tuple{typeof(Base.:(==)), Symbol, Symbol})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{QuoteNode, Int64}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{QuoteNode, Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.isequal), QuoteNode, QuoteNode})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{String, Int64}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{String, Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.:(+)), UInt64, UInt64})
precompile(Tuple{typeof(Base.hash), String, UInt64})
precompile(Tuple{typeof(Base.reinterpret), Type{Int64}, UInt64})
precompile(Tuple{typeof(OrderedCollections._setindex!), OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Nothing, Revise.RelocatableExpr, Int64})
precompile(Tuple{typeof(Base.:(!=)), Int32, Int64})
precompile(Tuple{typeof(OrderedCollections.ht_keyindex), OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}}, Module, Bool})
precompile(Tuple{getfield(Revise, Symbol("##fixpath#44")), String, String, typeof(Revise.fixpath), String})
precompile(Tuple{getfield(Revise, Symbol("##_fixpath#45")), Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Revise._fixpath), Core.LineInfoNode})
precompile(Tuple{typeof(Revise.fixpath), LineNumberNode})
precompile(Tuple{getfield(Revise, Symbol("##_fixpath#45")), Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Revise._fixpath), LineNumberNode})
precompile(Tuple{typeof(Revise._fixpath), LineNumberNode})
precompile(Tuple{getfield(Revise, Symbol("##fixpath#46")), Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Revise.fixpath), LineNumberNode})
precompile(Tuple{typeof(Revise.firstline), Expr})
precompile(Tuple{getfield(Revise, Symbol("#66#67")){OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Module, Array{String, 1}}})
precompile(Tuple{typeof(Base.CoreLogging.with_logstate), getfield(Revise, Symbol("#66#67")){OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Module, Array{String, 1}}, Base.CoreLogging.LogState})
precompile(Tuple{typeof(OrderedCollections.ht_keyindex), OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Revise.RelocatableExpr, Bool})
precompile(Tuple{typeof(Base.getkey), OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Revise.RelocatableExpr, Nothing})
precompile(Tuple{typeof(Base.CoreLogging.env_override_minlevel), String, Module})
precompile(Tuple{typeof(Base.CoreLogging.current_logger_for_env), Base.CoreLogging.LogLevel, String, Module})
precompile(Tuple{Type{Base.Dict{Union{GlobalRef, Symbol}, Nothing}}})
precompile(Tuple{Type{Base.Dict{Module, Array{Expr, 1}}}})
precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol}, Type{NamedTuple{(:define,), Tuple{Bool}}}, Type{NamedTuple{(), Tuple{}}}})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("#replace_coretypes_list!##kw")), NamedTuple{(:rev,), Tuple{Bool}}, typeof(JuliaInterpreter.replace_coretypes_list!), Array{Any, 1}})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##replace_coretypes_list!#62")), Bool, typeof(JuliaInterpreter.replace_coretypes_list!), Array{Any, 1}})
precompile(Tuple{typeof(JuliaInterpreter.compute_ssa_mapping_delete_statements!), Core.CodeInfo, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.lookup_global_refs!), Expr})
precompile(Tuple{typeof(JuliaInterpreter.optimize!), Core.CodeInfo, Module})
precompile(Tuple{typeof(JuliaInterpreter.scan_ssa_use!), Base.BitSet, Any})
precompile(Tuple{typeof(JuliaInterpreter.find_used), Core.CodeInfo})
precompile(Tuple{typeof(JuliaInterpreter.statementnumber), JuliaInterpreter.FrameCode, Int64})
precompile(Tuple{typeof(JuliaInterpreter.add_breakpoint_if_match!), JuliaInterpreter.FrameCode, JuliaInterpreter.BreakpointFileLocation})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##FrameCode#1")), Bool, Bool, Type{JuliaInterpreter.FrameCode}, Module, Core.CodeInfo})
precompile(Tuple{typeof(JuliaInterpreter.prepare_framedata), JuliaInterpreter.FrameCode, Array{Any, 1}, Core.SimpleVector, Bool})
precompile(Tuple{typeof(JuliaInterpreter.prepare_thunk), Module, Expr, Bool})
precompile(Tuple{typeof(Revise.toplevel_blocks), Core.Compiler.CFG})
precompile(Tuple{getfield(Revise, Symbol("#errorder#10")), Int64, Int64})
precompile(Tuple{typeof(Revise.add_block_dependents!), Revise.BackEdges, Core.Compiler.CFG, Base.BitArray{1}, Int64, Int64})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, Expr})
precompile(Tuple{Type{Revise.BackEdges}, Core.CodeInfo})
precompile(Tuple{typeof(Revise.toplevel_chunks), Revise.BackEdges})
precompile(Tuple{getfield(Revise, Symbol("#hastrackedexpr##kw")), NamedTuple{(:heads,), Tuple{Tuple{Symbol, Symbol, Symbol, Symbol}}}, typeof(Revise.hastrackedexpr), Core.CodeInfo})
precompile(Tuple{getfield(Revise, Symbol("##hastrackedexpr#11")), Tuple{Symbol, Symbol, Symbol, Symbol}, typeof(Revise.hastrackedexpr), Core.CodeInfo, Base.OneTo{Int64}})
precompile(Tuple{getfield(Revise, Symbol("#hastrackedexpr##kw")), NamedTuple{(:heads,), Tuple{Tuple{Symbol, Symbol, Symbol, Symbol}}}, typeof(Revise.hastrackedexpr), Core.CodeInfo, Base.OneTo{Int64}})
precompile(Tuple{getfield(Revise, Symbol("##hastrackedexpr#11")), Tuple{Symbol, Symbol, Symbol, Symbol}, typeof(Revise.hastrackedexpr), Core.CodeInfo, Base.UnitRange{Int64}})
precompile(Tuple{typeof(JuliaInterpreter.hasarg), Base.Fix2{typeof(Base.isequal), Symbol}, Array{Any, 1}})
precompile(Tuple{typeof(Revise.add_dependencies!), Revise.CodeTrackingMethodInfo, Revise.BackEdges, Core.CodeInfo, Array{Base.UnitRange{Int64}, 1}})
precompile(Tuple{typeof(Revise.minimal_evaluation!), Revise.CodeTrackingMethodInfo, JuliaInterpreter.Frame})
precompile(Tuple{typeof(JuliaInterpreter.codelocation), Core.CodeInfo, Int64})
precompile(Tuple{typeof(JuliaInterpreter.getfile), JuliaInterpreter.Frame})
precompile(Tuple{typeof(JuliaInterpreter.getfile), JuliaInterpreter.FrameCode, Int64})
precompile(Tuple{typeof(JuliaInterpreter.getfile), JuliaInterpreter.Frame, Int64})
precompile(Tuple{typeof(CodeTracking.whereis), JuliaInterpreter.FrameCode, Int64})
precompile(Tuple{typeof(Revise.trim_toplevel!), Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}})
precompile(Tuple{typeof(LoweredCodeUtils.ismethod3), JuliaInterpreter.Frame})
precompile(Tuple{typeof(LoweredCodeUtils.identify_framemethod_calls), JuliaInterpreter.Frame})
precompile(Tuple{typeof(LoweredCodeUtils.callchain), Array{NamedTuple{(:linetop, :linebody, :callee, :caller), Tuple{Int64, Int64, Symbol, Union{Bool, Symbol}}}, 1}})
precompile(Tuple{typeof(LoweredCodeUtils.replacename!), Array{Any, 1}, Base.Pair{Symbol, Nothing}})
precompile(Tuple{typeof(LoweredCodeUtils.replacename!), Array{Any, 1}, Base.Pair{Symbol, Symbol}})
precompile(Tuple{typeof(LoweredCodeUtils.rename_framemethods!), Any, JuliaInterpreter.Frame, Base.Dict{Symbol, LoweredCodeUtils.MethodInfo}, Array{NamedTuple{(:linetop, :linebody, :callee, :caller), Tuple{Int64, Int64, Symbol, Union{Bool, Symbol}}}, 1}, Base.Dict{Symbol, Union{Bool, Symbol}}})
precompile(Tuple{getfield(Revise, Symbol("##methods_by_execution!#15")), Bool, Bool, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Revise.methods_by_execution!), Any, Revise.CodeTrackingMethodInfo, Base.Dict{Module, Array{Expr, 1}}, Module, Expr})
precompile(Tuple{typeof(Base.copy), Array{Int32, 1}})
precompile(Tuple{typeof(Base.getproperty), Core.SSAValue, Symbol})
precompile(Tuple{typeof(Base.:(==)), GlobalRef, Symbol})
precompile(Tuple{typeof(Base.:(==)), QuoteNode, Symbol})
precompile(Tuple{typeof(Base.:(==)), Function, Function})
precompile(Tuple{typeof(JuliaInterpreter.extract_inner_call!), Expr, Int64, Bool})
precompile(Tuple{typeof(JuliaInterpreter.extract_inner_call!), Expr, Int64})
precompile(Tuple{typeof(Base._accumulate1!), typeof(Base.add_sum), Array{Int64, 1}, Int64, Array{Int64, 1}, Int64})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Expr, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.renumber_ssa!), Array{Any, 1}, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Core.CodeInfo, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Symbol, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), QuoteNode, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), String, Array{Int64, 1}})
precompile(Tuple{typeof(Base.isequal), Array{Any, 1}, Array{Any, 1}})
precompile(Tuple{typeof(Base.isequal), Function, Function})
precompile(Tuple{Type{Base.Dict{Symbol, Array{Int64, 1}}}})
precompile(Tuple{typeof(Base.fill!), Array{Union{Nothing, Base.Some{Any}}, 1}, Nothing})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Array{Int64, 1}, 1}, Array{Int64, 1}, Base.Generator{Base.UnitRange{Int64}, getfield(Revise, Symbol("#8#9"))}, Int64})
precompile(Tuple{typeof(Base.collect), Base.Generator{Base.UnitRange{Int64}, getfield(Revise, Symbol("#8#9"))}})
precompile(Tuple{Type{Base.Dict{Union{GlobalRef, Symbol}, Array{Int64, 1}}}})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, Core.CodeInfo})
precompile(Tuple{typeof(Base.push!), Revise.BackEdges, Base.Pair{Symbol, Int64}})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, Symbol})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Union{GlobalRef, Symbol}, Array{Int64, 1}}, Symbol})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Union{GlobalRef, Symbol}, Array{Int64, 1}}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Union{GlobalRef, Symbol}, Array{Int64, 1}}, Symbol})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Union{GlobalRef, Symbol}, Array{Int64, 1}}, Array{Int64, 1}, Symbol})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, JuliaInterpreter.SSAValue})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, String})
precompile(Tuple{typeof(Base.__subarray_throw_boundserror), Type{Base.SubArray{Bool, 1, Base.BitArray{1}, Tuple{Base.UnitRange{Int64}}, true}}, Base.BitArray{1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64, Tuple{Int64}})
precompile(Tuple{typeof(Base.fill!), Base.SubArray{Bool, 1, Base.BitArray{1}, Tuple{Base.UnitRange{Int64}}, true}, Bool})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, QuoteNode})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Function})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Symbol})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, JuliaInterpreter.SSAValue})
precompile(Tuple{typeof(Base.eltype), Array{JuliaInterpreter.AbstractBreakpoint, 1}})
precompile(Tuple{typeof(Base.getproperty), JuliaInterpreter.BreakpointRef, Symbol})
precompile(Tuple{getfield(Revise, Symbol("#16#18")), JuliaInterpreter.BreakpointRef})
precompile(Tuple{typeof(Base.foreach), getfield(Revise, Symbol("#16#18")), Array{JuliaInterpreter.BreakpointRef, 1}})
precompile(Tuple{typeof(Base.filter), getfield(Revise, Symbol("#17#19")), Array{JuliaInterpreter.BreakpointRef, 1}})
precompile(Tuple{typeof(Base.foreach), typeof(JuliaInterpreter.disable), Array{JuliaInterpreter.BreakpointRef, 1}})
precompile(Tuple{typeof(Base.merge_names), Tuple{Symbol}, Tuple{Symbol}})
precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol, Symbol}, Type{NamedTuple{(:filename,), Tuple{String}}}, Type{NamedTuple{(:extract_docexprs,), Tuple{Bool}}}})
precompile(Tuple{typeof(JuliaInterpreter.sparam_syms), Method})
precompile(Tuple{typeof(Base.error), String, Expr})
precompile(Tuple{typeof(JuliaInterpreter.lookup_expr), JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.get_return), JuliaInterpreter.Frame})
precompile(Tuple{typeof(JuliaInterpreter.show_stackloc), JuliaInterpreter.Frame})
precompile(Tuple{typeof(Base.collect), Base.Generator{Array{Any, 1}, getfield(JuliaInterpreter, Symbol("#53#54")){JuliaInterpreter.Frame}}})
precompile(Tuple{typeof(JuliaInterpreter.check_isdefined), JuliaInterpreter.Frame, Any})
precompile(Tuple{typeof(JuliaInterpreter.resolvefc), JuliaInterpreter.Frame, Any})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##collect_args#44")), Bool, typeof(JuliaInterpreter.collect_args), JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.bypass_builtins), JuliaInterpreter.Frame, Expr, Int64})
precompile(Tuple{typeof(JuliaInterpreter.getargs), Array{Any, 1}, JuliaInterpreter.Frame})
precompile(Tuple{typeof(JuliaInterpreter.maybe_evaluate_builtin), JuliaInterpreter.Frame, Expr, Bool})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##evaluate_call_compiled!#47")), Bool, typeof(JuliaInterpreter.evaluate_call_compiled!), JuliaInterpreter.Compiled, JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.step_expr!), Any, JuliaInterpreter.Frame, Bool})
precompile(Tuple{Type{JuliaInterpreter.BreakpointRef}, JuliaInterpreter.FrameCode, JuliaInterpreter.BreakpointRef, Nothing})
precompile(Tuple{Type{JuliaInterpreter.BreakpointRef}, JuliaInterpreter.FrameCode, JuliaInterpreter.BreakpointRef})
precompile(Tuple{typeof(JuliaInterpreter.finish!), Any, JuliaInterpreter.Frame, Bool})
precompile(Tuple{typeof(JuliaInterpreter.return_from), JuliaInterpreter.Frame})
precompile(Tuple{typeof(Base.indexed_iterate), JuliaInterpreter.Compiled, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), JuliaInterpreter.Compiled, Int64})
precompile(Tuple{typeof(Base._any), typeof(JuliaInterpreter.is_vararg_type), Array{Any, 1}, Base.Colon})
precompile(Tuple{typeof(JuliaInterpreter.whichtt), Any})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##prepare_call#23")), Bool, typeof(JuliaInterpreter.prepare_call), Any, Array{Any, 1}})
precompile(Tuple{typeof(Base.setproperty!), JuliaInterpreter.DispatchableMethod, Symbol, JuliaInterpreter.Compiled})
precompile(Tuple{typeof(JuliaInterpreter.scopeof), Any})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##get_call_framecode#43")), Bool, typeof(JuliaInterpreter.get_call_framecode), Array{Any, 1}, JuliaInterpreter.FrameCode, Int64})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##evaluate_call_recurse!#48")), Bool, typeof(JuliaInterpreter.evaluate_call_recurse!), Any, JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.evaluate_foreigncall), JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.evaluate_methoddef), JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.eval_rhs), Any, JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.do_assignment!), JuliaInterpreter.Frame, Any, Any})
precompile(Tuple{typeof(Base.getproperty), GlobalRef, Symbol})
precompile(Tuple{typeof(JuliaInterpreter.inplace_lookup!), Expr, Int64, JuliaInterpreter.Frame})
precompile(Tuple{typeof(JuliaInterpreter.evaluate_structtype), Any, JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.evaluate_abstracttype), Any, JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(JuliaInterpreter.evaluate_primitivetype), Any, JuliaInterpreter.Frame, Expr})
precompile(Tuple{typeof(Base.setproperty!), Nothing, Symbol, JuliaInterpreter.Frame})
precompile(Tuple{typeof(Base.setproperty!), JuliaInterpreter.Frame, Symbol, JuliaInterpreter.Frame})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##split_expressions#26")), Nothing, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(JuliaInterpreter.split_expressions), Module, Expr})
precompile(Tuple{typeof(JuliaInterpreter.step_expr!), Any, JuliaInterpreter.Frame, Any, Bool})
precompile(Tuple{typeof(LoweredCodeUtils.isanonymous_typedef), Core.CodeInfo})
precompile(Tuple{typeof(Base.to_index), JuliaInterpreter.BreakpointRef})
precompile(Tuple{typeof(Base.to_index), Array{Any, 1}, JuliaInterpreter.BreakpointRef})
precompile(Tuple{typeof(JuliaInterpreter.codelocation), Core.CodeInfo, JuliaInterpreter.BreakpointRef})
precompile(Tuple{typeof(Base.find_source_file), String})
precompile(Tuple{typeof(CodeTracking.safe_isfile), String})
precompile(Tuple{typeof(CodeTracking.replace_buildbot_stdlibpath), String})
precompile(Tuple{typeof(CodeTracking.maybe_fix_path), String})
precompile(Tuple{typeof(CodeTracking.fileline), LineNumberNode})
precompile(Tuple{typeof(CodeTracking.whereis), Method})
precompile(Tuple{typeof(CodeTracking.whereis), Core.LineInfoNode, Method})
precompile(Tuple{typeof(CodeTracking.whereis), JuliaInterpreter.FrameCode, JuliaInterpreter.BreakpointRef})
precompile(Tuple{typeof(Base.to_index), Array{Any, 1}, Nothing})
precompile(Tuple{typeof(JuliaInterpreter.pc_expr), Core.CodeInfo, Nothing})
precompile(Tuple{typeof(JuliaInterpreter.pc_expr), JuliaInterpreter.FrameCode, Nothing})
precompile(Tuple{typeof(JuliaInterpreter.pc_expr), JuliaInterpreter.Frame, Nothing})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##split_expressions#26")), Nothing, Base.Iterators.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:extract_docexprs,), Tuple{Bool}}}, typeof(JuliaInterpreter.split_expressions), Module, Expr})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Module, Array{Expr, 1}}, Module})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Module, Array{Expr, 1}}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Module, Array{Expr, 1}}, Module})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Module, Array{Expr, 1}}, Array{Expr, 1}, Module})
precompile(Tuple{typeof(Revise.add_docexpr!), Base.Dict{Module, Array{Expr, 1}}, Module, Expr})
precompile(Tuple{typeof(Base.to_index), Base.BitArray{1}, JuliaInterpreter.BreakpointRef})
precompile(Tuple{getfield(Revise, Symbol("##methods_by_execution!#20")), Bool, Bool, typeof(Revise.methods_by_execution!), Any, Revise.CodeTrackingMethodInfo, Base.Dict{Module, Array{Expr, 1}}, JuliaInterpreter.Frame, Base.BitArray{1}})
precompile(Tuple{typeof(Base.convert), Type{Union{Nothing, JuliaInterpreter.Frame}}, JuliaInterpreter.Frame})
precompile(Tuple{typeof(LoweredCodeUtils.signature), Core.SimpleVector})
precompile(Tuple{typeof(LoweredCodeUtils.signature), Any, JuliaInterpreter.Frame, Any, Int64})
precompile(Tuple{typeof(Base.setproperty!), JuliaInterpreter.Frame, Symbol, Nothing})
precompile(Tuple{typeof(JuliaInterpreter.codelocation), Core.CodeInfo, Nothing})
precompile(Tuple{typeof(LoweredCodeUtils.next_or_nothing), JuliaInterpreter.Frame, Nothing})
precompile(Tuple{typeof(LoweredCodeUtils.next_or_nothing), JuliaInterpreter.Frame, JuliaInterpreter.BreakpointRef})
precompile(Tuple{getfield(LoweredCodeUtils, Symbol("##methoddef!#3")), Bool, typeof(LoweredCodeUtils.methoddef!), Any, Array{Any, 1}, JuliaInterpreter.Frame, Any, Int64})
precompile(Tuple{getfield(LoweredCodeUtils, Symbol("#methoddef!##kw")), NamedTuple{(:define,), Tuple{Bool}}, typeof(LoweredCodeUtils.methoddef!), Function, Array{Any, 1}, JuliaInterpreter.Frame, Expr, Int64})
precompile(Tuple{typeof(LoweredCodeUtils.ismethod3), Expr})
precompile(Tuple{typeof(JuliaInterpreter.is_quotenode), Any, Any})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Module, Nothing}, Module})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("#57#58")), Int64})
precompile(Tuple{typeof(Base._collect), Array{Int64, 1}, Base.Generator{Array{Int64, 1}, getfield(JuliaInterpreter, Symbol("#57#58"))}, Base.EltypeUnknown, Base.HasShape{1}})
precompile(Tuple{typeof(Base.deleteat!), Base.BitArray{1}, Array{Int64, 1}})
precompile(Tuple{typeof(Base._deleteat!), Array{Any, 1}, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.optimize!), Core.CodeInfo, Method})
precompile(Tuple{typeof(Base.:(==)), WeakRef, Expr})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Symbol, Array{Int64, 1}}, Symbol})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Symbol, Array{Int64, 1}}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Symbol, Array{Int64, 1}}, Symbol})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Symbol, Array{Int64, 1}}, Array{Int64, 1}, Symbol})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("#extract_function_from_method#73")), Method})
precompile(Tuple{typeof(JuliaInterpreter.framecode_matches_breakpoint), JuliaInterpreter.FrameCode, JuliaInterpreter.BreakpointSignature})
precompile(Tuple{typeof(JuliaInterpreter.add_breakpoint_if_match!), JuliaInterpreter.FrameCode, JuliaInterpreter.BreakpointSignature})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##FrameCode#1")), Bool, Bool, Type{JuliaInterpreter.FrameCode}, Method, Core.CodeInfo})
precompile(Tuple{typeof(Base.rehash!), Base.Dict{Method, JuliaInterpreter.FrameCode}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Method, JuliaInterpreter.FrameCode}, Method})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Method, JuliaInterpreter.FrameCode}, JuliaInterpreter.FrameCode, Method})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Method, JuliaInterpreter.FrameCode}, Method})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Method, Nothing}, Method})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("##prepare_framecode#20")), Bool, typeof(JuliaInterpreter.prepare_framecode), Method, Any})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("#prepare_framecode##kw")), NamedTuple{(:enter_generated,), Tuple{Bool}}, typeof(JuliaInterpreter.prepare_framecode), Method, Type{T} where T})
precompile(Tuple{typeof(Base.uncompressed_ast), Method})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Nothing})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Expr})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, GlobalRef})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Core.SlotNumber})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Core.SSAValue})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Int64})
precompile(Tuple{typeof(Base.getproperty), Core.SlotNumber, Symbol})
precompile(Tuple{typeof(JuliaInterpreter.extract_inner_call!), Nothing, Int64})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), JuliaInterpreter.SlotNumber, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Int64, Array{Int64, 1}})
precompile(Tuple{typeof(Base.getindex), Array{Int64, 1}, Int64})
precompile(Tuple{typeof(Base.:(==)), Nothing, Expr})
precompile(Tuple{Type{JuliaInterpreter.DispatchableMethod}, Nothing, JuliaInterpreter.FrameInstance, Type})
precompile(Tuple{typeof(Revise.add_signature!), Revise.CodeTrackingMethodInfo, Any, Core.LineInfoNode})
precompile(Tuple{typeof(Base.setindex!), Base.IdDict{Type, Union{Base.Missing, Tuple{LineNumberNode, Expr}}}, Any, Any})
precompile(Tuple{typeof(Base.foreach), typeof(JuliaInterpreter.enable), Array{JuliaInterpreter.BreakpointRef, 1}})
precompile(Tuple{typeof(Base.setindex!), OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Array{Any, 1}}}, Array{Any, 1}, Revise.RelocatableExpr})
precompile(Tuple{typeof(Base.:(>)), Int32, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Revise.RelocatableExpr, 1}, Int32})
precompile(Tuple{typeof(Base.isequal), Revise.RelocatableExpr, Revise.RelocatableExpr})
precompile(Tuple{typeof(Base.oftype), Int64, Int32})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Int64}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.hash), Bool, UInt64})
precompile(Tuple{typeof(Base.:(==)), JuliaInterpreter.SSAValue, Symbol})
precompile(Tuple{typeof(Base.:(==)), Type{T} where T, Function})
precompile(Tuple{typeof(Base.:(==)), Expr, Function})
precompile(Tuple{typeof(JuliaInterpreter.extract_inner_call!), Core.NewvarNode, Int64})
precompile(Tuple{typeof(JuliaInterpreter.extract_inner_call!), JuliaInterpreter.SlotNumber, Int64})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Bool, Array{Int64, 1}})
precompile(Tuple{typeof(Base.:(==)), Core.NewvarNode, Expr})
precompile(Tuple{typeof(Base.isequal), Symbol, Module})
precompile(Tuple{typeof(Base.:(==)), JuliaInterpreter.SlotNumber, Expr})
precompile(Tuple{typeof(Base.isequal), Type{T} where T, Function})
precompile(Tuple{typeof(Base.isequal), QuoteNode, Module})
precompile(Tuple{typeof(Base.isequal), JuliaInterpreter.SSAValue, QuoteNode})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, Core.NewvarNode})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, QuoteNode})
precompile(Tuple{typeof(Base.getproperty), JuliaInterpreter.SlotNumber, Symbol})
precompile(Tuple{typeof(Revise.add_deps!), Array{Int64, 1}, Expr, Array{Revise.SlotDep, 1}})
precompile(Tuple{Type{Revise.SlotDep}, Int64, Expr, Array{Revise.SlotDep, 1}})
precompile(Tuple{typeof(Revise.add_deps!), Array{Int64, 1}, JuliaInterpreter.SSAValue, Array{Revise.SlotDep, 1}})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, JuliaInterpreter.SlotNumber})
precompile(Tuple{typeof(Revise.add_to_backedges!), Revise.BackEdges, Array{Revise.SlotDep, 1}, Int64, Bool})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, JuliaInterpreter.SlotNumber})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Type{T} where T})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Module})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, String})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Core.SimpleVector})
precompile(Tuple{typeof(JuliaInterpreter.static_eval), Expr})
precompile(Tuple{typeof(JuliaInterpreter.wrap_params), Expr, Array{Symbol, 1}})
precompile(Tuple{typeof(JuliaInterpreter.build_compiled_call!), Expr, Symbol, Core.CodeInfo, Int64, Int64, Array{Symbol, 1}, Module})
precompile(Tuple{typeof(Base.Iterators.zip), Core.SimpleVector, Vararg{Any, N} where N})
precompile(Tuple{Type{Base.Iterators.Zip{Is} where Is<:Tuple}, Tuple{Core.SimpleVector, Array{Any, 1}}})
precompile(Tuple{typeof(Base.map), getfield(Base.Iterators, Symbol("#3#4")), Tuple{Core.SimpleVector, Array{Any, 1}}})
precompile(Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{Core.SimpleVector, Array{Any, 1}}, Tuple{Tuple{}, Tuple{}}})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{DataType, JuliaInterpreter.SlotNumber}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{DataType, JuliaInterpreter.SlotNumber}, Int64, Int64})
precompile(Tuple{typeof(Base.iterate), Base.Iterators.Zip{Tuple{Core.SimpleVector, Array{Any, 1}}}, Tuple{Int64, Int64}})
precompile(Tuple{typeof(Base.hash), Tuple{Module, Int64}, UInt64})
precompile(Tuple{typeof(Base.hash), Tuple{Core.SimpleVector, Module, Int64}, UInt64})
precompile(Tuple{typeof(Base.hash), Tuple{DataType, Core.SimpleVector, Module, Int64}, UInt64})
precompile(Tuple{typeof(Base.hashindex), Tuple{QuoteNode, DataType, Core.SimpleVector, Module, Int64}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Any, Any}, Tuple{QuoteNode, DataType, Core.SimpleVector, Module, Int64}})
precompile(Tuple{typeof(Base.get), Base.Dict{Any, Any}, Tuple{QuoteNode, DataType, Core.SimpleVector, Module, Int64}, Nothing})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(JuliaInterpreter.parametric_type_to_expr), Core.SimpleVector})
precompile(Tuple{typeof(Base.collect), Base.Generator{Core.SimpleVector, typeof(JuliaInterpreter.parametric_type_to_expr)}})
precompile(Tuple{typeof(JuliaInterpreter.scopename), Core.TypeName})
precompile(Tuple{typeof(JuliaInterpreter.parametric_type_to_expr), Type})
precompile(Tuple{typeof(Base._array_for), Type{DataType}, Core.SimpleVector, Base.HasLength})
precompile(Tuple{typeof(Base.setindex!), Array{DataType, 1}, Type{T} where T, Int64})
precompile(Tuple{typeof(Base.collect_to!), Array{DataType, 1}, Base.Generator{Core.SimpleVector, typeof(JuliaInterpreter.parametric_type_to_expr)}, Int64, Int64})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{DataType, 1}, Type{T} where T, Base.Generator{Core.SimpleVector, typeof(JuliaInterpreter.parametric_type_to_expr)}, Int64})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Any, Any}, Tuple{QuoteNode, DataType, Core.SimpleVector, Module, Int64}})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Function, Tuple{QuoteNode, DataType, Core.SimpleVector, Module, Int64}})
precompile(Tuple{typeof(Base.parentmodule), Function})
precompile(Tuple{typeof(Base.parentmodule), DataType})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#253")), TypeVar, Type{T} where T})
precompile(Tuple{typeof(Base.invokelatest), Any})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#254"))})
precompile(Tuple{typeof(JuliaInterpreter.hasarg), getfield(JuliaInterpreter, Symbol("#21#22")), Array{Any, 1}})
precompile(Tuple{typeof(Base.getindex), Type{Symbol}, Symbol, Symbol})
precompile(Tuple{typeof(Base.getindex), Type{Symbol}, Symbol})
precompile(Tuple{typeof(Base.:(==)), Expr, Symbol})
precompile(Tuple{typeof(Base.ntuple), getfield(JuliaInterpreter, Symbol("#55#56")){JuliaInterpreter.Frame, Array{Any, 1}}, Int64})
precompile(Tuple{typeof(Base.:(==)), JuliaInterpreter.SlotNumber, Symbol})
precompile(Tuple{typeof(Base.:(==)), JuliaInterpreter.SlotNumber, Function})
precompile(Tuple{typeof(Base._append!), Array{Any, 1}, Base.HasLength, Core.SimpleVector})
precompile(Tuple{typeof(JuliaInterpreter.append_any), Any})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Nothing, Array{Int64, 1}})
precompile(Tuple{getfield(Base, Symbol("##dump#385")), Int64, typeof(Base.dump), Expr})
precompile(Tuple{typeof(JuliaInterpreter.lookup_or_eval), Any, JuliaInterpreter.Frame, Any})
precompile(Tuple{typeof(Base._array_for), Type{DataType}, Array{Any, 1}, Base.HasShape{1}})
precompile(Tuple{typeof(Base.collect_to!), Array{DataType, 1}, Base.Generator{Array{Any, 1}, getfield(JuliaInterpreter, Symbol("#53#54")){JuliaInterpreter.Frame}}, Int64, Int64})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{DataType, 1}, Type{T} where T, Base.Generator{Array{Any, 1}, getfield(JuliaInterpreter, Symbol("#53#54")){JuliaInterpreter.Frame}}, Int64})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{getfield(ArrayInterface, Symbol("#63#66"))}})
precompile(Tuple{typeof(Base.popfirst!), Array{DataType, 1}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{Any}}, Array{DataType, 1}})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Core.NewvarNode})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Base.Regex})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Array{Int64, 1}})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Char})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, UInt8})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Core.GotoNode})
precompile(Tuple{typeof(JuliaInterpreter.extract_inner_call!), QuoteNode, Int64})
precompile(Tuple{typeof(JuliaInterpreter.extract_inner_call!), Core.GotoNode, Int64})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Base.Regex, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Char, Array{Int64, 1}})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), UInt8, Array{Int64, 1}})
precompile(Tuple{typeof(Base.:(==)), QuoteNode, Expr})
precompile(Tuple{typeof(Base.:(==)), Core.GotoNode, Expr})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{DataType, JuliaInterpreter.SSAValue}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{DataType, JuliaInterpreter.SSAValue}, Int64, Int64})
precompile(Tuple{typeof(Base.getproperty), JuliaInterpreter.SSAValue, Symbol})
precompile(Tuple{typeof(Base._groupedunique!), Array{Int64, 1}})
precompile(Tuple{typeof(Base._unique!), typeof(Base.identity), Array{Int64, 1}, Base.Set{Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.unique!), Array{Int64, 1}})
precompile(Tuple{typeof(Base.collect), Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.Broadcast.dotview), Array{Int64, 1}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.getindex), Array{Int64, 1}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), Function, Array{Int64, 1}, Int64})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.:(-)), Tuple{Array{Int64, 1}, Int64}})
precompile(Tuple{typeof(Base.__subarray_throw_boundserror), Type{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64, Tuple{Int64}})
precompile(Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Int64}}, Tuple{Int64}})
precompile(Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(-)), Tuple{Array{Int64, 1}, Int64}}})
precompile(Tuple{typeof(Base._similar_for), Array{Int64, 1}, Type{Int64}, Base.Generator{Array{Int64, 1}, getfield(JuliaInterpreter, Symbol("#57#58"))}, Base.HasShape{1}})
precompile(Tuple{typeof(Base.collect_to!), Array{Int64, 1}, Base.Generator{Array{Int64, 1}, getfield(JuliaInterpreter, Symbol("#57#58"))}, Int64, Int64})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Int64, 1}, Int64, Base.Generator{Array{Int64, 1}, getfield(JuliaInterpreter, Symbol("#57#58"))}, Int64})
precompile(Tuple{typeof(Base._deleteat!), Array{Int32, 1}, Array{Int64, 1}})
precompile(Tuple{typeof(Base.deleteat!), Array{Int32, 1}, Array{Int64, 1}})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#255")), Int64})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#256")), String})
precompile(Tuple{typeof(Base.isequal), JuliaInterpreter.SlotNumber, QuoteNode})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, Bool})
precompile(Tuple{typeof(Base.isequal), JuliaInterpreter.SSAValue, Module})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#257")), String})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), Type{T} where T, Array{Int64, 1}})
precompile(Tuple{typeof(Base.:(==)), Core.SimpleVector, Core.SimpleVector})
precompile(Tuple{typeof(Base.isequal), Tuple{QuoteNode, DataType, Core.SimpleVector, Module, Int64}, Tuple{QuoteNode, DataType, Core.SimpleVector, Module, Int64}})
precompile(Tuple{typeof(Base.:(==)), Type{T} where T, Symbol})
precompile(Tuple{typeof(Base.map), getfield(JuliaInterpreter, Symbol("#59#60")), Core.SimpleVector})
precompile(Tuple{getfield(JuliaInterpreter, Symbol("#59#60")), TypeVar})
precompile(Tuple{typeof(JuliaInterpreter._scopename), Symbol})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{Base.Val{UInt8}}})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#259")), Array{UInt8, 1}, Base.Val{UInt8}})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.copyto!), Array{Any, 1}, Int64, Array{DataType, 1}, Int64, Int64})
precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{DataType, 1}, Int64, Int64})
precompile(Tuple{typeof(Base.collect_to!), Array{Any, 1}, Base.Generator{Array{Any, 1}, getfield(JuliaInterpreter, Symbol("#53#54")){JuliaInterpreter.Frame}}, Int64, Int64})
precompile(Tuple{typeof(Base.popfirst!), Array{Any, 1}})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{Base.LinearIndices{1, Tuple{Base.OneTo{Int64}}}}})
precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{DataType, 1}, Tuple{Base.OneTo{Int64}}, Int64})
precompile(Tuple{typeof(Base.isequal), JuliaInterpreter.SlotNumber, Module})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{DataType, Expr}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{DataType, Expr}, Int64, Int64})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#261")), Type{T} where T, Base.Val{UInt8}})
precompile(Tuple{Type{JuliaInterpreter.DispatchableMethod}, Nothing, JuliaInterpreter.Compiled, Type})
precompile(Tuple{typeof(Base.unsafe_store!), Ptr{UInt8}, UInt8, Int64})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#262")), Array{UInt8, 1}, UInt64})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#263")), Array{UInt8, 1}, UInt64})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#264")), Array{UInt8, 1}, UInt64})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#265")), Array{UInt8, 1}})
precompile(Tuple{typeof(JuliaInterpreter.extract_inner_call!), GlobalRef, Int64})
precompile(Tuple{typeof(Base.:(==)), GlobalRef, Expr})
precompile(Tuple{typeof(Base.something), Tuple{Symbol, String}, Expr})
precompile(Tuple{typeof(Base.hash), Tuple{Symbol, String}, UInt64})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Any, Any}, Tuple{Tuple{Symbol, String}, DataType, Core.SimpleVector, Module, Int64}})
precompile(Tuple{typeof(Base.get), Base.Dict{Any, Any}, Tuple{Tuple{Symbol, String}, DataType, Core.SimpleVector, Module, Int64}, Nothing})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{Ptr{Nothing}}})
precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{Any, Any}, Tuple{Tuple{Symbol, String}, DataType, Core.SimpleVector, Module, Int64}})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Function, Tuple{Tuple{Symbol, String}, DataType, Core.SimpleVector, Module, Int64}})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#266")), Ptr{Nothing}, Ptr{Nothing}})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#268"))})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#267")), Ptr{Nothing}, String, Int64, Int64, UInt32, Ptr{Nothing}, Ptr{Nothing}})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#269")), Ptr{Nothing}})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, UInt32})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), UInt32, Array{Int64, 1}})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{Base.UUID}})
precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{DataType, 1}, UInt128, Int64})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{Base.PkgId}})
precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{DataType, 1}, Base.UUID, Int64})
precompile(Tuple{Base.Fix2{typeof(Base.isequal), Symbol}, UInt64})
precompile(Tuple{typeof(JuliaInterpreter.replace_ssa!), UInt64, Array{Int64, 1}})
precompile(Tuple{typeof(Base.objectid), Any})
precompile(Tuple{typeof(JuliaInterpreter.append_any), Any, Vararg{Any, N} where N})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{Ptr{UInt8}}})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#270")), Ptr{UInt8}, Int64, UInt32})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{getfield(Requires, Symbol("#1#2"))}})
precompile(Tuple{getfield(JuliaInterpreter.CompiledCalls, Symbol("###compiledcall#262")), Array{Function, 1}, Int64})
precompile(Tuple{typeof(Base.convert), Type{DataType}, Type{Base.IndexLinear}})
precompile(Tuple{typeof(Base.print), String, String, String, Vararg{String, N} where N})
precompile(Tuple{typeof(Base.print), Base.TTY, String, String, Vararg{String, N} where N})
precompile(Tuple{getfield(Atom, Symbol("#229#231"))})
precompile(Tuple{typeof(REPL.ends_with_semicolon), AbstractString})
precompile(Tuple{typeof(REPL.print_response), REPL.AbstractREPL, Any, Bool, Bool})
precompile(Tuple{typeof(Base.uv_alloc_buf), Ptr{Nothing}, UInt64, Ptr{Nothing}})
precompile(Tuple{typeof(Base.uv_readcb), Ptr{Nothing}, Int64, Ptr{Nothing}})
precompile(Tuple{typeof(Atom.handlemsg), String, Array{Any, 1}})
precompile(Tuple{typeof(Base.allocatedinline), Type{Juno.LazyTree}})
precompile(Tuple{getfield(Atom, Symbol("#119#120")), Array{Any, 1}})
precompile(Tuple{typeof(JuliaInterpreter.caller), Nothing})
precompile(Tuple{typeof(Atom.JunoDebugger.active_frame), Atom.JunoDebugger.DebuggerState})
precompile(Tuple{typeof(Atom.JunoDebugger.localvars), Nothing})
precompile(Tuple{typeof(JuliaInterpreter.locals), JuliaInterpreter.Frame})
precompile(Tuple{typeof(Atom.wsitem), Module, Symbol, Any})
precompile(Tuple{typeof(Atom.JunoDebugger.localvars), JuliaInterpreter.Frame})
precompile(Tuple{typeof(Atom.JunoDebugger.contexts), Atom.JunoDebugger.DebuggerState})
precompile(Tuple{typeof(Atom.workspace), String})
precompile(Tuple{getfield(Atom, Symbol("#236#237")), String})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{String, 1}, String, Base.Generator{Array{Symbol, 1}, typeof(Base.string)}, Int64})
precompile(Tuple{typeof(Base._collect), Array{Symbol, 1}, Base.Generator{Array{Symbol, 1}, typeof(Base.string)}, Base.EltypeUnknown, Base.HasShape{1}})
precompile(Tuple{getfield(CodeTools, Symbol("#28#29")), String})
precompile(Tuple{typeof(Base.filter), getfield(CodeTools, Symbol("#28#29")), Array{String, 1}})
precompile(Tuple{getfield(Atom, Symbol("#238#240")), Symbol})
precompile(Tuple{typeof(Base.filter!), getfield(Atom, Symbol("#238#240")), Array{Symbol, 1}})
precompile(Tuple{typeof(Base.string), Module})
precompile(Tuple{typeof(Base.last), Array{Base.SubString{String}, 1}})
precompile(Tuple{typeof(Base.:(!=)), String, Base.SubString{String}})
precompile(Tuple{getfield(Atom, Symbol("#239#241")), Symbol})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Base.Dict{Any, Any}, 1}, Base.Dict{Any, Any}, Base.Generator{Array{Symbol, 1}, getfield(Atom, Symbol("#239#241"))}, Int64})
precompile(Tuple{typeof(Base._collect), Array{Symbol, 1}, Base.Generator{Array{Symbol, 1}, getfield(Atom, Symbol("#239#241"))}, Base.EltypeUnknown, Base.HasShape{1}})
precompile(Tuple{typeof(Atom.wsitem), Module, Symbol})
precompile(Tuple{typeof(CodeTools.getthing), Module, String, Atom.Undefined})
precompile(Tuple{getfield(Hiccup, Symbol("##Node#1")), Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{Hiccup.Node{tag} where tag}, Symbol, Base.Dict{Any, Any}, Array{Any, 1}})
precompile(Tuple{typeof(Media.render), Juno.Inline, Module})
precompile(Tuple{typeof(Juno.errmsg), Atom.DisplayError})
precompile(Tuple{typeof(Base.throw_boundserror), Array{Base.StackTraces.StackFrame, 1}, Tuple{Base.UnitRange{Int64}}})
precompile(Tuple{getfield(Atom, Symbol("#121#122")), Base.StackTraces.StackFrame})
precompile(Tuple{typeof(Atom.cliptrace), Array{Base.StackTraces.StackFrame, 1}})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Atom.EvalError{Atom.DisplayError}})
precompile(Tuple{getfield(DelimitedFiles, Symbol("##writedlm#14")), Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(DelimitedFiles.writedlm), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Atom.EvalError{Atom.DisplayError}, Char})
precompile(Tuple{typeof(DelimitedFiles.writedlm), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Atom.EvalError{Atom.DisplayError}, Char})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Base.Multimedia.MIME{Symbol("text/csv")}, Atom.EvalError{Atom.DisplayError}})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Base.Multimedia.MIME{Symbol("text/tab-separated-values")}, Atom.EvalError{Atom.DisplayError}})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String, Atom.EvalError{Atom.DisplayError}})
precompile(Tuple{typeof(Base.isvalid), Char})
precompile(Tuple{typeof(Atom.strlimit), String, Int64, String})
precompile(Tuple{typeof(Base.filter), typeof(Base.isvalid), String})
precompile(Tuple{typeof(Atom.defaultrepr), Atom.EvalError{Atom.DisplayError}, Bool})
precompile(Tuple{typeof(Media.render), Juno.Inline, Atom.EvalError{Atom.DisplayError}})
precompile(Tuple{typeof(Atom.render′), Juno.Inline, Module})
precompile(Tuple{typeof(Base.grow_to!), Array{Base.SubString{String}, 1}, Base.Generator{Base.RegexMatchIterator, getfield(Hiccup, Symbol("#4#6"))}, Tuple{Int64, Bool}})
precompile(Tuple{typeof(Base.grow_to!), Array{Base.SubString{String}, 1}, Base.Generator{Base.RegexMatchIterator, getfield(Hiccup, Symbol("#4#6"))}})
precompile(Tuple{typeof(Base.collect_to!), Array{Base.SubString{String}, 1}, Base.Generator{Array{Base.SubString{String}, 1}, getfield(Hiccup, Symbol("#trimfirst#5"))}, Int64, Int64})
precompile(Tuple{typeof(Base._collect), Array{Base.SubString{String}, 1}, Base.Generator{Array{Base.SubString{String}, 1}, getfield(Hiccup, Symbol("#trimfirst#5"))}, Base.EltypeUnknown, Base.HasShape{1}})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Array{Base.SubString{String}, 1}, Symbol})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.SubString{String}, Symbol})
precompile(Tuple{typeof(Hiccup.cssparse), String})
precompile(Tuple{Type{Hiccup.Node{:span}}, Base.Dict{Any, Any}, Array{Any, 1}})
precompile(Tuple{typeof(Juno.view), Hiccup.Node{:span}})
precompile(Tuple{typeof(Media.render), Juno.Inline, Hiccup.Node{:span}})
precompile(Tuple{typeof(Base._collect), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(Juno.view)}, Base.EltypeUnknown, Base.HasShape{1}})
precompile(Tuple{typeof(Juno.view), String})
precompile(Tuple{typeof(Base._similar_for), Array{Any, 1}, Type{String}, Base.Generator{Array{Any, 1}, typeof(Juno.view)}, Base.HasShape{1}})
precompile(Tuple{typeof(Base.collect_to!), Array{String, 1}, Base.Generator{Array{Any, 1}, typeof(Juno.view)}, Int64, Int64})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{String, 1}, String, Base.Generator{Array{Any, 1}, typeof(Juno.view)}, Int64})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Array{String, 1}})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Pair{Symbol, Symbol}, Vararg{Base.Pair{A, B} where B where A, N} where N})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Symbol, Symbol})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.Dict{Any, Any}, Symbol})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Array{String, 1}, Symbol})
precompile(Tuple{typeof(Atom.nativetype), Module, Symbol, Any})
precompile(Tuple{typeof(Atom.wstype), Module, Symbol, Module})
precompile(Tuple{typeof(Atom.wsicon), Module, Symbol, Module})
precompile(Tuple{typeof(Media.render), Juno.Inline, Nothing})
precompile(Tuple{typeof(Atom.render′), Juno.Inline, Nothing})
precompile(Tuple{typeof(Atom.wstype), Module, Symbol, Any})
precompile(Tuple{typeof(Atom.wsicon), Module, Symbol, Any})
precompile(Tuple{typeof(Lazy.d), Base.Pair{Symbol, String}, Vararg{Any, N} where N})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Pair{Symbol, String}, Vararg{Base.Pair{A, B} where B where A, N} where N})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Array{Base.Dict{Any, Any}, 1}, Symbol})
precompile(Tuple{typeof(JSON.Writer.show_pair), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Base.Pair{Any, Any}})
precompile(Tuple{typeof(JSON.Writer.show_json), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Base.Dict{Any, Any}})
precompile(Tuple{typeof(JSON.Writer.show_element), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Base.Dict{Any, Any}})
precompile(Tuple{typeof(JSON.Writer.show_json), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Array{Base.Dict{Any, Any}, 1}})
precompile(Tuple{typeof(JSON.Writer.show_element), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Array{Base.Dict{Any, Any}, 1}})
precompile(Tuple{typeof(JSON.Writer.show_string), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Symbol})
precompile(Tuple{typeof(JSON.Writer.show_key), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Symbol})
precompile(Tuple{typeof(JSON.Writer.show_pair), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Symbol, String})
precompile(Tuple{typeof(JSON.Writer.show_pair), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Symbol, Array{Base.Dict{Any, Any}, 1}})
precompile(Tuple{typeof(JSON.Writer.show_pair), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Symbol, Base.Dict{Any, Any}})
precompile(Tuple{typeof(JSON.Writer.show_json), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Symbol})
precompile(Tuple{typeof(JSON.Writer.show_pair), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Symbol, Symbol})
precompile(Tuple{typeof(JSON.Writer.show_string), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Base.SubString{String}})
precompile(Tuple{typeof(JSON.Writer.show_json), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Base.SubString{String}})
precompile(Tuple{typeof(JSON.Writer.show_element), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Base.SubString{String}})
precompile(Tuple{typeof(JSON.Writer.show_json), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Array{Base.SubString{String}, 1}})
precompile(Tuple{typeof(JSON.Writer.show_pair), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Symbol, Array{Base.SubString{String}, 1}})
precompile(Tuple{typeof(JSON.Writer.show_pair), JSON.Writer.CompactContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, JSON.Serializations.StandardSerialization, Symbol, Array{String, 1}})

KristofferC · 2020-04-19T20:39:18Z

Looks like a lot of things end up having to be recompiled...

IanButterworth · 2020-04-19T21:59:24Z

I tried out JuliaLang/julia#34613 rebased onto current master, to see what the inference looked like.
Not sure how helpful this is here, but I like this as a tool!

Code to get inference profile

const CC = Core.Compiler
using Base: IdSet

# count total number of nodes reachable from a given point
function edgecount(G, from, counts = IdDict{Any,Int}())
    if haskey(counts, from)
        return 0
    end
    if !CC.haskey(G, from)
        return 0
    end
    next = CC.collect(CC.getindex(G, from))
    counts[from] = 0
    counts[from] = sum(x->edgecount(G, x, counts), next) + length(next)
end

# sorted list of (node, count) for all nodes
function flat_count(G)
    nodes = CC.collect(CC.keys(G))
    sort([(n, edgecount(G, n)) for n in nodes], by = x->x[2])
end

# print a tree from the given starting point
function showtree(io, G, from, level = 0, seen = IdSet{Any}())
    for i = 1:level
        print(io, "  ")
    end
    println(io, from, " ", edgecount(G, from))
    if !in(from, seen)
        push!(seen, from)
        if CC.haskey(G, from)
            next = CC.collect(CC.getindex(G, from))
            for n in next
                showtree(io, G, n, level+1, seen)
            end
        end
    end
end

# print the "worst" path through the tree from a given point; i.e. at each
# level only follow the (not-yet-seen) link with the highest count.
function badpath(io, G, from, seen = IdSet{Any}(), count = edgecount(G, from))
    println(io, from, " ", count)
    push!(seen, from)
    if CC.haskey(G, from)
        next = filter(x->!in(x,seen), CC.collect(CC.getindex(G, from)))
        counts = map(n->edgecount(G, n), next)
        m = argmax(counts)
        badpath(io, G, next[m], seen, counts[m])
    end
end

G = CC.inference_graph;
CC.empty!(G);
CC.record_edges[] = true
using LsqFit
CC.record_edges[] = false

flatout = reverse(flat_count(G))
open("flat.txt","w") do f
    map(x->println(f, x), flatout)
end

using LoweredCodeUtils, JuliaInterpreter
open("inftree.txt", "w") do f
    showtree(f, G, Tuple{LoweredCodeUtils.var"#methoddef!##kw",NamedTuple{(:define,),Tuple{Bool}},typeof(LoweredCodeUtils.methoddef!),Function,Array{Any,1},JuliaInterpreter.Frame,Expr,Int64})
end

flat.txt - top 300

(Tuple{LoweredCodeUtils.var"#methoddef!##kw",NamedTuple{(:define,),Tuple{Bool}},typeof(methoddef!),Function,Array{Any,1},Frame,Expr,Int64}, 4916)
(Tuple{LoweredCodeUtils.var"##methoddef!#3",Bool,typeof(methoddef!),Function,Array{Any,1},Frame,Expr,Int64}, 4909)
(Tuple{Revise.var"##methods_by_execution!#20",Bool,Bool,typeof(Revise.methods_by_execution!),Any,Revise.CodeTrackingMethodInfo,Dict{Module,Array{Expr,1}},Frame,BitArray{1}}, 4807)
(Tuple{typeof(signature),Function,Frame,Expr,Int64}, 4806)
(Tuple{typeof(LoweredCodeUtils.define_anonymous),Function,Frame,Expr}, 4761)
(Tuple{typeof(JuliaInterpreter.step_expr!),Function,Frame,Expr,Bool}, 4739)
(Tuple{LoweredCodeUtils.var"#methoddef!##kw",NamedTuple{(:define,),Tuple{Bool}},typeof(methoddef!),Any,Array{Any,1},Frame,Any,Int64}, 4163)
(Tuple{LoweredCodeUtils.var"##methoddef!#3",Bool,typeof(methoddef!),Any,Array{Any,1},Frame,Any,Int64}, 4156)
(Tuple{typeof(signature),Function,Frame,Any,Int64}, 4081)
(Tuple{Atom.var"#242#243",Dict{String,Any}}, 4068)
(Tuple{typeof(LoweredCodeUtils.define_anonymous),Function,Frame,Any}, 4051)
(Tuple{typeof(JuliaInterpreter.finish!),Function,Frame,Bool}, 4038)
(Tuple{typeof(signature),Any,Frame,Any,Int64}, 4037)
(Tuple{typeof(JuliaInterpreter.step_expr!),Function,Frame,Bool}, 4033)
(Tuple{typeof(JuliaInterpreter.step_expr!),Function,Frame,Any,Bool}, 4031)
(Tuple{typeof(LoweredCodeUtils.define_anonymous),Any,Frame,Any}, 4007)
(Tuple{typeof(JuliaInterpreter.step_expr!),Any,Frame,Bool}, 3987)
(Tuple{typeof(JuliaInterpreter.step_expr!),Any,Frame,Any,Bool}, 3987)
(Tuple{typeof(JuliaInterpreter.finish!),Any,Frame,Bool}, 3987)
(Tuple{typeof(JuliaInterpreter.evaluate_structtype),Function,Frame,Expr}, 3931)
(Tuple{typeof(JuliaInterpreter.evaluate_abstracttype),Function,Frame,Expr}, 3922)
(Tuple{typeof(JuliaInterpreter.evaluate_primitivetype),Function,Frame,Expr}, 3922)
(Tuple{typeof(Atom.updateeditor),Any,Any,Any,Any}, 3916)
(Tuple{typeof(Atom.updateeditor),String,String,String,Bool}, 3915)
(Tuple{typeof(JuliaInterpreter.lookup_or_eval),Function,Frame,Any}, 3913)
(Tuple{typeof(JuliaInterpreter.eval_rhs),Any,Frame,Expr}, 3896)
(Tuple{typeof(JuliaInterpreter.eval_rhs),Function,Frame,Expr}, 3894)
(Tuple{typeof(JuliaInterpreter.evaluate_call_recurse!),Any,Frame,Expr}, 3865)
(Tuple{typeof(JuliaInterpreter.evaluate_call_recurse!),Function,Frame,Expr}, 3865)
(Tuple{JuliaInterpreter.var"##evaluate_call_recurse!#48",Bool,typeof(JuliaInterpreter.evaluate_call_recurse!),Any,Frame,Expr}, 3864)
(Tuple{JuliaInterpreter.var"##evaluate_call_recurse!#48",Bool,typeof(JuliaInterpreter.evaluate_call_recurse!),Function,Frame,Expr}, 3864)
(Tuple{typeof(JuliaInterpreter.step_expr!),typeof(JuliaInterpreter.finish_and_return!),Frame,Bool}, 3827)
(Tuple{typeof(JuliaInterpreter.step_expr!),typeof(JuliaInterpreter.finish_and_return!),Frame,Any,Bool}, 3827)
(Tuple{typeof(JuliaInterpreter.evaluate_structtype),typeof(JuliaInterpreter.finish_and_return!),Frame,Expr}, 3827)
(Tuple{typeof(JuliaInterpreter.lookup_or_eval),typeof(JuliaInterpreter.finish_and_return!),Frame,Any}, 3827)
(Tuple{typeof(JuliaInterpreter.evaluate_abstracttype),typeof(JuliaInterpreter.finish_and_return!),Frame,Expr}, 3827)
(Tuple{typeof(JuliaInterpreter.finish_and_return!),typeof(JuliaInterpreter.finish_and_return!),Frame,Bool}, 3827)
(Tuple{JuliaInterpreter.var"##evaluate_call_recurse!#48",Bool,typeof(JuliaInterpreter.evaluate_call_recurse!),typeof(JuliaInterpreter.finish_and_return!),Frame,Expr}, 3827)
(Tuple{typeof(JuliaInterpreter.evaluate_primitivetype),typeof(JuliaInterpreter.finish_and_return!),Frame,Expr}, 3827)
(Tuple{typeof(JuliaInterpreter.finish!),typeof(JuliaInterpreter.finish_and_return!),Frame,Bool}, 3827)
(Tuple{typeof(JuliaInterpreter.evaluate_call_recurse!),typeof(JuliaInterpreter.finish_and_return!),Frame,Expr}, 3827)
(Tuple{typeof(JuliaInterpreter.eval_rhs),typeof(JuliaInterpreter.finish_and_return!),Frame,Expr}, 3827)
(Tuple{typeof(Atom.updatesymbols),String,String,String}, 3604)
(Tuple{typeof(Atom.updatesymbols),Any,String,Any}, 3604)
(Tuple{typeof(Atom.collecttoplevelitems),Module,String,String}, 3447)
(Tuple{typeof(Atom._collecttoplevelitems),Module}, 3403)
(Tuple{JuliaInterpreter.var"#get_call_framecode##kw",NamedTuple{(:enter_generated,),Tuple{Bool}},typeof(JuliaInterpreter.get_call_framecode),Array{Any,1},JuliaInterpreter.FrameCode,Int64}, 3079)
(Tuple{JuliaInterpreter.var"##get_call_framecode#43",Bool,typeof(JuliaInterpreter.get_call_framecode),Array{Any,1},JuliaInterpreter.FrameCode,Int64}, 3073)
(Tuple{JuliaInterpreter.var"#prepare_call##kw",NamedTuple{(:enter_generated,),Tuple{Bool}},typeof(JuliaInterpreter.prepare_call),Any,Array{Any,1}}, 3015)
(Tuple{JuliaInterpreter.var"##prepare_call#23",Bool,typeof(JuliaInterpreter.prepare_call),Any,Array{Any,1}}, 3009)
(Tuple{JuliaInterpreter.var"#prepare_framecode##kw",NamedTuple{(:enter_generated,),Tuple{Bool}},typeof(JuliaInterpreter.prepare_framecode),Method,Any}, 2980)
(Tuple{JuliaInterpreter.var"##prepare_framecode#20",Bool,typeof(JuliaInterpreter.prepare_framecode),Method,Any}, 2973)
(Tuple{JuliaInterpreter.var"#prepare_framecode##kw",NamedTuple{(:enter_generated,),Tuple{Bool}},typeof(JuliaInterpreter.prepare_framecode),Method,Type{T} where T}, 2810)
(Tuple{JuliaInterpreter.var"##prepare_framecode#20",Bool,typeof(JuliaInterpreter.prepare_framecode),Method,Type{T} where T}, 2803)
(Tuple{Atom.var"#262#264",Dict{String,Any}}, 2744)
(Tuple{typeof(Atom._collecttoplevelitems_loaded),String,Array{String,1}}, 2675)
(Tuple{typeof(Pkg.Artifacts.do_artifact_str),String,Dict{String,Any},String,Module}, 2645)
(Tuple{typeof(Atom.withpath),Atom.var"#263#265"{_A,_B,_C,_D,_E,_F,_G} where _G where _F where _E where _D where _C where _B where _A,Any}, 2566)
(Tuple{typeof(CodeTools.withpath),Atom.var"#263#265"{_A,_B,_C,_D,_E,_F,_G} where _G where _F where _E where _D where _C where _B where _A,Any}, 2558)
(Tuple{Atom.var"#263#265"{_A,_B,_C,_D,_E,_F,_G} where _G where _F where _E where _D where _C where _B where _A}, 2532)
(Tuple{Pkg.Artifacts.var"#ensure_artifact_installed##kw",NamedTuple{(:platform,),_A} where _A<:Tuple,typeof(Pkg.Artifacts.ensure_artifact_installed),String,Dict,String}, 2532)
(Tuple{typeof(Atom.basecompletionadapter),Any,Any,Any,Any,Any,Any}, 2531)
(Tuple{Pkg.Artifacts.var"#ensure_artifact_installed##kw",NamedTuple{(:platform,),Tuple{Pkg.BinaryPlatforms.MacOS}},typeof(Pkg.Artifacts.ensure_artifact_installed),String,Dict{String,Any},String}, 2515)
(Tuple{Pkg.Artifacts.var"##ensure_artifact_installed#42",Pkg.BinaryPlatforms.Platform,Bool,Bool,typeof(Pkg.Artifacts.ensure_artifact_installed),String,Dict,String}, 2509)
(Tuple{Pkg.Artifacts.var"##ensure_artifact_installed#42",Pkg.BinaryPlatforms.Platform,Bool,Bool,typeof(Pkg.Artifacts.ensure_artifact_installed),String,Dict{String,Any},String}, 2509)
(Tuple{Pkg.Artifacts.var"##ensure_artifact_installed#42",Pkg.BinaryPlatforms.MacOS,Bool,Bool,typeof(Pkg.Artifacts.ensure_artifact_installed),String,Dict{String,Any},String}, 2509)
(Tuple{typeof(Pkg.Artifacts.with_show_download_info),Pkg.Artifacts.var"#44#46"{Bool,Bool,Base.SHA1,_A} where _A,String,Bool}, 2477)
(Tuple{Pkg.Artifacts.var"#44#46"{Bool,Bool,Base.SHA1,_A} where _A}, 2469)
(Tuple{Pkg.Artifacts.var"#download_artifact##kw",NamedTuple{(:verbose, :quiet_download),Tuple{Bool,Bool}},typeof(Pkg.Artifacts.download_artifact),Base.SHA1,String,Union{Nothing, String}}, 2466)
(Tuple{Core.var"#Type##kw",NamedTuple{(:generator,),Tuple{Bool}},Type{JuliaInterpreter.FrameCode},Method,Core.CodeInfo}, 2444)
(Tuple{JuliaInterpreter.var"##FrameCode#1",Bool,Bool,Type{JuliaInterpreter.FrameCode},Method,Core.CodeInfo}, 2437)
(Tuple{Pkg.Artifacts.var"##download_artifact#38",Bool,Bool,typeof(Pkg.Artifacts.download_artifact),Base.SHA1,String,String}, 2367)
(Tuple{typeof(Pkg.Artifacts.with_show_download_info),Pkg.Artifacts.var"#43#45"{Bool,Bool,Base.SHA1},String,Bool}, 2231)
(Tuple{Pkg.Artifacts.var"#43#45"{Bool,Bool,Base.SHA1}}, 2223)
(Tuple{Pkg.Artifacts.var"#download_artifact##kw",NamedTuple{(:verbose, :quiet_download),Tuple{Bool,Bool}},typeof(Pkg.Artifacts.download_artifact),Base.SHA1,String}, 2220)
(Tuple{Pkg.Artifacts.var"#download_artifact##kw",NamedTuple{(:verbose, :quiet_download),Tuple{Bool,Bool}},typeof(Pkg.Artifacts.download_artifact),Base.SHA1,String,Nothing}, 2219)
(Tuple{Pkg.Artifacts.var"##download_artifact#38",Bool,Bool,typeof(Pkg.Artifacts.download_artifact),Base.SHA1,String,Nothing}, 2213)
(Tuple{typeof(JuliaInterpreter.optimize!),Core.CodeInfo,Method}, 2190)
(Tuple{typeof(Pkg.Artifacts.create_artifact),Pkg.Artifacts.var"#39#40"{Bool,String,String}}, 2183)
(Tuple{Atom.var"#toplevelitems##kw",NamedTuple{(:mod,),Tuple{String}},typeof(Atom.toplevelitems),String}, 2166)
(Tuple{Atom.var"##toplevelitems#137",Base.Iterators.Pairs{Symbol,String,Tuple{Symbol},NamedTuple{(:mod,),Tuple{String}}},typeof(Atom.toplevelitems),String}, 2157)
(Tuple{typeof(CSTParser.parse),String,Bool}, 2147)
(Tuple{typeof(CSTParser.parse),CSTParser.ParseState,Bool}, 2141)
(Tuple{typeof(CSTParser.parse_local),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_unary_colon),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_if),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_string_or_cmd),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_operator_colon),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_let),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_export),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_macrocall),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.INSTANCE),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_call),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_string_or_cmd),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_return),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_operator_where),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_global),CSTParser.ParseState}, 2115)
(Tuple{CSTParser.var"##parse_parameters#6",Bool,typeof(CSTParser.parse_parameters),CSTParser.ParseState,Array{CSTParser.EXPR,1},Array{CSTParser.EXPR,1}}, 2115)
(Tuple{typeof(CSTParser.parse_imports),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_operator_dot),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_block),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_array),CSTParser.ParseState,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_primitive),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_comp_operator),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_function),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_doc),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_comma_sep),CSTParser.ParseState,Array{CSTParser.EXPR,1},Bool}, 2115)
(Tuple{typeof(CSTParser.parse_mutable),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_dot_mod),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_block),CSTParser.ParseState,Array{CSTParser.EXPR,1},Any}, 2115)
(Tuple{typeof(CSTParser.parse_abstract),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.mLITERAL),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_braces),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_paren),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_generator),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_parameters),CSTParser.ParseState,Array{CSTParser.EXPR,1},Array{CSTParser.EXPR,1}}, 2115)
(Tuple{typeof(CSTParser.parse_unary),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_compound),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_module),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_operator_eq),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_operator_anon_func),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_dot_mod),CSTParser.ParseState,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_operator_where),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_operator_power),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_expression),CSTParser.ParseState}, 2115)
(Tuple{CSTParser.var"#parse_parameters##kw",NamedTuple{(:usekw,),Tuple{Bool}},typeof(CSTParser.parse_parameters),CSTParser.ParseState,Array{CSTParser.EXPR,1}}, 2115)
(Tuple{typeof(CSTParser.parse_comma_sep),CSTParser.ParseState,Array{CSTParser.EXPR,1},Bool,Bool,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_quote),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_block),CSTParser.ParseState,Array{CSTParser.EXPR,1},Tuple{Tokenize.Tokens.Kind},Bool}, 2115)
(Tuple{typeof(CSTParser.parse_block),CSTParser.ParseState,Array{CSTParser.EXPR,1},Tuple{Tokenize.Tokens.Kind,Tokenize.Tokens.Kind,Tokenize.Tokens.Kind},Bool}, 2115)
(Tuple{typeof(CSTParser.parse_ref),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_begin),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_const),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_for),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_block),CSTParser.ParseState,Array{CSTParser.EXPR,1},Any,Bool}, 2115)
(Tuple{CSTParser.var"#parse_parameters##kw",NamedTuple{(:usekw,),Tuple{Bool}},typeof(CSTParser.parse_parameters),CSTParser.ParseState,Array{CSTParser.EXPR,1},Array{CSTParser.EXPR,1}}, 2115)
(Tuple{typeof(CSTParser.parse_do),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_while),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_block),CSTParser.ParseState,Array{CSTParser.EXPR,1},Tuple{Tokenize.Tokens.Kind,Tokenize.Tokens.Kind,Tokenize.Tokens.Kind}}, 2115)
(Tuple{typeof(CSTParser.parse_tuple),CSTParser.ParseState,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_array),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_call),CSTParser.ParseState,CSTParser.EXPR,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_try),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_iterator),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_if),CSTParser.ParseState,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_operator),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_operator_cond),CSTParser.ParseState,CSTParser.EXPR,CSTParser.EXPR}, 2115)
(Tuple{typeof(CSTParser.parse_kw),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_struct),CSTParser.ParseState,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_macro),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_iterators),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_iterators),CSTParser.ParseState,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_barray),CSTParser.ParseState}, 2115)
(Tuple{typeof(CSTParser.parse_string_or_cmd),CSTParser.ParseState,Bool}, 2115)
(Tuple{typeof(CSTParser.parse_block),CSTParser.ParseState,Array{CSTParser.EXPR,1}}, 2115)
(Tuple{Revise.var"#92#93"{Atom.var"#184#185"},Dict{String,Any}}, 2078)
(Tuple{typeof(Pkg.Artifacts.create_artifact),Pkg.Artifacts.var"#39#40"{Bool,String,Nothing}}, 2029)
(Tuple{Pkg.Artifacts.var"#39#40"{Bool,String,String},String}, 1921)
(Tuple{typeof(REPL.REPLCompletions.completions),Any,Any,Module}, 1921)
(Tuple{Pkg.PlatformEngines.var"#download_verify_unpack##kw",NamedTuple{(:ignore_existence, :verbose),Tuple{Bool,Bool}},typeof(Pkg.PlatformEngines.download_verify_unpack),String,String,String}, 1918)
(Tuple{Pkg.PlatformEngines.var"##download_verify_unpack#106",Nothing,Bool,Bool,Bool,Bool,typeof(Pkg.PlatformEngines.download_verify_unpack),String,String,String}, 1912)
(Tuple{typeof(revise)}, 1842)
(Tuple{Pkg.Artifacts.var"#39#40"{Bool,String,Nothing},String}, 1767)
(Tuple{Pkg.PlatformEngines.var"#download_verify_unpack##kw",NamedTuple{(:ignore_existence, :verbose),Tuple{Bool,Bool}},typeof(Pkg.PlatformEngines.download_verify_unpack),String,Nothing,String}, 1764)
(Tuple{Pkg.PlatformEngines.var"##download_verify_unpack#106",Nothing,Bool,Bool,Bool,Bool,typeof(Pkg.PlatformEngines.download_verify_unpack),String,Nothing,String}, 1758)
(Tuple{typeof(JuliaInterpreter.build_compiled_call!),Any,Core.IntrinsicFunction,Core.CodeInfo,Int64,Any,Any,Module}, 1614)
(Tuple{typeof(JuliaInterpreter.build_compiled_call!),Any,Symbol,Core.CodeInfo,Int64,Any,Any,Module}, 1614)
(Tuple{Pkg.PlatformEngines.var"#download_verify##kw",NamedTuple{(:force, :verbose, :quiet_download),Tuple{Bool,Bool,Bool}},typeof(Pkg.PlatformEngines.download_verify),String,String,String}, 1613)
(Tuple{Pkg.PlatformEngines.var"##download_verify#93",Bool,Bool,Bool,typeof(Pkg.PlatformEngines.download_verify),String,String,String}, 1607)
(Tuple{typeof(JuliaInterpreter.build_compiled_call!),Expr,Symbol,Core.CodeInfo,Int64,Int64,Array{Symbol,1},Module}, 1546)
(Tuple{Pkg.PlatformEngines.var"#download_verify##kw",NamedTuple{(:force, :verbose, :quiet_download),Tuple{Bool,Bool,Bool}},typeof(Pkg.PlatformEngines.download_verify),String,Nothing,String}, 1458)
(Tuple{Pkg.PlatformEngines.var"##download_verify#93",Bool,Bool,Bool,typeof(Pkg.PlatformEngines.download_verify),String,Nothing,String}, 1452)
(Tuple{Pkg.PlatformEngines.var"#download##kw",NamedTuple{(:verbose,),Tuple{Bool}},typeof(Pkg.PlatformEngines.download),String,String}, 1438)
(Tuple{Pkg.PlatformEngines.var"##download#92",Bool,Nothing,typeof(Pkg.PlatformEngines.download),String,String}, 1432)
(Tuple{typeof(Pkg.PlatformEngines.get_telemetry_headers),String}, 1289)
(Tuple{typeof(JuliaInterpreter.step_expr!),Compiled,Frame}, 1178)
(Tuple{typeof(JuliaInterpreter.finish!),Compiled,Frame,Bool}, 1177)
(Tuple{typeof(JuliaInterpreter.step_expr!),Compiled,Frame,Bool}, 1177)
(Tuple{typeof(JuliaInterpreter.step_expr!),Compiled,Frame,Any,Bool}, 1177)
(Tuple{typeof(Pkg.PlatformEngines.load_telemetry_file),String}, 1130)
(Tuple{typeof(Revise.handle_deletions),Revise.PkgData,String}, 1083)
(Tuple{typeof(CodeTools.withpath),Atom.var"#263#265"{String,String,String,Int64,Int64,Int64,Bool},String}, 954)
(Tuple{Revise.var"#34#35"{Base.PkgId}}, 928)
(Tuple{typeof(Revise._watch_package),Base.PkgId}, 927)
(Tuple{Atom.var"#263#265"{String,String,String,Int64,Int64,Int64,Bool}}, 927)
(Tuple{typeof(Atom.basecompletionadapter),String,String,String,Int64,Int64,Bool}, 925)
(Tuple{typeof(Base.require),Module,Symbol}, 922)
(Tuple{typeof(Revise.maybe_parse_from_cache!),Revise.PkgData,String}, 918)
(Tuple{typeof(Revise.parse_pkg_files),Base.PkgId}, 907)
(Tuple{Pkg.PlatformEngines.var"##handle_auth_error#77",Bool,typeof(Pkg.PlatformEngines.handle_auth_error),String,String}, 887)
(Tuple{Pkg.PlatformEngines.var"#get_auth_header##kw",NamedTuple{(:verbose,),Tuple{Bool}},typeof(Pkg.PlatformEngines.get_auth_header),String}, 887)
(Tuple{Pkg.PlatformEngines.var"#handle_auth_error##kw",NamedTuple{(:verbose,),Tuple{Bool}},typeof(Pkg.PlatformEngines.handle_auth_error),String,String}, 887)
(Tuple{Pkg.PlatformEngines.var"##get_auth_header#82",Bool,typeof(Pkg.PlatformEngines.get_auth_header),String}, 887)
(Tuple{Revise.var"#32#33"{String,Module,String,Base.PkgId}}, 875)
(Tuple{typeof(Base.require),Base.PkgId}, 870)
(Tuple{typeof(Base._require),Base.PkgId}, 863)
(Tuple{typeof(Revise.add_definitions_from_repl),String}, 827)
(Tuple{typeof(repr),Expr}, 799)
(Tuple{Base.var"##repr#353",Nothing,typeof(repr),Expr}, 798)
(Tuple{Base.var"#sprint##kw",NamedTuple{(:context,),Tuple{Nothing}},typeof(sprint),typeof(show),Expr}, 796)
(Tuple{Base.var"##sprint#352",Nothing,Int64,typeof(sprint),typeof(show),Expr}, 790)
(Tuple{typeof(show),Base.GenericIOBuffer{Array{UInt8,1}},Expr}, 784)
(Tuple{typeof(Base.show_unquoted_quote_expr),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},Expr,Int64,Int64,Int64}, 775)
(Tuple{typeof(Base.show_block),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},String,Expr,Int64,Int64}, 768)
(Tuple{typeof(Base.show_block),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},String,Array{Any,1},Expr,Int64,Int64}, 766)
(Tuple{typeof(Base.show_list),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},Array{Any,1},String,Int64,Int64,Int64,Bool}, 750)
(Tuple{typeof(Base.show_list),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},Array{Any,1},String,Int64,Int64,Int64,Bool,Bool}, 750)
(Tuple{typeof(Base.show_list),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},Array{Any,1},String,Int64,Int64,Int64}, 750)
(Tuple{typeof(Base.show_unquoted),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},Expr,Int64,Int64,Int64}, 750)
(Tuple{typeof(Base.show_import_path),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},Any,Int64}, 750)
(Tuple{typeof(Base.show_generator),IOContext{Base.GenericIOBuffer{Array{UInt8,1}}},Expr,Int64,Int64}, 750)
(Tuple{typeof(REPL.REPLCompletions.complete_symbol),Any,REPL.REPLCompletions.var"#22#26",Module}, 695)
(Tuple{typeof(REPL.REPLCompletions.complete_symbol),Any,REPL.REPLCompletions.var"#21#25",Module}, 695)
(Tuple{Type{OrderedCollections.OrderedDict{Module,OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}}}},Pair}, 644)
(Tuple{Type{OrderedCollections.OrderedDict{Module,OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}}}},Any}, 643)
(Tuple{typeof(setindex!),OrderedCollections.OrderedDict{Module,OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}}},Any,Any}, 641)
(Tuple{typeof(Revise.queue_includes),Module}, 630)
(Tuple{typeof(Revise.queue_includes!),Revise.PkgData,Base.PkgId}, 619)
(Tuple{typeof(setindex!),OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}},Array{Any,1},Revise.RelocatableExpr}, 614)
(Tuple{typeof(Revise.maybe_add_includes_to_pkgdata!),Revise.PkgData,String,Array{Pair{Module,Array{String,1}},1}}, 611)
(Tuple{typeof(convert),Type{OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}}},AbstractDict}, 608)
(Tuple{typeof(Base.compilecache),Base.PkgId,String}, 606)
(Tuple{typeof(REPL.REPLCompletions.completions),String,Int64,Module}, 605)
(Tuple{typeof(Rmath.__init__)}, 603)
(Tuple{typeof(Atom._collecttoplevelitems_static),String,String}, 602)
(Tuple{typeof(Atom._collecttoplevelitems_static),Nothing,String,String}, 602)
(Tuple{typeof(Atom._collecttoplevelitems_static),String,String,Dict{String,Array{Atom.GotoItem,1}}}, 592)
(Tuple{typeof(Atom._collecttoplevelitems_static),Nothing,String,String,Dict{String,Array{Atom.GotoItem,1}}}, 592)
(Tuple{Atom.var"##_collecttoplevelitems_static#289",Bool,typeof(Atom._collecttoplevelitems_static),Nothing,String,String,Dict{String,Array{Atom.GotoItem,1}}}, 591)
(Tuple{Atom.var"##_collecttoplevelitems_static#289",Bool,typeof(Atom._collecttoplevelitems_static),String,String,String,Dict{String,Array{Atom.GotoItem,1}}}, 591)
(Tuple{Atom.var"##_collecttoplevelitems_static#288",Bool,typeof(Atom._collecttoplevelitems_static),Nothing,String,Dict{String,Array{Atom.GotoItem,1}}}, 591)
(Tuple{Atom.var"##_collecttoplevelitems_static#288",Bool,typeof(Atom._collecttoplevelitems_static),String,String,Dict{String,Array{Atom.GotoItem,1}}}, 591)
(Tuple{Atom.var"#_collecttoplevelitems_static##kw",NamedTuple{(:inmod,),Tuple{Bool}},typeof(Atom._collecttoplevelitems_static),String,String,Dict{String,Array{Atom.GotoItem,1}}}, 591)
(Tuple{Atom.var"#_collecttoplevelitems_static##kw",NamedTuple{(:inmod,),Tuple{Bool}},typeof(Atom._collecttoplevelitems_static),Nothing,String,String,Dict{String,Array{Atom.GotoItem,1}}}, 591)
(Tuple{Atom.var"#_collecttoplevelitems_static##kw",NamedTuple{(:inmod,),Tuple{Bool}},typeof(Atom._collecttoplevelitems_static),String,String,String,Dict{String,Array{Atom.GotoItem,1}}}, 591)
(Tuple{Atom.var"#_collecttoplevelitems_static##kw",NamedTuple{(:inmod,),Tuple{Bool}},typeof(Atom._collecttoplevelitems_static),Nothing,String,Dict{String,Array{Atom.GotoItem,1}}}, 591)
(Tuple{Pkg.PlatformEngines.var"#unpack##kw",NamedTuple{(:verbose,),Tuple{Bool}},typeof(Pkg.PlatformEngines.unpack),String,String}, 571)
(Tuple{Pkg.PlatformEngines.var"##unpack#101",Bool,typeof(Pkg.PlatformEngines.unpack),String,String}, 565)
(Tuple{typeof(Pkg.PlatformEngines.probe_platform_engines!)}, 554)
(Tuple{Pkg.PlatformEngines.var"##probe_platform_engines!#14",Bool,typeof(Pkg.PlatformEngines.probe_platform_engines!)}, 553)
(Tuple{typeof(setindex!),OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}},Nothing,Revise.RelocatableExpr}, 549)
(Tuple{typeof(Random.randexp)}, 548)
(Tuple{typeof(randn)}, 546)
(Tuple{JuliaInterpreter.var"#split_expressions##kw",NamedTuple{(:extract_docexprs,),Tuple{Bool}},typeof(JuliaInterpreter.split_expressions),Module,Expr}, 512)
(Tuple{JuliaInterpreter.var"##split_expressions#26",Nothing,Base.Iterators.Pairs{Symbol,Bool,Tuple{Symbol},NamedTuple{(:extract_docexprs,),Tuple{Bool}}},typeof(JuliaInterpreter.split_expressions),Module,Expr}, 507)
(Tuple{typeof(JuliaInterpreter.split_expressions),Module,Expr}, 503)
(Tuple{JuliaInterpreter.var"##split_expressions#26",Nothing,Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(JuliaInterpreter.split_expressions),Module,Expr}, 500)
(Tuple{typeof(vcat),String,Any}, 495)
(Tuple{Base.var"#cat##kw",NamedTuple{(:dims,),Tuple{Val{1}}},typeof(cat),String,Any}, 493)
(Tuple{typeof(setindex!),OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}},Any,Revise.RelocatableExpr}, 492)
(Tuple{Base.var"##cat#110",Val{1},typeof(cat),String,Any}, 487)
(Tuple{typeof(repr),Frame}, 486)
(Tuple{typeof(Base._cat),Val{1},String,Any}, 486)
(Tuple{Base.var"##repr#353",Nothing,typeof(repr),Frame}, 485)
(Tuple{Base.var"#sprint##kw",NamedTuple{(:context,),Tuple{Nothing}},typeof(sprint),typeof(show),Frame}, 483)
(Tuple{typeof(CodeTracking.whereis),JuliaInterpreter.FrameCode,BreakpointRef}, 482)
(Tuple{Base.var"##sprint#352",Nothing,Int64,typeof(sprint),typeof(show),Frame}, 477)
(Tuple{Base.var"#cat_t##kw",NamedTuple{(:dims,),Tuple{Val{1}}},typeof(Base.cat_t),Type{S} where S,String,Any}, 474)
(Tuple{typeof(show),Base.GenericIOBuffer{Array{UInt8,1}},Frame}, 471)
(Tuple{Base.var"##cat_t#109",Val{1},typeof(Base.cat_t),Type{S} where S,String,Any}, 468)
(Tuple{typeof(Base._cat_t),Val{1},Type{S} where S,String,Any}, 467)
(Tuple{Base.var"#rsplit##kw",NamedTuple{(:limit,),Tuple{Int64}},typeof(rsplit),T,String} where T<:AbstractString, 466)
(Tuple{typeof(Revise.pkg_fileinfo),Base.PkgId}, 463)
(Tuple{Base.var"##rsplit#344",Int64,Bool,typeof(rsplit),AbstractString,String}, 460)
(Tuple{typeof(Base._rsplit),AbstractString,String,Int64,Bool,Array{_A,1} where _A}, 457)
(Tuple{Type{Dict{Pkg.BinaryPlatforms.Platform,Dict{String,Any}}},Base.Generator{Array{Dict{String,Any},1},Pkg.Artifacts.var"#21#22"{String,String}}}, 454)
(Tuple{JuliaInterpreter.var"#split_expressions!##kw",NamedTuple{(:filename,),_A} where _A<:Tuple,typeof(JuliaInterpreter.split_expressions!),Array{Tuple{Module,Expr},1},Dict{Module,Array{Expr,1}},Module,Expr}, 451)
(Tuple{typeof(setindex!),OrderedCollections.OrderedDict{Revise.RelocatableExpr,Union{Nothing, Array{Any,1}}},Nothing,Any}, 451)
(Tuple{JuliaInterpreter.var"#split_expressions!##kw",NamedTuple{(:filename, :extract_docexprs),_A} where _A<:Tuple,typeof(JuliaInterpreter.split_expressions!),Array{Tuple{Module,Expr},1},Dict{Module,Array{Expr,1}},Module,Expr}, 451)
(Tuple{typeof(iterate),Base.Generator{Array{Dict{String,Any},1},Pkg.Artifacts.var"#21#22"{String,String}}}, 441)
(Tuple{typeof(iterate),Base.Generator{Array{Dict{String,Any},1},Pkg.Artifacts.var"#21#22"{String,String}},Int64}, 441)
(Tuple{JuliaInterpreter.var"##split_expressions!#27",Base.Iterators.Pairs{Symbol,_A,Tuple{Symbol},_B} where _B where _A,typeof(JuliaInterpreter.split_expressions!),Array{Tuple{Module,Expr},1},Dict{Module,Array{Expr,1}},Module,Expr}, 440)
(Tuple{JuliaInterpreter.var"##split_expressions!#27",Base.Iterators.Pairs{Symbol,_A,Tuple{Symbol,Symbol},_B} where _B where _A,typeof(JuliaInterpreter.split_expressions!),Array{Tuple{Module,Expr},1},Dict{Module,Array{Expr,1}},Module,Expr}, 440)
(Tuple{Pkg.Artifacts.var"#21#22"{String,String},Dict{String,Any}}, 437)
(Tuple{Pkg.Artifacts.var"##query_override#7",Dict{Symbol,Dict},typeof(Pkg.Artifacts.query_override),Base.SHA1}, 437)
(Tuple{typeof(Atom.render′),Juno.Inline,Core.Compiler.IdDict{Any,Core.Compiler.IdSet{Any}}}, 436)
(Tuple{typeof(Pkg.Artifacts.unpack_platform),Dict{String,Any},String,String}, 435)
(Tuple{Pkg.Artifacts.var"#artifact_path##kw",NamedTuple{(:honor_overrides,),Tuple{Bool}},typeof(Pkg.Artifacts.artifact_path),Base.SHA1}, 433)
(Tuple{typeof(rand)}, 433)
(Tuple{typeof(Pkg.Artifacts.artifact_exists),Base.SHA1}, 433)
(Tuple{Pkg.Artifacts.var"##artifact_exists#11",Bool,typeof(Pkg.Artifacts.artifact_exists),Base.SHA1}, 432)
(Tuple{typeof(Random.randstring),Int64}, 430)
(Tuple{Pkg.Artifacts.var"##artifact_paths#9",Bool,typeof(Pkg.Artifacts.artifact_paths),Base.SHA1}, 427)
(Tuple{Pkg.Artifacts.var"##query_override#7",Dict,typeof(Pkg.Artifacts.query_override),Base.SHA1}, 427)
(Tuple{Pkg.Artifacts.var"#artifact_paths##kw",NamedTuple{(:honor_overrides,),Tuple{Bool}},typeof(Pkg.Artifacts.artifact_paths),Base.SHA1}, 427)
(Tuple{typeof(Pkg.Artifacts.artifact_path),Base.SHA1}, 427)
(Tuple{typeof(Pkg.Artifacts.query_override),Base.SHA1}, 427)
(Tuple{typeof(Pkg.Artifacts.map_override_path),Base.SHA1}, 427)
(Tuple{Pkg.Artifacts.var"##artifact_path#10",Bool,typeof(Pkg.Artifacts.artifact_path),Base.SHA1}, 427)
(Tuple{typeof(Base._require_from_serialized),String}, 423)
(Tuple{typeof(UUIDs.uuid4)}, 420)
(Tuple{typeof(Random.default_rng)}, 417)
(Tuple{typeof(Random.default_rng),Int64}, 414)
(Tuple{typeof(Pkg.Artifacts.process_overrides),Dict{String,Any},Base.UUID}, 412)
(Tuple{Type{Random.MersenneTwister}}, 406)
(Tuple{Type{Random.MersenneTwister},Nothing}, 405)
(Tuple{Pkg.PlatformEngines.var"#verify##kw",NamedTuple{(:verbose,),Tuple{Bool}},typeof(Pkg.PlatformEngines.verify),String,String}, 403)
(Tuple{typeof(Atom.displayandrender),Bool}, 402)
(Tuple{typeof(Random.seed!),Random.MersenneTwister,Nothing}, 401)
(Tuple{typeof(Pkg.Artifacts.load_overrides)}, 401)

inftree.txt for the most inference creating call, truncated

Tuple{LoweredCodeUtils.var"#methoddef!##kw",NamedTuple{(:define,),Tuple{Bool}},typeof(methoddef!),Function,Array{Any,1},Frame,Expr,Int64} 4916
  Tuple{LoweredCodeUtils.var"##methoddef!#3",Bool,typeof(methoddef!),Function,Array{Any,1},Frame,Expr,Int64} 4909
    Tuple{typeof(LoweredCodeUtils.ismethod3),Expr} 0
    Tuple{typeof(Base.Meta.isexpr),Any,Symbol,Int64} 0
    Tuple{typeof(Base.indexed_iterate),Tuple{Any,Union{Nothing, Int64, BreakpointRef}},Int64,Int64} 1
      Tuple{typeof(+),Int64,Int64} 0
    Tuple{typeof(error),String} 0
    Tuple{typeof(error),String,Expr} 2
      Tuple{Type{ErrorException},AbstractString} 0
      Tuple{Type{ErrorException},Any} 0
    Tuple{typeof(!),Function} 0
    Tuple{typeof(signature),Function,Frame,Any,Nothing} 0
    Tuple{typeof(!),Missing} 0
    Tuple{typeof(LoweredCodeUtils.next_or_nothing),Frame,BreakpointRef} 0
    Tuple{typeof(setproperty!),Frame,Symbol,Nothing} 1
      Tuple{typeof(convert),Type{Union{Nothing, Frame}},Nothing} 0
    Tuple{typeof(LoweredCodeUtils.next_or_nothing),Frame,Nothing} 0
    Tuple{typeof(JuliaInterpreter.codelocation),Core.CodeInfo,Nothing} 11
      Tuple{typeof(getindex),Array{Any,1},Nothing} 9
        Tuple{typeof(to_indices),Array{Any,1},Tuple{Nothing}} 6
          Tuple{typeof(to_indices),Array{Any,1},Tuple{Base.OneTo{Int64}},Tuple{Nothing}} 3
            Tuple{typeof(getindex),Tuple{Nothing},Int64} 0
            Tuple{typeof(Base.to_index),Array{Any,1},Nothing} 1
              Tuple{typeof(Base.to_index),Nothing} 0
          Tuple{Type{IndexLinear}} 0
          Tuple{typeof(eachindex),IndexLinear,Array{Any,1}} 0
        Tuple{typeof(Base.error_if_canonical_getindex),IndexLinear,Array{Any,1},Nothing} 0
        Tuple{Type{IndexStyle},Array{Any,1}} 0
      Tuple{typeof(getproperty),Core.CodeInfo,Symbol} 0
    Tuple{typeof(string),String,Union{Char, SubString{String}, String},String,Union{Char, SubString{String}, String},String,Union{Char, SubString{String}, String}} 67
      Tuple{typeof(iterate),Tuple{String,Union{Char, SubString{String}, String},String,Union{Char, SubString{String}, String},String,Union{Char, SubString{String}, String}},Int64} 4
        Tuple{typeof(<=),Int64,Int64} 0
        Tuple{typeof(getindex),Tuple{String,Union{Char, SubString{String}, String},String,Union{Char, SubString{String}, String},String,Union{Char, SubString{String}, String}},Int64} 0
        Tuple{typeof(length),Tuple{String,Union{Char, SubString{String}, String},String,Union{Char, SubString{String}, String},String,Union{Char, SubString{String}, String}}} 0
        Tuple{typeof(+),Int64,Int64} 0
      Tuple{typeof(sizeof),String} 0
      Tuple{typeof(ncodeunits),Char} 31
        Tuple{typeof(write),Base.DevNull,Char} 30
          Tuple{typeof(reinterpret),Type{UInt32},Char} 0
          Tuple{typeof(write),Base.DevNull,UInt8} 0
          Tuple{typeof(bswap),UInt32} 0
          Tuple{typeof(rem),UInt32,Type{UInt8}} 0
          Tuple{typeof(>>),UInt32,Int64} 6
            Tuple{typeof(<=),Int64,Int64} 0
            Tuple{typeof(unsigned),Int64} 1
              Tuple{typeof(reinterpret),Type{UInt64},Int64} 0
            Tuple{typeof(>>),UInt32,UInt64} 0
            Tuple{typeof(<<),UInt32,UInt64} 0
            Tuple{typeof(-),Int64} 0
          Tuple{typeof(==),UInt32,Int64} 19
            Tuple{typeof(unsigned),Int64} 1
            Tuple{typeof(==),UInt32,UInt64} 13
              Tuple{typeof(==),UInt64,UInt64} 0
              Tuple{typeof(promote),UInt32,UInt64} 11
                Tuple{typeof(Base._promote),UInt32,UInt64} 5
                  Tuple{typeof(convert),Type{UInt64},UInt32} 2
                    Tuple{Type{UInt64},UInt32} 1
                      Tuple{typeof(Core.toUInt64),UInt32} 0
                  Tuple{typeof(convert),Type{UInt64},UInt64} 0
                  Tuple{typeof(promote_type),Type{UInt32},Type{UInt64}} 0
                Tuple{typeof(Base.not_sametype),Tuple{UInt32,UInt64},Tuple{UInt64,UInt64}} 0

IanButterworth · 2022-06-10T14:50:08Z

Closing as stale and it's probably fair to say that many things including speed has improved since 1.4.1 so this is unlikely to be needed anymore.

skip read-only packages

3ea6626

IanButterworth mentioned this pull request Apr 17, 2020

Slowdown in package load times #456

Closed

timholy referenced this pull request in JuliaLang/julia Apr 17, 2020

make sure stale_cachefile is precompiled

628525e

timholy referenced this pull request in JuliaLang/julia Apr 17, 2020

Add more pkg-related precompile statements

7304998

IanButterworth closed this Jun 10, 2022

IanButterworth deleted the skip_non_deved branch June 10, 2022 14:50

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Trial at skipping read-only packages (packages in .julia/packages) #457

Trial at skipping read-only packages (packages in .julia/packages) #457

IanButterworth commented Apr 17, 2020

timholy commented Apr 17, 2020

IanButterworth commented Apr 17, 2020

timholy commented Apr 17, 2020

KristofferC commented Apr 17, 2020

timholy commented Apr 17, 2020

IanButterworth commented Apr 17, 2020 •

edited

Loading

timholy commented Apr 17, 2020

IanButterworth commented Apr 17, 2020

timholy commented Apr 17, 2020

IanButterworth commented Apr 17, 2020 •

edited

Loading

IanButterworth commented Apr 18, 2020

IanButterworth commented Apr 19, 2020

KristofferC commented Apr 19, 2020

IanButterworth commented Apr 19, 2020

KristofferC commented Apr 19, 2020

IanButterworth commented Apr 19, 2020

IanButterworth commented Jun 10, 2022

Trial at skipping read-only packages (packages in .julia/packages) #457

Trial at skipping read-only packages (packages in .julia/packages) #457

Conversation

IanButterworth commented Apr 17, 2020

timholy commented Apr 17, 2020

IanButterworth commented Apr 17, 2020

timholy commented Apr 17, 2020

KristofferC commented Apr 17, 2020

timholy commented Apr 17, 2020

IanButterworth commented Apr 17, 2020 • edited Loading

timholy commented Apr 17, 2020

IanButterworth commented Apr 17, 2020

timholy commented Apr 17, 2020

IanButterworth commented Apr 17, 2020 • edited Loading

IanButterworth commented Apr 18, 2020

IanButterworth commented Apr 19, 2020

KristofferC commented Apr 19, 2020

IanButterworth commented Apr 19, 2020

KristofferC commented Apr 19, 2020

IanButterworth commented Apr 19, 2020

IanButterworth commented Jun 10, 2022

IanButterworth commented Apr 17, 2020 •

edited

Loading

IanButterworth commented Apr 17, 2020 •

edited

Loading