From ef1cd7742ea745799c5385c5c2bb4fbe8755d198 Mon Sep 17 00:00:00 2001
From: aminya <aminya@users.noreply.github.com>
Date: Fri, 27 Nov 2020 10:14:11 +0000
Subject: [PATCH] Update precompile_*.jl file

---
 .gitattributes                                |   6 +
 .../apple/1.1/precompile_MatLang.jl           | 166 ++++++++++++++++++
 .../apple/1.5/precompile_MatLang.jl           |  90 ++++++++++
 .../apple/1.6/precompile_MatLang.jl           |  86 +++++++++
 .../linux/1.1/precompile_MatLang.jl           | 166 ++++++++++++++++++
 .../linux/1.5/precompile_MatLang.jl           |  84 +++++++++
 .../linux/1.6/precompile_MatLang.jl           |  88 ++++++++++
 .../windows/1.1/precompile_MatLang.jl         | 166 ++++++++++++++++++
 .../windows/1.3/precompile_MatLang.jl         | 142 ---------------
 .../windows/1.5/precompile_MatLang.jl         |  90 ++++++++++
 .../windows/1.6/precompile_MatLang.jl         |  88 ++++++++++
 src/MatLang.jl                                |   1 +
 src/precompile_includer.jl                    | 123 ++++++++++---
 13 files changed, 1128 insertions(+), 168 deletions(-)
 create mode 100644 .gitattributes
 create mode 100644 deps/SnoopCompile/precompile/apple/1.1/precompile_MatLang.jl
 create mode 100644 deps/SnoopCompile/precompile/apple/1.5/precompile_MatLang.jl
 create mode 100644 deps/SnoopCompile/precompile/apple/1.6/precompile_MatLang.jl
 create mode 100644 deps/SnoopCompile/precompile/linux/1.1/precompile_MatLang.jl
 create mode 100644 deps/SnoopCompile/precompile/linux/1.5/precompile_MatLang.jl
 create mode 100644 deps/SnoopCompile/precompile/linux/1.6/precompile_MatLang.jl
 create mode 100644 deps/SnoopCompile/precompile/windows/1.1/precompile_MatLang.jl
 create mode 100644 deps/SnoopCompile/precompile/windows/1.5/precompile_MatLang.jl
 create mode 100644 deps/SnoopCompile/precompile/windows/1.6/precompile_MatLang.jl

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..cf87526
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,6 @@
+# Set default behaviour to automatically normalize line endings.
+* text=auto
+
+# Force bash scripts to always use lf line endings so that if a repo is accessed
+# in Unix via a file share from Windows, the scripts will work.
+*.sh text eol=lf
diff --git a/deps/SnoopCompile/precompile/apple/1.1/precompile_MatLang.jl b/deps/SnoopCompile/precompile/apple/1.1/precompile_MatLang.jl
new file mode 100644
index 0000000..a2d3a16
--- /dev/null
+++ b/deps/SnoopCompile/precompile/apple/1.1/precompile_MatLang.jl
@@ -0,0 +1,166 @@
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    isdefined(MatLang, Symbol("##freqspaceM#28")) && precompile(Tuple{getfield(MatLang, Symbol("##freqspaceM#28")), Int64, typeof(identity), Int64, Symbol})
+    isdefined(MatLang, Symbol("##onesM#11")) && precompile(Tuple{getfield(MatLang, Symbol("##onesM#11")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##onesM#11")) && precompile(Tuple{getfield(MatLang, Symbol("##onesM#11")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##randM#17")) && precompile(Tuple{getfield(MatLang, Symbol("##randM#17")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##randM#17")) && precompile(Tuple{getfield(MatLang, Symbol("##randM#17")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##sortM#29")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#29")), Bool, typeof(identity), Array{Int64, 1}, Symbol})
+    isdefined(MatLang, Symbol("##sortM#30")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#30")), Bool, typeof(identity), Array{Int64, 2}, Int64, Symbol})
+    isdefined(MatLang, Symbol("##sortM#30")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#30")), Bool, typeof(identity), Array{Integer, 3}, Int64, Symbol})
+    isdefined(MatLang, Symbol("##sortperm#31")) && precompile(Tuple{getfield(MatLang, Symbol("##sortperm#31")), Int64, Bool, typeof(identity), Array{Int64, 2}})
+    isdefined(MatLang, Symbol("##zerosM#5")) && precompile(Tuple{getfield(MatLang, Symbol("##zerosM#5")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##zerosM#5")) && precompile(Tuple{getfield(MatLang, Symbol("##zerosM#5")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##eyeM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##eyeM")), NamedTuple{(:like,), Tuple{Array{Int8, 2}}}, typeof(MatLang.eyeM), Int64, Int64})
+    isdefined(MatLang, Symbol("#kw##freqspaceM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##freqspaceM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.freqspaceM), Int64, Symbol})
+    isdefined(MatLang, Symbol("#kw##freqspaceM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##freqspaceM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.freqspaceM), Int64})
+    isdefined(MatLang, Symbol("#kw##ndgridM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##ndgridM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.ndgridM), Base.StepRange{Int64, Int64}})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.onesM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.onesM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.onesM), Int64})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.randM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.randM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.randM), Int64})
+    isdefined(MatLang, Symbol("#kw##sortM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##sortM")), NamedTuple{(:I,), Tuple{Bool}}, typeof(MatLang.sortM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##sortM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##sortM")), NamedTuple{(:I,), Tuple{Bool}}, typeof(MatLang.sortM), Array{Int64, 2}, Int64, Symbol})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.zerosM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.zerosM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.zerosM), Int64})
+    precompile(Tuple{typeof(MatLang.__init__)})
+    precompile(Tuple{typeof(MatLang.blkdiagM), Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.blkdiagM), Symbol, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.catM), Int64, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.catM), Int64, Array{Float64, 3}, Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.clcM)})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 1}, Int64})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.doubleM), Float64})
+    precompile(Tuple{typeof(MatLang.eyeM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.eyeM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.falseM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.falseM), Int64})
+    precompile(Tuple{typeof(MatLang.falseM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.falseM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.flipM), String})
+    precompile(Tuple{typeof(MatLang.int16M), Int64})
+    precompile(Tuple{typeof(MatLang.int32M), Int64})
+    precompile(Tuple{typeof(MatLang.int64M), Int64})
+    precompile(Tuple{typeof(MatLang.int8M), Int64})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Bool})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Char})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.lengthM), Array{Any, 2}})
+    precompile(Tuple{typeof(MatLang.lengthM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.linspaceM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Symbol, Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Symbol, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64, Symbol})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.StepRange{Int64, Int64}, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.UnitRange{Int64}, Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(MatLang.ndgridM), Base.StepRange{Int64, Int64}, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.ndgridM), Base.UnitRange{Int64}, Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(MatLang.ndgrid_fill), Array{Int64, 3}, Base.UnitRange{Int64}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.onesM), Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.randM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.randM), Int64})
+    precompile(Tuple{typeof(MatLang.randM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.randM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.repelemM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.repmatM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.singleM), Float64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Float64, 3}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Float64, 3}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 1}, Symbol})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 2}, Int64, Symbol})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Integer, 3}, Int64})
+    precompile(Tuple{typeof(MatLang.squeezeM), Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.transposeM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.transposeM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.trueM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.trueM), Int64})
+    precompile(Tuple{typeof(MatLang.trueM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.trueM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.uint16M), Int64})
+    precompile(Tuple{typeof(MatLang.uint32M), Int64})
+    precompile(Tuple{typeof(MatLang.uint64M), Int64})
+    precompile(Tuple{typeof(MatLang.uint8M), Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.zerosM), Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Tuple{Int64, Int64}})
+end
diff --git a/deps/SnoopCompile/precompile/apple/1.5/precompile_MatLang.jl b/deps/SnoopCompile/precompile/apple/1.5/precompile_MatLang.jl
new file mode 100644
index 0000000..dde45c5
--- /dev/null
+++ b/deps/SnoopCompile/precompile/apple/1.5/precompile_MatLang.jl
@@ -0,0 +1,90 @@
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+end
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.freqspaceM)),NamedTuple{(:dim,),Tuple{Int64}},typeof(freqspaceM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.ndgridM)),NamedTuple{(:dim,),Tuple{Int64}},typeof(ndgridM),StepRange{Int64,Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.randM)),NamedTuple{(:like,),Tuple{Array{Int64,2}}},typeof(randM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortperm)),NamedTuple{(:dims,),Tuple{Int64}},typeof(sortperm),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(blkdiagM),Array{Float64,2},Array{Float64,2},Vararg{Array{Float64,2},N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64,2},Vararg{Array{Float64,2},N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64,3},Vararg{Array{Float64,3},N} where N})
+    Base.precompile(Tuple{typeof(diagM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(eyeM),Int64})
+    Base.precompile(Tuple{typeof(flipM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(flipM),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(isscalarM),Symbol,Array{Float64,3}})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64})
+    Base.precompile(Tuple{typeof(meshgridM),StepRange{Int64,Int64}})
+    Base.precompile(Tuple{typeof(meshgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(ndgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(randM),Symbol,Int64})
+    Base.precompile(Tuple{typeof(randM),Type{T} where T,Int64,Int64})
+    Base.precompile(Tuple{typeof(repelemM),Array{Int64,2},Int64})
+    Base.precompile(Tuple{typeof(repmatM),Array{Int64,1},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(repmatM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Float64,3},Int64,Int64})
+    Base.precompile(Tuple{typeof(sortM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(sortM),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(sortM),Array{Integer,3},Int64})
+    Base.precompile(Tuple{typeof(squeezeM),Array{Float64,3}})
+    Base.precompile(Tuple{typeof(trueM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(zerosM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(zerosM),Type{Int32},Array{Int64,1}})
+    let fbody = try __lookup_kwbody__(which(sortperm, (Array{Int64,2},))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Int64,Bool,typeof(sortperm),Array{Int64,2},))
+        end
+    end
+end
diff --git a/deps/SnoopCompile/precompile/apple/1.6/precompile_MatLang.jl b/deps/SnoopCompile/precompile/apple/1.6/precompile_MatLang.jl
new file mode 100644
index 0000000..f0ce2a3
--- /dev/null
+++ b/deps/SnoopCompile/precompile/apple/1.6/precompile_MatLang.jl
@@ -0,0 +1,86 @@
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+end
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.freqspaceM)),NamedTuple{(:dim,), Tuple{Int64}},typeof(freqspaceM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.ndgridM)),NamedTuple{(:dim,), Tuple{Int64}},typeof(ndgridM),StepRange{Int64, Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.randM)),NamedTuple{(:like,), Tuple{Matrix{Int64}}},typeof(randM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortperm)),NamedTuple{(:dims,), Tuple{Int64}},typeof(sortperm),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(blkdiagM),Matrix{Float64},Matrix{Float64},Vararg{Matrix{Float64}, N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64, 3},Vararg{Array{Float64, 3}, N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Matrix{Float64},Vararg{Matrix{Float64}, N} where N})
+    Base.precompile(Tuple{typeof(diagM),Vector{Int64}})
+    Base.precompile(Tuple{typeof(eyeM),Int64})
+    Base.precompile(Tuple{typeof(flipM),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64})
+    Base.precompile(Tuple{typeof(meshgridM),StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(meshgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(ndgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(onesM),Type{Int32},Vector{Int64}})
+    Base.precompile(Tuple{typeof(randM),Symbol,Int64})
+    Base.precompile(Tuple{typeof(randM),Type,Int64,Int64})
+    Base.precompile(Tuple{typeof(repelemM),Matrix{Int64},Int64})
+    Base.precompile(Tuple{typeof(repmatM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(repmatM),Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Float64, 3},Int64,Int64})
+    Base.precompile(Tuple{typeof(sortM),Array{Integer, 3},Int64})
+    Base.precompile(Tuple{typeof(sortM),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(sortM),Vector{Int64}})
+    Base.precompile(Tuple{typeof(squeezeM),Array{Float64, 3}})
+    let fbody = try __lookup_kwbody__(which(sortperm, (Matrix{Int64},))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Int64,Bool,typeof(sortperm),Matrix{Int64},))
+        end
+    end
+end
diff --git a/deps/SnoopCompile/precompile/linux/1.1/precompile_MatLang.jl b/deps/SnoopCompile/precompile/linux/1.1/precompile_MatLang.jl
new file mode 100644
index 0000000..a2d3a16
--- /dev/null
+++ b/deps/SnoopCompile/precompile/linux/1.1/precompile_MatLang.jl
@@ -0,0 +1,166 @@
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    isdefined(MatLang, Symbol("##freqspaceM#28")) && precompile(Tuple{getfield(MatLang, Symbol("##freqspaceM#28")), Int64, typeof(identity), Int64, Symbol})
+    isdefined(MatLang, Symbol("##onesM#11")) && precompile(Tuple{getfield(MatLang, Symbol("##onesM#11")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##onesM#11")) && precompile(Tuple{getfield(MatLang, Symbol("##onesM#11")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##randM#17")) && precompile(Tuple{getfield(MatLang, Symbol("##randM#17")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##randM#17")) && precompile(Tuple{getfield(MatLang, Symbol("##randM#17")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##sortM#29")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#29")), Bool, typeof(identity), Array{Int64, 1}, Symbol})
+    isdefined(MatLang, Symbol("##sortM#30")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#30")), Bool, typeof(identity), Array{Int64, 2}, Int64, Symbol})
+    isdefined(MatLang, Symbol("##sortM#30")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#30")), Bool, typeof(identity), Array{Integer, 3}, Int64, Symbol})
+    isdefined(MatLang, Symbol("##sortperm#31")) && precompile(Tuple{getfield(MatLang, Symbol("##sortperm#31")), Int64, Bool, typeof(identity), Array{Int64, 2}})
+    isdefined(MatLang, Symbol("##zerosM#5")) && precompile(Tuple{getfield(MatLang, Symbol("##zerosM#5")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##zerosM#5")) && precompile(Tuple{getfield(MatLang, Symbol("##zerosM#5")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##eyeM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##eyeM")), NamedTuple{(:like,), Tuple{Array{Int8, 2}}}, typeof(MatLang.eyeM), Int64, Int64})
+    isdefined(MatLang, Symbol("#kw##freqspaceM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##freqspaceM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.freqspaceM), Int64, Symbol})
+    isdefined(MatLang, Symbol("#kw##freqspaceM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##freqspaceM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.freqspaceM), Int64})
+    isdefined(MatLang, Symbol("#kw##ndgridM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##ndgridM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.ndgridM), Base.StepRange{Int64, Int64}})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.onesM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.onesM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.onesM), Int64})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.randM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.randM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.randM), Int64})
+    isdefined(MatLang, Symbol("#kw##sortM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##sortM")), NamedTuple{(:I,), Tuple{Bool}}, typeof(MatLang.sortM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##sortM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##sortM")), NamedTuple{(:I,), Tuple{Bool}}, typeof(MatLang.sortM), Array{Int64, 2}, Int64, Symbol})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.zerosM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.zerosM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.zerosM), Int64})
+    precompile(Tuple{typeof(MatLang.__init__)})
+    precompile(Tuple{typeof(MatLang.blkdiagM), Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.blkdiagM), Symbol, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.catM), Int64, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.catM), Int64, Array{Float64, 3}, Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.clcM)})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 1}, Int64})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.doubleM), Float64})
+    precompile(Tuple{typeof(MatLang.eyeM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.eyeM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.falseM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.falseM), Int64})
+    precompile(Tuple{typeof(MatLang.falseM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.falseM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.flipM), String})
+    precompile(Tuple{typeof(MatLang.int16M), Int64})
+    precompile(Tuple{typeof(MatLang.int32M), Int64})
+    precompile(Tuple{typeof(MatLang.int64M), Int64})
+    precompile(Tuple{typeof(MatLang.int8M), Int64})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Bool})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Char})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.lengthM), Array{Any, 2}})
+    precompile(Tuple{typeof(MatLang.lengthM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.linspaceM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Symbol, Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Symbol, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64, Symbol})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.StepRange{Int64, Int64}, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.UnitRange{Int64}, Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(MatLang.ndgridM), Base.StepRange{Int64, Int64}, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.ndgridM), Base.UnitRange{Int64}, Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(MatLang.ndgrid_fill), Array{Int64, 3}, Base.UnitRange{Int64}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.onesM), Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.randM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.randM), Int64})
+    precompile(Tuple{typeof(MatLang.randM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.randM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.repelemM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.repmatM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.singleM), Float64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Float64, 3}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Float64, 3}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 1}, Symbol})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 2}, Int64, Symbol})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Integer, 3}, Int64})
+    precompile(Tuple{typeof(MatLang.squeezeM), Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.transposeM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.transposeM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.trueM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.trueM), Int64})
+    precompile(Tuple{typeof(MatLang.trueM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.trueM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.uint16M), Int64})
+    precompile(Tuple{typeof(MatLang.uint32M), Int64})
+    precompile(Tuple{typeof(MatLang.uint64M), Int64})
+    precompile(Tuple{typeof(MatLang.uint8M), Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.zerosM), Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Tuple{Int64, Int64}})
+end
diff --git a/deps/SnoopCompile/precompile/linux/1.5/precompile_MatLang.jl b/deps/SnoopCompile/precompile/linux/1.5/precompile_MatLang.jl
new file mode 100644
index 0000000..fa919af
--- /dev/null
+++ b/deps/SnoopCompile/precompile/linux/1.5/precompile_MatLang.jl
@@ -0,0 +1,84 @@
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+end
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.freqspaceM)),NamedTuple{(:dim,),Tuple{Int64}},typeof(freqspaceM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.ndgridM)),NamedTuple{(:dim,),Tuple{Int64}},typeof(ndgridM),StepRange{Int64,Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortperm)),NamedTuple{(:dims,),Tuple{Int64}},typeof(sortperm),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(blkdiagM),Array{Float64,2},Array{Float64,2},Vararg{Array{Float64,2},N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64,2},Vararg{Array{Float64,2},N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64,3},Vararg{Array{Float64,3},N} where N})
+    Base.precompile(Tuple{typeof(diagM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(eyeM),Int64})
+    Base.precompile(Tuple{typeof(flipM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(flipM),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64})
+    Base.precompile(Tuple{typeof(meshgridM),StepRange{Int64,Int64}})
+    Base.precompile(Tuple{typeof(meshgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(ndgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(randM),Symbol,Int64})
+    Base.precompile(Tuple{typeof(repelemM),Array{Int64,2},Int64})
+    Base.precompile(Tuple{typeof(repmatM),Array{Int64,1},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(repmatM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Float64,3},Int64,Int64})
+    Base.precompile(Tuple{typeof(sortM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(sortM),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(sortM),Array{Integer,3},Int64})
+    Base.precompile(Tuple{typeof(squeezeM),Array{Float64,3}})
+    let fbody = try __lookup_kwbody__(which(sortperm, (Array{Int64,2},))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Int64,Bool,typeof(sortperm),Array{Int64,2},))
+        end
+    end
+end
diff --git a/deps/SnoopCompile/precompile/linux/1.6/precompile_MatLang.jl b/deps/SnoopCompile/precompile/linux/1.6/precompile_MatLang.jl
new file mode 100644
index 0000000..d88fc41
--- /dev/null
+++ b/deps/SnoopCompile/precompile/linux/1.6/precompile_MatLang.jl
@@ -0,0 +1,88 @@
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+end
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.freqspaceM)),NamedTuple{(:dim,), Tuple{Int64}},typeof(freqspaceM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.ndgridM)),NamedTuple{(:dim,), Tuple{Int64}},typeof(ndgridM),StepRange{Int64, Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.randM)),NamedTuple{(:like,), Tuple{Matrix{Int64}}},typeof(randM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortperm)),NamedTuple{(:dims,), Tuple{Int64}},typeof(sortperm),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(blkdiagM),Matrix{Float64},Matrix{Float64},Vararg{Matrix{Float64}, N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64, 3},Vararg{Array{Float64, 3}, N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Matrix{Float64},Vararg{Matrix{Float64}, N} where N})
+    Base.precompile(Tuple{typeof(diagM),Vector{Int64}})
+    Base.precompile(Tuple{typeof(eyeM),Int64})
+    Base.precompile(Tuple{typeof(flipM),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64})
+    Base.precompile(Tuple{typeof(meshgridM),StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(meshgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(ndgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(onesM),Type{Int32},Vector{Int64}})
+    Base.precompile(Tuple{typeof(randM),Symbol,Int64})
+    Base.precompile(Tuple{typeof(randM),Type,Int64,Int64})
+    Base.precompile(Tuple{typeof(randM),Type{Int32},Vector{Int64}})
+    Base.precompile(Tuple{typeof(repelemM),Matrix{Int64},Int64})
+    Base.precompile(Tuple{typeof(repmatM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(repmatM),Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Float64, 3},Int64,Int64})
+    Base.precompile(Tuple{typeof(sortM),Array{Integer, 3},Int64})
+    Base.precompile(Tuple{typeof(sortM),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(sortM),Vector{Int64}})
+    Base.precompile(Tuple{typeof(squeezeM),Array{Float64, 3}})
+    Base.precompile(Tuple{typeof(trueM),Vector{Int64}})
+    let fbody = try __lookup_kwbody__(which(sortperm, (Matrix{Int64},))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Int64,Bool,typeof(sortperm),Matrix{Int64},))
+        end
+    end
+end
diff --git a/deps/SnoopCompile/precompile/windows/1.1/precompile_MatLang.jl b/deps/SnoopCompile/precompile/windows/1.1/precompile_MatLang.jl
new file mode 100644
index 0000000..a2d3a16
--- /dev/null
+++ b/deps/SnoopCompile/precompile/windows/1.1/precompile_MatLang.jl
@@ -0,0 +1,166 @@
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    isdefined(MatLang, Symbol("##freqspaceM#28")) && precompile(Tuple{getfield(MatLang, Symbol("##freqspaceM#28")), Int64, typeof(identity), Int64, Symbol})
+    isdefined(MatLang, Symbol("##onesM#11")) && precompile(Tuple{getfield(MatLang, Symbol("##onesM#11")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##onesM#11")) && precompile(Tuple{getfield(MatLang, Symbol("##onesM#11")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##randM#17")) && precompile(Tuple{getfield(MatLang, Symbol("##randM#17")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##randM#17")) && precompile(Tuple{getfield(MatLang, Symbol("##randM#17")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##sortM#29")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#29")), Bool, typeof(identity), Array{Int64, 1}, Symbol})
+    isdefined(MatLang, Symbol("##sortM#30")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#30")), Bool, typeof(identity), Array{Int64, 2}, Int64, Symbol})
+    isdefined(MatLang, Symbol("##sortM#30")) && precompile(Tuple{getfield(MatLang, Symbol("##sortM#30")), Bool, typeof(identity), Array{Integer, 3}, Int64, Symbol})
+    isdefined(MatLang, Symbol("##sortperm#31")) && precompile(Tuple{getfield(MatLang, Symbol("##sortperm#31")), Int64, Bool, typeof(identity), Array{Int64, 2}})
+    isdefined(MatLang, Symbol("##zerosM#5")) && precompile(Tuple{getfield(MatLang, Symbol("##zerosM#5")), Array{Float64, 1}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("##zerosM#5")) && precompile(Tuple{getfield(MatLang, Symbol("##zerosM#5")), Array{Float64, 2}, typeof(identity), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##eyeM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##eyeM")), NamedTuple{(:like,), Tuple{Array{Int8, 2}}}, typeof(MatLang.eyeM), Int64, Int64})
+    isdefined(MatLang, Symbol("#kw##freqspaceM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##freqspaceM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.freqspaceM), Int64, Symbol})
+    isdefined(MatLang, Symbol("#kw##freqspaceM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##freqspaceM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.freqspaceM), Int64})
+    isdefined(MatLang, Symbol("#kw##ndgridM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##ndgridM")), NamedTuple{(:dim,), Tuple{Int64}}, typeof(MatLang.ndgridM), Base.StepRange{Int64, Int64}})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.onesM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.onesM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##onesM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##onesM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.onesM), Int64})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.randM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.randM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##randM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##randM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.randM), Int64})
+    isdefined(MatLang, Symbol("#kw##sortM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##sortM")), NamedTuple{(:I,), Tuple{Bool}}, typeof(MatLang.sortM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##sortM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##sortM")), NamedTuple{(:I,), Tuple{Bool}}, typeof(MatLang.sortM), Array{Int64, 2}, Int64, Symbol})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Float64, 2}}}, typeof(MatLang.zerosM), Array{Int64, 1}})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Int32, 2}}}, typeof(MatLang.zerosM), Symbol, Int64})
+    isdefined(MatLang, Symbol("#kw##zerosM")) && precompile(Tuple{getfield(MatLang, Symbol("#kw##zerosM")), NamedTuple{(:like,), Tuple{Array{Int64, 2}}}, typeof(MatLang.zerosM), Int64})
+    precompile(Tuple{typeof(MatLang.__init__)})
+    precompile(Tuple{typeof(MatLang.blkdiagM), Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.blkdiagM), Symbol, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.catM), Int64, Array{Float64, 2}, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.catM), Int64, Array{Float64, 3}, Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.clcM)})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 1}, Int64})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.diagM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.doubleM), Float64})
+    precompile(Tuple{typeof(MatLang.eyeM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.eyeM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.eyeM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.falseM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.falseM), Int64})
+    precompile(Tuple{typeof(MatLang.falseM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.falseM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.flipM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.flipM), String})
+    precompile(Tuple{typeof(MatLang.int16M), Int64})
+    precompile(Tuple{typeof(MatLang.int32M), Int64})
+    precompile(Tuple{typeof(MatLang.int64M), Int64})
+    precompile(Tuple{typeof(MatLang.int8M), Int64})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.iscolumnM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.ismatrixM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isrowM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Array{String, 2}})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Bool})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Char})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isscalarM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.isvectorM), Symbol, String})
+    precompile(Tuple{typeof(MatLang.lengthM), Array{Any, 2}})
+    precompile(Tuple{typeof(MatLang.lengthM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.linspaceM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Symbol, Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.linspaceM), Symbol, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64, Symbol})
+    precompile(Tuple{typeof(MatLang.logspaceM), Int64, Int64})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.StepRange{Int64, Int64}, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.meshgridM), Base.UnitRange{Int64}, Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(MatLang.ndgridM), Base.StepRange{Int64, Int64}, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.ndgridM), Base.UnitRange{Int64}, Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(MatLang.ndgrid_fill), Array{Int64, 3}, Base.UnitRange{Int64}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.onesM), Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.onesM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.randM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.randM), Int64})
+    precompile(Tuple{typeof(MatLang.randM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.randM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.randM), Type{Int}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.repelemM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Int64})
+    precompile(Tuple{typeof(MatLang.repmatM), Array{Int64, 1}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.repmatM), Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.singleM), Float64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Float64, 3}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Float64, 3}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Int64, 2}, Int64})
+    precompile(Tuple{typeof(MatLang.sizeM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 1}, Symbol})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 2}, Int64, Symbol})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.sortM), Array{Integer, 3}, Int64})
+    precompile(Tuple{typeof(MatLang.squeezeM), Array{Float64, 3}})
+    precompile(Tuple{typeof(MatLang.transposeM), Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.transposeM), Symbol, Array{Int64, 2}})
+    precompile(Tuple{typeof(MatLang.trueM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.trueM), Int64})
+    precompile(Tuple{typeof(MatLang.trueM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.trueM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.uint16M), Int64})
+    precompile(Tuple{typeof(MatLang.uint32M), Int64})
+    precompile(Tuple{typeof(MatLang.uint64M), Int64})
+    precompile(Tuple{typeof(MatLang.uint8M), Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.zerosM), Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Symbol, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int32}, Array{Int64, 1}})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Int64, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Int64, Int64})
+    precompile(Tuple{typeof(MatLang.zerosM), Type{Int}, Tuple{Int64, Int64}})
+end
diff --git a/deps/SnoopCompile/precompile/windows/1.3/precompile_MatLang.jl b/deps/SnoopCompile/precompile/windows/1.3/precompile_MatLang.jl
index 759a9ff..93d5f85 100644
--- a/deps/SnoopCompile/precompile/windows/1.3/precompile_MatLang.jl
+++ b/deps/SnoopCompile/precompile/windows/1.3/precompile_MatLang.jl
@@ -1,178 +1,36 @@
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.eyeM)),NamedTuple{(:like,),Tuple{Array{Int8,2}}},typeof(eyeM),Int64,Int64})
     Base.precompile(Tuple{Core.kwftype(typeof(MatLang.freqspaceM)),NamedTuple{(:dim,),Tuple{Int64}},typeof(freqspaceM),Int64})
     Base.precompile(Tuple{Core.kwftype(typeof(MatLang.ndgridM)),NamedTuple{(:dim,),Tuple{Int64}},typeof(ndgridM),StepRange{Int64,Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.onesM)),NamedTuple{(:like,),Tuple{Array{Float64,2}}},typeof(onesM),Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.onesM)),NamedTuple{(:like,),Tuple{Array{Int32,2}}},typeof(onesM),Symbol,Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.onesM)),NamedTuple{(:like,),Tuple{Array{Int64,2}}},typeof(onesM),Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.randM)),NamedTuple{(:like,),Tuple{Array{Float64,2}}},typeof(randM),Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.randM)),NamedTuple{(:like,),Tuple{Array{Int32,2}}},typeof(randM),Symbol,Int64})
     Base.precompile(Tuple{Core.kwftype(typeof(MatLang.randM)),NamedTuple{(:like,),Tuple{Array{Int64,2}}},typeof(randM),Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortM)),NamedTuple{(:I,),Tuple{Bool}},typeof(sortM),Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortM)),NamedTuple{(:I,),Tuple{Bool}},typeof(sortM),Array{Int64,2},Int64,Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortperm)),NamedTuple{(:dims,),Tuple{Int64}},typeof(sortperm),Array{Int64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.zerosM)),NamedTuple{(:like,),Tuple{Array{Float64,2}}},typeof(zerosM),Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.zerosM)),NamedTuple{(:like,),Tuple{Array{Int32,2}}},typeof(zerosM),Symbol,Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.zerosM)),NamedTuple{(:like,),Tuple{Array{Int64,2}}},typeof(zerosM),Int64})
     Base.precompile(Tuple{typeof(blkdiagM),Array{Float64,2},Array{Float64,2},Vararg{Array{Float64,2},N} where N})
-    Base.precompile(Tuple{typeof(blkdiagM),Symbol,Array{Float64,2},Vararg{Array{Float64,2},N} where N})
     Base.precompile(Tuple{typeof(catM),Int64,Array{Float64,2},Vararg{Array{Float64,2},N} where N})
     Base.precompile(Tuple{typeof(catM),Int64,Array{Float64,3},Vararg{Array{Float64,3},N} where N})
-    Base.precompile(Tuple{typeof(clcM)})
     Base.precompile(Tuple{typeof(diagM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(diagM),Array{Int64,2}})
-    Base.precompile(Tuple{typeof(doubleM),Float64})
-    Base.precompile(Tuple{typeof(eyeM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(eyeM),Int64,Int64})
     Base.precompile(Tuple{typeof(eyeM),Int64})
-    Base.precompile(Tuple{typeof(eyeM),Tuple{Int64,Int64}})
-    Base.precompile(Tuple{typeof(eyeM),Type,Array{Int64,1}})
-    Base.precompile(Tuple{typeof(eyeM),Type,Int64,Int64})
-    Base.precompile(Tuple{typeof(eyeM),Type,Tuple{Int64,Int64}})
-    Base.precompile(Tuple{typeof(falseM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(falseM),Int64})
-    Base.precompile(Tuple{typeof(falseM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(falseM),Tuple{Int64,Int64}})
     Base.precompile(Tuple{typeof(flipM),Array{Int64,1}})
     Base.precompile(Tuple{typeof(flipM),Array{Int64,2}})
-    Base.precompile(Tuple{typeof(flipM),String})
-    Base.precompile(Tuple{typeof(int16M),Int64})
-    Base.precompile(Tuple{typeof(int32M),Int64})
-    Base.precompile(Tuple{typeof(int64M),Int64})
-    Base.precompile(Tuple{typeof(int8M),Int64})
-    Base.precompile(Tuple{typeof(iscolumnM),Array{Float64,1}})
-    Base.precompile(Tuple{typeof(iscolumnM),Array{Float64,2}})
-    Base.precompile(Tuple{typeof(iscolumnM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(iscolumnM),Array{Int64,2}})
-    Base.precompile(Tuple{typeof(iscolumnM),Array{String,1}})
-    Base.precompile(Tuple{typeof(iscolumnM),Array{String,2}})
-    Base.precompile(Tuple{typeof(iscolumnM),Int64})
-    Base.precompile(Tuple{typeof(iscolumnM),String})
-    Base.precompile(Tuple{typeof(iscolumnM),Symbol,Array{Float64,1}})
-    Base.precompile(Tuple{typeof(iscolumnM),Symbol,Array{Float64,2}})
-    Base.precompile(Tuple{typeof(iscolumnM),Symbol,Array{Int64,1}})
-    Base.precompile(Tuple{typeof(iscolumnM),Symbol,Array{Int64,2}})
-    Base.precompile(Tuple{typeof(iscolumnM),Symbol,Array{String,1}})
-    Base.precompile(Tuple{typeof(iscolumnM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(iscolumnM),Symbol,String})
-    Base.precompile(Tuple{typeof(ismatrixM),Array{Float64,1}})
-    Base.precompile(Tuple{typeof(ismatrixM),Array{Float64,2}})
-    Base.precompile(Tuple{typeof(ismatrixM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(ismatrixM),Array{Int64,2}})
-    Base.precompile(Tuple{typeof(ismatrixM),Array{String,1}})
-    Base.precompile(Tuple{typeof(ismatrixM),Array{String,2}})
-    Base.precompile(Tuple{typeof(ismatrixM),String})
-    Base.precompile(Tuple{typeof(ismatrixM),Symbol,Array{Float64,1}})
-    Base.precompile(Tuple{typeof(ismatrixM),Symbol,Array{Float64,2}})
-    Base.precompile(Tuple{typeof(ismatrixM),Symbol,Array{Int64,1}})
-    Base.precompile(Tuple{typeof(ismatrixM),Symbol,Array{Int64,2}})
-    Base.precompile(Tuple{typeof(ismatrixM),Symbol,Array{String,1}})
-    Base.precompile(Tuple{typeof(ismatrixM),Symbol,String})
-    Base.precompile(Tuple{typeof(isrowM),Array{Float64,1}})
-    Base.precompile(Tuple{typeof(isrowM),Array{Float64,2}})
-    Base.precompile(Tuple{typeof(isrowM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(isrowM),Array{Int64,2}})
-    Base.precompile(Tuple{typeof(isrowM),Array{String,1}})
-    Base.precompile(Tuple{typeof(isrowM),Array{String,2}})
-    Base.precompile(Tuple{typeof(isrowM),Int64})
-    Base.precompile(Tuple{typeof(isrowM),String})
-    Base.precompile(Tuple{typeof(isrowM),Symbol,Array{Float64,1}})
-    Base.precompile(Tuple{typeof(isrowM),Symbol,Array{Float64,2}})
-    Base.precompile(Tuple{typeof(isrowM),Symbol,Array{Int64,1}})
-    Base.precompile(Tuple{typeof(isrowM),Symbol,Array{Int64,2}})
-    Base.precompile(Tuple{typeof(isrowM),Symbol,Array{String,1}})
-    Base.precompile(Tuple{typeof(isrowM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(isrowM),Symbol,String})
-    Base.precompile(Tuple{typeof(isscalarM),Array{Float64,3}})
-    Base.precompile(Tuple{typeof(isscalarM),Array{String,1}})
-    Base.precompile(Tuple{typeof(isscalarM),Array{String,2}})
-    Base.precompile(Tuple{typeof(isscalarM),Bool})
-    Base.precompile(Tuple{typeof(isscalarM),Char})
-    Base.precompile(Tuple{typeof(isscalarM),Int64})
-    Base.precompile(Tuple{typeof(isscalarM),Symbol,Array{Float64,3}})
-    Base.precompile(Tuple{typeof(isscalarM),Symbol,Array{Int64,1}})
-    Base.precompile(Tuple{typeof(isscalarM),Symbol,Array{String,1}})
-    Base.precompile(Tuple{typeof(isscalarM),Symbol,Array{String,2}})
-    Base.precompile(Tuple{typeof(isscalarM),Symbol,Bool})
-    Base.precompile(Tuple{typeof(isscalarM),Symbol,Char})
-    Base.precompile(Tuple{typeof(isscalarM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(isscalarM),Symbol,String})
-    Base.precompile(Tuple{typeof(isvectorM),Array{Float64,1}})
-    Base.precompile(Tuple{typeof(isvectorM),Array{Float64,2}})
-    Base.precompile(Tuple{typeof(isvectorM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(isvectorM),Array{Int64,2}})
-    Base.precompile(Tuple{typeof(isvectorM),Array{String,1}})
-    Base.precompile(Tuple{typeof(isvectorM),Array{String,2}})
-    Base.precompile(Tuple{typeof(isvectorM),Int64})
-    Base.precompile(Tuple{typeof(isvectorM),String})
-    Base.precompile(Tuple{typeof(isvectorM),Symbol,Array{Float64,1}})
-    Base.precompile(Tuple{typeof(isvectorM),Symbol,Array{Float64,2}})
-    Base.precompile(Tuple{typeof(isvectorM),Symbol,Array{Int64,1}})
-    Base.precompile(Tuple{typeof(isvectorM),Symbol,Array{Int64,2}})
-    Base.precompile(Tuple{typeof(isvectorM),Symbol,Array{String,1}})
-    Base.precompile(Tuple{typeof(isvectorM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(isvectorM),Symbol,String})
-    Base.precompile(Tuple{typeof(lengthM),Array{Any,2}})
-    Base.precompile(Tuple{typeof(lengthM),Array{Int64,2}})
-    Base.precompile(Tuple{typeof(linspaceM),Int64,Int64,Int64})
-    Base.precompile(Tuple{typeof(linspaceM),Int64,Int64})
-    Base.precompile(Tuple{typeof(linspaceM),Symbol,Int64,Int64,Int64})
-    Base.precompile(Tuple{typeof(linspaceM),Symbol,Int64,Int64})
     Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Int64})
     Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(logspaceM),Int64,Int64})
     Base.precompile(Tuple{typeof(meshgridM),StepRange{Int64,Int64}})
     Base.precompile(Tuple{typeof(meshgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{typeof(ndgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(onesM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(onesM),Int64})
-    Base.precompile(Tuple{typeof(onesM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(onesM),Tuple{Int64,Int64}})
-    Base.precompile(Tuple{typeof(onesM),Type,Int64,Int64})
-    Base.precompile(Tuple{typeof(onesM),Type,Tuple{Int64,Int64}})
-    Base.precompile(Tuple{typeof(onesM),Type{Int32},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(randM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(randM),Int64})
     Base.precompile(Tuple{typeof(randM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(randM),Tuple{Int64,Int64}})
     Base.precompile(Tuple{typeof(randM),Type,Int64,Int64})
-    Base.precompile(Tuple{typeof(randM),Type,Tuple{Int64,Int64}})
-    Base.precompile(Tuple{typeof(randM),Type{Int32},Array{Int64,1}})
     Base.precompile(Tuple{typeof(repelemM),Array{Int64,2},Int64})
     Base.precompile(Tuple{typeof(repmatM),Array{Int64,1},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(repmatM),Array{Int64,1},Int64,Int64})
-    Base.precompile(Tuple{typeof(repmatM),Array{Int64,1},Int64})
-    Base.precompile(Tuple{typeof(repmatM),Array{Int64,1},Tuple{Int64,Int64}})
     Base.precompile(Tuple{typeof(repmatM),Int64,Int64,Int64})
-    Base.precompile(Tuple{typeof(singleM),Float64})
     Base.precompile(Tuple{typeof(sizeM),Array{Float64,3},Int64,Int64})
-    Base.precompile(Tuple{typeof(sizeM),Array{Int64,2},Int64})
     Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Float64,3},Int64,Int64})
-    Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Int64,2},Int64})
     Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Int64,2}})
     Base.precompile(Tuple{typeof(sortM),Array{Int64,1}})
     Base.precompile(Tuple{typeof(sortM),Array{Int64,2}})
     Base.precompile(Tuple{typeof(sortM),Array{Integer,3},Int64})
     Base.precompile(Tuple{typeof(squeezeM),Array{Float64,3}})
-    Base.precompile(Tuple{typeof(transposeM),Array{Int64,2}})
-    Base.precompile(Tuple{typeof(transposeM),Symbol,Array{Int64,2}})
     Base.precompile(Tuple{typeof(trueM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(trueM),Int64})
-    Base.precompile(Tuple{typeof(trueM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(trueM),Tuple{Int64,Int64}})
-    Base.precompile(Tuple{typeof(uint16M),Int64})
-    Base.precompile(Tuple{typeof(uint32M),Int64})
-    Base.precompile(Tuple{typeof(uint64M),Int64})
-    Base.precompile(Tuple{typeof(uint8M),Int64})
     Base.precompile(Tuple{typeof(zerosM),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(zerosM),Int64})
-    Base.precompile(Tuple{typeof(zerosM),Symbol,Int64})
-    Base.precompile(Tuple{typeof(zerosM),Tuple{Int64,Int64}})
-    Base.precompile(Tuple{typeof(zerosM),Type,Int64,Int64,Int64})
-    Base.precompile(Tuple{typeof(zerosM),Type,Int64,Int64})
-    Base.precompile(Tuple{typeof(zerosM),Type,Tuple{Int64,Int64}})
     Base.precompile(Tuple{typeof(zerosM),Type{Int32},Array{Int64,1}})
     isdefined(MatLang, Symbol("##sortperm#31")) && Base.precompile(Tuple{getfield(MatLang, Symbol("##sortperm#31")),Int64,Bool,typeof(sortperm),Array{Int64,2}})
-    isdefined(MatLang, Symbol("#32#33")) && Base.precompile(Tuple{getfield(MatLang, Symbol("#32#33")),Array{Int64,1}})
 end
diff --git a/deps/SnoopCompile/precompile/windows/1.5/precompile_MatLang.jl b/deps/SnoopCompile/precompile/windows/1.5/precompile_MatLang.jl
new file mode 100644
index 0000000..c68872d
--- /dev/null
+++ b/deps/SnoopCompile/precompile/windows/1.5/precompile_MatLang.jl
@@ -0,0 +1,90 @@
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+end
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.freqspaceM)),NamedTuple{(:dim,),Tuple{Int64}},typeof(freqspaceM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.ndgridM)),NamedTuple{(:dim,),Tuple{Int64}},typeof(ndgridM),StepRange{Int64,Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.randM)),NamedTuple{(:like,),Tuple{Array{Int64,2}}},typeof(randM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortperm)),NamedTuple{(:dims,),Tuple{Int64}},typeof(sortperm),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(blkdiagM),Array{Float64,2},Array{Float64,2},Vararg{Array{Float64,2},N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64,2},Vararg{Array{Float64,2},N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64,3},Vararg{Array{Float64,3},N} where N})
+    Base.precompile(Tuple{typeof(diagM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(eyeM),Int64})
+    Base.precompile(Tuple{typeof(falseM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(flipM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(flipM),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64})
+    Base.precompile(Tuple{typeof(meshgridM),StepRange{Int64,Int64}})
+    Base.precompile(Tuple{typeof(meshgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(ndgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(randM),Symbol,Int64})
+    Base.precompile(Tuple{typeof(randM),Type{T} where T,Int64,Int64})
+    Base.precompile(Tuple{typeof(repelemM),Array{Int64,2},Int64})
+    Base.precompile(Tuple{typeof(repmatM),Array{Int64,1},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(repmatM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Float64,3},Int64,Int64})
+    Base.precompile(Tuple{typeof(sortM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(sortM),Array{Int64,2}})
+    Base.precompile(Tuple{typeof(sortM),Array{Integer,3},Int64})
+    Base.precompile(Tuple{typeof(squeezeM),Array{Float64,3}})
+    Base.precompile(Tuple{typeof(trueM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(zerosM),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(zerosM),Type{Int32},Array{Int64,1}})
+    let fbody = try __lookup_kwbody__(which(sortperm, (Array{Int64,2},))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Int64,Bool,typeof(sortperm),Array{Int64,2},))
+        end
+    end
+end
diff --git a/deps/SnoopCompile/precompile/windows/1.6/precompile_MatLang.jl b/deps/SnoopCompile/precompile/windows/1.6/precompile_MatLang.jl
new file mode 100644
index 0000000..eeb0fc1
--- /dev/null
+++ b/deps/SnoopCompile/precompile/windows/1.6/precompile_MatLang.jl
@@ -0,0 +1,88 @@
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+end
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.freqspaceM)),NamedTuple{(:dim,), Tuple{Int64}},typeof(freqspaceM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.ndgridM)),NamedTuple{(:dim,), Tuple{Int64}},typeof(ndgridM),StepRange{Int64, Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.randM)),NamedTuple{(:like,), Tuple{Matrix{Int64}}},typeof(randM),Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(MatLang.sortperm)),NamedTuple{(:dims,), Tuple{Int64}},typeof(sortperm),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(blkdiagM),Matrix{Float64},Matrix{Float64},Vararg{Matrix{Float64}, N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Array{Float64, 3},Vararg{Array{Float64, 3}, N} where N})
+    Base.precompile(Tuple{typeof(catM),Int64,Matrix{Float64},Vararg{Matrix{Float64}, N} where N})
+    Base.precompile(Tuple{typeof(diagM),Vector{Int64}})
+    Base.precompile(Tuple{typeof(eyeM),Int64})
+    Base.precompile(Tuple{typeof(flipM),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(logspaceM),Int64,Int64})
+    Base.precompile(Tuple{typeof(meshgridM),StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(meshgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(ndgridM),UnitRange{Int64},UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(onesM),Symbol,Int64})
+    Base.precompile(Tuple{typeof(randM),Symbol,Int64})
+    Base.precompile(Tuple{typeof(randM),Type,Int64,Int64})
+    Base.precompile(Tuple{typeof(repelemM),Matrix{Int64},Int64})
+    Base.precompile(Tuple{typeof(repmatM),Int64,Int64,Int64})
+    Base.precompile(Tuple{typeof(repmatM),Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(sizeM),Symbol,Array{Float64, 3},Int64,Int64})
+    Base.precompile(Tuple{typeof(sortM),Array{Integer, 3},Int64})
+    Base.precompile(Tuple{typeof(sortM),Matrix{Int64}})
+    Base.precompile(Tuple{typeof(sortM),Vector{Int64}})
+    Base.precompile(Tuple{typeof(squeezeM),Array{Float64, 3}})
+    Base.precompile(Tuple{typeof(trueM),Vector{Int64}})
+    Base.precompile(Tuple{typeof(zerosM),Type,Int64,Int64})
+    let fbody = try __lookup_kwbody__(which(sortperm, (Matrix{Int64},))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Int64,Bool,typeof(sortperm),Matrix{Int64},))
+        end
+    end
+end
diff --git a/src/MatLang.jl b/src/MatLang.jl
index f1834d6..2eacc04 100644
--- a/src/MatLang.jl
+++ b/src/MatLang.jl
@@ -23,4 +23,5 @@ function __init__()
 end
 ################################################################
 
+include("precompile_includer.jl")
 end # module
diff --git a/src/precompile_includer.jl b/src/precompile_includer.jl
index e9efa95..4193d8e 100644
--- a/src/precompile_includer.jl
+++ b/src/precompile_includer.jl
@@ -8,54 +8,125 @@ ismultiversion = true
 @static if !should_precompile
     # nothing
 elseif !ismultios && !ismultiversion
-    include("../deps/SnoopCompile/precompile/precompile_MatLang.jl")
-    _precompile_()
+    @static if (isfile("../deps/SnoopCompile/precompile/precompile_MatLang.jl"))
+        include("../deps/SnoopCompile/precompile/precompile_MatLang.jl")
+        _precompile_()
+    end
 else
     @static if Sys.islinux()
         @static if v"1.0.0-DEV" <= VERSION <= v"1.0.9"
-            include("../deps/SnoopCompile/precompile/linux/1.0/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/linux/1.0/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/linux/1.0/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.1.0-DEV" <= VERSION <= v"1.1.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/linux/1.1/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/linux/1.1/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.2.0-DEV" <= VERSION <= v"1.2.9"
-            include("../deps/SnoopCompile/precompile/linux/1.2/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/linux/1.2/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/linux/1.2/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.3.0-DEV" <= VERSION <= v"1.3.9"
-            include("../deps/SnoopCompile/precompile/linux/1.3/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/linux/1.3/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/linux/1.3/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.4.0-DEV" <= VERSION <= v"1.4.9"
-            include("../deps/SnoopCompile/precompile/linux/1.4/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/linux/1.4/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/linux/1.4/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.5.0-DEV" <= VERSION <= v"1.5.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/linux/1.5/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/linux/1.5/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.6.0-DEV" <= VERSION <= v"1.6.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/linux/1.6/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/linux/1.6/precompile_MatLang.jl")
+                _precompile_()
+            end
         else
         end
 
     elseif Sys.iswindows()
         @static if v"1.0.0-DEV" <= VERSION <= v"1.0.9"
-            include("../deps/SnoopCompile/precompile/windows/1.0/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/windows/1.0/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/windows/1.0/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.1.0-DEV" <= VERSION <= v"1.1.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/windows/1.1/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/windows/1.1/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.2.0-DEV" <= VERSION <= v"1.2.9"
-            include("../deps/SnoopCompile/precompile/windows/1.2/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/windows/1.2/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/windows/1.2/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.3.0-DEV" <= VERSION <= v"1.3.9"
-            include("../deps/SnoopCompile/precompile/windows/1.3/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/windows/1.3/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/windows/1.3/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.4.0-DEV" <= VERSION <= v"1.4.9"
-            include("../deps/SnoopCompile/precompile/windows/1.4/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/windows/1.4/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/windows/1.4/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.5.0-DEV" <= VERSION <= v"1.5.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/windows/1.5/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/windows/1.5/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.6.0-DEV" <= VERSION <= v"1.6.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/windows/1.6/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/windows/1.6/precompile_MatLang.jl")
+                _precompile_()
+            end
         else
         end
 
     elseif Sys.isapple()
         @static if v"1.0.0-DEV" <= VERSION <= v"1.0.9"
-            include("../deps/SnoopCompile/precompile/apple/1.0/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/apple/1.0/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/apple/1.0/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.1.0-DEV" <= VERSION <= v"1.1.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/apple/1.1/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/apple/1.1/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.2.0-DEV" <= VERSION <= v"1.2.9"
-            include("../deps/SnoopCompile/precompile/apple/1.2/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/apple/1.2/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/apple/1.2/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.3.0-DEV" <= VERSION <= v"1.3.9"
-            include("../deps/SnoopCompile/precompile/apple/1.3/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/apple/1.3/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/apple/1.3/precompile_MatLang.jl")
+                _precompile_()
+            end
         elseif v"1.4.0-DEV" <= VERSION <= v"1.4.9"
-            include("../deps/SnoopCompile/precompile/apple/1.4/precompile_MatLang.jl")
-            _precompile_()
+            @static if (isfile("../deps/SnoopCompile/precompile/apple/1.4/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/apple/1.4/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.5.0-DEV" <= VERSION <= v"1.5.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/apple/1.5/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/apple/1.5/precompile_MatLang.jl")
+                _precompile_()
+            end
+        elseif v"1.6.0-DEV" <= VERSION <= v"1.6.9"
+            @static if (isfile("../deps/SnoopCompile/precompile/apple/1.6/precompile_MatLang.jl"))
+                include("../deps/SnoopCompile/precompile/apple/1.6/precompile_MatLang.jl")
+                _precompile_()
+            end
         else
         end