text:
### A Pluto.jl notebook ###
# v0.18.0

using Markdown
using InteractiveUtils

# ╔═╡ 2babb04c-7f14-4c30-a4f9-348ed31d4fbf
md"""
### Flux Balance Analysis of the Urea Cycle
We are interested in the level of information required for flux balance analysis calculations. In particular, does a flux calculation significantly improve when including different levels of information in the bounds and the dilution terms? To explore this question, calculate the flux distribution through the urea cycle in a population of [HL60 cells](https://www.atcc.org/products/ccl-240?matchtype=b&network=g&device=c&adposition=&keyword=hl60%20cells&gclid=EAIaIQobChMIyfXmmfiG9gIVlDY4Ch3MYQ-YEAAYAiAAEgLPfvD_BwE) growing in batch culture with a doubling time of $\tau_{d}$ = 20 hr for four cases:

* __Case 1__: Ignore dilution and bounds metabolite effects
* __Case 2__: Ignore dilution but include metabolite data in the bounds
* __Case 3__: Include dilution but ignore metabolite data in the bounds
* __Case 4__: Include both dilution and metabolite data in bounds

The teaching team found that the rate of oxygen uptake by the urea cycle is $q_{O2}$ = 0.25 $\mu$mol/gDW-s.

__Assumptions__:
* The $k_{cat}$'s: EC:3.5.3.1 = 249 s$^{-1}$; EC:2.1.33 = 88.1 s$^{-1}$; EC:4.3.2.1 = 34.5 s$^{-1}$; EC:6.3.4.5 = 203 s$^{-1}$ and EC:1.14.13.39 = 13.7 s$^{-1}$;
* The steady-state enzyme concentration in the pathway is uniform E $\simeq$ 0.01 μmol/gDW;
* Use [Park et al. Nat Chem Biol 12:482-9, 2016](https://pubmed.ncbi.nlm.nih.gov/27159581/) for $K_{m}$ and metabolite concentrations measurements
* All enzymes are maximally active (ignore allosteric effects).
"""

# ╔═╡ 54d23ccb-211c-4716-a80c-2c087198232d
md"""
##### Load/build stoichiometric array
"""

# ╔═╡ 47a3f3fe-425d-434c-be06-1cd36a56fe25
md"""
### C1: Ignore dilution and bounds metabolite effects
"""

# ╔═╡ deafe11f-9065-43f4-b500-c64ff41026bd
md"""
##### Computation C1
"""

# ╔═╡ 12eef416-b3ab-4f03-8ac0-a9783dcca9bd
md"""
### C2: Ignore dilution but include metabolite data in the bounds

Let's use general multisubstrate kinetics to compute flux bounds for the urea cycle problem.
Suppose the irreversible rate $v_{i}$ is dependent upon susbtrates $S_{j},j=1,2,\dots,\mathcal{S}$, then the multiple saturation kinetic form is given by:

$$v_{i} = V_{max,i}\left[\frac{\prod_{j}\frac{S_{j}}{K_{j}}}{\prod_{j}\left(1+\frac{S_{j}}{K_{j}}\right) - 1}\right]\qquad{i=1,2,\dots,\mathcal{R}}$$

where $V_{max,i}$ denote the maximum reaction rate (units: concentration/time), $S_{j}$ denotes the substrate concentration (units: concentration) and $K_{j}$ denotes the saturation constant for substrate $j$.

* [Liebermeister W, Klipp E. Bringing metabolic networks to life: convenience rate law and thermodynamic constraints. Theor Biol Med Model. 2006;3:41. Published 2006 Dec 15. doi:10.1186/1742-4682-3-41](https://www.ncbi.nlm.nih.gov/labs/pmc/articles/PMC1781438/)

We need to calculate the substrate/$K_{m}$ ratios to calculate the rates. To do that, we can use the metabolite concentration and $K_{m}$ data from:

* [Park JO, Rubin SA, Xu YF, Amador-Noguez D, Fan J, Shlomi T, Rabinowitz JD. Metabolite concentrations, fluxes and free energies imply efficient enzyme usage. Nat Chem Biol. 2016 Jul;12(7):482-9. doi: 10.1038/nchembio.2077. Epub 2016 May 2. PMID: 27159581; PMCID: PMC4912430.](https://pubmed.ncbi.nlm.nih.gov/27159581/)
"""

# ╔═╡ e2917845-d956-45f0-a379-ea826caf7d88
md"""
##### Are any of the enzymes in our system in the Park dataset?
To answer this question, let's take advantage of the features of [DataFrames](https://dataframes.juliadata.org/stable/) and do in-memory filtering of the dataset using the [filter](https://dataframes.juliadata.org/stable/lib/functions/#Base.filter) command. Let's filter on the [enzyme commission number (ec number)](https://en.wikipedia.org/wiki/Enzyme_Commission_number).
"""

# ╔═╡ 70239f9d-1ea8-4ad2-92a3-126cd99de4f0
md"""
### C3: Include dilution but ignore metabolite data in the bounds

We have (up to now) ignored the dilution to growth terms (as often done in practice). Typically, we do not have access to intracellular metabolite concentration data; thus, including the dilution terms makes the problem more difficult. In particular, when including the dilution due to growth terms, the intracellular metabolite balances are given by (at steady state):

$$\sum_{j=1}^{\mathcal{R}}\sigma_{ij}v_{j} - \mu{x}_{i} = 0\qquad{i=1,2,\dots,\mathcal{M}}$$

where $\sigma_{ij}$ is the stoichiometric coefficient of metabolite $i$ in reaction $j$, $v_{j}$ denotes the $j$ metabolic flux, $\mu$ denotes the specific growth rate (units: hr$^{-1}$) and $x_{i}$ denotes the concentration of metabolite $i$ (units: $\star$mol/gDW-hr).

Let's use the [Park et al dataset](https://pubmed.ncbi.nlm.nih.gov/27159581/) to estimate values for $x_{i}$. However, how do we change the problem structure to account for the dilution terms and convert the concentration values to cell mass-specific units?
"""

# ╔═╡ cb7d76b8-85f9-4886-a4f3-3f9fb82e42dc
md"""
##### Propose a strategy (or strategies) for accounting for dilution terms
"""

# ╔═╡ d3a2474e-f502-4247-bba6-1f7d5f88f12d
md"""
Fill me in using markdown and latex
"""

# ╔═╡ db005134-6e21-474a-9539-91faf6d0a4a4
md"""
##### Compute specific growth rate
"""

# ╔═╡ a7df4d41-1c0f-422e-8f21-c84b812ac3cd
md"""
##### Concentration conversion factor
Assume HL60 cells are spherical. Use [bionumbers]() to formulate a concentration conversion factor.
"""

# ╔═╡ b552fa38-cdc2-4f46-917f-4cac78694c86
md"""
##### Formulate the concentration array
"""

# ╔═╡ c0569dfd-784f-43c5-966d-6ea2b25b9992
md"""
##### Computation C3
"""

# ╔═╡ 7e11b015-ab19-4aba-80b1-a413ab13439f
begin

	# computation for C3 goes here ...

end

# ╔═╡ eaa02eea-2c86-4e05-bbe3-46174bb9c7d2
md"""
### C4: Include both dilution and metabolite data in bounds
"""

# ╔═╡ 58a35e5c-2f3c-4818-a290-7b8ae509320f
function ingredients(path::String)

    # this is from the Julia source code (evalfile in base/loading.jl)
    # but with the modification that it returns the module instead of the last object
    name = Symbol("lib")
    m = Module(name)
    Core.eval(m,
        Expr(:toplevel,
            :(eval(x) = $(Expr(:core, :eval))($name, x)),
            :(include(x) = $(Expr(:top, :include))($name, x)),
            :(include(mapexpr::Function, x) = $(Expr(:top, :include))(mapexpr, $name, x)),
            :(include($path))))
    m
end

# ╔═╡ acd56faf-5f71-435f-ba5b-10faa7cc7b61
begin

    # import some packages -
    using PlutoUI
    using PrettyTables
    using LinearAlgebra
    using Plots
    using GLPK
    using DataFrames
    using CSV
	using StatsPlots
	using Statistics
	using StatsBase

    # setup paths -
    const _PATH_TO_NOTEBOOK = pwd()
    const _PATH_TO_SRC = joinpath(_PATH_TO_NOTEBOOK, "src")
    const _PATH_TO_DATA = joinpath(_PATH_TO_NOTEBOOK, "data")
	const _PATH_TO_CONFIG = joinpath(_PATH_TO_NOTEBOOK, "config")
	const _PATH_TO_FIGS = joinpath(_PATH_TO_NOTEBOOK, "figs")

    # load the PS3 code lib -
    lib = ingredients(joinpath(_PATH_TO_SRC, "Include.jl"))

    # return -
    nothing
end

# ╔═╡ 0fe1a22d-a333-4834-88be-92180c39bbb3
PlutoUI.LocalResource(joinpath(_PATH_TO_FIGS,"Fig-Urea-cycle.png"))

# ╔═╡ 24f4f6d4-7f78-40fa-bb3e-505c0940ec91
begin

	# Load the stoichiometric matrix -

    # load/parse the network file -
    _PATH_TO_NETWORK_FILE = joinpath(_PATH_TO_CONFIG,"Network.net")
    list_of_reactions = lib.read_reaction_file(_PATH_TO_NETWORK_FILE);

    # build the stoichiometric array -
    (S, mna, rna) = lib.build_stoichiometric_matrix(list_of_reactions; expand=true);

	# get expanded reaction strings -
	expanded_reaction_array = lib.expand_reversible_reactions(list_of_reactions)

    # return -
    nothing
end

# ╔═╡ e953d072-7b5a-4310-b259-4e0cabbd6291
(ℳ,ℛ) = size(S)

# ╔═╡ 7558ee4f-87ca-4fa2-89bb-7a476c5e1252
begin

	# E -
	Eₒ = 0.01 # units: μmol/gDW
	u = ones(6)
	E = Eₒ.*u

	# setup flux bounds array -
	flux_bounds_array = zeros(ℛ,2)
	flux_bounds_array[:,2] .= 100.0 # default value is 100 for flux units: μmol/gDW-s

	# setup species bounds array -
	species_bounds_array = zeros(ℳ,2)

	# setup the objective coefficient array -
	c_vector = zeros(ℛ)

	# what is the index of the urea flux?
	idx_b₄ = findall(x->x=="b4", rna)[1]
	c_vector[idx_b₄] = -1

	# compute the flux -
	result_case_1 = lib.flux(S,flux_bounds_array,species_bounds_array,c_vector);

	# show -
	nothing
end

# ╔═╡ 4dce933f-693c-4788-9c77-63784871a4c0
# check:
with_terminal() do
	ef = result_case_1.exit_flag
	sf = result_case_1.status_flag

	if (ef == 0.0 && sf == 5.0)
		println("Optimal solution found. exit flag = $(ef) and status flag = $(sf)")
	else
		println("Ooops! Check your problem setup. exit flag = $(ef) and status flag = $(sf)")
	end
end

# ╔═╡ 70d11054-4d8a-4dcc-a8cd-1f762c2dd9b8
let

	# get flux values from the result -
	calculated_flux_array = result_case_1.calculated_flux_array

	# build flux table -
	flux_table = Array{Any,2}(undef,ℛ,4)

	# populate -
	for i ∈ 1:ℛ
		flux_table[i,1] = i
		flux_table[i,2] = rna[i]
		flux_table[i,3] = calculated_flux_array[i]*(1) # units: μmol/gDW-hr
		flux_table[i,4] = expanded_reaction_array[i]
	end

	# setup header -
	header_row = (["i","name","flux","reaction"],["","","μmol/gDW-s",""])

	with_terminal() do
		pretty_table(flux_table; header=header_row, alignment=:l)
	end
end

# ╔═╡ 880ce921-308b-4e3c-8bd9-fb9d07d18bd3
begin

    # load the metabolite data into a DataFrame -
    path_to_data_file = joinpath(_PATH_TO_DATA, "Metabolite-NatChemBio-12-482-2016.csv")
    metabolite_table = CSV.read(path_to_data_file, DataFrame)
end

# ╔═╡ 85e1ac31-90cf-48da-b4d7-b6c009328084
begin

	# what are the ec numbers in our system? (add as strings)
	ec_number_array = ["6.3.4.5","4.3.2.1","3.5.3.1","2.1.3.3","1.14.13.39"]
	# ec_number_array = [];

	# use the filter command on the df to check: do we have our ec numbers?
	filter_col_key = Symbol("EC Number")
	df = filter(filter_col_key=>x->in(x,ec_number_array), metabolite_table)
end

# ╔═╡ 34682c11-8139-4e7e-8a8b-bcfafa8ce628
begin

	# default value for μ -
	μ = 1.0 # units: 1/s

	with_terminal() do
		println("Specific growth rate μ = $(μ) s⁻¹")
	end
end

# ╔═╡ e891e546-f275-4cc8-beb4-0447094f01b2
begin

	# Need: convert mol/L to μmol/gDW-hr
	CF = 1.0

	with_terminal() do
		println("Conversion factor CF = $(CF) M -> μmol/gDW")
	end
end

# ╔═╡ c1878272-dd06-46b3-84f3-6d05c459688a
begin

	# initialize -
	x_concentration_array = zeros(ℳ,2) # default: missing value = 0.0. Should we choose a different policy?
	# x_concentration_array = (gmean_x)*ones(ℳ,2)*CF # units: μmol/gDW

	# build table of metabolites concentrations (M) for the metabolites in the our model -
	metabolites_in_our_model_array = [
	];

	for (i,metabolite) ∈ enumerate(metabolites_in_our_model_array)

		# look up the metabolite value -
		df_metabolite = filter([:Metabolite,:Organism]=>(x,y)->
			(x == metabolite && y=="Homo sapiens"),metabolite_table)

		# is the df empty?
		if (isempty(df_metabolite) == false)
			x_concentration_array[i,1] = df_metabolite[1,:Concentration]
			x_concentration_array[i,2] = CF*df_metabolite[1,:Concentration]
		end
	end
end

# ╔═╡ 65c3eff4-006f-4b1b-b151-6857cf764d07
begin

	# compute geometric mean metabolite concentration -
	tmp = metabolite_table[!,:Concentration]
	gmean_x = geomean(tmp) # units: M
end

# ╔═╡ a7fb5ffb-d3ec-4ddc-909d-b9e1a7920321
let

	# setup the state array -
	state_array = Array{Any,2}(undef,ℳ,4)

	for (i,metabolite) ∈ enumerate(metabolites_in_our_model_array)

		state_array[i,1] = i
		state_array[i,2] = metabolites_in_our_model_array[i]
		state_array[i,3] = x_concentration_array[i,1]
		state_array[i,4] = x_concentration_array[i,2]
	end

	# setup the header -
	header_row = (["index","metabolite","concentration", "concentration"],
		["","","M","μmol/gDW"])

	with_terminal() do

		# make the table -
		pretty_table(state_array; header=header_row)
	end
end

# ╔═╡ fca0ae0f-607a-4144-9b30-e237df7f43af
begin

	# background color plots -
    background_color_outside = RGB(1.0, 1.0, 1.0)
    background_color = RGB(0.99, 0.98, 0.96)
    CB_BLUE = RGB(68 / 255, 119 / 255, 170 / 255)
    CB_LBLUE = RGB(102 / 255, 204 / 255, 238 / 255)
    CB_GRAY = RGB(187 / 255, 187 / 255, 187 / 255)
    CB_RED = RGB(238 / 255, 102 / 255, 119 / 255)

	# show -
	nothing
end

# ╔═╡ 07ca2450-8a84-4e71-adcf-91b12a1544ee
begin

	# grab data from the [Met]/Km col -
	col_key = Symbol("[Met]/Km")
	length = 1000
	saturation_data_set = sort(metabolite_table[!,col_key])[1:length]
	number_of_bins = round(Int64,0.25*length)

	# make a histogram plot -
	stephist(saturation_data_set, bins = number_of_bins, normed = :true,
                background_color = background_color, background_color_outside = background_color_outside,
                foreground_color_minor_grid = RGB(1.0, 1.0, 1.0),
                lw = 2, c = CB_RED, foreground_color_legend = nothing, label = "N = $(length)")

	# label the axis -
	xlabel!("Metabolite saturation xᵢ/Kₘ (dimensionless)",fontsize=18)
	ylabel!("Instance count", fontsize=18)
end

# ╔═╡ f472e85e-8f51-11ec-25e8-e94287a542b6
html"""
<style>
main {
    max-width: 900px;
    width: 70%;
    margin: auto;
    font-family: "Roboto, monospace";
}

a {
    color: blue;
    text-decoration: none;
}
</style>"""

# ╔═╡ 1d16ad51-bd30-48d6-ac19-b875b1bfe530
html"""
<script>
	// initialize -
	var section = 0;
	var subsection = 0;
	var subsubsection = 0;
	var headers = document.querySelectorAll('h3, h5, h6');

	// main loop -
	for (var i=0; i < headers.length; i++) {

		var header = headers[i];
	    var text = header.innerText;
	    var original = header.getAttribute("text-original");
	    if (original === null) {

			// Save original header text
	        header.setAttribute("text-original", text);
	    } else {

			// Replace with original text before adding section number
	        text = header.getAttribute("text-original");
	    }

	    var numbering = "";
	    switch (header.tagName) {
	        case 'H3':
	            section += 1;
	            numbering = section + ".";
	            subsection = 0;
	            break;
	        case 'H5':
	            subsection += 1;
	            numbering = section + "." + subsection;
	            break;
			case 'H6':
	            subsubsection += 1;
	            numbering = section + "." + subsection + "." + subsubsection;
	            break;
	    }
		// update the header text
		header.innerText = numbering + " " + text;
	};
</script>"""

# ╔═╡ ce4ed3a0-f75c-4807-a3c6-3642e373e951
TableOfContents(title="📚 Table of Contents", indent=true, depth=5, aside=true)

# ╔═╡ 00000000-0000-0000-0000-000000000001
PLUTO_PROJECT_TOML_CONTENTS = """
[deps]
CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
GLPK = "60bf3e95-4087-53dc-ae20-288a0d20c6a6"
LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"

[compat]
CSV = "~0.10.2"
DataFrames = "~1.3.2"
GLPK = "~0.15.3"
Plots = "~1.25.10"
PlutoUI = "~0.7.34"
PrettyTables = "~1.3.1"
StatsBase = "~0.33.16"
StatsPlots = "~0.14.33"
"""

# ╔═╡ 00000000-0000-0000-0000-000000000002
PLUTO_MANIFEST_TOML_CONTENTS = """
# This file is machine-generated - editing it directly is not advised

julia_version = "1.7.2"
manifest_format = "2.0"

[[deps.AbstractFFTs]]
deps = ["ChainRulesCore", "LinearAlgebra"]
git-tree-sha1 = "6f1d9bc1c08f9f4a8fa92e3ea3cb50153a1b40d4"
uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c"
version = "1.1.0"

[[deps.AbstractPlutoDingetjes]]
deps = ["Pkg"]
git-tree-sha1 = "8eaf9f1b4921132a4cff3f36a1d9ba923b14a481"
uuid = "6e696c72-6542-2067-7265-42206c756150"
version = "1.1.4"

[[deps.Adapt]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "af92965fb30777147966f58acb05da51c5616b5f"
uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
version = "3.3.3"

[[deps.ArgTools]]
uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"

[[deps.Arpack]]
deps = ["Arpack_jll", "Libdl", "LinearAlgebra", "Logging"]
git-tree-sha1 = "91ca22c4b8437da89b030f08d71db55a379ce958"
uuid = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97"
version = "0.5.3"

[[deps.Arpack_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "OpenBLAS_jll", "Pkg"]
git-tree-sha1 = "5ba6c757e8feccf03a1554dfaf3e26b3cfc7fd5e"
uuid = "68821587-b530-5797-8361-c406ea357684"
version = "3.5.1+1"

[[deps.Artifacts]]
uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"

[[deps.AxisAlgorithms]]
deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"]
git-tree-sha1 = "66771c8d21c8ff5e3a93379480a2307ac36863f7"
uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950"
version = "1.0.1"

[[deps.Base64]]
uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

[[deps.BenchmarkTools]]
deps = ["JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"]
git-tree-sha1 = "4c10eee4af024676200bc7752e536f858c6b8f93"
uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
version = "1.3.1"

[[deps.BinaryProvider]]
deps = ["Libdl", "Logging", "SHA"]
git-tree-sha1 = "ecdec412a9abc8db54c0efc5548c64dfce072058"
uuid = "b99e7846-7c00-51b0-8f62-c81ae34c0232"
version = "0.5.10"

[[deps.Bzip2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "19a35467a82e236ff51bc17a3a44b69ef35185a2"
uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0"
version = "1.0.8+0"

[[deps.CEnum]]
git-tree-sha1 = "215a9aa4a1f23fbd05b92769fdd62559488d70e9"
uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82"
version = "0.4.1"

[[deps.CSV]]
deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings"]
git-tree-sha1 = "9519274b50500b8029973d241d32cfbf0b127d97"
uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
version = "0.10.2"

[[deps.Cairo_jll]]
deps = ["Artifacts", "Bzip2_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "4b859a208b2397a7a623a03449e4636bdb17bcf2"
uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a"
version = "1.16.1+1"

[[deps.ChainRulesCore]]
deps = ["Compat", "LinearAlgebra", "SparseArrays"]
git-tree-sha1 = "f9982ef575e19b0e5c7a98c6e75ee496c0f73a93"
uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
version = "1.12.0"

[[deps.ChangesOfVariables]]
deps = ["ChainRulesCore", "LinearAlgebra", "Test"]
git-tree-sha1 = "bf98fa45a0a4cee295de98d4c1462be26345b9a1"
uuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0"
version = "0.1.2"

[[deps.Clustering]]
deps = ["Distances", "LinearAlgebra", "NearestNeighbors", "Printf", "SparseArrays", "Statistics", "StatsBase"]
git-tree-sha1 = "75479b7df4167267d75294d14b58244695beb2ac"
uuid = "aaaa29a8-35af-508c-8bc3-b662a17a0fe5"
version = "0.14.2"

[[deps.CodecBzip2]]
deps = ["Bzip2_jll", "Libdl", "TranscodingStreams"]
git-tree-sha1 = "2e62a725210ce3c3c2e1a3080190e7ca491f18d7"
uuid = "523fee87-0ab8-5b00-afb7-3ecf72e48cfd"
version = "0.7.2"

[[deps.CodecZlib]]
deps = ["TranscodingStreams", "Zlib_jll"]
git-tree-sha1 = "ded953804d019afa9a3f98981d99b33e3db7b6da"
uuid = "944b1d66-785c-5afd-91f1-9de20f533193"
version = "0.7.0"

[[deps.ColorSchemes]]
deps = ["ColorTypes", "Colors", "FixedPointNumbers", "Random"]
git-tree-sha1 = "12fc73e5e0af68ad3137b886e3f7c1eacfca2640"
uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
version = "3.17.1"

[[deps.ColorTypes]]
deps = ["FixedPointNumbers", "Random"]
git-tree-sha1 = "024fe24d83e4a5bf5fc80501a314ce0d1aa35597"
uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f"
version = "0.11.0"

[[deps.Colors]]
deps = ["ColorTypes", "FixedPointNumbers", "Reexport"]
git-tree-sha1 = "417b0ed7b8b838aa6ca0a87aadf1bb9eb111ce40"
uuid = "5ae59095-9a9b-59fe-a467-6f913c188581"
version = "0.12.8"

[[deps.Compat]]
deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "SHA", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"]
git-tree-sha1 = "44c37b4636bc54afac5c574d2d02b625349d6582"
uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
version = "3.41.0"

[[deps.CompilerSupportLibraries_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"

[[deps.Contour]]
deps = ["StaticArrays"]
git-tree-sha1 = "9f02045d934dc030edad45944ea80dbd1f0ebea7"
uuid = "d38c429a-6771-53c6-b99e-75d170b6e991"
version = "0.5.7"

[[deps.Crayons]]
git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15"
uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f"
version = "4.1.1"

[[deps.DataAPI]]
git-tree-sha1 = "cc70b17275652eb47bc9e5f81635981f13cea5c8"
uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
version = "1.9.0"

[[deps.DataFrames]]
deps = ["Compat", "DataAPI", "Future", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrettyTables", "Printf", "REPL", "Reexport", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"]
git-tree-sha1 = "ae02104e835f219b8930c7664b8012c93475c340"
uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
version = "1.3.2"

[[deps.DataStructures]]
deps = ["Compat", "InteractiveUtils", "OrderedCollections"]
git-tree-sha1 = "3daef5523dd2e769dad2365274f760ff5f282c7d"
uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
version = "0.18.11"

[[deps.DataValueInterfaces]]
git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6"
uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464"
version = "1.0.0"

[[deps.DataValues]]
deps = ["DataValueInterfaces", "Dates"]
git-tree-sha1 = "d88a19299eba280a6d062e135a43f00323ae70bf"
uuid = "e7dc6d0d-1eca-5fa6-8ad6-5aecde8b7ea5"
version = "0.4.13"

[[deps.Dates]]
deps = ["Printf"]
uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"

[[deps.DelimitedFiles]]
deps = ["Mmap"]
uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"

[[deps.DensityInterface]]
deps = ["InverseFunctions", "Test"]
git-tree-sha1 = "80c3e8639e3353e5d2912fb3a1916b8455e2494b"
uuid = "b429d917-457f-4dbc-8f4c-0cc954292b1d"
version = "0.4.0"

[[deps.Distances]]
deps = ["LinearAlgebra", "SparseArrays", "Statistics", "StatsAPI"]
git-tree-sha1 = "3258d0659f812acde79e8a74b11f17ac06d0ca04"
uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"
version = "0.10.7"

[[deps.Distributed]]
deps = ["Random", "Serialization", "Sockets"]
uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"

[[deps.Distributions]]
deps = ["ChainRulesCore", "DensityInterface", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SparseArrays", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "Test"]
git-tree-sha1 = "38012bf3553d01255e83928eec9c998e19adfddf"
uuid = "31c24e10-a181-5473-b8eb-7969acd0382f"
version = "0.25.48"

[[deps.DocStringExtensions]]
deps = ["LibGit2"]
git-tree-sha1 = "b19534d1895d702889b219c382a6e18010797f0b"
uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
version = "0.8.6"

[[deps.Downloads]]
deps = ["ArgTools", "LibCURL", "NetworkOptions"]
uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"

[[deps.EarCut_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "3f3a2501fa7236e9b911e0f7a588c657e822bb6d"
uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
version = "2.2.3+0"

[[deps.Expat_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "ae13fcbc7ab8f16b0856729b050ef0c446aa3492"
uuid = "2e619515-83b5-522b-bb60-26c02a35a201"
version = "2.4.4+0"

[[deps.FFMPEG]]
deps = ["FFMPEG_jll"]
git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8"
uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
version = "0.4.1"

[[deps.FFMPEG_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "Pkg", "Zlib_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"]
git-tree-sha1 = "d8a578692e3077ac998b50c0217dfd67f21d1e5f"
uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5"
version = "4.4.0+0"

[[deps.FFTW]]
deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"]
git-tree-sha1 = "463cb335fa22c4ebacfd1faba5fde14edb80d96c"
uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
version = "1.4.5"

[[deps.FFTW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c6033cc3892d0ef5bb9cd29b7f2f0331ea5184ea"
uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a"
version = "3.3.10+0"

[[deps.FilePathsBase]]
deps = ["Compat", "Dates", "Mmap", "Printf", "Test", "UUIDs"]
git-tree-sha1 = "04d13bfa8ef11720c24e4d840c0033d145537df7"
uuid = "48062228-2e41-5def-b9a4-89aafe57970f"
version = "0.9.17"

[[deps.FillArrays]]
deps = ["LinearAlgebra", "Random", "SparseArrays", "Statistics"]
git-tree-sha1 = "deed294cde3de20ae0b2e0355a6c4e1c6a5ceffc"
uuid = "1a297f60-69ca-5386-bcde-b61e274b549b"
version = "0.12.8"

[[deps.FixedPointNumbers]]
deps = ["Statistics"]
git-tree-sha1 = "335bfdceacc84c5cdf16aadc768aa5ddfc5383cc"
uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
version = "0.8.4"

[[deps.Fontconfig_jll]]
deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "21efd19106a55620a188615da6d3d06cd7f6ee03"
uuid = "a3f928ae-7b40-5064-980b-68af3947d34b"
version = "2.13.93+0"

[[deps.Formatting]]
deps = ["Printf"]
git-tree-sha1 = "8339d61043228fdd3eb658d86c926cb282ae72a8"
uuid = "59287772-0a20-5a39-b81b-1366585eb4c0"
version = "0.4.2"

[[deps.FreeType2_jll]]
deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "87eb71354d8ec1a96d4a7636bd57a7347dde3ef9"
uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7"
version = "2.10.4+0"

[[deps.FriBidi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "aa31987c2ba8704e23c6c8ba8a4f769d5d7e4f91"
uuid = "559328eb-81f9-559d-9380-de523a88c83c"
version = "1.0.10+0"

[[deps.Future]]
deps = ["Random"]
uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"

[[deps.GLFW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Pkg", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll"]
git-tree-sha1 = "51d2dfe8e590fbd74e7a842cf6d13d8a2f45dc01"
uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89"
version = "3.3.6+0"

[[deps.GLPK]]
deps = ["BinaryProvider", "CEnum", "GLPK_jll", "Libdl", "MathOptInterface"]
git-tree-sha1 = "6f4e9754ee93e2b2ff40c0b0a6b4cdffd289190d"
uuid = "60bf3e95-4087-53dc-ae20-288a0d20c6a6"
version = "0.15.3"

[[deps.GLPK_jll]]
deps = ["Artifacts", "GMP_jll", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "fe68622f32828aa92275895fdb324a85894a5b1b"
uuid = "e8aa6df9-e6ca-548a-97ff-1f85fc5b8b98"
version = "5.0.1+0"

[[deps.GMP_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "781609d7-10c4-51f6-84f2-b8444358ff6d"

[[deps.GR]]
deps = ["Base64", "DelimitedFiles", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Pkg", "Printf", "Random", "RelocatableFolders", "Serialization", "Sockets", "Test", "UUIDs"]
git-tree-sha1 = "9f836fb62492f4b0f0d3b06f55983f2704ed0883"
uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
version = "0.64.0"

[[deps.GR_jll]]
deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Pkg", "Qt5Base_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "a6c850d77ad5118ad3be4bd188919ce97fffac47"
uuid = "d2c73de3-f751-5644-a686-071e5b155ba9"
version = "0.64.0+0"

[[deps.GeometryBasics]]
deps = ["EarCut_jll", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"]
git-tree-sha1 = "58bcdf5ebc057b085e58d95c138725628dd7453c"
uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
version = "0.4.1"

[[deps.Gettext_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "9b02998aba7bf074d14de89f9d37ca24a1a0b046"
uuid = "78b55507-aeef-58d4-861c-77aaff3498b1"
version = "0.21.0+0"

[[deps.Glib_jll]]
deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "a32d672ac2c967f3deb8a81d828afc739c838a06"
uuid = "7746bdde-850d-59dc-9ae8-88ece973131d"
version = "2.68.3+2"

[[deps.Graphite2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "344bf40dcab1073aca04aa0df4fb092f920e4011"
uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472"
version = "1.3.14+0"

[[deps.Grisu]]
git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2"
uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe"
version = "1.0.2"

[[deps.HTTP]]
deps = ["Base64", "Dates", "IniFile", "Logging", "MbedTLS", "NetworkOptions", "Sockets", "URIs"]
git-tree-sha1 = "0fa77022fe4b511826b39c894c90daf5fce3334a"
uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3"
version = "0.9.17"

[[deps.HarfBuzz_jll]]
deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg"]
git-tree-sha1 = "129acf094d168394e80ee1dc4bc06ec835e510a3"
uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566"
version = "2.8.1+1"

[[deps.Hyperscript]]
deps = ["Test"]
git-tree-sha1 = "8d511d5b81240fc8e6802386302675bdf47737b9"
uuid = "47d2ed2b-36de-50cf-bf87-49c2cf4b8b91"
version = "0.0.4"

[[deps.HypertextLiteral]]
git-tree-sha1 = "2b078b5a615c6c0396c77810d92ee8c6f470d238"
uuid = "ac1192a8-f4b3-4bfe-ba22-af5b92cd3ab2"
version = "0.9.3"

[[deps.IOCapture]]
deps = ["Logging", "Random"]
git-tree-sha1 = "f7be53659ab06ddc986428d3a9dcc95f6fa6705a"
uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89"
version = "0.2.2"

[[deps.IniFile]]
deps = ["Test"]
git-tree-sha1 = "098e4d2c533924c921f9f9847274f2ad89e018b8"
uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f"
version = "0.5.0"

[[deps.InlineStrings]]
deps = ["Parsers"]
git-tree-sha1 = "61feba885fac3a407465726d0c330b3055df897f"
uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48"
version = "1.1.2"

[[deps.IntelOpenMP_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "d979e54b71da82f3a65b62553da4fc3d18c9004c"
uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0"
version = "2018.0.3+2"

[[deps.InteractiveUtils]]
deps = ["Markdown"]
uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"

[[deps.Interpolations]]
deps = ["AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"]
git-tree-sha1 = "b15fc0a95c564ca2e0a7ae12c1f095ca848ceb31"
uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
version = "0.13.5"

[[deps.InverseFunctions]]
deps = ["Test"]
git-tree-sha1 = "a7254c0acd8e62f1ac75ad24d5db43f5f19f3c65"
uuid = "3587e190-3f89-42d0-90ee-14403ec27112"
version = "0.1.2"

[[deps.InvertedIndices]]
git-tree-sha1 = "bee5f1ef5bf65df56bdd2e40447590b272a5471f"
uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"
version = "1.1.0"

[[deps.IrrationalConstants]]
git-tree-sha1 = "7fd44fd4ff43fc60815f8e764c0f352b83c49151"
uuid = "92d709cd-6900-40b7-9082-c6be49f344b6"
version = "0.1.1"

[[deps.IterTools]]
git-tree-sha1 = "fa6287a4469f5e048d763df38279ee729fbd44e5"
uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
version = "1.4.0"

[[deps.IteratorInterfaceExtensions]]
git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856"
uuid = "82899510-4779-5014-852e-03e436cf321d"
version = "1.0.0"

[[deps.JLLWrappers]]
deps = ["Preferences"]
git-tree-sha1 = "abc9885a7ca2052a736a600f7fa66209f96506e1"
uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
version = "1.4.1"

[[deps.JSON]]
deps = ["Dates", "Mmap", "Parsers", "Unicode"]
git-tree-sha1 = "3c837543ddb02250ef42f4738347454f95079d4e"
uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
version = "0.21.3"

[[deps.JpegTurbo_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b53380851c6e6664204efb2e62cd24fa5c47e4ba"
uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8"
version = "2.1.2+0"

[[deps.KernelDensity]]
deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"]
git-tree-sha1 = "591e8dc09ad18386189610acafb970032c519707"
uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b"
version = "0.6.3"

[[deps.LAME_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c"
uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d"
version = "3.100.1+0"

[[deps.LZO_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6"
uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac"
version = "2.10.1+0"

[[deps.LaTeXStrings]]
git-tree-sha1 = "f2355693d6778a178ade15952b7ac47a4ff97996"
uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
version = "1.3.0"

[[deps.Latexify]]
deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "Printf", "Requires"]
git-tree-sha1 = "a8f4f279b6fa3c3c4f1adadd78a621b13a506bce"
uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
version = "0.15.9"

[[deps.LazyArtifacts]]
deps = ["Artifacts", "Pkg"]
uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3"

[[deps.LibCURL]]
deps = ["LibCURL_jll", "MozillaCACerts_jll"]
uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"

[[deps.LibCURL_jll]]
deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"

[[deps.LibGit2]]
deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"

[[deps.LibSSH2_jll]]
deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"

[[deps.Libdl]]
uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

[[deps.Libffi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "0b4a5d71f3e5200a7dff793393e09dfc2d874290"
uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490"
version = "3.2.2+1"

[[deps.Libgcrypt_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll", "Pkg"]
git-tree-sha1 = "64613c82a59c120435c067c2b809fc61cf5166ae"
uuid = "d4300ac3-e22c-5743-9152-c294e39db1e4"
version = "1.8.7+0"

[[deps.Libglvnd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll", "Xorg_libXext_jll"]
git-tree-sha1 = "7739f837d6447403596a75d19ed01fd08d6f56bf"
uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29"
version = "1.3.0+3"

[[deps.Libgpg_error_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c333716e46366857753e273ce6a69ee0945a6db9"
uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8"
version = "1.42.0+0"

[[deps.Libiconv_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "42b62845d70a619f063a7da093d995ec8e15e778"
uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531"
version = "1.16.1+1"

[[deps.Libmount_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "9c30530bf0effd46e15e0fdcf2b8636e78cbbd73"
uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9"
version = "2.35.0+0"

[[deps.Libtiff_jll]]
deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"]
git-tree-sha1 = "340e257aada13f95f98ee352d316c3bed37c8ab9"
uuid = "89763e89-9b03-5906-acba-b20f662cd828"
version = "4.3.0+0"

[[deps.Libuuid_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7f3efec06033682db852f8b3bc3c1d2b0a0ab066"
uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700"
version = "2.36.0+0"

[[deps.LinearAlgebra]]
deps = ["Libdl", "libblastrampoline_jll"]
uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

[[deps.LogExpFunctions]]
deps = ["ChainRulesCore", "ChangesOfVariables", "DocStringExtensions", "InverseFunctions", "IrrationalConstants", "LinearAlgebra"]
git-tree-sha1 = "e5718a00af0ab9756305a0392832c8952c7426c1"
uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
version = "0.3.6"

[[deps.Logging]]
uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"

[[deps.MKL_jll]]
deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"]
git-tree-sha1 = "5455aef09b40e5020e1520f551fa3135040d4ed0"
uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7"
version = "2021.1.1+2"

[[deps.MacroTools]]
deps = ["Markdown", "Random"]
git-tree-sha1 = "3d3e902b31198a27340d0bf00d6ac452866021cf"
uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
version = "0.5.9"

[[deps.Markdown]]
deps = ["Base64"]
uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"

[[deps.MathOptInterface]]
deps = ["BenchmarkTools", "CodecBzip2", "CodecZlib", "JSON", "LinearAlgebra", "MutableArithmetics", "OrderedCollections", "Printf", "SparseArrays", "Test", "Unicode"]
git-tree-sha1 = "e8c9653877adcf8f3e7382985e535bb37b083598"
uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
version = "0.10.9"

[[deps.MbedTLS]]
deps = ["Dates", "MbedTLS_jll", "Random", "Sockets"]
git-tree-sha1 = "1c38e51c3d08ef2278062ebceade0e46cefc96fe"
uuid = "739be429-bea8-5141-9913-cc70e7f3736d"
version = "1.0.3"

[[deps.MbedTLS_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"

[[deps.Measures]]
git-tree-sha1 = "e498ddeee6f9fdb4551ce855a46f54dbd900245f"
uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e"
version = "0.3.1"

[[deps.Missings]]
deps = ["DataAPI"]
git-tree-sha1 = "bf210ce90b6c9eed32d25dbcae1ebc565df2687f"
uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
version = "1.0.2"

[[deps.Mmap]]
uuid = "a63ad114-7e13-5084-954f-fe012c677804"

[[deps.MozillaCACerts_jll]]
uuid = "14a3606d-f60d-562e-9121-12d972cd8159"

[[deps.MultivariateStats]]
deps = ["Arpack", "LinearAlgebra", "SparseArrays", "Statistics", "StatsBase"]
git-tree-sha1 = "6d019f5a0465522bbfdd68ecfad7f86b535d6935"
uuid = "6f286f6a-111f-5878-ab1e-185364afe411"
version = "0.9.0"

[[deps.MutableArithmetics]]
deps = ["LinearAlgebra", "SparseArrays", "Test"]
git-tree-sha1 = "842b5ccd156e432f369b204bb704fd4020e383ac"
uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0"
version = "0.3.3"

[[deps.NaNMath]]
git-tree-sha1 = "b086b7ea07f8e38cf122f5016af580881ac914fe"
uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
version = "0.3.7"

[[deps.NearestNeighbors]]
deps = ["Distances", "StaticArrays"]
git-tree-sha1 = "16baacfdc8758bc374882566c9187e785e85c2f0"
uuid = "b8a86587-4115-5ab1-83bc-aa920d37bbce"
version = "0.4.9"

[[deps.NetworkOptions]]
uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"

[[deps.Observables]]
git-tree-sha1 = "fe29afdef3d0c4a8286128d4e45cc50621b1e43d"
uuid = "510215fc-4207-5dde-b226-833fc4488ee2"
version = "0.4.0"

[[deps.OffsetArrays]]
deps = ["Adapt"]
git-tree-sha1 = "043017e0bdeff61cfbb7afeb558ab29536bbb5ed"
uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
version = "1.10.8"

[[deps.Ogg_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "887579a3eb005446d514ab7aeac5d1d027658b8f"
uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051"
version = "1.3.5+1"

[[deps.OpenBLAS_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]
uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"

[[deps.OpenLibm_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "05823500-19ac-5b8b-9628-191a04bc5112"

[[deps.OpenSSL_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "648107615c15d4e09f7eca16307bc821c1f718d8"
uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
version = "1.1.13+0"

[[deps.OpenSpecFun_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1"
uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e"
version = "0.5.5+0"

[[deps.Opus_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720"
uuid = "91d4177d-7536-5919-b921-800302f37372"
version = "1.3.2+0"

[[deps.OrderedCollections]]
git-tree-sha1 = "85f8e6578bf1f9ee0d11e7bb1b1456435479d47c"
uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
version = "1.4.1"

[[deps.PCRE_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b2a7af664e098055a7529ad1a900ded962bca488"
uuid = "2f80f16e-611a-54ab-bc61-aa92de5b98fc"
version = "8.44.0+0"

[[deps.PDMats]]
deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"]
git-tree-sha1 = "ee26b350276c51697c9c2d88a072b339f9f03d73"
uuid = "90014a1f-27ba-587c-ab20-58faa44d9150"
version = "0.11.5"

[[deps.Parsers]]
deps = ["Dates"]
git-tree-sha1 = "13468f237353112a01b2d6b32f3d0f80219944aa"
uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
version = "2.2.2"

[[deps.Pixman_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b4f5d02549a10e20780a24fce72bea96b6329e29"
uuid = "30392449-352a-5448-841d-b1acce4e97dc"
version = "0.40.1+0"

[[deps.Pkg]]
deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

[[deps.PlotThemes]]
deps = ["PlotUtils", "Requires", "Statistics"]
git-tree-sha1 = "a3a964ce9dc7898193536002a6dd892b1b5a6f1d"
uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
version = "2.0.1"

[[deps.PlotUtils]]
deps = ["ColorSchemes", "Colors", "Dates", "Printf", "Random", "Reexport", "Statistics"]
git-tree-sha1 = "6f1b25e8ea06279b5689263cc538f51331d7ca17"
uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043"
version = "1.1.3"

[[deps.Plots]]
deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "GeometryBasics", "JSON", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "Unzip"]
git-tree-sha1 = "d9c49967b9948635152edaa6a91ca4f43be8d24c"
uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
version = "1.25.10"

[[deps.PlutoUI]]
deps = ["AbstractPlutoDingetjes", "Base64", "ColorTypes", "Dates", "Hyperscript", "HypertextLiteral", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "Random", "Reexport", "UUIDs"]
git-tree-sha1 = "8979e9802b4ac3d58c503a20f2824ad67f9074dd"
uuid = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
version = "0.7.34"

[[deps.PooledArrays]]
deps = ["DataAPI", "Future"]
git-tree-sha1 = "db3a23166af8aebf4db5ef87ac5b00d36eb771e2"
uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
version = "1.4.0"

[[deps.Preferences]]
deps = ["TOML"]
git-tree-sha1 = "2cf929d64681236a2e074ffafb8d568733d2e6af"
uuid = "21216c6a-2e73-6563-6e65-726566657250"
version = "1.2.3"

[[deps.PrettyTables]]
deps = ["Crayons", "Formatting", "Markdown", "Reexport", "Tables"]
git-tree-sha1 = "dfb54c4e414caa595a1f2ed759b160f5a3ddcba5"
uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
version = "1.3.1"

[[deps.Printf]]
deps = ["Unicode"]
uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"

[[deps.Profile]]
deps = ["Printf"]
uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"

[[deps.Qt5Base_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "xkbcommon_jll"]
git-tree-sha1 = "ad368663a5e20dbb8d6dc2fddeefe4dae0781ae8"
uuid = "ea2cea3b-5b76-57ae-a6ef-0a8af62496e1"
version = "5.15.3+0"

[[deps.QuadGK]]
deps = ["DataStructures", "LinearAlgebra"]
git-tree-sha1 = "78aadffb3efd2155af139781b8a8df1ef279ea39"
uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc"
version = "2.4.2"

[[deps.REPL]]
deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"

[[deps.Random]]
deps = ["SHA", "Serialization"]
uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

[[deps.Ratios]]
deps = ["Requires"]
git-tree-sha1 = "01d341f502250e81f6fec0afe662aa861392a3aa"
uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
version = "0.4.2"

[[deps.RecipesBase]]
git-tree-sha1 = "6bf3f380ff52ce0832ddd3a2a7b9538ed1bcca7d"
uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
version = "1.2.1"

[[deps.RecipesPipeline]]
deps = ["Dates", "NaNMath", "PlotUtils", "RecipesBase"]
git-tree-sha1 = "37c1631cb3cc36a535105e6d5557864c82cd8c2b"
uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c"
version = "0.5.0"

[[deps.Reexport]]
git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"
uuid = "189a3867-3050-52da-a836-e630ba90ab69"
version = "1.2.2"

[[deps.RelocatableFolders]]
deps = ["SHA", "Scratch"]
git-tree-sha1 = "cdbd3b1338c72ce29d9584fdbe9e9b70eeb5adca"
uuid = "05181044-ff0b-4ac5-8273-598c1e38db00"
version = "0.1.3"

[[deps.Requires]]
deps = ["UUIDs"]
git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7"
uuid = "ae029012-a4dd-5104-9daa-d747884805df"
version = "1.3.0"

[[deps.Rmath]]
deps = ["Random", "Rmath_jll"]
git-tree-sha1 = "bf3188feca147ce108c76ad82c2792c57abe7b1f"
uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa"
version = "0.7.0"

[[deps.Rmath_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "68db32dff12bb6127bac73c209881191bf0efbb7"
uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f"
version = "0.3.0+0"

[[deps.SHA]]
uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"

[[deps.Scratch]]
deps = ["Dates"]
git-tree-sha1 = "0b4b7f1393cff97c33891da2a0bf69c6ed241fda"
uuid = "6c6a2e73-6563-6170-7368-637461726353"
version = "1.1.0"

[[deps.SentinelArrays]]
deps = ["Dates", "Random"]
git-tree-sha1 = "6a2f7d70512d205ca8c7ee31bfa9f142fe74310c"
uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c"
version = "1.3.12"

[[deps.Serialization]]
uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"

[[deps.SharedArrays]]
deps = ["Distributed", "Mmap", "Random", "Serialization"]
uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"

[[deps.Showoff]]
deps = ["Dates", "Grisu"]
git-tree-sha1 = "91eddf657aca81df9ae6ceb20b959ae5653ad1de"
uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
version = "1.0.3"

[[deps.Sockets]]
uuid = "6462fe0b-24de-5631-8697-dd941f90decc"

[[deps.SortingAlgorithms]]
deps = ["DataStructures"]
git-tree-sha1 = "b3363d7460f7d098ca0912c69b082f75625d7508"
uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c"
version = "1.0.1"

[[deps.SparseArrays]]
deps = ["LinearAlgebra", "Random"]
uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"

[[deps.SpecialFunctions]]
deps = ["ChainRulesCore", "IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"]
git-tree-sha1 = "8d0c8e3d0ff211d9ff4a0c2307d876c99d10bdf1"
uuid = "276daf66-3868-5448-9aa4-cd146d93841b"
version = "2.1.2"

[[deps.StaticArrays]]
deps = ["LinearAlgebra", "Random", "Statistics"]
git-tree-sha1 = "95c6a5d0e8c69555842fc4a927fc485040ccc31c"
uuid = "90137ffa-7385-5640-81b9-e52037218182"
version = "1.3.5"

[[deps.Statistics]]
deps = ["LinearAlgebra", "SparseArrays"]
uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

[[deps.StatsAPI]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "c3d8ba7f3fa0625b062b82853a7d5229cb728b6b"
uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0"
version = "1.2.1"

[[deps.StatsBase]]
deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"]
git-tree-sha1 = "8977b17906b0a1cc74ab2e3a05faa16cf08a8291"
uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
version = "0.33.16"

[[deps.StatsFuns]]
deps = ["ChainRulesCore", "InverseFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"]
git-tree-sha1 = "f35e1879a71cca95f4826a14cdbf0b9e253ed918"
uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c"
version = "0.9.15"

[[deps.StatsPlots]]
deps = ["AbstractFFTs", "Clustering", "DataStructures", "DataValues", "Distributions", "Interpolations", "KernelDensity", "LinearAlgebra", "MultivariateStats", "Observables", "Plots", "RecipesBase", "RecipesPipeline", "Reexport", "StatsBase", "TableOperations", "Tables", "Widgets"]
git-tree-sha1 = "4d9c69d65f1b270ad092de0abe13e859b8c55cad"
uuid = "f3b207a7-027a-5e70-b257-86293d7955fd"
version = "0.14.33"

[[deps.StructArrays]]
deps = ["Adapt", "DataAPI", "StaticArrays", "Tables"]
git-tree-sha1 = "d21f2c564b21a202f4677c0fba5b5ee431058544"
uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
version = "0.6.4"

[[deps.SuiteSparse]]
deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"]
uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"

[[deps.TOML]]
deps = ["Dates"]
uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"

[[deps.TableOperations]]
deps = ["SentinelArrays", "Tables", "Test"]
git-tree-sha1 = "e383c87cf2a1dc41fa30c093b2a19877c83e1bc1"
uuid = "ab02a1b2-a7df-11e8-156e-fb1833f50b87"
version = "1.2.0"

[[deps.TableTraits]]
deps = ["IteratorInterfaceExtensions"]
git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39"
uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"
version = "1.0.1"

[[deps.Tables]]
deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "TableTraits", "Test"]
git-tree-sha1 = "bb1064c9a84c52e277f1096cf41434b675cd368b"
uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
version = "1.6.1"

[[deps.Tar]]
deps = ["ArgTools", "SHA"]
uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"

[[deps.Test]]
deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

[[deps.TranscodingStreams]]
deps = ["Random", "Test"]
git-tree-sha1 = "216b95ea110b5972db65aa90f88d8d89dcb8851c"
uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
version = "0.9.6"

[[deps.URIs]]
git-tree-sha1 = "97bbe755a53fe859669cd907f2d96aee8d2c1355"
uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4"
version = "1.3.0"

[[deps.UUIDs]]
deps = ["Random", "SHA"]
uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"

[[deps.Unicode]]
uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"

[[deps.UnicodeFun]]
deps = ["REPL"]
git-tree-sha1 = "53915e50200959667e78a92a418594b428dffddf"
uuid = "1cfade01-22cf-5700-b092-accc4b62d6e1"
version = "0.4.1"

[[deps.Unzip]]
git-tree-sha1 = "34db80951901073501137bdbc3d5a8e7bbd06670"
uuid = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d"
version = "0.1.2"

[[deps.Wayland_jll]]
deps = ["Artifacts", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "3e61f0b86f90dacb0bc0e73a0c5a83f6a8636e23"
uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89"
version = "1.19.0+0"

[[deps.Wayland_protocols_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "66d72dc6fcc86352f01676e8f0f698562e60510f"
uuid = "2381bf8a-dfd0-557d-9999-79630e7b1b91"
version = "1.23.0+0"

[[deps.WeakRefStrings]]
deps = ["DataAPI", "InlineStrings", "Parsers"]
git-tree-sha1 = "c69f9da3ff2f4f02e811c3323c22e5dfcb584cfa"
uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5"
version = "1.4.1"

[[deps.Widgets]]
deps = ["Colors", "Dates", "Observables", "OrderedCollections"]
git-tree-sha1 = "505c31f585405fc375d99d02588f6ceaba791241"
uuid = "cc8bc4a8-27d6-5769-a93b-9d913e69aa62"
version = "0.6.5"

[[deps.WoodburyMatrices]]
deps = ["LinearAlgebra", "SparseArrays"]
git-tree-sha1 = "de67fa59e33ad156a590055375a30b23c40299d3"
uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6"
version = "0.5.5"

[[deps.XML2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "1acf5bdf07aa0907e0a37d3718bb88d4b687b74a"
uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a"
version = "2.9.12+0"

[[deps.XSLT_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"]
git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a"
uuid = "aed1982a-8fda-507f-9586-7b0439959a61"
version = "1.1.34+0"

[[deps.Xorg_libX11_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll", "Xorg_xtrans_jll"]
git-tree-sha1 = "5be649d550f3f4b95308bf0183b82e2582876527"
uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc"
version = "1.6.9+4"

[[deps.Xorg_libXau_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4e490d5c960c314f33885790ed410ff3a94ce67e"
uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec"
version = "1.0.9+4"

[[deps.Xorg_libXcursor_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"]
git-tree-sha1 = "12e0eb3bc634fa2080c1c37fccf56f7c22989afd"
uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724"
version = "1.2.0+4"

[[deps.Xorg_libXdmcp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fe47bd2247248125c428978740e18a681372dd4"
uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05"
version = "1.1.3+4"

[[deps.Xorg_libXext_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "b7c0aa8c376b31e4852b360222848637f481f8c3"
uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3"
version = "1.3.4+4"

[[deps.Xorg_libXfixes_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "0e0dc7431e7a0587559f9294aeec269471c991a4"
uuid = "d091e8ba-531a-589c-9de9-94069b037ed8"
version = "5.0.3+4"

[[deps.Xorg_libXi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXfixes_jll"]
git-tree-sha1 = "89b52bc2160aadc84d707093930ef0bffa641246"
uuid = "a51aa0fd-4e3c-5386-b890-e753decda492"
version = "1.7.10+4"

[[deps.Xorg_libXinerama_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll"]
git-tree-sha1 = "26be8b1c342929259317d8b9f7b53bf2bb73b123"
uuid = "d1454406-59df-5ea1-beac-c340f2130bc3"
version = "1.1.4+4"

[[deps.Xorg_libXrandr_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll"]
git-tree-sha1 = "34cea83cb726fb58f325887bf0612c6b3fb17631"
uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484"
version = "1.5.2+4"

[[deps.Xorg_libXrender_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "19560f30fd49f4d4efbe7002a1037f8c43d43b96"
uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa"
version = "0.9.10+4"

[[deps.Xorg_libpthread_stubs_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "6783737e45d3c59a4a4c4091f5f88cdcf0908cbb"
uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74"
version = "0.1.0+3"

[[deps.Xorg_libxcb_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"]
git-tree-sha1 = "daf17f441228e7a3833846cd048892861cff16d6"
uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b"
version = "1.13.0+3"

[[deps.Xorg_libxkbfile_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "926af861744212db0eb001d9e40b5d16292080b2"
uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a"
version = "1.1.0+4"

[[deps.Xorg_xcb_util_image_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "0fab0a40349ba1cba2c1da699243396ff8e94b97"
uuid = "12413925-8142-5f55-bb0e-6d7ca50bb09b"
version = "0.4.0+1"

[[deps.Xorg_xcb_util_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll"]
git-tree-sha1 = "e7fd7b2881fa2eaa72717420894d3938177862d1"
uuid = "2def613f-5ad1-5310-b15b-b15d46f528f5"
version = "0.4.0+1"

[[deps.Xorg_xcb_util_keysyms_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "d1151e2c45a544f32441a567d1690e701ec89b00"
uuid = "975044d2-76e6-5fbe-bf08-97ce7c6574c7"
version = "0.4.0+1"

[[deps.Xorg_xcb_util_renderutil_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "dfd7a8f38d4613b6a575253b3174dd991ca6183e"
uuid = "0d47668e-0667-5a69-a72c-f761630bfb7e"
version = "0.3.9+1"

[[deps.Xorg_xcb_util_wm_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "e78d10aab01a4a154142c5006ed44fd9e8e31b67"
uuid = "c22f9ab0-d5fe-5066-847c-f4bb1cd4e361"
version = "0.4.1+1"

[[deps.Xorg_xkbcomp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxkbfile_jll"]
git-tree-sha1 = "4bcbf660f6c2e714f87e960a171b119d06ee163b"
uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4"
version = "1.4.2+4"

[[deps.Xorg_xkeyboard_config_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xkbcomp_jll"]
git-tree-sha1 = "5c8424f8a67c3f2209646d4425f3d415fee5931d"
uuid = "33bec58e-1273-512f-9401-5d533626f822"
version = "2.27.0+4"

[[deps.Xorg_xtrans_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "79c31e7844f6ecf779705fbc12146eb190b7d845"
uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10"
version = "1.4.0+3"

[[deps.Zlib_jll]]
deps = ["Libdl"]
uuid = "83775a58-1f1d-513f-b197-d71354ab007a"

[[deps.Zstd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "e45044cd873ded54b6a5bac0eb5c971392cf1927"
uuid = "3161d3a3-bdf6-5164-811a-617609db77b4"
version = "1.5.2+0"

[[deps.libass_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47"
uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0"
version = "0.15.1+0"

[[deps.libblastrampoline_jll]]
deps = ["Artifacts", "Libdl", "OpenBLAS_jll"]
uuid = "8e850b90-86db-534c-a0d3-1478176c7d93"

[[deps.libfdk_aac_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55"
uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280"
version = "2.0.2+0"

[[deps.libpng_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "94d180a6d2b5e55e447e2d27a29ed04fe79eb30c"
uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f"
version = "1.6.38+0"

[[deps.libvorbis_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll", "Pkg"]
git-tree-sha1 = "b910cb81ef3fe6e78bf6acee440bda86fd6ae00c"
uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a"
version = "1.3.7+1"

[[deps.nghttp2_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"

[[deps.p7zip_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"

[[deps.x264_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fea590b89e6ec504593146bf8b988b2c00922b2"
uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a"
version = "2021.5.5+0"

[[deps.x265_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "ee567a171cce03570d77ad3a43e90218e38937a9"
uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76"
version = "3.5.0+0"

[[deps.xkbcommon_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Wayland_jll", "Wayland_protocols_jll", "Xorg_libxcb_jll", "Xorg_xkeyboard_config_jll"]
git-tree-sha1 = "ece2350174195bb31de1a63bea3a41ae1aa593b6"
uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd"
version = "0.9.1+5"
"""

# ╔═╡ Cell order:
# ╠═2babb04c-7f14-4c30-a4f9-348ed31d4fbf
# ╟─0fe1a22d-a333-4834-88be-92180c39bbb3
# ╟─54d23ccb-211c-4716-a80c-2c087198232d
# ╠═24f4f6d4-7f78-40fa-bb3e-505c0940ec91
# ╠═e953d072-7b5a-4310-b259-4e0cabbd6291
# ╟─47a3f3fe-425d-434c-be06-1cd36a56fe25
# ╟─deafe11f-9065-43f4-b500-c64ff41026bd
# ╠═7558ee4f-87ca-4fa2-89bb-7a476c5e1252
# ╟─4dce933f-693c-4788-9c77-63784871a4c0
# ╠═70d11054-4d8a-4dcc-a8cd-1f762c2dd9b8
# ╟─12eef416-b3ab-4f03-8ac0-a9783dcca9bd
# ╠═880ce921-308b-4e3c-8bd9-fb9d07d18bd3
# ╟─07ca2450-8a84-4e71-adcf-91b12a1544ee
# ╟─e2917845-d956-45f0-a379-ea826caf7d88
# ╠═85e1ac31-90cf-48da-b4d7-b6c009328084
# ╟─70239f9d-1ea8-4ad2-92a3-126cd99de4f0
# ╟─cb7d76b8-85f9-4886-a4f3-3f9fb82e42dc
# ╟─d3a2474e-f502-4247-bba6-1f7d5f88f12d
# ╟─db005134-6e21-474a-9539-91faf6d0a4a4
# ╠═34682c11-8139-4e7e-8a8b-bcfafa8ce628
# ╟─a7df4d41-1c0f-422e-8f21-c84b812ac3cd
# ╠═e891e546-f275-4cc8-beb4-0447094f01b2
# ╟─b552fa38-cdc2-4f46-917f-4cac78694c86
# ╠═65c3eff4-006f-4b1b-b151-6857cf764d07
# ╠═c1878272-dd06-46b3-84f3-6d05c459688a
# ╠═a7fb5ffb-d3ec-4ddc-909d-b9e1a7920321
# ╟─c0569dfd-784f-43c5-966d-6ea2b25b9992
# ╠═7e11b015-ab19-4aba-80b1-a413ab13439f
# ╟─eaa02eea-2c86-4e05-bbe3-46174bb9c7d2
# ╠═acd56faf-5f71-435f-ba5b-10faa7cc7b61
# ╠═fca0ae0f-607a-4144-9b30-e237df7f43af
# ╠═58a35e5c-2f3c-4818-a290-7b8ae509320f
# ╠═f472e85e-8f51-11ec-25e8-e94287a542b6
# ╠═1d16ad51-bd30-48d6-ac19-b875b1bfe530
# ╠═ce4ed3a0-f75c-4807-a3c6-3642e373e951
# ╟─00000000-0000-0000-0000-000000000001
# ╟─00000000-0000-0000-0000-000000000002


text:
### BasicDiscParamIOStream

type BasicDiscParamIOStream <: ParameterIOStream{Discrete}
  value::Union{IOStream, Void}
  loglikelihood::Union{IOStream, Void}
  logprior::Union{IOStream, Void}
  logtarget::Union{IOStream, Void}
  diagnosticvalues::Union{IOStream, Void}
  names::Vector{AbstractString}
  size::Tuple
  n::Integer
  diagnostickeys::Vector{Symbol}
  open::Function
  close::Function
  mark::Function
  reset::Function
  flush::Function
  write::Function

  function BasicDiscParamIOStream(
    size::Tuple,
    n::Integer,
    streams::Vector{Union{IOStream, Void}},
    diagnostickeys::Vector{Symbol}=Symbol[],
    filenames::Vector{AbstractString}=[(streams[i] == nothing) ? "" : streams[i].name[7:end-1] for i in 1:5]
  )
    instance = new()

    fnames = fieldnames(BasicDiscParamIOStream)
    for i in 1:5
      setfield!(instance, fnames[i], streams[i])
    end

    instance.names = filenames

    instance.size = size
    instance.n = n
    instance.diagnostickeys = diagnostickeys

    instance.open = eval(codegen(:open, instance, fnames))
    instance.close = eval(codegen(:close, instance, fnames))
    instance.mark = eval(codegen(:mark, instance, fnames))
    instance.reset = eval(codegen(:reset, instance, fnames))
    instance.flush = eval(codegen(:flush, instance, fnames))
    instance.write = eval(codegen(:write, instance, fnames))

    instance
  end
end

function BasicDiscParamIOStream(
  size::Tuple,
  n::Integer,
  filenames::Vector{AbstractString},
  diagnostickeys::Vector{Symbol}=Symbol[],
  mode::AbstractString="w"
)
  fnames = fieldnames(BasicDiscParamIOStream)
  BasicDiscParamIOStream(
    size,
    n,
    [isempty(filenames[i]) ? nothing : open(filenames[i], mode) for i in 1:5],
    diagnostickeys,
    filenames
  )
end

function BasicDiscParamIOStream(
  size::Tuple,
  n::Integer;
  monitor::Vector{Bool}=[true; fill(false, 3)],
  filepath::AbstractString="",
  filesuffix::AbstractString="csv",
  diagnostickeys::Vector{Symbol}=Symbol[],
  mode::AbstractString="w"
)
  fnames = fieldnames(BasicDiscParamIOStream)

  filenames = Array(AbstractString, 5)
  for i in 1:4
    filenames[i] = (monitor[i] == false ? "" : joinpath(filepath, string(fnames[i])*"."*filesuffix))
  end
  filenames[5] = (isempty(diagnostickeys) ? "" : joinpath(filepath, "diagnosticvalues."*filesuffix))

  BasicDiscParamIOStream(size, n, filenames, diagnostickeys, mode)
end

function BasicDiscParamIOStream(
  size::Tuple,
  n::Integer,
  monitor::Vector{Symbol};
  filepath::AbstractString="",
  filesuffix::AbstractString="csv",
  diagnostickeys::Vector{Symbol}=Symbol[],
  mode::AbstractString="w"
)
  fnames = fieldnames(BasicDiscParamIOStream)
  BasicDiscParamIOStream(
    size,
    n,
    monitor=[fnames[i] in monitor ? true : false for i in 1:4],
    filepath=filepath,
    filesuffix=filesuffix,
    diagnostickeys=diagnostickeys,
    mode=mode
  )
end

function codegen(::Type{Val{:open}}, iostream::BasicDiscParamIOStream, fnames::Vector{Symbol})
  body = []
  local f::Symbol

  push!(body,:(_iostream.names = _names))

  for i in 1:5
    if iostream.(fnames[i]) != nothing
      f = fnames[i]
      push!(body, :(setfield!(_iostream, $(QuoteNode(f)), open(_names[$i], _mode))))
    end
  end

  @gensym _open

  quote
    function $_open{S<:AbstractString}(_iostream::BasicDiscParamIOStream, _names::Vector{S}, _mode::AbstractString="w")
      $(body...)
    end
  end
end

function codegen(::Type{Val{:close}}, iostream::BasicDiscParamIOStream, fnames::Vector{Symbol})
  body = []
  local f::Symbol

  for i in 1:5
    if iostream.(fnames[i]) != nothing
      f = fnames[i]
      push!(body, :(close(getfield(_iostream, $(QuoteNode(f))))))
    end
  end

  @gensym _close

  quote
    function $_close(_iostream::BasicDiscParamIOStream)
      $(body...)
    end
  end
end

function codegen(::Type{Val{:mark}}, iostream::BasicDiscParamIOStream, fnames::Vector{Symbol})
  body = []
  local f::Symbol

  for i in 1:5
    if iostream.(fnames[i]) != nothing
      f = fnames[i]
      push!(body, :(mark(getfield(_iostream, $(QuoteNode(f))))))
    end
  end

  @gensym _mark

  quote
    function $_mark(_iostream::BasicDiscParamIOStream)
      $(body...)
    end
  end
end

function codegen(::Type{Val{:reset}}, iostream::BasicDiscParamIOStream, fnames::Vector{Symbol})
  body = []
  local f::Symbol

  for i in 1:5
    if iostream.(fnames[i]) != nothing
      f = fnames[i]
      push!(body, :(reset(getfield($(iostream), $(QuoteNode(f))))))
    end
  end

  @gensym _reset

  quote
    function $_reset(_iostream::BasicDiscParamIOStream)
      $(body...)
    end
  end
end

function codegen(::Type{Val{:flush}}, iostream::BasicDiscParamIOStream, fnames::Vector{Symbol})
  body = []
  local f::Symbol

  for i in 1:5
    if iostream.(fnames[i]) != nothing
      f = fnames[i]
      push!(body, :(flush(getfield($(iostream), $(QuoteNode(f))))))
    end
  end

  @gensym _flush

  quote
    function $_flush(_iostream::BasicDiscParamIOStream)
      $(body...)
    end
  end
end

function codegen(::Type{Val{:write}}, iostream::BasicDiscParamIOStream, fnames::Vector{Symbol})
  body = []
  local f::Symbol # f must be local to avoid compiler errors. Alternatively, this variable declaration can be omitted

  for i in 1:5
    if iostream.(fnames[i]) != nothing
      f = fnames[i]
      push!(
        body,
        :(write(getfield($(iostream), $(QuoteNode(f))), join(getfield(_state, $(QuoteNode(f))), ','), "\n"))
      )
    end
  end

  @gensym _write

  quote
    function $_write{F<:VariateForm}(_iostream::BasicDiscParamIOStream, _state::ParameterState{Discrete, F})
      $(body...)
    end
  end
end

function Base.write(iostream::BasicDiscParamIOStream, nstate::BasicDiscUnvParameterNState)
  fnames = fieldnames(BasicDiscParamIOStream)
  for i in 1:4
    if iostream.(fnames[i]) != nothing
      writedlm(iostream.(fnames[i]), nstate.(fnames[i]))
    end
  end
  if iostream.diagnosticvalues != nothing
    writedlm(iostream.diagnosticvalues, nstate.diagnosticvalues', ',')
  end
end

function Base.write(iostream::BasicDiscParamIOStream, nstate::BasicDiscMuvParameterNState)
  fnames = fieldnames(BasicDiscParamIOStream)
  for i in 2:4
    if iostream.(fnames[i]) != nothing
      writedlm(iostream.(fnames[i]), nstate.(fnames[i]))
    end
  end
  for i in (1, 5)
    if iostream.(fnames[i]) != nothing
      writedlm(iostream.(fnames[i]), nstate.(fnames[i])', ',')
    end
  end
end

function Base.read!{NI<:Integer, NR<:Real}(iostream::BasicDiscParamIOStream, nstate::BasicDiscUnvParameterNState{NI, NR})
  t = [NI, fill(NR, 3)]
  fnames = fieldnames(BasicDiscParamIOStream)
  for i in 1:4
    if iostream.(fnames[i]) != nothing
      setfield!(nstate, fnames[i], vec(readdlm(iostream.(fnames[i]), ',', t[i])))
    end
  end
  if iostream.diagnosticvalues != nothing
    nstate.diagnosticvalues = readdlm(iostream.diagnosticvalues, ',', Any)'
  end
end

function Base.read!{NI<:Integer, NR<:Real}(iostream::BasicDiscParamIOStream, nstate::BasicDiscMuvParameterNState{NI, NR})
  fnames = fieldnames(BasicDiscParamIOStream)
  if iostream.(fnames[1]) != nothing
    setfield!(nstate, fnames[1], readdlm(iostream.(fnames[1]), ',', NI)')
  end
  for i in 2:4
    if iostream.(fnames[i]) != nothing
      setfield!(nstate, fnames[i], vec(readdlm(iostream.(fnames[i]), ',', NR)))
    end
  end
  if iostream.diagnosticvalues != nothing
    nstate.diagnosticvalues = readdlm(iostream.diagnosticvalues, ',', Any)'
  end
end

function Base.read{NI<:Integer, NR<:Real}(iostream::BasicDiscParamIOStream, TI::Type{NI}, TR::Type{NR})
  nstate::DiscreteParameterNState
  fnames = fieldnames(BasicDiscParamIOStream)
  l = length(iostream.size)

  if l == 0
    nstate = BasicDiscUnvParameterNState(
      iostream.n,
      [iostream.(fnames[i]) != nothing ? true : false for i in 1:13],
      iostream.diagnostickeys,
      TI,
      TR
    )
  elseif l == 1
    nstate = BasicDiscMuvParameterNState(
      iostream.size[1],
      iostream.n,
      [iostream.(fnames[i]) != nothing ? true : false for i in 1:13],
      iostream.diagnostickeys,
      TI,
      TR
    )
  else
    error("BasicDiscParamIOStream.size must be a tuple of length 0 or 1, got $(iostream.size) length")
  end

  read!(iostream, nstate)

  nstate
end

function Base.show(io::IO, iostream::BasicDiscParamIOStream)
  fnames = fieldnames(BasicDiscParamIOStream)
  fbool = map(n -> getfield(iostream, n) != nothing, fnames[1:4])
  indentation = "  "

  println(io, "BasicDiscParamIOStream:")

  println(io, indentation*"state size = $(iostream.size)")
  println(io, indentation*"number of states = $(iostream.n)")

  print(io, indentation*"monitored components:")
  if !any(fbool)
    println(io, " none")
  else
    print(io, "\n")
    for i in 1:4
      if fbool[i]
        println(io, string(indentation^2, fnames[i]))
      end
    end
  end

  print(io, indentation*"diagnostics:")
  if isempty(iostream.diagnostickeys)
    print(io, " none")
  else
    for k in iostream.diagnostickeys
      print(io, "\n")
      print(io, string(indentation^2, k))
    end
  end
end

ext: jl


text:
# AST Manipulation for Approximate Computation

# Our main types and wrappers:
# ############################

using Plots.PlotMeasures

global g_ID = 0
function GetGlobalID()
   global g_ID
    g_ID = g_ID + 1
    g_ID
end

function ResetGlobalID()
   global g_ID
    println("WARNING: Global ID has been reset")
    g_ID = 0
end

abstract type TreeMember end

mutable struct Variable <: TreeMember
    var
    id
    Variable(x) = new(x, GetGlobalID())
end

mutable struct Operator <: TreeMember
    op
    leaves
    id
	result
    Operator(x::Variable) = new(identity, [x]      , GetGlobalID(), "NoStoredData"  )
    Operator(fun, x)      = new(fun     , [x]      , GetGlobalID(), "NoStoredData"  )
    Operator(fun, x,y)    = new(fun     , [x, y]   , GetGlobalID(), "NoStoredData"  )
    Operator(fun, x,y,z)  = new(fun     , [x, y, z], GetGlobalID(), "NoStoredData"  )
end

######################
## Debug function to view the tree.
##
########
function printtree(node::TreeMember, level = 0)
    outstr = "|"
    if(level > 0)
        for i in 1:level
            outstr = string(outstr,"  |")
        end
    end

    if(typeof(node) == Operator)
        println(string(outstr, "Function(", node.op, ") - (id:$(node.id)) - StoredData:", node.result))
        for leaf in node.leaves
            if(leaf != nothing)
                if(typeof(leaf) <: TreeMember)
                    printtree(leaf, level+1)
                else
                    varindent ="|"
                    for i in 1:level+1
                        varindent = string(varindent,"  |")
                    end
                    print(string(varindent, "Const ", typeof(leaf), "(", leaf, ")", "\n"))
                end
            end
        end
    else
        println(string(outstr, typeof(node.var), "(", node.var, ") - (id:$(node.id))"))
    end

	if(level == 0)
		println("\n")
	end
end

function ToString(node::TreeMember, level = 0)
    outstr = "|"
    if(level > 0)
        for i in 1:level
            outstr = string(outstr,"~~~|")
        end
    end

	s = ""
    if(typeof(node) == Operator)
        s = string(s, (string(outstr, "Function(", node.op, ")")), "\n")
        for leaf in node.leaves
            if(leaf != nothing)
                if(typeof(leaf) <: TreeMember)
                    s = string(s, ToString(leaf, level+1))
                else
                    varindent ="|"
                    for i in 1:level+1
                        varindent = string(varindent,"  |")
                    end
                    s = string(s,(string(varindent, "Const ", typeof(leaf), "(", leaf, ")", "\n")))
                end
            end
        end
    else
        s = string(s, (string(outstr, typeof(node.var), "(", node.var, ")")), "\n")
    end

	if(level == 0)
		s = string(s,("\n"))
	end

	s
end

# Extending the environment to allow for operators to work on wrapped types:
# ##########################################################################
# These functions allow us to automatically generate the functions we need for
# the functions we are trying to evaluate.

function GetOverrideFunctionList(func)
    display(func)
    ast = Base.uncompressed_ast(first(methods(func)))
    callsymbols = []
    for line in ast.code
        if(line.head == Symbol(:call))
            argTypes = []
            for arg in line.args[2:end]
                push!(argTypes, Float64)
            end

            argumentcount = length(line.args[2:end])
            argTypes[1] = TreeMember
            typeTuple = tuple(argTypes ...)

            # This optimisation check excluded a number of base operators due to the fold definition: operators.jl:502
            #    for op in (:+, :*, :&, :|, :xor, :min, :max, :kron)
            #    @eval begin
            #        ($op)(a, b, c, xs...) = afoldl($op, ($op)(($op)(a,b),c), xs...)
            #    end
            #end
            #if( length(methods(eval(line.args[1].name), typeTuple)) == 0)
                push!(callsymbols, (line.args[1].name, argumentcount))
                #println("Submitted $(line.args[1].name)")
            #end
        end
    end

    callsymbols
end

+(x::TreeMember, y::TreeMember) = Operator(+, x,y)
+(x::TreeMember, y) 			= Operator(+, x,y)
+(x, y::TreeMember) 			= Operator(+, x,y)

-(x::TreeMember, y::TreeMember) = Operator(-, x,y)
-(x::TreeMember, y) 			= Operator(-, x,y)
-(x, y::TreeMember) 			= Operator(-, x,y)
-(x::TreeMember) 				= Operator(-, x)

*(x::TreeMember, y::TreeMember) = Operator(*, x,y)
*(x::TreeMember, y) 			= Operator(*, x,y)
*(x, y::TreeMember) 			= Operator(*, x,y)

/(x::TreeMember, y::TreeMember) = Operator(/, x,y)
/(x::TreeMember, y) 			= Operator(/, x,y)
/(x, y::TreeMember) 			= Operator(/, x,y)

function BuildOverrideFromArray(ovr)
    for op = ovr
        display(eval(quote
            if($(op[2] == 1))
                    $(op[1])(x::TreeMember)       = Operator(($(op[1])), x)
            elseif($(op[2] == 2))
                    $(op[1])(x::TreeMember, y)    = Operator(($(op[1])), x,y)
                    $(op[1])(x, y::TreeMember)    = Operator(($(op[1])), x,y)
                    $(op[1])(x::TreeMember, y::TreeMember)    = Operator(($(op[1])), x,y)
            elseif($(op[2] == 3))
                    $(op[1])(x::TreeMember, y, z) = Operator(($(op[1])), x,y,z)
                    $(op[1])(x, y::TreeMember, z) = Operator(($(op[1])), x,y,z)
                    $(op[1])(x, y, z::TreeMember) = Operator(($(op[1])), x,y,z)
                    $(op[1])(x::TreeMember, y::TreeMember, z::TreeMember) = Operator(($(op[1])), x,y,z)
                    $(op[1])(x, y::TreeMember, z::TreeMember) = Operator(($(op[1])), x,y,z)
                    $(op[1])(x::TreeMember, y, z::TreeMember) = Operator(($(op[1])), x,y,z)
                    $(op[1])(x::TreeMember, y::TreeMember, z) = Operator(($(op[1])), x,y,z)
            end
        end))
    end

	for op in ovr
		println("$(op[1]) - declared with $(op[2]) inputs")
	end
end

function GetOverrides(func)
    overridefunctions = GetOverrideFunctionList(func)
    override = tuple(overridefunctions...)
end

function UpdateEnvironmentForFunction(func)
    overridefunctions = GetOverrideFunctionList(func)
    override = tuple(overridefunctions...)
    BuildOverrideFromArray(override)
end

function GetConstructionFunction()
    (quote
        function BuildOverrideFromArray_Gen(ovr; verbose=true)
			disp(x) = x
			if(verbose)
				disp = display
			end
            for op = ovr
                disp(eval(quote
                    if($(op[2] == 1))
                            $(op[1])(x::TreeMember)       = Operator(($(op[1])), x)
                    elseif($(op[2] == 2))
                            $(op[1])(x::TreeMember, y)    = Operator(($(op[1])), x,y)
                            $(op[1])(x, y::TreeMember)    = Operator(($(op[1])), x,y)
                            $(op[1])(x::TreeMember, y::TreeMember)    = Operator(($(op[1])), x,y)
                    elseif($(op[2] == 3))
                            $(op[1])(x::TreeMember, y, z) = Operator(($(op[1])), x,y,z)
                            $(op[1])(x, y::TreeMember, z) = Operator(($(op[1])), x,y,z)
                            $(op[1])(x, y, z::TreeMember) = Operator(($(op[1])), x,y,z)
                            $(op[1])(x::TreeMember, y::TreeMember, z::TreeMember) = Operator(($(op[1])), x,y,z)
                            $(op[1])(x, y::TreeMember, z::TreeMember) = Operator(($(op[1])), x,y,z)
                            $(op[1])(x::TreeMember, y, z::TreeMember) = Operator(($(op[1])), x,y,z)
                            $(op[1])(x::TreeMember, y::TreeMember, z) = Operator(($(op[1])), x,y,z)
                    end
                end))
            end

			if(verbose)
				for op in ovr
					println("$(op[1]) - declared with $(op[2]) inputs")
				end
			end
        end
    end)
end

macro BuildOverrideFromArray()
	:(eval(GetConstructionFunction()))
end

########################################
## Tree Manipulation Functions
##
########
function GetAllTrees(node)
    treelist = []
    if(typeof(node) == Operator)
        push!(treelist, node)
        for leaf in node.leaves
            if(leaf != nothing)
                if(typeof(leaf) <: TreeMember)
                    childarray = copy(GetAllTrees(leaf))
                    treelist = vcat(treelist, childarray)
                else
                    push!(treelist, Variable(copy(leaf)))
                end

            end
        end
    else
        treelist = vcat(treelist, node)
    end
    treelist
end

function GetSubTree(tree, id)
	trees = GetAllTrees(tree)
	for t in trees
		if(t.id == id)
			return t
		end
	end
end

HasId(x::TreeMember, target ) = x.id == target
HasId(x, target ) = false

function ReplaceSubTree(node, replnode, targetID)
    if(typeof(node) == Operator)
        for i in 1:length(node.leaves)
            if(node.leaves[i] != nothing)
                if HasId(node.leaves[i], targetID)
                    if(typeof(node.leaves[i]) != typeof(replnode) )
                        node.leaves[i] = typeof(node.leaves[i])(replnode)
                    else
                        node.leaves[i] = replnode
                    end
                else
                    ReplaceSubTree(node.leaves[i], replnode, targetID)
                end
            end
        end
    end
end

function WrapTree(node::TreeMember)
   Operator(identity, node)
end

function UnwrapTree(node::TreeMember)
    if(node.op == identity)
       return node.leaves[1]
    end
end

function FullUnwrap(node::TreeMember)
    current = node
    while(typeof(current) == Operator && current.op == identity)
       current = current.leaves[1]
    end
    return current
end

# Function to execute an AST

SymbolDict = Dict()
function SetSymbolValue(name, value)
	SymbolDict[name] = value
end

ClearSymbolDict() = SymbolDict = Dict()

function EmulateTree(node, localSymbolDict = Dict())
    result = 0

    if(typeof(node) == Operator)
        operation = node.op
		emulatedInputs = []
		for leaf in node.leaves
			push!(emulatedInputs, EmulateTree(leaf, localSymbolDict) )
		end
        #emulatedInputs = EmulateTree.(node.leaves, localSymbolDict)
        result = operation(emulatedInputs...)
		node.result = result
    elseif (typeof(node) == Variable)
        result = node.var
    else
        result = node
    end

    if(typeof(result) == Symbol)
		if(haskey(localSymbolDict, result) )
			result = localSymbolDict[result]
		elseif(haskey(SymbolDict, result))
			result = SymbolDict[result]
		else
			@show localSymbolDict
			@show SymbolDict
			println("ERROR: Undefined symbol: $(result)")
			println("ERROR: Proceeding with nil value...")
			result = 0
		end
    end

    result
end

function InArray(arr, x)
	for v in arr
		if(v == x)
			return true
		end
	end

	return false
end

#########################
## Extracting all instances from trees
##
##########

function GetAllLeaves(tree)
	nodes = GetAllTrees(tree)
    GetAllLeavesList(nodes)
end

function GetAllLeavesList(nodes)
    variables = []
    for v in nodes
        if(typeof(v) != Operator)
			if( !InArray(variables, v) )
				push!(variables, v)
			end
        end
    end
    variables
end

function GetAllSymbols(node)
    GetAllSymbolsList(GetAllLeavesList(node))
end

function GetAllSymbols(tree::TreeMember)
	nodes = GetAllTrees(tree)
    GetAllSymbolsList(GetAllLeavesList(nodes))
end

function GetAllSymbolsList(leafArray)
    variables = []
    for v in leafArray
        if(typeof(v) == Variable)
            if(typeof(v.var) == Symbol)
                push!(variables, v.var)
            end
        elseif typeof(v) == Symbol
            push!(variables, v)
        end
    end
    variables
end

function GetOperators(tree)
    nodes = GetAllTrees(tree)
    operators = []
    for v in nodes
        if(typeof(v) == Operator)
			if( !InArray(operators, v) )
				push!(operators, v)
			end
        end
    end
    operators
end

function GetOperatorIDs(tree)
    operators = GetOperators(tree)
    ids = []
    for op in operators
        push!(ids, op.id)
    end

    ids
end

##################
## Tree Editing Functions
##
######
function ReplaceAllVariablesOfType(node::TreeMember, targettype, replacementtype)
    if(typeof(node) == Operator)
        for i in 1:length(node.leaves)
            if(node.leaves[i] != nothing)
                if(typeof(node.leaves[i]) == Operator)
                    ReplaceAllVariablesOfType(node.leaves[i], targettype, replacementtype)
                elseif (typeof(node.leaves[i]) == Variable)
                    if(typeof(node.leaves[i].var)==targettype)
                       node.leaves[i].var =  replacementtype(node.leaves[i].var)
                    end
                end
            end
        end
    end
end

function ReplaceTypeOfSpecifiedVariable(node::TreeMember, id, replacementtype)
    if(typeof(node) == Operator)
        for i in 1:length(node.leaves)
            if(node.leaves[i] != nothing)
                if(typeof(node.leaves[i]) == Operator)
                    ReplaceTypeOfSpecifiedVariable(node.leaves[i], id, replacementtype)
                elseif (typeof(node.leaves[i]) == Variable)
                    if( node.leaves[i].id== id)
                       node.leaves[i].var =  replacementtype(node.leaves[i].var)
                    end
                end
            end
        end
    end
end

function ReplaceConstantsWithVariables(node::TreeMember)
    if(typeof(node) == Operator)
        for i in 1:length(node.leaves)
            if(node.leaves[i] != nothing)
                if(typeof(node.leaves[i]) <: TreeMember)
                    ReplaceConstantsWithVariables(node.leaves[i])
                else
                    node.leaves[i] = Variable(node.leaves[i])
                end
            end
        end
    end
end

###############
## Extracting computing information from tree
##
#####

# Getting all the results for a specific id
function GetResultForID(node, id)
    if(node.id == id)
        return node.result
    elseif(typeof(node) == Operator)
        for i in 1:length(node.leaves)
            if(node.leaves[i] != nothing)
                if(typeof(node.leaves[i]) == Operator)
                     ret = GetResultForID(node.leaves[i], id)
                     if(ret != "notfound")
                        return ret
                     end
                end
            end
        end
    end

    return "notfound"
end

function SetResultForID(node, id, val)
    if(node.id == id)
        node.result = val
    elseif(typeof(node) == Operator)
        for i in 1:length(node.leaves)
            if(node.leaves[i] != nothing)
                if(typeof(node.leaves[i]) == Operator)
                     SetResultForID(node.leaves[i], id, val)
                end
            end
        end
    end
end

################
## Helper to compute the error difference of two differently typed trees
##
#####

function TreeComparison(tree_a::TreeMember, tree_b::TreeMember, inputsa, inputsb)

    # Check that the input length is valid
    if(length(inputsa) != length(inputsb))
       throw(ErrorException("Error:Comparison ranges must be of equal length!"))
    end

    # Check that the input array is of type Array{Pair{Symbol, Any}, 1}
    ########TODO########

    # Initialise a results array
    resulta = []
    resultb = []

    # Push the results into the array
    for input in inputsa
        SetSymbolValue(input[1], input[2])
        push!(resulta,EmulateTree(tree_a))
    end

    for input in inputsb
        SetSymbolValue(input[1], input[2])
        push!(resultb,EmulateTree(tree_b))
    end

    # Calculate the error
    diff      = abs.(resulta - resultb)
    maxerr    = maximum(diff)
    minerr    = minimum(diff)
    medianerr = median(diff)
    meanerr   = mean(diff)

    # return results
    (minerr, maxerr, medianerr, meanerr, diff)

end

function PrintTreeComparisonError(error)
    println("Min    Error $(error[1])")
    println("Max    Error $(error[2])")
    println("Median Error $(error[3])")
    println("Mean   Error $(error[4])")
end

function GetErrorInTree(hiprecTree, loprecTree, inputSymbol, hiprec_inputValues, loprec_inputValues; fetchtimeline = false)

    outputTree = deepcopy(loprecTree)

    # Copy the trees for each result instance
    hiprec_testarray = []
    for v in hiprec_inputValues
        push!(hiprec_testarray, ( (inputSymbol,v) , deepcopy(hiprecTree) ) )
    end

    loprec_testarray = []
    for v in loprec_inputValues
        push!(loprec_testarray, ( (inputSymbol,v) , deepcopy(loprecTree) ) )
    end

    # Calculate the output results
    for i in 1:length(hiprec_testarray)
        d = Dict(hiprec_testarray[i][1][1]=>hiprec_testarray[i][1][2])
        EmulateTree(hiprec_testarray[i][2], d )
    end

    for i in 1:length(loprec_testarray)
        d = Dict(loprec_testarray[i][1][1]=>loprec_testarray[i][1][2])
        EmulateTree(loprec_testarray[i][2], d )
    end

    # Get the list of operator IDs
    operatorlist = GetOperators(hiprec_testarray[2][2])
    ids = GetOperatorIDs(hiprec_testarray[2][2])

    # Calculate the min,max, median and mean error for each.
    nodeerrors = []
    sumres     = [0.0,0.0,0.0,0.0]
    maxmax     = 0.0

	timelinedb = Dict()

    for id in ids
        targetID = id
        hiprecres = []
        for entry in hiprec_testarray
            res = GetResultForID(entry[2], targetID)
            push!(hiprecres, res)
        end

        loprecres = []
        for entry in loprec_testarray
            res = GetResultForID(entry[2], targetID)
            push!(loprecres, res)
        end

        dif = abs.(hiprecres - Float64.(loprecres))
        minval  = minimum(dif)
        maxval  = maximum(dif)
        medval  = median(dif)
        meanval = median(dif)

		if( fetchtimeline )
			timelinedb[targetID] = dif
		end

        push!(nodeerrors, (id, minval, maxval, medval, meanval))
        sumres[1] += minval
        sumres[2] += maxval
        sumres[3] += medval
        sumres[4] += meanval

        maxmax = max(maxval, maxmax)
    end

    for data in nodeerrors
        maxval = data[3]
        id = data[1]
        SetResultForID( outputTree, id, maxval )
    end

	if(fetchtimeline)
		return outputTree,timelinedb
	end

    outputTree
end

function PlotASTError(tree, errordict, hiprec_inputs, res=(2048,512))
    arr = []
    for i in hiprec_inputs
        push!(arr, i)
    end

    maxerror = 0.0
    for entry in errordict
        maxerror = max(maximum(entry[2]), maxerror)
    end

    ps = []
    for entry in errordict
        newplot = plot(arr, entry[2], title="OperatorID: $(entry[1])", ylims = (0,maxerror), legend=:none)
        push!(ps, newplot)

        idtree = GetSubTree(tree,entry[1])
        helper = plot([0, 1], [0, 1], framestyle=:none, legend=:none, linecolor=:white)
        annotate!(helper, [(0.0, 0.5, text(ToString(idtree), :left, 6) )])
        push!(ps, helper)
    end

    pAll = plot(ps..., layout = (Int64.(length(ps)/2),2), size=(res[1], (length(ps)/2)*res[2]), margin = 15.0mm) ##size=(2048,length(ps)*512)
    pAll
end

############################
## Source Code Generation for AST Tree
##
#######

function TreeToFunction(node::TreeMember, name)
    symbols = GetAllSymbols(node)
    funcbody = TreeToFunctionLeaf(node)

	inputstring = ""
	for inp in 1:length(symbols)
		inputstring = string(inputstring, "$(symbols[inp])" )
		if(inp != length(symbols))
			inputstring = string(inputstring, ", ")
		end
	end

    parsed = eval(Meta.parse("$(name)($(inputstring))= " * funcbody))
end
function TreeToFunctionLeaf(node::TreeMember)
    s = ""
    if(typeof(node) == Operator)
        leafcount = length(node.leaves)
        if( leafcount == 1)
            s = string(s, "(", node.op, TreeToFunctionLeaf(node.leaves[1]), ")" )
        elseif (leafcount == 2)
            s = string(s, "(", TreeToFunctionLeaf(node.leaves[1]), node.op, TreeToFunctionLeaf(node.leaves[2]), ")")
        else
            s = string(s, node.op, "(")
            for i in 1:length(node.leaves)
                if(node.leaves[i] != nothing)
                    if(typeof(node.leaves[i]) <: TreeMember)
                        s = string(s, TreeToFunctionLeaf(node.leaves[i]) )
                    else
                        s = string(s, node.leaves[i])
                    end

                    if(i != length(node.leaves))
                        s = string(s, ",")
                    end

                end
            end
            s = string(s, ")")
        end
    else
        s = string(s, node.var)
    end
    s
end


text:
module Encodings

export AbstractEncoding, MultiClassEncoding, TwoClassEncoding,
       OneZero, OneMinusOne, OneTwo, OneVsOne, OneVsRest, RestVsOne,
       check_encoding, ispositive, isnegative,
       current_encoding, set_encoding, reset_encoding, recode, classify

abstract type AbstractEncoding{T}; end
abstract type MultiClassEncoding{T} <: AbstractEncoding{T}; end
abstract type TwoClassEncoding{T} <: AbstractEncoding{T}; end

Base.show(io::IO, ::MIME"text/plain", enc::T) where {T <: TwoClassEncoding} =
    print(io, "$T: \n   positive class: $(enc.positives) \n   negative class: $(enc.negatives)")

include("twoclassencodings.jl")
include("utilities.jl")

const CURRENT_ENCODING = Ref{AbstractEncoding}(OneZero())

current_encoding() = CURRENT_ENCODING[]
set_encoding(enc::AbstractEncoding) = CURRENT_ENCODING[] = enc
reset_encoding() = CURRENT_ENCODING[] = OneZero()

end


text:
# Can we figure out how to get rid of this?
(p::DiffEqBase.DefaultLinSolve)(x, A::ComponentMatrix, b, update_matrix=false; tol=nothing, kwargs...) = p(x, getdata(A), b, update_matrix; tol, kwargs...)

# function (p::DiffEqBase.DefaultLinSolve)(x,A::ComponentMatrix,b,update_matrix=false;tol=nothing, kwargs...)
#     if p.iterable isa Vector && eltype(p.iterable) <: LinearAlgebra.BlasInt # `iterable` here is the pivoting vector
#         F = LU{eltype(A)}(A, p.iterable, zero(LinearAlgebra.BlasInt))
#         ldiv!(x, F, b)
#         return nothing
#     end

#     if update_matrix
#         blasvendor = BLAS.vendor()
#         if ArrayInterface.can_setindex(x) && (size(A,1) <= 100 || ((blasvendor === :openblas || blasvendor === :openblas64) && size(A,1) <= 500))
#             p.A = RecursiveFactorization.lu!(A)
#         else
#             p.A = lu!(A)
#         end
#     end

#     x .= b
#     ldiv!(p.A,x)
#     return nothing
# end


text:
# This file was generated by the Julia Swagger Code Generator
# Do not modify this file directly. Modify the swagger specification instead.

include("model_AddressSpace.jl")
include("model_AuthenticationMethod.jl")
include("model_BgpPeerStatus.jl")
include("model_BgpPeerStatusListResult.jl")
include("model_BgpSettings.jl")
include("model_CloudError.jl")
include("model_CloudErrorBody.jl")
include("model_ConnectionProtocol.jl")
include("model_ConnectionResetSharedKey.jl")
include("model_ConnectionSharedKey.jl")
include("model_DhGroup.jl")
include("model_Error.jl")
include("model_ErrorDetails.jl")
include("model_GatewayRoute.jl")
include("model_GatewayRouteListResult.jl")
include("model_IPAllocationMethod.jl")
include("model_IPConfigurationBgpPeeringAddress.jl")
include("model_IkeEncryption.jl")
include("model_IkeIntegrity.jl")
include("model_IpsecEncryption.jl")
include("model_IpsecIntegrity.jl")
include("model_IpsecPolicy.jl")
include("model_LocalNetworkGateway.jl")
include("model_LocalNetworkGatewayListResult.jl")
include("model_LocalNetworkGatewayPropertiesFormat.jl")
include("model_P2SVpnConnectionRequest.jl")
include("model_PfsGroup.jl")
include("model_ProvisioningState.jl")
include("model_RadiusServer.jl")
include("model_Resource.jl")
include("model_SubResource.jl")
include("model_TagsObject.jl")
include("model_TrafficSelectorPolicy.jl")
include("model_TunnelConnectionHealth.jl")
include("model_VirtualNetworkConnectionGatewayReference.jl")
include("model_VirtualNetworkGateway.jl")
include("model_VirtualNetworkGatewayConnection.jl")
include("model_VirtualNetworkGatewayConnectionListEntity.jl")
include("model_VirtualNetworkGatewayConnectionListEntityPropertiesFormat.jl")
include("model_VirtualNetworkGatewayConnectionListResult.jl")
include("model_VirtualNetworkGatewayConnectionPropertiesFormat.jl")
include("model_VirtualNetworkGatewayConnectionStatus.jl")
include("model_VirtualNetworkGatewayConnectionType.jl")
include("model_VirtualNetworkGatewayIPConfiguration.jl")
include("model_VirtualNetworkGatewayIPConfigurationPropertiesFormat.jl")
include("model_VirtualNetworkGatewayListConnectionsResult.jl")
include("model_VirtualNetworkGatewayListResult.jl")
include("model_VirtualNetworkGatewayPropertiesFormat.jl")
include("model_VirtualNetworkGatewaySku.jl")
include("model_VpnClientConfiguration.jl")
include("model_VpnClientConnectionHealthDetail.jl")
include("model_VpnClientConnectionHealthDetailListResult.jl")
include("model_VpnClientIPsecParameters.jl")
include("model_VpnClientParameters.jl")
include("model_VpnClientRevokedCertificate.jl")
include("model_VpnClientRevokedCertificatePropertiesFormat.jl")
include("model_VpnClientRootCertificate.jl")
include("model_VpnClientRootCertificatePropertiesFormat.jl")
include("model_VpnDeviceScriptParameters.jl")
include("model_VpnPacketCaptureStartParameters.jl")
include("model_VpnPacketCaptureStopParameters.jl")


text:
# ---
# title: 233. Number of Digit One
# id: problem233
# author: Tian Jun
# date: 2020-10-31
# difficulty: Hard
# categories: Math
# link: <https://leetcode.com/problems/number-of-digit-one/description/>
# hidden: true
# ---
#
# Given an integer n, count the total number of digit 1 appearing in all non-
# negative integers less than or equal to n.
#
# **Example:**
#
#
#
#     Input: 13
#     Output: 6
#     Explanation: Digit 1 occurred in the following numbers: 1, 10, 11, 12, 13.
#
#
#
## @lc code=start
using LeetCode

## add your code here:
## @lc code=end