text:
precompile(Tuple{typeof(Base.tuple_type_tail), Type})
precompile(Tuple{typeof(Base.argtail), Type, Type})
precompile(Tuple{typeof(Base.argtail), Type})
precompile(Tuple{typeof(Base._compute_eltype), Any})
precompile(Tuple{typeof(Base.iterate), Base.IdSet{Any}})
precompile(Tuple{typeof(Base.convert), Type{Any}, Type})
precompile(Tuple{typeof(Base.iterate), Base.IdSet{Any}, Int64})
precompile(Tuple{typeof(Base.afoldl), Base.var"#42#43", Type, Type, Type, Type, Type, Type, Type})
precompile(Tuple{Core.Compiler.var"#256#258"{DataType, Tuple{InMemoryDatasets.HeapSortAlg, Bool, Bool, Bool, Bool}}, Int64})
precompile(Tuple{Core.Compiler.var"#256#258"{DataType, Tuple{Base.Missing}}, Int64})
precompile(Tuple{typeof(Base.print_to_string), Int64, Vararg{Int64, N} where N})
precompile(Tuple{Type{Base.Pair{Symbol, Any}}, Any, Any})
precompile(Tuple{typeof(Base.convert), Type{Any}, Array{Int64, 1}})
precompile(Tuple{typeof(Base.convert), Type{Any}, Array{Float64, 1}})
precompile(Tuple{typeof(Base.convert), Type{Any}, Array{Dates.Date, 1}})
precompile(Tuple{typeof(Base.convert), Type{Any}, Array{InMemoryDatasets.Characters{2, UInt8}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Any}, Array{Int32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Any}, Array{Float32, 1}})
precompile(Tuple{typeof(Base.length), Array{Float64, 1}})
precompile(Tuple{typeof(Base.length), Array{Dates.Date, 1}})
precompile(Tuple{typeof(Base.length), Array{InMemoryDatasets.Characters{2, UInt8}, 1}})
precompile(Tuple{typeof(Base.length), Array{Float32, 1}})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{Int64, 1}, Int64, Bool})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{Float64, 1}, Int64, Bool})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{Dates.Date, 1}, Int64, Bool})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), String, Int64, Bool})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{InMemoryDatasets.Characters{2, UInt8}, 1}, Int64, Bool})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{Int32, 1}, Int64, Bool})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{Float32, 1}, Int64, Bool})
precompile(Tuple{typeof(Base.firstindex), Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{typeof(Base.firstindex), Array{Union{Base.Missing, Float64}, 1}})
precompile(Tuple{typeof(Base.firstindex), Array{Union{Base.Missing, Dates.Date}, 1}})
precompile(Tuple{typeof(Base.firstindex), Array{Union{Base.Missing, String}, 1}})
precompile(Tuple{typeof(Base.firstindex), Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}})
precompile(Tuple{typeof(Base.firstindex), Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{typeof(Base.firstindex), Array{Union{Base.Missing, Float32}, 1}})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Dates.Date}, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, String}, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int32}, 1}, Int64})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Int64})
precompile(Tuple{typeof(Base.length), Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{typeof(InMemoryDatasets.ds_sort_perm), InMemoryDatasets.Dataset, Array{Int64, 1}, Array{Function, 1}, Array{Bool, 1}, InMemoryDatasets.HeapSortAlg, Base.Val{Int32}})
precompile(Tuple{typeof(Base.Threads.threading_run), Function})
precompile(Tuple{InMemoryDatasets.var"#1275#threadsfor_fun#503"{Array{Int32, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._apply_by), Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, Function, Bool})
precompile(Tuple{typeof(InMemoryDatasets._apply_by_f_barrier), Array{Union{Base.Missing, Int64}, 1}, typeof(Base.identity), Bool})
precompile(Tuple{typeof(Core.Compiler.return_type), Any, Any})
precompile(Tuple{typeof(Core.Compiler.return_type), Any, Any, UInt64})
precompile(Tuple{typeof(Core.Compiler.return_type), Core.Compiler.NativeInterpreter, Any, Any})
precompile(Tuple{typeof(Core.Compiler.contains_is), Core.SimpleVector, Any})
precompile(Tuple{Type{Array{Union{Base.Missing, Int64}, 1}}, UndefInitializer, Int64})
precompile(Tuple{typeof(InMemoryDatasets._apply_by!), Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Bool, Bool, Symbol})
precompile(Tuple{InMemoryDatasets.var"#1209#threadsfor_fun#499"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets.hp_minimum), Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{typeof(InMemoryDatasets.hp_minimum), Function, Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{InMemoryDatasets.var"#215#threadsfor_fun#94"{typeof(Base.identity), Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, Int64, Int64, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"##stat_minimum#67", Int64, Int64, typeof(InMemoryDatasets.stat_minimum), typeof(Base.identity), Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Integer}, Int64})
precompile(Tuple{typeof(InMemoryDatasets.hp_maximum), Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{typeof(InMemoryDatasets.hp_maximum), Function, Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{InMemoryDatasets.var"#200#threadsfor_fun#93"{typeof(Base.identity), Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, Int64, Int64, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"##stat_maximum#64", Int64, Int64, typeof(InMemoryDatasets.stat_maximum), typeof(Base.identity), Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{typeof(Base.Checked.sub_with_overflow), Int64, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int64, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int64, Bool}, Int64, Int64})
precompile(Tuple{typeof(Base.Checked.add_with_overflow), Int64, Int64})
precompile(Tuple{typeof(Base.:(<)), Int64, Float64})
precompile(Tuple{typeof(Base.resize!), Array{Int32, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets.hp_ds_sort_int!), Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, Array{Int32, 1}, Array{Array{Int32, 1}, 1}, Int64, Int64, Bool, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering})
precompile(Tuple{InMemoryDatasets.var"#1120#threadsfor_fun#490"{Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, Array{Int32, 1}, Array{Array{Int32, 1}, 1}, Int64, Int64, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1067#threadsfor_fun#489"{Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, Base.Order.ForwardOrdering, Array{Int32, 1}, Array{Union{Base.Missing, Int64}, 1}, Base.StepRange{Int64, Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._fill_starts_v2!), Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, Int64}, 1}, Int32, Base.Order.ForwardOrdering, Base.Val{Int32}})
precompile(Tuple{InMemoryDatasets.var"#1011#threadsfor_fun#486"{Array{Int32, 1}, Array{Bool, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1026#threadsfor_fun#487"{Int32, Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, Int64}, 1}, Int32, Base.Order.ForwardOrdering, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(Base.:(==)), Int64, Int32})
precompile(Tuple{typeof(InMemoryDatasets._stablise_sort!), Array{Int32, 1}, Array{Int32, 1}, Int32, InMemoryDatasets.HeapSortAlg})
precompile(Tuple{InMemoryDatasets.var"#1311#threadsfor_fun#510"{Array{Int32, 1}, Array{Int32, 1}, Int32, InMemoryDatasets.HeapSortAlg, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._apply_by), Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}, Function, Bool})
precompile(Tuple{typeof(InMemoryDatasets._apply_by_f_barrier), Array{Union{Base.Missing, Float64}, 1}, typeof(Base.identity), Bool})
precompile(Tuple{Type{Array{Union{Base.Missing, Float64}, 1}}, UndefInitializer, Int64})
precompile(Tuple{typeof(InMemoryDatasets._apply_by!), Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Bool, Bool, Symbol})
precompile(Tuple{InMemoryDatasets.var"#1209#threadsfor_fun#499"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1225#threadsfor_fun#500"{Array{Union{Base.Missing, Float64}, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets.hp_ds_sort!), Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering})
precompile(Tuple{InMemoryDatasets.var"#1052#threadsfor_fun#488"{Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1067#threadsfor_fun#489"{Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}, Base.Order.ForwardOrdering, Array{Int32, 1}, Array{Union{Base.Missing, Float64}, 1}, Base.StepRange{Int64, Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._fill_starts_v2!), Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, Float64}, 1}, Int32, Base.Order.ForwardOrdering, Base.Val{Int32}})
precompile(Tuple{InMemoryDatasets.var"#1026#threadsfor_fun#487"{Int32, Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, Float64}, 1}, Int32, Base.Order.ForwardOrdering, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._apply_by), Array{Union{Base.Missing, Dates.Date}, 1}, Array{Int32, 1}, Function, Bool})
precompile(Tuple{typeof(InMemoryDatasets._apply_by_f_barrier), Array{Union{Base.Missing, Dates.Date}, 1}, typeof(Base.identity), Bool})
precompile(Tuple{typeof(InMemoryDatasets._apply_by!), Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Dates.Date}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Bool, Bool, Symbol})
precompile(Tuple{InMemoryDatasets.var"#1209#threadsfor_fun#499"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Dates.Date}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets.hp_ds_sort!), Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering})
precompile(Tuple{InMemoryDatasets.var"#1052#threadsfor_fun#488"{Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._apply_by), Array{Union{Base.Missing, String}, 1}, Array{Int32, 1}, Function, Bool})
precompile(Tuple{typeof(InMemoryDatasets._apply_by_f_barrier), Array{Union{Base.Missing, String}, 1}, typeof(Base.identity), Bool})
precompile(Tuple{Type{Array{Union{Base.Missing, String}, 1}}, UndefInitializer, Int64})
precompile(Tuple{typeof(InMemoryDatasets._apply_by!), Array{Union{Base.Missing, String}, 1}, Array{Union{Base.Missing, String}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Bool, Bool, Symbol})
precompile(Tuple{InMemoryDatasets.var"#1209#threadsfor_fun#499"{Array{Union{Base.Missing, String}, 1}, Array{Union{Base.Missing, String}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets.hp_ds_sort!), Array{Union{Base.Missing, String}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering})
precompile(Tuple{InMemoryDatasets.var"#1052#threadsfor_fun#488"{Array{Union{Base.Missing, String}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1067#threadsfor_fun#489"{Array{Union{Base.Missing, String}, 1}, Array{Int32, 1}, Base.Order.ForwardOrdering, Array{Int32, 1}, Array{Union{Base.Missing, String}, 1}, Base.StepRange{Int64, Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._fill_starts_v2!), Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, String}, 1}, Int32, Base.Order.ForwardOrdering, Base.Val{Int32}})
precompile(Tuple{InMemoryDatasets.var"#1026#threadsfor_fun#487"{Int32, Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, String}, 1}, Int32, Base.Order.ForwardOrdering, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._apply_by), Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Int32, 1}, Function, Bool})
precompile(Tuple{typeof(InMemoryDatasets._apply_by_f_barrier), Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, typeof(Base.identity), Bool})
precompile(Tuple{Type{Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}}, UndefInitializer, Int64})
precompile(Tuple{typeof(InMemoryDatasets._apply_by!), Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Bool, Bool, Symbol})
precompile(Tuple{InMemoryDatasets.var"#1209#threadsfor_fun#499"{Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets.hp_ds_sort!), Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering})
precompile(Tuple{InMemoryDatasets.var"#1052#threadsfor_fun#488"{Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1067#threadsfor_fun#489"{Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Int32, 1}, Base.Order.ForwardOrdering, Array{Int32, 1}, Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Base.StepRange{Int64, Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._fill_starts_v2!), Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Int32, Base.Order.ForwardOrdering, Base.Val{Int32}})
precompile(Tuple{InMemoryDatasets.var"#1026#threadsfor_fun#487"{Int32, Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Int32, Base.Order.ForwardOrdering, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._apply_by), Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}, Function, Bool})
precompile(Tuple{typeof(InMemoryDatasets._apply_by_f_barrier), Array{Union{Base.Missing, Int32}, 1}, typeof(Base.identity), Bool})
precompile(Tuple{Type{Array{Union{Base.Missing, Int32}, 1}}, UndefInitializer, Int64})
precompile(Tuple{typeof(InMemoryDatasets._apply_by!), Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Bool, Bool, Symbol})
precompile(Tuple{InMemoryDatasets.var"#1209#threadsfor_fun#499"{Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(Base.length), Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{typeof(InMemoryDatasets.hp_minimum), Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{typeof(InMemoryDatasets.hp_minimum), Function, Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{InMemoryDatasets.var"#215#threadsfor_fun#94"{typeof(Base.identity), Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, Int64, Int64, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"##stat_minimum#67", Int64, Int64, typeof(InMemoryDatasets.stat_minimum), typeof(Base.identity), Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{typeof(Base.convert), Type{Integer}, Int32})
precompile(Tuple{typeof(InMemoryDatasets.hp_maximum), Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{typeof(InMemoryDatasets.hp_maximum), Function, Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{InMemoryDatasets.var"#200#threadsfor_fun#93"{typeof(Base.identity), Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, Int64, Int64, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"##stat_maximum#64", Int64, Int64, typeof(InMemoryDatasets.stat_maximum), typeof(Base.identity), Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{typeof(Base.Checked.sub_with_overflow), Int32, Int32})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int32, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int32, Bool}, Int64, Int64})
precompile(Tuple{typeof(Base.Checked.add_with_overflow), Int32, Int32})
precompile(Tuple{typeof(Base.:(<)), Int32, Float64})
precompile(Tuple{typeof(InMemoryDatasets.hp_ds_sort_int!), Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}, Array{Int32, 1}, Array{Array{Int32, 1}, 1}, Int32, Int32, Bool, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering})
precompile(Tuple{InMemoryDatasets.var"#1120#threadsfor_fun#490"{Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}, Array{Int32, 1}, Array{Array{Int32, 1}, 1}, Int32, Int32, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1067#threadsfor_fun#489"{Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}, Base.Order.ForwardOrdering, Array{Int32, 1}, Array{Union{Base.Missing, Int32}, 1}, Base.StepRange{Int64, Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._fill_starts_v2!), Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, Int32}, 1}, Int32, Base.Order.ForwardOrdering, Base.Val{Int32}})
precompile(Tuple{InMemoryDatasets.var"#1026#threadsfor_fun#487"{Int32, Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, Int32}, 1}, Int32, Base.Order.ForwardOrdering, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._apply_by), Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}, Function, Bool})
precompile(Tuple{typeof(InMemoryDatasets._apply_by_f_barrier), Array{Union{Base.Missing, Float32}, 1}, typeof(Base.identity), Bool})
precompile(Tuple{Type{Array{Union{Base.Missing, Float32}, 1}}, UndefInitializer, Int64})
precompile(Tuple{typeof(InMemoryDatasets._apply_by!), Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Bool, Bool, Symbol})
precompile(Tuple{InMemoryDatasets.var"#1209#threadsfor_fun#499"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}, InMemoryDatasets.var"#496#498"{typeof(Base.identity)}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets.hp_ds_sort!), Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering})
precompile(Tuple{InMemoryDatasets.var"#1052#threadsfor_fun#488"{Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}, InMemoryDatasets.HeapSortAlg, Base.Order.ForwardOrdering, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1067#threadsfor_fun#489"{Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}, Base.Order.ForwardOrdering, Array{Int32, 1}, Array{Union{Base.Missing, Float32}, 1}, Base.StepRange{Int64, Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._fill_starts_v2!), Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, Float32}, 1}, Int32, Base.Order.ForwardOrdering, Base.Val{Int32}})
precompile(Tuple{InMemoryDatasets.var"#1026#threadsfor_fun#487"{Int32, Array{Int32, 1}, Array{Bool, 1}, Array{Union{Base.Missing, Float32}, 1}, Int32, Base.Order.ForwardOrdering, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets.ds_sort_perm), InMemoryDatasets.Dataset, Base.UnitRange{Int64}, Array{Function, 1}, Array{Bool, 1}, InMemoryDatasets.HeapSortAlg, Base.Val{Int32}})
precompile(Tuple{InMemoryDatasets.var"#1194#threadsfor_fun#494"{Array{Int32, 1}, Array{Int32, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, Array{Array{Int32, 1}, 1}, Int32, Bool, Base.Order.ForwardOrdering, InMemoryDatasets.HeapSortAlg, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1164#threadsfor_fun#492"{Array{Int32, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}, Int32, Base.Order.ForwardOrdering, InMemoryDatasets.HeapSortAlg, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1164#threadsfor_fun#492"{Array{Int32, 1}, Array{Union{Base.Missing, String}, 1}, Array{Int32, 1}, Int32, Base.Order.ForwardOrdering, InMemoryDatasets.HeapSortAlg, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1164#threadsfor_fun#492"{Array{Int32, 1}, Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Array{Int32, 1}, Int32, Base.Order.ForwardOrdering, InMemoryDatasets.HeapSortAlg, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1194#threadsfor_fun#494"{Array{Int32, 1}, Array{Int32, 1}, Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}, Array{Array{Int32, 1}, 1}, Int32, Bool, Base.Order.ForwardOrdering, InMemoryDatasets.HeapSortAlg, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1164#threadsfor_fun#492"{Array{Int32, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}, Int32, Base.Order.ForwardOrdering, InMemoryDatasets.HeapSortAlg, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(Base.Broadcast.combine_eltypes), Type, Tuple{Base.RefValue{Array{Int64, 1}}, Array{Function, 1}}})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Base.sum)}}, Any, Any})
precompile(Tuple{typeof(Base.convert), Type{Array{Int64, 1}}, Array{Int64, 1}})
precompile(Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, Type{Base.Pair{A, B} where B where A}, Tuple{Base.RefValue{Array{Int64, 1}}, Base.Broadcast.Extruded{Array{Function, 1}, Tuple{Bool}, Tuple{Int64}}}}, Type{Base.Pair{Array{Int64, 1}, typeof(Base.sum)}}})
precompile(Tuple{typeof(Base.setindex!), Array{Base.Pair{Array{Int64, 1}, typeof(Base.sum)}, 1}, Base.Pair{Array{Int64, 1}, typeof(Base.sum)}, Int64})
precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{Base.Pair{Array{Int64, 1}, typeof(Base.sum)}, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, Type{Base.Pair{A, B} where B where A}, Tuple{Base.RefValue{Array{Int64, 1}}, Base.Broadcast.Extruded{Array{Function, 1}, Tuple{Bool}, Tuple{Int64}}}}, Base.OneTo{Int64}, Int64, Int64})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Statistics.mean)}}, Any, Any})
precompile(Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, Type{Base.Pair{A, B} where B where A}, Tuple{Base.RefValue{Array{Int64, 1}}, Base.Broadcast.Extruded{Array{Function, 1}, Tuple{Bool}, Tuple{Int64}}}}, Type{Base.Pair{Array{Int64, 1}, _A} where _A}})
precompile(Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Array{Base.Pair{Array{Int64, 1}, _A} where _A, 1}, Array{Base.Pair{Array{Int64, 1}, typeof(Base.sum)}, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, Type{Base.Pair{A, B} where B where A}, Tuple{Base.RefValue{Array{Int64, 1}}, Base.Broadcast.Extruded{Array{Function, 1}, Tuple{Bool}, Tuple{Int64}}}}, Base.Pair{Array{Int64, 1}, typeof(Statistics.mean)}, Int64, Base.OneTo{Int64}, Int64, Int64})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Base.length)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Base.maximum)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Base.minimum)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Statistics.var)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Statistics.std)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Statistics.median)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{Array{Int64, 1}, typeof(Base.sort)}}, Any, Any})
precompile(Tuple{typeof(InMemoryDatasets.combine), InMemoryDatasets.GroupBy, Any})
precompile(Tuple{typeof(InMemoryDatasets.normalize_combine_multiple!), Int64, InMemoryDatasets.Index, InMemoryDatasets.Index, Any})
precompile(Tuple{typeof(InMemoryDatasets.normalize_combine!), Int64, InMemoryDatasets.Index, InMemoryDatasets.Index, Array{Base.Pair{Array{Int64, 1}, _A} where _A, 1}})
precompile(Tuple{typeof(Base.typename), DataType})
precompile(Tuple{typeof(InMemoryDatasets.normalize_combine!), Int64, InMemoryDatasets.Index, InMemoryDatasets.Index, Base.Pair{var"#s422", var"#s421"} where var"#s421"<:Union{Expr, Function} where var"#s422"<:Union{Base.Colon, Base.Regex, AbstractArray{T, 1} where T, InMemoryDatasets.DataAPI.All{T} where T<:Tuple, InMemoryDatasets.DataAPI.Between{T1, T2} where T2<:Union{Int64, Symbol} where T1<:Union{Int64, Symbol}, InMemoryDatasets.DataAPI.Cols{T} where T<:Tuple, InvertedIndices.InvertedIndex{S} where S}})
precompile(Tuple{typeof(Base.getindex), InMemoryDatasets.Index, Array{Int64, 1}})
precompile(Tuple{typeof(Base.getindex), Array{Int64, 1}, Int64})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Base.sum)}}, Any, Any})
precompile(Tuple{typeof(InMemoryDatasets.normalize_combine!), Int64, InMemoryDatasets.Index, InMemoryDatasets.Index, Base.Pair{var"#s422", var"#s421"} where var"#s421"<:Function where var"#s422"<:Union{AbstractString, Signed, Symbol, Unsigned}})
precompile(Tuple{typeof(InMemoryDatasets.funname), Function})
precompile(Tuple{typeof(Base.nameof), Function})
precompile(Tuple{typeof(Base.getindex), String, Int64})
precompile(Tuple{typeof(Base.:(==)), Char, Char})
precompile(Tuple{Type{Base.Pair{typeof(Base.sum), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Base.sum), Symbol}})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Statistics.mean)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{typeof(Statistics.mean), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Statistics.mean), Symbol}})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Base.length)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{typeof(Base.length), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Base.length), Symbol}})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Base.maximum)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{typeof(Base.maximum), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Base.maximum), Symbol}})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Base.minimum)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{typeof(Base.minimum), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Base.minimum), Symbol}})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Statistics.var)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{typeof(Statistics.var), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Statistics.var), Symbol}})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Statistics.std)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{typeof(Statistics.std), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Statistics.std), Symbol}})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Statistics.median)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{typeof(Statistics.median), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Statistics.median), Symbol}})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Base.sort)}}, Any, Any})
precompile(Tuple{Type{Base.Pair{typeof(Base.sort), Symbol}}, Any, Any})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, Base.Pair{typeof(Base.sort), Symbol}})
precompile(Tuple{typeof(InMemoryDatasets._create_index_for_newds), InMemoryDatasets.Dataset, Array{Any, 1}, Array{Int64, 1}})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Base.sum), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Base.sum), Symbol}, Symbol})
precompile(Tuple{typeof(Base.haskey), Base.Dict{Symbol, Int64}, Symbol})
precompile(Tuple{typeof(Base.push!), Base.Dict{Symbol, Int64}, Base.Pair{Symbol, Int64}})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Statistics.mean), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Statistics.mean), Symbol}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Base.length), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Base.length), Symbol}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Base.maximum), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Base.maximum), Symbol}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Base.minimum), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Base.minimum), Symbol}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Statistics.var), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Statistics.var), Symbol}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Statistics.std), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Statistics.std), Symbol}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Statistics.median), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Statistics.median), Symbol}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{Symbol, Base.Pair{typeof(Base.sort), Symbol}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Pair{typeof(Base.sort), Symbol}, Symbol})
precompile(Tuple{typeof(Base.haskey), InMemoryDatasets.Index, Symbol})
precompile(Tuple{typeof(Base.getindex), InMemoryDatasets.Index, Symbol})
precompile(Tuple{typeof(Base.push!), Array{Int64, 1}, Int64})
precompile(Tuple{typeof(Base.in), Symbol, Array{Any, 1}})
precompile(Tuple{Type{InMemoryDatasets.DatasetColumn{T, E} where E where T<:InMemoryDatasets.AbstractDataset}, Int64, InMemoryDatasets.Dataset, Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{typeof(Base.getproperty), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, Int64}, 1}}, Symbol})
precompile(Tuple{typeof(InMemoryDatasets.return_type), Function, Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{InMemoryDatasets.var"#475#476", Base.Pair{Symbol, Base.Pair{typeof(Base.sum), Symbol}}})
precompile(Tuple{typeof(Base._similar_for), Base.SubArray{Any, 1, Array{Any, 1}, Tuple{Base.UnitRange{Int64}}, true}, Type{Symbol}, Base.Generator{Base.SubArray{Any, 1, Array{Any, 1}, Tuple{Base.UnitRange{Int64}}, true}, InMemoryDatasets.var"#475#476"}, Base.HasShape{1}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Symbol, 1}, Symbol, Base.Generator{Base.SubArray{Any, 1, Array{Any, 1}, Tuple{Base.UnitRange{Int64}}, true}, InMemoryDatasets.var"#475#476"}, Tuple{Base.OneTo{Int64}, Int64}})
precompile(Tuple{Type{InMemoryDatasets.DatasetColumn{T, E} where E where T<:InMemoryDatasets.AbstractDataset}, Int64, InMemoryDatasets.Dataset, Array{Union{Base.Missing, Float64}, 1}})
precompile(Tuple{typeof(Base.getproperty), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, Float64}, 1}}, Symbol})
precompile(Tuple{typeof(InMemoryDatasets.return_type), Function, Array{Union{Base.Missing, Float64}, 1}})
precompile(Tuple{Type{InMemoryDatasets.DatasetColumn{T, E} where E where T<:InMemoryDatasets.AbstractDataset}, Int64, InMemoryDatasets.Dataset, Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{typeof(Base.getproperty), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, Int32}, 1}}, Symbol})
precompile(Tuple{typeof(InMemoryDatasets.return_type), Function, Array{Union{Base.Missing, Int32}, 1}})
precompile(Tuple{Type{InMemoryDatasets.DatasetColumn{T, E} where E where T<:InMemoryDatasets.AbstractDataset}, Int64, InMemoryDatasets.Dataset, Array{Union{Base.Missing, Float32}, 1}})
precompile(Tuple{typeof(Base.getproperty), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, Float32}, 1}}, Symbol})
precompile(Tuple{typeof(InMemoryDatasets.return_type), Function, Array{Union{Base.Missing, Float32}, 1}})
precompile(Tuple{Core.Compiler.var"#256#258"{DataType, Tuple{Base.Colon}}, Int64})
precompile(Tuple{InMemoryDatasets.var"#475#476", Base.Pair{Symbol, Base.Pair{typeof(Statistics.mean), Symbol}}})
precompile(Tuple{InMemoryDatasets.var"#475#476", Base.Pair{Symbol, Base.Pair{typeof(Base.length), Symbol}}})
precompile(Tuple{InMemoryDatasets.var"#475#476", Base.Pair{Symbol, Base.Pair{typeof(Base.maximum), Symbol}}})
precompile(Tuple{InMemoryDatasets.var"#475#476", Base.Pair{Symbol, Base.Pair{typeof(Base.minimum), Symbol}}})
precompile(Tuple{InMemoryDatasets.var"#475#476", Base.Pair{Symbol, Base.Pair{typeof(Statistics.var), Symbol}}})
precompile(Tuple{Core.Compiler.var"#256#258"{DataType, Tuple{Bool, Nothing}}, Int64})
precompile(Tuple{InMemoryDatasets.var"#475#476", Base.Pair{Symbol, Base.Pair{typeof(Statistics.std), Symbol}}})
precompile(Tuple{InMemoryDatasets.var"#475#476", Base.Pair{Symbol, Base.Pair{typeof(Statistics.median), Symbol}}})
precompile(Tuple{Type{Array{AbstractArray{Union{Base.Missing, Int64}, 1}, 1}}, UndefInitializer, Int32})
precompile(Tuple{Type{Array{Int64, 1}}, UndefInitializer, Int32})
precompile(Tuple{typeof(Base.getindex), Array{AbstractArray{T, 1} where T, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._threaded_permute_for_groupby), Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}})
precompile(Tuple{InMemoryDatasets.var"#296#threadsfor_fun#175"{Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}, Array{Union{Base.Missing, Int64}, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._compute_the_mutli_row_trans!), Array{AbstractArray{Union{Base.Missing, Int64}, 1}, 1}, Array{Int64, 1}, Array{Union{Base.Missing, Int64}, 1}, Int64, typeof(Base.sort), Int64, Array{Int32, 1}, Int32})
precompile(Tuple{InMemoryDatasets.var"#864#threadsfor_fun#477"{Array{AbstractArray{Union{Base.Missing, Int64}, 1}, 1}, Array{Int64, 1}, Array{Union{Base.Missing, Int64}, 1}, Int64, typeof(Base.sort), Array{Int32, 1}, Int32, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(Base.cumsum!), Array{Int64, 1}, Array{Int64, 1}})
precompile(Tuple{typeof(Base.lastindex), Array{Int64, 1}})
precompile(Tuple{typeof(Base.getindex), InMemoryDatasets.Dataset, typeof(Base.:(!)), Int64})
precompile(Tuple{InMemoryDatasets.var"#allocatecol##kw", NamedTuple{(:addmissing,), Tuple{Bool}}, typeof(InMemoryDatasets.allocatecol), Array{Union{Base.Missing, Int64}, 1}, Int64})
precompile(Tuple{typeof(Base.view), Array{Union{Base.Missing, Int64}, 1}, Array{Int32, 1}})
precompile(Tuple{typeof(InMemoryDatasets._push_groups_to_res!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Base.SubArray{Union{Base.Missing, Int64}, 1, Array{Union{Base.Missing, Int64}, 1}, Tuple{Array{Int32, 1}}, false}, Array{Int32, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}, Int32})
precompile(Tuple{InMemoryDatasets.var"#895#threadsfor_fun#479"{Array{Union{Base.Missing, Int64}, 1}, Base.SubArray{Union{Base.Missing, Int64}, 1, Array{Union{Base.Missing, Int64}, 1}, Tuple{Array{Int32, 1}}, false}, Array{Int32, 1}, Array{Int64, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(Base.get), Base.Dict{Int64, Function}, Int64, Function})
precompile(Tuple{Type{Base.Pair{Symbol, typeof(Base.identity)}}, Any, Any})
precompile(Tuple{typeof(InMemoryDatasets.setformat!), InMemoryDatasets.Dataset, Base.Pair{Symbol, typeof(Base.identity)}})
precompile(Tuple{typeof(InMemoryDatasets._combine_f_barrier), Array{Union{Base.Missing, Int64}, 1}, InMemoryDatasets.Dataset, Symbol, Function, Symbol, Base.Dict{Symbol, Int64}, Array{Int32, 1}, Int32, Array{Int64, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets.DataAPI.defaultarray), Type{Union{Base.Missing, Int64}}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.sum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.sum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._threaded_permute_for_groupby), Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}})
precompile(Tuple{InMemoryDatasets.var"#296#threadsfor_fun#175"{Array{Union{Base.Missing, Float64}, 1}, Array{Int32, 1}, Array{Union{Base.Missing, Float64}, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._combine_f_barrier), Array{Union{Base.Missing, Float64}, 1}, InMemoryDatasets.Dataset, Symbol, Function, Symbol, Base.Dict{Symbol, Int64}, Array{Int32, 1}, Int32, Array{Int64, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets.DataAPI.defaultarray), Type{Union{Base.Missing, Float64}}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.sum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.sum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._threaded_permute_for_groupby), Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}})
precompile(Tuple{InMemoryDatasets.var"#296#threadsfor_fun#175"{Array{Union{Base.Missing, Int32}, 1}, Array{Int32, 1}, Array{Union{Base.Missing, Int32}, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._combine_f_barrier), Array{Union{Base.Missing, Int32}, 1}, InMemoryDatasets.Dataset, Symbol, Function, Symbol, Base.Dict{Symbol, Int64}, Array{Int32, 1}, Int32, Array{Int64, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.sum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.sum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._threaded_permute_for_groupby), Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}})
precompile(Tuple{InMemoryDatasets.var"#296#threadsfor_fun#175"{Array{Union{Base.Missing, Float32}, 1}, Array{Int32, 1}, Array{Union{Base.Missing, Float32}, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._combine_f_barrier), Array{Union{Base.Missing, Float32}, 1}, InMemoryDatasets.Dataset, Symbol, Function, Symbol, Base.Dict{Symbol, Int64}, Array{Int32, 1}, Int32, Array{Int64, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets.DataAPI.defaultarray), Type{Union{Base.Missing, Float32}}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.sum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.sum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Statistics.mean), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Statistics.mean), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Statistics.mean), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Statistics.mean), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Statistics.mean), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Statistics.mean), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Statistics.mean), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Statistics.mean), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.length), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.length), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.length), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.length), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.length), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.length), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.length), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.length), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.maximum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.maximum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.maximum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.maximum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets.DataAPI.defaultarray), Type{Union{Base.Missing, Int32}}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.maximum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.maximum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.maximum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.maximum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.minimum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.minimum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.minimum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.minimum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.minimum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.minimum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.minimum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.minimum), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Statistics.var), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Statistics.var), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Statistics.var), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Statistics.var), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Statistics.var), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Statistics.var), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Statistics.var), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Statistics.var), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Statistics.std), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Statistics.std), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Statistics.std), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Statistics.std), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Statistics.std), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Statistics.std), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Statistics.std), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Statistics.std), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Statistics.median), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Statistics.median), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Statistics.median), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Statistics.median), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Statistics.median), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Statistics.median), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Statistics.median), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Statistics.median), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._combine_f_barrier_special), Array{AbstractArray{Union{Base.Missing, Int64}, 1}, 1}, Base.SubArray{Union{Base.Missing, Int64}, 1, Array{Union{Base.Missing, Int64}, 1}, Tuple{Array{Int32, 1}}, false}, InMemoryDatasets.Dataset, Symbol, Function, Symbol, Base.Dict{Symbol, Int64}, Int64, Int32, Array{Int64, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._fill_res_with_special_res!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{AbstractArray{Union{Base.Missing, Int64}, 1}, 1}, Int32, Array{Int64, 1}, Int64})
precompile(Tuple{InMemoryDatasets.var"#970#threadsfor_fun#484"{Array{Union{Base.Missing, Int64}, 1}, Array{AbstractArray{Union{Base.Missing, Int64}, 1}, 1}, Array{Int64, 1}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._special_res_fill_barrier!), Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, Int64, Int64})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.sort), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, typeof(Base.sort), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.sort), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float64}, 1}, Array{Union{Base.Missing, Float64}, 1}, typeof(Base.sort), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.sort), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Int32}, 1}, Array{Union{Base.Missing, Int32}, 1}, typeof(Base.sort), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._add_one_col_combine!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.sort), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#940#threadsfor_fun#482"{Array{Union{Base.Missing, Float32}, 1}, Array{Union{Base.Missing, Float32}, 1}, typeof(Base.sort), Array{Int32, 1}, Int32, Array{Int64, 1}, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"##transpose#548", Nothing, Nothing, Function, String, Base.Missing, Bool, Bool, typeof(Base.transpose), InMemoryDatasets.Dataset, Base.UnitRange{Int64}})
precompile(Tuple{Type{NamedTuple{(:id, :renamecolid, :renamerowid, :variable_name, :threads, :mapformats), T} where T<:Tuple}, Tuple{Nothing, Nothing, typeof(InMemoryDatasets._default_renamerowid_function), String, Bool, Bool}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(InMemoryDatasets._default_renamerowid_function), Array{String, 1}})
precompile(Tuple{typeof(Base.collect_similar), Array{String, 1}, Base.Generator{Array{String, 1}, typeof(InMemoryDatasets._default_renamerowid_function)}})
precompile(Tuple{typeof(InMemoryDatasets._simple_transpose_ds_generate), Type, Base.SubArray{AbstractArray{T, 1} where T, 1, Array{AbstractArray{T, 1} where T, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{String, 1}, Array{String, 1}, String, Bool})
precompile(Tuple{Type{Array{Any, 2}}, UndefInitializer, Int64, Int64})
precompile(Tuple{InMemoryDatasets.var"#1381#threadsfor_fun#533"{Base.SubArray{AbstractArray{T, 1} where T, 1, Array{AbstractArray{T, 1} where T, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Any, 2}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._simple_ds_transpose!), Array{Any, 2}, Array{Union{Base.Missing, String}, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._simple_ds_transpose!), Array{Any, 2}, Array{Union{Base.Missing, Float32}, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._simple_ds_transpose!), Array{Any, 2}, Array{Union{Base.Missing, Int64}, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._simple_ds_transpose!), Array{Any, 2}, Array{Union{Base.Missing, Float64}, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._simple_ds_transpose!), Array{Any, 2}, Array{Union{Base.Missing, Dates.Date}, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._simple_ds_transpose!), Array{Any, 2}, Array{Union{Base.Missing, InMemoryDatasets.Characters{2, UInt8}}, 1}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._simple_ds_transpose!), Array{Any, 2}, Array{Union{Base.Missing, Int32}, 1}, Int64})
precompile(Tuple{Type{InMemoryDatasets.Dataset}, Array{Any, 2}, Array{String, 1}})
precompile(Tuple{InMemoryDatasets.var"#266#threadsfor_fun#145"{Bool, Array{AbstractArray{T, 1} where T, 1}, Base.OneTo{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{Any, 1}, Int64, Bool})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Any, 1}, Int64})
precompile(Tuple{typeof(Base.firstindex), Array{Any, 1}})
precompile(Tuple{InMemoryDatasets.var"##transpose#549", Nothing, Nothing, Function, String, Base.Missing, Bool, Bool, typeof(Base.transpose), InMemoryDatasets.GroupBy, Array{Int64, 1}})
precompile(Tuple{Type{NamedTuple{(:id, :renamecolid, :renamerowid, :variable_name, :threads, :default_fill, :mapformats), T} where T<:Tuple}, Tuple{Nothing, Nothing, typeof(InMemoryDatasets._default_renamerowid_function), String, Bool, Base.Missing, Bool}})
precompile(Tuple{InMemoryDatasets.var"#ds_transpose##kw", NamedTuple{(:id, :renamecolid, :renamerowid, :variable_name, :threads, :default_fill, :mapformats), Tuple{Nothing, Nothing, typeof(InMemoryDatasets._default_renamerowid_function), String, Bool, Base.Missing, Bool}}, typeof(InMemoryDatasets.ds_transpose), InMemoryDatasets.GroupBy, Array{Int64, 1}, Array{Int64, 1}})
precompile(Tuple{InMemoryDatasets.var"##ds_transpose#547", Nothing, Nothing, Function, String, Base.Missing, Bool, Bool, typeof(InMemoryDatasets.ds_transpose), InMemoryDatasets.GroupBy, Array{Int64, 1}, Array{Int64, 1}})
precompile(Tuple{Base.BottomRF{typeof(Base.promote_type)}, Type, Type})
precompile(Tuple{Base.Colon, Int64, Int32})
precompile(Tuple{typeof(Base.view), Array{Int32, 1}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(InMemoryDatasets._obtain_maximum_groups_size), Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}, Int64})
precompile(Tuple{typeof(InMemoryDatasets._generate_col_row_names), Function, Function, Base.UnitRange{Int64}, Array{String, 1}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(InMemoryDatasets._default_renamecolid_function_withoutid), Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.collect_similar), Base.UnitRange{Int64}, Base.Generator{Base.UnitRange{Int64}, typeof(InMemoryDatasets._default_renamecolid_function_withoutid)}})
precompile(Tuple{InMemoryDatasets.var"#_fill_outputmat_withoutid##kw", NamedTuple{(:default_fill,), Tuple{Base.Missing}}, typeof(InMemoryDatasets._fill_outputmat_withoutid), Type, Base.SubArray{AbstractArray{T, 1} where T, 1, Array{AbstractArray{T, 1} where T, 1}, Tuple{Array{Int64, 1}}, false}, InMemoryDatasets.GroupBy, Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Int32, 1}, Array{String, 1}, Array{String, 1}, Bool})
precompile(Tuple{typeof(Base.:(*)), Int64, Int32})
precompile(Tuple{typeof(InMemoryDatasets._check_allocation_limit), Type, Int64, Int64})
precompile(Tuple{typeof(Base.:(/)), Int64, UInt64})
precompile(Tuple{typeof(Base.:(<)), Float64, Float64})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, InMemoryDatasets.var"#542#543"{Base.Missing, InMemoryDatasets.GroupBy, Array{String, 1}, Union}, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.collect), Base.Generator{Base.UnitRange{Int64}, InMemoryDatasets.var"#542#543"{Base.Missing, InMemoryDatasets.GroupBy, Array{String, 1}, Union}}})
precompile(Tuple{typeof(Base.fill!), Array{Union{Base.Missing, Float64}, 1}, Base.Missing})
precompile(Tuple{typeof(Base._array_for), Type{Array{Union{Base.Missing, Float64}, 1}}, Base.UnitRange{Int64}, Base.HasShape{1}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Array{Union{Base.Missing, Float64}, 1}, 1}, Array{Union{Base.Missing, Float64}, 1}, Base.Generator{Base.UnitRange{Int64}, InMemoryDatasets.var"#542#543"{Base.Missing, InMemoryDatasets.GroupBy, Array{String, 1}, Union}}, Int64})
precompile(Tuple{typeof(InMemoryDatasets.update_outputmat!), Array{Array{Union{Base.Missing, Float64}, 1}, 1}, Base.SubArray{AbstractArray{T, 1} where T, 1, Array{AbstractArray{T, 1} where T, 1}, Tuple{Array{Int64, 1}}, false}, Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Int32, 1}, Int64, Bool})
precompile(Tuple{InMemoryDatasets.var"#1428#threadsfor_fun#539"{Array{Array{Union{Base.Missing, Float64}, 1}, 1}, Array{Union{Base.Missing, Int64}, 1}, Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Int32, 1}, Int64, Int64, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{InMemoryDatasets.var"#1428#threadsfor_fun#539"{Array{Array{Union{Base.Missing, Float64}, 1}, 1}, Array{Union{Base.Missing, Float64}, 1}, Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Int32, 1}, Int64, Int64, Int64, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(Base.view), Array{Int32, 1}, Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}})
precompile(Tuple{typeof(InMemoryDatasets._fill_gcol!), Array{AbstractArray{T, N} where N where T, 1}, InMemoryDatasets.Dataset, Array{Int64, 1}, Array{Int64, 1}, Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}, Int32, Bool})
precompile(Tuple{typeof(InMemoryDatasets.allocatecol), Array{Union{Base.Missing, Int64}, 1}, Int64})
precompile(Tuple{typeof(Base.push!), Array{AbstractArray{T, N} where N where T, 1}, Array{Union{Base.Missing, Int64}, 1}})
precompile(Tuple{typeof(InMemoryDatasets._fill_onecol_for_tr_threaded!), Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, Int64, Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}})
precompile(Tuple{InMemoryDatasets.var"#1398#threadsfor_fun#537"{Array{Union{Base.Missing, Int64}, 1}, Array{Union{Base.Missing, Int64}, 1}, Int64, Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.SubArray{Int32, 1, Array{Int32, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}, Base.UnitRange{Int64}}})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{Union{Base.Missing, Int64}, 1}, Int64, Bool})
precompile(Tuple{Type{Base.Pair{Int64, typeof(Base.identity)}}, Any, Any})
precompile(Tuple{typeof(InMemoryDatasets.setformat!), InMemoryDatasets.Dataset, Base.Pair{Int64, typeof(Base.identity)}})
precompile(Tuple{Type{PooledArrays.PooledArray{T, R, N, RA} where RA where N where R<:Integer where T}, Array{String, 1}})
precompile(Tuple{typeof(PooledArrays._label), Array{String, 1}, Type{String}, Type{UInt32}})
precompile(Tuple{Type{PooledArrays.RefArray{R} where R}, Array{UInt32, 1}})
precompile(Tuple{Type{PooledArrays.PooledArray{T, R, N, RA} where RA where N where R<:Integer where T}, PooledArrays.RefArray{Array{UInt32, 1}}, Base.Dict{String, UInt32}, Array{String, 1}})
precompile(Tuple{typeof(Base.getproperty), PooledArrays.PooledArray{String, UInt32, 1, Array{UInt32, 1}}, Symbol})
precompile(Tuple{typeof(Base.repeat), Array{UInt32, 1}, Int32})
precompile(Tuple{typeof(Base.setproperty!), PooledArrays.PooledArray{String, UInt32, 1, Array{UInt32, 1}}, Symbol, Array{UInt32, 1}})
precompile(Tuple{typeof(Base.convert), Type{Array{UInt32, 1}}, Array{UInt32, 1}})
precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, PooledArrays.PooledArray{String, UInt32, 1, Array{UInt32, 1}}})
precompile(Tuple{InMemoryDatasets.var"#insertcols!##kw", NamedTuple{(:unsupported_copy_cols,), Tuple{Bool}}, typeof(InMemoryDatasets.insertcols!), InMemoryDatasets.Dataset, Int64, Base.Pair{Symbol, PooledArrays.PooledArray{String, UInt32, 1, Array{UInt32, 1}}}})
precompile(Tuple{Core.var"#Type##kw", NamedTuple{(:copycols,), Tuple{Bool}}, Type{InMemoryDatasets.Dataset}, Array{Array{Union{Base.Missing, Float64}, 1}, 1}, Array{String, 1}})
precompile(Tuple{typeof(Base.length), Array{Union{Base.Missing, Float64}, 1}})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Array{Union{Base.Missing, Float64}, 1}, Int64, Bool})
precompile(Tuple{typeof(InMemoryDatasets._columns), InMemoryDatasets.Dataset})
precompile(Tuple{typeof(Base.push!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Float64}, 1}})
precompile(Tuple{typeof(InMemoryDatasets.index), InMemoryDatasets.Dataset})
precompile(Tuple{typeof(Base.merge!), InMemoryDatasets.Index, InMemoryDatasets.Index})
precompile(Tuple{typeof(InMemoryDatasets._preprocess_column), Dates.Millisecond, Int64, Bool})
precompile(Tuple{typeof(Base.firstindex), Array{Union{Base.Missing, Dates.Millisecond}, 1}})
precompile(Tuple{typeof(Base.setindex!), Array{AbstractArray{T, 1} where T, 1}, Array{Union{Base.Missing, Dates.Millisecond}, 1}, Int64})
precompile(Tuple{typeof(REPL.ends_with_semicolon), AbstractString})
precompile(Tuple{typeof(Base.Multimedia.display), REPL.REPLDisplay{R} where R<:REPL.AbstractREPL, Any})
precompile(Tuple{Type{Ref{Any}}, InMemoryDatasets.Dataset})
precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.IOContext{Base.TTY}, Base.Dict{Symbol, Any}})
precompile(Tuple{Core.Compiler.var"#256#258"{DataType, Tuple{String}}, Int64})
precompile(Tuple{Base.Cartesian.var"#@ncall", LineNumberNode, Module, Int64, Any, Vararg{Any, N} where N})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.TTY}, Base.Multimedia.MIME{Symbol("text/plain")}, InMemoryDatasets.Dataset})
precompile(Tuple{PooledArrays.var"#1#2", PooledArrays.PooledArray{Union{Base.Missing, String}, UInt32, 1, Array{UInt32, 1}}})
precompile(Tuple{PooledArrays.var"#1#2", PooledArrays.PooledArray{String, UInt32, 1, Array{UInt32, 1}}})
precompile(Tuple{typeof(Base.length), Array{Union{Base.Missing, String}, 1}})
precompile(Tuple{typeof(Base.length), Array{Union{Base.Missing, Dates.Millisecond}, 1}})
precompile(Tuple{Type{InMemoryDatasets.DatasetColumn{T, E} where E where T<:InMemoryDatasets.AbstractDataset}, Int64, InMemoryDatasets.Dataset, Array{Union{Base.Missing, String}, 1}})
precompile(Tuple{Type{InMemoryDatasets.DatasetColumn{T, E} where E where T<:InMemoryDatasets.AbstractDataset}, Int64, InMemoryDatasets.Dataset, Array{Union{Base.Missing, Dates.Millisecond}, 1}})
precompile(Tuple{Base.var"#4#5"{InMemoryDatasets.var"#660#662"{Base.Dict{Any, String}}}, Tuple{Union, Int64}})
precompile(Tuple{InMemoryDatasets.var"#660#662"{Base.Dict{Any, String}}, Type, Int64})
precompile(Tuple{typeof(Base.get!), InMemoryDatasets.var"#661#663"{Union, Int64}, Base.Dict{Any, String}, Type{Union{Base.Missing, String}}})
precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, Type})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Type})
precompile(Tuple{typeof(Base.get!), InMemoryDatasets.var"#661#663"{Union, Int64}, Base.Dict{Any, String}, Type{Union{Base.Missing, Dates.Millisecond}}})
precompile(Tuple{typeof(Base.nameof), DataType})
precompile(Tuple{Type{NamedTuple{(:alignment, :alignment_anchor_fallback, :alignment_anchor_regex, :body_hlines, :compact_printing, :crop, :crop_num_lines_at_beginning, :ellipsis_line_skip, :formatters, :header, :header_alignment, :hlines, :highlighters, :maximum_columns_width, :newline_at_end, :nosubheader, :row_name_alignment, :row_name_crayon, :row_name_column_title, :row_names, :row_number_alignment, :row_number_column_title, :show_row_number, :title, :vlines), T} where T<:Tuple}, Tuple{Array{Symbol, 1}, Symbol, Base.Dict{Int64, Array{Base.Regex, 1}}, Array{Int64, 1}, Bool, Symbol, Int64, Int64, Tuple{}, Tuple{Array{String, 1}, Array{String, 1}, Array{String, 1}}, Symbol, Array{Symbol, 1}, Tuple{PrettyTables.Highlighter}, Array{Int64, 1}, Bool, Bool, Symbol, Crayons.Crayon, String, Nothing, Symbol, String, Bool, String, Array{Int64, 1}}})
precompile(Tuple{typeof(Base.afoldl), Base.var"#42#43", Type, Type, Type, Type, Type, Type, Type, Type, Type, Type, Type, Type})
precompile(Tuple{typeof(Base.afoldl), Base.var"#42#43", Type, Type, Type, Type, Type, Type, Type, Type, Type, Type, Type})
precompile(Tuple{Base.var"##s79#169", Any, Any, Any, Any, Any})
precompile(Tuple{typeof(Base.merge_types), Tuple{Vararg{Symbol, N} where N}, Type{var"#s79"} where var"#s79"<:(NamedTuple{names, T} where T<:Tuple where names), Type{var"#s78"} where var"#s78"<:(NamedTuple{names, T} where T<:Tuple where names)})
precompile(Tuple{typeof(Base.afoldl), Base.var"#42#43", Type, Type, Type, Type, Type, Type, Type, Type})
precompile(Tuple{PrettyTables.var"#pretty_table##kw", NamedTuple{(:alignment, :alignment_anchor_fallback, :alignment_anchor_regex, :body_hlines, :compact_printing, :crop, :crop_num_lines_at_beginning, :ellipsis_line_skip, :formatters, :header, :header_alignment, :hlines, :highlighters, :maximum_columns_width, :newline_at_end, :nosubheader, :row_name_alignment, :row_name_crayon, :row_name_column_title, :row_names, :row_number_alignment, :row_number_column_title, :show_row_number, :title, :vlines), Tuple{Array{Symbol, 1}, Symbol, Base.Dict{Int64, Array{Base.Regex, 1}}, Array{Int64, 1}, Bool, Symbol, Int64, Int64, Tuple{}, Tuple{Array{String, 1}, Array{String, 1}, Array{String, 1}}, Symbol, Array{Symbol, 1}, Tuple{PrettyTables.Highlighter}, Array{Int64, 1}, Bool, Bool, Symbol, Crayons.Crayon, String, Nothing, Symbol, String, Bool, String, Array{Int64, 1}}}, typeof(PrettyTables.pretty_table), Base.IOContext{Base.TTY}, InMemoryDatasets.Dataset})
precompile(Tuple{PrettyTables.var"##_pretty_table#73", Tuple{Array{String, 1}, Array{String, 1}, Array{String, 1}}, Base.Iterators.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}, NamedTuple{(:alignment, :alignment_anchor_fallback, :alignment_anchor_regex, :body_hlines, :compact_printing, :crop, :crop_num_lines_at_beginning, :ellipsis_line_skip, :formatters, :header_alignment, :hlines, :highlighters, :maximum_columns_width, :newline_at_end, :nosubheader, :row_name_alignment, :row_name_crayon, :row_name_column_title, :row_names, :row_number_alignment, :row_number_column_title, :show_row_number, :title, :vlines), Tuple{Array{Symbol, 1}, Symbol, Base.Dict{Int64, Array{Base.Regex, 1}}, Array{Int64, 1}, Bool, Symbol, Int64, Int64, Tuple{}, Symbol, Array{Symbol, 1}, Tuple{PrettyTables.Highlighter}, Array{Int64, 1}, Bool, Bool, Symbol, Crayons.Crayon, String, Nothing, Symbol, String, Bool, String, Array{Int64, 1}}}}, typeof(PrettyTables._pretty_table), IO, InMemoryDatasets.Dataset})
precompile(Tuple{typeof(Base.length), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, String}, 1}}})
precompile(Tuple{typeof(Base.get), Base.IOContext{Base.TTY}, Symbol, Bool})
precompile(Tuple{typeof(PrettyTables._compute_cell_alignment_override), PrettyTables.ColumnTable, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, Int64, Base.RefValue{Any}})
precompile(Tuple{typeof(PrettyTables._fill_matrix_data!), Array{String, 2}, Array{Array{String, 1}, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Int64, Any, Any, Ref{Any}, PrettyTables.Display, Bool, Bool, Array{Int64, 1}, Bool, Bool, Bool, Bool, Bool, Base.Val{:print}, Symbol})
precompile(Tuple{typeof(Base.isassigned), Array{String, 1}, Int64})
precompile(Tuple{PrettyTables.var"#_parse_cell_text##kw", NamedTuple{(:autowrap, :cell_first_line_only, :column_width, :compact_printing, :has_color, :limit_printing, :linebreaks, :renderer), Tuple{Bool, Bool, Int64, Bool, Bool, Bool, Bool, Base.Val{:print}}}, typeof(PrettyTables._parse_cell_text), String})
precompile(Tuple{Base.var"##sprint#385", Nothing, Int64, typeof(Base.sprint), Function, String, Vararg{String, N} where N})
precompile(Tuple{typeof(Base.convert), Type{Array{String, 1}}, Array{String, 1}})
precompile(Tuple{typeof(Base.isassigned), PrettyTables.ColumnTable, Int64, Int64})
precompile(Tuple{typeof(InMemoryDatasets.Tables.getcolumn), InMemoryDatasets.DatasetColumns{InMemoryDatasets.Dataset}, Symbol})
precompile(Tuple{typeof(Base.isassigned), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, String}, 1}}, Int64})
precompile(Tuple{typeof(Base.getindex), PrettyTables.ColumnTable, Int64, Int64})
precompile(Tuple{typeof(Base.getindex), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, String}, 1}}, Int64})
precompile(Tuple{PrettyTables.var"#_parse_cell_text##kw", NamedTuple{(:autowrap, :cell_data_type, :cell_first_line_only, :column_width, :compact_printing, :has_color, :limit_printing, :linebreaks, :renderer), Tuple{Bool, DataType, Bool, Int64, Bool, Bool, Bool, Bool, Base.Val{:print}}}, typeof(PrettyTables._parse_cell_text), String})
precompile(Tuple{typeof(Base.isassigned), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, Dates.Millisecond}, 1}}, Int64})
precompile(Tuple{typeof(Base.getindex), InMemoryDatasets.DatasetColumn{InMemoryDatasets.Dataset, Array{Union{Base.Missing, Dates.Millisecond}, 1}}, Int64})
precompile(Tuple{PrettyTables.var"#_parse_cell_text##kw", NamedTuple{(:autowrap, :cell_data_type, :cell_first_line_only, :column_width, :compact_printing, :has_color, :limit_printing, :linebreaks, :renderer), Tuple{Bool, DataType, Bool, Int64, Bool, Bool, Bool, Bool, Base.Val{:print}}}, typeof(PrettyTables._parse_cell_text), Dates.Millisecond})
precompile(Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.TTY, Base.Pair{Symbol, Bool}, Base.Pair{Symbol, Bool}})
precompile(Tuple{Type{NamedTuple{(:context,), T} where T<:Tuple}, Tuple{Base.IOContext{Base.TTY}}})
precompile(Tuple{Base.var"#sprint##kw", NamedTuple{(:context,), Tuple{Base.IOContext{Base.TTY}}}, typeof(Base.sprint), Function, Dates.Millisecond})
precompile(Tuple{typeof(Base.print), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Dates.Millisecond})
precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Int64, Array{Base.Regex, 1}}, Int64})
precompile(Tuple{typeof(Base.copyto!), Array{Int64, 1}, Base.KeySet{Int64, Base.Dict{Int64, Array{Base.Regex, 1}}}})
precompile(Tuple{typeof(Base._replace!), Base.var"#new#295"{Tuple{Base.Pair{Symbol, Int64}, Base.Pair{Symbol, Int64}, Base.Pair{Symbol, Int64}}}, Array{Any, 1}, Array{Symbol, 1}, Int64})
precompile(Tuple{typeof(Base._typed_vcat!), Array{Any, 1}, Tuple{Array{Any, 1}, Array{Int64, 1}}})
precompile(Tuple{typeof(Base.in), Int64, Base.Set{Any}})
precompile(Tuple{typeof(Base.push!), Base.Set{Any}, Int64})
precompile(Tuple{typeof(Base._replace!), Base.var"#new#295"{Tuple{Base.Pair{Symbol, Int64}, Base.Pair{Symbol, Int64}}}, Array{Int64, 1}, Array{Int64, 1}, Int64})
precompile(Tuple{typeof(Base.print), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Crayons.Crayon})
precompile(Tuple{typeof(PrettyTables._print_table_header!), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, PrettyTables.Display, Any, Array{String, 2}, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Ref{Any}, Bool, Bool, PrettyTables.TextFormat, Crayons.Crayon, Array{Crayons.Crayon, 1}, Array{Crayons.Crayon, 1}, Crayons.Crayon, Crayons.Crayon})
precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Crayons.Crayon, String, Vararg{Any, N} where N})
precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Crayons.Crayon})
precompile(Tuple{typeof(Base.getproperty), PrettyTables.Highlighter, Symbol})
precompile(Tuple{typeof(InMemoryDatasets._pretty_tables_highlighter_func), InMemoryDatasets.Dataset, Int64, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Union{Base.Missing, String}, 1}, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Union{Base.Missing, Dates.Millisecond}, 1}, Int64})
precompile(Tuple{typeof(PrettyTables._flush_buffer!), Base.IOContext{Base.TTY}, Base.GenericIOBuffer{Array{UInt8, 1}}, Bool, Bool, Int64})


text:
export DGSEM
export WeakForm
export FluxDifferencingForm

abstract type AbstractVolumeForm end

struct WeakForm <: AbstractVolumeForm end
struct FluxDifferencingForm{VNF} <: AbstractVolumeForm
  volume_numericalflux::VNF
end

struct DGSEM{L, G, A1, A2, A3, A4, VF, SNF}
  law::L
  grid::G
  MJ::A1
  MJI::A2
  faceMJ::A3
  auxstate::A4
  volume_form::VF
  surface_numericalflux::SNF
end

Bennu.referencecell(dg::DGSEM) = referencecell(dg.grid)

function Adapt.adapt_structure(to, dg::DGSEM)
  names = fieldnames(DGSEM)
  args = ntuple(j->adapt(to, getfield(dg, names[j])), length(names))
  DGSEM{typeof.(args)...}(args...)
end

function DGSEM(; law, grid, surface_numericalflux,
                 volume_form = WeakForm())
  cell = referencecell(grid)
  M = mass(cell)
  _, J = components(metrics(grid))
  MJ = M * J
  MJI = 1 ./ MJ

  faceM = facemass(cell)
  _, faceJ = components(facemetrics(grid))

  faceMJ = faceM * faceJ

  auxstate = auxiliary.(Ref(law), points(grid))

  args = (law, grid, MJ, MJI, faceMJ, auxstate,
          volume_form, surface_numericalflux)
  DGSEM{typeof.(args)...}(args...)
end
getdevice(dg::DGSEM) = Bennu.device(arraytype(referencecell(dg)))

function (dg::DGSEM)(dq, q, time; increment = true)
  cell = referencecell(dg)
  grid = dg.grid
  device = getdevice(dg)
  dim = ndims(cell)
  Nq = size(cell)[1]

  @assert all(size(cell) .== Nq)
  @assert(length(eltype(q)) == numberofstates(dg.law))

  comp_stream = Event(device)

  comp_stream = launch_volumeterm(dg.volume_form, dq, q, dg;
                                  increment, dependencies=comp_stream)

  Nfp = Nq ^ (dim  - 1)
  workgroup_face = (Nfp,)
  ndrange = (Nfp * length(grid),)
  faceix⁻, faceix⁺ = faceindices(grid)
  facenormal, _ = components(facemetrics(grid))
  comp_stream = surfaceterm!(device, workgroup_face)(
    dg.law,
    dq,
    q,
    Val(Bennu.connectivityoffsets(cell, Val(2))),
    dg.surface_numericalflux,
    dg.MJI,
    faceix⁻,
    faceix⁺,
    dg.faceMJ,
    facenormal,
    boundaryfaces(grid),
    dg.auxstate,
    Val(dim);
    ndrange,
    dependencies = comp_stream
  )

  wait(comp_stream)
end

function launch_volumeterm(::WeakForm, dq, q, dg; increment, dependencies)
  device = getdevice(dg)
  cell = referencecell(dg)
  Nq = size(cell)[1]
  dim = ndims(cell)
  workgroup = ntuple(i -> i <= dim ? Nq : 1, 3)
  ndrange = (length(dg.grid) * workgroup[1], Base.tail(workgroup)...)
  comp_stream = volumeterm!(device, workgroup)(
    dg.law,
    dq,
    q,
    derivatives_1d(cell)[1],
    metrics(dg.grid),
    dg.MJ,
    dg.MJI,
    dg.auxstate,
    Val(dim),
    Val(Nq),
    Val(numberofstates(dg.law)),
    Val(increment);
    ndrange,
    dependencies
  )

  comp_stream
end

function launch_volumeterm(form::FluxDifferencingForm, dq, q, dg; increment, dependencies)
  cell = referencecell(dg)
  device = getdevice(dg)
  Nq = size(cell)[1]
  dim = ndims(cell)
  Naux = eltype(eltype(dg.auxstate)) === Nothing ? 0 : length(eltype(dg.auxstate))

  kernel_type = :per_dir
  if kernel_type == :naive
    workgroup = ntuple(i -> i <= min(2, dim) ? Nq : 1, 3)
    ndrange = (length(dg.grid) * workgroup[1], Base.tail(workgroup)...)
    comp_stream = esvolumeterm!(device, workgroup)(
      dg.law,
      dq,
      q,
      derivatives_1d(cell)[1],
      form.volume_numericalflux,
      metrics(dg.grid),
      dg.MJ,
      dg.MJI,
      dg.auxstate,
      Val(dim),
      Val(Nq),
      Val(numberofstates(dg.law)),
      Val(Naux),
      Val(increment);
      ndrange,
      dependencies
    )
  elseif kernel_type == :per_dir
    workgroup = ntuple(i -> i <= dim ? Nq : 1, 3)
    ndrange = (length(dg.grid) * workgroup[1], Base.tail(workgroup)...)
    comp_stream = dependencies
    for dir in 1:dim
      comp_stream = esvolumeterm_dir!(device, workgroup)(
        dg.law,
        dq,
        q,
        derivatives_1d(cell)[1],
        form.volume_numericalflux,
        metrics(dg.grid),
        dg.MJ,
        dg.MJI,
        dg.auxstate,
        dir == 1, # add_source
        Val(dir),
        Val(dim),
        Val(Nq),
        Val(numberofstates(dg.law)),
        Val(Naux),
        Val(dir == 1 ? increment : true);
        ndrange,
        dependencies = comp_stream
      )
    end
  else
    error("Unknown kernel type $kernel_type")
  end

  comp_stream
end

@kernel function volumeterm!(law,
                             dq,
                             q,
                             D,
                             metrics,
                             MJ,
                             MJI,
                             auxstate,
                             ::Val{dim},
                             ::Val{Nq},
                             ::Val{Ns},
                             ::Val{increment}) where {dim, Nq, Ns, increment}
  @uniform begin
    FT = eltype(law)
    Nq1 = Nq
    Nq2 = dim > 1 ? Nq : 1
    Nq3 = dim > 2 ? Nq : 1
  end

  l_F = @localmem FT (Nq1, Nq2, Nq3, dim, Ns)
  dqijk = @private FT (Ns,)
  p_MJ = @private FT (1,)

  e = @index(Group, Linear)
  i, j, k = @index(Local, NTuple)

  @inbounds begin
    ijk = i + Nq * (j - 1 + Nq * (k - 1))

    g = metrics[ijk, e].g

    qijk = q[ijk, e]
    auxijk = auxstate[ijk, e]
    MJijk = MJ[ijk, e]

    fijk = flux(law, qijk, auxijk)

    @unroll for s in 1:Ns
      @unroll for d in 1:dim
        l_F[i, j, k, d, s] = g[d, 1] * fijk[1, s]
        if dim > 1
          l_F[i, j, k, d, s] += g[d, 2] * fijk[2, s]
        end
        if dim > 2
          l_F[i, j, k, d, s] += g[d, 3] * fijk[3, s]
        end
        l_F[i, j, k, d, s] *= MJijk
      end
    end

    fill!(dqijk, -zero(FT))
    source!(law, dqijk, qijk, auxijk)
    nonconservative_term!(law, dqijk, qijk, auxijk)

    @synchronize

    ijk = i + Nq * (j - 1 + Nq * (k - 1))
    MJIijk = MJI[ijk, e]

    @unroll for n in 1:Nq
      Dni = D[n, i] * MJIijk
      Dnj = D[n, j] * MJIijk
      Dnk = D[n, k] * MJIijk
      @unroll for s in 1:Ns
        dqijk[s] += Dni * l_F[n, j, k, 1, s]
        if dim > 1
          dqijk[s] += Dnj * l_F[i, n, k, 2, s]
        end
        if dim > 2
          dqijk[s] += Dnk * l_F[i, j, n, 3, s]
        end
      end
    end

    if increment
      dq[ijk, e] += dqijk
    else
      dq[ijk, e] = dqijk[:]
    end
  end
end

@kernel function esvolumeterm!(law,
                               dq,
                               q,
                               D,
                               volume_numericalflux,
                               metrics,
                               MJ,
                               MJI,
                               auxstate,
                               ::Val{dim},
                               ::Val{Nq},
                               ::Val{Ns},
                               ::Val{Naux},
                               ::Val{increment}) where {dim, Nq, Ns, Naux, increment}
  @uniform begin
    FT = eltype(law)
    Nq1 = Nq
    Nq2 = dim > 1 ? Nq : 1
    Nq3 = dim > 2 ? Nq : 1

    q1 = MVector{Ns, FT}(undef)
    q2 = MVector{Ns, FT}(undef)
    aux1 = MVector{Naux, FT}(undef)
    aux2 = MVector{Naux, FT}(undef)
  end

  dqijk = @private FT (Ns,)

  pencil_q = @private FT (Ns, Nq3)
  pencil_aux = @private FT (Naux, Nq3)
  pencil_g3 = @private FT (3, Nq3)
  pencil_MJ = @private FT (Nq3,)

  l_q = @localmem FT (Nq1, Nq2, Ns)
  l_aux = @localmem FT (Nq1, Nq2, dim)
  l_g = @localmem FT (Nq1, Nq2, min(2, dim), dim)

  e = @index(Group, Linear)
  i, j = @index(Local, NTuple)

  @inbounds begin
    @unroll for k in 1:Nq3
      ijk = i + Nq * (j - 1 + Nq * (k - 1))

      pencil_MJ[k] = MJ[ijk, e]
      @unroll for s in 1:Ns
        pencil_q[s, k] = q[ijk, e][s]
      end
      @unroll for d in 1:dim
        pencil_aux[d, k] = aux[ijk, e][d]
      end
      if dim > 2
        @unroll for d in 1:dim
          pencil_g3[d, k] = metrics[ijk, e].g[3, d]
          pencil_g3[d, k] *= pencil_MJ[k]
        end
      end
    end

    @unroll for k in 1:Nq3
      @synchronize
      ijk = i + Nq * (j - 1 + Nq * (k - 1))

      @unroll for s in 1:Ns
        l_q[i, j, s] = pencil_q[s, k]
      end
      @unroll for s in 1:Naux
        l_aux[i, j, s] = pencil_aux[s, k]
      end

      MJk = pencil_MJ[k]
      @unroll for d in 1:dim
        l_g[i, j, 1, d] = MJk * metrics[ijk, e].g[1, d]
        if dim > 1
          l_g[i, j, 2, d] = MJk * metrics[ijk, e].g[2, d]
        end
      end

      @synchronize

      fill!(dqijk, -zero(FT))

      @unroll for s in 1:Ns
        q1[s] = l_q[i, j, s]
      end
      @unroll for s in 1:Naux
        aux1[s] = l_aux[i, j, s]
      end

      source!(law, dqijk, q1, aux1)

      MJIijk = 1 / pencil_MJ[k]
      @unroll for n in 1:Nq
        @unroll for s in 1:Ns
          q2[s] = l_q[n, j, s]
        end
        @unroll for s in 1:Naux
          aux2[s] = l_aux[n, j, s]
        end

        f = twopointflux(volume_numericalflux, law, q1, aux1, q2, aux2)
        @unroll for s in 1:Ns
          Din = MJIijk * D[i, n]
          Dni = MJIijk * D[n, i]
          @unroll for d in 1:dim
            dqijk[s] -= Din * l_g[i, j, 1, d] * f[d, s]
            dqijk[s] += f[d, s] * l_g[n, j, 1, d] * Dni
          end
        end

        if dim > 1
          @unroll for s in 1:Ns
            q2[s] = l_q[i, n, s]
          end
          @unroll for s in 1:Naux
            aux2[s] = l_aux[i, n, s]
          end
          f = twopointflux(volume_numericalflux, law, q1, aux1, q2, aux2)
          @unroll for s in 1:Ns
            Djn = MJIijk * D[j, n]
            Dnj = MJIijk * D[n, j]
            @unroll for d in 1:dim
              dqijk[s] -= Djn * l_g[i, j, 2, d] * f[d, s]
              dqijk[s] += f[d, s] * l_g[i, n, 2, d] * Dnj
            end
          end
        end

        if dim > 2
          @unroll for s in 1:Ns
            q2[s] = pencil_q[s, n]
          end
          @unroll for s in 1:Naux
            aux2[s] = pencil_aux[s, n]
          end
          f = twopointflux(volume_numericalflux, law, q1, aux1, q2, aux2)
          @unroll for s in 1:Ns
            Dkn = MJIijk * D[k, n]
            Dnk = MJIijk * D[n, k]
            @unroll for d in 1:dim
              dqijk[s] -= Dkn * pencil_g3[d, k] * f[d, s]
              dqijk[s] += f[d, s] * pencil_g3[d, n] * Dnk
            end
          end
        end
      end

      ijk = i + Nq * (j - 1 + Nq * (k - 1))
      if increment
        dq[ijk, e] += dqijk
      else
        dq[ijk, e] = dqijk[:]
      end
    end
  end
end

@kernel function esvolumeterm_dir!(law,
                                   dq,
                                   q,
                                   D,
                                   volume_numericalflux,
                                   metrics,
                                   MJ,
                                   MJI,
                                   auxstate,
                                   add_source,
                                   ::Val{dir},
                                   ::Val{dim},
                                   ::Val{Nq},
                                   ::Val{Ns},
                                   ::Val{Naux},
                                   ::Val{increment}) where {dir, dim, Nq, Ns, Naux, increment}
  @uniform begin
    FT = eltype(law)
    Nq1 = Nq
    Nq2 = dim > 1 ? Nq : 1
    Nq3 = dim > 2 ? Nq : 1
  end

  dqijk = @private FT (Ns,)

  q1 = @private FT (Ns,)
  aux1 = @private FT (Naux,)

  l_g = @localmem FT (Nq ^ 3, 3)

  e = @index(Group, Linear)
  i, j, k = @index(Local, NTuple)

  @inbounds begin
    ijk = i + Nq * (j - 1 + Nq * (k - 1))

    MJijk = MJ[ijk, e]
    @unroll for d in 1:dim
      l_g[ijk, d] = MJijk * metrics[ijk, e].g[dir, d]
    end

    fill!(dqijk, -zero(FT))

    @unroll for s in 1:Ns
      q1[s] = q[ijk, e][s]
    end
    @unroll for s in 1:Naux
      aux1[s] = auxstate[ijk, e][s]
    end

    add_source && source!(law, dqijk, q1, aux1)

    @synchronize

    ijk = i + Nq * (j - 1 + Nq * (k - 1))

    MJIijk = MJI[ijk, e]
    @unroll for n in 1:Nq
      if dir == 1
        id = i
        ild = n + Nq * ((j - 1) + Nq * (k - 1))
      elseif dir == 2
        id = j
        ild = i + Nq * ((n - 1) + Nq * (k - 1))
      elseif dir == 3
        id = k
        ild = i + Nq * ((j - 1) + Nq * (n - 1))
      end

      q2 = q[ild, e]
      aux2 = auxstate[ild, e]

      f = twopointflux(volume_numericalflux, law, q1, aux1, q2, aux2)
      @unroll for s in 1:Ns
        Ddn = MJIijk * D[id, n]
        Dnd = MJIijk * D[n, id]
        @unroll for d in 1:dim
          dqijk[s] -= Ddn * l_g[ijk, d] * f[d, s]
          dqijk[s] += f[d, s] * l_g[ild, d] * Dnd
        end
      end
    end

    if increment
      dq[ijk, e] += dqijk
    else
      dq[ijk, e] = dqijk[:]
    end
  end
end

@kernel function surfaceterm!(law,
                              dq,
                              q,
                              ::Val{faceoffsets},
                              numericalflux,
                              MJI,
                              faceix⁻,
                              faceix⁺,
                              faceMJ,
                              facenormal,
                              boundaryfaces,
                              auxstate,
                              ::Val{dim}) where {faceoffsets, dim}
  @uniform begin
    FT = eltype(q)
    nfaces = 2 * dim
  end

  e⁻ = @index(Group, Linear)
  i = @index(Local, Linear)

  @inbounds begin
    @unroll for face in 1:nfaces
        j = i + faceoffsets[face]
        id⁻ = faceix⁻[j, e⁻]

        n⃗ = facenormal[j, e⁻]
        fMJ = faceMJ[j, e⁻]

        aux⁻ = auxstate[id⁻]
        q⁻ = q[id⁻]

        boundarytag = boundaryfaces[face, e⁻]
        if boundarytag == 0
          id⁺ = faceix⁺[j, e⁻]
          q⁺ = q[id⁺]
          aux⁺ = auxstate[id⁺]
        else
          q⁺, aux⁺ = boundarystate(law, n⃗, q⁻, aux⁻, boundarytag)
        end

        nf = surfaceflux(numericalflux, law, n⃗, q⁻, aux⁻, q⁺, aux⁺)
        dq[id⁻] -= fMJ * nf * MJI[id⁻]

        @synchronize(mod(face, 2) == 0)
    end
  end
end

ext: jl