From 9ad008739578dbd752dfd44b37195a69b20bc2c8 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Wed, 29 Jan 2025 14:47:30 +0100 Subject: [PATCH 01/56] initial implementation and tests --- Project.toml | 6 +++ src/RxInfer.jl | 1 + src/session.jl | 101 ++++++++++++++++++++++++++++++++++++++++++ test/session_tests.jl | 72 ++++++++++++++++++++++++++++++ 4 files changed, 180 insertions(+) create mode 100644 src/session.jl create mode 100644 test/session_tests.jl diff --git a/Project.toml b/Project.toml index 0e6612d2c..e3b4c7b0c 100644 --- a/Project.toml +++ b/Project.toml @@ -6,6 +6,7 @@ version = "3.10.1" [deps] BayesBase = "b4ee3484-f114-42fe-b91c-797d54a0c67e" DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" DomainSets = "5b8099bc-c8ec-5219-889f-1d9e522a28bf" ExponentialFamily = "62312e5e-252a-4322-ace9-a5f4bf9b357b" @@ -14,6 +15,7 @@ GraphPPL = "b3f8163a-e979-4e85-b43e-1f63d8c8b42c" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" Optim = "429524aa-4258-5aef-a3af-852621145aeb" +Preferences = "21216c6a-2e73-6563-6e65-726566657250" ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" ReactiveMP = "a194aa59-28ba-4574-a09c-4a745416d6e3" @@ -21,6 +23,7 @@ Reexport = "189a3867-3050-52da-a836-e630ba90ab69" Rocket = "df971d30-c9d6-4b37-b8ff-e965b2cb3a40" Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" TupleTools = "9d95972d-f1c8-5527-a6e0-b4b365fa01f6" +UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" [weakdeps] ExponentialFamilyProjection = "17f509fa-9a96-44ba-99b2-1c5f01f0931b" @@ -31,6 +34,7 @@ ProjectionExt = "ExponentialFamilyProjection" [compat] BayesBase = "1.1" DataStructures = "0.18" +Dates = "1.10" Distributions = "0.25" DomainSets = "0.5.2, 0.6, 0.7" ExponentialFamily = "1.5" @@ -40,6 +44,7 @@ GraphPPL = "~4.5.0" LinearAlgebra = "1.9" MacroTools = "0.5.6" Optim = "1.0.0" +Preferences = "1.4.3" ProgressMeter = "1.0.0" Random = "1.9" ReactiveMP = "~4.6.0" @@ -47,6 +52,7 @@ Reexport = "1.2.0" Rocket = "1.8.0" Static = "0.8.10, 1" TupleTools = "1.2.0" +UUIDs = "1.10" julia = "1.10" [extras] diff --git a/src/RxInfer.jl b/src/RxInfer.jl index a8bdd8bc5..84431b2a7 100644 --- a/src/RxInfer.jl +++ b/src/RxInfer.jl @@ -6,6 +6,7 @@ using Reexport include("helpers.jl") include("rocket.jl") +include("session.jl") include("score/actor.jl") include("score/diagnostics.jl") diff --git a/src/session.jl b/src/session.jl new file mode 100644 index 000000000..a7b3d68dd --- /dev/null +++ b/src/session.jl @@ -0,0 +1,101 @@ +using Dates, UUIDs, Preferences + +struct InferInvoke +end + +""" + Session + +A structure that maintains a log of all inference invocations during a RxInfer session. +Each session has a unique identifier and tracks when it was created. The session stores +a history of all inference invocations (`InferInvoke`) that occurred during its lifetime. + +# Fields +- `id::UUID`: A unique identifier for the session +- `created_at::DateTime`: Timestamp when the session was created +- `invokes::Vector{InferInvoke}`: List of all inference invocations that occurred during the session + +The session logging is transparent and only collects non-sensitive information about inference calls. +Users can inspect the session at any time using `get_current_session()` and reset it using `reset_session!()`. +""" +struct Session + id::UUID + created_at::DateTime + invokes::Vector{InferInvoke} +end + +""" + create_session() + +Create a new session with a unique identifier and current timestamp. + +# Returns +- `Session`: A new session instance with no inference invocations recorded +""" +function create_session() + return Session( + uuid4(), # Generate unique ID + now(), # Current timestamp + InferInvoke[] # Empty vector of invokes + ) +end + +session_logging_preference = @load_preference("enable_session_logging", true) + +const default_session_sem = Base.Semaphore(1) + +# See `Preferences.jl` to see how it works, but it should be a compile time choice of a user +@static if session_logging_preference +const default_session_ref = Ref{Union{Nothing, Session}}(create_session()) +else +const default_session_ref = Ref{Union{Nothing, Session}}(nothing) +end + +""" + default_session()::Union{Nothing, Session} + +Get the current default session. If no session exists, returns `nothing`. + +# Returns +- `Union{Nothing, Session}`: The current default session or `nothing` if logging is disabled +""" +function default_session()::Union{Nothing, Session} + return Base.acquire(default_session_sem) do + return default_session_ref[] + end +end + +""" + set_default_session!(session::Union{Nothing, Session}) + +Set the default session to a new session or disable logging by passing `nothing`. + +# Arguments +- `session::Union{Nothing, Session}`: The new session to set as default, or `nothing` to disable logging +""" +function set_default_session!(session::Union{Nothing, Session}) + return Base.acquire(default_session_sem) do + default_session_ref[] = session + return session + end +end + +""" +Disables session logging for RxInfer globally at compile time and saves it in package preferences. Has effect after Julia restart. + +Restart Julia and verify it by `isnothing(RxInfer.default_session())`. + +Note that session logging still can be enabled manually for the current session if `set_default_session!` is called manually with appropriate `Session` object. +""" +function disable_session_logging!() + @set_preferences!("enable_session_logging" => false) +end + +""" +Enables session logging for RxInfer globally at compile time and saves it in package preferences. Has effect after Julia restart. + +Restart Julia and verify it by `!isnothing(RxInfer.default_session())`. +""" +function enable_session_logging!() + @set_preferences!("enable_session_logging" => true) +end \ No newline at end of file diff --git a/test/session_tests.jl b/test/session_tests.jl new file mode 100644 index 000000000..450c44ae1 --- /dev/null +++ b/test/session_tests.jl @@ -0,0 +1,72 @@ + +@testitem "Session can be created" begin + session = RxInfer.create_session() + + @test hasproperty(session, :id) + @test hasproperty(session, :created_at) + @test hasproperty(session, :invokes) + + # Empty session has no invokes + @test length(session.invokes) == 0 +end + +@testitem "RxInfer should have a default session" begin + default_session = RxInfer.default_session() + + @test hasproperty(default_session, :id) + @test hasproperty(default_session, :created_at) + @test hasproperty(default_session, :invokes) +end + +@testitem "It should be possible to change the default session" begin + original_default_session = RxInfer.default_session() + new_session = RxInfer.create_session() + + RxInfer.set_default_session!(new_session) + + new_default_session = RxInfer.default_session() + + @test new_default_session != original_default_session + @test new_default_session.id != original_default_session.id + @test new_default_session.created_at > original_default_session.created_at +end + +@testitem "Session Logging basic execution" begin + + # Create a simple model for testing + @model function simple_model() + x ~ Normal(0.0, 1.0) + y ~ Normal(x, 1.0) + return y + end + + # Create test data + test_data = (y = 1.0,) + + session = RxInfer.create_session() + + # Run inference inside session `session` + result = infer( + model = simple_model(), + data = test_data, + session = session + ) + + # Basic checks + @test length(session_after.invokes) == 1 + + # Check the latest invoke + latest_invoke = session_after.invokes[end] + @test !isempty(latest_invoke.id) + @test latest_invoke.status == :success + @test latest_invoke.execution_time > 0.0 + @test hasproperty(latest_invoke.context, :model) + @test hasproperty(latest_invoke.context, :data) + @test length(latest_invoke.context.data) === 1 + + # Check saved properties of the passed data `y` + saved_data_properties = latest_invoke.context.data[end] + @test saved_data_properties.name === :y + @test saved_data_properties.type === Int + @test saved_data_properties.length === 1 +end \ No newline at end of file From e59e1aee16c4969e2e3731128d8d1807ae263e5c Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Wed, 29 Jan 2025 15:28:13 +0100 Subject: [PATCH 02/56] add more tests for logging data entries --- src/session.jl | 27 +++++++ test/session_tests.jl | 184 +++++++++++++++++++++++++++++++++++++++--- 2 files changed, 202 insertions(+), 9 deletions(-) diff --git a/src/session.jl b/src/session.jl index a7b3d68dd..a67ab85a5 100644 --- a/src/session.jl +++ b/src/session.jl @@ -1,5 +1,32 @@ using Dates, UUIDs, Preferences +struct InferInvokeDataEntry + name + type + size + elsize +end + +# Very safe by default, logging should not crash if we don't know how to parse the data entry +log_data_entry(data) = InferInvokeDataEntry(:unknown, :unknown, :unknown, :unknown) +log_data_entry(data::Pair) = log_data_entry(first(data), last(data)) + +log_data_entry(name::Union{Symbol, String}, data) = log_data_entry(name, Base.IteratorSize(data), data) +log_data_entry(name::Union{Symbol, String}, _, data) = InferInvokeDataEntry(name, typeof(data), :unknown, :unknown) +log_data_entry(name::Union{Symbol, String}, ::Base.HasShape{0}, data) = InferInvokeDataEntry(name, typeof(data), (), ()) +log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = InferInvokeDataEntry(name, typeof(data), size(data), isempty(data) ? () : size(first(data))) + +# Julia has `Base.HasLength` by default, which is quite bad because it fallbacks here +# for structures that has nothing to do with being iterators, we are safe here +# and simply return :unknown +log_data_entry(name::Union{Symbol, String}, ::Base.HasLength, data) = InferInvokeDataEntry(name, typeof(data), :unknown, :unknown) + +# Very safe by default, logging should not crash if we don't know how to parse the data entry +log_data_entries(data) = :unknown + +log_data_entries(data::Union{NamedTuple, Dict}) = log_data_entries_from_pairs(pairs(data)) +log_data_entries_from_pairs(pairs) = collect(Iterators.map(log_data_entry, pairs)) + struct InferInvoke end diff --git a/test/session_tests.jl b/test/session_tests.jl index 450c44ae1..73a5a926b 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -1,5 +1,4 @@ - -@testitem "Session can be created" begin +@testitem "Session can be created" begin session = RxInfer.create_session() @test hasproperty(session, :id) @@ -10,7 +9,7 @@ @test length(session.invokes) == 0 end -@testitem "RxInfer should have a default session" begin +@testitem "RxInfer should have a default session" begin default_session = RxInfer.default_session() @test hasproperty(default_session, :id) @@ -18,7 +17,7 @@ end @test hasproperty(default_session, :invokes) end -@testitem "It should be possible to change the default session" begin +@testitem "It should be possible to change the default session" begin original_default_session = RxInfer.default_session() new_session = RxInfer.create_session() @@ -31,6 +30,177 @@ end @test new_default_session.created_at > original_default_session.created_at end +@testitem "log_data_entry" begin + import RxInfer: log_data_entry + + @testset "Scalar values" begin + let entry = log_data_entry(:y => 1) + @test entry.name === :y + @test entry.type === Int + @test entry.size === () + @test entry.elsize === () + end + + let entry = log_data_entry(:x => 3.14) + @test entry.name === :x + @test entry.type === Float64 + @test entry.size === () + @test entry.elsize === () + end + end + + @testset "Vectors" begin + let entry = log_data_entry(:x => [1]) + @test entry.name === :x + @test entry.type === Vector{Int} + @test entry.size === (1,) + @test entry.elsize === () + end + + let entry = log_data_entry(:x => [1.0, 2.0, 3.0]) + @test entry.name === :x + @test entry.type === Vector{Float64} + @test entry.size === (3,) + @test entry.elsize === () + end + + let entry = log_data_entry(:x => [[1, 2], [3, 4]]) + @test entry.name === :x + @test entry.type === Vector{Vector{Int}} + @test entry.size === (2,) + @test entry.elsize === (2,) + end + end + + @testset "Matrices" begin + let entry = log_data_entry(:x => ones(2, 3)) + @test entry.name === :x + @test entry.type === Matrix{Float64} + @test entry.size === (2, 3) + @test entry.elsize === () + end + + let entry = log_data_entry(:x => reshape([1, 2, 3, 4], 2, 2)) + @test entry.name === :x + @test entry.type === Matrix{Int} + @test entry.size === (2, 2) + @test entry.elsize === () + end + end + + @testset "Matrix of vectors" begin + let data = Matrix{Vector{Float64}}(undef, 2, 2) + data[1, 1] = [1.0, 2.0] + data[1, 2] = [3.0, 4.0] + data[2, 1] = [5.0, 6.0] + data[2, 2] = [7.0, 8.0] + entry = log_data_entry(:x => data) + @test entry.name === :x + @test entry.type === Matrix{Vector{Float64}} + @test entry.size === (2, 2) + @test entry.elsize === (2,) + end + end + + struct StrangeDataEntry end + + @testset let entry = log_data_entry(StrangeDataEntry) + @test entry.name === :unknown + @test entry.type === :unknown + @test entry.size === :unknown + @test entry.elsize === :unknown + end +end + +@testitem "log_data_entries" begin + import RxInfer: log_data_entry, log_data_entries + + @testset "Named tuple entries" begin + data = (y = 1, x = [2.0, 3.0], z = [[1.0, 2.0], [3.0]]) + entries = log_data_entries(data) + + @test length(entries) === 3 + + # Check y entry + y_entry = entries[1] + @test y_entry.name === :y + @test y_entry.type === Int + @test y_entry.size === () + @test y_entry.elsize === () + + # Check x entry + x_entry = entries[2] + @test x_entry.name === :x + @test x_entry.type === Vector{Float64} + @test x_entry.size === (2,) + @test x_entry.elsize === () + + # Check z entry + z_entry = entries[3] + @test z_entry.name === :z + @test z_entry.type === Vector{Vector{Float64}} + @test z_entry.size === (2,) + @test z_entry.elsize === (2,) + end + + @testset "Dictionary entries" begin + data = Dict(:y => 1, :x => [2.0, 3.0], :z => [[1.0, 2.0], [3.0]]) + entries = log_data_entries(data) + + @test length(entries) === 3 + @test Set(entry.name for entry in entries) == Set([:x, :y, :z]) + + # Find and check y entry + y_entry = findfirst(e -> e.name === :y, entries) + @test !isnothing(y_entry) + y_entry = entries[y_entry] + @test y_entry.type === Int + @test y_entry.size === () + @test y_entry.elsize === () + + # Find and check x entry + x_entry = findfirst(e -> e.name === :x, entries) + @test !isnothing(x_entry) + x_entry = entries[x_entry] + @test x_entry.type === Vector{Float64} + @test x_entry.size === (2,) + @test x_entry.elsize === () + + # Find and check z entry + z_entry = findfirst(e -> e.name === :z, entries) + @test !isnothing(z_entry) + z_entry = entries[z_entry] + @test z_entry.type === Vector{Vector{Float64}} + @test z_entry.size === (2,) + @test z_entry.elsize === (2,) + end + + struct UnknownStruct end + @test log_data_entries(UnknownStruct()) == :unknown # be safe on something we don't know how to parse + + @testset "data with UnknownStructs as elements" begin + data = (y = UnknownStruct(), x = UnknownStruct()) + + entries = log_data_entries(data) + + @test length(entries) === 2 + + # Check y entry + y_entry = entries[1] + @test y_entry.name === :y + @test y_entry.type === UnknownStruct + @test y_entry.size === :unknown + @test y_entry.elsize === :unknown + + # Check x entry + x_entry = entries[2] + @test x_entry.name === :x + @test x_entry.type === UnknownStruct + @test x_entry.size === :unknown + @test x_entry.elsize === :unknown + end +end + @testitem "Session Logging basic execution" begin # Create a simple model for testing @@ -46,11 +216,7 @@ end session = RxInfer.create_session() # Run inference inside session `session` - result = infer( - model = simple_model(), - data = test_data, - session = session - ) + result = infer(model = simple_model(), data = test_data, session = session) # Basic checks @test length(session_after.invokes) == 1 From 44b2e28efaf75c9be57448ffd2f8d53d12bab8c3 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 13:55:26 +0100 Subject: [PATCH 03/56] save version info of the machine --- src/session.jl | 21 ++++++++++++++++----- test/session_tests.jl | 15 +++++++++++++++ 2 files changed, 31 insertions(+), 5 deletions(-) diff --git a/src/session.jl b/src/session.jl index a67ab85a5..f6fbf065c 100644 --- a/src/session.jl +++ b/src/session.jl @@ -17,8 +17,8 @@ log_data_entry(name::Union{Symbol, String}, ::Base.HasShape{0}, data) = InferInv log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = InferInvokeDataEntry(name, typeof(data), size(data), isempty(data) ? () : size(first(data))) # Julia has `Base.HasLength` by default, which is quite bad because it fallbacks here -# for structures that has nothing to do with being iterators, we are safe here -# and simply return :unknown +# for structures that has nothing to do with being iterators nor implement `length`, +# Better to be safe here and simply return :unknown log_data_entry(name::Union{Symbol, String}, ::Base.HasLength, data) = InferInvokeDataEntry(name, typeof(data), :unknown, :unknown) # Very safe by default, logging should not crash if we don't know how to parse the data entry @@ -41,6 +41,7 @@ a history of all inference invocations (`InferInvoke`) that occurred during its - `id::UUID`: A unique identifier for the session - `created_at::DateTime`: Timestamp when the session was created - `invokes::Vector{InferInvoke}`: List of all inference invocations that occurred during the session +- `versioninfo::Dict{Symbol, Any}`: Information about the Julia version and system when the session was created The session logging is transparent and only collects non-sensitive information about inference calls. Users can inspect the session at any time using `get_current_session()` and reset it using `reset_session!()`. @@ -49,6 +50,7 @@ struct Session id::UUID created_at::DateTime invokes::Vector{InferInvoke} + versioninfo::Dict{Symbol, Any} end """ @@ -60,10 +62,19 @@ Create a new session with a unique identifier and current timestamp. - `Session`: A new session instance with no inference invocations recorded """ function create_session() + vinfo = Dict{Symbol, Any}( + :julia_version => string(VERSION), + :os => string(Sys.KERNEL), + :machine => string(Sys.MACHINE), + :cpu_threads => Sys.CPU_THREADS, + :word_size => Sys.WORD_SIZE + ) + return Session( - uuid4(), # Generate unique ID - now(), # Current timestamp - InferInvoke[] # Empty vector of invokes + uuid4(), # Generate unique ID + now(), # Current timestamp + InferInvoke[], # Empty vector of invokes + vinfo # Version information ) end diff --git a/test/session_tests.jl b/test/session_tests.jl index 73a5a926b..4048df9e1 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -4,9 +4,24 @@ @test hasproperty(session, :id) @test hasproperty(session, :created_at) @test hasproperty(session, :invokes) + @test hasproperty(session, :versioninfo) # Empty session has no invokes @test length(session.invokes) == 0 + + # Version info should contain all required fields + @test haskey(session.versioninfo, :julia_version) + @test haskey(session.versioninfo, :os) + @test haskey(session.versioninfo, :machine) + @test haskey(session.versioninfo, :cpu_threads) + @test haskey(session.versioninfo, :word_size) + + # Version info should have correct types and values + @test session.versioninfo[:julia_version] == string(VERSION) + @test session.versioninfo[:os] == string(Sys.KERNEL) + @test session.versioninfo[:machine] == string(Sys.MACHINE) + @test session.versioninfo[:cpu_threads] == Sys.CPU_THREADS + @test session.versioninfo[:word_size] == Sys.WORD_SIZE end @testitem "RxInfer should have a default session" begin From 94f8a89239d8297e94e035a518b895564065e644 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 15:08:16 +0100 Subject: [PATCH 04/56] add session code to the infer function --- Project.toml | 6 +- src/RxInfer.jl | 9 +++ src/inference/inference.jl | 128 ++++++++++++++++++++++--------------- src/session.jl | 35 +++++----- test/session_tests.jl | 68 +++++++++++++------- 5 files changed, 151 insertions(+), 95 deletions(-) diff --git a/Project.toml b/Project.toml index e3b4c7b0c..ce31116bc 100644 --- a/Project.toml +++ b/Project.toml @@ -40,7 +40,7 @@ DomainSets = "0.5.2, 0.6, 0.7" ExponentialFamily = "1.5" ExponentialFamilyProjection = "1.1" FastCholesky = "1.3.0" -GraphPPL = "~4.5.0" +GraphPPL = "~4.6.0" LinearAlgebra = "1.9" MacroTools = "0.5.6" Optim = "1.0.0" @@ -51,6 +51,7 @@ ReactiveMP = "~4.6.0" Reexport = "1.2.0" Rocket = "1.8.0" Static = "0.8.10, 1" +TOML = "1.0.3" TupleTools = "1.2.0" UUIDs = "1.10" julia = "1.10" @@ -76,6 +77,7 @@ StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" StatsFuns = "4c63d2b9-4356-54db-8cca-17b64c39e42c" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" TestSetExtensions = "98d24dd4-01ad-11ea-1b02-c9a08f80db04" +TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76" [targets] -test = ["Test", "Pkg", "Logging", "InteractiveUtils", "TestSetExtensions", "Coverage", "CpuId", "Dates", "Distributed", "Documenter", "ExponentialFamilyProjection", "Plots", "BenchmarkCI", "BenchmarkTools", "PkgBenchmark", "Aqua", "StableRNGs", "StatsFuns", "Optimisers", "ReTestItems"] +test = ["Test", "Pkg", "Logging", "InteractiveUtils", "TestSetExtensions", "TOML", "Coverage", "CpuId", "Dates", "Distributed", "Documenter", "ExponentialFamilyProjection", "Plots", "BenchmarkCI", "BenchmarkTools", "PkgBenchmark", "Aqua", "StableRNGs", "StatsFuns", "Optimisers", "ReTestItems"] diff --git a/src/RxInfer.jl b/src/RxInfer.jl index 84431b2a7..e72409f51 100644 --- a/src/RxInfer.jl +++ b/src/RxInfer.jl @@ -25,4 +25,13 @@ include("constraints/form/form_sample_list.jl") include("inference/postprocess.jl") include("inference/inference.jl") +preference_enable_session_logging = @load_preference("enable_session_logging", true) + +function __init__() + if RxInfer.preference_enable_session_logging + default_session = create_session() + RxInfer.set_default_session!(default_session) + end +end + end diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 71081fb06..2fed5121e 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -9,7 +9,7 @@ import GraphPPL: ModelGenerator, create_model import ReactiveMP: israndom, isdata, isconst import ReactiveMP: CountingReal -import ProgressMeter +import ProgressMeter, Dates, UUIDs obtain_prediction(variable::Any) = getprediction(variable) obtain_prediction(variables::AbstractArray) = getpredictions(variables) @@ -282,6 +282,7 @@ Check the official documentation for more information about some of the argument - `uselock = false`: specifies either to use the lock structure for the inference or not, if set to true uses `Base.Threads.SpinLock`. Accepts custom `AbstractLock`. (exclusive for streamline inference) - `autostart = true`: specifies whether to call `RxInfer.start` on the created engine automatically or not (exclusive for streamline inference) - `warn = true`: enables/disables warnings +- `session = RxInfer.default_session()`: current logging session for the RxInfer invokes, see `Session` for more details, pass `nothing` to disable logging """ function infer(; @@ -311,7 +312,8 @@ function infer(; events = nothing, # streamline specific uselock = false, # streamline specific autostart = true, # streamline specific - warn = true + warn = true, + session = RxInfer.default_session() ) if isnothing(model) error("The `model` keyword argument is required for the `infer` function.") @@ -330,55 +332,77 @@ function infer(; infer_check_dicttype(:callbacks, callbacks) infer_check_dicttype(:data, data) - if isnothing(autoupdates) - check_available_callbacks(warn, callbacks, available_callbacks(batch_inference)) - check_available_events(warn, events, available_events(batch_inference)) - batch_inference( - model = model, - data = data, - initialization = initialization, - constraints = constraints, - meta = meta, - options = options, - returnvars = returnvars, - predictvars = predictvars, - iterations = iterations, - free_energy = free_energy, - free_energy_diagnostics = free_energy_diagnostics, - allow_node_contraction = allow_node_contraction, - showprogress = showprogress, - callbacks = callbacks, - addons = addons, - postprocess = postprocess, - warn = warn, - catch_exception = catch_exception - ) - else - check_available_callbacks(warn, callbacks, available_callbacks(streaming_inference)) - check_available_events(warn, events, available_events(streaming_inference)) - streaming_inference( - model = model, - data = data, - datastream = datastream, - autoupdates = autoupdates, - initialization = initialization, - constraints = constraints, - meta = meta, - options = options, - returnvars = returnvars, - historyvars = historyvars, - keephistory = keephistory, - iterations = iterations, - free_energy = free_energy, - free_energy_diagnostics = free_energy_diagnostics, - allow_node_contraction = allow_node_contraction, - autostart = autostart, - callbacks = callbacks, - addons = addons, - postprocess = postprocess, - warn = warn, - events = events, - uselock = uselock - ) + try + status = :unknown + execution_start = Dates.now() + if isnothing(autoupdates) + check_available_callbacks(warn, callbacks, available_callbacks(batch_inference)) + check_available_events(warn, events, available_events(batch_inference)) + batch_inference( + model = model, + data = data, + initialization = initialization, + constraints = constraints, + meta = meta, + options = options, + returnvars = returnvars, + predictvars = predictvars, + iterations = iterations, + free_energy = free_energy, + free_energy_diagnostics = free_energy_diagnostics, + allow_node_contraction = allow_node_contraction, + showprogress = showprogress, + callbacks = callbacks, + addons = addons, + postprocess = postprocess, + warn = warn, + catch_exception = catch_exception + ) + else + check_available_callbacks(warn, callbacks, available_callbacks(streaming_inference)) + check_available_events(warn, events, available_events(streaming_inference)) + streaming_inference( + model = model, + data = data, + datastream = datastream, + autoupdates = autoupdates, + initialization = initialization, + constraints = constraints, + meta = meta, + options = options, + returnvars = returnvars, + historyvars = historyvars, + keephistory = keephistory, + iterations = iterations, + free_energy = free_energy, + free_energy_diagnostics = free_energy_diagnostics, + allow_node_contraction = allow_node_contraction, + autostart = autostart, + callbacks = callbacks, + addons = addons, + postprocess = postprocess, + warn = warn, + events = events, + uselock = uselock + ) + end + catch e + status = :failed + rethrow(e) + finally + execution_end = Dates.now() + status = :success + if !isnothing(session) + infer_id = UUIDs.uuid4() + infer_invoke = InferInvoke( + infer_id, + status, + execution_start, + execution_end, + GraphPPL.getsource(model), + RxInfer.log_data_entries(data) + ) + push!(session.invokes, infer_invoke) + end end end diff --git a/src/session.jl b/src/session.jl index f6fbf065c..7f792db97 100644 --- a/src/session.jl +++ b/src/session.jl @@ -11,7 +11,7 @@ end log_data_entry(data) = InferInvokeDataEntry(:unknown, :unknown, :unknown, :unknown) log_data_entry(data::Pair) = log_data_entry(first(data), last(data)) -log_data_entry(name::Union{Symbol, String}, data) = log_data_entry(name, Base.IteratorSize(data), data) +log_data_entry(name::Union{Symbol, String}, data) = log_data_entry(name, Base.IteratorSize(data), data) log_data_entry(name::Union{Symbol, String}, _, data) = InferInvokeDataEntry(name, typeof(data), :unknown, :unknown) log_data_entry(name::Union{Symbol, String}, ::Base.HasShape{0}, data) = InferInvokeDataEntry(name, typeof(data), (), ()) log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = InferInvokeDataEntry(name, typeof(data), size(data), isempty(data) ? () : size(first(data))) @@ -27,7 +27,13 @@ log_data_entries(data) = :unknown log_data_entries(data::Union{NamedTuple, Dict}) = log_data_entries_from_pairs(pairs(data)) log_data_entries_from_pairs(pairs) = collect(Iterators.map(log_data_entry, pairs)) -struct InferInvoke +struct InferInvoke + id::UUID + status::Symbol + execution_start::DateTime + execution_end::DateTime + model + data end """ @@ -40,8 +46,8 @@ a history of all inference invocations (`InferInvoke`) that occurred during its # Fields - `id::UUID`: A unique identifier for the session - `created_at::DateTime`: Timestamp when the session was created +- `environment::Dict{Symbol, Any}`: Information about the Julia & RxInfer versions and system when the session was created - `invokes::Vector{InferInvoke}`: List of all inference invocations that occurred during the session -- `versioninfo::Dict{Symbol, Any}`: Information about the Julia version and system when the session was created The session logging is transparent and only collects non-sensitive information about inference calls. Users can inspect the session at any time using `get_current_session()` and reset it using `reset_session!()`. @@ -49,8 +55,8 @@ Users can inspect the session at any time using `get_current_session()` and rese struct Session id::UUID created_at::DateTime + environment::Dict{Symbol, Any} invokes::Vector{InferInvoke} - versioninfo::Dict{Symbol, Any} end """ @@ -62,32 +68,25 @@ Create a new session with a unique identifier and current timestamp. - `Session`: A new session instance with no inference invocations recorded """ function create_session() - vinfo = Dict{Symbol, Any}( + environment = Dict{Symbol, Any}( :julia_version => string(VERSION), + :rxinfer_version => string(pkgversion(RxInfer)), :os => string(Sys.KERNEL), :machine => string(Sys.MACHINE), :cpu_threads => Sys.CPU_THREADS, - :word_size => Sys.WORD_SIZE + :word_size => Sys.WORD_SIZE, ) - return Session( - uuid4(), # Generate unique ID + uuid4(), # Generate unique ID now(), # Current timestamp - InferInvoke[], # Empty vector of invokes - vinfo # Version information + environment, # Environment information + InferInvoke[] # Empty vector of invokes ) end -session_logging_preference = @load_preference("enable_session_logging", true) - const default_session_sem = Base.Semaphore(1) - -# See `Preferences.jl` to see how it works, but it should be a compile time choice of a user -@static if session_logging_preference -const default_session_ref = Ref{Union{Nothing, Session}}(create_session()) -else +# The `Ref` is initialized in the __init__ function based on user preferences const default_session_ref = Ref{Union{Nothing, Session}}(nothing) -end """ default_session()::Union{Nothing, Session} diff --git a/test/session_tests.jl b/test/session_tests.jl index 4048df9e1..6f3a5bf4e 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -1,27 +1,34 @@ @testitem "Session can be created" begin + using TOML + session = RxInfer.create_session() @test hasproperty(session, :id) @test hasproperty(session, :created_at) @test hasproperty(session, :invokes) - @test hasproperty(session, :versioninfo) + @test hasproperty(session, :environment) # Empty session has no invokes @test length(session.invokes) == 0 # Version info should contain all required fields - @test haskey(session.versioninfo, :julia_version) - @test haskey(session.versioninfo, :os) - @test haskey(session.versioninfo, :machine) - @test haskey(session.versioninfo, :cpu_threads) - @test haskey(session.versioninfo, :word_size) + @test haskey(session.environment, :julia_version) + @test haskey(session.environment, :rxinfer_version) + @test haskey(session.environment, :os) + @test haskey(session.environment, :machine) + @test haskey(session.environment, :cpu_threads) + @test haskey(session.environment, :word_size) # Version info should have correct types and values - @test session.versioninfo[:julia_version] == string(VERSION) - @test session.versioninfo[:os] == string(Sys.KERNEL) - @test session.versioninfo[:machine] == string(Sys.MACHINE) - @test session.versioninfo[:cpu_threads] == Sys.CPU_THREADS - @test session.versioninfo[:word_size] == Sys.WORD_SIZE + @test session.environment[:julia_version] == string(VERSION) + @test session.environment[:os] == string(Sys.KERNEL) + @test session.environment[:machine] == string(Sys.MACHINE) + @test session.environment[:cpu_threads] == Sys.CPU_THREADS + @test session.environment[:word_size] == Sys.WORD_SIZE + + rxinfer_version = + VersionNumber(TOML.parsefile(joinpath(pkgdir(RxInfer), "Project.toml"))["version"]) + @test session.environment[:rxinfer_version] == string(rxinfer_version) end @testitem "RxInfer should have a default session" begin @@ -29,7 +36,11 @@ end @test hasproperty(default_session, :id) @test hasproperty(default_session, :created_at) + @test hasproperty(default_session, :environment) @test hasproperty(default_session, :invokes) + + # Check second invokation doesn't change the return value + @test default_session === RxInfer.default_session() end @testitem "It should be possible to change the default session" begin @@ -219,35 +230,46 @@ end @testitem "Session Logging basic execution" begin # Create a simple model for testing - @model function simple_model() - x ~ Normal(0.0, 1.0) - y ~ Normal(x, 1.0) - return y + @model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) end # Create test data test_data = (y = 1.0,) - session = RxInfer.create_session() - # Run inference inside session `session` - result = infer(model = simple_model(), data = test_data, session = session) + result = infer(model = simple_model(), data = test_data) - # Basic checks - @test length(session_after.invokes) == 1 + session = RxInfer.default_session() + + # Basic checks, other tests may have produced more invokes here + @test length(session.invokes) >= 1 # Check the latest invoke - latest_invoke = session_after.invokes[end] + latest_invoke = session.invokes[end] @test !isempty(latest_invoke.id) @test latest_invoke.status == :success - @test latest_invoke.execution_time > 0.0 + @test latest_invoke.execution_end > latest_invoke.execution_start @test hasproperty(latest_invoke.context, :model) @test hasproperty(latest_invoke.context, :data) + @test !isnothing(latest_invoke.context.data) + @test latest_invoke.context.model == """ + function simple_model(y) + x ~ Normal(0.0, 1.0) + y ~ Normal(x, 1.0) + end""" @test length(latest_invoke.context.data) === 1 # Check saved properties of the passed data `y` saved_data_properties = latest_invoke.context.data[end] @test saved_data_properties.name === :y @test saved_data_properties.type === Int - @test saved_data_properties.length === 1 + + custom_session = RxInfer.create_session() + result = infer(model = simple_model(), data = test_data, session = session) + + @test length(custom_session.invokes) === 1 + @test latest_invoke.id != custom_session.invokes[1].id + @test latest_invoke.context == custom_session.invokes[1].context end \ No newline at end of file From f9be6adcefac9395cd490d9648b63c414372c58c Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 16:09:28 +0100 Subject: [PATCH 05/56] a bit of refactoring --- src/inference/inference.jl | 57 ++++--- src/session.jl | 92 ++++++----- test/inference/inference_tests.jl | 218 +++++++++++++++++++++++++++ test/session_tests.jl | 243 ++++-------------------------- 4 files changed, 344 insertions(+), 266 deletions(-) diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 2fed5121e..385f56a26 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -84,6 +84,35 @@ function check_and_reset_updated!(updates) end end +## Logging utilities + +struct InferenceLoggedDataEntry + name + type + size + elsize +end + +# Very safe by default, logging should not crash if we don't know how to parse the data entry +log_data_entry(data) = InferenceLoggedDataEntry(:unknown, :unknown, :unknown, :unknown) +log_data_entry(data::Pair) = log_data_entry(first(data), last(data)) + +log_data_entry(name::Union{Symbol, String}, data) = log_data_entry(name, Base.IteratorSize(data), data) +log_data_entry(name::Union{Symbol, String}, _, data) = InferenceLoggedDataEntry(name, typeof(data), :unknown, :unknown) +log_data_entry(name::Union{Symbol, String}, ::Base.HasShape{0}, data) = InferenceLoggedDataEntry(name, typeof(data), (), ()) +log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = InferenceLoggedDataEntry(name, typeof(data), size(data), isempty(data) ? () : size(first(data))) + +# Julia has `Base.HasLength` by default, which is quite bad because it fallbacks here +# for structures that has nothing to do with being iterators nor implement `length`, +# Better to be safe here and simply return :unknown +log_data_entry(name::Union{Symbol, String}, ::Base.HasLength, data) = InferenceLoggedDataEntry(name, typeof(data), :unknown, :unknown) + +# Very safe by default, logging should not crash if we don't know how to parse the data entry +log_data_entries(data) = :unknown + +log_data_entries(data::Union{NamedTuple, Dict}) = log_data_entries_from_pairs(pairs(data)) +log_data_entries_from_pairs(pairs) = collect(Iterators.map(log_data_entry, pairs)) + ## Extra error handling function inference_process_error(error) @@ -332,9 +361,13 @@ function infer(; infer_check_dicttype(:callbacks, callbacks) infer_check_dicttype(:data, data) - try - status = :unknown - execution_start = Dates.now() + return with_session(session) do invoke + + append_invoke_context(invoke) do ctx + ctx[:model] = GraphPPL.getsource(model) + ctx[:data] = log_data_entries(data) + end + if isnothing(autoupdates) check_available_callbacks(warn, callbacks, available_callbacks(batch_inference)) check_available_events(warn, events, available_events(batch_inference)) @@ -386,23 +419,5 @@ function infer(; uselock = uselock ) end - catch e - status = :failed - rethrow(e) - finally - execution_end = Dates.now() - status = :success - if !isnothing(session) - infer_id = UUIDs.uuid4() - infer_invoke = InferInvoke( - infer_id, - status, - execution_start, - execution_end, - GraphPPL.getsource(model), - RxInfer.log_data_entries(data) - ) - push!(session.invokes, infer_invoke) - end end end diff --git a/src/session.jl b/src/session.jl index 7f792db97..818a919f0 100644 --- a/src/session.jl +++ b/src/session.jl @@ -1,39 +1,11 @@ using Dates, UUIDs, Preferences -struct InferInvokeDataEntry - name - type - size - elsize -end - -# Very safe by default, logging should not crash if we don't know how to parse the data entry -log_data_entry(data) = InferInvokeDataEntry(:unknown, :unknown, :unknown, :unknown) -log_data_entry(data::Pair) = log_data_entry(first(data), last(data)) - -log_data_entry(name::Union{Symbol, String}, data) = log_data_entry(name, Base.IteratorSize(data), data) -log_data_entry(name::Union{Symbol, String}, _, data) = InferInvokeDataEntry(name, typeof(data), :unknown, :unknown) -log_data_entry(name::Union{Symbol, String}, ::Base.HasShape{0}, data) = InferInvokeDataEntry(name, typeof(data), (), ()) -log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = InferInvokeDataEntry(name, typeof(data), size(data), isempty(data) ? () : size(first(data))) - -# Julia has `Base.HasLength` by default, which is quite bad because it fallbacks here -# for structures that has nothing to do with being iterators nor implement `length`, -# Better to be safe here and simply return :unknown -log_data_entry(name::Union{Symbol, String}, ::Base.HasLength, data) = InferInvokeDataEntry(name, typeof(data), :unknown, :unknown) - -# Very safe by default, logging should not crash if we don't know how to parse the data entry -log_data_entries(data) = :unknown - -log_data_entries(data::Union{NamedTuple, Dict}) = log_data_entries_from_pairs(pairs(data)) -log_data_entries_from_pairs(pairs) = collect(Iterators.map(log_data_entry, pairs)) - -struct InferInvoke +mutable struct SessionInvoke id::UUID status::Symbol execution_start::DateTime execution_end::DateTime - model - data + context::Dict{Symbol, Any} end """ @@ -41,22 +13,22 @@ end A structure that maintains a log of all inference invocations during a RxInfer session. Each session has a unique identifier and tracks when it was created. The session stores -a history of all inference invocations (`InferInvoke`) that occurred during its lifetime. +a history of all session invocations (`SessionInvoke`) that occurred during its lifetime. # Fields - `id::UUID`: A unique identifier for the session - `created_at::DateTime`: Timestamp when the session was created - `environment::Dict{Symbol, Any}`: Information about the Julia & RxInfer versions and system when the session was created -- `invokes::Vector{InferInvoke}`: List of all inference invocations that occurred during the session +- `invokes::Vector{SessionInvoke}`: List of all inference invocations that occurred during the session -The session logging is transparent and only collects non-sensitive information about inference calls. +The session logging is transparent and only collects non-sensitive information about calls. Users can inspect the session at any time using `get_current_session()` and reset it using `reset_session!()`. """ struct Session id::UUID created_at::DateTime environment::Dict{Symbol, Any} - invokes::Vector{InferInvoke} + invokes::Vector{SessionInvoke} end """ @@ -80,10 +52,60 @@ function create_session() uuid4(), # Generate unique ID now(), # Current timestamp environment, # Environment information - InferInvoke[] # Empty vector of invokes + SessionInvoke[] # Empty vector of invokes ) end +""" + with_session(f::F, session) where {F} + +Execute function `f` within a session context. If `session` is provided, logs execution details including timing and errors. +If `session` is `nothing`, executes `f` without logging. +""" +function with_session(f::F, session) where {F} + if isnothing(session) + return f(nothing) + elseif session isa Session + invoke_id = uuid4() + invoke_status = :unknown + invoke_context = Dict{Symbol, Any}() + invoke_execution_start = Dates.now() + invoke_execution_end = Dates.now() + invoke = SessionInvoke( + invoke_id, + invoke_status, + invoke_execution_start, + invoke_execution_end, + invoke_context + ) + try + result = f(invoke) + invoke.status = :success + invoke.execution_end = Dates.now() + push!(session.invokes, invoke) + return result + catch e + invoke.status = :failed + invoke.context[:error] = string(e) + push!(session.invokes, invoke) + rethrow(e) + end + else + error(lazy"Unsupported session type $(typeof(session)). Should either be `RxInfer.Session` or `nothing`.") + end +end + +""" + append_invoke_context(f, invoke) + +Append context information to a session invoke. If `invoke` is a `SessionInvoke`, executes function `f` with the invoke's context. +If `invoke` is `nothing`, does nothing. +""" +function append_invoke_context end + +append_invoke_context(f::F, ::Nothing) where {F} = nothing +append_invoke_context(f::F, invoke::SessionInvoke) where {F} = f(invoke.context) + const default_session_sem = Base.Semaphore(1) # The `Ref` is initialized in the __init__ function based on user preferences const default_session_ref = Ref{Union{Nothing, Session}}(nothing) diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index f37bee5ff..ab67e1569 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -47,6 +47,177 @@ end end end +@testitem "log_data_entry" begin + import RxInfer: log_data_entry + + @testset "Scalar values" begin + let entry = log_data_entry(:y => 1) + @test entry.name === :y + @test entry.type === Int + @test entry.size === () + @test entry.elsize === () + end + + let entry = log_data_entry(:x => 3.14) + @test entry.name === :x + @test entry.type === Float64 + @test entry.size === () + @test entry.elsize === () + end + end + + @testset "Vectors" begin + let entry = log_data_entry(:x => [1]) + @test entry.name === :x + @test entry.type === Vector{Int} + @test entry.size === (1,) + @test entry.elsize === () + end + + let entry = log_data_entry(:x => [1.0, 2.0, 3.0]) + @test entry.name === :x + @test entry.type === Vector{Float64} + @test entry.size === (3,) + @test entry.elsize === () + end + + let entry = log_data_entry(:x => [[1, 2], [3, 4]]) + @test entry.name === :x + @test entry.type === Vector{Vector{Int}} + @test entry.size === (2,) + @test entry.elsize === (2,) + end + end + + @testset "Matrices" begin + let entry = log_data_entry(:x => ones(2, 3)) + @test entry.name === :x + @test entry.type === Matrix{Float64} + @test entry.size === (2, 3) + @test entry.elsize === () + end + + let entry = log_data_entry(:x => reshape([1, 2, 3, 4], 2, 2)) + @test entry.name === :x + @test entry.type === Matrix{Int} + @test entry.size === (2, 2) + @test entry.elsize === () + end + end + + @testset "Matrix of vectors" begin + let data = Matrix{Vector{Float64}}(undef, 2, 2) + data[1, 1] = [1.0, 2.0] + data[1, 2] = [3.0, 4.0] + data[2, 1] = [5.0, 6.0] + data[2, 2] = [7.0, 8.0] + entry = log_data_entry(:x => data) + @test entry.name === :x + @test entry.type === Matrix{Vector{Float64}} + @test entry.size === (2, 2) + @test entry.elsize === (2,) + end + end + + struct StrangeDataEntry end + + @testset let entry = log_data_entry(StrangeDataEntry) + @test entry.name === :unknown + @test entry.type === :unknown + @test entry.size === :unknown + @test entry.elsize === :unknown + end +end + +@testitem "log_data_entries" begin + import RxInfer: log_data_entry, log_data_entries + + @testset "Named tuple entries" begin + data = (y = 1, x = [2.0, 3.0], z = [[1.0, 2.0], [3.0]]) + entries = log_data_entries(data) + + @test length(entries) === 3 + + # Check y entry + y_entry = entries[1] + @test y_entry.name === :y + @test y_entry.type === Int + @test y_entry.size === () + @test y_entry.elsize === () + + # Check x entry + x_entry = entries[2] + @test x_entry.name === :x + @test x_entry.type === Vector{Float64} + @test x_entry.size === (2,) + @test x_entry.elsize === () + + # Check z entry + z_entry = entries[3] + @test z_entry.name === :z + @test z_entry.type === Vector{Vector{Float64}} + @test z_entry.size === (2,) + @test z_entry.elsize === (2,) + end + + @testset "Dictionary entries" begin + data = Dict(:y => 1, :x => [2.0, 3.0], :z => [[1.0, 2.0], [3.0]]) + entries = log_data_entries(data) + + @test length(entries) === 3 + @test Set(entry.name for entry in entries) == Set([:x, :y, :z]) + + # Find and check y entry + y_entry = findfirst(e -> e.name === :y, entries) + @test !isnothing(y_entry) + y_entry = entries[y_entry] + @test y_entry.type === Int + @test y_entry.size === () + @test y_entry.elsize === () + + # Find and check x entry + x_entry = findfirst(e -> e.name === :x, entries) + @test !isnothing(x_entry) + x_entry = entries[x_entry] + @test x_entry.type === Vector{Float64} + @test x_entry.size === (2,) + @test x_entry.elsize === () + + # Find and check z entry + z_entry = findfirst(e -> e.name === :z, entries) + @test !isnothing(z_entry) + z_entry = entries[z_entry] + @test z_entry.type === Vector{Vector{Float64}} + @test z_entry.size === (2,) + @test z_entry.elsize === (2,) + end + + struct UnknownStruct end + @test log_data_entries(UnknownStruct()) == :unknown # be safe on something we don't know how to parse + + @testset "data with UnknownStructs as elements" begin + data = (y = UnknownStruct(), x = UnknownStruct()) + + entries = log_data_entries(data) + + @test length(entries) === 2 + + # Check y entry + y_entry = entries[1] + @test y_entry.name === :y + @test y_entry.type === UnknownStruct + @test y_entry.size === :unknown + @test y_entry.elsize === :unknown + + # Check x entry + x_entry = entries[2] + @test x_entry.name === :x + @test x_entry.type === UnknownStruct + @test x_entry.size === :unknown + @test x_entry.elsize === :unknown + end +end + @testitem "Static inference with `inference`" begin # A simple model for testing that resembles a simple kalman filter with @@ -1019,3 +1190,50 @@ end ) @test probvec(last(last(result.predictions[:y]))) ≈ [0, 0, 1, 0] end + +@testitem "Session Logging basic execution" begin + + # Create a simple model for testing + @model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) + end + + # Create test data + test_data = (y = 1.0,) + + # Run inference inside session `session` + result = infer(model = simple_model(), data = test_data) + + session = RxInfer.default_session() + + # Basic checks, other tests may have produced more invokes here + @test length(session.invokes) >= 1 + + # Check the latest invoke + latest_invoke = session.invokes[end] + @test hasproperty(latest_invoke, :id) + @test latest_invoke.status == :success + @test latest_invoke.execution_end > latest_invoke.execution_start + @test haskey(latest_invoke.context, :model) + @test haskey(latest_invoke.context, :data) + @test !isnothing(latest_invoke.context[:data]) + @test latest_invoke.context[:model] == """ + function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) + end""" + @test length(latest_invoke.context[:data]) === 1 + + # Check saved properties of the passed data `y` + saved_data_properties = latest_invoke.context[:data][end] + @test saved_data_properties.name === :y + @test saved_data_properties.type === Float64 + + custom_session = RxInfer.create_session() + result = infer(model = simple_model(), data = test_data, session = custom_session) + + @test length(custom_session.invokes) === 1 + @test latest_invoke.id != custom_session.invokes[1].id + @test latest_invoke.context == custom_session.invokes[1].context +end \ No newline at end of file diff --git a/test/session_tests.jl b/test/session_tests.jl index 6f3a5bf4e..73a359399 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -26,9 +26,11 @@ @test session.environment[:cpu_threads] == Sys.CPU_THREADS @test session.environment[:word_size] == Sys.WORD_SIZE - rxinfer_version = - VersionNumber(TOML.parsefile(joinpath(pkgdir(RxInfer), "Project.toml"))["version"]) - @test session.environment[:rxinfer_version] == string(rxinfer_version) + if get(ENV, "CI", "false") === "true" + # This test breaks precompilation in VSCode, thus disabled locally, executes only in CI + rxinfer_version = VersionNumber(TOML.parsefile(joinpath(pkgdir(RxInfer), "Project.toml"))["version"]) + @test session.environment[:rxinfer_version] == string(rxinfer_version) + end end @testitem "RxInfer should have a default session" begin @@ -56,220 +58,41 @@ end @test new_default_session.created_at > original_default_session.created_at end -@testitem "log_data_entry" begin - import RxInfer: log_data_entry - - @testset "Scalar values" begin - let entry = log_data_entry(:y => 1) - @test entry.name === :y - @test entry.type === Int - @test entry.size === () - @test entry.elsize === () - end - - let entry = log_data_entry(:x => 3.14) - @test entry.name === :x - @test entry.type === Float64 - @test entry.size === () - @test entry.elsize === () - end - end - - @testset "Vectors" begin - let entry = log_data_entry(:x => [1]) - @test entry.name === :x - @test entry.type === Vector{Int} - @test entry.size === (1,) - @test entry.elsize === () - end - - let entry = log_data_entry(:x => [1.0, 2.0, 3.0]) - @test entry.name === :x - @test entry.type === Vector{Float64} - @test entry.size === (3,) - @test entry.elsize === () - end - - let entry = log_data_entry(:x => [[1, 2], [3, 4]]) - @test entry.name === :x - @test entry.type === Vector{Vector{Int}} - @test entry.size === (2,) - @test entry.elsize === (2,) - end - end - - @testset "Matrices" begin - let entry = log_data_entry(:x => ones(2, 3)) - @test entry.name === :x - @test entry.type === Matrix{Float64} - @test entry.size === (2, 3) - @test entry.elsize === () - end - - let entry = log_data_entry(:x => reshape([1, 2, 3, 4], 2, 2)) - @test entry.name === :x - @test entry.type === Matrix{Int} - @test entry.size === (2, 2) - @test entry.elsize === () +@testitem "Log session should save the context" begin + session = RxInfer.create_session() + result = RxInfer.with_session(session) do invoke + RxInfer.append_invoke_context(invoke) do ctx + ctx[:a] = 1 + ctx[:b] = 2 end + return 3 end - - @testset "Matrix of vectors" begin - let data = Matrix{Vector{Float64}}(undef, 2, 2) - data[1, 1] = [1.0, 2.0] - data[1, 2] = [3.0, 4.0] - data[2, 1] = [5.0, 6.0] - data[2, 2] = [7.0, 8.0] - entry = log_data_entry(:x => data) - @test entry.name === :x - @test entry.type === Matrix{Vector{Float64}} - @test entry.size === (2, 2) - @test entry.elsize === (2,) + @test length(session.invokes) === 1 + last_invoke = session.invokes[end] + @test last_invoke.context[:a] === 1 + @test last_invoke.context[:b] === 2 + @test result === 3 + + result = RxInfer.with_session(nothing) do invoke + RxInfer.append_invoke_context(invoke) do ctx + ctx[:a] = 1 + ctx[:b] = 2 end + return 4 end - - struct StrangeDataEntry end - - @testset let entry = log_data_entry(StrangeDataEntry) - @test entry.name === :unknown - @test entry.type === :unknown - @test entry.size === :unknown - @test entry.elsize === :unknown - end + @test result === 4 end -@testitem "log_data_entries" begin - import RxInfer: log_data_entry, log_data_entries - - @testset "Named tuple entries" begin - data = (y = 1, x = [2.0, 3.0], z = [[1.0, 2.0], [3.0]]) - entries = log_data_entries(data) - - @test length(entries) === 3 - - # Check y entry - y_entry = entries[1] - @test y_entry.name === :y - @test y_entry.type === Int - @test y_entry.size === () - @test y_entry.elsize === () - - # Check x entry - x_entry = entries[2] - @test x_entry.name === :x - @test x_entry.type === Vector{Float64} - @test x_entry.size === (2,) - @test x_entry.elsize === () - - # Check z entry - z_entry = entries[3] - @test z_entry.name === :z - @test z_entry.type === Vector{Vector{Float64}} - @test z_entry.size === (2,) - @test z_entry.elsize === (2,) - end - - @testset "Dictionary entries" begin - data = Dict(:y => 1, :x => [2.0, 3.0], :z => [[1.0, 2.0], [3.0]]) - entries = log_data_entries(data) - - @test length(entries) === 3 - @test Set(entry.name for entry in entries) == Set([:x, :y, :z]) - - # Find and check y entry - y_entry = findfirst(e -> e.name === :y, entries) - @test !isnothing(y_entry) - y_entry = entries[y_entry] - @test y_entry.type === Int - @test y_entry.size === () - @test y_entry.elsize === () - - # Find and check x entry - x_entry = findfirst(e -> e.name === :x, entries) - @test !isnothing(x_entry) - x_entry = entries[x_entry] - @test x_entry.type === Vector{Float64} - @test x_entry.size === (2,) - @test x_entry.elsize === () - - # Find and check z entry - z_entry = findfirst(e -> e.name === :z, entries) - @test !isnothing(z_entry) - z_entry = entries[z_entry] - @test z_entry.type === Vector{Vector{Float64}} - @test z_entry.size === (2,) - @test z_entry.elsize === (2,) - end - - struct UnknownStruct end - @test log_data_entries(UnknownStruct()) == :unknown # be safe on something we don't know how to parse - - @testset "data with UnknownStructs as elements" begin - data = (y = UnknownStruct(), x = UnknownStruct()) - - entries = log_data_entries(data) - - @test length(entries) === 2 - - # Check y entry - y_entry = entries[1] - @test y_entry.name === :y - @test y_entry.type === UnknownStruct - @test y_entry.size === :unknown - @test y_entry.elsize === :unknown - - # Check x entry - x_entry = entries[2] - @test x_entry.name === :x - @test x_entry.type === UnknownStruct - @test x_entry.size === :unknown - @test x_entry.elsize === :unknown +@testitem "Log session should save errors if any" begin + session = RxInfer.create_session() + @test_throws "I'm an error" RxInfer.with_session(session) do invoke + error("I'm an error") end -end + @test length(session.invokes) === 1 + last_invoke = session.invokes[end] + @test last_invoke.context[:error] == "ErrorException(\"I'm an error\")" -@testitem "Session Logging basic execution" begin - - # Create a simple model for testing - @model function simple_model(y) - x ~ Normal(mean = 0.0, var = 1.0) - y ~ Normal(mean = x, var = 1.0) + @test_throws "I'm an error" RxInfer.with_session(nothing) do invoke + error("I'm an error") end - - # Create test data - test_data = (y = 1.0,) - - # Run inference inside session `session` - result = infer(model = simple_model(), data = test_data) - - session = RxInfer.default_session() - - # Basic checks, other tests may have produced more invokes here - @test length(session.invokes) >= 1 - - # Check the latest invoke - latest_invoke = session.invokes[end] - @test !isempty(latest_invoke.id) - @test latest_invoke.status == :success - @test latest_invoke.execution_end > latest_invoke.execution_start - @test hasproperty(latest_invoke.context, :model) - @test hasproperty(latest_invoke.context, :data) - @test !isnothing(latest_invoke.context.data) - @test latest_invoke.context.model == """ - function simple_model(y) - x ~ Normal(0.0, 1.0) - y ~ Normal(x, 1.0) - end""" - @test length(latest_invoke.context.data) === 1 - - # Check saved properties of the passed data `y` - saved_data_properties = latest_invoke.context.data[end] - @test saved_data_properties.name === :y - @test saved_data_properties.type === Int - - custom_session = RxInfer.create_session() - result = infer(model = simple_model(), data = test_data, session = session) - - @test length(custom_session.invokes) === 1 - @test latest_invoke.id != custom_session.invokes[1].id - @test latest_invoke.context == custom_session.invokes[1].context end \ No newline at end of file From c7eb92b28f0d35b484da6a1e0f4afa8b0dd6ddaf Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 16:17:53 +0100 Subject: [PATCH 06/56] add a bit of documentation --- docs/make.jl | 1 + docs/src/manuals/session_logging.md | 256 ++++++++++++++++++++++++++++ src/inference/inference.jl | 1 - 3 files changed, 257 insertions(+), 1 deletion(-) create mode 100644 docs/src/manuals/session_logging.md diff --git a/docs/make.jl b/docs/make.jl index b52d5384f..12a75ccd5 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -41,6 +41,7 @@ makedocs(; "Inference specification" => ["Overview" => "manuals/inference/overview.md", "Static inference" => "manuals/inference/static.md", "Streamline inference" => "manuals/inference/streamlined.md", "Initialization" => "manuals/inference/initialization.md", "Auto-updates" => "manuals/inference/autoupdates.md", "Deterministic nodes" => "manuals/inference/delta-node.md", "Non-conjugate inference" => "manuals/inference/nonconjugate.md", "Undefined message update rules" => "manuals/inference/undefinedrules.md"], "Inference customization" => ["Defining a custom node and rules" => "manuals/customization/custom-node.md", "Inference results postprocessing" => "manuals/customization/postprocess.md"], "Debugging" => "manuals/debugging.md", + "Session logging" => "manuals/session_logging.md", "Migration from v2 to v3" => "manuals/migration-guide-v2-v3.md", "Sharp bits of RxInfer" => ["Overview" => "manuals/sharpbits/overview.md", "Rule Not Found Error" => "manuals/sharpbits/rule-not-found.md", "Stack Overflow in Message Computations" => "manuals/sharpbits/stack-overflow-inference.md", "Using `=` instead of `:=` for deterministic nodes" => "manuals/sharpbits/usage-colon-equality.md"] ], diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md new file mode 100644 index 000000000..5cf888f8c --- /dev/null +++ b/docs/src/manuals/session_logging.md @@ -0,0 +1,256 @@ +# Session Logging + +RxInfer provides a built-in session logging system that helps track and analyze inference invocations. This feature is particularly useful for debugging, performance monitoring, and understanding the behavior of your inference models. + +## Overview + +Session logging in RxInfer automatically captures: +- Model source code +- Input data characteristics and metadata +- Execution timing +- Success/failure status +- Error information (if any) +- Environment information (Julia version, OS, etc.) + +## Basic Usage + +By default, RxInfer creates and maintains a global session that logs all inference invocations: + +```@example basic-session +using RxInfer + +# Define a simple model +@model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) +end + +# Run inference with default session logging +result = infer( + model = simple_model(), + data = (y = 1.0,) +) + +# Access the current session +session = RxInfer.default_session() + +# Show the number of logged invocations +println("Number of invokes: $(length(session.invokes))") +``` + +!!! note + The number of logged invocations may be different from the number of invocations in the example above + since the session is created and logged at the start of the documentation build. + +You can also create and use custom sessions: + +```@example custom-session +using RxInfer + +@model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) +end + +# Create a custom session +session = RxInfer.create_session() + +# Run inference with custom session +result = infer( + model = simple_model(), + data = (y = 1.0,), + session = session +) + +println("Session ID: $(session.id)") +println("Created at: $(session.created_at)") +``` + +## Session Structure + +A session consists of the following components: + +### Session Fields +- `id::UUID`: Unique identifier for the session +- `created_at::DateTime`: Session creation timestamp +- `environment::Dict{Symbol, Any}`: System and environment information +- `invokes::Vector{SessionInvoke}`: List of inference invocations + +### Environment Information +The session automatically captures system information including: +- Julia version +- RxInfer version +- Operating system +- Machine architecture +- CPU threads +- System word size + +### Invoke Information +Each inference invocation (`SessionInvoke`) captures: +- `id::UUID`: Unique identifier for the invocation +- `status::Symbol`: Status of the invocation (`:success`, `:failed`, or `:unknown`) +- `execution_start::DateTime`: Start timestamp +- `execution_end::DateTime`: End timestamp +- `context::Dict{Symbol, Any}`: Contextual information about the invocation + +## Accessing Session Data + +You can inspect session data to analyze inference behavior: + +```@example inspect-session +using RxInfer + +@model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) +end + +session = RxInfer.create_session() +result = infer(model = simple_model(), data = (y = 1.0,), session = session) + +# Get the latest invoke +latest_invoke = session.invokes[end] + +# Check invocation status +println("Status: $(latest_invoke.status)") + +# Calculate execution duration +duration = latest_invoke.execution_end - latest_invoke.execution_start +println("Duration: $duration") + +# Access model source +println("Model source: $(latest_invoke.context[:model])") + +# Examine data properties +for entry in latest_invoke.context[:data] + println("\nData variable: $(entry.name)") + println("Type: $(entry.type)") + println("Size: $(entry.size)") +end +``` + +## Configuration + +### Enabling/Disabling Logging + +Session logging can be enabled or disabled globally: + +```@example config-session +using RxInfer + +# Disable session logging (takes effect after Julia restart) +RxInfer.disable_session_logging!() + +# Enable session logging (takes effect after Julia restart) +RxInfer.enable_session_logging!() +``` + +You can also disable logging for specific inference calls: + +```@example disable-session +using RxInfer + +@model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) +end + +# Run inference without logging +result = infer( + model = simple_model(), + data = (y = 1.0,), + session = nothing +) +``` + +### Managing Sessions + +```@example manage-session +using RxInfer + +# Create a new session +new_session = RxInfer.create_session() + +# Set as default session +RxInfer.set_default_session!(new_session) + +# Clear default session +RxInfer.set_default_session!(nothing) +``` + +## Best Practices + +1. **Error Handling**: Session logging automatically captures errors, making it easier to debug issues: +```@example error-handling +using RxInfer + +@model function problematic_model(y) + x ~ Normal(mean = 0.0, var = -1.0) # Invalid variance + y ~ Normal(mean = x, var = 1.0) +end + +try + result = infer(model = problematic_model(), data = (y = 1.0,)) +catch e + # Check the latest invoke for error details + latest_invoke = RxInfer.default_session().invokes[end] + println("Status: $(latest_invoke.status)") + println("Error: $(latest_invoke.context[:error])") +end +``` + +2. **Performance Monitoring**: Use session data to monitor inference performance: +```@example performance +using RxInfer, Statistics + +@model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) +end + +session = RxInfer.create_session() + +# Run multiple inferences +for i in 1:5 + infer(model = simple_model(), data = (y = randn(),), session = session) +end + +durations = map(session.invokes) do invoke + invoke.execution_end - invoke.execution_start +end + +println("Mean duration: $(mean(durations))") +println("Std duration: $(std(durations))") +``` + +3. **Data Validation**: Session logging helps track data characteristics: +```@example validation +using RxInfer + +@model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) +end + +session = RxInfer.create_session() +result = infer(model = simple_model(), data = (y = [1.0, 2.0],), session = session) + +for entry in session.invokes[end].context[:data] + println("Variable '$(entry.name)' size: $(entry.size)") +end +``` + +## Thread Safety + +The session logging system is thread-safe, using a semaphore to protect access to the default session: + +```@example thread-safety +using RxInfer + +# Thread-safe access to default session +session = RxInfer.default_session() + +# Thread-safe session update +new_session = RxInfer.create_session() +RxInfer.set_default_session!(new_session) +``` \ No newline at end of file diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 385f56a26..d37f69744 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -362,7 +362,6 @@ function infer(; infer_check_dicttype(:data, data) return with_session(session) do invoke - append_invoke_context(invoke) do ctx ctx[:model] = GraphPPL.getsource(model) ctx[:data] = log_data_entries(data) From 79618b6bcd28257ce8f9fef30fba1fbcdcba1f04 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 17:23:45 +0100 Subject: [PATCH 07/56] adjust docs --- docs/src/manuals/session_logging.md | 99 ++++++++++++++-------- src/inference/inference.jl | 54 +++++++++++- src/session.jl | 123 +++++++++++++++++++++++----- test/inference/inference_tests.jl | 92 ++++++++++++++++++++- 4 files changed, 305 insertions(+), 63 deletions(-) diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index 5cf888f8c..e59594c59 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -1,6 +1,6 @@ # Session Logging -RxInfer provides a built-in session logging system that helps track and analyze inference invocations. This feature is particularly useful for debugging, performance monitoring, and understanding the behavior of your inference models. +RxInfer provides a built-in session logging system that helps track and analyze various aspects of RxInfer usages. This feature is particularly useful for debugging, performance monitoring, and understanding the behavior of your inference models. ## Overview @@ -131,40 +131,30 @@ end ## Configuration -### Enabling/Disabling Logging - -Session logging can be enabled or disabled globally: +### Default Session -```@example config-session -using RxInfer +The default session is created automatically when RxInfer is first imported. It is used for logging all inference invocations by default. -# Disable session logging (takes effect after Julia restart) -RxInfer.disable_session_logging!() - -# Enable session logging (takes effect after Julia restart) -RxInfer.enable_session_logging!() +```@docs +RxInfer.default_session ``` -You can also disable logging for specific inference calls: - -```@example disable-session -using RxInfer +### Enabling/Disabling Logging -@model function simple_model(y) - x ~ Normal(mean = 0.0, var = 1.0) - y ~ Normal(mean = x, var = 1.0) -end +Session logging can be enabled or disabled globally -# Run inference without logging -result = infer( - model = simple_model(), - data = (y = 1.0,), - session = nothing -) +```@docs +RxInfer.disable_session_logging! +RxInfer.enable_session_logging! ``` ### Managing Sessions +```@docs +RxInfer.create_session +RxInfer.set_default_session! +``` + ```@example manage-session using RxInfer @@ -240,17 +230,56 @@ for entry in session.invokes[end].context[:data] end ``` -## Thread Safety +## Session Statistics -The session logging system is thread-safe, using a semaphore to protect access to the default session: +RxInfer automatically collects statistics about inference runs. You can view these statistics at any time to understand how your inference tasks are performing. -```@example thread-safety -using RxInfer +!!! note + Session statistics below are collected during the documentation build. -# Thread-safe access to default session -session = RxInfer.default_session() +## Viewing Statistics -# Thread-safe session update -new_session = RxInfer.create_session() -RxInfer.set_default_session!(new_session) -``` \ No newline at end of file +The main function for viewing session statistics is `summarize_session`: + +```@docs +RxInfer.summarize_session +``` + +```@example session-stats +using RxInfer #hide +RxInfer.summarize_session() +``` + +The summary includes: +- Total number of inference invocations and success rate +- Execution time statistics (mean, min, max) +- List of context keys present +- Number of unique models used +- Table of most recent invocations showing: + - Status (success/failed) + - Duration in milliseconds + - Model name + - Data variables used + +## Programmatic Access + +If you need to access the statistics programmatically, use `get_session_stats`: + +```@docs +RxInfer.get_session_stats +``` + +```@example session-stats +using RxInfer #hide +RxInfer.get_session_stats() +``` + +# Developers reference + + +```@docs +RxInfer.Session +RxInfer.with_session +RxInfer.create_invoke +RxInfer.append_invoke_context +``` \ No newline at end of file diff --git a/src/inference/inference.jl b/src/inference/inference.jl index d37f69744..a6a1687a9 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -100,7 +100,11 @@ log_data_entry(data::Pair) = log_data_entry(first(data), last(data)) log_data_entry(name::Union{Symbol, String}, data) = log_data_entry(name, Base.IteratorSize(data), data) log_data_entry(name::Union{Symbol, String}, _, data) = InferenceLoggedDataEntry(name, typeof(data), :unknown, :unknown) log_data_entry(name::Union{Symbol, String}, ::Base.HasShape{0}, data) = InferenceLoggedDataEntry(name, typeof(data), (), ()) -log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = InferenceLoggedDataEntry(name, typeof(data), size(data), isempty(data) ? () : size(first(data))) +log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = InferenceLoggedDataEntry(name, typeof(data), log_data_entry_size(data), isempty(data) ? () : log_data_entry_size(first(data))) + +log_data_entry_size(data) = log_data_entry_size(Base.IteratorSize(data), data) +log_data_entry_size(::Base.HasShape, data) = size(data) +log_data_entry_size(_, data) = () # Julia has `Base.HasLength` by default, which is quite bad because it fallbacks here # for structures that has nothing to do with being iterators nor implement `length`, @@ -113,6 +117,46 @@ log_data_entries(data) = :unknown log_data_entries(data::Union{NamedTuple, Dict}) = log_data_entries_from_pairs(pairs(data)) log_data_entries_from_pairs(pairs) = collect(Iterators.map(log_data_entry, pairs)) +function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) + # Count unique models + unique_models = length(unique(get(i.context, :model, nothing) for i in invokes)) + + println(io, "\nInference specific:") + println(io, " Unique models: $unique_models") + + # Show last N invokes in a table format + if !isempty(invokes) + println(io, "\nLast $n_last invokes:") + println(io, "┌──────────┬──────────┬───────────────────────────┬─────────────┐") + println(io, "│ Status │ Duration │ Model │ Data │") + println(io, "├──────────┼──────────┼───────────────────────────┼─────────────┤") + + for invoke in Iterators.take(Iterators.reverse(invokes), n_last) + status = invoke.status + duration = round(Dates.value(invoke.execution_end - invoke.execution_start) / 1000.0, digits=2) + model = get(invoke.context, :model_name, nothing) + model = model === nothing ? "N/A" : string(model) + model = length(model) > 25 ? model[1:23] * ".." : model + + data_entries = get(invoke.context, :data, nothing) + data_str = if data_entries === nothing || isempty(data_entries) + "N/A" + else + join(map(e -> string(e.name), data_entries), ",") + end + data_str = length(data_str) > 9 ? data_str[1:7] * ".." : data_str + + status_str = rpad(status, 8) + duration_str = rpad("$(duration)ms", 8) + model_str = rpad(model, 25) + data_str = rpad(data_str, 9) + + println(io, "│ $(status_str)│ $(duration_str)│ $(model_str)│ $(data_str)│") + end + println(io, "└──────────┴──────────┴───────────────────────────┴─────────────┘") + end +end + ## Extra error handling function inference_process_error(error) @@ -274,7 +318,8 @@ include("streaming.jl") events = nothing, uselock = false, autostart = true, - catch_exception = false + catch_exception = false, + session = RxInfer.default_session() ) This function provides a generic way to perform probabilistic inference for batch/static and streamline/online scenarios. @@ -361,9 +406,10 @@ function infer(; infer_check_dicttype(:callbacks, callbacks) infer_check_dicttype(:data, data) - return with_session(session) do invoke + return with_session(session, :inference) do invoke append_invoke_context(invoke) do ctx - ctx[:model] = GraphPPL.getsource(model) + ctx[:model_name] = string(GraphPPL.getmodel(model)) + ctx[:model_source] = GraphPPL.getsource(model) ctx[:data] = log_data_entries(data) end diff --git a/src/session.jl b/src/session.jl index 818a919f0..ffbfd6a16 100644 --- a/src/session.jl +++ b/src/session.jl @@ -1,7 +1,8 @@ using Dates, UUIDs, Preferences -mutable struct SessionInvoke +mutable struct SessionInvoke id::UUID + label::Symbol status::Symbol execution_start::DateTime execution_end::DateTime @@ -46,7 +47,7 @@ function create_session() :os => string(Sys.KERNEL), :machine => string(Sys.MACHINE), :cpu_threads => Sys.CPU_THREADS, - :word_size => Sys.WORD_SIZE, + :word_size => Sys.WORD_SIZE ) return Session( uuid4(), # Generate unique ID @@ -57,40 +58,38 @@ function create_session() end """ - with_session(f::F, session) where {F} + create_invoke(label::Symbol) -Execute function `f` within a session context. If `session` is provided, logs execution details including timing and errors. +Create a new session invoke with the given label. +""" +function create_invoke(label::Symbol) + return SessionInvoke(uuid4(), label, :unknown, Dates.now(), Dates.now(), Dict{Symbol, Any}()) +end + +""" + with_session(f::F, session, label::Symbol = :unknown) where {F} + +Execute function `f` within a session context with the specified label. If `session` is provided, logs execution details including timing and errors. If `session` is `nothing`, executes `f` without logging. """ -function with_session(f::F, session) where {F} +function with_session(f::F, session, label::Symbol = :unknown) where {F} if isnothing(session) return f(nothing) elseif session isa Session - invoke_id = uuid4() - invoke_status = :unknown - invoke_context = Dict{Symbol, Any}() - invoke_execution_start = Dates.now() - invoke_execution_end = Dates.now() - invoke = SessionInvoke( - invoke_id, - invoke_status, - invoke_execution_start, - invoke_execution_end, - invoke_context - ) - try + invoke = create_invoke(label) + try result = f(invoke) invoke.status = :success invoke.execution_end = Dates.now() push!(session.invokes, invoke) return result - catch e + catch e invoke.status = :failed invoke.context[:error] = string(e) push!(session.invokes, invoke) rethrow(e) end - else + else error(lazy"Unsupported session type $(typeof(session)). Should either be `RxInfer.Session` or `nothing`.") end end @@ -101,14 +100,14 @@ end Append context information to a session invoke. If `invoke` is a `SessionInvoke`, executes function `f` with the invoke's context. If `invoke` is `nothing`, does nothing. """ -function append_invoke_context end +function append_invoke_context end append_invoke_context(f::F, ::Nothing) where {F} = nothing append_invoke_context(f::F, invoke::SessionInvoke) where {F} = f(invoke.context) const default_session_sem = Base.Semaphore(1) # The `Ref` is initialized in the __init__ function based on user preferences -const default_session_ref = Ref{Union{Nothing, Session}}(nothing) +const default_session_ref = Ref{Union{Nothing, Session}}(nothing) """ default_session()::Union{Nothing, Session} @@ -157,4 +156,84 @@ Restart Julia and verify it by `!isnothing(RxInfer.default_session())`. """ function enable_session_logging!() @set_preferences!("enable_session_logging" => true) +end + +""" + summarize_session([io::IO], session::Session, label::Symbol = :inference; n_last = 5) + +Print a concise summary of session statistics for invokes with the specified label. +The default label is `:inference` which gathers statistics of the `infer` function calls. +""" +summarize_session(session::Session = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) = summarize_session(stdout, session, label; n_last = n_last) + +function summarize_session(io::IO, session::Session = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) + + stats = get_session_stats(session, label) + filtered_invokes = filter(i -> i.label === label, session.invokes) + + println(io, "\nSession Summary (label: $label)") + println(io, "Total invokes: $(stats.total_invokes)") + println(io, "Success rate: $(round(stats.success_rate * 100, digits=1))%") + println(io, "Failed invokes: $(stats.failed_invokes)") + println(io, "\nExecution time (ms):") + println(io, " Mean: $(round(stats.mean_duration_ms, digits=2))") + println(io, " Min: $(round(stats.min_duration_ms, digits=2))") + println(io, " Max: $(round(stats.max_duration_ms, digits=2))") + println(io, "\nContext keys: $(join(stats.context_keys, ", "))") + + if stats.total_invokes == 0 + println(io, "\nNo invokes found with label: $label") + return nothing + end + + # Call label-specific summary with n_last parameter + summarize_invokes(io, Val(label), filtered_invokes; n_last = n_last) + + return nothing +end + +""" + get_session_stats(session::Session, label::Symbol = :unknown) + +Return a NamedTuple with key session statistics for invokes with the specified label. + +# Returns +- `total_invokes`: Total number of invokes with the given label +- `success_rate`: Fraction of successful invokes (between 0 and 1) +- `failed_invokes`: Number of failed invokes +- `mean_duration_ms`: Mean execution time in milliseconds +- `min_duration_ms`: Minimum execution time in milliseconds +- `max_duration_ms`: Maximum execution time in milliseconds +- `context_keys`: Set of all context keys used across invokes +- `label`: The label used for filtering +""" +function get_session_stats(session::Session = RxInfer.default_session(), label::Symbol = :unknown) + filtered_invokes = filter(i -> i.label === label, session.invokes) + n_invokes = length(filtered_invokes) + + if n_invokes == 0 + return (total_invokes = 0, success_rate = 0.0, failed_invokes = 0, context_keys = Symbol[], label = label) + end + + n_success = count(i -> i.status === :success, filtered_invokes) + n_failed = count(i -> i.status === :failed, filtered_invokes) + + durations = map(filtered_invokes) do invoke + Dates.value(invoke.execution_end - invoke.execution_start) / 1000.0 + end + + context_keys = unique(Iterators.flatten(keys(i.context) for i in filtered_invokes)) + + stats = ( + total_invokes = n_invokes, + success_rate = n_success / n_invokes, + failed_invokes = n_failed, + mean_duration_ms = mean(durations), + min_duration_ms = minimum(durations), + max_duration_ms = maximum(durations), + context_keys = collect(context_keys), + label = label + ) + + return stats end \ No newline at end of file diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index ab67e1569..a7c7f76ee 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -64,6 +64,13 @@ end @test entry.size === () @test entry.elsize === () end + + let entry = log_data_entry(:x => missing) + @test entry.name === :x + @test entry.type === Missing + @test entry.size === :unknown + @test entry.elsize === :unknown + end end @testset "Vectors" begin @@ -87,6 +94,20 @@ end @test entry.size === (2,) @test entry.elsize === (2,) end + + let entry = log_data_entry(:x => [missing]) + @test entry.name === :x + @test entry.type === Vector{Missing} + @test entry.size === (1, ) + @test entry.elsize === () + end + + let entry = log_data_entry(:x => [1.0, missing]) + @test entry.name === :x + @test entry.type === Vector{Union{Float64, Missing}} + @test entry.size === (2, ) + @test entry.elsize === () + end end @testset "Matrices" begin @@ -1215,10 +1236,12 @@ end @test hasproperty(latest_invoke, :id) @test latest_invoke.status == :success @test latest_invoke.execution_end > latest_invoke.execution_start - @test haskey(latest_invoke.context, :model) + @test haskey(latest_invoke.context, :model_name) + @test haskey(latest_invoke.context, :model_source) @test haskey(latest_invoke.context, :data) @test !isnothing(latest_invoke.context[:data]) - @test latest_invoke.context[:model] == """ + @test occursin(latest_invoke.context[:model_name], "simple_model") + @test latest_invoke.context[:model_source] == """ function simple_model(y) x ~ Normal(mean = 0.0, var = 1.0) y ~ Normal(mean = x, var = 1.0) @@ -1236,4 +1259,69 @@ end @test length(custom_session.invokes) === 1 @test latest_invoke.id != custom_session.invokes[1].id @test latest_invoke.context == custom_session.invokes[1].context +end + +@testitem "Inference Session statistics" begin + using Statistics + + session = RxInfer.create_session() + + # Test empty session + empty_stats = RxInfer.get_session_stats(session, :inference) + @test empty_stats.total_invokes == 0 + @test empty_stats.success_rate == 0.0 + @test empty_stats.failed_invokes == 0 + @test isempty(empty_stats.context_keys) + @test empty_stats.label === :inference + + # Create a simple model for testing + @model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) + end + + # Create test data + test_data = (y = 1.0,) + + # Run inference inside session `session` + result = infer(model = simple_model(), data = test_data, session = session) + + # Test get_session_stats for inference invokes + stats = RxInfer.get_session_stats(session, :inference) + @test stats.total_invokes == 1 + @test stats.success_rate == 1 + @test stats.failed_invokes == 0 + @test :model_name ∈ Set(stats.context_keys) + @test :model_source ∈ Set(stats.context_keys) + @test :data ∈ Set(stats.context_keys) + @test stats.min_duration_ms <= stats.mean_duration_ms <= stats.max_duration_ms + @test stats.label === :inference + + # Test get_session_stats for other invokes + other_stats = RxInfer.get_session_stats(session, :other) + @test other_stats.total_invokes == 0 + @test other_stats.success_rate == 0.0 + @test other_stats.failed_invokes == 0 + @test Set(other_stats.context_keys) == Set([]) + + # Test summarize_session output format for inference invokes with default n_last + output = IOBuffer() + RxInfer.summarize_session(output, session, :inference; n_last = 3) + output_str = String(take!(output)) + + @test contains(output_str, "Session Summary (label: inference)") + @test contains(output_str, "Total invokes: 1") + @test contains(output_str, "Success rate: 100.0%") + @test contains(output_str, "Failed invokes: 0") + @test contains(output_str, "Execution time (ms)") + @test contains(output_str, "Context keys: ") + @test contains(output_str, "Inference specific:") + @test contains(output_str, "Unique models: 1") + @test contains(output_str, "Last 3 invokes:") + @test contains(output_str, "Status") + @test contains(output_str, "Duration") + @test contains(output_str, "Model") + @test contains(output_str, "simple_model") + + end \ No newline at end of file From dfe5f8842ce156e87c854701f538de42381f8b0d Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 17:28:20 +0100 Subject: [PATCH 08/56] style: make format --- src/inference/inference.jl | 17 +++++++++-------- src/session.jl | 21 ++++++++++++++++----- test/inference/inference_tests.jl | 10 ++++------ test/session_tests.jl | 2 +- 4 files changed, 30 insertions(+), 20 deletions(-) diff --git a/src/inference/inference.jl b/src/inference/inference.jl index a6a1687a9..3df6f8024 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -100,7 +100,8 @@ log_data_entry(data::Pair) = log_data_entry(first(data), last(data)) log_data_entry(name::Union{Symbol, String}, data) = log_data_entry(name, Base.IteratorSize(data), data) log_data_entry(name::Union{Symbol, String}, _, data) = InferenceLoggedDataEntry(name, typeof(data), :unknown, :unknown) log_data_entry(name::Union{Symbol, String}, ::Base.HasShape{0}, data) = InferenceLoggedDataEntry(name, typeof(data), (), ()) -log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = InferenceLoggedDataEntry(name, typeof(data), log_data_entry_size(data), isempty(data) ? () : log_data_entry_size(first(data))) +log_data_entry(name::Union{Symbol, String}, ::Base.HasShape, data) = + InferenceLoggedDataEntry(name, typeof(data), log_data_entry_size(data), isempty(data) ? () : log_data_entry_size(first(data))) log_data_entry_size(data) = log_data_entry_size(Base.IteratorSize(data), data) log_data_entry_size(::Base.HasShape, data) = size(data) @@ -120,24 +121,24 @@ log_data_entries_from_pairs(pairs) = collect(Iterators.map(log_data_entry, pairs function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) # Count unique models unique_models = length(unique(get(i.context, :model, nothing) for i in invokes)) - + println(io, "\nInference specific:") println(io, " Unique models: $unique_models") - + # Show last N invokes in a table format if !isempty(invokes) println(io, "\nLast $n_last invokes:") println(io, "┌──────────┬──────────┬───────────────────────────┬─────────────┐") println(io, "│ Status │ Duration │ Model │ Data │") println(io, "├──────────┼──────────┼───────────────────────────┼─────────────┤") - + for invoke in Iterators.take(Iterators.reverse(invokes), n_last) status = invoke.status - duration = round(Dates.value(invoke.execution_end - invoke.execution_start) / 1000.0, digits=2) + duration = round(Dates.value(invoke.execution_end - invoke.execution_start) / 1000.0, digits = 2) model = get(invoke.context, :model_name, nothing) model = model === nothing ? "N/A" : string(model) model = length(model) > 25 ? model[1:23] * ".." : model - + data_entries = get(invoke.context, :data, nothing) data_str = if data_entries === nothing || isempty(data_entries) "N/A" @@ -145,12 +146,12 @@ function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) join(map(e -> string(e.name), data_entries), ",") end data_str = length(data_str) > 9 ? data_str[1:7] * ".." : data_str - + status_str = rpad(status, 8) duration_str = rpad("$(duration)ms", 8) model_str = rpad(model, 25) data_str = rpad(data_str, 9) - + println(io, "│ $(status_str)│ $(duration_str)│ $(model_str)│ $(data_str)│") end println(io, "└──────────┴──────────┴───────────────────────────┴─────────────┘") diff --git a/src/session.jl b/src/session.jl index ffbfd6a16..2fedbd097 100644 --- a/src/session.jl +++ b/src/session.jl @@ -147,6 +147,7 @@ Note that session logging still can be enabled manually for the current session """ function disable_session_logging!() @set_preferences!("enable_session_logging" => false) + @info "Disabled session logging. Changes will take effect after Julia restart." end """ @@ -156,6 +157,7 @@ Restart Julia and verify it by `!isnothing(RxInfer.default_session())`. """ function enable_session_logging!() @set_preferences!("enable_session_logging" => true) + @info "Enabled session logging. Changes will take effect after Julia restart." end """ @@ -166,8 +168,11 @@ The default label is `:inference` which gathers statistics of the `infer` functi """ summarize_session(session::Session = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) = summarize_session(stdout, session, label; n_last = n_last) -function summarize_session(io::IO, session::Session = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) - +function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) + if isnothing(session) + println(io, "Session logging is disabled") + end + stats = get_session_stats(session, label) filtered_invokes = filter(i -> i.label === label, session.invokes) @@ -207,12 +212,18 @@ Return a NamedTuple with key session statistics for invokes with the specified l - `context_keys`: Set of all context keys used across invokes - `label`: The label used for filtering """ -function get_session_stats(session::Session = RxInfer.default_session(), label::Symbol = :unknown) +function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_session(), label::Symbol = :unknown) + empty_session = (total_invokes = 0, success_rate = 0.0, failed_invokes = 0, context_keys = Symbol[], label = label) + + if isnothing(session) + return empty_session + end + filtered_invokes = filter(i -> i.label === label, session.invokes) n_invokes = length(filtered_invokes) if n_invokes == 0 - return (total_invokes = 0, success_rate = 0.0, failed_invokes = 0, context_keys = Symbol[], label = label) + return empty_session end n_success = count(i -> i.status === :success, filtered_invokes) @@ -236,4 +247,4 @@ function get_session_stats(session::Session = RxInfer.default_session(), label:: ) return stats -end \ No newline at end of file +end diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index a7c7f76ee..2902f83fb 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -98,14 +98,14 @@ end let entry = log_data_entry(:x => [missing]) @test entry.name === :x @test entry.type === Vector{Missing} - @test entry.size === (1, ) + @test entry.size === (1,) @test entry.elsize === () end let entry = log_data_entry(:x => [1.0, missing]) @test entry.name === :x @test entry.type === Vector{Union{Float64, Missing}} - @test entry.size === (2, ) + @test entry.size === (2,) @test entry.elsize === () end end @@ -1263,7 +1263,7 @@ end @testitem "Inference Session statistics" begin using Statistics - + session = RxInfer.create_session() # Test empty session @@ -1322,6 +1322,4 @@ end @test contains(output_str, "Duration") @test contains(output_str, "Model") @test contains(output_str, "simple_model") - - -end \ No newline at end of file +end diff --git a/test/session_tests.jl b/test/session_tests.jl index 73a359399..882c16698 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -95,4 +95,4 @@ end @test_throws "I'm an error" RxInfer.with_session(nothing) do invoke error("I'm an error") end -end \ No newline at end of file +end From 7711ed47a3041c18d4492a8a986b4e7e663102fd Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 17:36:46 +0100 Subject: [PATCH 09/56] update docs --- docs/src/manuals/session_logging.md | 6 +++--- src/inference/inference.jl | 3 ++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index e59594c59..5f66ac225 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -119,7 +119,8 @@ duration = latest_invoke.execution_end - latest_invoke.execution_start println("Duration: $duration") # Access model source -println("Model source: $(latest_invoke.context[:model])") +println("Model name: $(latest_invoke.context[:model_name])") +println("Model source: $(latest_invoke.context[:model_source])") # Examine data properties for entry in latest_invoke.context[:data] @@ -210,7 +211,6 @@ durations = map(session.invokes) do invoke end println("Mean duration: $(mean(durations))") -println("Std duration: $(std(durations))") ``` 3. **Data Validation**: Session logging helps track data characteristics: @@ -223,7 +223,7 @@ using RxInfer end session = RxInfer.create_session() -result = infer(model = simple_model(), data = (y = [1.0, 2.0],), session = session) +result = infer(model = simple_model(), data = (y = 1.0,), session = session) for entry in session.invokes[end].context[:data] println("Variable '$(entry.name)' size: $(entry.size)") diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 3df6f8024..ec8022cd6 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -187,9 +187,10 @@ function inference_process_error(error, rethrow) 1. Check our Sharp bits documentation which covers common issues: https://reactivebayes.github.io/RxInfer.jl/stable/manuals/sharpbits/overview/ - 2. Browse our existing issues - your question may already be answered: /~https://github.com/ReactiveBayes/RxInfer.jl/issues + 3. Take inspiration from our set of examples: + https://reactivebayes.github.io/RxInferExamples.jl/ Still stuck? We'd love to help! You can: - Start a discussion for questions and help. Feedback and questions from new users is also welcome! If you are stuck, please reach out and we will solve it together. From 722552a05f2d4beb54d4563449b415bec6a1cbbd Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 17:58:38 +0100 Subject: [PATCH 10/56] fix docs --- docs/src/manuals/session_logging.md | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index 5f66ac225..432c95ea3 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -156,19 +156,6 @@ RxInfer.create_session RxInfer.set_default_session! ``` -```@example manage-session -using RxInfer - -# Create a new session -new_session = RxInfer.create_session() - -# Set as default session -RxInfer.set_default_session!(new_session) - -# Clear default session -RxInfer.set_default_session!(nothing) -``` - ## Best Practices 1. **Error Handling**: Session logging automatically captures errors, making it easier to debug issues: @@ -209,8 +196,6 @@ end durations = map(session.invokes) do invoke invoke.execution_end - invoke.execution_start end - -println("Mean duration: $(mean(durations))") ``` 3. **Data Validation**: Session logging helps track data characteristics: From 20398f095e7c9a53c3ea5757747b78a62095744c Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 30 Jan 2025 18:01:51 +0100 Subject: [PATCH 11/56] fix 2prev --- src/session.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/session.jl b/src/session.jl index 2fedbd097..798ddb7e5 100644 --- a/src/session.jl +++ b/src/session.jl @@ -198,7 +198,7 @@ function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.de end """ - get_session_stats(session::Session, label::Symbol = :unknown) + get_session_stats(session::Session, label::Symbol = :inference) Return a NamedTuple with key session statistics for invokes with the specified label. @@ -212,7 +212,7 @@ Return a NamedTuple with key session statistics for invokes with the specified l - `context_keys`: Set of all context keys used across invokes - `label`: The label used for filtering """ -function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_session(), label::Symbol = :unknown) +function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_session(), label::Symbol = :inference) empty_session = (total_invokes = 0, success_rate = 0.0, failed_invokes = 0, context_keys = Symbol[], label = label) if isnothing(session) From bf35914abb9de67f678f8031105b199b0bddce9d Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Fri, 31 Jan 2025 15:09:14 +0100 Subject: [PATCH 12/56] add logging buffer and benchmarking caveats --- Project.toml | 3 +- docs/src/manuals/model-specification.md | 8 ++- docs/src/manuals/session_logging.md | 82 ++++++++++++++++++++++--- src/inference/inference.jl | 62 ++++++++++++------- src/session.jl | 31 +++++++--- test/inference/inference_tests.jl | 45 +++++++++++++- test/session_tests.jl | 29 ++++++++- 7 files changed, 217 insertions(+), 43 deletions(-) diff --git a/Project.toml b/Project.toml index ce31116bc..2e43e549b 100644 --- a/Project.toml +++ b/Project.toml @@ -16,6 +16,7 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" Optim = "429524aa-4258-5aef-a3af-852621145aeb" Preferences = "21216c6a-2e73-6563-6e65-726566657250" +PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" ReactiveMP = "a194aa59-28ba-4574-a09c-4a745416d6e3" @@ -75,9 +76,9 @@ Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" ReTestItems = "817f1d60-ba6b-4fd5-9520-3cf149f6a823" StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" StatsFuns = "4c63d2b9-4356-54db-8cca-17b64c39e42c" +TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" TestSetExtensions = "98d24dd4-01ad-11ea-1b02-c9a08f80db04" -TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76" [targets] test = ["Test", "Pkg", "Logging", "InteractiveUtils", "TestSetExtensions", "TOML", "Coverage", "CpuId", "Dates", "Distributed", "Documenter", "ExponentialFamilyProjection", "Plots", "BenchmarkCI", "BenchmarkTools", "PkgBenchmark", "Aqua", "StableRNGs", "StatsFuns", "Optimisers", "ReTestItems"] diff --git a/docs/src/manuals/model-specification.md b/docs/src/manuals/model-specification.md index 8cf57d263..ab49bce63 100644 --- a/docs/src/manuals/model-specification.md +++ b/docs/src/manuals/model-specification.md @@ -383,15 +383,19 @@ We can also verify that node contraction indeed improves the performance of the ```@example node-contraction using BenchmarkTools +benchmark_session = nothing #hide + benchmark_without_contraction = @benchmark infer( model = Model(precision = 1.0, shift = 1.0), - data = (data = 10.0, ) + data = (data = 10.0, ), + session = benchmark_session #hide ) benchmark_with_contraction = @benchmark infer( model = Model(precision = 1.0, shift = 1.0), data = (data = 10.0, ), - allow_node_contraction = true + allow_node_contraction = true, + session = benchmark_session #hide ) using Test #hide diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index 432c95ea3..0e5b62bb6 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -42,6 +42,32 @@ println("Number of invokes: $(length(session.invokes))") The number of logged invocations may be different from the number of invocations in the example above since the session is created and logged at the start of the documentation build. +## Session Capacity + +By default, RxInfer maintains a fixed-size history of the last 1000 inference invocations. +When this limit is exceeded, the oldest invocations are automatically dropped. This prevents +memory growth while maintaining recent history. + +You can customize the capacity when creating a session: + +```@example custom-session +using RxInfer + +# Create a session that keeps last 100 invokes +session = RxInfer.create_session(capacity = 100) + +# Create a session with larger history +large_session = RxInfer.create_session(capacity = 5000) + +println("Session capacity: $(capacity(session.invokes))") +println("Large session capacity: $(capacity(large_session.invokes))") +``` + +This is particularly useful when: +- Running benchmarks that might generate many invocations +- Working with long-running applications +- Managing memory usage in resource-constrained environments + You can also create and use custom sessions: ```@example custom-session @@ -52,8 +78,8 @@ using RxInfer y ~ Normal(mean = x, var = 1.0) end -# Create a custom session -session = RxInfer.create_session() +# Create a custom session with capacity of 10 invokes +session = RxInfer.create_session(capacity = 10) # Run inference with custom session result = infer( @@ -74,7 +100,7 @@ A session consists of the following components: - `id::UUID`: Unique identifier for the session - `created_at::DateTime`: Session creation timestamp - `environment::Dict{Symbol, Any}`: System and environment information -- `invokes::Vector{SessionInvoke}`: List of inference invocations +- `invokes::CircularBuffer{SessionInvoke}`: Fixed-size circular buffer of inference invocations ### Environment Information The session automatically captures system information including: @@ -105,7 +131,7 @@ using RxInfer y ~ Normal(mean = x, var = 1.0) end -session = RxInfer.create_session() +session = RxInfer.create_session(capacity = 100) result = infer(model = simple_model(), data = (y = 1.0,), session = session) # Get the latest invoke @@ -186,7 +212,7 @@ using RxInfer, Statistics y ~ Normal(mean = x, var = 1.0) end -session = RxInfer.create_session() +session = RxInfer.create_session(capacity = 100) # Run multiple inferences for i in 1:5 @@ -207,7 +233,7 @@ using RxInfer y ~ Normal(mean = x, var = 1.0) end -session = RxInfer.create_session() +session = RxInfer.create_session(capacity = 100) result = infer(model = simple_model(), data = (y = 1.0,), session = session) for entry in session.invokes[end].context[:data] @@ -232,7 +258,7 @@ RxInfer.summarize_session ```@example session-stats using RxInfer #hide -RxInfer.summarize_session() +RxInfer.summarize_session(; n_last = 25) ``` The summary includes: @@ -259,6 +285,48 @@ using RxInfer #hide RxInfer.get_session_stats() ``` +## Benchmarking Considerations + +When benchmarking code that involves the `infer` function, it's important to be aware of session logging behavior: + +### Why Disable Session Logging During Benchmarking? + +1. **Multiple Executions**: Benchmarking tools like `BenchmarkTools.jl` execute the code multiple times to gather accurate performance metrics. Each execution is logged as a separate invoke in the session, which can quickly fill up the session buffer. + +2. **Session Pollution**: These benchmark runs can pollute your session history with test invocations, making it harder to track and analyze your actual inference calls. + +3. **Performance Impact**: While minimal, session logging does add some overhead to each `infer` call, which could affect benchmark results. + +### Best Practices + +To get accurate benchmarking results and maintain a clean session history: + +```julia +# DON'T: This will fill your session with benchmark invocations +@benchmark infer(model = my_model, data = my_data) + +# DO: Explicitly disable session logging during benchmarking +@benchmark infer(model = my_model, data = my_data, session = nothing) +``` + +You can also temporarily disable session logging globally: + +```julia +# Disable session logging +previous_session = RxInfer.default_session() +RxInfer.set_default_session!(nothing) +# Run your benchmarks +# ... +# Re-enable session logging reusing the previous session +RxInfer.set_default_session!(previous_session) +``` + +or disable it explicitly: + +```julia +RxInfer.disable_session_logging!() # works after Julia restart +``` + # Developers reference diff --git a/src/inference/inference.jl b/src/inference/inference.jl index ec8022cd6..980deb7af 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -9,7 +9,7 @@ import GraphPPL: ModelGenerator, create_model import ReactiveMP: israndom, isdata, isconst import ReactiveMP: CountingReal -import ProgressMeter, Dates, UUIDs +import ProgressMeter obtain_prediction(variable::Any) = getprediction(variable) obtain_prediction(variables::AbstractArray) = getpredictions(variables) @@ -118,43 +118,59 @@ log_data_entries(data) = :unknown log_data_entries(data::Union{NamedTuple, Dict}) = log_data_entries_from_pairs(pairs(data)) log_data_entries_from_pairs(pairs) = collect(Iterators.map(log_data_entry, pairs)) +using PrettyTables + function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) # Count unique models - unique_models = length(unique(get(i.context, :model, nothing) for i in invokes)) - + unique_models = length(unique(get(i.context, :model_name, nothing) for i in invokes)) + println(io, "\nInference specific:") println(io, " Unique models: $unique_models") - + # Show last N invokes in a table format if !isempty(invokes) - println(io, "\nLast $n_last invokes:") - println(io, "┌──────────┬──────────┬───────────────────────────┬─────────────┐") - println(io, "│ Status │ Duration │ Model │ Data │") - println(io, "├──────────┼──────────┼───────────────────────────┼─────────────┤") - - for invoke in Iterators.take(Iterators.reverse(invokes), n_last) - status = invoke.status + println(io, "\nLast $n_last invokes, use `n_last` keyword argument to see more or less.") + println(io, "* Note that benchmarking with `BenchmarkTools` or similar will pollute the session with test invokes.") + println(io, " It is advised to explicitly pass `session = nothing` when benchmarking code involving the `infer` function.") + + # Prepare data for the table + last_invokes = collect(Iterators.take(Iterators.reverse(invokes), n_last)) + data = Matrix{String}(undef, length(last_invokes), 5) + + for (i, invoke) in enumerate(last_invokes) + status = string(invoke.status) duration = round(Dates.value(invoke.execution_end - invoke.execution_start) / 1000.0, digits = 2) model = get(invoke.context, :model_name, nothing) model = model === nothing ? "N/A" : string(model) - model = length(model) > 25 ? model[1:23] * ".." : model - + data_entries = get(invoke.context, :data, nothing) - data_str = if data_entries === nothing || isempty(data_entries) + data_str = if data_entries isa Symbol + string(data_entries) + elseif isnothing(data_entries) || ismissing(data_entries) || isempty(data_entries) "N/A" else - join(map(e -> string(e.name), data_entries), ",") + join(map(e -> string(e.name, " isa ", e.type), data_entries), ",") end - data_str = length(data_str) > 9 ? data_str[1:7] * ".." : data_str - - status_str = rpad(status, 8) - duration_str = rpad("$(duration)ms", 8) - model_str = rpad(model, 25) - data_str = rpad(data_str, 9) - println(io, "│ $(status_str)│ $(duration_str)│ $(model_str)│ $(data_str)│") + error_str = string(get(invoke.context, :error, "")) + + data[i, 1] = status + data[i, 2] = "$(duration)ms" + data[i, 3] = model + data[i, 4] = data_str + data[i, 5] = error_str end - println(io, "└──────────┴──────────┴───────────────────────────┴─────────────┘") + + header = (["Status", "Duration", "Model", "Data", "Error"],) + pretty_table( + io, + data; + header = header, + tf = tf_unicode_rounded, + maximum_columns_width = [8, 10, 35, 25, 25], + autowrap = true, + linebreaks = true + ) end end diff --git a/src/session.jl b/src/session.jl index 798ddb7e5..410b372fa 100644 --- a/src/session.jl +++ b/src/session.jl @@ -1,5 +1,8 @@ using Dates, UUIDs, Preferences +import DataStructures: CircularBuffer, capacity + + mutable struct SessionInvoke id::UUID label::Symbol @@ -20,7 +23,7 @@ a history of all session invocations (`SessionInvoke`) that occurred during its - `id::UUID`: A unique identifier for the session - `created_at::DateTime`: Timestamp when the session was created - `environment::Dict{Symbol, Any}`: Information about the Julia & RxInfer versions and system when the session was created -- `invokes::Vector{SessionInvoke}`: List of all inference invocations that occurred during the session +- `invokes::CircularBuffer{SessionInvoke}`: Circular buffer of inference invocations with fixed capacity The session logging is transparent and only collects non-sensitive information about calls. Users can inspect the session at any time using `get_current_session()` and reset it using `reset_session!()`. @@ -29,18 +32,22 @@ struct Session id::UUID created_at::DateTime environment::Dict{Symbol, Any} - invokes::Vector{SessionInvoke} + invokes::CircularBuffer{SessionInvoke} end """ - create_session() + create_session(; capacity::Int = 1000) Create a new session with a unique identifier and current timestamp. +# Arguments +- `capacity::Int = 1000`: Maximum number of invokes to store in the session. When exceeded, + oldest invokes are automatically dropped. + # Returns - `Session`: A new session instance with no inference invocations recorded """ -function create_session() +function create_session(; capacity::Int = 1000) environment = Dict{Symbol, Any}( :julia_version => string(VERSION), :rxinfer_version => string(pkgversion(RxInfer)), @@ -53,7 +60,7 @@ function create_session() uuid4(), # Generate unique ID now(), # Current timestamp environment, # Environment information - SessionInvoke[] # Empty vector of invokes + CircularBuffer{SessionInvoke}(capacity) # Fixed-size circular buffer ) end @@ -84,7 +91,7 @@ function with_session(f::F, session, label::Symbol = :unknown) where {F} push!(session.invokes, invoke) return result catch e - invoke.status = :failed + invoke.status = :error invoke.context[:error] = string(e) push!(session.invokes, invoke) rethrow(e) @@ -178,6 +185,7 @@ function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.de println(io, "\nSession Summary (label: $label)") println(io, "Total invokes: $(stats.total_invokes)") + println(io, "Session invokes limit: $(capacity(session.invokes))") println(io, "Success rate: $(round(stats.success_rate * 100, digits=1))%") println(io, "Failed invokes: $(stats.failed_invokes)") println(io, "\nExecution time (ms):") @@ -213,7 +221,16 @@ Return a NamedTuple with key session statistics for invokes with the specified l - `label`: The label used for filtering """ function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_session(), label::Symbol = :inference) - empty_session = (total_invokes = 0, success_rate = 0.0, failed_invokes = 0, context_keys = Symbol[], label = label) + empty_session = ( + total_invokes = 0, + success_rate = 0.0, + failed_invokes = 0, + mean_duration_ms = 0.0, + min_duration_ms = 0.0, + max_duration_ms = 0.0, + context_keys = Symbol[], + label = label + ) if isnothing(session) return empty_session diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index 2902f83fb..f1b1c155a 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -1261,7 +1261,7 @@ end @test latest_invoke.context == custom_session.invokes[1].context end -@testitem "Inference Session statistics" begin +@testitem "Inference Session statistics #1" begin using Statistics session = RxInfer.create_session() @@ -1317,9 +1317,50 @@ end @test contains(output_str, "Context keys: ") @test contains(output_str, "Inference specific:") @test contains(output_str, "Unique models: 1") - @test contains(output_str, "Last 3 invokes:") + @test contains(output_str, "Last 3 invokes") @test contains(output_str, "Status") @test contains(output_str, "Duration") @test contains(output_str, "Model") @test contains(output_str, "simple_model") end + +@testitem "Session statistics should be robust with models which have no data" begin + f(a, M) = a * M + + @model function simple_model_missing_data(y) + a ~ Normal(mean = 0.0, variance = 1.0) + M ~ Normal(mean = 0.0, variance = 1.0) + y := f(a, M) + end + + meta = @meta begin + f() -> Linearization() + end + + result = infer(model = simple_model_missing_data(), predictvars = (y = KeepEach(),), meta = meta) + + # Test summarize_session output format for inference invokes with default n_last + output = IOBuffer() + RxInfer.summarize_session(output; n_last = 1) + output_str = String(take!(output)) + + @test contains(output_str, "Status") + @test contains(output_str, "Duration") + @test contains(output_str, "Model") + @test contains(output_str, "simple_model_missing_data") +end + +@testitem "Session should save the error message" begin + @model function simple_errored_model(y) + error("Oops") + end + + session = RxInfer.create_session() + + @test_throws "Oops" infer(model = simple_errored_model(), data = (y = 1,), session = session) + + last_invoke = last(session.invokes) + + @test last_invoke.status === :error + @test last_invoke.context[:error] === "ErrorException(\"Oops\")" +end \ No newline at end of file diff --git a/test/session_tests.jl b/test/session_tests.jl index 882c16698..b51d9eeb1 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -1,5 +1,5 @@ @testitem "Session can be created" begin - using TOML + using TOML, DataStructures session = RxInfer.create_session() @@ -10,6 +10,9 @@ # Empty session has no invokes @test length(session.invokes) == 0 + + # Default capacity should be 1000 + @test capacity(session.invokes) == 1000 # Version info should contain all required fields @test haskey(session.environment, :julia_version) @@ -33,6 +36,30 @@ end end +@testitem "Session capacity limits" begin + using DataStructures + + # Test default capacity + session = RxInfer.create_session() + @test capacity(session.invokes) == 1000 + + # Test custom capacity + small_session = RxInfer.create_session(capacity = 5) + @test capacity(small_session.invokes) == 5 + + # Test circular behavior + for i in 1:10 + invoke = RxInfer.create_invoke(:test) + push!(small_session.invokes, invoke) + end + + # Should only keep last 5 invokes + @test length(small_session.invokes) == 5 + + # The invokes should be the last 5 ones + @test all(invoke.label === :test for invoke in small_session.invokes) +end + @testitem "RxInfer should have a default session" begin default_session = RxInfer.default_session() From a1d96f9515a6e97a4e4df407e9e88a24ea6f664f Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Fri, 31 Jan 2025 15:20:09 +0100 Subject: [PATCH 13/56] update 2prev --- docs/src/manuals/session_logging.md | 30 +++++++++++++++++++++-------- src/inference/inference.jl | 10 ++++------ 2 files changed, 26 insertions(+), 14 deletions(-) diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index 0e5b62bb6..ae6e8c4ab 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -59,8 +59,7 @@ session = RxInfer.create_session(capacity = 100) # Create a session with larger history large_session = RxInfer.create_session(capacity = 5000) -println("Session capacity: $(capacity(session.invokes))") -println("Large session capacity: $(capacity(large_session.invokes))") +nothing #hide ``` This is particularly useful when: @@ -68,7 +67,7 @@ This is particularly useful when: - Working with long-running applications - Managing memory usage in resource-constrained environments -You can also create and use custom sessions: +You can also pass custom sessions to the `infer` function: ```@example custom-session using RxInfer @@ -92,6 +91,18 @@ println("Session ID: $(session.id)") println("Created at: $(session.created_at)") ``` +or pass `nothing` to disable session logging: + +```@example custom-session +result = infer( + model = simple_model(), + data = (y = 1.0,), + session = nothing # skips session logging for this invocation +) +``` + +See [Configuration](@ref session-configuration) for more details on how to manage sessions. + ## Session Structure A session consists of the following components: @@ -156,7 +167,7 @@ for entry in latest_invoke.context[:data] end ``` -## Configuration +## [Configuration](@id session-configuration) ### Default Session @@ -184,12 +195,12 @@ RxInfer.set_default_session! ## Best Practices -1. **Error Handling**: Session logging automatically captures errors, making it easier to debug issues: +**Error Handling**: Session logging automatically captures errors, making it easier to debug issues: ```@example error-handling using RxInfer @model function problematic_model(y) - x ~ Normal(mean = 0.0, var = -1.0) # Invalid variance + x ~ Normal(mean = 0.0, var = sqrt(-1.0)) # Invalid variance y ~ Normal(mean = x, var = 1.0) end @@ -203,7 +214,7 @@ catch e end ``` -2. **Performance Monitoring**: Use session data to monitor inference performance: +**Performance Monitoring**: Use session data to monitor inference performance: ```@example performance using RxInfer, Statistics @@ -224,7 +235,10 @@ durations = map(session.invokes) do invoke end ``` -3. **Data Validation**: Session logging helps track data characteristics: +!!! note + The first invocation is typically slower due to Julia's JIT compilation. + +**Data Validation**: Session logging helps track data characteristics: ```@example validation using RxInfer diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 980deb7af..b93f3a86e 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -197,14 +197,12 @@ function inference_process_error(error, rethrow) """ end @error """ - We encountered an error during inference, but don't worry - we're here to help! 🤝 - - Here are some helpful resources to get you back on track: + We encountered an error during inference, here are some helpful resources to get you back on track: 1. Check our Sharp bits documentation which covers common issues: https://reactivebayes.github.io/RxInfer.jl/stable/manuals/sharpbits/overview/ - 2. Browse our existing issues - your question may already be answered: - /~https://github.com/ReactiveBayes/RxInfer.jl/issues + 2. Browse our existing discussions - your question may already be answered: + /~https://github.com/ReactiveBayes/RxInfer.jl/discussions 3. Take inspiration from our set of examples: https://reactivebayes.github.io/RxInferExamples.jl/ @@ -221,7 +219,7 @@ function inference_process_error(error, rethrow) - A minimal example that reproduces the issue - The complete error message and stack trace - Together we'll get your inference working! 💪 + Use `RxInfer.disable_inference_error_hint!()` to disable this message. """ if rethrow Base.rethrow(error) From bf8bb7acf6e4f433fa3a0ad8d749c1ba320edd01 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Fri, 31 Jan 2025 15:37:48 +0100 Subject: [PATCH 14/56] allow to disable the error messages --- docs/src/manuals/inference/overview.md | 13 +++- src/inference/inference.jl | 97 +++++++++++++++++++------- 2 files changed, 84 insertions(+), 26 deletions(-) diff --git a/docs/src/manuals/inference/overview.md b/docs/src/manuals/inference/overview.md index 8a8ab7395..89fa48dc1 100644 --- a/docs/src/manuals/inference/overview.md +++ b/docs/src/manuals/inference/overview.md @@ -283,7 +283,6 @@ result = infer( ) ``` - The `callbacks` keyword argument accepts a named-tuple of 'name = callback' pairs. The list of all possible callbacks for different inference setting (batch or streamline) and their arguments is present below: @@ -323,6 +322,18 @@ By default, the inference function uses the `DefaultPostprocess` strategy, which Change this setting to `NoopPostprocess` if you would like to keep the `Marginal` wrapper type, which might be useful in the combination with the `addons` argument. If the `addons` argument has been used, automatically changes the default strategy value to `NoopPostprocess`. +- ### [Error hints](@id inference-error-hints) + +By default, RxInfer provides helpful error hints when an error occurs during inference. +This, for example, includes links to relevant documentation, common solutions and troubleshooting steps, information about where to get help, and suggestions for providing good bug reports. + +Use [`RxInfer.disable_inference_error_hint!`](@ref) to disable error hints or [`RxInfer.enable_inference_error_hint!`](@ref) to enable them. Note that the change requires a Julia session restart to take effect. + +```@docs +RxInfer.disable_inference_error_hint! +RxInfer.enable_inference_error_hint! +``` + ## Where to go next? Read more explanation about the other keyword arguments in the [Streamlined (online) inference](@ref manual-online-inference)section or check out the [Static Inference](@ref manual-static-inference) section or check some more advanced [examples](https://reactivebayes.github.io/RxInfer.jl/stable/examples/overview/). \ No newline at end of file diff --git a/src/inference/inference.jl b/src/inference/inference.jl index b93f3a86e..7f45b3749 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -3,6 +3,8 @@ export infer export InferenceResult export RxInferenceEngine, RxInferenceEvent +using Preferences + import DataStructures: CircularBuffer import GraphPPL: ModelGenerator, create_model @@ -181,6 +183,40 @@ function inference_process_error(error) return inference_process_error(error, true) end +const preference_inference_error_hint = @load_preference("inference_error_hint", true) + +""" + disable_inference_error_hint!() + +Disable error hints that are shown when an error occurs during inference. + +The change requires a Julia session restart to take effect. When disabled, only the raw error will be shown +without additional context or suggestions. + +See also: [`enable_inference_error_hint!`](@ref), [`infer`](@ref) +""" +function disable_inference_error_hint!() + @set_preferences!("inference_error_hint" => false) + @info "Inference error hints are disabled. Restart Julia session for the change to take effect." +end + +""" + enable_inference_error_hint!() + +Enable error hints that are shown when an error occurs during inference. + +The change requires a Julia session restart to take effect. When enabled, errors during the inference call will include: +- Links to relevant documentation +- Common solutions and troubleshooting steps +- Information about where to get help + +See also: [`disable_inference_error_hint!`](@ref), [`infer`](@ref) +""" +function enable_inference_error_hint!() + @set_preferences!("inference_error_hint" => true) + @info "Inference error hints are enabled. Restart Julia session for the change to take effect." +end + function inference_process_error(error, rethrow) if error isa StackOverflowError @error """ @@ -196,31 +232,33 @@ function inference_process_error(error, rethrow) • See `infer` function docs for options """ end - @error """ - We encountered an error during inference, here are some helpful resources to get you back on track: - - 1. Check our Sharp bits documentation which covers common issues: - https://reactivebayes.github.io/RxInfer.jl/stable/manuals/sharpbits/overview/ - 2. Browse our existing discussions - your question may already be answered: - /~https://github.com/ReactiveBayes/RxInfer.jl/discussions - 3. Take inspiration from our set of examples: - https://reactivebayes.github.io/RxInferExamples.jl/ - - Still stuck? We'd love to help! You can: - - Start a discussion for questions and help. Feedback and questions from new users is also welcome! If you are stuck, please reach out and we will solve it together. - /~https://github.com/ReactiveBayes/RxInfer.jl/discussions - - Report a bug or request a feature: - /~https://github.com/ReactiveBayes/RxInfer.jl/issues - - Note that we use GitHub discussions not just for technical questions! We welcome all kinds of discussions, - whether you're new to Bayesian inference, have questions about use cases, or just want to share your experience. - - To help us help you, please include: - - A minimal example that reproduces the issue - - The complete error message and stack trace - - Use `RxInfer.disable_inference_error_hint!()` to disable this message. - """ + @static if preference_inference_error_hint + @error """ + We encountered an error during inference, here are some helpful resources to get you back on track: + + 1. Check our Sharp bits documentation which covers common issues: + https://reactivebayes.github.io/RxInfer.jl/stable/manuals/sharpbits/overview/ + 2. Browse our existing discussions - your question may already be answered: + /~https://github.com/ReactiveBayes/RxInfer.jl/discussions + 3. Take inspiration from our set of examples: + https://reactivebayes.github.io/RxInferExamples.jl/ + + Still stuck? We'd love to help! You can: + - Start a discussion for questions and help. Feedback and questions from new users is also welcome! If you are stuck, please reach out and we will solve it together. + /~https://github.com/ReactiveBayes/RxInfer.jl/discussions + - Report a bug or request a feature: + /~https://github.com/ReactiveBayes/RxInfer.jl/issues + + Note that we use GitHub discussions not just for technical questions! We welcome all kinds of discussions, + whether you're new to Bayesian inference, have questions about use cases, or just want to share your experience. + + To help us help you, please include: + - A minimal example that reproduces the issue + - The complete error message and stack trace + + Use `RxInfer.disable_inference_error_hint!()` to disable this message. + """ + end if rethrow Base.rethrow(error) end @@ -374,6 +412,15 @@ Check the official documentation for more information about some of the argument - `warn = true`: enables/disables warnings - `session = RxInfer.default_session()`: current logging session for the RxInfer invokes, see `Session` for more details, pass `nothing` to disable logging +## Error hints + +By default, RxInfer provides helpful error hints with documentation links, solutions, and troubleshooting guidance. + +Use `RxInfer.disable_inference_error_hint!()` to disable error hints or `RxInfer.enable_inference_error_hint!()` to enable them. +Note that changes to error hint settings require a Julia session restart to take effect. + +See also: [`RxInfer.disable_inference_error_hint!`](@ref), [`RxInfer.enable_inference_error_hint!`](@ref) + """ function infer(; model = nothing, From 0f708ae9b5a6fa84864cdbb92c25b6f4d93c8fe9 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Fri, 31 Jan 2025 16:25:50 +0100 Subject: [PATCH 15/56] collect more statistics --- Project.toml | 2 + docs/src/manuals/session_logging.md | 3 +- src/inference/inference.jl | 33 +++++---- src/session.jl | 38 ++++++---- test/inference/inference_tests.jl | 103 ++++++++++++++++++++++++---- test/session_tests.jl | 12 ++-- 6 files changed, 143 insertions(+), 48 deletions(-) diff --git a/Project.toml b/Project.toml index 2e43e549b..be9dd43c3 100644 --- a/Project.toml +++ b/Project.toml @@ -23,6 +23,7 @@ ReactiveMP = "a194aa59-28ba-4574-a09c-4a745416d6e3" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" Rocket = "df971d30-c9d6-4b37-b8ff-e965b2cb3a40" Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" TupleTools = "9d95972d-f1c8-5527-a6e0-b4b365fa01f6" UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" @@ -52,6 +53,7 @@ ReactiveMP = "~4.6.0" Reexport = "1.2.0" Rocket = "1.8.0" Static = "0.8.10, 1" +Statistics = "1.10" TOML = "1.0.3" TupleTools = "1.2.0" UUIDs = "1.10" diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index ae6e8c4ab..a1531d42c 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -157,7 +157,7 @@ println("Duration: $duration") # Access model source println("Model name: $(latest_invoke.context[:model_name])") -println("Model source: $(latest_invoke.context[:model_source])") +println("Model source: $(latest_invoke.context[:model])") # Examine data properties for entry in latest_invoke.context[:data] @@ -349,4 +349,5 @@ RxInfer.Session RxInfer.with_session RxInfer.create_invoke RxInfer.append_invoke_context +Base.push!(session::Session, invoke::SessionInvoke) ``` \ No newline at end of file diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 7f45b3749..ad63bbfc9 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -125,26 +125,26 @@ using PrettyTables function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) # Count unique models unique_models = length(unique(get(i.context, :model_name, nothing) for i in invokes)) - + println(io, "\nInference specific:") println(io, " Unique models: $unique_models") - + # Show last N invokes in a table format if !isempty(invokes) println(io, "\nLast $n_last invokes, use `n_last` keyword argument to see more or less.") println(io, "* Note that benchmarking with `BenchmarkTools` or similar will pollute the session with test invokes.") println(io, " It is advised to explicitly pass `session = nothing` when benchmarking code involving the `infer` function.") - + # Prepare data for the table last_invokes = collect(Iterators.take(Iterators.reverse(invokes), n_last)) data = Matrix{String}(undef, length(last_invokes), 5) - + for (i, invoke) in enumerate(last_invokes) status = string(invoke.status) duration = round(Dates.value(invoke.execution_end - invoke.execution_start) / 1000.0, digits = 2) model = get(invoke.context, :model_name, nothing) model = model === nothing ? "N/A" : string(model) - + data_entries = get(invoke.context, :data, nothing) data_str = if data_entries isa Symbol string(data_entries) @@ -155,24 +155,16 @@ function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) end error_str = string(get(invoke.context, :error, "")) - + data[i, 1] = status data[i, 2] = "$(duration)ms" data[i, 3] = model data[i, 4] = data_str data[i, 5] = error_str end - + header = (["Status", "Duration", "Model", "Data", "Error"],) - pretty_table( - io, - data; - header = header, - tf = tf_unicode_rounded, - maximum_columns_width = [8, 10, 35, 25, 25], - autowrap = true, - linebreaks = true - ) + pretty_table(io, data; header = header, tf = tf_unicode_rounded, maximum_columns_width = [8, 10, 35, 25, 25], autowrap = true, linebreaks = true) end end @@ -472,8 +464,15 @@ function infer(; return with_session(session, :inference) do invoke append_invoke_context(invoke) do ctx ctx[:model_name] = string(GraphPPL.getmodel(model)) - ctx[:model_source] = GraphPPL.getsource(model) + ctx[:model] = GraphPPL.getsource(model) ctx[:data] = log_data_entries(data) + + !isnothing(datastream) && (ctx[:datastream_type] = eltype(datastream)) + !isnothing(constraints) && (ctx[:constraints] = GraphPPL.source_code(constraints)) + !isnothing(meta) && (ctx[:meta] = GraphPPL.source_code(meta)) + + ctx[:iterations] = iterations + ctx[:free_energy] = free_energy end if isnothing(autoupdates) diff --git a/src/session.jl b/src/session.jl index 410b372fa..cf65186d3 100644 --- a/src/session.jl +++ b/src/session.jl @@ -2,7 +2,6 @@ using Dates, UUIDs, Preferences import DataStructures: CircularBuffer, capacity - mutable struct SessionInvoke id::UUID label::Symbol @@ -24,6 +23,7 @@ a history of all session invocations (`SessionInvoke`) that occurred during its - `created_at::DateTime`: Timestamp when the session was created - `environment::Dict{Symbol, Any}`: Information about the Julia & RxInfer versions and system when the session was created - `invokes::CircularBuffer{SessionInvoke}`: Circular buffer of inference invocations with fixed capacity +- `semaphore::Base.Semaphore`: Thread-safe semaphore for pushing invokes The session logging is transparent and only collects non-sensitive information about calls. Users can inspect the session at any time using `get_current_session()` and reset it using `reset_session!()`. @@ -33,6 +33,7 @@ struct Session created_at::DateTime environment::Dict{Symbol, Any} invokes::CircularBuffer{SessionInvoke} + semaphore::Base.Semaphore end """ @@ -60,7 +61,8 @@ function create_session(; capacity::Int = 1000) uuid4(), # Generate unique ID now(), # Current timestamp environment, # Environment information - CircularBuffer{SessionInvoke}(capacity) # Fixed-size circular buffer + CircularBuffer{SessionInvoke}(capacity), # Fixed-size circular buffer + Base.Semaphore(1) # semaphore for thread safety ) end @@ -73,6 +75,25 @@ function create_invoke(label::Symbol) return SessionInvoke(uuid4(), label, :unknown, Dates.now(), Dates.now(), Dict{Symbol, Any}()) end +""" + Base.push!(session::Session, invoke::SessionInvoke) + +Thread-safely push a new invoke into the session's circular buffer. +Uses a semaphore to ensure thread safety when multiple threads try to push invokes simultaneously. + +# Arguments +- `session::Session`: The session to push the invoke to +- `invoke::SessionInvoke`: The invoke to push + +# Returns +- `Nothing` +""" +function Base.push!(session::Session, invoke::SessionInvoke) + return Base.acquire(session.semaphore) do + push!(session.invokes, invoke) + end +end + """ with_session(f::F, session, label::Symbol = :unknown) where {F} @@ -88,12 +109,12 @@ function with_session(f::F, session, label::Symbol = :unknown) where {F} result = f(invoke) invoke.status = :success invoke.execution_end = Dates.now() - push!(session.invokes, invoke) + push!(session, invoke) return result catch e invoke.status = :error invoke.context[:error] = string(e) - push!(session.invokes, invoke) + push!(session, invoke) rethrow(e) end else @@ -222,14 +243,7 @@ Return a NamedTuple with key session statistics for invokes with the specified l """ function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_session(), label::Symbol = :inference) empty_session = ( - total_invokes = 0, - success_rate = 0.0, - failed_invokes = 0, - mean_duration_ms = 0.0, - min_duration_ms = 0.0, - max_duration_ms = 0.0, - context_keys = Symbol[], - label = label + total_invokes = 0, success_rate = 0.0, failed_invokes = 0, mean_duration_ms = 0.0, min_duration_ms = 0.0, max_duration_ms = 0.0, context_keys = Symbol[], label = label ) if isnothing(session) diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index f1b1c155a..921a0b046 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -47,7 +47,7 @@ end end end -@testitem "log_data_entry" begin +@testitem "session context log_data_entry" begin import RxInfer: log_data_entry @testset "Scalar values" begin @@ -150,7 +150,7 @@ end end end -@testitem "log_data_entries" begin +@testitem "session context log_data_entries" begin import RxInfer: log_data_entry, log_data_entries @testset "Named tuple entries" begin @@ -1237,15 +1237,13 @@ end @test latest_invoke.status == :success @test latest_invoke.execution_end > latest_invoke.execution_start @test haskey(latest_invoke.context, :model_name) - @test haskey(latest_invoke.context, :model_source) + @test haskey(latest_invoke.context, :model) @test haskey(latest_invoke.context, :data) @test !isnothing(latest_invoke.context[:data]) @test occursin(latest_invoke.context[:model_name], "simple_model") - @test latest_invoke.context[:model_source] == """ - function simple_model(y) - x ~ Normal(mean = 0.0, var = 1.0) - y ~ Normal(mean = x, var = 1.0) - end""" + @test occursin("function simple_model", latest_invoke.context[:model]) + @test occursin("Normal(mean = 0.0, var = 1.0)", latest_invoke.context[:model]) + @test occursin("Normal(mean = x, var = 1.0)", latest_invoke.context[:model]) @test length(latest_invoke.context[:data]) === 1 # Check saved properties of the passed data `y` @@ -1261,7 +1259,7 @@ end @test latest_invoke.context == custom_session.invokes[1].context end -@testitem "Inference Session statistics #1" begin +@testitem "Session statistics for a simple model" begin using Statistics session = RxInfer.create_session() @@ -1284,7 +1282,19 @@ end test_data = (y = 1.0,) # Run inference inside session `session` - result = infer(model = simple_model(), data = test_data, session = session) + result = infer( + model = simple_model(), + data = test_data, + iterations = 10, + free_energy = true, + session = session + ) + + last_invoke = last(session.invokes) + @test last_invoke.context[:model_name] == "simple_model" + @test last_invoke.context[:iterations] == 10 + @test last_invoke.context[:free_energy] == true + @test last_invoke.context[:data][begin].name == :y # Test get_session_stats for inference invokes stats = RxInfer.get_session_stats(session, :inference) @@ -1292,8 +1302,10 @@ end @test stats.success_rate == 1 @test stats.failed_invokes == 0 @test :model_name ∈ Set(stats.context_keys) - @test :model_source ∈ Set(stats.context_keys) + @test :model ∈ Set(stats.context_keys) @test :data ∈ Set(stats.context_keys) + @test :iterations ∈ Set(stats.context_keys) + @test :free_energy ∈ Set(stats.context_keys) @test stats.min_duration_ms <= stats.mean_duration_ms <= stats.max_duration_ms @test stats.label === :inference @@ -1363,4 +1375,71 @@ end @test last_invoke.status === :error @test last_invoke.context[:error] === "ErrorException(\"Oops\")" -end \ No newline at end of file +end + +@testitem "Session statistics should be able to handle reactive infer call" begin + @model function state_space_model_one_time_step(y, x_prev_mean, x_prev_var) + x_prev ~ Normal(mean = x_prev_mean, var = x_prev_var) + x_next ~ Normal(mean = x_prev, var = 1.0) + y ~ Normal(mean = x_next, var = 1.0) + end + + datastream = from([(y = 1,), (y = 2,), (y = 3,)]) + + autoupdates = @autoupdates begin + x_prev_mean, x_prev_var = mean_var(q(x_next)) + end + + initialization = @initialization begin + q(x_next) = vague(NormalMeanVariance) + end + + session = RxInfer.create_session() + + engine = infer(model = state_space_model_one_time_step(), datastream = datastream, autoupdates = autoupdates, initialization = initialization, session = session) + + @test length(session.invokes) === 1 + @test haskey(session.invokes[end].context, :datastream_type) + @test session.invokes[end].context[:datastream_type] == @NamedTuple{y::Int64} +end + +@testitem "Session statistics should save constraints" begin + @model function iid(y) + m ~ Normal(mean = 0.0, var = 1.0) + t ~ Gamma(shape = 1.0, rate = 1.0) + y ~ Normal(mean = m, prec = t) + end + @constraints function iidconstraints() + q(m, t) = q(m) * q(t) + end + @initialization function iidinit() + q(t) = vague(Gamma) + end + session = RxInfer.create_session() + result = infer(model = iid(), data = (y = 1.0,), constraints = iidconstraints(), initialization = iidinit(), session = session) + last_invoke = session.invokes[end] + @test haskey(last_invoke.context, :constraints) + @test occursin("function iidconstraints()", last_invoke.context[:constraints]) + @test occursin("q(m, t)", last_invoke.context[:constraints]) + @test occursin("q(m)", last_invoke.context[:constraints]) + @test occursin("q(t)", last_invoke.context[:constraints]) +end + +@testitem "Session statistics should save meta" begin + f(a) = a + 1 + @model function simple_nonlinear_model(y) + m ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = f(m), prec = 1.0) + end + @meta function model_meta() + f() -> Linearization() + end + session = RxInfer.create_session() + result = infer(model = simple_nonlinear_model(), data = (y = 1.0,), meta = model_meta(), session = session) + last_invoke = session.invokes[end] + @test haskey(last_invoke.context, :meta) + @test occursin("function model_meta()", last_invoke.context[:meta]) + @test occursin("f()", last_invoke.context[:meta]) + @test occursin("->", last_invoke.context[:meta]) + @test occursin("Linearization()", last_invoke.context[:meta]) +end diff --git a/test/session_tests.jl b/test/session_tests.jl index b51d9eeb1..6d1f527a4 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -10,7 +10,7 @@ # Empty session has no invokes @test length(session.invokes) == 0 - + # Default capacity should be 1000 @test capacity(session.invokes) == 1000 @@ -38,24 +38,24 @@ end @testitem "Session capacity limits" begin using DataStructures - + # Test default capacity session = RxInfer.create_session() @test capacity(session.invokes) == 1000 - + # Test custom capacity small_session = RxInfer.create_session(capacity = 5) @test capacity(small_session.invokes) == 5 - + # Test circular behavior for i in 1:10 invoke = RxInfer.create_invoke(:test) push!(small_session.invokes, invoke) end - + # Should only keep last 5 invokes @test length(small_session.invokes) == 5 - + # The invokes should be the last 5 ones @test all(invoke.label === :test for invoke in small_session.invokes) end From 895a2429dfd333896b1daf94208f003615e06dd8 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 3 Feb 2025 11:53:34 +0100 Subject: [PATCH 16/56] refactor and update tests --- src/session.jl | 223 ++++++++++++++++++------------ test/inference/inference_tests.jl | 43 +++--- test/session_tests.jl | 153 ++++++++++++++++---- 3 files changed, 287 insertions(+), 132 deletions(-) diff --git a/src/session.jl b/src/session.jl index cf65186d3..8ebf201cf 100644 --- a/src/session.jl +++ b/src/session.jl @@ -4,26 +4,63 @@ import DataStructures: CircularBuffer, capacity mutable struct SessionInvoke id::UUID - label::Symbol status::Symbol execution_start::DateTime execution_end::DateTime context::Dict{Symbol, Any} end +""" + SessionStats + +Statistics for a specific label in a session. + +# Fields +- `label::Symbol`: The label these statistics are for +- `total_invokes::Int`: Total number of invokes with this label +- `success_count::Int`: Number of successful invokes +- `failed_count::Int`: Number of failed invokes +- `success_rate::Float64`: Fraction of successful invokes (between 0 and 1) +- `min_duration_ms::Float64`: Minimum execution duration in milliseconds +- `max_duration_ms::Float64`: Maximum execution duration in milliseconds +- `total_duration_ms::Float64`: Total execution duration for mean calculation +- `context_keys::Set{Symbol}`: Set of all context keys used across invokes +- `invokes::CircularBuffer{SessionInvoke}`: A series of invokes attached to the statistics +""" +mutable struct SessionStats + label::Symbol + total_invokes::Int + success_count::Int + failed_count::Int + success_rate::Float64 + min_duration_ms::Float64 + max_duration_ms::Float64 + total_duration_ms::Float64 + context_keys::Set{Symbol} + invokes::CircularBuffer{SessionInvoke} +end + +const DEFAULT_SESSION_STATS_CAPACITY = 1000 + +# Constructor for empty stats +function SessionStats(label::Symbol, capacity::Int = DEFAULT_SESSION_STATS_CAPACITY) + invokes = CircularBuffer{SessionInvoke}(capacity) + return SessionStats(label, 0, 0, 0, 0.0, Inf, -Inf, 0.0, Set{Symbol}(), invokes) +end + """ Session -A structure that maintains a log of all inference invocations during a RxInfer session. -Each session has a unique identifier and tracks when it was created. The session stores -a history of all session invocations (`SessionInvoke`) that occurred during its lifetime. +A structure that maintains a log of RxInfer usage. +Each session has a unique identifier and saves when it was created together with its environment. +The session stores a dictionary of labeled stats, each of each maintains a series invocations (`SessionInvoke`) that occurred during its lifetime. # Fields - `id::UUID`: A unique identifier for the session - `created_at::DateTime`: Timestamp when the session was created - `environment::Dict{Symbol, Any}`: Information about the Julia & RxInfer versions and system when the session was created -- `invokes::CircularBuffer{SessionInvoke}`: Circular buffer of inference invocations with fixed capacity -- `semaphore::Base.Semaphore`: Thread-safe semaphore for pushing invokes +- `semaphore::Base.Semaphore`: Thread-safe semaphore for updating stats +- `stats::Dict{Symbol, SessionStats}`: Statistics per label The session logging is transparent and only collects non-sensitive information about calls. Users can inspect the session at any time using `get_current_session()` and reset it using `reset_session!()`. @@ -32,23 +69,16 @@ struct Session id::UUID created_at::DateTime environment::Dict{Symbol, Any} - invokes::CircularBuffer{SessionInvoke} semaphore::Base.Semaphore + stats::Dict{Symbol, SessionStats} end """ - create_session(; capacity::Int = 1000) + create_session() -Create a new session with a unique identifier and current timestamp. - -# Arguments -- `capacity::Int = 1000`: Maximum number of invokes to store in the session. When exceeded, - oldest invokes are automatically dropped. - -# Returns -- `Session`: A new session instance with no inference invocations recorded +Create a new session with a unique identifier, environment info and current timestamp. """ -function create_session(; capacity::Int = 1000) +function create_session() environment = Dict{Symbol, Any}( :julia_version => string(VERSION), :rxinfer_version => string(pkgversion(RxInfer)), @@ -61,36 +91,90 @@ function create_session(; capacity::Int = 1000) uuid4(), # Generate unique ID now(), # Current timestamp environment, # Environment information - CircularBuffer{SessionInvoke}(capacity), # Fixed-size circular buffer - Base.Semaphore(1) # semaphore for thread safety + Base.Semaphore(1), # Thread-safe semaphore + Dict{Symbol, SessionStats}() # Empty stats dictionary ) end """ - create_invoke(label::Symbol) + reset_session!(session, [ labels ]) + +Removes gathered statistics from the session. Optionally accepts a vector of labels to delete. If no labels specified deletes everything. +""" +function reset_session!(session::Union{Nothing, Session} = RxInfer.default_session(), labels = nothing) + if isnothing(labels) + labels = keys(session.stats) + end + for label in labels + if haskey(session.stats, label) + delete!(session.stats, label) + @info "Removed statistics for `$label`" + else + @warn "Cannot remove statistics for `$label`. Statistics labeled with `$label` do not exist." + end + end +end + +""" + create_invoke() + +Create a new session invoke with status set to `:unknown`. +""" +function create_invoke() + return SessionInvoke(uuid4(), :unknown, Dates.now(), Dates.now(), Dict{Symbol, Any}()) +end + +""" + update_stats!(stats::SessionStats, invoke::SessionInvoke) -Create a new session invoke with the given label. +Update session statistics with a new invoke labeled as `label`. """ -function create_invoke(label::Symbol) - return SessionInvoke(uuid4(), label, :unknown, Dates.now(), Dates.now(), Dict{Symbol, Any}()) +function update_stats!(stats::SessionStats, invoke::SessionInvoke) + stats.total_invokes += 1 + + # Update success/failure counts + if invoke.status === :success + stats.success_count += 1 + elseif invoke.status === :error + stats.failed_count += 1 + end + + # Update success rate + stats.success_rate = stats.success_count / stats.total_invokes + + # Calculate duration in milliseconds + duration_ms = Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)) + + # Update duration stats + stats.min_duration_ms = min(stats.min_duration_ms, duration_ms) + stats.max_duration_ms = max(stats.max_duration_ms, duration_ms) + stats.total_duration_ms += duration_ms + + # Update context keys + union!(stats.context_keys, keys(invoke.context)) + + push!(stats.invokes, invoke) end """ - Base.push!(session::Session, invoke::SessionInvoke) + update_session!(session::Session, label::Symbol, invoke::SessionInvoke) -Thread-safely push a new invoke into the session's circular buffer. -Uses a semaphore to ensure thread safety when multiple threads try to push invokes simultaneously. +Thread-safely push a new invoke labeled with `label` into the session's circular buffer and update statistics. Uses a semaphore to ensure thread safety when multiple threads try to push invokes simultaneously. # Arguments - `session::Session`: The session to push the invoke to +- `label::Symbol`: Label for the invoke - `invoke::SessionInvoke`: The invoke to push - -# Returns -- `Nothing` """ -function Base.push!(session::Session, invoke::SessionInvoke) +function update_session!(session::Session, label::Symbol, invoke::SessionInvoke) return Base.acquire(session.semaphore) do - push!(session.invokes, invoke) + # Get or create stats for this label + stats = get!(session.stats, label) do + SessionStats(label) + end + + # Update stats with new invoke + update_stats!(stats, invoke) end end @@ -100,22 +184,22 @@ end Execute function `f` within a session context with the specified label. If `session` is provided, logs execution details including timing and errors. If `session` is `nothing`, executes `f` without logging. """ -function with_session(f::F, session, label::Symbol = :unknown) where {F} +function with_session(f::F, session, label::Symbol) where {F} if isnothing(session) return f(nothing) elseif session isa Session - invoke = create_invoke(label) + invoke = create_invoke() try result = f(invoke) invoke.status = :success invoke.execution_end = Dates.now() - push!(session, invoke) return result catch e invoke.status = :error invoke.context[:error] = string(e) - push!(session, invoke) rethrow(e) + finally + update_session!(session, label, invoke) end else error(lazy"Unsupported session type $(typeof(session)). Should either be `RxInfer.Session` or `nothing`.") @@ -199,21 +283,22 @@ summarize_session(session::Session = RxInfer.default_session(), label::Symbol = function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) if isnothing(session) println(io, "Session logging is disabled") + return nothing end - stats = get_session_stats(session, label) - filtered_invokes = filter(i -> i.label === label, session.invokes) + stats = get_session_stats(session, label) + invokes = stats.invokes println(io, "\nSession Summary (label: $label)") println(io, "Total invokes: $(stats.total_invokes)") - println(io, "Session invokes limit: $(capacity(session.invokes))") + println(io, "Session invokes limit: $(capacity(invokes))") println(io, "Success rate: $(round(stats.success_rate * 100, digits=1))%") - println(io, "Failed invokes: $(stats.failed_invokes)") + println(io, "Failed invokes: $(stats.failed_count)") println(io, "\nExecution time (ms):") - println(io, " Mean: $(round(stats.mean_duration_ms, digits=2))") - println(io, " Min: $(round(stats.min_duration_ms, digits=2))") - println(io, " Max: $(round(stats.max_duration_ms, digits=2))") - println(io, "\nContext keys: $(join(stats.context_keys, ", "))") + println(io, " Mean: $(round(stats.total_duration_ms / max(1, stats.total_invokes), digits=2))") + println(io, " Min: $(stats.min_duration_ms == Inf ? 0.0 : round(stats.min_duration_ms, digits=2))") + println(io, " Max: $(stats.max_duration_ms == -Inf ? 0.0 : round(stats.max_duration_ms, digits=2))") + println(io, "\nContext keys: $(join(collect(stats.context_keys), ", "))") if stats.total_invokes == 0 println(io, "\nNo invokes found with label: $label") @@ -221,7 +306,7 @@ function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.de end # Call label-specific summary with n_last parameter - summarize_invokes(io, Val(label), filtered_invokes; n_last = n_last) + summarize_invokes(io, Val(label), invokes; n_last = n_last) return nothing end @@ -229,53 +314,19 @@ end """ get_session_stats(session::Session, label::Symbol = :inference) -Return a NamedTuple with key session statistics for invokes with the specified label. +Get statistics for invokes with the specified label. + +# Arguments +- `session::Union{Nothing, Session}`: The session to get statistics from, or nothing +- `label::Symbol`: The label to filter invokes by, defaults to :inference # Returns -- `total_invokes`: Total number of invokes with the given label -- `success_rate`: Fraction of successful invokes (between 0 and 1) -- `failed_invokes`: Number of failed invokes -- `mean_duration_ms`: Mean execution time in milliseconds -- `min_duration_ms`: Minimum execution time in milliseconds -- `max_duration_ms`: Maximum execution time in milliseconds -- `context_keys`: Set of all context keys used across invokes -- `label`: The label used for filtering +- `SessionStats`: Statistics for the specified label """ function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_session(), label::Symbol = :inference) - empty_session = ( - total_invokes = 0, success_rate = 0.0, failed_invokes = 0, mean_duration_ms = 0.0, min_duration_ms = 0.0, max_duration_ms = 0.0, context_keys = Symbol[], label = label - ) - if isnothing(session) - return empty_session + return SessionStats(label) end - filtered_invokes = filter(i -> i.label === label, session.invokes) - n_invokes = length(filtered_invokes) - - if n_invokes == 0 - return empty_session - end - - n_success = count(i -> i.status === :success, filtered_invokes) - n_failed = count(i -> i.status === :failed, filtered_invokes) - - durations = map(filtered_invokes) do invoke - Dates.value(invoke.execution_end - invoke.execution_start) / 1000.0 - end - - context_keys = unique(Iterators.flatten(keys(i.context) for i in filtered_invokes)) - - stats = ( - total_invokes = n_invokes, - success_rate = n_success / n_invokes, - failed_invokes = n_failed, - mean_duration_ms = mean(durations), - min_duration_ms = minimum(durations), - max_duration_ms = maximum(durations), - context_keys = collect(context_keys), - label = label - ) - - return stats + return get!(session.stats, label, SessionStats(label)) end diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index 921a0b046..7fcd8ff0c 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -1228,11 +1228,13 @@ end session = RxInfer.default_session() + stats = RxInfer.get_session_stats(session, :inference) + # Basic checks, other tests may have produced more invokes here - @test length(session.invokes) >= 1 + @test length(stats.invokes) >= 1 # Check the latest invoke - latest_invoke = session.invokes[end] + latest_invoke = stats.invokes[end] @test hasproperty(latest_invoke, :id) @test latest_invoke.status == :success @test latest_invoke.execution_end > latest_invoke.execution_start @@ -1253,10 +1255,11 @@ end custom_session = RxInfer.create_session() result = infer(model = simple_model(), data = test_data, session = custom_session) + custom_stats = RxInfer.get_session_stats(custom_session, :inference) - @test length(custom_session.invokes) === 1 - @test latest_invoke.id != custom_session.invokes[1].id - @test latest_invoke.context == custom_session.invokes[1].context + @test length(custom_stats.invokes) === 1 + @test latest_invoke.id != custom_stats.invokes[1].id + @test latest_invoke.context == custom_stats.invokes[1].context end @testitem "Session statistics for a simple model" begin @@ -1268,7 +1271,7 @@ end empty_stats = RxInfer.get_session_stats(session, :inference) @test empty_stats.total_invokes == 0 @test empty_stats.success_rate == 0.0 - @test empty_stats.failed_invokes == 0 + @test empty_stats.failed_count == 0 @test isempty(empty_stats.context_keys) @test empty_stats.label === :inference @@ -1290,30 +1293,30 @@ end session = session ) - last_invoke = last(session.invokes) + stats = RxInfer.get_session_stats(session, :inference) + last_invoke = last(stats.invokes) @test last_invoke.context[:model_name] == "simple_model" @test last_invoke.context[:iterations] == 10 @test last_invoke.context[:free_energy] == true @test last_invoke.context[:data][begin].name == :y - # Test get_session_stats for inference invokes - stats = RxInfer.get_session_stats(session, :inference) @test stats.total_invokes == 1 @test stats.success_rate == 1 - @test stats.failed_invokes == 0 + @test stats.failed_count == 0 @test :model_name ∈ Set(stats.context_keys) @test :model ∈ Set(stats.context_keys) @test :data ∈ Set(stats.context_keys) @test :iterations ∈ Set(stats.context_keys) @test :free_energy ∈ Set(stats.context_keys) - @test stats.min_duration_ms <= stats.mean_duration_ms <= stats.max_duration_ms + @test stats.min_duration_ms <= stats.total_duration_ms + @test stats.max_duration_ms <= stats.total_duration_ms @test stats.label === :inference # Test get_session_stats for other invokes other_stats = RxInfer.get_session_stats(session, :other) @test other_stats.total_invokes == 0 @test other_stats.success_rate == 0.0 - @test other_stats.failed_invokes == 0 + @test other_stats.failed_count == 0 @test Set(other_stats.context_keys) == Set([]) # Test summarize_session output format for inference invokes with default n_last @@ -1371,7 +1374,8 @@ end @test_throws "Oops" infer(model = simple_errored_model(), data = (y = 1,), session = session) - last_invoke = last(session.invokes) + stats = RxInfer.get_session_stats(session, :inference) + last_invoke = last(stats.invokes) @test last_invoke.status === :error @test last_invoke.context[:error] === "ErrorException(\"Oops\")" @@ -1397,10 +1401,11 @@ end session = RxInfer.create_session() engine = infer(model = state_space_model_one_time_step(), datastream = datastream, autoupdates = autoupdates, initialization = initialization, session = session) + stats = RxInfer.get_session_stats(session, :inference) - @test length(session.invokes) === 1 - @test haskey(session.invokes[end].context, :datastream_type) - @test session.invokes[end].context[:datastream_type] == @NamedTuple{y::Int64} + @test length(stats.invokes) === 1 + @test haskey(stats.invokes[end].context, :datastream_type) + @test stats.invokes[end].context[:datastream_type] == @NamedTuple{y::Int64} end @testitem "Session statistics should save constraints" begin @@ -1417,7 +1422,8 @@ end end session = RxInfer.create_session() result = infer(model = iid(), data = (y = 1.0,), constraints = iidconstraints(), initialization = iidinit(), session = session) - last_invoke = session.invokes[end] + stats = RxInfer.get_session_stats(session, :inference) + last_invoke = stats.invokes[end] @test haskey(last_invoke.context, :constraints) @test occursin("function iidconstraints()", last_invoke.context[:constraints]) @test occursin("q(m, t)", last_invoke.context[:constraints]) @@ -1436,7 +1442,8 @@ end end session = RxInfer.create_session() result = infer(model = simple_nonlinear_model(), data = (y = 1.0,), meta = model_meta(), session = session) - last_invoke = session.invokes[end] + stats = RxInfer.get_session_stats(session, :inference) + last_invoke = stats.invokes[end] @test haskey(last_invoke.context, :meta) @test occursin("function model_meta()", last_invoke.context[:meta]) @test occursin("f()", last_invoke.context[:meta]) diff --git a/test/session_tests.jl b/test/session_tests.jl index 6d1f527a4..ae75fc5ed 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -5,14 +5,11 @@ @test hasproperty(session, :id) @test hasproperty(session, :created_at) - @test hasproperty(session, :invokes) + @test hasproperty(session, :stats) @test hasproperty(session, :environment) - # Empty session has no invokes - @test length(session.invokes) == 0 - - # Default capacity should be 1000 - @test capacity(session.invokes) == 1000 + # Empty session has no stats in the beginning + @test length(session.stats) == 0 # Version info should contain all required fields @test haskey(session.environment, :julia_version) @@ -36,28 +33,23 @@ end end -@testitem "Session capacity limits" begin +@testitem "SessionStats should have capacity limits" begin using DataStructures # Test default capacity session = RxInfer.create_session() - @test capacity(session.invokes) == 1000 + stats = RxInfer.get_session_stats(session, :for_testing) - # Test custom capacity - small_session = RxInfer.create_session(capacity = 5) - @test capacity(small_session.invokes) == 5 + @test capacity(stats.invokes) == RxInfer.DEFAULT_SESSION_STATS_CAPACITY # Test circular behavior - for i in 1:10 - invoke = RxInfer.create_invoke(:test) - push!(small_session.invokes, invoke) + for i in 1:(RxInfer.DEFAULT_SESSION_STATS_CAPACITY + 1) + invoke = RxInfer.create_invoke() + RxInfer.update_session!(session, :for_testing, invoke) end - # Should only keep last 5 invokes - @test length(small_session.invokes) == 5 - - # The invokes should be the last 5 ones - @test all(invoke.label === :test for invoke in small_session.invokes) + # Should only keep last `RxInfer.DEFAULT_SESSION_STATS_CAPACITY` + @test length(stats.invokes) == RxInfer.DEFAULT_SESSION_STATS_CAPACITY end @testitem "RxInfer should have a default session" begin @@ -66,7 +58,7 @@ end @test hasproperty(default_session, :id) @test hasproperty(default_session, :created_at) @test hasproperty(default_session, :environment) - @test hasproperty(default_session, :invokes) + @test hasproperty(default_session, :stats) # Check second invokation doesn't change the return value @test default_session === RxInfer.default_session() @@ -87,20 +79,21 @@ end @testitem "Log session should save the context" begin session = RxInfer.create_session() - result = RxInfer.with_session(session) do invoke + result = RxInfer.with_session(session, :testing_session) do invoke RxInfer.append_invoke_context(invoke) do ctx ctx[:a] = 1 ctx[:b] = 2 end return 3 end - @test length(session.invokes) === 1 - last_invoke = session.invokes[end] + stats = RxInfer.get_session_stats(session, :testing_session) + @test length(stats.invokes) === 1 + last_invoke = stats.invokes[end] @test last_invoke.context[:a] === 1 @test last_invoke.context[:b] === 2 @test result === 3 - result = RxInfer.with_session(nothing) do invoke + result = RxInfer.with_session(nothing, :testing_session) do invoke RxInfer.append_invoke_context(invoke) do ctx ctx[:a] = 1 ctx[:b] = 2 @@ -108,18 +101,122 @@ end return 4 end @test result === 4 + @test length(stats.invokes) === 1 end @testitem "Log session should save errors if any" begin session = RxInfer.create_session() - @test_throws "I'm an error" RxInfer.with_session(session) do invoke + @test_throws "I'm an error" RxInfer.with_session(session, :error_session) do invoke error("I'm an error") end - @test length(session.invokes) === 1 - last_invoke = session.invokes[end] + stats = RxInfer.get_session_stats(session, :error_session) + @test length(stats.invokes) === 1 + last_invoke = stats.invokes[end] @test last_invoke.context[:error] == "ErrorException(\"I'm an error\")" - @test_throws "I'm an error" RxInfer.with_session(nothing) do invoke + @test_throws "I'm an error" RxInfer.with_session(nothing, :error_session) do invoke error("I'm an error") end + @test length(stats.invokes) === 1 +end + +@testitem "Real-time session statistics" begin + using Dates + + session = RxInfer.create_session() + + # Test initial empty state + @test isempty(session.stats) + empty_stats = RxInfer.get_session_stats(session, :test) + @test empty_stats.total_invokes == 0 + @test empty_stats.success_count == 0 + @test empty_stats.failed_count == 0 + @test empty_stats.success_rate == 0.0 + @test empty_stats.total_duration_ms == 0.0 + @test empty_stats.min_duration_ms == Inf + @test empty_stats.max_duration_ms == -Inf + @test isempty(empty_stats.context_keys) + + # Create test invokes with controlled durations + start_time = now() + + # First invoke: 100ms duration + invoke1 = RxInfer.create_invoke() + invoke1.status = :success + invoke1.context[:key1] = "value1" + invoke1.execution_start = start_time + invoke1.execution_end = start_time + Millisecond(100) + + # Test after first successful invoke + RxInfer.update_session!(session, :session_stats_test, invoke1) + stats1 = RxInfer.get_session_stats(session, :session_stats_test) + @test stats1.total_invokes == 1 + @test stats1.success_count == 1 + @test stats1.failed_count == 0 + @test stats1.success_rate == 1.0 + @test stats1.total_duration_ms == 100.0 + @test stats1.min_duration_ms == 100.0 + @test stats1.max_duration_ms == 100.0 + @test stats1.context_keys == Set([:key1]) + + # Second invoke: 200ms duration + invoke2 = RxInfer.create_invoke() + invoke2.status = :error + invoke2.context[:key2] = "value2" + invoke2.context[:error] = "test error" + invoke2.execution_start = start_time + Millisecond(200) + invoke2.execution_end = start_time + Millisecond(400) # 200ms duration + + # Test after error invoke + RxInfer.update_session!(session, :session_stats_test, invoke2) + stats2 = RxInfer.get_session_stats(session, :session_stats_test) + @test stats2.total_invokes == 2 + @test stats2.success_count == 1 + @test stats2.failed_count == 1 + @test stats2.success_rate == 0.5 + @test stats2.total_duration_ms == 300.0 # 100ms + 200ms + @test stats2.min_duration_ms == 100.0 + @test stats2.max_duration_ms == 200.0 + @test stats2.context_keys == Set([:key1, :key2, :error]) + + # Third invoke: 50ms duration (shortest) + invoke3 = RxInfer.create_invoke() + invoke3.status = :success + invoke3.context[:key3] = "value3" + invoke3.execution_start = start_time + Millisecond(500) + invoke3.execution_end = start_time + Millisecond(550) # 50ms duration + + # Test after quick successful invoke + RxInfer.update_session!(session, :session_stats_test, invoke3) + stats3 = RxInfer.get_session_stats(session, :session_stats_test) + @test stats3.total_invokes == 3 + @test stats3.success_count == 2 + @test stats3.failed_count == 1 + @test stats3.success_rate ≈ 2/3 + @test stats3.total_duration_ms == 350.0 # 100ms + 200ms + 50ms + @test stats3.min_duration_ms == 50.0 + @test stats3.max_duration_ms == 200.0 + @test stats3.context_keys == Set([:key1, :key2, :key3, :error]) + + # Test multiple labels with 150ms duration + other_invoke = RxInfer.create_invoke() + other_invoke.status = :success + other_invoke.context[:other_key] = "other_value" + other_invoke.execution_start = start_time + Millisecond(600) + other_invoke.execution_end = start_time + Millisecond(750) # 150ms duration + + RxInfer.update_session!(session, :other_session_stats_test, other_invoke) + other_stats = RxInfer.get_session_stats(session, :other_session_stats_test) + @test other_stats.total_invokes == 1 + @test other_stats.success_count == 1 + @test other_stats.failed_count == 0 + @test other_stats.success_rate == 1.0 + @test other_stats.total_duration_ms == 150.0 + @test other_stats.min_duration_ms == 150.0 + @test other_stats.max_duration_ms == 150.0 + @test other_stats.context_keys == Set([:other_key]) + + # Verify original stats unchanged + final_test_stats = RxInfer.get_session_stats(session, :session_stats_test) + @test final_test_stats === stats3 # Should be exactly the same object end From ee329330eb85bf1765d708183a1f03d48466b7e1 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 3 Feb 2025 11:58:26 +0100 Subject: [PATCH 17/56] docs & style guide --- docs/src/manuals/session_logging.md | 107 +++++++++++++++++++--------- src/inference/inference.jl | 2 +- src/session.jl | 46 ++++++++---- test/inference/inference_tests.jl | 8 +-- test/session_tests.jl | 4 +- 5 files changed, 111 insertions(+), 56 deletions(-) diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index a1531d42c..26267970a 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -4,13 +4,13 @@ RxInfer provides a built-in session logging system that helps track and analyze ## Overview -Session logging in RxInfer automatically captures: -- Model source code -- Input data characteristics and metadata -- Execution timing -- Success/failure status +Session logging in RxInfer automatically captures and maintains statistics for: +- Model source code and metadata +- Input data characteristics +- Execution timing and success rates - Error information (if any) - Environment information (Julia version, OS, etc.) +- Context keys used across invocations ## Basic Usage @@ -34,8 +34,10 @@ result = infer( # Access the current session session = RxInfer.default_session() -# Show the number of logged invocations -println("Number of invokes: $(length(session.invokes))") +# Get statistics for inference invocations +stats = RxInfer.get_session_stats(session, :inference) +println("Number of invokes: $(stats.total_invokes)") +println("Success rate: $(round(stats.success_rate * 100, digits=1))%") ``` !!! note @@ -103,6 +105,32 @@ result = infer( See [Configuration](@ref session-configuration) for more details on how to manage sessions. +## Session Statistics + +RxInfer maintains detailed statistics for each label in a session. These statistics include: + +### Per-Label Statistics +- Total number of invocations +- Success and failure counts +- Success rate +- Minimum, maximum, and total execution duration +- Set of all context keys used +- Fixed-size history of recent invocations + +You can access these statistics using `get_session_stats`: + +```@example stats-example +using RxInfer + +session = RxInfer.create_session() +stats = RxInfer.get_session_stats(session, :inference) + +println("Total invokes: $(stats.total_invokes)") +println("Success rate: $(round(stats.success_rate * 100, digits=1))%") +println("Failed invokes: $(stats.failed_count)") +println("Mean duration (ms): $(stats.total_invokes > 0 ? round(stats.total_duration_ms / stats.total_invokes, digits=2) : 0.0)") +``` + ## Session Structure A session consists of the following components: @@ -111,7 +139,8 @@ A session consists of the following components: - `id::UUID`: Unique identifier for the session - `created_at::DateTime`: Session creation timestamp - `environment::Dict{Symbol, Any}`: System and environment information -- `invokes::CircularBuffer{SessionInvoke}`: Fixed-size circular buffer of inference invocations +- `stats::Dict{Symbol, SessionStats}`: Statistics per label +- `semaphore::Base.Semaphore`: Thread-safe semaphore for concurrent updates ### Environment Information The session automatically captures system information including: @@ -122,13 +151,18 @@ The session automatically captures system information including: - CPU threads - System word size -### Invoke Information -Each inference invocation (`SessionInvoke`) captures: -- `id::UUID`: Unique identifier for the invocation -- `status::Symbol`: Status of the invocation (`:success`, `:failed`, or `:unknown`) -- `execution_start::DateTime`: Start timestamp -- `execution_end::DateTime`: End timestamp -- `context::Dict{Symbol, Any}`: Contextual information about the invocation +### Statistics Information +Each label's statistics (`SessionStats`) captures: +- `label::Symbol`: The label these statistics are for +- `total_invokes::Int`: Total number of invokes +- `success_count::Int`: Number of successful invokes +- `failed_count::Int`: Number of failed invokes +- `success_rate::Float64`: Fraction of successful invokes +- `min_duration_ms::Float64`: Minimum execution duration +- `max_duration_ms::Float64`: Maximum execution duration +- `total_duration_ms::Float64`: Total execution duration +- `context_keys::Set{Symbol}`: Set of all context keys used +- `invokes::CircularBuffer{SessionInvoke}`: Recent invocations history ## Accessing Session Data @@ -142,11 +176,14 @@ using RxInfer y ~ Normal(mean = x, var = 1.0) end -session = RxInfer.create_session(capacity = 100) +session = RxInfer.create_session() result = infer(model = simple_model(), data = (y = 1.0,), session = session) +# Get inference statistics +stats = RxInfer.get_session_stats(session, :inference) + # Get the latest invoke -latest_invoke = session.invokes[end] +latest_invoke = stats.invokes[end] # Check invocation status println("Status: $(latest_invoke.status)") @@ -208,13 +245,14 @@ try result = infer(model = problematic_model(), data = (y = 1.0,)) catch e # Check the latest invoke for error details - latest_invoke = RxInfer.default_session().invokes[end] + stats = RxInfer.get_session_stats(RxInfer.default_session(), :inference) + latest_invoke = stats.invokes[end] println("Status: $(latest_invoke.status)") println("Error: $(latest_invoke.context[:error])") end ``` -**Performance Monitoring**: Use session data to monitor inference performance: +**Performance Monitoring**: Use session statistics to monitor inference performance: ```@example performance using RxInfer, Statistics @@ -223,16 +261,16 @@ using RxInfer, Statistics y ~ Normal(mean = x, var = 1.0) end -session = RxInfer.create_session(capacity = 100) +session = RxInfer.create_session() # Run multiple inferences for i in 1:5 infer(model = simple_model(), data = (y = randn(),), session = session) end -durations = map(session.invokes) do invoke - invoke.execution_end - invoke.execution_start -end +stats = RxInfer.get_session_stats(session, :inference) +println("Mean duration (ms): $(round(stats.total_duration_ms / stats.total_invokes, digits=2))") +println("Success rate: $(round(stats.success_rate * 100, digits=1))%") ``` !!! note @@ -247,23 +285,26 @@ using RxInfer y ~ Normal(mean = x, var = 1.0) end -session = RxInfer.create_session(capacity = 100) +session = RxInfer.create_session() result = infer(model = simple_model(), data = (y = 1.0,), session = session) -for entry in session.invokes[end].context[:data] - println("Variable '$(entry.name)' size: $(entry.size)") +stats = RxInfer.get_session_stats(session, :inference) +latest_invoke = stats.invokes[end] + +# Check data properties +for entry in latest_invoke.context[:data] + println("Variable: $(entry.name)") + println("Type: $(entry.type)") end ``` -## Session Statistics +## Session Summary -RxInfer automatically collects statistics about inference runs. You can view these statistics at any time to understand how your inference tasks are performing. +You can view a tabular summary of these statistics at any time to understand how your inference tasks are performing: !!! note Session statistics below are collected during the documentation build. -## Viewing Statistics - The main function for viewing session statistics is `summarize_session`: ```@docs @@ -296,7 +337,8 @@ RxInfer.get_session_stats ```@example session-stats using RxInfer #hide -RxInfer.get_session_stats() +session = RxInfer.default_session() +stats = RxInfer.get_session_stats(session, :inference) ``` ## Benchmarking Considerations @@ -349,5 +391,6 @@ RxInfer.Session RxInfer.with_session RxInfer.create_invoke RxInfer.append_invoke_context -Base.push!(session::Session, invoke::SessionInvoke) +RxInfer.reset_session! +RxInfer.update_session! ``` \ No newline at end of file diff --git a/src/inference/inference.jl b/src/inference/inference.jl index ad63bbfc9..3820896e3 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -466,7 +466,7 @@ function infer(; ctx[:model_name] = string(GraphPPL.getmodel(model)) ctx[:model] = GraphPPL.getsource(model) ctx[:data] = log_data_entries(data) - + !isnothing(datastream) && (ctx[:datastream_type] = eltype(datastream)) !isnothing(constraints) && (ctx[:constraints] = GraphPPL.source_code(constraints)) !isnothing(meta) && (ctx[:meta] = GraphPPL.source_code(meta)) diff --git a/src/session.jl b/src/session.jl index 8ebf201cf..5587520c2 100644 --- a/src/session.jl +++ b/src/session.jl @@ -53,7 +53,8 @@ end A structure that maintains a log of RxInfer usage. Each session has a unique identifier and saves when it was created together with its environment. -The session stores a dictionary of labeled stats, each of each maintains a series invocations (`SessionInvoke`) that occurred during its lifetime. +The session maintains a dictionary of labeled statistics, each tracking a series of invocations (`SessionInvoke`) +and computing real-time statistics. # Fields - `id::UUID`: A unique identifier for the session @@ -77,6 +78,8 @@ end create_session() Create a new session with a unique identifier, environment info and current timestamp. +The session maintains separate statistics for each label, with each label's statistics +having its own circular buffer of invokes. """ function create_session() environment = Dict{Symbol, Any}( @@ -99,17 +102,18 @@ end """ reset_session!(session, [ labels ]) -Removes gathered statistics from the session. Optionally accepts a vector of labels to delete. If no labels specified deletes everything. +Removes gathered statistics from the session. Optionally accepts a vector of labels to delete. +If no labels specified deletes everything. """ function reset_session!(session::Union{Nothing, Session} = RxInfer.default_session(), labels = nothing) if isnothing(labels) labels = keys(session.stats) end - for label in labels + for label in labels if haskey(session.stats, label) delete!(session.stats, label) @info "Removed statistics for `$label`" - else + else @warn "Cannot remove statistics for `$label`. Statistics labeled with `$label` do not exist." end end @@ -127,7 +131,12 @@ end """ update_stats!(stats::SessionStats, invoke::SessionInvoke) -Update session statistics with a new invoke labeled as `label`. +Update session statistics with a new invoke. Updates all statistics including: +- Total invokes count +- Success/failure counts and success rate +- Duration statistics (min, max, total) +- Context keys set +- Invokes history """ function update_stats!(stats::SessionStats, invoke::SessionInvoke) stats.total_invokes += 1 @@ -159,12 +168,13 @@ end """ update_session!(session::Session, label::Symbol, invoke::SessionInvoke) -Thread-safely push a new invoke labeled with `label` into the session's circular buffer and update statistics. Uses a semaphore to ensure thread safety when multiple threads try to push invokes simultaneously. +Thread-safely update session statistics for a given label with a new invoke. +Uses a semaphore to ensure thread safety when multiple threads try to update statistics simultaneously. # Arguments -- `session::Session`: The session to push the invoke to +- `session::Session`: The session to update - `label::Symbol`: Label for the invoke -- `invoke::SessionInvoke`: The invoke to push +- `invoke::SessionInvoke`: The invoke to add to statistics """ function update_session!(session::Session, label::Symbol, invoke::SessionInvoke) return Base.acquire(session.semaphore) do @@ -181,7 +191,8 @@ end """ with_session(f::F, session, label::Symbol = :unknown) where {F} -Execute function `f` within a session context with the specified label. If `session` is provided, logs execution details including timing and errors. +Execute function `f` within a session context with the specified label. If `session` is provided, +logs execution details including timing and errors, and updates the session statistics for the given label. If `session` is `nothing`, executes `f` without logging. """ function with_session(f::F, session, label::Symbol) where {F} @@ -276,10 +287,11 @@ end summarize_session([io::IO], session::Session, label::Symbol = :inference; n_last = 5) Print a concise summary of session statistics for invokes with the specified label. +The summary includes total invokes, success rate, execution time statistics, +context keys used, and details of the most recent invokes. + The default label is `:inference` which gathers statistics of the `infer` function calls. """ -summarize_session(session::Session = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) = summarize_session(stdout, session, label; n_last = n_last) - function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) if isnothing(session) println(io, "Session logging is disabled") @@ -314,14 +326,20 @@ end """ get_session_stats(session::Session, label::Symbol = :inference) -Get statistics for invokes with the specified label. +Get statistics for invokes with the specified label. If the label doesn't exist in the session, +returns a new empty `SessionStats` instance. # Arguments - `session::Union{Nothing, Session}`: The session to get statistics from, or nothing -- `label::Symbol`: The label to filter invokes by, defaults to :inference +- `label::Symbol`: The label to get statistics for, defaults to :inference # Returns -- `SessionStats`: Statistics for the specified label +- `SessionStats`: Statistics for the specified label, including: + - Total invokes count + - Success/failure counts and success rate + - Duration statistics (min, max, total) + - Context keys set + - Recent invokes history """ function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_session(), label::Symbol = :inference) if isnothing(session) diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index 7fcd8ff0c..f16203a3d 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -1285,13 +1285,7 @@ end test_data = (y = 1.0,) # Run inference inside session `session` - result = infer( - model = simple_model(), - data = test_data, - iterations = 10, - free_energy = true, - session = session - ) + result = infer(model = simple_model(), data = test_data, iterations = 10, free_energy = true, session = session) stats = RxInfer.get_session_stats(session, :inference) last_invoke = last(stats.invokes) diff --git a/test/session_tests.jl b/test/session_tests.jl index ae75fc5ed..8357d7b1f 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -139,7 +139,7 @@ end # Create test invokes with controlled durations start_time = now() - + # First invoke: 100ms duration invoke1 = RxInfer.create_invoke() invoke1.status = :success @@ -192,7 +192,7 @@ end @test stats3.total_invokes == 3 @test stats3.success_count == 2 @test stats3.failed_count == 1 - @test stats3.success_rate ≈ 2/3 + @test stats3.success_rate ≈ 2 / 3 @test stats3.total_duration_ms == 350.0 # 100ms + 200ms + 50ms @test stats3.min_duration_ms == 50.0 @test stats3.max_duration_ms == 200.0 From 2646d2db0f90ce02c424784f52bc5c869b25e0bb Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 3 Feb 2025 12:02:17 +0100 Subject: [PATCH 18/56] update docstrings --- src/session.jl | 24 ++++++------------------ 1 file changed, 6 insertions(+), 18 deletions(-) diff --git a/src/session.jl b/src/session.jl index 5587520c2..283fd97e8 100644 --- a/src/session.jl +++ b/src/session.jl @@ -131,12 +131,7 @@ end """ update_stats!(stats::SessionStats, invoke::SessionInvoke) -Update session statistics with a new invoke. Updates all statistics including: -- Total invokes count -- Success/failure counts and success rate -- Duration statistics (min, max, total) -- Context keys set -- Invokes history +Update session statistics with a new invoke. """ function update_stats!(stats::SessionStats, invoke::SessionInvoke) stats.total_invokes += 1 @@ -287,11 +282,10 @@ end summarize_session([io::IO], session::Session, label::Symbol = :inference; n_last = 5) Print a concise summary of session statistics for invokes with the specified label. -The summary includes total invokes, success rate, execution time statistics, -context keys used, and details of the most recent invokes. - The default label is `:inference` which gathers statistics of the `infer` function calls. """ +summarize_session(session::Session = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) = summarize_session(stdout, session, label; n_last = n_last) + function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.default_session(), label::Symbol = :inference; n_last = 5) if isnothing(session) println(io, "Session logging is disabled") @@ -333,18 +327,12 @@ returns a new empty `SessionStats` instance. - `session::Union{Nothing, Session}`: The session to get statistics from, or nothing - `label::Symbol`: The label to get statistics for, defaults to :inference -# Returns -- `SessionStats`: Statistics for the specified label, including: - - Total invokes count - - Success/failure counts and success rate - - Duration statistics (min, max, total) - - Context keys set - - Recent invokes history """ function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_session(), label::Symbol = :inference) if isnothing(session) return SessionStats(label) end - - return get!(session.stats, label, SessionStats(label)) + return Base.acquire(session.semaphore) do + return get!(session.stats, label, SessionStats(label)) + end end From db09ff0c99dcb34a0f2793d79005b0bf0d6dab8c Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 3 Feb 2025 13:24:49 +0100 Subject: [PATCH 19/56] fix docs build --- docs/src/manuals/inference/overview.md | 2 +- docs/src/manuals/session_logging.md | 87 +++++++++++++++++--------- src/inference/inference.jl | 2 +- src/session.jl | 52 +++++++++++++-- test/inference/inference_tests.jl | 2 +- test/session_tests.jl | 9 +-- 6 files changed, 113 insertions(+), 41 deletions(-) diff --git a/docs/src/manuals/inference/overview.md b/docs/src/manuals/inference/overview.md index 89fa48dc1..06a581bfa 100644 --- a/docs/src/manuals/inference/overview.md +++ b/docs/src/manuals/inference/overview.md @@ -322,7 +322,7 @@ By default, the inference function uses the `DefaultPostprocess` strategy, which Change this setting to `NoopPostprocess` if you would like to keep the `Marginal` wrapper type, which might be useful in the combination with the `addons` argument. If the `addons` argument has been used, automatically changes the default strategy value to `NoopPostprocess`. -- ### [Error hints](@id inference-error-hints) +- ### Error hints By default, RxInfer provides helpful error hints when an error occurs during inference. This, for example, includes links to relevant documentation, common solutions and troubleshooting steps, information about where to get help, and suggestions for providing good bug reports. diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index 26267970a..0321b6827 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -46,22 +46,13 @@ println("Success rate: $(round(stats.success_rate * 100, digits=1))%") ## Session Capacity -By default, RxInfer maintains a fixed-size history of the last 1000 inference invocations. +By default, RxInfer maintains a fixed-size history of the invocations. When this limit is exceeded, the oldest invocations are automatically dropped. This prevents -memory growth while maintaining recent history. +memory growth while maintaining recent history. -You can customize the capacity when creating a session: - -```@example custom-session -using RxInfer - -# Create a session that keeps last 100 invokes -session = RxInfer.create_session(capacity = 100) - -# Create a session with larger history -large_session = RxInfer.create_session(capacity = 5000) - -nothing #hide +```@docs +RxInfer.DEFAULT_SESSION_STATS_CAPACITY +RxInfer.set_session_stats_capacity! ``` This is particularly useful when: @@ -69,6 +60,12 @@ This is particularly useful when: - Working with long-running applications - Managing memory usage in resource-constrained environments +!!! note + Changing the session stats capacity requires a Julia session restart to take effect. + The change is persistent across Julia sessions until explicitly changed again. + +## Custom sessions + You can also pass custom sessions to the `infer` function: ```@example custom-session @@ -79,8 +76,8 @@ using RxInfer y ~ Normal(mean = x, var = 1.0) end -# Create a custom session with capacity of 10 invokes -session = RxInfer.create_session(capacity = 10) +# Create a custom session +session = RxInfer.create_session() # Run inference with custom session result = infer( @@ -105,17 +102,48 @@ result = infer( See [Configuration](@ref session-configuration) for more details on how to manage sessions. +## Session Reset + +You can reset the session to its initial state with [`RxInfer.reset_session!`](@ref) function: + +```@docs +RxInfer.reset_session! +``` + ## Session Statistics -RxInfer maintains detailed statistics for each label in a session. These statistics include: +RxInfer maintains detailed statistics for each label in a session. Currently, only the `:inference` label is actively used, which collects information about inference invocations. + +### What's being collected + +For the `:inference` label, each invocation records: +- **Basic Information**: + - Unique identifier (UUID) + - Status (`:success` or `:error`) + - Execution start and end timestamps +- **Model Information**: + - Model source code + - Model name + - Inference parameters (e.g. number of iterations, free energy) +- **Data Information**: + - Input variable names and types + - Data characteristics +- **Error Information** (if any): + - Error message and type + +!!! note + No actual data is collected for the `:inference` label. Only metadata such as size and type is recorded. + +These individual invocations are then aggregated into real-time statistics: +- Total number of invocations and success/failure counts +- Success rate (fraction of successful invokes) +- Execution timing statistics (min, max, total duration) +- Set of all context keys used across invocations +- Fixed-size history of recent invocations (controlled by `DEFAULT_SESSION_STATS_CAPACITY`) -### Per-Label Statistics -- Total number of invocations -- Success and failure counts -- Success rate -- Minimum, maximum, and total execution duration -- Set of all context keys used -- Fixed-size history of recent invocations +```@docs +RxInfer.SessionStats +``` You can access these statistics using `get_session_stats`: @@ -164,6 +192,11 @@ Each label's statistics (`SessionStats`) captures: - `context_keys::Set{Symbol}`: Set of all context keys used - `invokes::CircularBuffer{SessionInvoke}`: Recent invocations history +```@docs +RxInfer.SessionInvoke +RxInfer.create_invoke +``` + ## Accessing Session Data You can inspect session data to analyze inference behavior: @@ -383,14 +416,12 @@ or disable it explicitly: RxInfer.disable_session_logging!() # works after Julia restart ``` -# Developers reference - +# Developers Reference ```@docs RxInfer.Session RxInfer.with_session -RxInfer.create_invoke RxInfer.append_invoke_context -RxInfer.reset_session! RxInfer.update_session! +RxInfer.update_stats! ``` \ No newline at end of file diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 3820896e3..9141ad9fb 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -141,7 +141,7 @@ function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) for (i, invoke) in enumerate(last_invokes) status = string(invoke.status) - duration = round(Dates.value(invoke.execution_end - invoke.execution_start) / 1000.0, digits = 2) + duration = round(Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)), digits = 2) model = get(invoke.context, :model_name, nothing) model = model === nothing ? "N/A" : string(model) diff --git a/src/session.jl b/src/session.jl index 283fd97e8..524eca743 100644 --- a/src/session.jl +++ b/src/session.jl @@ -2,6 +2,18 @@ using Dates, UUIDs, Preferences import DataStructures: CircularBuffer, capacity +""" + SessionInvoke + +Represents a single invocation of an inference operation. + +# Fields +- `id::UUID`: Unique identifier for this invocation +- `status::Symbol`: Status of the invocation (e.g. :success, :failure) +- `execution_start::DateTime`: When the invocation started +- `execution_end::DateTime`: When the invocation completed +- `context::Dict{Symbol, Any}`: Additional contextual information +""" mutable struct SessionInvoke id::UUID status::Symbol @@ -40,7 +52,33 @@ mutable struct SessionStats invokes::CircularBuffer{SessionInvoke} end -const DEFAULT_SESSION_STATS_CAPACITY = 1000 +""" + DEFAULT_SESSION_STATS_CAPACITY + +The default capacity for the circular buffer storing session invocations. +This value determines how many past invocations are stored for each label's statistics. +Can be modified at compile time using preferences: + +```julia +using RxInfer +set_session_stats_capacity!(100) +``` + +The change requires a Julia session restart to take effect. Default value is `1000`. +Must be a positive integer. +""" +const DEFAULT_SESSION_STATS_CAPACITY = @load_preference("session_stats_capacity", 1000) + +""" + set_session_stats_capacity!(capacity::Int) + +Set the default capacity for session statistics at compile time. The change requires a Julia session restart to take effect. +""" +function set_session_stats_capacity!(capacity::Int) + @assert capacity > 0 "Session stats capacity must be positive" + @set_preferences!("session_stats_capacity" => capacity) + @info "Session stats capacity set to $capacity. Restart Julia for the change to take effect." +end # Constructor for empty stats function SessionStats(label::Symbol, capacity::Int = DEFAULT_SESSION_STATS_CAPACITY) @@ -300,11 +338,13 @@ function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.de println(io, "Session invokes limit: $(capacity(invokes))") println(io, "Success rate: $(round(stats.success_rate * 100, digits=1))%") println(io, "Failed invokes: $(stats.failed_count)") - println(io, "\nExecution time (ms):") - println(io, " Mean: $(round(stats.total_duration_ms / max(1, stats.total_invokes), digits=2))") - println(io, " Min: $(stats.min_duration_ms == Inf ? 0.0 : round(stats.min_duration_ms, digits=2))") - println(io, " Max: $(stats.max_duration_ms == -Inf ? 0.0 : round(stats.max_duration_ms, digits=2))") - println(io, "\nContext keys: $(join(collect(stats.context_keys), ", "))") + + mean_execution = round(stats.total_duration_ms / max(1, stats.total_invokes), digits=2) + min_execution = stats.min_duration_ms == Inf ? 0.0 : round(stats.min_duration_ms, digits=2) + max_execution = stats.max_duration_ms == -Inf ? 0.0 : round(stats.max_duration_ms, digits=2) + + println(io, "Average execution time ", mean_execution, "ms (min: ", min_execution, "ms, max: ", max_execution, "ms)") + println(io, "Context keys: $(join(collect(stats.context_keys), ", "))") if stats.total_invokes == 0 println(io, "\nNo invokes found with label: $label") diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index f16203a3d..d1f4faed5 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -1322,7 +1322,7 @@ end @test contains(output_str, "Total invokes: 1") @test contains(output_str, "Success rate: 100.0%") @test contains(output_str, "Failed invokes: 0") - @test contains(output_str, "Execution time (ms)") + @test contains(output_str, "Average execution time") @test contains(output_str, "Context keys: ") @test contains(output_str, "Inference specific:") @test contains(output_str, "Unique models: 1") diff --git a/test/session_tests.jl b/test/session_tests.jl index 8357d7b1f..02f0ea54f 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -37,19 +37,20 @@ end using DataStructures # Test default capacity + default_capacity = RxInfer.DEFAULT_SESSION_STATS_CAPACITY session = RxInfer.create_session() stats = RxInfer.get_session_stats(session, :for_testing) - @test capacity(stats.invokes) == RxInfer.DEFAULT_SESSION_STATS_CAPACITY + @test capacity(stats.invokes) == default_capacity # Test circular behavior - for i in 1:(RxInfer.DEFAULT_SESSION_STATS_CAPACITY + 1) + for i in 1:(default_capacity + 1) invoke = RxInfer.create_invoke() RxInfer.update_session!(session, :for_testing, invoke) end - # Should only keep last `RxInfer.DEFAULT_SESSION_STATS_CAPACITY` - @test length(stats.invokes) == RxInfer.DEFAULT_SESSION_STATS_CAPACITY + # Should only keep last `default_capacity` + @test length(stats.invokes) == default_capacity end @testitem "RxInfer should have a default session" begin From b896343f0b9257f6696e5662466b50a1f966a04a Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 3 Feb 2025 13:31:32 +0100 Subject: [PATCH 20/56] be more explicit about whats being collected --- docs/src/manuals/session_logging.md | 24 ++++++++++++++++++++++++ src/session.jl | 14 ++++++++++++++ test/session_tests.jl | 29 +++++++++++++++++++++++++++++ 3 files changed, 67 insertions(+) diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index 0321b6827..14034e476 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -134,6 +134,30 @@ For the `:inference` label, each invocation records: !!! note No actual data is collected for the `:inference` label. Only metadata such as size and type is recorded. +#### An example of a last infer call in the session + +The documentation build for `RxInfer` executes real code and maintains its own session. Let's look at an example of a last infer call in the session: + +```@example docs-build-stats +using RxInfer + +session = RxInfer.default_session() +``` + +```@example docs-build-stats +stats = RxInfer.get_session_stats(session, :inference) +``` + +```@example docs-build-stats +last_invoke = stats.invokes[end] +``` + +```@example docs-build-stats +last_invoke.context +``` + +### Aggregated statistics + These individual invocations are then aggregated into real-time statistics: - Total number of invocations and success/failure counts - Success rate (fraction of successful invokes) diff --git a/src/session.jl b/src/session.jl index 524eca743..2b534887f 100644 --- a/src/session.jl +++ b/src/session.jl @@ -86,6 +86,20 @@ function SessionStats(label::Symbol, capacity::Int = DEFAULT_SESSION_STATS_CAPAC return SessionStats(label, 0, 0, 0, 0.0, Inf, -Inf, 0.0, Set{Symbol}(), invokes) end +# Show methods for nice printing +function Base.show(io::IO, invoke::SessionInvoke) + duration_ms = round(Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)), digits=2) + print(io, "SessionInvoke(status=$(invoke.status), duration=$(duration_ms)ms, context_keys=[$(join(keys(invoke.context), ", "))])") +end + +function Base.show(io::IO, stats::SessionStats) + print(io, "SessionStats(label=:$(stats.label), total=$(stats.total_invokes), success_rate=$(round(stats.success_rate * 100, digits=1))%, invokes=$(length(stats.invokes))/$(capacity(stats.invokes)))") +end + +function Base.show(io::IO, session::Session) + print(io, "Session(id=$(session.id), labels=[$(join(keys(session.stats), ", "))])") +end + """ Session diff --git a/test/session_tests.jl b/test/session_tests.jl index 02f0ea54f..bb47f0631 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -221,3 +221,32 @@ end final_test_stats = RxInfer.get_session_stats(session, :session_stats_test) @test final_test_stats === stats3 # Should be exactly the same object end + +@testitem "Show methods should produce expected output" begin + using Dates + + # Test SessionInvoke show + invoke = RxInfer.create_invoke() + invoke.status = :success + invoke.execution_end = invoke.execution_start + Millisecond(123) + + output = sprint(show, invoke) + @test occursin("SessionInvoke(status=success, duration=123.0ms)", output) + + # Test SessionStats show + stats = RxInfer.SessionStats(:test) + RxInfer.update_stats!(stats, invoke) + + output = sprint(show, stats) + @test occursin("SessionStats(label=:test, total=1, success_rate=100.0%, invokes=1/$(RxInfer.DEFAULT_SESSION_STATS_CAPACITY))", output) + + # Test Session show + session = RxInfer.create_session() + RxInfer.update_session!(session, :test, invoke) + RxInfer.update_session!(session, :other, invoke) + + output = sprint(show, session) + @test occursin("Session(id=$(session.id), labels=", output) + @test occursin("test", output) + @test occursin("other", output) +end From b04c90d2970c945b76bb2d0acf7e47bb4ea19c64 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 3 Feb 2025 13:34:37 +0100 Subject: [PATCH 21/56] 2prev --- docs/src/manuals/session_logging.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_logging.md index 14034e476..047af15b6 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_logging.md @@ -174,7 +174,7 @@ You can access these statistics using `get_session_stats`: ```@example stats-example using RxInfer -session = RxInfer.create_session() +session = RxInfer.default_session() stats = RxInfer.get_session_stats(session, :inference) println("Total invokes: $(stats.total_invokes)") From a693b90451633d851a371cb4bd2eac663381510a Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 3 Feb 2025 13:37:35 +0100 Subject: [PATCH 22/56] create a new doc page for telemetry --- docs/make.jl | 3 ++- docs/src/manuals/{session_logging.md => session_summary.md} | 2 +- docs/src/manuals/telemetry.md | 3 +++ 3 files changed, 6 insertions(+), 2 deletions(-) rename docs/src/manuals/{session_logging.md => session_summary.md} (99%) create mode 100644 docs/src/manuals/telemetry.md diff --git a/docs/make.jl b/docs/make.jl index 12a75ccd5..27e9a0dd9 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -41,7 +41,8 @@ makedocs(; "Inference specification" => ["Overview" => "manuals/inference/overview.md", "Static inference" => "manuals/inference/static.md", "Streamline inference" => "manuals/inference/streamlined.md", "Initialization" => "manuals/inference/initialization.md", "Auto-updates" => "manuals/inference/autoupdates.md", "Deterministic nodes" => "manuals/inference/delta-node.md", "Non-conjugate inference" => "manuals/inference/nonconjugate.md", "Undefined message update rules" => "manuals/inference/undefinedrules.md"], "Inference customization" => ["Defining a custom node and rules" => "manuals/customization/custom-node.md", "Inference results postprocessing" => "manuals/customization/postprocess.md"], "Debugging" => "manuals/debugging.md", - "Session logging" => "manuals/session_logging.md", + "Session summary" => "manuals/session_summary.md", + "Sharing sessions & telemetry" => "manuals/telemetry.md", "Migration from v2 to v3" => "manuals/migration-guide-v2-v3.md", "Sharp bits of RxInfer" => ["Overview" => "manuals/sharpbits/overview.md", "Rule Not Found Error" => "manuals/sharpbits/rule-not-found.md", "Stack Overflow in Message Computations" => "manuals/sharpbits/stack-overflow-inference.md", "Using `=` instead of `:=` for deterministic nodes" => "manuals/sharpbits/usage-colon-equality.md"] ], diff --git a/docs/src/manuals/session_logging.md b/docs/src/manuals/session_summary.md similarity index 99% rename from docs/src/manuals/session_logging.md rename to docs/src/manuals/session_summary.md index 047af15b6..ee3c62f22 100644 --- a/docs/src/manuals/session_logging.md +++ b/docs/src/manuals/session_summary.md @@ -1,4 +1,4 @@ -# Session Logging +# [Session Summary](@id manual-session-summary) RxInfer provides a built-in session logging system that helps track and analyze various aspects of RxInfer usages. This feature is particularly useful for debugging, performance monitoring, and understanding the behavior of your inference models. diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md new file mode 100644 index 000000000..0f52a0c57 --- /dev/null +++ b/docs/src/manuals/telemetry.md @@ -0,0 +1,3 @@ +# Sharing sessions & telemetry + +Please, first read the [Session Summary](@ref manual-session-summary) manual to understand the basic concepts of RxInfer sessions. \ No newline at end of file From e42e7d3a4ddf1fb158a3632646a4e8c64292e12b Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 13:53:54 +0100 Subject: [PATCH 23/56] update --- Project.toml | 4 ++ docs/src/manuals/telemetry.md | 55 ++++++++++++++++- src/RxInfer.jl | 7 ++- src/session.jl | 30 ++++----- src/telemetry.jl | 112 ++++++++++++++++++++++++++++++++++ test/session_tests.jl | 2 +- 6 files changed, 192 insertions(+), 18 deletions(-) create mode 100644 src/telemetry.jl diff --git a/Project.toml b/Project.toml index be9dd43c3..50125b1e6 100644 --- a/Project.toml +++ b/Project.toml @@ -12,6 +12,8 @@ DomainSets = "5b8099bc-c8ec-5219-889f-1d9e522a28bf" ExponentialFamily = "62312e5e-252a-4322-ace9-a5f4bf9b357b" FastCholesky = "2d5283b6-8564-42b6-bb00-83ed8e915756" GraphPPL = "b3f8163a-e979-4e85-b43e-1f63d8c8b42c" +HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" Optim = "429524aa-4258-5aef-a3af-852621145aeb" @@ -43,6 +45,8 @@ ExponentialFamily = "1.5" ExponentialFamilyProjection = "1.1" FastCholesky = "1.3.0" GraphPPL = "~4.6.0" +HTTP = "1.10" +JSON = "0.21.4" LinearAlgebra = "1.9" MacroTools = "0.5.6" Optim = "1.0.0" diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index 0f52a0c57..c50a6ebd8 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -1,3 +1,56 @@ # Sharing sessions & telemetry -Please, first read the [Session Summary](@ref manual-session-summary) manual to understand the basic concepts of RxInfer sessions. \ No newline at end of file +Please, first read the [Session Summary](@ref manual-session-summary) manual to understand the basic concepts of RxInfer sessions. + +## [Usage Telemetry](@id manual-usage-telemetry) + +RxInfer collects minimal anonymous usage statistics to help improve the package. The only data collected is: +- A timestamp of when the package is loaded +- A random UUID for deduplication + +### Default Behavior + +By default, [Usage Telemetry](@ref manual-usage-telemetry) is enabled but you can disable it in several ways: + +1. Using environment variables: + ```bash + export LOG_USING_RXINFER=false + ``` + +2. Using Julia functions: + ```julia + using RxInfer + RxInfer.disable_rxinfer_using_telemetry!() # Requires Julia restart + ``` + +3. Setting the endpoint to `nothing`: + ```julia + using RxInfer + RxInfer.set_telemetry_endpoint!(nothing) # Requires Julia restart + ``` + +### Configuration Functions + +The following functions are available for telemetry configuration: + +- `set_telemetry_endpoint!(endpoint)`: Set a custom telemetry endpoint or disable telemetry by setting it to `nothing` +- `disable_rxinfer_using_telemetry!()`: Disable telemetry collection (requires Julia restart) +- `enable_rxinfer_using_telemetry!()`: Enable telemetry collection (requires Julia restart) + +### When Telemetry is Disabled + +Telemetry is automatically disabled in the following cases: +1. When running in CI environments (detected via `CI=true` environment variable) +2. When `LOG_USING_RXINFER=false` environment variable is set +3. When telemetry is disabled via `disable_rxinfer_using_telemetry!()` +4. When the telemetry endpoint is set to `nothing` + +### Privacy Considerations + +- No personal information is collected +- No code or data from your sessions is transmitted, but you can share your sessions if you want. Read more about [session sharing](@ref manual-session-sharing) +- All requests are made asynchronously and will never block or affect your work +- Failed telemetry requests are silently discarded +- The code is open source and can be inspected in the `src/telemetry.jl` file + +## [Session Sharing](@id manual-session-sharing) \ No newline at end of file diff --git a/src/RxInfer.jl b/src/RxInfer.jl index e72409f51..d2211d901 100644 --- a/src/RxInfer.jl +++ b/src/RxInfer.jl @@ -7,6 +7,7 @@ using Reexport include("helpers.jl") include("rocket.jl") include("session.jl") +include("telemetry.jl") include("score/actor.jl") include("score/diagnostics.jl") @@ -25,13 +26,15 @@ include("constraints/form/form_sample_list.jl") include("inference/postprocess.jl") include("inference/inference.jl") -preference_enable_session_logging = @load_preference("enable_session_logging", true) - function __init__() if RxInfer.preference_enable_session_logging default_session = create_session() RxInfer.set_default_session!(default_session) end + + if RxInfer.preference_enable_using_rxinfer_telemetry + log_using_rxinfer() + end end end diff --git a/src/session.jl b/src/session.jl index 2b534887f..4a6d2c210 100644 --- a/src/session.jl +++ b/src/session.jl @@ -2,6 +2,8 @@ using Dates, UUIDs, Preferences import DataStructures: CircularBuffer, capacity +preference_enable_session_logging = @load_preference("enable_session_logging", true) + """ SessionInvoke @@ -86,20 +88,6 @@ function SessionStats(label::Symbol, capacity::Int = DEFAULT_SESSION_STATS_CAPAC return SessionStats(label, 0, 0, 0, 0.0, Inf, -Inf, 0.0, Set{Symbol}(), invokes) end -# Show methods for nice printing -function Base.show(io::IO, invoke::SessionInvoke) - duration_ms = round(Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)), digits=2) - print(io, "SessionInvoke(status=$(invoke.status), duration=$(duration_ms)ms, context_keys=[$(join(keys(invoke.context), ", "))])") -end - -function Base.show(io::IO, stats::SessionStats) - print(io, "SessionStats(label=:$(stats.label), total=$(stats.total_invokes), success_rate=$(round(stats.success_rate * 100, digits=1))%, invokes=$(length(stats.invokes))/$(capacity(stats.invokes)))") -end - -function Base.show(io::IO, session::Session) - print(io, "Session(id=$(session.id), labels=[$(join(keys(session.stats), ", "))])") -end - """ Session @@ -390,3 +378,17 @@ function get_session_stats(session::Union{Nothing, Session} = RxInfer.default_se return get!(session.stats, label, SessionStats(label)) end end + +# Show methods for nice printing +function Base.show(io::IO, invoke::SessionInvoke) + duration_ms = round(Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)), digits=2) + print(io, "SessionInvoke(status=$(invoke.status), duration=$(duration_ms)ms, context_keys=[$(join(keys(invoke.context), ", "))])") +end + +function Base.show(io::IO, stats::SessionStats) + print(io, "SessionStats(label=:$(stats.label), total=$(stats.total_invokes), success_rate=$(round(stats.success_rate * 100, digits=1))%, invokes=$(length(stats.invokes))/$(capacity(stats.invokes)))") +end + +function Base.show(io::IO, session::Session) + print(io, "Session(id=$(session.id), labels=[$(join(keys(session.stats), ", "))])") +end \ No newline at end of file diff --git a/src/telemetry.jl b/src/telemetry.jl new file mode 100644 index 000000000..2f7cc1705 --- /dev/null +++ b/src/telemetry.jl @@ -0,0 +1,112 @@ +const RXINFER_DEFAULT_TELEMETRY_ENDPOINT = "https://firestore.googleapis.com/v1/projects/reactive-bayes/databases/(default)/documents/" + +preference_telemetry_endpoint = @load_preference("telemetry_endpoint", RXINFER_DEFAULT_TELEMETRY_ENDPOINT) + +preference_enable_using_rxinfer_telemetry = @load_preference("enable_using_rxinfer_telemetry", true) + +""" + set_telemetry_endpoint!(endpoint) + +Set the telemetry endpoint URL for RxInfer.jl at compile time. This endpoint is used for collecting anonymous usage statistics +to help improve the package. + +The change requires a Julia session restart to take effect. + +# Arguments +- `endpoint`: The URL of the telemetry endpoint as a `String` or `nothing`` +""" +function set_telemetry_endpoint!(endpoint) + @set_preferences!("telemetry_endpoint" => endpoint) + if !isnothing(endpoint) + @info "Telemetry endpoint set to $endpoint. Restart Julia for the change to take effect." + elseif isnothing(endpoint) + @info "Telemetry endpoint is set to `nothing`." + end + return nothing +end + +using HTTP, Dates, UUIDs, JSON + +const logged_usage = Ref(false) + +""" + log_using_rxinfer() + +Send an anonymous usage statistics event to the telemetry endpoint on `using RxInfer`. +This function makes an asynchronous HTTP POST request to the configured endpoint. +See `RxInfer.set_telemetry_endpoint!` to configure the endpoint. +If the telemetry endpoint is set to `nothing`, this function does nothing. +The call sends only timestamp and a random UUID. +The request is made asynchronously to avoid blocking the user's workflow. +See `RxInfer.disable_rxinfer_using_telemetry!` to disable telemetry on `using RxInfer`. +Alternatively, set the environment variable `LOG_USING_RXINFER` to `false` to disable logging. +""" +function log_using_rxinfer() + if logged_usage[] + return nothing + end + + if !preference_enable_using_rxinfer_telemetry || isnothing(preference_telemetry_endpoint) + return nothing + end + + # Do not log usage statistics in CI + if get(ENV, "CI", "false") == "true" + return nothing + end + + # Do not log usage statistics if the environment variable is set to `false` + if get(ENV, "LOG_USING_RXINFER", "true") == "false" + return nothing + end + + Base.Threads.@spawn :interactive try + # Firestore requires collection name in the URL + collection = "using_rxinfer" + endpoint = joinpath(preference_telemetry_endpoint, collection) + + # Headers required for Firestore REST API + headers = ["Accept" => "application/json", "Content-Type" => "application/json"] + + # Firestore document structure + # See: https://firebase.google.com/docs/firestore/reference/rest/v1/projects.databases.documents + payload = Dict( + "fields" => Dict("timestamp" => Dict("timestampValue" => Dates.format(now(UTC), "yyyy-mm-ddTHH:MM:SS.sssZ")), "id" => Dict("stringValue" => string(uuid4()))) + ) + + # Make request to Firestore REST API + HTTP.post(endpoint, headers, JSON.json(payload)) + catch e + nothing # Discard any log errors to avoid disrupting the user + end + + logged_usage[] = true + + return nothing +end + +""" + disable_rxinfer_using_telemetry!() + +Disable telemetry collection on `using RxInfer` at compile time. The change requires a Julia session restart to take effect. + +See also: [`set_telemetry_endpoint!`](@ref), [`enable_rxinfer_using_telemetry!`](@ref) +""" +function disable_rxinfer_using_telemetry!() + @set_preferences!("enable_using_rxinfer_telemetry" => false) + @info "Disabled telemetry collection on `using RxInfer`. Changes will take effect after Julia restart." + return nothing +end + +""" + enable_rxinfer_using_telemetry!() + +Enable telemetry collection on `using RxInfer` at compile time. The change requires a Julia session restart to take effect. + +See also: [`set_telemetry_endpoint!`](@ref), [`disable_rxinfer_using_telemetry!`](@ref) +""" +function enable_rxinfer_using_telemetry!() + @set_preferences!("enable_using_rxinfer_telemetry" => true) + @info "Enabled telemetry collection on `using RxInfer`. Changes will take effect after Julia restart." + return nothing +end diff --git a/test/session_tests.jl b/test/session_tests.jl index bb47f0631..2b306a125 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -231,7 +231,7 @@ end invoke.execution_end = invoke.execution_start + Millisecond(123) output = sprint(show, invoke) - @test occursin("SessionInvoke(status=success, duration=123.0ms)", output) + @test occursin("SessionInvoke(status=success, duration=123.0ms", output) # Test SessionStats show stats = RxInfer.SessionStats(:test) From fc107c6dcbe6bdd4a0d2d664ed7c56cadf4a5e31 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 14:03:01 +0100 Subject: [PATCH 24/56] update --- .github/workflows/CI.yml | 4 ++++ docs/src/manuals/telemetry.md | 33 ++++++++++++++++++++++++++++----- 2 files changed, 32 insertions(+), 5 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 8223ae28f..b7ef96cf9 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -60,6 +60,7 @@ jobs: - uses: julia-actions/julia-runtest@v1 env: USE_DEV: "false" + LOG_USING_RXINFER: "false" - uses: julia-actions/julia-processcoverage@v1 - uses: codecov/codecov-action@v4 with: @@ -89,6 +90,8 @@ jobs: version: '1.11' - uses: julia-actions/cache@v1 - name: Build and test examples + env: + LOG_USING_RXINFER: "false" run: | julia -e 'using Pkg; Pkg.add("Weave"); Pkg.develop(path="RxInfer.jl"); Pkg.precompile()' cd RxInferExamples.jl @@ -111,4 +114,5 @@ jobs: - run: make docs env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + LOG_USING_RXINFER: "false" diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index c50a6ebd8..7f8b7c53c 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -1,6 +1,4 @@ -# Sharing sessions & telemetry - -Please, first read the [Session Summary](@ref manual-session-summary) manual to understand the basic concepts of RxInfer sessions. +# RxInfer Usage Telemetry ## [Usage Telemetry](@id manual-usage-telemetry) @@ -8,6 +6,28 @@ RxInfer collects minimal anonymous usage statistics to help improve the package. - A timestamp of when the package is loaded - A random UUID for deduplication +These statistics help us understand how RxInfer is being used and guide our development efforts. We share and discuss these numbers in our public meetings, which happen every 4 weeks. We encourage you to join our community meetings to: +- Learn about usage patterns and how others are using RxInfer +- Provide feedback and suggestions +- Help shape the future of the package +- Connect with the RxInfer community + +### Join Our Meetings + +We hold public meetings every 4 weeks where we: +- Share and discuss usage statistics +- Present new features and improvements +- Discuss the roadmap and future development +- Answer questions from the community +- Welcome feedback and suggestions + +To join: +1. Check our [meeting schedule](https://dynalist.io/d/F4aA-Z2c8X-M1iWTn9hY_ndN) for the next meeting date +2. Join our [GitHub discussions](/~https://github.com/reactivebayes/RxInfer.jl/discussions) to stay updated +3. Feel free to add topics you'd like to discuss to the meeting agenda + +We welcome participants of all experience levels - whether you're new to RxInfer or a seasoned user! + ### Default Behavior By default, [Usage Telemetry](@ref manual-usage-telemetry) is enabled but you can disable it in several ways: @@ -48,9 +68,12 @@ Telemetry is automatically disabled in the following cases: ### Privacy Considerations - No personal information is collected -- No code or data from your sessions is transmitted, but you can share your sessions if you want. Read more about [session sharing](@ref manual-session-sharing) +- No code from your sessions is transmitted, but you can share your sessions if you want to help us to debug issues and improve the package. Read more about [session sharing](@ref manual-session-sharing) - All requests are made asynchronously and will never block or affect your work - Failed telemetry requests are silently discarded - The code is open source and can be inspected in the `src/telemetry.jl` file +- Usage statistics are shared during our public meetings + +## [Session Sharing](@id manual-session-sharing) -## [Session Sharing](@id manual-session-sharing) \ No newline at end of file +Please, first read the [Session Summary](@ref manual-session-summary) manual to understand the basic concepts of RxInfer sessions. \ No newline at end of file From 24896cbb671d13a86d0239f9c90288ef824e5349 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 14:32:52 +0100 Subject: [PATCH 25/56] support doc deduplication --- docs/src/manuals/session_summary.md | 1 + src/session.jl | 8 +-- src/telemetry.jl | 75 +++++++++++++++++++++++------ test/runtests.jl | 2 + test/session_tests.jl | 4 +- test/utiltests.jl | 2 + 6 files changed, 72 insertions(+), 20 deletions(-) diff --git a/docs/src/manuals/session_summary.md b/docs/src/manuals/session_summary.md index ee3c62f22..d6876f1b6 100644 --- a/docs/src/manuals/session_summary.md +++ b/docs/src/manuals/session_summary.md @@ -205,6 +205,7 @@ The session automatically captures system information including: ### Statistics Information Each label's statistics (`SessionStats`) captures: +- `id::UUID`: Unique identifier for these statistics - `label::Symbol`: The label these statistics are for - `total_invokes::Int`: Total number of invokes - `success_count::Int`: Number of successful invokes diff --git a/src/session.jl b/src/session.jl index 4a6d2c210..bd9d46aa2 100644 --- a/src/session.jl +++ b/src/session.jl @@ -30,6 +30,7 @@ end Statistics for a specific label in a session. # Fields +- `id::UUID`: Unique identifier for these statistics - `label::Symbol`: The label these statistics are for - `total_invokes::Int`: Total number of invokes with this label - `success_count::Int`: Number of successful invokes @@ -42,6 +43,7 @@ Statistics for a specific label in a session. - `invokes::CircularBuffer{SessionInvoke}`: A series of invokes attached to the statistics """ mutable struct SessionStats + id::UUID label::Symbol total_invokes::Int success_count::Int @@ -85,7 +87,7 @@ end # Constructor for empty stats function SessionStats(label::Symbol, capacity::Int = DEFAULT_SESSION_STATS_CAPACITY) invokes = CircularBuffer{SessionInvoke}(capacity) - return SessionStats(label, 0, 0, 0, 0.0, Inf, -Inf, 0.0, Set{Symbol}(), invokes) + return SessionStats(uuid4(), label, 0, 0, 0, 0.0, Inf, -Inf, 0.0, Set{Symbol}(), invokes) end """ @@ -382,11 +384,11 @@ end # Show methods for nice printing function Base.show(io::IO, invoke::SessionInvoke) duration_ms = round(Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)), digits=2) - print(io, "SessionInvoke(status=$(invoke.status), duration=$(duration_ms)ms, context_keys=[$(join(keys(invoke.context), ", "))])") + print(io, "SessionInvoke(id=$(invoke.id), status=$(invoke.status), duration=$(duration_ms)ms, context_keys=[$(join(keys(invoke.context), ", "))])") end function Base.show(io::IO, stats::SessionStats) - print(io, "SessionStats(label=:$(stats.label), total=$(stats.total_invokes), success_rate=$(round(stats.success_rate * 100, digits=1))%, invokes=$(length(stats.invokes))/$(capacity(stats.invokes)))") + print(io, "SessionStats(id=$(stats.id), label=:$(stats.label), total=$(stats.total_invokes), success_rate=$(round(stats.success_rate * 100, digits=1))%, invokes=$(length(stats.invokes))/$(capacity(stats.invokes)))") end function Base.show(io::IO, session::Session) diff --git a/src/telemetry.jl b/src/telemetry.jl index 2f7cc1705..61b32967f 100644 --- a/src/telemetry.jl +++ b/src/telemetry.jl @@ -61,21 +61,8 @@ function log_using_rxinfer() end Base.Threads.@spawn :interactive try - # Firestore requires collection name in the URL - collection = "using_rxinfer" - endpoint = joinpath(preference_telemetry_endpoint, collection) - - # Headers required for Firestore REST API - headers = ["Accept" => "application/json", "Content-Type" => "application/json"] - - # Firestore document structure - # See: https://firebase.google.com/docs/firestore/reference/rest/v1/projects.databases.documents - payload = Dict( - "fields" => Dict("timestamp" => Dict("timestampValue" => Dates.format(now(UTC), "yyyy-mm-ddTHH:MM:SS.sssZ")), "id" => Dict("stringValue" => string(uuid4()))) - ) - - # Make request to Firestore REST API - HTTP.post(endpoint, headers, JSON.json(payload)) + id = string(uuid4()) + __add_document(id, "using_rxinfer", (fields = (timestamp = (timestampValue = Dates.format(now(UTC), "yyyy-mm-ddTHH:MM:SS.sssZ"),), id = (stringValue = id,)),)) catch e nothing # Discard any log errors to avoid disrupting the user end @@ -110,3 +97,61 @@ function enable_rxinfer_using_telemetry!() @info "Enabled telemetry collection on `using RxInfer`. Changes will take effect after Julia restart." return nothing end + +# The mapping of the document ID to the endpoint name +# This is used to avoid duplicate documents in Firestore +const id_name_mapping = Dict{String, String}() + +# Adds or updates a document in Firestore based on the provided id and collection. +# If a document with the same id already exists (tracked in id_name_mapping), +# it updates that document instead of creating a new one to avoid duplicates. +# The document name from Firestore is stored in id_name_mapping for future updates. +function __add_document(id, collection, payload) + if !isnothing(preference_telemetry_endpoint) + # Headers required for Firestore REST API + headers = ["Accept" => "application/json", "Content-Type" => "application/json"] + + # Example values: + # id = "550e8400-e29b-41d4-a716-446655440000" (a UUID string) + # collection = "using_rxinfer" + # payload = (fields = ( + # timestamp = (timestampValue = "2024-01-20T14:30:15.123Z"), + # id = (stringValue = "550e8400-e29b-41d4-a716-446655440000") + # )) + # preference_telemetry_endpoint = "https://firestore.googleapis.com/v1/projects/myproject/databases/(default)/documents" + + # Firestore document structure + # See: https://firebase.google.com/docs/firestore/reference/rest/v1/projects.databases.documents + response = if haskey(id_name_mapping, id) + # If document exists, endpoint would be like: + # "https://firestore.../using_rxinfer/abc123def456" + endpoint = string(rstrip(preference_telemetry_endpoint, '/'), '/', collection, '/', id_name_mapping[id]) + HTTP.patch(endpoint, headers, JSON.json(payload)) + else + # For new documents, endpoint would be like: + # "https://firestore.../using_rxinfer" + endpoint = string(rstrip(preference_telemetry_endpoint, '/'), '/', collection) + HTTP.post(endpoint, headers, JSON.json(payload)) + end + + # Parse response if successful + # Example response body: + # { + # "name": "projects/myproject/databases/(default)/documents/using_rxinfer/abc123def456", + # "fields": { ... }, + # "createTime": "2024-01-20T14:30:15.123456Z", + # "updateTime": "2024-01-20T14:30:15.123456Z" + # } + if response.status == 200 + body = JSON.parse(String(response.body)) + name = get(body, "name", nothing) + if !isnothing(name) + # Extract just the document ID ("abc123def456") from the full path + name = split(name, "/") |> last + id_name_mapping[id] = name + end + return name + end + end + return nothing +end \ No newline at end of file diff --git a/test/runtests.jl b/test/runtests.jl index bb6616bc5..b92ed15b8 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -3,6 +3,8 @@ using Aqua, CpuId, ReTestItems, RxInfer const IS_USE_DEV = get(ENV, "USE_DEV", "false") == "true" const IS_BENCHMARK = get(ENV, "BENCHMARK", "false") == "true" +ENV["LOG_USING_RXINFER"] = "false" + import Pkg if IS_USE_DEV diff --git a/test/session_tests.jl b/test/session_tests.jl index 2b306a125..d89f9f319 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -231,14 +231,14 @@ end invoke.execution_end = invoke.execution_start + Millisecond(123) output = sprint(show, invoke) - @test occursin("SessionInvoke(status=success, duration=123.0ms", output) + @test occursin("SessionInvoke(id=$(invoke.id), status=success, duration=123.0ms", output) # Test SessionStats show stats = RxInfer.SessionStats(:test) RxInfer.update_stats!(stats, invoke) output = sprint(show, stats) - @test occursin("SessionStats(label=:test, total=1, success_rate=100.0%, invokes=1/$(RxInfer.DEFAULT_SESSION_STATS_CAPACITY))", output) + @test occursin("SessionStats(id=$(stats.id), label=:test, total=1, success_rate=100.0%, invokes=1/$(RxInfer.DEFAULT_SESSION_STATS_CAPACITY))", output) # Test Session show session = RxInfer.create_session() diff --git a/test/utiltests.jl b/test/utiltests.jl index 962db1074..c45eddeef 100644 --- a/test/utiltests.jl +++ b/test/utiltests.jl @@ -1,6 +1,8 @@ import Dates: format, now using MacroTools +ENV["LOG_USING_RXINFER"] = "false" + # Some tests use plotting, this part contains helper functions to simplify executing plots """ From b286f5d87e4b8328b18ce3192184500673799a96 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 15:10:32 +0100 Subject: [PATCH 26/56] implement share session function --- src/RxInfer.jl | 18 ++-- src/telemetry.jl | 233 +++++++++++++++++++++++++++++++++++++++++- test/session_tests.jl | 2 +- 3 files changed, 242 insertions(+), 11 deletions(-) diff --git a/src/RxInfer.jl b/src/RxInfer.jl index d2211d901..1ca33de17 100644 --- a/src/RxInfer.jl +++ b/src/RxInfer.jl @@ -26,14 +26,18 @@ include("constraints/form/form_sample_list.jl") include("inference/postprocess.jl") include("inference/inference.jl") -function __init__() - if RxInfer.preference_enable_session_logging - default_session = create_session() - RxInfer.set_default_session!(default_session) - end +_isprecompiling() = ccall(:jl_generating_output, Cint, ()) == 1 - if RxInfer.preference_enable_using_rxinfer_telemetry - log_using_rxinfer() +function __init__() + if !_isprecompiling() + if RxInfer.preference_enable_session_logging + default_session = create_session() + RxInfer.set_default_session!(default_session) + end + + if RxInfer.preference_enable_using_rxinfer_telemetry + log_using_rxinfer() + end end end diff --git a/src/telemetry.jl b/src/telemetry.jl index 61b32967f..a26d48418 100644 --- a/src/telemetry.jl +++ b/src/telemetry.jl @@ -102,6 +102,10 @@ end # This is used to avoid duplicate documents in Firestore const id_name_mapping = Dict{String, String}() +# The mapping of the collection name to the allow_patch flag +# This is used to avoid pushing data to Firestore if the document already exists +const collection_allow_patch = Dict{String, Bool}("using_rxinfer" => true, "sessions" => true, "session_stats" => true, "invokes" => false) + # Adds or updates a document in Firestore based on the provided id and collection. # If a document with the same id already exists (tracked in id_name_mapping), # it updates that document instead of creating a new one to avoid duplicates. @@ -125,8 +129,18 @@ function __add_document(id, collection, payload) response = if haskey(id_name_mapping, id) # If document exists, endpoint would be like: # "https://firestore.../using_rxinfer/abc123def456" - endpoint = string(rstrip(preference_telemetry_endpoint, '/'), '/', collection, '/', id_name_mapping[id]) - HTTP.patch(endpoint, headers, JSON.json(payload)) + name = id_name_mapping[id] + endpoint = string(rstrip(preference_telemetry_endpoint, '/'), '/', collection, '/', name) + # For collections that allow patching (like using_rxinfer, sessions, session_stats), + # send a PATCH request to update the existing document with new data + if collection_allow_patch[collection] + HTTP.patch(endpoint, headers, JSON.json(payload)) + # For collections that don't allow patching (like invokes), + # return a fake successful response without making a request, + # since we don't want to update existing documents in these collections + else + (body = """{"name": "$name"}""", status = 200) + end else # For new documents, endpoint would be like: # "https://firestore.../using_rxinfer" @@ -154,4 +168,217 @@ function __add_document(id, collection, payload) end end return nothing -end \ No newline at end of file +end + +# Conversion functions between Julia objects and Firestore data types + +""" + to_firestore_value(value) + +Convert a Julia value to a Firestore-compatible value format. +Returns a NamedTuple with the appropriate Firestore field type. +""" +function to_firestore_value(value::String) + return (stringValue = value,) +end + +function to_firestore_value(value::Symbol) + return (stringValue = string(value),) +end + +function to_firestore_value(value::Integer) + return (integerValue = value,) +end + +function to_firestore_value(value::AbstractFloat) + return (doubleValue = value,) +end + +function to_firestore_value(value::DateTime) + return (timestampValue = Dates.format(value, "yyyy-mm-ddTHH:MM:SS.sssZ"),) +end + +function to_firestore_value(value::UUID) + return (stringValue = string(value),) +end + +function to_firestore_value(value::Bool) + return (booleanValue = value,) +end + +function to_firestore_value(value::Nothing) + return (nullValue = nothing,) +end + +function to_firestore_value(value::AbstractVector) + return (arrayValue = (values = [to_firestore_value(item) for item in value],),) +end + +function to_firestore_value(value::AbstractDict) + return (mapValue = (fields = Dict(string(k) => to_firestore_value(v) for (k, v) in value),),) +end + +function to_firestore_value(value::Any) + # For any other type, convert to string but include the type information + return (stringValue = string("$(typeof(value)): ", value),) +end + +""" + to_firestore_document(data::NamedTuple) + +Convert a Julia NamedTuple to a Firestore document format. +Returns a NamedTuple with fields in Firestore format. +""" +function to_firestore_document(data::NamedTuple) + return (fields = NamedTuple(k => to_firestore_value(v) for (k, v) in pairs(data)),) +end + +""" + to_firestore_session(session::Session) + +Convert a Session object to a Firestore-compatible document format. +""" +function to_firestore_session(session::Session) + return to_firestore_document((id = session.id, created_at = session.created_at, environment = session.environment)) +end + +""" + to_firestore_session_stats(stats::SessionStats, session_id::UUID) + +Convert a SessionStats object to a Firestore-compatible document format. +Includes a reference to the parent session. +""" +function to_firestore_session_stats(stats::SessionStats, session_id::UUID) + return to_firestore_document(( + id = stats.id, + session = session_id, + label = stats.label, + total_invokes = stats.total_invokes, + success_count = stats.success_count, + failed_count = stats.failed_count, + success_rate = stats.success_rate, + min_duration_ms = stats.min_duration_ms == Inf ? 0.0 : stats.min_duration_ms, + max_duration_ms = stats.max_duration_ms == -Inf ? 0.0 : stats.max_duration_ms, + total_duration_ms = stats.total_duration_ms, + context_keys = collect(stats.context_keys) + )) +end + +""" + to_firestore_invoke(invoke::SessionInvoke, stats_id::UUID) + +Convert a SessionInvoke object to a Firestore-compatible document format. +Includes a reference to the parent session stats. +""" +function to_firestore_invoke(invoke::SessionInvoke, stats_id::UUID) + return to_firestore_document(( + id = invoke.id, session_stats = stats_id, status = invoke.status, execution_start = invoke.execution_start, execution_end = invoke.execution_end, context = invoke.context + )) +end + +import ProgressMeter + +""" + share_session_data(session::Session; show_progress::Bool = true) + +Share your session data to help improve RxInfer.jl and its community. This data helps us: +- Understand how the package is used in practice +- Identify areas for improvement +- Make informed decisions about future development +- Share aggregate usage patterns in our community meetings + +The data is organized in a structured way: +1. Basic session info (Julia version, OS, etc.) +2. Anonymous statistics about different types of package usage +3. Information about individual labeled runs + +All data is anonymous and only used to improve the package. We discuss aggregate statistics +in our public community meetings to make the development process transparent and collaborative. + +# Arguments +- `session::Session`: The session object containing data to share +- `show_progress::Bool = true`: Whether to display progress bars during sharing + +# Progress Display +When `show_progress` is true (default), the function displays: +- A blue progress bar for sharing session statistics +- A green progress bar for sharing labeled runs +""" +function share_session_data(session::Session; show_progress::Bool = true) + if isnothing(preference_telemetry_endpoint) + @warn "Cannot share session data: telemetry endpoint is not set" + return nothing + end + + @info "Starting to share session data to help improve RxInfer.jl" session_id = session.id num_stats = length(session.stats) + + # Share session information + session_name = __add_document(string(session.id), "sessions", to_firestore_session(session)) + if isnothing(session_name) + @warn "Unable to share session data" session_id = session.id + return nothing + end + + # Track sharing progress + total_stats = length(session.stats) + shared_stats = 0 + total_invokes = sum(length(stats.invokes) for (_, stats) in session.stats) + shared_invokes = 0 + + # Create progress meter for stats if requested + stats_progress = show_progress ? ProgressMeter.Progress(total_stats; desc = "Sharing statistics: ", color = :blue) : nothing + + # Share session statistics + for (label, stats) in session.stats + stats_name = __add_document(string(stats.id), "session_stats", to_firestore_session_stats(stats, session.id)) + if isnothing(stats_name) + @warn "Unable to share statistics data" stats_id = stats.id label = label session_id = session.id + continue + end + shared_stats += 1 + show_progress && ProgressMeter.next!(stats_progress) + + # Create progress meter for invokes within this stats if requested + invokes_progress = show_progress ? ProgressMeter.Progress(length(stats.invokes); desc = "Sharing runs for $(label): ", color = :green) : nothing + + # Share labeled runs + invokes_shared = 0 + for invoke in stats.invokes + invoke_name = __add_document(string(invoke.id), "invokes", to_firestore_invoke(invoke, stats.id)) + if isnothing(invoke_name) + @warn "Unable to share run data" invoke_id = invoke.id stats_id = stats.id session_id = session.id + continue + end + invokes_shared += 1 + shared_invokes += 1 + show_progress && ProgressMeter.next!(invokes_progress) + end + + if invokes_shared < length(stats.invokes) + @warn "Some runs could not be shared" stats_id = stats.id label = label shared = invokes_shared total = length(stats.invokes) session_id = session.id + end + end + + # Final summary + if shared_stats < total_stats || shared_invokes < total_invokes + @warn """ + Session data sharing completed with some limitations. + We appreciate your contribution even if not all data could be shared. + """ session_id = session.id shared_stats = shared_stats total_stats = total_stats shared_invokes = shared_invokes total_invokes = total_invokes + else + @info """ + Thank you for sharing your session data! + + This helps us understand how RxInfer.jl is used and guides our improvements. + We discuss aggregate usage patterns in our public community meetings to make + the development process transparent and collaborative. + + When opening issues on GitHub at /~https://github.com/reactivebayes/RxInfer.jl/issues/new, + please include this session ID `$(session.id)` and session name: `$(session_name)` + + This helps us provide better support by understanding your usage context. + """ session_id = session.id session_name = session_name stats_count = shared_stats invokes_count = shared_invokes + end + + return nothing +end diff --git a/test/session_tests.jl b/test/session_tests.jl index d89f9f319..10006109c 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -26,7 +26,7 @@ @test session.environment[:cpu_threads] == Sys.CPU_THREADS @test session.environment[:word_size] == Sys.WORD_SIZE - if get(ENV, "CI", "false") === "true" + if get(ENV, "CI", "false") == "true" # This test breaks precompilation in VSCode, thus disabled locally, executes only in CI rxinfer_version = VersionNumber(TOML.parsefile(joinpath(pkgdir(RxInfer), "Project.toml"))["version"]) @test session.environment[:rxinfer_version] == string(rxinfer_version) From 558f67ab73ad9c058cd487f164e32b7751529d3e Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 15:14:29 +0100 Subject: [PATCH 27/56] update docs --- docs/src/index.md | 5 ++++ docs/src/manuals/debugging.md | 8 ++++++ docs/src/manuals/sharpbits/overview.md | 34 ++++++++++++++++++++++++++ 3 files changed, 47 insertions(+) diff --git a/docs/src/index.md b/docs/src/index.md index 7f08005f4..9ce6594a4 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -48,6 +48,11 @@ RxInfer aims to remedy these issues by running efficient Bayesian inference in s - High performance. - Inference procedure is differentiable. - Easy to extend with custom nodes and message update rules. +- Community-driven development and support + - Regular public meetings to discuss usage patterns and improvements + - Optional telemetry to help guide development (see [Usage Telemetry](@ref manual-usage-telemetry)) + - Active community support through GitHub discussions + - Session sharing for better debugging support (see [Session Sharing](@ref manual-session-sharing)) **Curious about how RxInfer compares to other tools you might be considering?** We invite you to view a detailed [comparison](@ref comparison), where we put RxInfer head-to-head with other popular packages in the field. diff --git a/docs/src/manuals/debugging.md b/docs/src/manuals/debugging.md index 29bb3fe58..736ac3677 100644 --- a/docs/src/manuals/debugging.md +++ b/docs/src/manuals/debugging.md @@ -2,6 +2,14 @@ Debugging inference in `RxInfer` can be quite challenging, mostly due to the reactive nature of the inference, undefined order of computations, the use of observables, and generally hard-to-read stack traces in Julia. Below we discuss ways to help you find problems in your model that prevents you from getting the results you want. +## Getting Help from the Community + +When you encounter issues that are difficult to debug, the RxInfer community is here to help. To get the most effective support: + +1. **Share Session Data**: For complex issues, you can share your session data to help us understand exactly what's happening in your model. See [Session Sharing](@ref manual-session-sharing) to learn how. + +2. **Join Community Meetings**: We discuss common issues and solutions in our regular community meetings. See [Getting Help with Issues](@ref getting-help) for more information. + ## Requesting a trace of messages `RxInfer` provides a way that allows to save the history of the computations leading up to the computed messages and marginals in the inference procedure. This history is added on top of messages and marginals and is referred to as a _Memory Addon_. Below is an example explaining how you can extract this history and use it to fix a bug. diff --git a/docs/src/manuals/sharpbits/overview.md b/docs/src/manuals/sharpbits/overview.md index 3e389e4af..2e346c1e7 100644 --- a/docs/src/manuals/sharpbits/overview.md +++ b/docs/src/manuals/sharpbits/overview.md @@ -14,9 +14,43 @@ This page serves as a collection of sharp bits - potential pitfalls and common i - [Using `=` instead of `:=` for deterministic nodes](@ref usage-colon-equality) - Why not `=`? +- [Getting Help with Issues](@ref getting-help) + - Using session IDs for better support + - Understanding telemetry benefits + - Sharing sessions for debugging + !!! note This is a community document that will be updated as we identify more common issues and their solutions. If you encounter a problem that isn't covered here, please consider opening an [issue/discussion](/~https://github.com/rxinfer/rxinfer/discussions) or contributing to this guide. +## [Getting Help with Issues](@id getting-help) + +When you encounter issues with RxInfer, we want to help you as effectively as possible. Here's how you can help us help you: + +### Session IDs and Telemetry + +RxInfer includes an optional telemetry system that can help us understand how the package is used and identify areas for improvement. By default, telemetry is disabled. If you'd like to help improve RxInfer by enabling telemetry, please see [Usage Telemetry](@ref manual-usage-telemetry) for details about: + +- How to enable telemetry +- What data is collected (only anonymous usage statistics) +- How this data helps improve RxInfer +- How we discuss aggregate patterns in our community meetings + +When telemetry is enabled and you open an issue, including your session ID helps us provide better support by understanding your usage context. + +### Sharing Sessions for Debugging + +For more complex issues, you can share your session data with us. This helps us: +- Understand exactly what's happening in your model +- Identify potential issues more quickly +- Provide more accurate solutions + +See [Session Sharing](@ref manual-session-sharing) to learn how to: +- Share your session data securely +- Control what information is shared +- Use session IDs in GitHub issues + +Remember, all data sharing is optional and under your control. We value your privacy while trying to provide the best possible support for the RxInfer community. + ## How to contribute If you have a sharp bit to share, please consider opening an [issue/discussion](/~https://github.com/rxinfer/rxinfer/discussions) or contributing to this guide. From 290697d71f62393202a60731ca42a8ccc5e942a9 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 15:17:25 +0100 Subject: [PATCH 28/56] update docs --- docs/src/manuals/sharpbits/overview.md | 30 ++---- docs/src/manuals/telemetry.md | 122 +++++++++++++++---------- 2 files changed, 85 insertions(+), 67 deletions(-) diff --git a/docs/src/manuals/sharpbits/overview.md b/docs/src/manuals/sharpbits/overview.md index 2e346c1e7..e4b4c0925 100644 --- a/docs/src/manuals/sharpbits/overview.md +++ b/docs/src/manuals/sharpbits/overview.md @@ -26,30 +26,20 @@ This page serves as a collection of sharp bits - potential pitfalls and common i When you encounter issues with RxInfer, we want to help you as effectively as possible. Here's how you can help us help you: -### Session IDs and Telemetry +### Session Data and Telemetry -RxInfer includes an optional telemetry system that can help us understand how the package is used and identify areas for improvement. By default, telemetry is disabled. If you'd like to help improve RxInfer by enabling telemetry, please see [Usage Telemetry](@ref manual-usage-telemetry) for details about: +RxInfer includes optional telemetry and session sharing features to help us provide better support and improve the package. When enabled, these features help us: -- How to enable telemetry -- What data is collected (only anonymous usage statistics) -- How this data helps improve RxInfer -- How we discuss aggregate patterns in our community meetings +- Understand how the package is used in practice +- Identify and debug issues more effectively +- Make informed decisions about improvements +- Share aggregate usage patterns in community meetings -When telemetry is enabled and you open an issue, including your session ID helps us provide better support by understanding your usage context. +For details on enabling telemetry and sharing session data, see: +- [Usage Telemetry](@ref manual-usage-telemetry) - Learn about anonymous usage statistics +- [Session Sharing](@ref manual-session-sharing) - Share session data for debugging -### Sharing Sessions for Debugging - -For more complex issues, you can share your session data with us. This helps us: -- Understand exactly what's happening in your model -- Identify potential issues more quickly -- Provide more accurate solutions - -See [Session Sharing](@ref manual-session-sharing) to learn how to: -- Share your session data securely -- Control what information is shared -- Use session IDs in GitHub issues - -Remember, all data sharing is optional and under your control. We value your privacy while trying to provide the best possible support for the RxInfer community. +All data sharing is optional and privacy-focused. When opening issues, including your session ID helps us provide more targeted support by understanding your usage context. ## How to contribute diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index 7f8b7c53c..08b236c52 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -2,62 +2,59 @@ ## [Usage Telemetry](@id manual-usage-telemetry) -RxInfer collects minimal anonymous usage statistics to help improve the package. The only data collected is: -- A timestamp of when the package is loaded -- A random UUID for deduplication +RxInfer includes an optional telemetry system that can help us understand how the package is used and guide our improvements. By default, telemetry is disabled. If you'd like to help improve RxInfer by enabling telemetry, here's what you need to know: -These statistics help us understand how RxInfer is being used and guide our development efforts. We share and discuss these numbers in our public meetings, which happen every 4 weeks. We encourage you to join our community meetings to: -- Learn about usage patterns and how others are using RxInfer -- Provide feedback and suggestions -- Help shape the future of the package -- Connect with the RxInfer community +### What We Collect -### Join Our Meetings +When telemetry is enabled, we collect minimal anonymous usage statistics: +- A timestamp of when the package is loaded +- A random UUID for deduplication +- No personal information +- No code from your sessions +- No actual data or model parameters -We hold public meetings every 4 weeks where we: -- Share and discuss usage statistics -- Present new features and improvements -- Discuss the roadmap and future development -- Answer questions from the community -- Welcome feedback and suggestions +### How This Helps -To join: -1. Check our [meeting schedule](https://dynalist.io/d/F4aA-Z2c8X-M1iWTn9hY_ndN) for the next meeting date -2. Join our [GitHub discussions](/~https://github.com/reactivebayes/RxInfer.jl/discussions) to stay updated -3. Feel free to add topics you'd like to discuss to the meeting agenda +This anonymous data helps us: +- Understand how RxInfer is used in practice +- Identify areas that need improvement +- Make informed decisions about future development +- Share aggregate usage patterns in our community meetings -We welcome participants of all experience levels - whether you're new to RxInfer or a seasoned user! +### Community Transparency -### Default Behavior +We believe in full transparency about how we use this data: +- We discuss aggregate statistics in our public meetings (every 4 weeks) +- All telemetry code is open source and can be inspected in `src/telemetry.jl` +- Failed telemetry requests are silently discarded +- All requests are asynchronous and never block your work -By default, [Usage Telemetry](@ref manual-usage-telemetry) is enabled but you can disable it in several ways: +### How to Enable/Disable Telemetry -1. Using environment variables: - ```bash - export LOG_USING_RXINFER=false - ``` +By default, telemetry is disabled. You can enable it in several ways: -2. Using Julia functions: +1. Using Julia functions: ```julia using RxInfer - RxInfer.disable_rxinfer_using_telemetry!() # Requires Julia restart + RxInfer.enable_rxinfer_using_telemetry!() # Requires Julia restart ``` -3. Setting the endpoint to `nothing`: +2. Or disable it at any time: ```julia using RxInfer - RxInfer.set_telemetry_endpoint!(nothing) # Requires Julia restart + RxInfer.disable_rxinfer_using_telemetry!() # Requires Julia restart ``` -### Configuration Functions - -The following functions are available for telemetry configuration: - -- `set_telemetry_endpoint!(endpoint)`: Set a custom telemetry endpoint or disable telemetry by setting it to `nothing` -- `disable_rxinfer_using_telemetry!()`: Disable telemetry collection (requires Julia restart) -- `enable_rxinfer_using_telemetry!()`: Enable telemetry collection (requires Julia restart) +3. Using environment variables: + ```bash + # To disable + export LOG_USING_RXINFER=false + + # To enable (default) + export LOG_USING_RXINFER=true + ``` -### When Telemetry is Disabled +### When Telemetry is Automatically Disabled Telemetry is automatically disabled in the following cases: 1. When running in CI environments (detected via `CI=true` environment variable) @@ -65,15 +62,46 @@ Telemetry is automatically disabled in the following cases: 3. When telemetry is disabled via `disable_rxinfer_using_telemetry!()` 4. When the telemetry endpoint is set to `nothing` -### Privacy Considerations - -- No personal information is collected -- No code from your sessions is transmitted, but you can share your sessions if you want to help us to debug issues and improve the package. Read more about [session sharing](@ref manual-session-sharing) -- All requests are made asynchronously and will never block or affect your work -- Failed telemetry requests are silently discarded -- The code is open source and can be inspected in the `src/telemetry.jl` file -- Usage statistics are shared during our public meetings +```@docs +RxInfer.disable_rxinfer_using_telemetry! +RxInfer.enable_rxinfer_using_telemetry! +RxInfer.set_telemetry_endpoint! +``` ## [Session Sharing](@id manual-session-sharing) -Please, first read the [Session Summary](@ref manual-session-summary) manual to understand the basic concepts of RxInfer sessions. \ No newline at end of file +For more complex scenarios, like debugging issues or getting help from the community, you can choose to share your session data. This is separate from telemetry and gives us more context to help solve problems. + +### What Session Data Contains + +When you share a session, it includes: +- Basic session info (Julia version, OS, etc.) +- Anonymous statistics about different types of package usage +- Information about individual labeled runs +- No personal information or sensitive data + +### How to Share Sessions + +You can share your session data using the `share_session_data` function: + +```@docs +RxInfer.share_session_data +``` + +### Using Session IDs in Issues + +When you share a session and then open a GitHub issue, include your session ID. This helps us: +- Link your issue to the shared session data +- Understand your usage context +- Provide more accurate and helpful support + +### Privacy and Control + +Remember: +- Session sharing is completely optional +- All statistics are anonymous +- No actual data is shared, only meta information, e.g. type of the data, number of observations, etc. +- You can inspect the sharing code in `src/telemetry.jl` +- We only use this data to help improve RxInfer and provide better support + +We appreciate your help in making RxInfer better! Whether you choose to enable telemetry or share sessions, your contribution helps us improve the package for everyone. \ No newline at end of file From b47ecaa916be86d8a5144727fb32ff3b524cc5fe Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 15:43:33 +0100 Subject: [PATCH 29/56] fix documentation build --- docs/src/manuals/telemetry.md | 26 ++++++++++++++++++-------- src/inference/inference.jl | 23 ++++++++++++++--------- src/session.jl | 3 +++ src/telemetry.jl | 16 ++++++++++++---- 4 files changed, 47 insertions(+), 21 deletions(-) diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index 08b236c52..fd4150d72 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -2,22 +2,22 @@ ## [Usage Telemetry](@id manual-usage-telemetry) -RxInfer includes an optional telemetry system that can help us understand how the package is used and guide our improvements. By default, telemetry is disabled. If you'd like to help improve RxInfer by enabling telemetry, here's what you need to know: +RxInfer includes an optional telemetry system that can help us understand how the package is used and guide our improvements. + +```@docs +RxInfer.log_using_rxinfer +``` ### What We Collect -When telemetry is enabled, we collect minimal anonymous usage statistics: +We collect minimal anonymous usage statistics: - A timestamp of when the package is loaded - A random UUID for deduplication -- No personal information -- No code from your sessions -- No actual data or model parameters ### How This Helps This anonymous data helps us: - Understand how RxInfer is used in practice -- Identify areas that need improvement - Make informed decisions about future development - Share aggregate usage patterns in our community meetings @@ -31,7 +31,7 @@ We believe in full transparency about how we use this data: ### How to Enable/Disable Telemetry -By default, telemetry is disabled. You can enable it in several ways: +You can interact with telemetry in several ways: 1. Using Julia functions: ```julia @@ -104,4 +104,14 @@ Remember: - You can inspect the sharing code in `src/telemetry.jl` - We only use this data to help improve RxInfer and provide better support -We appreciate your help in making RxInfer better! Whether you choose to enable telemetry or share sessions, your contribution helps us improve the package for everyone. \ No newline at end of file +We appreciate your help in making RxInfer better! Whether you choose to enable telemetry or share sessions, your contribution helps us improve the package for everyone. + +## Developers Reference + +```@docs +RxInfer.to_firestore_invoke +RxInfer.to_firestore_value +RxInfer.to_firestore_session +RxInfer.to_firestore_document +RxInfer.to_firestore_session_stats +``` \ No newline at end of file diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 9141ad9fb..b630da00c 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -137,7 +137,7 @@ function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) # Prepare data for the table last_invokes = collect(Iterators.take(Iterators.reverse(invokes), n_last)) - data = Matrix{String}(undef, length(last_invokes), 5) + data = Matrix{String}(undef, length(last_invokes), 6) for (i, invoke) in enumerate(last_invokes) status = string(invoke.status) @@ -155,16 +155,18 @@ function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) end error_str = string(get(invoke.context, :error, "")) - - data[i, 1] = status - data[i, 2] = "$(duration)ms" - data[i, 3] = model - data[i, 4] = data_str - data[i, 5] = error_str + invoke_id = string(invoke.id)[1:8] * "..." + + data[i, 1] = invoke_id + data[i, 2] = status + data[i, 3] = "$(duration)ms" + data[i, 4] = model + data[i, 5] = data_str + data[i, 6] = error_str end - header = (["Status", "Duration", "Model", "Data", "Error"],) - pretty_table(io, data; header = header, tf = tf_unicode_rounded, maximum_columns_width = [8, 10, 35, 25, 25], autowrap = true, linebreaks = true) + header = (["ID", "Status", "Duration", "Model", "Data", "Error"],) + pretty_table(io, data; header = header, tf = tf_unicode_rounded, maximum_columns_width = [12, 8, 10, 35, 25, 25], autowrap = true, linebreaks = true) end end @@ -240,6 +242,8 @@ function inference_process_error(error, rethrow) /~https://github.com/ReactiveBayes/RxInfer.jl/discussions - Report a bug or request a feature: /~https://github.com/ReactiveBayes/RxInfer.jl/issues + - (Optional) Share your session data with `RxInfer.share_session_data()` to help us better understand the issue + https://reactivebayes.github.io/RxInfer.jl/stable/manuals/telemetry/ Note that we use GitHub discussions not just for technical questions! We welcome all kinds of discussions, whether you're new to Bayesian inference, have questions about use cases, or just want to share your experience. @@ -247,6 +251,7 @@ function inference_process_error(error, rethrow) To help us help you, please include: - A minimal example that reproduces the issue - The complete error message and stack trace + - (Optional) If you shared your session data, please include the session ID in the issue Use `RxInfer.disable_inference_error_hint!()` to disable this message. """ diff --git a/src/session.jl b/src/session.jl index bd9d46aa2..dd00737e1 100644 --- a/src/session.jl +++ b/src/session.jl @@ -358,6 +358,9 @@ function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.de # Call label-specific summary with n_last parameter summarize_invokes(io, Val(label), invokes; n_last = n_last) + println(io, "\nTip: Share this session with `RxInfer.share_session_data()` to help improve RxInfer") + println(io, " and get better support when reporting issues.") + return nothing end diff --git a/src/telemetry.jl b/src/telemetry.jl index a26d48418..316d826a1 100644 --- a/src/telemetry.jl +++ b/src/telemetry.jl @@ -279,7 +279,7 @@ end import ProgressMeter """ - share_session_data(session::Session; show_progress::Bool = true) + share_session_data(session = RxInfer.default_session(); show_progress::Bool = true) Share your session data to help improve RxInfer.jl and its community. This data helps us: - Understand how the package is used in practice @@ -304,9 +304,14 @@ When `show_progress` is true (default), the function displays: - A blue progress bar for sharing session statistics - A green progress bar for sharing labeled runs """ -function share_session_data(session::Session; show_progress::Bool = true) +function share_session_data(session::Union{Session, Nothing} = RxInfer.default_session(); show_progress::Bool = true) if isnothing(preference_telemetry_endpoint) - @warn "Cannot share session data: telemetry endpoint is not set" + @warn "Cannot share session data: telemetry endpoint is not set. See `RxInfer.set_telemetry_endpoint!()`" + return nothing + end + + if isnothing(session) + @warn "Cannot share session data: session logging is not enabled. See `RxInfer.enable_session_logging!()`" return nothing end @@ -374,7 +379,10 @@ function share_session_data(session::Session; show_progress::Bool = true) the development process transparent and collaborative. When opening issues on GitHub at /~https://github.com/reactivebayes/RxInfer.jl/issues/new, - please include this session ID `$(session.id)` and session name: `$(session_name)` + please include this session ID `$(session.id)` and session name: `$(session_name)`. + + Optionally, provide IDs of individual runs that you are interested in. + Call `RxInfer.summarize_session()` to get the list of run IDs. This helps us provide better support by understanding your usage context. """ session_id = session.id session_name = session_name stats_count = shared_stats invokes_count = shared_invokes From a7b1e9136f21fa77c5d6dbec14c81120d1d3108d Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 15:44:59 +0100 Subject: [PATCH 30/56] adjust docs --- docs/src/manuals/migration-guide-v2-v3.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/src/manuals/migration-guide-v2-v3.md b/docs/src/manuals/migration-guide-v2-v3.md index 8ecd0b44f..cc7ae70fa 100644 --- a/docs/src/manuals/migration-guide-v2-v3.md +++ b/docs/src/manuals/migration-guide-v2-v3.md @@ -12,7 +12,7 @@ The most notable change in the model specification is the removal of the `random Now, the `@model` macro automatically determines whether to use `randomvar` or `constvar` based on their usage. Previously declared `datavar` variables must now be listed in the argument list of the model. -The following example is a simple model definition in version 3: +The following example is a simple model definition in previous version: ```julia @model function SSM(n, x0, A, B, Q, P) x = randomvar(n) @@ -27,7 +27,7 @@ The following example is a simple model definition in version 3: end ``` -The equivalent model definition in version 4 is as follows: +The equivalent model definition in the new version is as follows: ```julia @model function SSM(y, prior_x, A, B, Q, P) x_prev ~ prior_x From 0198ae4f042efb94960c0d492b438f8083d6842d Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 17:58:04 +0100 Subject: [PATCH 31/56] add an option to opt-in to automatic telemetry --- Project.toml | 2 + docs/src/manuals/telemetry.md | 35 +++++++++++---- src/session.jl | 55 +++++++++++++++++++++--- src/telemetry.jl | 81 ++++++++++++++++++++++------------- test/session_tests.jl | 6 +-- 5 files changed, 132 insertions(+), 47 deletions(-) diff --git a/Project.toml b/Project.toml index 50125b1e6..9e96fd4a1 100644 --- a/Project.toml +++ b/Project.toml @@ -15,6 +15,7 @@ GraphPPL = "b3f8163a-e979-4e85-b43e-1f63d8c8b42c" HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3" JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +Logging = "56ddb016-857b-54e1-b83d-db4d58db5568" MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" Optim = "429524aa-4258-5aef-a3af-852621145aeb" Preferences = "21216c6a-2e73-6563-6e65-726566657250" @@ -48,6 +49,7 @@ GraphPPL = "~4.6.0" HTTP = "1.10" JSON = "0.21.4" LinearAlgebra = "1.9" +Logging = "1.10.0" MacroTools = "0.5.6" Optim = "1.0.0" Preferences = "1.4.3" diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index fd4150d72..4a9753823 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -2,22 +2,22 @@ ## [Usage Telemetry](@id manual-usage-telemetry) -RxInfer includes an optional telemetry system that can help us understand how the package is used and guide our improvements. - -```@docs -RxInfer.log_using_rxinfer -``` +RxInfer includes an optional telemetry system that can help us understand how the package is used and guide our improvements. By default, telemetry is disabled. If you'd like to help improve RxInfer by enabling telemetry, here's what you need to know: ### What We Collect -We collect minimal anonymous usage statistics: +When telemetry is enabled, we collect minimal anonymous usage statistics: - A timestamp of when the package is loaded - A random UUID for deduplication +- No personal information +- No code from your sessions +- No actual data or model parameters ### How This Helps This anonymous data helps us: - Understand how RxInfer is used in practice +- Identify areas that need improvement - Make informed decisions about future development - Share aggregate usage patterns in our community meetings @@ -31,7 +31,7 @@ We believe in full transparency about how we use this data: ### How to Enable/Disable Telemetry -You can interact with telemetry in several ways: +By default, telemetry is disabled. You can enable it in several ways: 1. Using Julia functions: ```julia @@ -82,12 +82,31 @@ When you share a session, it includes: ### How to Share Sessions -You can share your session data using the `share_session_data` function: +You can share your session data either manually or automatically. + +#### Manual Sharing + +Use the `share_session_data` function to manually share your session: ```@docs RxInfer.share_session_data ``` +#### Automatic Sharing + +You can enable automatic session sharing after each inference call: + +```@docs +RxInfer.enable_automatic_session_sharing! +RxInfer.disable_automatic_session_sharing! +``` + +When automatic sharing is enabled: +- Session data is shared after each inference call +- Sharing is done asynchronously (won't block your code) +- No progress bars or messages are shown +- Failed sharing attempts are silently ignored + ### Using Session IDs in Issues When you share a session and then open a GitHub issue, include your session ID. This helps us: diff --git a/src/session.jl b/src/session.jl index dd00737e1..01981c9a4 100644 --- a/src/session.jl +++ b/src/session.jl @@ -1,8 +1,9 @@ -using Dates, UUIDs, Preferences +using Dates, UUIDs, Preferences, Logging import DataStructures: CircularBuffer, capacity preference_enable_session_logging = @load_preference("enable_session_logging", true) +const preference_automatic_session_sharing = @load_preference("automatic_session_sharing", false) """ SessionInvoke @@ -222,6 +223,17 @@ function update_session!(session::Session, label::Symbol, invoke::SessionInvoke) # Update stats with new invoke update_stats!(stats, invoke) + + # Share session data automatically if enabled and invoke was successful + if preference_automatic_session_sharing + Base.Threads.@spawn try + Logging.with_logger(Logging.NullLogger()) do + share_session_data(session, stats, [invoke], show_progress = false) + end + catch e + nothing + end + end end end @@ -343,9 +355,9 @@ function summarize_session(io::IO, session::Union{Session, Nothing} = RxInfer.de println(io, "Success rate: $(round(stats.success_rate * 100, digits=1))%") println(io, "Failed invokes: $(stats.failed_count)") - mean_execution = round(stats.total_duration_ms / max(1, stats.total_invokes), digits=2) - min_execution = stats.min_duration_ms == Inf ? 0.0 : round(stats.min_duration_ms, digits=2) - max_execution = stats.max_duration_ms == -Inf ? 0.0 : round(stats.max_duration_ms, digits=2) + mean_execution = round(stats.total_duration_ms / max(1, stats.total_invokes), digits = 2) + min_execution = stats.min_duration_ms == Inf ? 0.0 : round(stats.min_duration_ms, digits = 2) + max_execution = stats.max_duration_ms == -Inf ? 0.0 : round(stats.max_duration_ms, digits = 2) println(io, "Average execution time ", mean_execution, "ms (min: ", min_execution, "ms, max: ", max_execution, "ms)") println(io, "Context keys: $(join(collect(stats.context_keys), ", "))") @@ -386,14 +398,43 @@ end # Show methods for nice printing function Base.show(io::IO, invoke::SessionInvoke) - duration_ms = round(Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)), digits=2) + duration_ms = round(Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)), digits = 2) print(io, "SessionInvoke(id=$(invoke.id), status=$(invoke.status), duration=$(duration_ms)ms, context_keys=[$(join(keys(invoke.context), ", "))])") end function Base.show(io::IO, stats::SessionStats) - print(io, "SessionStats(id=$(stats.id), label=:$(stats.label), total=$(stats.total_invokes), success_rate=$(round(stats.success_rate * 100, digits=1))%, invokes=$(length(stats.invokes))/$(capacity(stats.invokes)))") + print( + io, + "SessionStats(id=$(stats.id), label=:$(stats.label), total=$(stats.total_invokes), success_rate=$(round(stats.success_rate * 100, digits=1))%, invokes=$(length(stats.invokes))/$(capacity(stats.invokes)))" + ) end function Base.show(io::IO, session::Session) print(io, "Session(id=$(session.id), labels=[$(join(keys(session.stats), ", "))])") -end \ No newline at end of file +end + +""" + enable_automatic_session_sharing!() + +Enable automatic session sharing after each inference call. The change requires a Julia session restart to take effect. +When enabled, session data will be automatically shared after each successful inference call. +This helps improve RxInfer by providing usage patterns and helps with debugging issues. + +See also: [`disable_automatic_session_sharing!`](@ref), [`share_session_data`](@ref) +""" +function enable_automatic_session_sharing!() + @set_preferences!("automatic_session_sharing" => true) + @info "Automatic session sharing enabled. Restart Julia for the change to take effect." +end + +""" + disable_automatic_session_sharing!() + +Disable automatic session sharing after inference calls. The change requires a Julia session restart to take effect. + +See also: [`enable_automatic_session_sharing!`](@ref), [`share_session_data`](@ref) +""" +function disable_automatic_session_sharing!() + @set_preferences!("automatic_session_sharing" => false) + @info "Automatic session sharing disabled. Restart Julia for the change to take effect." +end diff --git a/src/telemetry.jl b/src/telemetry.jl index 316d826a1..94ead6b07 100644 --- a/src/telemetry.jl +++ b/src/telemetry.jl @@ -135,9 +135,9 @@ function __add_document(id, collection, payload) # send a PATCH request to update the existing document with new data if collection_allow_patch[collection] HTTP.patch(endpoint, headers, JSON.json(payload)) - # For collections that don't allow patching (like invokes), - # return a fake successful response without making a request, - # since we don't want to update existing documents in these collections + # For collections that don't allow patching (like invokes), + # return a fake successful response without making a request, + # since we don't want to update existing documents in these collections else (body = """{"name": "$name"}""", status = 200) end @@ -317,6 +317,19 @@ function share_session_data(session::Union{Session, Nothing} = RxInfer.default_s @info "Starting to share session data to help improve RxInfer.jl" session_id = session.id num_stats = length(session.stats) + if !preference_automatic_session_sharing + @info """ + The data collection is disabled by default. + If you would like to opt in to sharing your session data automatically, + call `RxInfer.enable_automatic_session_sharing!()`. + """ + else + @info """ + You have opted in to sharing your session data automatically. + If you would like to opt out, call `RxInfer.disable_automatic_session_sharing!()`. + """ + end + # Share session information session_name = __add_document(string(session.id), "sessions", to_firestore_session(session)) if isnothing(session_name) @@ -334,34 +347,10 @@ function share_session_data(session::Union{Session, Nothing} = RxInfer.default_s stats_progress = show_progress ? ProgressMeter.Progress(total_stats; desc = "Sharing statistics: ", color = :blue) : nothing # Share session statistics - for (label, stats) in session.stats - stats_name = __add_document(string(stats.id), "session_stats", to_firestore_session_stats(stats, session.id)) - if isnothing(stats_name) - @warn "Unable to share statistics data" stats_id = stats.id label = label session_id = session.id - continue - end + for (_, stats) in session.stats + shared_invokes += share_session_data(session, stats; show_progress = show_progress) shared_stats += 1 show_progress && ProgressMeter.next!(stats_progress) - - # Create progress meter for invokes within this stats if requested - invokes_progress = show_progress ? ProgressMeter.Progress(length(stats.invokes); desc = "Sharing runs for $(label): ", color = :green) : nothing - - # Share labeled runs - invokes_shared = 0 - for invoke in stats.invokes - invoke_name = __add_document(string(invoke.id), "invokes", to_firestore_invoke(invoke, stats.id)) - if isnothing(invoke_name) - @warn "Unable to share run data" invoke_id = invoke.id stats_id = stats.id session_id = session.id - continue - end - invokes_shared += 1 - shared_invokes += 1 - show_progress && ProgressMeter.next!(invokes_progress) - end - - if invokes_shared < length(stats.invokes) - @warn "Some runs could not be shared" stats_id = stats.id label = label shared = invokes_shared total = length(stats.invokes) session_id = session.id - end end # Final summary @@ -390,3 +379,37 @@ function share_session_data(session::Union{Session, Nothing} = RxInfer.default_s return nothing end + +function share_session_data(session::Session, stats::SessionStats; show_progress::Bool = true) + return share_session_data(session, stats, stats.invokes; show_progress = show_progress) +end + +function share_session_data(session::Session, stats::SessionStats, invokes; show_progress::Bool = true) + label = stats.label + stats_name = __add_document(string(stats.id), "session_stats", to_firestore_session_stats(stats, session.id)) + if isnothing(stats_name) + @warn "Unable to share statistics data" stats_id = stats.id label = label session_id = session.id + return nothing + end + + # Create progress meter for invokes within this stats if requested + invokes_progress = show_progress ? ProgressMeter.Progress(length(invokes); desc = "Sharing runs for $(label): ", color = :green) : nothing + + # Share labeled runs + invokes_shared = 0 + for invoke in invokes + invoke_name = __add_document(string(invoke.id), "invokes", to_firestore_invoke(invoke, stats.id)) + if isnothing(invoke_name) + @warn "Unable to share run data" invoke_id = invoke.id stats_id = stats.id session_id = session.id + continue + end + invokes_shared += 1 + show_progress && ProgressMeter.next!(invokes_progress) + end + + if invokes_shared < length(invokes) + @warn "Some runs could not be shared" stats_id = stats.id label = label shared = invokes_shared total = length(stats.invokes) session_id = session.id + end + + return invokes_shared +end diff --git a/test/session_tests.jl b/test/session_tests.jl index 10006109c..7f77725aa 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -229,14 +229,14 @@ end invoke = RxInfer.create_invoke() invoke.status = :success invoke.execution_end = invoke.execution_start + Millisecond(123) - + output = sprint(show, invoke) @test occursin("SessionInvoke(id=$(invoke.id), status=success, duration=123.0ms", output) # Test SessionStats show stats = RxInfer.SessionStats(:test) RxInfer.update_stats!(stats, invoke) - + output = sprint(show, stats) @test occursin("SessionStats(id=$(stats.id), label=:test, total=1, success_rate=100.0%, invokes=1/$(RxInfer.DEFAULT_SESSION_STATS_CAPACITY))", output) @@ -244,7 +244,7 @@ end session = RxInfer.create_session() RxInfer.update_session!(session, :test, invoke) RxInfer.update_session!(session, :other, invoke) - + output = sprint(show, session) @test occursin("Session(id=$(session.id), labels=", output) @test occursin("test", output) From e242678859ebaeb0cd9a01c097d2dd702028ed9a Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 18:18:26 +0100 Subject: [PATCH 32/56] fix Aqua tests --- Project.toml | 1 + docs/src/manuals/telemetry.md | 6 ++++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/Project.toml b/Project.toml index 9e96fd4a1..1c55d5b09 100644 --- a/Project.toml +++ b/Project.toml @@ -53,6 +53,7 @@ Logging = "1.10.0" MacroTools = "0.5.6" Optim = "1.0.0" Preferences = "1.4.3" +PrettyTables = "2" ProgressMeter = "1.0.0" Random = "1.9" ReactiveMP = "~4.6.0" diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index 4a9753823..34602a4c6 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -94,7 +94,7 @@ RxInfer.share_session_data #### Automatic Sharing -You can enable automatic session sharing after each inference call: +You can enable automatic session sharing: ```@docs RxInfer.enable_automatic_session_sharing! @@ -102,11 +102,13 @@ RxInfer.disable_automatic_session_sharing! ``` When automatic sharing is enabled: -- Session data is shared after each inference call +- Session is shared automatically - Sharing is done asynchronously (won't block your code) - No progress bars or messages are shown - Failed sharing attempts are silently ignored +To check your preference, inspect the `RxInfer.preference_automatic_session_sharing` variable or your `LocalPreferences.toml` file. Note that automatic sharing is disabled by default. + ### Using Session IDs in Issues When you share a session and then open a GitHub issue, include your session ID. This helps us: From fbc46f7e525a03ed32a619e9187c3647335cc486 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Tue, 4 Feb 2025 18:56:06 +0100 Subject: [PATCH 33/56] include missing docstring in the manual --- docs/src/manuals/telemetry.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index 34602a4c6..0c67d884b 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -54,6 +54,10 @@ By default, telemetry is disabled. You can enable it in several ways: export LOG_USING_RXINFER=true ``` +```@docs +RxInfer.log_using_rxinfer +``` + ### When Telemetry is Automatically Disabled Telemetry is automatically disabled in the following cases: From ac92c8536660c4749b1d970dcb435dc1eb3ad67a Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Wed, 5 Feb 2025 11:19:29 +0100 Subject: [PATCH 34/56] make manual more transparent --- docs/src/manuals/telemetry.md | 97 ++++++++++++----------------------- 1 file changed, 34 insertions(+), 63 deletions(-) diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index 0c67d884b..e5a07065d 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -1,72 +1,42 @@ # RxInfer Usage Telemetry -## [Usage Telemetry](@id manual-usage-telemetry) +RxInfer has two separate telemetry features: +1. A minimal package usage counter (enabled by default) +2. Optional session sharing for better support and development insights -RxInfer includes an optional telemetry system that can help us understand how the package is used and guide our improvements. By default, telemetry is disabled. If you'd like to help improve RxInfer by enabling telemetry, here's what you need to know: +Users are welcome to join our regular online meetings where we analyze the collected data and discuss how it helps shape RxInfer's development. -### What We Collect +## Package Usage Counter -When telemetry is enabled, we collect minimal anonymous usage statistics: -- A timestamp of when the package is loaded -- A random UUID for deduplication -- No personal information -- No code from your sessions -- No actual data or model parameters +By default, RxInfer counts how many times the package is loaded via `using RxInfer`. This counter: +- Only records a timestamp and a random UUID for deduplication +- UUIDs are not persistent and are re-generated for each session +- Does not collect any code, data, or environment information +- Is completely anonymous +- Helps us understand how widely RxInfer is used -### How This Helps +### Disabling Package Usage Counter -This anonymous data helps us: -- Understand how RxInfer is used in practice -- Identify areas that need improvement -- Make informed decisions about future development -- Share aggregate usage patterns in our community meetings - -### Community Transparency - -We believe in full transparency about how we use this data: -- We discuss aggregate statistics in our public meetings (every 4 weeks) -- All telemetry code is open source and can be inspected in `src/telemetry.jl` -- Failed telemetry requests are silently discarded -- All requests are asynchronous and never block your work - -### How to Enable/Disable Telemetry - -By default, telemetry is disabled. You can enable it in several ways: +You can disable the counter in several ways: 1. Using Julia functions: - ```julia - using RxInfer - RxInfer.enable_rxinfer_using_telemetry!() # Requires Julia restart - ``` - -2. Or disable it at any time: ```julia using RxInfer RxInfer.disable_rxinfer_using_telemetry!() # Requires Julia restart ``` -3. Using environment variables: +2. Using environment variables: ```bash - # To disable export LOG_USING_RXINFER=false - - # To enable (default) - export LOG_USING_RXINFER=true ``` -```@docs -RxInfer.log_using_rxinfer -``` - -### When Telemetry is Automatically Disabled - -Telemetry is automatically disabled in the following cases: -1. When running in CI environments (detected via `CI=true` environment variable) -2. When `LOG_USING_RXINFER=false` environment variable is set -3. When telemetry is disabled via `disable_rxinfer_using_telemetry!()` -4. When the telemetry endpoint is set to `nothing` +The counter is also automatically disabled in: +1. CI environments (detected via `CI=true` environment variable) +2. When telemetry is disabled via `disable_rxinfer_using_telemetry!()` +3. When the telemetry endpoint is set to `nothing` ```@docs +RxInfer.log_using_rxinfer RxInfer.disable_rxinfer_using_telemetry! RxInfer.enable_rxinfer_using_telemetry! RxInfer.set_telemetry_endpoint! @@ -74,15 +44,12 @@ RxInfer.set_telemetry_endpoint! ## [Session Sharing](@id manual-session-sharing) -For more complex scenarios, like debugging issues or getting help from the community, you can choose to share your session data. This is separate from telemetry and gives us more context to help solve problems. - -### What Session Data Contains +RxInfer includes a built-in session tracking feature (detailed in [Session Summary](@ref manual-session-summary)) that helps you monitor and debug your inference tasks. You can choose to share these sessions with core developers to: +- Get better support when encountering issues +- Help improve RxInfer through real-world usage insights +- Contribute to community-driven development -When you share a session, it includes: -- Basic session info (Julia version, OS, etc.) -- Anonymous statistics about different types of package usage -- Information about individual labeled runs -- No personal information or sensitive data +Read more about what data is present in the session history in the [Session Summary](@ref manual-session-summary) manual. ### How to Share Sessions @@ -98,7 +65,7 @@ RxInfer.share_session_data #### Automatic Sharing -You can enable automatic session sharing: +You can enable automatic session sharing after each session update: ```@docs RxInfer.enable_automatic_session_sharing! @@ -106,13 +73,11 @@ RxInfer.disable_automatic_session_sharing! ``` When automatic sharing is enabled: -- Session is shared automatically +- Session data is shared after each session update - Sharing is done asynchronously (won't block your code) - No progress bars or messages are shown - Failed sharing attempts are silently ignored -To check your preference, inspect the `RxInfer.preference_automatic_session_sharing` variable or your `LocalPreferences.toml` file. Note that automatic sharing is disabled by default. - ### Using Session IDs in Issues When you share a session and then open a GitHub issue, include your session ID. This helps us: @@ -120,12 +85,18 @@ When you share a session and then open a GitHub issue, include your session ID. - Understand your usage context - Provide more accurate and helpful support +### Deleting Shared Data + +If you wish to delete previously shared session data, you can contact the core developers through GitHub issues at [RxInfer.jl](/~https://github.com/ReactiveBayes/RxInfer.jl) or anonymously with the following [form](https://docs.google.com/forms/d/e/1FAIpQLSfLF5HcJODLyvovh0vOTjkh0b8it1GDUlyViqpDH06BxVbyYA/viewform?usp=sharing). + +When requesting deletion, you must provide the session UUID. Without this identifier, we cannot trace specific sessions back to individual users. See the [Session Summary](@ref manual-session-summary) manual for details on how to obtain your session ID. + ### Privacy and Control Remember: - Session sharing is completely optional -- All statistics are anonymous -- No actual data is shared, only meta information, e.g. type of the data, number of observations, etc. +- All statistics are anonymous, UUIDs are not persistent and are re-generated for each session +- No actual data is shared, only meta information (e.g., type of data, number of observations) - You can inspect the sharing code in `src/telemetry.jl` - We only use this data to help improve RxInfer and provide better support From 088a60103dd35186ad580b96b1ad2f47b8ea9bea Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Wed, 5 Feb 2025 11:49:42 +0100 Subject: [PATCH 35/56] refine docs --- docs/src/index.md | 2 +- docs/src/manuals/sharpbits/overview.md | 10 ++++------ docs/src/manuals/telemetry.md | 2 +- 3 files changed, 6 insertions(+), 8 deletions(-) diff --git a/docs/src/index.md b/docs/src/index.md index 9ce6594a4..456b7d3f8 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -50,8 +50,8 @@ RxInfer aims to remedy these issues by running efficient Bayesian inference in s - Easy to extend with custom nodes and message update rules. - Community-driven development and support - Regular public meetings to discuss usage patterns and improvements - - Optional telemetry to help guide development (see [Usage Telemetry](@ref manual-usage-telemetry)) - Active community support through GitHub discussions + - Optional telemetry to help guide development (see [Usage Telemetry](@ref manual-usage-telemetry)) - Session sharing for better debugging support (see [Session Sharing](@ref manual-session-sharing)) **Curious about how RxInfer compares to other tools you might be considering?** We invite you to view a detailed [comparison](@ref comparison), where we put RxInfer head-to-head with other popular packages in the field. diff --git a/docs/src/manuals/sharpbits/overview.md b/docs/src/manuals/sharpbits/overview.md index e4b4c0925..4f5246466 100644 --- a/docs/src/manuals/sharpbits/overview.md +++ b/docs/src/manuals/sharpbits/overview.md @@ -2,6 +2,9 @@ This page serves as a collection of sharp bits - potential pitfalls and common issues you might encounter while using RxInfer. While RxInfer is designed to be user-friendly, there are certain scenarios where you might encounter unexpected behavior or errors. Understanding these can help you avoid common problems and debug your code more effectively. +!!! note + See [Session Data and Telemetry](@ref sharpbits-telemetry-note) for more information on how to share sessions for better support. + - [Rule Not Found Error](@ref rule-not-found) - What causes it - How to diagnose and fix it @@ -14,11 +17,6 @@ This page serves as a collection of sharp bits - potential pitfalls and common i - [Using `=` instead of `:=` for deterministic nodes](@ref usage-colon-equality) - Why not `=`? -- [Getting Help with Issues](@ref getting-help) - - Using session IDs for better support - - Understanding telemetry benefits - - Sharing sessions for debugging - !!! note This is a community document that will be updated as we identify more common issues and their solutions. If you encounter a problem that isn't covered here, please consider opening an [issue/discussion](/~https://github.com/rxinfer/rxinfer/discussions) or contributing to this guide. @@ -26,7 +24,7 @@ This page serves as a collection of sharp bits - potential pitfalls and common i When you encounter issues with RxInfer, we want to help you as effectively as possible. Here's how you can help us help you: -### Session Data and Telemetry +### [Session Data and Telemetry](@id sharpbits-telemetry-note) RxInfer includes optional telemetry and session sharing features to help us provide better support and improve the package. When enabled, these features help us: diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index e5a07065d..965698093 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -1,4 +1,4 @@ -# RxInfer Usage Telemetry +# [RxInfer Usage Telemetry](@id manual-usage-telemetry) RxInfer has two separate telemetry features: 1. A minimal package usage counter (enabled by default) From 5a09e50dce015eed2e7888ec1d73f56ce91fae11 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 6 Feb 2025 09:26:24 +0100 Subject: [PATCH 36/56] checkpoint --- docs/src/manuals/session_summary.md | 3 +++ src/inference/inference.jl | 4 ++++ src/telemetry.jl | 2 +- test/inference/inference_tests.jl | 11 +++++++++++ 4 files changed, 19 insertions(+), 1 deletion(-) diff --git a/docs/src/manuals/session_summary.md b/docs/src/manuals/session_summary.md index d6876f1b6..a70ae232e 100644 --- a/docs/src/manuals/session_summary.md +++ b/docs/src/manuals/session_summary.md @@ -2,6 +2,9 @@ RxInfer provides a built-in session logging system that helps track and analyze various aspects of RxInfer usages. This feature is particularly useful for debugging, performance monitoring, and understanding the behavior of your inference models. +!!! note + Sessions are **not** shared and are intended for your personal use. However, you can opt-in to share your session data with the RxInfer team. See [RxInfer Usage Telemetry](@ref manual-usage-telemetry) for more details. + ## Overview Session logging in RxInfer automatically captures and maintains statistics for: diff --git a/src/inference/inference.jl b/src/inference/inference.jl index b630da00c..3f8900748 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -120,6 +120,10 @@ log_data_entries(data) = :unknown log_data_entries(data::Union{NamedTuple, Dict}) = log_data_entries_from_pairs(pairs(data)) log_data_entries_from_pairs(pairs) = collect(Iterators.map(log_data_entry, pairs)) +function Base.show(io::IO, entry::InferenceLoggedDataEntry) + print(io, "data: ", entry.name, " (type=", entry.type, ", size=", entry.size, ", elsize=", entry.elsize, ")") +end + using PrettyTables function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) diff --git a/src/telemetry.jl b/src/telemetry.jl index 94ead6b07..0b41b0a44 100644 --- a/src/telemetry.jl +++ b/src/telemetry.jl @@ -220,7 +220,7 @@ end function to_firestore_value(value::Any) # For any other type, convert to string but include the type information - return (stringValue = string("$(typeof(value)): ", value),) + return (stringValue = repr(value),) end """ diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index d1f4faed5..35f80efc0 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -239,6 +239,17 @@ end end end +@testitem "session context log_data_entry string representation" begin + import RxInfer: log_data_entry + + @testset "repr formatting" begin + @test repr(log_data_entry(:x => 1.5)) == "data: x (type=Float64, size=(), elsize=())" + @test repr(log_data_entry(:y => [1.0, 2.0, 3.0])) == "data: y (type=Vector{Float64}, size=(3,), elsize=())" + @test repr(log_data_entry(:z => [[1,2], [3,4]])) == "data: z (type=Vector{Vector{Int64}}, size=(2,), elsize=(2,))" + @test repr(log_data_entry(:w => missing)) == "data: w (type=Missing, size=unknown, elsize=unknown)" + end +end + @testitem "Static inference with `inference`" begin # A simple model for testing that resembles a simple kalman filter with From 285ffb850a788c21ada68cc1e0936dc6f6580944 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 13 Feb 2025 13:25:52 +0100 Subject: [PATCH 37/56] add a comparison table --- docs/src/manuals/telemetry.md | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/docs/src/manuals/telemetry.md b/docs/src/manuals/telemetry.md index 965698093..f0e5f1b2d 100644 --- a/docs/src/manuals/telemetry.md +++ b/docs/src/manuals/telemetry.md @@ -4,9 +4,33 @@ RxInfer has two separate telemetry features: 1. A minimal package usage counter (enabled by default) 2. Optional session sharing for better support and development insights +!!! note + The telemetry implementation in RxInfer has been designed with careful consideration of the community discussion about telemetry in Julia packages, particularly the discourse thread ["Pkg.jl telemetry should be opt-in"](https://discourse.julialang.org/t/pkg-jl-telemetry-should-be-opt-in/42209). We've aimed to strike a balance between gathering useful information for package development while respecting user privacy and control. + +The following table compares the key properties of RxInfer's two telemetry features. + +| Property | Package Usage Counter | Session Sharing | +|--------------------------------------|-----------------------------------|-----------------------------------| +| Entirely Anonymous | Yes | Yes | +| Shared Across Julia Sessions | No | No | +| Enabled by default | Yes (opt-out) | No (opt-in) | +| Deletion Request Support | No (UUIDs not persistent, we cannot backtrace the session to a specific user) | Yes* (only if users save their session ID and share it with us anonymously with the form below, otherwise we cannot backtrace the session to a specific user) | +| Can Be Disabled for a Specific Julia Session | Yes | Yes (disabled by default) | +| Can Be Disabled for All Julia Sessions | Yes | Yes (disabled by default) | +| Can Be Disabled with Environment Variable | Yes | Yes (disabled by default) | +| Customizable Behavior | Yes (with Preferences.jl, see [Package Usage Counter](@ref manual-package-usage-counter) manual) | Yes (with Preferences.jl, see [Session Sharing](@ref manual-session-sharing) manual) | +| Can Be Enabled for a Specific Julia Session | Yes | Yes | +| Can Be Enabled for All Julia Sessions | Yes | Yes | +| What Is Being Recorded | Only timestamp and random UUID | Session metadata & errors, no actual data | +| Real-Time Sharing of Recorded Data | Yes (on package load) | Optional (manual/automatic) | +| Local Access to Recorded Data | N/A (No data is collected) | Yes (via session inspection, see [Session Summary](@ref manual-session-summary) manual) | +| Enables Extra Support from Core Developers | No | Yes* (if users are willing to share their session ID when opening a GitHub issue or a discussion on the GitHub repository, otherwise we cannot backtrace the session to a specific user) | +| Performance Impact | Negligible (only on package load)| Minimal (async sharing) | +| CI Environment Behavior | Automatically disabled | Automatically disabled | + Users are welcome to join our regular online meetings where we analyze the collected data and discuss how it helps shape RxInfer's development. -## Package Usage Counter +## [Package Usage Counter](@id manual-package-usage-counter) By default, RxInfer counts how many times the package is loaded via `using RxInfer`. This counter: - Only records a timestamp and a random UUID for deduplication @@ -15,7 +39,7 @@ By default, RxInfer counts how many times the package is loaded via `using RxInf - Is completely anonymous - Helps us understand how widely RxInfer is used -### Disabling Package Usage Counter +### [Disabling Package Usage Counter You can disable the counter in several ways: From 479d550b3e044affa059b8b9a726a964b8def516 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 13 Feb 2025 15:00:11 +0100 Subject: [PATCH 38/56] bump version of projection deps --- Project.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Project.toml b/Project.toml index 1c55d5b09..93407b532 100644 --- a/Project.toml +++ b/Project.toml @@ -43,7 +43,7 @@ Dates = "1.10" Distributions = "0.25" DomainSets = "0.5.2, 0.6, 0.7" ExponentialFamily = "1.5" -ExponentialFamilyProjection = "1.1" +ExponentialFamilyProjection = "1.3.1" FastCholesky = "1.3.0" GraphPPL = "~4.6.0" HTTP = "1.10" From da993deb6c0ef4da943d580007891c0754976604 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 13 Feb 2025 15:01:01 +0100 Subject: [PATCH 39/56] remove BenchmarkCI from deps --- Project.toml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Project.toml b/Project.toml index 93407b532..26888040a 100644 --- a/Project.toml +++ b/Project.toml @@ -68,7 +68,6 @@ julia = "1.10" [extras] Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595" -BenchmarkCI = "20533458-34a3-403d-a444-e18f38190b5b" BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" Coverage = "a2441757-f6aa-5fb2-8edb-039e3f45d037" CpuId = "adafc99b-e345-5852-983c-f28acb93d879" @@ -90,4 +89,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" TestSetExtensions = "98d24dd4-01ad-11ea-1b02-c9a08f80db04" [targets] -test = ["Test", "Pkg", "Logging", "InteractiveUtils", "TestSetExtensions", "TOML", "Coverage", "CpuId", "Dates", "Distributed", "Documenter", "ExponentialFamilyProjection", "Plots", "BenchmarkCI", "BenchmarkTools", "PkgBenchmark", "Aqua", "StableRNGs", "StatsFuns", "Optimisers", "ReTestItems"] +test = ["Test", "Pkg", "Logging", "InteractiveUtils", "TestSetExtensions", "TOML", "Coverage", "CpuId", "Dates", "Distributed", "Documenter", "ExponentialFamilyProjection", "Plots", "BenchmarkTools", "PkgBenchmark", "Aqua", "StableRNGs", "StatsFuns", "Optimisers", "ReTestItems"] From 2e5e61a2269867deea754811816a639140c1ff8d Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Thu, 13 Feb 2025 15:46:55 +0100 Subject: [PATCH 40/56] style: make format --- test/inference/inference_tests.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index 35f80efc0..b278e1092 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -245,7 +245,7 @@ end @testset "repr formatting" begin @test repr(log_data_entry(:x => 1.5)) == "data: x (type=Float64, size=(), elsize=())" @test repr(log_data_entry(:y => [1.0, 2.0, 3.0])) == "data: y (type=Vector{Float64}, size=(3,), elsize=())" - @test repr(log_data_entry(:z => [[1,2], [3,4]])) == "data: z (type=Vector{Vector{Int64}}, size=(2,), elsize=(2,))" + @test repr(log_data_entry(:z => [[1, 2], [3, 4]])) == "data: z (type=Vector{Vector{Int64}}, size=(2,), elsize=(2,))" @test repr(log_data_entry(:w => missing)) == "data: w (type=Missing, size=unknown, elsize=unknown)" end end From 1143ba53e6a681426bc5daf1ff0d65abf0c6d8b5 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Fri, 14 Feb 2025 16:52:13 +0100 Subject: [PATCH 41/56] add more metadata --- src/inference/inference.jl | 52 +++++++++++++++++++++------ test/inference/inference_tests.jl | 58 +++++++++++++++++++++++++++++++ 2 files changed, 100 insertions(+), 10 deletions(-) diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 3f8900748..bfdbc238f 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -124,6 +124,22 @@ function Base.show(io::IO, entry::InferenceLoggedDataEntry) print(io, "data: ", entry.name, " (type=", entry.type, ", size=", entry.size, ", elsize=", entry.elsize, ")") end +struct InferenceLoggedDictNTEntries + base_type::Symbol + entries::Vector{InferenceLoggedDataEntry} +end + +# Very safe by default, logging should not crash if we don't know how to parse the dict/nt entry +log_dictnt_entries(data) = string(typeof(data)) + +log_dictnt_entries(data::Dict) = InferenceLoggedDictNTEntries(:Dict, log_data_entries(data)) +log_dictnt_entries(data::NamedTuple) = InferenceLoggedDictNTEntries(:NamedTuple, log_data_entries(data)) + +function Base.show(io::IO, entry::InferenceLoggedDictNTEntries) + entries_str = join(map(e -> "$(e.name)::$(e.type)", entry.entries), ", ") + print(io, entry.base_type, ": ", entries_str) +end + using PrettyTables function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) @@ -472,16 +488,32 @@ function infer(; return with_session(session, :inference) do invoke append_invoke_context(invoke) do ctx - ctx[:model_name] = string(GraphPPL.getmodel(model)) - ctx[:model] = GraphPPL.getsource(model) - ctx[:data] = log_data_entries(data) - - !isnothing(datastream) && (ctx[:datastream_type] = eltype(datastream)) - !isnothing(constraints) && (ctx[:constraints] = GraphPPL.source_code(constraints)) - !isnothing(meta) && (ctx[:meta] = GraphPPL.source_code(meta)) - - ctx[:iterations] = iterations - ctx[:free_energy] = free_energy + try + ctx[:model_name] = string(GraphPPL.getmodel(model)) + ctx[:model] = GraphPPL.getsource(model) + ctx[:data] = log_data_entries(data) + + !isnothing(datastream) && (ctx[:datastream_type] = eltype(datastream)) + !isnothing(constraints) && (ctx[:constraints] = GraphPPL.source_code(constraints)) + !isnothing(meta) && (ctx[:meta] = GraphPPL.source_code(meta)) + + ctx[:returnvars] = log_dictnt_entries(returnvars) + ctx[:predictvars] = log_dictnt_entries(predictvars) + ctx[:historyvars] = log_dictnt_entries(historyvars) + !isnothing(keephistory) && (ctx[:keephistory] = keephistory) + + ctx[:iterations] = iterations + ctx[:free_energy] = free_energy + ctx[:allow_node_contraction] = allow_node_contraction + ctx[:showprogress] = showprogress + ctx[:catch_exception] = catch_exception + + ctx[:callbacks] = log_dictnt_entries(callbacks) + ctx[:addons] = log_dictnt_entries(addons) + ctx[:options] = log_dictnt_entries(options) + catch + # suppress any errors here, we don't want to crash the inference over logging issues + end end if isnothing(autoupdates) diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index b278e1092..7c11004ff 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -250,6 +250,64 @@ end end end +@testitem "session context log_dictnt_entries" begin + import RxInfer: log_dictnt_entries + + struct UnknownArbitraryType end + + @test occursin("UnknownArbitraryType", log_dictnt_entries(UnknownArbitraryType())) + @test occursin("Nothing", log_dictnt_entries(nothing)) + + @testset let entry = log_dictnt_entries(Dict(:x => 1.5)) + @test length(entry.entries) === 1 + @test entry.base_type === :Dict + @test entry.entries[1].name === :x + @test entry.entries[1].type === Float64 + end + + @testset let entry = log_dictnt_entries(Dict(:y => [1.0, 2.0, 3.0], :a => 1)) + @test length(entry.entries) === 2 + @test entry.base_type === :Dict + + # Find entries by name since Dict order is not guaranteed + y_entry = first(filter(e -> e.name === :y, entry.entries)) + a_entry = first(filter(e -> e.name === :a, entry.entries)) + + @test y_entry.type === Vector{Float64} + @test a_entry.type === Int64 + end + + @testset let entry = log_dictnt_entries((y = [1.0, 2.0, 3.0], a = 1)) + @test length(entry.entries) === 2 + @test entry.base_type === :NamedTuple + @test entry.entries[1].name === :y + @test entry.entries[1].type === Vector{Float64} + @test entry.entries[2].name === :a + @test entry.entries[2].type === Int64 + end + + @testset let entry = log_dictnt_entries((x = 1.5,)) + @test length(entry.entries) === 1 + @test entry.base_type === :NamedTuple + @test entry.entries[1].name === :x + @test entry.entries[1].type === Float64 + end +end + +@testitem "session context log_dictnt_entries string representation" begin + import RxInfer: log_dictnt_entries + + struct UnknownArbitraryType2 end + + @testset "repr formatting" begin + @test occursin("Nothing", repr(log_dictnt_entries(nothing))) + @test occursin("UnknownArbitraryType2", repr(log_dictnt_entries(UnknownArbitraryType2()))) + @test occursin("Dict: x::Float64", repr(log_dictnt_entries(Dict(:x => 1.5)))) + @test occursin("NamedTuple: y::Vector{Float64}, a::Int64", repr(log_dictnt_entries((y = [1.0, 2.0], a = 1)))) + @test occursin("NamedTuple: x::Missing", repr(log_dictnt_entries((x = missing,)))) + end +end + @testitem "Static inference with `inference`" begin # A simple model for testing that resembles a simple kalman filter with From c674980dc1faedc4ba634a4b53b4305ba8887300 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Fri, 14 Feb 2025 16:56:52 +0100 Subject: [PATCH 42/56] suppress errors if session context update (if any) --- src/inference/inference.jl | 48 +++++++++++++++++--------------------- src/session.jl | 10 +++++++- test/session_tests.jl | 26 +++++++++++++++++++++ 3 files changed, 57 insertions(+), 27 deletions(-) diff --git a/src/inference/inference.jl b/src/inference/inference.jl index bfdbc238f..4e2d7fc85 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -488,32 +488,28 @@ function infer(; return with_session(session, :inference) do invoke append_invoke_context(invoke) do ctx - try - ctx[:model_name] = string(GraphPPL.getmodel(model)) - ctx[:model] = GraphPPL.getsource(model) - ctx[:data] = log_data_entries(data) - - !isnothing(datastream) && (ctx[:datastream_type] = eltype(datastream)) - !isnothing(constraints) && (ctx[:constraints] = GraphPPL.source_code(constraints)) - !isnothing(meta) && (ctx[:meta] = GraphPPL.source_code(meta)) - - ctx[:returnvars] = log_dictnt_entries(returnvars) - ctx[:predictvars] = log_dictnt_entries(predictvars) - ctx[:historyvars] = log_dictnt_entries(historyvars) - !isnothing(keephistory) && (ctx[:keephistory] = keephistory) - - ctx[:iterations] = iterations - ctx[:free_energy] = free_energy - ctx[:allow_node_contraction] = allow_node_contraction - ctx[:showprogress] = showprogress - ctx[:catch_exception] = catch_exception - - ctx[:callbacks] = log_dictnt_entries(callbacks) - ctx[:addons] = log_dictnt_entries(addons) - ctx[:options] = log_dictnt_entries(options) - catch - # suppress any errors here, we don't want to crash the inference over logging issues - end + ctx[:model_name] = string(GraphPPL.getmodel(model)) + ctx[:model] = GraphPPL.getsource(model) + ctx[:data] = log_data_entries(data) + + !isnothing(datastream) && (ctx[:datastream_type] = eltype(datastream)) + !isnothing(constraints) && (ctx[:constraints] = GraphPPL.source_code(constraints)) + !isnothing(meta) && (ctx[:meta] = GraphPPL.source_code(meta)) + + ctx[:returnvars] = log_dictnt_entries(returnvars) + ctx[:predictvars] = log_dictnt_entries(predictvars) + ctx[:historyvars] = log_dictnt_entries(historyvars) + !isnothing(keephistory) && (ctx[:keephistory] = keephistory) + + ctx[:iterations] = iterations + ctx[:free_energy] = free_energy + ctx[:allow_node_contraction] = allow_node_contraction + ctx[:showprogress] = showprogress + ctx[:catch_exception] = catch_exception + + ctx[:callbacks] = log_dictnt_entries(callbacks) + ctx[:addons] = log_dictnt_entries(addons) + ctx[:options] = log_dictnt_entries(options) end if isnothing(autoupdates) diff --git a/src/session.jl b/src/session.jl index 01981c9a4..8a5bb6bfe 100644 --- a/src/session.jl +++ b/src/session.jl @@ -275,7 +275,15 @@ If `invoke` is `nothing`, does nothing. function append_invoke_context end append_invoke_context(f::F, ::Nothing) where {F} = nothing -append_invoke_context(f::F, invoke::SessionInvoke) where {F} = f(invoke.context) + +function append_invoke_context(f::F, invoke::SessionInvoke) where {F} + try + f(invoke.context) + catch e + invoke.context[:__append_invoke_context_error] = string(e) + end + nothing +end const default_session_sem = Base.Semaphore(1) # The `Ref` is initialized in the __init__ function based on user preferences diff --git a/test/session_tests.jl b/test/session_tests.jl index 7f77725aa..26cb36db6 100644 --- a/test/session_tests.jl +++ b/test/session_tests.jl @@ -250,3 +250,29 @@ end @test occursin("test", output) @test occursin("other", output) end + +@testitem "append_invoke_context should suppress and log errors if any" begin + session = RxInfer.create_session() + + RxInfer.with_session(session, :test_1) do invoke + RxInfer.append_invoke_context(invoke) do ctx + error("I'm an error") + end + end + + stats = RxInfer.get_session_stats(session, :test_1) + @test length(stats.invokes) === 1 + last_invoke = stats.invokes[end] + @test last_invoke.context[:__append_invoke_context_error] == "ErrorException(\"I'm an error\")" + + RxInfer.with_session(session, :test_2) do invoke + RxInfer.append_invoke_context(invoke) do ctx + ctx[:a] = 1 + end + end + + stats = RxInfer.get_session_stats(session, :test_2) + @test length(stats.invokes) === 1 + last_invoke = stats.invokes[end] + @test last_invoke.context[:a] === 1 +end From a180ef634fa95d044f30a991065e9af32421c8e6 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Fri, 14 Feb 2025 18:20:05 +0100 Subject: [PATCH 43/56] update version to 4.0.0 --- .github/workflows/CI.yml | 1 + Project.toml | 10 +++++----- codemeta.json | 4 ++-- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 680d68ae6..878a58089 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -53,6 +53,7 @@ jobs: fail-fast: false matrix: version: + - '1.10' - '1.11' os: - ubuntu-latest diff --git a/Project.toml b/Project.toml index 373867616..87a5ddecd 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "RxInfer" uuid = "86711068-29c9-4ff7-b620-ae75d7495b3d" authors = ["Bagaev Dmitry and contributors"] -version = "3.10.1" +version = "4.0.0" [deps] BayesBase = "b4ee3484-f114-42fe-b91c-797d54a0c67e" @@ -30,12 +30,12 @@ ExponentialFamilyProjection = "17f509fa-9a96-44ba-99b2-1c5f01f0931b" ProjectionExt = "ExponentialFamilyProjection" [compat] -BayesBase = "1.1" +BayesBase = "1.5.0" DataStructures = "0.18" Distributions = "0.25" DomainSets = "0.5.2, 0.6, 0.7" -ExponentialFamily = "1.5" -ExponentialFamilyProjection = "1.3.1" +ExponentialFamily = "2.0.0" +ExponentialFamilyProjection = "2.0.0" FastCholesky = "1.3.0" GraphPPL = "~4.6.0" LinearAlgebra = "1.9" @@ -44,7 +44,7 @@ Optim = "1.0.0" PrettyTables = "2.4" ProgressMeter = "1.0.0" Random = "1.9" -ReactiveMP = "~4.6.0" +ReactiveMP = "~5.0.0" Reexport = "1.2.0" Rocket = "1.8.0" Static = "0.8.10, 1" diff --git a/codemeta.json b/codemeta.json index 5109312fb..d807ca0f5 100644 --- a/codemeta.json +++ b/codemeta.json @@ -9,12 +9,12 @@ "downloadUrl": "/~https://github.com/reactivebayes/RxInfer.jl/releases", "issueTracker": "/~https://github.com/reactivebayes/RxInfer.jl/issues", "name": "RxInfer.jl", - "version": "3.9.1", + "version": "4.0.0", "description": "Julia package for automated, scalable and efficient Bayesian inference on factor graphs with reactive message passing. ", "applicationCategory": "Statistics", "developmentStatus": "active", "readme": "https://reactivebayes.github.io/RxInfer.jl/stable/", - "softwareVersion": "3.9.1", + "softwareVersion": "4.0.0", "keywords": [ "Bayesian inference", "message passing", From 6ad872b00fde40ed199793f6ff084367eb4191e6 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 10:30:34 +0100 Subject: [PATCH 44/56] add autoupdates and init in the session stats --- src/inference/inference.jl | 3 +- test/inference/autoupdates_tests.jl | 9 ++++++ test/inference/inference_tests.jl | 39 +++++++++++++++++++++++ test/model/initialization_plugin_tests.jl | 9 ++++++ 4 files changed, 59 insertions(+), 1 deletion(-) diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 6565a8d3a..642955d24 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -495,7 +495,8 @@ function infer(; !isnothing(datastream) && (ctx[:datastream_type] = eltype(datastream)) !isnothing(constraints) && (ctx[:constraints] = GraphPPL.source_code(constraints)) !isnothing(meta) && (ctx[:meta] = GraphPPL.source_code(meta)) - + !isnothing(autoupdates) && (ctx[:autoupdates] = repr(autoupdates)) + !isnothing(initialization) && (ctx[:initialization] = repr(initialization)) ctx[:returnvars] = log_dictnt_entries(returnvars) ctx[:predictvars] = log_dictnt_entries(predictvars) ctx[:historyvars] = log_dictnt_entries(historyvars) diff --git a/test/inference/autoupdates_tests.jl b/test/inference/autoupdates_tests.jl index 0e488f70d..845380f97 100644 --- a/test/inference/autoupdates_tests.jl +++ b/test/inference/autoupdates_tests.jl @@ -791,3 +791,12 @@ end ) ) end + +@testitem "@autoupdates should save have nice pretty printing" begin + autoupdates_object = @autoupdates begin + a, b = params(q(x)) + end + @test occursin("a, b", repr(autoupdates_object)) + @test occursin("params(q(x))", repr(autoupdates_object)) + @test occursin("@autoupdates", repr(autoupdates_object)) +end diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index 11ef10c05..2a947c028 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -1514,6 +1514,45 @@ end @test occursin("Linearization()", last_invoke.context[:meta]) end +@testitem "Session statistics should save initialization" begin + @model function simple_model(y) + x ~ Normal(mean = 0.0, var = 1.0) + y ~ Normal(mean = x, var = 1.0) + end + + initialization = @initialization begin + q(x) = vague(NormalMeanVariance) + end + session = RxInfer.create_session() + result = infer(model = simple_model(), data = (y = 1.0,), initialization = initialization, session = session) + stats = RxInfer.get_session_stats(session, :inference) + last_invoke = stats.invokes[end] + @test haskey(last_invoke.context, :initialization) + @test occursin("q(x)", last_invoke.context[:initialization]) + @test occursin("NormalMeanVariance", last_invoke.context[:initialization]) +end + +@testitem "Session statistics should save @autoupdates" begin + @model function simple_model(y, x_mean, x_var) + x ~ Normal(mean = x_mean, var = x_var) + y ~ Normal(mean = x, var = 1.0) + end + + initialization = @initialization begin + q(x) = vague(NormalMeanVariance) + end + autoupdates = @autoupdates begin + x_mean, x_var = mean_var(q(x)) + end + session = RxInfer.create_session() + result = infer(model = simple_model(), data = (y = 1.0,), autoupdates = autoupdates, initialization = initialization, session = session) + stats = RxInfer.get_session_stats(session, :inference) + last_invoke = stats.invokes[end] + @test haskey(last_invoke.context, :autoupdates) + @test occursin("x_mean, x_var", last_invoke.context[:autoupdates]) + @test occursin("mean_var(q(x))", last_invoke.context[:autoupdates]) +end + @testitem "Test inference benchmark statistics" begin using RxInfer diff --git a/test/model/initialization_plugin_tests.jl b/test/model/initialization_plugin_tests.jl index 706b37fcd..342d94869 100644 --- a/test/model/initialization_plugin_tests.jl +++ b/test/model/initialization_plugin_tests.jl @@ -707,3 +707,12 @@ end μ(u) = NormalMeanVariance(0, 1) end end + +@testitem "initialization should have nice pretty printing" begin + init = @initialization begin + q(x) = vague(NormalMeanVariance) + end + @test occursin("Initial state", repr(init)) + @test occursin("q(x)", repr(init)) + @test occursin("NormalMeanVariance", repr(init)) +end From 6873ec5eb913c0a45e87b1a64732d2f2e4421ae7 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 10:39:00 +0100 Subject: [PATCH 45/56] update docs and display --- docs/src/manuals/session_summary.md | 29 +++++++++++++++------ src/inference/inference.jl | 39 +++++++++++++++++++---------- 2 files changed, 48 insertions(+), 20 deletions(-) diff --git a/docs/src/manuals/session_summary.md b/docs/src/manuals/session_summary.md index a70ae232e..c20ebe931 100644 --- a/docs/src/manuals/session_summary.md +++ b/docs/src/manuals/session_summary.md @@ -125,14 +125,29 @@ For the `:inference` label, each invocation records: - Status (`:success` or `:error`) - Execution start and end timestamps - **Model Information**: - - Model source code - - Model name - - Inference parameters (e.g. number of iterations, free energy) + - Model source code (via `GraphPPL.getsource`) + - Model name (via `GraphPPL.getmodel`) + - Model constraints (if specified) + - Model meta information (if specified) + - Model autoupdates specification (if specified) + - Model initialization specification (if specified) - **Data Information**: - - Input variable names and types - - Data characteristics -- **Error Information** (if any): - - Error message and type + - Input data characteristics (names, types, sizes) - **no actual data is collected**` + - Datastream type (for streaming inference) + - Return variables structure + - Predict variables structure (for batch inference) + - History variables structure (for streaming inference) + - History buffer size (if specified) +- **Inference Parameters**: + - Number of iterations + - Free energy computation flag + - Node contraction settings + - Progress display settings + - Exception catching settings +- **Additional Settings**: + - Callbacks configuration + - Addons configuration + - Options configuration !!! note No actual data is collected for the `:inference` label. Only metadata such as size and type is recorded. diff --git a/src/inference/inference.jl b/src/inference/inference.jl index 642955d24..42daeed7f 100644 --- a/src/inference/inference.jl +++ b/src/inference/inference.jl @@ -155,38 +155,51 @@ function summarize_invokes(io::IO, ::Val{:inference}, invokes; n_last = 5) println(io, "* Note that benchmarking with `BenchmarkTools` or similar will pollute the session with test invokes.") println(io, " It is advised to explicitly pass `session = nothing` when benchmarking code involving the `infer` function.") + println(io, "\nLegend:") + println(io, " ✓ - Present/Success ✗ - Absent/Failure ⚠ - Error") + # Prepare data for the table last_invokes = collect(Iterators.take(Iterators.reverse(invokes), n_last)) - data = Matrix{String}(undef, length(last_invokes), 6) + data = Matrix{String}(undef, length(last_invokes), 9) for (i, invoke) in enumerate(last_invokes) - status = string(invoke.status) + # Basic info + invoke_id = string(invoke.id)[1:8] * "..." + status = invoke.status === :success ? "✓" : "✗" duration = round(Dates.value(Dates.Millisecond(invoke.execution_end - invoke.execution_start)), digits = 2) model = get(invoke.context, :model_name, nothing) model = model === nothing ? "N/A" : string(model) + # Features present + has_constraints = haskey(invoke.context, :constraints) ? "✓" : "✗" + has_meta = haskey(invoke.context, :meta) ? "✓" : "✗" + has_init = haskey(invoke.context, :initialization) ? "✓" : "✗" + + # Data info data_entries = get(invoke.context, :data, nothing) - data_str = if data_entries isa Symbol - string(data_entries) - elseif isnothing(data_entries) || ismissing(data_entries) || isempty(data_entries) - "N/A" + data_str = if data_entries isa Vector{InferenceLoggedDataEntry} && !isempty(data_entries) + join(map(e -> string(e.name), data_entries), ",") else - join(map(e -> string(e.name, " isa ", e.type), data_entries), ",") + "N/A" end - error_str = string(get(invoke.context, :error, "")) - invoke_id = string(invoke.id)[1:8] * "..." + # Error info if present + error_str = get(invoke.context, :error, "") + error_str = isempty(error_str) ? "" : "⚠" data[i, 1] = invoke_id data[i, 2] = status data[i, 3] = "$(duration)ms" data[i, 4] = model - data[i, 5] = data_str - data[i, 6] = error_str + data[i, 5] = has_constraints + data[i, 6] = has_meta + data[i, 7] = has_init + data[i, 8] = data_str + data[i, 9] = error_str end - header = (["ID", "Status", "Duration", "Model", "Data", "Error"],) - pretty_table(io, data; header = header, tf = tf_unicode_rounded, maximum_columns_width = [12, 8, 10, 35, 25, 25], autowrap = true, linebreaks = true) + header = (["ID", "Status", "Duration", "Model", "Cstr", "Meta", "Init", "Data", "Error"],) + pretty_table(io, data; header = header, tf = tf_unicode_rounded, maximum_columns_width = [12, 6, 10, 25, 6, 6, 6, 20, 6], autowrap = true, linebreaks = true) end end From b7831a9dc5d28c98d226c237742a378740ef02e5 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 10:44:08 +0100 Subject: [PATCH 46/56] fix HMM tests with new names --- test/models/statespace/hmm_tests.jl | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/test/models/statespace/hmm_tests.jl b/test/models/statespace/hmm_tests.jl index 64ee83a28..529525fc5 100644 --- a/test/models/statespace/hmm_tests.jl +++ b/test/models/statespace/hmm_tests.jl @@ -6,15 +6,15 @@ ## Model definition @model function hidden_markov_model(x) - A ~ MatrixDirichlet(ones(3, 3)) - B ~ MatrixDirichlet([10.0 1.0 1.0; 1.0 10.0 1.0; 1.0 1.0 10.0]) + A ~ DirichletCollection(ones(3, 3)) + B ~ DirichletCollection([10.0 1.0 1.0; 1.0 10.0 1.0; 1.0 1.0 10.0]) s_0 ~ Categorical(fill(1.0 / 3.0, 3)) s_prev = s_0 for t in eachindex(x) - s[t] ~ Transition(s_prev, A) - x[t] ~ Transition(s[t], B) + s[t] ~ DiscreteTransition(s_prev, A) + x[t] ~ DiscreteTransition(s[t], B) s_prev = s[t] end end @@ -24,8 +24,8 @@ end init = @initialization begin - q(A) = vague(MatrixDirichlet, 3, 3) - q(B) = vague(MatrixDirichlet, 3, 3) + q(A) = vague(DirichletCollection, (3, 3)) + q(B) = vague(DirichletCollection, (3, 3)) q(s) = vague(Categorical, 3) end From 35a0624da780c5f12205f7a71a35a5f8b9ba58fb Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 11:26:12 +0100 Subject: [PATCH 47/56] update tests --- test/inference/inference_tests.jl | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index 2a947c028..654e7fe5d 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -1242,10 +1242,10 @@ end @model function pred_model(p_s_t, y, goal, p_B, A) s[1] ~ p_s_t B ~ p_B - y[1] ~ Transition(s[1], A) + y[1] ~ DiscreteTransition(s[1], A) for i in 2:3 - s[i] ~ Transition(s[i - 1], B) - y[i] ~ Transition(s[i], A) + s[i] ~ DiscreteTransition(s[i - 1], B) + y[i] ~ DiscreteTransition(s[i], A) end s[3] ~ Categorical(goal) end @@ -1259,9 +1259,9 @@ end end result = infer( - model = pred_model(A = diageye(4), goal = [0, 1, 0, 0], p_B = MatrixDirichlet(ones(4, 4)), p_s_t = Categorical([0.7, 0.3, 0, 0])), + model = pred_model(A = diageye(4), goal = [0, 1, 0, 0], p_B = DirichletCollection(ones(4, 4)), p_s_t = Categorical([0.7, 0.3, 0, 0])), data = (y = [[1, 0, 0, 0], missing, missing],), - initialization = pred_model_init(MatrixDirichlet(ones(4, 4))), + initialization = pred_model_init(DirichletCollection(ones(4, 4))), constraints = pred_model_constraints, iterations = 10 ) @@ -1272,9 +1272,9 @@ end q(y[1], s) = q(y[1])q(s) end result = infer( - model = pred_model(A = diageye(4), goal = [0, 0, 1, 0], p_B = MatrixDirichlet(ones(4, 4)), p_s_t = Categorical([0.7, 0.3, 0, 0])), + model = pred_model(A = diageye(4), goal = [0, 0, 1, 0], p_B = DirichletCollection(ones(4, 4)), p_s_t = Categorical([0.7, 0.3, 0, 0])), data = (y = UnfactorizedData([[1, 0, 0, 0], missing, missing]),), - initialization = pred_model_init(MatrixDirichlet(ones(4, 4))), + initialization = pred_model_init(DirichletCollection(ones(4, 4))), constraints = pred_model_constraints, iterations = 10 ) From bec8466631af480e680c0b77177caf8e7be7a730 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 11:26:49 +0100 Subject: [PATCH 48/56] update tests --- test/inference/inference_tests.jl | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/inference/inference_tests.jl b/test/inference/inference_tests.jl index 1216b7bb6..509bedad4 100644 --- a/test/inference/inference_tests.jl +++ b/test/inference/inference_tests.jl @@ -981,10 +981,10 @@ end @model function pred_model(p_s_t, y, goal, p_B, A) s[1] ~ p_s_t B ~ p_B - y[1] ~ Transition(s[1], A) + y[1] ~ DiscreteTransition(s[1], A) for i in 2:3 - s[i] ~ Transition(s[i - 1], B) - y[i] ~ Transition(s[i], A) + s[i] ~ DiscreteTransition(s[i - 1], B) + y[i] ~ DiscreteTransition(s[i], A) end s[3] ~ Categorical(goal) end @@ -998,9 +998,9 @@ end end result = infer( - model = pred_model(A = diageye(4), goal = [0, 1, 0, 0], p_B = MatrixDirichlet(ones(4, 4)), p_s_t = Categorical([0.7, 0.3, 0, 0])), + model = pred_model(A = diageye(4), goal = [0, 1, 0, 0], p_B = DirichletCollection(ones(4, 4)), p_s_t = Categorical([0.7, 0.3, 0, 0])), data = (y = [[1, 0, 0, 0], missing, missing],), - initialization = pred_model_init(MatrixDirichlet(ones(4, 4))), + initialization = pred_model_init(DirichletCollection(ones(4, 4))), constraints = pred_model_constraints, iterations = 10 ) @@ -1011,9 +1011,9 @@ end q(y[1], s) = q(y[1])q(s) end result = infer( - model = pred_model(A = diageye(4), goal = [0, 0, 1, 0], p_B = MatrixDirichlet(ones(4, 4)), p_s_t = Categorical([0.7, 0.3, 0, 0])), + model = pred_model(A = diageye(4), goal = [0, 0, 1, 0], p_B = DirichletCollection(ones(4, 4)), p_s_t = Categorical([0.7, 0.3, 0, 0])), data = (y = UnfactorizedData([[1, 0, 0, 0], missing, missing]),), - initialization = pred_model_init(MatrixDirichlet(ones(4, 4))), + initialization = pred_model_init(DirichletCollection(ones(4, 4))), constraints = pred_model_constraints, iterations = 10 ) From b22c668dde3b932a2fef6f5e335997ba268ae5ff Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 11:49:45 +0100 Subject: [PATCH 49/56] update benchmark plots to use Julia 1.11 --- README.md | 5 +- ...Gaussian State Space Model Benchmark.ipynb | 4999 +++++++++++++---- benchmarks/Manifest.toml | 1716 +++--- benchmarks/plots/inference_rxinfer.png | Bin 101472 -> 101462 bytes benchmarks/plots/inference_rxinfer.svg | 918 +-- benchmarks/plots/inference_turing.png | Bin 111934 -> 111925 bytes benchmarks/plots/inference_turing.svg | 918 +-- benchmarks/plots/lgssm_comparison.png | Bin 60587 -> 71302 bytes benchmarks/plots/lgssm_comparison.svg | 2374 ++++---- benchmarks/plots/lgssm_scaling.png | Bin 75805 -> 81924 bytes benchmarks/plots/lgssm_scaling.svg | 1778 +++--- 11 files changed, 7765 insertions(+), 4943 deletions(-) diff --git a/README.md b/README.md index 2ad9437eb..5bf11c934 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ Turing comparison | Scalability performance :-------------------------:|:-------------------------: ![](benchmarks/plots/lgssm_comparison.svg?raw=true&sanitize=true) | ![](benchmarks/plots/lgssm_scaling.svg?raw=true&sanitize=true) +> [!NOTE] +> See many more examples in the [RxInferExamples.jl](https://reactivebayes.github.io/RxInferExamples.jl/) repository. ### Faster inference with better results RxInfer.jl not only beats generic-purpose Bayesian inference methods in conjugate models, executes faster, and scales better, but also provides more accurate results. Check out the [documentation](https://reactivebayes.github.io/RxInfer.jl/stable/examples/overview/) for more examples! @@ -174,10 +176,11 @@ For a more granular view of our progress and ongoing tasks, check out our [proje ## Ecosystem -The `RxInfer` framework consists of three *core* packages developed by [ReactiveBayes](/~https://github.com/reactivebayes/): +The `RxInfer` framework consists of four *core* packages developed by [ReactiveBayes](/~https://github.com/reactivebayes/): - [`ReactiveMP.jl`](/~https://github.com/reactivebayes/ReactiveMP.jl) - the underlying message passing-based inference engine - [`GraphPPL.jl`](/~https://github.com/reactivebayes/GraphPPL.jl) - model and constraints specification package +- [`ExponentialFamily.jl`](/~https://github.com/reactivebayes/ExponentialFamily.jl) - package for exponential family distributions - [`Rocket.jl`](/~https://github.com/reactivebayes/Rocket.jl) - reactive extensions package for Julia # Where to go next? diff --git a/benchmarks/Linear Multivariate Gaussian State Space Model Benchmark.ipynb b/benchmarks/Linear Multivariate Gaussian State Space Model Benchmark.ipynb index 52ff69eef..abaca828f 100644 --- a/benchmarks/Linear Multivariate Gaussian State Space Model Benchmark.ipynb +++ b/benchmarks/Linear Multivariate Gaussian State Space Model Benchmark.ipynb @@ -25,22 +25,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "Julia Version 1.10.2\n", - "Commit bd47eca2c8a (2024-03-01 10:14 UTC)\n", + "Julia Version 1.11.3\n", + "Commit d63adeda50d (2025-01-21 19:42 UTC)\n", "Build Info:\n", " Official https://julialang.org/ release\n", "Platform Info:\n", - " OS: macOS (arm64-apple-darwin22.4.0)\n", - " CPU: 10 × Apple M2 Pro\n", + " OS: macOS (arm64-apple-darwin24.0.0)\n", + " CPU: 11 × Apple M3 Pro\n", " WORD_SIZE: 64\n", - " LIBM: libopenlibm\n", - " LLVM: libLLVM-15.0.7 (ORCJIT, apple-m1)\n", - "Threads: 1 default, 0 interactive, 1 GC (on 6 virtual cores)\n" + " LLVM: libLLVM-16.0.6 (ORCJIT, apple-m2)\n", + "Threads: 1 default, 0 interactive, 1 GC (on 5 virtual cores)\n", + "Environment:\n", + " JULIA_NUM_THREADS = \n" ] } ], "source": [ - "# All benchmarks have been performed on a MacBook (Apple M3 pro) 2023 with Julia 1.10.0\n", "import Pkg; Pkg.activate(\".\"); Pkg.instantiate(); versioninfo() " ] }, @@ -48,15 +48,7 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling IJuliaExt [2f4121a4-3b3a-5ce6-9c5e-1f2673ce168a]\n" - ] - } - ], + "outputs": [], "source": [ "using RxInfer\n", "using Random, Distributions\n", @@ -77,12 +69,12 @@ "\n", "We wil use the following model:\n", "\n", - "\\begin{equation} \\label{eq:linear_gaussian_ssm}\n", + "$$\\begin{equation}\n", " \\begin{aligned}\n", " \\mathbf{x}_k & = \\, \\mathbf{A}\\mathbf{x}_{k - 1} + \\mathcal{P} \\\\\n", " \\mathbf{y}_k & = \\, \\mathbf{B}\\mathbf{x}_{k} + \\mathcal{Q} \\\\\n", " \\end{aligned}\n", - "\\end{equation}\n", + "\\end{equation}$$\n", " \n", "In this model, we denote by $\\mathbf{x}_k$ the current state of the system (at time step $k$), by $\\mathbf{x}_{k - 1}$ the previous state at time $k-1$, $\\mathbf{A}$ and $\\mathbf{B}$ are a constant system inputs and $\\mathbf{y}_k$ is a noisy observation of $\\mathbf{x}_k$. We further assume that the states and the observations are corrupted by i.i.d. Gaussian noise with variances $\\mathcal{P}$ and $\\mathcal{Q}$ respectively.\n", "\n", @@ -90,7 +82,7 @@ "\n", "\"Gaussian\n", "\n", - "For smoothing (forward-backward) estimation in ReactiveMP.jl, it is possible to build a full graph of the model." + "We can use the following code to create the model using the `RxInfer.jl` package interface with the `@model` macro:" ] }, { @@ -134,9 +126,8 @@ "generate_data (generic function with 1 method)" ] }, - "execution_count": 4, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -182,17 +173,16 @@ { "data": { "text/plain": [ - "reactivemp_inference_filtering (generic function with 1 method)" + "rxinfer_inference_filtering (generic function with 1 method)" ] }, - "execution_count": 6, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "# Inference procedure for full graph\n", - "function reactivemp_inference_smoothing(observations, A, B, P, Q)\n", + "function rxinfer_inference_smoothing(observations, A, B, P, Q)\n", " n = length(observations) \n", " \n", " result = infer(\n", @@ -205,7 +195,7 @@ "end\n", "\n", "# Inference procedure for single time step graph and filtering\n", - "function reactivemp_inference_filtering(observations, A, B, P, Q)\n", + "function rxinfer_inference_filtering(observations, A, B, P, Q)\n", " n = length(observations) \n", " \n", " autoupdates = @autoupdates begin \n", @@ -231,7 +221,7 @@ "metadata": {}, "outputs": [], "source": [ - "x_reactivemp_smoothing_inferred = reactivemp_inference_smoothing(real_y, A, B, P, Q);" + "x_rxinfer_smoothing_inferred = rxinfer_inference_smoothing(real_y, A, B, P, Q);" ] }, { @@ -240,14 +230,988 @@ "metadata": {}, "outputs": [], "source": [ - "x_reactivemp_filtering_inferred = reactivemp_inference_filtering(real_y, A, B, P, Q);" + "x_rxinfer_filtering_inferred = rxinfer_inference_filtering(real_y, A, B, P, Q);" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, - "outputs": [], + "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", + "\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", + "\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", + "\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", + "\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", + "\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", + "\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", + "\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", + "\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", + "\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", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Results verification\n", "\n", @@ -260,11 +1224,11 @@ "generated_data = plot!(generated_data, legend = :bottomleft, ylimit = ylimit, title = \"Original data\")\n", "\n", "rmp_smoothing_results_plot = plot(1:n, real_x |> reshape_data, label = [ \"x[:, 1]\" \"x[:, 2]\" ])\n", - "rmp_smoothing_results_plot = plot!(rmp_smoothing_results_plot, 1:n, mean.(x_reactivemp_smoothing_inferred) |> reshape_data, ribbon = var.(x_reactivemp_smoothing_inferred) |> reshape_data, label = [ \"inferred[:, 1]\" \"inferred[:, 2]\" ])\n", + "rmp_smoothing_results_plot = plot!(rmp_smoothing_results_plot, 1:n, mean.(x_rxinfer_smoothing_inferred) |> reshape_data, ribbon = var.(x_rxinfer_smoothing_inferred) |> reshape_data, label = [ \"inferred[:, 1]\" \"inferred[:, 2]\" ])\n", "rmp_smoothing_results_plot = plot!(rmp_smoothing_results_plot, legend = :bottomleft, ylimit = ylimit, title = \"RxInfer smoothing\")\n", "\n", "rmp_filtering_results_plot = plot(1:n, real_x |> reshape_data, label = [ \"x[:, 1]\" \"x[:, 2]\" ])\n", - "rmp_filtering_results_plot = plot!(rmp_filtering_results_plot, 1:n, mean.(x_reactivemp_filtering_inferred) |> reshape_data, ribbon = var.(x_reactivemp_filtering_inferred) |> reshape_data, label = [ \"inferred[:, 1]\" \"inferred[:, 2]\" ])\n", + "rmp_filtering_results_plot = plot!(rmp_filtering_results_plot, 1:n, mean.(x_rxinfer_filtering_inferred) |> reshape_data, ribbon = var.(x_rxinfer_filtering_inferred) |> reshape_data, label = [ \"inferred[:, 1]\" \"inferred[:, 2]\" ])\n", "rmp_filtering_results_plot = plot!(rmp_filtering_results_plot, legend = :bottomleft, ylimit = ylimit, title = \"RxInfer filtering\")\n", "\n", "p = plot(generated_data, rmp_smoothing_results_plot, rmp_filtering_results_plot, layout = @layout([ a; b; c ]))\n", @@ -311,34 +1275,33 @@ "data": { "text/plain": [ "12-element Vector{Tuple{Int64, BenchmarkTools.Trial, BenchmarkTools.Trial}}:\n", - " (50, 4.567 ms, 416.500 μs)\n", - " (100, 9.050 ms, 699.875 μs)\n", - " (250, 23.120 ms, 1.553 ms)\n", - " (500, 48.114 ms, 3.014 ms)\n", - " (1000, 104.699 ms, 5.808 ms)\n", - " (2000, 233.407 ms, 11.386 ms)\n", - " (5000, 714.368 ms, 29.101 ms)\n", - " (10000, 1.588 s, 58.149 ms)\n", - " (15000, 2.431 s, 90.139 ms)\n", - " (20000, 4.024 s, 122.298 ms)\n", - " (25000, 4.653 s, 153.484 ms)\n", - " (50000, 12.422 s, 330.068 ms)" + " (50, 3.726 ms, 469.250 μs)\n", + " (100, 7.365 ms, 818.125 μs)\n", + " (250, 20.236 ms, 1.897 ms)\n", + " (500, 42.718 ms, 3.684 ms)\n", + " (1000, 90.045 ms, 7.291 ms)\n", + " (2000, 188.200 ms, 14.834 ms)\n", + " (5000, 515.521 ms, 36.741 ms)\n", + " (10000, 1.301 s, 74.048 ms)\n", + " (15000, 2.104 s, 109.335 ms)\n", + " (20000, 3.355 s, 150.005 ms)\n", + " (25000, 5.081 s, 183.194 ms)\n", + " (50000, 9.262 s, 369.503 ms)" ] }, - "execution_count": 11, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "reactivemp_benchmark_results = map(benchmark_rmp_sizes) do size\n", + "rxinfer_benchmark_results = map(benchmark_rmp_sizes) do size\n", " # states, observations = generate_data(size, A, B, P, Q);\n", " \n", - " benchmark_smoothing = @benchmark reactivemp_inference_smoothing(observations, $A, $B, $P, $Q) setup=begin\n", + " benchmark_smoothing = @benchmark rxinfer_inference_smoothing(observations, $A, $B, $P, $Q) setup=begin\n", " states, observations = generate_data($size, $A, $B, $P, $Q);\n", " end\n", " \n", - " benchmark_fitlering = @benchmark reactivemp_inference_filtering(observations, $A, $B, $P, $Q) setup=begin\n", + " benchmark_fitlering = @benchmark rxinfer_inference_filtering(observations, $A, $B, $P, $Q) setup=begin\n", " states, observations = generate_data($size, $A, $B, $P, $Q);\n", " end\n", " \n", @@ -360,9 +1323,8 @@ "benchmark_time_ms (generic function with 1 method)" ] }, - "execution_count": 12, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -376,150 +1338,150 @@ "outputs": [ { "data": { - "image/png": "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", + "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", - "\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", + "\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" ] }, "metadata": {}, @@ -528,8 +1490,8 @@ ], "source": [ "lgssm_scaling = plot(xscale = :log10, yscale = :log10, xlabel = \"Number of observations\", ylabel = \"Minimum execution time (in ms)\", title = \"RxInfer.jl Linear Gaussian State Space Model Benchmark\", legend = :bottomright, size = (650, 400))\n", - "lgssm_scaling = plot!(lgssm_scaling, benchmark_rmp_sizes, map(i -> benchmark_time_ms(reactivemp_benchmark_results[i][2]), 1:length(benchmark_rmp_sizes)), markershape = :diamond, label = \"Smoothing\")\n", - "lgssm_scaling = plot!(lgssm_scaling, benchmark_rmp_sizes, map(i -> benchmark_time_ms(reactivemp_benchmark_results[i][3]), 1:length(benchmark_rmp_sizes)), markershape = :utriangle, label = \"Filtering\")\n", + "lgssm_scaling = plot!(lgssm_scaling, benchmark_rmp_sizes, map(i -> benchmark_time_ms(rxinfer_benchmark_results[i][2]), 1:length(benchmark_rmp_sizes)), markershape = :diamond, label = \"Smoothing\")\n", + "lgssm_scaling = plot!(lgssm_scaling, benchmark_rmp_sizes, map(i -> benchmark_time_ms(rxinfer_benchmark_results[i][3]), 1:length(benchmark_rmp_sizes)), markershape = :utriangle, label = \"Filtering\")\n", "\n", "display(lgssm_scaling)\n", "\n", @@ -570,9 +1532,8 @@ "turing_inference_smoothing (generic function with 1 method)" ] }, - "execution_count": 15, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -590,8 +1551,460 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:02\u001b[39m\n", - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:04\u001b[39m\n" + "\u001b[32mSampling 0%| | ETA: N/A\u001b[39m\n", + "\u001b[32mSampling 0%|▏ | ETA: 0:16:47\u001b[39m\n", + "\u001b[32mSampling 1%|▍ | ETA: 0:08:24\u001b[39m\n", + "\u001b[32mSampling 1%|▌ | ETA: 0:05:36\u001b[39m\n", + "\u001b[32mSampling 2%|▋ | ETA: 0:04:12\u001b[39m\n", + "\u001b[32mSampling 2%|▉ | ETA: 0:03:21\u001b[39m\n", + "\u001b[32mSampling 2%|█ | ETA: 0:02:47\u001b[39m\n", + "\u001b[32mSampling 3%|█▏ | ETA: 0:02:23\u001b[39m\n", + "\u001b[32mSampling 3%|█▍ | ETA: 0:02:05\u001b[39m\n", + "\u001b[32mSampling 4%|█▌ | ETA: 0:01:51\u001b[39m\n", + "\u001b[32mSampling 4%|█▋ | ETA: 0:01:40\u001b[39m\n", + "\u001b[32mSampling 4%|█▉ | ETA: 0:01:31\u001b[39m\n", + "\u001b[32mSampling 5%|██ | ETA: 0:01:23\u001b[39m\n", + "\u001b[32mSampling 5%|██▏ | ETA: 0:01:17\u001b[39m\n", + "\u001b[32mSampling 6%|██▍ | ETA: 0:01:11\u001b[39m\n", + "\u001b[32mSampling 6%|██▌ | ETA: 0:01:06\u001b[39m\n", + "\u001b[32mSampling 6%|██▊ | ETA: 0:01:02\u001b[39m\n", + "\u001b[32mSampling 7%|██▉ | ETA: 0:00:58\u001b[39m\n", + "\u001b[32mSampling 7%|███ | ETA: 0:00:55\u001b[39m\n", + "\u001b[32mSampling 8%|███▎ | ETA: 0:00:52\u001b[39m\n", + "\u001b[32mSampling 8%|███▍ | ETA: 0:00:49\u001b[39m\n", + "\u001b[32mSampling 8%|███▌ | ETA: 0:00:47\u001b[39m\n", + "\u001b[32mSampling 9%|███▊ | ETA: 0:00:45\u001b[39m\n", + "\u001b[32mSampling 9%|███▉ | ETA: 0:00:43\u001b[39m\n", + "\u001b[32mSampling 10%|████ | ETA: 0:00:41\u001b[39m\n", + "\u001b[32mSampling 10%|████▎ | ETA: 0:00:39\u001b[39m\n", + "\u001b[32mSampling 10%|████▍ | ETA: 0:00:38\u001b[39m\n", + "\u001b[32mSampling 11%|████▌ | ETA: 0:00:36\u001b[39m\n", + "\u001b[32mSampling 11%|████▊ | ETA: 0:00:35\u001b[39m\n", + "\u001b[32mSampling 12%|████▉ | ETA: 0:00:33\u001b[39m\n", + "\u001b[32mSampling 12%|█████ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 12%|█████▎ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 13%|█████▍ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 13%|█████▌ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 14%|█████▊ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|█████▉ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 14%|██████ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 15%|██████▎ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 15%|██████▍ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 16%|██████▌ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 16%|██████▊ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 16%|██████▉ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 17%|███████ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 17%|███████▎ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 18%|███████▍ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 18%|███████▌ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 18%|███████▊ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 19%|███████▉ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 19%|████████▏ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 20%|████████▎ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 20%|████████▍ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 20%|████████▋ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 21%|████████▊ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 21%|████████▉ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▏ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▎ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▍ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▋ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▊ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 24%|█████████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▏ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▍ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▋ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▉ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 26%|███████████▏ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 31%|████████████▉ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 31%|█████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 33%|█████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 33%|██████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▎ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 38%|███████████████▊ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▎ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▋ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▊ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 40%|█████████████████ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▎ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▋ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████▏ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▎ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▋ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 45%|██████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 45%|███████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▏ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▏ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 50%|████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████▏ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 52%|██████████████████████ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 57%|███████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 62%|█████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 64%|███████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 69%|████████████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 69%|█████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▍ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 74%|██████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▍ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 76%|████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▍ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▍ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 81%|█████████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 81%|██████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 83%|██████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 83%|███████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 88%|████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 90%|██████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▎ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▌ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▋ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 95%|███████████████████████████████████████▉ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 95%|████████████████████████████████████████ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▏ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▍ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▌ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▋ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▉ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▏| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▍| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▌| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▋| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|█████████████████████████████████████████▉| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|██████████████████████████████████████████| Time: 0:00:07\u001b[39m\n", + "\u001b[90mSampling 100%|██████████████████████████████████████████| Time: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 0%| | ETA: N/A\u001b[39m\n", + "\u001b[32mSampling 0%|▎ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 1%|▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 2%|▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 2%|▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 2%|█ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 3%|█▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 4%|█▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 4%|█▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 4%|█▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 5%|██▏ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 6%|██▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 6%|██▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 6%|██▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 7%|███ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 8%|███▏ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 8%|███▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 8%|███▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 9%|███▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 10%|████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 10%|████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 10%|████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 11%|████▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 12%|████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 12%|█████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 12%|█████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 13%|█████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 14%|█████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 14%|█████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 14%|██████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 15%|██████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 16%|██████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 16%|██████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 16%|██████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 17%|███████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 18%|███████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 18%|███████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 18%|███████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 19%|████████ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 20%|████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 20%|████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 20%|████████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 21%|████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 22%|█████████ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 24%|█████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 26%|███████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 28%|████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 31%|█████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 33%|█████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 36%|██████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 38%|███████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 40%|█████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 45%|██████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 50%|████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 52%|██████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 55%|██████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▍ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 62%|█████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 64%|███████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▍ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 69%|█████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▍ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 74%|██████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▉ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 76%|████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 78%|█████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 81%|██████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 83%|██████████████████████████████████▉ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 86%|███████████████████████████████████▉ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 88%|████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 90%|██████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▋ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▉ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▎ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▌ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▊ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 95%|███████████████████████████████████████▉ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▏ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▍ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▌ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▊ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▏| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▍| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▋| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|█████████████████████████████████████████▊| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|██████████████████████████████████████████| Time: 0:00:06\u001b[39m\n", + "\u001b[90mSampling 100%|██████████████████████████████████████████| Time: 0:00:06\u001b[39m\n" ] } ], @@ -627,9 +2040,8 @@ "reshape_turing_data (generic function with 1 method)" ] }, - "execution_count": 18, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -643,977 +2055,976 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOydd0AT1x/A310mkBD2Btl7KwIiWxFx4d57712t/qzWVmudVVtbF060rjrAgQqIgCAoCLKHsvcIELLv7vdHbBpDgLBtzeev5OXde99ccve9974LwjAMyJAhQ4YMGV8r8EALIEOGDBkyZAwkMkUo42sHQZDc3NxXr15lZGS0trZ29fCjR48uXry4rq6uqwfu3bt38eLFLBarqwdKQ2lp6eLFi0+dOtWNYxMTE5cvXx4eHt7rUsmQ8WUiU4Qyvl7q6urWr1+vqalpaWnp4eFhZ2enpqY2adKkzMxM6Qd5/PhxSEhIc3NzV2e/d+9eSEgIl8vt6oHSUF9fHxISEhkZ2Y1j8/Lyzpw58/bt264eePbs2WvXrnVjRhkyBhb8QAsgQ8bAkJOTExAQUFpaqqent3nzZgMDg4aGhvDw8Lt37z569OjatWuTJk2SZhxHR0c+ny8nJ9dVAVxcXGg0Gh7/37kGV65cqaOjM2vWrIEWRIaMrvHfuQhlyJCe5ubmsWPHlpaWzpo16+zZs/Ly8oL23bt3nzhxYuPGjbNmzUpMTHR0dOx0qEOHDnVPhtOnT3fvQBkyZPQuMkUo42vk0KFDhYWFzs7Oly5dEl2TQRC0fv36wsLCkydPbtiw4cWLF4L2xsbGDx8+aGpq6unpffz4MTo6uqGhYerUqYMGDcrPz29ubrazsyMSicJxUBSNiYlJT08nkUjDhw+3tbWtqKiorKw0MjJSUVER9MnOzmYymU5OTjAMAwC4XO779+8pFIqFhUVjY+OjR48qKysNDAwCAwMVFRXF5K+vr09MTCwpKWGxWAYGBv7+/srKyt0+G6mpqXFxcRAEubi4uLq6SuzDZrNfvXpVXFxcW1urra3t6elpaGgo/LShoeHjx48YhnG5XOGeqqKiopmZmeB1U1PTq1evSktLW1pa9PT0/Pz81NXVuy2wDBm9DCZDxlcGiqIaGhoAgHv37knsUFVVRSAQAADZ2dmCllu3bgEAtmzZsm3bNgiCBNeO4PARI0YAAAoLC4WH19bWenh4iF5lS5cu3bVrFwDgypUrwm5OTk4AADqdLnhbUlICAPD09Lx7966o5tPU1ExNTRUVb9GiRTgcTnR8CoVy5swZ0T6pqakAgEmTJnV8Krhc7ty5c0WHGjNmzB9//AEA2LNnj7Dbb7/9Jlw0C4BheM2aNXw+X9Dh6tWrbe8tAQEBgk83bdokOJ9CyGTyoUOHOpZNhox+Q7YilPHVkZWVVVNTQyAQRo0aJbGDpqbm0KFD4+PjY2JiLC0the03b95kMBgHDhwYOnQoi8UyNjZueyyGYVOnTo2Pjx8/fvyuXbs0NTWTkpLWr1+PSRewW1BQMGfOnLVr1wYFBQEAfv/99+vXr8+dOzc9PV2ogBsbGzdv3uzn52dgYMDhcF6+fPnDDz+sWLHCwsLCy8urS6di69atV65ccXJyOnLkiKmp6fv379evXy9QoqJUV1dPnTo1ODjYyMiISCSmp6fv3bv3119/1dXV3b59OwDA39//2bNno0aNUlVVFfrLqKqqCl7U1dWtWrUqICDA0NAQQZCEhITvv/9+69atZmZmEyZM6JLAMmT0CQOtiWXI6G8ePHgAALCwsOigz9KlSwEAW7duFbwVrAgBAFFRUWI9xVaET548AQDY2NjweDxhn4SEBMHhna4IAQCnTp0S9kEQxMrKCgCQlZXVgbQC79DJkycLW6RZEZaUlOBwOCqVWltbK2zMz88X7BWLrgjbUlVVpaSkpK2tjaKosBGHw+nr63dwlKh4EAT5+vpK01mGjL5GFj4h46tDEOpApVI76CP4tKmpSbRx6NChvr6+HQ8eFhYGAFi7dq2o6dHNzW3YsGHSyEaj0ZYtWyZ8C8OwQNF+/Pixg6N8fX0VFRWTkpKkmUJUVARB5s+fr6amJmw0NTWVZpWmqanp5uZWWVlZWlrapUkFODo6GhgYdFVgGTL6CJkilPHVoaCgAADoOJJd8CmFQhFttLa27nTwvLw8iT1tbW2lkc3U1FTM/qepqQkAqK6uFrYwGIy9e/e6uLhoa2vDMAxBEAzDzc3N9fX10kwhJCsrCwDg4OAg1t7WVxZF0ZCQED8/P319fSKRCEEQBEGCta80k7LZ7EOHDrm7u+vo6OBwOMHhxcXFra2tbDa7SzLLkNEXyGyEMr469PT0AABFRUUIgohpHSEFBQXCnkJEV07tIdCgSkpKYu1tWyQi5pMCABCYBlEUFbxls9leXl6pqalWVlbTpk1TVVUlkUgAgJ9++qmrSWoYDAYAoK33psCTSJTly5efO3dOS0trzJgxurq6AiGvXbuWnp7O5/M7ngVBkFGjRr18+dLExGTSpEnq6upkMhkAcPz48crKyk4PlyGjH5ApQhlfHQ4ODhQKhcFgxMfHS/QuYTAYAquemPOn0F2lAwRhDBUVFXZ2dqLtFRUVPRL6b0JDQ1NTU6dPn379+nWhPAiC7N69u6tDCbZ/a2pqxNpFV58AgOzs7HPnzllZWSUmJoq6sz5+/FiaWcLCwl6+fBkQEPDw4UPR7eJjx451VWAZMvoI2daojK8OAoEwe/ZsAMDBgwcldjh16hSDwbCxsXFxcenq4M7OzgCAmJgY0UY+nx8bG9stYcVJS0sDAEyfPl1UK2dmZnI4nK4OZWNjAwBo6yOakpLSdsagoCBRLcjhcNomoiMQCG1XeO/evQMATJ06VVQLlpeXi6lbGTIGEJkilPE1smPHDmVl5YcPH/70009iHz1//nzPnj0QBB04cECaJaAYs2fPxuPxv//+e3FxsbDx1KlTom97gmB7VuhiKqAby0EAwPjx4/F4/JUrV0QXhbm5uQJ/HyGCvVOxGU+cONE2z7iurm59fb3YDq3Ew7/77rtuCCxDRh8h2xqV8TViYGBw7dq1yZMn79ix4/nz5/PmzRs0aFBjY2NYWNjly5cRBNm7d+/YsWO7MbKZmdmOHTv27t07ZMiQRYsWaWtrJyQk3L1718/PLyoqqhuaVQwfHx8AwJ49exQUFIYPH15XV3fixInY2FgajdZVG6GOjs7GjRsPHTrk5+d34MABCwuLd+/ebd26VVdXV1RvDR48mEql3r59e/fu3YJ4jBs3bhw9etTQ0LCoqEh0wCFDhhQWFk6cOHHUqFEKCgp6enpBQUHe3t4wDB85ckRDQ8PPz6+5ufnMmTO3bt3S0NBouysrQ8bAMNDxGzJkDBipqakCvSKKiYnJ7du3xXoK4giFYYWitM0sg2HYsWPHBN6eAAArK6tHjx6tX78eAHD37l1hn/Yyy4iNv2/fPgDAuXPnhC179+4VZGUToKen9+rVK4E/p+hXA1JkluHz+cuXLxdVz5MnTz5z5gz4PI7wwYMHotEmcnJyISEhM2bMAAAkJSUJu5WWlvr7+wu3QIWZZU6cOCGaWUZdXf3Zs2cCb9WWlpaOJZQhox+AMFmFehlfN8XFxa9fv25oaKBQKNbW1k5OTm3Xba2trdXV1UpKSsJMoULKy8uZTKaRkZFYHQkEQaqqqkgkkmAzc+zYsQ8fPkxJSRHoPwBAaWkpm802MTERaDU+n19SUkImk3V0dETHodPpDQ0N6urqoqqouLg4OTm5oaHByMjI29ubSCSWlJQgCGJkZCTowOVyi4uLKRSKtrZ2p2cgJydH4Bzk5OTk6OjIYDBqamqUlZVF85c2NjYmJCSUlpZqaGj4+voqKSnV1NQwGAxdXV2B26rYF+dwOHJycsLZKyoqEhMTa2trDQwMfHx85OTkysrKuFyuoaGhqFKXIWNAkClCGTL6nMLCQltbW0VFxfLy8v9S3SUZMv4byK5JGTJ6matXryYmJk6aNMnIyKi5ufnNmzd79uxhs9n79++XaUEZMr5AZCtCGTJ6mYsXLy5cuFC0hUwmb9++/bvvvuu5s4wMGTJ6HZkilCGj96moqEhKSqqqquJyuXp6el5eXtJkpZEhQ8aAIFOEMmTIkCHjq0bmryVDhgwZMr5qZIpQhgwZMmR81fSCD1thYeHt27eFb6dOndq2cjePxzt37tz79+/t7e0XL14sGl0rQ4YMGTJkDCC9sCLMzs4+efJk49/weLy2fRYuXHj9+vXBgweHhoYuWbKk55PKkCFDhgwZvUIvOMuEh4f/9NNP8fHx7XUoKiqytLQsKytTU1Orq6vT09PLy8szMDDo4bwyZMiQIUNGz+kdG2FNTc2PP/546tQpsRzzAl69emVnZydwH1dTU7O1tX316lWvzCtDhgwZMmT0kF6wEVKpVA8PDwzD4uLitm/fHh4eLlbstLKyUrQKtoaGRmVlpcShMAxzd3cXlEkT4ObmJigd17bnFxibzGQy2SwOhapAJBL7eWp6fZMcUY4P8RQoCv0w3Zd5/iXC5/Ob65sxgHFR7vuUDDsnW22dztNvfskIdnH+Lef/C4TH47W2tsrLy3d8nd68dyu3JG/66KnmZuai7f/S89/Q1ABwEAHgqRRq572/YLp6/olEYqcZnXpBEXp7e3t7ewte7969e9euXWJVSYlEomi5Th6P197/D0GQN2/eLFiwQNji6OgoltIXAIBhGJPJVFDozTs+nU4vLy83NzfviSMPgiD19fXqGmr9n0kr9kVs+YeKUZNHWqpa9vVcCIJwOBx5efm+nqhXIBAIyflv8AR8QXahId4s4v6z5RuWDrRQHYGiaG5uroqKirB+hYCkt8nP4p+PGh7gYGePIEjb60KGlBCJRDabTaFQOr6Z5pbkwTqEDyUf7WztRNs5HA4EQf3/sNtDiotL4lNeTRoVrKYqVW4HVmoMycwBpij1tWAdw2Qyn754ZqCj7+zoLGhhs9l4PF76e6w0Wd17+X7t6up68eJFsUZdXd2ysjLh27KyMl1d3fZGgCBoxYoVHc+CYRgOh8PhcD2QVJxTl39nUrnu5UPGjx4vTX8Oh9P2TkSlUi0sLNo7hM/nFxUV6erqysnJ9UhWSUyfO60/V2m9fv77DhwO5x/gBwCgUilxT18N9RryhUue9i4t9XEGnd+w5tuVov+xuLfxJHOFuLfxzo5OAIAv/Ft84Yg9ZEhk+cyl+R8Khg11FzvVOBwOgqB/3fn3cBvm4TZMqq4YRr93mvn6GdHEVm3p930sVye8S3+X0piemJnkYOcgePjA/U0vztILNsLW1lbBCwzD7t69a29vL3j7+vVrQd1Of3//0tLS9PR0AEBaWlp5ebm/v3/P5+1d1JXVUTpfTUW9864ApLxL/e74nlMhv3dpinuP7odEXTl1sWtHSc+/bq+mA+48uLPj4P/epL7pxTGdhziv27HGbbhbL47ZFygrK7fwm0gU8f2cmeOnG3C0Jo+eePnMlZDfLjIYjIGS8Mvn8fMnh38/UlFR0ZNBDAcZjvQd0cOdp8bGxvfv30v0pf8ywRB+w5UDvPJCrf+FoM0NrQmPB1Yec1NzBTrZ0dS+T5fgvbAiXLx4cXFxsYGBQU5ODoPBePTokaB906ZNEydO3LJlC41G+/777wMDA/38/CIjI3/44QfRymr9Rm5ObnNz8+AhgyWulFcsWM5isaRcq1XXVgMlXHVDdZcEoCpQkFY+RYXSpaO+TjILswn65JyC3CFOQwAABfkFCTGJ7t5upmamAy1an2NkbLTy22UEAkHsj6qnqzdz0syqqip2HY+Mk6+oqDA3N29vkK+cqKRoipnS2/QUseKO/c+V06FqsFZ5cUXg2FEDK4mUNN39A+Ww1ZbvgwhE5Tlba09uJZk74lU7MaunpaW3tjBc3V17ZaHGYDAUFBQET/aampo71m3v+Zgd0wvhE62trSkpKVVVVTo6Oi4uLkK9XVBQQKPRhG4yOTk5goD6jjcP5eTkOn166oaNkE6nXzx2lUZUGhrsJOqM0z14PF5Wdpaerp6qqmqXDqTT6TQa7d++dOsHG2FVVVVWbraL8xDBM9OZ4+fslJ3TG95+4ea9fgDDsPjYeBaT5TfS71+3O9dvJKckZ+Vnjw8YJ1pbuLfoko3wyrmrDWV0jzHuQ1wG97okvQ4rPb7pwTmNLb/B5E9XNyPmHvPdS/U1ByFcu6umhoaG0BM3qETa0GBHa2vrHsqQkJRwN/aBnqLOuqVrJXboqo1QGnphLAUFBU9Pz7btpqafPbxbWlpaWva5H4coLS0tEARRKBQAgIKCgrwquYVBl8Y20CkEAsHB3qEbByopDbDl+d+ClpaWlpaW8K3XyOFxkfFeI4cPoEi9S11dnYqKSjeKs0MQ5OruiiCITAt2gIuzi4uzSz9MxOfzQ0OusRjsGYumSby65y6Zw2azyWRy38mQk5dzN+Kel4unh5tHT8ZB6LX0W7+qLt4t1IIAAIrXBE5BenNYCC14WXsHUqlUeXUyo5Wurd0jf2w2m83hcOhNTTAF38Ro6slQXeXLqj7RvRUhgiB+fn5CU6Wwkd7SBAGgpKjUwe0GRVEmi4nHE8gyHzwp4PP5Ak+B/nHMsbGxuXTpUl/P0v88ePzgVX6SEc1g+fx2by4dwOPxEATp03trr/Dh44esvGwvd09FRcWBlqU3EV0RNjQ0hJ68oURSdhpra2trOyDynL8WUkNtZOe1fr/5u+6PgmG1J7eQ7YZRfSeLfYIyW2qOrKVNWCpn3yNF2zFsNnvfyf0cwF0xeRmPx9PR0WnPgvaFrggHHD6fn5iYKAvS/49RWlr6zTffDLQU0oKiKJvNlnK7mMPh4Eg4FpvV11INLCG3L+L0Sa2RrdMnThtoWfoKFRWVYWOGMpoZ/bzdBQDAMOx18msujzvaJ/BZ7HO38WO7dHhFeUXyq+Qh7kN09XQBAK2vIzAMo/pMatsTlqeqzN9Rd+Y7vIY+QauvMoKhKMpHUYwAoSjagfmsj/gvrAg5HA6NRmOz2X0voIz+Iz8/f8yYMXl5eR13+xJC+zEM+/nkoQYOfcHYOdZWndtIEAQpKSnR0dHpXizgv2VFeO/R/dScdzPGTLOysBpYSV6/TYp7Ez8xYIKxkXg9gG7whcQRVlRU/HLzJMBDy0cvNjEx6aAniw+iK7GIMrSgGTvhjjNRhAAA506eN1OwyWl+v3zDUpTZUv3TMrUVPxJ02x2H+Taafve0ypytZMu+MnbS6XQmk9mpf9Ojjxw9Ks5eTbYilCEDABRFL/xxqbmhZfK8YARB1NTUBsQbGQCAYVgLqwVQQCO9UZr+OBzOyMior6UacIKDJgQHTRBrxDAs8VUiiqDDPIf12xPMo+hH8la06IQXvaIIvxBUVVW15TS5PF7Hfg8sPnB/wFcigdF6sD4FGnanZSr9+hAtssNQ+8TopGF+bgCApocX5Rw9O9CCAAD5wb44ZY2Gi/uoflMo3hNBH/x2SkpK0nhRfJ8G7XUG9r06tUwRyvi3wuVym6qa1eU0nz+NxKpxzVjjhp3rBmR1CMPw5qUba2trzczM+nlqFEUvnbnc3NAybeGUHroq9A/l5eXp0dk4CKejr9NvTwOTAycnpLwa5R/QP9P1DyQSaePyDZ12W5eAmKAVF72UBY+Jhq2VW++WlragAd4j125fDQDgluaz3ydofnum8xmNbTQ2/FJ/cR87L1V5xiacYu975HZKNQvkNQNPrc57dglZYV4Z/1bIZHLw/HHmvkb29vZMpJUoRxzAPVIVFRULC4tueIH2EA6HQ69sVoE0yko/JW8SGA76WQzpUVNTwykBjMrT0NDou1kYDEZRURGKooK39rZ2y+ct19PV67sZv0yuFqCRbzL0i38/8PtBLpcLAJgw2Hijk2MsayiP+mkd2Rx+QXH0XFhOqvhmnIqGxoajRH3zmsOruB8z+1D0dggvQf21AbG3rzPZilDGvxhjE2NjE2MAgJmFqSBO5mtDTk5u7OzRtbV1jk6OgpZfTh+vaqmeNmLqYCfngZVNImQyecmaRX09y/mTFygozWK48XDvPg+5KfxQyGAw7O3se/4clpObcy38TxsTm+nBU7s9SF5+3pX7oeYG5o4jZm1KREI8STHRGA7CCcQjEAjrZkxptkDXJKBhAaA1P+1OTCoJM59q3yptZDaMUxw9F6+h2xR+UX3toW7L2T3CSrAJer3v19JripXD4cjcVWQMFDQarY/i6t6lpp05fi4/L78vBu8VzMzNhnm4C5PF0xlNkCK+obG+f2bHMIzH42VlZTU19VrgF4IgPRyBQMSzECZZvs/9ieh0+h+3z16JuZ6Tk9Pz0XIKcoE27l3Ou54MUvCxENOAk3Izxj1FTg7DjR1iuWPJtp3rvhUtJ/CNA1zUAm59RItvn+FpuOFb5EpLS7s0i7yTN7++klfxsSeidhUWH0RXoIHtZqruPr2wIoyLi1u3bl12djYej3dwcAgJCWmb+WnChAmxsbGC16ampklJST2f998Ik8lEUZRAIPSwdIAgzySJROpJrYx/L+Vl5VGPo+1d7B0cu2AyZzKZuXm5ZqZmXVo7xj6Nc9IcmvAi0cy8v+1/3WPD4nXV1dX9YK3k8Xi/nDnewmZY6Jm9b8pWaCXv2vi/DvozGIzCD4XmZuYdJzL89fyp8vryBcHzLMy770O/bP3SlpaWbqSV6aoTsry8vDJZiclmdjXJlERGePuTEkgW7t3MnMfj8Tgcjs9wb348YTvTcLU1PGUQBgBoex6IMDjjiTv4V8pvCNtmzHAmm9Ox36kEYJyCexAjPlx5quT8L31BVCXmpAYpE7/IFSEEQYcOHWppaWlsbLSxsVm0SMK+B4PBOHbsWGFhYWFh4fPnz3s+6b8Ue3v7YcOGHT9+XMr+Hz9+PHLkyLx587Zt2yZs5HK5I0eONDQ0PHOmc/v2f5JXMQn6sElUeHSXjgq9E3r3ffj5ayGCt1mZ2cf3nXz0oJOcwiPHjyhBC3wDfbonqgAEA8/LMaRfIpWUlZUtLS17d30c/ezFLz+eSHmTItrIZDJrWutYZA4MYKwJUaV1ognOhp67/e5+6J1rHfTBMKysthxVgsore5QvG4/Hd1ULYhh28tyvuw7v7nRt1NDQ0Nj4yT2YSCR+u3bb95t294rJk0KhjB4Z2D3XVh6P99uhP84fvphXUnmM6+Nnb6Tw5vTOI99lZkm25LlrQOuqQvOGzPYd5T9mQlA3HqkV3EezUl/WV5X3WwxeWDE6zqBPzPC9MKiHh4e/v78g1H/GjBnZ2dkSuykoKCgrKysrK//H0kx0lZCQEOnjxFNTU7OzszEMe/bsmbCRSCQmJCSMHDmybwT8F+DqOfQDO9drVNfMPzpaupxqlp7Wp42V/Jx8E0XL3PRO4hQtrSxmLZqpb6DfTVkBoHPB2Aj+7Bd8jzB+ZuMXFLYrPVlp2VZq9tnpn+3+0Wi0xRMWTHWdNH3q9D1rvlu1aGXHg+hq6nJr2DqaHUWJQRC0fv6aqc7BnsOk/XHr6uqETjE9gcvlltSW8mhoeUV5B92qq6uvnbpx9dfrdXV1gpYvpCQTgiAYD+Uh5KmPGXYq0C9ucFltOaQCl1dK/jq88kJ9tOEY7CXxU2nAKSrHsGjXf/z9Zujtbg8iPRgA4aXYOIM+cYjrZWeZO3fu+Pr6SvxoyZIlc+bMsbW13b9/f0BAR37MHz58EL7W1tbui+p9fU1tbe2xY8e++eYbQVjMsWPH3Nzc3N3dxbrl5eVpamrSaLT2xpk0adKkSZOuX7+emTkADlpfAlwuF4ZhsXRKBgYGi1Yv6OpQY0YGjfDyF25K+wX4Jr1Knmw5sUuDlJWVJbxIdHZzMjGVaispm45NeIYE6UMPAvAX8lDfh/wt9rit9vC/K+36pNnBmWlZQa6jxdotLT6lU5HmIp0WPHU8e1yneQC0tbWljwN59uR54ZsiOQ3i/GXzpDykPUgk0soZy6uqqwY7dxQwDsMwBjAASVXutT8hk8nOs+dMe0Tf5W+4xgYHAFg3f01ZWZmwLp4YrcmRSq5+sdVYLRuod9eWihnYkpMLWa394aV8+yOqTgbmNKgvfFF6UxHeuHHj9u3bycnJbT86cOCAhYUFgUC4dOnSxIkT09LSxFJyC0EQRLRa4aRJk/bs2SPWB8MwFoslfAzkcDi98wV6D3V19ebm5nnz5t2/f//06dMhISESqw0HBgb+8MMPs2fP7n8J/xUgCHJ073EYB81fNbe3il0InMgFDB3mAgBoaWmR/vDH9yKMiRb3r4ct3bC4085R1bhFD0q/cSSsslFnt4KZusBTGSxMIL4sB3+48miEbq4OBZll+rPEHYVCcfUYCrp4riTSu2I3NTYRALGlmdFzwQAA6mrq6mrqbDa7A78/Mpk8ec5oUJ7HfxRSWZpHGjGTYDmk51P3nDoONC+ZetCfPMmAKTgZCgoKFhYWHA5Hwh0SRZhvoxQW7w0sQC5m8VeY8bs3aeD8ebllK4yHmvXK+e+AGja0Np54fTivpYXV1VyjZDK5043fXlOEYWFh69evj4iI0NeXsInk4vIpE/yKFSuuXr36/Pnz9hQhDof7+LETTyRBhXqhs2/bXEcYAC73+I39pR+NqOB5kPiZPHLkyLBhw9avX3/9+vW4uDiJj8znz5+XlZTrGEUijYty8Xj8QGWNEcPTzyP68QvvQM9O5TmVhe55khfEvlCfDKODtwvW/VZUEDsebE1CfJ/jkoPxSt3K0iVQhCQSqaamRk1N7UvYl+PxeP3jt5WVnfUs7vko7wBLc0sAwMRpwT1JVtclkKZ6+l9/8MoKiC2NeH1zeftheGcv+u3fcBUFimMXdlClqB/go2BJLH+yZqMPhUmhGHTq78POSsar6dAMzRcRsO3JyFbn7u+62QRORAtTqE7Duj2CNMxOQJZaAV9DIgCAQCB8oUm3nz59unTp0rCwMAeHzosTsVisvk7TBwEQFoBn9Y9zAgAKeAl/OxKJ9Ouvvw4bNuznn39uL4dse9vIMgTgcDhPMwTHbJWvyENwZmhrE7++GgCMoDUIr6YNYFxVVVVDQ4OlpWW/7VNZWltaWneSXjm1HvsmCallgQfjFBWzli8AACAASURBVO/dxZNgougfngCDX9xwzVzk8quSOaXX2TlvYbICgGE5R0+q7xRYXlqP1odPH8XlJeiQNdsr29ZvpLxNfRkWp2GoPmvBjK4ei6Lozau3mxubps6bIo17S1jkQ5wZ+WHUY4Ei7LdkdUhTfe2v38g7+9DGLkCoqhAMC35TjS1WDaFHao6spY2ZT7Zx6wdJ2oJiYGMiQkDYxKRfTqYj80fMtrO16/gQZvJzhSH+AAA/HaiaBbLomLVSN3fr5Z19a46tp01c0XePAudz0bJW7PaIPnzU6J3wieDg4J07dzY1NQk8Qv38/GAYPnv2bGFh4YEDBxoaGq5everj44PD4S5dulRUVDR6tLixoSeIbnYJ0ZYHAAykIQZF0e+//97Pz+/s2bMrVqz4yl2Eugfa2qLVWEIytW+ND6eXf4CpSnhVLQAAr7IYZdCpi/Yc++s6SgEzWFMGD/4iqp4yeGBjIvKwFP3OCbfEAsbDOo7rdkl8et1VeqolNR4LmKg5YRnGY2NcDiPmXtX+xQquo4iGVkQ9E5zyP16I9Lt/AACUgpeLJnhEED6Mh/lINze1ugGKopExUTAE+Xn7cTgcobWvprJGS0G3uh2njI5hMBg1H2rV5bWKPhZJowgnjBz3LD5y1Igx3Zir2yD0utrftikMCxKUKEJEdhpheara0j2sjMSm8IvNz26oLf0eVujXKz29AVseh5Bx4IYv6VQeicljyct1YkRA2a3snLdKU9cCAGAIzDGFLuSih1xxAAAMw67cDK2srVg0faGwpnrH4FW18Op6nNwUsvXQnn+dttz8gP7vDRI5Bt/r2WRE6QVFWFFR4eHh8eLFixcvXghavL29YRgmkUgCuw4ej3/9+vW5c+cwDLOzs4uJiendpIghpy5i6BfnjPfzzz/T6fTY2NjVq1cvXbr0xo0bbfscPXp0xIgRAmv2zz//HBgYKM2S+usBIhLVV+6XmN6X9f5Vw5/HaBTjZhZLWWUAch625W0dNjMa8dKCcqcSqH9vE0r0DWHnvJUvzfg+4JyDjvxGxU/Xt/KMDdTaqczk560JjxpL8hSGjqSNXwIAYKXHszOTcEpqDVcPKs/aLHzuHhc4zqnMSbR8cV9TXFwcmfUCYFhZRXlWRY6jkf3MyTMAAH4Bvlm6WSMNvONfxpcWlQeODxBNndzc3Hz2+nmaguLCmQva7uIqKiq6Bbo01Dda20hV2dzSwlLoodM/8CqL6s5+R/UKpkgqUSRAztZNzsa18dbJ5ohQpUmdeM/2ItcL0Y2JyH4X3EJzGAJg57pv2Wx2p5v2rHexJHMn4d7DCit48F3+/5xwNCLgcDjvizIImqT8gnwpFSEAQH6IL/NNlERF2MPiMJfy0R3J6NPR+G4vWKWkFxThtGnTpk2TUG9s3rxPflyKioqhoaE9n6g9BrwKT1tSU1PPnz8fHR1NIBCOHz/u7e39559/zpghvnEUEhKiq6srUITHjh1zdHQUU4SxsbETJnzK36+iouLv73/r1q3++QpfAhCB1F6Sezm7YfIZicthHCX4m36wD7UHn88vKCjQ1tE5W0w5lI78Ogw31ajzB9fmJ1cUA+dsNFAYG4GssoJJf2sHvLquYtB8AADKZNSe3ALLU+VdRtBv/6q6aDdB17jh0v7683tVF38qvgrDsIFBXxWHk4iWlpY2URMAwOFzCOqkqrpqQTuRSHR0cuTz+QnPkszVrdNS07x9vQEArfEPWxMjitQtakBtTU0tnU6XGHU+1K1PVhK9Ajs3peHKQaVJK+SdfTrpCkG0oPlVPy2leAfjVbUZDMaj54+NDAxdnF36SDYeCna8Qe+NxLtpfLpGCASCNJZa5tsXFK/xwreDKNBoffh0DvqNPUwmk6eNnFxWWeHk6CS9JPKOXs3hFzEOCyJ9Zmv88OHD/avhqtrK85bOlX40IfHV2P/eoFFjcBa0Pr/D/xdyjS5cOf+b77YMtBSf4eTkVFBQIHgtJycnmknn5cuXRCJRoPwyMjIEjYWFherq6m1DAz09PRsaGsQaURQNCwsrL+/OTtR/CdrEFTWHViFZicDJe6BkeBr19En+q+fZRJVRO5Im4AdROr9i2dlvMA5bzmG4AwQ5qoJL+egyS3HdCctT1Fburz2xuTUxQmHYGKKhJQBAddGu+ks/NV47Qp2+sU++TGfIycmtX7oWAMBms/Py8oyNP4v7xuPxTsMdSj+WetiPRVubG68fRZoaqCNnGCQ+sXmVoG49RKH6A0ZVgIhSuerzeLykN0ka6hpmpn2VIgfBwJ4UpIYFDrniFNuoD5TZ0vLsT+bbKNVF/yMZS1V6HqbQKF7BzY8uq8zdFvMy5n7kQxwCQk6c6123DiGhBaipIhBqQSlBmht55YVkK5eS0pLYpLjhLsMHGRh8Yw8HPkHW28AkHHBxdumq6oYVFInGNqz0V/Iu/qLtFeWVWiSd8rISBEG64dJ1tQBdZwP3gxYE/43qEwNeIVN6Vq1aVV9fX1RUJNYuJyd38+ZNKT0+UBRNSkry9PQcMuSL8NseKGCyvMrcbc2PLlfunUe/expl9o4Dd3hE+I/H93/ozHVZgLKSyr1MvpGa0osxUmlBAEBzxFXFwNmCle5OR9z+dyhHUmZNnKKK2sr9ZGsXxYCZn5pgnMqcbxB6HePhBSm/ixAURWPjY18nv+7qgRIhk8n29vZtM9X5j/JbsGK+fFl29cGVeK1B6huOytkP01q2d9bBy8OdB7dE3arYNbP2163NEaEtUbfrL/xYfWAZ612sxCneprx98P7xmdvn+yI4ik6nh0fG+96sfV2DwRBw/IsfX/2PbYVXXdIcca1q/1KUy9bYekpKLSiA6jORk5/GKytEOIgV15rS0juuzq2trQUFBXz+P/ZgBAMH0tCdjl3WLqy0WLKNK4Qn3Hp4p1yu5mb4LQCAnQrkqAquFHQ/L4G8szcrPU6scairi6Gn3pSFk7qhBREM3C1Cpxr1026frEK9jC+U/Pz8wMDAwsLCTnvyqopbIm+hrU1qS/f2vF7otz/vJBtTbEjmU8ZP7rTzg2L0h8SWpGmKUu7Ps7OTmx6c1/zmd6Gc457yA3ThtTbSPpKiLEbN8c0kJx/lUTM77/03hYWFZx6fx/jYhmlrO60A3m1QBr3x1m+8qmKVmRuJhhKq0mNcNudDJicvFePzUpkgIuuddU3R+MDxtOBlEP6zRVlpaemZG+c0lTVWL1rVbdsHi8UKf/pQS11LLE/N7kMX8yt0EXLx9f1LYAiEl2DL4vhTDJCdnMdYQhiG8uVs3CjDx9Wi+JLiEls725zsHCUlJWEKhY4r1DPiwxnRdzj2Pk/zGfomBn7O5gAAokH386YCAA6c/LmJ2OpuMGT86E9bmjc+oCcz0bhxXVhr0un0oqIi1ecX6iw8FK0G0xn0xy8iAr0DhjgNAQC8rMKWxiLZU/DS5HpgMpl/XrwJ46CZC2YIDBMos6Vq7wLtH/8U+x27TVQFtj0ZSZog4Qt2NY5QGv4LW6P/Iurr6/l8vry8fA+j4qqrqwEAioqK/8a0O9LD40oVfE3QGqQ8Y0Ptya0t0XeoflN6OOm84DkZOZkjvPw77wrAiUx0w2Bq2zs1g8GoqKgwNjb+7HLFsKbwi4pB80S19Q+DcWMikMUWsLx01yIsR1Feurfh929b8Hiqv7TFejQ1NVWAMoGMV1FRkfKQTsEAuFaAIhiYZwYDAFjvYul/nZIfGqAyZytEkKwkICKZbDmYbDkYAPDh2gWyw6CScl2ktanmlw2qc7fXA6KKiorAyqWvr793854emv/fZ7xPbXzPy3vj7OAkfG4+k4OebRo0DZc+3vdTgp+xBlCaSXzt/ZDnJCPqyG/GD/vkjHN973E9+UEpb1LJTZQmbuPiLQukuWwpHmMJGvqtyc/H1L7CalB6oT6/vkL7+2vtnRNpoMhTG5ubKH+7t2AA7H+HHnDp2jLr2rnrqjyV4rg3iq223LcRM1dP/d+GHcJPvbQgGhFElGGj9Ts/51VVVVATnovwampqBIHjsDwVr23IKUgX/Lg95/ZHVBpze28hU4T9iqurq4qKyqxZszZs6Ly0NADg+vXrV69eLSws1NTUXLVq1fTp0wEAXC531qxZmZmZu3btWr16dR+LPJAQiNI+XUI4vOr8b2uOricZWRONpPI/bA8rCysrCwmrmbZkNGJZdGyqsYTL9dIfVxQR5Q82HwPHjhI2Mt9EQUSynN2n0GMMw+4+vFddV+2mNuNkpuI2B8mXPZ1OP3nxNzKRvG7xGsHTN6yoQlv2Y/O57wCGUkdMl0ZUCoWybc1WaXpKSW4TtioeoXNBJRMzpEJ2UUe5JbmqS74nGkibIGLKmElvUt/a+dqqami0Jjx+uG1pKcUVMtJavfmT12XPneDMTM1U3yrpGGsL0xLtSEYelGAxW31MqN4Yht25/herlTV+hAsv7A/TZXsQRYtRT/jyg7ARuhAAQMdQu/xjsfMQpyfP0tRUyG/evY17Gz8xINjMRHIyECEkMweSmQM2bZ1geVT723Z2boqcbfejDFcvWtnU1CT0xQ0rRvEwCJRCY4mirq1e9PKVib1TKY4F42HBkwGHwzkZ8hubw16zYNUyS8UzOeho/c71q6GhYdGQYjwep6f3T61jOWsXdnZyryhCBAN/FaEJ4/tPPckUYX9z6tQp6W17ycnJCxcutLOzy8jIWLBggbKyckBAAJFIjIyMnDmzCztj/1K6ZFrAKWsoz1hff+kn9bWHBOGGfc3JTHSFFU5ieJMCVb6pmm5C+8erE+Nxmx5fUp27XdjS0tKSmJOEVyPOpBSsznBYYQXTJK0ZampqWgitzayWpqYmYYkDWFFFfc3B2t+2Y3yeYuCc3v1eHYBiIKIMO5ODxlah3znjVlvDkRXY9ZtPTNgfdTb/2umiB0VRoSGcRqP5+/gJXiu4j6ZVsYqvhfOw3iyjqKysvHnFP45F53PRv4qwhPF4ZRIAAKqurq4rbKQQqJmhv9r6TSEaWtoBcN0XPyOKHz8eb0yFZsybVtmKbkvGnlq5Uog4t9A1KJfFb729Y8v29uf8B4EWjIh8mlBUO4F336kHihCCINGIlH3v0J2O7W5hFuQXPLz5WN9Eb9KMz/LoTp09pbzihdqExXgTewiCBD9Ec3NzNbMGIsM1NTUzjJW2JfEqmTjtzrIZwjDsN1I8GQjZ2qX+4n4wUUIuya7ysgrTV4CMqP0XDiBThH1CY2PjoUOHNm3apKamhmHY4cOHfXx8XNp4Y6Wnp+vq6nZQyezo0aOCFxYWFnfu3ImOju44X/l/jK5Gh5Jt3Kj0urrfv1VfexjXWVWgHtLAAbc+otlTPluz1tXVXQ/5c5DpoPnL5jEYDNGdNEbsA6KemehqlUql+jl6V9dVj3axCoTgX7PQnY4SlKqpqenExnHycvJihX5wiioaaw/W/r4D47Jp4xZLaRzNK8iLiHnmP8zX2qrL62YUA1MikWIGttIKvuJDoBAAAMBfod6o4uJ3zvtOQkTh/ZPJZJLJZDHnryfhEdlvc4d4O3n6eLYd3Dt4orGlKRb6EzvnbW9tr4kSU4ntfIPEjhVoQQAA0NDQMHI2aC4u1K2op3h+sr15a0P/c8IFP0MmG8Lv6rG4anSpBVw4g3QpD/3llu5SfR0qpWsZDF6+iSUNHvT6/lNHPq9X7GdPy7FWPgge1O624ceCIn15o8Js8bIq/NpyuLmeZGoP4H+eL9XV1eeMnMlkMU1NTWEYTDWCL+ShOyT9DzuFoGOMcdn82nK8ek8r5976gErcaOk7/gteo18gysrKPB5v3rx5GIYdP3785s2bEiPlg4ODnzx5Is2APB4vJSXFxsamtyX9omlt555TXlF+9uq5tPfpbT+ieIxVcB9d9/sOtLW5T2X7NQudMAjW/NxE++jR44rc+j8v3+RwOFQqtamp6fQvZ6+eD+UxW1uibtHGLhTtDEFQ4IjA+TPmKygo7HCET2QiDEkmURiG3V3dHezF/z9NTU3R8Smc4PWcgvcNlw/wqoqlEfth5GOOHvIgMrxLX1bArrdIHRtLGI9fYgFT/r6lN944ru4zgaNhpHuNNysaCStB07Oy9/z2w4GTB8Uc8UoKS0xVLIsLSyQODkGQgZW91qL/NYYe5tdJW4yQy+VmZWV1kPE5rgrb+QaZEYVMjeRf98ObifjiQxAUEDTSG/kgN2J6YvLbmpoaQftqa3iOKcxBsFmm0LuJ+P0uOAU8WGUNr1q34ARRx1kKFypRZo2bYUow83MezM5526UD22NfKrLDEe7ApcXDe5iKPWXKAvGyKq0Jj+WHjhDVggIc7B3cXd0FTy1LLeHzuWg305NAENnKhZ0loehCl0AxcK8YnWzYr9HhvbMirKmpCQkJaWpqGjt2rIeHR9sOCIJcvnw5JyfH2tp6zpw5fZ4mGMOqDixDWxr7dpa/wWsaaKw/Kta4f/9+Ly+vJUuWhIWFJSYmSvQxCw0NFQvGao9t27apqqp+DduhorD4oIYFNORAaVlpXFKch4uHgb4BAOD5y8g6WtPtiL8c7CSUmKH6T0OZLfUXflRbub/b+Q9ZLNZfD++qKqmM8h/V1lhVzwEnM5HXbVzajE2MHr54oqhPEfjIlJWVybGpTc1N1cnRZF0TvIYeaAcLGuSvA/+ejW61l/bZ9OnD5wqNtHspz9ZuOtASc6/8xDfZPAWLOauNHTpaTgX5BUbEPA3yHyvlLEKuFaLXC7HXEz7LdNUSdRtpaVQdOe0qDlfHxt36iB5OR9NTGqx42GBSC4Igor5C0+ZPzcnO8bEVL0YmCsnYhjpqdsPVQxobjnUsD5/PxzDsr/C76Q2ZSmzqN5IsoNGV2Iwo/mpr3IRBYLcz3qpNdhJ2zlukhZ5YjWLlDckxb9d9u0bQvs6cSyKRxH73DZ76Spq6U1+jzwOQQdJmhAU21jY21jaMeCorLbYnZkIBsVVYBRNM73C1JC8v7+PvAwBgMBh1dXUGBgYwDGN8XmvSc40N4rcpMQarQUokEFmBjdTtjh4iWw9tffWQ4h3cpaOYTGZubq6JiYkgD+XrWkyNDJko/tsUIYPBcHV19fX1tba2njBhwoULF8aNGyfWZ9myZRkZGXPnzj116lR8fHyfl1aHIM1NJzBEUnxWX8wmyZGXQCAcO3bM3d394MGD7Wm7thUKJbJv376IiIiYmJgvoc5Af0LGg4PpyGFX3I2wW4gBVBZ2a+uqzQAALzevv5785eM1qr0DaWMX1Z//vumvP5Smrune1Hl5eZnNufxinutg17Y5MH96h0w3ho3b2DA8hnkYDjJUUlISKAALC4vK0ioqzUg+L4rk0Eml2Z2O8MjH/NXW0rqPWtqaRz14YeVsCZHkFANmJmPqDU8zru74bkfoJbySWntHyZPl9Sh6CnIKHQ+OYOB9A4ZgoIUH0uqxiHL0TS0WGYQXLVzHePFX66uH6msOCp421MhgpRW80gou9XY78Fz1fr3K2lacuUipTSUlJTf3zjUBxWMM48UdblG2xACMT1MzGOd+CcEQbJCTAdLEV9OS8H1T67EZUfybfnhv7XZvqS3P/1QMnD0IVYzJjh1k9cmg+z7z/ZWH1zQo6ltWbRLrv8AcZvBB0HMschQwaMceyufzWSyWmH+pnL1H88NLWI93R3/JQLfawzgpdASGYedOXKBgilZeph6eHqz0eIKOEV6t88iZpRbw6Rx0sFzTk3sRRuaG7sOlukcJIFs4NYQeaptiRoyqqqrU9+9cBw8V+DA/uB1OrJdLfvlm2fqlAICLL3MsXz4LA8bjJnX5ca3b9IIivHLliq6ubkhICABAWVl5//79YoqwtLQ0NDS0uLhYU1NzypQpRkZGu3fv1tXt6T5yx0AkuYFNvIYgyLfffhsUFHTq1KklS5ZIk1BYIocPH75y5Up0dLSaWrt3t/8qFDw4H50xhaLg7er15GXEKM9P9lEjQ8PNK8RvUp8BQSpzt9Uc29D85CqCIzyICJdT1Zq8ZR9Oahd2Y2Nj3RQtFSOVtmWTy1qxi3loxhQJdzQIgkT96PB4/IhAf4zHrXxwSGnyqo5ntFGGhmnCZ3PQ9bZSLQrt7O3s7P8pMjDI2DCdlqXvYFP3+w6NtYdgiuRqz0/vPzOn2D7668nKTcsldihsxi7no+fzMBoByOEBlQDMadASC/iaLywsGpWZkfXsj9PWaKn//tM4JfGMlPpU3G8TLV3yUN+HyKNAnINKFy9ECKJ4jme8vKfSviJks9kQDybCBGd7p1H+AcLQCCFFLdjYCOQPD1wHWpBbnIM01so7eDrBsIOTg9Ci2djYCKhQY3ODqGuPkDXWcCWDvzIBPAyUMCaKoqeO/AFYkP8UHxvbfwwZOKoyQceInZ0s9BmWhrKysrM3Q3TVtJfOXQJBUD0HRFWgF7ylUqUQBBFIeBaDKScvBwBoffVQaAftmLlm8O4U3qOXqSos9biIV2UlFWWF5WOmBZpbdO4PDJHkyJZDWhMjOl4UXrh1ka8DFYcVr5i/HACgo6eV+jHdyHaQ4NPotwXb9czzM3JBu7lde59eUIQxMTFCD46AgIAlS5awWCzR+La4uDhbW1tNTU0AgJaWlrW1dVxcnCASoIdsTETKWsEUffRLygrwiR9++AHDsAcPHmzYsGHevHkPHjxou8O2b9++0aNHOzs7g3aSbh8/fvyXX3558uQJmUxubGwkEoltr/n/MBiKODCuLT6DPf12664NO7t0LESSU12yp/Hm8VIgn6FE5JW/N/9hhe2avR3sT4pCpVJXL5ScPfn7FHS5FawldQAnO/sNQc+0Pc0kSkB91M+hH0buHm89qMtZ6U3NTDfsWgtBUPOTq9UHVxCNbAjahvIu/njVz4Zy8XR5GRE7zO/Tyqyuri42Ms7awQrSNt+bir6sxBAMTDGCIgJxNsrtqpBXf163RNRzdQwC2mhBIQvMYQoBBD1BMqd0ueyivGtAc8Q1pKm+PY8nNTW1SUsmcDgcQ0PDtp9yEDA1EtlqD0807OiRoiXqNsVnEoBhAD4rN+/h7qGhpqGuri5obG1t/fP+TQ1V9bEBYwSX8HY7bHAYHFGG+WshYmHdGIbxOHxFvBKLxRKbTmFYUEvUnS4pwuLSEo4iL7+ikMvlkkikPwvRMQZw22xw7bF8/dKWlhZlZWVedQm/ppzc4ab0P3LiwTJL+GmxkVb+aVsH29KCMkOKyceCImkUIQBAceSMunO78UNGtLI57bkBDrEdHPMm1tHXR/DWy8/LbbibwHiU24QxzT0NdFP8zbu2v9pDekERVlZW+vj4CF4LtF1lZaXoZmBlZaVoInNNTc2KinaN4SiKLlmyRPh2+PDhbXNVYxjGZrNxONw2a3CvBPoji9/91EB9Q1JSUmho6MuXL3E43OHDh/38/C5fvjx//nyxbvfu3bO0tBQowqNHj7atJXT58mUmk+nl5SV4O3PmzN9++60f5P9CgCDIjYKPaCYuTCTcGskmdXVjmKJMXbTHmM0edDsUrztUR1+1+vgmpeX7cdLpQomkNUJhxdC78SibLW2ldUbKC7yNa6eZjzAMq3+XOl3HYfPNtLtrO9o/EBTmbe9Tos8UnI07UlnEK82rPrpeIWA2eWiA0KfU3MLM3MIMACCQJ/JxlBJDPfRK+CXbdUvNsW9tUJO/t/TYbMBmsx9HPlahqXgP/yebK+9DhgvjfZZN4Eh/n46/1Fht8FQP/l8S9/CQrl6gOJKjV9OLe/KjZrfXQ3BLkSjA+iRYTx4sN+V3IB1SV8EueC8/ea3EEQT6VfDR+/fv81iFWe+yhzq6CLYHUC7nR3v88pDISfgoN2uX8YGfbYDNWT6zsbFx0KBBYiPDVq7Ik6stGUkEUwmGbYnY2di2MJq1h2oL7ngXcuE9jpj0fzwAgJycHJvNbn35gDjYj8PjA55ULq/LTCDbOzmL7cjvytJXTF9aUlTi7OIsbeouNV1Iy/CXTdvlNa08xruJLouFeLp7erp7gs9/PsHrO4XwWFP54S7DQDs/Lp/Pj4yJUqRQ3V2l3bMlEAidGpV6QRHi8XhhEjzBC7EM6Hg8XvS67biYNQRBomF2ZmZmbTtjGCbIs67KZyxUrJlhXK8Fvqwl4dChQ/Pz8wWvSSRSfHy88KOnT58CAATfMTn5k4dVfn6+np6ev794NpO3byV4miEIcvPmzZISyd53/yVgGN67afduDJofB82Kxa54S4606xgCgbBy4afYplYSkXHnpNqaw6BbhXxRDKx9je4fAqkrfLqueDxeXl6ejo5Oe1vfGI/Ly0uhBS/Dtf+fRxCksLBQS0vLf4Jvbk7RVcQ3to7gJ7KQ43A4OBxOdPEBw3AHFxFBxxDoGILBPjz3wKbrR/l5KcoLdrZ1FwQAOLs63b397CZp8FpraKMtDMBnfTIzM9PqM/gf+PTmprSC9HE+Y5211RjXj1is3G0n3d38xyHA/i661JJgK7Vl4E3Sm6KCEh9XX+Tyj4qjZkmZkOXPD9jxTMxdE6ISQHQ1eD0OIhI6uvcx48Mow8cSFTp3erGyskrLTdewUVdVVRWsCFEUHTcI+pFZ/FGXolNRIvZDqKmptWfFoI6YwYy+KW8lbXAIHo+3Mrei0WgEAiGbjlUyuC3vwqPyKQF+AdJnG+DXV3LevVTbcqqDf6AYOgQwdrDV+6Q3C1ycTExNhLnlpIQ6Yjo/bCtB2x6CIGmqYYjysAzd5QQTJP12PB6vvr6+oaEh5kM8xAY2VjYdBJ6JIk0O515QhDo6OsIVXnl5OQ6HE6uRJtoBAFBRUdGBgRCCoBUrOgnJxDAMh8PhcLiW5zc4+e/4RAXwhSnC9ti8eXNDQ0Ntba1Yu5KS0u3bt6X8c2MY9uHDh6CgIDe3gamI3Z8INkyu+YKNiYjzfey8F85fp/vGX8Xh4zjvE5gxf3WQkOVxWERBVmHQ5FFtr/8z2agcHlpoiRdKEPk0qja9MRqNWf+t+gC/WAAAIABJREFU5DLxrOw0go4RsX3vFQBA1Mvo5znRckzins27h7q6qJZiq14hiRPwqiQAAKipqQn9/TqEAyMm+Kclv3f3dtU30AfSZRvA6RiRN/5Sd+a71sibbePuUQxkEE2uWhpN1Ie2OOAAAB8+frhw57KhtsHC4CnNz/6kZabIJSepKSpnVdeSnA2Sb5waJMdRnrxazkLaGj0a8mCHNXPJvns7hilOmDyu01sSiqIvH8VZadhnFtU4GNvQrxxQnr4ep9hJWrjkWmxTEv/UMFxhC0iqxW77w8rk9v8kKNISdZuTkai57Q9YinNIo9GWz18m2oLD4SAIurB2VkBIxvEV1tK7sFGG+DGeXecXZZFMOqkgLyDtXVpCWDITtK77dnXoB2g0qTC9PgMt5g9xHCIWVNoB9IcXqb6Ticpd8zDYPcLQi/3tpGBCN/zzFEzt5gXYc00ppoOdu3RgNQtkN6F+ujicpL/JsdPH69EGF4PBKgiNpqyooqLSi86DvRBHOG7cuPv37wsyZd+5c2fUqFGCp4C0tLSysjIAgL+//8ePH7OzswEAWVlZxcXFvr7iWQm6h1LwMs2tp9RW/Aigf0dA5MqVK3fu3Dl69GixdnV1dSMjIykHwePxO3fu3Llz5xdSlr0fwMPg5DDcGU/cwhhk19seOANDkMrMjS0v/uJVFrXXJTsl21jBPOt9tlh7FQvsSUF+H/6Zy56KqnI9u1ZJVbL9j1dW2HT/rLyLeHUtMZQUaVgrSlP4NEiQPhSoBxn+yTO+wV/4EqltbiUBOcCDn4dHGeHNIx9GdfotAQAYhpWWltLpdADjlGduan31kFv0zzdi8MDJTNT8Fv9gOvqdE7z/76yVH4uL+KpYTmFG9cmtgMfVn7n2u9uvl+w5PkNLyfRBxAR7e61vz8o5eXU8dUNDw6UzV6KeRQveeuOKTPhyd2KqPlR9KihWVVXVnnEEhmEnD8dKrMTGwUZl/rdEPdPqg6uYyc87mK6KBaZEImeG4yYbwd/Yw7f9cfbtu+fwqoprjm3kFKRrbDoujdW2AwbrUid4D71c1pWkwTBMHTmj+Ym0xVkJBAIP4cI4CAXQ1QJs5XAjPVjLWstSypUQAIBT8J5XVkDxFo8p7BRzGjRUHb7xoZtGJ82gWdRMyXVFOuDmBzRIH26/Ej2GASAvL79lxaaVC1b0btLtXqg+wePx/Pz8EAQxNzcPDw9/9OjR0KFDAQAeHh4TJ07csmULAGD//v1//PHH6NGjHz9+vHr16m3btkkcaqCqT9Dp9JiYmPLycjqdrqKiYmBg4OXl1bbKTM8pKSnR1NQcwEKyAAAMw4qKiqTXux1QUlKCIIiSklK3fWIBAAiCCLZ5NTQ0RF2B8vPzx4wZk5f3WYKMeg4Y+YgfoAd1NeOwKK2vHjHfRquvPSTx0/y8/PycQg9vd1F/0UYOGBPBH6EL7R0sPq+Ya9gnMKwl6nZL9B2lySvlpSiXyGAwFBQURLcEUAwUNmP709CPLdgpyzIlOWJjfWNcZPzwEcPNLcwQBCGTPyvsV11dfe3edRtT6wD/AABAVmZWzJ14Fta6atsKMpnMSn/V9OCs5tZTDFju5zTkdA7qrQ1vtoPdNSAAANJU35r0lF9Tjg2yeltNV3wdZu03VmwFifG4Uu5Sxr6Ma3zXmlebNdR3cM77PN8g79iEjAc18q80fbc64Odr1R2+dBRA0IZZUtXB4JUVNvx5DKegqDR1LV5N3IcIwYDPQ/5IXfg7p84ehTGsJeZuy/MbtLELFVxH9aRKibD6RF4T5hXOL5xOUJD6nowh/Jqj6ykeYxSGBUnTv7GxUUFB4VEl/mAa+urv3JvPXzyPSnoR6BHg5dHhQwmGVR9ZozhihpyjhFQ+nfJXEXoyE40e0y19g2GVP8xXW/I9QUfa+wwfBea3+Nd8ce1VWORyubW1tTo6OhwOp9erT/ROGSYejxcZGVlfX+/n56et/enPmpGRoaKiIvyvp6SkZGZm2traOjm1u68yIIowJSXl8ePHPB6Pi/C4KJeEIxJgAplMnjBhgpWVVMmXpcfQ0PDu3bsdnIE+4tatWzY2NtbW1gCAlpYWRUVFPp/f840FNTU1e3v7+fPnt/UDkkhqauq1a9cyMjJsbGwOHz4saKTT6XPnzk1KSjpy5MicOf/cfCUqQgBAPQeMeMQP1IN+aqMLBT4FnVfkQNHqgytp4xaRbVzbDn4+F31Xjx12hXXkIQDAs+hnj5Piw/GB44a7HHaVJoILYDxuw7XDCL1edd42nLIGAKC6ujo95b3zUCfpn+U/SYqB5XFIXhP2cBRemMxF4CwjpggfPX2U3JTGyKcf/PYABEGJGQXbDj+uRfj281a4apNc1SGLmN/q87O+UVuqbGW/y+lTEGRF8cdbh7+x4bYMGTmWoGPMzn/HyXtH9Z0sZS5vidDp9Ed/PdY31kt++dZeazBDqT54WjAAIL8JmxGNTNRoZsYdxQC2ZfEmac8GirS8vN/y7E8F1wCF4ePwKprCTw6/R5+Uos+C8O39LkhTPbcom19Xyc58DSBIfspaopp2Vw1XYoiWYZoRhQxVhzbZdWFHil9TVnNis/rqnwnahlIe4v6Av9UenvS3E+zh34+yNHhKdIW1i9cAAFLepsY8jLVythDN8A4AaE2MYCY9U193WHrZROGiQO8aL2kC3rBbOT+bwi8ADKWNWyxl/6sF6PlcqfTul1uGiUAgBAaKh9XY2n5W0NLZ2VngHvlFUVpaGhYWxkW4Jc3lLZxPiZpoZJo+qnPnzp0VK1b8N6L3Lly4MHv2bIEiVFBQSEhI6K3t9dOnT5uZSVtD/MOHD0QiUUtLS9QJSElJKSwsLChIqgdkAIAqCTwPwvuE842o4rXdT577tYxeOX3ElMFOHf7TYFhx7MKGByEsooq2rq6cvPzbOiyxBouvxp6UosGGsCEFDLnHv+SNt1OBTkUm5yiSbdjvjri6AQA4HE5hYeGgQYPai2NBGU115/bgVbXVVx8QRk//de2eqbxVWHH4ghVSPTH8IykETg/HrUtAXO7zQ31wzmrt3pLchrhVRVRbjfCBICivCZudaTh98ZyZFvLvmglJNdj1QjSDuXyu6qtfKk9QCUaKJrMB1QRpabz3w6oGa41ortmIKWsAAFIuUzpGSUlp1qKZAACaMi0rLcf/bzuIGQ26NxLnep96bspOX20gZQWx5MTktDfvR47z19vqyYi5V3NkLcnYRs7Jm2w1pICrcDANeT2hXS3Izk1puHKQZGSNV9NWGBbEHGS378JxHIzbtmJrb+337HCEgyKQVdYwWerrCa+hpzRhacOl/RqbTkJEEgAAw7CIh08b6xrHTx3X9n/1sgpr4HyWXHTB1Hmp6amDfT9ZRgqyC81VrAsy84BIADrGYTU/vqy6eHe3vxoRBjNM4MsF2HdO3VGE8kP86v7YSRu7SJrFNwbAz2noYdcBSxjytSfdfvnyJYqhH+hFLD5H11Sfpq7UUFlXVVSJoIipslFcXFxwcDfDWUpKSg4cOFBUVGRnZ7djxw7hPtvHjx+PHTvW1NQ0ffr0WbNmAQCam5v37duXlpZG+D975xkWxdUF4DuznV6WKr03KzYEpAgoYsUSib3ErrFgrJ8liSYm1sQYUOwVxViCjaJSFCwUBQFBAeltdynby8z3Y5LNursgZQXLvA8/2LN3Zs7cmZ0z995TSKSgoKAVK1YAAOrq6nbv3p2fn29ra7tp0yZsnL1hw4axY8dGRUVxudzRo0fr6elJcxdERkba2NgEBgZGRUXdvXuXw+H07t17w4YNurq6sbGxubm5x48fT05ODgwMHDt27LFjx4YMGQJBkEgk2rdvX0pKCp1OX7lyJfamEhMTAwAoKiq6f/++q6vrjh07sNRHJ06cuHr1qkAgsLe337lzp2KkeWpqqrOzcxuv+ZMmTZo0aVJERERpaWnnehVDnwKuBBC8Y8WDDaB++v/9zBhNTEgLbmA2YB9FIlFtba2pqamijwbNbehfEb9mR/+kr+3IHRZ+7jXqo8vWe3P3cj+bAI9BAICRZvCMBxKuGB3Rf+ZM0YvFQf/4al+8dqmQ84aeorN60SrFgGtJM7P+0Hdq/X20Rs2Q/f279Xd9lpLpGdAZ5yYYAoeGES68QYLvir91Jax2g+V+tM+Z6E/ZCEughejMBAwAbotzmOiuQYR5DroAgN6GYKYdAAAIJIAA+RCQYZzUvxuObiMZW4obqof7BN9uEQ0dOrgTir2XPn379On7jnOpuTp0wY847R54OI7YrtSCAKQmPOpvMujpwwzLr0O1x3+jFTyTm5XMy3zQeOm3BOPRW4PmtVajgPPoVvOdM/rztkhLzDeUlYmIErFEwufzVWUI++hB7nToz3xklStUUVFhZGTUWsFeWdQGBfBfZbbEX9QKmQ0AaGpqKnr2xkjDtLCwUHG66JfnkvDe7yQXpdPpgf7/LTyPGheU+TRzsus78ect92Iodn3bXxVLKbPt4a/uSf7Xvz3FeuUhGVvC6tqC1y8o9v/FRrc2mPv7LUImgJFmPZYE5Ys2hCiKlpSUcEU8nohv09uut1dfAADo5/A07nHVmwqBRFhcXNy5Pbe0tAwdOnT58uULFiyIiIgIDAx8/PgxtgK0ffv2gwcPAgDmzp1LJBKnTp26ceNGDoezb98+LpdbUFAA/s1at3Tp0tmzZ8fHx/v6+ubk5JDJ5HPnzsXFxe3YsUNPT6+mpmbHjh2YIeTz+Rs3bnz06BF26FWrVmlpaf35558zZsy4efOmu7u7ubm5n59fcHCwkZGRUCiMioqKiIggEAjffPNNTU3Njz/+mJOT4+/v//jxY0dHx/T09NOnT2/fvv3HH3/cvn37pk2bDh06lJCQsHv37pMnT2ppaWVkZCidvh4/fvzp06dDQkI612kdwkEb+s2DMPWe5NkEIluEZjGAvwm0av7KqqoqR8d/qoGfjToHmggGTvpjJigZ6BgOH8u/HsE0pnLQuw99DF7U1KVqF959kOnbzxWWCH1MdPInE0kwoBDMATCXbmWgR8+vLNA10Y04cETAEYR98xXmv8fn81lVZfClPeqDAxXnFb19vbx935NirW3CbGFPI2hVOmIVLZpvD5Y6QmZUAAAQIWDWA8kka3iIwX+Zt0zUgGI4/D9RmDBJwzdU3Xsc91kiRCAZD/R3A52HxWLxeLwOlbz3MYF2uBN8YiWXRhA8WlkNkmXEWL8Xz3L8ff8ZVkJkqvqQIOLAoF2pTVPiv3OtNwBgPADgZe7LhroGDy8PMpksqixuij0hYdUZrNwnu6xoYWGxLHQRiURS7TTP7kFw4G1JWswxJOeBtq7msah25Y9scfNlnPppQPBMAMPa2tr2A21ZDSwHB3m7lctCMxloTEBbU69aWlpYclEpksYGdurfRuGHOngq8rjTIRoBpNag3sadGhS6+3Ez7kkNYUVFxeWov2AKtHjNQjk/iZ+fIxtaqcfZPXzRhlAgEIjFYqFECADQNfrPRVvfRL/qTYVQIuRwOJ3b86VLl2xsbDZt2gQAOHTokLm5+aNHj7B05KtXr8acZrdt23b48OGpU6fW1tba2dlZW1vTaDQsvvDs2bN9+/Zdt24dAKBPnz7Xrl1LSkoKDAwEAKxfvx4zfkKhcPHixS9evMAaODs7Ozk5YfvHvPJmzZo1fPhwoVBoYmKira1tbW2NeZlKU/WzWKyzZ8+WlZWZmpoOHDgwLS0tMjISK/w0YsSIpUuXYodbuXIlAKC2tlZHR8fc3LxXr17YFKsicXFxtrYdCznqCl/ZwEnVqNl5EZUAtMnQJGvo50G6sm47GaXVL/Map+gpL9kROHWOGQHEF7ACNAoJqcmG+c8Bi+9EJdduC4OIZO0xczWUzROODgz2GTZcIpEc33dam6RTW1traGiIIMifuw8hL14M8XPy6sLqGovFqq+vt7W1VTpxbaEB/RVAeN0M//pcPPw2/GAMaqEB/foCMVMHiq4iPB7vVsJtI7qh51BP2ZquGBCBqD6k1Uyt7YTNZp84eIoMqMEzAzt03Rc6wWbq0IR48c6BhAWO73n8KQ4rc1no9PsSe20N++U/sP9cTTIw4fIF13dFGEJagr9+62dvJWFUawaFqXsEK6ZcV5qJpos46UBp4wg+S5heFPsWZkl7Nqmtrb1+/Sm/TF03Nc56+CgIguSW914Vviotfzt8mPfeHPJKV0L7510BAABFG68fUR82Gluf7iKzHeBTRYi3cWcmLdXc/Wp3L9aZtAxzs+JwODRIjSfgYolypM3uV6NMAQhtMw3Qh+aLNoRkMplAIJBgEgCgmflf1Z6mhiYAAAkmtXMZQ5HS0lJpySQymezg4FBSUoIZQsxcAQBcXFywEeeOHTsWLVpkZGQ0fPjw8PBwX1/fwsLCx48fSxMLcDgcFuufShrSd0YymRwWFnbmzJlff/311KlTmLuKWCwOCwsrLCx0c3PT0NBAUbShoaG1F/a3b99qa2tLv3V1db1//x+Xd6lPqY6OTlNTEwBg0qRJiYmJzs7Ojo6OM2bMWLFiheJ8Y/eHc/zmQVjXB7bWhGp5oPcV0VwH2PHfOjsNfHC5gd/LgxZdyVOa5ZMvAQspM4JDYJd+MACALha5VLyGKDSSkbmYUcM4/oOwNF9nygqpqyTmVgZBELaKEzJ9ZHNTs/Qq8wsy1LSM1TyUJaBsHyiK7j26T6SBjK4Lks3kIoedFnRoKDiYi/jfkhzxIuzPlTyboORXnPvy5bP6bHG+MCs3u5JT7evmPSqg87ophUAgAAIkFreVH6M1RptDKWOI4+MlhU3o7sHtckHCuFuBznwg3j2YMNcBBsBQOO9/9X+shw3MjFztuCRdl/ELtKkEsoVj20mfVY6ZOpR+aNXsP+MfUueNi5Os7g37tZLjNCkxOTv9ed+hvSWQGKXTkbw0MFz+uiAIEhVzgtyLwkmBr9f6FE3tQPeiEjHr3B6khaU1bfX7W7eDMBuo71+SCE8CseN2iqCtT7Z0Yj+M1fQNBQA4ODgQZxA1NDTkMpLvzJJs7NeuTOIfji/aEMIwbG5uLi4tIRPIb54XIhKJNl2HWcMoe/VWjUSjEimdfn+k0+k5OTnSj7W1tdIkc9Jo+rq6Okzo6uqampra0NBw/vz5kJCQqqoqQ0PDgICAM2fOKO5Zdqwwe/bskJCQFStWpKamXrhwAQBw7969169fZ2VlwTDc2Nh45MgR6eNbcVcGBgbNzc18Ph/zP8QGN9hXiu2pVOrx48cjIiLi4uJWrlxpbGyskmyxHQJF0Ucpj/g8gW+AD9YPRBhgS0RGNLC5H2HlI8ndYCIAAEHBzAfikBFjHJoe/S7yT65Bh787tyNGwLR7EnN1SDohAxFJ0nIHRINehqsPsmIO1e5ZpjdjHdncoaWlZV/UAYCCNd+swn7Gsi5C/Ozk6a5qpNlrTMzNQWeBIEhbXbuBy9TWfH9823JnlECCA26J9w8lWGq8c2oikaixsdHO1pb+TMfI2qiOUQerE5vZqq/OSKPRlq5bJBQKsSXkjuKgDT0aS5wQLw67JznlQ2hP/rw7FejsJPH1IKJ0TpVs6WSy7QysrtVe38QPhoEW7db6cS0icKUEmZoofjmJZKjMFr/MznOh9y0vLlu6fjHCaWb9ugThc2HqOyXhYRh2s3UtrizJNLEdawHrtzvYChXyGcd/gEgU+qKd0hc4kUj0OO0x3YDu5OzUifPqpQ7ZaEEptWhrpr1tdKYsr9+/imrXh2RmB0GQ4sxBWh1a3AKm2/ZwIPinEYf+4fDy8oIAZK1jSYbIb54XZSY+LX1ZrE5Ss9K2gGF42LAOZMiVZcyYMffu3cN8Iy9evNjc3Cwt0/jbb7/x+Xw+n3/gwAHMEyclJUUgENDp9EmTJkkkErFYPHny5Js3bz548ADbJCMjQzoilMXd3d3Q0HDu3Lljx46Vzn2x2Wwej4ei6I4dO6T2zNjYODc3V25hz9TU1N3d/eeffwYAlJWVnTp1auLEVgNvc3Nza2pqyGTyqFGjzM3NuVyuYpvw8PDc3Fzs/9WrV0v/l8LhcIqLixsaGng8XnFxsbQUajupra3NScqvzKp9/fq14rfLXOAqLoh8KbjwBgm7L+FLwJFpgzYs+fbQONvFqRKuGOSy0KulyJN6lCUA36RKhAh6yocgdQOoKK84tPtwzIW/sI8QmaL39VrtUTMZR7Y13z3XxGKxAZcNcbHxsSySJkbT1UiTORu7YgUx1i5Zs3XJ5n59+7Wn8Wo3OHkMcbmr/E848uDRy39eLXxVtHbxmhlTpi+ZvXiu74zQMR8kkz+VSu2cFcTQpYC4YCIMAa+/xS9ZbcVxCSTgeCEyO0l8PZAot7IIq3deAZWjSQJzHOBZ9nBraR8mfj0eWAhHhwZTKBSangHFvi8vW0ng+eyvZm5fs/VSk/li5w48opvvnIWoavpzt8hGfGZnZZc+qrp14a5iHvB2Mt4SvvG2vZH1TU1NCPJfY6KekU7oEsapn1CB8qPvzJKs7wt3YripWnr6+D2NnZ2dv7+/GonmqG9vr2drqW3uoGdnr2tDI9NGjx7dIS8AWWxtbU+ePDlt2jQTE5Pdu3dfu3YN81KzsLAYMWKEq6urhYVFr169sGwDFy9etLCwsLa29vb2/uOPP/T19e3s7GJiYtauXWtmZmZsbLx27VqhUIhtLueTtmTJktLS0vnz/3khDggI8PDwsLKysra2NjExcXFxwRy01q5d++zZM2dn559++gmGYUtLSwiCIAg6f/58SkqKiYmJp6fn2rVrsZQ3enp60pU2MplsYWEBACgoKBg2bJiZmZm1tbWtre306UqyIScmJmLjXbFYHBkZieksy8OHDwMDA0+cOFFfXx8YGPjjjz92qFf19fXVTKhCda7SFH1EGEwsORexK+J4Qs5gAygmgIj9uiZawQ7akO5p0aQEyYlCdOlDicVF0etmNGYEkSRz+78pemNMMivJK5XNi0vrP9ww/JDgTS7l78OzvMbNGTnDEOE0/vUnO/VvUW2ZpLGek3a74eg29eHjSGZ2HToXpcAwrK6u3tLScuriqcSk92eQ8TKGFCeUEAlCgkkiwT+dT6PR7O3tVRt0pUIoBHDOj7DQCfa7Kd6ZjYj+fYSiABwtQDY8lWx9Kvzmdq35BVH0G+T2SGJr0dadAEXRv+/GXrx6SfFGbQMEQeLvJ9xPvt9GBPb/+hNuvEWeM5U0MDExCQwOkHpWM3r1Pn34eN7L/5L+1NTUYC+siZWoGgG0x58IQ9LM4jyO05m4WC6Prpm5GROp0zPT7XQej3EW0I237Qo3T01KPXvwwqnI07JCWv/hFNverEu/AUTemmYx0OdMMMdeuRlis9nl5eUqiXR/L6oJqAcAIAiCpQDtyk56KrNMVVXVvXv3Kioq+Hy+mpqahYVFQECASlzLlJY0UyqXSCSKvadU+F46ulVrSr53z3Q6fc2aNYGBgYMGDZJt9vjx461bt969e7c9++TxeOfOnfvtt9++++679gTUt8H+Hw8akkyN++uPCPKXlfMlQIKCttN/8Hi8h8mPepmbOrsoZFFAkOa485z0O0Q9Y0ljvdqQkRJmreD1c0TAozq6U10Hq/Ub3rks3kpJS0+7WRgnqOZ9v3Kb0lVqpQH1sifS0NBgZmbW/rzMHwPlHHRRqqSCAw4PIzjqQLOTxE1CMM4CTr16SIjUTh88fNaYrnr3yFFbW7v/4m+QGmGWV5hc6ow2fhHFxcWHY48AFHwbusy89TmAiHzkUjFyr/XwcKw+wYXjF4yy3r4gMMIP7QcApCalvkx5JVETLV2zeHKiJMAUav+IsPGvPwFM0Jmw8P1NO45NtPhGEMFNWWWupqYmaSTV3ZtxtbmMFkLjsvB3SpihQgHj2A6ITNGbuQELnQQAoAD43xRPsYaXuih/Qm7f+z2fLJw0bMKQQe+E9zBjT1KsXdRdVRnzo4L3xPT09PDw8MzMTBiGhw4deuTIEcWC7DNmzEhLS8P+t7GxiY+P7/pxVYipqSn2CBYIBKrNf9baz0lRrtR0de7FoqNbtdMKKu55586dPB5P8YXa3NwcK9TcHlAUZbPZ8+bNk6060jlmLp5eWVHp4irv1NoepzsajRYwUr76xz/AsNaoGRS7vgi7kdZnmNIyDirEydHp2ctMMzezzvlq0Wi0Nh7QrZGYdK+8ujx09MSuTHV2BXN16NZIYkwJEnZfwhOjC53g790JRBjAD4VMCNYhtmvQJhaL8wvyTYxN5N5iC/IKXmTkePl7lrwpIVHIg4cMAgDQ6XQ3UxcOl2NpaSnbuKiwKPbiLbqp/swF8mnKAQAmJiYmJEMigdR22utvnOA/85F9OYjSpDNNTU17juxDUXRSwMRnjawBFc+bYk9oh8xBURSGYDGKlrHRe1XIieHtdZORsOq4GfeNN7YrcqMTjLOEbrxFFQ3hlb//elac6WLiNHPqDABAwKgRxQ7FihNpEJmiv/D7xuiD9X+spy/8HpvNPlqA8CVgUSuWHoIgMpHEFwvI77piIXwO72Gsuod8uuYuooIRYVJSUlNTU2BgIAzDixYtKi0tlS5uSRkxYsSsWbPGjRsHACAQCK392HpqRIjzEdKJEeHHj0omTtoeEXYCgUCwef//aOaaQVZ+3p5eAAAOh1NXV2dpadn+lyRV0SICpS1o738TZ/P5/NraWnNz8/ZoknA/Ib7oAbkJ/j58h+yA+OCu3/saDcxmPNEU6QoRwYQFY6SZIBVJupdU9bShkvt2zbZVSg8qm2KtDcrYaOBtyWx7eFM/+Z3U1NTsOXsAgsCqaSt69eqFcJoboraTTK11Ji+vrq6mauuPjCdMtobXtzO0DkGYF/YRdOjaIXPa1b7j3KtCNz6VPB4vP3A6cf7kG/5bY5S+fP6y9+8FRRuvRUoaG/TnbqnkoP2viu+HENuo/ywSiVpaWvT03qk90vLgL/7bV7rT1310KdbayI12AAAgAElEQVR8fP5z9Z49e/bkyZOVNlNXV+9KamalsNlsNTW197d7HwwG4/79+5WVlVjElYWFhZ+fn2LmlK6Tk5Nja2urEp07DYIg+fn5Ur//rvDq1SuxWGxgYND+ojCKiMXiV69eAQDMzMw+RJ9/PLDZ7GO/nwAIOnvZLNnAvrq6ujvX7jq6OQwZ9k7u07dlb3Pyc72GeMpFAaocCoXi0394acVbN5d/7or9Rw+ySVw/p+EjRwR90EMrokkCvWXKR1CpVEtLSxRFXxW8oqnRsBXr1jCkG4KnEgNdI7lpYQ+/IZlpWf4j/R7dSycRiXLPVjk8vDwyaZmevQa1bXqzs56n3E0d7D1wiKd8xloMCw0oaQwx8JZYhIBtA97ZlbGx8fLJixEEwVa7YXUtg8U76/av4qbfMRwSPCFe3E8fao8VRLgt7JS/OWm3CbqGOhPfU72uK3gbQ6+b0Wou0IX5FRUVVlZWmB2aPvnrkpISuSF1q0CQ9ph5tb8s4ec9XVY5YJkLoQ0rCADIeJJRVlIRGDKiurqaTqcbGhoCBOEkX9eYvk4lJyWLipfQb9y44e2tPNP5smXLli5d6ujouHPnTmnJdaXIekiqqam1Nlf57Omzi5GXtQw1vtvapX558uTJ3bt3JRKJRIigYrRBwGAymS9fvhw3blzv3u0qG9Z+xo4d2+NJtzkcjpubm0qSbnt6eg4ZMmTGjBlhYWHtab9nz56LFy+WlpaampquXr167ty5mD7ff/99SkrKL7/8IrtG+PnBZrMJQiIMCNj7FoIgl89daWI26hroGCHmyXceyhnC45dOwpZkVlzjzKmtFmpXFX6evk1NTdJXVRqF1sxlq6spz6faDTQ2Nt64/LeJmUlgcAAA4M2bNw8upfAkvFnfTm/DjPXp3cfRwVHxiTHYY/Bgj8EAALnYfKWQyeShHu9Phpf9OLu3Qf+MtMzWDCEAwJgG7oUQHS+LFjnDxu/Oc8uFZkEUmv78rXUH10Y1WCNkuz893//bREXChogtRMNe9G92kHq1M2Ndh2EwGJVVlc5OzqFW8PonEs+ccxp8zVzrlxMmjwcAkMlkaSKn9gCRyDqTl1We/73c7Y9LI9oaD0gkkpQ7j5wN3S6dv0RqVGOJGd9uXi7Ke0zQoRN7qcAxTY72GsJffvlFURgUFNSv33+u3tevXz979uyTJ08UW+7YscPW1pZCoZw6dWr06NG5ubmthehJJBLZJcYZM2b89NNPcm1QFOXxeEnJSRwhvzD7laJHe/spLS29ffu2RIhw6/gS3j9OTUQ1gpoheu3aNSMjo66MdT4e5JJuP3/+XFVJtw8cOND+pNuNjY0HDx50cXF5+vTppEmTrKyssJF3dHS00qTb2PKhSvT8GCAQCMXCN2KJeBJ1PJvNZrPZFa8qDdVMqDbUMsbrgT4D5E7Wzd41Iy/TIcBeTo5NjWLeFipBLBZH7D2iAWm5B/fFXv4WfD2PzWZra2v3VP9nPsukNWlllTzvP6gflUolEolNokaYCEskkveq9N61lS6CTY16B3plPcny9/RrWx8aAOPNiBE5knCX910vmvaDgYtDHu5ctGI3n/v+lVpuzG9Ax4A8fokAggQf7DL9GrFXrIt6lg7Z6R0wLZUUXU4aT2vQhM07fWM0GzomEe2Pi84JuWFtL/w6D3AsLy12GeD8JC6DpEnkcrncxBjKsBA2m92h6hPY/dN2m/buq7GxUVEoEAik/8fFxS1cuPDWrVtKC915ef2TaHH16tWXL1++e/fuokWLlB6IQCAojZmTBUVRGIYnTZ60j3FgtO9oLpfb6ZXOlJQUFEU51XxEhLjauhnqGVXWVxaWFnBrBeq9oNTU1NDQTgZgvX79+ocffigtLe3bt+/WrVulq/evXr3atWsXk8kMCwtbsGABAIDJZG7fvj0zM5NCoYwcOfK7774DAFRWVv744495eXl2dnbbtm3DZoSWLFkyadKkY8eONTc3h4SE0On0qVOnYrvdu3evg4PD2LFjf/vtt7i4uMbGxgEDBmzZssXQ0DAmJiYrK4vJZF6/fn3s2LFTpkzZvXv32bNnIQji8/m7du1KTU2l0+mrVq3C4iZPnz4N/k267eLi8vPPP2Pv4H/88cfVq1f5fL6dnd2BAwcU5+vi4+P79esnTR2giDReIigoyNvb+/Hjx22XaIYg6ENUhewpmpqaiAZkIpHM4XCMjIw0NDS8xwxjNrD8An2VTntMGT95ynglCw0qXyOUSCRUGg0VIlqaWtIO79lp6oGDB96svD24nzv2w9HQ0Fi99VsYhlVYlLzTkEgkCIL09PTamVhuRW90UqJk6yBq27mr71Sg67heacPKoejd6st/kXpXKqUl8TJg1Bis3NPOIpGdxszYrJxRbmVhZaijcSsYhBLD7vOblo6jkzqydlz4qrAwr8jLz1NHR2fdQ4nGsIWj7i+jBoUQ6W3Fp42Z+E/W4qFDh5LJZFFpHpfN0h3kzxcKVV6GCaCqIDk52dDQMCkpqT2NBw0adPToUaVfiUQiIpH43j0gCMJms6Uf1+/cSCKT2qmq3H6+//77zd9tWTU9/PSPF0pv12B/EVuOrZoe/r+N/9uzZ08ndouiKIvFMjAw2L9/f15e3ooVK/r16yeRSFAUtbS07NOnT1paWlpamq2t7ZkzZ1AUXbhw4cKFC4uLi3Nzc2NiYlAUbWpqMjc3/+OPP169evXnn3/a2NhgMfJmZmbu7u7x8fEZGRlXr151c3PDDsflcnV0dIqKilAU/fPPP7OysgoKCtasWRMQEICiaFVV1bBhw3744Ydnz56Vl5c3NzcDAMRiMYqiYWFh48aNy8nJuXDhgpaWVm5uLoqia9eu1dfXP3HiRG5u7vjx4xctWoSi6O3bt11dXbOzs4uLi69cudLQ0ICiqL6+fmFhofSs9fT0YmNj29M/TU1NRkZG8fHxUklwcDDWG1IKCwvt7e071/8fJwiCpD9JT01LxVxmOs3bt29fvXqlKq0w+Hw+g8FQ7T4/V/h8vkAg6NAmg66Jbpa1ddFTaxDDs8KHNQiKIMzzexuitqMSSWuNeblpVdumi1n1HdKh0/D5/P/+F6Pj4sTj48SCVrVTwt7t+28eir9x5e/UGsTsvKhRgDYnRDcc+75DatQdXMN5HIeiKI/HE4lEHdr2vajAJSw9PT04OHjRokVCoTAhISEhIQHLLHDy5Mlt27YBABobG6OiogoLC0tLS3fs2FFYWKhYvLArOFo5gE4NCAUCgUQiQcUoAMBQ31gqN6abAAAQMao0f0p7uHz5souLy6pVq5ydnfft21dTU/Pw4UPsq/Dw8KFDhw4dOnTbtm2RkZEAABaLRaPR9PT0XF1dJ02aBAA4c+bM4MGDly5d6uDgsHjxYjMzs6SkJGzzDRs2BAQEDBgwYMyYMfX19c+fPwcAXLlypXfv3nZ2dgCAxYsXa2lp1dbWBgYGPnjwQCAQyCbdNjMzkyrJYDCio6OPHj3q5uY2bdq0r7/++siRf9yvR40aNWfOHFdX1zVr1mBFLVgsFpVKVVdXt7a2Dg0NVVprKTU1te3VXwwEQebNm+fj4xMQENC57u0iKIoiCrG93QAEQUMGDfEc6tmVCD8Gg3Hw/KGIa0ffvn2rQt0oFErbLiQYpaWlqj3uF8IiJziyQPktV85Bp9+XhN2THB9OHGYEAQjSmboSFQlZMYeAsokuUWUx88IB/XlbCTrdVCpVdrqCQgAxIwgkGEyMF/OVJ89Rgtsg1zfsQpaR06QE8Z+eBG0y0Bg+QVT5RvA65/0bAwAA4OWmIzyO2sBWApy6jAoMYVlZmYeHR1pa2u5/wXJzSJcxYBiOjY0dO3bsiBEjsrKyEhMTZR/HXefrSWGdc/KmUCgEAgEiQgCAematVF7LqAEAwESo0+6db9++la4hE4lEOzs76eNDuqLm4OCACXfu3FlQUGBmZubv73/nzh0AwOvXrxMTE23/paKiQjo1LZ2NIRKJYWFhp06dAgBIk24LhcLRo0dPmzbtzJkzV69eBQA0NDS0pmR5ebmOjo50EdTJyUmqpNQ3T1tbGxtBTpo0ycPDY+jQoa6urj/99JNs+hUpzs7Ocul0FUFRdOHChUwm8+TJk223/EAIBIKffv95694d0qSvnxYUCoUKUQgSQqczwneaqqqqv0/eun4itqamppsP/akzzRZ+WIOUc+QNWzUXDLwmttcGBVOIIeb/vB5BBKL+3C3imjLmhX0AeeeHJmmsbzi2XXfysi4WGuwKJBhc8COoE6H1T9prCYNGB4pDFm94a3lpBHGMBQQAgEhk7THzmq4fkTX2zc3NtbW1SrZHkObYE9pj56kwbYUcKphmnTp1qnSlShZp3i8tLa1r1651/UAqB4IgS0vL4jfFMBnKLMgQikRG+saVdeX5JXkEKgyT4U4n3TY0NHzx4oX0Y3V1tZGREfa/9CFSU1ODGSF7e/s7d+40NzdfunRp4sSJ1dXVxsbGwcHB58+fV9yz7BrJvHnzAgICVq5cmZ6ejlXTvXfvXl1d3dOnTyEIYjKZ0hEeBCkJGDU0NGxqauJyuZi9l1VScchCJpN///33AwcOJCUlLVq0yNLSEqsq3CFQFF2+fHl+fv6dO3e6/zmOweVyWfwmQIOYTGYby5kfLRoaGptXbBQKhR86pkIRNTU1MUEEQHuLy+NIEbawBuQf8d+qlbhtgYXWfxHi4Y8l8x3g7QPkFz4hCo2+eCfjxI+MkzuprkOFbwtE5a/FzBpULNIK+prWT7lnfrdBhMEfngTny6K1vWELjfdPb/z0HLnwBkkfR5RtTOvn3ZJ8nfssUWg/MCM7087aNubkVTKgjJ4R9M7iKyJhp9yA1bWoLh+kfDTGl55r1MvLC4IhdRMqTIZyip4npN/NL84j0gjqxlQYhqWZsjvKuHHjHjx4kJqaCgA4duwYn8+X7mr//v2Yx+DevXuxmMv4+Hg2m62lpeXv7w8AQFH0q6++unPnzq1btwAACIIkJyczGAzFo/Tu3btXr14zZ86cMGEC5tpAIpGYTGZzc7NYLN68ebPUnpmammZmZmJlVKWbm5qaenh4fP/99wiCFBUVnTx5UukLDUZWVlZpaSmBQPD09DQyMlLqsrhs2TJsqha0knR7zZo1cXFxhw8frq+vLy4uVnpSHxpdXd3Fk7+Z6RuGFbRCUfTYuePfH/ixsrKy+5XpHCQSSYWeMu1HR0dn+Yalyzcs/bzDPT8ElZWV/a1a7KhvPaJZT+r/eSVNqUFTa9HN/ZW7/0Bkiv6CbQQtfUFRNsnESmfSUuONR3vtvqo5Yko3Kt4qBlSwyBnema18vvdFzoubcbe4XG5xcfGpF6zDecitkQR5kwlB2mPnNt89d+l6dGpd+qkrZyAIQpD/kjiKat4yorZXbZrKeRKvM1G5c6Wq+EhT8XYbNjY2QUFB8fHxGmawRIAgYpRAgmAyTCQSx4wZY2xs/P5dKMPKyurixYtLliypra21t7e/ceMGNuqysLAYP378wIEDmUxmaGjo6tWrAQB3796dN28egiDa2tpRUVG6urq6urqxsbHr16/Hqtj37dsXmwJVTLq9ePHi3bt3//DDD9hHf3//oKAgOzs7LS2t1atXS5Nuf/fdd+Hh4Z6enjNnzvz222+dnZ0xG3n+/PklS5aYmppqaGhs3759xIgRAAA9PT3pUaRJt8vKyqZPn85ischk8rhx45QOB7OysrBQFpFIFBkZic3WypKamoogiNQRd86cOf/73/8618Ndwdbmv/dNsVicX/aKZEQpLi1WmssbR5ZOlB5sJy0tLSlpKQ62jnbdWNu523BychpY2He0k2GTJX1snHicBRzeB16cKjkwFG4jBS5EIOpMbkfGlh5ibW+C42XR+r6wjaZ8IbDTsefIJtSyc2XprLex+YR7v+4wU1cycKTYuBF0jexQ4du3XM/+nn6evnw+HwtmFVW8aTjyP82gMN1pq2GND/7ipbKk2yqhp1Ks1dXV3b9/v6KioqWlRVtb28LCwt/fX+V5cD4/6HT6kiVLgoOD5epVpaWl7dy5MzY2tj074XK5UVFRkZGRGzdu7GLS7c7xMu9lRXWlj+fwDzfMepzxJOFh4lj/MX3cVJCiQeXhEz0LgiAikehO4p2MphzRW95PG3b2tEbvoZ0p1mQpKSm5ceoWAokXhi8QENUP5kp+e4l4GEG3Rn7aQ5EdmUhJC3rSR35Qeyr6THlN+SCXIXOvxI000T6+dWNrDmKC1zmsi/uNNx2VTeErfFvAiNqhM2UFrY+SQnh8Pl/l4ROf9mVQFYaGhliZ2c5Ve/hi2bdvH3ZTyskdHBza7wsDQRCVSv3222+HDn1/Oo8PgauLq6uLChLOtcG9R/fJ9mr30x6oxBB+TohEot1//MoWcsZ4BkMFyADnriZd4vP5FArlY6u8AUEQBAAKUACAHgXscCes6U1oO6xQlryX+XnP83wCh38kq9o8Hi/q3DEikbhsyry+1+Hrb5Hxlu+sss3+aiYA4FAe0mdk/6hx2m1cDopdb4KOPjfjvtqgAEkzi/fiIS8rSVTzVm/6OqrLOzVtrsfcKM4rCZgwwt6h5zLLfCHgVrBDzJo1S6lcaXBFa9BotIULP0jtGKUIhcKTEacFXMH0hWHtCRhQCdPGTk19kuob7Ns9h/uEEAqFzfwWhIbq6OjsWLO1i3vLeZGT+NcDDQP1BcvmqUQ9VWFlZTV9xTQKhSKdx9LuSBz8nb/i+hq7pySmhk6bCAAQiUQVFRVmZmYfbqa6baqqqiqFtSgP4TFrb48yC7otphGhoF7vWDueGOx+jtwI0iUo1sx8F62RM5jn9rBTY8X1lVTnQZr+kyhOAyGCvG0qLXxrrW1fUlSCG0IcnK7CZrMFTKE6Sau2trYrhrC5uZnH40n9bNvG2sra2kpJxiWVkF+QX1tf5zl0mNLH4tP0p5lpWQFjR9jafYxrb+rq6qtnr2xqaupQysrWYDYw9akGDaxaFEU/tkFhh94O5RgyfGBORq40AfrF05cgJpFk/PSrma16t31QrKysfOyHEQjEXr16mcNQtD9x6j3xlRFEL+P/+vz3PMTDEOqv//6rQLHvqxkwlWRkTrZxU7R/UqbOnfy68PWAgQNUcw7vghtCnC8LPT09/8k+bDa7K09eLpf705+7xUTJ4gnftDPP1geCx+Mdv34S1iOpUWiDByvxL390L72f8aAnqU/lDGFJSQmfx3dydlJqMFAU5fP53RMmYWJi0kZRpA7hOdxT37DAxCTwY7OCXcTTx9PT5z8PdgqV0iRq0aD2mBMDgUAIDvyvIqCPCXTKhxh2X9JXD6zrQzCggToe2JsjedB6XWI5NLzGvreN9D75EBX3PklDyOfzS0pK3NzceloRnE8SV7eurghCEARDMOihFWUWi8XlcrEgVwqFYmNoXcuqa60+0cgJgdlPn/sG+sjt4frJm2oENWIYUWnO9FNHTjfXsD1DPNw/zAv4B4JIJHbDY6G+vh6GYcXys93GlK8nMRiMrgwxVc4oM+j1VOKpIuTbNIkQAXoUsNKV4KzzQV5HqqqqtLW1VXv6KjCEZWVlWD4UjODgYMUC2QiCxMTEvHz50s3NbfLkyV18X0tMTIyMjPz777+7shMcnE5Do9G2rNgkdfXuZs6ePVtWVnbgwAEAAAzDS+a2VYjOycXJycVJTkij0WA1iCNitxaV38Rs1qcasRrek/6+2xAKhdduXddQ1wgOGIU9PZ48eyoUCYYNGdb9pYMjIiKoVOqWLVu6+bhSIAiSJvH/eKAQwEIneKHTB78ce/bscXNzW7p0qQr3qQJD+OLFi61bt44fPx77OGzYMEVDuHz58rS0tLCwsF27diUnJ//+++9dOSKCID2SKxLnk4DH4/19N9ZQ38DX2/fDHYVGo/VUgpWu3/9UKnX5uiUIgrTmgz5r8YzKykoTE5MTf57U1tWeMHV899sbWd68eZNVn4OUit37DDAyMqqpqbmc8hdEgowNjLEUu90JgiBKUwzidANCobDqbTWVRFPtMrBqpkZtbW2x/NFKqaqqOn78eHFxsamp6fTp0+3s7DZv3tzpWHVFCAQCjUb7zFYFcAAAcuGJ7eRl3sssZo64SOjez/29uU+/WGAYbsO2YVkdsrKy1DjaVXU1zc3N3Z/RTRZLS0vzdFN1E3VsJKSrq2tCMxSKhe10VsL5CBEIBOeOX4AA+HpeWGvV1xUpKioyJVoKasQMBkOFw2LVGEImkxkZGamrqztixAjFqdukpCQXFxdsSr1Xr15OTk7JycltZPPqKEQisY0ShsVvipPjUgZ5D3J1c1HVEeVgsVg3LseamBkHjQ78QIdQ5MXznNqqWm8/r24LrL79952KnGqaMVkECRMTE8+ePds9x5WComj8/XgunxcSOFrWQxJBkJKSEgMDAy0tLQCAna2d4TN9I2uDz6mWYY/g7Oxc9qa8j55rz1pBAICamtpSmRlgCoWyZvHqHtQHp+sUFhY+ScqEADRgWP++ffu2cysrK6syzhtzuplqVyVUkFkmPj7+4MGDtra2BQUFGRkZd+/edXd3l22wf//+uLi427dvYx+Dg4NHjhy5atUqxV2JxWIymTxo0H9xlCYmJoqL+W/evMnOzsYqFn0M1NbUWkD2xQ2FRo50FZeL/Mjgcrk0Gu3ly5dlZWVKa8p/6KMXNL2GaQRL1FT2Z1BTV1MFatFGibvDp+TZ0WmePXvW3NyMZab90qivaWiqbdEx1aIb9JirSHJyMolE8vDw6CkFPg/YbHZGYTYAwN2hX4feWePj4+l0ev/+7c294OnpOWHChLbbtOupnZKSMmbMGEX548ePnZycAgMDAwP/GQmtW7duw4YN8fHxss1gGJZd0mgjewuRSPTx8ZFdejEyMlIc/6qpqSmV9xSYJn3Bl+LFOmDAADs7ux7pfwugxDeSTqe7fTGdDwAYPHiwUCj8eO7/7oROp/f4pfby8oJh+MvsfxVCp9M7V97Hx8dHTU2t/bMU7blS7TKEnp6eVVVVinLFcn3+/v6XLl2SE5qamlZXV0s/VldXt+F5fP/+/faohIODg4ODoxLa5QkGw7C6MjD/FNmKPPHx8U5O//hqFxQUYFUW/f39X79+XVRUBAAoKioqLi728/NT/ang4ODg4OB0HBUsaM2bN4/JZFpaWubn5+fm5t69exeTz58/f+LEieHh4fr6+uHh4SNHjhw/fvz169e/++67bsvxiIODg4OD0zYqcJapqalJS0urr683MjLy8/PDPPcAAM+ePTM0NJQmvHj48CEWUN85n3gcHBwcHJwPwcdVjxAHBwcHB6eb6clsEZ3m9evXjx8/FggEPa3IF4FEImHJINvtQqHw8ePH2Oovjsrh8/mKAbICgeDx48evX7+Wk5eXl6elpbHZ7O7S7vOHx+M1NjbKSlpaWqQ/hObmZtmvSkpK0tPTeTxe9+r42cLhcDIzM3Nzc+XqtIvF4qdPnxYUFMi1r66uTktLk7teHQD9pEAQZObMmebm5p6enhYWFoWFhT2t0edPRkYGkUi0+Zfo6GhMXlxcbGVl5eHhYWVlNW3aNIlE0rN6fk4UFhb27t0bi0nl8/lSeUFBAXbzm5ubz5kzB0EQTL5161YDAwMfHx9DQ8OUlJQe0vrz4dmzZy4uLgQCQUNDQ1bu7e1tbGyM/RCCg4Ol8hUrVpiYmHh7e5uammZnZ3e7vp8bUVFROjo6/fv3d3Z2trGxycnJweTl5eV2dnZDhgyxsbGZMGGCSCTC5Pv379fX1/f19aXT6bdu3erEET8xQxgXF2dubt7Y2Iii6Nq1a6dOndrTGn3+ZGRkWFlZKcpnzpy5bNkyFEWbm5ttbGxiY2O7XbXPloaGhqSkpOzsbDlDOHny5PDwcBRFWSyWmZlZYmIiiqKvX7/W0NAoLS1FUfTw4cPu7u49pfZnQ2VlZWpqalJSkqIhvHbtmlzjp0+f6uvr19bWoij6448/BgUFdZ+inynPnj3D+hNF0cWLF48aNQr7f9GiRXPnzkVRlMvlOjs7X7p0CUXR2tpaGo2Wm5uLomh0dLSNjU0nXso/sanRy5cvh4aGamtrAwDmzp179epVuYEzzgeivLycwWBIP6IoGhMTM2/ePACApqbmlClTFONHcTqNvr7+8OHD5RKlCoXC69evY32uo6MTGhp6+fJlAEBMTIyvr6+lpSUAYObMmS9evCguLu4RtT8bTE1NPT09FeOkAQAtLS1v376VjRm7fPlySEiIoaEhAGDu3Lnx8fFtZHzEaQ/u7u5YfwIABg8eXFdXh/1/+fJl7P6n0WjTpk3D7v8bN27069fP1dUVABAaGspgMDIyMjp6xE/MEJaXl0uTEVhbW4tEopqamh7V6Iuguro6MDDQ1tbWw8OjtLQUANDQ0MDj8ayt/6m6bmVlVV5e3pMqfgHU1NSIRCLFPi8vL5cKNTQ06HR6WVlZj2n5ubNhwwY/Pz86nR4VFYVJZPvf1NSUTCZXVFT0nIKfFWKx+OjRo6GhoQAADofDZDLbvv+JRKKZmVkn7v9PzBDyeDxpnnIKhQJBEIfD6VmVPnscHR0bGhqw9Ag2NjYLFy4EAHC5XAAAmUzG2lCpVPxCfGi4XC4EQdJs49I+5/F40gsBAKDRaNjVwVE5MTExFRUVxcXFV65cWbFiRW5uLnj3oQTw34LqQFF05cqVRCJx3bp1oPVnjkru/0/MEBoZGUkn6BgMBoqiJiYmPavSZ4+6ujqWEpdCoaxZswbzxTAyMoIgiMlkYm0YDAZ+IT40xsbGKIpKp92kfS77owAANDQ0qLDGGY4s0vm6ESNGuLu7P3z4ELzb/0KhsLm5Gf8tqITw8PBnz57FxsZidk5fX59EIik+c4yMjKRC0Nn7/xMzhIMGDcJuPgBAamqqo6Mjtl6I0z2UlZXp6elBEESlUnv37p2amorJU1JSZGuG4HwIdHR07O3tpX2emo4U8hkAACAASURBVJqK9Tn2o0BRFADw/PlzCIIcHR17UtEvALFYXFVVhWXIGjRokPSiPHz40MTExMzMrEe1+xzYsmVLYmLinTt3pBlaYBh2d3dXfOYMGjQoLS0NK5VcXl5eXV3dr1+/jh6OsH37dpXp/uFxcHDYtGmTWCxmsVhr164NDw8fOHBgTyv1mRMZGZmUlMRgMOLi4tavX79q1SovLy8AAI1G27x5s42Nzd9//33u3Lljx47h9f9UhUgk2rNnT2pq6sOHD6lUamZm5tChQwEARCJx+/bt1tbWMTExV69ePXr0qJqamr29/R9//FFUVARBUHh4eGhoaEhISE+fwadNS0vLgQMHUlJSnjx5QiaTX758OXDgwKqqqg0bNrS0tBQUFGzatInJZO7du5dMJjs6Ou7cuZPBYPB4vPDw8G+++cbb27unz+DT5vDhw5s2bZo5c2Z+fv7Dhw+zsrKGDBkCANDS0lq/fr21tXVcXNzRo0ejoqK0tbUtLCwuX76cnp5OpVK/++47Hx+fsLCwjh7xEzOEampqY8aMuXPnTnp6+qJFi+bPn9/TGn3+CASC5OTk5ORkNpu9du1aaZ/369fP0NAwOjqay+VGRETY2tr2rJ6fExKJ5Pbt2xAEeXl5CYVCsVjs6+sLABg0aJC2tvalS5dEIlFkZCSWvxCG4dDQ0IcPHz548CAkJGTjxo1tlJ7HaQ98Pj8+Pp5MJnt4ePD5fAKB4OnpCcPwixcvUlNTc3Nz3d3djxw5gg1WyGTyxIkTExMTU1NTv/7665UrV2LVCHA6TXV1tYWFBQRBfD6fz+cjCOLj4wMAcHV1tbCwiI6ObmxsPHz4MFbgAYKg0NDQzMzMhIQEb2/vH3/8sRNFYfEUazg4ODg4XzT4myMODg4OzhcNbghxcHBwcL5ocEOIg4ODg/NFgxtCHBwcHJwvGtwQ4uDg4OB80eCGEAcHBwfniwY3hDg4ODg4XzS4IcTBwcHB+aLBDSEODg4OzhcNbghxcHBwcL5ocEOIg4ODg/NFgxtCHBwcHJwvGtwQ4uDg4OB80eCGEAfnHRAESUxMzM/P72lFcD44eXl5iYmJeAUenA7XbcLB6QTPnz//5ZdfnJyc/ve//yl+u3nz5tLS0m3btjk4OGCSX3755dmzZwCAr7/+esKECXLt+Xz+vHnzxGIxAOC3334zNjaW/RZF0Zs3b8bExGRmZjIYDBqNZmdnFxAQMGPGDLmWSjl58uT8+fPv3Lnj7OwsK4+Li/v9999zcnJIJNLAgQPXrVs3YMCA9pw7iqLHjx8/ffp0cXGxlpaWn5/fpk2bTE1NZdvExsaePn1acdugoKAFCxa05yhy8Hi87OzsjIyMrKyslpYWb2/vFStWKG3J4XD27Nlz/fr1+vp6IyOjCRMmrF27lkajtecoFRUVP/300/3791taWmxtbWfPnj1nzpzOVeOTXnE5Vq9e7eHhISe8du1aREREXl6emprakCFDNmzYIHexMJ48ebJnz57MzEyJRNK3b99vv/3Wz89PtsHr16/Hjx9/5syZGTNmdEJnnM8HFAfnw3Pz5k0AgLe3t9Jv+/XrBwBISUmRSsaPH4/dn0OHDlVsf/HiRekNXFRUJPtVVVWVp6cn9pWhoaG7u7ubmxv2WFdXV798+XLbera0tJiYmAwbNkxOvmfPHgiCiESip6fnwIEDIQgikUjXrl1774kjCDJt2jQAgKampq+vL2bp6XR6fn6+bLO9e/cq/XkuXbr0vYdQRCAQyNUmnTFjhtKWjY2Nbm5uAAATE5OAgAAjIyMAwIABA1paWt57lNzcXD09PQCAo6Ojr6+vhoYGAGDmzJkIgnRC53HjxintgejoaLmWmzdvBgBQKJThw4djdw6NRrt//75cs+joaCKRCEHQ4MGDhw0bRiAQIAj6448/5JoNHjy4V69eHA6nEzrjfDbghhCnO+icIbS0tAQA5OXlybUPDg6mUqmGhoZyhpDFYtnZ2QEAPD09Hz9+LJVzudzz58/b29tv2rSpbT0xgxQTEyMrzM7OhmFYW1s7OztbejoEAkFbW7uhoaHtHR47dgwA4ObmVltbi0m+//57AIC7u7uswcCO+/PPPzPfpXMPaIFA4OTkNH369H379q1ataoNQzh//nwAwJQpU4RCIYqifD4f6/nly5e3fQhsjAUA2LVrFyapqalxcXEBAJw+fboTOmOGMDU1Va4HBAKBbLMHDx4AAIyNjQsLCzHJuXPnIAgyMTGR7avq6mp1dXUSiRQfH49Jnj59qqmpSSQSCwoKZHd47tw5AMChQ4c6oTPOZwNuCHG6g84ZQmwedcOGDbKNKysrCQRCWFiYvb29nCGcO3cuAMDLy4vP5ysepaWl5cGDB20oiSCIg4ODrq6u3OYzZ84EAPzyyy+yQsyE7Ny5s40doijq6OgIAJAdryAI0qdPHwCA9BmN/msIDx482PbeOkFUVFRrhrC2tpZIJKqrqzOZTKmwrq6OSqWSyWQWi9XGbm/fvg0A6N+/v6w5T0xMxKx+J/TEDOGLFy/abhYSEgIAOHbsmKxw4sSJAICIiAipBLtz5MbTP/zwAwBg4cKFskIOh6Opqens7Ny5gSzO5wHuLIPz8TJkyBBnZ+fTp09LJBKpEPs4e/ZsucZVVVVnz56FICgyMpJCoSjuTUNDw8fHp43DPXr0qLCwcOzYsbKbo/9acWyGUwr28e+//25jh0VFRa9evTI1NfX19ZUKIQj66quv3rttN3D79m2xWDxq1ChdXV2p0MDAICAgQCgU3r17t41tMeWnTZsmuyLo5+dnZGSUm5tbUlLyIRTm8XgJCQkEAmHKlCmycsVrgf0fFhbWdjMAgJqaWkhISH5+vtIVSpwvBNwQ4nzUzJo1q6qqKj4+Xio5depUr169AgIC5FrGxcWJRCJ3d3dsgq4TYAOaYcOGyQrLy8uZTKaenp65ubmsHBvF5uTkoK37HD5//hwA0Lt3bzk5ti32rSz5+fn79+/fsWNHZGRkUVFR586i/WAKYMNTWbA5T0X13rstBEHt2bYNEhMTd+3atXPnznPnzjU0NMh9++rVK4FAYG1trampKSvH+vPFixfYR7FYnJeXp6ienZ2dhoZGdXV1XV2drBxzxrl3717ndMb5DMC9RnG6j8rKyn379inK6+vrW9tk1qxZW7ZsOXXq1KhRowAAaWlpBQUFGzduJBAIci2zs7MBAAMHDuy0eikpKQAAd3d3WWFZWRkAAPMKkUVXVxeGYQ6Hw2Aw6HS60h1i2+rr68vJsfbYt7JERERI/4cgaNq0aREREVpaWp04l/ZQXl7eIfXasy0maXvbNli9erX0fxqNtnnz5k2bNkkHnW33Z0VFhUQiIRAINTU1QqGQRCLJ2UusJZvNLi8vxxaYMQYNGgQASE5OXr9+fefUxvnUwQ0hTvdRXFy8du3aDm1iamoaGBh47do1Foulq6t78uRJAMCsWbMUWzKZTPDvM7FzlJaWAgB69eolK2Sz2UCZISQQCLq6ugwGo6WlpbWDYtu2Zi1aWlqkEm1t7VmzZgUEBFhZWTU3N6enpx84cODChQv19fVxcXGdC0h4L62dmqJ6qt1WKebm5uHh4UOHDjUyMqqurr5169bp06e3bNmCouiWLVvaPqiOjg6BQJBIJBwOR0tLS9pMsd/09PRKS0vl1MOuOHb1cb5McEOI0324ubnt2bNHUb5s2bI3b960ttWcOXPu3LkTHR09Z86cS5cuDRs2zMnJSbEZDMMAgDYmKt8LNhcnu2AGAMAepgiCKLbHAhmx4yoF21Z2gRMDk8huOH/+fMz7BiMkJGTOnDmDBw9OSEi4efPmmDFjOn4276e1U1NUT7XbKuXQoUOyH6dMmTJu3LjQ0NCdO3cuXrwYe9Vo7aAIgmBC7LitdXtr6mGWVW6+FOeLAjeEON2Hrq7uyJEjFeWKU1iyjB8/XldX99SpU1paWo2NjYpuMhgGBgYAgJqamk6rp/Q5i81MYsNNWcRicXNzc9vKt7Ytg8GQftsaWHz6/v3779y584EMIaZ559TT1NRkMBgMBgPz3ZWC7U0l07kTJ07s169fdnb2/fv3Me+Y1voTc3AlEAhqamrSZo2NjSiKyg0KsW3lLhl2xRUn23G+HHBnGZyPHSqVOm3atPT09B9++IFGo2Eul4pgq4NpaWmdPhBmSuWes9bW1gAALF5QVl5fX4+iqI6OjuJMndy2iiugmAT7tg0wr5/q6ur2n0KH6Ip62LeKoyhM8t5TaydYD0hfbtpW2NLSEhvqGRkZqampicVizKJLQRAEG/TLqYc1k101xPnSwA0hzifAnDlzAAAFBQUTJ07U1tZW2iYwMFBdXT0vL+/hw4edOwr2fKysrJQVGhsbm5qaNjc3FxYWysqfPn0KAGg7y1r//v0hCMrKypKbpnvy5AlQ8MpRpKKiAgCgo6PTgXPoCJjyimED7Tk17Nv79+/LCsVicVZWFgRB/fv3V4mGWA9Ir7i9vb2mpubbt2/lbKFcf8IwjPmRyqmXm5vL4/FsbGzkuhS74lZWVirRGedTBDeEOJ8AgwcPDg8PX7hwIZYnRSl6enrLli0DACxcuFBuKIBRUVFx5cqVNo7i7e0N/jUDsmDx2qdOnZIVYh9DQ0OlEqFQWFNTI/uMNjc3HzhwIJPJvHHjhmyzCxcuSHfbGjweLzo6Gvzr3I+BoiiLxcJmAtvYtp2MGjVKTU0tISEBszcYJSUlSUlJWlpasgEqjY2NNTU1XC5XKsGUv3btmkgkkgqvX7/e2Njo4eFhYmIiFbLZbBaLxefzO6pefn5+eno6kOkBEok0ZswYFEWVXgvZ/sT+v3z5smIz2UuGgdnR4cOHd1RDnM+HHgrkx/my6FxmmdjY2Db2qZhZhs/nYw9NGxubM2fOYKtEKIq+evVq+/bt2trabadYwx67X3/9tZy8pKSESqVSKJS//voLRVGxWLx//34AgFyOSiwQzdzcXHbb69evYy2zsrJQFGWz2fPmzQMAjBw5Utqmvr4+JCTkypUr5eXlYrG4paUlISEBm+m1tLSUPURTUxP2s62rq2vjRFAUzcjIiI+Pj4+Px9x0R4wYgX1MSEiQbYYFDHh5edXU1KAoWllZOWTIEADA9u3bZZthaV/27t0rK/T39wcAfPPNN5iGGRkZmP27deuWbDPsUsptK8fNmzcXLFiQlJSEnVddXd2JEyewvU2dOlW25fPnz4lEoqamZlxcHIqiQqFw+/btAAAnJyeRSCTbUYaGhhAEHT58WCKRoCh68eJFEomkrq5eWVkpd/TJkycDADIzM9vuUpzPGNwQ4nQH3WMIURRls9lz5syRugVqaWlJ08RYW1snJSW1rWfv3r21tLQUM3xeunSJSqUCAAwNDTG3Uj09vfT0dNk2Sg0hiqJbtmyBIAiCIDMzM8ybw9nZGTM8GLIrbbLJsu3t7XNzc2V3hY10YRiW2vjWCAwMVPriSyKRZJsJBILg4GBMbmFhQSKRAAATJkyQNSpoK4awsrISyyGupqZmZmaGnaOcBUX/TYp2+PDhNrTFxr6KPTBq1Kjm5ma5xlFRUVgbExMTbNbUxMTk5cuXcs2Sk5OxKVA9PT1s9VdNTe3GjRtyzdhstoaGRt++fdtQD+ezB0LxWlw4H543b95ER0dbWFgorXdz/PjxmpqaWbNmmZmZYZK//vqrqKho8uTJtra2re3zyJEjLBZr4cKFcgEPAID8/Pxr165lZWUxmUwymWxvbx8QEBAcHCxXk0GRw4cPL1u27Pz583LZuQAAr169OnLkSF5eHoFAGDhw4KJFi2QnAAEAZWVlZ8+e1dbWxmZoZUlOTj579mxJSYmGhoa/v//8+fMxi4ghkUiSkpKSk5MLCwvr6+thGLawsPDz85s0aZJcrri4uLiRI0dOnz797NmzbZ9IdHS00sA4GIbXrVsnK0EQJDo6+saNG9IyTJMnT5ZztoyJiSksLAwICBg8eLCsnMPhREVFPXjwgM1m29jYzJw508vLS7YBiqKmpqY8Hq+4uLgNr6Lm5uaEhIRHjx6VlJQ0NTVRKBQHB4exY8f6+fkpjaF88eJFVFRUYWEhmUweOnTookWLFIM1AQAVFRWRkZHYGq2bm9uiRYuwnOyynDp1as6cOUeOHPnmm29aUw/nswc3hDg4/8Hn852dnfX19Z8+ffqBwti7wsaNG3/99deXL19iubw/fvLy8lxdXXfs2LF169ae1kUJKIr279+/ubk5Pz9faX5anC8E3FkGB+c/qFTqrl27MjIyZN1bPh7evHmzfPnyT8UKAgCeP3/u5ubWhotTz3LlyhWsZDRuBb9w8BEhDs47oCiamZlJp9Oxaog4nzGlpaVMJhOLculpXXB6EtwQ4uDg4OB80eBTozg4ODg4XzS4IcTBwcHB+aLBDSEODg4OzheNCqpPcLlc2ZT/xsbGsjFSUmpqagoKCpycnIyNjbt+UBwcHBwcHJWgghHhvXv3XF1dA/8FS9wnx/Hjx93c3H7++Wc3Nze5PIE4ODg4ODg9iGrqEQ4YMKCNlP8cDmft2rWxsbGenp6pqanjxo2bOnUqjUZTyaFxcHBwcHC6gmrWCCUSSUFBgWKdMIyEhAQ6ne7p6QkA8PLy0tPTS0xMVMlxcXBwcHBwuohqRoQFBQVTp04tKysbMGDAhQsXjIyMZL8tLy+XrfVlZWVVVlbW2q7OnDkjm8LR0tJSrgQ2Dg4ODg6OClGBIfTx8amvryeRSFwud8qUKeHh4WfOnJFtwOfzyWSy9COFQuHxeEp3JZFI5syZ4+vrK5WMGTNm6dKlcs1QFOXz+fjkak+BIIhQKMSqMeB0P2KxGEEQ2d8UTneClWDEKnV8kqCAU83n1QhR8T/ZVAg0WNtRnUB+Z4IQ4bbANA3w8eXcEQgERCKRQCC0sz2ZTH5v5iAVGEJNTU3sHzU1tSVLlqxcuVKugbGxsWyh1IaGBrm0/VJQFIVh+L0TpyiKSiQSPD1gT4EVeMP7v6eAYRi//3sWCIJ6/EUERdF8RmF+QyFPzEdQxFHfrreBixrpPcMDFEWZuS3synfqJEs4EmYzW89NS83wn5tKUPScdWyHZsBXmgFffagT6CwoihKJxPdWkukQKo4jLC4uptPpcsLBgwc/f/68ubkZANDc3PzixQu5Yi44ODg4OO1HIBHeK0t5XJXRLGwRISIJKslreBVTcKOAUdT2ho2FHHalkgk5iRBpyGriVPMBALysZMapn3SmrGh5cFVU+eaDnMBHhgqM6s6dO2k0mqWlZX5+/q+//hoREYHJg4KCxowZs3LlSgcHh6CgoOnTpy9YsODo0aPBwcGKVcFwcHBwcNqDCBHfKU5g8hrl5BJUklb5VCgR9jF0VbphcwmnuYTT2m5RFG140SQozBTcP2qw7GeSiRVAUebZXw3X/g4RP9l54PahghHhkCFDSktLo6OjGf9n703D5LjKs+Hn1NbVa/Xes+8z2vfFsmwZy/KGdxsbbGNDHPhYAvYVeJOX94LYFzhAEkjgg0ACjjHwYkzC5zhxsLFjS14ka7HW0Ugaafa9p/fu6q59O9+PHs3S0yONpJEliO5f3VWnqs6p5Tzn2e4nnX799dcnK5ref//9a9euLf5+4YUXNm3a9MILL2zevPmsNUWv4Aqu4AquoCwwxrtH9s2WgpM4FDt6cLx99natYOR65pSCRViSMP77w457n6IrGwDAsf4GKlKbf+XnF9blPwBcXtUnDMOw2+1FX/QZgDGWJMnpdH4wvbqCEpimqapqWf6gK/gAoOu6aZpXgpUuFVRVvYQ+wo5E56FYGTlXgg2Va5aHlkz9xxB7P6Pmzji1Ykvc9wZd1WhrWMw1O7kWJwBYYj7+91/0fuTP7Ms3XWjXFwiKoiy4j3Ahz3UJ8Y//+I+SJF3qXvxPgWVZpmlORs3dfvvty5cvv7RduoIrWCjogiEnVUCIdpIMR5fEUl5apKT0kXjHfFoeHG930o5G70RNzfyQdBYpCKB2txM2lqlfhDHO9QqGbHItTsrpCXzyq+mffYOubKACf7TsmH8MglBV1S996Ut/8Rd/cak78j8Ru3bt0nX9iiC8gj8C6IKRPMLrojG5BZHI2+Jy19sRcemzCDDG+6KHLGzNqzHgXaP7aIKu8VQZisn3CnO1tDRLjqtyUlTTAcbXqPVJ9iDDcJQwJotRhQ0xnoYm900PZn7xrdAT/4DoD1QP1kxtkB/pzw3mVcHAOoFIP+v1097VFSsW9kJ/DKZRVVU5jlMU5cxHXcHFwJNPPmmz2f7qr/7qUnfkfxCumEYvBjReTxzKmVoZMUM7qcgGH8lOqIaXyjTamx3YNbL3DA0MyxA10ck4KWJCwyEQsTqyvCZRlx+RR0XIanilf0ZKnZrW0scLNj+Dsl1sdRB5qrS8IY7KrnqHp94Op5s6K1l85FkQk4HHvkY43BdpgCUY5kd3juzRLaNku2pQDy29j2OvmEav4Aqu4ArOhrxa6M8NGZbhsbnDjqCX5eZqqeb0xKGcpZdXtnTRSBzORTb6COqS6YW6ZczlGjSxdSrdPZwfyyhZB+UQdQkBavY1rAwtcdCO9uHjOw+KXfkKjmFIBB0Z/JEGwkEBYOB7BXFcDazwENKQJqUdzesBwB5iXNVs6iiv85p/uQeRCADEcYWoftQhvpP43hOBT3+drqi/2OM9njx5cLwdQxk97T+HEefGDy0o4dgVQXgFV3AFf2yQdHnnyJ6YmJi0eBGIWFuxanloMYJSYWYZOHWUn0sKFqHl9eSRXHid91LZSDsSJyS9TP4fr+Z3jeyzU/aV4aURZ5hCJADIutyZ7n659/VWX3Nt9uqCkL8+JFQ4fWFneHeceuaU9VAzYRsWNN6o2ORHSBePHnWsv2HynCRLhDf4MsfzmeP5wEqueMMsE4vO692bg8kffYW761POjTddvMEeiR9rjx8ru8vA0FeArZUL/BQuIz/wFfyPAAaV13XRwNZlZJNfQGCr7Cr2Cj445FT+ld43xoX4dL+Pha2D40fe6H9bNbSS9pkTeUM2z3paJa1lu+b0tF1UqKZ2MtU1e/twfvS1vrda/U3bGrZUuyqLUhAA7LR9XcWqe9tuy/KSMJxc4sU0gdNypjvTs9af31qFjh4T5bQWXMsRDFL7jlGROsLtmzwtIhAiILDcbWo43z8VhIhNLFjLPY98W3j3P9LP/bUlFS7GYKPC+NH48bn2DhagkhXs5AKHRl4RhFfwAcGQzfSJ/Og7ydjeTHRXeviNRHx/VkmXzkp/uJBTavpYfvSt5PAbibF3UsnDOV0odW9cwcVGSs78vvdNUS+fMBcVYm8MvjVdFgpjcpFOZT4QhmU5pS5AL88Rnamu2a6yhJTcO3bg5qYPLfKX5ychEUtltnloW7QwYFgGAJiWOcgP+3KxJlEdqOUICmFV1qP9tpaJ2BPKQYbXeiuv8TMeCggUXOURo4ocnxqyZeDcuDvwZ98j7C7+5WcXfKSiLr07vHeutaRqqodiRyjj9wP80MJe94pp9AouFJp5dmEmRpXMyUKJ9UnJaEpGY4NMcCV3mQSpWxj35wZOpXskXVZNjbN56rmaRm+9hzlTgIBlWJkThenzqaGYhmLKSc1Vw3oXuS+hb+l/FFRDe3tol3rGFzIlZd4YeOvmxhtsFGNqVvbkOag1RaJO33onxcyX8fnCoVvGbHWQV/NvD+/ZUnu1n/WVPQoDvNwP12rORT7XuBAf4EdafA0IEKETeJAw26TdGW5RGJx9x5maFsSwAOCqsfuWuAkSAUDFJn/2VKEwLAdXexKH+AqOnowVMlUrfVIO3fmp2Lf/lLvrU4TTs1AjxRi/O7xHMcqvS8aF+M6RPTmj5u6mO5cHl5Rtc95YAEEYjUZ/+ctf7t+/H2N8/fXXf/7zn59NB/y9732vq2viWUYikaeffvrCr3sFlwlOpLoOxY6uiawgUBlhhjFOH8uL0TkX3UpKi+3LhNZ4GfclXpbFxMTu0ffz6tTMmJYzaTnTHj++KrxsZXhZ2QFqBSPVPiPmfhIY48KIrItmaK33spKFumV0Z3pH81EAQAhVuiINXJ2bcc3nWFO31Iym5nSCJEgbwXjpS/7gisAYvze6T9DOQp4CACk58/bwrluabuD7RMs4N0O2oZj8KTGwcsFm/7OiK91TIto1S98+tHNtZGWVq3xiXwNX+3x/JCQz26qkcWG8whXpzw2NC4kqV8Q5xilBSaaFtX60o9/z4dig69o7AcARtvmXuSerNCAC+Zd45JQGAO5aNtNZCK2dCjVSUloh4WKXbRL3v+ne+pGFGukgPxIXE3Pt2hc9tCpy7fZYoMa58PG6C/AG79ixY2ho6NFHH6Uo6sknn+zs7HzmmWdK2rz66qutra1FxjWv13vhF/0Dxac+9aloNHr77bd/8YtfnOchQ0NDHR0dLMvedNOEd1rTtLvvvhsAvvCFL9xxxx0Xq6/zBsa4I3EiJWWur7/GRs58RzFkjhfOIAWLMCQzvj8bWsOx/kvG6D+SH3t76D0Tl/EVWdg6Ej82lB/ZWrfFY5uhGhqSmTiYNdUzxVkoGS15OBde5y0G4F1ynEx1tyeOT193jxXGD46317irNlat42xz6r66aPC9ohRTp/veEEJsiOEanTbfJaajPJnuHs6PzrPxuBDvHOt2j5RXp84MOa6JYwrT+EG8q6ZlnkidKtl4cLy9ylnR6muc3Z4mqKuq1r000ngoY75UnScVO02SI/nReq6mO9MbkSOkRgr1OQDw0xk6161WtLkZlvHQwVVcaa0iBFyzM30s72lyxvZmpLjqiExpOHyvGFh3Z+HFv3Vff9+ClGqysDUXV0BPtv9I/NjNjdcfy3KL5oz8vSAsgCB89NFHH3300eJvu93+8MMPzxaEAHDjjTfef//9F365P2i8++67P/jBDzZv3jzP9v/0T//01a9+NRwOu1yuSUFI0/QzzzzzxS9+LvDzLgAAIABJREFUcWhogQ3lF4KoMP67ntdvbdrmYibyOzHGmROFslT3s2HpVvIIX7HJTzs/OKPTJAZywztH9pw5VTkj514feOvWxhsmZaGpWYlDuTNLwSL29qi/2pvedL3/SysI6tLZgE1s7h55vy83WHbvaCE63hNfEVqyOrKiJLQSY5zrEgrD8uwQJ4yxnFCVpOaut3vbXJcqqJJX8wfnQTw2HZ1He1fiFSx5lmpW2AItp2MLk3aSshPFAeZOic6Ag/FcdFV4gB8uCRYdK4yPC/G7W2+d3dhJO25svOHpducbo9ZrV1lwwgAAP+tFAEP8SKOz0dvr55syGGEAANNgIHHAvvoOhgit5cqu0lxVdr5PNCTTv9SdOppnA8ykYQNbWMiHkd2tnDrILtlw4SPtzw3yan729jFh/HCs47bmG92Mq4u3bq4hzlpc8DywwB9lb29vXV1d2V0/+9nPHn300b/7u7/jeX5hL3oZIp/PHz58eHLh3NvbOzo6sVaNRCI+33zXoX/yJ3+SzWa/8Y1vTN+IEKqtrb0MqT4LmvBa//aCNhFZx/eKwui8pGARlm4lD5fPaL6oiImJs0rBIkRNfH3graLtFFs4eShX1iI6HRaG34/gPXH8xSrz1Anh6v8yTmQvTVCpYiiv9W2fSwoWYVpme/z4ntH9M3g2MKQ78vlB6QyBvhjj/KAUfz87n/DLBQcGvHv0fdM6h0uTKsmkbcP8yBlifLW8kWrPj72TyvWKhSE51c6PvZPme0VsYmzhZHvOPGPGxYKgO9M7/a9u6XujB66p2TiZMj8JlmKvrb3hE+86TmTxnrsoe3Lq0/OxXifjDKaDBRc/bE5MRJaQA6enT4ixLSzFzrH6ROBtdgEA46XZkG16BCkAKBmNXHmvsOt3FzzKCaPL7O28WnhvZN+H6ja7GVdaBV6DOics9bdd+BVLsJArmsHBwSeffPLXv/717F233nqr3+9nGObXv/71c889d/jw4bkos03TXLNmzeTfe++990tf+lJJG4yxLMuWNfEWquoliOM6M+x2+xe+8IWHHnroiSeeOHbs2LZt23bu3Dm72c033/zEE0+cwbx5GUq72TBNU9MmfBgZTXv55O+31V5HZmn+5DmHOGuaNrpP8612XoxFX1mIuvT60I4zh1dMh6Zpr5z671vqtyr9ppQ8y4snm/DSMMkQ8Ikm00bAV2zqu0HY+ir7rdXGg/XnLzCKzDJnJWCacYhl7BjZmVGy82l8PHZSUdQN4dUIIWzhXKeoJucV/qolNWmX7F/tIu0fqNrbm+sfyY6d0yGuUc7UzYIudKf66lzVJDFDEmALhEFFiWmuRtbd5kan1SBTtYR+RdgjO5sYnYkOnNobvHU16btYvp6cypeMa3/8cJWz0k97J7+4IhiS3ly54TO7bB7a+NEmHXiLH50RBOQzODFn8C05vlDwMoKDspv5LOWLyITwTPTg4771c3bCDRZpGrLpqKNTBwq2Kopkpr5Ng2piB3/Kjw4QXGkZ2nNCT64/I5S+nJqp7xjeuTK4zE97FVX7jwHymhCusIVq6MpCoTB/0m2WZSeJkefCggnCaDR60003PfXUU7fccsvsvX/5l39Z/PHQQw8tXrz45Zdffvjhh8uehyCIZ5+disqtqqpyu0udFhhjkiQnRelsriMM8O12q6B/QEvvMIu+vGLGl0/T9PPPP79p06alS5c+/vjj3/ve9xYvXjz7wFWrVgUCgQ+mkxcPJElOfwQ6GPuGD69OrD5PDioJUJZy138QKwDdMt7qew+TwJDn0FUVtKODJ5sTrWceYFqFFwasxRy6sRohmJhnb9O0q2923v8ucYRHP9pMnp8d8Vwp1ixs7RjaKVji/J/IsDTKiZ71lasznXnME+fwKC0QT+qRDT7K8QGZuEVd6sz3zKeHGDCvFmRdJnXSmfYSNIkAZFMelsaavA30aR3LUKzUEZ5ykJVX+wnbjO/ayAx57BlFVoVTNZY9Yfea0X/+j9oHb3CvuihcuycL3dPHlZIzUSF+z6LbGGLGtI4A3dR4/c96I7xp/cctFE2wuR6h9IaM0WaFRNmIahyJivFWVzWYJsm5bZH0rjj/yNJ8nad6rm7gVjJ7qgAMOCt1ZVT3LZ4RVGU13k50HXRve+C8h2lhayA6PPsJ7h9tr3RFloTaAOC9OGZIfHM9d2PLVmxYl2n1iXg8vm3btk9/+tNPPPHEWa5HUfX19alUaq4GCKF169ZdYH8QgI8B6oPSKrzlvAzNzc0//vGPb7311scee+yRRx4pe+B3v/vdi9uzSwFkIXyK7MNDLb7G2Swe80GuR7CHbZSdBAAjNW4JPF3bgkgKAABjwBYQCzPJHhg/kpHnpSRNB2EQfJccZ5IRZ6hsAwvDkTR+exxvq0JrAjPugKGYFePCgXu4ra8aLw2Yt4vvK6cOEawTEHKsvo6uaT7PkZwRe8cOFANEzwnHkp2OrNM5fM7hkYZsxg9kI1f55jS4LSgOxdrPmsCTU/NH48djYpwiaBfjrMnUEYW4hWOV7gjHuGVd7kr3eFmOs3lsii3VnnfX2d0NpUsx5fg+s5ClI3X2hoCN8WVPOGgPa6+oH3rhXX9nT+W9tyLWvoDjMiyjNzsw+RcDfj96aG3FqhIpCAArw8uOZCuePWXuv4eiCQAMJeFpalbXC4ZvvSefz3lZb1rOpvMxn9srVwmtfuvVY/id4UMPL43MNrcW4apic90CtjDX6Bjfm/E0Oshp6wODWyUcfOZCBOFIfmx6qHYRUSEWE+L3tH0YAOIy7I3jzy4hrqu92kYxc+VXXAgWQBAmk8kbb7zx4Ycf/spXvjJ9+969e9Pp9B133CHLcjqdrqmpAYD9+/fv27fvb//2by/8umfGny299HlpPT09Docjny/jAf4jhmPMRaqkCOIQP9LAlXcYnxmWgTMnCuG17sJbLxbeeYn0+I10jK6st8SCmU0AQlSwiq5u8t77uQvJYUpKqe5079nbzYJ9xE1oKKbHXYzDSZda+Pvy8N+jlouGR1qIinIToziuOCps/+A/Ds/9PO9FzqtuxpqCNSX1L08xDUvdNz7AVDeXSHrl5EFE0bbWVefR2+5MX3em7zwOpGSqt2eohWt20uesnRuymTiQi2zwkhdZFmbkbH/2TCFjFsbHk52dqZ6V4aUbKlc7aAcykLcQRH7Ea4XxQjxNZuq4GrAgJaVzyYJn0Ec1Y7amVNgox/ZaiujceBOQlGmaJEBogz15MEc0+V1X35bvPlL4xvcrti3ltt29ICGUADDIj0y32PdlhwCg2VdK8hl2hHckln23w/ivm6ni+6ZktBJPba5b4FqddjsTk2yqoVa5KgbSfd7KgBKQbQhaOPR+orAi2LmmYmXZnhAM4YjYxHGFsBGuKjY/IPoWT1npCE9EFjz6+GCxlu95YHZYrGEZe0YPbK7eQBEUr8FvB6xbatDKYO1cS88LxwIIwl/84hcnTpz4/ve///3vf7+4ZXx83GazvfLKKx0dHXfccUc+n1+6dGlVVRVFUSMjI9/61rc2bFiAKKPLHLt27frBD35w8ODBBx988Cc/+cnnPve52W26uroikUgxn+TYsWPV1dV+v/8D7+lCgs4ztrQDAANATuGjZGyuVKciJF3OqjnVUHXLwBg7aLudsntZDuLG8Hd+aPfIkS//I+kPW7KgRwdIt4/0RwBjIzEi7Ppd9rf/GHjsa+fXTwtbe8cOngcZGp1nbDkbAGCMh/jRRYEW8jSvlYFh+xju4vFttUTrGQV06uB4y+7vP93w+Xtu3fzhuokVm3vbx4T3fpf51XfMXIqubODueKwo+YzUeObX30WI8N7/Z/ZVW86pt2k5s2/s4LmOEQCQhVwDXmzCQG6o1d9cmhUzD+iikTiUi2zwEWegSsBwXiaDKRyMledlLkI11e2Du2wkc2frzZPi3JZxIBMBAMe4PQHXuJDozvTWe2o94HYPcYW6nM6qyXQy7AhFnCECEWBZ8vG9WJUda7cCSQIAohDCgEgiuJpLHMzRazn7ymssYVn0vZ2YfNO79eYLGtJp9ExbvuimcTh29IaGLSUmFl6nf9ixMeLA799NNbondpWog0pKAxMcFTYACNoDY4Uoa5g2IE/6+mtQJQCsDaDfj1gbQyebfY2eOZJnnDX2Il+Eu8ExvjvjaXROVwqtyLXigbe9dz12HsNMSqm4mCzZeCjWUekKV7krsir8315rUwitDpDrKlafx/nniQUQhI8//vinP/3p6VuKCfVf//rXi7FnkUgknU739fVhjJuamman2583MMYfWFTFOSGbzX7iE5949tln29ra/u3f/u2aa6656qqrpgcBFfHhD3/4r//6rz/+8Y8DwJ133vmd73znox/96PQGx48ff/rpp4eHhwcGBj760Y+uXr36q1/96gc3jHMEMpFzhINpAYcJMUkTdMhR6gfFgDNyNiGlVGNGvIliKADZqDDuzot+1FrxyP2khwYAwu6yNU9VIKOrm733fyHxD49LB3Y4Nmw7j66eTPek5cw5H2Yi58iUiNNMbTQfredqASClwIsDVoBFn11MnFULkk92ONoevOG6zX/TYU0KQsTY3Dfc777hfqzKSteR9C//JviZbzA1LZnnv+O56UFb6+rUT//KkkXnpjJx82Whmdo7w7vLZkaeFY4xF6ESAGBYRn9usNXXTM1tjsaABU1UDEUzdQtbLMU6aNZJO5VEbuAX7aEty9yLI8Xv1NItOaEJ47LOG6ZhIUAMR9lDNmcVW7SEnxPGhfhYYXyuvQVN2D64s56rXRNZPiU/MLCJKT0dAapyRVyMYzg7tjG7UQ5JulsFAIxxXEzkFL7OGUHH9iPG5li3FQjSWck6q1nCBaZqSQOaGFP8S12pdr5ik49weW1Lrom+8Ra7/Fo2dKEe7oImxKUp8dCZ7qp0VwTtpavkV6KrHmpx/e+V02SSYUnxGYKQ7xM9zRP98bHeqBAzC1kfR2+Xd3/Eup0kyEY3MCSczBm1sfYb6suvtFg/TTlIQzIJhnBWscKwxLVOeQrJiubMgZ3eO/F5aMOz1cGcmh/kh+5puz2vwy96rA9VoLVBtCTYNpeQXhAsgCBkWbas3356oA5N02WjRS4Qet4gaAIuQeLZWVAoFH7zm99s2rQJAFpbW99+++2yAvu5555ra2sDAJ7nBUGYzBScRFVV1Wc+85nJv5d5ZI0j6ia00mFGhXGSIP3sRGQdBsjK2ZiYOINfB2OcyozkK+phb/+KbW0lnCwYYz1vKBmN2Py/Rv/9t658C+nxEBRBO0naTdk4+qxhGrKhHInNq8x36QDjTkKbod9klRxn8/QLnh1RvK0arQ2cfSKwZEFPjJqL77rdpT8lk7tieEvFjKOQzW5fuRlRVPrZr7NLNxI2u+u6ewCh0OPfTf7T/0E0Q6+cl164L3pwtutlPqDzjC01JS1UQx3gy3t8FVNNiElezc9OXaAEwTM2GuAqhp970V4bsbctxfaQqcD0xAwMWM3pak7n+0Wu2elpcMw/DRFjPFdZIgDIqvyb/e+siiwr4eFkciyhTz3Bgg4GBh/trhCr00RG88oumJJhspg91X+slavzLNqAEOJanVyTEwBUVaXsZHA1x44x6WN5LW9kThSCaziSCxBcxei/7615YAsbuKB0+77c4OSNUk21M9V9R0vp5CCZoT6x8UvLZ7yQUlydzpUjJzVsgT08oXtQBMkxrriYpzb6g3lfV7ZvaaANAK6JoN1xvNg7mlVyPrZMECxCyFVjz3ULAOCuc8Tez7gbHZMpsYTLKxMNSu9xtvXc6uWKmjjEj5RsPDTeviK0zEYy+5N4EYfWBpGNYlaFL27p78uCG+m8gS3IdQvuJZddhdK6urrp+ZTLli0r/mhsbPzkJz/54IMPPvnkkwBw/fXXF7cPDw9/97vfnZ1f6Pf7b7zxxpKNqqquW7fONM3LgVZmEpRM29JlHgTGeJgfSYjJsDMIgOJiokQLnA1LzANFgY0djI0I7wobrl5JFgP8UpoUV5W0dpqz1IPqN2ff/D1d2UBFaknvhP+AcVOOiM1ZY58rWONw7KhunUPuQRGkQtkSZZx+b4yMZo2Wx9pswfm9hlrfcaauDVEM31n4Pyt8Tx8x3/xwmc+QXbqRu/sz/MvPhP/Xj4oLbSpYFfzsN1M//oqbdVHN5d05k+jPDfZlB+fVoZkgDGJ2gIyoiX3ZgSpXheO0gVG39JiQyCjZ2ZW9sWUayTFNVfTGBtHBNS5abY4N5fbst2SB8kfIQAUVqEAEZeSSlphnatuQjcUmznUL0rgSWuOdZ7jpSGEsKaXL7pIMefvAzvWVq5q8DSW72GkCPiYzXQWOQuZKVfEYtFYnD/LDzd4GO8ViXTXScaxIZLBilPO0YqNiud9VU/r0XdV2MaqAhWP7ckXiFVvbanHffycPLqq8rvI8dNwiMMZ9makwmePJUw1cbQkBHkVQr0U3/O9VJD3T8DwjcxdDvlfkmh3TFzCcrI14ZNNHrrYv3z64c5GvmSTIJV60I4qHCvhYsvO62vJ0H65qe65HAAyknbAHbOKI4m6cWjSQFW3Z3Qcrz1EQdmf7rZnvT0xM5NT89fXXAsCJLL6tlgCApYHF52GcPyf8YQtCABBjCh259HEx88Sbb75ZdvuKFStWrJjvO2Sz2Y4fn7NMySUBxtgx4jqDx00xlGG+lP5Ks0DWAYk0pzJOjSYVElkEYSIDOXWPX5PBtBup0ex7Lx9q9NaX5flkGpdSwSo9Pix37GFqW5nGpQCgFQytYPB9kj3EuBscJbRtaTnTk+k/jzE6Rt0Il+orogEpxbyheizANs7H31VUB13X3QUAhmLebknfLtjfHsdl66s51m11rNs6fQsdqQs89mTqZ097HnsSmpfNdRVRE/eel2sQANgx53SdaRKCJnZn+jibhyGZgiYohgqznzcGxEtmJkE7fERFA6Yt1VC78yP1NfVc83KsKUY6ZqZj0sBJwBbJBRDDint/b1+5mfRXAIBWMGL7MqG1nM179lmvI3Gi7HbN0rcPvrs40DxbCpIyRQk0AFhA9ArVOd3ziUUEoxiJA7ndQb4GOaodof7MQJNKkqZJckEyUgsIaabW5TnVUPWhspfzLXbHMrpvqSvdkbcHGcLhpiO14tH9CXpd5fV158ezk5TTeW1ClZcNpTvbd3frh0vaONklRzKuF2+amd2hmFpuKuNTTmmAwB6a4YpiE3FyMaMD+FlfgPX15Qbb/M0IYHMY7Y5bDe6h1eEVZY2QpI1gfYyS0QDA3ehIHsq56h2THyUVruUPHa48l2Fa2Cr5EjHgg+PtaytWkohIqyCZUOsChmSWBhc+g74Ef/CCEAD4nktTJOwKJsFmHZRIm9gyLMPClolNjMHEJolImqQYkiFOCwndgqgEvI41haiTHPWKHRAkGXWQUlSPoSOLtOQ2KesmW92DLKYsOSwKnNiT7Z+e6TUdhNtrc3uZmhZx72ukLzSpF2KMpYQqJVR7gOFaXTbvhKF+//iR84iRYXI2ulAmJ3dMgioHUnQxLiYrnGEA0HhdKxiGYBqqhQCAANpOMV6K8VIERai9HUz9IkRNTPTyiPTNJuqvDsLuO+f7JTKNS7mPPs7/4q9tn/0mXVOm/g7G+L3R9+dTEmTqELAETRJ1iSzQ4XGbAjpFUDRBMdNzpwEAoIQES7PAwuCWGbpgo0SakkgLGUDWYQMTGRIZCNOW5lFHC+O42vKyHF3ZUBJbaGZicsceuqbF1rwCEDI1K74/F1zNOcJniiQYzUfLqoMY8LtDe8KO0IrQ0tl72bQdABQTtedqql2e+5oQiXH8eD681LWOtA0M7fEaObfbFnMSjdO4S+SwKLvFvWMHt9Rumn1Oxk05a1iMMRtg+F7Ru8hla1ut9hzNvP479aDl9sT1xAhhc0S+8pMzDKcE07MmOpInWr1NDmqGMuqxuX87tOjLK0q90dK4Ml1Bz/eLnqYZ6iCYJpE+smjVHUfz/QCwIrzkvZH9rf4mBGhVAL0zjhMyPp48ublmY9mOOSvZoiCkXSTjoaSo7DytJRNOjwke4VS/a3HTPIcZFWIl1bKG+FEAaOBqAaAzi5d6EQJYEmgrSfM1ZJNaaJ73PwZBKOe02faZyxMf//jHR0dH77777i9/+cvzaZ9MJl999dW+vr5IJPKxj30sFAoBgKZpRW/il770pXvuuefi9vhswID7s4M9R4cJDQECiqBIRJKIAIRIRJiWqVuGbukuxum1+TOaKy5DNUOtERwe3q5zilKRN5yaC4DFIBuANJlMj/WzXDBY8FYWGJ61J5z2hLNQn+ux+lr9TfSsJKoiEOtgl18lH33Pufk2RM+YQ+W0JqczjojN2+aKGuMxIT6fcVmWmVF5SZcsjE3daBpqA1Oykcx0YWxgSMh4YwgBQDqRRSJlpjFJE7SXZlwk42MAMFigC0Z+UNLyBusBMq97r5vmLMewKV14hnf9foS8rXZW5XTd0vKGqVqmak1WsEIUslwrmJu+kPrpU4HPfJ2pLV0sd2d6o0LsrAOUDWUkP5aQkkkpXdAkB8W6Gdeq8VV5PW+CZVqmbummVYx8sbtop5NxTNZ9BQAMwKcZOsNWKCyymZo9n4ces4ogA6HJiAkEiFBJhmedUXcuKuE28EVKKZNJf4Vz821yxx5x/xv2ldcSdie2cKqdD6/3noGBvT1R3iJyKHYUI3xV1drZu5AJTMbOa+hwrnpLpWd9EAFArluk3bQzTNXu+r0jHDpKh6MK4YWBlJwpRqZoPkWuEgGgN9sfdgQWBVpnn9nX6pLGFW+rK7Yn46xiabeNXbqRXbzeSEWpNvC2Vqd+8jV9tLfsqmU2TMscPF1sT9bl/uzwPW23lbQJuta8HUM/+1Cp4i6OTzkdlLSGTVyiDuqpUU89XVm1vKMwgDEOO0IsbRviRxu4WgrBmgA6nMYRx8DqyAoHXcYLYI/YoHPCEOBusGc6Bec0czEVqsoc6J6/IOyalbzUkehcWzHBc9uZwx+uIWiCWhpcVNJMGlPZxQsWcVnEH7wg1GemnV7meP/993/6058Wg2jmg7vvvru2tnbFihXvvffe17/+9QMHDjQ2NjIM89JLL33mM58ZGzs3WqmLhBpcs8TdShM0MUfMmIWtlMwP5lMUil1lLAqnAqpP4RelLXoqwoLEJpsew4pI+iMBm78zh9cEEHgVjVPsaSfXE5Cq8z3QfwZZSIVq6IqE3LHHsfb62dFrUlyVEupxsgcFESbmXDbJutyXGxrkR3JqzsN43DYnAlTD1/D5vIFN1dAIhBy0nbN5vDbPuEQEGOTmWTblRAaRC+YCK73BMkSyNgDAJs7tO6rRbeN78u5au7PaThTVLYz/N1P44U5880ftJIksA6sZTU5palY3JLPsCs+yLMtqIpf9xfA//6ryEw87F0/VZhN18cD4WbinebVwInVqiB+tcVdGnKFlwSUem5tEBJtwOBwzHFEGNhVDETUpJWeG86NO2uG3ez0MpyVZb8plx6AH5FPBlGCIDcIAXdtI2mbMnhiwaTPksCCHBYZnURfSRq3gitLak4hhHetv0AZPintfc6zbSnIBbOHkET6ywct4yjzrqDCelMowcgzyI4P8yJ3Nt5SlcWCyDkmFI7nwvY2+BhcAgJY3xJhasdmvDhwjAxW1SzYVUl1W3siqNTFhwEU7aScl1hW68/i1UVzvQggd9tv9s0OgCYZwVtsLQxLX7Mh1iaH1HAAAQVDhGlEhPVzAvnqL1L6Lm58gHCmMTdYNPpHubvLW26kZk361u/LnvZVPLEPOmZO3LhpafsrznR+QPI2OkjtBZY+5r77aybjCjmAxaWFFcGl78nhRCVsTRD/rsrZVmSfT3esqyiStkgzBBhglpQGAzccQJJKTmj00sV6hQtVC/3FdMmjH2cWKpMujhRnT15gwjgFXuysBIKOCqEOtCxYFWtmZwzc1S45psNCRl3/YglAy5J5Mn2ycA7PzBwNBELq7u9esWVMMFu3u7na5XFVVVQDAcdxcPKuz8cYbb7hcE3PTzTff/Ktf/eqpp54CgEAgcJ4EZgsNBIjTuDO7sg1MDIneeircnHTJSD4YOhj0+j30zDk3MYpIiq5fDAj5ABpc6HgWrw8ihEAOirpLcw16NUXuwf0t/sa5GNFsbaulw+/Kx/bYV14zey+v5I2c5Un5pdqC7i61HGbk3NHkiZiQqOdq1leuCjoCRQWIUEguE0CnI+k0Sxc0Mafwo4Vxn1K7QagjaCRFBMOjYcCjmqgWVI/NXfRoqqamGqpu6YZlqPm0Qg+SDTQhk1LKyfQzRqVGVGE7zdba3Wui1o5/Lyz2noNLCXmr0dL7Bn7+ln+rHrp2Ke2iMMa7R/efIQ5IMuQjsWMjheiSQMt9bbfbqKnbSOikPVZaj5BCpIt2umhnBMDCOKfwWhLZeQ9DQDrCOwM6AFRhnB8a5V2VYduZeFU0TtE9ijPJmfuswErPpKV6EkzDEsLplo/sdF59K7LZLd1KHMpVXO2fHfHUHi/jHcwq/L6xQzc3fWj6oKYDxdn2rHdbdagoBTHG2c6Ct9VJYFUb7nJefRuBiLAzZFjjgm4jUGQgP1qo8h4YsDIqvq2WeD9h/bbfcNJ7720rk77iqrEXhiRHDVsYUabLBkMxM515bvWW9M+/xd0xrzS7gdyEOqiaak+2766WGZcjEFHhXvPqiNV7dekNlKapg2pONxXLXjFDhGBTp8bftq/4CQA0cvVFQVjjqTwUa48K8SpXxMdAxA4nc9hJ964KLytLNOOsZIuCEADc9XZhSJoShP6I3L4r35MJrAqfdZi9s8JkjiVOLg8tLi5iTmTxEh+iCHJZsFTiCSNlSqBcOP5gwkzKQtKkc/KFfGBgWfaJJ574+7//ewA4cODAli1byjKDb9my5eWXXz7DeSalIABgjOdPL/mB4oyvpWZBRwov05yLxn1qWDHalJD5KcVvAAAgAElEQVQ3MJqPjhSi5umCDyafxoZOhaomNbkqBxAUPsVK/KK0xqkGq+db0nTBRg/ZuzP9JYVppoAIx5rrsCIpnftn7yx++aRKuvt8ziGO0CdmWF7NvzO8e/vguxFH6IHFd26u3lDhDBelIMbYNepG0wbIELSf9bayzRtzm1sKNf2envd9++JM3Dp9F5JSqi870JPp68n0DfMjcTGRkbN5tVBIDOFghYUtg9WFmlyuLQ15hI9RyWSmJ9Pb4ux6bzwqnyN3FBWscqzaknlr1/BLR3I9hZ5M/1x5dRbGHYkTL/e8xlK2jyy6fVV4eYnAcIy50BkTDtmCrW64uSrfmK8o9FadGMDHElLKwtjMJVmG7sPezhykVDhDOQaMQAjzaq2YOpoXR8o8QSpUQ9e1Skd2gmUBgKlaycM8Nme8XnExObt2q2yoO4Z2bqxeO7tcu4EhJsNglDoVcy/2V63wT7xgwrCCKOSsZNW+43RVI2F3AkDIEaBJeokXZOztZlP7hY4WD3xuCdHqgYeaCQvDMydzB2NlrLKMm7J5aYSQb5Ez1yXCtJlajCoGXQMI6aNn5/fRTX309BM8me6pc1eX0PosCbT90yn355YQ3CxxX0x4LyLfL7kbHCUpW5TUbV+8mHC4AKDRW1e03yBAy0NLJpP51gXR4RRWDHWukGN72DYZAeSI2AzJ1Aunw3MIkvRH+I7B+dQ6LjHjJaW0oIlN3olI+84cXupFjVx9iYUWW7hQ7s25cCyYRtjf38/z/PLly+fi+c5kMgMDA42NjR8EeQrG/Cs/t+QPKIiG9IY8Nz80fQtFUb/5zW82bNhQJN3+wQ9+0NhYporm1q1bi2riWfHKK6+0t7eXrexxOUPH0JmiNhdCHrCkJQWNkAHAzTgXBVqiQqwr01vvqXFgwsjEmZqW6VGXpt2gm3K/HTW+YCdwXYHqogGAb854Br32fmdfw0Cdt4azlaNvIUjHuq3i/u1qb4etZSrHoKAJkn66GgbGtoyNyTFCqLAPvd+THVgeWnRtzabZOeO2jJ0qzJhykEk4Yi4mx55yFehaOcwGHDo7LiQSYrLSVTFXVVtLlQDj6YRwFmPmG7NM1u7u96lBCYWFPiu9J5qpczsrXRHXLOa2uUD6I4511yvH3x/qPdpXY6eWM4arVCNMyZndo/udtOOulltmc8IBAJ1nmOycThdCJ51jbqRQRx0FX0T12qABahVTjQmJTvFUULEiVW3rCZSUYVTEXTkIsCjMgs8Gls0UawvIQoROOMZdyEAAwDv48DJbvks2dKuYljcdtqblVj6rnDrELt0AAFpeTx3LB1d5Juf0Y8nOkkNMy3x7eFeLt7FpFp+fZMDPuy0CwTV591pv3XWVE8/XVM1Cvxje6LMUQR8fcF17V3E7AhS0B8aF2OoqK9JcEe1/vcVdQyIOAEgEDzSiFwfhGwc6f7olUuEqNZC6au1qTrcFGMohF0YUd/3UDJ7tEhyrtkjtO7mzcckOF8YMywAAwzK60j23Ns0gi7BTbMS9/MUB69QDpXOsljcmK4LpBUMvmMHVMxbNCCGi/xXnPROkxyzFVroqisumJq7ucKwjq/I+G7eIQ78fwRkVTqa72/zNs7OfSZpgA4xcrLtCIGedPT8kBZZPvNhUqEqLRaW44qo+k3kgJWdKoq6OJ08uCy5GQAAAr0FBhzoXWh5aUnKgFFNMxbwY6tsCCEKM8WOPPbZ9+/bq6upkMrl9+/amplJ/6QsvvPD4448vW7bsxIkTP/7xjx988MELv+6ZgBBd2YC1hedmLQvCWWb6q62t/ed//uc777zz85///Fzjffrpp+dz/v379//pn/7pv/7rv4bDZ7c5XD4wMETH7B/ivf5almtxAQoP50eLJNckImrdVbxWGOCHvRquDFUhekremA6z0JyroSwuAR0ZvDpgiXV5V58XEbjQmHMNcY4Bz2DjSLW7IjjLYQMAQFKOddeLe18j3V4qMjE5zlYjBEUaPjFe72xes2wlwZWxSRI6ckZnWAuZPOscdesetbs+Na6aq1kEAC7a2eprzGvCWGE8q+Sq3ZWzo1stgSdcZUpraz7ZcGnOEY+nJ9BawfcJesAm9mb6XYyr2l1hp+ZF4kxyQec1t/eMtFvJQcduxlwckqoFTFkAYFjmkXhHPz+8oWJ1k7eUpvJ055BjdA7ODgy2rN0x7k5z8sGAUe/Gk/zyLGmrt4cKuULMxQj50VpPdZWDqXIg1YKkDP0FrIPetiKPqAkV0WJMd7+3qDYnrGTjqjrlmGZp2LfIVeLHYpdfJbz7n7bm5chmBwAppuQ9VFFkZpXcaKGUPXzP2AEn5VgVKU0m0Sx4oc9a4kXbQuSqkUY/O/WC5U6JrloH5SSVEyeYukWImVoEBB3+uJzgG7IOm31dZNXu0fdvb765KA4IBB9pQP/aZz2x+8Cvb7ypRCVzRNjsKcHSLW+bK3Eo56xmJ4kgdNGwQtdob/7NWa2jk3bRrkxvxBkpWeqtr1zzo07yT9pgdsaqOD6lJxUGZVedvSTbiKFSoGfZtilyqyZvfVEQEgS5ONDSmTx1Tc1VJIJVfnQ4jf22XFSIFT12JXBWsvLpAmSuGvv4rrSlWsUyHXSwWu3pKAxJZxaE/TPVQV7NJ6TkltqrJ8bO4zYPqnFX+NjST6YwfLG8YAsgCN9888233nrr+PHjXq/3z//8z5966qnnn39+egNZlh9//PEXX3xx69atb7311sc+9rF77rnnYlv5HOtvuKjnnw+OHDnCcdzY2NiFUMEdPnz4rrvueu6557ZtOx8usQ8ekgldOawZaFGeW6E7qlZzNv/EArbaVVnQBN2cUFk4xs3ozBitDxi5RuwhEQEAJmsWmrMWZQHA9ZXEfw5ZK/1Id2tqSGITDoxwoT7nGva6+7mxhqhm6WW5TBHDOtZcLx7c4XS4EcVkM6MFK4+YiVfOAhwT4lmFr/PUuBknDCDVJ08Kj4kzGISr14uM09wZOumMukmZFup41aX1JfGSmf48D+Ny+VviUrIr01vlqvDPpOewBH4uSmKLNgtNWVva0TDi1x1i1iX6bCBoQle6L2D3VbrmrAkwHSk5IzIkXdWkjw+QXWlOqBJr+RFydPfo/rAjeE/rrba567A7xp2kOkMVFg2ISqCKxPIcZ2D0Lpe3+yqu8bmW+ZBhGYP8iKAJWFP06IArVN3q5JJSujvTX+kKB+x+GwE1TgjUqL+w8oeHrAcaJ+hHdI8mVYqOqBMAAOMReax1XTPfLvE9Itc2Qy9EFENXNmrD3ZMk43yPaPPQbJDpSHSWRA8dT57k1fytzdtKAmRMDL/ttyJ2dEMVqs/XTzeZKilNyxv+FR6sKnpsuJjTOQkSkf5WLmWPAUCzv7En29+XG2zxNZzeCx9tIp7v4b+6/+QPPjQjNpWgkLPSVhiWaRfJ+hlxRJ6eby4KXhLT+mjfGQqMqKZWlEwmtk6kum9smMEfFHGG6j0Nz/cau2Zl2mCMpfiEZDJlS06rlUtmqtoIyOgO9urbpgeR1XlqSEQWGfgW+Vtf6n51naGwFLs+hJ49ZX2oAp1Md5cVhPYwQ5DIMnFx1I4IK0QVT6MDAJDdSbAOqX9EW+4pG+gEABbG/aflfRGdqe42f8ukPeZUDl8VLqMOagVDzZ0zD8Y8sQBK5m9/+9v777+/yBz9qU996sUXXzTNGd6G7du3e73erVu3AsANN9zgdrvfeuutC78uAGwfsxIKXATX6QLgnXfeefbZZ48ePRqPx3/4wx+WbdPe3p5OT6RDHTt2LJMpZb/s6Oi47bbbfvjDH15WJDJngInhRBbXg+3mTGipx92wxT8pBQGAJMga91TZMyMVpYBoDrXZKVt3pk81NUxioSlnnRZIdS7w2WBvAgOAHJEmoj0RCHU5i7LcA/5kPjXIj5QNrSQ8PvvSDeLe14R9r4+l+rSxfiObAADN0nszA6qpLQq0uJmJedmWYb2dAVvSXmRQQwbh6fVSCgUACBCbdnDdAcNm5haldJcWlcBJIW7WZ04gVOkMN3sbklKqPzesWxOmKkuVAaFJMVwWakDiW9M1pi3UHyCU4kyH03KmM9U1LsTPzBda0IRo0bGEEF3ZYKmKMTLCH+SjHYmrK9Zvqd10BinI8DY26QQADJBSoa8Ah1L4eBrqcq4tmSAZUG2rrI+vbX6gyb3MhwCAIqgGro6xsB4doELVhJNDAGFHoNXflFayA7kh3TI1TlXqCw80go1E/9o/tbaQw4LOTczXhmUMi6OB1ZyUVIXhUssNU79IH+2F05W3McapDj6T4wf54enNxgrjnenuG+qvnZ7XUcSbY5hEcEcdspP2Rm3KK4EtyJ4SfEtciABt+BRd1VCSbGPz0stWtaDT/rMNVWsOxzsMaypLnSbgnnp4Y+RkR6r0a52knuGaHPkhebp309Itq+F2Yfcrcz0IABjiRyxsAUB/btDHctOFNwJ0VdW6/x6DZg9q8ZQuqbW8YUgTb0hhWHJVs5PkZ0U4/KCffNd51QySNoZkajwTfhkbxTR6606mewDAx0CDGx1O49F8tCxFH0ERbHBKH3bVssKoPPkNMo1Ltb5jwsic1rhxITbdF66a6iA/vOR0XopiQlSC9WH/7AWucNHUQVgQQTg8PDzpAGtsbFRVNR6PlzSYbixtbGwcGpqzcgrGePs09PefiQQkkNALeXJf4rJLI0wkEo888sgvf/nLurq6559//pvf/Oa+fftmN7vvvvtef/314u877rhjx44dJQ0eeeQRjPG//Mu/3HTTTTfddNPlX7+wN4dWFbjmuNfdZguv9JV8kADA2dxFMkOTT1mSQEXqEKBqV2XIEejNDoxGhk3bjEn/rjriYAofTGFMWVrg9PeDQKzLmzbTPeDnRb4vN2jhMlEaVEW9a+tHtE03mBW1TG0rloVMtKc70+djuQaurmT2RCZyjrq9J4LeE0Guy0/KFACQMuXu9duybL4lI1cUAGEDw7CAm+am/7VTbJu/xUGzXZm+gibC3HbR0xeemNcsxpSbM1Gn5O712+OuYoSOha24mOhMdUWFmG6VKRPPq/n+6cNHhBGu7CMkXVOuSVS17GWoxJzxK4ROOIY8RfbPzhwMC5gmYDnJ3pINBS2Kb01Hmj1t/lpyppWNNIxI3wAdqJzu8mRJps3XbKfY96WDQxWDGGECwb0NSDHhaAafHigSq4XJKUfUxLgWD63l8gOSnJgRSkY4PYTHp48PTm4xNev4e13WNNHCq/ldo+9fX3uNY1aVqM4c7ubxvQ0EgdBG23o0jf+2MCAxbpINMmAa2kgv0zBD7SAoFFzJeVmu0jkxCwftgUpn+Fjy5PRmHho2BvHX9u0reesYD11UgygnaQ8wJXY807emcLTdzJaa6CdRtItiDMeTJ1fM1Ida/U0Bu///9lifbC0zY0uxie/C0rEYVVx1M28IAjp/gF28jnCVkog2clPW8qXBtu5Mr4FNALgmgvYlsIlxV6Z8nTJH5dSqjnZTlI1UkhNBi3RFvaUp/PFByyj/4vXNtIueSvfUc7UsNXHCHh43utHqcGnuoGVY06OBFhwLYBqVZXmyoETR4CmKM/gCJEmaHutvt9slSYI5YFnWt7/97cm/N9544+xivxhjWZYxxvWk5kkGWty5H19mJSgkSXrppZc2btwIAM3NzTt37pzUkk3TtCyLIAgA+M1vflNcQ2QyGVmWb7nllpLz/OQnP5l+ryorJywVhmFcPsIfY2yapmKBlLavSXHgUYmVhsft07TyAb0hWyAV7zeyKbKqwcIYTBMAfAwnBPK/y7x+Fb2uetpi0A7wcAP69QBpmuY6b84fZyZjOPMVGVeM8/T6cg3pk3p3nbt6tupjYTzKj5mWCYhIe1xpKVVrOV02r2XOrWPJxQNNZ8LDZp1imJd9EiAAEwCgr4CCNmBR6QkogqIIUjlNoxpiAw7SPpQfCdkDXiFHhmtLzCS6Q1O8iu5RMbLYrIPNOEiNBAB7hfg2pVwrcB4+kK/JGjYdAEzTHNdjsULCa/NwNo+dYAGDpMt5tZCQk5NvAgZISKmMkq10RbyMBwAsPm17L0XUOOXFNpOdIUcJE3kGAlizTICeAjJMtNKDPXE3k7cXqnKGR6t1V3sod+lDtEztyLv2YG1NpG64UMqZ5/dz4xXUm4PvrAuvqvfUAMBNFejFYbLZYTCT2rynYE9PzNTj+TjL2bjl9kxHwUth2jU1yxNVzWr/cRyqKf5VTTWdy7GGPV+TAwDN1HYM71wVXOqlPcUe5jTUnUfVDswQ8Oow8bF6izCNenczOUpNDsGUrMKIHFjn1DTNHOkmfGGDZGDaAD0NDsWSQYBGZ+1gZmKxviKw5LXBHY3uukl6F9M013nRz/ozP+s4/FDzjPh+wo+1lAYAbC2dbReZCpIgp+YmovbOzGu/tt/1/8AsSIY8nB21sDVSGKMI2k97J7vNkMwiV/NoRnxjlP5/1+qCMOPDxxhnh/KmZgGAOKTagrSJjOmh9PYwKb3+b86PfUkQSoMHfYQHm7joqmDB5rf5e1P9TVx9kAIPRXakdNI62epsnG2cx3asm/qkystWUflhiTztLCDrF0tdR1N9VY7q0u9Rt4zeVP/kks7E5sl077baLZOD7cySizgmRAVKeiuNqYp0Wt4jUxCE+VeoZ1n2rI0XQBBGIpFJm17R0Dc5XxdRUVEx3eiXTqcrKuasUUeS5FkNpxhjgiCcTqdNeC/lNOy5+nPnzLq4aGhoaGhomPy7ZMnE+m7p0qWf/exnH3jgga997WsAcNVVVxW3JxKJH/3oRx5PaRjk5s1lCHBVVS0eeN99912Evp8zTEDH0lQr727UbIU6PhBx1Xqqz9AexcZ9ySRf3zQ9QEb36J4mx43KdTsGd62BFW3+KVdKiIFPtsHzPZBQ0QMBwzEtvlGuEVDM5RsI5Zuz/YXhKlck5AhOv9ZYYRwjTJDEaGFc0uVWXzOM9SO3UgyXnwukSrmGOUxZ/KKURVnk6fomeR0yGt4QQtMmN/CyXMDudzEuBCDoYkJMFg1KHtLdxjQPZAYl2qpn7ZNcqZjCUrWg+CSEEAkEAGE4NbFK93T5SYV0k+D34P323DrL4R0IKhFRCUqTnHB5vZDXCwgIAqGivbS4ogIAxVSH82MkIhcFWiajdUh/GLs8aGzAbvj1WkrzKabDwAizabt93IUMZBIwUADJxOvsDNfHGQ6dX5SiGGqxt40RBDPZa+aShNPD1C9BNtbMJpRTh0inx754rQNAMMXpsX8WbcmtQgNTyzk9O4Z2FkxhTXhlPQNtHN6dom6pmbhlRo1G5F3ImvgblWKLAq2+pe7ccSGyyTeVa19ZL/QeRfEhurYVAKJ8jCAIB+8CN8gh4e2B3bWemiWhCVYd1YT/b9iK2FFnHsdluK0W1XGkj/Vu9K1P9eYnVuEYEj05rsnBullL4LWRbsfa64npC/SgLbSIKxpFW13Nx7Ini4SfDMMsCbR1pE9ed5pizTRNBuCmavSzrp772loC9ilNy97kUIdNbGGGATmoaVHD0zz1puGa9eKeN/23qyRXGuTVnximaAoATmZ7VoWXTdccNlSuCXqDPzlpfbgOV/lK0ybUnE5aEskAtkCOFkLrvTQzZepABHJm37YaFnNLyrDtAEBLsHEyU2JpqO1I/NjiUCsAXFsJb0fR6hAkzUyrpwxZjFozpaLRVUyhL410knaSAAC1LcJgp9oVCy8qjWDqyw0iimBgYhTdmb6g3R86HYJrYhgUrK+sW8K5Z4XJpLXJe4IJy+VyzV8QzgcLYBpdv379e++9V/y9e/fuxYsXT89+A4B169YdPXq0qCYKgnD06NH169df+HUBgF21maiuFhZrF1je8wPDf/3Xf7W3txel4HQsXry4pBLhGWCz2drb29vb2+d/yEWFKlJbksGwHYlLUlzINpcUNHMp6dDbhR2/VXuO1q7YStumDDgWYwn1PCAI2gO3Nd14LHXySPzYdEZQHwOfXUIAwI9zhbw+42FLFYISkLheP6EQY4XxrkxvVslhAMVUe7L9SSllYas/N6yZeouvkaFtVLjGSIxAOVMqFD2CKYen16/65HxD1poWPoMBunnc7EGTVaFokmnyNjRwdW7GVdzmop1N3gbudLQbg6hG00bQTHe2XzFVQKAG5dyStOqXS4KnMIGFxpxFYACoc4Fk4P1IPF6ZRlmbp9dHqjO+eQubkwFHxY6l5ExvZsDPepu89SUxq4hhqUitGR+1JRhPj8/bEfIeDzlG3JqG+gqwL4ENC12tuf9/9t47MI7y2v8+z/SZLbO9SCuterflIhsX3BE2vYQSYhJMQnIDhtwE4iSEAAnJj7y/wH3DG5JLEge43OBLJyQGAzZgg7GNe5Ot3vsWbe87M+8fK69Wq5Us27INvvr8tfvslGdmZ+bM85xzvkfdrg6Z/P5cD8uwJepC1FwXOrZLjAQJc54kCP7PNwf2bg0d20XllSfFCiyKLOxUgIOEi95Ct0iJAKBm+GuLagcD9h3dn8fF+KosdNwldZ16vxdJIawbmeSIi/FOTzdrpOTZjOOwN/Vv4WYtjXY1BQ/tCAbc7vCwxWV7ZXXNTTjCa8zVycN/q0MsUKJb8tH3yrCfz8Lm6hCO8KU5C4PdIyOjQF9YEiV5DhNtOxHYt40uqsaUI3lcGIG0VSNJGghQWYqaWpW+bDBgS1M3rVQjAgl/OjpqghSnsGTNI75A5usOp84QIpIWcq72fvQ6jCExYTgQsMXEWE6KH11JKxIaYy81i98qmmheNNAfppTEsClKnkNNLPT5W/z194xdMUHq7GiW3BwRo4nDLFZCXIROP9Q7mjKuKEuZHUUYyLKYQLLwBcLo/MrAiRMRV3psS+q8qATSCWdTZYqCWpsPjCw235wuwRNxR1NFc84HU2AI77777t27d//ud7977733NmzY8KMf/SjRft111z333HMAUFFRsWzZsnXr1m3btm3dunUrVqwoLU2fAj47cBmPSAqNXzJ0mguAKkj7czwBi4ej2Tw+d7x3knD9fkJrki+5Xr7kelKpNciG1bEBk/wF7mTEpoKWX11Q2+sb2NWzT0rJz6YwuC4XLckXPw6G3KOn68L6YMDkV7ZoKA8dioU6Pd0nHQ2NzuZANBAT482udgonC1S5CV8XxikwVh53ZlDjxMOEskVNuxlv4VBYF0x7u+rwAYmBgQEAQAgzygzl2uKMOv1WpYUmaCkWifa0IEnK1ebrWe2B4KHDhkP+HG9qbGoqAiMEc30AgAHM0SGLDAm0sIN39nNhZYuGGxgZRaXijfqbh1qHwu4iTb6O1WQ8+Rgrx+SquK0HAJAEwTCqd8MBuyRJsJCjFgxqqQjpKugPUw4jqylWFwiNhwWPU7boaqashjRZmfIa+ZLrqdwS+ZLrU2NfSZzMkhsBQMIkX4FHZEemXhmcuTJ/BY3TW9o+Aghdn4ve7BDfaJccYQCAsCkoESNvOf6ov8fXpyyQ4Qw2dHJkiIkpVLJFV+FKTfvRrYJ32AjZA05dj2GlfmkyTHR7nxQTYXX2qXk5BABQY56lBGUoGUsZEd0tAVU+Fvjiw/jQoHzRVWnRm5pKJc6MehgWawqSrxQERswxzRwr177EhL3f5ahzNKY2yi3DFoLgcFZH+TtHeQpxy0z3gaZY76jQB0doyB3xAMAJe0Olriz1Heky81wMYSdcUpcfarPT/97UeFFfR1CRN8o7iBEINbwhW3Q1oTHCOGQrzElZKISgTFPU4GxOfJ2tQ0eckjM0ZBtTQR4AGB2VWgJKkcMG+sPJVHoyKz8+NOhtGqWEF4yF+lOUfnt9/QTCzPKRvn1hE1fk5MrGOH3PX9ZEkikwhEajcceOHY2NjRs3bnz00UeThWRra2uTU4KvvvpqUVHRs88+W1pa+sorr5z7Tr/kPPPMM3/+80R68z6f77777lu4cOGzzz57Pjrw8ssv//rXvwaA3bt319TU1NTUtLdPVpHVZrO9//77f/3rXxsbR+7w//7v/66pqUnO5abSrwhIyqiMkhWq8zMWSwKAuKMfRJHKK08GT+o5LYlTABDI8cfZUe4rlqDXFKwMxyOfdOyKjw6YLOGhtDx00i2l2cKoOuTLd8n6lFy/HEkoJsQkSQrGw82uVhWjzFFkpYbX4zqz4HNLsZFNoDgm61EqWzURdXgw3zWI4gAgpSjKtPrAGRlOmeAZvlxbbJYbxztYDGGWMBbvacN5HWmyCnKJrALzZbrjwfqt7Tt80XF1HqLqcEQbBgACgZaGXBlU61AdGThpcWAxXFWvZ20yJGCQ0LyO+JpcbX3+AYNMX6wuYMb4R7sD0OYDRxgiIhBakxSLRp0DTW7x+JAkJ2GBDqv2K3Vd6gBvHyIPSAPNFqdPvu/zwK53RZ9bNm8VIkbiYhFFk+Y8GPPGqWO1HM358z1js/hxhC3KnpfPW7e0fGRkfD+owLI5eLFJ7A2ChEth/agoAWdwqMffp61SxHyCL9VyIMyblR3NyRd8rlhvq8vvsAedxcpCdacWiyEA6PTD0SHp1nwstd5RrtJSri3xdQaHvaeS5DzqZhWBaN020lLA1axEzKiJcbmFTR3fJKBwKrWQU4HKKklih3tU2GoJD6IErzceTZ0iZrRUshKhspBLHxRSjFR+u/2lp6TIyGEmxkmeiNceGio4laoBALm8JRHY+fRx8f7KsZFnEHHF4iEBAEK2CEYgWj0qlJmVD0Wb9yuvuD19tRQwhOWpRoQIitQFPb6+sBAGgJka1OCRYiLUnzKNqSAMscaRSw5nMEZDBftOxbPgBKHP9hxrTjgvE7SNDmqrszekDgf7guAMw/cq0sdIQlQMDpymgum5MzXTrDNnznz++efTGlODXHie/+1vfzsl+/pKUFBQMLEW6MaNG/v6+v7xj3/w/PjxhOfA4OBgIjTX7XaTJLl9+/ZkQNNpqa2tlclkTU1NTz31VHLsvnbt2pUrV2EHXlMAACAASURBVFqt6UnZEoCCBjklK1DljWcYACDaVkcVjHIYIEBZcmMT1RjRZFLbwvCV1iW7evZua9+xyrqUwkfucJMxpjULJ/vxmRokT7l+41zMU+yU9/B8k9Zv8dpwW59vwKLMUo0RoEEYjqt08aEB0piLRMTY5IyTDalCrfmO3ojgdQAQ4n4qPKc8xCAkOJiuDlqK4rO0SE4y2QpzWonUTAd7AnU35VbO76HdfqM7wkcQQmrgryladcLe9G7Lthxl9kxDuZLKMJoMZPtIL5WsCEhjMEuLjjiFAO8pMRDcgFzVIPPIhzqY9igVNXJ6nh4TTQ8gATR6IBiXNDTqD0GTV0IAai5P5e/LFpvytSZFxMx2KWKyiMNwUgwNZWeVmbPKEcJAFAS3Hef1gE9qlgVhqHxBYZ+vazwn/Qx9OUcwH7RvX5m7eJFRp2Pg9Tbxu2UY6IO0g8NSZrkdQScCZJhlsO9zkwqC0ZAAEIqH+/wDiGKo7EKfe6AnMGiNU3gwgCOlvE09VOj6V5dwTQ5KFXmWkdxiy2VCWPR1h6RYNHRsV8DJCphOru5hFqzGuPRzTsoJTXnmIOAybUkybBIBmpc1Z2f37hzeknrCl5jQpwPxhT17rypYlbj+EUIyM+NpCwAAweKsnvJ1hVI1dHBDfjy40PXmnzRrfwwAoiQm8upOOBrKtEXJYGYCI+ab5wBAT0Da3Cm23J4hLS9wyvD4OkKKvFHWnWBxcf8Lyqu+iSbUgAWAfN6aLARB41Su0tI81DZDXyEjIFeGTrolGu+qic0aO1CTmZnUOsDyXHaozi/PHd4dmZUfaTke6JmrPHXsre6O5MLOkMsX9eelTMx+PiitsGizFHoYTaAnXVzU3xn2tgU1JZmEpc6Wr7bo9peWsrIyHMcBwOFwdHR05OXlvfvuuyqV6tprryUIoqGh4fPPP+d5vq6ubu7cuSzLut3u7du3B4PBZcuWWSwWALDZbN3d3dnZ2R988MHs2bMxDFOr1QMDA4cOHbrjjjsUCsXx48cPHjxoMplqa2vxU4+tY8eO7d+/v7p6lHI8QuiM5AuOHDmCEEqL08FxfDxTqqKYia2g4LKL4SBpSjeiRqOuV9cVGEcJD0Po8pzLDvQf2dzy4dKchamq/7KcYFFAedIlzdWNilsRCdGb5yLcNNehUJMin8XjdOaZWkKli7d3MH006+L98sinWocPCYoIGBhUrhfdZa4PB4XnWiWegsFQrNLiv1WrLgwVqGKqjJUNUgmf2Ct4h9Srr7GW67pc26LRaHIVBFiVvqxEU1jvbNzS8rFRrivVFJvlhlHbxKWAxadoH3k9ojCYrUNNbnG/16lUtkq0UBAumO2YI3BCBA9GqbAAMBSBuATJOGJHWEIIqjXJk4PCAnhjJKfIU7swtksmopjH0CVITnUwbqleQ9KnnqEYnqiROxkwEtNVK1kdXdJb2JBp0JCgUJ3PkMwnnTsvy5pbwuf2h+CNNvFbxVjY5Oe6R1kge9ARIAPmCrPzuNdYo8I41OnpliQRAAKxYGfcbVXlyuOS4B2K23oxVuayy3OzsZKUN0kSI1ZalzIE7ajzCD5v8OB24AtjlMm4UIXTGYo/IBzpqvlR11AKGlZlkhuTdbuMnE7Hak/aGyq1I5GiFWq0vV/aP2jP45uSCtGybNbbPjweVRZwg3vdylxuxLcMIOauCh15Knj4U272sh5vXzgeDsUjnZ6em0pHKi7N0JcnXrl+XyeuK8HG1iqWRCnhIIy4okJUZA2jh4PQHAv5ZPOvzHhoqRhleo5kk/q9Zdri7V07q/RlCLBZWthvl6o1YqOzZY5pZtqKjIbCGUwIDw/yaBWJERB2RBNZhoTWHD6+x9MwqMjPRwgNhdwJVakEJxyN5bqSZL0aZwS6/NLvFqcPByUpXVxUjIje1mDBzZO9SifJV9sQvtW42e+IRWORL00qwTB/+ctfOI779a9/vWfPnoceeqioqKiysnLHjh1vvvnmyy+/XF9f39XVxbJsQo6ut7f3hhtuuOKKK3ief/jhh1955ZXFixfv3Lnz4YcfVqvVixcv1mq1mzZtam9vV6lU5eXlgUDg6aeffvvtt2+44Ya33nrr6aef/vDDD3Ec//vf//7Tn/70rrvuevvttwcHB2fNmjW2Y9u2bbv//vtT5zzHckYiOAhAxfATWEEAiLTV0QWVaaWRCBbXz1bNF2e/17ptvFQQBGieebZRpv+4c2eFrnSGvjShRhhTRXRK0R3BGj1QMTo5yhcNdAtNymxFQayA61ZLpCTIY1EuMlzySQIsjmMRnPSTZMAYijkdefaD/lihitCeMpn+HD9GildZULESCZK0wKir1BcXqvIwhMWDQnAwEhwMR73xjBL4sabdVLwz6wf30Fo5AMxn537c8WnaMhROVhuqKnVlbe7O/f2H4qJgUWRZFGYNq0kU3ImpIjE+QnpoAIiJgj/m90X8YtzHYvRQVKVk+ZBWcmE2xsuxNk7WrRzkwl4mGGfjyRPMUyg3VblMAkWY1HgY2sUKXCxoDQDl1zhcKmDkcy8H/GweAgSLG+aqSDkBAHOM1R2e7vD4iuHZcvOV+Ss/6vjMG/EvNZUPBNFbHdJNuSHaxqWJ2gRjoTbUwWfxvQfinmKniAsA4I8FOjzdVqVFQcmBBkymBEn0ur3ZA323KbKiQlTCAQAQoKU5i3ScJmwPuw+eiDQdIfJmu7p5TZUCpzMPcLWVSmrCEq9lmuLUApZzTdXvtm4t4PPYU3lvCGCFGf2jQ5STRy2K7ITYLCnDKZ5IyKAQ7HBOobJgZESFMAIqv+X/9L+52csahpoB4KSjMV9lZfDhzfK0coahAgBcEXipSTxyc4ZOhmzRhE/O2x5Kk9imlHjk443q2+4H7PTOLwxh+bw1qbutZdUyguvy9Fr5nBIevdsleaLQONRSbazE04QLEMjMjLd9ZJZbnsv6ukLD6fYIESZrqL0t7Mhm9XRbynAwEAv2+voXZs9NtuwakBYamQpt+rty2B5NzP0m8XYEuSyaGqtncW58tQ3hVYVXHOlsEAQh7dEtgfSfh14MjVejYKrRsKpvz1w73q8DAwN79uzRarV2u91sNm/cuPGmm27avn27Vqt9/PHHAaC2tvZnP/vZd7/7XQBYsGDBI488smPHDgDo6+vbtWtXohjvpk2bDAbD5s2bAaCurm7jxo0NDQ2JdIvly5f/85//vOGGGzZs2PDGG28sWbJEkqTLL788Y2csFsvtt0/kM5hihHjo5D4pEiKzR0VgYyRmmKsiGFwPugLemjpnMpZcpUXHanb17m91d8w3zcpWmCUkhQ2BoqjikEM64UZRQfLHoFARDsdt4XjEoshSUvIohDAT4XaZynEh6o7HI4IgCoIkxIm4SAlRPuKzuqN9LfHByAwALAAxVoaxsjAz5G47CqKonbn0+oLKYnWBhh0R+CA4XJnPKfM5UZCinlgsIEiCJIkSRmA4gwV3vCyKdfofPpmcjMpVZpvlxv5MpYAJjCjRFJZoCodC7h5//3F7vSvilkRJRslwhMskrtxVKQiCJIGCkslJuUluoDAyLkFfEOpckpqCUnUoqokEA1RggKnxqcGFxfhwnI6JuAQggQcAAI/ieJAk/aRISDE+HCr1K5ScgbbIKRmkK1SfAayO1s5UJlMdaIKaZ561szuDZESSRCjpxx07nWHX9db523qI55vEu3VBc2/6tKQkiW6liwvK5e0qX4HTGXX3+Qfy+JykELkE0BHA+mP8DB2i2vtpItdf4I84mqu9oOoT/Iyi95MukVAzs5Y76zFFHpMqg5KKwsrJsk4zU2LlLamjJQUlL1YXHrHVLcwaiXuvVCMJ4IXGmAB7NtRckXgplGezST0wZQE3eMAtz2WxlEFhnMqKOcHZ29DnHwgL4SZXS7LiEgJ0ec6ChNV5rl68zopZZBneTRP6olFfPO6Py2aNjIsRQox3t2DMZkozp0yMpVCdlzSEAFCuKznpbLLyOTiCSjU6OiQtpcJtro5iTbo+XJohlJkZT3MgFhASwatkVn7o2C5fVw2tI1vdIzEK9Y6mInVesrCoNwYNHuk/q4vSDe2YMBkhIgb6w8bL05UBzp2vtiHkCJbCyNiYKLxE9PNItYHzzFgvVCplZWVarRYA9Hq9TCYbHBxMTTGUJGnPnj0ajebAgQMA4PP5jh07lvipqqoqYQUTJDTqAGDv3r04jm/YsCHxdWho6Pjx4zU1NR6PJ2H/EEJXXHFFxrK95eXlk1T6PgMEIdbfLoVDUiSEa02Efjj4W/S6Qsd2YbxWdtlqSBkyIhwZ5vLkKf/eXPOsTm9PPJNsShKO5GrzlvX4+vb1H8YGjug5nYHWFsZLrTLcExVZIsyg0GAgmi3X5ytzE6/GPMN/4bB0BIHIRjUFKQ8gMe6PBQLRYCiOH+dLfDFhhgaBKEihgBDz0Dr3bPNyU1hg/rVFc3spkzW2yi4AAIYjRkMxKWVU/Dv/JXQd1t//f9NcMvPNcza3fJhR+CaBhlVpWNVMfTkARIRoIBoUJCEuxlWM3GA3psnfEAhyZZDFwgk3NHuV1+Vnb7RjV1diViXEg/GQLRoLCbGoIAoCSCCBJFESZgC8CGPlNEvoJyNbOjEIIWWhjC9ML/FTqMpvdXX2+TMXgUrAEszVBSv39h/+oHXrstxFrT7VnwYCP0ScTsowXAsa/bIoRrRwTnVbkSY/GQoUFaHOJZEY1OgQhfGCFBVaurmmWIWBLquaGRoIBtoiRMnluNbsOOylNFjSZZUGrSLVpafx9QIAhrASTdGRwePJlmpDxVuN7w2F3XrZyFx9lRqpKPRyk+0T2/Fvls640YpxJtrVMCzISchwRk0GekKjojoRihlrj+7dLBVl19kb83lr0glXoSsxcDoAiIvwXL24ZXWG8yNExZA9CgC+tqDcOkpim4q3hvb8j+GBM1Ch0rIaFcO7w57E11xlzr7+I0Mht4ZVVWvROx3iUhM66WwaawgpJUnKiZj/1M2LQJ7D+jqCmkoFACTSJX1NXZEcXfJlIirGmt1t1xeNiIfsGpDm6rB5puK0jcf88bBzVFCctz0gz2LSCjtPCV9tQzgBq6xLTr/QBSE1agbDsLRpwMTX22+/PRmHkrRwHDfKO82ybHKVnJycZHTu9773PZPJJIqiKIpJdW9RHPfJO+VEOhvigz0YK0M0E2k6Emk5TpqtsYEuKRygi2eljwUJpJ+tolM8HjKSq9KXHRnMUOYtDYsiK1thcoZcjuDQQMgRY6TsgIVEiCEYLavrC8r8AmZAAAByStYbygkJ0t0l2N+bxTLVSFgNgREqmlfR/EGH1B2RvlOKaEyUQMIRZqhWJ4cI0YJ5zpee5FqOKa9Zlxo/mZH4YLf3w02GH/4eY9Lz9DWsukxbfNIx0Vx0EhqnaPZULLsMQVCCTO9yJIZdlZP14YDqr42QI0NFSgAAgiMUeZO9nWkVqSqWM1pKFCQpLkZc8ZAjEnamT0ONAoHMxPBFMlKWYS8IocWW+e80vZdRBy4JhuELs2va3J1b2z+1KLKuscx4rdl3q6AyjB6YSQDuqOck11QZq5zrrfFpXYm8hagIR4ckPYPyTpkwXKUnCbpAXyxXGoaCAArAFIAEyXnEizCkGsfUkTJCP0eFsEm5AEo1RcdsJ5KvMiRGVusr9w8cuqqgNvVlwCKDByqxJs+JTU2Gp4/pD95EsAY6mXKuzOfshzzyXDZ1p8hY0N+4N5QXaXa13lB0VaJRQclnn6oOv7lLtMphRqakmOBARBKleEAIu2LqqpFRtdDXKHQ+b7j3ScKYM5mjS1Koyjs4cDTxGUOoTFNU72xcbLksm4OoCM4IALh6ff1jZbhlZsbdPOLml+ey/Z87hYgMpzEAYErnhI9/0W2ugFNvjc1DbdkyU7IcmD8Ox13Sk5flyqn0e8ebjPtNHFpYDA5ETIu1p6mAelZ8tQvzXgJgGLZkyZKTJ0/OPUVVVdXEqyxevLihocFkMiVXMRgM2dnZer0+IcojimJSwjQNp9P52WefJT7b7fbk53OBzi1lZy2hS+dQ+ZWyxdfQ+RWiz00XVsmX3ZRmBXESM9SoGG36VFWVviKtAud4IMB0rLZMW3y5ZX5FRaFVa7EqLUZOx1OKQiXWH5SCAogS8gumfXbp1nzMxMIcHfqgO/3OOemWPh2QvlmEyQhEYDiJEaya5swj0UBUXplxw5/iLpvtPx6I9U5YUlUUhjY9xV99F6HLXFpyjmnmJI8uFQlJwRyfNOYZmPDoaBjl1wuwUh6ttpyBQxcAAIGumjct0CT+BQxHOI1zJlpbpcxepstaqtXOUMqzWUpBJH2MlIJQFcmyl+h01XxGK5hATsnmmKrH+zWVApX15tJrOII+1P+B3rizLuTp8A8/22Ji3Bl2N7vabEFHLp8NhXGBjitbNVgMH2sFAZCO01bmL5ArDQDDj0cxJtkPejAC081UZPR24wxmqFFNflTBkayVH2VUilUFANDkStfhJDGoVMN3CvZrmdjGBjG1FBGpICgV6R8d9+HGJUrM6mhsLuDzElcIQmix5bJk/uJfGsTvl2fopyRJ/u4gAHjbg4pcNqniFuvvwLveM/7g/6bdd5OhQJWXerpKtAVd3t6IEAGAEh41uiUAOGY7MXZFWRaTGuyFEUhmZpLZk4TBgunNzgMnE7lIEognHU2pdef3DEozNWhh1hhx0ZiYjIlN4GkJKHI4nDwv4ilfbUMoSVJMGfUVu06/6JeYZ599dtOmTddee+2PfvSjG2+8ce3acd2NCcrLyx977LEFCxZ8//vf//73v19dXf3pp59iGPbMM8+sXbt2/fr1K1euHC95Y8+ePTfddFPi865duzIWSvzxj39cU1Nz7NixJ554oqamZteuXac5gNFaR4Qpl5mxkNBnj42OMcwbNRZMQmLEbGN6TNppkXAI60ZUbSkMrHJ0xCntGOQPOplb8jEFCQCwzIT6gtKrbdKfToq/Piw+Uyf+vUXc0i2tLcTUpwwfQkhToUx7bmKcQrvuEcWq2+zPPeL/fPNwqyhG20+Ifvfwt4DX/c+NmJyXLbxqvH6SGJmIgz9T4lwsqhv16EQIy1dZE+/OJAZrLGh8w5QBhJCuih+bMzfSVY6QZ7PaGUrzYq11tdG6xmhdYzQv1vJFcoI7fUJFua7EKEsPf88IhZFzTNU3lV5l4pRu9WfuYP1RW1Odo6nB2eKL+AycrkRdSOIyb0yyGb0eeVjeqO3soYzssBVECFMxfIm20KLIwlOyG8PO6OBeF60mNFUKyDTgw2nMWKNO5vlNklSVGQBACC4z1xweqAvGM0Qh+KL+23N2PXEoElZQqTviCzhf+0hJCgnAEXQKciXbp5mlHn73LdEUJRPMW73SIYd0a36GR3TEGYv64jG/EHZERyoAS6LY9pnxzrWE9mwiKuWUzJAiT8jgjJXPaXC2AEAZjxo9EgAMBGz2oCNtRYLFGc2om1ph5QK9I0cazC0QwwJqdABAu6dHTnFabnh4GBLgsFO6xqo1ydIrrfq7R5XviPniYWdUbj3jF8pJ8tWeGiVVuK/QHY+eX/Wds+CHP/xhQgRy6dKlJSUlyfbt27cnStJv2LAhqZVXVFR05MiRvXv39vX13XLLLYmk9ZUrV86YMSO54pNPPqlQKFK3f8stt+zfvx/DsJ/+9KcJ5e5bbrll9uzZBw8eXL9+vVarDYeH36cEQfB6vXK5HMOwyy+//KOPPkq0Hzly5O67M1QKvffee++4447k16KiIgCIRqNjRXuHmcQrGqOldNX8BK/hRer8emdTaoD1ZAgbwoxDlih9DgDZMlDR+FyjmU3JPSYwuK0AGwxJJhbTMeCNgTMMKmpUdVO5haWUme8FrmYllVfu/K//E22to/Ir/J++gyhacDtwlQ7RTHygmy6pVn/9QZgw1DZfZW12tSWqzZ0RgSw/4ScTpTAAoUTk5FnPe6tK5bLs81gHFAFabFmwufn9iSdIkzA4U6Uvl3SSvJ63D2HdfjDJyFw5wgD6Q9DmlRgCiRKBKKHI7J9vU0mYQMiA4zmeVqQFVsR8cW97MOqJq8vl40XH0GpSX83jzBkLUZlkBh2ncQRHBJNVtLJUW7S39+AKa4aoNFKyLdXufuLIksctbHLakFQQjJbydYSUhRwA2AL2iBDpl0KmMKltVQYqIxzFzTOPRHr/tUFcV4JlDHf1dgQAwNMaUOSzydyPeH8rb/IzRWf8QpmkUJU3mCIiU6kre7/t40pdWZ4Cf7MdgnHgCDhmO7kqb2naivIsNtWZhzMYraP9PSGFlQMAV8RDmnLpxjqPsrUu2Dwn5ZV354BUoUJLLBVpG5REyds1yivgbg4oC7lEtJHg7I/bwkRWPkwdU2AIbTbbK6+8sm/fPlEUV6xYcffdd5Nkuk9l48aNra3D80t6vf6hhx469/0CTOoRfFHIyRmeS+F5PjVlPpnSkFwgAU3TS5eOurzUarVaPRKpkVrHKoHFYklkHKZSWFhYWDjKoa1Wq3EcX7Nmzf/8z//k5eWpVKrZs4erVOv1+lSDl7qRsY2vv/76f/7nf2YUAVfkcnILGxwYEVhKBacxhZVT5qeHV6SBIWxR9rz3WrZJZ+IAkHAxZAgOl3sFQADFKj07Ro3XxIKJHd67moI04WKMxPjiiTS4CZ3Z8O//r2fz85G2Os03f0LllYMoRntapEiIKqhEk0s/WGyZ/07T+1Ehc0WOccEkv9WrbNQgCUwyg2pMze7Jo8yXKfPSc6KnHJ5WzDXP+qL3wORXQQhFLWFLRKVnodUL++2SjEBhAdZYLQW8OplkKZVIvp6QvyEkyJGfD5NyAuFICAnxkBCyR0ECmYXRVCkzJvLgFCbPYVVF8rN+YlTqyj7t2p3aUq0v39yytdXVXqjO8ES+3DD4/53cudayWIdGXFrKIs72hUuew0Sw6EBg0BP1RcRoLp8lNvfSlGrx6vnJQMqIAP/VLO4aU4MXhkNIYlFPPOqJaWecCtMTBaz9HfV3M9S1mDx5vHVv/yFBHPYT87TCwOlaXG1l2uICJWrySLO0qNvb6w570q5D1khh9Sj19lfmsfZDHpmFjUEsEA8hkmbMVa1N7yF9xKIY9iD0B+H4kPTjmcpEoZJUgoORZHoiAISd0XhQlJ/y30fq9kjzl5/LkY5lCgzhe++9d/DgwauvvpogiF/96lfHjx8fKxv26quvFhcXz5kzBwASJXynuTAsXLhw9+7dGX9av3795Ldz55133nnnnRl/wilMW6XUVChCjmjUHYsF4vGwSDAYzuCsjmJ01CQTE/WcrlRbNEFqdkbC+iDjGC6oS+FUWvWJyaAukZ/WY4RISnXzvSPfMYzKLRl/8QzISNmi7Hk7uk43zzwGgY2Hsn1Zjpyx00eTh9XTqpKJjP0UUqYp7vL09PkzqLmOR0wZjSkjtJeuUMFQBHljcJXVqmVHBWMjAinzOKWVC9kjUV88ZItIgoQzGM7i2pnK5IAe4YjkcJzBcRrDSIQRGK0iaQ15RtmxY8njcw9QRwPRkal4DMOXWhd92Lpdx+n4MZKzMgJuzB24c8fWP2fNy4sMX10Ei3NmxtMetOkHBEns9fVbFFkEJRdxUn+khzV0wdLhUJRHDggLDdjYGrxwKoTE3RJQFspGrP7QSUWunMo9Jw1nmqByldntKTJyMw3lO7p2l2oLS3lU74ZZWpBAOmo7sSx31AsxRmCsgU516ZEKgtaQ/q6QT+cZFnog6Tgqqgi4ou0nqfwKUYJ/dYm12Wi+uTQtC1mSJG9bSiE/UXI3BVTFXGKuO27vQSRNWqdGrTrJFBjCu+++OznDplKpvvnNb2bUz7ziiituueWWc9/dNF9OEIY4A80ZJivklpEa86wub0/wjBJAMSlkDsg6FQCQrTBPnNo/FponZZbzOFuYSr7K2uPrb3FNVGs6I0qrrNxQGOo9w9HkKUg5oatO94CePxBCl1su29y69YwSeQNZAZWPBgm0DKoxWjOqmQMAIGANNDvOZUYwuKFGRcqn3uODIaxcW3yg/0hqo5rmZ5uqPuvefU3BFdgYIdYKFSIx/6NNe35Cl1Vq1Ikrk8ujBvd4omx0IGbjCFZJyQFArc7K1Zb0v/cJqdUrKgv+0iBu6ZYyDgfjYSHYFw7Zo0JYkJtpABADHqG/ge19hb///5z7YRaq8lMNoY7Vykiu3dNTzOdu6RZjIiIxaHd3ztCXp+bXAoAsi0mLbeGLZINfuNyMJxGI4o54ZILcmHuN6+RbhMm6y8PJSZhvYMamZITs0ahvZGrd2xnGaSypaxrtaCDz0qdSz50pDpbp6upK+MDG8vLLL69fv/4Pf/jDBFV5LxmeeuqpidW0PR7PunXrqqqqfve7352PDjz//PM/+9nPAGDnzp2VlZVVVVVtbZN6/sZisS1btvzsZz974IEHXnzxxVhs2P/6wgsvVFVVpbotzwckRi7IOuMSXRF1SGDjSlrBT5jQORaEkLo8c2zheWJB1lwtqzn9cinoOe2VBSv0VSqZ6WwMdkICJoNg8/lERslWWZeMzY+eAJGNh7UhAMiSm8e1ghNCKQjTQs35sIIJSjVFJJ7u9CnVFMkp+b6BIxlXKVbCspLw1sGu4/aGHl9fh6er3tsUNPiYLrk77E4IajMEY+VzcKWWLpvXvWnbuweGfnNYfH8Nrh5j6yVRchzxCDHR3eBXl8sBQ5GmI6H9H6qzfKYN/99ZRIqOJVuRxY6OcJ6hL6+zn2QwyOKgziUBgATSocFjaSumSo0nIFgc0wE5wACABDDgt5lkRplLT+dV+E7s/8ImXZuDzdBXkGNyW1OHg0JY9HUG1eXDgcKizy0GvPgYscZzZ7IXTcbaBTqdLjWCo6en55FHHhmrvg0AK1asUCgUDMO88sorGzdu3L9//3jql4IgrFy5Mvl14gr1gWAgGo3Go5PyzF9IZsyYMdZRmspf//rXQCDw2WefJbMDpxa3nIC6KgAAIABJREFU2+1wOADA5/PxPD/e7OhY9u3b99hjj33ta1/Ly8v7wx/+8M9//vOdd94BgG9/+9vXXXddxorKE8XRnDlaXG2V5TS7JsxYGIPX6C51laSXUz8dsmwmRkRi/vOubZ/KYv38Hb27HCHn6RcFUNH8Qv28SDASgQhdgAUDUsQZE09x2tVxGlNVsGEhBFP2/0wWFpjZmhl7BvaPp583lpjWpfcbeEJxpv8jABAsLqtgQ7EgnM/IOQtjbnS1CIIAAEmB3/mG2Vu7dhwbPFmmziBnamGgSxXsD2DxuC3R4lIO8TZtqVQGYhzH8RxZdjwWBwDQZgVtg9KbH75yw5VaiR57S3magkFbxNcWJpQ4JodQV5Mw0Gm462Y6hw8BwBTdg2ba0BAYcU8YaB0OeJOjeYUx7/VODBPFcl5qdbQXcFbDaDcEroNg66g/zq11cQ3KoMbnEJ0ERnA4AwGgVTPs3n9eldWlIQostDnt0RF1xX22EUPoOhHkLJSIC9GoAACxthN4dlE0FrtoFeqvvDKDeOuvfvWrb3zjG4nPNpvtyiuvfPDBB6+77rqxS/7iF79IfLj77rtLS0v/+c9/jif0hWHYz3/+8+TXgoKCtDK/kFKhPoCCFEVhX76YGYvFkjj1fX19jY2NZWVlb7/9tlqtvuWWWyiKOnTo0Pbt2xUKxccff7x8+XKWZW0220cffeTz+WpraxNxMT09Pa2trfn5+Zs3b54/f74gCHq9vre398CBA9/97ncVCsXevXsTotvXXXdd0uju27fviy++SIbDnAWXXXZZQuMGAFavXl1QUOBwOHS6iRxvFEWN/Y/OhWWyRf6WgDM0dPpFT1Fjrc5y6r0dZzDZQCkI0yzNeILL5w85wPWKNR91fjaQSXotFbPcuDz3coYYGRooFilcDT53u18UxdPf2wxumKeaIPPvfDNDXiGRUjJN+7QY1Pqa7CrXiTN+oCMMmearp1x/cizz6Dldwd5oPAophpACqjZv+Za2bTyjtPLpcR8AYM6L9B1VmDgMAESQur29MVM8dyA/ZPAW6kaUxvwx+B9s7lpqu2L/fj82X1OuoJSnjkgCf28obpNQDA8PxEyL1BAcirQcy/r61ZryzHWwz5oZeEWbvzO1ZX7W7E+7d99YUvDNIvzlFoThaIYGNfpaCgx5qYuxxVy015HU4A3EghE8jOkI+YCqTt5YqLImzliwS3NEfdmywV3zlt6gUqbHi9jqXcnUr0B/GCKSukCe8A5KkXDE0cctvR5o8qJVqG/ORNIKOp3O2tra2267LTEdNwEURRUWFg4MjOtIT8iDJRkbLfmV4MUXX9y0aRMAHDx48J577rnnnnvsdvtzzz2XyBHs7Oy02Wx9fX0HDx70+XyHDx9OmJ/e3t7ly5dv374dAPbu3fvtb3/761//el9f39DQ0DPPPHPLLbf8/ve/dzgcwWDwJz/5yfr164eGhl577bXly5fH43EA+Nvf/va1r33N4/E888wzL730UsaOvf/++2kBq2mkXl4ej4ckSZnsAgVZJMERvjx3MYVPVMcqlXyVtVJXpiqRTyygnApGTFR24HxD4uTq/BUz9BUT1LIo0xZfmb8y1QoCACBQlyvUlXLsdD3nTLRpkeYiWsEEMw2VY6sWZMQo01+Zv1xh4Rj1ZP/3JOpS+QWwggAgI7liTYYnkpziVlqX7Ok90O3LoGtYrJVaqFAwDnFJaHW10zgl18gEPqq3G5JWMC7Cq23iXAOunbcsZuvxHTvRv3uoZ4fdWee1H3Z3f2J31nklEYaOe1WFHCaGQ0c+M145XzNnKlMIEmhYdZr/T8/pdKy23tFoYOFbxdhHfdIRpzQQsKV5u3EKS5WkSMx5hAwBCKHceE5CpjwqQqcbrVLl8yqz+Wj6fHJwMBI6lYYRD8bdjQH1zJF80EjrMSq7AJHnFIUwHlNwn7jd7jVr1tTW1v7yl79MbT948ODQ0FBtbW0kEvF6vQnZzKNHj37xxRe/+c1vzn2/AEDhdObgCAla3uiNhy6QzBitIfOvGzeJ1eFwbNq0SaVS/eAHP9Dr9aFQKE10e8WKFY8//vi6desAoKam5rHHHtu5cycA2O32/fv3azQaAHjxxRfz8/PffvttADh69OimTZuampoSJqq2tvYf//jHzTff/PDDD2/evHnBggUAsGzZsoydKSwsvO+++yZzULFY7IEHHnjooYfO0+TtxChpxQrr4m3tn06g0plAw6oWWy5DCAEC7QzlwBeujHUh0lCXK86fM2kyYAirMc+yKLP29R1KHfsiQDnK7DJt8VgtqySyLIbksUi/6O9OL9UGAASLq4rlp5WTvmBUG6oQoEODxyaYIzXLjavyliXcRZpKRf/uocn8iQlYAz2eoOj5YKa+4qStcWySj47VrMpbsqNrl0M9NMswI9XvjCGQW8K9nURc6OIphVluxDHcVKnzHgwFesOybKbRI23tlfLl6HIjAqC4uSuCe7diDAd6S2rBP1e9j+BwWRYZ2LtVPceqv2LeeTrGMk3x7t59qS1zjdXvtm4r0RTqGPquYuy/m8W4BBR+yCw3pdYpVFplgd4wAESESEK5NCSEupX9M1wzPHpHDJPq3ZKJRWaPrHz+uuDf/x/FgjUJPVIAEGPi0Mnh+saSCM6jPr6Io07dpGLQFxvolC+5HgBIfurv3CnY4saNGw8cONDa2vrCCy8kWvr7+2mafvvtt48dO1ZbW+t2uwsLC4uKiiiKamho+PnPf554WJ87aoZfU7BqW8v29B8QaGcoU4sjn1cmFt0oKytLZIxoNBqFQjFWdHvfvn0Mw2zZsgUAAoFAXd2w6mZlZWXCCiZYsmRYPTWRspmM1O3q6jpx4sT8+fP9fn+ygvyKFSt6enrGdqakpOThhx8+7REJgvCtb32L5/mpV+ieNFly87LcRZ927Z7AFvK0YqV1adLfTilJ7Qyl87h3gscoQkhToUiVv7qImGSG64vX+KOBXl8fAHAkp2FUsjGii2PBGVxTLuMLZWFnNDIUiwXjcKokLGemJ6miecGYaajUc7o9vftTK7knIDFypqGiUl+WjKwh5YSqWO5q9E1my6Sc0M3kL2S4k4ySFanym90ZQs/0nPbaotWfdu3a0rYtn7fm8tkkRkSEqDvs9aL2XjG7gik2cBqEUB6fw1EsWU3Z9ru3efF+wK/JwQpOhVtgrJydsyx4YDtbdRlhGJ6/CfSEop644TJV6Nhnimw867arx3ZgqihU5x0cPBKJjzj8FLS8SJ23t/fg0txFGhrWlWAvNYs0HjFw+2rzlycXo5QErSIj7li/f1CSJAmkHl+fWqOKC1GyX/4F7dUxKF8BclKmdFmZ+Vd7t7ykvuPBxLquJr8QGb7T3Q1+QobLLSM3aaTpCJ1XgUgaI5CqdOrnqKbAED7wwAP33HNPakuigusjjzyS8CobjcbBwcHm5mZBEIqLixPFg6YKo0x/dWHt2Bkm9ThVpy88qVEzCKGx78UYhn3nO99JqMMkviY+pA3FkuFFGIbl5eX99Kc/Tf6UiGERBCEpup2YLD07RFH8zne+43Q6//Wvf00c8nO+yeNzY9mx3b37xEyDiSy5aXnu5TQxaiZNZmYwAtkPezLaQoQh3UyeM52X2ZWzRk7JSrXp0vuTAacwmZmZQDLty4NZbryx5Op6Z3OPt9cWdIiSqGU1WXJTha40ffoXQJHHRr2xpGL1eGAkZpijSq1tdGGo0pW3ejoy/sQS9OqCFT2+vi5Pb529Pi7FaZxWULIC3tqhK8p1awwAZrlJSQ2XLXRkycp7vdcuUqedA1ypldWsCh78hI7HCENOsHPI3QEqfV/ogI3jhiz33H9eD5DAiCJVQWphJgCYY5y5uXVrq7ujUJWnouDWfOy1NrFc1dc01FqSkgKhyONc+wfcES8ADATsGMK0rGbA4NO3aKv1cUYRQgjlKLKjnjhor5IObpD3tJKWwrAzmhz7etuDUXdMP38kZ1/wOAW3nZ2xCAD4QjnOfCmrTzAMkzEENLV4gkwmy1gndkqQkdxp64Z/aUEILV++/OjRo8kky1DoNNlXS5Ys2bBhg1arTYwsJUmKRCIURWVlZX3wwQdXX311PB5/77335s6dO3Zdm812+PDh1atXA0BfX9+BAweuv/761AUkSVq/fn1ra+v7779/RnXtzxPFmkK9TLe/73CPry/ZSOFUhbak2jgDyzQUYPW0oUY1dMIXC4x6G2A01AVzJk0zFgxhlbrSSl2pIAmSJE1QEwohpKlSxgLxqHfc9zmEIf0sfjIKqFOOnJJV6cpPDDVk/BUBylFk5yjSY1hMCqF7VzzqVVXqh0PPfDHYGqa+mSPZ97l1c/hEDb8kmFLNza8NHvjYe6I/jPJ5g5NUyRQzqoyrKiYpZnQuJEqmpM4A4xi+LHfRh63bDaxOQcuzODBz6KBDorD9DE7nnooSkhmZPrEPJMkfCzpDrlJNYViAY15hhnUot1vjZ0W1WZl49Yn6AUq+3f/Ge+Rld0a9w8G+/q5woDdsmK/CCAxEMTbQKTgH4o4+umQW4DilIBRWNhKd+jDvr7bW6KXBs88+e+ONN37++efFxcUdHR1qtfq1116bYPmSkpInn3xy8eLFK1aswDBs7969zz333MqVK//4xz+uW7fummuuaWhoGE++Z9++fXfddZfT6QSAvXv3PvDAA2mG8KOPPvrzn/9cXl6+fPnyRMvLL79cVlY2dlMXDBXN1+YvtwcdzpDLG/FyJJcxoysVRkOZL9cEByL+3hCGIUQizsicY7L/NFMFjvDTvrhiONLPUTmOeCPuDKkUOI3pZ/MZBdwvDFW6si5/jy96BgGuchJqqoW+essLTWJtNlaggK290lwdMmWxAQ7ZDri1lYp0lVRCHtNdEXPHTHNVOJNF86RhvvrCRHgpaYVFmdXtHRX7o6b5mYaKz3r2rM5fQWDECjPa1CLO0Yrbuz5faV2So8yOibE2V0e/to8dUnR5u3OV2YCI404pT44UnODLcyvbNWoND8kYc22p70QD2z2Q8BR620P+nuBwbRBBCB7eAZJEmHK5wiqMUyAMaaqU52naP8NM3UUkHo+zLJtM4h4PSZKCwWAymjESifA8n9SY/jIwODiIEDIYDB6PZ2BgoLR0WBDoyJEj5eXlNE13d3cTBGE2DwdExOPxo0eP9vb2WiyWWbNmYRjmcrnsdntSsLutrU2hUKTW6bXb7UeOHJEkaebMmcn0vt7e3sOHD1dWVnIcFw6HrVbrli1bHn/88c2bN+v1ehzH/X5/b29voj+PPfYYhmFpIU4ej6elZVR9mfLyco7jAoFAR0fHzJkzE9PdSR599FGappPpMdNcAGKxmCAIX4bx+nlHAk9rwNMaSH1M0SpSP0t1PubHJkkkEkEI2cKObR07Jr8WQuiK3GXoKHW0N/5pv4QhiIhwXzlGYgAA4aGoq96P4UhhZTEKkwQp6o75+8IyM6Ms5DACwyjMvFBzpnUzzoU+f/+HbenhFxJIu3v2eyK+K/KXUhj5RruULYNFBoQjXMdp7EGHKEkxId7zhS1LMptlxuMuiSNQoQIAAEN4Pmb1nYjIzDRfNCyZFu1qijv66IqlQ3VeSQJtlRJnMRDiwUM7EM2yMxYl5ex1M/lECFg4HCYIYmrTJ6YN4SXOvn37HnnkEQB4/vnnc3NzU3/6r//6r5tuuilVE3wCXn/99Y0bN+I4nlbpcNoQXnj+FxlCAACIB4XwUDTqiWEUxpmYySfJnCcShpCiqO2dOzs83ZNca7Zp5ixDlb835DzulQDq3ZKSRJbRYR8hezTQE5IEQAQiOFxhZXAaBwCEkH6uih2nqsb5472WrbYxdZckkPb1H7IHnLV5y71x6qVm8d/KhkueAUBcFLZ17MiWspd5l3qi0OiR5usRAkAI5ausSkohxCRXnTceEhktSSoIMSYGmroFXKPIkynyWYhGYoOdse5mXKVnKi9L7lSZL1OfKrM8bQiHmTaEXx6mDeGF53+bIfyykTSEESH6bvOH3ujpA1wLVHlLcxYihCRR6vvcGQ8Kp10lFbmF1VZNZYzhJOn3D37Q9nHGnw4PHm8aaqnUlbnF4mNObF0JxhEwELAdGjiupGWLsxcoOpUnWugsDhlZQAhlK7J0SXFBCcKuWNQTj/vjgCNCsuPBTlJvjNt6BJ+LMFhIc15qmWt5NqupGpFCPB+GcNpHOM0000xzNtA4dUX+sndbtk5cXUvHahZb5iee4whDqhK544hn8nshWDw5GLrAmOXGLLkpYyGR2cYZBSrr4cHjA4F31Zji1UZGTXoRSOW6khJNIQI4qvIFcWIWS5A4lcdbZGTK4BcBoyEZzalRpMgGD7SIAS9VUElojJAqX45AXaq4AOXDpg3hNNNMM81ZwtPKpTkLP+74bLw6mnpOd0XestQQWZmJCRrCQdukQh8RQppK5bAj8WIwxzSzryWzEBhPK5fnLg7EAv5ocPdAaCBMLTIbitXD0SwfDQhXz4gYXCYTZziN/DqGc/NrxzYzGkpVLKfVFyLMe9oQTjPNNNOcPTnK7FV5Sz/r3jN2XJglN6/MWzK2wIKmUhl2OcXY6RU/5DnMhXcNpqLndHl8zgSuUBkpk5Gymwqhww87B8SPehFNqF1xtVFmfmRFTqg3PHTCN54DDiMQq6dpFUnKCSEiRn0xMSoBBjiFcUZ6RGr1/DMFhjAWi6UqiMvl8oxZ2H6/v729PT8//9wFmvfs2fPCCy/87W9/O8ftTDPNV5FXX321u7s7VZt+mgvJc889R9P0vfeOFGrOUWZfV7T6487PErpiAMAQTKmmaJaxKqMGJE5jqhL50Il0nZ00aJ5Ul118YZBF2Zc5QkP+lKLEGcmXo9r5xTw3EyFGSyMdAzgCuYXFacxx1JNavz4Bo6E0lcrU7EkZTMrt/dvf/raiomK8sg1nxxQYwg8//PCmm25K1mN67bXXamvTx7lvv/329773vfz8/Pb29r/97W833njjuezR4XD09/efyxammeary+Dg4ASy9dOcb2w2W0I8KxUlrbih+GpPxJOwhVY+Z+Ia0XILE3XH/L3jqmdgJKabxX8Z1PJoglqRe/l7rdsmEDtUUoqluYv0nHbsT6yeNi3UOOu8UU9cEiVAwGgoeTbDmZmz08YbHBxMTSSbEqZmanT+/Pm7du0a79dIJPL9739/06ZNq1ev/uCDD+66666rr746WWvj3EEIxePx2267bao2OM3ERKPReDyeUA6qq6u78847L3aPppnm4oMhpGZUaiazlkUaCCFNlUISpYxKcghHumrlhcwanBgdp51nnr2372DGX8fWC0uDlBGmyzSSKMX8cZzBceqiuTzHY8p8hENDQwqFIuOk6EcffSSTyRKyXmvWrGFZ9pNPPlmzZs1U7ZqiqPfff9/tdk/VBqeZmO3bt9fV1d11110AcNttty1duvRi92iaab56IIS0M5SSBMGBUbaQ4HD9LP5CesgmQ4WuVEZyu3v3h+MjvSUxolRbPNdUPfHwNwHC0JftoJJMjSE8cOBAVVWVy+W69tprN27cmKbv1dnZWVg4ospaUFDQ0dEx3qYkSXr55ZeTX/V6/diqsK2trR6P5+DBkdcTjUaTWqhhmvPKiRMn5HJ5slRkd3d3d/dk04qnOXd6enrsdnvq9T/NhaS/v5+iqCk8/xKHBBuSAoAYQBzgjDjQfPq1LgpWwdQS6oxLMQBQEkoLbcb6xMN9hy9kH+x2e1dX1+TPf3Z2dlJ7azwmlVDf2Nj41FNPjW1/4oknsrKynE4nQRA8zzudzptuuqm8vPwvf/lL6mJPPfXUjh073nvvvcTXa6+9dvny5T/+8Y/HblCSJJZlk6WfAUClUhkMhrTFwuGw1+sd2z7NhSEQCIRCoYnL1k9z/vD5fLFYbPrN72LhdrsRQpOUZJpmynE6nTRNTz7o8o477vjJT34y8TKTGhHyPH/55ZePbU94ibTaYQepVqv98Y9//OCDD6YtZjQaXS5X8uvQ0NB49hkhNC0QM80000wzzYVkUobQZDIl6qefloGBgbHlBmfPnn306NFQKMSybDAYPHr06Jw5c860o9NMM80000xzPpgCrdE//OEPKpUqNze3vr7+scce+81vfvNv//ZvAHDrrbdeeeWV3/3udwFg1apVZrP5vvvu+9Of/mS327du3ToFfZ9mmmmmmWaac2YKgmVyc3Nfe+01h8NhNBpfeOGF6667LtE+f/78ROVYAHjjjTeeeOKJxx9/vKqq6o9//OO573SaaaaZZppppoQvV/WJaaaZZpppprnAfOkSG6eZZpppppnmQvLVM4Rvv/32nDlzcnNzH3jggUhkUgru05wLzc3NtSm8//77ifZoNPrDH/7QarXOmjXr9ddfv7idvMRwOp2/+c1vbr755tra2tTynOFweP369bm5uXPmzHnnnXeS7bt27Vq4cGFOTs7atWuHhoYuRpcvKXp7e3/5y1/eeOON119/fWr7gw8+mLwRvve97yXbt27dOm/evJycnHvuuSdVeHmas+OLL7649dZbi4qKKioqHnrooUBgWOY0Ho9v2LAhLy9v5syZqenmR44cWbZsWU5Ozs0339zX13c2u5S+UrS0tCgUig8++KC3t3fp0qW/+MUvLnaPLn0OHjxoNpsPnMJutyfan3jiiQULFnR3d3/88cdKpbK+vv7i9vNSoqmp6f7773/yyScBIBwOJ9sffvjhpUuX9vb2fvDBBwqFoq2tTZIkr9er0WhefPFFm832jW9844477rh4Hb9EOHTo0L//+78/+uijcrk8tX3JkiX/8R//kbgRTpw4kWgcGBhQKBRvvfVWf3//Nddcc//991+MLl9SvPTSS3/961+bm5uPHz8+b968++67L9H+9NNPz549u7Ozc+fOnSqV6tChQ5IkRaNRi8XyzDPP2O32e++998orrzyLPX7FDOHPf/7zr3/964nPH3/8scFgEEXx4nbpkufgwYN5eXlj2y0Wy5YtWxKf161b99BDD13Yfl36tLa2phpCQRD0ev327dsTX2+//fZHH31UkqTnn39+3rx5icaOjg6KohwOx8Xo76XG/v37xxrCd955J22xp556avXq1YnPhw4dUigUoVDoAnXxfwF///vfZ86cmfhcUlLy5ptvJj7fd999CQP5zjvvFBQUJBqHhoYoimptbT3TvXzFpkZPnjw5e/bsxOc5c+bYbDan03lxu/S/AbvdvmjRolWrVv3+979PzNT5fL6enp5kPujs2bPr6+svah8vfRwOh91uH3vOT548mWy0Wq0KhaKlpeWi9fJS59FHH12wYMHdd9+dPMknT56cO3du4nN1dXUwGOzp6bl4HbzU+Pzzz6urqwEgFou1tLRMfP2r1Wqr1drQ0HCme/mKFeZ1Op3JhH2lUokQstvt01pf5xWj0bhx48aKiorOzs4NGzb09vY+/fTTDocDAJL/hUqlstlsF7Wblz4OhwMhlKx3ljznTqcz9RZQqVR2u/3idPFSZ/369Tk5OSRJvvjii0uWLKmrq9NqtU6ns6SkJLEAhmEKhcJutxcVFV3crl4abN68+c033zx8+DAADA0NiaKYfObwPJ+8/pM3BZzt9f8VM4Rqtdrn8yU++3w+SZKmFRfPN9nZ2XfccQcAVFdXMwyzdu3ap59+OnHafT4fy7IA4PF4kkp705wnNBqNJEl+vz9x2yfPuVqtTg3QSLgML1ovL2mSxWBramp27NjxwQcfrF27NvX8J/6g6fM/JXz88cff+c533n333ZycHABQq9UIIZ/Pl7jsvV5v8vrv6upKrnV21/9XbGq0sLAwOeytr6/neX7KKzROMwE8zydcVjzP63S65HRoQ0NDaoGRac4Her0+EZSU+Jo854WFhclGm83mcrmShUGmOU8ghJRKZUIYubCw8OTJk4n2pqYmHMctFstF7d2lwGefffaNb3zjzTffXLBgQaKFoqicnJzkpV5fXz/2+g8EAp2dnWczHJ8Cb+YF5PDhwyqVqqGhIRaL3XzzzevXr7/YPbr02bNnT2dnpyRJfX19tbW1t9xyS6L9wQcfvOaaayKRSEtLi1ar3bdv30Xt5iWFKIqtra07duxI3PDt7e2J9nvvvfdrX/taLBarr69XqVTHjh2TJMlut8vl8k8//VQQhIceemjNmjUXs+uXBLFYrLW19Z133uE4rrW1taurS5Ikt9v9ySefRCKRWCz2wgsvcBzX0tIiSVJbW5tcLv//2TvP+Diqq+GfKTvbu1ZadVldsrFckI2NbYxtiHGMKTbdSSDw5iENXpyQ8ibwC8QEkgfyJCHUhCSU8IQECATiBGKDe7esYlm9ayVtr7O7U+/7YcR6vVrJsizjNv9Pu3dvOXdm9p65955z7pEjR3ie/+pXv3rXXXeda/EvePbs2WM0Gn/3u991dXV1dXX19vZK6T/+8Y9XrlwZj8f7+vrsdvv27dsRQjRNm83m999/XxTFzZs3JwzHTosLTBEihH7zm99YLBa9Xr927Vq/33+uxbn4+e1vf2uz2ZRKpclk+tKXvpRwnwgGgzfeeKNerzebzc8888y5FfIiIxqNFicxZ84cKd3n861Zs0av11ut1t/+9reJ/G+//bbdbtfr9YsXL06MGjJTZmhoKPn6L1++HCHkdDpnzZqlUCg0Gk1NTU3CZBoh9Mc//jEjI0Ov169cuXJkZOTcCX6R8NhjjyVf/8svv1xKj0Qit9xyi16vN5lMTzzxRCL/Rx99VFBQoNfr586de/z48Sm0eKGGWON5niQvsA3OC5rxLrh8Iz5/5HtxbpGv/7nlbFz/C1URysjIyMjITAsXmLGMjIyMjIzM9CIrQhkZGRmZSxpZEcrIyMjIXNLIilBGRkZG5pJGVoQyMjIyMpc0siKUkZGRkbmkkRWhjIyMjMwljawIZWRkZGQuaWRFKCMjIyNzSSMrQhkZGRmZSxpZEcrIyMjxrkvCAAAgAElEQVTIXNLIilBGRkZG5pJGVoQyMjIyMpc08qEhMtPPxx9/HIvFVq5cqdPpUn7q7e1taGjIz8+fN2+elDI8PLx7924AMJlM11xzzdjaGhoa2tvbAaCiomL27NlpM+zcudPhcLAsm5mZuWjRoiVLlhAEcUo5EUIrVqxgGGb37t04ftJL4Z49e7Zt2xYMBgsLC9evX5+bmzu5rgPP81u2bDl06FA8Hp85c+bNN99sMBhSMvz9738fWxDDsA0bNkyylbEwDNPY2Njb2wsAN99883jdD4VC7777bnNzs1KpXLBgwZo1ayZ/co3D4XjnnXf6+vqMRuPKlSuvvPLKKUsr0dXV1dTUxHHcvHnzpNPGx4IQ2r59+44dO8LhcGlp6fr16zMzM9PmbGxs/PDDD71er91uv/HGG8vKytJmGxgYeOeddwYGBkwm07XXXrtw4cLkX0VRvOKKK4xG48cff4xh2Bl2UOaC4cwPUZSRSSEvLw8A0p6Q+cILLwDAxo0bEyn//Oc/pUdRoVC4XK6xRebMmSNlePjhh1N+OnLkyOLFi8c+1Xl5eX/4wx9OKecbb7wBAH/5y1+SExmGueWWW5JrU6vVr7766mQ6PjQ0NH/+/OSy2dnZ+/btS84TiUTS/hMJgphME2N56aWX5s6dq1AoElXRNJ025969e7Ozs5MbnT9//tDQ0GRa+dOf/qRWq5PL3nrrrSzLTkHg1tbWVatWmc3mRFUvvPBC2pyRSGT16tXJjRoMhr///e8p2URRfPDBB5P1FkmSTz755NgKX375ZaVSmVzhxo0bOY5LzvPqq68CwF//+tcpdE3mAkVWhDLTzxQUoUajAYBf/epXKfnr6+sTv6Yowq1bt2q1WgBYtWrVW2+91dLS0t3dvWPHjh/96EdWq9VqtU4sJMdxhYWF5eXlgiAkpz/wwAMAcMUVVxw+fNjtdr/55psGg4EkyT179kxcoSiKkla+6667Ojs7h4aGNm/ejON4RkZGsoKXFGFOTs5LJ/Pyyy9PXP943HPPPRiGlZaW3nbbbdK8Nq0idDqdGRkZOI5v3rx5aGios7PzrrvuAoDFixeLojhxE7t37yZJ0mAwvPnmm263+/Dhw1dccQUAPPjgg1MQ+JNPPgEAs9m8atWqysrKCRThxo0bAWDlypWNjY0ul+v3v/+9SqVSqVTHjh1LzvbLX/4SAMrLy3fs2OH1erds2SLp+7feeis527Zt23AcN5vNf/3rX91u98GDB6W3lu9///vJ2XieLyoqKi0tTXkwZC5iZEUoM/1MQRGuXr3aZrPNnTs3Jf+DDz4o5U9RhMPDwxkZGQDw2GOPjW0lEAh87Wtfm1jId999FwB++tOfJif29vYqFAqDweB0OhOJf/jDHwBg+fLlE1coLXjOnTuX5/lE4v333w8A3/ve9xIpkiKcOXPmxLVNno6ODr/fL32W1jnTKsKHH34YAP7rv/4rkcLzvLRA/d57703cxPLlywEgeZLtdDqNRqNCoejr6ztdgX0+X1dXl/T5q1/96niKsLGxEcMwu90eDAYTiU8//TQArF+/PpESiUTMZjNBEM3NzYlESdeWlJQk63hJeb/55puJFIfDodVqlUplyrT4xz/+MQD885//PN2uyVygyIpQZvqZgiJct26dpPPq6+sTP7Esa7PZ5s2b99///d8pilAa1q+55popCymtuSVGZAlpbnHfffclJzIMYzKZcByfeBXx9ttvB4CUid2xY8cAoLCwMJEy7YowmQkUYWFhIQCkzKVefvllALj99tsnqHNoaAjHcZPJxDBMcvp9990HAL/85S/PROAJFKGkjVKma6FQiKIolUoVDoelFOmFZtWqVSnFq6urAeDAgQPS156eHgDIzMxMfk1Bn006n3/++eTElpYW6Zk8k67JXEDIVqMy5wtf+cpXAEDaoZH48MMP3W63lJ7Cm2++CQCS7pwCsVjs008/LSwsLC4uTk7fv38/AKSYgVAUtXDhQlEUDxw4MEGdactWV1dbLJa+vr6hoaGU/MFgsKWlRZpRTa0Xk2doaKivr89kMknqIcHSpUvhM8nH48CBA6Io1tbWUhR1umXPhLTXU6/X19TUxOPxo0ePTpBtrHjSh4ULF6aYEaXtRWVlZU5OztatW1mWnb4OyZy/yIpQ5mwxMjIyMAa/3z9e/rlz59bU1Pz5z3/mOE5K+dOf/kRR1B133JGSs7+/3+Fw4DgujWJTYN++fQzDpFgMAkBHRwcA2O32lHRpz6mzs3O8ClmW7e/vH1tWWtwbW7atrc1qtVZXVxcVFdlstu9+97vjGdFMC1Lrdrs9xRJSkq2/v3+CET9RNiX9lNfkDJlkuxPfMunXU9aWyJZgwYIF0Wj00KFDZ9oNmQsB2X1C5myxYsWK0y1y9913P/TQQ1u2bLnhhhtcLte//vWv66+/3mazpWQbHh4GAKPRmOKZMHmam5sBYKzJfjAYBACr1ZqSLqVIv6YlHA6LoigtIZ6yLI7jtbW1FRUVer2+vb1927ZtzzzzzNatW3fu3DnlHk3MeP2S9vk4jguHw2N/TS4r7cgmc8prcoYEAgEAsFgsE7c7yVt2ur0oLS0FgGPHjp25l4jM+Y+sCGXOFuvXrx+rFVpbW/fs2TNekS996Uvf//73X3311RtuuOH111/nOO7uu+8em41hGABIWak7LdxuN6QbZKXJqEqlSkmXPAekdtMiFaQoKsUfcWxZlUrV39+f7Jh4/Pjxm266qaGh4bHHHnvmmWem1KFTIImX4jkAABiGKZVKjuNO2bWxZaWrdPYWDyd5L04r2+R7IT0bLpfrDHshc0EgK0KZs8VPf/rTqqqqlMQXX3xxAkVotVrXrFkjbQ2+9tprmZmZKW5kEpJ+DYVCCKGpeT1Ho1FIN3pK/hg+ny8l3ev1AoBerx+vQsnBIx6Px2KxFH+7lLIEQaS451dXVz///POrVq3685///PTTT58NP25JvLHr0izLSkuyp+za2LLSVRobM2G60Gq1NE37/f6Uy5VyPSd5y6Rsk++F1GuapqehJzLnPfIeocz5xd13381x3KZNmxobGzdu3JjsJ56gtLRUoVDEYrGxWzuTRFoQGzssSjtGY0dVKWXsDlMCvV4vDaZTKAsAixcvJgjC6XSepZXG8folaQudTjeBPpvyNTlDJtnuxNkSAQSk/KfMlpI+dilV5qJEVoQy5xdf/OIX7Xa7FPMlrb0oAGg0Gsl1/Z133plaK9LA5/F4UtJnzpwJAG1tbSnpra2tADBr1qzxKsQwTDLITCkbiUQGBgYUCkV5efkE8ki+2wAw+YBnp0V5eblCoXA4HCkmOVK/qqurJ5iGSr2WciYj+RhIV+xsMMl7MV62FPFOtxfS4nlOTs4Z9kLmgkBWhDLnFyRJfuUrXzGbzcuWLUsbWVRCiv/y9NNPDw4Ops0wdmRMRrIXbWhoSEmXVmL/8Y9/JCf29PQ0NTVZrdba2toJ6kxbdsuWLTzPL1++PGW9NIXt27eLopiXl3eWVhrVavVVV13F83wioJ2EJO111103Qdna2lqLxdLc3Nzd3T22bNq162kh7fWsq6sbGBgoLi5OvFhI2bZs2SIIQiJbJBL55JNPSJJMRK9dvHixXq+vq6tLeWDG64UU0kjywZe5+DnHfowyFyNTc6ifoMKxDvUIofXr1wNAaWnp/v37k9Npmn7qqafy8vImqFAUxaysLJ1Ol+JezXGcFKz59ddfT6SsW7cOAH70ox8l57zjjjuWLFmS3HR/f79KpVKr1YmYAF6vVxqv33///US2d999t6OjI7mqnTt3Slfsxz/+cXL6E088sWrVqjfeeGOCjqQwgUP9e++9BwDl5eVer1dKqa+v12g0KpVqYGAgkW3fvn1Lliy58847k8v+v//3/6R7lAjLKU3Zy8rKkgN1HjhwYNWqVXfffffkBZ7AoZ6m6ezsbAzDEhFe4vG4FOMmxYtfSty8eXMi5Rvf+EbKY4YQ2rRpEwDccsstiZv++9//HgBmzZqVEk2NYRiVSjXxIyRzMSErQpnp5/NRhDRNS7oQw7DZs2dv3Ljx3nvvXb16tWTmUFNTM7GQ0pxy69atKek7duygKIogiJtuumnTpk01NTVSbYlQJhKSvtyyZUty4m9+8xsA0Ol099xzz7e+9S3JyuOOO+5IDvR18803S+uoa9euvfXWW+fOnSu9ki5btiwajSbXJjlQpgSBG8v7779v/gypKpPJJH1NVqKiKEqxb3Jzc7/1rW/dc8890uzz2WefTa5Nuh3l5eXJiaFQKHEdNm3adNNNNxEEoVQqd+7cObZsRUXFxAIjhHJyciQJJTNOjUYjfV27dm1ytg8++IAgCIVCcdtttz300ENSYNKlS5fG4/HkbC0tLZL91LXXXvud73xnyZIlAJCfn58SCSgQCEjL1/Pmzdu0adO6detwHFer1SkvUomOjA3yLnOxIitCmennC1/4Qk1NTXd399if/va3v9XU1CTPrnbv3j1//vyHHnpoggpff/31+fPnjw3JjRD68MMP165dm1hRVKlUS5cuffHFF1PGyrG0tLRgGPaVr3xl7E8HDhxYvny55AhhMBjuv//+RDDPBOvWraupqdm9e3dK+ltvvZXYvsrJyXniiSdSDjd47bXXVq5cmfAXJAiipqbmf/7nf8ae5LBgwQIASDm8Yixbt26dPw7JM1GEEMdxTzzxRGLfa9asWSlhqRFCu3btqqmpueGGG1LS/X7//fffL4mN4/jy5csPHjyYkufZZ58FgG9+85sTC4wQuvLKK9MKPDZC7Keffrpo0SJJYLPZvGnTpkgkMrbCtra266+/XjKtUqlUd9xxh8PhGJvN4/Hcd9990tOC4/jKlSvr6urGZrv99tsxDGtvbz9lR2QuDjB09sM7ych8DoTDYZZlzWbzWE++8bjhhhu2bdvW09Mz1mcfAFiWncDNfGJisRjLskajceI80WhUr9endYgMh8MWi2X16tUffPDBFASYmGAwSFHUxNuW4+H1eseTef369Vu2bOno6JCWBKYRhmGi0WjyyU1p4Xk+GAxO5hnwer0GgyGtTfLIyEhxcfGaNWvefvvtqUssc0EhG8vIXCTo9Xqr1Tp5LQgAv/jFL1iWlQ40GAtFUVPTggCgVqsn1oJSHqvVOl5YgO3btwuC8Oijj05NgIkxGo1T04IAMJ7Moiju3Lnz61//+rRrQQBQKpWn1IIAQJLkJJ8Bq9WaVgsCwM9//nNBEJ588snTllLmgkV2qJe5dKmoqHj55Zf7+/vRVB3zzx4LFixoaGi47LLLzrUgk0UUxX//+98Te4mc/4iiaDKZfve73413wL3MRYm8NCojIyMjc0kjL43KyMjIyFzSyIpQRkZGRuaSRlaEMjIyMjKXNLIilJGRkZG5pJkGRbhr167Lk0h7yE5ra+uKFStsNtvKlSvb29vPvFEZGRkZGZlpYRrcJ4LBIMdxf/jDH6Sv0snOySCENmzYcNttt7333nu/+tWvbrnllrHBjmVkZGRkZM4J0+A+8eGHHz755JMTnLa6Z8+edevWOZ1OkiR5ns/MzNyyZYsc1l1GRkZG5nxgevYIW1paampqVqxY8cILL4iiOPbXWbNmSXHxSZKcNWuWdAaYjIyMjIzMOWcalkbLy8tff/31kpKS1tbWBx54IBwOf+9730vO4PP59Hp94qvRaBx7IKqEKIoajSY5+NOdd9751FNPpWRDCLEsK8Wtl/n8EUWR5/nxYoPJnG0EQRBFcbwIYTJnG57n4awdoSxzSjiOw3GcIIhJ5lepVKf8s0yPIpTiKlVWVoZCoaeffjpFEZrN5uRzsYPB4HghHEVRFAQh+fxPg8EwtsMIoWg0qtVqz1x4mSkgCALDMNJpRzKfPxzHCYKgUqnOtSCXKAzDYBh2cb8IitGI/y+/1F11k7LkvAvyF4/HSZKc3heRaXaf0Ol0DMOkJJaVlbW0tEhLpqIotrW1jTWoScacxOTVvoyMjIzMmSMEPO7ffAcQ+P/8tBiPnmtxPg+mQRFu27ZtYGAAANra2jZv3rx27Vop/amnnvroo48AYNmyZXq9/sUXX0QIvfDCCwaDQTo5U0ZGRkbmvIL3DLt+s0mz8FrrvY+qqmqD775wriX6PJgGRbhv374FCxbgOL5ixYrly5f/9Kc/ldLr6+sHBwcBAMfxv/zlLy+99JJGo/nd73731ltvndZZOTIyMjIyZwkuyod6aH9r2NMQ9DX7HS//jpx3u2L29UyAVa+8J9bdFW3Ye65lPOucX6dP8DyvVqs5jps4m7xHeG6R9wjPLfIe4bnlotkjFOJCsDsaGYwhcVQLxFsPo3hUPWfZiTwBT7z+k4x1Nxgq7CrredHls7FHeJEYPg0NDcXj8XMtxaWCIAgsyyaMe3NycuRBWUbmXMHw7DFPiy/mpzkax4hMTUaWLjNXZ6eIifQWG+Jdh/0Ce8LbjXcP8c4B7eIvJmcjTBmKwlmejz6NBa7VFWitMw1wfh3cOT1cDIqQ47jCwsKCgoJzLciliM/n++EPf5hiJywjI/M5gBBq83UedTbG+RMmit6Yr8XbjmO4XZuVq7frKZ1BqddROgV+YrSP+1j30aDIndCCiGPjx/ap5y7DSAqJCMNPqDtqRrUQcMfb6gC/XOTEjNlGjLjYlOHFoAhFUSQIoqur61wLcinyyCOPsCx7rqWQkbkUOTRc1+xpS/uTiMShyPBQZDiRolao1aT1cnuZlbe6DgcSy6ESTEc9nlES8WqjTT6BEUg1QRkUuiI1pScBQHXZInrvv1iNDqDSXR/MnGe6yOaFF4MilJGRkbnUqHcdG08LptAfgaNe1BmiWZH+QvbgF4N5hcoCDXkibokQ8kWH2RherM1BGXMMpI7gaIHxce4jQV2ByjBDg5GUpnZlrG67GAlCdW2gizSV6s5azyaC4dkfHuq6Or9iXdF0VisrQhkZGZkLjDZvx9GRxrQ/8UjoCw5EuRhCIoETBlX+W93q5dnYsmwcIWg+rGvgWMbYPcNUYFSOBvzyHXVwRFlWrZnUjvptUzqS0pGaLKWvOew+FMyYZ8TVOu0Vq6MNu6OHtonslUqjQm37XGN7cSLf6DrW4u3YOgBfra6Y3splRSgjIyNzIRFgggeG6samMzzb7Gnp8Hdb1VazyohhWDgeOzT8cZFSm6uuMVNZVEBVrNa0stASEDGsL0+fa1WbvYccgqCzL8nEqdTlTkKJ2+Ya/cfD3saQbY4BCFIzbznb3Uzv2TISurzg1ssJ5ecU8GQoMrJ38GCYjThjgGOKKuM01y8rQhkZGZkLBhGJu/r3CUhISffEfNv79uTqs9cUX6NXjq5b/qMP6fXzFlhGdg/sn2WpWuxehGNQYYTDHuSJA4ADnFg8IGTO0ye0oDpDaSjS0MPxqDMu8ggwMFXrfI1hb3PYepkBAKjimWRGdrRxz/C7wbw7rj3b/UUI1TkbmtwtkqdfaxBVGaff5U9WhDIyMjKp8DEhOhyP+ziRExGAykLp8lQK7bkfMBtdzZ6YLyWx0997eLh+Ue78QmN+IvGwBw3S6P9U4go8x6q+pqthsJ8eLjTkERiUGbH2ILKxVKQvZjD3KaxLpSK6fLW12gAYqDIoc5V+ZJ+Po3kMwyyX6d2Hg6GemGGGGgBwg0VTsyRYtz3j2pjKqoazhojEfY5D7b4ThpAdQbQim+dEnpxW5TU9dXV2dh48eBAhdOWVVxYVFY3NUFdX5/ON3jyNRrN48eJpaVdGRkZmehFY0Xc8FHOyycFG2CAX7o2qMihzhQ7O3bEfvligwdWcktgb7K93NV5XssKoNCQSO0Owddi2udYQZXpFJOoE/TLyym6xzxEeztNnWyjIwAltnzGgOhbLtpkAYYDpCzWWqhPHBOEkljHHOLLfhwSE4ZjlMr1rv19jp0g1AQC43oyptK5PmvM3zMews2JCKiL0Sd+ugZAjkRLmwM9Ejw7vqHeVLcqrnca2pkERvvbaa9///vevuuoqkiS//vWvP//88xs3bkzJ8/DDD3s8nszMTADIy8u7ZBXh22+/HQqFKisrz+QKCILw6quvAsDixYsrKyunTzoZmUudqDPuaw4nu5knQAjF3EzMw6jsCkOJBs5FlJVDw3UiOkk2T8y3f6ju2qLlyVpQxPP+2HfZ+9eaam1YiJ15eLje2xXGEFZkLOjwd3tivgy1pSai91A+0MYRibtod54tx1yeaghK6UnrTIOnMQgApJrQF2n8LRHbvNENOqqgnG5rj/RX6wvPSpCpQ8N1yVoQAI77Ipn49pnWylr73OltaxoU4TXXXHPbbbdJpwP+8Y9/fPTRR8cqQgB45JFHNmzYcObNXdD84Ac/WLduXWFh4STzf/zxx4888khjY2NVVVVd3ej2OEIoEAi88cYbsVhMVoQXBN1h9IsG8f/OwitNF5f71YWAJ+br9HUPhodInFCRKqvakqu3Z2psJJ46+tHDcW9j6BRRJxHQg/HoMGMq1huKNAT1+YVNHgg5hiIjySkRNvpJ764r8xZY1KZEYkiwP9W08OWlilobBgAGSr9Iu2A/Ux+CMIHhM4wFHf4eU8xMRSlR1RJQ52cDOKOekvL8tG7y2hxVzMPSQzEA0BWp6REmOsJo7EoAUNgLmNYjgaZhXX5xsgP+tNDp7zl+snNIlIu2uj8pMFXNypj+QW8a7mJ2dnbijFybzTZepNDjx4//4x//kN3e77zzzpUrV04ys91uf/zxx59++unkRJIkN23aVFExzQbEMmeJbUNo8T94EWDZh/yTDSKfZrIhc1aIcbH/9Gz/oOPfLd72MBvxx4PDEecxd8tH3Z/+teW9Nm8HghM6L+5jvU2n0oKfgQQU6qYd2z0jB3yBjggbPEV45DNHROKh4aMnyQBo9+D+6oyKfH1OIrE9bH3y+KI/X01dX3BibA91R/MNeZLiVxJUkS7fOGQOZAyBgnTwKgCImeij8YbxmjaVayU9h2GYuUoXaKNFAQEAYLgirzTa2UoPTXN4S2/Mt3fwYHKKgMRP+vaExNJF2WXT25bEdO43chy3efPmr33ta2N/0mq1e/fuPXz48I4dO7785S8/++yz41UiiuLPfvazxNeFCxcuW7YsJQ9CiOO4hMY9ZZDuzx+Px7N69eoXXnihtrY2FAp94Qtf+NnPfnb11VenZPv1r3+9YsWKyy4b9+jL2bNnz549O7G9en4iCMJ5eAvOE37bAr9ogjeWwVV28Qez4Bv7hH/0Cv+7HHLPYDFJCrotH9U5MYPhoT2Og4yQejyqREyM7x440OJpr7SU29RWNad2HQqMscRMjyAIGIZhAGI4LPCGmJfxd4QVOkKbq9Llq89SyJUWb7s/FkhOafN3CYivspZJR70CQL1P9W/XldtWk+UGPvGPZAN81BMnAM/RZfcF+wEg05tFqyMDYk+2IYOPQ1AQhOxQOBDo8vYUGPLStE2AOlcR6YsDgMJAKE1EuC+qL1IDAJlbEt3/L3+bn8okpmunUERoR99eTjhpSDk4dCTCK3P1FRQmSgPO5I+LIAjilOcdTZsiFEXx3nvvNRqNP/jBD8b++t5770mi9PX11dTU3HzzzWO1QoLkcd/j8QhC6uOJEBIEIZE+NgMAtAYQzU+hH1PBSEGp4aSHICMj44c//OEtt9xSV1f3wAMP1NTUpO3vSy+9ZLfbJ1CEFwTS7TjXUpx38CJsOozvd2PbvyAU6kAQIEcFf78afnUcX/QhvLIYrcieohW48BnTK/CZ4In5RminL+5nBDZDbbWprbn6bGxCnSCyIh8TCDVxNlYX+0IDux0HUrbTxuKmvW56H4YgozNbwSgAgMAJNaHSKNRGykDgn71qIIj7uLiTZbwciAghRBAxpdCrwDxERhZVeTkQJBMSmRAXccTMM3UJt/Tpghf5BldzQuEBAM3HGpzHrim8ColImtcORLH3hy7/eDVZpD3p0Qh0RqSCBoXOqDSGwmFlQB0u9gVDrJmiMjGop+gqnAcRDg0fzdHa0941bYGSHowLnAgAumK153BInU3hCgwoFa63xHr76FKtOmt6/OuPe9u80ZNe/XuCfQMR1zC36v/MAFEUjQq99C4yyQonc+rf9ChChND999/f39+/ZcsWhSKNTVVClMLCwtra2oaGhvEUIY7jKSuBaZsTRTFx4sHYK4IAvrFHCH1es5R8Lfb3a1If/fXr13/66aeLFi1SKpUHDhxIW/D48eNnX7qzDkmSp3X6BBJQ3Mcyfo6Pjv5fSQ0BekQYcb3mIjlaa5BGX90pUDjsWUfqT/5H/HAeLM5Gt37Cb1tDVqtjXH87ptZiOK7IngHj/2NFHomsKPIiqSYIgjh/jmEKMqEjIw19wYFEiofxtQY6bEHrFbm1GWpLSn6BFUPdND0UTxikkBpCl6s2zNBM1z7TUGTkgKsOJ3B8cls/GocOi2M88ADACzwjMAE2OBJ1WdWWTK0NRcDbGCYoTKWLKfgDhFaNqQ08ZWfp2fGooOOG0aH/qGuW4noTAIhR8B2hrTMN2tzpvDvNnlYe+OSDhw4NHq3OKLdqRy9viIO/9M/4w9WFlRknXUMmwPFBMVEwz5Dd34nHrVFgQ1mgdkSduZYZr6LYTILEMYiJcSfjLjKmO71ABZZy8LeFAYDUg8aujPazpgotAKDcYm6kL+6oMBdOQ5cjLH3c35bc0ygXPeJs8ohXrS1U6pRAYMTSgkUqleq8O4YJIfTtb3/72LFjH330UfIZdZFIhOM4s9mcnJmm6ZaWlm984xtn3u4EYACffPHce/ysW7fuueee27x5c+LEoosSTuRFJOLYqQcdJKBQbzTUG5XC3nMiH4gH/PFgnI+LSEQYQIagzVfNyCuYYSwgcIJz9vv/8ish4FGWzKLyy8RIiPeNABJJexGZPYPMn8eEBCEuAI7hBEYZSaVJMe2b9qdLmIOfNwgvtoj/txr/4TwibZj+q7KxH1ax+//2tnftzwoAACAASURBVKX/fUVWPmLjIhMDDDOu/pJ6zlJIerFjgxw9Eo8OhrgYwshRhYpRoLSRVJUSJ89xZ4972g4N14npFqncUe8/Oz+enVk9N2u2lCLyKNwfDfVEkw89AAA+KgQ6IlEnY5mpVxrP1DXBE/N90rtTECeaLoui4Ig4JZ90Q9xgcFrHzoJEJLppT7Sf0bh05io9hbnixw9qFq7ADWZpwkUQBBvgvE24QmUVD35CZtqVpbNxtQ6JyHMsiESky5+efz0v8k2uk96Y+4KDEY5eYRt1/vMy8LcezX0z563KTe1GsJs+6XsUV9JKX25QGPZbLVlBxuPQd+gEY3cYKzUAADS5W9IrQgB9gTrYTUv3zlCiHdnr0xeqCRWuyMqPtxxivJG4V3fmBxYeGDrCiSct5e11HEFkaaHKVGYAAJhnn51sHztdTIO2+OMf//j888/fdttt3/3ud6WU5557jiTJJ598srGx8YMPPnA4HLfffrvkX/HOO+8UFxdff/31Z97ueY7b7b733nt/85vfPP7441/84hfnzJlzriU6WzS5jr9x7G8ZGkuWNrPAkJuhtqZdtYg6477jEYERAIAX+eGI0xf3Jy/0YwjATUTd3NHu43UF9cUjw9l7dpjWfEVZVsN0H+MGu3CdSVVZy0SJQLeX3tVI5jFU4Un2YxiBaTKVugK1yjwNtu2cyAmiQOCEAp/s6Lyjm/vFx/QSDb/dJurdyLEVI1WEykrp8lSU4UQliGVu+eCbW/DK+Ff/O6d41AM63noktOXV4Id/pIoqFXmlystWBgcg6mRAFOl9HwESNZevxFQaABDiYqQvzrk9xlKtLl99lry4Jibh6YxzBMkQOIMDDghDiBQFNY8IJOWpdx7jBO7yrLm0gwl2RQRm3LVKNsQ5D/itlxm02VOfWMR55tO+XSkjaTI8Ejp8XU3uVgOlU5FKXCTK+3THmTaKoLK0NrMyKXIXAq3DQMYUgXKvVvSJbU2ay1fg+pNe6ymTwr7Y7D8eiYpXG1WD9L5/aeavIIxWQOA7HkYI9AXToAvbfF0x/oQ1ioDEw876RdmX4xgmINg9gg660Zeq5z1ck7oyyUX4uPukk2GC7bShWOtDLPAcrtFnquEv3N9mZ6w+7MGkzR1P1DsccWbrssaKgRGYLk8V6okCAEHhujx1qIs2z9QDQZIZOdxwX3jAeIaK0BX19IcGk1O6Av1DdARRi1bnYQCQpbXNtFUy8fT7vmfCNCjC+fPnv/jii8kp0j9zw4YNK1asAIDMzMzvfOc7TU1NCKHHH3983bp1F/0+P0Lo3nvv3bhx47e//e2srKxbbrnlyJEjBkPqi8yqVasefPBB6bXgqquu+u53v5vyiuByuXbs2HHgwIFAIPC3v/3NbrcvXbr08+vGpBGQ4KTdTtrd6GrWUdpiU1GpeUbixU0UUKAtEu6PAoCIRE/MOxJxi+NbJlABpeCMN4X6QzfdvXTuNSROEtYcrpKnR5jwcJyPC5ANKlOE3vdv0pqN604MXkhA9HCcHo5TRoW5QqeynPbfUkTiQMjR6e/xxf0RdvRtmsAJq9qSobYUGPLs2sy0iof2ca9tDbX2sd8pxEs+u89IQBzNszQ/3OWmqUg4J+RX+GiOjvccF4rU9fmzt3e5fp2tldYPVZXzVRXzuOFeZqAjUNcT3v6uuvZajFQw7UdxrZ4w2egDH2tqV+KaUZdngRV9x8NxH2edZZjC1JAT+cGQwx3zeqI+AfG8KOAYrqO0ekqXo7Pn6OwTTPFpLrqzeX/IQZtCGTibJpuoEEWlICgFgY8NtLtYqM/X5Z5SJCQib2NIYERD0VRMiRCgXQP7EndtLK6oe9fAAYvatLJwqVVtBgD1iE5t0CAAmqMd4WFfLJCnz1YSFCDQOoxknAiV+PiQuyPgqZqzJKEFlVYFqSI4nyCwIkZglll63/FwOFxgKtMwbXWaBdcAAELI1xIiNYQ644x0g4CEY+6TpoMt3nYTZczR2wHgPw7kiaNH5tvvqEozjQv1RpNfNBkfx8cFW57B2BHz6E0AQORDRsxMoXYHXemJYxkqAIAm9/G0ihAA9IWaUG9UsrTVF2qG93j1cS2pwhU5M5ju5qizXIjrCdXUd3zrnU3JX6Mcu3uwjqCW3F5KkhjgGL4ot3bijecpMw2KsKampqamZmz63LmjPo8KheLGG2+88cYbz7ytC4WGhoaKiorHH38cAG699da+vr6dO3euXbs2Jdv8+fNtNhsA8DxfX19fXFycksHv92/duhUArrnmmq1bt86cOfP8VITJRFi60dXc6GrO1NoKDLmZZIZwHGdCnICEEBMZoZ0p9mBpEb0+o/7y8DHFtv49VbZyLEqkHJ+Gq3Wq8rmxxj3aRathzJDNBjnXoYA2R2Wq0E3eFqPD11XvOjZ2JBVEwUW7XbT7uKfNoNSXmUuqrGUKYnSGJzBCW0P4rf1xJY7+qwpPDsIV4+OeqNcfD45q/RFAZhwyEdtzXFO7co468Gyz783jbVWWnDlZs2yaDMAwwlYYGzELM2rw2KFY3XZqRjU30qe98ouYQokpqOjB/2gWXAOqEzup0ZE4HxVsc41SvI/JICKx3ddV72xKnmdI+GJ+AGh2typJqtCQX24psWkykjMghPr7HA11rSgMKhh3uoNzOBYXkXMY4jRSadwmRokrM0+uKi0IIX9rGInIWHzau8VNruOD4aH01YJ4ZLixO9C3KLc235CTEFLpVAsICAx0Cm25pcQd9Xb4u2cYCzJddiJOhIr9nNchxiOKvJJePlAhZGiManOlHtcjDMMoBRV1xT0NISQic7XOWx8KB2wUe5x3D5G2HKlVb2PQvthCqqb+3t/p74lyscTXGM8cc7VeV7ICAGgeGn3om1XEtUXzxhYUGCHFqyHYRRuKNYBjZpcnUJSLSMRY4vOE2f/s3Hq5tWSPk7qhEAOAociIPx4wq0xj6yRVhCZLFR2JAwCuwHQ5qkhv1FSpIzOyY037xGgkPKgzlU5xm98T9TrCw8kpnw40iUT+xrIMaX+h2FSYVqpp4dxvpF2UzJkzJ3kt9OGHH058fvTRR2+55ZZ77rkHAH7+859LiYcPH16zZs3MmTNT6qmoqHjppZdSEjmOu+eee/bt27dkyZKzIv004aLdXp9P32nGOQImbesMAIiNIzZO6I0AwIS4Zrqj1FykJFJXfhR5Jbx7MNa4lyqqJIypgyxCKOKIxdyMZaZBcyp7NpqL7h08ON4wmkyICR8ZqW/2tFxmq66wlgkBcfv2wD+7hCuzsEWZJzRujI8PRUbCbCSl45RfhfeGgZwrqs1qAs21YnucSK8YcoSH52RdVqko9x4LSTZEquraWOOeaN12zeUrMIUSABS5JYAgevgTVe0qUJzoERviXIcDWQvMhPLUKt8X8+/o3xtgghNnY3i23dfV7uuyqE15+ly7NtOoNAw4h4abPGF39JStiHSIdztwo1WZXSTQQd473OsaIDTZhox80mrHKBUAgCiI0UjyhD5BsINWaMlT3rVknLT7qDP9sUQIxB39+zmBu6F8dfJTJPTq6lw4K1JVRsasBAywTE2GilQJDsAZIpjdxw0MYUqVIrcUw3Fe5DvZ7qsXLFJSCoZhAAAw0GSpLNXIeyyEYZi1xuA6HMRNlzPtdaOKEEBgRffRoH2heWpb1wih4+6TnMrrnU0l5iJprWWfE11mwWoyZ1jHWCQBQLg/lvzuGPdxAitq7Eox5CMAs5pyBg39QCADoZ9hKgBoaQvODnOYXgEIoRZP++K8BWlF0heoJUUIALoizcgen6FYg1O4wl7ID/dGTAZj8RSNnlJCxwWYkCfaPzf7OkkL4hg+J+ssWtdjk/fG+BzgeV6tVp/SKQ0hFI1GtdrRV49Od8/MvMrRp/P8prW1lWGYjIyM3NxTrxSNB0KosbERAPLy8qxW6/RJNxUeeeSRZn/b9V9LM90naYW+24Txp/hXiAhS/ji8axBTUIQ580RVOFliLlKTqVMQxLFsbwvv7Ec8p56zjDCln3PoctWWan3awBkAMBQZ3t63hxHYtL+OB0LI6DHZfPlv9Zg2lipzPlvM40XeSbs9MW/6fxZCbF+rImcG0lKxzKjPFHuuVbi/CjfioBnW28JZhYY8AktY7YtCwJN8HQCA6WrinQPK+StI5Ul7aZSezFpgxhXj6kKEUIu3/fBI/cSGJGnBEGgceqVHDacaLZAg8B4HYmJkVj6uHL0oOE9gMQFno3lRHg86cJUGCFIMBzBSQVgyVTOvSNgBJcBJLGuBOXljdQIYnv1H57/SLooiQLv69zEit7JgCY6fmJn1DJPRxqKF9mybinq/jy83RLKVDgxEyk2qnfpD1kMZSDCZc3H1aNQxQSmEy/xFtoKrChYzDINhGEWNrnn628LSzpkQF0cO+HVki6YoW5FbkmjLMENjrtDD6eMID3/c82nia5iJ/LNr600V1ykJZUyAZ5vFb1Yr7rnseq0idSVZFJBjh0dMChTnOhTQ5ak02Sqm/ShgOJRU7rfvFUgRAKJ87P2Of5n11+GY6tpcDAAUOHlr1Y0UkX5Rd3ivj/3MIt/fGsYI3FSmFXzOeNtR7aLVGTXGKezyemO+Dzo/Sv7LfNS9oy1iv39WhbSgU2ktW5Q7Glw0Ho+TJHneWY2eWxzh4Z0De861FJNlWiKiYRiWdi36vIIMU7puIyams5oRIMRCmIMIh2ICcCJQOJgoTKsAhAAJfDYdVOXOJCIUhgAABKXAU3ynv6fMXKIiT5olYApKWVajLKvhnQOxhl3axWswRZppRMQRY4JcRo2R0qc+8M2e1sPD9ad0OEsFga7fRPqUjbQrX+kKRpUsp8IxnOaiDD/RC5kQ9GBqLUapMA60Dp3GqbmV5UIHiSItCQhCEOoUekpMRaPRvzA8RQsCgLLkMjEeZep3kpevAOJEd9gw7zwcsC8wp9X3IhJ3D+7v8veeXjcBAABncV2viaRPPVaIkSDvGcL1ZkVmPmAYSVNKv1oRoXABExQCJtpCIk5SVZRW1FiRNtcCgMVbj9B7t6jnLCUMJ01rRB6564L2xZbJrGzvdRwYTwvuHjjAiNyKJC2IALY5RHXH7PtKzNkaAID/qiK3DBhbhjwVTJ82XOXP7MzVW3piLpWCkDSMSKJwcUBUiN2B3gJDbo7antyKuVzPBDjGzxEq3FKt9zdX4O172cFORc4MDMNFOuTuIrQ5K8Y+e6fkmLs1+etRZ2O1rUKa1B5woSoTVmsvHasFAYAeiidrwbiXFVhRbVcCADfcp5m/3FBgsmuzpKVIDameYSxE0LHLM2uZHVMRwIl8V6C3ylqeVipdvtrXPKoIDYXakQM+www1YbaJ0RBi4+F+xRQUYeKUJYnB8JCfpbN0ZdLNJ3GyJnPW6dZ5WlzYijDIhD/p2zWFN9xzxRtvvBEIBGbNmrV8+fJJFgmFQr29vVlZWVlZozvYgiC88MILAHDVVVedn874VFCp7TFiCCQzhDBL8yIPAJyIhTmSERU6hcagpGwqTE2CEoeYAEEWohyYo8psv0bNLUcdmKgUAEeAgGBJEIHXcn02R1FBnpJM86JKZuUrAu5Y417N/PT+qVyEH9nvs840aHNG/6UIoQNDR1q87afdPQEzdJvIiAIBOKKo2oQxAjNeBJNkkCjwfjeVd2KugPH4ZbjyYBjFlCDt8cW4WIe/u9Q8YwJTVWXl5fHjB6JHPtXMv/okXRjkPE3BjBpjijkPK7DbeneO0K7T7ikAESX13SacwwEAAcS4WJSPsQLHiRwvoggHgJGFeq0WV4LXidg4mV2EK9WKkFLt0hEcHrdGw0W0oOQTJg4FVJ4ipAn0xmlPxFiuU1XX8s7+6OFPlMUzqaKq5Kb5uOA9FrLNTe1OCu2+rt4kL8Zk6kaawlzk2hlXJybZMQHe6RFtbOV3S8yJTVU1AWuCe+LBgI+//LgtZLebtQD5pKIn0F9mKaZwRTQ/KKpGB5l9jkOrC1fqqKSdMAzMFXrnAT9CSG2jmGwNG1tuzKW54R4MJ3Ctgelu9hyuzl6ee1r2vf54YJg+EVnUF/eP0G5pxZIV4ZAbfa1KMTszdTNFItJ/0vJ1qDtqLNZgGCYEPBhB4HqTYYZmFqpM7MnNyqj6oOvfxYbyJp9SilDa6umotJSlFVibrQq0RyQ/CkKNq6xUdIjRFahJazbvGWKVJRzNn9Z5VRGWlkLeSCBAh4frBaKmxjzaermlRKM4ux5on1/E2LNBnI/x45tKn4f85Cc/GRoamrzR7L333pufn/+lL32pqqpqw4YNieVfkiRfffXVnTt3njVJp44iSOl6jZzAOSIjzZ5WR3gEANSkKsyrvAylJsRMZVgUekKxdpodRiIDAGocCmOa+QPWAi/BKZ1N+SOf2p2BUm+o2Bcq8fmrXMFyD2uIUw7VyD5feCi9WaCyfA7iGLZn3BgFSEDeplCwa7R4nbNhCloQ5zBjh5mMKADAywCFw+RW7wAABL+L0BlT5qwKDPK0WG/4RArDMx2+bk4cf4MAw6iqBbjWED38CQgnPf/RESbYcdL1iXKxLV1bp6YFFWHK0GnBOTzKxwfCQ8c9bf2hwRgfwwDnkM7DGrSUAQE5FPG1+jr7iHg8K5sgdPpek3bIwGTQ/kp3LJMWVHyyod8QP6LOV2YvsaislOtQINIfJ7MKtIuu45wD0cOfIP6kXsdcTLg3lipWEjRLH0x3VjsAtPk6+0ODKwuWkZ9pQV6ENzrFfH3Of+cUJZsW8c4BkQ6J5mXmPJ1LiUv3wqjUZ2lt3YG+kDG6hWbagqPzFUZg9w0dTln3VpoUUhxqADCWaTla4ESrevaVqllXUDOqycxcuqMn0j9RR8Zy3NOW3MqRkcaarJnSUsEhNyoxYIuzy9RkmrlX3Mey4RNPBeNPmg6O9JHZRWqbUqEls7X2hO2JjtIUGvKsROcRz2iLASbojLrTCoaTmC7nRLv6AnW4PwYApC2Hdw8hhCKDpxd6tNnTmuyK2hPoU+DKgWh2uREDABzDqzPOelzlC1sRXojcfPPNk7f8XL9+/fDwcENDQ29vb1NT0yuvvAIABEHcf//9paWlZ1PMKaIIU9BO9vj727xdGECZubjCUpKtzfRxFkY0z7NZy81ZRcb8mRkVM4wFOEZ0Bnq8QwFDq5VyE371sWCxSyjW55oJCsc6kuw5RIXIWGLBcm8kJ+jrCY3s88XcY7b0MFxTs5Tta+WGe8cTDyEU6Ih4j4UanMcaXacd1gdncX2nmYiNvu0O0ihPO9l3fMRzQshPWNIYpudpwc+eFBGQFdguf+/YU8iTUc1ciOtN9KGtiDvZV6ybjjhGx9wwG9nS9R9/PJCuglNA+VW6LlMwGurwd/cG+yiCKjXPKDSV0WJuF53BItNsq7HUaKyy2Iw0OQMZLfpM3o30rSaGigcqPIwpntbQnRd5R2QIMNAVqLMWmiKDUX9rGFNptAuuwdXaWMPulPyBjggTSP9OgBDa4ziY9o1hKDLS4GxeVbQsef3gvT6UqdI+Uz5fjArJtcQ76gXLfC4qmMt11xfnOePgjgMAWFQWRgEvhnfRPHzYj5p8o4P1MD3SGehJadFUphuNTI2Deabe30onwqsr7IX8SF+ggxbik127ivNMd6Av8XWEdoWYcJm5BAA4Efa70PJs8jJbVdqy4ZM1bqgnZijSSHM7fqRPYS80FGoAAMOwqowTi5+X2apHwh2cyDk+m0y2esZ9TUyOFUAZFbgCi7lZMiOH9wwDQrQjlmLjPQGswHb4uxNfEaAGV7NJO2uGHpPWRQuNeXoq9XyoaefCVoRCVMTZ89El0e/3L1iwYM+ePSmfU3jyySePHj06Nj3BmjVrpGA9BoNhzpw5Q0OnNms8Vwii0O8YGjjkcgSH9ZRuZkZ5js6uJCgA6AgBzaHZlhO7VxiAmlTlKO2LIlcUBWe0GVoaDPuZXKNkm4ABVJrAx6DwmCGO07H+Uk84MxjoCLuOBPnoSfMhTK3VXL6SaT3CuwdTSybR2+Ho2DOA86f38OMMbuiwEPFRLRjhIcaDTQUAwIl8iI14Y35X1OOMetwxry8eCLERMcm2hPeNEEYrRpAAQDCE0q9WO3XaIb2u32jqNV/tt1o6rMZ2q7HLou+x6PpM+CDZ2z3ITTh0qqoXkObM6KGtiD1pYdbXHGaDnD8e2NL1nzAbOa1uSlBOZbyVb/V0uKMemyajylqRpcnAMKrBi1QELLRh1abRtVwFE7GKkTYsxzZSWEwXD+cP1lH1I1Fn8kAoqATJxV7CHwtIUpFqImuBmY+K3voQIFBVLwBRYNrrkyVBIvI2BZGQZmDt8HenGNxLRLnoroH9ywoWJQZQBPDpMAqz8KvFi2M9Jz1VnKMLkabwCJkx24DhYFGqlmRntAfRIQ/a44LDJr2eGqi1OL9Shm8dQokJU52rIcX5hNQQCfWgNCnUNirQPqpSSGu2EA4IdNTfMdl70e7rSl7rqhtpmpM1C8cwAKjzoHwdtiyvXJ1utVBgxJjrxMPAhniO5qXtAN4zjFEqld2itIwuYhSbihIWMXpKl6vLKtb0JfrYFxqMj3GwkVDoyGQnXV2+Otwfw5RqXKMTAm6BPUmGiWnzdSb7U3X7e9Wkuj+aWf1Z6IJZGen1/fRyYe8RIhb0XUZfYRp7P3agHcXGda2dXnCdSZEzIznFbDb/5Cc/ueOOO+rq6r72ta8tXrz4yiuvHFvw7bffLisrSzhcTkB/f/9//vOfhx56aNqEnj4EUWhwHet3Di/yLcrWZumok2ZJnSGIcMR8G0FiwIknYsZTAZXWYWAs0WhB2DzoxzSG9lB/ji5L8nQmMMjXw2EhXlvKkDGF0q3G0IlaaV2EN3I5kRzXgYA2X20o1iY8CXGdUT1/efTwp5q5y8ZamgBAIB4cDA0pQGFos4SLA4J6UkvreIw0dI1ulUn0hYVMZWQgFAmxYQBQkyqKoHAMxwDjQBREkRPYvuCAjtKalEYjqcbCnM5URvYrFREKAfA6TlTwIiWKah4RSMCFxiCqNGEqhGEIAwEjGRLcxHCfl1KT6gylOktJGdL8W5UV86Czkd7zoSK/jCoolzwTkIh6DwwdzaqLYqe3HAcAvMh7O0JiP6YmVQWG3IQthgjQ7Ed2DVaU9HaORJF3DaosRVcNZfpJbo/RY0TqTF1pOO7o8vcUmQuY/BhnZESFgHOEelhL+VSSAdRAyFFpLcMxHCMx2xyDpyHkPRa2zjao5yyl9/0bN5gV9hNndnK0EOiImCtPMrykuWjKsUSjciK0fWBvdUa5XZsJAFsdqCWIgizYVPDYgipzUBeIJ2kjUWA6G6PUUkOxJhEpu9qSRbMBTuTJzPjMQmw4snDX4IEbyr5wd7ny1XaRwOAyEzA8u99x6OrCk5Z2jCVa2hETeQQAxnKNc6+fCSiVJgXgOJmZyzn7aZVKX6A5ZRg5EYltvo7EV0dkmBHZYlMhAAgI9rrQXaWK8c7kC/dHk2dj4Z6ovlAjTc25gQ4qv0xfqEns/ClwstQ8I3HsX6W1fOfggS6mdHUeRuEgIrHL3zvTlr4hXb467hsdeDV2VbCd5miBtOXwbgdhzowMxjT2U5vMiEhsSZp3IhDr3c0Lchb8uQvdPAMHgCxtZobm8zCMnx5F+N57723evDkYDF5//fVPPfVUwrA4QVdX1wMPPNDS0lJdXf3ss8/OmDEjbT1TgIiTuu4xrkgIhT/+i8ic9igwRRmMFstdD6ckrlmz5tZbb62trbVarf/7v/+btuCRI0cmU38oFNqwYcPXv/71K6644kxlnW4QoGZvW268ZIN4o9aQ6kvbHYYgp7mjfIaGxAEgwtK9wX6BE7UOPRlThIr9gprjnIOkWmc355p4pi80GGRDBYY8TINUMwOftvMZSjzXwrAWRttvIKInZv+MwAzrh2dcURRuizn3+ywzDZRx9GEmDFZNzZJY/S7NFatx9UkiRVi6LzQIgEBa52w30zOCnOEUjhNElNR3mXEeQ4AibDTEhkIMzQqcitJoKL1dl0mNY9jCIyEeZhUjlCZqpIRsjmA5Axu1R0QqzTxPB9DBQ+VnzzL72fW1CFY1rfQ2hZCANFkqba6K0Jy05qgsna3ILmR7WyO7PlBV1yqyi6JctCvQS4ZUUBoHfLKLVIzAtHo7mW6uMl6VZbIl7z/xCLpChEqhvypXz4m8i3bzIg8I8SN9KjLXNFAQzaIVGfQ8EdxxcNBElC/IVDn/gX04R1dtUhgBQFQIdEGINcd1XSYMASuwI7QrR2cHAMAxa43RUxf0N4fN1Xr1nKWxI58qMvOTQ5CH+qKaLJXSfOI673UcZNN5vBwZqVfi1CxbFQBsG0K9EXRHMW5WglVlXJFb49zpT87M9rezVAVOKfRJa304hpebs3vp/mBuBACydVlFxryDw/VL8xZ+uQz/U4dIAFSboDc40B8cLDCeOLeIoHBdvlpypcBJ3FiuC7RGsq4wA4DCXsD2tFAF5f6WcNZC88RWMwMhR8IIFgE6OtI0N3OWFFGl3ouy1HB1Xmna6SASUcRxYg7H0QLj5yyz9ACAmBjvG9HOv1Kbc5J+qrCWtnjbpdfTTG2GkiALNCNNvuz5GRgAdPi7xlOEmiwlQeFS5HQMB12eOtIfNWTnxpv3K8vnxrwsHxdOGUmgLzhAcyfserr9fTqFNsLb8rRI8omdNc7y77QzDYqws7Pzy1/+8ltvvVVdXX3nnXc+9dRTjz76aEqeDRs2XHfdda+88sqvf/3rDRs2TFIBTBIyNmYYwjDrvakyfP6sWLHimWeeueeeexIHF08BmqbXrl07f/78zZs3T6Ns00i1pXxVbCUhjj70IsAQDXEBojxikOGu8kLNZwHAdJS2lCp2HQ8wuniwzItwJATciGMkpysVqSyzFI9EnEfoo6ZSnY2yLLVj24fFu0pxXs2FS/yGNktyQK84H++N9ZXOnsG6ec/RoCZXZSrVSi+/hNVOZXjp+wAAIABJREFUFc+K1W3XXvEFIEgQRcAwVuR6gn0oyVMCFzF9jylSEGLN427vK4JKdY8uFA+HmHCQCSsJhVFlZCEnU6fO1Yw7nGGAKYKU0aPB4yRjiYeg02PifQKNI8zMmYyEQTUmPkCuFg64UFyHnTR6YOAjvWQOnlNu58J81Mm4jwQINa7JV+ntZGITDtcaVTMXUoWV0UNboyD0kYwoCiSt0PUbIoXBUwalinD0cU9bV6B3AV+7iLxMZaSCLIyEAQHwCGgOhXnKrivZUKSQ3BQz1JaR8Iij67CGzdHT+aHCIK9jAIDCIVcDuRoswsNroLJl2P/d8+nKwqW2z17qOT1LFwV1vUZA4I56LCqTilQBAIaDdY7BfSQQ6ooaSi243syN9CpykgItIfA0BbMXW6Vgcp3+7sFQmm2C3uBAX2jw+tJrMcD2u1BrAH21AlcTgAG2NP8Kumf0IKHP6hRjPf0xmG+fa0i5RGaVyZHpEMnRzPOyZr/X8a+hyEiOzr6xBH+tQ1CTWKkR9g8fydbbFUkn3RuKNOH+mLSQq8lSRvpjkcG4Lk9FWnNijfsQG2cCEB1hJnYwSD6ZvT/oEBEq/EzdHvGgL+SRs2zVaQtGXUzyNmS4O6ovVEsbEqyjS2Ev1BcbU7zdTUpjlsaWsKWqspY3ezsOue2SIvTHg9La+Ni2MBzT5akTQb21+aqRvT5TqUVk4mI0gmt0kYGYqewUe3vJ1moI0DFPa2323AMeqDRhAGBQ6hNhgM4207BH+Morr6xdu/a6664rLCz8yU9+MjYSyv79+3t7ex977DHpvPWurq5Dhw6debsA4Iqn3Ts4LxgZGbnvvvteeeWV55577uDBg6cukI5YLLZu3bqSkpLnnnvunMRWPiUYYNqALnmu1hEEL4NUBBQbDRsrTmhBAKAdce/RSEalEYoFhCORDgkBjyK7KHHeAg6YLcuima34ZGhXs6d1jhXzMNAfAQAQSTE8I4BOvgYxLtYd7FNmKuyLzTwtjOz3c5/Zy1GFFYQpgz74H3rfv8Lb3grv/WeXszWNp40Iuj6jakQ71lWc5Tl/V9hzNNjiavfGfBqFusJaUm4pUZIZcVGdM44WxACjAipjq1Xt0sX/P3tfHufGWd/9e+bSHBrdx2pX0p7a07ter3d9xYltnJsQIGkS0pBAgAIhDSGlCU0/pC9XgcCn5UMLtE1CKSG4XOkLmDiXHTuxnXV8H2vvfd+SVrc00pzvH1prtVrt2klsSHn9/UsaPTOakWae3/O7vl9LOtIYSDrCijZXYiptsNZ6DGWSKg+GR3rmBvypoJxXDkMgKOXQaLEskj8ZmE36SZ4w1nCuayz6ciY5Isy+FU7PLXKJML1RWb2hb/SoHA9nvV4qrGOnV2rlDqXDb4y9uXPgZQzhH+HvrBPW+tPU4YDWF9UQAgIDPQHVRvKvGqvvrCJzzfqYBsbenrJEIyeWRX1zWSuYD9yTvKFF7IqW2/XrXxt9YzYVXPhVTZmkOwZZtrbY5MLJE8i+xpicTqemMlR5nTjaW3BMOaVE+hIAkJKEw9NFKkWjmdihyWPbvJt1uK4nqh3ya/f6sGwis85aY8bN8cVNBdL0SEptMNXqcaZwGtSZyPaWhcY1AiM2lrZ3Th6VVcXBwAe98MI4KBokxeSp2a5FF67DF5xLBKZ6fWwwqcrqfHR0ahgAIv2JFWpJQkIkZ5Y00E4FutaUzLuD/jSkZLjeu2wvQXJ8IQYmC4owJ+bSltJ4P1VeyxcTxKjPK5mpNHrTUghBfDA2vyW/kqUAnJvOTUq4DqOtVHI6Q3l84vBZAEhMCiuztQRTodnkQmHqVGIGADk5Z39MqzMiAGi01hVlFlXSb7Pr9yJwCQzh2bNn165dm329du3aqampcDhcMKClpSWrU0iSZHNz89mzZ4sc6O3jd6Nqp1/rjlyQ7+KPDVVV77vvvk9/+tOf+MQnfvSjH91xxx1FVeY3b97829/+Nvt6y5YtO3fuLBhwzz339Pb2rl+//plnnnnqqaf27dt3uc/8HSC/XmlagJikrTKjaqNuo8vDnC+P0VQtdDYeH0k5O0ysk64yletkVfJPEK4KlNcJp1BKoipWZnS9v+q6wfDo4amjN7rhN8NqtopPYeWUJ7b4yyEpJkei44jCbK0GvpzxH4tG+pLZPA3d2EG5a+iGdn77nYHSkthYtxIJwlJoGjvN8QPm7IUoqjISHX9z8FjvwVE0Rhh1hgZbbbWpwsZYsiHQobhWyReuShBCLMHSEcbYa6WDXLI0HvXNZcyChkBNRDHOAIAQAEeybt7VaKtzG0oFOX00eryTOjRjmxZKkiqueTiYy2hFdTSnE7OBVDD7RYydsrUb+Eou3J0MnojKwrw1jWXio3IEd1XIoZnM0FlxvE+JztGzjM5fpOc6kJp7dfj13SP7razlL2pvLYlu7O4y90U1UYE6I+qwowo9eDlwc/g6ZyWzmPklcepILO7TmRzOdSZsiRWROTntTJl1cH8tdjLiXOXYuG90vz+vFj9jS6cdKQBISak5YeG5wCjM1mYM9ycU3KHJkhIpLN+Pj6fSIbFz8nBGLgyKyqq8d/TAWtdqK2MOZ+APY9qdVVi2s4UhmTbn6ujQ/F2RQ6wvguvpglAhAAACSyPv1Du8hgX6pzLeZWdtWVboKh6cDHT6NQA4G+wpKMo1VHK5qjDKQDA2KjYoAICuokEc6QZVkVNKYnzZrE1PXnZwLDqBAebh50/j1JzWYsFWO4u7g1JSSYcWbp34cIr3MIhAACAHphBF83WuoiR85QZ3zrLiGO4zV3nogTf988ZmKDy6nJoHyRL5chN6Dx0fF6jyeml2TEunlLSaDq6UdChoXuoK9Kyy1Y0nkVkHPAk6gqqxFHIvz1/ayIVJ/t4uLkFodG5uLqerYDQaASAQCOTLEM7NzfH8wrLUZDIFAsU7VABAUZT8fT/60Y9+61vfKhijaZogCJqm3ePNHB/WZpLF+Ev+pDh+/HhbW9sTTzwBALfffvv4+Pgbb7yxlHZ8+/btbrcbACRJOnnypM/nKxjQ1NRkt9tzlaVLk6/vBeQU6uMyGoqh1WYN05CbdSmSooACAEpajXSlCA4zt3EqroiiogmJkv4B0eORCSonp60hiLqDkiqBCBQQ2z1XH5h6KyHu3+Jc/2w/9ZcVilWnibwIBowOL1rYhlNhULUyfSlpw6xGLj6YnjkY0lfraDsFznIFYCo2E9YReGmVPDuqYhjGFeG3xKIYcZIeh4lRZZyjuPWZdUaWn2/EViF7IQAwm0aahixkngg4QkbSYIlb0pMKRgJVgweoQFpMnd8DlHgEM9kKBOVpXGeu1oPFOhAd/l30BZZgmpwN9ZG6KoHpjcAaS5Fbeiw6KcmyjbaoqqqqKmEmrB1ccjwzeyjMllFiSXoyOa1pGpA6vLQaQNMyaSU0oySitFgmy6Rgm49ipWThZKDLnwo22xo2l67HAIX79YlRrtWsMedrO+dPFqEy3oWpmCguzGipswOJoEdfpWc9NACUc+7B6EiuxFHFtHBpQJUUAKABrnZgbwXt17o6Xhs5sNV9leV845pkC2txRCWo8egkg2giF10kwdjAzJ2OGkpr08PnyKaNBT9C18G+AccI4ItMmgbaGxOdBspazpWlMuIvh/Cr7JqNkLNnvda6WpgT5gZi+etlcWpWkFzWNoMoFU7WnEcnYhkxkannfUNzI7kWt1Zb067h3V59GU/ot9jRz0bIRl7VE9rrw29ud1+dH7AhrJCcmD8sU0EGDyd0JTjOcIg3CyO9uLsm0B3WjDJGFJolSZV6ZnuzhkfT4MTsmVb7quyPrwGcDhF/1+LVMloiUyRuEOtP5fqMlYyanM3Y1/PZfaXhc3hZNW6HRKJ42aqbLu1KdmdfVxkqekJ75tTm8Rhy0poIYvd0T5WxouiOmEUTp+avFHEACJJhBS+pEAbPEL41wf6wmSkeHc0omd5Afy5CE85EoulYKevaOyv79CCKso+vzKSK6C3JKSU6kaAr3gbF2sWo+F4CQ2gymeLx+X7g7AuLxVIwIP8PiMViBQPygeP40NCCM86y7NIEm6ZpGIZxHEf4DxMxvyOTea+5hO3t7e3t7bm3X/jCF3KvH3300Y985COf+cxnAOCrX/1qduPJkyfvvPPOpQRsX//615ceXBTFu+666+jRo+8V0m2EJgR8LqOlZKg3IT2FVZq8vG5+6ZOcTkf6ksZKTu89T+mSTiVPvq73tdY5y/rDQ7mHIemNIyOiYN7YU0BdV7n1zcm3pmKvbym56r9H2A+WY9UGECsEOsPgmUV5+JgU11JTFQYPRVF0C52JSJHehDAhGWu5GB2by4RwHAccx5xeeXoE4wz5bqisKWEhGk5HJFWy0KZqporCyKLKCpIKI0mtxYKI85QIuEQ4kyXytKoawdrIZwvTLWAMpuamEjOqpmqKLEtpgjPky+1qmBarjih6iQf9Gra51bVqNDrRFeg+gU5vKl1PDddOpXFvMRJ/vxDQkFbCOjRNyz7bVA3Fu9nZMyFpVqa8OpnOcydZPbA1StivTA0ZcB+Jkwl77Eygu2duoMHq2+xZT2AEUlGynw+N6prNSE8WGl8bzpniCYzDsvxnmiSHTkykowbbGhNtY3N/Uz3l6w8Py4oEAGlvnNDjAPO/T4cTTkXUiFp2lRt7Y7Lzhqr3Gc/fGOmapK5HBxIEMnPlRk/uSykHhUQUH0FsppuRRYxdmEklVZ6ZC5hwS8qdR0AAcGjq2GwGxjLtJ+OII8HOoI0l89fi0jubSxsDx6IUubCI1FR1bkgxlCLGUOgOEgzuarFmXTq9Xt8o1PeFBnNX2lbSctR/+vqKLQ4KrbVhbwSwD5WjsBTxy3PV5orcQegGZjIQnJ+UKDB4ldSYaG024L7VwvHXmYp6AEwNYoaaQiPRPdeHCCz7CIxEx0mcrDDP6ysNxMBEwYfr2ziyyJ2hKlokLCzQnw4l+DJGx+oAQA5MaqJgam00lxRZ/2XRqls1kBjOEg1SFFXCOSwwdjhUfXsFAoCJ9HRLWXGGM47V0qNyTmaS9zLpacna2JzYv5OpWa3GEU0wRUtmBv0jOIHj5++TvtmhRlsdo6P74+rd1Ritw9a4VxdljwsORXWUTq/Xv+e4Rmtqanp65jnxuru7TSZTARN0dXV1X1+fqqoYhqmq2tfXV11dXexI8ygQtV8BiXQiqKVnIa6911zCZbBnzx5RFE2mQjGRjo6Ojo6OizwISZLf+c53AMDhKNIe8MdHTIKwqFXyyEQBAijlnVl2fCWjhs/F5bTqaDOSPKHJkjw7poQDcnCKqmwky6pJgAqjdygyomlaxpLOWAvjRRhCm90bzgX7zgT3bHVu2Dlm9xnRdWWQLI8Z+s0Fq594Jt4XHqwwehmC1plI5zpzajY9dy4qqTJtZTOmtEaomI7BDBbZP0G6KjRNi4rxcDqSEJMGHe/SO/SUfuX7aDAODhrpCcBknIpRVISh0hTlIi0dTK74Pgsba2VIZjA8LCUiGLvICgIGicqYol+wWAhQhdFTYfTMJP2nA12a+Wx54GoMbEYK58jC7EUgFRTktIOxMYjGMCxbzpDxZnRhhh80i2Yh5Uxq+EISBTc7NABpdjwtmnr7R8RS6YO+G1iSBYDgHJHsNqYSWJMZ8YsLzlQhQU5PGjNINtqV6BymN6hcRXScInVKyQY7zi+aoXS4rsZUORAeSulTaUsqP6+DAG72YL8cUh9sLF3rWv3qyN4bK6/VUywAaISaqIwa+s3hdMREm3IGEgA4NyMm5HRoPTr0Ml2/Jlc1MxGbVFSFDrKSIZOr9e0KdA9HAym07dEWPCHDVFLLMpJANrdXti4dFIXggmuhJqKhY8MIGQ0NRYjvzfX6fLLWVueqwchIbq3mM1f3h4eGIqPVpoqrS9C/nlX9aeSg4ejMCa/RnauaIRicK6GT0+dVGsrZmYMhMSZTBgvGm6TJQdLji48IvJfNZ1LVNK1nrv/8azjp7+ooWVCwORXStnp8Ra0gAAizGeU8uaiSUVPTaddVFgAATU33Hqfr1xoqV6pb4UiujHeNn0/ZNlh9h6dPDglVUREZKfCngtFMrKguPMKQvmyhZIZ10dGBpKrqybJKceScrq4tOSEYl9h7VVN75wZzb1NSaiIxtb507awACMBBQ7nRU9QKyiklNXNZxBUuQY7wvvvue/755wcGBmRZ/qd/+qd77703GyX43ve+t2fPHgDYunUrRVHPPvssAPz0pz9lGOaaa655998LAK/BjEiSFeby/yV2EMrLy30+X1aD8B0DIeTz+Xw+XzYQ/SdHXIRqHpkpQAAWxuxg7aqiRYeSM50hykCWrDeRPAEA6XOHpelRzGBh174vpyzPU3o3XyazctITX+74jbbaLZ6NA3OHrrafk1Ttv/rUBC0JJUXyBBk50xsaGAyPxMR4UJgbIUYDNTPJshiRIs3ddmO/lZnhGcotKPJ4aKQr2BtMzRl1hkZbXbnBza9oBZGCpeIEF6Fb4ryx12rssZJxHe9myrbYTfX6AiuYBUcwZRFBDQfyNTE0BAlvTDIUf5hLOMd1FVs6GlbPlJ+dFroGwhOH/cmlrALxTHwgPHQ22HPGf24iNpml+c6YhWhdECmYqddKhxbJRAgcO4QLwWRgrW7NjbEbbTPO6DlD1xumueNmG+DrHci0OOKupuLazHiNbwO/9XZmzTXMhg8klcboJGPy6RxbqnG+yFxME7pqa6VULiwt6SpjocGEnulRM1DeaK1/dfT1HC+rzEmCIwUAY7HxAvUPc60eUaxs3yqOdKeO79PSqaAwF83EAAA0jRszZPkQBsIjZ4IDM/Lmu6p0JAZmCprMKFfU0+pcZSD14Z7zt5amiUNnY291ZuRS28byQtETANahY52LfESO5HzmhUwVQrChtP2E/4yoiBQGGx3owIwGAClJOO1fVDVjqOJyPwVGIEM1m6W+09U0Z4a6QJFVWc2x/WUxk/RH0vN0SiPRURIjy3hX9m1agf4oPLCqOLMoAOTXAcWGU1wpjVEYAIhjfRijZyq89IX0gessC0xVJXqHqsl1hrmTcxoAaJrWHxpcbke9m1m4UhxxLiYxlqLK68XJIdDUxGR6abhuIj6VlBau/Vywr8ZUSeHk8TltlRkBwHKcarGR1MVz1rwtXBqF+r//+7/v6OjQNG3Tpk1ZNVoAeP3111mW3b59O47jO3bsuO+++/7mb/7GarXu2LEDwy4No83N5I2Dypig/JH6BS8e+/btIwhi5dDl3r17T5w40dbWdvEE3BePI0eOBIPBm266aWho6De/+Q0AfPKTn7x4zSZVVaPRKMdxuWDL4cOH9+3bh2HY3/7t3xYMxhFk/QmO4txMaXw0FR9J6yykc705pxarCgk5OM1v+VA+SXQWDoM1U5GIJYsUE+VQwjk+4LvhjfFOnbbXy61/tp/9WE2SjJFEcknnjKbFxXhcPD/3IZD0oqQXkRaFOK5GgJrQlYsbpYiIUTgQoEVVDYGGa4CpC3EFFTAZxyQMkzGkISRjAEBisplRVFZMemIyI3tNZRZ62dCFlhFSJ95gSNLXuG1UmM2Vz6Xc8RVaNbIw08YtdUbFrcpdWCg2PRBWzLTRzhhYcvl2jexZE2rCEyUEkp3iaT8Xcsb9umAsE1BUxcWXMLMzJA9hFQa6aRyDeg7ZeUAAmqoosYgSC2lSBmP0SMeo0VBtzQbG5lYENTEhJCcEzmu0tTPL6VhlUdZkN9uufmV431L635vcaCiO9kypCGpaDMLukTduqNyWzQsKrgQVo0CAkeioz1yNLTAjIGurIXA4Sri2Utrw7FsvTLnsmHH+BsYkjB3jz1rPHp05OSNvu61Sb1wyz1sYc5OtPjaYlJIKAKhCQjj9JmBEWtduruaJJULqGIHMDUUqbFscTf2hoRzdnZUxlxvcJ/xnNrnXtdvRv5xVQxlk0UFXoKfGXJ3zaymeoK1UzhPVl9LxkXR6TqStNsJWKpx9i2m5KjEuGCrY3DPSc754RNW047NnrspTBDwa1FocNWX64u5gJirlWOjUjJqaTpdsyoayM5nBLm79dcZK7oI152W8S09x2f5FBKjO4huPD5wKWbe4sv0qw20lq7ElCtgAQLA4bSGF8wXMei/tPxQ2VFsxziAHp8FeJgQzjH1Reqt3biD3WlKl/sjQB2tuTMpwJqR9rhGzsZaiGs5KRk1MXK6p/tIYpC9+8YuhUGhmZmbXrl25uN9vf/vbbCYMADZt2jQwMDA5Odnf338pu8IVoKI0P2x6r+UI9+/ff+jQoRUGPP/88w888ABJkgxzWVjV33jjjeeffx4Aenp6nn766ZKSkosPqd99991ms9lisfz85z/PbeQ4juO4L33pS0vHGygAAFphbEH79MGwGJVtbQZrM5+vmS4OnaW8tUutIELI0mxYX9Xm4C7gJTMEfX3FNg9fFo6/asKOPNsfCXti2kXw62mgRcX4YGz0dObshHk8Uj0XWRWIm/sThjHBnsiY05IhrTCiSqkqrsY0dSKjDIhKkE0LrkS8IhKtDg3WBP7gnPH75jJVkbQ9JbMXsIJqLJzsfIl0eti17zPxdq/BnZ2GBFcyY7vYJxnnMHY13lBa7dKXB9JoNDbVFegZjU1ExfjKN7vMSP6K6UHjOD1NVgyXmcI+VakNypakyZ2eHBFmJmv06lorctCAANR0ShrrU9MpwlZKVTTgBjNSlDJXO5FyBI5HZ94KaYrm2GA2VrMrW0HaQvFe1sk5tng3YcXm3Coe/qoOK+PQQGqVmTbtHnlj3l4iSJTHAANBSo/FJrS8JxkjMGubMT6RzugqAr4aJRkVR3uVSFBTVQDIBKSx3mkgr1ltNZQvCfthCLvKvV5OqIE3zginDiQ7X0y++SJZ4hX5DtJAsa4ifb3Gai7/js2BI9k66yJe31bHqonEjD8VoDDosKGDsxoAqJp6eHpRe7ShMi+4hyGjj432JQGAbmhX42FpclBTtejAvGMUFxNjsXlewL7QgEHHZ5lxAEDR4C0//ljbsjpE+XTesVGBc9HZ6tDMwBnSVU7ZLEWvtwAYwmotCxmrGnNlSJimsHS2n0eQ00UbN7Pg3AuTGMHglJlKTqep0spsu0hBiWxcTOQT4/XODbr1pSzJvuXXmsxIT8By8k+x4eRlcgfhEnKNIoRo+gKcOpd80md9VLwiEqkPXrBl+I+MJ554osBzSiQSsrywUu7s7Lzrrrseeuih9evXZ7coipJOF/EVEolE/vZwOKyq88mAZDK5tFMnFosVbLTb7ffdd9/Fx1E//elPd3V1bdy4qGCvqanpzjvvXDpYAzBIpGHIwveakIocHSZri6FAek3LCNLsGFVeJNxhqGRZhw5D2Dbv5qJU+vlACFbZ62+re3+dSa9TXtsx/Gov36MsIyWoAaRkYSoxey7Y508GTJShyVbr4Us5ktEwAIdJEMZEThCN6bgxfY4SOlHiVS1xjklorpTBkzoNwllZHFPl43G5J640m3PxQ+Q1rmQF5cBU8ugeuqGdqpwvczfTJo+hLOMQhJK3x/mn0EqsJuQwUzUmZ0SpZulqlmT9ycDZYO9YfHI2FYxkYoKcljVFBS0hZULp2Hh8unuuvy80PIxHpqoCckW6gtRv9juap6x0tCzDtpRSjH6mTw7NaIqspuLS9Ahh99KmSlq2sEGD0V/hmF2DTZjEuMS5dKXXWE31+qLmIR8YjixNfPYZ9BrcG0qXzXbfUIYkFQmo3aDjXx7eJyoSACiMLDiTABBJR4cWU40TNGZooSO9STzJkaVVRIlHzaTE0e7g7MBodHytuEWLO7IuSwEabXU2yjjx09+Jw+cIh5tu7NBv+aBEVqTnJHNjkWwZxROGiuL+FgC02Bvzu+ZJjOwoaT04eVRVlfUO1B2Z73iZiE2NRRdIbmkrlc+mxjp0CEfJqTRgONN6dbr3hJqIJqaErFJEV6A7W54qq/Ip/9m1JS25HU/NaR6jr8Ne/PQUSU2el4xXRTU5KfCVDACoyZg0PaKraeHLL1Yy3meuzi1iKJwsN3rc9FA2OgorNhSyTh2Wl+zUe5nEmEA4vXJgChQ5FcjkqmkAoC80mFvuKJp6bq63yV6fUeFYUNvkRDShqzSVF34BgCJeRncQ/reTbr9n8eUvf/mb3/wmALz00kvXXnvtRz/60ebmZqvV+l//9V8A8K1vfetnP/vZM888097efuzYsUQicf/991dUVDQ1Nd14443Z3pKdO3fecMMNH/7whxsbG3/4wx9+8pOf/MIXvtDY2Lhq1aqRkZEDBw40NzevWbPG7Xb/4Ac/yH5pT09Pc3NzW1vbmjVrzp0rLq3Q1dX12GOPrXzy27Zt83g8K4/JAWlAiISl3FC6xWaq05PFsmXi8DmqtGqpZC5toXLcEyzJvK/iGhy7sIunw6nVjqaPNNyaRr4D8tm9yTf6w8MzycCcEJ4TwkEhNJ30j8YmzgV7R6MTCKDaXOkzV1kYc35gB5EUrjcqIb8GcC6iSSqU82ijA7WYkVUHegLW2pAGEBPBo0frHedrSRDyGEpXtIKT6a5Odu02wrnoB/T6Sls6incHrwxVp8R8Id4kt9tQUibGkmYLW1VrruIpvaIqISEyGps4G+g7NXuuLzw2FAtPC0REcYuorsnqstGMzIkpTzTSNCu54zZa86b05nCdK7bNPtFsPmezDHpcia22wSrDsIkOskjCMIfq2mxxXWWxNPGsi77ICdRYw+Xrz9VZa1qdxWUyMQR3VGJdYY1j1tpZy8vDrwlyBgDSzpTEygAQFxP9oaGElJRUSQPNnwoOZoZjlWFu3EgmKEzHkk5v1OGYxeRyWcf5p+9RDKRceM8YKL6FcY99/18zUYldfwPpqsCNNlnAIn1JW6txadMCILCsKiSXyQdDMvlCDQDg5ctMOv50sJvGoc2GXhyfZ/Z4a/pYfmTYULlIttBYy0UHkpoKGGdmrcnpAAAgAElEQVTUVa/KDJ4BDSJ9CUESBsLzchZng70uvTN3j2kAB/3ko8u7g8nJBVaR+EiKdelwHQ4Amd7juspGgmOKNtEXBUsy7rzWyQZrbSIz2BPNKg/CRHwqWUz9GLIlM3ntmLSZBECZBCIsDmlmDDTI2TBVU/MN6nB4xEybLLTpaECrNiAzBbWWmpx4ZD7iI6mCNtBLi//dpNsr4GywJ72iVvglhJ7kCoIngjBfNSBJ0t69e19++eXnnnvuwIEDt9xyy7333vv4449PT09brdb/83/+DwA8/PDDCKHh4WGCIB5//PHHHnvsJz/5iSiKr7766q5du2688UZN0+6+++79+/cfOHDA4XDMzc1t3rz5N7/5zaZNmwKBwLp16zZt2tTW1nb//fffd999jz766PT0dHt7+0033bT0VGdnZ19++eVs0emlAQK+hDWVLktfIgcmxKkh/VW3FGwnGNy22pg/+zhY26ayjv3jK4WUc6Bw/PYqz3/2ldU2aPKALpgQOUIiMECACIzgKb2Tc9A4lZBhOb5D3OIUx/pSKcGrIZ4hMYzDME5TVTWTBk3DDea6AhcaoTK9y8os2/kjB6eFM53s2m24cVEuVu9hLI28FRkogto/fkhdxoVdDiqpxmvC3JixBaP8aRiJa4pGVuqNpXoMADIqHA1oa6yIXf5R1hDIelHWn+/3AgQKAkkBVQMa186TkbIkU26uKpoHWgE6E8lXFBb4rXE2i4qYTxWWA0vAX1ZjOwbVVeY1HsPZXYOvXltxjVFnSJVHjb0WUFFaTg+EFjkfMivFK8P8sDnuDQ9pI4IslBlqumO4TzfF+SewQXe8KqJoSSUewWgWkVTLWHT62a9Jrg+wDS3Zel0lowZPxswNfNGFmrFaf0Ei7CZbQ3ewP1/yab1r7e/7Xy43eraWGP/vqPZsv3pXFQaQPBM4t8Y578+xTh3JEdJ5hS2diaSMZHxUMFQyZGlVZuC0JotCAEYHRrPmM62kzwX7bqm5LvctPRGN1jW+r3SZ2Ka2EHhURDUxlS7ZaAYAJTSrJKJM6zW89wIx7QLUmqtzTq2ZNpooXkYT3RFviwWpmtobGmzLc1XzoXczsVyfOwJ9OZMYFUylVeJ4P1lWlZgQjFUcIBiOjgnS/AlrGpwJ9mwsa5c1eMuv3VODYQjVL55Is1BlLb48BcElwZ+nIdRA+8W5/5tP53pZ4dI7H7X+9XKfNjU1XXvttQCwefNmSZJmZmbKyhbVbf/yl7/8yle+kmWNqa2tfe6553I73njjjQCQtan33ntvtl9i9+7dNpstlUrt3r0bAJqbm1977bXy8vLDhw/v3bsXAFwu11133RWLFZKwAMD27dtPnTp1aS77PEicAFXVMoIqCrjetJAI1LRM/0lpeoRt24Z0i5alGIHZ1xiX8lzUmKvC6WhXoPtivteig/d70P4ZqHaoq0RHTEKrjYue+YkkDMa1NVZUVDsX4YTgqJ6MiT4DwhRRTcWl0IRIxxUeaWKSDpQw1gZ03kNFCPMaynJCpkuhROeE0wfZti0FVpD3sJbG+bBhlamCwqh9YwdXEt0tBg3X4hVhOsjaJ3kHjcIZrTuKAIGdhv4olHErWcEiRwMNcA1wBIAAclaQrTJVvF0riBHIuspQtBBjnatN0dTeuf6lH9lp+HQ99ushdQY1ttm4l4b3bvFsLOEcKVeSnSxe5S+zUtgb4EctFrNtzkiei6IaAzLTpdLUiDY6w0yIQfV1zazTMkJVRNQ7b8is+xuKnjfPSkbxH4lxHpp1FqmcpAyksapIpX4BaELXZKs7mVcaypLMWlfLgYm3bqm+9o5KbM8UPNOrXlOCJLW7ylQ5XzWDgK9gQ2cXnkSTj509HOXcNE5ShNUlT4/i7uqprgCqRRrSTvnPVpvL8+X3OgPs36xdVpY2FcjkrGx8OMW5aFyHa+mUcPYtunYNRuF8+dvLRpXxLo5kczNng9V3ZKbvVMjTYkEA0BcebHWuKnqTkHpCZyYz4fkbm3PRsYGkWl2ixN7SMoIMTLZk5lywJ7fLaGxcR1AlnONIQCvlkJMBj8FdtD8kNpxUpUtPq5aPP09DiAB9/ZrH/9RnMY8c7Q4AUBSVT9IBAKqqBoPB06dPj4yMZLd87GMfy76w2RaVTuXe+v3+TCaTtYIA0NjY2NTUFA6HWZbNpWmtVmtRQ3g5IE0Nx/f8ElE0InVaRqAqG8mScmlmVJwYwBg9t+nmgqAoQsi22kAto+ze7mpNSqnhPFXSFdBgQg0mBKASlljvEWMgPS8QCABRCcaSWiWP+qLaWluRqTopw7kk1WjVZQtj5QouXcaqhBMAQNOi/aeiE6dtlptJzUTgZKXRW7SxaR6KIpw+yDStw02LSn4MFaypTp/v9boNpR+qvfngxFtTiZmLucAcEEIZuyBzIjtutCHdakw9FVbDIhJkrdH8bjPkRtpQbvC8XSsIAJZGntQXn0MQQhvL2hVVGSiWW2Jw+GgN9vKkts9ffp2L3T/+lpUxr3Wudsd0ZLzwxpBUaTYVDGciXrendKoSMmlXeZzCAQARJV55dpwg+VLbvWm7aGGMbdbW1FQGnU+TK2nVfzSqd9NL3VYAQBiyNhsuMgLcZK/vDvXls7vVmCtHouOn/d2rHU3bS1G5Hh0Lai9NSJ3B/c+874ZsnF9fRkcHFyR5CZbgXLroQNLSoCfLqjJDZxMWI6RAF6RnDbPD4fEP196cO/6sAJOZ1g95l/VWY+cb+OS0mpxOuzZa1GQsdXQP5a0jSryGSg4j3+bKBmE+S9XJ8wSqXmPZ4ekT/lQkrVhoHARJGImOVZkqiu7Ll7OZ8Hz7B8JAX87GR9N6jy997giz5pr4SCrKRoOp+eJwDbTT/nNtJc2qBgdntTuqMACotxZSawGAKqrx0UUujZJW5bRCLHPjvTP8eRrC/0XAMKy2tvbaa6+97bbbCj5aruK5vr5ekqRvfOMb+YWg6XRaFMWRkZGKigoAOH36dD6t3WWEBrjeyG+/KyuaoyaimYHTmf5TRImXadqAmwtrQRFC5gZ9QTn1ogGArvFsFBWxqObqcpBNorU2Mdijt+gQjkDR8K4wu95Jl+vJF8fjk6mkm120okwrcCakVfPIRIFGaInyxWJMCOlqW2Xz5PSZX1QZttfZbiHxldqw0r3HcZONcHrzNxqrOFNtEf9GT3HXV27rCw0cnz198dF7DGFVpvL6Gp+xw5gYESL9cY9J/u1wbI0liMFK4r2LgJBCSxInEQKJp3CkIUDIzlhL+ZJ3kL/ky1mudCWHAwHa7FkPAEVtIYbgJjfq9MPOCftdVTeHUwMvDu2xEuZNqU16TI8Q0kBLy5mEmEzLGStjbrDWDsfxMXtwY8KED9iSnqjMSgjDSVcFAIAGhjmm2lKTzKssEwJi+Fycr2R5b/HzNDfoCwq7VgCFU832xqPTC7rBCNBVZet2DrzkMZRZaFONAWoMSFDQv3eHftZz4uON7QCAMGQoZ8O9C22yhmpu+mBI9NCUrTR+9tBMZAIIkpnRn0q8tsperyMW7rQzUfvH6suX5jSzyIQXuiZiwyl9KQNSPHVkt65uDVlahetwvvzCnu5S+MzVp2bPZutZEGB1Vl862N8fXddsQQDQM9e/nCHknHSYjucYsXkPPbU/ZexYJZ9+VRzvA6gdHM0TWYxPA0AZ7zo1p1lpKGPBRBtdnHPpYaPDhdnBueNxYxVHr3rnkj5LccUQ/unx9a9//eGHH47FYrW1tcPDw+Pj43/3d3+3wvhrr722srLy7rvv/uxnPwsAnZ2d119//bp16z772c/ef//9X/nKV06cOLFv374PfOADS/d95ZVXHnzwwf7+fgB48cUXH3744b6+voIx//M//9Pf3z85Oblr1y6/33/HHXdUVRVnvwUAQIAZLDnpOExvZFqvXnYwgKlOz3sv8HxiCNtWfvUrQ6/5U8U4spc7crkwEELdYT2G8VPp0g472e5AAHBLhfXHvbKdjftTgbiY0eHA4jCe1Dx65GRApuVEVUTVFQm86Bze9bdtLX31BeHMj7RVn9KIZaJ2wWk5MMHlJUERhixNvL5sWSOBEKqz+iqM5af8Z7rn+lfOGjIEXWupqbf6cszIvBd0DsIyo1aY2IxoHo1OJC4kQ69SatqWFM0ZlZr/LqSAPmqqT9Xx2AW0copCZ6LMdRfecWVbCAAbHchEwc8HYIOj9va6mlA6FMBmlQkVABBCOpwq4RwsyURF7FxEU1St2QYJe5iK0PyIWeLEtD0psxIAYBheafTmOEuVjBodSGZCknW1QWcq7lFxZTTveXumosFa2x3siykLVo0lmfaS1v3jnbdUX591ARkctpeip8/2bC1zVhg9AKD3MNHBRG42xwhkrOKiPUl7uzHksEmxEGFxJgWBT5gb1i+4RJKKXp1p/e7mZRcoOT4XOakIsxnXJkv6zD6qalWWiMdQxWLEOwkV6CmulC/JLUPrzNWnZ1/oiaSbLQwAzCYDISFsYYrViyHgPWykf/5WRDji3Ux8RDCu3pw89LJiNIcGY3C+IPSM/1yLowEA7Z9Vb/XOu4NLl/5KWinQDElOpxEGpou4994WrhjCy4Jt27Zl1TZqamruueee3PaHH34428Zw7bXXctx8NPz22293u93PPffczp07PR7PHXfcAQB1dXV33313bsdbb701Z40QQi+99NJTTz31n//5nwihlpaWLGXdP//zP3//+9//wQ9+sHr16h07dkQii0jxs/B4PLnzGR4ebmgoonuZSCTC4XD228PhsCS9vYTWCjDX6Q3FIlRLQWLE9VXbXh3ely/UckGsahH9Q+XtouH9HOQ6rC062FaKD8RMTtro5BIhIRzNxEs5KGNBNKeTxZoRsz1VLY4mjmThkx3Jgy9Edn0F2h+UkFMc7ZGmhjHOgFtLEE7IgSklOse2bUHn9RlwHW5bbaAtF6ZH1xHUutK1LY6m4cjYcHR0TgjnFxzSBF2mL/EaPV5D2dKgJU5inI81VLCJyTQ7QU8HAtOJmSIiUwgkXsxYBdGYKXD5Kqze9c3tOo2K9Cfi48Lb6sQl9YS9rVDZbjlkbSFL0qf9xSuZG0yolEU7x9TuCLq13F5RA3rKqPp1vVEtnQEEoGigwzUXi5z0PBuMaEpLvKgL0fyYUcU0xSDZHBYyTWUSkpJRU7OZTEhkXbRzo3k5Y0AZSEtjEc6wlUFgxGrHqv1jnfkbq82VE4mZIzMnN5TOi/C0WNDhgPaDU4f+vkNvYcwYgfhyNp9HhnPrEuNCZCoW41l1ekQ128djk2v5VkxQZG7+cZvM+K4utSyn9iXG5Zy2Q6QvYahktFRQTUSpti0AQDD4xReLLkW91ZczhDqCqjSXn5zrVbTWbNnNubm+ze71RXfUu+no4EK3n97LTB+cM9SY6fq1Y2f3495yrBRTSXU6MZtWMuUGb1dI0xNQrgcSJ2vMRdTao0OpfKU9TdGi/UnLKp0mi0BeSuOFVpaMukhMTEwcPXpUVdUNGzaUlhaRUuzr68sRc9M03dRUnCtIlmWGYS4482qalkqlOI6bnJw5uuds3BD95F1355jXryAfu3btuueee9atW/f00097vYtid5/85Ccfeuih1tbW5fbNx69//et/+7d/e/311wtUFJ544glhTHro7kdW3j3barZyJG0pJFXePbwvJ8+2MnhKv73iGjNtSvkzc2diK2TXFU2JyrFISWiCmSigQTHo+GpTpc9cyVGLkvbSxMDcf/1jJknJnpswZ5MqJJS5GU2RCVspYS2Zrw9CwHtZk0//zlbiAJCUUoKUJnCcQARHscuFKyVJUhQlv21XjMuRmVjP0GAwFlJxFTBVoVWFkiWjqJKF1tGg4zeUtufouwAgHRLnzsRyck4rg2DxknVm/ELi40sxEB5+c+JwfptgAU7OabuntGYzcjMofsrcTJE2GlQNMATLtjJqwAisQ7HLMU3NqIhAGIkxNpJ10StUSxIsXrLeUlST6IJQNe03534XE+M4vnBOsirvHHilzdmSU9CdSMKvh9W/bWE/5LvOoOMVUZ18PZg/p6dDov90OFwXEP2jMyCoDFtu9CiMHKsLa0jjKf03u697ch19XVnxqwicjGRZN9NzYrgn4dpkSR3dTZZWZjWuba1GruQCXbkrQAPt+Z6d8fNhhpSU+lXPyxu9t9QZSQDAEPYX9bculzIPno4mpxai09H+hCoBX0+fGTwohWblVea0D3txaE+tpbqMr/hRt3pHJebhoMFau6GsveBQUkKefjOU30QfG0qJcZmTO903V+rXrBR5eru4BEZ1x44dn//856+66iqCIO6///4f//jHf/EXf1Ew5oEHHggGg9miR7fb/ZOf/OTdfy8AmDijb5M3gPvfaw317x1s3769q6sLAJzOwvj7j3/844s/zk033bRp06aiacsLegYEg9tajResUF8KEiOurdx6eOpYf3ho5RWb11B2lXsDTegAgHXoqI2WcG885S8iS4IRmN7FeKucBIMrqiLIaUEWJFWmMIomdHqqeNsy6a5xPvbvoKlA0emgmJrNCAF3rk2Y4gnGruNK6eUqRy4SHMmuVJKzPCiecPAWh88SFxM9c/0D4aGl2UcMITdfVmetKeNdBSaWtlCuq6zR/kR8XFiZvIPUE461pndgBQGgxlxppo37xw8VCPjl0GpFdSb06qT2+qx6+9pY2bgZk1a0VQhZWUup01m082w5EAzuXGd+Z1YQADCE1jiaX594c9ExMeJqz/o9owesjDl7C7k58BnQT3pTJL7vQ77rGIrm3Uwsr+jDT/gzepWd1scdtmh4pDqe1vQyLhC6ACM60yK+ISGT1y5jBdMhMWsFNU2L9iZNPk4JzajpVDYoylipd2MFIUuxZq3JZUNZkuUZ1+lAf52xEQBUTT0b6FlX2lZ0X76czTeEfAU3fTAkOJLIYCEIQu0anWaSaTlTZSrfOao1mJCHAwyhJnuh8A4AhHsWKRgrGTUxmrKtJqRTYV3DHe/mApfiEniE4+PjFoslG+h76qmnvvOd7wwMDBSM2b59+wMPPLDUQBbg7XqE2beZTMZoNBalZbmCy40nnniCxKnP/+Ujyen0UpeCYHC+nOU9F6CpvCAm49NvTh5OFOvntTDmda42l75Iml1KyPExQUrKSkbFcEQZSMpEsE5dkZbqtw9N07JZH4TQO3YB3xmWeoQF0ECLpKPTiVlBFgAAxwg7Y3Vw9nx6lOJHTiqRvrjgF5dOCwghvZcx1+kvMiK6HFRNPe0/1xU4t5zcq4k2evhSlmTpNB06lkqmE0kpJSmL5gQcw/WU3sFal1NjWA7ZoC75ttpNliCdTu8Ze8OfLkxg94YGzgX7bq7ersN1AKAB/GFMmxG0TzfwN1VusuKWqTfmsjP7ZHw6kAoiBTP1WM9YzvAWjksJajxCeWo0DEMt9s+ebfzNtcRVzmI/tQbTnXNiTAaAxJgg+DOWGil99i2qahXpqkAYcm2yvMsFGQCk5cyve36Xi5cMx6J7R/d+rOkD2TwoiZN31H0wv64nH/6jYSFPkjc6mAyGwnFvGADUVGy//CbbYsbJyt+OqJ9rxCgMqkwVW7ybCg6Smk0HTkTztwRPxUg9oct0IR1Z9Zlr33MyTPksJG63ezmDNDg4uHfvXp/Pl5Wi/fPGK6+8QpLktm3bVhiza9euM2fOrF+//rKSbvf392cpQx988MGLVL0QRfHMmTPJZLKxsTHXs3Hw4MFXX30Vw7B/+Id/KBiPEchUqzf6ODEqSwlZSSuaBgSDk3pCZyQvibNexrtur/vARHyqLzQYEsIUTukIXQnn8PBlVsa8XHktqScsjZerdBYhhC8R8HuPAAEy06YVuh6XA8nh9jUmKSHHRlLJqXR21sZwRNt1vJe5mMTnBYEhrNW5qtnRMBmfnohNhdORmJjQQLXQZitjqTB67HmEy26D7D8WUTKKqIhJKaVoKokRJEYwy/OPIwwVdWoRhgxVrLGKe5eGHAAQQutca18c2V0Q5q2z1CTE5GujB66v2IpjOAL4gBe9OAE/6Y0jbXers1lvM8bGUgkxGRJCACBjcr9xoD5SnyiJgo6XJVHyT+hc9S/sLfnhzVDcCgIkJoWsFZSSSnQwwROnhDMpylubrZ7lvcy7t4IAkKU6y4lOVBqMe5DlyOzgBlctAEiK1BPqW+0ozndjqOLyDaFgT5KjJCEQMiOnSNyW8Jj9c0/J6i1ejMIAIdRsL6xUUBUt3Luo/kvwZ6SEbKmnkwdGuS3vf/cXWIBLaVRlWf72t799//33L/1Ip9P94Q9/2L1796FDhz73uc89+eSTyx1E07R///d/z71tbm5eStKdlUTPJasKslbvBZw4cYKm6RUM4S9/+ctvfOMbf/3Xf335SLe7u7uzhvAXv/jFP/7jP16QCTaLrq6urVu3ejwes9l87Nix7373u5/+9KcBwG63l5eXf+pTn1pqCFVVzf4FBI8R/KK5skj5xrtAGecq41wFG3PMq///QDmPy3R8jEGmBs5Yz6qipqQVgiOyLu+l/cai/2bBt+AcsrXzweNRMkWadHlMP4s9VoxCvIdhnDqcxjECKaIqxiQ5qcopWRZUjEK0mdJZSILBVU29+GaT5aAoip5gm+0NJ2bPFHy0xtm8f+LQ3rEDV7s3UDgFADeUwg+6YTyhKuopTMVMcRuoCABUTR2KjDJGGlRNP8nH3THcVqpNDAWHU1vL1Q1zMVkqUo6kiGqoN65pmqZpoVNhnTLANNURtjJASNM0nMb0lfSl+ptqTVV9eTIRDdbmc8HXq43lNoYCgLOB3jqzr2iMgTTilInINtcrmuJPBygnw8zoYxWRqcSMS+9U+2Zq6xLVPK9p4OKcRspQcM6RvkSOKAAAVFkNdyesLQZpopdwuDWCUhTlgnoaOWAYdsHBF2sIi8rGfulLX8pFOzVN+9znPofj+Je//OWlI3/3u99lqyj7+vra29vf//73LydJqGna0aNHc29pml67du3SMZIk5SKol7Cs8VJhqUrD7OyswWDImb3Dhw/fdtttOXUOABAEQRAEi6WQwcvv9zMMk20KlGV5amrK7XZndaz8fr/ZbM7+sDlMTU0VCPZaLJbbb7/9Is/cZrN1dnb6fD4AeOmllz74wQ/ee++9DMPU1tYuJ5isqup78C/4M0Y2NJpfrHG5gAFiQdFk5U/495JgaeeTY+n4iJBfbDL/oYHg3Dq2RIcwBKDNnyoCwogRRix/ftNAlS4RO4kkSQihOmNNf3AoKhbSVmws6TjuP/X7gVc2l3XYGRsAtFrQ0YD2fremYErKkmD8XEYRx+KTDEG7OGeciZgHbLo5OmNOj+o3Xz35ugFZhJBz5ohiXqXPV+5VRTV4PCYJCgAkBhOaENbX2pDFpWTXgggsDXpFUxTp0hhCA8E7GXuO+WG9nQ8kXf8z1H1b1SozBUkleWL69BpHcVJZxkOlgmkAmE7OyoosmxOWoE30y0AhgrDMQvM1cweVqvUA0GDyFcwemZAUGUrkZ/ejvSnaRuJ6TTjVp1t9jaIokiRdfFKPJMkLPiwXawiffvrppRvzg6Jf+MIXurq6Xn75ZZ2uSJ9jbrKura1dv3798ePHlzOEGIY988wzK5+MpmmqquZcnItfGvzR8Nhjj7Es+5WvfGXnzp1f+9rXvF5vb2/v+Pj4k08++dnPfvaJJ5545plncBx/7rnnduzYUV9f/6lPferYsWMURdnt9l/96lcul+v555//7ne/a7FYBgYGHnzwwc7OTo7j3nzzTVmWX3755eHh4c985jMcxwUCgUceeeTRRx8FgNOnT3/oQx/S6/WaprW2thb9I06dOvX000/neLqXoqSkpKSkJPu6paVFFMVkMrmy20oQxEW6m1dwSYDj+Mo5wj8/sA2MucKQms2IMUlOKQSNE3qCsZE60yWI1r5dIIQQQhRFva/q6hcGX13aBrqhrN0dn3pj4pBLX9JgrWm32/71rHqDB6dxSJcKwpQ4Ew2U6B22LG8tBvHKqGHAMoPborjR0HaNeGo/27FdiZkix1O2NfNVZoqo+s+EtTQiCCIdyCTHU2ZXkvYulHwbKllDySXurltbuto/tJAKvaG85Td9L/33UM1HfXqLDvpjQ00l9QaqSPaBLqOFMSkeSoQy4eyqPeqJ2IYcUKudjaNSq90Q9iZDs2WVa8qti0rZFVGd60sQeXptyem0GJVLNpjlqQFcb6LMNg1TaZr+0+QIVy6yf/zxx/fv379nz558NpNMJqMoCssuqoITBKG3tzffE7pMCPcklMwfKWRK8YShalHSPj9ydeLEie9973ubN28+cuTI9u3b/+qv/urrX/96NBrNkW4/8MADdrt9YGAAw7CvfvWrjz322M9+9jMAOHz48GuvvZbNIHZ2dnZ2dr755ptms9nv93/0ox994YUX2trawuFwR0fHli1b1q1b94lPfOKRRx556KGHgsFgW1vb9ddfv/RUw+HwsWPHlm4viu9///vbt28vYHq7giv4k4Bg8ItsQv2jwcZa20taD08fX/qRmy/9cO37B8LDByYOA0AZZdo9xhuJ5ER8up6q3WTemC86JurUMSfpnlDXdWiUwYE1tKeO7eU23CgDM3MoROhwRCBV1rI8bWJEmjsV4fVjbONCMx/FEzkhl0uIEr3TydlzvbwMybTYa0dip3/av+HeGsxGK0emTmyvKO7SWBr47pf7c37buDbhMqjshB0zh0sYpGp10vHjbesW9dFpmhbqisnphXlbisuR3qSjw4RAyQyeYdq2XvJrzOISGNVnn33229/+9h133JHjQ/nhD39IEMTXvva106dP79y5c3p6+uMf//g111xDUdSvfvWrkpKSW2+99d1/70rQIHgymi+CdVlBGQoNYT6ampqyUvUdHR2Koiwl3X7++ecfffTRrI6uyWTKEmcDQHNzc34dzT333JMNTr722mtms3lwcHBwcBAAapQQDaIAABRXSURBVGpqXn/99aqqqpMnTx48eBAAbDbbnXfeWbShfuvWrZ2dnUu3L8WOHTt+/vOfHzhw4GIGX8EV/P+JRlvdTMqfL0OYA4WTjbbaBpsvnI4MRGKn5mI+l62tpEVPcFQfCec7KWbTxLmox2fiVpkysRMRaq2RKimn0qnUkd1sx7VIx+QbBjEhB4+F9GQv374RzkfCcAqzrzG9+yKgolhlb8gntWiy1Q+EX1xrmXq2v/Q+HwYwMRGfcvNFesen0UyQDejSNAAkJSGSjqWMjuZJvE1jVRAwVu+KVMGeU/Dh+TyxKqqB09F0XpWNKmvB0zFzvZ7k8MxgF2524IZltV/eJS6BIVy9evV//Md/5G/JxipvvfXWq666CgCsVut999137ty5WCz2hS984c477yxIa116IPB9pOzCw/4oyPeSl5JuK4oSDoeHhobm5uayWz7+8Y9nX1iti3QMcunDYDAoy3LOsWttbV21alUkEqFpOhcONZlMRQ3hReL555//4he/+Oqrr2aZS6/gCq6gKBBCm8s2/EF4OSbGiw8AZKHN60rMR0IqSWIcCRpoybK4YcBM4zoZLN1x41/6CCcDALSOQMGjUVMdx1Y0gKYm33qF7diOMXoAUFKJxEgyMQ0M9PLr2nJMRhiBHB1mgr1cCWMPX2amTbnWTwLDt3g37Rl5Y6PjhhfGdR/zYQfGD91Sc0NBA25STL41dVQoy1BRnSpro9FxGUpAw8XqqGnQktApMi+5qzuCnfvAOUM7eILFI32JfJOvSlrgWIS169gSnSZmxNFubkMRXblLhUtjCFevXr10e057naKofJqxK8gHjuP19fXbtm0rqv9eFI2NjaIofu1rX6OohQRJNhA9MDBQU1MDACdPnjSZ3nb1fBYvvvjigw8++MILL6xatawc6BVcwRVkoSOoG6ret2twd1IqrlubxQ1u7H9G1Js9qNlClLtL3Tov8pP/0aPe4EbO8yl41qnDdVikLxkbEfjyaqyESR7aq7EOMa5KWgnCNZN1jq5syppGAMAIZF9junje8HcAhFCHa80rw3tzW2yMpc5aM5t8Ky5dPRyHSj69Z/T1m6uvI7F525yWM6+M7EtJAhAguBKzZ8Mi8BxlrDGABnKiPKIfNeGrFNZgS5d4o0dOpOsKe/NVUfUfizJWylitkwOT4lgf6arA2PmrpoyX/nqvKNT/6fGtb33rkUce+dGPfrR79+6nnnrqq1/96srjt23b1tTUdNttt+3cuXPnzp2PP/54Z2enTqd76KGHPvaxj+3ateub3/xmNka6FC+++GIuMPv73/++oL4UzlfcbNmyZffu3U8++eSTTz45Ozv77q/xCq7gzxh6iruh6n35ab+lqDHAx33kH6bqe1K3dJRuKm8ufTOCGUhoMC0KaepMpHOdyVjDpQNiPGSOaRtSYiVe0mBaXVqyrYpr7cgJXlIGsmSjhbZe9nKhMt5VYVxU0rLa0ahoci3Xs3daBYCQENk7ekBURMjSIo68HknP98Ifh1PDuJ/AS2oM8x3Fkl7MlKXwXjoTFnXVzeLEoCYuaj3PRKTZIxHWoWPoifje58WRbtxs1/nmfS2MxIx1lz5VfIV0+7Lg+uuvv3jS7VtuueWFF174xS9+0dnZ6fF4PvzhD8OFSLd///vf//SnP/39738PAK2trVnu7G9/+9tPPfXUL37xi9bW1h07doRCoaUnVl1d/fnPfz77enR0dGntrk6ne+SRRwAgHA5nt8hycQaQK7iCK8jBqONvrr7u4OThmUSRhSNLMnVWX73F97Fm3efeVKp/JX2uAX9O0P+3t7hoKGOnGPuyFg7hiPeyJt8lIAe4SHS41kzEp3JEMwiwbd7NLw3tUWQ0EGusMcBkfPrnZ38DACRG5DiDekMDx/09ivV9f61qSFo4VUeFRWemQ2fitE2nK6kRh8/p6toAQEmrsZGUMCuaGzg8OSiO9OuvugUxi4KulgYevwzl0peGdPtS4QrF2iXHrl27PvKRj6xevfq5554rLy/P/+ihhx76zGc+c5Hxzx07dvzLv/zLkSNHlpJu63S6os2jV3CZcEGKtSu4rMhkMtn2iaUfaZo2GBnpCnQnxOT/a+/eY5o6+weAP6c9baEttB29gNwK84JcpgL2Vy6VyyqCr0BmmL5zZoGRvIvJMrOwsWzZ/jQ/jLDFmBDinLqEvImTIYJs4+eFH8g2FIEpMpko+kKVIrRaSun1nPP+cVzXgSJiodJ+P389fXqg3zw97bfn8jxfO2nnsvxX8IPDAkIjBWGuJUT69NT/XiWTxdi/RFbd9ecooI1zmfwwf36Yv+v8wqXx29j13rFrrj3TDnPTrQtThPzduLjZCbl/YuD3iVvDtk3/WhsotLMCb4owCiGEBH6CKEEEQohyUI9umaZHzchhZYl4xDRJkogr5QRGMhyaAfv4Pd5GNcb528QtfylHmii0WCw4jrt3+gQkQi/ncDjouh8CgYDBWPiHx2q1Tk9PYxg249IjJMKlB4nQs+ZIhK7spOOZi7sihPQ3jDMqsM/GZDMCIrj+Ms6iXg6cG0ESLXcuzCiLNu0wfzfQxsL9CqKSAziPr+FN2aa7x67qLY+YrE1cNle9AkMIsQ0c3n8EOMWMCVo9Y1hM13oI0p8bGU4a7zvGhonJhyxZGGf1Boz9tz2cHYDLFCIGi7EYiRBOjXo5HMeftiLMc+FwOE+coQ8AeKL5ZEFEn+vjMB4NTj2xJCQDZwRE+gfKuQyWh+/nYDKY2ZGbmm//36TVpS4x7v/W2i3/vjlwavBsZKCMXlXurmFkrXhVnERx7Cb2/p/HijaBFYsxJBmSWPaZw8JdvWbqYpNZ38+ShLIjY3DxCjTrJzuLx5QmCxdvECARAgCAJwmieSw+rr8+Sdj+mvqMMTB+uL/gVd7SnwV9Gj+c87p8U/Ots/R9MTQOE/vn6rXH/4jQO8ZX+jswzFG4KpfL8j91l1JI/yokycAYm9akrPALNo6Yp0bMrpVqMD8eX1WAcfzR01bP5zGlySImZxHXFIRECAAAHsaVcrhZErPOah63MZgYKwD3E7GZfi9LCnQScgQ5UVkXR341WP+6tOnPRO+s5v3/KPfHUSpehOnsyOSgbhupf0Q8jp/FYKWF/Q89714QzQuM4lr1dsJKEnaSMBN2o8M6yXhiJW0MwwLkXOFK3gvWcXumZZkI7969e+HChdLSUk8HAoAHXLlyZWJiIj8/39OB+Kj29nYcx+cusrYQGPIXc/zFL/sFCAk3qHB1Xo/22g3dTWd5GR6O/hGOZQRjvTrKQaEgDvpnNIM+lI0IDFOGJrtWnMYwbOasDwpZH9mnxyyWh3bSShI2kh2Ac0Qsbojf7ILeP/74Y3h4eHLyzIr2L8INibCzs/OLL75wPty3b59CoZixzfDwcFlZWX9/f0JCQlVV1QuWJOzr66uvr4dECHzTzz//PDw8DInQU1pbWzkcjvsT4fLBxJgbQzaslyXcN47em9LaCKvVYXNQhIiwh/AcGIaxmSx/3F/Gk4Twgx+vLT43DHFELI5oXiuOtbS0xMfHv3SJcGJi4v79+wcPHqQfOqe7uSoqKkpPT9+/f/+hQ4eKioo6Oztf/HVdkSR58uRJ9/5PMB+///77hg0bPB0FAGCpsRh4pCA8UhD+7E1feu45NSoUCtVq9dOe7erq+uOPPzo6OthsdkVFhUQi6enpSUycuazOgrHZ7OLiYkiES0aj0eh0OnpdPRaL9bSKWgAAsCy4JxEODg6+/vrrIpFox44ds9fMvH79ekJCAj3thsPhvPbaa319fW5MhBiGHT582F3/DTzTsWPHzp8/X1tb6+lAAADADeaVCB8+fNjV1TW7Py0tjcfjyeXyAwcOvPrqqwMDA++//75Op9uzZ4/rZuPj466zsOmKek98IQzDCIJwrU3B4/FmT4OzWCyTk5NRUVHzCR64nclkMpvNMP6eMjk5SRBEU1OTpwPxUY8ePcIw7Pjx454OxEfp9Xo2m11VVTXP7Xft2rVv3765t5lXItRoNM5LgK5iYmJ4PF58fDy9TFd6ejpFUdXV1TMSoUAgMJn+WpfdaDQ+bYo3k8m8cuUKvRIKTSKRzF5Bg6Iou93+zJUdwCIhSXLG7xWwlAiCoCjKvStrgPmjVxlkMhdxWhuYg8PhwDBs/uMfEhLyzG3m9VlKSEhobm6ez5ZSqdQ1jdGioqIGBwcpisIwjKKowcHBOQ4m3HjKFAAAAHgmN0zY7Orqog/4Hjx4UFlZuXnzZrq/urq6vb0dIZSdnY0Q+u677xBCJ06cYDKZroXXAQAAAA9yQyKsq6sTi8VSqVQul8vl8oqKCrq/qanp2rVrCCEcx2tra8vKysLCwj7++OPa2lo4qwAAAOAl4Z7qEwRBGAwGoVA4R30DkiQNBsML1kAAAAAA3OvlKsMEAAAALLHld+PZ2NjYN998o9PpCgoKMjIyPB2O95uYmKivr3c+3LRpU0xMDN3u6OhoaGgQiUTvvvvufG7NAvNEkuTNmzd7e3uNRmNpaanrpYTW1tYzZ86IxeLS0lKpVEp3Tk1NHT58WKPRqFSqN954w0NRew+CIAYGBnp7e+12e0lJibO/sbFRq9XS7VdeeaWoqIhu6/X6I0eOaLXaLVu2bNmyxQMRe5epqanm5ubffvuNzWbn5eUplUrnU52dnd9//31AQEBJSUl4+ONFbSwWy5EjR4aGhpKTk9966y3sKVUs5rDMzlIajUalUnnnzp2IiIg333zT9QsaLJLh4eHy8vKhPznvCj5z5kxhYWFYWJhGo1EoFAaDwbNxepPu7u6MjIzq6ur33nvP4XA4+0+ePLlz586IiIjbt28rlUr6JjWKotRqdXt7+8qVK8vLyysrKz0XuJc4e/ZsTk5OdXX1Bx984NpfWVnZ0tJCfxA0Gg3dabPZVCrV1atXo6OjS0tLjx496omQvcqBAweOHj0qEAgQQrm5uc4hPXfuXG5ubnBwsE6nUygU4+OPqwRv3769sbFx1apVFRUVn3322UJeklpWampqUlNT6fbx48eTkpI8G48v6O7ulsvls/tTU1NramrodnZ29sGDB5c2Lm9GzxS8ffs2QshisTj7N2zY8O2339LtlJSUr7/+mqKos2fPhoWF2Ww2iqIuXrwolUqtVqsnovYe9Ph3dXXx+XzXfpVK1dDQMGPjEydOxMXF0X9y+vTplStXkiS5ZKF6JbPZ7GwfOnRo48aNdFutVn/55Zd0e9u2bRUVFRRF9fT0BAYGmkwmiqL6+/v5fL7BYHjeV1xmR4Tt7e3O6RmbN2/u7u6emprybEi+wGQyffXVVzU1NfRXM0LIbrf/+uuvru9FW1ub5wL0Nk+8ocxoNPb29s4e87a2tszMTHp9g9TUVJPJNDAwsJTRep85buj76aefqqqqmpubqT/vrmhvb1er1fSfqNXqW7du3bt3b4kC9VKui6hYLBY+n48Qoijq4sWLOTk5dL/r/p+WlsblchFCsbGxQqGwu7v7eV9xmSXC0dFRiURCtyUSCYZho6Ojng3J67HZ7LS0NJ1O98svv6xfv/706dMIIa1WS1GU8xqVTCaDN2KxjY6OYhjm3P9lMtn9+/cRQlqt1tnJYDAkEgndD9wuNjbWz8/vwYMHe/fu3bZtG0mS6O9fSlwuNyAgAD4L7qLRaPbv3//JJ58ghPR6vdVqdQ61VCqlx9l1/6f7F7D/L7ObZXAcd14yoc9FwEJriy0+Pv7UqVN0u7q6ury8vLCwkD7+cL4XsOLdEmCxWBRFEQRBL65mt9s5HA5CCMdxetEvGrwXi6empoZufPrpp6tWrWppacnLy3P9UkIIORwOGH+3mJiYyMvL27t3L33/0YzvHOc4u2X/X2ZHhKGhoc5sr9FoGAxGcHCwZ0PyKampqXfv3qUoSiKRsFgs5ymge/fuwV2jiy0kJITBYMwe89DQUGen1WqdmJhYsWKFx6L0DUKhMC4u7s6dO+jvX0o6nc5sNsP4v7iHDx/m5OQUFBR8/vnndE9gYCCfz597/6coanR0dAHjv8wSYX5+fmNjo81mQwjV1dXl5OTQP4rB4jGbzc52U1NTbGwsveLt1q1b6RqQdru9oaGhoKDAczH6BD8/P7VaTY+51WptbGykxzw/P//8+fN6vR4h1NjYGBkZuWbNGg/H6o0cDofzcGRkZKS3tzcuLg4hlJ+f/8MPP9B38NbV1SmVStczdWABDAZDbm5uRkbGjKoR+fn59P5PEER9fT29/2/duvXSpUt0LmxtbcVxXKFQPPdLvsi9PUvPbrdnZWUpFIq3335bLBZfvnzZ0xF5vw8//FCpVO7evTs9PV0ikXR0dND9PT09YrF4165dKSkpKpUK7lR0o+np6aSkJLqoS2JiYmZmJt3f2dkZFBS0e/fujRs3qtVqu91O9xcXF8fExBQXF4vF4lOnTnkucC+h1WqTkpLWrl3LYDCSkpIKCwspihoaGgoJCdm+ffuOHTtEItGePXvojUmSLCwsXLdu3TvvvBMUFHThwgWPxu4NPvroI3rkaWq1mu7v7++XSCQ7d+5UqVQKhWJ6epruLysri46OLikpkclkx44dW8ArLr+VZRwOR2trq16vz8zMlMlkng7H+5lMpsuXL2u1WrFYrFQqAwICnE+Nj4+3trYKhcKsrCyoyuRGJEn29vY6HzKZzPXr19NtrVbb1tYWFBSUlZXlOtG+o6NjZGQkJSVFLpcvcbTex2az9fX1OR9yOBz6R8mNGzdu3LhBkmRCQoLrYTdJkm1tbWNjYyqVKjQ01AMRe5eRkRHXmrU4jq9bt45u6/X6c+fOBQYGZmdnu14LvHTp0tDQUGJi4sJOhyy/RAgAAAC40TK7RggAAAC4FyRCAAAAPg0SIQAAAJ8GiRAAAIBPg0QIAADAp0EiBAAA4NMgEQIAAPBpkAgBAAD4NEiEAAAAfBokQgAAAD4NEiEAAACf9l9NGC4yvn/gewAAAABJRU5ErkJggg==", + "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", - "\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", - "\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", - "\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", - "\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", + "\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", + "\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", + "\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", + "\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", - "\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", - "\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", - "\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", - "\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", - "\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", - "\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", + "\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", + "\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", + "\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", + "\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", - "\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", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 19, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -1662,14 +3073,1368 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:14\u001b[39m\n", - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:13\u001b[39m\n", - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:13\u001b[39m\n", - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:13\u001b[39m\n", - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:27\u001b[39m\n", - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:26\u001b[39m\n", - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:26\u001b[39m\n", - "\u001b[32mSampling: 100%|█████████████████████████████████████████| Time: 0:00:27\u001b[39m\n" + "\u001b[32mSampling 0%| | ETA: N/A\u001b[39m\n", + "\u001b[32mSampling 0%|▏ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 1%|▍ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 1%|▌ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 2%|▋ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 2%|▉ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 2%|█ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 3%|█▏ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 3%|█▍ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 4%|█▌ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 4%|█▋ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 4%|█▉ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 5%|██ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 5%|██▏ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 6%|██▍ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 6%|██▌ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 6%|██▊ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 7%|██▉ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 7%|███ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 8%|███▎ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 8%|███▍ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 8%|███▌ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 9%|███▊ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 9%|███▉ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 10%|████ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 10%|████▎ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 10%|████▍ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 11%|████▌ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 11%|████▊ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|█████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|█████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 13%|█████▍ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 13%|█████▌ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 14%|█████▊ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 14%|█████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 14%|██████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 15%|██████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 15%|██████▍ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 16%|██████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 16%|██████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 16%|██████▉ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 17%|███████ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 17%|███████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 19%|███████▉ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 19%|████████▏ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 20%|████████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 20%|████████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 20%|████████▋ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 21%|████████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 21%|████████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▏ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 24%|█████████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▏ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 26%|███████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▊ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▊ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 31%|████████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 31%|█████████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 33%|█████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 33%|██████████████ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 38%|███████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|█████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▎ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 45%|██████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 45%|███████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▍ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▍ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 50%|████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▋ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|██████████████████████ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▋ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████▏ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 57%|███████████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▎ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▎ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|█████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|███████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 69%|████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 69%|█████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|██████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|████████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 81%|█████████████████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 81%|██████████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 83%|██████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 83%|███████████████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|██████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 95%|███████████████████████████████████████▉ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 95%|████████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▉ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▏| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▍| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▌| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▋| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|█████████████████████████████████████████▉| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|██████████████████████████████████████████| Time: 0:00:16\u001b[39m\n", + "\u001b[90mSampling 100%|██████████████████████████████████████████| Time: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 0%| | ETA: N/A\u001b[39m\n", + "\u001b[32mSampling 0%|▏ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 1%|▍ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 1%|▌ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 2%|▋ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 2%|▉ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 2%|█ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 3%|█▏ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 3%|█▍ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 4%|█▌ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 4%|█▋ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 4%|█▉ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 5%|██ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 5%|██▏ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 6%|██▍ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 6%|██▌ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 6%|██▊ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 7%|██▉ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 7%|███ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 8%|███▎ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 8%|███▍ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 8%|███▌ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 9%|███▊ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 9%|███▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 10%|████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 10%|████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 10%|████▍ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 11%|████▌ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 11%|████▊ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|█████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|█████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 13%|█████▍ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 13%|█████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 14%|█████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 14%|█████▉ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 14%|██████ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 15%|██████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 15%|██████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 16%|██████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 16%|██████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 16%|██████▉ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 17%|███████ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 17%|███████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 19%|███████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 19%|████████▏ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 20%|████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 20%|████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 20%|████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 21%|████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 21%|████████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▏ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 24%|█████████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▏ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▊ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 26%|███████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▊ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 31%|████████████▉ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 31%|█████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 33%|█████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 33%|██████████████ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 38%|███████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|█████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▊ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▎ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 45%|██████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 45%|███████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▍ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▋ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 50%|████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▋ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|██████████████████████ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▋ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████▏ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 57%|███████████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▎ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▎ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|█████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|███████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 69%|████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 69%|█████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|██████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|████████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 81%|█████████████████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 81%|██████████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 83%|██████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 83%|███████████████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|██████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 95%|███████████████████████████████████████▉ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 95%|████████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▉ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▏| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▍| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▌| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▋| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|█████████████████████████████████████████▉| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|██████████████████████████████████████████| Time: 0:00:16\u001b[39m\n", + "\u001b[90mSampling 100%|██████████████████████████████████████████| Time: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 0%| | ETA: N/A\u001b[39m\n", + "\u001b[32mSampling 0%|▏ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 1%|▍ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 1%|▌ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 2%|▋ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 2%|▉ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 2%|█ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 3%|█▏ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 3%|█▍ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 4%|█▌ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 4%|█▋ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 4%|█▉ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 5%|██ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 5%|██▏ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 6%|██▍ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 6%|██▌ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 6%|██▊ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 7%|██▉ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 7%|███ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 8%|███▎ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 8%|███▍ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 8%|███▌ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 9%|███▊ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 9%|███▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 10%|████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 10%|████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 10%|████▍ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 11%|████▌ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 11%|████▊ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|█████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 12%|█████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 13%|█████▍ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 13%|█████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 14%|█████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 14%|█████▉ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 14%|██████ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 15%|██████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 15%|██████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 16%|██████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 16%|██████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 16%|██████▉ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 17%|███████ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 17%|███████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 18%|███████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 19%|███████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 19%|████████▏ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 20%|████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 20%|████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 20%|████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 21%|████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 21%|████████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▏ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 24%|█████████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▊ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 26%|███████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▊ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▍ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 31%|████████████▉ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 31%|█████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 33%|█████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 33%|██████████████ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▋ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 38%|███████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 40%|█████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▏ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▊ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▎ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 45%|██████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 45%|███████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▍ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▋ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 50%|████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▋ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 52%|██████████████████████ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▋ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████▏ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 57%|███████████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▎ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▉ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▎ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|█████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 64%|███████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▍ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 69%|████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 69%|█████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▋ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|██████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 76%|████████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▎ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▉ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 81%|█████████████████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 81%|██████████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 83%|██████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 83%|███████████████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▏ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▌ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▋ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 90%|██████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▎ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 95%|███████████████████████████████████████▉ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 95%|████████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▋ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▉ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████ | ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▏| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▍| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▌| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▋| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|█████████████████████████████████████████▉| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|██████████████████████████████████████████| Time: 0:00:16\u001b[39m\n", + "\u001b[90mSampling 100%|██████████████████████████████████████████| Time: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 0%| | ETA: N/A\u001b[39m\n", + "\u001b[32mSampling 0%|▎ | ETA: 0:00:38\u001b[39m\n", + "\u001b[32mSampling 1%|▍ | ETA: 0:00:37\u001b[39m\n", + "\u001b[32mSampling 2%|▋ | ETA: 0:00:35\u001b[39m\n", + "\u001b[32mSampling 2%|▉ | ETA: 0:00:34\u001b[39m\n", + "\u001b[32mSampling 2%|█ | ETA: 0:00:34\u001b[39m\n", + "\u001b[32mSampling 3%|█▎ | ETA: 0:00:33\u001b[39m\n", + "\u001b[32mSampling 4%|█▌ | ETA: 0:00:33\u001b[39m\n", + "\u001b[32mSampling 4%|█▋ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 4%|█▉ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 5%|██▏ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 6%|██▎ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 6%|██▌ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 6%|██▊ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 7%|███ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 8%|███▏ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 8%|███▍ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 8%|███▋ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 9%|███▊ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 10%|████ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 10%|████▎ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 10%|████▍ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 11%|████▋ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|████▉ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|█████ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|█████▎ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 13%|█████▌ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|█████▋ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|█████▉ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|██████▏ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 15%|██████▎ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 16%|██████▌ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 16%|██████▊ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 16%|██████▉ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 17%|███████▏ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▍ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▌ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▊ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 19%|████████ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 20%|████████▎ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 20%|████████▍ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 20%|████████▋ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 21%|████████▉ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 22%|█████████ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▎ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▌ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▋ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|█████████▉ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▏ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▎ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▌ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▊ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▉ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 26%|███████████▏ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▍ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▌ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▊ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 28%|████████████ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▏ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▍ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▋ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▊ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 31%|█████████████ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▎ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▌ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▋ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 33%|█████████████▉ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▏ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▎ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▌ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▊ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 36%|██████████████▉ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▏ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▍ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▌ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 38%|███████████████▊ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████▏ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▍ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▋ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▊ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 40%|█████████████████ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▎ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▍ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▋ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▉ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▎ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▌ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▊ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 45%|██████████████████▉ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▏ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▍ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▌ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▊ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▏ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▍ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▋ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 50%|████████████████████▊ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████▎ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▍ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▋ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▉ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 52%|██████████████████████ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▎ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▌ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▋ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 55%|██████████████████████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████▏ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▌ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▊ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████▏ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▋ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 62%|█████████████████████████▉ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▌ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 64%|███████████████████████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▌ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▉ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▍ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 69%|█████████████████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▍ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▉ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▎ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 74%|██████████████████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▏ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▎ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▊ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|████████████████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▍ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 78%|█████████████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▏ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▋ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 81%|██████████████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 83%|██████████████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▏ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|███████████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▍ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|████████████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▋ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 90%|██████████████████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▉ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 95%|███████████████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▏ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▏| ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▍| ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▋| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|█████████████████████████████████████████▊| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|██████████████████████████████████████████| Time: 0:00:33\u001b[39m\n", + "\u001b[90mSampling 100%|██████████████████████████████████████████| Time: 0:00:33\u001b[39m\n", + "\u001b[32mSampling 0%| | ETA: N/A\u001b[39m\n", + "\u001b[32mSampling 0%|▎ | ETA: 0:00:38\u001b[39m\n", + "\u001b[32mSampling 1%|▍ | ETA: 0:00:34\u001b[39m\n", + "\u001b[32mSampling 2%|▋ | ETA: 0:00:34\u001b[39m\n", + "\u001b[32mSampling 2%|▉ | ETA: 0:00:33\u001b[39m\n", + "\u001b[32mSampling 2%|█ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 3%|█▎ | ETA: 0:00:33\u001b[39m\n", + "\u001b[32mSampling 4%|█▌ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 4%|█▋ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 4%|█▉ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 5%|██▏ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 6%|██▎ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 6%|██▌ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 6%|██▊ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 7%|███ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 8%|███▏ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 8%|███▍ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 8%|███▋ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 9%|███▊ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 10%|████ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 10%|████▎ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 10%|████▍ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 11%|████▋ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|████▉ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|█████ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|█████▎ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 13%|█████▌ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|█████▋ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|█████▉ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|██████▏ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 15%|██████▎ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 16%|██████▌ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 16%|██████▊ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 16%|██████▉ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 17%|███████▏ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▍ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▌ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▊ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 19%|████████ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 20%|████████▎ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 20%|████████▍ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 20%|████████▋ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 21%|████████▉ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 22%|█████████ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▎ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▌ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▋ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|█████████▉ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▏ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▎ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▌ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▊ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▉ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 26%|███████████▏ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▍ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▌ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▊ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 28%|████████████ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▏ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▍ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▋ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▊ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 31%|█████████████ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▎ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▌ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▋ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 33%|█████████████▉ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▏ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▎ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▌ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▊ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 36%|██████████████▉ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▏ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▍ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▌ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 38%|███████████████▊ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████▏ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▍ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▋ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▊ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 40%|█████████████████ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▎ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▍ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▋ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▉ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▎ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▌ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▊ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 45%|██████████████████▉ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▏ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▍ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▌ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▊ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▏ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▍ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▋ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 50%|████████████████████▊ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████▎ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▍ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▋ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 52%|██████████████████████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▌ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▋ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 55%|██████████████████████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████▏ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████▏ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 62%|█████████████████████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▌ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 64%|███████████████████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▉ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▍ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 69%|█████████████████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▍ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▎ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 74%|██████████████████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▎ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▊ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|████████████████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 78%|█████████████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▏ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 81%|██████████████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 83%|██████████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|███████████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|████████████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 90%|██████████████████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 95%|███████████████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▏| ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▍| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▋| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|█████████████████████████████████████████▊| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|██████████████████████████████████████████| Time: 0:00:32\u001b[39m\n", + "\u001b[90mSampling 100%|██████████████████████████████████████████| Time: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 0%| | ETA: N/A\u001b[39m\n", + "\u001b[32mSampling 0%|▎ | ETA: 0:00:38\u001b[39m\n", + "\u001b[32mSampling 1%|▍ | ETA: 0:00:34\u001b[39m\n", + "\u001b[32mSampling 2%|▋ | ETA: 0:00:35\u001b[39m\n", + "\u001b[32mSampling 2%|▉ | ETA: 0:00:34\u001b[39m\n", + "\u001b[32mSampling 2%|█ | ETA: 0:00:33\u001b[39m\n", + "\u001b[32mSampling 3%|█▎ | ETA: 0:00:33\u001b[39m\n", + "\u001b[32mSampling 4%|█▌ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 4%|█▋ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 4%|█▉ | ETA: 0:00:32\u001b[39m\n", + "\u001b[32mSampling 5%|██▏ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 6%|██▎ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 6%|██▌ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 6%|██▊ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 7%|███ | ETA: 0:00:31\u001b[39m\n", + "\u001b[32mSampling 8%|███▏ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 8%|███▍ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 8%|███▋ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 9%|███▊ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 10%|████ | ETA: 0:00:30\u001b[39m\n", + "\u001b[32mSampling 10%|████▎ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 10%|████▍ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 11%|████▋ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|████▉ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|█████ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 12%|█████▎ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 13%|█████▌ | ETA: 0:00:29\u001b[39m\n", + "\u001b[32mSampling 14%|█████▋ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|█████▉ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 14%|██████▏ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 15%|██████▎ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 16%|██████▌ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 16%|██████▊ | ETA: 0:00:28\u001b[39m\n", + "\u001b[32mSampling 16%|██████▉ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 17%|███████▏ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▍ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▌ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 18%|███████▊ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 19%|████████ | ETA: 0:00:27\u001b[39m\n", + "\u001b[32mSampling 20%|████████▎ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 20%|████████▍ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 20%|████████▋ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 21%|████████▉ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 22%|█████████ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▎ | ETA: 0:00:26\u001b[39m\n", + "\u001b[32mSampling 22%|█████████▌ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 23%|█████████▋ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|█████████▉ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▏ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 24%|██████████▎ | ETA: 0:00:25\u001b[39m\n", + "\u001b[32mSampling 25%|██████████▌ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▊ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 26%|██████████▉ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 26%|███████████▏ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 27%|███████████▍ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▌ | ETA: 0:00:24\u001b[39m\n", + "\u001b[32mSampling 28%|███████████▊ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 28%|████████████ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 29%|████████████▏ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▍ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▋ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 30%|████████████▊ | ETA: 0:00:23\u001b[39m\n", + "\u001b[32mSampling 31%|█████████████ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▎ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▌ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 32%|█████████████▋ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 33%|█████████████▉ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▏ | ETA: 0:00:22\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▎ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 34%|██████████████▌ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 35%|██████████████▊ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 36%|██████████████▉ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▏ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 36%|███████████████▍ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 37%|███████████████▌ | ETA: 0:00:21\u001b[39m\n", + "\u001b[32mSampling 38%|███████████████▊ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 38%|████████████████▏ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 39%|████████████████▍ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▋ | ETA: 0:00:20\u001b[39m\n", + "\u001b[32mSampling 40%|████████████████▊ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 40%|█████████████████ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 41%|█████████████████▎ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▍ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▋ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 42%|█████████████████▉ | ETA: 0:00:19\u001b[39m\n", + "\u001b[32mSampling 43%|██████████████████ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▎ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▌ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 44%|██████████████████▊ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 45%|██████████████████▉ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▏ | ETA: 0:00:18\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▍ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 46%|███████████████████▌ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 47%|███████████████████▊ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▏ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 48%|████████████████████▍ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 49%|████████████████████▋ | ETA: 0:00:17\u001b[39m\n", + "\u001b[32mSampling 50%|████████████████████▊ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 50%|█████████████████████▎ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 51%|█████████████████████▍ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▋ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 52%|█████████████████████▉ | ETA: 0:00:16\u001b[39m\n", + "\u001b[32mSampling 52%|██████████████████████ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 53%|██████████████████████▎ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▌ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 54%|██████████████████████▋ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 55%|██████████████████████▉ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 55%|███████████████████████▏ | ETA: 0:00:15\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▎ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▌ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 56%|███████████████████████▊ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 57%|████████████████████████▏ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▍ | ETA: 0:00:14\u001b[39m\n", + "\u001b[32mSampling 58%|████████████████████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 59%|████████████████████████▊ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▎ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 60%|█████████████████████████▍ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 61%|█████████████████████████▋ | ETA: 0:00:13\u001b[39m\n", + "\u001b[32mSampling 62%|█████████████████████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 62%|██████████████████████████▎ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 63%|██████████████████████████▌ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▋ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 64%|██████████████████████████▉ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 64%|███████████████████████████▏ | ETA: 0:00:12\u001b[39m\n", + "\u001b[32mSampling 65%|███████████████████████████▎ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▌ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▊ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 66%|███████████████████████████▉ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 67%|████████████████████████████▏ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▍ | ETA: 0:00:11\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▌ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 68%|████████████████████████████▊ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 69%|█████████████████████████████ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▎ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▍ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 70%|█████████████████████████████▋ | ETA: 0:00:10\u001b[39m\n", + "\u001b[32mSampling 71%|█████████████████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▎ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 72%|██████████████████████████████▌ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 73%|██████████████████████████████▋ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 74%|██████████████████████████████▉ | ETA: 0:00:09\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 74%|███████████████████████████████▎ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 75%|███████████████████████████████▌ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▊ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|███████████████████████████████▉ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 76%|████████████████████████████████▏ | ETA: 0:00:08\u001b[39m\n", + "\u001b[32mSampling 77%|████████████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▌ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 78%|████████████████████████████████▊ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 78%|█████████████████████████████████ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 79%|█████████████████████████████████▏ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▍ | ETA: 0:00:07\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 80%|█████████████████████████████████▊ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 81%|██████████████████████████████████ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▎ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▌ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 82%|██████████████████████████████████▋ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 83%|██████████████████████████████████▉ | ETA: 0:00:06\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▎ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 84%|███████████████████████████████████▌ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 85%|███████████████████████████████████▊ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|███████████████████████████████████▉ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▏ | ETA: 0:00:05\u001b[39m\n", + "\u001b[32mSampling 86%|████████████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 87%|████████████████████████████████████▌ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|████████████████████████████████████▊ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 88%|█████████████████████████████████████▏ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 89%|█████████████████████████████████████▍ | ETA: 0:00:04\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 90%|█████████████████████████████████████▊ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 90%|██████████████████████████████████████ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 91%|██████████████████████████████████████▎ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▍ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▋ | ETA: 0:00:03\u001b[39m\n", + "\u001b[32mSampling 92%|██████████████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 93%|███████████████████████████████████████ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▎ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▌ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 94%|███████████████████████████████████████▊ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 95%|███████████████████████████████████████▉ | ETA: 0:00:02\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▏ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▍ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 96%|████████████████████████████████████████▌ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 97%|████████████████████████████████████████▊ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████ | ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▏| ETA: 0:00:01\u001b[39m\n", + "\u001b[32mSampling 98%|█████████████████████████████████████████▍| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 99%|█████████████████████████████████████████▋| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|█████████████████████████████████████████▊| ETA: 0:00:00\u001b[39m\n", + "\u001b[32mSampling 100%|██████████████████████████████████████████| Time: 0:00:32\u001b[39m\n", + "\u001b[90mSampling 100%|██████████████████████████████████████████| Time: 0:00:32\u001b[39m\n" ] } ], @@ -1684,8 +4449,8 @@ "metadata": {}, "outputs": [], "source": [ - "reactivemp_filtering_n_1000_benchmark = @benchmark reactivemp_inference_filtering($real_y_1000, $A, $B, $P, $Q);\n", - "reactivemp_smoothing_n_1000_benchmark = @benchmark reactivemp_inference_smoothing($real_y_1000, $A, $B, $P, $Q);" + "rxinfer_filtering_n_1000_benchmark = @benchmark rxinfer_inference_filtering($real_y_1000, $A, $B, $P, $Q);\n", + "rxinfer_smoothing_n_1000_benchmark = @benchmark rxinfer_inference_smoothing($real_y_1000, $A, $B, $P, $Q);" ] }, { @@ -1719,14 +4484,13 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/html": [ - "" + "" ] }, - "execution_count": 24, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -1735,8 +4499,8 @@ " # Local vars\n", " local bar_names = [ \"RxInfer Filtering\", \"RxInfer Smoothing\", \"Turing HMC(500)\", \"Turing HMC(1000)\" ]\n", " local bar_values = [\n", - " benchmark_time_ms(reactivemp_filtering_n_1000_benchmark),\n", - " benchmark_time_ms(reactivemp_smoothing_n_1000_benchmark),\n", + " benchmark_time_ms(rxinfer_filtering_n_1000_benchmark),\n", + " benchmark_time_ms(rxinfer_smoothing_n_1000_benchmark),\n", " benchmark_time_ms(turing_500_n_1000_benchmark),\n", " benchmark_time_ms(turing_1000_n_1000_benchmark)\n", " ] \n", @@ -1807,14 +4571,13 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/html": [ - "" + "" ] }, - "execution_count": 25, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -1840,8 +4603,8 @@ " )\n", " \n", " local range = benchmark_rmp_sizes\n", - " local smoothing = map(i -> benchmark_time_ms(reactivemp_benchmark_results[i][2]), 1:length(benchmark_rmp_sizes))\n", - " local filtering = map(i -> benchmark_time_ms(reactivemp_benchmark_results[i][3]), 1:length(benchmark_rmp_sizes))\n", + " local smoothing = map(i -> benchmark_time_ms(rxinfer_benchmark_results[i][2]), 1:length(benchmark_rmp_sizes))\n", + " local filtering = map(i -> benchmark_time_ms(rxinfer_benchmark_results[i][3]), 1:length(benchmark_rmp_sizes))\n", " \n", " CairoMakie.lines!(ax, range, smoothing)\n", " CairoMakie.scatter!(ax, range, smoothing, marker = :diamond, markersize = 15, label = \"Smoothing\")\n", @@ -1865,15 +4628,15 @@ "lastKernelId": null }, "kernelspec": { - "display_name": "Julia 1.10.2", + "display_name": "Julia 1.11.3", "language": "julia", - "name": "julia-1.10" + "name": "julia-1.11" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.10.2" + "version": "1.11.3" } }, "nbformat": 4, diff --git a/benchmarks/Manifest.toml b/benchmarks/Manifest.toml index 74067063b..f19cf9a8c 100644 --- a/benchmarks/Manifest.toml +++ b/benchmarks/Manifest.toml @@ -1,13 +1,23 @@ # This file is machine-generated - editing it directly is not advised -julia_version = "1.10.0" +julia_version = "1.11.3" manifest_format = "2.0" project_hash = "a9bcc6c901255954a595c3296f4a80a5eea60012" [[deps.ADTypes]] -git-tree-sha1 = "41c37aa88889c171f1300ceac1313c06e891d245" +git-tree-sha1 = "fb97701c117c8162e84dfcf80215caa904aef44f" uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" -version = "0.2.6" +version = "1.13.0" + + [deps.ADTypes.extensions] + ADTypesChainRulesCoreExt = "ChainRulesCore" + ADTypesConstructionBaseExt = "ConstructionBase" + ADTypesEnzymeCoreExt = "EnzymeCore" + + [deps.ADTypes.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" [[deps.AbstractFFTs]] deps = ["LinearAlgebra"] @@ -20,68 +30,68 @@ weakdeps = ["ChainRulesCore", "Test"] AbstractFFTsChainRulesCoreExt = "ChainRulesCore" AbstractFFTsTestExt = "Test" -[[deps.AbstractLattices]] -git-tree-sha1 = "222ee9e50b98f51b5d78feb93dd928880df35f06" -uuid = "398f06c4-4d28-53ec-89ca-5b2656b7603d" -version = "0.3.0" - [[deps.AbstractMCMC]] deps = ["BangBang", "ConsoleProgressMonitor", "Distributed", "FillArrays", "LogDensityProblems", "Logging", "LoggingExtras", "ProgressLogging", "Random", "StatsBase", "TerminalLoggers", "Transducers"] -git-tree-sha1 = "63ae0647e8db221d63256820d1e346216c65ac66" +git-tree-sha1 = "aa469a7830413bd4c855963e3f648bd9d145c2c3" uuid = "80f14c24-f653-4e6a-9b94-39d6b0f70001" -version = "5.0.0" +version = "5.6.0" [[deps.AbstractPPL]] -deps = ["AbstractMCMC", "DensityInterface", "Random", "Setfield", "SparseArrays"] -git-tree-sha1 = "917ad8da4becae82028aba80b7e25197f0c76dd1" +deps = ["AbstractMCMC", "Accessors", "DensityInterface", "JSON", "Random", "StatsBase"] +git-tree-sha1 = "b155685b5daa9d9d19dfe42684a53fa8cbbb83b8" uuid = "7a57a42e-76ec-4ea3-a279-07e840d6d9cf" -version = "0.7.0" +version = "0.10.1" [[deps.AbstractTrees]] -git-tree-sha1 = "faa260e4cb5aba097a73fab382dd4b5819d8ec8c" +git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" -version = "0.4.4" +version = "0.4.5" [[deps.Accessors]] -deps = ["CompositionsBase", "ConstructionBase", "InverseFunctions", "MacroTools"] -git-tree-sha1 = "01a3b46e47004b18e54b9a37d1b333ba70859068" +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"] +git-tree-sha1 = "0ba8f4c1f06707985ffb4804fdad1bf97b233897" uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" -version = "0.1.34" +version = "0.1.41" [deps.Accessors.extensions] - AccessorsAxisKeysExt = "AxisKeys" - AccessorsDatesExt = "Dates" - AccessorsIntervalSetsExt = "IntervalSets" - AccessorsLinearAlgebraExt = "LinearAlgebra" - AccessorsStaticArraysExt = "StaticArrays" - AccessorsStructArraysExt = "StructArrays" - AccessorsTestExt = "Test" + AxisKeysExt = "AxisKeys" + IntervalSetsExt = "IntervalSets" + LinearAlgebraExt = "LinearAlgebra" + StaticArraysExt = "StaticArrays" + StructArraysExt = "StructArrays" + TestExt = "Test" + UnitfulExt = "Unitful" [deps.Accessors.weakdeps] AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" - Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" Requires = "ae029012-a4dd-5104-9daa-d747884805df" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" [[deps.Adapt]] deps = ["LinearAlgebra", "Requires"] -git-tree-sha1 = "cde29ddf7e5726c9fb511f340244ea3481267608" +git-tree-sha1 = "50c3c56a52972d78e8be9fd135bfb91c9574c140" uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" -version = "3.7.2" +version = "4.1.1" weakdeps = ["StaticArrays"] [deps.Adapt.extensions] AdaptStaticArraysExt = "StaticArrays" +[[deps.AdaptivePredicates]] +git-tree-sha1 = "7e651ea8d262d2d74ce75fdf47c4d63c07dba7a6" +uuid = "35492f91-a3bd-45ad-95db-fcad7dcfedb7" +version = "1.2.0" + [[deps.AdvancedHMC]] deps = ["AbstractMCMC", "ArgCheck", "DocStringExtensions", "InplaceOps", "LinearAlgebra", "LogDensityProblems", "LogDensityProblemsAD", "ProgressMeter", "Random", "Requires", "Setfield", "SimpleUnPack", "Statistics", "StatsBase", "StatsFuns"] -git-tree-sha1 = "dfa0e3508fc3df81d28624b328f3b937c1df8bc2" +git-tree-sha1 = "6f6a228808fe00ad05b47d74747c800d3df18acb" uuid = "0bf59076-c3b1-5ca4-86bd-e02cd72cde3d" -version = "0.6.1" +version = "0.6.4" [deps.AdvancedHMC.extensions] AdvancedHMCCUDAExt = "CUDA" @@ -94,10 +104,10 @@ version = "0.6.1" OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" [[deps.AdvancedMH]] -deps = ["AbstractMCMC", "Distributions", "FillArrays", "LinearAlgebra", "LogDensityProblems", "Random", "Requires"] -git-tree-sha1 = "1cc336be36fef7df68473a7d0d60ebba25958b9e" +deps = ["AbstractMCMC", "Distributions", "DocStringExtensions", "FillArrays", "LinearAlgebra", "LogDensityProblems", "Random", "Requires"] +git-tree-sha1 = "6e3d18037861bf220ed77f1a2c5f24a21a68d4b7" uuid = "5b7e9947-ddc0-4b3f-9b55-0d8042f74170" -version = "0.8.0" +version = "0.8.5" weakdeps = ["DiffResults", "ForwardDiff", "MCMCChains", "StructArrays"] [deps.AdvancedMH.extensions] @@ -106,47 +116,70 @@ weakdeps = ["DiffResults", "ForwardDiff", "MCMCChains", "StructArrays"] AdvancedMHStructArraysExt = "StructArrays" [[deps.AdvancedPS]] -deps = ["AbstractMCMC", "Distributions", "Random", "Random123", "Requires", "StatsFuns"] -git-tree-sha1 = "672f7ce648e06f93fceefde463c5855d77b6915a" +deps = ["AbstractMCMC", "Distributions", "Random", "Random123", "Requires", "SSMProblems", "StatsFuns"] +git-tree-sha1 = "c017e6cded5495294ff82d5c8a176492f752b22e" uuid = "576499cb-2369-40b2-a588-c64705576edc" -version = "0.5.4" +version = "0.6.1" weakdeps = ["Libtask"] [deps.AdvancedPS.extensions] AdvancedPSLibtaskExt = "Libtask" [[deps.AdvancedVI]] -deps = ["Bijectors", "Distributions", "DistributionsAD", "DocStringExtensions", "ForwardDiff", "LinearAlgebra", "ProgressMeter", "Random", "Requires", "StatsBase", "StatsFuns", "Tracker"] -git-tree-sha1 = "1f919a9c59cf3dfc68b64c22c453a2e356fca473" +deps = ["ADTypes", "Bijectors", "DiffResults", "Distributions", "DistributionsAD", "DocStringExtensions", "ForwardDiff", "LinearAlgebra", "ProgressMeter", "Random", "Requires", "StatsBase", "StatsFuns", "Tracker"] +git-tree-sha1 = "e45e57cea1879400952fe34b0cbc971950408af8" uuid = "b5ca4192-6429-45e5-a2d9-87aec30a685c" -version = "0.2.4" +version = "0.2.11" + + [deps.AdvancedVI.extensions] + AdvancedVIEnzymeExt = ["Enzyme"] + AdvancedVIFluxExt = ["Flux"] + AdvancedVIReverseDiffExt = ["ReverseDiff"] + AdvancedVIZygoteExt = ["Zygote"] + + [deps.AdvancedVI.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.AliasTables]] +deps = ["PtrArrays", "Random"] +git-tree-sha1 = "9876e1e164b144ca45e9e3198d0b689cadfed9ff" +uuid = "66dad0bd-aa9a-41b7-9441-69ab47430ed8" +version = "1.1.3" [[deps.Animations]] deps = ["Colors"] -git-tree-sha1 = "e81c509d2c8e49592413bfb0bb3b08150056c79d" +git-tree-sha1 = "e092fa223bf66a3c41f9c022bd074d916dc303e7" uuid = "27a7e980-b3e6-11e9-2bcd-0b925532e340" -version = "0.4.1" +version = "0.4.2" [[deps.ArgCheck]] -git-tree-sha1 = "a3a402a35a2f7e0b87828ccabbd5ebfbebe356b4" +git-tree-sha1 = "680b3b8759bd4c54052ada14e52355ab69e07876" uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" -version = "2.3.0" +version = "2.4.0" [[deps.ArgTools]] uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" -version = "1.1.1" +version = "1.1.2" [[deps.ArrayInterface]] -deps = ["Adapt", "LinearAlgebra", "Requires", "SparseArrays", "SuiteSparse"] -git-tree-sha1 = "bbec08a37f8722786d87bedf84eae19c020c4efa" +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "017fcb757f8e921fb44ee063a7aafe5f89b86dd1" uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" -version = "7.7.0" +version = "7.18.0" [deps.ArrayInterface.extensions] ArrayInterfaceBandedMatricesExt = "BandedMatrices" ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = "CUDSS" + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" ArrayInterfaceTrackerExt = "Tracker" @@ -154,24 +187,42 @@ version = "7.7.0" BandedMatrices = "aae01518-5342-5314-be14-df237901396f" BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" [[deps.Artifacts]] uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" [[deps.Atomix]] deps = ["UnsafeAtomics"] -git-tree-sha1 = "c06a868224ecba914baa6942988e2f2aade419be" +git-tree-sha1 = "93da6c8228993b0052e358ad592ee7c1eccaa639" uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" -version = "0.1.0" +version = "1.1.0" + + [deps.Atomix.extensions] + AtomixCUDAExt = "CUDA" + AtomixMetalExt = "Metal" + AtomixOpenCLExt = "OpenCL" + AtomixoneAPIExt = "oneAPI" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" [[deps.Automa]] -deps = ["PrecompileTools", "TranscodingStreams"] -git-tree-sha1 = "0da671c730d79b8f9a88a391556ec695ea921040" +deps = ["PrecompileTools", "SIMD", "TranscodingStreams"] +git-tree-sha1 = "a8f503e8e1a5f583fbef15a8440c8c7e32185df2" uuid = "67c07d97-cdcb-5c2c-af73-a7f9c32a568b" -version = "1.0.2" +version = "1.1.0" [[deps.AxisAlgorithms]] deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"] @@ -186,16 +237,17 @@ uuid = "39de3d68-74b9-583c-8d2d-e117c070f3a9" version = "0.4.7" [[deps.BangBang]] -deps = ["Compat", "ConstructionBase", "InitialValues", "LinearAlgebra", "Requires", "Setfield", "Tables"] -git-tree-sha1 = "e28912ce94077686443433c2800104b061a827ed" +deps = ["Accessors", "ConstructionBase", "InitialValues", "LinearAlgebra", "Requires"] +git-tree-sha1 = "e2144b631226d9eeab2d746ca8880b7ccff504ae" uuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66" -version = "0.3.39" +version = "0.4.3" [deps.BangBang.extensions] BangBangChainRulesCoreExt = "ChainRulesCore" BangBangDataFramesExt = "DataFrames" BangBangStaticArraysExt = "StaticArrays" BangBangStructArraysExt = "StructArrays" + BangBangTablesExt = "Tables" BangBangTypedTablesExt = "TypedTables" [deps.BangBang.weakdeps] @@ -203,10 +255,12 @@ version = "0.3.39" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" [[deps.Base64]] uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" [[deps.Baselet]] git-tree-sha1 = "aebf55e6d7795e02ca500a689d326ac979aaf89e" @@ -214,43 +268,47 @@ uuid = "9718e550-a3fa-408a-8086-8db961cd8217" version = "0.1.1" [[deps.BenchmarkTools]] -deps = ["JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"] -git-tree-sha1 = "f1f03a9fa24271160ed7e73051fba3c1a759b53f" +deps = ["Compat", "JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"] +git-tree-sha1 = "e38fbc49a620f5d0b660d7f543db1009fe0f8336" uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" -version = "1.4.0" +version = "1.6.0" [[deps.Bijectors]] -deps = ["ArgCheck", "ChainRules", "ChainRulesCore", "ChangesOfVariables", "Compat", "Distributions", "Functors", "InverseFunctions", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "MappedArrays", "Random", "Reexport", "Requires", "Roots", "SparseArrays", "Statistics"] -git-tree-sha1 = "199dc2c4151db557549a0ad8888ce1a60337ff42" +deps = ["ArgCheck", "ChainRulesCore", "ChangesOfVariables", "Distributions", "DocStringExtensions", "Functors", "InverseFunctions", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "MappedArrays", "Random", "Reexport", "Roots", "SparseArrays", "Statistics"] +git-tree-sha1 = "af42d5383609f5cd167a2f9b1b2371c2d6604d02" uuid = "76274a88-744f-5084-9051-94815aaf08c4" -version = "0.13.8" +version = "0.15.4" [deps.Bijectors.extensions] BijectorsDistributionsADExt = "DistributionsAD" + BijectorsEnzymeCoreExt = "EnzymeCore" BijectorsForwardDiffExt = "ForwardDiff" BijectorsLazyArraysExt = "LazyArrays" + BijectorsMooncakeExt = "Mooncake" BijectorsReverseDiffExt = "ReverseDiff" BijectorsTrackerExt = "Tracker" BijectorsZygoteExt = "Zygote" [deps.Bijectors.weakdeps] DistributionsAD = "ced4e74d-a319-5a8a-b0ac-84af2272839c" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" [[deps.BitFlags]] -git-tree-sha1 = "2dc09997850d68179b69dafb58ae806167a32b1b" +git-tree-sha1 = "0691e34b3bb8be9307330f88d1a3c3f25466c24d" uuid = "d1d4a3ce-64b1-5f1a-9ba4-7e7e69966f35" -version = "0.1.8" +version = "0.1.9" [[deps.Bzip2_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "19a35467a82e236ff51bc17a3a44b69ef35185a2" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1b96ea4a01afe0ea4090c5c8039690672dd13f2e" uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" -version = "1.0.8+0" +version = "1.0.9+0" [[deps.CEnum]] git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" @@ -259,12 +317,7 @@ version = "0.5.0" [[deps.CRC32c]] uuid = "8bf52ea8-c179-5cab-976a-9e18b702a9bc" - -[[deps.CRlibm]] -deps = ["CRlibm_jll"] -git-tree-sha1 = "32abd86e3c2025db5172aa182b982debed519834" -uuid = "96374032-68de-5a5b-8d9e-752f78720389" -version = "1.0.1" +version = "1.11.0" [[deps.CRlibm_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -274,83 +327,82 @@ version = "1.0.1+0" [[deps.Cairo]] deps = ["Cairo_jll", "Colors", "Glib_jll", "Graphics", "Libdl", "Pango_jll"] -git-tree-sha1 = "d0b3f8b4ad16cb0a2988c6788646a5e6a17b6b1b" +git-tree-sha1 = "71aa551c5c33f1a4415867fe06b7844faadb0ae9" uuid = "159f3aea-2a34-519c-b102-8c37f9878175" -version = "1.0.5" +version = "1.1.1" [[deps.CairoMakie]] -deps = ["CRC32c", "Cairo", "Colors", "FFTW", "FileIO", "FreeType", "GeometryBasics", "LinearAlgebra", "Makie", "PrecompileTools"] -git-tree-sha1 = "ec7c21818710774e72195bda25c70fd6c56bc005" +deps = ["CRC32c", "Cairo", "Cairo_jll", "Colors", "FileIO", "FreeType", "GeometryBasics", "LinearAlgebra", "Makie", "PrecompileTools"] +git-tree-sha1 = "6d76f05dbc8b7a52deaa7cdabe901735ae7b6724" uuid = "13f3f980-e62b-5c42-98c6-ff1f3baf88f0" -version = "0.11.5" +version = "0.13.1" [[deps.Cairo_jll]] -deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_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" +deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "009060c9a6168704143100f36ab08f06c2af4642" uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a" -version = "1.16.1+1" - -[[deps.Calculus]] -deps = ["LinearAlgebra"] -git-tree-sha1 = "f641eb0a4f00c343bbc32346e1217b86f3ce9dad" -uuid = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9" -version = "0.5.1" +version = "1.18.2+1" [[deps.ChainRules]] deps = ["Adapt", "ChainRulesCore", "Compat", "Distributed", "GPUArraysCore", "IrrationalConstants", "LinearAlgebra", "Random", "RealDot", "SparseArrays", "SparseInverseSubset", "Statistics", "StructArrays", "SuiteSparse"] -git-tree-sha1 = "0aa0a3dd7b9bacbbadf1932ccbdfa938985c5561" +git-tree-sha1 = "4312d7869590fab4a4f789e97bd82f0a04eaaa05" uuid = "082447d4-558c-5d27-93f4-14fc19e9eca2" -version = "1.58.1" +version = "1.72.2" [[deps.ChainRulesCore]] deps = ["Compat", "LinearAlgebra"] -git-tree-sha1 = "2118cb2765f8197b08e5958cdd17c165427425ee" +git-tree-sha1 = "1713c74e00545bfe14605d2a2be1712de8fbcb58" uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" -version = "1.19.0" +version = "1.25.1" weakdeps = ["SparseArrays"] [deps.ChainRulesCore.extensions] ChainRulesCoreSparseArraysExt = "SparseArrays" [[deps.ChangesOfVariables]] -deps = ["LinearAlgebra", "Test"] -git-tree-sha1 = "2fba81a302a7be671aefe194f0525ef231104e7f" +deps = ["LinearAlgebra"] +git-tree-sha1 = "799b25ca3a8a24936ae7b5c52ad194685fc3e6ef" uuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" -version = "0.1.8" -weakdeps = ["InverseFunctions"] +version = "0.1.9" +weakdeps = ["InverseFunctions", "Test"] [deps.ChangesOfVariables.extensions] ChangesOfVariablesInverseFunctionsExt = "InverseFunctions" + ChangesOfVariablesTestExt = "Test" [[deps.CodecZlib]] deps = ["TranscodingStreams", "Zlib_jll"] -git-tree-sha1 = "cd67fc487743b2f0fd4380d4cbd3a24660d0eec8" +git-tree-sha1 = "962834c22b66e32aa10f7611c08c8ca4e20749a9" uuid = "944b1d66-785c-5afd-91f1-9de20f533193" -version = "0.7.3" +version = "0.7.8" [[deps.ColorBrewer]] -deps = ["Colors", "JSON", "Test"] -git-tree-sha1 = "61c5334f33d91e570e1d0c3eb5465835242582c4" +deps = ["Colors", "JSON"] +git-tree-sha1 = "e771a63cc8b539eca78c85b0cabd9233d6c8f06f" uuid = "a2cac450-b92f-5266-8821-25eda20663c8" -version = "0.4.0" +version = "0.4.1" [[deps.ColorSchemes]] deps = ["ColorTypes", "ColorVectorSpace", "Colors", "FixedPointNumbers", "PrecompileTools", "Random"] -git-tree-sha1 = "67c1f244b991cad9b0aa4b7540fb758c2488b129" +git-tree-sha1 = "403f2d8e209681fcbd9468a8514efff3ea08452e" uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4" -version = "3.24.0" +version = "3.29.0" [[deps.ColorTypes]] deps = ["FixedPointNumbers", "Random"] -git-tree-sha1 = "eb7f0f8307f71fac7c606984ea5fb2817275d6e4" +git-tree-sha1 = "c7acce7a7e1078a20a285211dd73cd3941a871d6" uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" -version = "0.11.4" +version = "0.12.0" +weakdeps = ["StyledStrings"] + + [deps.ColorTypes.extensions] + StyledStringsExt = "StyledStrings" [[deps.ColorVectorSpace]] deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "Requires", "Statistics", "TensorCore"] -git-tree-sha1 = "a1f44953f2382ebb937d60dafbe2deea4bd23249" +git-tree-sha1 = "8b3b6f87ce8f65a2b4f857528fd8d70086cd72b1" uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4" -version = "0.10.0" +version = "0.11.0" weakdeps = ["SpecialFunctions"] [deps.ColorVectorSpace.extensions] @@ -358,9 +410,9 @@ weakdeps = ["SpecialFunctions"] [[deps.Colors]] deps = ["ColorTypes", "FixedPointNumbers", "Reexport"] -git-tree-sha1 = "fc08e5930ee9a4e03f84bfb5211cb54e7769758a" +git-tree-sha1 = "64e15186f0aa277e174aa81798f7eb8598e0157e" uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" -version = "0.12.10" +version = "0.13.0" [[deps.Combinatorics]] git-tree-sha1 = "08c8b6831dc00bfea825826be0bc8336fc369860" @@ -373,16 +425,16 @@ uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" version = "0.2.4" [[deps.CommonSubexpressions]] -deps = ["MacroTools", "Test"] -git-tree-sha1 = "7b8a93dba8af7e3b42fecabf646260105ac373f7" +deps = ["MacroTools"] +git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" -version = "0.3.0" +version = "0.3.1" [[deps.Compat]] -deps = ["UUIDs"] -git-tree-sha1 = "886826d76ea9e72b35fcd000e535588f7b60f21d" +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "8ae8d32e09f0dcf42a36b90d4e17f5dd2e4c4215" uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" -version = "4.10.1" +version = "4.16.0" weakdeps = ["Dates", "LinearAlgebra"] [deps.Compat.extensions] @@ -391,7 +443,7 @@ weakdeps = ["Dates", "LinearAlgebra"] [[deps.CompilerSupportLibraries_jll]] deps = ["Artifacts", "Libdl"] uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" -version = "1.0.5+1" +version = "1.1.1+0" [[deps.CompositionsBase]] git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" @@ -404,9 +456,9 @@ weakdeps = ["InverseFunctions"] [[deps.ConcurrentUtilities]] deps = ["Serialization", "Sockets"] -git-tree-sha1 = "8cfa272e8bdedfa88b6aefbbca7c19f1befac519" +git-tree-sha1 = "d9d26935a0bcffc87d2613ce14c527c99fc543fd" uuid = "f0e56b4a-5159-44fe-b623-3e5288b988bb" -version = "2.3.0" +version = "2.5.0" [[deps.ConsoleProgressMonitor]] deps = ["Logging", "ProgressMeter"] @@ -415,20 +467,20 @@ uuid = "88cd18e8-d9cc-4ea6-8889-5259c0d15c8b" version = "0.1.2" [[deps.ConstructionBase]] -deps = ["LinearAlgebra"] -git-tree-sha1 = "c53fc348ca4d40d7b371e71fd52251839080cbc9" +git-tree-sha1 = "76219f1ed5771adbb096743bff43fb5fdd4c1157" uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" -version = "1.5.4" -weakdeps = ["IntervalSets", "StaticArrays"] +version = "1.5.8" +weakdeps = ["IntervalSets", "LinearAlgebra", "StaticArrays"] [deps.ConstructionBase.extensions] ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseLinearAlgebraExt = "LinearAlgebra" ConstructionBaseStaticArraysExt = "StaticArrays" [[deps.Contour]] -git-tree-sha1 = "d05d9e7b7aedff4e5b51a029dced05cfb6125781" +git-tree-sha1 = "439e35b0b36e2e5881738abc8857bd92ad6ff9a8" uuid = "d38c429a-6771-53c6-b99e-75d170b6e991" -version = "0.6.2" +version = "0.6.3" [[deps.Crayons]] git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15" @@ -436,15 +488,15 @@ uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" version = "4.1.1" [[deps.DataAPI]] -git-tree-sha1 = "8da84edb865b0b5b0100c0666a9bc9a0b71c553c" +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" -version = "1.15.0" +version = "1.16.0" [[deps.DataStructures]] deps = ["Compat", "InteractiveUtils", "OrderedCollections"] -git-tree-sha1 = "ac67408d9ddf207de5cfa9a97e114352430f01ed" +git-tree-sha1 = "1d0a14036acb104d9e89698bd408f63ab58cdc82" uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" -version = "0.18.16" +version = "0.18.20" [[deps.DataValueInterfaces]] git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" @@ -454,6 +506,13 @@ version = "1.0.0" [[deps.Dates]] deps = ["Printf"] uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Dbus_jll]] +deps = ["Artifacts", "Expat_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "fc173b380865f70627d7dd1190dc2fce6cc105af" +uuid = "ee1fde0b-3d02-5ea6-8484-8dfef6360eab" +version = "1.14.10+0" [[deps.DefineSingletons]] git-tree-sha1 = "0fba8b706d0178b4dc7fd44a96a92382c9065c2c" @@ -461,10 +520,10 @@ uuid = "244e2a9f-e319-4986-a169-4d1fe445cd52" version = "0.1.2" [[deps.DelaunayTriangulation]] -deps = ["DataStructures", "EnumX", "ExactPredicates", "Random", "SimpleGraphs"] -git-tree-sha1 = "26eb8e2331b55735c3d305d949aabd7363f07ba7" +deps = ["AdaptivePredicates", "EnumX", "ExactPredicates", "Random"] +git-tree-sha1 = "5620ff4ee0084a6ab7097a27ba0c19290200b037" uuid = "927a84f5-c5f4-47a5-9785-b46e178433df" -version = "0.8.11" +version = "1.6.4" [[deps.DelimitedFiles]] deps = ["Mmap"] @@ -490,15 +549,62 @@ git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272" uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" version = "1.15.1" +[[deps.DifferentiationInterface]] +deps = ["ADTypes", "LinearAlgebra"] +git-tree-sha1 = "258fa016b2d03f19e4d0d1cd8e30c84907af1528" +uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +version = "0.6.42" + + [deps.DifferentiationInterface.extensions] + DifferentiationInterfaceChainRulesCoreExt = "ChainRulesCore" + DifferentiationInterfaceDiffractorExt = "Diffractor" + DifferentiationInterfaceEnzymeExt = ["EnzymeCore", "Enzyme"] + DifferentiationInterfaceFastDifferentiationExt = "FastDifferentiation" + DifferentiationInterfaceFiniteDiffExt = "FiniteDiff" + DifferentiationInterfaceFiniteDifferencesExt = "FiniteDifferences" + DifferentiationInterfaceForwardDiffExt = ["ForwardDiff", "DiffResults"] + DifferentiationInterfaceGTPSAExt = "GTPSA" + DifferentiationInterfaceMooncakeExt = "Mooncake" + DifferentiationInterfacePolyesterForwardDiffExt = "PolyesterForwardDiff" + DifferentiationInterfaceReverseDiffExt = ["ReverseDiff", "DiffResults"] + DifferentiationInterfaceSparseArraysExt = "SparseArrays" + DifferentiationInterfaceSparseMatrixColoringsExt = "SparseMatrixColorings" + DifferentiationInterfaceStaticArraysExt = "StaticArrays" + DifferentiationInterfaceSymbolicsExt = "Symbolics" + DifferentiationInterfaceTrackerExt = "Tracker" + DifferentiationInterfaceZygoteExt = ["Zygote", "ForwardDiff"] + + [deps.DifferentiationInterface.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" + Diffractor = "9f5e2b26-1114-432f-b630-d3fe2085c51c" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastDifferentiation = "eb9bf01b-bf85-4b60-bf87-ee5de06c00be" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PolyesterForwardDiff = "98d1487c-24ca-40b6-b7ab-df2af84e126b" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + [[deps.Distributed]] deps = ["Random", "Serialization", "Sockets"] uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" +version = "1.11.0" [[deps.Distributions]] -deps = ["FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] -git-tree-sha1 = "a4532d110ce91bd744b99280193a317310960c46" +deps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "03aa5d44647eaec98e1920635cdfed5d5560a8b9" uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" -version = "0.25.106" +version = "0.25.117" weakdeps = ["ChainRulesCore", "DensityInterface", "Test"] [deps.Distributions.extensions] @@ -508,9 +614,9 @@ weakdeps = ["ChainRulesCore", "DensityInterface", "Test"] [[deps.DistributionsAD]] deps = ["Adapt", "ChainRules", "ChainRulesCore", "Compat", "Distributions", "FillArrays", "LinearAlgebra", "PDMats", "Random", "Requires", "SpecialFunctions", "StaticArrays", "StatsFuns", "ZygoteRules"] -git-tree-sha1 = "d61f08c7bd15c5ab215fd7a2eb61c1ae15d8ff5e" +git-tree-sha1 = "02c2e6e6a137069227439fe884d729cca5b70e56" uuid = "ced4e74d-a319-5a8a-b0ac-84af2272839c" -version = "0.6.53" +version = "0.6.57" [deps.DistributionsAD.extensions] DistributionsADForwardDiffExt = "ForwardDiff" @@ -535,28 +641,28 @@ deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" version = "1.6.0" -[[deps.DualNumbers]] -deps = ["Calculus", "NaNMath", "SpecialFunctions"] -git-tree-sha1 = "5837a837389fccf076445fce071c8ddaea35a566" -uuid = "fa6b7ba4-c1ee-5f82-b5fc-ecf0adba8f74" -version = "0.6.8" - [[deps.DynamicPPL]] -deps = ["AbstractMCMC", "AbstractPPL", "BangBang", "Bijectors", "Compat", "ConstructionBase", "Distributions", "DocStringExtensions", "LinearAlgebra", "LogDensityProblems", "MacroTools", "OrderedCollections", "Random", "Requires", "Setfield", "Test"] -git-tree-sha1 = "26c17df3ef86eec24851f00bfec25c734d6f0ad9" +deps = ["ADTypes", "AbstractMCMC", "AbstractPPL", "Accessors", "BangBang", "Bijectors", "Compat", "ConstructionBase", "Distributions", "DocStringExtensions", "InteractiveUtils", "KernelAbstractions", "LinearAlgebra", "LogDensityProblems", "LogDensityProblemsAD", "MacroTools", "OrderedCollections", "Random", "Requires", "Test"] +git-tree-sha1 = "18fcc77ba683967339473b731143fa269ea671f5" uuid = "366bfd00-2699-11ea-058f-f148b4cae6d8" -version = "0.24.4" +version = "0.34.2" [deps.DynamicPPL.extensions] DynamicPPLChainRulesCoreExt = ["ChainRulesCore"] DynamicPPLEnzymeCoreExt = ["EnzymeCore"] + DynamicPPLForwardDiffExt = ["ForwardDiff"] + DynamicPPLJETExt = ["JET"] DynamicPPLMCMCChainsExt = ["MCMCChains"] + DynamicPPLMooncakeExt = ["Mooncake"] DynamicPPLZygoteRulesExt = ["ZygoteRules"] [deps.DynamicPPL.weakdeps] ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + JET = "c3a54625-cd67-489e-a8e7-0a5a0ff4e31b" MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" ZygoteRules = "700de1a5-db45-46bc-99cf-38207098b444" [[deps.EarCut_jll]] @@ -578,48 +684,49 @@ version = "1.0.4" [[deps.EpollShim_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "8e9441ee83492030ace98f9789a654a6d0b1f643" +git-tree-sha1 = "8a4be429317c42cfae6a7fc03c31bad1970c310d" uuid = "2702e6a9-849d-5ed8-8c21-79e8b8f9ee43" -version = "0.0.20230411+0" - -[[deps.ErrorfreeArithmetic]] -git-tree-sha1 = "d6863c556f1142a061532e79f611aa46be201686" -uuid = "90fa49ef-747e-5e6f-a989-263ba693cf1a" -version = "0.5.2" +version = "0.0.20230411+1" [[deps.ExactPredicates]] -deps = ["IntervalArithmetic", "Random", "StaticArraysCore"] -git-tree-sha1 = "499b1ca78f6180c8f8bdf1cabde2d39120229e5c" +deps = ["IntervalArithmetic", "Random", "StaticArrays"] +git-tree-sha1 = "b3f2ff58735b5f024c392fde763f29b057e4b025" uuid = "429591f6-91af-11e9-00e2-59fbe8cec110" -version = "2.2.6" +version = "2.2.8" [[deps.ExceptionUnwrapping]] deps = ["Test"] -git-tree-sha1 = "dcb08a0d93ec0b1cdc4af184b26b591e9695423a" +git-tree-sha1 = "d36f682e590a83d63d1c7dbd287573764682d12a" uuid = "460bff9d-24e4-43bc-9d9f-a8973cb893f4" -version = "0.1.10" +version = "0.1.11" [[deps.Expat_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "4558ab818dcceaab612d1bb8c19cee87eda2b83c" +git-tree-sha1 = "d55dffd9ae73ff72f1c0482454dcf2ec6c6c4a63" uuid = "2e619515-83b5-522b-bb60-26c02a35a201" -version = "2.5.0+0" +version = "2.6.5+0" [[deps.ExprTools]] git-tree-sha1 = "27415f162e6028e81c72b82ef756bf321213b6ec" uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" version = "0.1.10" +[[deps.Expronicon]] +deps = ["MLStyle", "Pkg", "TOML"] +git-tree-sha1 = "fc3951d4d398b5515f91d7fe5d45fc31dccb3c9b" +uuid = "6b7a57c9-7cc1-4fdf-b7f5-e857abae3636" +version = "0.8.5" + [[deps.Extents]] -git-tree-sha1 = "2140cd04483da90b2da7f99b2add0750504fc39c" +git-tree-sha1 = "063512a13dbe9c40d999c439268539aa552d1ae6" uuid = "411431e0-e8b7-467b-b5e0-f676ba4f2910" -version = "0.1.2" +version = "0.1.5" [[deps.FFMPEG]] deps = ["FFMPEG_jll"] -git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8" +git-tree-sha1 = "53ebe7511fa11d33bec688a9178fac4e49eeee00" uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" -version = "0.4.1" +version = "0.4.2" [[deps.FFMPEG_jll]] deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] @@ -629,27 +736,30 @@ version = "4.4.4+1" [[deps.FFTW]] deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] -git-tree-sha1 = "ec22cbbcd01cba8f41eecd7d44aac1f23ee985e3" +git-tree-sha1 = "7de7c78d681078f027389e067864a8d53bd7c3c9" uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" -version = "1.7.2" +version = "1.8.1" [[deps.FFTW_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "c6033cc3892d0ef5bb9cd29b7f2f0331ea5184ea" +git-tree-sha1 = "4d81ed14783ec49ce9f2e168208a12ce1815aa25" uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" -version = "3.3.10+0" +version = "3.3.10+3" -[[deps.FastRounding]] -deps = ["ErrorfreeArithmetic", "LinearAlgebra"] -git-tree-sha1 = "6344aa18f654196be82e62816935225b3b9abe44" -uuid = "fa42c844-2597-5d31-933b-ebd51ab2693f" -version = "0.3.1" +[[deps.FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" [[deps.FileIO]] deps = ["Pkg", "Requires", "UUIDs"] -git-tree-sha1 = "c5c28c245101bd59154f649e19b038d15901b5dc" +git-tree-sha1 = "2dd20384bf8c6d411b5c7370865b1e9b26cb2ea3" uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" -version = "1.16.2" +version = "1.16.6" +weakdeps = ["HTTP"] + + [deps.FileIO.extensions] + HTTPExt = "HTTP" [[deps.FilePaths]] deps = ["FilePathsBase", "MacroTools", "Reexport", "Requires"] @@ -658,19 +768,25 @@ uuid = "8fc22ac5-c921-52a6-82fd-178b2807b824" version = "0.8.3" [[deps.FilePathsBase]] -deps = ["Compat", "Dates", "Mmap", "Printf", "Test", "UUIDs"] -git-tree-sha1 = "9f00e42f8d99fdde64d40c8ea5d14269a2e2c1aa" +deps = ["Compat", "Dates"] +git-tree-sha1 = "2ec417fc319faa2d768621085cc1feebbdee686b" uuid = "48062228-2e41-5def-b9a4-89aafe57970f" -version = "0.9.21" +version = "0.9.23" +weakdeps = ["Mmap", "Test"] + + [deps.FilePathsBase.extensions] + FilePathsBaseMmapExt = "Mmap" + FilePathsBaseTestExt = "Test" [[deps.FileWatching]] uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" [[deps.FillArrays]] -deps = ["LinearAlgebra", "Random"] -git-tree-sha1 = "5b93957f6dcd33fc343044af3d48c215be2562f1" +deps = ["LinearAlgebra"] +git-tree-sha1 = "6a70198746448456524cb442b8af316927ff3e1a" uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" -version = "1.9.3" +version = "1.13.0" weakdeps = ["PDMats", "SparseArrays", "Statistics"] [deps.FillArrays.extensions] @@ -679,44 +795,45 @@ weakdeps = ["PDMats", "SparseArrays", "Statistics"] FillArraysStatisticsExt = "Statistics" [[deps.FiniteDiff]] -deps = ["ArrayInterface", "LinearAlgebra", "Requires", "Setfield", "SparseArrays"] -git-tree-sha1 = "73d1214fec245096717847c62d389a5d2ac86504" +deps = ["ArrayInterface", "LinearAlgebra", "Setfield"] +git-tree-sha1 = "f089ab1f834470c525562030c8cfde4025d5e915" uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" -version = "2.22.0" +version = "2.27.0" [deps.FiniteDiff.extensions] FiniteDiffBandedMatricesExt = "BandedMatrices" FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffSparseArraysExt = "SparseArrays" FiniteDiffStaticArraysExt = "StaticArrays" [deps.FiniteDiff.weakdeps] BandedMatrices = "aae01518-5342-5314-be14-df237901396f" BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" [[deps.FixedPointNumbers]] deps = ["Statistics"] -git-tree-sha1 = "335bfdceacc84c5cdf16aadc768aa5ddfc5383cc" +git-tree-sha1 = "05882d6995ae5c12bb5f36dd2ed3f61c98cbb172" uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" -version = "0.8.4" +version = "0.8.5" [[deps.Fontconfig_jll]] -deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Pkg", "Zlib_jll"] -git-tree-sha1 = "21efd19106a55620a188615da6d3d06cd7f6ee03" +deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Zlib_jll"] +git-tree-sha1 = "21fac3c77d7b5a9fc03b0ec503aa1a6392c34d2b" uuid = "a3f928ae-7b40-5064-980b-68af3947d34b" -version = "2.13.93+0" +version = "2.15.0+0" -[[deps.Formatting]] -deps = ["Printf"] -git-tree-sha1 = "8339d61043228fdd3eb658d86c926cb282ae72a8" -uuid = "59287772-0a20-5a39-b81b-1366585eb4c0" -version = "0.4.2" +[[deps.Format]] +git-tree-sha1 = "9c68794ef81b08086aeb32eeaf33531668d5f5fc" +uuid = "1fa38f19-a742-5d3f-a2b9-30dd87b9d5f8" +version = "1.3.7" [[deps.ForwardDiff]] deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] -git-tree-sha1 = "cf0fe81336da9fb90944683b8c41984b08793dad" +git-tree-sha1 = "a2df1b776752e3f344e5116c06d75a10436ab853" uuid = "f6369f11-7733-5829-9624-2563aa707210" -version = "0.10.36" +version = "0.10.38" weakdeps = ["StaticArrays"] [deps.ForwardDiff.extensions] @@ -730,21 +847,21 @@ version = "4.1.1" [[deps.FreeType2_jll]] deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Zlib_jll"] -git-tree-sha1 = "d8db6a5a2fe1381c1ea4ef2cab7c69c2de7f9ea0" +git-tree-sha1 = "786e968a8d2fb167f2e4880baba62e0e26bd8e4e" uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" -version = "2.13.1+0" +version = "2.13.3+1" [[deps.FreeTypeAbstraction]] deps = ["ColorVectorSpace", "Colors", "FreeType", "GeometryBasics"] -git-tree-sha1 = "055626e1a35f6771fe99060e835b72ca61a52621" +git-tree-sha1 = "d52e255138ac21be31fa633200b65e4e71d26802" uuid = "663a7486-cb36-511b-a19d-713bb74d65c9" -version = "0.10.1" +version = "0.10.6" [[deps.FriBidi_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "aa31987c2ba8704e23c6c8ba8a4f769d5d7e4f91" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "846f7026a9decf3679419122b49f8a1fdb48d2d5" uuid = "559328eb-81f9-559d-9380-de523a88c83c" -version = "1.0.10+0" +version = "1.0.16+0" [[deps.FunctionWrappers]] git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" @@ -758,50 +875,56 @@ uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf" version = "0.1.3" [[deps.Functors]] -deps = ["LinearAlgebra"] -git-tree-sha1 = "9a68d75d466ccc1218d0552a8e1631151c569545" +deps = ["Compat", "ConstructionBase", "LinearAlgebra", "Random"] +git-tree-sha1 = "60a0339f28a233601cb74468032b5c302d5067de" uuid = "d9f16b24-f501-4c13-a1f2-28368ffc5196" -version = "0.4.5" +version = "0.5.2" [[deps.Future]] deps = ["Random"] uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" +version = "1.11.0" [[deps.GLFW_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll"] -git-tree-sha1 = "ff38ba61beff76b8f4acad8ab0c97ef73bb670cb" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll", "libdecor_jll", "xkbcommon_jll"] +git-tree-sha1 = "fcb0584ff34e25155876418979d4c8971243bb89" uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89" -version = "3.3.9+0" +version = "3.4.0+2" [[deps.GPUArraysCore]] deps = ["Adapt"] -git-tree-sha1 = "2d6ca471a6c7b536127afccfa7564b5b39227fe0" +git-tree-sha1 = "83cf05ab16a73219e5f6bd1bdfa9848fa24ac627" uuid = "46192b85-c4d5-4398-a991-12ede77f4527" -version = "0.1.5" +version = "0.2.0" [[deps.GR]] -deps = ["Artifacts", "Base64", "DelimitedFiles", "Downloads", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Pkg", "Preferences", "Printf", "Random", "Serialization", "Sockets", "TOML", "Tar", "Test", "UUIDs", "p7zip_jll"] -git-tree-sha1 = "27442171f28c952804dede8ff72828a96f2bfc1f" +deps = ["Artifacts", "Base64", "DelimitedFiles", "Downloads", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Preferences", "Printf", "Qt6Wayland_jll", "Random", "Serialization", "Sockets", "TOML", "Tar", "Test", "p7zip_jll"] +git-tree-sha1 = "0ff136326605f8e06e9bcf085a356ab312eef18a" uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71" -version = "0.72.10" +version = "0.73.13" [[deps.GR_jll]] deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "FreeType2_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Qt6Base_jll", "Zlib_jll", "libpng_jll"] -git-tree-sha1 = "025d171a2847f616becc0f84c8dc62fe18f0f6dd" +git-tree-sha1 = "9cb62849057df859575fc1dda1e91b82f8609709" uuid = "d2c73de3-f751-5644-a686-071e5b155ba9" -version = "0.72.10+0" +version = "0.73.13+0" + +[[deps.GeoFormatTypes]] +git-tree-sha1 = "8e233d5167e63d708d41f87597433f59a0f213fe" +uuid = "68eda718-8dee-11e9-39e7-89f7f65f511f" +version = "0.4.4" [[deps.GeoInterface]] -deps = ["Extents"] -git-tree-sha1 = "d4f85701f569584f2cff7ba67a137d03f0cfb7d0" +deps = ["DataAPI", "Extents", "GeoFormatTypes"] +git-tree-sha1 = "294e99f19869d0b0cb71aef92f19d03649d028d5" uuid = "cf35fbd7-0cd7-5166-be24-54bfbe79505f" -version = "1.3.3" +version = "1.4.1" [[deps.GeometryBasics]] -deps = ["EarCut_jll", "Extents", "GeoInterface", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"] -git-tree-sha1 = "424a5a6ce7c5d97cca7bcc4eac551b97294c54af" +deps = ["EarCut_jll", "Extents", "GeoInterface", "IterTools", "LinearAlgebra", "PrecompileTools", "Random", "StaticArrays"] +git-tree-sha1 = "f0895e73ba6c469ec8efaa13712eb5ee1a3647a3" uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326" -version = "0.4.9" +version = "0.5.2" [[deps.Gettext_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"] @@ -809,29 +932,35 @@ git-tree-sha1 = "9b02998aba7bf074d14de89f9d37ca24a1a0b046" uuid = "78b55507-aeef-58d4-861c-77aaff3498b1" version = "0.21.0+0" +[[deps.Giflib_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6570366d757b50fabae9f4315ad74d2e40c0560a" +uuid = "59f7168a-df46-5410-90c8-f2779963d0ec" +version = "5.2.3+0" + [[deps.Glib_jll]] deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] -git-tree-sha1 = "e94c92c7bf4819685eb80186d51c43e71d4afa17" +git-tree-sha1 = "b0036b392358c80d2d2124746c2bf3d48d457938" uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" -version = "2.76.5+0" +version = "2.82.4+0" [[deps.Graphics]] deps = ["Colors", "LinearAlgebra", "NaNMath"] -git-tree-sha1 = "d61890399bc535850c4bf08e4e0d3a7ad0f21cbd" +git-tree-sha1 = "a641238db938fff9b2f60d08ed9030387daf428c" uuid = "a2bd30eb-e257-5431-a919-1863eab51364" -version = "1.1.2" +version = "1.1.3" [[deps.Graphite2_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "344bf40dcab1073aca04aa0df4fb092f920e4011" +git-tree-sha1 = "01979f9b37367603e2848ea225918a3b3861b606" uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472" -version = "1.3.14+0" +version = "1.3.14+1" [[deps.GridLayoutBase]] deps = ["GeometryBasics", "InteractiveUtils", "Observables"] -git-tree-sha1 = "af13a277efd8a6e716d79ef635d5342ccb75be61" +git-tree-sha1 = "dc6bed05c15523624909b3953686c5f5ffa10adc" uuid = "3955a311-db13-416c-9275-1d80ed98e5e9" -version = "0.10.0" +version = "0.11.1" [[deps.Grisu]] git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2" @@ -839,28 +968,28 @@ uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe" version = "1.0.2" [[deps.HTTP]] -deps = ["Base64", "CodecZlib", "ConcurrentUtilities", "Dates", "ExceptionUnwrapping", "Logging", "LoggingExtras", "MbedTLS", "NetworkOptions", "OpenSSL", "Random", "SimpleBufferStream", "Sockets", "URIs", "UUIDs"] -git-tree-sha1 = "abbbb9ec3afd783a7cbd82ef01dcd088ea051398" +deps = ["Base64", "CodecZlib", "ConcurrentUtilities", "Dates", "ExceptionUnwrapping", "Logging", "LoggingExtras", "MbedTLS", "NetworkOptions", "OpenSSL", "PrecompileTools", "Random", "SimpleBufferStream", "Sockets", "URIs", "UUIDs"] +git-tree-sha1 = "c67b33b085f6e2faf8bf79a61962e7339a81129c" uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3" -version = "1.10.1" +version = "1.10.15" [[deps.HarfBuzz_jll]] -deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg"] -git-tree-sha1 = "129acf094d168394e80ee1dc4bc06ec835e510a3" +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll"] +git-tree-sha1 = "55c53be97790242c29031e5cd45e8ac296dadda3" uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566" -version = "2.8.1+1" +version = "8.5.0+0" [[deps.HypergeometricFunctions]] -deps = ["DualNumbers", "LinearAlgebra", "OpenLibm_jll", "SpecialFunctions"] -git-tree-sha1 = "f218fe3736ddf977e0e772bc9a586b2383da2685" +deps = ["LinearAlgebra", "OpenLibm_jll", "SpecialFunctions"] +git-tree-sha1 = "2bd56245074fab4015b9174f24ceba8293209053" uuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a" -version = "0.3.23" +version = "0.3.27" [[deps.ImageAxes]] deps = ["AxisArrays", "ImageBase", "ImageCore", "Reexport", "SimpleTraits"] -git-tree-sha1 = "2e4520d67b0cef90865b3ef727594d2a58e0e1f8" +git-tree-sha1 = "e12629406c6c4442539436581041d372d69c55ba" uuid = "2803e5a7-5153-5ecf-9a86-9b4c37f5f5ac" -version = "0.6.11" +version = "0.6.12" [[deps.ImageBase]] deps = ["ImageCore", "Reexport"] @@ -869,28 +998,28 @@ uuid = "c817782e-172a-44cc-b673-b171935fbb9e" version = "0.1.7" [[deps.ImageCore]] -deps = ["AbstractFFTs", "ColorVectorSpace", "Colors", "FixedPointNumbers", "MappedArrays", "MosaicViews", "OffsetArrays", "PaddedViews", "PrecompileTools", "Reexport"] -git-tree-sha1 = "fc5d1d3443a124fde6e92d0260cd9e064eba69f8" +deps = ["ColorVectorSpace", "Colors", "FixedPointNumbers", "MappedArrays", "MosaicViews", "OffsetArrays", "PaddedViews", "PrecompileTools", "Reexport"] +git-tree-sha1 = "8c193230235bbcee22c8066b0374f63b5683c2d3" uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534" -version = "0.10.1" +version = "0.10.5" [[deps.ImageIO]] -deps = ["FileIO", "IndirectArrays", "JpegTurbo", "LazyModules", "Netpbm", "OpenEXR", "PNGFiles", "QOI", "Sixel", "TiffImages", "UUIDs"] -git-tree-sha1 = "bca20b2f5d00c4fbc192c3212da8fa79f4688009" +deps = ["FileIO", "IndirectArrays", "JpegTurbo", "LazyModules", "Netpbm", "OpenEXR", "PNGFiles", "QOI", "Sixel", "TiffImages", "UUIDs", "WebP"] +git-tree-sha1 = "696144904b76e1ca433b886b4e7edd067d76cbf7" uuid = "82e4d734-157c-48bb-816b-45c225c6df19" -version = "0.6.7" +version = "0.6.9" [[deps.ImageMetadata]] deps = ["AxisArrays", "ImageAxes", "ImageBase", "ImageCore"] -git-tree-sha1 = "355e2b974f2e3212a75dfb60519de21361ad3cb7" +git-tree-sha1 = "2a81c3897be6fbcde0802a0ebe6796d0562f63ec" uuid = "bc367c6b-8a6b-528e-b4bd-a4b897500b49" -version = "0.9.9" +version = "0.9.10" [[deps.Imath_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "3d09a9f60edf77f8a4d99f9e015e8fbf9989605d" +git-tree-sha1 = "0936ba688c6d201805a83da835b55c61a180db52" uuid = "905a6f67-0a94-5f89-b386-d35d92009cd1" -version = "3.1.7+0" +version = "3.1.11+0" [[deps.IndirectArrays]] git-tree-sha1 = "012e604e1c7458645cb8b436f8fba789a51b257f" @@ -898,9 +1027,9 @@ uuid = "9b13fd28-a010-5f03-acff-a1bbcff69959" version = "1.0.0" [[deps.Inflate]] -git-tree-sha1 = "ea8031dea4aff6bd41f1df8f2fdfb25b33626381" +git-tree-sha1 = "d1b1b796e47d94588b3757fe84fbf65a5ec4a80d" uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9" -version = "0.1.4" +version = "0.1.5" [[deps.InitialValues]] git-tree-sha1 = "4da0f88e9a39111c2fa3add390ab15f3a44f3ca3" @@ -913,20 +1042,16 @@ git-tree-sha1 = "50b41d59e7164ab6fda65e71049fee9d890731ff" uuid = "505f98c9-085e-5b2c-8e89-488be7bf1f34" version = "0.3.0" -[[deps.IntegerMathUtils]] -git-tree-sha1 = "b8ffb903da9f7b8cf695a8bead8e01814aa24b30" -uuid = "18e54dd8-cb9d-406c-a71d-865a43cbb235" -version = "0.1.2" - [[deps.IntelOpenMP_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "5fdf2fe6724d8caabf43b557b84ce53f3b7e2f6b" +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "0f14a5456bdc6b9731a5682f439a672750a09e48" uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" -version = "2024.0.2+0" +version = "2025.0.4+0" [[deps.InteractiveUtils]] deps = ["Markdown"] uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" [[deps.Interpolations]] deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] @@ -939,36 +1064,48 @@ weakdeps = ["Unitful"] InterpolationsUnitfulExt = "Unitful" [[deps.IntervalArithmetic]] -deps = ["CRlibm", "EnumX", "FastRounding", "LinearAlgebra", "Markdown", "Random", "RecipesBase", "RoundingEmulator", "SetRounding", "StaticArrays"] -git-tree-sha1 = "f59e639916283c1d2e106d2b00910b50f4dab76c" +deps = ["CRlibm_jll", "LinearAlgebra", "MacroTools", "RoundingEmulator"] +git-tree-sha1 = "0fcf2079f918f68c6412cab5f2679822cbd7357f" uuid = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253" -version = "0.21.2" +version = "0.22.23" +weakdeps = ["DiffRules", "ForwardDiff", "IntervalSets", "RecipesBase"] + + [deps.IntervalArithmetic.extensions] + IntervalArithmeticDiffRulesExt = "DiffRules" + IntervalArithmeticForwardDiffExt = "ForwardDiff" + IntervalArithmeticIntervalSetsExt = "IntervalSets" + IntervalArithmeticRecipesBaseExt = "RecipesBase" [[deps.IntervalSets]] -deps = ["Dates", "Random"] -git-tree-sha1 = "3d8866c029dd6b16e69e0d4a939c4dfcb98fac47" +git-tree-sha1 = "dba9ddf07f77f60450fe5d2e2beb9854d9a49bd0" uuid = "8197267c-284f-5f27-9208-e0e47529a953" -version = "0.7.8" -weakdeps = ["Statistics"] +version = "0.7.10" +weakdeps = ["Random", "RecipesBase", "Statistics"] [deps.IntervalSets.extensions] + IntervalSetsRandomExt = "Random" + IntervalSetsRecipesBaseExt = "RecipesBase" IntervalSetsStatisticsExt = "Statistics" [[deps.InverseFunctions]] -deps = ["Test"] -git-tree-sha1 = "68772f49f54b479fa88ace904f6127f0a3bb2e46" +git-tree-sha1 = "a779299d77cd080bf77b97535acecd73e1c5e5cb" uuid = "3587e190-3f89-42d0-90ee-14403ec27112" -version = "0.1.12" +version = "0.1.17" +weakdeps = ["Dates", "Test"] + + [deps.InverseFunctions.extensions] + InverseFunctionsDatesExt = "Dates" + InverseFunctionsTestExt = "Test" [[deps.InvertedIndices]] -git-tree-sha1 = "0dc7b50b8d436461be01300fd8cd45aa0274b038" +git-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe" uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" -version = "1.3.0" +version = "1.3.1" [[deps.IrrationalConstants]] -git-tree-sha1 = "630b497eafcc20001bba38a4651b327dcfc491d2" +git-tree-sha1 = "e2222959fbc6c19554dc15174c81bf7bf3aa691c" uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" -version = "0.2.2" +version = "0.2.4" [[deps.Isoband]] deps = ["isoband_jll"] @@ -988,15 +1125,15 @@ version = "1.0.0" [[deps.JLFzf]] deps = ["Pipe", "REPL", "Random", "fzf_jll"] -git-tree-sha1 = "a53ebe394b71470c7f97c2e7e170d51df21b17af" +git-tree-sha1 = "71b48d857e86bf7a1838c4736545699974ce79a2" uuid = "1019f520-868f-41f5-a6de-eb00f4b6a39c" -version = "0.1.7" +version = "0.1.9" [[deps.JLLWrappers]] deps = ["Artifacts", "Preferences"] -git-tree-sha1 = "7e5d6779a1e09a36db2a7b6cff50942a0a7d0fca" +git-tree-sha1 = "a007feb38b422fbdab534406aeca1b86823cb4d6" uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" -version = "1.5.0" +version = "1.7.0" [[deps.JSON]] deps = ["Dates", "Mmap", "Parsers", "Unicode"] @@ -1012,103 +1149,102 @@ version = "0.1.5" [[deps.JpegTurbo_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "60b1194df0a3298f460063de985eae7b01bc011a" +git-tree-sha1 = "eac1206917768cb54957c65a615460d87b455fc1" uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8" -version = "3.0.1+0" +version = "3.1.1+0" [[deps.KernelAbstractions]] -deps = ["Adapt", "Atomix", "InteractiveUtils", "LinearAlgebra", "MacroTools", "PrecompileTools", "Requires", "SparseArrays", "StaticArrays", "UUIDs", "UnsafeAtomics", "UnsafeAtomicsLLVM"] -git-tree-sha1 = "653e0824fc9ab55b3beec67a6dbbe514a65fb954" +deps = ["Adapt", "Atomix", "InteractiveUtils", "MacroTools", "PrecompileTools", "Requires", "StaticArrays", "UUIDs"] +git-tree-sha1 = "b9a838cd3028785ac23822cded5126b3da394d1a" uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" -version = "0.9.15" +version = "0.9.31" [deps.KernelAbstractions.extensions] EnzymeExt = "EnzymeCore" + LinearAlgebraExt = "LinearAlgebra" + SparseArraysExt = "SparseArrays" [deps.KernelAbstractions.weakdeps] EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" [[deps.KernelDensity]] deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"] -git-tree-sha1 = "fee018a29b60733876eb557804b5b109dd3dd8a7" +git-tree-sha1 = "7d703202e65efa1369de1279c162b915e245eed1" uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" -version = "0.6.8" +version = "0.6.9" [[deps.LAME_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "170b660facf5df5de098d866564877e119141cbd" uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" -version = "3.100.1+0" +version = "3.100.2+0" + +[[deps.LBFGSB]] +deps = ["L_BFGS_B_jll"] +git-tree-sha1 = "e2e6f53ee20605d0ea2be473480b7480bd5091b5" +uuid = "5be7bae1-8223-5378-bac3-9e7378a2f6e6" +version = "0.4.1" [[deps.LERC_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "bf36f528eec6634efc60d7ec062008f171071434" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "aaafe88dccbd957a8d82f7d05be9b69172e0cee3" uuid = "88015f11-f218-50d7-93a8-a6af411a945d" -version = "3.0.0+1" - -[[deps.LLVM]] -deps = ["CEnum", "LLVMExtra_jll", "Libdl", "Preferences", "Printf", "Requires", "Unicode"] -git-tree-sha1 = "cb4619f7353fc62a1a22ffa3d7ed9791cfb47ad8" -uuid = "929cbde3-209d-540e-8aea-75f648917ca0" -version = "6.4.2" - - [deps.LLVM.extensions] - BFloat16sExt = "BFloat16s" - - [deps.LLVM.weakdeps] - BFloat16s = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" - -[[deps.LLVMExtra_jll]] -deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"] -git-tree-sha1 = "98eaee04d96d973e79c25d49167668c5c8fb50e2" -uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" -version = "0.0.27+1" +version = "4.0.1+0" [[deps.LLVMOpenMP_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "d986ce2d884d49126836ea94ed5bfb0f12679713" +git-tree-sha1 = "78211fb6cbc872f77cad3fc0b6cf647d923f4929" uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" -version = "15.0.7+0" +version = "18.1.7+0" [[deps.LRUCache]] -git-tree-sha1 = "5930ef949f30a9a947c69ef6b069c0b1aa27619d" +git-tree-sha1 = "b3cc6698599b10e652832c2f23db3cab99d51b59" uuid = "8ac3fa9e-de4c-5943-b1dc-09c6b5f20637" -version = "1.6.0" +version = "1.6.1" +weakdeps = ["Serialization"] + + [deps.LRUCache.extensions] + SerializationExt = ["Serialization"] [[deps.LZO_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1c602b1127f4751facb671441ca72715cc95938a" uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac" -version = "2.10.1+0" +version = "2.10.3+0" + +[[deps.L_BFGS_B_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "77feda930ed3f04b2b0fbb5bea89e69d3677c6b0" +uuid = "81d17ec3-03a1-5e46-b53e-bddc35a13473" +version = "3.0.1+0" [[deps.LaTeXStrings]] -git-tree-sha1 = "50901ebc375ed41dbf8058da26f9de442febbbec" +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" -version = "1.3.1" +version = "1.4.0" [[deps.Latexify]] -deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "OrderedCollections", "Printf", "Requires"] -git-tree-sha1 = "f428ae552340899a935973270b8d98e5a31c49fe" +deps = ["Format", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "OrderedCollections", "Requires"] +git-tree-sha1 = "cd714447457c660382fe634710fb56eb255ee42e" uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" -version = "0.16.1" +version = "0.16.6" [deps.Latexify.extensions] DataFramesExt = "DataFrames" + SparseArraysExt = "SparseArrays" SymEngineExt = "SymEngine" [deps.Latexify.weakdeps] DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" SymEngine = "123dc426-2d89-5057-bbad-38513e3affd8" -[[deps.Lazy]] -deps = ["MacroTools"] -git-tree-sha1 = "1370f8202dac30758f3c345f9909b97f53d87d3f" -uuid = "50d2b5c4-7a5e-59d5-8109-a42b560f39c0" -version = "0.15.1" - [[deps.LazyArtifacts]] deps = ["Artifacts", "Pkg"] uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" [[deps.LazyModules]] git-tree-sha1 = "a560dd966b386ac9ae60bdd3a3d3a326062d3c3e" @@ -1129,16 +1265,17 @@ version = "0.6.4" [[deps.LibCURL_jll]] deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" -version = "8.4.0+0" +version = "8.6.0+0" [[deps.LibGit2]] deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"] uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" [[deps.LibGit2_jll]] deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"] uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" -version = "1.6.4+0" +version = "1.7.2+0" [[deps.LibSSH2_jll]] deps = ["Artifacts", "Libdl", "MbedTLS_jll"] @@ -1147,97 +1284,88 @@ version = "1.11.0+1" [[deps.Libdl]] uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" [[deps.Libffi_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "0b4a5d71f3e5200a7dff793393e09dfc2d874290" +git-tree-sha1 = "27ecae93dd25ee0909666e6835051dd684cc035e" uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490" -version = "3.2.2+1" +version = "3.2.2+2" [[deps.Libgcrypt_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll", "Pkg"] -git-tree-sha1 = "64613c82a59c120435c067c2b809fc61cf5166ae" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll"] +git-tree-sha1 = "8be878062e0ffa2c3f67bb58a595375eda5de80b" uuid = "d4300ac3-e22c-5743-9152-c294e39db1e4" -version = "1.8.7+0" +version = "1.11.0+0" [[deps.Libglvnd_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll", "Xorg_libXext_jll"] -git-tree-sha1 = "6f73d1dd803986947b2c750138528a999a6c7733" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll", "Xorg_libXext_jll"] +git-tree-sha1 = "ff3b4b9d35de638936a525ecd36e86a8bb919d11" uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29" -version = "1.6.0+0" +version = "1.7.0+0" [[deps.Libgpg_error_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "c333716e46366857753e273ce6a69ee0945a6db9" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "df37206100d39f79b3376afb6b9cee4970041c61" uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8" -version = "1.42.0+0" +version = "1.51.1+0" [[deps.Libiconv_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "f9557a255370125b405568f9767d6d195822a175" +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" -version = "1.17.0+0" +version = "1.18.0+0" [[deps.Libmount_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "9c30530bf0effd46e15e0fdcf2b8636e78cbbd73" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "89211ea35d9df5831fca5d33552c02bd33878419" uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" -version = "2.35.0+0" +version = "2.40.3+0" [[deps.Libtask]] deps = ["FunctionWrappers", "LRUCache", "LinearAlgebra", "Statistics"] -git-tree-sha1 = "345a40c746404dd9cb1bbc368715856838ab96f2" +git-tree-sha1 = "902ece54b0cb5c5413a8a15db0ad2aa2ec4172d2" uuid = "6f1fad26-d15e-5dc8-ae53-837a1d7b8c9f" -version = "0.8.6" +version = "0.8.8" [[deps.Libtiff_jll]] deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "XZ_jll", "Zlib_jll", "Zstd_jll"] -git-tree-sha1 = "2da088d113af58221c52828a80378e16be7d037a" +git-tree-sha1 = "4ab7581296671007fc33f07a721631b8855f4b1d" uuid = "89763e89-9b03-5906-acba-b20f662cd828" -version = "4.5.1+1" +version = "4.7.1+0" [[deps.Libuuid_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "7f3efec06033682db852f8b3bc3c1d2b0a0ab066" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e888ad02ce716b319e6bdb985d2ef300e7089889" uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" -version = "2.36.0+0" - -[[deps.LightXML]] -deps = ["Libdl", "XML2_jll"] -git-tree-sha1 = "3a994404d3f6709610701c7dabfc03fed87a81f8" -uuid = "9c8b4983-aa76-5018-a973-4c85ecc9e179" -version = "0.9.1" +version = "2.40.3+0" [[deps.LineSearches]] deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] -git-tree-sha1 = "7bbea35cec17305fc70a0e5b4641477dc0789d9d" +git-tree-sha1 = "e4c3be53733db1051cc15ecf573b1042b3a712a1" uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" -version = "7.2.0" +version = "7.3.0" [[deps.LinearAlgebra]] deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" - -[[deps.LinearAlgebraX]] -deps = ["LinearAlgebra", "Mods", "Permutations", "Primes", "SimplePolynomials"] -git-tree-sha1 = "89ed93300377e0742ae8a7423f7543c8f5eb73a4" -uuid = "9b3f67b0-2d00-526e-9884-9e4938f8fb88" -version = "0.2.5" +version = "1.11.0" [[deps.LogDensityProblems]] deps = ["ArgCheck", "DocStringExtensions", "Random"] -git-tree-sha1 = "f9a11237204bc137617194d79d813069838fcf61" +git-tree-sha1 = "4e0128c1590d23a50dcdb106c7e2dbca99df85c0" uuid = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" -version = "2.1.1" +version = "2.1.2" [[deps.LogDensityProblemsAD]] -deps = ["DocStringExtensions", "LogDensityProblems", "Requires", "SimpleUnPack"] -git-tree-sha1 = "9c50732cd0f188766b6217ed6a2ebbdaf9890029" +deps = ["DocStringExtensions", "LogDensityProblems"] +git-tree-sha1 = "a10e798ac8c44fe1594ad7d6e02898e16e4eafa3" uuid = "996a588d-648d-4e1f-a8f0-a84b347e47b1" -version = "1.7.0" +version = "1.13.0" [deps.LogDensityProblemsAD.extensions] LogDensityProblemsADADTypesExt = "ADTypes" + LogDensityProblemsADDifferentiationInterfaceExt = ["ADTypes", "DifferentiationInterface"] LogDensityProblemsADEnzymeExt = "Enzyme" LogDensityProblemsADFiniteDifferencesExt = "FiniteDifferences" LogDensityProblemsADForwardDiffBenchmarkToolsExt = ["BenchmarkTools", "ForwardDiff"] @@ -1249,6 +1377,7 @@ version = "1.7.0" [deps.LogDensityProblemsAD.weakdeps] ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b" BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" + DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" @@ -1258,9 +1387,9 @@ version = "1.7.0" [[deps.LogExpFunctions]] deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] -git-tree-sha1 = "7d6dd4e9212aebaeed356de34ccf262a3cd415aa" +git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f" uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" -version = "0.3.26" +version = "0.3.29" weakdeps = ["ChainRulesCore", "ChangesOfVariables", "InverseFunctions"] [deps.LogExpFunctions.extensions] @@ -1270,54 +1399,59 @@ weakdeps = ["ChainRulesCore", "ChangesOfVariables", "InverseFunctions"] [[deps.Logging]] uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" [[deps.LoggingExtras]] deps = ["Dates", "Logging"] -git-tree-sha1 = "c1dd6d7978c12545b4179fb6153b9250c96b0075" +git-tree-sha1 = "f02b56007b064fbfddb4c9cd60161b6dd0f40df3" uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" -version = "1.0.3" +version = "1.1.0" [[deps.MCMCChains]] -deps = ["AbstractMCMC", "AxisArrays", "Dates", "Distributions", "Formatting", "IteratorInterfaceExtensions", "KernelDensity", "LinearAlgebra", "MCMCDiagnosticTools", "MLJModelInterface", "NaturalSort", "OrderedCollections", "PrettyTables", "Random", "RecipesBase", "Statistics", "StatsBase", "StatsFuns", "TableTraits", "Tables"] -git-tree-sha1 = "3b1ae6bcb0a94ed7760e72cd3524794f613658d2" +deps = ["AbstractMCMC", "AxisArrays", "Dates", "Distributions", "IteratorInterfaceExtensions", "KernelDensity", "LinearAlgebra", "MCMCDiagnosticTools", "MLJModelInterface", "NaturalSort", "OrderedCollections", "PrettyTables", "Random", "RecipesBase", "Statistics", "StatsBase", "StatsFuns", "TableTraits", "Tables"] +git-tree-sha1 = "cd7aee22384792c726e19f2a22dc060b886edded" uuid = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" -version = "6.0.4" +version = "6.0.7" [[deps.MCMCDiagnosticTools]] deps = ["AbstractFFTs", "DataAPI", "DataStructures", "Distributions", "LinearAlgebra", "MLJModelInterface", "Random", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "Tables"] -git-tree-sha1 = "6ea46c36b86320593d2017da3c28c79165167ef4" +git-tree-sha1 = "a586f05dd16a50c490ed95415b2a829b8cf5d57f" uuid = "be115224-59cd-429b-ad48-344e309966f0" -version = "0.3.8" +version = "0.3.14" [[deps.MKL_jll]] -deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl"] -git-tree-sha1 = "72dc3cf284559eb8f53aa593fe62cb33f83ed0c0" +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "5de60bc6cb3899cd318d80d627560fae2e2d99ae" uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" -version = "2024.0.0+0" +version = "2025.0.1+1" [[deps.MLJModelInterface]] deps = ["Random", "ScientificTypesBase", "StatisticalTraits"] -git-tree-sha1 = "0cd3514d865b928e6a36f03497f65b5b1dee38c1" +git-tree-sha1 = "ceaff6618408d0e412619321ae43b33b40c1a733" uuid = "e80e1ace-859a-464e-9ed9-23947d8ae3ea" -version = "1.9.4" +version = "1.11.0" + +[[deps.MLStyle]] +git-tree-sha1 = "bc38dff0548128765760c79eb7388a4b37fae2c8" +uuid = "d8e11817-5142-5d16-987a-aa16d5891078" +version = "0.4.17" [[deps.MacroTools]] -deps = ["Markdown", "Random"] -git-tree-sha1 = "b211c553c199c111d998ecdaf7623d1b89b69f93" +git-tree-sha1 = "72aebe0b5051e5143a079a4685a46da330a40472" uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" -version = "0.5.12" +version = "0.5.15" [[deps.Makie]] -deps = ["Animations", "Base64", "CRC32c", "ColorBrewer", "ColorSchemes", "ColorTypes", "Colors", "Contour", "DelaunayTriangulation", "Distributions", "DocStringExtensions", "Downloads", "FFMPEG_jll", "FileIO", "FilePaths", "FixedPointNumbers", "Formatting", "FreeType", "FreeTypeAbstraction", "GeometryBasics", "GridLayoutBase", "ImageIO", "InteractiveUtils", "IntervalSets", "Isoband", "KernelDensity", "LaTeXStrings", "LinearAlgebra", "MacroTools", "MakieCore", "Markdown", "MathTeXEngine", "Observables", "OffsetArrays", "Packing", "PlotUtils", "PolygonOps", "PrecompileTools", "Printf", "REPL", "Random", "RelocatableFolders", "Scratch", "Setfield", "ShaderAbstractions", "Showoff", "SignedDistanceFields", "SparseArrays", "StableHashTraits", "Statistics", "StatsBase", "StatsFuns", "StructArrays", "TriplotBase", "UnicodeFun"] -git-tree-sha1 = "a37c6610dd20425b131caf65d52abdf859da5ab1" +deps = ["Animations", "Base64", "CRC32c", "ColorBrewer", "ColorSchemes", "ColorTypes", "Colors", "Contour", "Dates", "DelaunayTriangulation", "Distributions", "DocStringExtensions", "Downloads", "FFMPEG_jll", "FileIO", "FilePaths", "FixedPointNumbers", "Format", "FreeType", "FreeTypeAbstraction", "GeometryBasics", "GridLayoutBase", "ImageBase", "ImageIO", "InteractiveUtils", "Interpolations", "IntervalSets", "InverseFunctions", "Isoband", "KernelDensity", "LaTeXStrings", "LinearAlgebra", "MacroTools", "MakieCore", "Markdown", "MathTeXEngine", "Observables", "OffsetArrays", "PNGFiles", "Packing", "PlotUtils", "PolygonOps", "PrecompileTools", "Printf", "REPL", "Random", "RelocatableFolders", "Scratch", "ShaderAbstractions", "Showoff", "SignedDistanceFields", "SparseArrays", "Statistics", "StatsBase", "StatsFuns", "StructArrays", "TriplotBase", "UnicodeFun", "Unitful"] +git-tree-sha1 = "9680336a5b67f9f9f6eaa018f426043a8cd68200" uuid = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" -version = "0.20.4" +version = "0.22.1" [[deps.MakieCore]] -deps = ["Observables", "REPL"] -git-tree-sha1 = "ec5db7bb2dc9b85072658dcb2d3ad09569b09ac9" +deps = ["ColorTypes", "GeometryBasics", "IntervalSets", "Observables"] +git-tree-sha1 = "c731269d5a2c85ffdc689127a9ba6d73e978a4b1" uuid = "20f20a25-4f0e-4fdf-b5d1-57303727442b" -version = "0.7.2" +version = "0.9.0" [[deps.MappedArrays]] git-tree-sha1 = "2dab0221fe2b0f2cb6754eaa743cc266339f527e" @@ -1327,12 +1461,13 @@ version = "0.4.2" [[deps.Markdown]] deps = ["Base64"] uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" [[deps.MathTeXEngine]] deps = ["AbstractTrees", "Automa", "DataStructures", "FreeTypeAbstraction", "GeometryBasics", "LaTeXStrings", "REPL", "RelocatableFolders", "UnicodeFun"] -git-tree-sha1 = "96ca8a313eb6437db5ffe946c457a401bbb8ce1d" +git-tree-sha1 = "f45c8916e8385976e1ccd055c9874560c257ab13" uuid = "0a4f8689-d25c-4efe-a92b-7142dfc1aa53" -version = "0.5.7" +version = "0.6.2" [[deps.MbedTLS]] deps = ["Dates", "MbedTLS_jll", "MozillaCACerts_jll", "NetworkOptions", "Random", "Sockets"] @@ -1343,7 +1478,7 @@ version = "1.1.9" [[deps.MbedTLS_jll]] deps = ["Artifacts", "Libdl"] uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" -version = "2.28.2+1" +version = "2.28.6+0" [[deps.Measures]] git-tree-sha1 = "c13304c81eec1ed3af7fc20e75fb6b26092a1102" @@ -1352,29 +1487,25 @@ version = "0.3.2" [[deps.Memoization]] deps = ["MacroTools"] -git-tree-sha1 = "073f080e733bc6697411901224ed4fd15fefaffa" +git-tree-sha1 = "7dbf904fa6c4447bd1f1d316886bfbe29feacf45" uuid = "6fafb56a-5788-4b4e-91ca-c0cea6611c73" -version = "0.2.1" +version = "0.2.2" [[deps.MicroCollections]] -deps = ["BangBang", "InitialValues", "Setfield"] -git-tree-sha1 = "629afd7d10dbc6935ec59b32daeb33bc4460a42e" +deps = ["Accessors", "BangBang", "InitialValues"] +git-tree-sha1 = "44d32db644e84c75dab479f1bc15ee76a1a3618f" uuid = "128add7d-3638-4c79-886c-908ea0c25c34" -version = "0.1.4" +version = "0.2.0" [[deps.Missings]] deps = ["DataAPI"] -git-tree-sha1 = "f66bdc5de519e8f8ae43bdc598782d35a25b1272" +git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d" uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" -version = "1.1.0" +version = "1.2.0" [[deps.Mmap]] uuid = "a63ad114-7e13-5084-954f-fe012c677804" - -[[deps.Mods]] -git-tree-sha1 = "f241641066029f1e35c1ce1814dbea4e5ca29582" -uuid = "7475f97c-0381-53b1-977b-4c60186c8d62" -version = "2.2.2" +version = "1.11.0" [[deps.MosaicViews]] deps = ["MappedArrays", "OffsetArrays", "PaddedViews", "StackViews"] @@ -1384,12 +1515,7 @@ version = "0.3.4" [[deps.MozillaCACerts_jll]] uuid = "14a3606d-f60d-562e-9121-12d972cd8159" -version = "2023.1.10" - -[[deps.Multisets]] -git-tree-sha1 = "8d852646862c96e226367ad10c8af56099b4047e" -uuid = "3b2b4ff1-bcff-5658-a3ee-dbcf1ce5ac09" -version = "0.4.4" +version = "2023.12.12" [[deps.NLSolversBase]] deps = ["DiffResults", "Distributed", "FiniteDiff", "ForwardDiff"] @@ -1398,34 +1524,38 @@ uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" version = "7.8.3" [[deps.NNlib]] -deps = ["Adapt", "Atomix", "ChainRulesCore", "GPUArraysCore", "KernelAbstractions", "LinearAlgebra", "Pkg", "Random", "Requires", "Statistics"] -git-tree-sha1 = "900a11b3a2b02e36b25cb55a80777d4a4670f0f6" +deps = ["Adapt", "Atomix", "ChainRulesCore", "GPUArraysCore", "KernelAbstractions", "LinearAlgebra", "Random", "Statistics"] +git-tree-sha1 = "bdc9d30f151590aca0af22690f5ab7dc18a551cb" uuid = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" -version = "0.9.10" +version = "0.9.27" [deps.NNlib.extensions] NNlibAMDGPUExt = "AMDGPU" NNlibCUDACUDNNExt = ["CUDA", "cuDNN"] NNlibCUDAExt = "CUDA" NNlibEnzymeCoreExt = "EnzymeCore" + NNlibFFTWExt = "FFTW" + NNlibForwardDiffExt = "ForwardDiff" [deps.NNlib.weakdeps] AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" [[deps.NaNMath]] deps = ["OpenLibm_jll"] -git-tree-sha1 = "0877504529a3e5c3343c6f8b4c0381e57e4387e4" +git-tree-sha1 = "cc0a5deefdb12ab3a096f00a6d42133af4560d71" uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" -version = "1.0.2" +version = "1.1.2" [[deps.NamedArrays]] deps = ["Combinatorics", "DataStructures", "DelimitedFiles", "InvertedIndices", "LinearAlgebra", "Random", "Requires", "SparseArrays", "Statistics"] -git-tree-sha1 = "6d42eca6c3a27dc79172d6d947ead136d88751bb" +git-tree-sha1 = "58e317b3b956b8aaddfd33ff4c3e33199cd8efce" uuid = "86f7a689-2022-50b4-a561-43c23ac3c673" -version = "0.10.0" +version = "0.10.3" [[deps.NaturalSort]] git-tree-sha1 = "eda490d06b9f7c00752ee81cfa451efe55521e21" @@ -1448,9 +1578,9 @@ uuid = "510215fc-4207-5dde-b226-833fc4488ee2" version = "0.5.5" [[deps.OffsetArrays]] -git-tree-sha1 = "6a731f2b5c03157418a20c12195eb4b74c8f8621" +git-tree-sha1 = "5e1897147d1ff8d98883cda2be2187dcf57d8f0c" uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" -version = "1.13.0" +version = "1.15.0" weakdeps = ["Adapt"] [deps.OffsetArrays.extensions] @@ -1465,19 +1595,19 @@ version = "1.3.5+1" [[deps.OpenBLAS_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" -version = "0.3.23+2" +version = "0.3.27+1" [[deps.OpenEXR]] deps = ["Colors", "FileIO", "OpenEXR_jll"] -git-tree-sha1 = "327f53360fdb54df7ecd01e96ef1983536d1e633" +git-tree-sha1 = "97db9e07fe2091882c765380ef58ec553074e9c7" uuid = "52e1d378-f018-4a11-a4be-720524705ac7" -version = "0.3.2" +version = "0.3.3" [[deps.OpenEXR_jll]] deps = ["Artifacts", "Imath_jll", "JLLWrappers", "Libdl", "Zlib_jll"] -git-tree-sha1 = "a4ca623df1ae99d09bc9868b008262d0c0ac1e4f" +git-tree-sha1 = "8292dd5c8a38257111ada2174000a33745b06d4e" uuid = "18a262bb-aa17-5467-a713-aee519bc75cb" -version = "3.1.4+0" +version = "3.2.4+0" [[deps.OpenLibm_jll]] deps = ["Artifacts", "Libdl"] @@ -1486,44 +1616,98 @@ version = "0.8.1+2" [[deps.OpenSSL]] deps = ["BitFlags", "Dates", "MozillaCACerts_jll", "OpenSSL_jll", "Sockets"] -git-tree-sha1 = "51901a49222b09e3743c65b8847687ae5fc78eb2" +git-tree-sha1 = "38cb508d080d21dc1128f7fb04f20387ed4c0af4" uuid = "4d8831e6-92b7-49fb-bdf8-b643e874388c" -version = "1.4.1" +version = "1.4.3" [[deps.OpenSSL_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "cc6e1927ac521b659af340e0ca45828a3ffc748f" +git-tree-sha1 = "a9697f1d06cc3eb3fb3ad49cc67f2cfabaac31ea" uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" -version = "3.0.12+0" +version = "3.0.16+0" [[deps.OpenSpecFun_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1" +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1346c9208249809840c91b26703912dff463d335" uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" -version = "0.5.5+0" +version = "0.5.6+0" [[deps.Optim]] deps = ["Compat", "FillArrays", "ForwardDiff", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "PositiveFactorizations", "Printf", "SparseArrays", "StatsBase"] -git-tree-sha1 = "01f85d9269b13fedc61e63cc72ee2213565f7a72" +git-tree-sha1 = "c1f51f704f689f87f28b33836fd460ecf9b34583" uuid = "429524aa-4258-5aef-a3af-852621145aeb" -version = "1.7.8" +version = "1.11.0" + + [deps.Optim.extensions] + OptimMOIExt = "MathOptInterface" + + [deps.Optim.weakdeps] + MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" [[deps.Optimisers]] deps = ["ChainRulesCore", "Functors", "LinearAlgebra", "Random", "Statistics"] -git-tree-sha1 = "c1fc26bab5df929a5172f296f25d7d08688fd25b" +git-tree-sha1 = "53ff746a3a2b232a37dbcd262ac8bbb2b18202b8" uuid = "3bd65402-5787-11e9-1adc-39752487f4e2" -version = "0.2.20" +version = "0.4.4" + + [deps.Optimisers.extensions] + OptimisersAdaptExt = ["Adapt"] + OptimisersEnzymeCoreExt = "EnzymeCore" + + [deps.Optimisers.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + +[[deps.Optimization]] +deps = ["ADTypes", "ArrayInterface", "ConsoleProgressMonitor", "DocStringExtensions", "LBFGSB", "LinearAlgebra", "Logging", "LoggingExtras", "OptimizationBase", "Printf", "ProgressLogging", "Reexport", "SciMLBase", "SparseArrays", "TerminalLoggers"] +git-tree-sha1 = "df361b5dc1f91ffb601700a2bc4bfdcd4cc584ef" +uuid = "7f7a1694-90dd-40f0-9382-eb1efda571ba" +version = "4.1.1" + +[[deps.OptimizationBase]] +deps = ["ADTypes", "ArrayInterface", "DifferentiationInterface", "DocStringExtensions", "FastClosures", "LinearAlgebra", "PDMats", "Reexport", "Requires", "SciMLBase", "SparseArrays", "SparseConnectivityTracer", "SparseMatrixColorings"] +git-tree-sha1 = "9e8569bc1c511c425fdc63f7ee41f2da057f8662" +uuid = "bca83a33-5cc9-4baa-983d-23429ab6bcbb" +version = "2.4.0" + + [deps.OptimizationBase.extensions] + OptimizationEnzymeExt = "Enzyme" + OptimizationFiniteDiffExt = "FiniteDiff" + OptimizationForwardDiffExt = "ForwardDiff" + OptimizationMLDataDevicesExt = "MLDataDevices" + OptimizationMLUtilsExt = "MLUtils" + OptimizationMTKExt = "ModelingToolkit" + OptimizationReverseDiffExt = "ReverseDiff" + OptimizationSymbolicAnalysisExt = "SymbolicAnalysis" + OptimizationZygoteExt = "Zygote" + + [deps.OptimizationBase.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + MLDataDevices = "7e8f7934-dd98-4c1a-8fe8-92b47a384d40" + MLUtils = "f1d291b0-491e-4a28-83b9-f70985020b54" + ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SymbolicAnalysis = "4297ee4d-0239-47d8-ba5d-195ecdf594fe" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.OptimizationOptimJL]] +deps = ["Optim", "Optimization", "PrecompileTools", "Reexport", "SparseArrays"] +git-tree-sha1 = "980ec7190741db164a2923dc42d6f1e7ce2cc434" +uuid = "36348300-93cb-4f02-beb5-3c3902f8871e" +version = "0.4.1" [[deps.Opus_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6703a85cb3781bd5909d48730a67205f3f31a575" uuid = "91d4177d-7536-5919-b921-800302f37372" -version = "1.3.2+0" +version = "1.3.3+0" [[deps.OrderedCollections]] -git-tree-sha1 = "dfdf5519f235516220579f949664f1bf44e741c5" +git-tree-sha1 = "cc4054e898b852042d7b503313f7ad03de99c3dd" uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" -version = "1.6.3" +version = "1.8.0" [[deps.PCRE2_jll]] deps = ["Artifacts", "Libdl"] @@ -1532,9 +1716,9 @@ version = "10.42.0+1" [[deps.PDMats]] deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] -git-tree-sha1 = "949347156c25054de2db3b166c52ac4728cbad65" +git-tree-sha1 = "966b85253e959ea89c53a9abebbf2e964fbf593b" uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" -version = "0.11.31" +version = "0.11.32" [[deps.PNGFiles]] deps = ["Base64", "CEnum", "ImageCore", "IndirectArrays", "OffsetArrays", "libpng_jll"] @@ -1544,9 +1728,9 @@ version = "0.4.3" [[deps.Packing]] deps = ["GeometryBasics"] -git-tree-sha1 = "ec3edfe723df33528e085e632414499f26650501" +git-tree-sha1 = "bc5bf2ea3d5351edf285a06b0016788a121ce92c" uuid = "19eb6ba3-879d-56ad-ad62-d5c202156566" -version = "0.5.0" +version = "0.5.1" [[deps.PaddedViews]] deps = ["OffsetArrays"] @@ -1556,9 +1740,9 @@ version = "0.5.12" [[deps.Pango_jll]] deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "FriBidi_jll", "Glib_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl"] -git-tree-sha1 = "4745216e94f71cb768d58330b059c9b76f32cb66" +git-tree-sha1 = "3b31172c032a1def20c98dae3f2cdc9d10e3b561" uuid = "36c8627f-9965-5494-a995-c6b170f724f3" -version = "1.50.14+0" +version = "1.56.1+0" [[deps.Parameters]] deps = ["OrderedCollections", "UnPack"] @@ -1572,12 +1756,6 @@ git-tree-sha1 = "8489905bcdbcfac64d1daa51ca07c0d8f0283821" uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" version = "2.8.1" -[[deps.Permutations]] -deps = ["Combinatorics", "LinearAlgebra", "Random"] -git-tree-sha1 = "c7745750b8a829bc6039b7f1f0981bcda526a946" -uuid = "2ae35dd2-176d-5d53-8349-f30d82d94d4f" -version = "0.4.19" - [[deps.Pipe]] git-tree-sha1 = "6842804e7867b115ca9de748a0cf6b364523c16d" uuid = "b98c9c47-44ae-5843-9183-064241ee97a0" @@ -1585,14 +1763,18 @@ version = "1.3.0" [[deps.Pixman_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] -git-tree-sha1 = "64779bc4c9784fee475689a1752ef4d5747c5e87" +git-tree-sha1 = "35621f10a7531bc8fa58f74610b1bfb70a3cfc6b" uuid = "30392449-352a-5448-841d-b1acce4e97dc" -version = "0.42.2+0" +version = "0.43.4+0" [[deps.Pkg]] -deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"] uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" -version = "1.10.0" +version = "1.11.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" [[deps.PkgVersion]] deps = ["Pkg"] @@ -1602,21 +1784,21 @@ version = "0.3.3" [[deps.PlotThemes]] deps = ["PlotUtils", "Statistics"] -git-tree-sha1 = "1f03a2d339f42dca4a4da149c7e15e9b896ad899" +git-tree-sha1 = "41031ef3a1be6f5bbbf3e8073f210556daeae5ca" uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a" -version = "3.1.0" +version = "3.3.0" [[deps.PlotUtils]] -deps = ["ColorSchemes", "Colors", "Dates", "PrecompileTools", "Printf", "Random", "Reexport", "Statistics"] -git-tree-sha1 = "862942baf5663da528f66d24996eb6da85218e76" +deps = ["ColorSchemes", "Colors", "Dates", "PrecompileTools", "Printf", "Random", "Reexport", "StableRNGs", "Statistics"] +git-tree-sha1 = "3ca9a356cd2e113c420f2c13bea19f8d3fb1cb18" uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" -version = "1.4.0" +version = "1.4.3" [[deps.Plots]] -deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "JLFzf", "JSON", "LaTeXStrings", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "PrecompileTools", "Preferences", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "RelocatableFolders", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "UnitfulLatexify", "Unzip"] -git-tree-sha1 = "ccee59c6e48e6f2edf8a5b64dc817b6729f99eb5" +deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "JLFzf", "JSON", "LaTeXStrings", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "PrecompileTools", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "RelocatableFolders", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "TOML", "UUIDs", "UnicodeFun", "UnitfulLatexify", "Unzip"] +git-tree-sha1 = "dae01f8c2e069a683d3a6e17bbae5070ab94786f" uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" -version = "1.39.0" +version = "1.40.9" [deps.Plots.extensions] FileIOExt = "FileIO" @@ -1637,24 +1819,6 @@ git-tree-sha1 = "77b3d3605fc1cd0b42d95eba87dfcd2bf67d5ff6" uuid = "647866c9-e3ac-4575-94e7-e3d426903924" version = "0.1.2" -[[deps.Polynomials]] -deps = ["LinearAlgebra", "RecipesBase", "Setfield", "SparseArrays"] -git-tree-sha1 = "a9c7a523d5ed375be3983db190f6a5874ae9286d" -uuid = "f27b6e38-b328-58d1-80ce-0feddd5e7a45" -version = "4.0.6" - - [deps.Polynomials.extensions] - PolynomialsChainRulesCoreExt = "ChainRulesCore" - PolynomialsFFTWExt = "FFTW" - PolynomialsMakieCoreExt = "MakieCore" - PolynomialsMutableArithmeticsExt = "MutableArithmetics" - - [deps.Polynomials.weakdeps] - ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" - FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" - MakieCore = "20f20a25-4f0e-4fdf-b5d1-57303727442b" - MutableArithmetics = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" - [[deps.PositiveFactorizations]] deps = ["LinearAlgebra"] git-tree-sha1 = "17275485f373e6673f7e7f97051f703ed5b15b20" @@ -1663,35 +1827,30 @@ version = "0.2.4" [[deps.PrecompileTools]] deps = ["Preferences"] -git-tree-sha1 = "03b4c25b43cb84cee5c90aa9b5ea0a78fd848d2f" +git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f" uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" -version = "1.2.0" +version = "1.2.1" [[deps.Preferences]] deps = ["TOML"] -git-tree-sha1 = "00805cd429dcb4870060ff49ef443486c262e38e" +git-tree-sha1 = "9306f6085165d270f7e3db02af26a400d580f5c6" uuid = "21216c6a-2e73-6563-6e65-726566657250" -version = "1.4.1" +version = "1.4.3" [[deps.PrettyTables]] deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"] -git-tree-sha1 = "88b895d13d53b5577fd53379d913b9ab9ac82660" +git-tree-sha1 = "1101cd475833706e4d0e7b122218257178f48f34" uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" -version = "2.3.1" - -[[deps.Primes]] -deps = ["IntegerMathUtils"] -git-tree-sha1 = "1d05623b5952aed1307bf8b43bec8b8d1ef94b6e" -uuid = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae" -version = "0.5.5" +version = "2.4.0" [[deps.Printf]] deps = ["Unicode"] uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" [[deps.Profile]] -deps = ["Printf"] uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" +version = "1.11.0" [[deps.ProgressLogging]] deps = ["Logging", "SHA", "UUIDs"] @@ -1701,47 +1860,78 @@ version = "0.1.4" [[deps.ProgressMeter]] deps = ["Distributed", "Printf"] -git-tree-sha1 = "00099623ffee15972c16111bcf84c58a0051257c" +git-tree-sha1 = "8f6bc219586aef8baf0ff9a5fe16ee9c70cb65e4" uuid = "92933f4c-e287-5a05-a399-4b506db050ca" -version = "1.9.0" +version = "1.10.2" + +[[deps.PtrArrays]] +git-tree-sha1 = "1d36ef11a9aaf1e8b74dacc6a731dd1de8fd493d" +uuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d" +version = "1.3.0" [[deps.QOI]] deps = ["ColorTypes", "FileIO", "FixedPointNumbers"] -git-tree-sha1 = "18e8f4d1426e965c7b532ddd260599e1510d26ce" +git-tree-sha1 = "8b3fc30bc0390abdce15f8822c889f669baed73d" uuid = "4b34888f-f399-49d4-9bb3-47ed5cae4e65" -version = "1.0.0" +version = "1.0.1" [[deps.Qt6Base_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Vulkan_Loader_jll", "Xorg_libSM_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_cursor_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "libinput_jll", "xkbcommon_jll"] -git-tree-sha1 = "37b7bb7aabf9a085e0044307e1717436117f2b3b" +git-tree-sha1 = "492601870742dcd38f233b23c3ec629628c1d724" uuid = "c0090381-4147-56d7-9ebc-da0b1113ec56" -version = "6.5.3+1" +version = "6.7.1+1" + +[[deps.Qt6Declarative_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll", "Qt6ShaderTools_jll"] +git-tree-sha1 = "e5dd466bf2569fe08c91a2cc29c1003f4797ac3b" +uuid = "629bc702-f1f5-5709-abd5-49b8460ea067" +version = "6.7.1+2" + +[[deps.Qt6ShaderTools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll"] +git-tree-sha1 = "1a180aeced866700d4bebc3120ea1451201f16bc" +uuid = "ce943373-25bb-56aa-8eca-768745ed7b5a" +version = "6.7.1+1" + +[[deps.Qt6Wayland_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll", "Qt6Declarative_jll"] +git-tree-sha1 = "729927532d48cf79f49070341e1d918a65aba6b0" +uuid = "e99dba38-086e-5de3-a5b1-6e4c66e897c3" +version = "6.7.1+1" [[deps.QuadGK]] deps = ["DataStructures", "LinearAlgebra"] -git-tree-sha1 = "9ebcd48c498668c7fa0e97a9cae873fbee7bfee1" +git-tree-sha1 = "9da16da70037ba9d701192e27befedefb91ec284" uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" -version = "2.9.1" +version = "2.11.2" + + [deps.QuadGK.extensions] + QuadGKEnzymeExt = "Enzyme" + + [deps.QuadGK.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" [[deps.REPL]] -deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] +deps = ["InteractiveUtils", "Markdown", "Sockets", "StyledStrings", "Unicode"] uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" [[deps.Random]] deps = ["SHA"] uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" [[deps.Random123]] deps = ["Random", "RandomNumbers"] -git-tree-sha1 = "c860e84651f58ce240dd79e5d9e055d55234c35a" +git-tree-sha1 = "4743b43e5a9c4a2ede372de7061eed81795b12e7" uuid = "74087812-796a-5b5d-8853-05524746bad3" -version = "1.6.2" +version = "1.7.0" [[deps.RandomNumbers]] -deps = ["Random", "Requires"] -git-tree-sha1 = "043da614cc7e95c703498a491e2c21f58a2b8111" +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" -version = "1.5.3" +version = "1.6.0" [[deps.RangeArrays]] git-tree-sha1 = "b9039e93773ddcfc828f12aadf7115b4b4d225f5" @@ -1777,22 +1967,30 @@ uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c" version = "0.6.12" [[deps.RecursiveArrayTools]] -deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "IteratorInterfaceExtensions", "LinearAlgebra", "RecipesBase", "SparseArrays", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables"] -git-tree-sha1 = "4873672a6d7990c683b4badf8671c50043ad321b" +deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "IteratorInterfaceExtensions", "LinearAlgebra", "RecipesBase", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables"] +git-tree-sha1 = "fe9d37a17ab4d41a98951332ee8067f8dca8c4c2" uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" -version = "3.4.2" +version = "3.29.0" [deps.RecursiveArrayTools.extensions] RecursiveArrayToolsFastBroadcastExt = "FastBroadcast" + RecursiveArrayToolsForwardDiffExt = "ForwardDiff" RecursiveArrayToolsMeasurementsExt = "Measurements" RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements" + RecursiveArrayToolsReverseDiffExt = ["ReverseDiff", "Zygote"] + RecursiveArrayToolsSparseArraysExt = ["SparseArrays"] + RecursiveArrayToolsStructArraysExt = "StructArrays" RecursiveArrayToolsTrackerExt = "Tracker" RecursiveArrayToolsZygoteExt = "Zygote" [deps.RecursiveArrayTools.weakdeps] FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" @@ -1815,41 +2013,37 @@ version = "1.3.0" [[deps.ReverseDiff]] deps = ["ChainRulesCore", "DiffResults", "DiffRules", "ForwardDiff", "FunctionWrappers", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NaNMath", "Random", "SpecialFunctions", "StaticArrays", "Statistics"] -git-tree-sha1 = "d1235bdd57a93bd7504225b792b867e9a7df38d5" +git-tree-sha1 = "cc6cd622481ea366bb9067859446a8b01d92b468" uuid = "37e2e3b7-166d-5795-8a7a-e32c996b4267" -version = "1.15.1" - -[[deps.RingLists]] -deps = ["Random"] -git-tree-sha1 = "f39da63aa6d2d88e0c1bd20ed6a3ff9ea7171ada" -uuid = "286e9d63-9694-5540-9e3c-4e6708fa07b2" -version = "0.2.8" +version = "1.15.3" [[deps.Rmath]] deps = ["Random", "Rmath_jll"] -git-tree-sha1 = "f65dcb5fa46aee0cf9ed6274ccbd597adc49aa7b" +git-tree-sha1 = "852bd0f55565a9e973fcfee83a84413270224dc4" uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa" -version = "0.7.1" +version = "0.8.0" [[deps.Rmath_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "6ed52fdd3382cf21947b15e8870ac0ddbff736da" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "58cdd8fb2201a6267e1db87ff148dd6c1dbd8ad8" uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" -version = "0.4.0+0" +version = "0.5.1+0" [[deps.Roots]] -deps = ["Accessors", "ChainRulesCore", "CommonSolve", "Printf"] -git-tree-sha1 = "af540898b1e6ca7aa6ba7213c05052809c6c522a" +deps = ["Accessors", "CommonSolve", "Printf"] +git-tree-sha1 = "e52cf0872526c7a0b3e1af9c58a69b90e19b022e" uuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665" -version = "2.1.0" +version = "2.2.5" [deps.Roots.extensions] + RootsChainRulesCoreExt = "ChainRulesCore" RootsForwardDiffExt = "ForwardDiff" RootsIntervalRootFindingExt = "IntervalRootFinding" RootsSymPyExt = "SymPy" RootsSymPyPythonCallExt = "SymPyPythonCall" [deps.Roots.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" IntervalRootFinding = "d2bf35a9-74e0-55ec-b149-d360ff49b807" SymPy = "24249f21-da20-56a4-8eb1-6a02cf4ae2e6" @@ -1862,22 +2056,35 @@ version = "0.2.1" [[deps.RuntimeGeneratedFunctions]] deps = ["ExprTools", "SHA", "Serialization"] -git-tree-sha1 = "6aacc5eefe8415f47b3e34214c1d79d2674a0ba2" +git-tree-sha1 = "04c968137612c4a5629fa531334bb81ad5680f00" uuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" -version = "0.5.12" +version = "0.5.13" [[deps.SHA]] uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" version = "0.7.0" +[[deps.SIMD]] +deps = ["PrecompileTools"] +git-tree-sha1 = "fea870727142270bdf7624ad675901a1ee3b4c87" +uuid = "fdea26ae-647d-5447-a871-4b548cad5224" +version = "3.7.1" + +[[deps.SSMProblems]] +deps = ["AbstractMCMC"] +git-tree-sha1 = "f640e4e8343c9d5f470e2f6ca6ce79f708ab6376" +uuid = "26aad666-b158-4e64-9d35-0e672562fa48" +version = "0.1.1" + [[deps.SciMLBase]] -deps = ["ADTypes", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FillArrays", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables", "TruncatedStacktraces"] -git-tree-sha1 = "bda8bddc47915ee94bb10a5fc901b112e337e898" +deps = ["ADTypes", "Accessors", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "Expronicon", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "SciMLStructures", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface"] +git-tree-sha1 = "ffed2507209da5b42c6881944ef41a340ab5449b" uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" -version = "2.17.0" +version = "2.74.1" [deps.SciMLBase.extensions] SciMLBaseChainRulesCoreExt = "ChainRulesCore" + SciMLBaseMakieExt = "Makie" SciMLBasePartialFunctionsExt = "PartialFunctions" SciMLBasePyCallExt = "PyCall" SciMLBasePythonCallExt = "PythonCall" @@ -1887,6 +2094,7 @@ version = "2.17.0" [deps.SciMLBase.weakdeps] ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" @@ -1894,10 +2102,21 @@ version = "2.17.0" Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" [[deps.SciMLOperators]] -deps = ["ArrayInterface", "DocStringExtensions", "Lazy", "LinearAlgebra", "Setfield", "SparseArrays", "StaticArraysCore", "Tricks"] -git-tree-sha1 = "51ae235ff058a64815e0a2c34b1db7578a06813d" +deps = ["Accessors", "ArrayInterface", "DocStringExtensions", "LinearAlgebra", "MacroTools"] +git-tree-sha1 = "6149620767866d4b0f0f7028639b6e661b6a1e44" uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" -version = "0.3.7" +version = "0.3.12" +weakdeps = ["SparseArrays", "StaticArraysCore"] + + [deps.SciMLOperators.extensions] + SciMLOperatorsSparseArraysExt = "SparseArrays" + SciMLOperatorsStaticArraysCoreExt = "StaticArraysCore" + +[[deps.SciMLStructures]] +deps = ["ArrayInterface"] +git-tree-sha1 = "0444a37a25fab98adbd90baa806ee492a3af133a" +uuid = "53ae85a6-f571-4167-b2af-e1d143709226" +version = "1.6.1" [[deps.ScientificTypesBase]] git-tree-sha1 = "a8e18eb383b5ecf1b5e6fc237eb39255044fd92b" @@ -1912,11 +2131,7 @@ version = "1.2.1" [[deps.Serialization]] uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" - -[[deps.SetRounding]] -git-tree-sha1 = "d7a25e439d07a17b7cdf97eecee504c50fedf5f6" -uuid = "3cc68bcd-71a2-5612-b932-767ffbe40ab0" -version = "0.2.1" +version = "1.11.0" [[deps.Setfield]] deps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"] @@ -1925,14 +2140,15 @@ uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" version = "1.1.1" [[deps.ShaderAbstractions]] -deps = ["ColorTypes", "FixedPointNumbers", "GeometryBasics", "LinearAlgebra", "Observables", "StaticArrays", "StructArrays", "Tables"] -git-tree-sha1 = "db0219befe4507878b1a90e07820fed3e62c289d" +deps = ["ColorTypes", "FixedPointNumbers", "GeometryBasics", "LinearAlgebra", "Observables", "StaticArrays"] +git-tree-sha1 = "818554664a2e01fc3784becb2eb3a82326a604b6" uuid = "65257c39-d410-5151-9873-9b3e5be5013e" -version = "0.4.0" +version = "0.5.0" [[deps.SharedArrays]] deps = ["Distributed", "Mmap", "Random", "Serialization"] uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" +version = "1.11.0" [[deps.Showoff]] deps = ["Dates", "Grisu"] @@ -1947,33 +2163,9 @@ uuid = "73760f76-fbc4-59ce-8f25-708e95d2df96" version = "0.4.0" [[deps.SimpleBufferStream]] -git-tree-sha1 = "874e8867b33a00e784c8a7e4b60afe9e037b74e1" +git-tree-sha1 = "f305871d2f381d21527c770d4788c06c097c9bc1" uuid = "777ac1f9-54b0-4bf8-805c-2214025038e7" -version = "1.1.0" - -[[deps.SimpleGraphs]] -deps = ["AbstractLattices", "Combinatorics", "DataStructures", "IterTools", "LightXML", "LinearAlgebra", "LinearAlgebraX", "Optim", "Primes", "Random", "RingLists", "SimplePartitions", "SimplePolynomials", "SimpleRandom", "SparseArrays", "Statistics"] -git-tree-sha1 = "f65caa24a622f985cc341de81d3f9744435d0d0f" -uuid = "55797a34-41de-5266-9ec1-32ac4eb504d3" -version = "0.8.6" - -[[deps.SimplePartitions]] -deps = ["AbstractLattices", "DataStructures", "Permutations"] -git-tree-sha1 = "e9330391d04241eafdc358713b48396619c83bcb" -uuid = "ec83eff0-a5b5-5643-ae32-5cbf6eedec9d" -version = "0.3.1" - -[[deps.SimplePolynomials]] -deps = ["Mods", "Multisets", "Polynomials", "Primes"] -git-tree-sha1 = "7063828369cafa93f3187b3d0159f05582011405" -uuid = "cc47b68c-3164-5771-a705-2bc0097375a0" -version = "0.2.17" - -[[deps.SimpleRandom]] -deps = ["Distributions", "LinearAlgebra", "Random"] -git-tree-sha1 = "3a6fb395e37afab81aeea85bae48a4db5cd7244a" -uuid = "a6525b86-64cd-54fa-8f65-62fc48bdc0e8" -version = "0.3.1" +version = "1.2.0" [[deps.SimpleTraits]] deps = ["InteractiveUtils", "MacroTools"] @@ -1994,6 +2186,7 @@ version = "0.1.3" [[deps.Sockets]] uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" [[deps.SortingAlgorithms]] deps = ["DataStructures"] @@ -2004,7 +2197,27 @@ version = "1.2.1" [[deps.SparseArrays]] deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" -version = "1.10.0" +version = "1.11.0" + +[[deps.SparseConnectivityTracer]] +deps = ["ADTypes", "DocStringExtensions", "FillArrays", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "6651f4663027f3b30a31429d257185f56a571184" +uuid = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" +version = "0.6.13" + + [deps.SparseConnectivityTracer.extensions] + SparseConnectivityTracerDataInterpolationsExt = "DataInterpolations" + SparseConnectivityTracerLogExpFunctionsExt = "LogExpFunctions" + SparseConnectivityTracerNNlibExt = "NNlib" + SparseConnectivityTracerNaNMathExt = "NaNMath" + SparseConnectivityTracerSpecialFunctionsExt = "SpecialFunctions" + + [deps.SparseConnectivityTracer.weakdeps] + DataInterpolations = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" + LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688" + NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" + NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" [[deps.SparseInverseSubset]] deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] @@ -2012,11 +2225,21 @@ git-tree-sha1 = "52962839426b75b3021296f7df242e40ecfc0852" uuid = "dc90abb0-5640-4711-901d-7e5b23a2fada" version = "0.1.2" +[[deps.SparseMatrixColorings]] +deps = ["ADTypes", "DataStructures", "DocStringExtensions", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "97092c0a40d6033b7da27ea15bcf75fd5b446254" +uuid = "0a514795-09f3-496d-8182-132a7b665d35" +version = "0.4.13" +weakdeps = ["Colors"] + + [deps.SparseMatrixColorings.extensions] + SparseMatrixColoringsColorsExt = "Colors" + [[deps.SpecialFunctions]] deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] -git-tree-sha1 = "e2cfc4012a19088254b3950b85c3c1d8882d864d" +git-tree-sha1 = "64cca0c26b4f31ba18f13f6c12af7c85f478cfde" uuid = "276daf66-3868-5448-9aa4-cd146d93841b" -version = "2.3.1" +version = "2.5.0" weakdeps = ["ChainRulesCore"] [deps.SpecialFunctions.extensions] @@ -2028,17 +2251,11 @@ git-tree-sha1 = "e08a62abc517eb79667d0a29dc08a3b589516bb5" uuid = "171d559e-b47b-412a-8079-5efa626c420e" version = "0.1.15" -[[deps.StableHashTraits]] -deps = ["Compat", "SHA", "Tables", "TupleTools"] -git-tree-sha1 = "5a26dfe46e2cb5f5eca78114c7d49548b9597e71" -uuid = "c5dd0088-6c3f-4803-b00e-f31a60c170fa" -version = "1.1.3" - [[deps.StableRNGs]] -deps = ["Random", "Test"] -git-tree-sha1 = "ddc1a7b85e760b5285b50b882fa91e40c603be47" +deps = ["Random"] +git-tree-sha1 = "83e6cce8324d49dfaf9ef059227f91ed4441a8e5" uuid = "860ef19b-820b-49d6-a774-d7a799459cd3" -version = "1.0.1" +version = "1.0.2" [[deps.StackViews]] deps = ["OffsetArrays"] @@ -2048,9 +2265,9 @@ version = "0.1.1" [[deps.StaticArrays]] deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] -git-tree-sha1 = "4e17a790909b17f7bf1496e3aec138cf01b60b3b" +git-tree-sha1 = "e3be13f448a43610f978d29b7adf78c76022467a" uuid = "90137ffa-7385-5640-81b9-e52037218182" -version = "1.9.0" +version = "1.9.12" weakdeps = ["ChainRulesCore", "Statistics"] [deps.StaticArrays.extensions] @@ -2058,20 +2275,25 @@ weakdeps = ["ChainRulesCore", "Statistics"] StaticArraysStatisticsExt = "Statistics" [[deps.StaticArraysCore]] -git-tree-sha1 = "36b3d696ce6366023a0ea192b4cd442268995a0d" +git-tree-sha1 = "192954ef1208c7019899fbf8049e717f92959682" uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" -version = "1.4.2" +version = "1.4.3" [[deps.StatisticalTraits]] deps = ["ScientificTypesBase"] -git-tree-sha1 = "30b9236691858e13f167ce829490a68e1a597782" +git-tree-sha1 = "542d979f6e756f13f862aa00b224f04f9e445f11" uuid = "64bff920-2084-43da-a3e6-9bb72801c0c9" -version = "3.2.0" +version = "3.4.0" [[deps.Statistics]] -deps = ["LinearAlgebra", "SparseArrays"] +deps = ["LinearAlgebra"] +git-tree-sha1 = "ae3bb1eb3bba077cd276bc5cfc337cc65c3075c0" uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" -version = "1.10.0" +version = "1.11.1" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] [[deps.StatsAPI]] deps = ["LinearAlgebra"] @@ -2080,16 +2302,16 @@ uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" version = "1.7.0" [[deps.StatsBase]] -deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] -git-tree-sha1 = "1d77abd07f617c4868c33d4f5b9e1dbb2643c9cf" +deps = ["AliasTables", "DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "29321314c920c26684834965ec2ce0dacc9cf8e5" uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" -version = "0.34.2" +version = "0.34.4" [[deps.StatsFuns]] deps = ["HypergeometricFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"] -git-tree-sha1 = "f625d686d5a88bcd2b15cd81f18f98186fdc0c9a" +git-tree-sha1 = "b423576adc27097764a90e163157bcfc9acf0f46" uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c" -version = "1.3.0" +version = "1.3.2" weakdeps = ["ChainRulesCore", "InverseFunctions"] [deps.StatsFuns.extensions] @@ -2098,15 +2320,27 @@ weakdeps = ["ChainRulesCore", "InverseFunctions"] [[deps.StringManipulation]] deps = ["PrecompileTools"] -git-tree-sha1 = "a04cabe79c5f01f4d723cc6704070ada0b9d46d5" +git-tree-sha1 = "725421ae8e530ec29bcbdddbe91ff8053421d023" uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" -version = "0.3.4" +version = "0.4.1" [[deps.StructArrays]] -deps = ["Adapt", "ConstructionBase", "DataAPI", "GPUArraysCore", "StaticArraysCore", "Tables"] -git-tree-sha1 = "0a3db38e4cce3c54fe7a71f831cd7b6194a54213" +deps = ["ConstructionBase", "DataAPI", "Tables"] +git-tree-sha1 = "9537ef82c42cdd8c5d443cbc359110cbb36bae10" uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" -version = "0.6.16" +version = "0.6.21" +weakdeps = ["Adapt", "GPUArraysCore", "KernelAbstractions", "LinearAlgebra", "SparseArrays", "StaticArrays"] + + [deps.StructArrays.extensions] + StructArraysAdaptExt = "Adapt" + StructArraysGPUArraysCoreExt = ["GPUArraysCore", "KernelAbstractions"] + StructArraysLinearAlgebraExt = "LinearAlgebra" + StructArraysSparseArraysExt = "SparseArrays" + StructArraysStaticArraysExt = "StaticArrays" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" [[deps.SuiteSparse]] deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] @@ -2115,12 +2349,13 @@ uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9" [[deps.SuiteSparse_jll]] deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" -version = "7.2.1+1" +version = "7.7.0+0" [[deps.SymbolicIndexingInterface]] -git-tree-sha1 = "74502f408d99fc217a9d7cd901d9ffe45af892b1" +deps = ["Accessors", "ArrayInterface", "RuntimeGeneratedFunctions", "StaticArraysCore"] +git-tree-sha1 = "fd2d4f0499f6bb4a0d9f5030f5c7d61eed385e03" uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5" -version = "0.3.3" +version = "0.3.37" [[deps.TOML]] deps = ["Dates"] @@ -2134,10 +2369,10 @@ uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" version = "1.0.1" [[deps.Tables]] -deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "TableTraits"] -git-tree-sha1 = "cb76cf677714c095e535e3501ac7954732aeea2d" +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "598cd7c1f68d1e205689b1c2fe65a9f85846f297" uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" -version = "1.11.1" +version = "1.12.0" [[deps.Tar]] deps = ["ArgTools", "SHA"] @@ -2159,39 +2394,37 @@ version = "0.1.7" [[deps.Test]] deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +version = "1.11.0" [[deps.TiffImages]] -deps = ["ColorTypes", "DataStructures", "DocStringExtensions", "FileIO", "FixedPointNumbers", "IndirectArrays", "Inflate", "Mmap", "OffsetArrays", "PkgVersion", "ProgressMeter", "UUIDs"] -git-tree-sha1 = "34cc045dd0aaa59b8bbe86c644679bc57f1d5bd0" +deps = ["ColorTypes", "DataStructures", "DocStringExtensions", "FileIO", "FixedPointNumbers", "IndirectArrays", "Inflate", "Mmap", "OffsetArrays", "PkgVersion", "ProgressMeter", "SIMD", "UUIDs"] +git-tree-sha1 = "f21231b166166bebc73b99cea236071eb047525b" uuid = "731e570b-9d59-4bfa-96dc-6df516fadf69" -version = "0.6.8" +version = "0.11.3" [[deps.Tracker]] -deps = ["Adapt", "DiffRules", "ForwardDiff", "Functors", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NNlib", "NaNMath", "Optimisers", "Printf", "Random", "Requires", "SpecialFunctions", "Statistics"] -git-tree-sha1 = "bc54b1c65e87edfccf3f59d9ae7abb79f60d86f3" +deps = ["Adapt", "ChainRulesCore", "DiffRules", "ForwardDiff", "Functors", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NNlib", "NaNMath", "Optimisers", "Printf", "Random", "Requires", "SpecialFunctions", "Statistics"] +git-tree-sha1 = "c266e49953dadd0923caa17b3ea464ab6b97b3f2" uuid = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" -version = "0.2.30" +version = "0.2.37" weakdeps = ["PDMats"] [deps.Tracker.extensions] TrackerPDMatsExt = "PDMats" [[deps.TranscodingStreams]] -git-tree-sha1 = "1fbeaaca45801b4ba17c251dd8603ef24801dd84" +git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" -version = "0.10.2" -weakdeps = ["Random", "Test"] - - [deps.TranscodingStreams.extensions] - TestExt = ["Test", "Random"] +version = "0.11.3" [[deps.Transducers]] -deps = ["Adapt", "ArgCheck", "BangBang", "Baselet", "CompositionsBase", "ConstructionBase", "DefineSingletons", "Distributed", "InitialValues", "Logging", "Markdown", "MicroCollections", "Requires", "Setfield", "SplittablesBase", "Tables"] -git-tree-sha1 = "e579d3c991938fecbb225699e8f611fa3fbf2141" +deps = ["Accessors", "ArgCheck", "BangBang", "Baselet", "CompositionsBase", "ConstructionBase", "DefineSingletons", "Distributed", "InitialValues", "Logging", "Markdown", "MicroCollections", "Requires", "SplittablesBase", "Tables"] +git-tree-sha1 = "7deeab4ff96b85c5f72c824cae53a1398da3d1cb" uuid = "28d57a85-8fef-5791-bfe6-a80928e7c999" -version = "0.4.79" +version = "0.4.84" [deps.Transducers.extensions] + TransducersAdaptExt = "Adapt" TransducersBlockArraysExt = "BlockArrays" TransducersDataFramesExt = "DataFrames" TransducersLazyArraysExt = "LazyArrays" @@ -2199,38 +2432,23 @@ version = "0.4.79" TransducersReferenceablesExt = "Referenceables" [deps.Transducers.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02" OnlineStatsBase = "925886fa-5bf2-5e8e-b522-a9147a512338" Referenceables = "42d2dcc6-99eb-4e98-b66c-637b7d73030e" -[[deps.Tricks]] -git-tree-sha1 = "eae1bb484cd63b36999ee58be2de6c178105112f" -uuid = "410a4b4d-49e4-4fbc-ab6d-cb71b17b3775" -version = "0.1.8" - [[deps.TriplotBase]] git-tree-sha1 = "4d4ed7f294cda19382ff7de4c137d24d16adc89b" uuid = "981d1d27-644d-49a2-9326-4793e63143c3" version = "0.1.0" -[[deps.TruncatedStacktraces]] -deps = ["InteractiveUtils", "MacroTools", "Preferences"] -git-tree-sha1 = "ea3e54c2bdde39062abf5a9758a23735558705e1" -uuid = "781d530d-4396-4725-bb49-402e4bee1e77" -version = "1.4.0" - -[[deps.TupleTools]] -git-tree-sha1 = "155515ed4c4236db30049ac1495e2969cc06be9d" -uuid = "9d95972d-f1c8-5527-a6e0-b4b365fa01f6" -version = "1.4.3" - [[deps.Turing]] -deps = ["ADTypes", "AbstractMCMC", "AdvancedHMC", "AdvancedMH", "AdvancedPS", "AdvancedVI", "BangBang", "Bijectors", "DataStructures", "Distributions", "DistributionsAD", "DocStringExtensions", "DynamicPPL", "EllipticalSliceSampling", "ForwardDiff", "Libtask", "LinearAlgebra", "LogDensityProblems", "LogDensityProblemsAD", "MCMCChains", "NamedArrays", "Printf", "Random", "Reexport", "Requires", "SciMLBase", "Setfield", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] -git-tree-sha1 = "e0aa30e8db582b302e6bf448ab417f43b5188418" +deps = ["ADTypes", "AbstractMCMC", "Accessors", "AdvancedHMC", "AdvancedMH", "AdvancedPS", "AdvancedVI", "BangBang", "Bijectors", "Compat", "DataStructures", "Distributions", "DistributionsAD", "DocStringExtensions", "DynamicPPL", "EllipticalSliceSampling", "ForwardDiff", "Libtask", "LinearAlgebra", "LogDensityProblems", "LogDensityProblemsAD", "MCMCChains", "NamedArrays", "Optimization", "OptimizationOptimJL", "OrderedCollections", "Printf", "Random", "Reexport", "SciMLBase", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "5218eb833eaaffa0021de7a550564ff6bd53b96c" uuid = "fce5fe82-541a-59a6-adf8-730c64b5f9a0" -version = "0.30.1" +version = "0.36.2" [deps.Turing.extensions] TuringDynamicHMCExt = "DynamicHMC" @@ -2248,6 +2466,7 @@ version = "1.5.1" [[deps.UUIDs]] deps = ["Random", "SHA"] uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" [[deps.UnPack]] git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" @@ -2256,6 +2475,7 @@ version = "1.0.2" [[deps.Unicode]] uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" [[deps.UnicodeFun]] deps = ["REPL"] @@ -2265,9 +2485,9 @@ version = "0.4.1" [[deps.Unitful]] deps = ["Dates", "LinearAlgebra", "Random"] -git-tree-sha1 = "3c793be6df9dd77a0cf49d80984ef9ff996948fa" +git-tree-sha1 = "c0667a8e676c53d390a09dc6870b3d8d6650e2bf" uuid = "1986cc42-f94f-5a68-af5c-568840ba703d" -version = "1.19.0" +version = "1.22.0" weakdeps = ["ConstructionBase", "InverseFunctions"] [deps.Unitful.extensions] @@ -2276,20 +2496,20 @@ weakdeps = ["ConstructionBase", "InverseFunctions"] [[deps.UnitfulLatexify]] deps = ["LaTeXStrings", "Latexify", "Unitful"] -git-tree-sha1 = "e2d817cc500e960fdbafcf988ac8436ba3208bfd" +git-tree-sha1 = "975c354fcd5f7e1ddcc1f1a23e6e091d99e99bc8" uuid = "45397f5d-5981-4c77-b2b3-fc36d6e9b728" -version = "1.6.3" +version = "1.6.4" [[deps.UnsafeAtomics]] -git-tree-sha1 = "6331ac3440856ea1988316b46045303bef658278" +git-tree-sha1 = "b13c4edda90890e5b04ba24e20a310fbe6f249ff" uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" -version = "0.2.1" +version = "0.3.0" -[[deps.UnsafeAtomicsLLVM]] -deps = ["LLVM", "UnsafeAtomics"] -git-tree-sha1 = "323e3d0acf5e78a56dfae7bd8928c989b4f3083e" -uuid = "d80eeb9a-aca5-4d75-85e5-170c8b632249" -version = "0.1.3" + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsLLVM = ["LLVM"] + + [deps.UnsafeAtomics.weakdeps] + LLVM = "929cbde3-209d-540e-8aea-75f648917ca0" [[deps.Unzip]] git-tree-sha1 = "ca0969166a028236229f63514992fc073799bb78" @@ -2304,15 +2524,21 @@ version = "1.3.243+0" [[deps.Wayland_jll]] deps = ["Artifacts", "EpollShim_jll", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg", "XML2_jll"] -git-tree-sha1 = "7558e29847e99bc3f04d6569e82d0f5c54460703" +git-tree-sha1 = "85c7811eddec9e7f22615371c3cc81a504c508ee" uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89" -version = "1.21.0+1" +version = "1.21.0+2" [[deps.Wayland_protocols_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "93f43ab61b16ddfb2fd3bb13b3ce241cafb0e6c9" +git-tree-sha1 = "5db3e9d307d32baba7067b13fc7b5aa6edd4a19a" uuid = "2381bf8a-dfd0-557d-9999-79630e7b1b91" -version = "1.31.0+0" +version = "1.36.0+0" + +[[deps.WebP]] +deps = ["CEnum", "ColorTypes", "FileIO", "FixedPointNumbers", "ImageCore", "libwebp_jll"] +git-tree-sha1 = "aa1ca3c47f119fbdae8770c29820e5e6119b83f2" +uuid = "e3aaa7dc-3e4b-44e0-be63-ffb868ccd7c1" +version = "0.1.3" [[deps.WoodburyMatrices]] deps = ["LinearAlgebra", "SparseArrays"] @@ -2322,111 +2548,111 @@ version = "1.0.0" [[deps.XML2_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] -git-tree-sha1 = "801cbe47eae69adc50f36c3caec4758d2650741b" +git-tree-sha1 = "ee6f41aac16f6c9a8cab34e2f7a200418b1cc1e3" uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" -version = "2.12.2+0" +version = "2.13.6+0" [[deps.XSLT_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"] -git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "XML2_jll", "Zlib_jll"] +git-tree-sha1 = "7d1671acbe47ac88e981868a078bd6b4e27c5191" uuid = "aed1982a-8fda-507f-9586-7b0439959a61" -version = "1.1.34+0" +version = "1.1.42+0" [[deps.XZ_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "522b8414d40c4cbbab8dee346ac3a09f9768f25d" +git-tree-sha1 = "56c6604ec8b2d82cc4cfe01aa03b00426aac7e1f" uuid = "ffd25f8a-64ca-5728-b0f7-c24cf3aae800" -version = "5.4.5+0" +version = "5.6.4+1" [[deps.Xorg_libICE_jll]] -deps = ["Libdl", "Pkg"] -git-tree-sha1 = "e5becd4411063bdcac16be8b66fc2f9f6f1e8fe5" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "326b4fea307b0b39892b3e85fa451692eda8d46c" uuid = "f67eecfb-183a-506d-b269-f58e52b52d7c" -version = "1.0.10+1" +version = "1.1.1+0" [[deps.Xorg_libSM_jll]] -deps = ["Libdl", "Pkg", "Xorg_libICE_jll"] -git-tree-sha1 = "4a9d9e4c180e1e8119b5ffc224a7b59d3a7f7e18" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libICE_jll"] +git-tree-sha1 = "3796722887072218eabafb494a13c963209754ce" uuid = "c834827a-8449-5923-a945-d239c165b7dd" -version = "1.2.3+0" +version = "1.2.4+0" [[deps.Xorg_libX11_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] -git-tree-sha1 = "afead5aba5aa507ad5a3bf01f58f82c8d1403495" +git-tree-sha1 = "9dafcee1d24c4f024e7edc92603cedba72118283" uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc" -version = "1.8.6+0" +version = "1.8.6+3" [[deps.Xorg_libXau_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "6035850dcc70518ca32f012e46015b9beeda49d8" +git-tree-sha1 = "e9216fdcd8514b7072b43653874fd688e4c6c003" uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec" -version = "1.0.11+0" +version = "1.0.12+0" [[deps.Xorg_libXcursor_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"] -git-tree-sha1 = "12e0eb3bc634fa2080c1c37fccf56f7c22989afd" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "807c226eaf3651e7b2c468f687ac788291f9a89b" uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724" -version = "1.2.0+4" +version = "1.2.3+0" [[deps.Xorg_libXdmcp_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "34d526d318358a859d7de23da945578e8e8727b7" +git-tree-sha1 = "89799ae67c17caa5b3b5a19b8469eeee474377db" uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05" -version = "1.1.4+0" +version = "1.1.5+0" [[deps.Xorg_libXext_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"] -git-tree-sha1 = "b7c0aa8c376b31e4852b360222848637f481f8c3" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "d7155fea91a4123ef59f42c4afb5ab3b4ca95058" uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3" -version = "1.3.4+4" +version = "1.3.6+3" [[deps.Xorg_libXfixes_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"] -git-tree-sha1 = "0e0dc7431e7a0587559f9294aeec269471c991a4" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "6fcc21d5aea1a0b7cce6cab3e62246abd1949b86" uuid = "d091e8ba-531a-589c-9de9-94069b037ed8" -version = "5.0.3+4" +version = "6.0.0+0" [[deps.Xorg_libXi_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXfixes_jll"] -git-tree-sha1 = "89b52bc2160aadc84d707093930ef0bffa641246" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll", "Xorg_libXfixes_jll"] +git-tree-sha1 = "984b313b049c89739075b8e2a94407076de17449" uuid = "a51aa0fd-4e3c-5386-b890-e753decda492" -version = "1.7.10+4" +version = "1.8.2+0" [[deps.Xorg_libXinerama_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll"] -git-tree-sha1 = "26be8b1c342929259317d8b9f7b53bf2bb73b123" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll"] +git-tree-sha1 = "a1a7eaf6c3b5b05cb903e35e8372049b107ac729" uuid = "d1454406-59df-5ea1-beac-c340f2130bc3" -version = "1.1.4+4" +version = "1.1.5+0" [[deps.Xorg_libXrandr_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll"] -git-tree-sha1 = "34cea83cb726fb58f325887bf0612c6b3fb17631" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "b6f664b7b2f6a39689d822a6300b14df4668f0f4" uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484" -version = "1.5.2+4" +version = "1.5.4+0" [[deps.Xorg_libXrender_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"] -git-tree-sha1 = "19560f30fd49f4d4efbe7002a1037f8c43d43b96" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "a490c6212a0e90d2d55111ac956f7c4fa9c277a6" uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa" -version = "0.9.10+4" +version = "0.9.11+1" [[deps.Xorg_libpthread_stubs_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "8fdda4c692503d44d04a0603d9ac0982054635f9" +git-tree-sha1 = "c57201109a9e4c0585b208bb408bc41d205ac4e9" uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74" -version = "0.1.1+0" +version = "0.1.2+0" [[deps.Xorg_libxcb_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"] -git-tree-sha1 = "b4bfde5d5b652e22b9c790ad00af08b6d042b97d" +git-tree-sha1 = "1a74296303b6524a0472a8cb12d3d87a78eb3612" uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b" -version = "1.15.0+0" +version = "1.17.0+3" [[deps.Xorg_libxkbfile_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] -git-tree-sha1 = "730eeca102434283c50ccf7d1ecdadf521a765a4" +git-tree-sha1 = "dbc53e4cf7701c6c7047c51e17d6e64df55dca94" uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a" -version = "1.1.2+0" +version = "1.1.2+1" [[deps.Xorg_xcb_util_cursor_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_jll", "Xorg_xcb_util_renderutil_jll"] @@ -2466,9 +2692,9 @@ version = "0.4.1+1" [[deps.Xorg_xkbcomp_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxkbfile_jll"] -git-tree-sha1 = "330f955bc41bb8f5270a369c473fc4a5a4e4d3cb" +git-tree-sha1 = "ab2221d309eda71020cdda67a973aa582aa85d69" uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4" -version = "1.4.6+0" +version = "1.4.6+1" [[deps.Xorg_xkeyboard_config_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xkbcomp_jll"] @@ -2478,9 +2704,9 @@ version = "2.39.0+0" [[deps.Xorg_xtrans_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "e92a1a012a10506618f10b7047e478403a046c77" +git-tree-sha1 = "6dba04dbfb72ae3ebe5418ba33d087ba8aa8cb00" uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10" -version = "1.5.0+0" +version = "1.5.1+0" [[deps.Zlib_jll]] deps = ["Libdl"] @@ -2489,15 +2715,15 @@ version = "1.2.13+1" [[deps.Zstd_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "49ce682769cd5de6c72dcf1b94ed7790cd08974c" +git-tree-sha1 = "622cf78670d067c738667aaa96c553430b65e269" uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" -version = "1.5.5+0" +version = "1.5.7+0" [[deps.ZygoteRules]] deps = ["ChainRulesCore", "MacroTools"] -git-tree-sha1 = "9d749cd449fb448aeca4feee9a2f4186dbb5d184" +git-tree-sha1 = "434b3de333c75fc446aa0d19fc394edafd07ab08" uuid = "700de1a5-db45-46bc-99cf-38207098b444" -version = "0.2.4" +version = "0.2.7" [[deps.eudev_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "gperf_jll"] @@ -2507,15 +2733,15 @@ version = "3.2.9+0" [[deps.fzf_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "a68c9655fbe6dfcab3d972808f1aafec151ce3f8" +git-tree-sha1 = "6e50f145003024df4f5cb96c7fce79466741d601" uuid = "214eeab7-80f7-51ab-84ad-2988db7cef09" -version = "0.43.0+0" +version = "0.56.3+0" [[deps.gperf_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "3516a5630f741c9eecb3720b1ec9d8edc3ecc033" +git-tree-sha1 = "0ba42241cb6809f1a278d0bcb976e0483c3f1f2d" uuid = "1a1c6b14-54f6-533d-8383-74cd7377aa70" -version = "3.1.1+0" +version = "3.1.1+1" [[deps.isoband_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -2524,21 +2750,27 @@ uuid = "9a68df92-36a6-505f-a73e-abb412b6bfb4" version = "0.2.3+0" [[deps.libaom_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "3a2ea60308f0996d26f1e5354e10c24e9ef905d4" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "522c1df09d05a71785765d19c9524661234738e9" uuid = "a4ae2306-e953-59d6-aa16-d00cac43593b" -version = "3.4.0+0" +version = "3.11.0+0" [[deps.libass_jll]] -deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"] -git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47" +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "e17c115d55c5fbb7e52ebedb427a0dca79d4484e" uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" -version = "0.15.1+0" +version = "0.15.2+0" [[deps.libblastrampoline_jll]] deps = ["Artifacts", "Libdl"] uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" -version = "5.8.0+1" +version = "5.11.0+0" + +[[deps.libdecor_jll]] +deps = ["Artifacts", "Dbus_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "Pango_jll", "Wayland_jll", "xkbcommon_jll"] +git-tree-sha1 = "9bf7903af251d2050b467f76bdbe57ce541f7f4f" +uuid = "1183f4f0-6f2a-5f1a-908b-139f9cdfea6f" +version = "0.2.2+0" [[deps.libevdev_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -2547,10 +2779,10 @@ uuid = "2db6ffa8-e38f-5e21-84af-90c45d0032cc" version = "1.11.0+0" [[deps.libfdk_aac_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8a22cf860a7d27e4f3498a0fe0811a7957badb38" uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" -version = "2.0.2+0" +version = "2.0.3+0" [[deps.libinput_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "eudev_jll", "libevdev_jll", "mtdev_jll"] @@ -2560,21 +2792,27 @@ version = "1.18.0+0" [[deps.libpng_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] -git-tree-sha1 = "93284c28274d9e75218a416c65ec49d0e0fcdf3d" +git-tree-sha1 = "055a96774f383318750a1a5e10fd4151f04c29c5" uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" -version = "1.6.40+0" +version = "1.6.46+0" [[deps.libsixel_jll]] -deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Pkg", "libpng_jll"] -git-tree-sha1 = "d4f63314c8aa1e48cd22aa0c17ed76cd1ae48c3c" +deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "Libdl", "libpng_jll"] +git-tree-sha1 = "c1733e347283df07689d71d61e14be986e49e47a" uuid = "075b6546-f08a-558a-be8f-8157d0f608a5" -version = "1.10.3+0" +version = "1.10.5+0" [[deps.libvorbis_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll", "Pkg"] -git-tree-sha1 = "b910cb81ef3fe6e78bf6acee440bda86fd6ae00c" +git-tree-sha1 = "490376214c4721cdaca654041f635213c6165cb3" uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a" -version = "1.3.7+1" +version = "1.3.7+2" + +[[deps.libwebp_jll]] +deps = ["Artifacts", "Giflib_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libglvnd_jll", "Libtiff_jll", "libpng_jll"] +git-tree-sha1 = "d2408cac540942921e7bd77272c32e58c33d8a77" +uuid = "c5f90fcd-3b7e-5836-afba-fc50a0988cb2" +version = "1.5.0+0" [[deps.mtdev_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -2585,7 +2823,13 @@ version = "1.1.6+0" [[deps.nghttp2_jll]] deps = ["Artifacts", "Libdl"] uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" -version = "1.52.0+1" +version = "1.59.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d5a767a3bb77135a99e433afe0eb14cd7f6914c3" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2022.0.0+0" [[deps.p7zip_jll]] deps = ["Artifacts", "Libdl"] @@ -2606,6 +2850,6 @@ 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 = "9c304562909ab2bab0262639bd4f444d7bc2be37" +git-tree-sha1 = "63406453ed9b33a0df95d570816d5366c92b7809" uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd" -version = "1.4.1+1" +version = "1.4.1+2" diff --git a/benchmarks/plots/inference_rxinfer.png b/benchmarks/plots/inference_rxinfer.png index 2af1a5bfd248d44e6b9f4640b3106c3e5f27b1c1..a6bd2d0262f637c5979743ab49971097baa8af5b 100644 GIT binary patch delta 98813 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ⅈ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 delta 98966 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

@(JB7yn+t+1a(D#dPDLsC7IDCxT(H( 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 AbN~PV diff --git a/benchmarks/plots/inference_rxinfer.svg b/benchmarks/plots/inference_rxinfer.svg index 656b0837f..cfc92d40a 100644 --- a/benchmarks/plots/inference_rxinfer.svg +++ b/benchmarks/plots/inference_rxinfer.svg @@ -1,481 +1,481 @@ - + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/benchmarks/plots/inference_turing.png b/benchmarks/plots/inference_turing.png index 590d3fbb5ce49698736848bd21b81eedb23c4d3a..fd2d1a41f1b3121ba22adc6b16460c5305232a92 100644 GIT binary patch literal 111925 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 BosIwi literal 111934 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
vYitd9XI}xI5 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 w-$zcfdBiWr7vvDD4 - + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/benchmarks/plots/lgssm_comparison.png b/benchmarks/plots/lgssm_comparison.png index d133c16559e554b8dc46d3dcf037c36d4762a381..65e710af306eb8a859a42af72854dc37ae223788 100644 GIT binary patch literal 71302 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 z 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 literal 60587 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 HGk^R8?Ok9@ diff --git a/benchmarks/plots/lgssm_comparison.svg b/benchmarks/plots/lgssm_comparison.svg index 63cdf680c..8e15d93b3 100644 --- a/benchmarks/plots/lgssm_comparison.svg +++ b/benchmarks/plots/lgssm_comparison.svg @@ -1,1507 +1,1363 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - - + + + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - - - - - + + + + + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - - - - - - - - - - - - + + + + + + + + + + + + + + + + diff --git a/benchmarks/plots/lgssm_scaling.png b/benchmarks/plots/lgssm_scaling.png index e4b1008d9662b4387965eae069327cbad7c292b3..00ab904524fdee004aa2eb531a4e1e174759b8ee 100644 GIT binary patch literal 81924 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

=jZ1Ymh(xD`(Nv8(1C*whm8BipbG_rp?mys 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 diff --git a/benchmarks/plots/lgssm_scaling.svg b/benchmarks/plots/lgssm_scaling.svg index f44d8dd2b..4919afdec 100644 --- a/benchmarks/plots/lgssm_scaling.svg +++ b/benchmarks/plots/lgssm_scaling.svg @@ -1,1089 +1,1045 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 30191ff4d715d240413da1dd87347ea2d9a20120 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 12:53:52 +0100 Subject: [PATCH 50/56] actually test with 1.10 --- .github/workflows/CI.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 878a58089..8efda13c7 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -62,6 +62,8 @@ jobs: steps: - uses: actions/checkout@v4 - uses: julia-actions/setup-julia@v2 + with: + version: ${{ matrix.version }} - uses: julia-actions/cache@v2 - uses: julia-actions/julia-buildpkg@v1 - uses: julia-actions/julia-runtest@v1 @@ -92,8 +94,6 @@ jobs: repository: ReactiveBayes/RxInferExamples.jl path: RxInferExamples.jl - uses: julia-actions/setup-julia@v2 - with: - version: '1.11' - uses: julia-actions/cache@v1 - name: Build and test examples run: | From 038d0a5ea85d12e9a5798248d6c21698699b9b9b Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 13:58:53 +0100 Subject: [PATCH 51/56] fix test artifacts archivation --- .github/workflows/CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 8efda13c7..f63f6e122 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -78,7 +78,7 @@ jobs: - name: Archive test artifacts uses: actions/upload-artifact@v4 with: - name: test-output + name: test-output-${{ matrix.version }}-${{ matrix.os }}-${{ matrix.arch }} path: test/_output test-examples: name: Examples From c232afdeb002d48d048b88871d4701e47a34d577 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 15:29:03 +0100 Subject: [PATCH 52/56] fix CVI tests --- test/models/nonlinear/cvi_tests.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/models/nonlinear/cvi_tests.jl b/test/models/nonlinear/cvi_tests.jl index 8533602b5..a85238a29 100644 --- a/test/models/nonlinear/cvi_tests.jl +++ b/test/models/nonlinear/cvi_tests.jl @@ -60,7 +60,7 @@ end seed = 123 - rng = MersenneTwister(seed) + rng = StableRNG(seed) T = 50 sensor_location = 53 From f64a0061c0eea3fd68009fc755d114d6a265c3d9 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 15:44:52 +0100 Subject: [PATCH 53/56] Update README --- README.md | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/README.md b/README.md index 5bf11c934..d9d34cc0f 100644 --- a/README.md +++ b/README.md @@ -230,6 +230,32 @@ Also check out the recorded presentation at the Julia User Group Munich meetup f

+# Telemetry + +RxInfer collects completely anonymous telemetry data regarding package usage. This information helps us understand how RxInfer is used and shapes our roadmap to prioritize features and improvements. The telemetry: +- Does not collect any code, data, or environment information, only the fact of `using RxInfer` once per Julia session +- Entirely anonymous +- (Opt-out) Can be disabled for a single Julia session or permanently + +You can learn more about it and how to opt-out by visiting our [documentation](https://reactivebayes.github.io/RxInfer.jl/stable/). + +## Session Sharing + +RxInfer includes an optional session sharing feature that can help us provide better support and improve the package. When you encounter an issue, you can share your session data with us, which includes: +- Model source code and metadata +- Input data characteristics (no actual data) +- Execution timing and success rates +- Error information (if any) +- Environment information (Julia version, OS, etc.) + +This information is invaluable for debugging issues and improving RxInfer. Session sharing is: +- Completely optional and disabled by default +- Entirely anonymous +- Only shared when you explicitly choose to do so +- (Opt-in) Can be enabled to send reports automatically when an error occurs. When enabled, still entirely anonymous. + +If you're opening a GitHub issue, we encourage you to share your session ID with us - it helps us understand your use case better and provide more accurate support. Learn more about session sharing and how to opt-in in our [documentation](https://reactivebayes.github.io/RxInfer.jl/stable/). + # License [MIT License](LICENSE) Copyright (c) 2021-2024 BIASlab, 2024-present ReactiveBayes From f97d78af25fe907630a47ccdb22c0bb91254ea9a Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 15:51:30 +0100 Subject: [PATCH 54/56] CVI test seed fix --- test/models/nonlinear/cvi_tests.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/models/nonlinear/cvi_tests.jl b/test/models/nonlinear/cvi_tests.jl index a85238a29..7faa2c3b1 100644 --- a/test/models/nonlinear/cvi_tests.jl +++ b/test/models/nonlinear/cvi_tests.jl @@ -59,7 +59,7 @@ ) end - seed = 123 + seed = 42 rng = StableRNG(seed) T = 50 From 0cb11ce902850f5366e95cbf13ef6ae72d9f6bd5 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 15:52:41 +0100 Subject: [PATCH 55/56] remove note about 3.0.0 --- README.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/README.md b/README.md index d9d34cc0f..45f994cf6 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ Turing comparison | Scalability performance > [!NOTE] > See many more examples in the [RxInferExamples.jl](https://reactivebayes.github.io/RxInferExamples.jl/) repository. + ### Faster inference with better results RxInfer.jl not only beats generic-purpose Bayesian inference methods in conjugate models, executes faster, and scales better, but also provides more accurate results. Check out the [documentation](https://reactivebayes.github.io/RxInfer.jl/stable/examples/overview/) for more examples! @@ -62,9 +63,6 @@ Optionally, use `] test RxInfer` to validate the installation by running the tes For more information about `RxInfer.jl` please refer to the [documentation](https://reactivebayes.github.io/RxInfer.jl/stable/). -> [!NOTE] -> `RxInfer.jl` API has been changed in version `3.0.0`. See [Migration Guide](https://reactivebayes.github.io/RxInfer.jl/stable/manuals/migration-guide-v2-v3) for more details. - # Getting Started > [!NOTE] From 225903fe752fa34047ce3d940d30faf090bf0c59 Mon Sep 17 00:00:00 2001 From: Bagaev Dmitry Date: Mon, 17 Feb 2025 15:53:36 +0100 Subject: [PATCH 56/56] remove note about old GraphPPL --- README.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/README.md b/README.md index 45f994cf6..943b934ed 100644 --- a/README.md +++ b/README.md @@ -144,9 +144,6 @@ end As you can see, `RxInfer` in combination with `GraphPPL` offers a model specification syntax that resembles closely to the mathematical equations defined above. -> [!NOTE] -> `GraphPPL.jl` API has been changed in version `4.0.0`. See [Migration Guide](https://reactivebayes.github.io/GraphPPL.jl/stable/) for more details. - ### Inference specification Once we have defined our model, the next step is to use `RxInfer` API to infer quantities of interests. To do this we can use a generic `infer` function from `RxInfer.jl` that supports static datasets.