text:
precompile(Tuple{Pkg3.Display.InProject{Base.Dict{String, Any}}, String, Base.Dict{String, Any}})
precompile(Tuple{Type{Array{Array{T, 1} where T, 1}}, UndefInitializer, Int64})
precompile(Tuple{Type{Base.Dict{K, V} where V where K}, Base.Pair{String, Base.VersionNumber}, Base.Pair{String, Base.VersionNumber}})
precompile(Tuple{Type{Base.Dict{K, V} where V where K}, Base.Pair{String, Base.VersionNumber}})
precompile(Tuple{Type{Base.Dict{String, Any}}, Base.Pair{String, String}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, Type{Base.UUID}, Base.ValueIterator{Base.Dict{Any, Any}}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, Any}}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, String}}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.close), Array{LibGit2.GitAnnotated, 1}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Pkg3.TOML.table2dict), Array{Any, 1}})
precompile(Tuple{Type{Base.GenericIOBuffer{Array{UInt8, 1}}}, Array{UInt8, 1}})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Base.UUID, Int64})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Base.UUID, Pkg3.Types.VersionSpec})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Base.VersionNumber, Base.SHA1})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Int64, Int64})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, String, Base.UUID})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, String, Base.VersionNumber})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Tuple{Base.UUID, Base.VersionNumber}, Int64})
precompile(Tuple{Type{Base.SHA1}, Base.SubString{String}})
precompile(Tuple{Type{Base.SHA1}, String})
precompile(Tuple{Type{Expr}, Symbol, Expr, Symbol, Float64})
precompile(Tuple{Type{Expr}, Symbol, Expr, Symbol, String})
precompile(Tuple{Type{Expr}, Symbol, Expr, Symbol, Symbol, Symbol, Symbol, Symbol})
precompile(Tuple{Type{Expr}, Symbol, Float64, typeof(Base.isapprox), Float64})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Char, Core.SSAValue, String, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SSAValue, Core.SSAValue, Core.SSAValue, Core.SSAValue, Core.SSAValue, Core.SSAValue, Core.SSAValue, Core.SSAValue, Core.SSAValue, Core.SSAValue, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SSAValue, Core.SSAValue, String, Core.SSAValue})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SSAValue, Core.SlotNumber, GlobalRef})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SSAValue, GlobalRef, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SlotNumber, Core.SlotNumber, Core.SlotNumber, Core.SlotNumber, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SlotNumber, Core.TypedSlot})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SlotNumber, String, Core.SSAValue, String, Core.SSAValue})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SlotNumber, String, Core.SSAValue, String})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SlotNumber, String, Core.SlotNumber, String, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SlotNumber, String, Core.SlotNumber, String})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.SlotNumber, String, GlobalRef})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.TypedSlot, Core.TypedSlot, Core.TypedSlot})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.TypedSlot, Core.TypedSlot})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Core.TypedSlot, String})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, GlobalRef, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Int64, Int64})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, Core.SSAValue, Core.SlotNumber, Core.SlotNumber, Core.SSAValue})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, Core.SSAValue, GlobalRef, Base.VersionNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, Core.SSAValue, GlobalRef, Core.SSAValue, GlobalRef, Core.SSAValue})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, Core.SSAValue, GlobalRef, Core.SSAValue})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, Core.SSAValue, GlobalRef, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, Core.SSAValue, GlobalRef, Int64})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, Core.SSAValue, GlobalRef, UInt32})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, QuoteNode, QuoteNode, QuoteNode})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, String, Core.SSAValue, String, Core.SSAValue, String, Core.SSAValue, String, Core.SSAValue, String})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, String, Core.SSAValue, String, Core.SSAValue, String, Core.SlotNumber, String})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, String, Core.SSAValue, String, Core.SSAValue, String, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, String, Core.SlotNumber, Core.SlotNumber})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, String, Core.SlotNumber, String, Core.SSAValue, String, Core.SSAValue})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, String, Core.SlotNumber, String, Core.SlotNumber, String, Core.SSAValue})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, String, String, String, String, String})
precompile(Tuple{Type{Expr}, Symbol, GlobalRef, Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}})
precompile(Tuple{Type{Expr}, Symbol, Int64, typeof(Base.:(==)), Int64})
precompile(Tuple{Type{Expr}, Symbol, String, typeof(Base.:(==)), String})
precompile(Tuple{Type{Expr}, Symbol, Symbol, Expr, Symbol})
precompile(Tuple{Type{Expr}, Symbol, Symbol, Int64, Int64})
precompile(Tuple{Type{Expr}, Symbol, Symbol, Int64, Symbol})
precompile(Tuple{Type{Expr}, Symbol, Symbol, Symbol, Expr})
precompile(Tuple{Type{Expr}, Symbol, typeof(Base.lastindex), Symbol})
precompile(Tuple{Type{Expr}, Symbol, typeof(Base.maybeview), Symbol, Expr})
precompile(Tuple{Type{LibGit2.GitCommit}, LibGit2.GitRepo, Ptr{Nothing}})
precompile(Tuple{Type{LibGit2.GitHash}, LibGit2.GitCommit})
precompile(Tuple{Type{LibGit2.GitHash}, LibGit2.GitHash})
precompile(Tuple{Type{LibGit2.GitHash}, LibGit2.GitTree})
precompile(Tuple{Type{LibGit2.GitHash}, Tuple{UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8}})
precompile(Tuple{Type{LibGit2.GitTree}, LibGit2.GitRepo, LibGit2.GitHash})
precompile(Tuple{Type{LibGit2.GitTree}, LibGit2.GitRepo, Ptr{Nothing}})
precompile(Tuple{Type{LibGit2.Signature}, String, String, Float64, Int64})
precompile(Tuple{Type{NamedTuple{(:bare, :checkout_branch, :fetch_opts, :remote_cb), Tuple{Int32, Base.Cstring, LibGit2.FetchOptions, Ptr{Nothing}}}}, Tuple{Int32, Base.Cstring, LibGit2.FetchOptions, Ptr{Nothing}}})
precompile(Tuple{Type{NamedTuple{(:callbacks,), Tuple{LibGit2.RemoteCallbacks}}}, Tuple{LibGit2.RemoteCallbacks}})
precompile(Tuple{Type{NamedTuple{(:color, :bold), Tuple{Symbol, Bool}}}, Tuple{Symbol, Bool}})
precompile(Tuple{Type{NamedTuple{(:color,), Tuple{Symbol}}}, Tuple{Symbol}})
precompile(Tuple{Type{NamedTuple{(:env,), Tuple{Pkg3.Types.EnvCache}}}, Tuple{Pkg3.Types.EnvCache}})
precompile(Tuple{Type{NamedTuple{(:msg, :options), Tuple{String, LibGit2.FetchOptions}}}, Tuple{String, LibGit2.FetchOptions}})
precompile(Tuple{Type{NamedTuple{(:name, :uuid), T} where T<:Tuple}, Tuple{String, Base.UUID}})
precompile(Tuple{Type{NamedTuple{(:pkgs,), T} where T<:Tuple}, Tuple{Array{String, 1}}})
precompile(Tuple{Type{NamedTuple{(:prompt_prefix, :prompt_suffix, :sticky), Tuple{String, String, Bool}}}, Tuple{String, String, Bool}})
precompile(Tuple{Type{NamedTuple{(:q, :d, :sat), T} where T<:Tuple}, Tuple{Int64, Int64, Bool}})
precompile(Tuple{Type{NamedTuple{(:remoteurl, :refspecs), Tuple{String, Array{String, 1}}}}, Tuple{String, Array{String, 1}}})
precompile(Tuple{Type{NamedTuple{names, T} where T<:Tuple where names}})
precompile(Tuple{Type{Pkg3.Display.DiffEntry}, Base.UUID, String, Nothing, Pkg3.Display.VerInfo})
precompile(Tuple{Type{Pkg3.Display.DiffEntry}, Base.UUID, String, Pkg3.Display.VerInfo, Nothing})
precompile(Tuple{Type{Pkg3.Display.DiffEntry}, Base.UUID, String, Pkg3.Display.VerInfo, Pkg3.Display.VerInfo})
precompile(Tuple{Type{Pkg3.Display.VerInfo}, Base.SHA1, Nothing, Base.VersionNumber, Bool, Nothing})
precompile(Tuple{Type{Pkg3.Display.VerInfo}, Base.SHA1, Nothing, Base.VersionNumber, Bool, Pkg3.Types.GitRepo})
precompile(Tuple{Type{Pkg3.Display.VerInfo}, Nothing, Nothing, Nothing, Bool, Nothing})
precompile(Tuple{Type{Pkg3.Display.VerInfo}, Nothing, String, Base.VersionNumber, Bool, Nothing})
precompile(Tuple{Type{Pkg3.GraphType.ResolveLogEntry}, Array{Tuple{Base.UUID, String}, 1}, Base.UUID, String})
precompile(Tuple{Type{Pkg3.Pkg2.Reqs.Comment}, String})
precompile(Tuple{Type{Pkg3.Pkg2.Reqs.Requirement}, String})
precompile(Tuple{Type{Pkg3.REPLMode.Command}, Pkg3.REPLMode.CommandKind, Base.SubString{String}})
precompile(Tuple{Type{Pkg3.REPLMode.Option}, Pkg3.REPLMode.OptionKind, String, Nothing})
precompile(Tuple{Type{Pkg3.REPLMode.Rev}, Base.SubString{String}})
precompile(Tuple{Type{Pkg3.Resolve.VersionWeights.VersionWeight}, Base.VersionNumber})
precompile(Tuple{Type{Pkg3.Types.GitRepo}, String, String, Base.SHA1})
precompile(Tuple{Type{Pkg3.Types.GitRepo}, String, String})
precompile(Tuple{Type{Pkg3.Types.PackageSpec}, Base.SubString{String}, Pkg3.Types.VersionSpec})
precompile(Tuple{Type{Pkg3.Types.PackageSpec}, Base.SubString{String}})
precompile(Tuple{Type{Pkg3.Types.PackageSpec}, String, Base.UUID})
precompile(Tuple{Type{Pkg3.Types.PackageSpec}, String})
precompile(Tuple{Type{Pkg3.Types.VersionBound}, Base.SubString{String}})
precompile(Tuple{Type{Pkg3.Types.VersionBound}, Int64, Int64, Int64})
precompile(Tuple{Type{Pkg3.Types.VersionBound}, Int64, Int64})
precompile(Tuple{Type{Pkg3.Types.VersionBound}, Int64})
precompile(Tuple{Type{Pkg3.Types.VersionBound}, UInt32, UInt32, UInt32})
precompile(Tuple{Type{Pkg3.Types.VersionRange}, Pkg3.Types.VersionBound, Pkg3.Types.VersionBound})
precompile(Tuple{Type{Pkg3.Types.VersionRange}, UInt32, UInt32})
precompile(Tuple{Type{Pkg3.Types.VersionRange}, UInt32})
precompile(Tuple{Type{Pkg3.Types.VersionSpec}, Array{Any, 1}})
precompile(Tuple{Type{Pkg3.Types.VersionSpec}, Array{String, 1}})
precompile(Tuple{Type{Pkg3.Types.VersionSpec}, Pkg3.Types.VersionRange})
precompile(Tuple{Type{Pkg3.Types.VersionSpec}, String})
precompile(Tuple{Type{Ref{T} where T}, LibGit2.GitHash})
precompile(Tuple{Type{Symbol}, Symbol, Int64})
precompile(Tuple{getfield(Base, Symbol("#@show")), LineNumberNode, Module, Expr})
precompile(Tuple{getfield(Base, Symbol("#@time")), LineNumberNode, Module, Expr})
precompile(Tuple{getfield(Base, Symbol("#kw##_spawn")), NamedTuple{(:chain,), Tuple{Nothing}}, typeof(Base._spawn), Base.Cmd, Tuple{Base.DevNullStream, Base.IOStream, Base.IOStream}})
precompile(Tuple{getfield(Base, Symbol("#kw##_spawn")), NamedTuple{(:chain,), Tuple{Nothing}}, typeof(Base._spawn), Base.CmdRedirect, Tuple{Base.DevNullStream, Base.DevNullStream, Base.IOStream}})
precompile(Tuple{getfield(Base, Symbol("#kw##pipeline")), NamedTuple{(:stdout, :stderr), Tuple{Base.IOStream, Base.IOStream}}, typeof(Base.pipeline), Base.Cmd})
precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:bold, :color), Tuple{Bool, Symbol}}, typeof(Base.printstyled), Base.TTY, String})
precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:bold, :color), Tuple{Bool, Symbol}}, typeof(Base.printstyled), String, String})
precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:bold, :color), Tuple{Bool, Symbol}}, typeof(Base.printstyled), String})
precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:color, :bold), Tuple{Symbol, Bool}}, typeof(Base.printstyled), String})
precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:color,), Tuple{Symbol}}, typeof(Base.printstyled), String, String})
precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:color,), Tuple{Symbol}}, typeof(Base.printstyled), String})
precompile(Tuple{getfield(Base, Symbol("#kw##sort!")), NamedTuple{(:by,), Tuple{typeof(Base.Unicode.lowercase)}}, typeof(Base.sort!), Array{String, 1}})
precompile(Tuple{getfield(Base, Symbol("#kw##with_output_color")), NamedTuple{(:bold,), Tuple{Bool}}, typeof(Base.with_output_color), typeof(Base.print), Symbol, Base.TTY, String})
precompile(Tuple{getfield(Base.Filesystem, Symbol("#kw##rm")), NamedTuple{(:force,), Tuple{Bool}}, typeof(Base.Filesystem.rm), String})
precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:bare, :checkout_branch, :fetch_opts, :remote_cb), Tuple{Int32, Base.Cstring, LibGit2.FetchOptions, Ptr{Nothing}}}, Type{LibGit2.CloneOptions}})
precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:callbacks,), Tuple{LibGit2.RemoteCallbacks}}, Type{LibGit2.FetchOptions}})
precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:env,), Tuple{Pkg3.Types.EnvCache}}, Type{Pkg3.Types.Context}})
precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:prompt_prefix, :prompt_suffix, :complete, :sticky), Tuple{String, String, Pkg3.REPLMode.PkgCompletionProvider, Bool}}, Type{REPL.LineEdit.Prompt}, String})
precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:prompt_prefix, :prompt_suffix, :sticky), Tuple{String, String, Bool}}, Type{REPL.LineEdit.Prompt}, String})
precompile(Tuple{getfield(LibGit2, Symbol("#kw##fetch")), NamedTuple{(:msg, :options), Tuple{String, LibGit2.FetchOptions}}, typeof(LibGit2.fetch), LibGit2.GitRemote, Array{AbstractString, 1}})
precompile(Tuple{getfield(LibGit2, Symbol("#kw##fetch")), NamedTuple{(:msg, :options), Tuple{String, LibGit2.FetchOptions}}, typeof(LibGit2.fetch), LibGit2.GitRemote, Array{String, 1}})
precompile(Tuple{getfield(LibGit2, Symbol("#kw##merge!")), NamedTuple{(:merge_opts, :checkout_opts), Tuple{LibGit2.MergeOptions, LibGit2.CheckoutOptions}}, typeof(LibGit2.merge!), LibGit2.GitRepo, Array{LibGit2.GitAnnotated, 1}, Bool})
precompile(Tuple{getfield(Pkg3.REPLMode, Symbol("#@pkg_str")), LineNumberNode, Module, String})
precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##_print")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML._print), Base.IOStream, Base.Dict{String, Any}, Array{String, 1}})
precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##print")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML.print), Base.IOStream, Base.Dict{String, Any}})
precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##printvalue")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML.printvalue), Base.IOStream, Array{String, 1}})
precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##printvalue")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML.printvalue), Base.IOStream, Bool})
precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##printvalue")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML.printvalue), Base.IOStream, String})
precompile(Tuple{getfield(Pkg3.Types, Symbol("#kw##printpkgstyle")), NamedTuple{(:ignore_indent,), Tuple{Bool}}, typeof(Pkg3.Types.printpkgstyle), Base.TTY, Symbol, String})
precompile(Tuple{typeof(Base.:(!=)), Base.SHA1, Base.SHA1})
precompile(Tuple{typeof(Base.:(!=)), Base.SubString{String}, Nothing})
precompile(Tuple{typeof(Base.:(!=)), Base.UUID, Base.UUID})
precompile(Tuple{typeof(Base.:(!=)), Base.VersionNumber, Base.VersionNumber})
precompile(Tuple{typeof(Base.:(!=)), Bool, Bool})
precompile(Tuple{typeof(Base.:(!=)), Char, Char})
precompile(Tuple{typeof(Base.:(!=)), Nothing, Base.SHA1})
precompile(Tuple{typeof(Base.:(!=)), String, String})
precompile(Tuple{typeof(Base.:(!=)), UInt8, UInt8})
precompile(Tuple{typeof(Base.:(+)), Int64, Bool})
precompile(Tuple{typeof(Base.:(-)), Bool, Bool})
precompile(Tuple{typeof(Base.:(<)), Pkg3.Resolve.VersionWeights.VersionWeight, Pkg3.Resolve.VersionWeights.VersionWeight})
precompile(Tuple{typeof(Base.:(<<)), UInt32, Int64})
precompile(Tuple{typeof(Base.:(<=)), Int64, Int64})
precompile(Tuple{typeof(Base.:(==)), Base.SHA1, Nothing})
precompile(Tuple{typeof(Base.:(==)), Bool, Bool})
precompile(Tuple{typeof(Base.:(==)), Expr, Int64})
precompile(Tuple{typeof(Base.:(==)), LibGit2.Error.Code, LibGit2.Error.Code})
precompile(Tuple{typeof(Base.:(==)), LibGit2.GitCommit, Nothing})
precompile(Tuple{typeof(Base.:(==)), Module, Module})
precompile(Tuple{typeof(Base.:(==)), Pkg3.Resolve.VersionWeights.VersionWeight, Pkg3.Resolve.VersionWeights.VersionWeight})
precompile(Tuple{typeof(Base.:(==)), Symbol, Int64})
precompile(Tuple{typeof(Base.:(==)), UInt32, Int64})
precompile(Tuple{typeof(Base.:(>)), Int64, Int64})
precompile(Tuple{typeof(Base.:(∉)), Base.UUID, Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.Broadcast._broadcast!), typeof(Base._views), Array{Any, 1}, Tuple{Tuple{Bool}}, Tuple{Tuple{Int64}}, Tuple{Array{Any, 1}}, Base.Val{1}, Base.IteratorsMD.CartesianIndices{1, Tuple{Base.OneTo{Int64}}}, Base.IteratorsMD.CartesianIndex{1}, Int64})
precompile(Tuple{typeof(Base.Broadcast._broadcast!), typeof(Base._views), Array{Expr, 1}, Tuple{Tuple{Bool}}, Tuple{Tuple{Int64}}, Tuple{Array{Any, 1}}, Base.Val{1}, Base.IteratorsMD.CartesianIndices{1, Tuple{Base.OneTo{Int64}}}, Base.IteratorsMD.CartesianIndex{1}, Int64})
precompile(Tuple{typeof(Base.Broadcast._broadcast!), typeof(Base._views), Array{LineNumberNode, 1}, Tuple{Tuple{Bool}}, Tuple{Tuple{Int64}}, Tuple{Array{Any, 1}}, Base.Val{1}, Base.IteratorsMD.CartesianIndices{1, Tuple{Base.OneTo{Int64}}}, Base.IteratorsMD.CartesianIndex{1}, Int64})
precompile(Tuple{typeof(Base.Broadcast._broadcast!), typeof(Base._views), Array{Symbol, 1}, Tuple{Tuple{Bool}}, Tuple{Tuple{Int64}}, Tuple{Array{Any, 1}}, Base.Val{1}, Base.IteratorsMD.CartesianIndices{1, Tuple{Base.OneTo{Int64}}}, Base.IteratorsMD.CartesianIndex{1}, Int64})
precompile(Tuple{typeof(Base.Broadcast._broadcast!), typeof(Base._views), Array{typeof(Base.lastindex), 1}, Tuple{Tuple{Bool}}, Tuple{Tuple{Int64}}, Tuple{Array{Any, 1}}, Base.Val{1}, Base.IteratorsMD.CartesianIndices{1, Tuple{Base.OneTo{Int64}}}, Base.IteratorsMD.CartesianIndex{1}, Int64})
precompile(Tuple{typeof(Base.Filesystem.isabspath), String})
precompile(Tuple{typeof(Base.Filesystem.ispath), String})
precompile(Tuple{typeof(Base.Iterators.enumerate), Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.Iterators.enumerate), Array{Base.VersionNumber, 1}})
precompile(Tuple{typeof(Base.Iterators.enumerate), Array{String, 1}})
precompile(Tuple{typeof(Base.Iterators.enumerate), Array{Tuple{Any, Any}, 1}})
precompile(Tuple{typeof(Base.Iterators.enumerate), Array{Tuple{Base.UUID, Base.VersionNumber}, 1}})
precompile(Tuple{typeof(Base.Libc.time)})
precompile(Tuple{typeof(Base._array_for), Type{Array{Any, 1}}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Array{Base.BitArray{2}, 1}}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Array{Base.VersionNumber, 1}}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Base.BitArray{1}}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Base.BitArray{2}}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Base.Dict{Base.VersionNumber, Int64}}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Base.UUID}, Base.ValueIterator{Base.Dict{Any, Any}}, Base.HasLength})
precompile(Tuple{typeof(Base._array_for), Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, Any}}, Base.HasLength})
precompile(Tuple{typeof(Base._array_for), Type{Expr}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Int64}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{LineNumberNode}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Tuple{String, Base.VersionNumber}}, Array{Any, 1}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{Tuple{String, Base.VersionNumber}}, Array{Tuple{String, Base.VersionNumber}, 1}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._array_for), Type{typeof(Base.lastindex)}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._compute_eltype), Type{Tuple{Int32, Base.Cstring, Ptr{Nothing}}}})
precompile(Tuple{typeof(Base._compute_eltype), Type{Tuple{Symbol, Bool}}})
precompile(Tuple{typeof(Base._similar_for), Array{Any, 1}, Type{Pkg3.Types.VersionRange}, Base.Generator{Array{Any, 1}, Type{Pkg3.Types.VersionRange}}, Base.HasShape{1}})
precompile(Tuple{typeof(Base._views), Expr})
precompile(Tuple{typeof(Base._views), Int64})
precompile(Tuple{typeof(Base._views), LineNumberNode})
precompile(Tuple{typeof(Base._views), typeof(Base.lastindex)})
precompile(Tuple{typeof(Base.add_sum), Int64, Int64})
precompile(Tuple{typeof(Base.append!), Array{String, 1}, Array{String, 1}})
precompile(Tuple{typeof(Base.arg_gen), Base.SubString{String}, Base.SubString{String}})
precompile(Tuple{typeof(Base.arg_gen), String})
precompile(Tuple{typeof(Base.cconvert), Type{Ptr{Ptr{Nothing}}}, Array{Ptr{Nothing}, 1}})
precompile(Tuple{typeof(Base.close), Base.Channel{Any}})
precompile(Tuple{typeof(Base.close), LibGit2.GitAnnotated})
precompile(Tuple{typeof(Base.close), LibGit2.GitCommit})
precompile(Tuple{typeof(Base.close), LibGit2.GitConfig})
precompile(Tuple{typeof(Base.close), LibGit2.GitDiff})
precompile(Tuple{typeof(Base.close), LibGit2.GitIndex})
precompile(Tuple{typeof(Base.close), LibGit2.GitReference})
precompile(Tuple{typeof(Base.close), LibGit2.GitRemote})
precompile(Tuple{typeof(Base.close), LibGit2.GitRepo})
precompile(Tuple{typeof(Base.close), LibGit2.GitSignature})
precompile(Tuple{typeof(Base.close), LibGit2.GitTree})
precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{Base.Cmd}, Tuple{Base.SubString{String}}}})
precompile(Tuple{typeof(Base.coalesce), Symbol})
precompile(Tuple{typeof(Base.collect), Base.Generator{Array{Any, 1}, typeof(Pkg3.TOML.table2dict)}})
precompile(Tuple{typeof(Base.collect), Base.Generator{Base.ValueIterator{Base.Dict{Any, Any}}, Type{Base.UUID}}})
precompile(Tuple{typeof(Base.collect), Base.Generator{Base.ValueIterator{Base.Dict{String, Any}}, Type{Base.UUID}}})
precompile(Tuple{typeof(Base.collect), Base.Generator{Base.ValueIterator{Base.Dict{String, String}}, Type{Base.UUID}}})
precompile(Tuple{typeof(Base.collect), Base.KeySet{String, Base.Dict{String, Any}}})
precompile(Tuple{typeof(Base.collect), Tuple{String}})
precompile(Tuple{typeof(Base.collect_similar), Array{LibGit2.GitAnnotated, 1}, Base.Generator{Array{LibGit2.GitAnnotated, 1}, typeof(Base.close)}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Base.UUID, 1}, Base.UUID, Base.Generator{Base.ValueIterator{Base.Dict{Any, Any}}, Type{Base.UUID}}, Int64})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Base.UUID, 1}, Base.UUID, Base.Generator{Base.ValueIterator{Base.Dict{String, Any}}, Type{Base.UUID}}, Int64})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Pkg3.Types.VersionRange, 1}, Pkg3.Types.VersionRange, Base.Generator{Array{Any, 1}, Type{Pkg3.Types.VersionRange}}, Int64})
precompile(Tuple{typeof(Base.convert), Type{Array{Array{Base.BitArray{2}, 1}, 1}}, Array{Any, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Array{Base.BitArray{2}, 1}, 1}}, Array{Array{Any, 1}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Array{Base.BitArray{2}, 1}, 1}}, Array{Array{Base.BitArray{2}, 1}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Array{Base.BitArray{2}, 1}, 1}}, Array{Array{T, 1} where T, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Array{Base.VersionNumber, 1}, 1}}, Array{Any, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Array{Base.VersionNumber, 1}, 1}}, Array{Array{Base.VersionNumber, 1}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Array{Int64, 1}, 1}}, Array{Array{Int64, 1}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Base.BitArray{1}, 1}}, Array{Any, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Base.BitArray{1}, 1}}, Array{Base.BitArray{1}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Base.Dict{Base.VersionNumber, Int64}, 1}}, Array{Any, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Base.Dict{Base.VersionNumber, Int64}, 1}}, Array{Base.Dict{Base.VersionNumber, Int64}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Base.UUID, 1}}, Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{Int64, 1}}, Array{Int64, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{String, 1}}, Array{Any, 1}})
precompile(Tuple{typeof(Base.convert), Type{Base.Cstring}, Ptr{Nothing}})
precompile(Tuple{typeof(Base.convert), Type{Base.Dict{Base.UUID, Int64}}, Base.Dict{Any, Any}})
precompile(Tuple{typeof(Base.convert), Type{Base.Dict{Base.UUID, Int64}}, Base.Dict{Base.UUID, Int64}})
precompile(Tuple{typeof(Base.convert), Type{Base.Dict{Base.UUID, Pkg3.GraphType.ResolveLogEntry}}, Base.Dict{Base.UUID, Pkg3.GraphType.ResolveLogEntry}})
precompile(Tuple{typeof(Base.convert), Type{Base.Dict{Char, V} where V}, Base.Dict{Char, Any}})
precompile(Tuple{typeof(Base.convert), Type{Base.UUID}, Base.UUID})
precompile(Tuple{typeof(Base.convert), Type{Pkg3.Types.PackageMode}, Pkg3.Types.PackageMode})
precompile(Tuple{typeof(Base.convert), Type{Ptr{Nothing}}, Ptr{UInt8}})
precompile(Tuple{typeof(Base.convert), Type{String}, Base.SubString{String}})
precompile(Tuple{typeof(Base.convert), Type{Union{Pkg3.Types.UpgradeLevel, Base.VersionNumber, Pkg3.Types.VersionSpec}}, Base.VersionNumber})
precompile(Tuple{typeof(Base.convert), Type{Union{Pkg3.Types.UpgradeLevel, Base.VersionNumber, Pkg3.Types.VersionSpec}}, Pkg3.Types.VersionSpec})
precompile(Tuple{typeof(Base.convert), Type{typeof(Base.lastindex)}, typeof(Base.lastindex)})
precompile(Tuple{typeof(Base.copy), Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.copyto!), Array{Any, 1}, Tuple{String, Base.VersionNumber, String, String}})
precompile(Tuple{typeof(Base.copyto!), Array{Any, 1}, Tuple{String, Base.VersionNumber}})
precompile(Tuple{typeof(Base.copyto!), Array{Array{T, 1} where T, 1}, Int64, Array{Array{Base.BitArray{2}, 1}, 1}, Int64, Int64})
precompile(Tuple{typeof(Base.count), Base.BitArray{1}})
precompile(Tuple{typeof(Base.count), Base.Fix2{typeof(isequal),Char}, String})
precompile(Tuple{typeof(Base.count), Base.Fix2{typeof(==),Char}, String})
precompile(Tuple{typeof(Base.deepcopy), Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.deepcopy_internal), Array{Base.Dict{String, Any}, 1}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{Any, Any}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{Base.UUID, Array{String, 1}}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{Base.UUID, String}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{String, Array{Base.UUID, 1}}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{String, String}, Base.IdDict{Any, Any}})
precompile(Tuple{typeof(Base.delete!), Base.Dict{String, Any}, String})
precompile(Tuple{typeof(Base.delete!), Base.IdDict{Any, Any}, Symbol})
precompile(Tuple{typeof(Base.delete!), Base.Set{Any}, Char})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol, Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol, Symbol, Symbol}, Tuple{Symbol}})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Base.displaysize), Base.TTY})
precompile(Tuple{typeof(Base.divrem), Int64, Int64})
precompile(Tuple{typeof(Base.done), Array{Base.Dict{String, Any}, 1}, Int64})
precompile(Tuple{typeof(Base.done), Array{Base.UUID, 1}, Int64})
precompile(Tuple{typeof(Base.done), Array{Base.VersionNumber, 1}, Int64})
precompile(Tuple{typeof(Base.done), Array{Tuple{Any, Any}, 1}, Int64})
precompile(Tuple{typeof(Base.done), Array{Tuple{Base.UUID, Base.VersionNumber}, 1}, Int64})
precompile(Tuple{typeof(Base.done), Base.Dict{Any, Any}, Int64})
precompile(Tuple{typeof(Base.done), Base.Dict{String, Any}, Int64})
precompile(Tuple{typeof(Base.done), Tuple{Base.BitArray{1}}, Int64})
precompile(Tuple{typeof(Base.done), Tuple{Expr}, Int64})
precompile(Tuple{typeof(Base.eltype), Array{Any, 1}})
precompile(Tuple{typeof(Base.empty!), Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.empty), Array{Tuple{Any, Any}, 1}, Type{Tuple{Base.UUID, Base.VersionNumber}}})
precompile(Tuple{typeof(Base.empty), Base.Dict{Union{}, Union{}}, Type{Base.UUID}, Type{Int64}})
precompile(Tuple{typeof(Base.empty), Base.Dict{Union{}, Union{}}, Type{String}, Type{Base.UUID}})
precompile(Tuple{typeof(Base.empty), Base.Dict{Union{}, Union{}}, Type{String}, Type{Base.VersionNumber}})
precompile(Tuple{typeof(Base.empty), Base.Dict{Union{}, Union{}}, Type{String}, Type{String}})
precompile(Tuple{typeof(Base.falses), Int64})
precompile(Tuple{typeof(Base.find_env), Array{Any, 1}})
precompile(Tuple{typeof(Base.find_env), Base.SubString{String}})
precompile(Tuple{typeof(Base.first), Base.SubString{String}})
precompile(Tuple{typeof(Base.foldl), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}})
precompile(Tuple{typeof(Base.foldl), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}})
precompile(Tuple{typeof(Base.foldl), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}})
precompile(Tuple{typeof(Base.foldl), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}})
precompile(Tuple{typeof(Base.get!), Base.Dict{Base.UUID, Array{String, 1}}, Base.UUID, Array{String, 1}})
precompile(Tuple{typeof(Base.get!), Base.Dict{Pkg3.Types.VersionRange, Base.Dict{String, Base.UUID}}, Pkg3.Types.VersionRange, Base.Dict{String, Base.UUID}})
precompile(Tuple{typeof(Base.get!), Base.Dict{Pkg3.Types.VersionRange, Base.Dict{String, Pkg3.Types.VersionSpec}}, Pkg3.Types.VersionRange, Base.Dict{String, Pkg3.Types.VersionSpec}})
precompile(Tuple{typeof(Base.get!), Base.Dict{String, Any}, String, Array{Base.Dict{String, Any}, 1}})
precompile(Tuple{typeof(Base.get!), Base.Dict{String, Array{Base.UUID, 1}}, String, Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.get!), Base.Dict{String, Array{String, 1}}, String, Array{String, 1}})
precompile(Tuple{typeof(Base.get), Base.Dict{String, Any}, String, Array{Any, 1}})
precompile(Tuple{typeof(Base.get), Base.TTY, Symbol, Bool})
precompile(Tuple{typeof(Base.getindex), Array{Array{Base.VersionNumber, 1}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Array{Int64, 1}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Array{UInt64, 1}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Base.BitArray{1}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Base.BitArray{2}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Base.Dict{Int64, Int64}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Base.Dict{String, Any}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Base.UUID, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Base.VersionNumber, 1}, Base.BitArray{1}})
precompile(Tuple{typeof(Base.getindex), Array{String, 1}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.getindex), Array{String, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Tuple{Base.UUID, Base.VersionNumber}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{UInt8, 1}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.getindex), Array{UInt8, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Base.BitArray{1}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.getindex), Base.BitArray{1}, Int64})
precompile(Tuple{typeof(Base.getindex), Base.BitArray{2}, Base.BitArray{1}, Base.BitArray{1}})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Any, Any}, Char})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Base.UUID, Array{String, 1}}, Base.UUID})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Base.UUID, Base.Dict{Union{Nothing, Base.VersionNumber}, Base.Set{Union{Nothing, Base.VersionNumber}}}}, Base.UUID})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Base.UUID, Int64}, Base.UUID})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Base.VersionNumber, Base.Dict{String, Pkg3.Types.VersionSpec}}, Base.VersionNumber})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Base.VersionNumber, Int64}, Base.VersionNumber})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Int64, Int64}, Int64})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Pkg3.Types.VersionRange, Base.Dict{String, Base.UUID}}, Pkg3.Types.VersionRange})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Pkg3.Types.VersionRange, Base.Dict{String, Pkg3.Types.VersionSpec}}, Pkg3.Types.VersionRange})
precompile(Tuple{typeof(Base.getindex), Base.Dict{String, Base.Dict{Base.VersionNumber, Base.Dict{String, Pkg3.Types.VersionSpec}}}, String})
precompile(Tuple{typeof(Base.getindex), Base.Dict{String, Base.UUID}, String})
precompile(Tuple{typeof(Base.getindex), Base.Dict{String, Pkg3.REPLMode.CommandKind}, Base.SubString{String}})
precompile(Tuple{typeof(Base.getindex), Base.Dict{String, Pkg3.REPLMode.OptionKind}, Base.SubString{String}})
precompile(Tuple{typeof(Base.getindex), Base.RefValue{LibGit2.GitHash}})
precompile(Tuple{typeof(Base.getindex), Pkg3.TOML.Table, String})
precompile(Tuple{typeof(Base.getindex), Tuple{Base.UUID, Int64}, Int64})
precompile(Tuple{typeof(Base.getindex), Tuple{Int64, Int64}, Int64})
precompile(Tuple{typeof(Base.getindex), Tuple{String, Int64}, Int64})
precompile(Tuple{typeof(Base.getindex), Tuple{String, String}, Int64})
precompile(Tuple{typeof(Base.getindex), Tuple{Tuple{Base.UUID, Base.VersionNumber}, Int64}, Int64})
precompile(Tuple{typeof(Base.getindex), Type{Any}, Array{Any, 1}, Array{Any, 1}, Array{Any, 1}, Array{Any, 1}})
precompile(Tuple{typeof(Base.getindex), Type{Any}, Array{Any, 1}, Array{Any, 1}})
precompile(Tuple{typeof(Base.getindex), Type{Any}, Array{String, 1}, Array{String, 1}, Array{String, 1}, Array{String, 1}})
precompile(Tuple{typeof(Base.getindex), Type{Any}, Array{String, 1}, Array{String, 1}})
precompile(Tuple{typeof(Base.getindex), Type{Any}, Tuple{String, Base.VersionNumber}, Tuple{String, Base.VersionNumber}, Tuple{String, Base.VersionNumber}, Tuple{String, Base.VersionNumber}, Tuple{String, Base.VersionNumber}, Tuple{String, Base.VersionNumber}, Tuple{String, Base.VersionNumber}})
precompile(Tuple{typeof(Base.getindex), Type{Base.UUID}})
precompile(Tuple{typeof(Base.getindex), Type{Pkg3.Types.VersionRange}, Pkg3.Pkg2.Pkg2Types.VersionInterval})
precompile(Tuple{typeof(Base.getproperty), LibGit2.Error.GitError, Symbol})
precompile(Tuple{typeof(Base.getproperty), Pkg3.GraphType.ResolveLogEntry, Symbol})
precompile(Tuple{typeof(Base.getproperty), Pkg3.Pkg2.Pkg2Types.VersionSet, Symbol})
precompile(Tuple{typeof(Base.getproperty), Pkg3.TOML.Table, Symbol})
precompile(Tuple{typeof(Base.getproperty), Pkg3.Types.PackageSpec, Symbol})
precompile(Tuple{typeof(Base.getproperty), REPL.REPLHistoryProvider, Symbol})
precompile(Tuple{typeof(Base.getproperty), Random.MersenneTwister, Symbol})
precompile(Tuple{typeof(Base.hash), Tuple{String, UInt64}, UInt64})
precompile(Tuple{typeof(Base.hash), Tuple{String}, UInt64})
precompile(Tuple{typeof(Base.hash), Tuple{}, UInt64})
precompile(Tuple{typeof(Base.haskey), Base.Dict{Base.UUID, Base.Dict{K, V} where V where K}, Base.UUID})
precompile(Tuple{typeof(Base.haskey), Base.Dict{Base.VersionNumber, Base.Dict{String, Pkg3.Types.VersionSpec}}, Base.VersionNumber})
precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Base.Dict{Base.VersionNumber, Base.Dict{String, Pkg3.Types.VersionSpec}}}, String})
precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Base.UUID}, String})
precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Pkg3.REPLMode.CommandKind}, Base.SubString{String}})
precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Pkg3.REPLMode.OptionKind}, Base.SubString{String}})
precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Pkg3.Types.VersionSpec}, String})
precompile(Tuple{typeof(Base.haskey), Pkg3.TOML.Table, String})
precompile(Tuple{typeof(Base.ident_cmp), Tuple{String}, Tuple{String}})
precompile(Tuple{typeof(Base.ident_cmp), Tuple{String}, Tuple{}})
precompile(Tuple{typeof(Base.identity), Char})
precompile(Tuple{typeof(Base.identity), Int64})
precompile(Tuple{typeof(Base.in), Base.UUID, Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.in), Base.VersionNumber, Base.VersionNumber})
precompile(Tuple{typeof(Base.in), Pkg3.Types.VersionRange, Array{Pkg3.Types.VersionRange, 1}})
precompile(Tuple{typeof(Base.in), String, Array{String, 1}})
precompile(Tuple{typeof(Base.in), String, Base.KeySet{String, Base.Dict{String, Any}}})
precompile(Tuple{typeof(Base.in), Tuple{String, Base.VersionNumber}, Array{Tuple{String, Base.VersionNumber}, 1}})
precompile(Tuple{typeof(Base.incomplete_tag), Symbol})
precompile(Tuple{typeof(Base.indexed_next), Base.Pair{Any, Any}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_next), Base.Pair{String, Any}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_next), Tuple{Array{Any, 1}, Array{Array{String, 1}, 1}, Base.Dict{String, Base.VersionNumber}, Array{Any, 1}}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_next), Tuple{Base.UUID, Base.VersionNumber}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_next), Tuple{Expr, Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_next), Tuple{Pkg3.Types.PackageSpec, Bool, String}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_next), Tuple{Pkg3.Types.PackageSpec, String}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_next), Tuple{String, Array{String, 1}, Array{String, 1}}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_next), Tuple{String, String}, Int64, Int64})
precompile(Tuple{typeof(Base.isapprox), Float64, Float64})
precompile(Tuple{typeof(Base.isdeprecated), Module, Symbol})
precompile(Tuple{typeof(Base.isempty), Array{Base.Dict{String, Any}, 1}})
precompile(Tuple{typeof(Base.isempty), Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.isempty), Array{String, 1}})
precompile(Tuple{typeof(Base.isempty), Array{Tuple{String, String}, 1}})
precompile(Tuple{typeof(Base.isempty), Base.Dict{Base.UUID, Int64}})
precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Base.UUID}})
precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Base.VersionNumber}})
precompile(Tuple{typeof(Base.isempty), Base.Dict{String, String}})
precompile(Tuple{typeof(Base.isless), Int64, Int64})
precompile(Tuple{typeof(Base.isopen), Base.Channel{Any}})
precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{String}, Char})
precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{String}})
precompile(Tuple{typeof(Base.join), Tuple{Symbol, Symbol, Symbol, Symbol}, String})
precompile(Tuple{typeof(Base.join), Tuple{Symbol, Symbol, Symbol}, String})
precompile(Tuple{typeof(Base.keys), Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.lastindex), Array{String, 1}})
precompile(Tuple{typeof(Base.lastindex), Array{UInt8, 1}})
precompile(Tuple{typeof(Base.lastindex), Base.BitArray{1}})
precompile(Tuple{typeof(Base.length), Array{Array{Base.BitArray{2}, 1}, 1}})
precompile(Tuple{typeof(Base.length), Array{Array{Base.VersionNumber, 1}, 1}})
precompile(Tuple{typeof(Base.length), Array{Array{Int64, 1}, 1}})
precompile(Tuple{typeof(Base.length), Array{Base.BitArray{1}, 1}})
precompile(Tuple{typeof(Base.length), Array{Base.Dict{Base.VersionNumber, Int64}, 1}})
precompile(Tuple{typeof(Base.length), Array{Base.Dict{Int64, Int64}, 1}})
precompile(Tuple{typeof(Base.length), Array{Base.Dict{String, Any}, 1}})
precompile(Tuple{typeof(Base.length), Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.length), Array{Base.VersionNumber, 1}})
precompile(Tuple{typeof(Base.length), Array{Tuple{Any, Any}, 1}})
precompile(Tuple{typeof(Base.length), Array{Tuple{Base.UUID, Base.VersionNumber}, 1}})
precompile(Tuple{typeof(Base.length), Base.BitArray{1}})
precompile(Tuple{typeof(Base.length), Base.Dict{Any, Any}})
precompile(Tuple{typeof(Base.length), Base.Dict{Base.UUID, Int64}})
precompile(Tuple{typeof(Base.length), Base.Dict{Base.UUID, Pkg3.GraphType.ResolveLogEntry}})
precompile(Tuple{typeof(Base.length), Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.length), Base.Dict{String, String}})
precompile(Tuple{typeof(Base.length), Tuple{DataType}})
precompile(Tuple{typeof(Base.map), Type{Base.UUID}, Base.ValueIterator{Base.Dict{Any, Any}}})
precompile(Tuple{typeof(Base.map), Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, Any}}})
precompile(Tuple{typeof(Base.map), Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, String}}})
precompile(Tuple{typeof(Base.map), typeof(Base.close), Array{LibGit2.GitAnnotated, 1}})
precompile(Tuple{typeof(Base.mapfoldl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}})
precompile(Tuple{typeof(Base.mapfoldl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}})
precompile(Tuple{typeof(Base.mapfoldl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}})
precompile(Tuple{typeof(Base.mapfoldl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}})
precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}, Int64})
precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}, Int64})
precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}, Int64})
precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}, Int64})
precompile(Tuple{typeof(Base.mapreduce_first), typeof(Base.identity), typeof(Base.max), Base.VersionNumber})
precompile(Tuple{typeof(Base.mapreduce_first), typeof(Base.identity), typeof(Base.max), Int64})
precompile(Tuple{typeof(Base.max), Int64, Int64})
precompile(Tuple{typeof(Base.maybeview), Array{UInt8, 1}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.mean), Array{Int64, 1}})
precompile(Tuple{typeof(Base.merge!), Base.Dict{Base.UUID, Int64}, Base.Dict{Union{}, Union{}}})
precompile(Tuple{typeof(Base.merge!), Base.Dict{String, Any}, Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.merge!), Base.Dict{String, Base.UUID}, Base.Dict{Union{}, Union{}}})
precompile(Tuple{typeof(Base.merge!), Base.Dict{String, Base.VersionNumber}, Base.Dict{Union{}, Union{}}})
precompile(Tuple{typeof(Base.merge!), Base.Dict{String, String}, Base.Dict{Union{}, Union{}}})
precompile(Tuple{typeof(Base.merge), Base.Dict{String, Any}, Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.merge), Base.Dict{String, Any}, Base.Dict{String, String}})
precompile(Tuple{typeof(Base.merge_names), Tuple{Symbol, Symbol, Symbol}, Tuple{Symbol}})
precompile(Tuple{typeof(Base.merge_names), Tuple{Symbol}, Tuple{Symbol}})
precompile(Tuple{typeof(Base.merge_names), Tuple{Symbol}, Tuple{}})
precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol, Symbol, Symbol, Symbol}, Type{NamedTuple{(:bare, :checkout_branch, :remote_cb), Tuple{Int32, Base.Cstring, Ptr{Nothing}}}}, Type{NamedTuple{(:fetch_opts,), Tuple{LibGit2.FetchOptionsStruct}}}})
precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol, Symbol}, Type{NamedTuple{(:credentials,), Tuple{Ptr{Nothing}}}}, Type{NamedTuple{(:payload,), Tuple{Ptr{Nothing}}}}})
precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol, Symbol}, Type{NamedTuple{(:mode,), Tuple{Symbol}}}, Type{NamedTuple{(:preview,), Tuple{Bool}}}})
precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol}, Type{NamedTuple{(:mode,), Tuple{Symbol}}}, Type{NamedTuple{(), Tuple{}}}})
precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol}, Type{NamedTuple{(:prefix,), Tuple{String}}}, Type{NamedTuple{(), Tuple{}}}})
precompile(Tuple{typeof(Base.min), Int64, Int64})
precompile(Tuple{typeof(Base.mod1), Int64, Int64})
precompile(Tuple{typeof(Base.next), Array{Base.Dict{String, Any}, 1}, Int64})
precompile(Tuple{typeof(Base.next), Array{Base.UUID, 1}, Int64})
precompile(Tuple{typeof(Base.next), Array{Base.VersionNumber, 1}, Int64})
precompile(Tuple{typeof(Base.next), Array{Tuple{Base.UUID, Base.VersionNumber}, 1}, Int64})
precompile(Tuple{typeof(Base.next), Base.Channel{Any}, Base.ChannelIterState{Any}})
precompile(Tuple{typeof(Base.next), Base.Dict{Any, Any}, Int64})
precompile(Tuple{typeof(Base.next), Base.Dict{String, Any}, Int64})
precompile(Tuple{typeof(Base.next), Base.Dict{Symbol, Any}, Int64})
precompile(Tuple{typeof(Base.next), Tuple{Base.BitArray{1}}, Int64})
precompile(Tuple{typeof(Base.next), Tuple{Expr}, Int64})
precompile(Tuple{typeof(Base.notify_error), Base.Channel{Any}, Base.InvalidStateException})
precompile(Tuple{typeof(Base.parse_input_line), String})
precompile(Tuple{typeof(Base.popfirst!), Array{Base.SubString{String}, 1}})
precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, LibGit2.GitHash})
precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Base.UUID, String})
precompile(Tuple{typeof(Base.print_to_string), Base.VersionNumber, String})
precompile(Tuple{typeof(Base.println), Base.GenericIOBuffer{Array{UInt8, 1}}, String, String, String, String})
precompile(Tuple{typeof(Base.println), Base.TTY})
precompile(Tuple{typeof(Base.promote_eltype), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}})
precompile(Tuple{typeof(Base.promote_eltype), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}})
precompile(Tuple{typeof(Base.promote_eltype), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}})
precompile(Tuple{typeof(Base.promote_eltype), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}})
precompile(Tuple{typeof(Base.promote_type), Type{Base.UUID}, Type{Base.UUID}})
precompile(Tuple{typeof(Base.promote_type), Type{String}, Type{Base.VersionNumber}})
precompile(Tuple{typeof(Base.promote_typejoin), Type{Any}, Type{Ptr{Nothing}}})
precompile(Tuple{typeof(Base.promote_typejoin), Type{Array{Base.BitArray{2}, 1}}, Type{Array{Any, 1}}})
precompile(Tuple{typeof(Base.promote_typejoin), Type{Int32}, Type{Base.Cstring}})
precompile(Tuple{typeof(Base.promote_typejoin), Type{Symbol}, Type{Bool}})
precompile(Tuple{typeof(Base.promote_typejoin), Type{Union{}}, Type{Base.UUID}})
precompile(Tuple{typeof(Base.promote_typejoin), Type{Union{}}, Type{Base.VersionNumber}})
precompile(Tuple{typeof(Base.promote_typejoin), Type{Union{}}, Type{Int32}})
precompile(Tuple{typeof(Base.promote_typejoin), Type{typeof(Base.lastindex)}, Type{Symbol}})
precompile(Tuple{typeof(Base.promote_typeof), Base.VersionNumber, String, String})
precompile(Tuple{typeof(Base.promote_typeof), Base.VersionNumber})
precompile(Tuple{typeof(Base.promote_typeof), String, Base.VersionNumber, String, String})
precompile(Tuple{typeof(Base.promote_typeof), String, String})
precompile(Tuple{typeof(Base.promote_typeof), String})
precompile(Tuple{typeof(Base.push!), Array{Base.Dict{String, Any}, 1}, Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.push!), Array{Base.UUID, 1}, Base.UUID})
precompile(Tuple{typeof(Base.push!), Array{Int64, 1}, Int64})
precompile(Tuple{typeof(Base.push!), Array{LibGit2.GitHash, 1}, LibGit2.GitHash})
precompile(Tuple{typeof(Base.push!), Array{Pkg3.Pkg2.Reqs.Line, 1}, Pkg3.Pkg2.Reqs.Comment})
precompile(Tuple{typeof(Base.push!), Array{Pkg3.Pkg2.Reqs.Line, 1}, Pkg3.Pkg2.Reqs.Requirement})
precompile(Tuple{typeof(Base.push!), Array{Pkg3.Types.PackageSpec, 1}, Pkg3.Types.PackageSpec})
precompile(Tuple{typeof(Base.push!), Array{Symbol, 1}, Symbol})
precompile(Tuple{typeof(Base.push!), Array{Tuple{Base.UUID, Base.VersionNumber}, 1}, Tuple{Base.UUID, Base.VersionNumber}})
precompile(Tuple{typeof(Base.push!), Array{Tuple{Base.UUID, String, Union{Base.SHA1, String}, String}, 1}, Tuple{Base.UUID, String, String, String}})
precompile(Tuple{typeof(Base.push!), Array{Tuple{Base.UUID, String}, 1}, Tuple{Base.UUID, String}})
precompile(Tuple{typeof(Base.push!), Array{Tuple{String, Base.VersionNumber}, 1}, Tuple{String, Base.VersionNumber}})
precompile(Tuple{typeof(Base.push!), Array{Union{Pkg3.Types.VersionRange, String, Pkg3.REPLMode.Command, Pkg3.REPLMode.Option, Pkg3.REPLMode.Rev}, 1}, String})
precompile(Tuple{typeof(Base.push!), Base.Set{Any}, Char})
precompile(Tuple{typeof(Base.push!), Pkg3.GraphType.ResolveLogEntry, Tuple{Nothing, String}})
precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Pkg3.Types.PackageSpec, Bool, String}})
precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Pkg3.Types.PackageSpec, String}})
precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{String, Array{String, 1}, Array{String, 1}}})
precompile(Tuple{typeof(Base.rand), Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.reduce_first), typeof(Base.add_sum), Int64})
precompile(Tuple{typeof(Base.reduce_first), typeof(Base.max), Base.VersionNumber})
precompile(Tuple{typeof(Base.reduce_first), typeof(Base.max), Int64})
precompile(Tuple{typeof(Base.reinterpret), Type{Char}, UInt32})
precompile(Tuple{typeof(Base.remove_linenums!), Float64})
precompile(Tuple{typeof(Base.remove_linenums!), LineNumberNode})
precompile(Tuple{typeof(Base.remove_linenums!), String})
precompile(Tuple{typeof(Base.remove_linenums!), UInt32})
precompile(Tuple{typeof(Base.replace_ref_end_!), Expr, Expr})
precompile(Tuple{typeof(Base.replace_ref_end_!), Int64, Expr})
precompile(Tuple{typeof(Base.replace_ref_end_!), Int64, Nothing})
precompile(Tuple{typeof(Base.replace_ref_end_!), LineNumberNode, Nothing})
precompile(Tuple{typeof(Base.repr), String})
precompile(Tuple{typeof(Base.reverseind), String, Int64})
precompile(Tuple{typeof(Base.round), Type{Int64}, Float64})
precompile(Tuple{typeof(Base.run), Base.Cmd, Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}})
precompile(Tuple{typeof(Base.setindex!), Array{Array{Base.BitArray{2}, 1}, 1}, Array{Any, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{Array{Base.BitArray{2}, 1}, 1}, Array{Base.BitArray{2}, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{Array{T, 1} where T, 1}, Array{Any, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{Expr, 1}, Expr, Base.IteratorsMD.CartesianIndex{1}})
precompile(Tuple{typeof(Base.setindex!), Array{LineNumberNode, 1}, LineNumberNode, Base.IteratorsMD.CartesianIndex{1}})
precompile(Tuple{typeof(Base.setindex!), Array{typeof(Base.lastindex), 1}, typeof(Base.lastindex), Base.IteratorsMD.CartesianIndex{1}})
precompile(Tuple{typeof(Base.setindex!), Array{typeof(Base.lastindex), 1}, typeof(Base.lastindex), Int64})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Base.UUID, Base.Dict{K, V} where V where K}, Base.Dict{String, Any}, Base.UUID})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Base.VersionNumber, Base.Dict{String, Pkg3.Types.VersionSpec}}, Base.Dict{String, Pkg3.Types.VersionSpec}, Base.VersionNumber})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Base.VersionNumber, Base.SHA1}, Base.SHA1, Base.VersionNumber})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Array{Any, 1}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Array{Base.Dict{String, Any}, 1}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Base.Dict{Any, Any}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Base.Dict{String, String}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Base.UUID, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Bool, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Pkg3.TOML.Table, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Base.Dict{Base.VersionNumber, Base.Dict{String, Pkg3.Types.VersionSpec}}}, Base.Dict{Base.VersionNumber, Base.Dict{String, Pkg3.Types.VersionSpec}}, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Union{Nothing, Base.VersionNumber}}, Base.VersionNumber, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Union{Nothing, Base.VersionNumber}}, Nothing, String})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{Base.UUID, Base.VersionNumber}, Int64}, Int64, Tuple{Base.UUID, Base.VersionNumber}})
precompile(Tuple{typeof(Base.setindex!), Base.IdDict{Pkg3.GraphType.ResolveLogEntry, Bool}, Bool, Pkg3.GraphType.ResolveLogEntry})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Any, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Array{Any, 1}, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Array{Base.BitArray{2}, 1}, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Array{Int64, 1}, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Array{T, 1} where T, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Base.BitArray{1}, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Int64, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Any, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Array{Base.VersionNumber, 1}, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Base.Dict{Base.VersionNumber, Int64}, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Int64, 1}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Base.Dict{Base.UUID, Int64}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.ResolveLog, Symbol, Base.Dict{Base.UUID, Pkg3.GraphType.ResolveLogEntry}})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.Types.GitRepo, Symbol, Base.SHA1})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.Types.PackageSpec, Symbol, Base.UUID})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.Types.PackageSpec, Symbol, Base.VersionNumber})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.Types.PackageSpec, Symbol, Pkg3.Types.PackageMode})
precompile(Tuple{typeof(Base.setproperty!), Pkg3.Types.PackageSpec, Symbol, Pkg3.Types.VersionSpec})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.Prompt, Symbol, String})
precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{String, 1}})
precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
precompile(Tuple{typeof(Base.showerror), Base.GenericIOBuffer{Array{UInt8, 1}}, Pkg3.Types.ResolverError})
precompile(Tuple{typeof(Base.similar), Array{Any, 1}, Type{Pkg3.Types.VersionRange}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.similar), Array{Base.Dict{String, Any}, 1}})
precompile(Tuple{typeof(Base.similar), Array{LibGit2.GitAnnotated, 1}, Type{Nothing}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.similar), Array{String, 1}})
precompile(Tuple{typeof(Base.similar), Type{Array{Expr, N} where N}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.similar), Type{Array{LineNumberNode, N} where N}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.similar), Type{Array{typeof(Base.lastindex), N} where N}, Tuple{Base.OneTo{Int64}}})
precompile(Tuple{typeof(Base.spawn_opts_inherit), Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}})
precompile(Tuple{typeof(Base.sprint), typeof(Base.showerror), Pkg3.Types.ResolverError})
precompile(Tuple{typeof(Base.start), Array{Base.Dict{String, Any}, 1}})
precompile(Tuple{typeof(Base.start), Array{Base.UUID, 1}})
precompile(Tuple{typeof(Base.start), Array{Base.VersionNumber, 1}})
precompile(Tuple{typeof(Base.start), Array{Tuple{Any, Any}, 1}})
precompile(Tuple{typeof(Base.start), Array{Tuple{Base.UUID, Base.VersionNumber}, 1}})
precompile(Tuple{typeof(Base.start), Base.Channel{Any}})
precompile(Tuple{typeof(Base.start), Base.Dict{Any, Any}})
precompile(Tuple{typeof(Base.start), Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.start), Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(Base.start), Base.Pair{Any, Any}})
precompile(Tuple{typeof(Base.start), Base.Pair{String, Any}})
precompile(Tuple{typeof(Base.start), Tuple{Array{Any, 1}, Array{Array{String, 1}, 1}, Base.Dict{String, Base.VersionNumber}, Array{Any, 1}}})
precompile(Tuple{typeof(Base.start), Tuple{Base.BitArray{1}}})
precompile(Tuple{typeof(Base.start), Tuple{Base.UUID, Base.VersionNumber}})
precompile(Tuple{typeof(Base.start), Tuple{Expr}})
precompile(Tuple{typeof(Base.start), Tuple{Pkg3.Types.PackageSpec, Bool, String}})
precompile(Tuple{typeof(Base.start), Tuple{Pkg3.Types.PackageSpec, String}})
precompile(Tuple{typeof(Base.start), Tuple{String, Array{String, 1}, Array{String, 1}}})
precompile(Tuple{typeof(Base.string), Base.VersionNumber, String})
precompile(Tuple{typeof(Base.string), LibGit2.GitHash})
precompile(Tuple{typeof(Base.string), String, Base.SubString{String}, String, String})
precompile(Tuple{typeof(Base.string), String, Module, String, String, String, Int64})
precompile(Tuple{typeof(Base.success), Base.CmdRedirect})
precompile(Tuple{typeof(Base.trues), Int64})
precompile(Tuple{typeof(Base.unescape_string), Base.SubString{String}})
precompile(Tuple{typeof(Base.union!), Base.Set{Base.UUID}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}})
precompile(Tuple{typeof(Base.union), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int64}}, Base.Threads.Atomic{Int64}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{LibGit2.GitHash}}, Base.RefValue{LibGit2.GitHash}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{Nothing}}, Ptr{Nothing}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{Ptr{Nothing}}}, Array{Ptr{Nothing}, 1}})
precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{UInt64}}, Base.Threads.Atomic{UInt64}})
precompile(Tuple{typeof(Base.values), Base.Dict{Any, Any}})
precompile(Tuple{typeof(Base.values), Base.Dict{String, Any}})
precompile(Tuple{typeof(Base.values), Base.Dict{String, String}})
precompile(Tuple{typeof(Base.vcat), Array{Pkg3.Types.VersionRange, 1}, Array{Pkg3.Types.VersionRange, 1}, Array{Pkg3.Types.VersionRange, 1}, Array{Pkg3.Types.VersionRange, 1}})
precompile(Tuple{typeof(Base.vcat), Array{Pkg3.Types.VersionRange, 1}, Array{Pkg3.Types.VersionRange, 1}})
precompile(Tuple{typeof(Base.vcat), Array{Pkg3.Types.VersionRange, 1}})
precompile(Tuple{typeof(Base.vcat), Base.BitArray{1}, Base.BitArray{1}, Base.BitArray{1}})
precompile(Tuple{typeof(Base.vcat), Base.BitArray{1}, Base.BitArray{1}})
precompile(Tuple{typeof(Base.vcat), Base.BitArray{1}})
precompile(Tuple{typeof(Base.vcat), Base.BitArray{2}, Base.BitArray{2}, Base.BitArray{2}})
precompile(Tuple{typeof(Base.vcat), Base.BitArray{2}, Base.BitArray{2}})
precompile(Tuple{typeof(Base.vcat), Base.BitArray{2}})
precompile(Tuple{typeof(Base.vcat)})
precompile(Tuple{typeof(Base.vect), Nothing})
precompile(Tuple{typeof(Base.vect), String, Base.VersionNumber, String, String})
precompile(Tuple{typeof(Base.vect), String, Base.VersionNumber})
precompile(Tuple{typeof(Base.vect), Tuple{String, Base.VersionNumber}})
precompile(Tuple{typeof(Base.version_slug), Base.UUID, Base.SHA1})
precompile(Tuple{typeof(Base.view), Array{UInt8, 1}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.write), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{UInt8, 1}})
precompile(Tuple{typeof(Base.write), String, Array{UInt8, 1}})
precompile(Tuple{typeof(Core.Compiler.collect), Type{Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Core.Compiler.collect), Type{Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{Array{Base.StackTraces.StackFrame, 1}, 1}}})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{Array{Pkg3.Types.VersionRange, 1}, 1}}})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{Base.BitArray{2}, 1}}})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, 1}}})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{LibGit2.GitCommit, 1}}})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{UInt32, 1}}})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Base.__atreplinit)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_add_or_develop!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_build!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_free!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_free!)},Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_gc!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_generate!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_help!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_help!)},Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_init!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_init!)},Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_pin!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_rm!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_status!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_test!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_test!)},Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_up!)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), typeof(Pkg3.Pkg2.Reqs.read)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), typeof(Pkg3.TOML.parse)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), typeof(Pkg3.Types.read_manifest)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), typeof(Pkg3.Types.read_project)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.warn)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Pkg3.API.add)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.IteratorsMD.CartesianIndex{0}}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Missing}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Base.Val{1}, Union}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Bool, typeof(Pkg3.Types.parse_toml)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Int64, Int64, Int64}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Int64, Tuple{Int64, Tuple{Int64, Tuple{Int64, Tuple{}}}}}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Int64, typeof(Base.replace), Nothing}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Nothing, Int64, typeof(Base.sprint), typeof(Base.showerror)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Nothing, Int64, typeof(Base.sprint), typeof(Pkg3.GraphType.showlog)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Nothing, Nothing}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{String, typeof(Base.info)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{UInt128, UInt128}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{UInt32}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{typeof(Pkg3.BinaryProvider.parse_tar_list)}, Int64})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, Bool, typeof(Pkg3.Types.parse_toml), Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, Core.SSAValue, Bool, Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, Core.SlotNumber, QuoteNode, Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, Core.SlotNumber, String, Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, Int64, Core.SSAValue, Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, Int64, typeof(Base.replace), Nothing, Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, Nothing, Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, QuoteNode, typeof(Base.warn), Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, String, String, Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, GlobalRef, String, typeof(Base.info), Expr})
precompile(Tuple{typeof(Core.Compiler.getindex), Type{Any}, Tuple{Symbol}, Tuple{}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Base.__atreplinit)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_add_or_develop!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_build!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_free!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_gc!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_generate!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_help!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_init!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_pin!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_rm!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_status!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_test!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest), typeof(Pkg3.REPLMode.do_up!)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), typeof(Pkg3.Pkg2.Reqs.read)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), typeof(Pkg3.TOML.parse)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), typeof(Pkg3.Types.read_manifest)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), typeof(Pkg3.Types.read_project)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.warn)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Pkg3.API.add)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.IteratorsMD.CartesianIndex{0}}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Missing}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Base.Val{1}, Union}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Bool, typeof(Pkg3.Types.parse_toml)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Int64, Int64, Int64}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Int64, typeof(Base.replace), Nothing}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Nothing, Int64, typeof(Base.sprint), typeof(Base.showerror)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Nothing, Int64, typeof(Base.sprint), typeof(Pkg3.GraphType.showlog)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{Nothing, Nothing}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{String, typeof(Base.info)}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{UInt128, UInt128}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{UInt32}})
precompile(Tuple{typeof(Core.Compiler.length), Tuple{typeof(Pkg3.BinaryProvider.parse_tar_list)}})
precompile(Tuple{typeof(Core.Compiler.return_type), typeof(Base._views), Type{Tuple{Any}}})
precompile(Tuple{typeof(Core.Compiler.scan_expr_use!), Core.Compiler.ValueInfoMap, Array{Any, 1}, Int64, Tuple{Int64, Int64}, Core.CodeInfo})
precompile(Tuple{typeof(Core.Compiler.scan_expr_use!), Core.Compiler.ValueInfoMap, Array{Any, 1}, Int64, Tuple{Tuple{}}, Core.CodeInfo})
precompile(Tuple{typeof(Core.Compiler.scan_expr_use!), Core.Compiler.ValueInfoMap, Array{Any, 1}, Int64, UInt128, Core.CodeInfo})
precompile(Tuple{typeof(Core.Compiler.typeinf_type), Method, Type{Tuple{typeof(Base._views), Expr}}, Core.SimpleVector, Bool, Core.Compiler.Params})
precompile(Tuple{typeof(LibGit2.commit), LibGit2.GitRepo, String, String, LibGit2.GitSignature, LibGit2.GitSignature, LibGit2.GitTree, LibGit2.GitCommit})
precompile(Tuple{typeof(LibGit2.commit), LibGit2.GitRepo, String, String, LibGit2.GitSignature, LibGit2.GitSignature, LibGit2.GitTree})
precompile(Tuple{typeof(LibGit2.peel), Type{LibGit2.GitTree}, LibGit2.GitCommit})
precompile(Tuple{typeof(LibGit2.peel), Type{LibGit2.GitTree}, LibGit2.GitTree})
precompile(Tuple{typeof(Pkg3.API.entrypoint), String, String})
precompile(Tuple{typeof(Pkg3.API.project), String, String})
precompile(Tuple{typeof(Pkg3.Display.filter_manifest), Pkg3.Display.InProject{Base.Dict{String, Any}}, Base.Dict{String, Any}})
precompile(Tuple{typeof(Pkg3.Display.in_project), Base.Dict{String, Any}})
precompile(Tuple{typeof(Pkg3.Display.manifest_diff), Pkg3.Types.Context, Base.Dict{String, Any}, Base.Dict{String, Any}})
precompile(Tuple{typeof(Pkg3.Display.name_ver_info), Base.Dict{String, Any}})
precompile(Tuple{typeof(Pkg3.Display.not_in_project), Base.Dict{String, Any}})
precompile(Tuple{typeof(Pkg3.Display.print_diff), Base.TTY, Pkg3.Types.Context, Array{Pkg3.Display.DiffEntry, 1}})
precompile(Tuple{typeof(Pkg3.GraphType.showlog), Base.GenericIOBuffer{Array{UInt8, 1}}, Pkg3.GraphType.ResolveLog, Base.UUID})
precompile(Tuple{typeof(Pkg3.Operations.install_archive), Array{String, 1}, Base.VersionNumber, String})
precompile(Tuple{typeof(Pkg3.REPLMode.create_mode), REPL.LineEditREPL, REPL.LineEdit.Prompt})
precompile(Tuple{typeof(Pkg3.REPLMode.do_cmd), REPL.LineEditREPL, String})
precompile(Tuple{typeof(Pkg3.REPLMode.parse_option), Base.SubString{String}})
precompile(Tuple{typeof(Pkg3.Resolve.MaxSum.decimate!), Pkg3.GraphType.Graph, Pkg3.Resolve.MaxSum.SolutionTrace, Pkg3.Resolve.MaxSum.Messages, Int64})
precompile(Tuple{typeof(Pkg3.Resolve.sanity_check), Pkg3.GraphType.Graph, Base.Set{Base.UUID}, Bool})
precompile(Tuple{typeof(Pkg3.TOML.SOME), Array{String, 1}})
precompile(Tuple{typeof(Pkg3.TOML.SOME), Pkg3.TOML.Table})
precompile(Tuple{typeof(Pkg3.TOML.insertpair), Pkg3.TOML.Parser{Base.GenericIOBuffer{Array{UInt8, 1}}}, Pkg3.TOML.Table, String, Dates.DateTime, Int64})
precompile(Tuple{typeof(Pkg3.TOML.insertpair), Pkg3.TOML.Parser{Base.IOStream}, Pkg3.TOML.Table, String, Array{String, 1}, Int64})
precompile(Tuple{typeof(Pkg3.TOML.insertpair), Pkg3.TOML.Parser{Base.IOStream}, Pkg3.TOML.Table, String, Bool, Int64})
precompile(Tuple{typeof(Pkg3.TOML.insertpair), Pkg3.TOML.Parser{Base.IOStream}, Pkg3.TOML.Table, String, String, Int64})
precompile(Tuple{typeof(Pkg3.Types.pkgID), Base.UUID, Pkg3.GraphType.Graph})
precompile(Tuple{typeof(Pkg3.Types.printpkgstyle), Base.TTY, Symbol, String, String})
precompile(Tuple{typeof(Pkg3.Types.printpkgstyle), Pkg3.Types.Context, Symbol, String, String})
precompile(Tuple{typeof(REPL.LineEdit.complete_line), Pkg3.REPLMode.PkgCompletionProvider, REPL.LineEdit.PromptState})
precompile(Tuple{typeof(REPL.LineEdit.edit_splice!), REPL.LineEdit.PromptState, Base.Pair{Int64, Int64}, String})
precompile(Tuple{typeof(REPL.LineEdit.fixup_keymaps!), Base.Dict{Char, Any}, Int64, Char, Nothing})
precompile(Tuple{typeof(REPL.LineEdit.region_active), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(REPL.LineEdit.setup_prefix_keymap), REPL.REPLHistoryProvider, REPL.LineEdit.Prompt})
precompile(Tuple{typeof(REPL.LineEdit.setup_search_keymap), REPL.REPLHistoryProvider})

precompile(Tuple{typeof(REPL.LineEdit.complete_line), Pkg3.REPLMode.PkgCompletionProvider, REPL.LineEdit.PromptState})

@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_help!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}, REPL.LineEditREPL})
@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_status!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}})
@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_add_or_develop!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}, Pkg3.REPLMode.CommandKind})
@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_rm!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}})
@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_up!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}})
@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_pin!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}})
@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_free!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}})
@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_test!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}})
@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_build!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}})

@assert precompile(Tuple{Type{Pkg3.GraphType.GraphData}, Dict{UUID,Set{VersionNumber}},
       Dict{UUID,Dict{VersionRange,Dict{String,UUID}}},
       Dict{UUID,Dict{VersionRange,Dict{String,VersionSpec}}},
       Dict{UUID,String}})

@assert precompile(Tuple{Type{Pkg3.GraphType.Graph},Dict{UUID,Set{VersionNumber}},
                                            Dict{UUID,Dict{VersionRange,Dict{String,UUID}}},
                                            Dict{UUID,Dict{VersionRange,Dict{String,VersionSpec}}},
                                            Dict{UUID,String},
                                            Requires,
                                            Dict{UUID,Pkg3.Types.Fixed},
                                            Bool})

@assert precompile(Tuple{typeof(Pkg3.Resolve.simplify_graph!), Pkg3.GraphType.Graph, Set{Int}})

max_stars_repo_name: djsegal/julia-fork

max_issues_repo_name: djsegal/julia-fork

max_forks_repo_name: djsegal/julia-fork


text:
__precompile__(true)

using Base.Dates, Reactive, Match, TimeSeries, Compat

module TradingLogic

using Base.Dates, Reactive, Match, TimeSeries, Compat

export runtrading!, runbacktest, runbacktesttarg
export emptyblotter, printblotter, writeblotter
export tradeperfcurr, tradeperf, tradepnlfinal, vtradespnl, perf_prom

# general components
include("sigutils.jl")
include("types.jl")
include("errorhandl.jl")
include("exchange.jl")
include("orderhandl.jl")
include("performance.jl")

# specific trading strategy examples
include("strategies/goldencross.jl")
include("strategies/luxor.jl")

"Event-driven backtesting / live trading."
:runtrading!

"""
Backtesting or real-time order submission with status output.

Input:

- `blotter` (could be initially empty) to write transactions to,
as an associative collection DateTime => (Qty::Int64, FillPrice::Float64)`;
- `backtest` is `Bool`, live trading performed if `false`;
- `s_ohlc` is tuple-valued `(DateTime, Vector-ohlc)` signal;
- `ohlc_inds` provides index correspondence in Vector-ohlc;
- `s_pnow` is instantaneous price signal;
- `position_initial` corresponds to the first timestep;
- `targetfun` is the trading strategy function generating
`(poschg::Int64, Vector[limitprice, stopprice]` signal;
- additional arguments `...` to be passed to `targetfun`: these would
most commonly be trading strategy parameters.

In-place modifies `blotter` (adds transactions to it).

Returns tuple-signal with:

* the overall status of the trading system (false if problems are detected);
* current cumulative profit/loss since the signals were initiated (i.e. since
the beginning of the trading session).

See `orderhandling!` for the PnL details.
"""
function runtrading!(blotter::Blotter,
                     backtest::Bool,
                     s_ohlc::Signal{OHLC},
                     ohlc_inds::Dict{Symbol,Int64},
                     s_pnow::Signal{Float64},
                     position_initial::Int64,
                     targetfun::Function, strategy_args...)
  # set initial position in a mutable object
  # NOTE: using closures to deal with a cyclic part of the signal graph
  # (for the actual position and current order updates) since
  # concurrent reactive programming is outside the scope of Reactive.jl
  position_actual_mut = [position_initial]

  # target signal: strategy-specific
  ##s_target = apply(targetfun, tuple(s_ohlc, ohlc_inds,
  ##                                  position_actual_mut, strategy_args...))
  s_target = targetfun(tuple(s_ohlc, ohlc_inds,
                                    position_actual_mut, strategy_args...)...)

  # current time signal from OHLC timestamp
  s_tnow = Reactive.map(s -> s[1], s_ohlc, typ=DateTime)

  # general order handling part
  order_current = emptyorder()
  s_overallstatus = map(
    (tgt, pnow, tnow) -> orderhandling!(tgt, pnow, tnow,
                                        position_actual_mut,
                                        order_current,
                                        blotter, backtest),
    s_target, s_pnow, s_tnow, typ=@compat(Tuple{Bool,Float64}))
  # error notification
  map(s -> tradesyserror(s[1]), s_overallstatus, typ=Bool)

  return s_overallstatus
end

"""
Backtesting process with final position and targets included in the output.

Input: `backtest = true` enforced. Error notification function is
not called (check the status-output signal tuple).

Return tuple components:

* `s_overallstatus` tuple-signal;
* current position single-element mutable array with `Int64` value;
* current target signal per targeting function output.

This method is useful for feeding current step's targets
to some external code.
"""
function runtrading!(blotter::Blotter,
                     s_ohlc::Signal{OHLC},
                     ohlc_inds::Dict{Symbol,Int64},
                     s_pnow::Signal{Float64},
                     position_initial::Int64,
                     targetfun::Function, strategy_args...)
  backtest = true
  position_actual_mut = [position_initial]

  # target signal: strategy-specific
  ##s_target = apply(targetfun, tuple(s_ohlc, ohlc_inds,
  ##                                  position_actual_mut, strategy_args...))
  s_target = targetfun(tuple(s_ohlc, ohlc_inds,
                                    position_actual_mut, strategy_args...)...)

  # current time signal from OHLC timestamp
  s_tnow = Reactive.map(s -> s[1], s_ohlc, typ=DateTime)

  # general order handling part
  order_current = emptyorder()
  s_overallstatus = map(
    (tgt, pnow, tnow) -> orderhandling!(tgt, pnow, tnow,
                                        position_actual_mut,
                                        order_current,
                                        blotter, backtest),
    s_target, s_pnow, s_tnow, typ=@compat(Tuple{Bool,Float64}))

  return s_overallstatus, position_actual_mut, s_target
end

"""
Backtesting run with OHLC timearray input.
Selected performance metrics and equity curve in the output.

Input:

- `ohlc_ta` timearray with OHLC data along with any other input values
provided at each timestep for the trading strategy use;
- `ohlc_inds` provides index correspondence for `ohlc_ta.colnames`;
**at least** the index of `:close` has to be specified.
- `fileout` filename with path or `nothing` to suppress output at each step;
- `dtformat_out` formats `DateTime` in `fileout`
(use e.g. `""` if not writing the output)
- `pfill` specifies price symbol in `ohlc_inds` to use for filling orders
at next-timestep after placement. Commonly set to open price.
**NOTE**: final performance metrics are using `:close` at the last timestep.
- `position_initial` corresponds to the first timestep;
- `targetfun` is the trading strategy function generating
`(poschg::Int64, Vector[limitprice, stopprice]` signal;
- additional arguments `...` to be passed to `targetfun`: these would
most commonly be trading strategy parameters.

Returns tuple with:

* `Float64` final cumulative profit/loss;
* `Float64` maximum return-based drawdown;
* transaction blotter as an associative collection;
* `Vector{Float64}` equity curve (values for each timestep of `ohlc_ta`).

Make sure to suppress output file when using within
optimization objective function to improve performance.
"""
function runbacktest{M}(ohlc_ta::TimeSeries.TimeArray{Float64,2,M},
                        ohlc_inds::Dict{Symbol,Int64},
                        fileout::Union{Void,AbstractString},
                        dtformat_out,
                        pfill::Symbol,
                        position_initial::Int64,
                        targetfun::Function, strategy_args...)
  # initialize signals
  s_ohlc = Signal((Dates.DateTime(ohlc_ta.timestamp[1]),
                   vec(ohlc_ta.values[1,:])))
  s_pnow = map(s -> s[2][ohlc_inds[pfill]], s_ohlc, typ=Float64)
  blotter = emptyblotter()
  s_status = runtrading!(blotter, true, s_ohlc, ohlc_inds, s_pnow,
                         position_initial, targetfun, strategy_args...)
  s_perf = tradeperfcurr(s_status)

  # core of the backtest run
  vequity = runbacktestcore(ohlc_ta, s_ohlc, s_status, s_perf,
                            fileout, dtformat_out)

  # finalize perf. metrics at the last step close-price
  pfinal = s_ohlc.value[2][ohlc_inds[:close]]
  pnlfin = tradepnlfinal(blotter, pfinal)
  pnlmax = s_perf.value[1] > pnlfin ? s_perf.value[1] : pnlfin
  ddownfin = pnlfin - pnlmax
  ddownmax = s_perf.value[2] > ddownfin ? s_perf.value[2] : ddownfin

  # FinalPnL, MaxDDown, blotter, equity curve
  return pnlfin, ddownmax, blotter, vequity
end

"""
Similar to `runbacktest` but instead of performance metrics,
current position and targets from the latest step are included
in the output.

Input: same as `runbacktest`.

Return tuple components:

* transaction blotter as an associative collection;
* `Int64` position as of the latest timestep;
* `Targ` targeting tuple as of the latest timestep.

This function is useful to run through a recent historical period and
determine the latest timestep actions.
"""
function runbacktesttarg{M}(ohlc_ta::TimeSeries.TimeArray{Float64,2,M},
                            ohlc_inds::Dict{Symbol,Int64},
                            fileout::Union{Void,AbstractString},
                            dtformat_out,
                            pfill::Symbol,
                            position_initial::Int64,
                            targetfun::Function, strategy_args...)
  # initialize signals
  s_ohlc = Signal((Dates.DateTime(ohlc_ta.timestamp[1]),
                   vec(ohlc_ta.values[1,:])))
  nt = length(ohlc_ta)
  s_pnow = map(s -> s[2][ohlc_inds[pfill]], s_ohlc, typ=Float64)
  blotter = emptyblotter()

  # using method with targeting info output
  s_status, pos_act_mut, s_targ = runtrading!(
    blotter, s_ohlc, ohlc_inds, s_pnow, position_initial,
    targetfun, strategy_args...)
  s_perf = tradeperfcurr(s_status)

  # core of the backtest run
  vequity = runbacktestcore(ohlc_ta, s_ohlc, s_status, s_perf,
                            fileout, dtformat_out)

  # blotter, latest position, latest targets
  ##println("timestep")
  ##println(s_ohlc.value[1])
  if haskey(blotter, s_ohlc.value[1])
    # current step had position update;
    # avoid double action, be consistent with orderhandling!:
    # no forther target position change at this step
    newtarg = 0
  else
    newtarg = s_targ.value
  end

  return blotter, pos_act_mut[1], newtarg
end

"Core of the backtest run."
function runbacktestcore{M}(ohlc_ta::TimeSeries.TimeArray{Float64,2,M},
                            s_ohlc::Signal{OHLC},
                            s_status::Signal{@compat(Tuple{Bool, Float64})},
                            s_perf::Signal{@compat(Tuple{Float64, Float64})},
                            fileout::Union{Void,AbstractString},
                            dtformat_out)
  nt = length(ohlc_ta)
  vequity = zeros(nt)

  if fileout == nothing
    writeout = false
  else
    # prepare file to write to at each timestep
    fout = open(fileout, "w")
    separator = ','; quotemark = '"'
    rescols = ["Timestamp"; ohlc_ta.colnames; "CumPnL"; "DDown"]
    printvecstring(fout, rescols, separator, quotemark)
    writeout = true
  end
  for i = 1:nt
    if i > 1
      # first timestep already initialized all the signals
      push!(s_ohlc, (Dates.DateTime(ohlc_ta.timestamp[i]),
                     vec(ohlc_ta.values[i,:])))
    end
    pnlcum = s_status.value[2]
    vequity[i] = pnlcum
    if writeout
      # print current step info: timestamp
      print(fout, quotemark)
      print(fout, Dates.format(s_ohlc.value[1], dtformat_out))
      print(fout, quotemark); print(fout, separator)
      # OHLC timearray columns
      print(fout, join(s_ohlc.value[2], separator))
      print(fout, separator)
      # trading performance
      ddownnow = pnlcum - s_perf.value[1]
      print(fout, pnlcum) #CumPnL
      print(fout, separator)
      print(fout, ddownnow) #DDown
      print(fout, '\n')
    end
  end
  if writeout
    close(fout)
  end

  return vequity
end

end # module

ext: jl


text:
add_verbose_scope(:NfMaxOrd)
add_assert_scope(:NfMaxOrd)

#set_verbose_level(:NfMaxOrd, 1)

include("NfMaxOrd/NfMaxOrd.jl")
include("NfMaxOrd/Ideal.jl")
include("NfMaxOrd/Zeta.jl")
include("NfMaxOrd/FracIdl.jl")
include("NfMaxOrd/Clgp.jl")
include("NfMaxOrd/Unit.jl")
include("NfMaxOrd/ResidueField.jl")
include("NfMaxOrd/ResidueRing.jl")
include("NfMaxOrd/FactorBaseBound.jl")
include("NfMaxOrd/FacElem.jl")
include("NfMaxOrd/LinearAlgebra.jl")