diff --git a/examples/boston/notebook.ipynb b/examples/boston/notebook.ipynb index 61663d3d..d653cbc3 100644 --- a/examples/boston/notebook.ipynb +++ b/examples/boston/notebook.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -73,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -115,7 +115,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -124,7 +124,7 @@ "AbstractVector{Continuous} (alias for AbstractArray{Continuous, 1})" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -159,7 +159,7 @@ "└─────────┴───────────────┴──────────────────────────────────┘\n" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -178,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -194,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -219,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -228,7 +228,7 @@ "GenericBuilder{#1#2}\n" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -251,21 +251,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "┌ Info: For silent loading, specify `verbosity=0`. \n", - "└ @ Main /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/loading.jl:168\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ + "[ Info: For silent loading, specify `verbosity=0`. \n", "import MLJFlux ✔\n" ] }, @@ -274,7 +267,7 @@ "text/plain": [ "NeuralNetworkRegressor(\n", " builder = GenericBuilder(\n", - " apply = var\"#1#2\"()),\n", + " apply = Main.##283.var\"#1#2\"()),\n", " optimiser = ADAM(0.001, (0.9, 0.999), IdDict{Any, Any}()),\n", " loss = Flux.Losses.mse,\n", " epochs = 20,\n", @@ -286,7 +279,7 @@ " acceleration = CPU1{Nothing}(nothing))" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -314,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -334,7 +327,7 @@ " cache = true)" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -370,89 +363,51 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "┌ Info: Training Machine{DeterministicPipeline{NamedTuple{,…},…},…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: Training Machine{Standardizer,…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: Features standarized: \n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:825\n", - "┌ Info: :CRIM mu=3.689791468926554 sigma=8.486186608186063\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :ZN mu=10.392655367231638 sigma=22.078531026900794\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :INDUS mu=11.477372881355933 sigma=6.83192917494762\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :NOX mu=0.5619451977401131 sigma=0.11706875291419269\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :RM mu=6.256881355932204 sigma=0.655703581671515\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :AGE mu=69.98474576271187 sigma=27.70464405221309\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :DIS mu=3.704779096045197 sigma=2.018034269570148\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :RAD mu=5.72316384180791 sigma=2.4534591735797426\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :TAX mu=415.97457627118644 sigma=172.0508915025351\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :PTRATIO mu=18.54971751412429 sigma=2.176727910395866\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :B mu=354.88437853107337 sigma=91.70747435121616\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: :LSTAT mu=12.997796610169493 sigma=7.067143799083826\n", - "└ @ MLJModels /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/builtins/Transformers.jl:836\n", - "┌ Info: Training Machine{TransformedTargetModelDeterministic{NeuralNetworkRegressor{GenericBuilder{#1#2},…}},…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: Training Machine{Standardizer,…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: Training Machine{NeuralNetworkRegressor{GenericBuilder{#1#2},…},…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: Loss is 0.3687\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.2216\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.1775\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.1519\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.1322\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.117\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.1064\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.09521\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.08949\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.08277\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.07997\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.07727\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.0719\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.07051\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.06697\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.06423\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.06024\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.05974\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.05666\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n", - "┌ Info: Loss is 0.05577\n", - "└ @ MLJFlux /Users/anthony/.julia/packages/MLJFlux/ex3rh/src/core.jl:127\n" + "[ Info: Training Machine{DeterministicPipeline{NamedTuple{,…},…},…}.\n", + "[ Info: Training Machine{Standardizer,…}.\n", + "[ Info: Features standarized: \n", + "[ Info: :CRIM mu=3.689791468926554 sigma=8.486186608186063\n", + "[ Info: :ZN mu=10.392655367231638 sigma=22.078531026900794\n", + "[ Info: :INDUS mu=11.477372881355933 sigma=6.83192917494762\n", + "[ Info: :NOX mu=0.5619451977401131 sigma=0.11706875291419269\n", + "[ Info: :RM mu=6.256881355932204 sigma=0.655703581671515\n", + "[ Info: :AGE mu=69.98474576271187 sigma=27.70464405221309\n", + "[ Info: :DIS mu=3.704779096045197 sigma=2.018034269570148\n", + "[ Info: :RAD mu=5.72316384180791 sigma=2.4534591735797426\n", + "[ Info: :TAX mu=415.97457627118644 sigma=172.0508915025351\n", + "[ Info: :PTRATIO mu=18.54971751412429 sigma=2.176727910395866\n", + "[ Info: :B mu=354.88437853107337 sigma=91.70747435121616\n", + "[ Info: :LSTAT mu=12.997796610169493 sigma=7.067143799083826\n", + "[ Info: Training Machine{TransformedTargetModelDeterministic{NeuralNetworkRegressor{GenericBuilder{#1#2},…}},…}.\n", + "[ Info: Training Machine{Standardizer,…}.\n", + "[ Info: Training Machine{NeuralNetworkRegressor{GenericBuilder{#1#2},…},…}.\n", + "[ Info: Loss is 0.3687\n", + "[ Info: Loss is 0.2216\n", + "[ Info: Loss is 0.1775\n", + "[ Info: Loss is 0.1519\n", + "[ Info: Loss is 0.1322\n", + "[ Info: Loss is 0.117\n", + "[ Info: Loss is 0.1064\n", + "[ Info: Loss is 0.09521\n", + "[ Info: Loss is 0.08949\n", + "[ Info: Loss is 0.08277\n", + "[ Info: Loss is 0.07997\n", + "[ Info: Loss is 0.07727\n", + "[ Info: Loss is 0.0719\n", + "[ Info: Loss is 0.07051\n", + "[ Info: Loss is 0.06697\n", + "[ Info: Loss is 0.06423\n", + "[ Info: Loss is 0.06024\n", + "[ Info: Loss is 0.05974\n", + "[ Info: Loss is 0.05666\n", + "[ Info: Loss is 0.05577\n" ] }, { @@ -461,11 +416,11 @@ "Machine{DeterministicPipeline{NamedTuple{,…},…},…} trained 1 time; caches data\n", " model: MLJBase.DeterministicPipeline{NamedTuple{(:standardizer, :transformed_target_model_deterministic), Tuple{Unsupervised, Deterministic}}, MLJModelInterface.predict}\n", " args: \n", - " 1:\tSource @768 ⏎ `Table{AbstractVector{Continuous}}`\n", - " 2:\tSource @147 ⏎ `AbstractVector{Continuous}`\n" + " 1:\tSource @185 ⏎ `Table{AbstractVector{Continuous}}`\n", + " 2:\tSource @132 ⏎ `AbstractVector{Continuous}`\n" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -485,7 +440,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -515,7 +470,7 @@ " 0.055767894928594526" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -533,7 +488,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -547,7 +502,7 @@ " 0.05" ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -579,158 +534,307 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Plot{Plots.GRBackend() n=5}" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -748,7 +852,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -764,7 +868,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -773,7 +877,7 @@ "0.0001" ] }, - "execution_count": 18, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -808,7 +912,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -817,7 +921,7 @@ "clear (generic function with 1 method)" ] }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -840,7 +944,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -849,7 +953,7 @@ "update_epochs (generic function with 1 method)" ] }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -873,7 +977,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -884,12 +988,12 @@ " NumberSinceBest(6)\n", " InvalidValue()\n", " TimeLimit(Dates.Millisecond(60000))\n", - " WithLossDo{typeof(update_loss)}(update_loss, false, nothing)\n", - " WithReportDo{typeof(update_training_loss)}(update_training_loss, false, nothing)\n", - " WithIterationsDo{typeof(update_epochs)}(update_epochs, false, nothing)" + " WithLossDo{typeof(Main.##283.update_loss)}(Main.##283.update_loss, false, nothing)\n", + " WithReportDo{typeof(Main.##283.update_training_loss)}(Main.##283.update_training_loss, false, nothing)\n", + " WithIterationsDo{typeof(Main.##283.update_epochs)}(Main.##283.update_epochs, false, nothing)" ] }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -914,7 +1018,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -925,7 +1029,7 @@ " standardizer = Standardizer,\n", " transformed_target_model_deterministic = TransformedTargetModelDeterministic{NeuralNetworkRegressor{GenericBuilder{#1#2},…}},\n", " cache = true),\n", - " controls = Any[Step(1), NumberSinceBest(6), InvalidValue(), TimeLimit(Dates.Millisecond(60000)), WithLossDo{typeof(update_loss)}(update_loss, false, nothing), WithReportDo{typeof(update_training_loss)}(update_training_loss, false, nothing), WithIterationsDo{typeof(update_epochs)}(update_epochs, false, nothing)],\n", + " controls = Any[Step(1), NumberSinceBest(6), InvalidValue(), TimeLimit(Dates.Millisecond(60000)), WithLossDo{typeof(Main.##283.update_loss)}(Main.##283.update_loss, false, nothing), WithReportDo{typeof(Main.##283.update_training_loss)}(Main.##283.update_training_loss, false, nothing), WithIterationsDo{typeof(Main.##283.update_epochs)}(Main.##283.update_epochs, false, nothing)],\n", " resampling = Holdout(\n", " fraction_train = 0.8,\n", " shuffle = false,\n", @@ -936,11 +1040,11 @@ " operation = MLJModelInterface.predict,\n", " retrain = false,\n", " check_measure = true,\n", - " iteration_parameter = :(neural_network_regressor.epochs),\n", + " iteration_parameter = nothing,\n", " cache = true)" ] }, - "execution_count": 22, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -950,7 +1054,6 @@ " IteratedModel(model=pipe,\n", " controls=controls,\n", " resampling=Holdout(fraction_train=0.8),\n", - " iteration_parameter=:(neural_network_regressor.epochs),\n", " measure = l2)" ] }, @@ -963,23 +1066,18 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "┌ Info: Training Machine{DeterministicIteratedModel{DeterministicPipeline{NamedTuple{,…},…}},…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: final loss: 18.029846309038444\n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/train.jl:44\n", - "┌ Info: final training loss: 0.15870439154333713\n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/train.jl:46\n", - "┌ Info: Stop triggered by NumberSinceBest(6) stopping criterion. \n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/stopping_controls.jl:54\n", - "┌ Info: Total of 13 iterations. \n", - "└ @ MLJIteration /Users/anthony/.julia/packages/MLJIteration/jtWxG/src/core.jl:35\n" + "[ Info: Training Machine{DeterministicIteratedModel{DeterministicPipeline{NamedTuple{,…},…}},…}.\n", + "[ Info: final loss: 18.029846309038444\n", + "[ Info: final training loss: 0.15870439154333713\n", + "[ Info: Stop triggered by NumberSinceBest(6) stopping criterion. \n", + "[ Info: Total of 13 iterations. \n" ] }, { @@ -988,11 +1086,11 @@ "Machine{DeterministicIteratedModel{DeterministicPipeline{NamedTuple{,…},…}},…} trained 1 time; does not cache data\n", " model: MLJIteration.DeterministicIteratedModel{MLJBase.DeterministicPipeline{NamedTuple{(:standardizer, :transformed_target_model_deterministic), Tuple{Unsupervised, Deterministic}}, MLJModelInterface.predict}}\n", " args: \n", - " 1:\tSource @623 ⏎ `Table{AbstractVector{Continuous}}`\n", - " 2:\tSource @109 ⏎ `AbstractVector{Continuous}`\n" + " 1:\tSource @189 ⏎ `Table{AbstractVector{Continuous}}`\n", + " 2:\tSource @474 ⏎ `AbstractVector{Continuous}`\n" ] }, - "execution_count": 23, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1012,177 +1110,345 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdZ1wUV9sH4DNb6GVXUBAQpEm1ICpoIiIiYO+KGkuwRtGoMbb4PHaNHTX2XmIsRFGjETuaaOwVbKBgQ3qvW+b9MI/7EhwU0Z1t/+tDfrOzszM362bvPXPucw5F0zQBAADQVTxVBwAAAKBKSIQAAKDTkAgBAECnIRECAIBOQyIEAACdhkQIAAA6DYkQAAB0GhIhAADoNCRCAADQaUiEAACg0zQ1ERYXFz98+FDVUXBBLperOgTNI5PJVB2C5pHL5ZhwsQbwYasBzt603NzcpKSkjx6mqYkwISFh8ODBqo5C6WiaLikpUXUUmqe4uFjVIWie8vJyfKfXAD5sNcDZm3bhwoXJkyd/9DBNTYQAAABfBBIhAADoNCRCAADQaUiEAACg05AIAQBAp2l5IpTL5ds3bmzfqFErZ+dJERGZmZmqjggAANSLQNUBKNfsH37I2rp1f0GBKSF/pKR0vnjx3L17RkZGqo4LAADUhTa3CMvKyk78+uuagoJahAgJ6SGT9Xz16sC+faqOCwAA1Ig2J8KkpCQviqr4F/qWlT26dk1lAQEAgPrR5luj9evXf/LvKaPiBQKhWHzz5k1VhfSpaJouLS01NDRUdSDccXZ2FolEqo4CQLlevHiRkZGh6ihUpri4uAZdVHw+v3HjxhRFffF4tDkRGhkZNQsNnfv77zNKSgSEXKGolXp6ZN++P0+fVnVon4CmaWX8w6unt2/fRkREzJ07V9WBAChXv379cnNzjY2NVR2IatTsay0+Pv7u3bsNGjT44vFocyIkhCzfunVF/fpf7d79tkDSqLGXh4EgIiKid+/eqo4L2C1cuLCoqEjVUQAonUwm27VrV/PmzVUdiCbx9PRU0nS42txHSAjR09ObNm/e1eRk/4MvBmw+qbO/vwAAoCpanggVPEVUQi6WmAEAgMp0JRF6iUl8jqqDAAAA9aM7iZCKz0GLEAAAKtOVROhqRr0qouVIhQAA8M6GDRtsbW21vGpUQcAjTqZUkVTVcQAAfAn37t27d++eTCZzdXX18/Pj8/mqjkjz3LlzZ/r06XFxcbrSIiSEeImpIoluNQnPnj27cuXKK1eucHnRK1eunD9/nssrAuiUf/75p4mnZ+PGjb+PiJg2atRXX33lYm9/6NAhjsNYvXr1BwY7ZWdnb9y4kct4amD79u19+vRp1KiRDiVCTzFVqLEtwocPH3777bef9JIdO3ZMnDixvLxcSSFVJTY2NiYmhuOLAuiIc+fOBQYEeDx58pCQLIkktazsFSE9U1P79O69ZcuWGp924sSJn/qLOSoq6sOJcP369TWOhxtPnjzx9vYmutNHSAjxEpFCiaqDYFNSUvLRY/Ly8i5fvvxJ5/n777+HDBkyderUli1bVjqyvLz8/U9wQUEB62nz8/MV26yf+7KyMonkQ+9sdf5AAPiosrKyiG++GSST/SaTub/baUvIcppeStPfR0a+fv26Zme+cePG+1O+lZWVFRcXK7Yr/ap+9uxZnTp1Ku4pLCxUbLu4uNy5c6fiszKZ7P2vgo9+e9TAtGnTqHd69OiRl5dX1ZHZ2dmmpqZEtxKhWO36CE+fPu3i4uLh4WFvb3/w4EFmZ+vWrRU5b82aNRMmTCCE9O7d+/nz587Ozs7OzoqPpsKBAwfs7e09PDxcXV3PnDlDCJkwYcK+ffsWLVrk7OyckJCgOLKoqKhLly7169dv1qyZg4PD27dvmYPt7Ox8fX3r1aunuMHy/fffjxs3ztfX183NrXHjxk+ePOnYsaObm1u9evXu3btHCMnLy6tVq9bcuXO9vLxsbW0nT55M05XvPO/du9fJyalRo0aKwACgxk6dOpWalrZYLn//qQmE1CHk119/rcFpFy1adOPGjVGjRjk7O69atYr5qpk2bZqTk9PYsWNfv37t4+Pj7u7u5OTUrl075kuDEGJnZ5eWlkYI6du37/z58xs3buzq6tq0adPU1FRCyNOnT728vJgj3dzc1qxZ4+bmZmdn17VrVybzlZWVDRkyxN7e3svLa/bs2XXr1q3Ze/K+n3/+mX7n8OHD5ubmVR1paWnJ/NDXlWIZQoiLGVX63uw86SXkXjYXHYe19ElTy3/NrZeVldW3b9/9+/eHhITcuHEjMDCwWbNmjo6O+fn5Uun/MnZpaSmT9qKjo4cMGfL48eP3z/zs2bNhw4ZduHDB19f35MmTffr0SUxMjIqKysnJ8fHxYfKowqFDh6RS6evXrymKysnJYabzHj169MqVKymKunv3bvv27UNDQ42NjYuLi8+fP3/58uXatWv37NkzMDAwNja2YcOGc+bMmTt3bnR0NE3TOTk5ubm5iYmJ2dnZ/v7+rVq16tmzp+JaN2/enDZt2qVLlxwcHG7evNmlS5eHDx9+4EMJAB92586dRnp6tUpL33+KR0jr8vI7t27V4LTTp08/ceLEjz/+2LVrV0JIYmLi8+fPRSLR69ev5XJ5UVHRsWPH7OzsaJqePHny3Llz161bRwjJysqSy+WEkMLCwiNHjly8eNHMzGzgwIGrV69etGiRVCrNzs5mzp+Xl3f16tVHjx5JpVI/P7/Dhw/37dt3/fr1SUlJycnJBgYGw4cPz8lRwUBvNzc35me9DiVCAY8YvffnPs6jF99TyuR1lTS1oJpa/qus6+LFi05OTiEhIYSQZs2atW7dOjY2dvTo0R89lUwmU2REDw+PU6dOBQQE+Pr6EkLCwsLq169/6dKl7t27K45/9uxZaWkpIcTe3t7Gxubu3bvr16/v0qVLvXr1mANsbW137Njx/Pnz8vJymUz29OnTJk2aEELCw8OZWx+BgYFlZWUNGzYkhAQFBSkar4SQiRMnEkJq1ao1ZMiQY8eOVUyEBw4caNas2dOnT58+fUoIMTc3v3XrVtu2bWvy9gEAIcXFxcbv3XdRMKHp11V0cHwqHo83adIkZsPU1PTFixcHDhxIT09PTU1NSkp6//iIiAjmN25ISAhricC4ceMEAoFAIGjTps2jR48IISdPnhwxYgTzWzwyMrJmbdnP9O2337Zu3XrkyJE6lAgJIcbv/bmtranTHVTzJmRnZ1tYWCgeWlpaZmVlVTrm/ZuNhJC8vDxF4cxff/2VlZVV6TyZmZkVj//vf//LpKLly5e3a9duw4YNv/766/Tp05s2bfr7778bGxv7+/u3bdu2devWPB5v9+7dis5CMzMzZkMoFCq29fT0KnYVKC5taWl57d9rPaalpb18+VKRNQMCAhQnAYAaqFev3m6apglhXbjhiVDo4eT0RS5kbm6up6fHbJ8+fXrYsGFTpkzx9fU1NDSs1PPHqOr74f0D9PX1mQPy8/MVO1V1o6hhw4arVq365ptvdCsRmqjTn+vs7Pzw4UOpVCoQCAgh9+7d69SpEyHE3NxccZcgMTGR2RAKhYr7pbVq1bp69WrF80RHRzPbUqk0ISHBxcWl4oX27NlT8WHXrl27du1aUlISGhq6b9++r776qqio6JdffiGE5OXlfeoNivj4eGYG/QcPHjg7O1d8ys3NLT8/X/1LqAE0RYcOHcaPG3eckM7vPfWYkIsy2eROnWp2ZqFQWNXCDkeOHBk9enRkZCQhZO3atTU7//vc3d1v3LjRo0cPQsj169e/1Gk/1ZAhQ4YMGaJOmUH5TISqjqCCgIAAa2vrMWPGDB48OCYmpqioiLmf2bZt28WLF5ubm9+/f//EiRMdO3YkhDg5OWVkZKxbt6527do9evRgcieje/fuP/3009SpU7t06bJ9+3ZbW9uAgICqLhodHZ2VldW4ceOCgoKXL196eHjY2dnl5OTs2rXL0dFx+fLlQuGnvUc//fTTjBkznj9//uuvv1Yqvx49evT69etnzJjRuXPnwsLCU6dO/fTTT2Kx+NPeJgB4x9HRcdTIkRFbtx6XSCou4JRMSC89vdZ+fqGhoTU7s5eX144dO8rLy729vfX19Ss+1aBBg127dgUEBLx69eqXX375UsujTpo0KSgoyMDAQCQS7d27V7WrrupWIjQWqtEKtzwe7+zZs8uWLVuxYoWrq+uVK1cMDAwIIdOnT+fz+VFRUf7+/rt27crNzSWEiMXi2NjYkydPvnjxolu3bhXPY2Bg8M8//zDnadiw4cqVK3k8HiGkU6dONjY2lS7aoEGDbdu2HT9+XCQSrVmzhumxO3r06Pr16ymKioyMDAwMZPoOw8LCLC0tmVc1bdpUsWq8jY3NyJEjFSdcuHBhVFQUj8c7ceKEm5sbIaRly5ZMkbRYLL59+/aqVauWLl1qYmLSqlUrLIMF8JlWrlqVnZXVMjq6E5//lVSqR8gNHu8QRTVt0uRgTEyN08mCBQt27Nhx+/ZtCwsLHx+f77//XvHUd999V1xcvGTJEmdn5z179sTFxTH7x48fb2JiQgjp06ePokDU09OzT58+hBALCwvFF0VkZKSiD6Vt27bMJDje3t6XLl36/fffy8vLlyxZMnjw4JpF/mXQmun69evNmjX71Ff16tX74MGDyohHBzE3UWUy2Rc854IFC2bMmPH558nPz//8k+iakpISiUSi6ig0T80+bM2bN7927VqNLxobGzuwf39vFxdPJ6funTvv3btXKpXW+GwqIZVKnz59StN0eXn50KFDhw0b9tGXeHh4JCQkfNJVDh8+3L17948epqwWYUpKyq1bt3JychwdHdu0acO0UQgh9+7du3v3rrGxcWBgYK1atd5/YVxcnGJ8pZWVFVOp+KWotPENAPBlhISEMAXnmksqlfbs2TM/P18ikXz11VfMkAxVUVYi7Nu3r4ODg7m5+dKlS62srGJjY/X19X/88cfDhw/7+/vn5uYOHz48NjaWqbOoqFevXm5ubkZGRoSQNm3afNlECF+QSCSiq67kBgD4AH19fWYMnzpQViJUlDUWFxfb29v/9ddf7dq1Gzt27OLFi5nW4fjx4xctWsQ6UeyOHTtcXV2VFBgAAEBFSp9irbS0VCqV1q5dmxBSv359xT1Sa2vrqqaYu379+qlTp5jJewAAAJRKiVWjCxYsOHfu3MOHD5cuXdqoUaOKT2VkZKxdu5b1prCFhcXevXtLSkquXbu2fPnyigWKlWRnZy9cuFDxcNKkSR9dkQu38tSfXC7//El4JRLJF5/JV+spKmVUHYiGqdmHDe9zzUil0k96t6saHFmJEhNh165dfX194+Li5s6d26FDBzs7O2Z/YWFhjx49evfuXWkYACMhIYHJZ+fOnevYsWO3bt2srKxYzy+XyxVz2ZHq/cH48Kk/uVxezc/uB8hkss8/ia6RyWTMhP2qDkTD4MPGpU99t+VyeXW+9pWYCBs2bNiwYcOwsLC7d+/u3r17+vTphJDi4uKuXbu6ublFRUWxvkrRqgsKCjIzM3v48GFVidDS0nLZsmWfFBKPx7ty5QrSodp68OCBo6MjM57yc0gkks8/iQ5iZoNUdRQapmYfNoqizp49m5ycrISItFZ+fr6+vv4nvdtCobA6v+2U/qGnaTojI4OZSq68vLxPnz61a9fetGlTxeDy8/MFAgFTKarw/PnzrKwse3v7LxjM5MmTly9f/ue9Fxb6pK6RZvzylclkH73lq03eXz0RQPvMmjVr586dt2q0WIQWqNnXWuvWra2trZURj1IS4ZMnT0aPHh0QECAUCs+dO5eXl9e/f39CyJQpU86ePfvNN9+MGTOGEFK3bt3Zs2cTQvr37+/j4zN//vxTp06tX7/e19e3tLR0586dw4cPd/pCc8gy/Pz8Dhw4sOCOvFBCL2quAdmFpuni4mJMyAKgZTp16tSppvOCaoGCggJmRVw1oZRE6OjoOHHixNu3b5eXl3/77be9e/dmGrNdu3b19PRUHKaYtWvChAnM4PoWLVowy3wYGhpu3749ODhYGeF5isiOp8o4MQAAaB6lJEKhUNilS5cuXbpU2h8UFBQUFPT+8e3bt2c2RCLRkCFDlBFSRV5iKj6HZYlnAADQQUofR6iGnM2o1GK6SKrqOAAAQA3oYiLkU8TVjHqci9pRAADQyURImLujSIQAAKCzidBTTMXnIBECAICuJkIvMUnIUXUQAACgBnQ1EYrQIgQAAEJ0NhE6mVFpJSgcBQAAXU2EfIq4mlOPUC8DAKDzdDQRkv8Nq0ciBADQdbqbCD1FVAJahAAAOk93E6GXmKBFCAAAupwIqXiMoAAA0Hm6mwidTKl0FI4CAOg83U2EPIo0MKceopsQAEC36W4iJCgcBQAAHU+EnmIqAYkQAEC36XQi9BKhcBQAQNfpdiIUU/G5qg4CAABUSqcToaMplVlKF0hUHQcAAKiOTidCpnAUM44CAOgynU6EBBOtAQDoPJZEmJGR4ezsfPr0ae6j4R5GUAAA6DiWRCgUCp89e2ZsbMx9NNzDjKMAADqOJRGKRCJ/f/+zZ89yHw33MOMoAICOE7DunTNnzpAhQyQSSZcuXSwsLCo+5eTkxElgHKlvQmWV0QUSYipUdSgAAMC5R48esSfCwYMHp6WlzZs3b968eZWeommtupGoKBxtXptSdSwAAMAduVzev3//a9eusSfCpUuXlpSUcByTqniJqPgcJEIAAN3y559/Xr9+/d69e+yJcNCgQRwHpEIoHAUA0EEHDx7s06ePqakpeyJkyOXyV69evXr1qm7duvXq1RMIPnSw5vISU+seylUdBQAAfAGJiYnJycnM9t27d6XSKledffHihZ+fH6mqWIYQsmrVqvnz52dmZjIPzczMJk6c+J///IfP53/JkNWAp5gkoHAUAEArXLhwYf/+/cx2RkZGnTp1qjqypKREX1+fVJUIo6KiJk6cGBAQ0Ldv37p162ZmZh49enTu3LnFxcVLlixRRugqhMJRAACtMXz48OHDhzPbMTExO3furOpIa2vrrKwswjqOUC6XL1q0aMSIEXFxcWPHju3Zs+fIkSP/+OOPWbNmrV69uqCgQEnRqwqPIm5Yqh4AQMe0aNHi0qVLhDURpqenp6enf/fdd5X2f/fdd2VlZU+ePOEiQG6hXgYAQNdERET89ddfixYtYkmEBgYGhBCmwVgRs8fIyIiD+DiGRAgAoGusrKwuXrz4/Plz9inWfH19J02a9OLFC8XOzMzMyMhIOzs7Nzc3DuPkCNagAADQQd7e3ps2bWIvllm7dm1wcLCLi4u/v7+NjU1GRsY///wjkUgOHz7M42nhyk1eYoIZRwEAdBN7VvPz87t9+/bw4cNzcnIuXryYmprar1+/mzdvdurUieP4uFHflMopo/PKVR0HAABwjqVFWFRUNG/evPDw8HXr1nEfkEpQhLiZU49yab86mGgNAEC3sLQICwsLFy9eXFZWxn00KuQlpuLRTQgAoHtYEmHt2rVtbGwSExO5j0aFPMVUAgpHAQB0D8utUR6Pt3z58hkzZri7u/v6+tbgpGVlZUeOHImPj5fL5Y0aNerZs6diYrYnT57s3buXEDJgwIAGDRq8/9rCwsKtW7e+ffu2TZs2YWFhNbh6zXiJqfNvMOMoAIDOYS+W2bZtW25ubvPmze3s7Jr9W3VOmpaWduDAAT09PVNT0zlz5gwYMIDZ//jx4xYtWkgkEqlU2qJFi0ePHlV6oVwuDwoKOnfunJWV1ahRo7jspPQSoXAUAEAXsQ+fcHBwEIlENT6pvb19dHQ0s92lSxdvb++SkhJDQ8OoqKiBAwcuWLCAEJKXlxcVFbVhw4aKLzx16lRGRsbly5cFAoG3t3dERMSoUaO4mebbwZTKLafzyom5HgdXAwAAdcGSCOVy+fTp0y0sLMzNzT//AteuXXNycmJmq7lw4cLPP//M7A8JCfnxxx8rHXzhwoWgoCBmvafAwMC0tLTExERuhvBThLiLqIe5tD8KRwEAdAlLInz79q2zs/OZM2fatWv3Oaf29/dPTk6mKCo2NpaiKEJIamqqYkUMKyurN2/eVHpJamqqjY3N/yITCCwsLN68eVNVIkxLS1NMMU4IiYqK+swVE93NeHfSZU3M1Khkhqbp0tJS7Vv6StlKS0uFQiwm8mlKS0sFAoG2LjuqPPiw1QBnb5pEIqHpj3+ls3zoxWLxFwkxNjY2PT1948aNffv2vXPnjoGBgUAgkMlkzLNSqfT9qwgEArn8/ytWJBLJByIxMDCo2Gepr6//mbPeeInpJ4VEKFSjFiFN00KhEP+bfSq8aTUgk8mQCGsAH7Ya4OxN4/P5TDPsw1g+9IaGhuHh4Vu2bPnMFqG5ubm5ufmyZcu2bdt2/fr11q1b29jYKFqBb968UTT+FGxsbJ4/f85sl5SU5Obmvn9MxfOPHj36cyKspKEFfT5eplbNL5qm+Xy+WoWkEfCm1QD/HVUHomHwptUAZ29aNVtH7L/+WrVqNXPmTH9//86dO1da3nfkyJEfPWlpaSnTKUgISUpKys/Pt7OzI4R07tw5Ojq6b9++hJDo6OjOnTszx1y+fNnT01MkEnXu3LlLly75+flmZmYxMTFubm5OTk7V+TO+CMw4CgCgg9gT4ezZs7OysrKysq5evVrpqeokwl27dq1bt65x48ZlZWWnTp2aNm2ao6MjIWT8+PH+/v7du3enKOr27dsrV65kjg8JCYmJiQkODvbz8wsMDGzdunWLFi1iYmK2bt36eX/dp7E3ofLL6dxyIkLhKACAzmBPhI8fP67YV/ephg0b5uPj8/jxY0NDwwULFjg7OzP7ra2t7927d+rUKULIzp07zczMmP1nzpzx8PBgtvfv33/hwoWXL19Onz6dy+YgqVA42hKFowAAOoM9EX7mwAk+n9+8efPmzZu//5SZmVnv3r0r7fT391dsUxTVtm3bz7n652AmWkMiBADQHVVWiEkkklOnTsXHx0ul0hkzZhBCHj16ZGRkZG9vz2F4XMNS9QAAuoY9Eb558yYsLOz+/fv6+vqWlpZMIty8efOVK1cuX77MbYSc8hJRp19hxlEAAB3CXlo6YsSIkpKS69evnzx5UrGzX79+V69ezcvL4yo2FfASk/hcVQcBAAAcYl+PMDY2NioqqlmzZhWHIrq4uMjl8pcvX3IYHtfqmVAF5XQulqoHANAZLIkwPz9fJpO9X7EplUoJIeXl2pwlFIWjqg4EAAA4wr4wr7Gx8fsjCE+fPi0QCFxcXDgJTGVQLwMAoFNYimWEQuHAgQOnTZtmY2Ojp6dHCJHL5SdOnJg0aVLv3r0Vg/+0FRIhAIBOYa8aXb58+ZMnT0JDQw0MDKRSqUgkKigoaNKkyZo1aziOj3teYioWhaMAADqDPRGamJicPXv22LFjzEq5JiYmgYGB4eHhTANRu3mKSAIKRwEAdEaVA+p5PF63bt26devGZTTqoJ4JVSihc8qIWF/VoQAAgPJ91gJ+WgmFowAAOgWJkIWXCPUyAAC6AomQhZeYikeLEABANyARsmDWoFB1FAAAwAUkQhZYqh4AQHdUKxHev39/586dd+/eVXY0asLOmCqS0tllqo4DAACUjz0RhoSEzJw5k9k+evSoj4/P0KFDmzZtun37dg5jUxmKEA8UjgIA6AaWRCiRSM6fP9+uXTvm4axZs/z8/JKSkn744Yfp06dLJBJuI1QNTLQGAKAjWBJhVlaWVCp1cHAghLx+/frOnTs//PCDk5PTlClT0tLSUlJSOA9SBTxFVAJahAAAOoAlERoZGRFCCgsLCSHHjh3j8XiBgYGEEGNjY0KIdi/Mq4AWIQCAjmBJhGZmZs7OzitXrnz48OGmTZv8/f1r1apFCHn27BkhxMrKiusYVcFLTJAIAQB0Aftco8uWLQsPD9+xY4eBgcEff/zB7Dx8+LCNjY2dnR2H4amMnTFVIiXZZaQWZhwFANBq7Imwe/fuSUlJDx488Pb2trW1ZXY2atRo8+bNHMamYh4iKiGH/tqaUnUgAACgFDk5Ofv27aty9QlbW1tFCmR07dpV+VGpEWaiNSRCAACtVFhY6Ofn5+PjU+WA+gcPHowePbp169atWrVi9mzZsuXgwYNcRah6mGgNAECL7d2719LSct++feyJ8OzZs82bNz916pRQKHzx4gWzs7i4eOrUqRwGqWIoHAUA0GJnzpzp2LEjRVHst0YjIyM7dOiwb9++y5cvf/PNN8zOkJCQ77//PjU1tW7duhyGqjJeIhSOAgBomD///DMuLo7Zfvr0aWlpaVVHvnnzJiQkhLAWy2RmZj569GjXrl16enoU9f89ZEy9qO4kQltjqkxOMkuJpYGqQwEAgOoxNDQUi8XMtrGxcUlJSVVH8ng8mUxGWBOhXC4nhAgElZ9KT08nhOjr69B4AmbG0daolwEA0BCBgYHMJDCEkJiYmJ07d1Z1pI2Nzdu3bwnrgPratWvb2dlFR0cTQiq2CLdu3SoWi93c3L5s0OrME0vVAwBoqQ4dOhw7dkwul7O0CCmKmjFjRmRkZH5+vqOjo1QqPXfu3P79+7ds2bJgwYL3W4pazEuMGUcBALRT3759o6KiOnbsyJ7Vvvvuu6Kiojlz5jAzjrZr105PT2/KlClTpkzhNk4V8xJTx17IVR0FAAB8eYaGhn///fexY8dYEiFN07m5uZGRkSNHjrx8+XJqamqtWrVatmxZp04d7gNVLcw4CgCgxYyMjPr168eSCN++fWtjY3Py5MnQ0NCwsDDuI1MfNkaUBIWjAABajaVYxtzcnM/n61R16Ad4YGFCAACtxr4eYY8ePfbs2cN9NGoIE60BAGg39mKZLl26/PDDD69everSpUulrsE+ffpwEpi68MIICgAArcaeCKdMmZKZmRkbGxsbG1vpKZrWrazgJaaOpKBwFABAa7EnwqtXrzITzwCzGJOqowAAAGVhT4QODg4cx6G26hoRKQpHAQC0l1KmiSkvL4+Ojj537lx2dra3t/f48eMtLS0JISdOnLh48WLFIxcuXMjj/atgZ+7cucXFxcx2o0aNBgwYoIwIPwlTOBqAGUcBALRRlYnwt99+279/f1JSkoV9l1cAACAASURBVCItMZKSkj560tevX2/atKl///42Njbbt28PDAy8deuWnp6ehYWFk5MTc8wff/yRmppaKQsSQlavXj1hwgSmQkdNhvAzCxMiEQIAaCX2RLh8+fLJkye3bdu2vLzc3Nzc2dn54sWLRUVF4eHh1Tmpo6PjhQsXmO2QkBAzM7P4+HgfHx8/Pz8/Pz9m/4YNG0aMGMH68n79+rm6un7yn6I0WKEXAECLsa9Qv3z58gkTJpw7d65Vq1YdO3Y8ePBgYmLi119//X4D7qNSU1NlMpm1tXXFnbdu3Xr06FFVaXXRokWRkZG7du1Sk4IdJEIAAC3G0iLMy8tLTU0dPHgwIYSiKGZ5X1NT01WrVnl5eS1cuJDp8KsOqVQ6bNiwMWPGVFrLd9u2bb169VKsnVjRgAEDvL29S0tLf/7556NHjzKrQbF69epVUFCQ4uGhQ4eUtDKGg5CKzxEy849zjKbpkpISXRuy8vmKiooqriAG1VFaWioQCHRqeZkvAh+2GuDsTSstLa3O92eVC/MyU6zVqVPn1atXzP569erJZLKUlJRqJkKZTDZkyBB9ff1ly5ZVimzv3r2///4766tWr17NbPTp08fe3v7Ro0fu7u6sR9aqVWvGjBmKh2ZmZjVosFaHiwmR0ZISgUltzgtHaZrm8XjGxsZcX1jD0TRtYmKi6ig0jOAdVQeiYfBhqwHO3jQDA4PqZFyWD71YLLawsEhMTPT09GzYsOHWrVvfvHljY2PDTLpma2tbncvL5fIRI0akpaUdO3ZMT0+v4lOHDh0SiURt2rT58Bnq1q1rbm6elpZWVSI0MjIKDg6uTjCfj5lorU1d/O4DANA27E2o0NDQ3377jRDSu3dvMzMzZ2dnR0fH0aNH9+vXr1JvHyuapiMjI588eRITE2NoaFjp2W3btg0bNqxi6y02NvbGjRuEkOzs7KKiImZndHR0aWlpw4YNa/aHfVmYaA0AQFux3wb59ddfmQ19ff2///57586dz58/9/HxGTZsWHVOeu/evfXr15uYmNjb2zN79u7dy6zolJycHBcXt3379orHr1692sfHp1mzZrdu3erVq1eDBg1KS0vfvn27Y8eOWrVq1fyP+3IwvwwAgLb6eH+AtbX11KlTP+mk3t7e2dnZFfcobgfb2NhkZmaam5tXfHbfvn1Mz0RwcHBycnJSUpKBgYGrq6v6LAXlKaYOJWPGUQAALaSUjnE+n89aEUoI0dPTq9RlSAgxNTVVbIvF4mbNmikjqs/hJaYe4NYoAIA2Yk+Efn5+mZmZrE9VZ2YZ7WNtSAghGaWE+8JRAABQqirXI6w4bC4jI+Ovv/7KyMioZh+hVvIQUfE5dCAKRwEAtAt7Ipw5c2alPVKpdOjQofn5+coPSU0x88sgEQIAaJnqjkAXCAQzZ87csmVLWlqaUgNSW54iKgGFowAAWucTpmIxNjaWy+Vv3rxRXjTqDDOOAgBopeomwtzc3J9++kkgEKjVuhBcQiIEANBK1aoaLSkpefv2LUVRc+bM0dlZ9awMCSEkvYTUqTxVDgAAaLBqVY0SQqytrYODg729vTmJSk15iqj4XLqOIeplAAC0R3WrRoG8uzvaFoWjAABaRCnrFmkrZg0KVUcBAABfEnuL8Mcff/zokMFBgwZ9/fXXSghJfXmJqYPPMOMoAIBWYU+EFy9efPjwYUFBAUVRtWrVys3NlclkRkZGFddgateuHVdBqgssxgQAoH3Yb43OnDnT3Nx83759paWlmZmZpaWlx48ft7GxmTFjRtI7ffv25ThWlatjSHgUSStRdRwAAPDlsLQI5XL5mDFjVqxY0adPn/8dJBB07NjR3Nw8JCSkX79+OjuCghDiKabic2grFI4CAGgLlhZhenr6q1evGjVqVGl/o0aNiouLnzx5wklgagoTrQEAaBmWRGhqaioUCo8fP15p/4kTJwghFhYWXMSlrjC/DACAlmG5NWpsbDxkyJCpU6e+fPmyR48edevWTU9PP3ny5MqVKzt27Ojg4MB9lOrDS0ztR+EoAIAWYa8a/eWXX4RC4dq1a6Oiopg9PB6vX79+GzZs4DA2deSNpeoBALQLeyLU19dft27dnDlzHjx48Pr1a2tra09PTxsbG46DU0OWBkRAkbcl/1uzHgAANB17ImTUrl27bdu2nIWiKZj5ZaxROAoAoBXYxxFGR0cfOXKE2c7JyRkwYICrq2t4eHhWVhaHsakp1MsAAGiHK1eu9O7dmz0Rfv/99xkZGcz2tGnTDh061Lx580uXLg0dOpS7ANUV5pcBANACr169CgsLCw4OZkmE+fn5b968ad68OSFEIpHs379/6tSpe/fu/f33348fP56dnc15tOrFS0zFYyghAICG27p1a/v27UePHs2SCIuKiggh5ubmhJCrV6/m5eV169aNENK0aVOaplNSUjiOVd3g1igAgBa4fft2y5YtCWuxTO3atYVC4f379+vXr3/gwAFLS8vGjRsTQpi2oIGBAcexqhsUjgIAqK01a9bs3LmT2c7NzXV0dKzqyLdv34rFYsKaCAUCQa9evYYPHx4SEhIdHT1y5Eg+n08IuXXrllAotLe3V07wmoRpFKJwFABA3fTs2bNVq1bM9oULF+Li4qo60tTUtKSkhFRVNbpx48aePXs+ffp06NCh8+bNY3ZGR0e3adPG2Nj4S4eteXB3FABAPdna2vq+4+zszDTkWDk4ODx79oxUNY7QzMxs/fr1lXZu27btC8aq0bzE1J0sJEIAAA3Wr1+/iIiIn376ib1FCB+GNSgAADRdcHBw586dPTw8kAhrArdGAQA0HUVR69evv3fvHhJhTVgaECGPpBarOg4AAPg8VlZWSIQ1hPllAAC0w/8nwuTk5NjYWBWGollwdxQAQDv8fyI8f/78pEmTmG03N7dr166pKCTN4ClGvQwAgDb4/0QoEolyc3NpmiaE5OXlSaVS1UWlAdAiBADQDv8/jtDX1zczM7NTp04NGzYsLCxcv3790aNH33/Bzz//zGF46guJEABAO/x/IrS3t//tt98WL168Y8eOkpKSI0eOCAQsw+2RCBkW+kSfT94U0zZGmGgNAECD/SvV9ezZs2fPnoQQa2vrQ4cOKaZrA1ZeYio+h9gYqToOAAD4DOzDJzZv3uzm5sZxKBoHd0cBALQA+1yjXbp0IYSkpaU9ePDg1atXdevW9fT0tLOz4zY2decpom5hxlEAAA3H3iKUSqWRkZF2dnbBwcFDhw4NDQ11cHAYOHAgs2bvRyUlJY0ZM8bX17dJkybjx49XLGr/66+/tq8gMzPz/ddevXq1Xbt27u7u3333XWFhYY3/MA6gRQgAoAXYW4Q//fTT+vXrhw4dGh4ebm1tnZmZefTo0fXr1/N4vN27d3/0pAkJCXXr1t24caNQKJw8efLQoUOZAtTnz58bGhqOHz+eOczU1LTSCwsKCjp27Lho0aL27dt///33P/zww8aNGz/vD1QibzEVn0PThKBaBgBAc7EkQolEsmHDhv/85z+zZ89W7Gzbtq2Hh8eYMWOioqIsLCw+fNIuXbowN1cJIbNnzw4LC1M8Va9eveDg4KpeuG/fvgYNGowcOZIQsmTJEl9f32XLlr2fL9WEWJ8Y8smbItrWGKkQAEBTsdwazcjIyM/P79WrV6X9vXv3lslkz58//6QLXL9+3cvLS/EwNja2devW/fv3v3Tp0vsHx8fHN2vWjNl2d3fn8XjMqolqy0tMxeeqOggAAPgMLC1CMzMzHo+XlJTUsGHDivuTkpIIISKRqPpnf/DgwZw5c44fP848bNWqlZeXl7W19d9//x0SEnLy5Mk2bdpUPD4jI8PR0VHxUCQSpaenV3Xy5OTkigffvHlTKBRWP7YvwsVYcOutpKWZsmbhoWm6pKRELpcr6fzaSs17l9VTaWmpQCBgHT0MH4APWw1w9qaVlJQw06V9GMuH3sTEpG3btpGRkRYWFq1bt2Z23r17NyIiwtPT08XFpZoRPHnyJDQ0dO3atYrxiEFBQcxGy5YtU1JStm3bVikRikSiivU4+fn5YrG4qvPb2toeOnRI8VAsFlMU17cofazkNzJoU1NDJZ2fpmk+n29sbKyk82sxtb2jrraEQiESYc3gw1YD3LxphoaG1ckL7B/6DRs2tG3bNiAgwNra2sbGJiMj49WrV2Kx+OTJk9W8fFJSUvv27efPnz9gwADWA2rXrp2amlppp6Oj49mzZ5nt1NTUoqIiBweHqi4hFAqdnJyqGY+SeImonU/QXAMA0GDswydcXFwePHiwYsUKf39/c3Pzxo0bz58//+HDh82bN6/OSVNSUoKCgr777rvu3bvn5OTk5OQwjdO4uDiJREIIefjw4ebNm9u3b88cP2PGjKdPnxJCmL7DW7duEUJWrFgRFhZWu3btL/J3KomXmErIrUbDGwAA1FWVt0HMzc0nTpw4ceLEGpz05MmTBQUFS5YsWbJkCbPnxYsXJiYmK1asCA0NNTQ0JISMHTt2xIgRzLN79+4NCwtzdXW1tbVds2ZN+/bt+Xx+vXr1oqOja3B1Lon1iZGAvC6i7VA4CgCgmZTSHzBq1KhRo0a9v//IkSNSqbS4uNjMzKzi/uTkZMX2t99+O3jw4KKiokrHqC1PERWfQ+zYevEKCwt3bNz45NYtp4YNh44e/Ul1RgAAwA2uO8YFAsFHMxyfz9eULEje3R0NtavcIkxLS+vYvHlEWlr/8vIHQmHbNWuOXLlib2+vkiABAKAq7H2EUH1VTbQ2a9y4Ba9fjy0vb0nICIlkbWrqtOHDuQ8PAAA+DInwc1WVCO/euBFcYfxfK5p++vAhh3EBAEC1IBF+Li8xlZDDUjhqamqaX+FhKSEGhsoabggAADWGRPi5RHrEREi9KqqcCvuNHDnTzExGCCGEJmSWiUnPwYO5Dw8AAD6MvVhGLpcfOXIkJibm7du3leb3On36NCeBaRJPMUnIIfX+XTg6bOzYNykpzXbscOfxHstkoX36fD9jhooCBACAKrEnwsmTJ69cubJ+/frOzs7cz1umcZhuwvcLR/+zZMnU+fNfvnxpZ2enr6+vktgAAODDWBJheXn52rVrp02btnDhQmTB6vASUf+ks08vo6en5+zszHE8AABQfSx9hPn5+eXl5X369EEWrCYvMRWfi3nWAAA0EksitLS09PT0vHfvHvfRaKiqCkcBAED9sfcRbtu2bdCgQcbGxu3bt8fEYB9lrkdMhdSrIroeZhwFANA07ImwQYMGXl5effv2ff+p6ixyqIO8xCT+vcJRAABQf+yJsG/fvpcuXfrmm29cXV1R7lgdTOFo2HuFowAAoOZYEmF2dvaZM2e2bdv27bffch+QhvISU5fT0FYGANA8LMUyfD6foqhGjRpxH43m8hRRCSgcBQDQQCyJ0NzcPDg4+MSJE9xHo7lQOAoAoKGqnFlmxIgRmZmZoaGhVlZWFZ/y9fXlJDANY65HzPSol4W0vQm6CQEANAl7Ihw8eHBaWtrq1atXr15d6SlUjVbFS0Tic4i9iarjAACAT8GeCA8cOFBeXs5xKJqOmV+mQz20CAEANAl7IgwICOA4Di3gicJRAACNsmrVqrlz52I9wi+mqqXqAQBADd28eXPOnDmXL19mbxGGhIRkZ2ezPnXjxg1lBqbBvMTUw1yaJgT3RgEA1N+OHTv69u3r5ubGnggdHBwqTjGal5d369at8vLy0NBQriLUPGZCYq5HvSikHVA4CgCgIiUlJaWlpcx2YWHhBwo8nz592qlTJ1JVH+HmzZsr7SkoKOjbt2+DBg2+UKjaiZlx1AGFowAAKrJkyZJVq1Yx2xKJpEWLFlUdmZOTY2JiQlgH1LMyNTVdvHjxkiVLqrplCgTdhAAAqjZr1qzsd3bv3m1mZlbVkZaWlnl5eaT6iZB5jUQiSU5O/vxAtRUmWgMA0BQeHh53794l1U+EEolkxYoVFEU5OTkpMzDNhhYhAICmiIiIOHToUFxcXLWqRqVS6YsXL3JycsaOHYt1ej/AE4WjAAAawtPTc+PGjZGRkdWqGuXz+cHBwWFhYcHBwVxFqJHMhESsR6UU0PVNkQoBANRdeHh4eHh4datGoZq8xCQ+l9Q3VXUcAABQPdXqI5TL5W/evMF029XhKaYS0E0IAKA52BPh3LlzN2zYwGw/evTIycnJ1ta2Xr16N2/e5DA2jYR6GQAAzcKSCOVy+bJly+rUqcM8/OGHHyQSybp161xdXYcNG4Z24Yd5iZAIAQA0CUsfYU5OTkFBgaenJyGkoKDgzJkzUVFR3333Xfv27V1dXd+8eWNra8t5nBqDmXFUThMeymUAADQBS4tQJpMRQgQCASHk3LlziilGHRwcCCGpqancRqhhTITEwoBKKUSjEABAM7Akwtq1a5uZmZ08eZIQsmvXLhcXF2YQ/evXrwkhGEf4UZ4ikpCr6iAAAKB6WBIhRVHff//9hAkT6tevf+jQobFjxzL74+LiTExMmHYhfADqZQAANAj7OMI5c+a4u7vfuHGjWbNm/fv3Z3ampqZOmjRJKBRyGJ5G8hJTF1KRCAEANAN7IqQoasCAAQMGDKi4c9q0aZyEpPG8xNTaBLmqowAAgGr5hNUnoJo8RdSjXFqONiEAgCZAIvzyUDgKAKBBlJII8/Ly+vXrZ2lpaWBg0KhRo9OnTzP7Dx065Ovra2RkJBKJhg4dWlhY+P5rfX19nd8ZN26cMsLjALNUPQAAqD+lJMLS0lJ/f/8HDx4UFxdHRkb27NkzNzeXEFJeXr5s2bKcnJzHjx8/fvz4v//97/uvTUlJ2bx58+nTp0+fPj1z5kxlhMcBzC8DAKAplJIIraysJk6caG1tzePxhg8fLpFIEhMTCSHh4eFt27bV19e3srIKDw9nlgZ+X7169ZycnJycnKysrJQRHgcwggIAQFMovY/wzJkzJiYmHh4eFXfSNH38+PGvvvqK9SVBQUH16tXr1atXUlLSB84sl8tzKviSQX82TzGVkItECACgAdiHT5SWlq5fv/7w4cOpqaly+b9GAnw4OVXy8uXLiIiINWvWGBsbV9y/ePHily9fHj58+P2X7N6928fHp6ysbP78+R06dLh3756BgQHryZ8/f85MeaMITE9Pr/qxKZWDkHqYI8wvKPzMGUdpmi4pKcFE55+qqKiIojDZ66cpLS0VCATM3IpQffiw1QBnb1ppaWl1vj/ZP/RDhw7dv39/QEBAYGAgj1fDVmNqamq7du1++OEHxZB8xtq1azdt2hQXF1cpOzI6dOjAbKxfv14sFt+7d69Fixas53d2dr5+/XrNYlM2E0JqG0ozibGTyWf9Y9M0zePxWN8o+ACapk1MTFQdhYYRvKPqQDQMPmw1wNmbZmBgUJ2My/KhLy8vP3z48MKFC6dPn17jy6enp7dv337o0KETJ06suH/btm1Lliw5f/58vXr1PnwGmqZpmtbcn1peYhKfQzuZamr8AAA6gqW1l5ubW15eHhYWVuOT5uXltWvXzt3dPTQ09ObNmzdv3szLyyOE7N27d9y4cUuWLMnJybl582Z8fDxz/Jw5c/bs2UMISUhIiImJefPmTVJS0siRI21tbRs1alTjMFTLS0xhBAUAgPpjaRHWrl3b2dk5ISHBx8enZifNzMy0trbOy8tTzMo2b948f3//lJSUVq1abdmyhdlpb2+/detWQkhRUVFJSQkhRCaTRUVFJSYmGhgY+Pv7nzx5Ul9fv2YxqJyniDr3Bn17AADqjiURUhS1devWUaNG2dratmnTpgY3J52dnRWD6CuaPn066+3WJUuWMBsNGza8cOHCp15OPXmJqTWqm3FUKpVu37Dh/OHDJmZmvUeNCvmM9j0AgHZj7xifMmXK27dv27Zta2hoWLdu3YpPfVLVqC7zFFOPcmkZTfic9xLSNN2jTZsW9+7NKSwsIOTnCxfuTZgwedYsruMAANAE7IkwICCgSZMmHIeiZYwFpI4hlVxAO5txnQljY2Prx8f/590Mdr/l5vr98svoH35AbRsAwPvYE+HSpUs5jkMreYlIfI4KEuGdy5cD8/IUD/mE+BGSkJBQ1UAUAABdhtUnlMhLTMXnquC6Ns7Or/5dZPSKz7exsVFBKAAAaq/KwbMlJSUXL1589uxZfn5+xf1Tp05VflRawlNMnXmtgsLRjp06hdWq1TE11ZUQQsgRHk/i4GBnZ8d9JAAA6o89Ed6/f79Dhw6vX79+/ykkwurzElOrHqigcNTS0nLLiROjBw0qy8gop2m3Zs127dzJfRgAABqBPRGOGjXKwsLi9OnTixcvtrOzGz9+/B9//DFnzpzNmzdzHJ9G8xRRj/NUUzjapEmTs/fvl5WVCQQCPp/P9eUBADQHSyKUSqU3btw4cuSIh4cHRVEymaxOnToRERHm5uaDBw9+9eoVZiOsJiMBsTKknhfQLpzXyzA0dzoCAADOsBTLZGZmSiQSZ2dnQoiJiUneu/rD0NDQtLS0R48ecRqghmNmHFV1FAAAUCWWRGhpaSkQCNLT0wkh9erVU6zwkJKSQgjBfbZP4imiElRROAoAANXEkggFAkGLFi2Yqc769Olz586d/v37L1u2rHfv3g4ODi4uLlzHqMmwVD0AgJpjH0e4dOlSZtkHR0fHDRs2/P3331OmTNHT0ztw4IBQKOQ2Qs2GRAgAoObYy15atWql2B42bNiwYcMkEglSYA14iKineXReOTHXU3UoAADA5iMzy0ilUqZYBlmwZowEZJgb75sLUjmahQAAaqnKRLhz586GDRsaGRl5eXkxe2bPnj1v3jyuAtMey/34hRIy+5ZM1YEAAAAL9kS4bt26b7/91t3dffTo0Yqd7u7uq1atkkqlXMWmJQQ8Eh0s+DWRPvhcZcsTAgBAVVgSoVwunzNnzvTp0w8ePNirVy/Ffj8/v6ysLNZ51+DDLPTJ78H8yMsyFM4AAKiV27dvsyTCtLS09PT08PDwSvvr1KlDCGHGF8KnamJBLffj9zwjyy1XdSgAAECITCbr3r17eHg4SyI0NDQkhFRadIIQkpiYSAixsLDgID6t9I0LL9SOCj8nlaFZCACgasePH4+Pj2dvEYpEoiZNmqxcuVImk1HU/ybJlEqlc+fOdXJycnR05DZUrbLCj18mI3NROAMAoGq///577969jYyM2McRLlu2LCwszN/f39vbu7i4eN68eYcOHbp79250dLQiNUINMIUzzWOkDWvJeztiVWQAgC/s/v37ijmxr1+/LpFIqjryxYsXLVu2JFUNqG/Xrt3Zs2enTp26c+dOmqb/+9//enp6xsTEdO3aVRlx6xSmcCbspNRDRHmJtfNXxbVr13atXJmXnd0yNHR4ZKSeHmYTAACO3Lt378iRI8z269evTUxMqjqyrKyMGSJf5YJKAQEBV65cyc3NzcrKMjU1ZSpl4IvwsaCW+fF7npFd7SYQaV2O2L1ly56pU/+bnW1ByLG//grbufPUzZtYugsAuDFw4MCBAwcy2zExMTurXpbc2to6KyuLfHRmGZFI5OzsjCz4xQ1y4YXYUoMvyLRsxhmappfNnHk4O/srQtwJ+bG4uE1i4m979qg6LgCAyvz8/OLi4sgHWoTJycl//PFHamqqTPavyo6ff/5Z6dHphpX+/OA/pXNvy2Y31Z6VrVJSUhoQYlRhT1Bx8eELFwYNHaqqkAAAWEVERCxdunTWrFnsiXDHjh0jR46USCSmpqaVbmohEX4pAh7ZHyRocUTqLdaewpk6deq8pf/VyH1NUTbOzqqKBwCgKrVr1758+fIvv/zCPrPM+PHjO3XqlJaWlp+fn/1v3MeqxawMSUx7/lgtmnHGyMjIvmnTne9+PL0hZGXt2r2++Ua1UQEAsGrQoMHq1atZEmFmZmZBQcGMGTPQNcgBReFMnrbMOLN+//6/unVrVqdOmzp1+ri4LN2/H2NPAUCdsdwatbS0tLa2TktL4z4a3TTIhXc1nR50QRbTns/T/PEUZmZmm6OjZTJZWVmZkZHRx18AAKBSLC1CHo+3dOnSGTNmJCUlcR+Qblrpz8+X0HNva8+MM3w+H1kQADQCe7FM//79z5496+7u7uTkZGpqWvGpGzducBKYbhHyyP4gQfMYaUOxvJe2FM4AAGgE9kQ4bty4HTt2uLi4uLq64nc9N6wMyZEQfthJqbv2zjgDAKCGWBJhUVHRpk2bfvrpp/nz53MfkC5TFM5c6yYw17oZZwAA1BPLXbji4mKZTNazZ0/uo4FBLrxgW2pwnLbNOAMAoLZYEmHt2rU9PT3v3r3LfTRACIny5+eV0/Nuy1UdCACATmDvI9y1a9fgwYP19fVDQkIsLS05jknHKQpnvMWkZ310Fn6yJ0+e3L5928PDo1GjRqqOBQA0AHsiZKaVUUzgXRFN456d0jEzznSIlbqL+PXRWVhtMplsaNeu+dev+xYXHzE0zHVyOnjunLGxsarjAgC1xp4IZ86cWVRUxHEoUFFTS2qZH7/XGfn59hS+yKspasECj7i4GcxHt6hoT37+T2PGRFW9CAsAAKkqEUZGRnIcB7xvkAvvn3R6xD+Co6FEC2ac4cDJ6Oj9FX7ADSwvX3PhgurCAQDNgLHbam2lHy+vnJ5/B4Uz1SKTySr+sqMIkcvx1gHARygrEcrl8pcvXyYnJ1dazpAQkpKSkpyc/IHXZmdnP3z4UCKRKCk2DSLkkV1fybY8kh9Kxhf6xwV27PirgYHi4XGBoHHz5iqMBwA0QpUL836O8+fPDxo0iBCir69P0/TevXv9/f0JISUlJd27d3/8+DEhxM3NLSYmxtDQsNJrf/755yVLltjb2+fk5Bw7dgyFf3UM6HeFM5SnCHdIP2Tq/Pk9Ll68nZjYIicn3tz8mpXVsS1bVB0UAKg7pbQILSwsTpw48erVq6SkpEGDBg0fPpzZv3HjxsLCwqdPnyYmJhYXF2/YsKHSC5OSkhYsWHD9+vU7tGfLMgAAIABJREFUd+6MHj16woQJyghP4zS1pJa24Pc8rT1LNSmJvr7+iatXvzl8uGj58g7791+Mj69Vq5aqgwIAdaeURNioUSNFSy44OPjly5fM9r59+4YNGyYUCgUCwbBhw/bt21fphfv372/Xrp2zszMhZOTIkXFxcampqcqIUOMMduUF2WDGmWoJCAiIGD48JCSEz+erOhYA0ABKL5bZuXNn586dme3k5GQmyRFCnJ2dU1JSKh2ckpLi4uLCbFtYWJibm7948aKqM5eVld2sQOsHOK5qyc8toxegcAYA4ItSSh+hwubNm0+fPn3t2jXmYVFRkcG7WgYjI6P8/PxKxxcVFVWcyMbIyKigoKCqk6elpY0YMULx8OzZs0Kh8IuFrh5omi4pKVHk+O3+VOBpPQ/jsjAb7Vm5UBmKioooCv2pn6a0tFQgEAgEyv1O0D74sNUAZ29aaWlpddpISvzQ79mzZ86cOefPn7eysmL2WFlZ5eTkMNtZWVnW1taVXlLxAEJITk7O+8co2NvbX79+/UtHrV5omubxeIq5UUxMyMF2dOdTJK6zAQpnPoCmaRMTE+4veujgwTMHDxqZmvaMiPjq6685DuAzCd5RdSAaRiUfNk3H2ZtmYGBQnYyrrFuj0dHRU6ZMiY2NdXV1Vez08fH5559/mO1//vmnadOmlV7VpEkTxQF3794VCoVOTk5KilBD+dWhlvuhcEYdDena9dLIkRHR0V23b1/SrduqhQtVHREAVItSEuG5c+f69+/fu3fvv//+e9OmTZs2bWIGBUZGRq5evfrIkSNHjx5dtWqVYv6axo0bX758mRDSu3fvtLS0OXPmXL58edy4ccOHD8eywO8b7Mpra0MNiZNpeaeoRvnrr7+oy5ej8vKaE9KGkN+zs/esXJmXl6fquADg45TVIoyIiKhYzMIMq2/Tps22bds2bdq0cePGrVu3BgYGMge3bt1aLBYTQgwNDc+dO5eYmDhz5sz27dsvxG/qKqxuyc8poxdgqSa1cePvv0Mq3NUXEPK1XH7//n0VhgQA1aSU/oCgoKCgoCDWp7p37969e/dKO3/55RfFtpub2+7du5URlTYR8siBdoIWR6RNLKjO9ugsVL06dnZv9fVJaaliT5pQWKdOHRWGBADVhLlGNZWVIdkfxP/2ovRhLm6Rql5IaOhekUgx1ucSIa8tLBRjgQBAnaFCTIP516GW+fF7nJZd7SYwx7KFKmVpabnu8OEBgwcb5+eXEWLq6LjnwAEeDz80ATQAEqFmG+LKu5JGD4mTHW7Pxx1S1Wrh7//XkyfZ2dn6+vpYDRhAg+AXq8Zb04qfjcIZtVGrVi2VZEG5XH7r1q3Tp0+np6dzf3UAjYZEqPGYwplNj+R/vEBnoY5KTk5u7eGxLjT0fJ8+3b29V8yZo+qIADQJbo1qA2tDcqAdv8sp6cXOAg/MOKN7RvboserJk2aEEELkhPRavbp527atAwJUHBaAhkCLUEswhTM9z8jysZ6xjiksLJSlpjZ795BHyJjs7D/fW9oFAKqCRKg9hrjyAqypwRcw44xuKSsrq3Rjx4CQ0uJi1UQDoIGQCLXKL6342WX0QizVpEssLCwKTU2TK+z51dw8sEcPVcUDoHGQCLUKUziz8aH8+Es0C3XImn37etWtu9jAYAdF9bWwoMLCunbrpuqgADQGimW0DQpndFBTX9/zjx6dOHEiMzV1SuvWzZo1+/hrvqgXL14kJCQ4ODh4eHhwfGmAz4dEqIX861Dzm/F7npFd7SYw07a1ioGdmZlZeHg499elaXpM//5J5875lZdv09Mrdnbed/o01ucDzYJbo9pplDsvwJoagsIZULKNUVHiEydOZWTMy8s7kJEx4NataaNGqToogE+DRKi1VrfkZ5TSgX9I9yXJy2Sqjga01PHffhtfUKB4OKC8/NrFiyqMB6AGkAi1lj6fxHUW/MeHfyiZtt0rGfWX7H422ofwhZWXl1ea752Wo2gZNEZmZuaKFSuQCLUZnyLBttSBdvw7PQVOplTnU7JmMdJNj+TFUlVHBtqiTceOew0NFQ8vUJSrt7cK4wGovoKCghYtWty5cwfFMjrBzpia2pia3Ih3/g296ZF8xnVJL0feGE9e41ooK4XP8sOsWd3PnElITPTPyXliYnK6Tp0jO3dyGYBEInn8+LG+vr6TkxOfz+fy0qDp9uzZY2tru2vXLiRCHcI0EINt+a+LeHsS6W6nZJYGZKQ7b6ALzxgfBKgRfX39E1evnj9//sHt281dXGZ17CgUclepfDY2dsqwYY3Ky8so6pmJyaZDhxo1bszZ1UHTnTt3LiwsjGD4hG6yNaamNqZ+bMQ7V6GB+J0Hr4kFGojwySiKCgoKCgoK4vi6aWlp04YMOZWWZkEIISQxPb1/165/P32qp4dVqnXaoUOHYmNjme3k5GSKqvJrLTU1NSQkhCAR6jLeuwbim2Le7qd0jzMyC30y0p03wJlngtGHoPbOnzvXLz/f4t1DF0J8S0ru37/v6+uryrBA1WxtbRWfAT6fn5KSUtWRfD5fLpcTJEIghNgY/auBOP26pLcjb7QHzwcNRFBjBXl5ZpJ/LbZiJpXm5+erKh5QE35+fn5+fsx2TEzMzqo7rW1sbFJTUwmGT4AC712J6YNeQidTqteZ/5WYFmJdJ1BLLb/+OkYkUgwJKiPkvEDg4+OjyphAo3Tq1OnIkSMymQyJECqra0SmNuYl9hX83Jx/5jXtsE8y6i/ZzUyMQQT14u3t3XzgwF4WFocI2UdImKXlmNmzRSIRN1enaXrrunVfN2jQ1sOjf/v2T58+5ea68AX16dNHKBQGBwfj1iiwU/Qgvi3h73wi73tWZsAng115I915Yn1VBwdACCFkTlTUtQEDzh49KjQw2NCnj5ubG2eXXjJr1vOoqJMFBSaEXH/9OrxNmz9u3qxbty5nAcDn09fXv3Tp0p9//olECB9hbUimNuYpehDr75OE2vFGuvOCbdGDCKrXokWLFi1acHxRmqb3bdp0o6CAGbfYnJDJb99u/+WXGQsWcBwJfCZ9ff3u3bsjEUK1KBqIaSX8HU/k3/0t0+ORwa68Ee68Wmgggo7Jzs62IqTi6P2GNH3q7l2VBQSfB32E8GmsDMnUxrynfQW7AvnPCmiXA5K+Z2VnXqMHEXSIhYVFGiEVy8ju8HhuTZuqLCD4PEiEUEO+ltTGr/lJfYXBttTEf2Qe0dLFd+VZZaoOC4ATg8eNG2lmlk0IISSOolZaW0dERnJ29YcPH34TFtbcwaFjs2axf/7J2XW1FW6NwmcR65OR7ryR7rybmfSmR3LXA5JgG95Id14726qncwDQfBNmzNhra9t72bL8vLyGPj6/r15dp04dbi6dmJg4KDBwfXp6c0JevngxauDAovXre/brx83VtRISIXwZTANxQTP+rqfycVdkPELCnXmuZsTZjHIyoyzQjwjahaKogUOHDhw6tKCgwNTUlMtLr5o1a2l6enNCCCH1CNmXkxM6fToS4edAIoQvydKATGrIm9SQd/EtfeKl/FAyeVYgT8qnaUKczSgnU8rJ9N2GGbE3pgS4Nw/wiR7dv9+kwkMzQqRFRSqLRisgEYJSBFhTAdb/X1WXU0aeFdDPCuhn+eRmJn3wufxZPnlTTNsYUU5mxMn0f6nRyZRyMaPMMWcyQNVc3NwS7t//6t3DYkL4RkZcBkDTdHJyMp/Pt7e35/K6yoNECFwQ6xNffcrX8l/9huVyklxAPysgz/LppAL6n/T/NR8NBSzNRztjdDoCEEJI5OzZwy5c2J2Z6UpILiEjzc3HzJjB2dX/uXIlMry/fWmplCZvzczm7D7o26SxkEcoiog09icsEiGojB6PNDCnGpgTQv6V49JKyLMCOimfflZA4lLpbU/kz/JJVhntWDE1vtswxEcYdIyXl9eaEycmjB2b/uaNoYnJ2Jkz+33zzeefVkaTrFKSVUb/779lJLOUZJTQWWX/1969R0Vxng0Af2Z2d/YCrMBycXeRS1TKCgLGghi8VAkmaQqRcALe0hg1OX5qGpIajzmNp0kxsX5fT5qGEJueY2IT7UnUgEZTiaQnxgulIjWxNOqi3OWOe2fvM98fA5OVhXgJe4F9fn94Zud9Z/aZdXce3ndm3hcGrDBgYQas0HdTI9xWeF7XpQQAAHVfz5L8fNv/Njj5IpoBnQ0AQMgDCR8AIERA8AkgCWD7eEQ8YH+tUyiCdlAiyhkiAACQ8EHIAwAIpQgCQEACO/tNEB8oHgBAGEUAAMUDdtrUYAHEBBHjO4UqnkWQ34kWQ7SYmB91S3a0OOG6fqhz9bqB+fIG02SAZgMTJuRSIzGd7WWVEkG+Ch0hr8jIyPj8/Pk7rGynv89kAxam3wJ9rgnPAgNW6LcwGitEiEAmImTC4X+FECkmVGEgE4JMSMpEUP+P2ianQTm850SAQsa0Mqlh/vz53NtZnGB2AADo7YyTAScNejsAgNkBFicAgM7GmMwOgVBgsAMADDrA6gQA0NoYBsBOAzvQv8kBNicAgMZGA4DVCYMOAACDHd7N5uUoxrOHCBMhmhhEPEgOI5LDbvn2MwA3TEyTYShHnmiH6wa6Sc8Y7cJwkUMqACkFIQIIowgpBcMvCakAQoUwhSKkAggRgJQCqQAvTKKJx+q8JZP1WUZv0pkcECECmZCQDf8bKQKFhJgdxia879ffNrfUGW+GWW95WDjMZtNoNK5rRDwQsS054Vj7IwwGOiTkXu6Uo2n64sWL3Re7bzDpSqXy9hvcGUyEaAIjAGKCiJggWDT11s5VrdEuCNLbQW8Dgx20NkZnA70N9Hamc5C5YgOdDbQ2Wm8Hgw30dtDbGL0dQtk0OZwypQIiVMguf58y2ZwaIhhaH4IzGE8ERjvY6XvfnG2pjMVkIkQ0wzZ6uO5BBkBrG9pIM5w4dDagGYDhphIAGOzgoG+J0ORgbDSASzuJa0hZaRh0MABgc4LJAQAgIG/JcBEiiBDBtCBijgxkIpJt0kWIiHEcJT9z3rySKVO29PezvzcnQLVI9D/eGlKnq6uraOnSmf39sVbr/4lEC4qLd5aVjcueMRGiSUjCY0KCXFPjHfWiaKxgsDNs+tTbwWBnNNahNNliHEqZWhuts4FhqA5jskOoEKSCW1qc7C0DIQLgkyDigZhH8EiQCgAApALgkSDmESIe8Elg8+gUCkgCJHxCSH5/gWRyY3u92HygsYKTAb0NbDSYHAx73r/bCj8sWACCH/GgDnvtaiw0TQn4Tvb/l7seBsNXtgAgVDj0/WP/owFAKiB4BABAbBCwTxBxEUr4pJAEABDzh9pV3KU1IQkS/i1Xy7wvKSkpc9Wq4v3719286QDYI5MV/epXU6dO9c67byoqel2tXkTTAAAGw7r9+z9bujS/oODH7xkTIUJDwoQjOnNunz7ZFoDOdkv6ZNsEejs4aTA7GY2NcdLQaAcYbhMMOmgrDQ4a2GskWhswzFBTgLtAEkoBQUAQn6DI70987J/2wXxCQA7dksCdedkbE34Mh4MkSSDJe2w6sVmKvT70A2mMrcDeB8HGHCoEHgFTKBCQEMwn2PM+W4FNGAkhrhVI9wpcpvEJ7z9Q71u/+9OfzhUVVR08yBcIfrdy5dy5c73zvg6Ho6excSgLAgDAJq1279/+hokQIR8jiXtJn3eCbeUYHYydHuoKYwC0VgAAg51xMEP3DnB9cVxv2z1zOBiSZEjyHvciICGMuiWNhQjIsfIcmtCys7Ozs7NvX29cuc8jTwHYrOMzurEHv5Jms1mtVkdFRXGTVXZ0dPT09LjWuf/++4lbex2+/fZbh8PBLoeFhd13332eixAhv8U2/sa43cAj7R+Lxc7nE3w+7/ZVEfI6oVAokcsbenpShtfsDwlZMh7NQfBcInzyyScPHjxIEMQrr7zyyiuvsCs//fTTjz76iF3u7e21WCwj8iIA5OTkyOVyoVAIALm5ubt27fJQhAghhCaQdz75ZGVOTr5GE2M2/yM8nJo/f/XateOyZ08lwpdffvndd999+umnXVc+//zzzz//PLtcXFysVCqJ0S5CV1RUzJw500OBIYQQmogSExPPqtVVVVU9nZ0lGRmZmZnjtWdPJcJZs2b9QOnAwMDRo0fPj/FAqFqt1mq1KpUqODjYM9EhhBCaeMRiccE4dYe68s1l6/3796enp6emproXicXi119/3WKxNDc379mzZ8WKFWPtRKfT/fnPf+Zerl+/niQn21wGVVVV+/bt+/jjj30dyASTnJz87bffSqVSXwcykWzfvl2lUm3YsMHXgUwkdXV1v/nNb06ePOnrQCaY7OzsysrK+Ph4T78RTd/RXdC+SYQffPDBpk2bRi1Sq9VisRgAKisr16xZk5ubK5PJRq1psVjq6uq4l6tWreLzJ9vtaIODgwaDwTpOd0YFDq1Wa7Va8XO7K0aj0WQy4Yd2V/AXem/0er3FYvHC52a325kfGg5hiA8yR11dnVqtLioqGrWUzYIAUFBQIJFIGhoaFi9ePGrN6OjovXv3eipK/yAUCnk8nsS7c6xMAgRBiMVi/NzuCp/PpygKP7S7IhKJSJLED+1uee0XKhQKR70TZQQf9CW+//77RUVFoaGh3Bqapt0bsJ2dnRqNhnv0AiGEEPIET7UIjxw5Ultb29DQ0NvbazQaCwsLMzIyAMBsNn/88cdHjx51rZyXlzdnzpydO3d+9dVX+/fvv//++61W63vvvVdYWJiYmDjq/oOCgqxWa25urofi9xNarbanp2fSH+a4I0myoKCAx8NH4u5Cc3NzTU3NiN8m+mFGo7GtrQ1/oXfLaDSuXbuWfUzOozQaTXp6+m2reSoRSiSSsLAw7vEJ7oB7e3t37NixcOFC18rr16+Pjo4GgOTk5JSUlMuXL4tEop07dxYWFo61f5VK9eGHH/b393sofoQQQpPAvHnzbluHuJMLiQghhNBkNdmeN0AIIYTuCiZChBBCAQ0TIUIIoYCGiRAhhFBAm2xDsUxcjY2Nf/3rX/v7+x999NG8vDz3CidPnvzmm2+4ly+++OLkG0nnbh05ckStVrPLFEWVlJS419Hr9b///e81Gs3mzZtTUlLcKwSar7/++l//+pfrmpKSEoqiXNeUl5ebTCZ2OS4urri42Hvx+Zn6+vpTp07l5ua6Dgmp1Wp3796t0+m2bNky1rjK77333vnz5x9++OEnnnjCW8H6C71eX1lZabPZnnnmGW6lWq3et2+fRqP5xS9+8eijj7pvVVVVdenSJe6lV09xDPID7JRVUVFR06dPJwhi4cKF7nXmzp3L5/PDh+l0Ou/H6W/i4uIoimI/ELlc7l5hYGBAIpGEhoayH+yhQ4e8H6S/efbZZ7lvEUVRBEGYzeYRdXg8XnBwMFtnwYIFPonTH0gkEnZcko0bN3Ir+/r6xGIxO1sqSZKVlZXuG2ZkZAgEglmzZpEkWVxc7MWQfY/9e5QkSYqiuJUHDhxwPcX97Gc/c98wPT1dIBBwX073r6XnYCL0C01NTWq1ml3+8MMPAaCtrW1Enblz5wbyKWlUcXFxRUVFP1Dh6aefZsdeYBgmOzs7JibGW6FNDHFxcWlpae7reTwe/tHAMMzXX39tt9uDgoJcE+GaNWuCg4PZQSyzsrJiY2NHbHXhwgUAqK2tZRjmL3/5C0EQAwMD3gzbt65evdrS0rJ9+3bXRNjU1HTt2jV2mR0as7Ozc8SG6enpixcv9lqcrvAaoV9ISEjgpmBke1rMZrN7td7e3tLS0mPHjnk1OP/W3NxcWlr61VdfjVr6xRdfZGdns/1+zz33XEdHh3ej82utra2tra0vv/zyqKXV1dW7d+9uaGjwclR+ZdGiRe69c9XV1dz6zZs3t7e3j6hQVlYWEhLCPsf9zDPPkCT5/vvveydgf5CYmBgXFzdiZUJCwvTp09ll9hQ3ODjovm13d3dpaennn3/u6SBHwETod5588km5XO4+thyPx+vq6iovL1++fHl0dLTRaPRJeH6Fz+er1eqysrKcnJwZM2a4j1ir0+m4qV7S0tIA4Pr1614O0m+99NJLEolk1Ot/AoGgoqJi9+7ds2fPHmt8/IBlMBi4E31qairDMCNyYVtbm+tYyiKRqLGx0ash+rennnpKoVBweZHD4/E6OzvLy8vz8/PlcvmomdJDMBH6l8cff/zatWujTm925swZvV7f3d3d1tam1Wqfeuop74fnb7777jutVtvb23vp0qXm5uZf//rXIyowDMPNUikQCAAAZ8zhHD9+PD8/f9QinU7X19d38+bNd95559ChQ7W1tV6OzZ8xDMMNY8t2NlgsFtcKTqfTdcYDkiTtdrs3I/Rnjz32WEtLS3V1tXtRTU0Ne4praWm5efMmN0KnF2Ai9COrVq06duzYqVOnRr25kbuvT6lUpqamut5eFbC4zyQlJSU2Ntb9fB0SEtLZ2ckuX7lyBQDGGsY90Bw+fNhsNr/xxhujlnIf7ObNm/l8/hdffOHF0PxdUFDQjRs32GX2SzWicaNUKg0GA/fSYrHcd9993ozQb61cufLvf//76dOnR73VlvvWTZs2LTk52fUmeU/DROgv1q9ff+jQoZMnTz7wwAPcSqPR2Nra6l75+vXrOEGVK4vF0t3dzfaCOhyOxsZGtps0MzPz3LlzbJ29e/eGh4fjMyes0tLS+Pj4hIQEbk1PT4/7KPb19fUOh2P27Nnejc6vZWRknD17ll3+4IMPIiIi2F6H9vZ2vV4PAKtXr9ZoNGyyrK6uttvtq1ev9mHAfmLdunWHDx/+8ssvXUfBHvUUR9N0c3OzQqHwXnA+uUUHjfDRRx8BQHh4uGrYmTNnGIYpKSnh8XhsnfDw8AceeOCRRx6RyWQ8Hu8///mPT0P2PbPZHBISsmjRooceekgqlQqFwu7uboZhzpw5AwAXL15kGObatWs8Hk+lUi1btowgiD/84Q++jtov6HQ6kiTffPNN15UxMTFz585lGKa8vFwulz/44IOLFy/m8/nx8fE+CtP3nnjiCZVKRZJkWFiYSqU6fvw4wzBXr14lSTI5OTk3N5cgiD/+8Y9sZaFQ+Mtf/pJdjomJmTJlSkFBgUgkyszM9NkB+MKpU6dUKpVMJiMIQqVS5eXlMQyzb98+AJDJZNwp7p///CfDMM899xyfz2c3DAsLy87O5k5xly9f9lrMvFdffdV7WReNwWq1ms3mmTNnKoYtW7YsMjJSIpFIJJKf//znAOB0Ojs6OoxGY1ZWVlVVFXa2kCRpMBhu3LhhtVqXLFlSXV0tk8kAQCgU9vT0FBcXi8Xi8PDw5cuX19fXm0ymnTt3bty40ddR+4XGxkaTybRr1y7XS1k0TS9atGjOnDkKhaK7u7urq4vP569du7aiosKHofrW1atXKYqaPXt2YmKiQqF48MEHFQqFTCZ77LHHLly4MDg4uGvXLu6ZcZ1Ol5+fP2PGDADYuHFjc3Nzc3NzYWHhJ598cieTpE8aRqOxqalp5syZqampCoUiKSlp6dKlVqvVYrG4nuIefvhhmUwmkUiCgoIeeeQRALDb7R0dHSaTKSsr68SJE9xtbl6A0zAhhBAKaHiNECGEUEDDRIgQQiigYSJECCEU0DARIoQQCmiYCBFCCAU0TIQIIYQCGiZChAJXbW0tO+0XQoEMEyFCgevTTz998cUXfR0FQj6GiRAhhFBAw0SIkB9hGKa3t1ej0YxVwW639/T0jDWtz8DAgPvA2RyTydTd3e10Okct7e/vx9mCUGDCRIiQvygrK4uJiYmOjg4PD09LS+PmzQCAhQsXPvvss2+88UZERMTUqVOjo6PLy8tdtz1+/PhPfvKTiIiIyMjI6dOnHz582LW0trZ2wYIFUqlULpdLJJLly5e7ltbU1CQlJUVGRgYHB69YscJsNnv0MBHyN5gIEfILpaWlL7zwwvr16+vr62tqapRK5UMPPXT9+nW2VK/XV1RUHDp06OjRo//+97/z8vK2bNly8OBBtvT06dPLly+fNm3a6dOnz507l5SUVFRUdOLECba0vr5+yZIlRqOxsrLyv//972effeY6wY3JZFq3bt327dsvXLjw2muvHTx4sKyszMvHjpCPeW2eC4TQWPr6+kQi0datW7k1JpNJLpe/8MIL7MvU1FSBQNDa2sq+pGk6NTU1LS2Nfbls2bKoqCiTycS+tFqtsbGx8+bN40plMplGo3F/361btwJAVVUVtyYnJycrK2u8jw8hv4YtQoR87/Tp0xaLRaFQfDmspqYmPj6+oaGBq5ORkREbG8suEwRRWFjY0NDAXtX75ptv8vLyJBIJW0pR1OOPP15XVzc4OGi320+dOlVYWBgaGjrqWwsEgpycHO7lrFmz2tvbPXWcCPklnK0bId/r6ekBgNdee42d65yjUqm45alTp7oWyeVyp9PZ1dUVFRXV29srl8tdSxUKBU3TWq1WKBTabLaYmJix3loqlfL5358H2Po/8nAQmlgwESLke1OmTAGAqqqqrKysseqMuB20t7eXJMmoqCiKogQCwYjSvr4+giCkUilFUXw+n020CKFRYdcoQr63YMECHo/H3fwyqgsXLrhmu6qqqhkzZohEIpIkMzMzq6qqHA4HW0TT9PHjx1NSUoKDgymKmj9//rFjxywWi2ePAaEJCxMhQr4XGxu7adOmt99+u7S0tLW11Ww2X7ly5a233jpw4IBrtTVr1jQ3N2s0mt/+9rdnz54tKSlh17/00kstLS0bNmxob2+/cePGpk2bLl++vG3bNrb01Vdf7ejoKCgouHTp0uDgoFqt3r17t7ePECF/5uu7dRBCDMMwdrt9x44dwcHB3G8zISHhyJEjbGlqauqKFSs2bNjAXkTk8Xjbtm2jaZrbfM+ePWz/KgAEBwe/+eabrjuvqKhwvUz405/+lF2/detWmUzmWnPr1q2RkZEePlaE/AvBMIyXUy9CaCw2m+3y5cs2m02pVLqAE6o4AAAAh0lEQVQ+7ZeWlpaSknLgwIHu7u62trb4+PioqKgR21qt1u+++46m6VmzZonF4hGlNE1fuXLFaDQqlUqlUunxI0Fo4sBEiNAEwCVCXweC0CSE1wgRQggFNHx8AqEJYMeOHeHh4b6OAqHJCbtGEUIIBTTsGkUIIRTQMBEihBAKaJgIEUIIBbT/B3OUZFgm7VJLAAAAAElFTkSuQmCC", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", - "\n", - "\n", - "\n" + "\n", + "\n" + ], + "text/plain": [ + "Plot{Plots.GRBackend() n=2}" ] }, - "execution_count": 24, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1198,7 +1464,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -1244,14 +1510,21 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "\u001b[33mEvaluating over 8 folds: 100%[=========================] Time: 0:00:12\u001b[39m\n" + "\r", + "Evaluating over 8 folds: 25%[======> ] ETA: 0:00:06\u001b[K\r", + "Evaluating over 8 folds: 38%[=========> ] ETA: 0:00:05\u001b[K\r", + "Evaluating over 8 folds: 50%[============> ] ETA: 0:00:04\u001b[K\r", + "Evaluating over 8 folds: 62%[===============> ] ETA: 0:00:03\u001b[K\r", + "Evaluating over 8 folds: 75%[==================> ] ETA: 0:00:02\u001b[K\r", + "Evaluating over 8 folds: 88%[=====================> ] ETA: 0:00:01\u001b[K\r", + "Evaluating over 8 folds: 100%[=========================] Time: 0:00:12\u001b[K\n" ] }, { @@ -1262,16 +1535,16 @@ " per_observation, fitted_params_per_fold,\n", " report_per_fold, train_test_pairs\n", "Extract:\n", - "┌───────────────┬─────────────┬───────────┬─────────────────────────────────────\n", - "│\u001b[22m measure \u001b[0m│\u001b[22m measurement \u001b[0m│\u001b[22m operation \u001b[0m│\u001b[22m per_fold \u001b[0m ⋯\n", - "├───────────────┼─────────────┼───────────┼─────────────────────────────────────\n", - "│ LPLoss(p = 1) │ 2.64 │ predict │ [2.38, 2.8, 2.96, 2.89, 1.81, 2.43 ⋯\n", - "│ LPLoss(p = 2) │ 17.8 │ predict │ [19.8, 24.4, 26.6, 14.4, 6.1, 10.6 ⋯\n", - "└───────────────┴─────────────┴───────────┴─────────────────────────────────────\n", - "\u001b[36m 1 column omitted\u001b[0m\n" + "┌───────────────┬─────────────┬───────────┬─────────────────────────────────────────────────\n", + "│\u001b[22m measure \u001b[0m│\u001b[22m measurement \u001b[0m│\u001b[22m operation \u001b[0m│\u001b[22m per_fold \u001b[0m ⋯\n", + "├───────────────┼─────────────┼───────────┼─────────────────────────────────────────────────\n", + "│ LPLoss(p = 1) │ 2.64 │ predict │ [2.38, 2.8, 2.96, 2.89, 1.81, 2.43, 2.52, 3.29 ⋯\n", + "│ LPLoss(p = 2) │ 17.8 │ predict │ [19.8, 24.4, 26.6, 14.4, 6.1, 10.6, 16.9, 23.7 ⋯\n", + "└───────────────┴─────────────┴───────────┴─────────────────────────────────────────────────\n", + "\u001b[36m 1 column omitted\u001b[0m\n" ] }, - "execution_count": 26, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1284,7 +1557,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -1303,7 +1576,7 @@ "2.64 ± 0.17" ] }, - "execution_count": 27, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1340,90 +1613,33 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "┌ Info: Training Machine{DeterministicIteratedModel{DeterministicPipeline{NamedTuple{,…},…}},…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: final loss: 18.029846309038444\n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/train.jl:44\n", - "┌ Info: final training loss: 0.15870439154333713\n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/train.jl:46\n", - "┌ Info: Stop triggered by NumberSinceBest(6) stopping criterion. \n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/stopping_controls.jl:54\n", - "┌ Info: Total of 13 iterations. \n", - "└ @ MLJIteration /Users/anthony/.julia/packages/MLJIteration/jtWxG/src/core.jl:35\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "import EvoTrees ✔\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "┌ Info: For silent loading, specify `verbosity=0`. \n", - "└ @ Main /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/loading.jl:168\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "import MLJLinearModels ✔" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "┌ Info: For silent loading, specify `verbosity=0`. \n", - "└ @ Main /Users/anthony/.julia/packages/MLJModels/Ci1zC/src/loading.jl:168\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "┌ Info: Training Machine{EvoTreeRegressor{Float64,…},…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: Training Machine{LinearRegressor,…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: Training Machine{DeterministicIteratedModel{DeterministicPipeline{NamedTuple{,…},…}},…}.\n", - "└ @ MLJBase /Users/anthony/.julia/packages/MLJBase/GxHVg/src/machines.jl:464\n", - "┌ Info: final loss: 18.029846309038444\n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/train.jl:44\n", - "┌ Info: final training loss: 0.15870439154333713\n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/train.jl:46\n", - "┌ Info: Stop triggered by NumberSinceBest(6) stopping criterion. \n", - "└ @ IterationControl /Users/anthony/.julia/packages/IterationControl/lO4bA/src/stopping_controls.jl:54\n", - "┌ Info: Total of 13 iterations. \n", - "└ @ MLJIteration /Users/anthony/.julia/packages/MLJIteration/jtWxG/src/core.jl:35\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ + "[ Info: Training Machine{DeterministicIteratedModel{DeterministicPipeline{NamedTuple{,…},…}},…}.\n", + "[ Info: final loss: 18.029846309038444\n", + "[ Info: final training loss: 0.15870439154333713\n", + "[ Info: Stop triggered by NumberSinceBest(6) stopping criterion. \n", + "[ Info: Total of 13 iterations. \n", + "[ Info: For silent loading, specify `verbosity=0`. \n", + "import EvoTrees ✔\n", + "[ Info: For silent loading, specify `verbosity=0`. \n", + "import MLJLinearModels ✔\n", + "[ Info: Training Machine{EvoTreeRegressor{Float64,…},…}.\n", + "[ Info: Training Machine{LinearRegressor,…}.\n", + "[ Info: Training Machine{DeterministicIteratedModel{DeterministicPipeline{NamedTuple{,…},…}},…}.\n", + "[ Info: final loss: 18.029846309038444\n", + "[ Info: final training loss: 0.15870439154333713\n", + "[ Info: Stop triggered by NumberSinceBest(6) stopping criterion. \n", + "[ Info: Total of 13 iterations. \n", "┌────────────────────────────┬────────────────────┐\n", - "│\u001b[1m models \u001b[0m│\u001b[1m mean_square_errors \u001b[0m│\n", - "│\u001b[90m String \u001b[0m│\u001b[90m Float64 \u001b[0m│\n", - "│\u001b[90m Textual \u001b[0m│\u001b[90m Continuous \u001b[0m│\n", + "│ models │ mean_square_errors │\n", + "│ String │ Float64 │\n", + "│ Textual │ Continuous │\n", "├────────────────────────────┼────────────────────┤\n", "│ EvoTreeRegressor │ 3.59326 │\n", "│ LinearRegressor │ 3.56423 │\n", @@ -1460,10 +1676,6 @@ } ], "metadata": { - "@webio": { - "lastCommId": null, - "lastKernelId": null - }, "kernelspec": { "display_name": "Julia 1.6.5", "language": "julia", diff --git a/examples/boston/notebook.jl b/examples/boston/notebook.jl index 6dbdf005..da38986a 100644 --- a/examples/boston/notebook.jl +++ b/examples/boston/notebook.jl @@ -177,7 +177,6 @@ iterated_pipe = IteratedModel(model=pipe, controls=controls, resampling=Holdout(fraction_train=0.8), - iteration_parameter=:(neural_network_regressor.epochs), measure = l2) # Training the wrapped model on all the train/validation data: diff --git a/examples/boston/notebook.unexecuted.ipynb b/examples/boston/notebook.unexecuted.ipynb index 4f9ddc95..4895e2dc 100644 --- a/examples/boston/notebook.unexecuted.ipynb +++ b/examples/boston/notebook.unexecuted.ipynb @@ -456,7 +456,6 @@ " IteratedModel(model=pipe,\n", " controls=controls,\n", " resampling=Holdout(fraction_train=0.8),\n", - " iteration_parameter=:(neural_network_regressor.epochs),\n", " measure = l2)" ], "metadata": {},