From a61721e35254f58d5449db1d03d349467a2245af Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 14:11:03 -0500 Subject: [PATCH 01/22] Add script to update the fn signatures in the frontmatter of qmds in the components folder --- Makefile | 1 + scripts/post-quartodoc.py | 129 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 130 insertions(+) create mode 100644 scripts/post-quartodoc.py diff --git a/Makefile b/Makefile index ac8e37a4..be3154e9 100644 --- a/Makefile +++ b/Makefile @@ -77,6 +77,7 @@ quartodoc: cp -R py-shiny/docs/_inv py-shiny/docs/objects.json ./ # Copy over index.qmd, but rename it to _api_index.qmd cp py-shiny/docs/api/index.qmd ./api/_api_index.qmd + . $(PYBIN)/activate && python scripts/post-quartodoc.py ## Build website site: diff --git a/scripts/post-quartodoc.py b/scripts/post-quartodoc.py new file mode 100644 index 00000000..fa4635b1 --- /dev/null +++ b/scripts/post-quartodoc.py @@ -0,0 +1,129 @@ +# Details: For each .qmd in components folder, update the `relevantfunctions` object in the yaml front matter to contain the latest info from `func_info` filed in `./objects.json` +# Benefit: Updates the function signatures and links without doing it by hand. + +import json +import os +import typing +from pathlib import PurePath + +# Using `ruamel.yaml` over `yaml` as it preserves multiline strings +from ruamel.yaml import YAML + +yaml = YAML() +yaml.indent(mapping=2, sequence=4, offset=2) +# Do not wrap single line strings by setting a wide width +yaml.width = 10000 + +base_url = "https://shiny.posit.co/py/" + +with open("objects.json", "r") as file: + quartodoc_obj = json.load(file) +if "func_info" not in quartodoc_obj.keys(): + raise TypeError( + "./objects.json file does not contain top level key: `func_info`. Please call `make quartodoc` with an up-to-date version of py-shiny module" + ) +func_info = quartodoc_obj["func_info"] + + +for dir in os.listdir("components"): + dirpath = PurePath("components") / dir + # Only work on full folders + if dir.startswith("_") or not os.path.isdir(dirpath): + continue + for subfile in os.listdir(dirpath): + # Only work on quarto documents + if not subfile.endswith(".qmd"): + continue + + filepath = dirpath / subfile + print(f"Processing: {filepath}") + + with open(filepath, "r") as file: + lines = "".join(file.readlines()) + + sep = "---\n" + parts = lines.split(sep) + # print(parts[1]) + + frontmatter = yaml.load(parts[1]) + # print(frontmatter) + + if "listing" not in frontmatter.keys(): + print("No listing!") + continue + + if not isinstance(frontmatter["listing"], list): + print("frontmatter's `listing` is not an array. Upgrading!") + frontmatter["listing"] = [frontmatter["listing"]] + # print(frontmatter["listing"]) + + for listing, listing_i in zip( + frontmatter["listing"], + range(len(frontmatter["listing"])), + ): + if not isinstance(listing, dict): + print(listing) + raise TypeError( + "{filepath} : `listing[{listing_i}]` array item received is not a `dict`. Please fix." + ) + # print("### Listing:") + # print(listing) + contents_arr = listing["contents"] + has_variations = ( + isinstance(contents_arr, dict) and "variations" in contents_arr.keys() + ) + if has_variations: + # Content will not have any `relevantfunctions` fields. Skip to next info + continue + + for contents, contents_i in zip( + contents_arr, + range(len(contents_arr)), + ): + if not isinstance(contents, dict): + print(contents) + raise TypeError( + f"{filepath} : `listing[{listing_i}].contents[{contents_i}]` array item received is not a `dict`. Please fix." + ) + contents = typing.cast(dict[str, typing.Any], contents) + + # print("## Contents") + # print(contents) + if "relevantfunctions" not in contents.keys(): + continue + for relevantfunction, relevantfunction_i in zip( + contents["relevantfunctions"], + range(len(contents["relevantfunctions"])), + ): + if not isinstance(relevantfunction, dict): + raise TypeError( + f"{filepath} : `listing[{listing_i}].contents[{contents_i}].relevantfunctions[{relevantfunction_i}] array item received is not a `dict`. Please fix" + ) + fn_name = typing.cast(str, relevantfunction["title"]) + if fn_name.startswith("@"): + fn_name = fn_name.replace("@", "") + if fn_name.endswith("()"): + fn_name = fn_name.replace("()", "") + # print("## Name") + # print(fn_name) + if fn_name not in func_info.keys(): + print( + f"`{fn_name}` not found in quartodoc config. To update `objects.json` from the quartodoc config, please call `make quartodoc`" + ) + continue + + func_obj = func_info[fn_name] + + # # Make important function API updates + # relevantfunction["href"] = f"{base_url}{func_obj['uri']}" + # relevantfunction["signature"] = func_obj["signature"] + # relevantfunction["github"] = func_obj["github"] + # print(relevantfunction) + + # Overwrite file with updated content + with open(filepath, "w") as file: + file.write(parts[0]) + file.write(sep) + yaml.dump(frontmatter, file) + file.write(sep) + file.write(parts[2]) From d20f1e53d13b5c01c9fb6e0f67b1567f301cd905 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 14:11:15 -0500 Subject: [PATCH 02/22] Run script --- components/display-messages/modal.qmd | 24 +- components/display-messages/notifications.qmd | 4 +- components/display-messages/progress-bar.qmd | 92 +++---- components/display-messages/tooltips.qmd | 18 +- components/inputs/action-button.qmd | 4 +- components/inputs/action-link.qmd | 60 ++--- components/inputs/checkbox-group.qmd | 108 ++++---- components/inputs/checkbox.qmd | 52 ++-- components/inputs/date-range-selector.qmd | 58 ++--- components/inputs/date-selector.qmd | 56 ++--- components/inputs/numeric-input.qmd | 54 ++-- components/inputs/password-field.qmd | 54 ++-- components/inputs/radio-buttons.qmd | 60 ++--- components/inputs/select-multiple.qmd | 12 +- components/inputs/select-single.qmd | 20 +- components/inputs/selectize-multiple.qmd | 16 +- components/inputs/selectize-single.qmd | 16 +- components/inputs/slider-range.qmd | 70 +++--- components/inputs/slider.qmd | 52 ++-- components/inputs/switch.qmd | 52 ++-- components/inputs/text-area.qmd | 52 ++-- components/inputs/text-box.qmd | 52 ++-- components/outputs/data-grid.qmd | 58 ++--- components/outputs/datatable.qmd | 58 ++--- components/outputs/image.qmd | 69 ++--- components/outputs/map-ipyleaflet.qmd | 138 +++++----- components/outputs/plot-matplotlib.qmd | 22 +- components/outputs/plot-plotly.qmd | 30 +-- components/outputs/plot-seaborn.qmd | 30 +-- components/outputs/text.qmd | 38 +-- components/outputs/ui.qmd | 24 +- components/outputs/value-box.qmd | 236 +++++++++--------- components/outputs/verbatim-text.qmd | 18 +- 33 files changed, 855 insertions(+), 852 deletions(-) diff --git a/components/display-messages/modal.qmd b/components/display-messages/modal.qmd index f779527f..5c8ff868 100644 --- a/components/display-messages/modal.qmd +++ b/components/display-messages/modal.qmd @@ -1,6 +1,6 @@ --- -title: "Modal" -sidebar: components +title: Modal +sidebar: components previewapp: | from shiny import App, Inputs, Outputs, Session, reactive, ui @@ -29,11 +29,11 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6cKITIcAbnAkBXDgB0IGtKgD6qpgF4mqrFADmcHTQA2qgCYAKDUxfGOGLqmVkdMuaR0AI28yUicwdmIAdzV8JliAZTZophhiOyhrJjsOTOIzWIBKPA1CjQ07OBpWODpFOgdPbwliby8yCRY4FhYOUkLEZ1cAASk-BTgMAFEaGjhZIZdR6VkJjDhFckaIdoxIqLKIV2yqph0HAcXj1MM3DDSM6ycj69fYgBVOFl5vqFZGOBRNhQYR8ARCKDkVLdFjmSaxEovV7HORkaxwAyJAFAkG8fiCMiQ4TwHpwhFXZFMaQsbA6QjWYhdAzvOjKJQU5E0YjECh0AwmB6ZIIhMKxAAiHBYMElLCKiMph0pAvSQv2Dhghy06FuYlQDm0eg4nVq9UKYAAvgBdIA code: | from shiny import App, reactive, ui - + app_ui = ui.page_fluid( ui.input_action_button("show", "Show modal dialog"), ) - + def server(input, output, session): @reactive.Effect @reactive.event(input.show) @@ -44,19 +44,19 @@ listing: easy_close=True #<< ) #<< ui.modal_show(m) #<< - + app = App(app_ui, server) relevantfunctions: - - title: "ui.modal" + - title: ui.modal href: https://shiny.posit.co/py/api/ui.modal.html signature: ui.modal(*args, title=None, footer=MISSING, size='m', easy_close=False, fade=True, **kwargs) - - title: "ui.modal_show" + - title: ui.modal_show href: https://shiny.posit.co/py/api/ui.modal_show.html signature: ui.modal_show(modal, session=None) - - title: "ui.modal_remove" + - title: ui.modal_remove href: https://shiny.posit.co/py/api/ui.modal_remove.html signature: ui.modal_remove(session=None) - - title: "ui.modal_button" + - title: ui.modal_button href: https://shiny.posit.co/py/api/ui.modal_button.html signature: ui.modal_button(label, icon=None, **kwargs) - id: variations @@ -68,11 +68,11 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6cKITIcAbnAkBXDgB0IGtKgD6qpgF4mqrFADmcHTQA2qgCYAKDUxfGOGLqmVkdMuaR0AI28yUicwa2IzLjV8JliAGSiYsABKPA1UjQ07OBpWODpFOgdPbwliby8yCRY4FhYOUlTEZ1cAASk-BTgMAFEaGjhZNpdO6VkejDhFclKIaoxI6IgsiFcmXPydBxbRjaZmIxMYYjsoayd1g5uTMp8KAA8ycOh4WIlYgFU6uje4VppDLXG4bO4Lbw6VBQBoAd0Ejli0LhCI+8TAAAUYSx4XQ7ID0vtQW4PBCfN0AsEyKEIOESBAIMMyGjYgBhUiMkZAomg6QsbA6QiROoGAAqdGUSh5NxoxGIFDoBgAcqQ4NKmGtiSczhcdOxiLCHDBNaD9uNuop+oMmWaupNLTNKC97hh6ZyyCaXFsmDodnsQQdtedrDopKdFLt1QBiJjs3JMUJMN1MpiwjhkNi8MkYf67JhQCB2LOLZE4hGRzTQdCGUToBzaPQcWqFYqpMAAXwAukA code: | from shiny import App, reactive, ui - + app_ui = ui.page_fluid( ui.input_action_button("login", "Login"), ) - + def server(input, output, session): @reactive.Effect @reactive.event(input.login) @@ -91,7 +91,7 @@ listing: def __(): #<< ui.modal_remove() #<< # Code to connect with input.name() and input.password() #<< - + app = App(app_ui, server) --- diff --git a/components/display-messages/notifications.qmd b/components/display-messages/notifications.qmd index 2c3a0e49..8e6d7fe9 100644 --- a/components/display-messages/notifications.qmd +++ b/components/display-messages/notifications.qmd @@ -1,5 +1,5 @@ --- -title: "Notifications / Help Text" +title: Notifications / Help Text sidebar: components previewapp: | from shiny import App, reactive, ui @@ -180,7 +180,7 @@ listing: app = App(app_ui, server) - title: Help Text - description: "[`ui.help_text()`](https://shiny.posit.co/py/api/ui.help_text.html) creates stylized help text which can be added to the user interface to provide additional explanation or context. [Tooltips](tooltips.qmd) provides a similar, but alternative way to display information to the user." + description: '[`ui.help_text()`](https://shiny.posit.co/py/api/ui.help_text.html) creates stylized help text which can be added to the user interface to provide additional explanation or context. [Tooltips](tooltips.qmd) provides a similar, but alternative way to display information to the user.' preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6cKITIcAbnAkBXDgB0IGtKgD6qpgF4mqrFADmcHTQA2qgCYAKDUxfGOGLqmVkdMuaR0AI28yUicwdmIAdzV8JliAZTZopgA5YjkaDkIof00wAEo8Z1cTT29fWQ4A4LJQiHCpGGJFWIlYgCU4ZsU0jI4snLzYoo0CjQ07OBpWODpFOgdysgliby8V2ZYWaogCxBKXDjsWRCZrDhYyYCu6AF1DJmA7w6YIM65hIwAGCYhXJgAASkfgUcAwAFEaDQ4LJXsDpFVFBg4IpyEsIBsMJEouN-q4pjMdA59q8ARBSNZiDlrLwTmTXBSIFSaW8GS4AMRMBJQXpkNhwJgASQAIkwaIJJN0WlBadZcnN2XTHiYKZlsrldjoceEALJwbbmQWxJgAalYZEWewkdmUdE1pAM6QgcDxAIBxxYGG0lEcxzd7pc-1NRgAjH8AQjQcioTC4fiXFGkeDUZQyBisU0Wq7XoSmMTSQn3UyWbK6SwlQNywci4GXKr+oMHRAdFnFEsTlhiKgSXitOhHmIe9o9BwJCw5gsCmAAL53IA height: 200px code: | diff --git a/components/display-messages/progress-bar.qmd b/components/display-messages/progress-bar.qmd index 38c0feef..c9b37f2c 100644 --- a/components/display-messages/progress-bar.qmd +++ b/components/display-messages/progress-bar.qmd @@ -1,6 +1,6 @@ --- -title: "Progress Bar" -sidebar: components +title: Progress Bar +sidebar: components previewapp: | import asyncio @@ -33,50 +33,50 @@ previewapp: | ## file: styles.css #shiny-notification-panel { max-width: 100%; } listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Progress Bar - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACKAZ2wkJuIB0IAgGaNiMFuwAWNCNhZ0GzFgEF0eFozhRCZGgDc46zRAAmcRuoCuNAQLSoA+tZYBeFtaxQA5nAdCANtYmABQCLOHuNBgyqJZkDtq6pA4ARnFkpKFgaWQZgvgsfGAAwmKxFEUAlHhhER7EceUOFAAeZFkk9HFwVTUQlbamcEIS5gaMwTFx6g1k5erscOzsvP2IteEAArPlGyybxmaMGK1kewdaOvpwGHAG5JMQ5Rg5eQMQEWyc3CxmI53lODBSrrD6fCIAdxoZEkkQwAAVRF5NMtgjAZC4AIzqGBQFpYgCslS+LFQoPBFNJGEW7Xgy28cBcRWKUH8hEs-igSQ+MlJSJR7CK6jMZCgNH8TLAABVpOwWLi5KKANZwNgsCHSfw3DAYKqDSngoRMeTyD6MKAQHzBbEsTFE8kGymYGmTHFLdgMyWlLq6S16sGO8FQCFi1gcLg8YjUrVwVDBAAMGEx7z2n00ZEsjA+RQAIqRVQC4jIvABCIqDeyuFToYL2Jw0BZjcyVMAAXwAukA - height: 200px - code: | - import asyncio - - from shiny import App, reactive, render, ui - - app_ui = ui.page_fluid( - ui.input_action_button("button", "Compute"), - ui.output_text("compute"), - ) - - def server(input, output, session): - @output - @render.text - @reactive.event(input.button) - async def compute(): - with ui.Progress(min=1, max=15) as p: - p.set(message="Calculation in progress", detail="This may take a while...") - - for i in range(1, 15): - p.set(i, message="Computing") - await asyncio.sleep(0.1) - - return "Done computing!" - - app = App(app_ui, server) - relevantfunctions: - - title: "ui.Progress" - href: https://shiny.posit.co/py/api/ui.Progress.html - signature: ui.Progress(self, min=0, max=1, session=None) - - title: "ui.Progress.close" - href: https://shiny.posit.co/py/api/ui.Progress.html - signature: ui.Progress.close(self) - - title: "ui.Progress.inc" - href: https://shiny.posit.co/py/api/ui.Progress.html - signature: ui.Progress.inc(self, amount=0.1, message=None, detail=None) - - title: "ui.Progress.set" - href: https://shiny.posit.co/py/api/ui.Progress.html - signature: ui.Progress.set(self, value=None, message=None, detail=None) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Progress Bar + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACKAZ2wkJuIB0IAgGaNiMFuwAWNCNhZ0GzFgEF0eFozhRCZGgDc46zRAAmcRuoCuNAQLSoA+tZYBeFtaxQA5nAdCANtYmABQCLOHuNBgyqJZkDtq6pA4ARnFkpKFgaWQZgvgsfGAAwmKxFEUAlHhhER7EceUOFAAeZFkk9HFwVTUQlbamcEIS5gaMwTFx6g1k5erscOzsvP2IteEAArPlGyybxmaMGK1kewdaOvpwGHAG5JMQ5Rg5eQMQEWyc3CxmI53lODBSrrD6fCIAdxoZEkkQwAAVRF5NMtgjAZC4AIzqGBQFpYgCslS+LFQoPBFNJGEW7Xgy28cBcRWKUH8hEs-igSQ+MlJSJR7CK6jMZCgNH8TLAABVpOwWLi5KKANZwNgsCHSfw3DAYKqDSngoRMeTyD6MKAQHzBbEsTFE8kGymYGmTHFLdgMyWlLq6S16sGO8FQCFi1gcLg8YjUrVwVDBAAMGEx7z2n00ZEsjA+RQAIqRVQC4jIvABCIqDeyuFToYL2Jw0BZjcyVMAAXwAukA + height: 200px + code: | + import asyncio + + from shiny import App, reactive, render, ui + + app_ui = ui.page_fluid( + ui.input_action_button("button", "Compute"), + ui.output_text("compute"), + ) + + def server(input, output, session): + @output + @render.text + @reactive.event(input.button) + async def compute(): + with ui.Progress(min=1, max=15) as p: + p.set(message="Calculation in progress", detail="This may take a while...") + + for i in range(1, 15): + p.set(i, message="Computing") + await asyncio.sleep(0.1) + + return "Done computing!" + + app = App(app_ui, server) + relevantfunctions: + - title: ui.Progress + href: https://shiny.posit.co/py/api/ui.Progress.html + signature: ui.Progress(self, min=0, max=1, session=None) + - title: ui.Progress.close + href: https://shiny.posit.co/py/api/ui.Progress.html + signature: ui.Progress.close(self) + - title: ui.Progress.inc + href: https://shiny.posit.co/py/api/ui.Progress.html + signature: ui.Progress.inc(self, amount=0.1, message=None, detail=None) + - title: ui.Progress.set + href: https://shiny.posit.co/py/api/ui.Progress.html + signature: ui.Progress.set(self, value=None, message=None, detail=None) --- diff --git a/components/display-messages/tooltips.qmd b/components/display-messages/tooltips.qmd index 9f7586b7..c28b6815 100644 --- a/components/display-messages/tooltips.qmd +++ b/components/display-messages/tooltips.qmd @@ -1,6 +1,6 @@ --- -title: "Tooltips" -sidebar: components +title: Tooltips +sidebar: components previewapp: | from shiny import App, render, ui @@ -29,7 +29,7 @@ listing: height: 200px code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.tooltip( #<< ui.input_action_button("btn", "A button with a tooltip"), @@ -39,12 +39,12 @@ listing: ), ui.output_text_verbatim("text") ) - + def server(input, output, session): @render.text def text(): return input.btn_tooltip() #<< - + app = App(app_ui, server) relevantfunctions: @@ -75,7 +75,7 @@ listing: ui.tags.br(), ui.input_action_button("btn_update", "Update tooltip message") ) - + def server(input, output, session): @reactive.Effect @reactive.event(input.btn_update) @@ -83,11 +83,11 @@ listing: content = ( "A " + " ".join(["NEW" for _ in range(input.btn_update())])+ " message" ) - + ui.update_tooltip("btn_tooltip", content, show=True) #<< - + app = App(app_ui, server) - + --- :::{#component} diff --git a/components/inputs/action-button.qmd b/components/inputs/action-button.qmd index 3e9cab71..365ec321 100644 --- a/components/inputs/action-button.qmd +++ b/components/inputs/action-button.qmd @@ -1,6 +1,6 @@ --- -title: "Action Button" -sidebar: components +title: Action Button +sidebar: components previewapp: | from shiny import App, reactive, render, ui app_ui = ui.page_fluid( diff --git a/components/inputs/action-link.qmd b/components/inputs/action-link.qmd index 6233deed..09a58fc7 100644 --- a/components/inputs/action-link.qmd +++ b/components/inputs/action-link.qmd @@ -1,6 +1,6 @@ --- -title: "Action Link" -sidebar: components +title: Action Link +sidebar: components previewapp: | from shiny import App, reactive, render, ui app_ui = ui.page_fluid( @@ -16,34 +16,34 @@ previewapp: | return f"" app = App(app_ui, server) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Action Link - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6cKITIcAbnAlSIAEzh0JAVw4AdaOgD6OpgF4mOrFADmcQzQA2O1QAp9TDxY4YGAdzcQnkFeGCROMBAuAGza3lyoWmSGMnKkhg5cANZuKLIcaRkQmbr4TCUAkhCEUlAscEwAclowAEYaJQCUHRLuwR6WYc2RMSHEiQlJFAAeZDkkWuTtYB0YUKqqhoQOtSw5qhwsqNvYALQArEytJwAMnd29fSAlWzsliGVg8mwnAIzX10wAFZaFhyGinEiLcgnQiUCh0JhQDLWCAnDgUGAsGFwjRMVBTc4lAC+DyYKzWGxeLF2JWmZGxizonQ8+g6+nUNFYGkUdBc8USEjGZAmEjq1PyEFFZCgQi41kM8iRWnq5muHUQpPm5DMkmkeUUGAAakq4C5QTK5BB5YqnHA2RBSQABGr6uAYACiNBocFkTpdcgNcEU5D5EAmqzyBSy9qCHKYhhc6tJQS1ZAwdVmqcTTAA1Ewfva-ZR1HQMHTSXHUxpExrAn1dWQtHRAjQSiAsx0SWB9D2DKgdWJUC40KhjBxRdyNIWHTOwESALpAA - height: 200px - code: | - from shiny import App, reactive, render, ui - - app_ui = ui.page_fluid( - ui.input_action_link("action_link", "Action"), #<< - ui.output_text("counter") - ) - - def server(input, output, session): - @render.text() - @reactive.event(input.action_link) - def counter(): - return f"{input.action_link()}" - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_action_link - href: https://shiny.posit.co/py/api/ui.input_action_link.html - signature: ui.input_action_link(id, label, *, icon=None, **kwargs) - - title: reactive.event - href: https://shiny.posit.co/py/api/reactive.event.html - signature: reactive.event(*args, ignore_none=True, ignore_init=False) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Action Link + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6cKITIcAbnAlSIAEzh0JAVw4AdaOgD6OpgF4mOrFADmcQzQA2O1QAp9TDxY4YGAdzcQnkFeGCROMBAuAGza3lyoWmSGMnKkhg5cANZuKLIcaRkQmbr4TCUAkhCEUlAscEwAclowAEYaJQCUHRLuwR6WYc2RMSHEiQlJFAAeZDkkWuTtYB0YUKqqhoQOtSw5qhwsqNvYALQArEytJwAMnd29fSAlWzsliGVg8mwnAIzX10wAFZaFhyGinEiLcgnQiUCh0JhQDLWCAnDgUGAsGFwjRMVBTc4lAC+DyYKzWGxeLF2JWmZGxizonQ8+g6+nUNFYGkUdBc8USEjGZAmEjq1PyEFFZCgQi41kM8iRWnq5muHUQpPm5DMkmkeUUGAAakq4C5QTK5BB5YqnHA2RBSQABGr6uAYACiNBocFkTpdcgNcEU5D5EAmqzyBSy9qCHKYhhc6tJQS1ZAwdVmqcTTAA1Ewfva-ZR1HQMHTSXHUxpExrAn1dWQtHRAjQSiAsx0SWB9D2DKgdWJUC40KhjBxRdyNIWHTOwESALpAA + height: 200px + code: | + from shiny import App, reactive, render, ui + + app_ui = ui.page_fluid( + ui.input_action_link("action_link", "Action"), #<< + ui.output_text("counter") + ) + + def server(input, output, session): + @render.text() + @reactive.event(input.action_link) + def counter(): + return f"{input.action_link()}" + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_action_link + href: https://shiny.posit.co/py/api/ui.input_action_link.html + signature: ui.input_action_link(id, label, *, icon=None, **kwargs) + - title: reactive.event + href: https://shiny.posit.co/py/api/reactive.event.html + signature: reactive.event(*args, ignore_none=True, ignore_init=False) --- diff --git a/components/inputs/checkbox-group.qmd b/components/inputs/checkbox-group.qmd index 62504575..a7f885fa 100644 --- a/components/inputs/checkbox-group.qmd +++ b/components/inputs/checkbox-group.qmd @@ -1,60 +1,60 @@ --- -title: "Checkbox Group" -sidebar: components +title: Checkbox Group +sidebar: components previewapp: | - from shiny import App, render, req, ui - app_ui = ui.page_fluid( - ui.input_checkbox_group( - "checkbox_group", - "", - { - "a": "Watch me Whip", - "b": "Watch me Nae Nae", - "c": "Watch neither", - }, - ).add_class("mb-0"), - ui.output_text("value"), - {"class": "vh-100 d-flex justify-content-center align-items-center px-4"} - ) - def server(input, output, session): - @output - @render.text - def value(): - return "" - app = App(app_ui, server) + from shiny import App, render, req, ui + app_ui = ui.page_fluid( + ui.input_checkbox_group( + "checkbox_group", + "", + { + "a": "Watch me Whip", + "b": "Watch me Nae Nae", + "c": "Watch neither", + }, + ).add_class("mb-0"), + ui.output_text("value"), + {"class": "vh-100 d-flex justify-content-center align-items-center px-4"} + ) + def server(input, output, session): + @output + @render.text + def value(): + return "" + app = App(app_ui, server) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Checkbox Group - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EqQEcJAVw4AdaOgD6apgF4marFADmcbTQA2a6QApNTJ0Y4YuqFWW2E2cQgGsAI2IAD21TBhVUOyZHZ3j1Il8A4LCI4ijEiTj4p0SAYWSg0KZ0zPxYiFznEErq6sSoRMRYsBEsuvqEsEDm1oAhDpyu1sI+gqGq+oBfbKmnAEo5+OMMsg8vChCyBzAANygbOESlzRBEwisoFhZx-bYAWgBGAAYXpmkH6zgQpkOOUwQB4cCgwFgPQiUCh0JioEIPAAsiWmmgWmlkNFYcj2cjs7k8EjWGwkLDgNw4pAWiGGAAEiZ5aVIILI6BgtmRhhimAcjnYqcN4lIyCo6FUhmAMAArYhcPEQDYYHx+YppSLRBZorSoAyidB2NCoXQcEnYuQLMDTAC6QA - height: 200px - code: | - from shiny import App, render, req, ui - - app_ui = ui.page_fluid( - ui.input_checkbox_group( #<< - "checkbox_group", #<< - "Checkbox group", #<< - { #<< - "a": "A", #<< - "b": "B", #<< - "c": "C", #<< - }, #<< - ), #<< - ui.output_text("value"), - ) - - def server(input, output, session): - @render.text - def value(): - return ", ".join(input.checkbox_group()) - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_checkbox_group - href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html - signature: ui.input_checkbox_group(id, label, choices, *, selected=None, inline=False, width=None) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Checkbox Group + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EqQEcJAVw4AdaOgD6apgF4marFADmcbTQA2a6QApNTJ0Y4YuqFWW2E2cQgGsAI2IAD21TBhVUOyZHZ3j1Il8A4LCI4ijEiTj4p0SAYWSg0KZ0zPxYiFznEErq6sSoRMRYsBEsuvqEsEDm1oAhDpyu1sI+gqGq+oBfbKmnAEo5+OMMsg8vChCyBzAANygbOESlzRBEwisoFhZx-bYAWgBGAAYXpmkH6zgQpkOOUwQB4cCgwFgPQiUCh0JioEIPAAsiWmmgWmlkNFYcj2cjs7k8EjWGwkLDgNw4pAWiGGAAEiZ5aVIILI6BgtmRhhimAcjnYqcN4lIyCo6FUhmAMAArYhcPEQDYYHx+YppSLRBZorSoAyidB2NCoXQcEnYuQLMDTAC6QA + height: 200px + code: | + from shiny import App, render, req, ui + + app_ui = ui.page_fluid( + ui.input_checkbox_group( #<< + "checkbox_group", #<< + "Checkbox group", #<< + { #<< + "a": "A", #<< + "b": "B", #<< + "c": "C", #<< + }, #<< + ), #<< + ui.output_text("value"), + ) + + def server(input, output, session): + @render.text + def value(): + return ", ".join(input.checkbox_group()) + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_checkbox_group + href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html + signature: ui.input_checkbox_group(id, label, choices, *, selected=None, inline=False, width=None) --- diff --git a/components/inputs/checkbox.qmd b/components/inputs/checkbox.qmd index 66c82ebd..7aa6c29b 100644 --- a/components/inputs/checkbox.qmd +++ b/components/inputs/checkbox.qmd @@ -1,6 +1,6 @@ --- -title: "Checkbox" -sidebar: components +title: Checkbox +sidebar: components previewapp: | from shiny import App, render, ui app_ui = ui.page_fluid( @@ -15,30 +15,30 @@ previewapp: | return f"" app = App(app_ui, server) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Checkbox - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOtHQB9JUwC8TJVigBzOOpoAbJdIAUqpnb0cMDAO42I9jw4wkLMCFYA2RUcuVAUydUI2OEIAawAjYgAPGyJouMSk5XwmbIBhdITk7IkAFToFOABKDChpaUizKBYWVJh4gFoABiYKJLIOwkoKOmyqqolbTzt9HwU-QOCMYnCwiKVUgDcoCzgx2vrG5tbs9u7euH7B4bkxianpkGzCJpbsxFywTbYOgEYunoAKwULDIHBo2EGpAo5Gu5DkTB2HEMEA6HAoMBYcJGTFQSQ6AFZsgBfB5MKqqCkQVSyGisOSbORWULhCQrMhrCQsOAtDikKqIMkAASkEFkdAwSjJtKY212VgFZI8UjICjo7hZZG8hUyCtUaFQOlE6CsBs0HC5DLkVTAxIAukA - height: 150px - code: | - from shiny import App, render, ui - - app_ui = ui.page_fluid( - ui.input_checkbox("checkbox", "Checkbox", False), #<< - ui.output_ui("value"), - ) - - def server(input, output, session): - @render.ui - def value(): - return input.checkbox() - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_checkbox() - href: https://shiny.posit.co/py/api/ui.input_checkbox.html - signature: ui.input_checkbox(id, label, value=False, *, width=None) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Checkbox + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOtHQB9JUwC8TJVigBzOOpoAbJdIAUqpnb0cMDAO42I9jw4wkLMCFYA2RUcuVAUydUI2OEIAawAjYgAPGyJouMSk5XwmbIBhdITk7IkAFToFOABKDChpaUizKBYWVJh4gFoABiYKJLIOwkoKOmyqqolbTzt9HwU-QOCMYnCwiKVUgDcoCzgx2vrG5tbs9u7euH7B4bkxianpkGzCJpbsxFywTbYOgEYunoAKwULDIHBo2EGpAo5Gu5DkTB2HEMEA6HAoMBYcJGTFQSQ6AFZsgBfB5MKqqCkQVSyGisOSbORWULhCQrMhrCQsOAtDikKqIMkAASkEFkdAwSjJtKY212VgFZI8UjICjo7hZZG8hUyCtUaFQOlE6CsBs0HC5DLkVTAxIAukA + height: 150px + code: | + from shiny import App, render, ui + + app_ui = ui.page_fluid( + ui.input_checkbox("checkbox", "Checkbox", False), #<< + ui.output_ui("value"), + ) + + def server(input, output, session): + @render.ui + def value(): + return input.checkbox() + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_checkbox() + href: https://shiny.posit.co/py/api/ui.input_checkbox.html + signature: ui.input_checkbox(id, label, value=False, *, width=None) --- :::{#component} diff --git a/components/inputs/date-range-selector.qmd b/components/inputs/date-range-selector.qmd index 528a08bc..d1cdce3c 100644 --- a/components/inputs/date-range-selector.qmd +++ b/components/inputs/date-range-selector.qmd @@ -1,6 +1,6 @@ --- -title: "Date Range Selector" -sidebar: components +title: Date Range Selector +sidebar: components previewapp: | from shiny import App, render, ui @@ -18,33 +18,33 @@ previewapp: | app = App(app_ui, server, debug=True) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Date Range Selector - preview: | - https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAEygrIEt4nvVi6ZVuzgAdCOPqMmAZwAWnCNl4x+gpgEF0eJnUos4dHQFdO48WlQB9U0wC8TU1igBzOFZoAbUywAU4pkDHTgxFVGMyKzYKKzooCDd-MGjDeLdRfCYMjJ0ZMihBOwyAJgAGMoBaUoBGKuqMgEoMKBYWK0JPKBkZJNQyCoBWJhgADwqoCOImChH+wkoKOka8AKCnYgjwyJmyJIA3KG8xMAaViCCLphAMjq6ZDMQssD25CurS0qYAK2M8zhpsBUSOQFkCFoYmIdOC4IBVOBQYDIwSC6ExUGMBhkAL7iJotNq3bpJGCAiZkKY7ZGLRrmCQQAw0WSGPaGXxhCI6DZkLa5ODdTikBqIVaBAACXK2IqYor09MMGB2UoZTAOR18QqlFz0ZGMdHONAyIHZZAwKTiCTg6uApQAuljplMjRAtqaRObEg1gNU7dk6RZ0PZNOhfJYbJxeXQWXQGmAsTagA - height: 380px - code: | - from datetime import date - - from shiny import App, render, ui - - app_ui = ui.page_fluid( - ui.input_date_range("daterange", "Date range", start="2020-01-01"), #<< - ui.output_text("value"), - ) - - def server(input, output, session): - @render.text - def value(): - return f"{input.daterange()[0]} to {input.daterange()[1]}" - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_date_range - href: https://shiny.posit.co/py/api/ui.input_date_range.html - signature: ui.input_date_range(id, label, *, start=None, end=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', separator=' to ', width=None, autoclose=True) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Date Range Selector + preview: | + https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAEygrIEt4nvVi6ZVuzgAdCOPqMmAZwAWnCNl4x+gpgEF0eJnUos4dHQFdO48WlQB9U0wC8TU1igBzOFZoAbUywAU4pkDHTgxFVGMyKzYKKzooCDd-MGjDeLdRfCYMjJ0ZMihBOwyAJgAGMoBaUoBGKuqMgEoMKBYWK0JPKBkZJNQyCoBWJhgADwqoCOImChH+wkoKOka8AKCnYgjwyJmyJIA3KG8xMAaViCCLphAMjq6ZDMQssD25CurS0qYAK2M8zhpsBUSOQFkCFoYmIdOC4IBVOBQYDIwSC6ExUGMBhkAL7iJotNq3bpJGCAiZkKY7ZGLRrmCQQAw0WSGPaGXxhCI6DZkLa5ODdTikBqIVaBAACXK2IqYor09MMGB2UoZTAOR18QqlFz0ZGMdHONAyIHZZAwKTiCTg6uApQAuljplMjRAtqaRObEg1gNU7dk6RZ0PZNOhfJYbJxeXQWXQGmAsTagA + height: 380px + code: | + from datetime import date + + from shiny import App, render, ui + + app_ui = ui.page_fluid( + ui.input_date_range("daterange", "Date range", start="2020-01-01"), #<< + ui.output_text("value"), + ) + + def server(input, output, session): + @render.text + def value(): + return f"{input.daterange()[0]} to {input.daterange()[1]}" + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_date_range + href: https://shiny.posit.co/py/api/ui.input_date_range.html + signature: ui.input_date_range(id, label, *, start=None, end=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', separator=' to ', width=None, autoclose=True) --- diff --git a/components/inputs/date-selector.qmd b/components/inputs/date-selector.qmd index 14018afc..818e9ba1 100644 --- a/components/inputs/date-selector.qmd +++ b/components/inputs/date-selector.qmd @@ -1,6 +1,6 @@ --- -title: "Date Selector" -sidebar: components +title: Date Selector +sidebar: components previewapp: | from shiny import App, render, ui @@ -17,32 +17,32 @@ previewapp: | app = App(app_ui, server, debug=True) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Date Selector - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAEygrIEt4nvVi6ZVuzgAdCOPqMmAZwAWnCNl4x+gpgEF0eJnUos4dHQFdO48WlQB9U0wC8TU1igBzOFZoAbUywAU4pkDHTgxFVGMyKzYKfzBosXwmUTBkgEoMKBYWK0JPKBkZWNQyAFoAViYYAA8SqAjiJgoq0sJKCjo0vACgp2II8MimsliANyhvBNSuiCCmEGTc-JlkxCSwEbkSgEYABh2mACtjGS4abBKScjaLtsMmcc4XCBLOChgZG6u6JlQasuSAL7idKZbKLAqxGDnOpkBpDT7tNLmCQQAw0WSGEaGXxhCI6PpkAY6GRwAqcUipRDdQIAAQJA2pTBpelRhgwQ0ZaKYYwmvkpjNmejIxjoM1xZAw8T5yIs6HsmnQvksNk4xMxhlSYABAF0gA - height: 380px - code: | - from datetime import date - - from shiny import App, render, ui - - app_ui = ui.page_fluid( - ui.input_date("date", "Date"), #<< - ui.output_text("value") - ) - - def server(input, output, session): - @render.text - def value(): - return input.date() - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_date - href: https://shiny.posit.co/py/api/ui.input_date.html - signature: ui.input_date(id, label, *, value=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', width=None, autoclose=True, datesdisabled=None, daysofweekdisabled=None) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Date Selector + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAEygrIEt4nvVi6ZVuzgAdCOPqMmAZwAWnCNl4x+gpgEF0eJnUos4dHQFdO48WlQB9U0wC8TU1igBzOFZoAbUywAU4pkDHTgxFVGMyKzYKfzBosXwmUTBkgEoMKBYWK0JPKBkZWNQyAFoAViYYAA8SqAjiJgoq0sJKCjo0vACgp2II8MimsliANyhvBNSuiCCmEGTc-JlkxCSwEbkSgEYABh2mACtjGS4abBKScjaLtsMmcc4XCBLOChgZG6u6JlQasuSAL7idKZbKLAqxGDnOpkBpDT7tNLmCQQAw0WSGEaGXxhCI6PpkAY6GRwAqcUipRDdQIAAQJA2pTBpelRhgwQ0ZaKYYwmvkpjNmejIxjoM1xZAw8T5yIs6HsmnQvksNk4xMxhlSYABAF0gA + height: 380px + code: | + from datetime import date + + from shiny import App, render, ui + + app_ui = ui.page_fluid( + ui.input_date("date", "Date"), #<< + ui.output_text("value") + ) + + def server(input, output, session): + @render.text + def value(): + return input.date() + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_date + href: https://shiny.posit.co/py/api/ui.input_date.html + signature: ui.input_date(id, label, *, value=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', width=None, autoclose=True, datesdisabled=None, daysofweekdisabled=None) --- :::{#component} diff --git a/components/inputs/numeric-input.qmd b/components/inputs/numeric-input.qmd index 2b05803b..a2217b09 100644 --- a/components/inputs/numeric-input.qmd +++ b/components/inputs/numeric-input.qmd @@ -1,6 +1,6 @@ --- -title: "Numeric Input" -sidebar: components +title: Numeric Input +sidebar: components previewapp: | from shiny import App, render, ui @@ -17,31 +17,31 @@ previewapp: | app = App(app_ui, server, debug=True) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Numeric Input - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOtHQB9JUwC8TJVigBzOOpoAbJdIAUqpnb0cMXVArLqIC+HQ6EbkT3I+yvhMwcESAIwSMFzaUUwwUAAecQAMAJQYUNLS6oRmUCwsfqhkALQArAlJZVCuxEwUSeWElBR0wel4tvb6xK4ubk1uAG5yAEZQZHx+I1AWcJ3dEPZMIMH5hSzBiKFgI2xlEampTABWCizTNNhlJORtd21yTPMchhBlHBQwLE8PdCYqBqFWCAF9VJlsrlNkU-DBbnUyA1hv92p1VLIaKw5GM6FZnK4JP0yIMJCw4EUOKR0ogenYAAJSCCyOgYYb0phYphzBZWWmc1ZSMgKOgrQlkDAeLw+fmqNCoHSidBWBWaDjk3FydJgMEAXSAA - height: 200px - code: | - from shiny import App, render, ui - - app_ui = ui.page_fluid( - ui.input_numeric("numeric", "Numeric input", 1, min=1, max=10), #<< - ui.output_text_verbatim("value"), - ) - - def server(input, output, session): - @render.text - def value(): - return input.numeric() - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_numeric - href: https://shiny.posit.co/py/api/ui.input_numeric.html - signature: ui.input_numeric(id, label, value, *, min=None, max=None, step=None, width=None) - + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Numeric Input + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOtHQB9JUwC8TJVigBzOOpoAbJdIAUqpnb0cMXVArLqIC+HQ6EbkT3I+yvhMwcESAIwSMFzaUUwwUAAecQAMAJQYUNLS6oRmUCwsfqhkALQArAlJZVCuxEwUSeWElBR0wel4tvb6xK4ubk1uAG5yAEZQZHx+I1AWcJ3dEPZMIMH5hSzBiKFgI2xlEampTABWCizTNNhlJORtd21yTPMchhBlHBQwLE8PdCYqBqFWCAF9VJlsrlNkU-DBbnUyA1hv92p1VLIaKw5GM6FZnK4JP0yIMJCw4EUOKR0ogenYAAJSCCyOgYYb0phYphzBZWWmc1ZSMgKOgrQlkDAeLw+fmqNCoHSidBWBWaDjk3FydJgMEAXSAA + height: 200px + code: | + from shiny import App, render, ui + + app_ui = ui.page_fluid( + ui.input_numeric("numeric", "Numeric input", 1, min=1, max=10), #<< + ui.output_text_verbatim("value"), + ) + + def server(input, output, session): + @render.text + def value(): + return input.numeric() + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_numeric + href: https://shiny.posit.co/py/api/ui.input_numeric.html + signature: ui.input_numeric(id, label, value, *, min=None, max=None, step=None, width=None) + --- :::{#component} diff --git a/components/inputs/password-field.qmd b/components/inputs/password-field.qmd index d7e0832a..bdb8c4a5 100644 --- a/components/inputs/password-field.qmd +++ b/components/inputs/password-field.qmd @@ -1,6 +1,6 @@ --- -title: "Password Field" -sidebar: components +title: Password Field +sidebar: components previewapp: | from shiny import App, render, ui @@ -17,31 +17,31 @@ previewapp: | app = App(app_ui, server, debug=True) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Password Field - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhFVpUAfSVMAvEyVYoAcziaaAGyXSAFKqYODHDF1QKym1FBYsA7oNtlMC8ffzppIIkgyKYgmGwQvwCARiCASgwoaWlNQgtvFjtgsgBaAFYmGAAPEqh3YiYKKtLCSgo6dLx7R0NidzcPJo8ANzkAIygyPiLhqCs4Tu6HECC8gqDEWLBhthLkgAZ9pgArBRYpmmwSknI267a5JjmOYwgSjgoYFnvbuiZUGplIIAX1UGSyOTWPiK8Vq9UacGaP3a6VUaIgshorDkozoNlc7gkfTIAwkLDgPg4pDSiCWTAAAsSBnT6VIMXIMEM6ZimLN5jYaXTHJI4GQFHQILwIAMjKEAgL0ep0HpROgbBptBwyTi5GkwMCALpAA - height: 200px - code: | - from shiny import App, render, ui - - app_ui = ui.page_fluid( - ui.input_password("password", "Password", "mypassword1"), #<< - ui.output_text_verbatim("value"), - ) - - def server(input, output, session): - @render.text - def value(): - return input.password() - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_password - href: https://shiny.posit.co/py/api/ui.input_password.html - signature: ui.input_password(id, label, value='', *, width=None, placeholder=None) - + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Password Field + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhFVpUAfSVMAvEyVYoAcziaaAGyXSAFKqYODHDF1QKym1FBYsA7oNtlMC8ffzppIIkgyKYgmGwQvwCARiCASgwoaWlNQgtvFjtgsgBaAFYmGAAPEqh3YiYKKtLCSgo6dLx7R0NidzcPJo8ANzkAIygyPiLhqCs4Tu6HECC8gqDEWLBhthLkgAZ9pgArBRYpmmwSknI267a5JjmOYwgSjgoYFnvbuiZUGplIIAX1UGSyOTWPiK8Vq9UacGaP3a6VUaIgshorDkozoNlc7gkfTIAwkLDgPg4pDSiCWTAAAsSBnT6VIMXIMEM6ZimLN5jYaXTHJI4GQFHQILwIAMjKEAgL0ep0HpROgbBptBwyTi5GkwMCALpAA + height: 200px + code: | + from shiny import App, render, ui + + app_ui = ui.page_fluid( + ui.input_password("password", "Password", "mypassword1"), #<< + ui.output_text_verbatim("value"), + ) + + def server(input, output, session): + @render.text + def value(): + return input.password() + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_password + href: https://shiny.posit.co/py/api/ui.input_password.html + signature: ui.input_password(id, label, value='', *, width=None, placeholder=None) + --- :::{#component} diff --git a/components/inputs/radio-buttons.qmd b/components/inputs/radio-buttons.qmd index 9e3ab806..d8427991 100644 --- a/components/inputs/radio-buttons.qmd +++ b/components/inputs/radio-buttons.qmd @@ -1,6 +1,6 @@ --- -title: "Radio Buttons" -sidebar: components +title: Radio Buttons +sidebar: components previewapp: | from shiny import App, render, ui @@ -22,34 +22,34 @@ previewapp: | app = App(app_ui, server, debug=True) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Radio Buttons - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOtHQB9JUwC8TJVigBzOOpoAbJdIAUqpnb0cMXVArLq6UaR2LqARq7JSFismW3tw5TAPL2JIiTDwu0iAJU9vJn8yQIgWONCIRPsQSIBGSMRQsAB5VDJvArL8SoAmcsqautImVqbIgGY2yI76pgGwAF94gvsASinw-WJXFzclGzAANygLOEi5hKZiojMoFlykSo22AFoSgAY7pmlr8zgADyZtjkMIa44KGAsa6ESgUOhMVBva4AFki41UM1UshorDkGzkVmcrgkSzIKwkLDgZ3qM0QBwAAlIILI6BglAdkUwtjsrKSDuEpGQFHQCliyBhot5Wao0KgdKJ0FZRZoOAS0XJERBVKoJgBdIA - height: 200px - code: | - from shiny import App, render, ui - - app_ui = ui.page_fluid( - ui.input_radio_buttons( #<< - "radio", #<< - "Radio buttons", #<< - {"1": "Option 1", "2": "Option 2", "3": "Option 3"}, #<< - ), #<< - ui.output_ui("value"), - ) - - def server(input, output, session): - @render.ui - def value(): - return input.radio() - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_radio_buttons - href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html - signature: ui.input_radio_buttons(id, label, choices, *, selected=None, inline=False, width=None) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Radio Buttons + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOtHQB9JUwC8TJVigBzOOpoAbJdIAUqpnb0cMXVArLq6UaR2LqARq7JSFismW3tw5TAPL2JIiTDwu0iAJU9vJn8yQIgWONCIRPsQSIBGSMRQsAB5VDJvArL8SoAmcsqautImVqbIgGY2yI76pgGwAF94gvsASinw-WJXFzclGzAANygLOEi5hKZiojMoFlykSo22AFoSgAY7pmlr8zgADyZtjkMIa44KGAsa6ESgUOhMVBva4AFki41UM1UshorDkGzkVmcrgkSzIKwkLDgZ3qM0QBwAAlIILI6BglAdkUwtjsrKSDuEpGQFHQCliyBhot5Wao0KgdKJ0FZRZoOAS0XJERBVKoJgBdIA + height: 200px + code: | + from shiny import App, render, ui + + app_ui = ui.page_fluid( + ui.input_radio_buttons( #<< + "radio", #<< + "Radio buttons", #<< + {"1": "Option 1", "2": "Option 2", "3": "Option 3"}, #<< + ), #<< + ui.output_ui("value"), + ) + + def server(input, output, session): + @render.ui + def value(): + return input.radio() + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_radio_buttons + href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html + signature: ui.input_radio_buttons(id, label, choices, *, selected=None, inline=False, width=None) --- diff --git a/components/inputs/select-multiple.qmd b/components/inputs/select-multiple.qmd index 07d90920..293cd66a 100644 --- a/components/inputs/select-multiple.qmd +++ b/components/inputs/select-multiple.qmd @@ -1,6 +1,6 @@ --- -title: "Select (Multiple)" -sidebar: components +title: Select (Multiple) +sidebar: components previewapp: | from shiny import App, Inputs, Outputs, Session, render, ui @@ -48,7 +48,7 @@ listing: @render.text def value(): return f"{input.select()}" - + app = App(app_ui, server) relevantfunctions: - title: ui.input_select @@ -63,7 +63,7 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhFVpUAfSVMAvEyVYoAcziaaAGyXSAFKqYODHDF1QKymlnAtxCZG0wAxAA8wfaOEcpgXj5+URIhYRARkWAAyt6+wsSoZBykLEwARt7EAO6I8UGh4SlMINVJdXVRAIxRiPVtIh1MUQDCbMQchHBMrT34fWCtAEK9A0MjY3NVbf0LYIPDo+MbYAC+CTXJzakATL0gUeeTnYs7Y7drYOfzSNPby0xvL+f79y2S12-yiB0atRSRwhpzqMAUFjyqB8ugAKnQFGNEpCAJTHJqOQzEdxuDwUAAe-iiADcoFY4FE8aocapVLIaKw5NS5DZXO4JMSyKSJF4WCx8hAcZVYUwAAJSCCyOgYClkSHspi0+k2KWQiJSMgKOjJGhREB8sgYGJZHUHKKs6DoPSidA2DTaDgirlyHGHAC6QA code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_select( #<< "select", #<< @@ -73,12 +73,12 @@ listing: ), #<< ui.output_text("value"), ) - + def server(input, output, session): @render.text def value(): return f"{input.select()}" - + app = App(app_ui, server) --- diff --git a/components/inputs/select-single.qmd b/components/inputs/select-single.qmd index e8d1c47a..a1d7777b 100644 --- a/components/inputs/select-single.qmd +++ b/components/inputs/select-single.qmd @@ -1,6 +1,6 @@ --- -title: "Select (Single)" -sidebar: components +title: Select (Single) +sidebar: components previewapp: | from shiny import App, Inputs, Outputs, Session, render, ui @@ -33,7 +33,7 @@ listing: height: 200px code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_select( #<< "select", #<< @@ -42,18 +42,18 @@ listing: ), #<< ui.output_text("value"), ) - + def server(input, output, session): @render.text def value(): return f"{input.select()}" - + app = App(app_ui, server) relevantfunctions: - title: ui.input_select href: https://shiny.posit.co/py/api/ui.input_select.html - signature: ui.input_select(id, label, choices, *, selected=None, multiple=False, selectize=False, width=None, size=None) - + signature: ui.input_select(id, label, choices, *, selected=None, multiple=False, selectize=False, width=None, size=None) + - id: variations template: ../_partials/components-variations.ejs contents: @@ -63,7 +63,7 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhFVpUAfSVMAvEyVYoAcziaaAGyXSAFKqYODHDF1QKymlnAtxCZG0wAxAA8wfaOEcpgXj5+URIhYRARkWAAyt6+wlDJxKhkHKRMAEbexADuiPFBoeEpTCA1SfX1UQCMUYgN7SKdTFEAwmzEHIRwTG29+P1gbQBCfYPDo+Pz1e0Di2BDI2MTm2AAvgm1yS2pAEx9IFEXU11Lu+N362AXC0gzOytM768XBwe22WewBUUOTTqKWOkLODgAlCdmo5DMR3G4PBQAB7+KIANygVjgUURqnhqlUshorDkeLkNlc7gkaLIGIkXhYLEKEHhVThTAAAlIILI6BhsWQoVSmASiTZeVCIlIyAo6MkaFEQIyyBgYll5YcohToOg9KJ0DYNNoOOzaXJ4UcALpAA code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_select( #<< "select", #<< @@ -75,12 +75,12 @@ listing: ), #<< ui.output_text("value"), ) - + def server(input, output, session): @render.text def value(): return f"{input.select()}" - + app = App(app_ui, server) --- diff --git a/components/inputs/selectize-multiple.qmd b/components/inputs/selectize-multiple.qmd index 9cb4fee4..a3fcad87 100644 --- a/components/inputs/selectize-multiple.qmd +++ b/components/inputs/selectize-multiple.qmd @@ -1,6 +1,6 @@ --- -title: "Selectize (Multiple)" -sidebar: components +title: Selectize (Multiple) +sidebar: components previewapp: | from shiny import App, Inputs, Outputs, Session, render, ui @@ -34,7 +34,7 @@ listing: height: 200px code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_selectize( #<< "selectize", #<< @@ -44,12 +44,12 @@ listing: ), #<< ui.output_text("value"), ) - + def server(input, output, session): @render.text def value(): return f"{input.selectize()}" - + app = App(app_ui, server) relevantfunctions: - title: ui.input_selectize @@ -64,7 +64,7 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhFVpUAfSVMAvEyVYoAcziaaAGyXSAFKqYODHDF1QKymlnAtxCZDgBecDZMAMQAPOH2jjHKYF4+foFwcRIRURAxsWAAyt6+wsSo-qQsTABG3sQA7oipYZHRWUwgDRnNzXEAjHGILd0ivUxxAMJsxByEcExdg-jDYF0AQkOj45PTy-XdI6tgYxNTM7tgAL5pjZkd2QBMQyBxN3N9a4fTT9tgNytICwcbTG+nxuJxe+3WRxBcVObSaWXOsKuzRgCgs-lQPl0ABU6Appuk4QBKC7tRyGYjuNweCgADzIdjAADcoFYUmBiapCapVLIaKw5Iy5DZXO4JBSyFSJF4WCwOKRCXUkUwAAJSCCyOgYWlkOG8pjM1k2BVwmJSMgKOiZGhxEAisgYBIFZJG05xbnQdB6UToGwabQcKUCuSEs4AXSAA code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_selectize( #<< "selectize", #<< @@ -77,12 +77,12 @@ listing: ), #<< ui.output_text("value"), ) - + def server(input, output, session): @render.text def value(): return f"{input.selectize()}" - + app = App(app_ui, server) --- diff --git a/components/inputs/selectize-single.qmd b/components/inputs/selectize-single.qmd index 3065eb55..c9aa55c2 100644 --- a/components/inputs/selectize-single.qmd +++ b/components/inputs/selectize-single.qmd @@ -1,6 +1,6 @@ --- -title: "Selectize (Single)" -sidebar: components +title: Selectize (Single) +sidebar: components previewapp: | from shiny import App, Inputs, Outputs, Session, render, ui @@ -33,7 +33,7 @@ listing: height: 200px code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_selectize( #<< "selectize", #<< @@ -42,12 +42,12 @@ listing: ), #<< ui.output_text("value"), ) - + def server(input, output, session): @render.text def value(): return f"{input.selectize()}" - + app = App(app_ui, server) relevantfunctions: - title: ui.input_selectize @@ -62,7 +62,7 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhFVpUAfSVMAvEyVYoAcziaaAGyXSAFKqYODHDF1QKymlnAtxCZDgBecDZMAMQAPOH2jjHKYF4+foFwcRIRURAxsWAAyt6+wlCZxKj+pEwARt7EAO6IqWGR0VlMII0ZLS1xAIxxiK09In1McQDCbMQchHBM3UP4I2DdAELDYxNTMysNPaNrYOOT07N7YAC+aU2ZndkATMMgcbfz-etHM887YLerSIuHmyYPy+t1OrwOG2OoLiZ3azSyFzh1wcAEpLh1HIZiO43B4KAAPMh2MAANygVhSYDRqhRqlUshorDkJLkNlc7gk2LIuIkXhYLA4pBR9WRTAAAlIILI6BgCWR4QymGSKTZhfCYlIyAo6JkaHEQOyyBgEgVkqqznE6dB0HpROgbBptBxecy5CjzgBdIA code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_selectize( #<< "selectize", #<< @@ -74,12 +74,12 @@ listing: ), #<< ui.output_text("value"), ) - + def server(input, output, session): @render.text def value(): return f"{input.selectize()}" - + app = App(app_ui, server) --- diff --git a/components/inputs/slider-range.qmd b/components/inputs/slider-range.qmd index 60ca7b92..069833b4 100644 --- a/components/inputs/slider-range.qmd +++ b/components/inputs/slider-range.qmd @@ -1,6 +1,6 @@ --- -title: "Slider Range" -sidebar: components +title: Slider Range +sidebar: components previewapp: | from shiny import App, render, ui @@ -15,39 +15,39 @@ previewapp: | app = App(app_ui, server) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Slider Range - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNLCx1l07YT95yyvhMwcESMFy6AAwRUAAeugCM0bFMAG5QVnC6wADMAKwSAGwFALoAlBhQ0tKahBZQLCx+qGQAtAVMMPHtUG7ETBTxHYSUFHTBFXj2jmIYxG6u7sPu6XIARlBkfH6Z2VMzEI5MIMENTSzBiKFg6WztKdFMAFYiLDs02O0k5OM-4zkTCyHGMEHaHAoMBYAL+dCYqF6BWCAF9VFUanULs0-DBvv0yINVrCJlNVKpZDRWHJ1r4XG4JIsyMsJCw4M0OKQKohZg4AAJM5a8ph8qQQHwYVbCykZLIiOA2bnCk5SMgiOjHGjBED0sgYAI+RVosDk6DoPRMJSoGwabTial0WkVMAospAA - height: 200px - code: | - from shiny import ui, render, App - - app_ui = ui.page_fluid( - ui.input_slider("slider", "Slider", min=0, max=100, value=[35, 65]), #<< - ui.output_text_verbatim("value"), - ) - - def server(input, output, session): - @render.text - def value(): - return f"{input.slider()}" - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_slider - href: https://shiny.posit.co/py/api/ui.input_slider.html - signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) - - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html - signature: ui.output_data_frame(id) - - title: render.data_frame - href: https://shiny.posit.co/py/api/render.data_frame.html - signature: render.data_frame(fn=None) - - title: render.DataTable - href: https://shiny.posit.co/py/api/render.DataTable.html - signature: render.DataTable(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Slider Range + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNLCx1l07YT95yyvhMwcESMFy6AAwRUAAeugCM0bFMAG5QVnC6wADMAKwSAGwFALoAlBhQ0tKahBZQLCx+qGQAtAVMMPHtUG7ETBTxHYSUFHTBFXj2jmIYxG6u7sPu6XIARlBkfH6Z2VMzEI5MIMENTSzBiKFg6WztKdFMAFYiLDs02O0k5OM-4zkTCyHGMEHaHAoMBYAL+dCYqF6BWCAF9VFUanULs0-DBvv0yINVrCJlNVKpZDRWHJ1r4XG4JIsyMsJCw4M0OKQKohZg4AAJM5a8ph8qQQHwYVbCykZLIiOA2bnCk5SMgiOjHGjBED0sgYAI+RVosDk6DoPRMJSoGwabTial0WkVMAospAA + height: 200px + code: | + from shiny import ui, render, App + + app_ui = ui.page_fluid( + ui.input_slider("slider", "Slider", min=0, max=100, value=[35, 65]), #<< + ui.output_text_verbatim("value"), + ) + + def server(input, output, session): + @render.text + def value(): + return f"{input.slider()}" + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_slider + href: https://shiny.posit.co/py/api/ui.input_slider.html + signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) + - title: ui.output_data_frame + href: https://shiny.posit.co/py/api/ui.output_data_frame.html + signature: ui.output_data_frame(id) + - title: render.data_frame + href: https://shiny.posit.co/py/api/render.data_frame.html + signature: render.data_frame(fn=None) + - title: render.DataTable + href: https://shiny.posit.co/py/api/render.DataTable.html + signature: render.DataTable(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') --- :::{#component} diff --git a/components/inputs/slider.qmd b/components/inputs/slider.qmd index f8b2e90c..1c5876f5 100644 --- a/components/inputs/slider.qmd +++ b/components/inputs/slider.qmd @@ -1,6 +1,6 @@ --- -title: "Slider" -sidebar: components +title: Slider +sidebar: components previewapp: | from shiny import App, render, ui @@ -17,30 +17,30 @@ previewapp: | app = App(app_ui, server, debug=True) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Slider - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNLCx1l07YT95yyvhMwcESAAwSAIwRUUwArBEAlBhQ0tKahBZQLCx+qGQAtAlMMAAeRVBuxEwU5cWElBR0wcl49o5iGMRuru717gBucgBGUGR8fkNQVnBtHRCOTCDB2bkswYihYENsRbERTABWIiyTNNhFJOTN181yTLMcxhBFHBQwLPe3dEyolQSwQAvqpUulMus8n4YFdqmRaoMfi02qpVLIaKw5CNfC43BJemR+hIWHA8hxSMlEJ0HAABQn9GlMWlSCA+DCDJkYpgzOY2KlM5ZSMgiOhLGjBEB4sgYAI+fmgsBo6DoPRMJSoGwabTiLF0HHJMDAgC6QA - height: 200px - code: | - from shiny import ui, render, App - - app_ui = ui.page_fluid( - ui.input_slider("slider", "Slider", 0, 100, 50), #<< - ui.output_text_verbatim("value"), - ) - - def server(input, output, session): - @render.text - def value(): - return f"{input.slider()}" - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_slider - href: https://shiny.posit.co/py/api/ui.input_slider.html - signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Slider + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNLCx1l07YT95yyvhMwcESAAwSAIwRUUwArBEAlBhQ0tKahBZQLCx+qGQAtAlMMAAeRVBuxEwU5cWElBR0wcl49o5iGMRuru717gBucgBGUGR8fkNQVnBtHRCOTCDB2bkswYihYENsRbERTABWIiyTNNhFJOTN181yTLMcxhBFHBQwLPe3dEyolQSwQAvqpUulMus8n4YFdqmRaoMfi02qpVLIaKw5CNfC43BJemR+hIWHA8hxSMlEJ0HAABQn9GlMWlSCA+DCDJkYpgzOY2KlM5ZSMgiOhLGjBEB4sgYAI+fmgsBo6DoPRMJSoGwabTiLF0HHJMDAgC6QA + height: 200px + code: | + from shiny import ui, render, App + + app_ui = ui.page_fluid( + ui.input_slider("slider", "Slider", 0, 100, 50), #<< + ui.output_text_verbatim("value"), + ) + + def server(input, output, session): + @render.text + def value(): + return f"{input.slider()}" + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_slider + href: https://shiny.posit.co/py/api/ui.input_slider.html + signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) --- :::{#component} diff --git a/components/inputs/switch.qmd b/components/inputs/switch.qmd index 966aaa64..2e8c4b96 100644 --- a/components/inputs/switch.qmd +++ b/components/inputs/switch.qmd @@ -1,6 +1,6 @@ --- -title: "Switch" -sidebar: components +title: Switch +sidebar: components previewapp: | from shiny import ui, render, App app_ui = ui.page_fluid( @@ -14,30 +14,30 @@ previewapp: | return "" app = App(app_ui, server) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Switch - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNLAO4cyhNnbAvHz9lfCZQgGVvXzZQiQAVOhE4AEo8e0cxDGI3V3cxAIA3KCs4ULTVFIwoaWlNQgsoFhYA1ABaAFZy1VVZGlY5QrkbFzcJHLI8iRY4Zo5SFMQMhwABCbzlphWpCFk6DDFNvqZi0ptFzcdJODIROgheCDyMIJjznuh0PSYlVBsNbTiAZ0IZ0FJgAC+AF0gA - height: 200px - code: | - from shiny import ui, render, App - - app_ui = ui.page_fluid( - ui.input_switch("switch", "Switch", False), #<< - ui.output_ui("value"), - ) - - def server(input, output, session): - @render.ui - def value(): - return input.switch() - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_switch - href: https://shiny.posit.co/py/api/ui.input_switch.html - signature: ui.input_switch(id, label, value=False, *, width=None) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Switch + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNLAO4cyhNnbAvHz9lfCZQgGVvXzZQiQAVOhE4AEo8e0cxDGI3V3cxAIA3KCs4ULTVFIwoaWlNQgsoFhYA1ABaAFZy1VVZGlY5QrkbFzcJHLI8iRY4Zo5SFMQMhwABCbzlphWpCFk6DDFNvqZi0ptFzcdJODIROgheCDyMIJjznuh0PSYlVBsNbTiAZ0IZ0FJgAC+AF0gA + height: 200px + code: | + from shiny import ui, render, App + + app_ui = ui.page_fluid( + ui.input_switch("switch", "Switch", False), #<< + ui.output_ui("value"), + ) + + def server(input, output, session): + @render.ui + def value(): + return input.switch() + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_switch + href: https://shiny.posit.co/py/api/ui.input_switch.html + signature: ui.input_switch(id, label, value=False, *, width=None) --- :::{#component} diff --git a/components/inputs/text-area.qmd b/components/inputs/text-area.qmd index 8359b8c5..644e6a28 100644 --- a/components/inputs/text-area.qmd +++ b/components/inputs/text-area.qmd @@ -1,6 +1,6 @@ --- -title: "Text Area" -sidebar: components +title: Text Area +sidebar: components previewapp: | from shiny import App, render, ui @@ -17,30 +17,30 @@ previewapp: | app = App(app_ui, server, debug=True) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Text Area - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNFAB7uoUqHbAvMl84KGV8JnDwiXCACTgLC2ImAHVBC2lwgEoMKGlpTUILKBYWANQyAFoAViYYT0qoN2SgysJKCjpsvHtHMQxiN1d3IM0ANzkAIygyPgCxqCs4bt6HEHCikpZwxEiwMbZKgEYABhOmACsRFlmabDbSCnI2jrkmRY5jCEqOChgWF7kN6oBrVcIAX1UOTyBU2pQCMHuTTILTg3kBnWyqlUshorDkEzoNhcbgkgzIwwkLDgpQ4pCyiFWTAAAlIILI6BggkzcUwFksbAymY5JHAyCI6BBeBBhly0cE-ILsdB0HomEpUDYNNpxPi6ISsqowOCALpAA - height: 200px - code: | - from shiny import ui, render, App - - app_ui = ui.page_fluid( - ui.input_text_area("textarea", "Text input", "Hello World"), #<< - ui.output_text_verbatim("value"), - ) - - def server(input, output, session): - @render.text - def value(): - return input.textarea() - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_text_area - href: https://shiny.posit.co/py/api/ui.input_text_area.html - signature: ui.input_text_area(id, label, value='', *, width=None, height=None, cols=None, rows=None, placeholder=None, resize=None, autoresize=False, autocomplete=None, spellcheck=None) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Text Area + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNFAB7uoUqHbAvMl84KGV8JnDwiXCACTgLC2ImAHVBC2lwgEoMKGlpTUILKBYWANQyAFoAViYYT0qoN2SgysJKCjpsvHtHMQxiN1d3IM0ANzkAIygyPgCxqCs4bt6HEHCikpZwxEiwMbZKgEYABhOmACsRFlmabDbSCnI2jrkmRY5jCEqOChgWF7kN6oBrVcIAX1UOTyBU2pQCMHuTTILTg3kBnWyqlUshorDkEzoNhcbgkgzIwwkLDgpQ4pCyiFWTAAAlIILI6BggkzcUwFksbAymY5JHAyCI6BBeBBhly0cE-ILsdB0HomEpUDYNNpxPi6ISsqowOCALpAA + height: 200px + code: | + from shiny import ui, render, App + + app_ui = ui.page_fluid( + ui.input_text_area("textarea", "Text input", "Hello World"), #<< + ui.output_text_verbatim("value"), + ) + + def server(input, output, session): + @render.text + def value(): + return input.textarea() + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_text_area + href: https://shiny.posit.co/py/api/ui.input_text_area.html + signature: ui.input_text_area(id, label, value='', *, width=None, height=None, cols=None, rows=None, placeholder=None, resize=None, autoresize=False, autocomplete=None, spellcheck=None) --- :::{#component} diff --git a/components/inputs/text-box.qmd b/components/inputs/text-box.qmd index 5fdf2817..13dd118a 100644 --- a/components/inputs/text-box.qmd +++ b/components/inputs/text-box.qmd @@ -1,6 +1,6 @@ --- -title: "Text Box" -sidebar: components +title: Text Box +sidebar: components previewapp: | from shiny import App, render, ui @@ -17,30 +17,30 @@ previewapp: | app = App(app_ui, server, debug=True) listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Text Box - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNFAB5k7YL2WV8JkDAiUCAUXI5Jn8MOMCASgwoaWlNQgsoFhZfVDIAWgBWJhhPfKg3Yhi4b3zCSgo6RLx7RzEMYjdXd39NADc5ACMoMj5fPqgrOGbWhxBAjKyWQMRgsD62fIBGAAYdpgArERZRmmw60gpyOoboyY5jCHyOChgWG6i6JlQywsCAX1USRSaUW2V8MHOFTIVX8H0aiVUqlkNFYcgGdBsLjcEk6ZG6EhYcGyHFICUQsyYAAE8d1KVSpBBZHQMP5KSimBMpjZyZTHJI4GQRHQILwIN1WTUfAkkdB0HomEpUDYNNpxGi6BiEmB-gBdIA - height: 200px - code: | - from shiny import ui, render, App - - app_ui = ui.page_fluid( - ui.input_text("text", "Text input", "Enter text..."), #<< - ui.output_text_verbatim("value"), - ) - - def server(input, output, session): - @render.text - def value(): - return input.text() - - app = App(app_ui, server) - relevantfunctions: - - title: ui.input_text - href: https://shiny.posit.co/py/api/ui.input_text.html - signature: ui.input_text(id, label, value='', *, width=None, placeholder=None, autocomplete='off', spellcheck=None) + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Text Box + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMArhzxM6lACZw6EgILoAOhFVpUAfTFMAvKI5YoAcziaaAGzHSAFKqYODGLqhFlNFAB5k7YL2WV8JkDAiUCAUXI5Jn8MOMCASgwoaWlNQgsoFhZfVDIAWgBWJhhPfKg3Yhi4b3zCSgo6RLx7RzEMYjdXd39NADc5ACMoMj5fPqgrOGbWhxBAjKyWQMRgsD62fIBGAAYdpgArERZRmmw60gpyOoboyY5jCHyOChgWG6i6JlQywsCAX1USRSaUW2V8MHOFTIVX8H0aiVUqlkNFYcgGdBsLjcEk6ZG6EhYcGyHFICUQsyYAAE8d1KVSpBBZHQMP5KSimBMpjZyZTHJI4GQRHQILwIN1WTUfAkkdB0HomEpUDYNNpxGi6BiEmB-gBdIA + height: 200px + code: | + from shiny import ui, render, App + + app_ui = ui.page_fluid( + ui.input_text("text", "Text input", "Enter text..."), #<< + ui.output_text_verbatim("value"), + ) + + def server(input, output, session): + @render.text + def value(): + return input.text() + + app = App(app_ui, server) + relevantfunctions: + - title: ui.input_text + href: https://shiny.posit.co/py/api/ui.input_text.html + signature: ui.input_text(id, label, value='', *, width=None, placeholder=None, autocomplete='off', spellcheck=None) --- :::{#component} diff --git a/components/outputs/data-grid.qmd b/components/outputs/data-grid.qmd index fa2bf95a..6ff5604d 100644 --- a/components/outputs/data-grid.qmd +++ b/components/outputs/data-grid.qmd @@ -1,6 +1,6 @@ --- -title: "Data Grid" -sidebar: components +title: Data Grid +sidebar: components preview: |
@@ -15,26 +15,26 @@ listing: code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 20), ui.output_data_frame("penguins_df") #<< ) - + def server(input, output, session): @render.data_frame #<< def penguins_df(): data = penguins.head(input.n()) return render.DataGrid(data) #<< - + app = App(app_ui, server) relevantfunctions: - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html signature: ui.output_data_frame(id) - - title: "@render.data_frame" + - title: '@render.data_frame' href: https://shiny.posit.co/py/api/render.data_frame.html signature: render.data_frame(fn=None) - title: render.DataGrid @@ -45,93 +45,93 @@ listing: contents: variations: - title: Select Rows - height: "350px" + height: 350px description: Set `row_selection_mode` in `render.DataGrid()` to `"single"` to allow the user to select one row at a time. Set it to `"multiple"` to allow the user to select multiple rows at a time. Access the selection(s) as `input._selected_rows()`. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgBMAAzReAVFTQBKg6IubHCEFAqILc2pxBXllRQAHmQNDENzYhBsQnCBACp0fHAra4VnC4VJQKKBkKBZOiwOANcIaEE0JqxCDI7QOPouOgAN0ckTKFRs5zIl2crncpGiiH+TAAAkTLtSaXYIA46BhQeDIdDqeiWLwIsIETEqRAimKxmCoMk4SIMAY4Io8RBLhgIDFkeKinYyHw6KLmayMAARSUAcToAjyHKgNgeSl2+zIHggShgxAcgSaMD4bCdUzgSLiYrpQLIjINjgwNzDoqKvIewmF1MKDoOcAUyXxZCw-PhCho9rgezTygTMWTtjgOr1TAA5DZaxgAFbEISRYRkOh46JMGhSMTPfRFx3p1HxVDJKyoSJoVCJASk7GOaJgAC+AF0gA shinylive: https://shinylive.io/py/editor/#code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgBMAAzReAVFTQBKg6IubHCEFAqILc2pxBXllRQAHmQNDENzYhBsQnCBACp0fHAra4VnC4VJQKKBkKBZOiwOANcIaEE0JqxCDI7QOPouOgAN0ckTKFRs5zIl2crncpGiiH+TAAAkTLtSaXYIA46BhQeDIdDqeiWLwIsIETEqRAimKxmCoMk4SIMAY4Io8RBLhgIDFkeKinYyHw6KLmayMAARSUAcToAjyHKgNgeSl2+zIHggShgxAcgSaMD4bCdUzgSLiYrpQLIjINjgwNzDoqKvIewmF1MKDoOcAUyXxZCw-PhCho9rgezTygTMWTtjgOr1TAA5DZaxgAFbEISRYRkOh46JMGhSMTPfRFx3p1HxVDJKyoSJoVCJASk7GOaJgAC+AF0gA code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 20), "Rows selected: ", ui.output_text("rows", inline=True), ui.output_data_frame("penguins_df") ) - + def server(input, output, session): @render.data_frame def penguins_df(): data = penguins.head(input.n()) return render.DataGrid(data, row_selection_mode="multiple") #<< - + @render.text def rows(): selected = input.penguins_df_selected_rows() #<< return ', '.join(str(i) for i in selected) - + app = App(app_ui, server) - title: Filterable Table - height: "350px" + height: 350px description: Set `render.DataGrid(filters=True)` to add a row of filter options to the header row. Users can interact with these options to filter the table. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgDMACyL0XgFRanEFeWVClBkUFl0sHAN4RpKCjRNsRC32g59LnQAbo6RZRU2W2Q7zq7uUjRRDrQoAAR+O1BTDBdggDjoGD2ByOJ2hjxYvAiwkuNBiIIgRSJY32UGS5xEGAMcEUHwgOwwEBit2JRTsZD4dEJcIRGAAIqSAOJ0AR5ZFQGw0ARsCh0UTBAAqdD4cHu8VQySsqEiaFQiQE-1ejmiYAAvgBdIA code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 344), ui.output_data_frame("penguins_df") ) - + def server(input, output, session): @render.data_frame def penguins_df(): data = penguins.head(input.n()) return render.DataGrid(data, filters = True) #<< - + app = App(app_ui, server) - title: Set Table Size - height: "350px" + height: 350px description: Set the `height` and `width` parameters of `render.DataGrid()` to constrain the output size of the table. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgBMAAzReAVFqcQV5ZUKUGRQWXSwcA3hGkoKNE2xEDfaDn0udABujpFlFTabZNvOru6kaKINaFAAC322IKYoLsEAcdAwu32h2OUIeLF4EWEFxoMWBECKhLGeygyTOIgwBjgineEG2GAgMRuRKKdjIfDoBNh8IwABESQBxOgCPJIqA2AYisgGZJNADMi0WqAAHnMmFSBDwDDJgk15gBWJWqsB3eKoZJWVCRNCoRICP4vRzRMAAXwAukA code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 20), ui.output_data_frame("penguins_df") ) - + def server(input, output, session): @render.data_frame def penguins_df(): data = penguins.head(input.n()) return render.DataGrid(data, width = "300px", height = "250px") #<< - + app = App(app_ui, server) - title: Customize Summary Statement - height: "350px" - description: Set `summary` in `render.DataGrid()` to `False` to remove the statement “Viewing rows 1 through 10 of 20”. Set it to a string template containing `{start}`, `{end}`, and `{total}` tokens, to customize the message. + height: 350px + description: Set `summary` in `render.DataGrid()` to `False` to remove the statement “Viewing rows 1 through 10 of 20”. Set it to a string template containing `{start}`, `{end}`, and `{total}` tokens, to customize the message. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgBMAAzReAVFqcQV5ZUKUGRQWXSwcA3hGkoKNE2xEDfaDn0udABujpFlFTabZNvOru6kaKINaFAAC322IKYoLsEAcdAwu32h2OUIeLF4EWEFxoMWBECKhLGeygyTOIgwBjgineEG2GAgMRuRKKdjIfDoBNh8IwABESQBxOgCPJQlmFJFQGxi8XCGowKB0EzBJoANQE9lGNAE01EIGE+2kAF8mKSQPYTQ4mCARvs2EamjLCnd4qhklZUJE0KhEgI-i9HNEwEaALpAA code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 20), ui.output_data_frame("penguins_df") ) - + def server(input, output, session): @render.data_frame def penguins_df(): @@ -140,7 +140,7 @@ listing: data, summary = "Viendo filas {start} a {end} de {total}" #<< ) - + app = App(app_ui, server) --- diff --git a/components/outputs/datatable.qmd b/components/outputs/datatable.qmd index 62638025..f086f981 100644 --- a/components/outputs/datatable.qmd +++ b/components/outputs/datatable.qmd @@ -1,6 +1,6 @@ --- -title: "DataTable" -sidebar: components +title: DataTable +sidebar: components preview: |
@@ -14,26 +14,26 @@ listing: code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 20), ui.output_data_frame("penguins_df") #<< ) - + def server(input, output, session): @render.data_frame #<< def penguins_df(): data = penguins.head(input.n()) return render.DataTable(data) #<< - + app = App(app_ui, server) relevantfunctions: - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html signature: ui.output_data_frame(id) - - title: "@render.data_frame" + - title: '@render.data_frame' href: https://shiny.posit.co/py/api/render.data_frame.html signature: render.data_frame(fn=None) - title: render.DataTable @@ -44,92 +44,92 @@ listing: contents: variations: - title: Select Rows - height: "350px" + height: 350px description: Set `row_selection_mode` in `render.DataTable()` to `"single"` to allow the user to select one row at a time. Set it to `"multiple"` to allow the user to select multiple rows at a time. Access the selection(s) as `input._selected_rows()`. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgBMAAzReAVFTQBKg6IubHCEFAqILc2pxBXllRQAHmQNDENzYhBsQnCBACp0fHAra4VnC4VJQKKBkKBZOiwOANcIaEE0JqxCDI7QOPouOgAN0ckTKFRs5zIl2crncpGiiH+TAAAkTLtSaXYIA46BhQeDIdDqeiWLwIsIETEqRAimKxmCoMk4SIMAY4Io8RBLhgIDFkeKinYyHw6KLmayMAARSUfKAdPaRDlQGwPJS7fZkDwQJQwYgOQJNGB8NhOqZwJFxMV0oFkRkGxwYG5h0VFXkPYTC6mFB0HOAKZL4shYfnwhQ0e1wPZp5QJmLJ2xwHV6pgAchstYwACtiEJIsIyHQ8dEmDQpGJnvoi4706j4qhklZUJE0KhEgJSdjHNEwABfAC6QA code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 20), "Rows selected: ", ui.output_text("rows", inline=True), ui.output_data_frame("penguins_df") ) - + def server(input, output, session): @render.data_frame def penguins_df(): data = penguins.head(input.n()) return render.DataTable(data, row_selection_mode="multiple") #<< - + @render.text def rows(): selected = input.penguins_df_selected_rows() #<< return ', '.join(str(i) for i in selected) - + app = App(app_ui, server) - title: Filterable Table - height: "350px" + height: 350px description: Set `render.DataTable(filters=True)` to add a row of filter options to the header row. Users can interact with these options to filter the table. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgDMACyL0XgFRanEFeWVClBkUFl0sHAN4RpKCjRNsRC32g59LnQAbo6RZRU2W2Q7zq7uUjRRDrQoAAR+O1BTDBdggDjoGD2ByOJ2hjxYvAiwkuNBiIIgRSJY32UGS5xEGAMcEUHwgOwwEBit2JRTsZD4dEJcIRGAAIqSACpQDpsU7IqA2GgCNgUOiiYKCuh8OD3eKoZJWVCRNCoRICf6vRzRMAAXwAukA code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 344), ui.output_data_frame("penguins_df") ) - + def server(input, output, session): @render.data_frame def penguins_df(): data = penguins.head(input.n()) return render.DataTable(data, filters = True) #<< - + app = App(app_ui, server) - title: Set Table Size - height: "350px" + height: 350px description: Set the `height` and `width` parameters of `render.DataTable()` to constrain the output size of the table. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgBMAAzReAVFqcQV5ZUKUGRQWXSwcA3hGkoKNE2xEDfaDn0udABujpFlFTabZNvOru6kaKINaFAAC322IKYoLsEAcdAwu32h2OUIeLF4EWEFxoMWBECKhLGeygyTOIgwBjgineEG2GAgMRuRKKdjIfDoBNh8IwABESQAVKAdNgnJFQGwDAQKMgGZJNADMi0WqAAHnMmFSBDwDDJgk15gBWFXqsB3eKoZJWVCRNCoRICP4vRzRMAAXwAukA code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 20), ui.output_data_frame("penguins_df") ) - + def server(input, output, session): @render.data_frame def penguins_df(): data = penguins.head(input.n()) return render.DataTable(data, width = "300px", height = "250px") #<< - + app = App(app_ui, server) - title: Customize Summary Statement - height: "350px" - description: Set `summary` in `render.DataGrid()` to `False` to remove the statement “Viewing rows 1 through 10 of 20”. Set it to a string template containing `{start}`, `{end}`, and `{total}` tokens, to customize the message. + height: 350px + description: Set `summary` in `render.DataGrid()` to `False` to remove the statement “Viewing rows 1 through 10 of 20”. Set it to a string template containing `{start}`, `{end}`, and `{total}` tokens, to customize the message. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACVKAG3jtUoHMBXAJYQAzkwExUxOmSZtiUACYB9bhH5DhAHQj1GTYQAsh2MRKkyAgujxM6lBXDo3hcYcIGkbg7dtXqRTAC8svLKfoIiABQAlD7Q6EqCQUyCWFA8cEo0bIIKkdpMhSkCGEKofGRKEHycAoT5kJr4TE0AcjUARo5MxDS2xADuomTETAoCwqhsUNhNNgBMAAzReAVFqcQV5ZUKUGRQWXSwcA3hGkoKNE2xEDfaDn0udABujpFlFTabZNvOru6kaKINaFAAC322IKYoLsEAcdAwu32h2OUIeLF4EWEFxoMWBECKhLGeygyTOIgwBjgineEG2GAgMRuRKKdjIfDoBNh8IwABESQAVKAdNgnKEswpIqA2cUS4Q1GBQOgmYJNABqAnsoxoAmmohAwn20gAvkxSSB7KaHEwQCN9mxjU1ZYU7vFUMkrKhImhUIkBH8Xo5omBjQBdIA code: | from palmerpenguins import load_penguins from shiny import App, render, session, ui - + penguins = load_penguins() - + app_ui = ui.page_fluid( ui.input_numeric("n", "Number of rows to display", 20), ui.output_data_frame("penguins_df") ) - + def server(input, output, session): @render.data_frame def penguins_df(): @@ -138,7 +138,7 @@ listing: data, summary = "Viendo filas {start} a {end} de {total}" #<< ) - + app = App(app_ui, server) --- diff --git a/components/outputs/image.qmd b/components/outputs/image.qmd index 4ee44655..49977fc2 100644 --- a/components/outputs/image.qmd +++ b/components/outputs/image.qmd @@ -1,43 +1,44 @@ --- -title: "Image" -sidebar: components +title: Image +sidebar: components preview: |
listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: Image - preview: https://shinylive.io/py/app/#h=0&code=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 - height: 200px - code: | - from shiny import App, render, ui - from shiny.types import ImgData - from pathlib import Path - here = Path(__file__).parent - - app_ui = ui.page_fluid( - ui.input_checkbox("show", "Show image?", value = True), - ui.output_image("image") #<< - ) - - def server(input, output, session): - @render.image #<< - def image(): - img = {"src": here/"shiny.png", "width": "100px"} #<< - return img if input.show() else None - - app = App(app_ui, server) - relevantfunctions: - - title: ui.output_image - href: https://shiny.posit.co/py/api/ui.output_image.html - signature: ui.output_image(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=False) - - title: "@render.image" - href: https://shiny.posit.co/py/api/render.image.html - signature: render.image(_fn=None, *, delete_file=False) - + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Image + preview: + https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhHqNWnbhjLZUcFr36DhASRgBzACJQyUVeuapbbADYcARkYFCmABRdVNjk4JgBefxcACgB9GJoOVzg4gEosKClyVVU0VBilcKYldItkmlclaSjVJlqijgwuVAUyGMJgwgBrD2IAD2qwdmIAd2V8JjGAZTYRoyhSgH4xiQA3KArQiIAVOgU4FLwauuLiFubWvnm4AcvSsZSmAGIAHmfVFOyIWRpWORW5KJNFoSU5kc4SFgGFgcUgpRBHWoAAUysjojRgVyerwRTG+c1KUThOLqRgshRAYxYdEIY0QTGCUgA9JStNgsBALMsJmBhhxpGQ2LTuQBGAAMotQvTGAF8sW8ICSSVIyAo6Aq+GSOD8gWQMENhoSmHBXJCmAA5UhwT65QpiVBRXL5DgQv5yD4QMDSvDgaDwajsLhs1Ac-BEUgUKjIDgANQAQgB5ABKw1FAGkAOIWYgiHMiM2TACqbAAogWLDmAMLSTq5sg0CsiACauZEhAAEgBFABWAFkc6mIHBi65ix3o4mACwAJgUAC9pJMAMwAKS2U48jYUE7bxfnpmGwxoLAsU7ghDIAEcRJ1hR2rwXRcMPB2RBfU6KoApU420BYAOoThWHiJhYbAAFqoCIxbCpMADUHB-sKYFmt0E6pm2AAyNBmtIhCprOEAAGyEDQPYVgWbaLqgAAcAAa1GTI20gWJMiZalOGETmwACcXaJi2uYcIRPakMKtFbKOL4thhpgeIy+6mAJf4iBWqC0bGNC9HQ6BwGaUBmheXYwBhHZ+L0xZ9i2VjDCwq4sAJQ5dmawoMIuwoeLOhEWLO1HSImrjxlO6bDMQqYCbGhHpp0bCigJfjLpMHBbD2f6EdGGFWAA7AojLxsMy7cX+1Fdp0ABijIZVJuYKKV3GpsxLaxsMi4The2DRploo0BeCgQLBvRtrB0YVhAHgrI23Gxoy74CSIChWHVDW5k1tGtdg6ailOACsdBdjQbaMlOBYFrO0ZQJlXbDKYpUthYGG9WBrYCdIhGisQooEY2mWEdIbAeNRLDDDAdAYdIy7DMWVgtsMzmJselkqXNMFFtxtGZdpdDxm2NCimavTcQWhC9FAIiMqVXbNi2i5WBOAXDC2FaAaKtFgUJYGENxsHDHAjJ0GBBYsMWZClQoU5+LGIj0zmPZWGQBZ0KYUO5hYZpy64znENgEC0X4g2xisbZibOpgWB43HEB21ENi26aEW20WxVTphQEl8bMbRRs9go2VmvG2B+FFYFbAKKxbZTy0WH4nSoFOAlWBWKzEF22AsIue3RtIGm2bOCgXltXYWOmjIeMWfgVlVIhWNgqYoRLuYdqmhEcJlxbRjsCgsGQ1HFrBYEjVA43caT1GNsWdc5sMPbcVs8O5g2ECFe0EBG0OkyMguNDEFwHhWLRsdxVYXZ0wJE7poQBZbdIKwXjQ0bq2BoquIyFgToy-nxsK6ZR1LuawW2ZD1XLLmaypgJx0GwHALYWwPCEUyoIaiZoFCdGLJlDC19ZwwHjB2WijJAbDALHPEQfgfqdCao1RkqBEo0ETNGeMChCKEUXKbWccA84cELm-Hs2E47UR7IWTKcULB8TAhAPKMDUBbTllACqO8oA9hjh2Xo1FqJxWGJlOyAlYLFm4qVGAjZUDCgvH+Xef4PB+BoNNSYUAxSZUUkAkQfZprVnHpLNs0hSpTgHnABa0ZRTClnBwUq6VYyZTbBOPwsE-yMmovYnMkNlxWFibGSYCgoBbTGnAWCF44CTGEoyWc6ZUxgQvCsPywpiwCRYD2QiBYBGNUbLRUUf4wKzhYKVWCfhmoYTbL0MgRVsCmCLmBYs2YWylTYG2SYEBw45joKmOAHA-CmF6PAYUwo2zpisIyToChlyGS-lsNsxAkkWAgJMLsj0qoYVjAshW4kPAQAUDALYsZIkcDoPoqAoMWCTFiSIP8sZpCAIZuwQiGEWCJggClbirgmxE2FoQUUy4pxhVGbmaMMdJidgZnQOg5ythuzYB7Dwk8Y6lRWFOXyF5aKQkjr0a6AlUwAOwB2CchDhTRj-CjUqVJYIsFTBOUUE5pDRloj2QgFhGRhxuiC9MHBakCVKmBPwBYtiEToIuNQ0ZuKmETL0DwwprkYRgFOYU8ZzIytzEy4sLK2WVhEMKaQZ82CdEXBUToZo2DxS9aKIOAoLyKRbI2WMBZiBTg7BUyswx0yCGwB4Ggf5YJzMbF2LsphowQyeT2TKYVGTFgsAQls2APoJPsYrVwGKth+GIDCuAwpei0WCp0ToEBkKoyJtgLZrgLCEAEhWYYXYNEtlcOrRM0gSmLg7LOAs3FGyTGwNRVViYPCZQvhUqqZFsAFg8IrINGFOgFiDsQQahEoBQGjNRZcjZ4wsAMjSuAkrRQHr7cMDCQ7cyuE6H5VAMBlxAoFMKNg3TVUBpjrOaK-bcwy3IrYpWOZGx+FbmBOCUBRSZUBT+bAPZgmhPCZE8plSezyrqctBpxYWZ0GkFtNyWxhi0V6CwYgUBl1+A6heESiqSxTJmSIN9TcCXMVDrBdMQdRQ9gvIuToIEpUMsqcWYj4UwIYQLImLa6YWCZRnKA7AjrSqzjNAWKdhFGwEZbPZBT9SrDkdZoRdm3FHyYeoh1UqGFEyZW7YW4BKZ305jbK4MCY72NbQrIuRjVg-CZSsKmZcxAZ4ev4i2cWHZj4tjgLGNgujCDoevnQGAQcVY6cZJlP8PZFx0C-omI5sTEkrC4Jc3MbYtkcBWPuGACg1m0T-G2CGE5CIXnjI2LaGlsDDDCi2eMYKHYCW4sRUStEVii1QIRXksYthMsSHQWijYIDHKspHDgFyRBVUa4uGAZA8oXmjL0RcYVegKGwFAaQmtW1WEM41YYrgtozwEhhP6iYaAmuNIVUU5l0zSFgteUUbBW3YOop0Cs1WFAWFQKYaQAk2xwC7OhFY0ZYKRQyF2RmjZYIwBQX4S8Rk-AdjCSwODIgVZIMer2nMUNMqTDmR4LsWwKioAnMMBQ6ZMdQBQaYGgbAOyWpzKDUqtrCGmvTAWQiiZWkmv0BWRsPY2wWmwDAMxYNJeVz4XD+Mt0o7RmQ3QP8qBGx-r1RYFgnRlza9bX7EQgaVIdi2F0E3ysekeK8dIAm3dhiNgwqmIlqdaWMmFI2TzOYkwdlniziwW1eh3zNFtHAi5aKepYBWRM6Z3IDNh8QBHjVYJsBR2jqysEvxmh7FtKc8ZYLTL-MWMCNh5FTgnARjdFYVUyTpxOcVF82+bT5ctmAIhSptlKtIWcpVTARIBRXUmIaUss8ia4NsU5iBkFcIQetPZCnYEbM51z7mC2qLAj50mrg2CBfkfWtMFgG2LgvGBTbPYH1+ETBG4BIgNAwoqY2AksuY8YVgNApUXKhEU0uc-AYuZoFYs4dAW0JWvqHgCgiYY2wCE4cWPuOYFgbY1EbUCgt8eOp6u0sYjYjYXU0YbY3+dKjYBuxYMcjKiY2Ai4HgzuM6seIgwscAs4kw0YdALAWwb2c8t6W6JG9ObYnWEApgyE6SqAVgjYvaNAUUHgUAO8m8VgooBYLitkNSMhlcf40Y0Y6YSaL0HstEkwFSOCdAy4eynBZYceIg8YwssuOYsYFgi4iY-kGqxAjI0Y9ecYKwW60gxYGEU4NAWwtEDBCyZk-+UabYqA32LYZoYEpUBYtEUAWO0gQBbA0+BSoqs48YpsvEhE7uOYXWwBS0lYuKB2Amvh7kwwkwsYugF4jYWw-kCgoo8EnGC40yAkF4y2xAtSxYNUcAwwYxIgmURMTuU4hAE4y4f4VUikGK6Y1OZmpgb4LASQ3E30Eiy4Fg2AE4pUhE3a3Es4p8xcCyiqFgZA3GIxhEHYpw3ECuhEW0E4GEIgvQLcF4MWYqP+f+kaKk0aaR9kYyYEIaUALSt63EnSV0fgHgvQbAZoU4AE8OZaVgrgP62xuYLAfsqYxUFY50tEBY0gah8c8Y50MAYUZsPyfyeJ8YWKfe1cLA+gZoy4KwUg-KIg4EjY9UF4vEooVg1EiYsYG6Vc26u6uYxiWRU4jYU4MA8RJAVgpUFgF4REpgMcwwwoN0VyIg1EG+OYn6rgiY18i4xoWiooGEFY2As4XYHxtSBYLsnGDEwxRahEIgokNAC2U4oxIUFY0YhAbcZohARmJmYJUujMG+pgsYQSaR1aXAtEs6HYsYqYU4B6RizUhEy4sEdiuY6Yfx9UpC0kqYqYrszEtSjyBhHAwwpUxAwEAUQUu2pGGErB+8uYpgTyqYtUHUki-W-JZAYqkwWw0gFQy4vphCxMsYpCP8vxW8jh82iYWSrxxAVgwol4E4MAKwRMYKTmUpUGVgr2sGqW6YGWSpKpOehALyKwIgKwiYfSxUnQB0msfyRyhEbJUGsYUWhAqAYpXYj2RKj8VgJuKwUWXei4oo7R0pBM55uYcAAppUcA0YHAhx6qqADYfgE4HYkw1CAUi4MasSjMfgEo3ZOYfgcAqA2O78ew5cSyNYMcyuRyNO1sOY24E4YayRlc7QYKEKAUewZxPYE4sYci2pUmkqW0Eu4Ui4kwxuLYgEE45uWwx6eOF4+k1EikmU9kQMIMC4x5LY0goo8UiS4BFYNU8Y0Y6J8YqUu0DY8Y6S5qxmKuZoCWuYZo-O76DYpqUABYKwf4+RWwgGRCJAqFvQcAvQsB8kWYcuhEtcP8bYsYHg7ysk0CdZsYJUU4ZAmULsHAjIHsjIbYmUpV1EGEFgwo2Am828r2BhLYMsJpeUPZVgHgBYy4lpF468o6gGnQ8YeMCgvQoog03MDGHgpUiY7S3lqAolbYW05V0OrgxURSt69KkuHYNM8ZsYW0pU8YtEnky84koZg2cqwof4EAf4W0ulEAMAW0KwjIhELAMKbSdA3E3EjIHAU4sEWw2S6ubAW0hsrFm51EK+J5KqiFOY2ApUCunkupwojIbeHYg2NA-pnQrg0gXwSphE+S3EAMfgqA3EZoqAFUjIfgKwhUAUMSooiQkwQUb8v+UEXmhAX2UJDWambpYE6Yw0m2nYF4u8qsHgUSe8Cgrgkw-RvQagWw1EfAWWqYHYzG6JmJ3FZeOYikm84abYLY1EqY8YJJrgHs18MAMA+4vQ-stsi4jYhEsEC+sE7+UAXxAsQsIsMEE43kMAhAk1gU6YE48OSlJJCiYJ4p0A4K0YmSbYGQdAFYpgxYcgwoGQoMf4MAVgi4f420CgHgv6aGfgWwsEVgF40gqkbAyxU4Ug0VWyNlq+OM6i5l8e4W0NBYp2EAf6WwvQJUKSqUi4YEU4GNNxZoeOzetE5ULMY0YEHgFYYELAJAgZcAiYU4WyX6HlVFvQKwzxLYD1nQ70n030v0pghACgWws4iK04VgsEe+vEv0pNvQ8YjMMA5Uo+EqooWOE99mz6iWsEnQTOXmdAYCKcbYdAt80gPYkp2VZoXYqVhENAQ2ZAZoKwFAjIsEnUs4501EZMW0g9l8sEkw6u120EQNXY+hLixAWxmtuYooFYWOtEXOFQMA9Y0dhAsBW0LApqpqKwHgWwLUs4s49UWwCg92i4BRb4U42BKVcsZAVgLAoNUuVgItzV9q3EZ0DdQV9UhAsEpU8tmUGNYEFtVtp0y6wsnQYDaAHgf6U4EAIgbYMA260YLWbAw2FgOBTYpUFFvFVgdAF4+KhKxKpKU4bYBUGEXY0gR8sEFibAF4ZA0YZ2bANA1E8aFi1E3EGEHAUAPDMAwwbYRMbACumUjYqVHY7u1BZoFF0M1aOALAfgN8IRZoV2bdqYqUjIjIKwfiU4HAi4U4ooKws41S-I46GNxNfmsEZAx6na2A8YhkmCsOee9i6YgKNc5ZuYDCIkcALpjCkddDDDKwF2HkVSl48YqAxFV12dCgxq81jY6YkwqYDaLA96FgNAAyDjwab04aYJFYuK4GfdDCUAHYQU8ti4ZAcyaic9WSLTkwF4E4KwGEF4F4Zo3EItstHYaUPYGBCgbADjCZGKMABJsyGELsUBCgCThEKw2Fpg4qzpsDItnBLAHg6YvQhAr1Hg62gTKDFMXYGEvQnu8YfgzpWTbpHAiqzGU2UaMAsakC0CsCqzMddAcdBlBY1EU4zkNAsEVGi4mRBsHgW071Qki4P1px0gtE8YHAJVhLu0ByYSSSf4HAYEqOZmpUb4JpnQoo6S2SPYRGyuLAbY3sc46YtENDMKPEuziJE4kD71F4ooZAkm6YrgJ00YFk8E9xYyUApUAr4JMamsekGEaFfgZoGY8YWwUAvzb4+5W0cA+50YvUUA+1kIMAPYO8pAFYW0MAG0fqoT1RIgeJU4P5Uj0taa0YhEhqsYdAHAzrhAXYd2ZAAz2AtEY035g7HUZOPDfg2AhEG9jYZR8YnQZ20gru7uVgGEyUfVLYf4pUO1ni-wPiUOBY6YHhnZItxb7RXYKwsEU4pWZoWw0YU4X1s4+dFYxAEZRiydfgFRZAVRAkeJZz2KUusY0tCsbDGduywwptakoMulW08YpNGE6H5VbKuOqotenBf4wwU4xYwwaSz5PKdYjGKtIg6Y49szLii7IkH00y29bAu9+9h9QqgLZ9I7yiuGmUHADSL7raFYbYyUzh8lfkAkPYZAIgXhIg1BVgnQ0YaBGEi418SCJsvQT41LKwvQ0gfgMSM477PYtJBYZAZAMAjLjIXY1ECgtF6YPYTpuy+y2dVWSkeWVrhJZoHAqY7A0giCcAtmzrHArr6YMAs4tEk7iEKwllXraqz4osrTZAKwnQqYMAwSrmHgZAXYEhlYGEkwDuBB-yxYvQHiypqpfguEl7ub-Dv6hbcAk7WwXYmU7jOEF4Jorgs4HgkZcJiY+Y3EHAooryYU9impsFXplcTYXA9UcxU4bcAVBHrgGuXYwoLQHStEqAmUHxIpBYkwrdi4W0jIKNNA04pg2AF454T7qO6J6Yf4mUnQvyhCiYCbC5c8IzScKcacAD6aWVotF4sEhVlVzTrTl6E4gyuu1pEAW056vQNAtE-OVgM9aeHaXaV+uYEML7SeOY9X2+u+qZs6wDEAHYbsMA3Ei4KnXdT2u3pgqYbD56773st1o4aSAs7r0gRmy4wHLYqRqYHbRCTUZ2eU30xAO1IgaSfzUA3eSdicFYeVVzHAqoF4zX+xoo+Z-OyqinwcbAX49ODWFgpgq9E3ww2AWOZAqMulqA-WQXiYM8qX54xFvQxAjYjZrgwwF4U4y4woNAUK1YPYJY6Y1EASf67ebTry059iv2fgBvUMjI7OqY6rPKdAfKqYr+2A4TF4LA7Wpq6dyOycRMMALAVnpvWElxFYvQ93fIrqjqs4bYS+kSZCLOgBw0oBP8TlbYORGQ9mPYwofgf4Wxpgjeyd0gndFyvz4dv0rgworvnif4E77ObPPXZo5KZAWwnQGZVMr2G+8YsYNUMBcBRtrgtDZoCaworgHgGmcAmUnK-UjYGO8YGEYZvQPY90qArSqAsYqAJWZWX8HYH1eTc8aERTNHoUxwCi0fkwwW7qmisCmAmkjCRhH+j5QW9fkt3UUKTR4YQtCI+aDyPGHMC654wQ4X4g1lcYb5fKwoOAAFT-BsA8oi4BNkjS2hikVgYECwN9AR4a4XoRzW6udzIBThbMieYZMQBFiMgDyGEI8sdiAjECRApqeMA3RoryNqI-iRsDCVxSZQewerbiBpmkBOp4wqMaFrfCnBow-wUADBFsCgFmh9EMAEUushy4qRJ03uFsLfW4iJhgwVAlAVYA7CoBuCh9YUIRDrQl1hQiYDCKF06AsAhO9XToHxwE5bAaA8LMCOiUmD9dBusEMPrmGXAGsk2ksHUsVBEyZQKShAQbKA2VKpgWWsgYUJiVbrUQYAmULYGaEygdNFkjcVULFljBLJ1UA2N-rc1GwthTApgHJOBxEDLgRodFISnAHVziolcrSRcAoCLaZR4wrSKOqh25JmpYE8ArUvzEFhTEm8oJYBOVRgxKV4w58IOHACgAaZhOK2WiEynWAWBXAooN3iwC-jTBYGM8REq2ljDb4oWsWY8AnkDra0dhuYYfPsLUonpNKrgW0m+jOSTBfoNAZOglWjDp9XAO7VMJ0EeKSZ2gGECABOGVZsAewpgDpEXiwT0RsS4BKwCsFo4tgaAhEaiJuUIh+AwItEMgGGR+4gtckPbQ1AkgqGtUbAQgbiKgF1bChyqvhToGGTFQSopUzBBqhWBoCyk6cjIVwL0ETDlN-ggeRpH7zdgiBG80gJYouHjC7Ausi4UwFRGgZqQtC2UDwFJn7ai02ikiZfhCiMp88-MsjRGA9QdZWAwIxIqkof2P6LcsssYRcCph4YTg0k8UZcKJQ6YtBX+7-dMKF1nDUDSYN0TzNZFQLpFCCbYVGK4EsKvUjoHKYgLBETDLgu6xYLYHAFSgUxcYDSBOI7SmIu0OwmUd2rGEWJYlKOFYWMHDAsAIxReY6YGEwmCLSBvuR8DIObnoCgNCAi4Iupsnz7CgYAvkQlnJALAf9CA8qGeBwCTSwRGwYlClFfRtgVhFoczKGEoGJGc5uctnPnNgGXBtg8oF-b2NWy0HEBKheeLdOlGXAYRR6csBQD+xEhTh9AZdRkCpiqj9pCWiYxxqKFUrqVT056bSpVW4iC1S2s4XKuExXTTNEwXYNeGfC2Dpgto7GRkMuDvAxCzQN3SoZz0RjcR9IL3ePC+P7LmpfsNKG9CbDcylJRCZALwfl2PAwRhgMwlAcBVVBZkiOXYLaM7jAhbtpYovSUfahFSpgAqMgi9B9AUEiAuw0yKeHPRfHQsuwsYHsG4y2ipIIAoMJ5AWACHCMxoi4b-AVTUaeYKwLAWMNIQPYiB3E15crpVxzb21raemBgXtQ8CTBnRtEQPLoP0GGDnkJgjIDAD-yeQOwpmCbusFdxSwLAQSP8AFAFGZRzEM8ZcC8KHEzC3U2QjIG3nwSoAnC4aCAJ9njC7k9MDdUUPGD0Q9EKgW0EZEGlewB1pYFYPYnQBsAYQPA7kxsMAzDSgMPAqAQ-NwOHGEBSoPPbiCsBYABJcoE4JNO4zYC9gJwfHKAH0HwbRV3cDYOOsuGIkiBUwfZNsE+XpbowRh9DV1hMKmEzC88pgD+E-gmzqJwcKwlngoDZ6eQOeC0h1M93r6rSlAqYNBO-CJJsAL2CgaMBc2uSZdTOpgZyK4GgRQBW0EDfVphD8BWAdqtSHJuwgWnnUtoHnWZNTy1AiwEmCCD-lFk-SZQKwxVFYMRzoDm4AhpUWsSlRWDLgto45c1ME3VyxhA2z2TnIZjo7tNS0yQsCPzDVQrBNUX3OMEfBBZaCmBg7ZVlsC6zmN84KrTlAoFgi8kJeXEhKmMypzsVh0WY3ng6S7CkBwB0CNrODAQ6niWJOcXSh4GkCJ9Jg6YRcJlCUSJ9ZYRNbiKJRmGwQzQt1Slm2FnB1tHBbYeqMQAiQcAHu3hCwAoHOT1ZJYUAnAE8X14KBUoXzLYhLz+aphi41MXOAaxoCxhZwy4VANyUJy5RGEfsToFFG6KTlteaKeTtHEoq3i9aBtbUrbC7DphU+MDFUK4ApYlw2AVgZcC3PWyuBiAVwiTD2GLB3lQM3eXvD2Wgayd-ktEegoGVKRWAqmvVVMKxigCKcvg2NOAM2BoCEByAJoUqATXMSEQyAC7AsLbziKDwpoqYEKKRlohdkzMVZHzmwGgapIJwEAKwJ7JilzF4w2UBjJlDThIFD6xAYtnQEIizgmBxCQ1FRnf7RhSs5WKnB9T14HtuJyM3jHsmrIWA-E0yC9CbG1TOBXAmUJqZQhKHDByKDSCcK3RUlCsfIrgVSKTgwJ7z2ybuDUsQDWIkMcwQkN4lYAJbZ5xCVJGEhTCfaktCA8YPfCt37Tf4OwLzT5CUOjCOo4eU+OAAVCyaEB3Sysboa2iei5dS8bATqEHDVAWAk6p4gUWPU2yoAgpU4SeG-PTr8BOCbDNKLQJGQixhIE0UwDoiOwtgEmo8sga4A8TPYdYiYQgOmH3r51SkI-C8MZGkCmTfZlpMgGiS949gXRnqYsL4tVQBVGw0nBIDAqQqV54FSyRKM0RsKdMcA6YP9H4FuoYgBp50M6BYE6Aalu0VRHhltChSJgBR7ixkNDIba+pg4iYANIQjxzRgVp1FABCICTT2Y-EnWPvmg21LqLqIvikoX+F6ANleupgGcJUPSgmomE4GQUeKmkqiiGsd+e0TVgfyuAMImeCdjK0GzFgZJjYaRplAv7phWkWGFKOmF3aEQoEMwzoFZzUmc1L2uklYMCS1C8tt2vUKvFTAwjetfY2APKhYEIhqNmedAYsG0naxi0HUHeFUhwFohaw+JnadCFsBdLZMFFhBe6IdmZxyd385yW+DlGxZdhxW9DceudhmLdFJ6edSYB2Fu4QICwnQO7GaFnDdF+8XLV0jivpyIJlFBK70cQCoRuYtBA7KpIQAvCJglwNAS5YyruweAswW5Uybeh6itMJ+sPeHnq1JyxSKcMAJWROFpwtgegmDXoWaB1yay-w2suDnrLygzDvYooaQDAHhp-k-wzMeFl2BUYQByaUU+MFTR6iNhiA+sUUOIWlJyxB89qU1ORClWGx0AakXkLvG3JgQ-wrDUUOsJEDTw4SKE5cNRDDIQNOgKlHsAR3yLxZoYbYcycWRuSJgwI9JaQBcLAhfjGwf4E2WQEnKGdeIo8EQCSj8B9sKJz44sE5QgDJJZwf4YIY9EjQVhxRSbBTj530CoxCIxAVABwAlV0AnuUgLsBpjlgrpK431KwMQCdVoZdSAUbAPDkU6ZRqhRyPwIVElxQzZwG+RJGBDTyuAw2-9aMNhB8VJh++U4b0ZoxH4Gxz0BcNgGslh7UQaAYELfNIAUlvjPqpjAhlVE6QrFExNMY6M0laTtJOkdpZtRhD-Cqg4hxqKcL0GNKv4VgE0tsGBF8aQoUOpUZKHeiZJmRZMOYJpY-HtEAd-CtEToCuxoD21IBpgSltS2LA0BcqsYHRC0AnAGE3ZgE89asXoQcTCOA6R2WMxMjKzcwFCbALzwXbRhTgJXRXFdROK2rXe0YCdqrAsDejsWGdNSYRB3hwBpAalOMHQHNFi1bu0ZAAobDCmEEFokwdWMKGICtJuh37CMhAGZpXLZwKwcpLUjugKACwqsKFsIIlmoBbIlVY3sLlgwHoXEjINDGzKopbRowHNVpKmCyQz06YSM4MC1O4jFt+2wsPfI2A2orgFEEAK7ANixxoSMIf8F5Emhnpz1tkqPHMKKFKgOkwC9OZvCSUJzkkM4Uko+DRRSRMi6kOSMEDACwVaF9AJQrEULmF74NXkvxIBEQXOqf1vC7SKANFTcjiQiOg2R+tMhzgHTZheYU5maHxr15phOdQpVtA40nL+B3sV9ndw7Bx56pPYDfJkVohEww0SQD6V9J+m9A-poja7QXhgBdhbCdADwKyUwiNYYZ2TVKqkoTLChUAxDBvrciZRm9OSlvF1jPHuiWzFwxXFgFAHs6mAKwpUF3jHE6DUQyAy4XsF7yBgiAZFANV3N9FMDBT+0WwSEge03H+5T28jc9pexhHhNgRTDdlXABujzp1R+Hc6qKGDYoDMJH+UUB2AYGE1CAB5UwGTCcUhzDFSeEsjogVyN1m6rde7m7AsBD8u614s0KbOChkw30GENSM+L6rQbEdq6P-JIX1YKp0Uz6xwd0ALCq5hhjYCMohDIBmwuNaUEyFYD-AVgrVW6ErMIINTWUFCZoU7rrgq7LhJcp8wEomNjBmFP4eibuVOETYODUAXddrMKF5JtZFwbYQiG9XJSMgiFs4aJC-BEB3w3B5emHkZFKhX1MRxYaiD9V1JThwMbASDJLHkTNjLImyA0jd3+Cm8JJIeNTBwDOrlZNMu5JnbXobBmgqWngs0AoVJqXFc5FYM9Reu9nXqWwp8yYO+iL2JgDSu+LWF4o-XdjG8y4X5l8Hl4rJFuzBR1LKqbwoMZhVbccQmtoiAliAwJSOJsIcSvhtJcpHwtmLvjlFZVjILYLwLNBLUVgLwy5Q0wNIbqRAD87iMSXhJv8sdxYTurkwcZ4kYAvPL2H0tghdhZu2Q0cHkO4WEQm64OA0lS0rjyREwNKR+OdDaiow2dUVAmETBJhkxutO7SYD2H3aIxsthYQKieHhqI1Tth8c9LAigBwAPA14GmOmDtmNMys4XSxdGGsVvaYIRU3oJsshqihjGNdCwNZU80awtYXWU4WBHmJrg1BGjSIuUVeQ55LwJoeibekxG+Ktg2WgPkQ0ZDC40U-yWMGBGBSVh-YpAfVCvSaXnpTira2Bv1TYCMh0wF4M6rt3LAWdTAyKQgOC0LBndwR3EKwAIDfgBRP4NCzZNgWcRRpCy4COAAmnXKNh6pz80zouCah+dvZu+X4rBET1Y6ShW0RVoFpoBuQKBk0puFACIVzT8JPhHbsoqkgsBEmete1o6zgBW9Wk7rTKK2gtaj8Sy3o5VKgD6SoBBN5m5FnEsi1QB501AqaCbDiN-gP68CoSCQEY5n4BUmUG6FCsmIRUxa8LOaIuCAJQ9Tg4+6KNgFNqNtNeHS-2fd0OxbHSo3nE0pXKNom065sDJvINKURUsJpOYdzJ0Dd6lRSBWwX9NREDamBAtGCdOakzJ3daKwJkeQz7gbBp5yI-wV6gWGgiNokwe+GEb0nmIA4Jw1EYcdTgPDphDBzSCBDQC+jcjv24qIxLdUGkTQ+6w3Qgt0LywqKZYUWTkgoF9ipQIAXYKATFI0jWckC1EWMHwFoiWa7sEACRJlEArbVUxuIjsAqyxxc8swBvY0ljiDHAUYo5Kc9EF2FCFR2cGECgPsq2y8ZUw6iKmR2COaUszU0YDPVnr1y56MizUd9NIw9gx1S2CDKABeG5jQDvY1A1BMULbCC0KkMkSNrTgL64VVQGET3nTIfmtKIlyJyuBYFqxomcw7YWCDfL857BAuLrVWOsEICuBqBq81sKpIUDbYfId8J-J6nhwsAOo-fAbuKUkZEJM4XhanZfy+x1qn8NxOzSwDUnLg8q-DIcxFxaiSl7Ia0vwFtEIidZH2E4sAxwF3iQHoDv+ZIj2EBTyw5SiSTKHstQPNcLeq0DAywGeSNgaA-0DwHAE1RN62WPpMSHjB7BfRKZnzRIWr1vncteVylHipGk1qLhmsp8uAKbwfC9AL2ObZUoghwC0RBNiYaZeWBAKSIWAobCoI9RxyXoiCnQW+AkSYKS4yAooJuo4dVh3xWzz2Xgo9DOVmgM8HgMJh72i7T5vIm0dA08magQBFckKraCzxYDMQHqy4BxhVSeLjcrAw7Bc2hmjN81iAdmvZmQC+ABMNGntYYPHowVdzqIMcKAIQB7DSBlU4xCchUFRTAJ+ADChvvJHATxpE0yac057PHwcdiCfYpTCWVez+lGQb1PjtRChRbA+c30p8y1hWQGU4KwCA9ArDgwWACzTBqcJ4fHm5DypiQF8RAQJrtJhQ1BEssQWbIeBs0fgWcLBAwgMJCqpw2AH90T4rjYwEAHKhgYayno0hvMbAFqBoR0JJ8T8tdlljin2QQElmmgMGBZjGj-JE0vORWgXy19fZ9iAwzOMooVQOASUeZT+0KjdwLAYvCRCwF06XLygbTIg+KP33u1H+g9eaA-LrYtKm23ZxJBwX7PGlL2qYX3rRDoAs8JsNcvE1wPjCEmYml5LsDmFJwsA3etTZFezkIDDA9UozCAOQEn0-wpoiYRSojFC3+VeTBMAUx8uFOSsdodAPGHdUcpF6R1hgiAhbK1z40+Z93f8Jt2r7EAdOBYSXDjAcNbaFoUUs0O-lvjvrvmX6wfoOA4B1ptSpgZgoBB4nGHnSv+Uw3zTWwWgzOLVkQHGJj62DEYQBMgWMKeokHhgec2G+1DP4nHFLQK5sL1Nggt4hsGecNDFFxkJsRb+DNfhNxMpsEVNpUdyvbEMFrAJwcV98F9W4E55uD7VnMNLVQplEfIH1R6t9J7DM70mr7BIoslgPU7eeqYA-MKAnBPIdYgDD5crcXADSPA9UuMxhN6AfUt+qHcxC+zAj+xZwU4UwJwbvC7xy7lwicDHHmmkYPAgAnMAwhCh4tnUWwAhmqEmAs3cqXdU9E9EXFN3hQAzR6txGFChHj8kW4CE3UsnwycwJussnXBMnEB8yDeb9QrZ7BaxNbVwjpBY0KozhXAGQTCfTFp233TAtIlDgvLUAdhe4fgU-mUQqKC3gE5rJGdXh3FTcCOn1YUCnTUaDYCwhkFgBODSwXhdYluG6IQGSTgjBpiTTKP73q4YRgZ2DcpPWiDsEMUiAu3MMKEU5yiSk1m1GFDjiUqjNMj7RbtPjYAwALZPEwiFfWwDsqhxpwjuZtm2w0Lxk3EA3i812geoJxBiNgGBMM2W5rcf6JlEGtGwo5LCMEJYisT-C6HRsxSTgtGDNstgQ2FMmujbgLBKcr4FTUdJbq+RwXKW9TMRhOETD9oXmqYWMDSkSbZWHB-mKttyRUJ+xpKDG1aWQHLWsoL7Xe1CvtS+RNSqSfM37lOEbvWc4AmbMTU1BtYrtTEHKXYF8qtqQrV06yGHuFxjauALwehq1CGsy32PD0xsqkcKCgQna6BZy5jv8ksko0mGATbOlGPW6Hwa4ScaKLBDC3WPhqTTkNIeitzFg1gN1YGVALK1bBlwIhTJ32qo5WACiUtAR9RHURYTrut3NVPkxyalzvS3FCYlMV-ocAzQ90biE3mpOEBGQ+QqcEUQqSMgBk5+fwUSgXNEGIAnZ0+zKmoIsrw7kNBdb-LN7aRgwK2NsCKT-AXgfIqXXeM2HygJMY4fgXq01zcR7q7N5ouAOq3CyoAnyyRa5E1R-iJ7X2Hil-b-jf1fr4wX+iA+0H-DmNDuXglOuvIO6VoWsWbXLAFNeLBSRAtOCtQ2DAgWFFcrrN6nlD6r0YJTFtTJwoFgbcQTN5jGAN7djC+2OwMUN2UcPonRPTAe8rwiWSyLWV0SMDTGCwA05o3-IM4HmJMGIAmR6YCgf5Fo7gDvsIA+3OcQWAbwQBSohAU6DGxgDuVpIcZWRhYFbhRSpLqsQolw7RzTgkgewTNvdx8IWX-wh3UlxE2llXDk+CHG3P+n3UNlA0JZXoFfcJLEALw4Keiuag7C+KWYmoshwNPAVowRFc0PS++yMR4cCORHAMfrUgdmxhVsSWBx5yhimApuaOTTHNwJlThFuKkydhoz2iaQwm3SlgM2DbD95RQpyHu4zuXDUUsF-sRRMDFBglXcuHYS2+set5LVYIBNXxGJDrvuC+a4KzSBCtKi8HrIKseZTlF6sF8uwTezTSu3jD8K2sGFu2XGyx7jIkjOYAZtFh0SK5tpGuXaa0hlf0wZYi46kTcbuO3UHj8S545wSgBvG4qbuYTjxRIbWR2qdAG3gfmkDYAWxkq9CnDs+RWt7SjYFYNwDQmdwpwM8U4mwEI5IsUW42fNTFGlh-lobakT3k8iFZHjF+LQKkWuGJygMgpRRPsJMEmD-JMoC6JnYPTOKMhft-csfT3nXQDnBo-u+PF9gLBcaRSYmMSL3zeLyMLwb1royOxlnn6+w4yEydxCCGtJRp12eFrpYLCuBerUQzyFPfqpyd8FLNFsHd3crjon8CNNg3QKJErpMjTYcB5zCQaFNESFXOAB7rDTZJZ689CTrmEXAVhmN4U6MwF4RH+QssCcFjr4rAgSnPEBlROt0hEXgD-5NAZBJqj7gic87bUcTovUXAiAyvuKp4q4FFy45CI-oi8KBugEwBYBZPJ7I6rIDVaoY5+2FaTVaRWdsAelx3mUXkPHvpAO5kLApQUOJIBQklw5Vq1XMVhVY0KlYBUEo9-kTNN-Q+sq1nAx0IATmIqZ9N8U4Z2ERcP8KG+K-0yUsKsMb64e1h+Bfv30hMx4F+b5laIQj-wuWH5RQBgmdAGcNCxWCZEnILqdMHLA5VrudU4HkQL+lNVSRX01cLvJAVFQ4Tvm2NNsF2HnBgNuBttWOBUgSmEBVoWViAIJx6+id+vrhFsL3H-FbRUxKMT4ttOJYaEy+YEE2d6uuGle+wW-GPlfBYCmdHkO32lpyurSBkBsQ8BIFdFroQBy3lcFLvIl0h2VOD5p0wJaeDCgxOg2AaQCSiASMg7AXBEg5ZoR42a7LZoyYKNU63EAN6pI2+x20njmwZ4zeP7mBDrd2SEfn+6QGaknYbUiEFgCVzvYXMKEtIe0brsqk7PNtcCPYS64lihduQxo2AXfMtg4Cxh3WTz1DjQFg1IvQqxYOgOhmlruFsmpVepn5lCHv5q+gbtgCu16LlS4jFCdxuBxhheXsAZBZdPHMjrEBVT0YGVYyGG9M-DEQiuaFYHRak9X4DpDH00n98Fg3n2ug8gT+k5u-rwYPhaNzh7DwR6ocby9gm9MY5N1RTU7uCpAnBaCvbBY-ToyGQJe2vcBGJYI56GKhlgRlg4y4UK4OkSKwwRAlCoAAmonTzah-JAjKWs9JBq1YFtFRRi42VvrwFqEShKITgJWCeD5Et6LAbiwkfOZaMgF4BwBsAM8JMAqUOaGWY2cATPewEmOnPRiUswwEAjuY1wiijmscOgTZE22pKTZT6Y8FXDxOiMCAKZQnvDQH0k8HKnw2sEYBVwSmpjkAj-wDGBaBzgLACgz6otmv77cwxLvjRkukaKfLqI6RNRw6IXKObo2alupMDW6uVEPyNg6fGgCEcPhORizgGjBxbgYr8F4K1InaOczFIpSI-qB0eKAVzeE3RE0jwk6GimDYaDXrKzOBQ-IrjcQbLGyg24tUAuzpgWzOQo-oxYFQrVo9iHpAoQwnrxivIZFtzDL6IOFw6JgvbFOBkOW+tvjOkkdJWB-gbEB8ieqpNIaoKAZwnJpdgCmkZBKahqtbDUETjOHZQw8EBQxUMTyLQx9ysBANLr2kphz7xm91HXo5qZMGBA0Ay4Odgw+6XHozZcVUB4QyckgXI7tiGeBwCtIsWFALAyTUoLSqcYWgIhos1EH4Cw2LvlQbAUY9OHpT0H4rmixiUjOXayMisOYRBwqAKeLYAdAOsCRQaGPOTFsvQIarcQRbCUKFGnziICOEQ1JrqKW7QKmAewyTC1h6c4dFgpHI4pKe7WuF4KZ4qwOWuN7UI9LLzAqm9Hiv5r+y3BeCb+XWLQak8HGmwAw8D3vlD8iaysKLSoaPKpCz6OYEqjKYaqBqhaoOqATxE8TqohbaIrDH6qBo++h4RTgGlhVSNg-xDtYC2SAplDQMtEFgRGUZEKSERqcnGsT6S+kGpD1SfvvZr5cAfrdzpQqfuMjQAUABVwdInTCGQ3UDEBiCdwt4JaivodkC2I5guYhKIwIYbLcYZwuqFlT8WranOArAwCmZBu4w3vmi2KlRvD4d4CgGBCZoVbDmikw+aIWj2k+xACG4kqlNWi1o9aDRY-SqALihMuYSKBokom5O4RNCBSIYKsIpSF4JDWNfrkTmCS4uNaTWy-FJDXoG9E8zSwvUK9I44eOLKZmmFpl6I0A1pv2hQwXYIyCTWwEMGASIvMFDjMOUUH+CzgpAuVK+hrckKF9C5GhzSF4WwdSjaKu8D3C6GZoJOy9srmIkjzw-DChzbYy4PqgWAOFumG3yRUCVAHQTvkAgJknctjo5goKEGL6oqAALAYQZoIRCE4-sDODaM1tNjCmoeeHAajwhEO67CkLvN6KiUSTBPTfEieFGhIo6RFyYKM-wLe7UQkkn3DLcf4ETJd0InFlRQkqEnqxAaGjONB3UnQKYySOZABhT4MB0Hih-hiZB-yYsBOtW5DCIlJKqusMDAjqAm0YAEyyM3olbSlOMyl7wU0fqsgo9QWRCS6vY6xGQC1yxwfbjVqoiHRivwrgmQDkaC4ZjjZoXRhqilQ94f0qk03EJkwzE4MB+HaRPKryy5gTZH+AdstOJiYja2QpSQKCh8B0zKkjYCTyxhsIYRL24UMNfTv8ZRuqIdiW0HvTgK+dneT0EBkr+aRo1kARFQkEBBlhcoKwGOLd8tnsrZbALomqDM+wyBYDoupgJxCZQakgjqvImkPGioAWoULb2hgJqjxlwyWACHCcF8BORyIqjmBI72F5nlTd0QLOByLiFiKnBDikwIhBf27So+SvoNhutAjINfEXqhQtEHW4RStEPYxbQ-BHOBvyU8KKDUQsIbGBdAkwC1iyQf4OtH0wIBC+CgQH1JCiLgVIiuiK8yLtjbG89MOmx3SmUCQRWAEbHEJtgiYIMag8i4LOCoAUTCJY+aBlvi79sGrtGB+AhAF9SY+mZMrAFQZkpIFtgbAN44iIeiNCwzoYMUWpbQ6co2D6Ss4PMHwQbpGmgdg9MBYCJ6tEMuDPIc1MJA-0m3NcoFQ5KvFo0eHQj2b68mxiziPUUBmJAzh8jIBjlhqYPDr-cLAINJUsZbtTH04fcnuR-gJMVDLu8C6Lsg9g5MMWBsAp9Pwq40aOoGhtgevKvQGm0NtSiHo9AObB8yXYNTiZOrpr0DUipQn+GCC3ELfDpmHPFFRMuoDMYKmArgD3ppQt3DzqB0WrJbaMwOCA+D6K8RB2CfmZwotx06gZH+BEEDiFYBe4F8hLSvULAA-C1MUpLyCBU4XJlD6kRniICDGU5rIzhIYmltAuif3AwhQRtvnxpqYmBFfA2UTUjSwlkfYNzg96r8O5RN0SEIyAYsD+J-Bowg2IaQ5g1MAF6lxeUkpxow8NBLzqotvk0jIKggG-Iy4ZWpnr1UC7BhB+AD1NTHgK44mhjcSObIuC9wvAqwTsqx-m5idQ6kFJCEAy4GQIkYd0Mvzqwz+tnj5xNfhYw-sUesbIXIoGl2BsAI2LRDi4bKN4gcAVem4jki5ACuYuodCFXb-0bmDBSSMhDrfHKwxfubgLOzUdMhmgg0dxDJqqYNow8wEMlJCQQraPPEPyVGlsDHSmsJ3TUIjNCpC9ADpMcGYiKmHpYtQwRPVzsY1yJSwk8GOMRBt2R2IkhEQCenDpoAhAKjgYQJuLfbSsRlBUjxgQ6I2IqoRLnIRpIOaIohiOsYFCxfIWWI6q9ATIR2B9gd0PZiIWYhMMAkGOdLH4ZxNigoDDAb8JbIooOvP0qlQfUktBXQ0-hUIXwHUnDwdhcgG1hnUdTmwBX4oPLhDsafHB4CGxYtLBCRsl7PCy7A2QlSI+KNCgNbsaJQeLD9cLLF5TiIrpo+D+wtEMFzJQnBgag5MWwHYRHYEsOZwj60FgFDkwgMlvDYKbYI2BIRlcHgSReDomMSsKvZCg6HsSNL2x1gtENeJLxDGLAAIwCgAmCeQtEImAUWuwKfBb+T3BEZz03YLW4yo1kBp4Q20eFtBuYX6C2pXMWVGcgbI0VKkhfEfgoMgs4LULySEQCIiIiWJnQAwLmJmUNQjWJSQv0rTySRvgqowUtH3SYwu0R8p1OCFl2DWkygi0yUwjWJsFRMfQRdz9E4STmwYC2sKPS8sY2HwmoqBug9TEAxAG5Ao0EZhIrKiZoGT46h68BhD1SP4NwGcUxYLVCHcxAPWgKAv+Pka1IJWFYAQA7GFwIT2uYHfrpE-jlFL5aWoJj5fgCgWaCqJGJHLaZQEroRDN888NmSmMhABmFpYWITKI3eLAMKAvs8jNICt03EOQAhRuYLmqAC1kIMa0QjclBGgw-pFHQx08wJtCtIUULLpAIJoMvDyMvrovYfU8wcAGRJkwgtD-wrnINrSAGEF4Qc8DAKyqtI0fnAC3KhAM6pmcf4AOBDSFRlOCRuksGHjlspgARAYQMLAFDpmgMuO7e+kZEZRQyi0EAi2mwwObjs4VuAW56obdMuB5QmNNepR6pUCHiq03EBWDrY7lFUjbYo0kRznMxNn8w6ulMMuATg9MekSYx+rKb7wMocH+B1WJ1MgrpgGzA6ZeC1ECTD1hCZOHS5s8qcEKXmunrOLyo-cJvCm8qCGfLmMpQClgm4W0GJ7tY1vgmh98kph0Tw6U9s35e4ZEEQjXgmUqDDEQ3qtEpmoMPr1gQxR4JMxY8BkKZ6AQnQOAjWxg0G0wJsjhJSyC0LTBfzFgJZr7xwYzpsvQoI6clsBD+naFAC9kU4DBSSkUkIhh1E6aWoxKcFEPDQ2UfkJbpyszLNSLxgDaj8TeEPfOzjbYQUs2YpCvxOAJhkATNrHfJhfsR4QA3igoYVgcAOYL38TXJ1L72mtuVJsArSJ-p7UiEinTWu8eAkbp0mTmrapEE7GW7kwI9mXq8e2piIAcgtMLIzDCexGwChaoidgDKSRGKKh5wQgCbKzgxACUFWADaJ9iQIsECClhJNFnanRJCMSRSEEflguySBEUHAieptwgVq9AKpGoRAuPtNGDt6EAJRigZLcoJCpEVYJdBRUOAbdqSmVxkOJXwNaBOAi8UkNxI9CKGSJioUiYFuSMIY2lwqC0yulqK5UfGrLFSwAHDPDv0ooO0qeo2nr7yEA8mOA5AxX8NaQGEKGTTAki-5l2DRgmEtfD-cjemsBoOgqMJoqgL0KmAoOiYKczeE1ENrG8kDnnyAI8PMKeodQ-LtWBxsXJszCZaqRJBHpgwFD2wzETPHpbQqsKlYYDaR4OBiNgAmTTCNgjuK0GokN8UL5WOlcCxLkMlyFDAmYWTASwrAVtLfbwuQrBOQqh+xDZS3o1WhPB9CtoRKZtg0qYJqL+M+MWAGCnQIhZpwqWizi7sIcX2kWE8ELyQrcoLEbyL8P7IUgQAr1hUaUMkwMPGWSoaSKlbQdxgoDZWIgNHGpcqALBCwAy2Ewa-MqhBLDTMxlm0abos6niyN+KoMvAuo-eF5QOmHgL4mFob8lequxTdD9H-w-NpGH8K30NGBn8+wRPDxQQoYXBtwrgFV6ESDCBgkmwEZsmrSIz5oIkG6VgHKxPBggE9xWAWoAWrgKb4VICJgdAIyB+EPurxjGkKWNRxZECuIUZGIS6eWph4DGImAWcXBDHiIQGyZf6TAaEeOgYRNkBODvI8Wg-CmAykCpAJxy4MjLHgYKLSyZQgbBJickT8tAIxo+3AEK9An7FuiWQ1BCiF3axYChw7WiJFuipc6UFlClQfgNaR1okaDLD404VoxoFgT+prDZCT5IMhuwu9FSzew4dGdTj6eEUBHEAFRnlwdg2AL4yk0WKGsTqo3sA6aOZ7ZBYAFQEgXaiN6MaJ5l90eiFiitm-mM7nBZdauxhhZ7OpR7cQFSNZARG0SDqguieWMJxkJozBYoVSPZnOibGUMPPnEi4KlEyJ81rq-haQ6Pk+Td0HEBTAypc6IRoXgOifTjdCCeq2gQAwwE+G0Qp3KWmTAx0l1QsAP-FRiyUadvHDvpqYKWBoMq6DGmCajMOKifMjeBtwqCSDJiQIwYlOmA1CHgO7xPUObEcxW0+aMzxrCqFEVLkBenF4ROUbVLkQssdIgXSAyWWGBBmoHgECpQA1EFUTwOMMHLRowlMWoQ64BYAz6hs7kFSIaErtNbDSMcCvA5Tmd9l6LXwhOdIA-ovjOQoxC0gOvDwQIqFsS9AQCH4BQQhiqcZ5ofQHsB9B-0DFCwQcABQnBJm+fdACqVFHAAosA5Mwlja6ToyKRIsenKTsZKwCvR5s6kBODDg9XMWBBQvIKTD0EbpG85ss8ye2D8IlYBOBi0tEFtBewWeB4BHiJ4nohYQDyBQJmceTizjkUzwRyg92GNGIS5UtBEbzLgB8pBoVo92MD5Qwi4E3ySwDYO1hNCMxD3YW0RHMeKBpdat2iuAY9vvBQwAfGkj2cYGrwh2EMkGu6VYfMEIAxMvyt4R5Eu2rxptQ6cPvZrIbYEVGigJXtlA5wunOCEKAGNqrTz0Peu0juUk0iwCyqctLfZFCkIG5E4Ul8h7iXF7+LBADSNnmg6X8bENUijQFtNhClgPhGnZFwRNGQCiU5iK4CIk8qMajdZUtN3yigmSI4ooZGWjXTlA-hLF7tYsEHaQgFKhKwzcEU+jLDyUCEJfyPirulsC4hemOqKs51aHUkVg3th5yQc-8kGYGpeMtpEfJTduhR0FZPObB1wCnPkodID8imBQoGElhKxgn8LdwDWgaLAF7snJtmLlIaFH3Q9qmqVBH9oVLGpLL0m7A2rG+4JBeCgmsFIwFT4TYgPHYqwJYASq6NdNsioAqyRoJqg+eZ7KhGq6g8gA4MaWq58U2RhnSAKsUmBCBeDeWlwZQLcK3mBFfshAR+A5bmRA0AqYABS7pqUGgoWA0YBMIQA0EC0DmcfDj2ZuojqNSagISyK2gF0i-u0BiQTzo0zTEIxY+TAEgqYARx0bpFWJceEXCRqPGs4P9iQRInNtBdUzYChmpglpFBlpEsGTYAIZPmZto5gC8mMHDAr7DHSTUM4Mth80GyH8ywI1yoNSEAFpSpa5gO1nQCigZ2N5qZ6acmniVR9pBBHRUCgp4if59Mq6aER9jNRTiFlBX8I0F74soLJOjBcrCpgV2LDyASjeJCKYMnntqGm8G0jUm+0isBAB6ltCjSkLWq6BsGWhkpEIBd0b8h4APItECxl2OsYPNrtI8lBYrgxnJQ4oVgEBt6HT4uYIhhAoS0Ihg6IsECugEsoxAoC4mCAdMih5ipptiJgFSJTAZQ7TBACsxQKQWCAe3SLBAnqU8P5CPsnwq4j6sn9Pgr5g2uVkg-R3UB3DUSYIRij0x-6HMzGkiCDeDSy3WMZZV2OaugrviN8BeC7APYCWFw2jsK2mlQQ6BzxHIKBfL4eAFQPRht0+ssxjKkh9Oelp2-ILDyFlHiBEU4JZALOCH88qX5DwQoMT8hGU0yR2whUZAI4JnKgeH+C358tPWwVAyNoTkcqXAi2BS0EAOyES0qBU+YQApfHnJSY-IFrx2IDYIBSOENkUtiMYNzqhQzEv2bFjqi6otGYeAEiiDlxIhUAyxdgE4OqHQ+vFvoRhkKNBQJiB2YgKzaIciWgwN265K7xPya0l3HwsF-HNRbwnQJZCJINVuiR7MFxNRCwMDELBnW4oMIznfJi4MQBIR1OixkcmzGZrDNw5sa9R++qaDbFcig1FKzAQ9Ct4QTg++C7pu6BYEgjxgvvOsgxGlGDIWRobhQfK1wRCDTDQEBgo+gzJJkfNotA6iT9Ge8rNHTkRIYEMgj+InJO-zFgchJ4Y3VoyPTJpy6RPTK6i4CN7KM5cyHHZPyy4HxoFInnrUrPwUJGRAx8QtiwCqMq4DLzBQU+ImA8Q2qAax3UIVnJxx2Q6BFA7YugH4Ai0UYkWDeVdqo3icwHYAVUqaQKmwWMMX-n3ZBwJpKpAOaTSJlBBS0NaoQkiZcOcRm6nBqDBZkWxIrxasSTGdR1or0ANrhIrahSRbQHABATHiegkPY18IqOvCvUkOZpFp2mpERbGkiSIejFItPhVwAKeYLkjcEpUJKb7q1IhwCtqo4CiVHY34KKAAOr1pDmrQkIlsBvOXHi+Zy2MCNRTyVfodx59gCGIpx6WhsAAwioluoexR63EvwwBKypFKQlklcGZA8Q3zorDnqYENAzoiKYL2D+uAKPbg+0zkDxAbSdVBLCbogFlDDTMO1BQ5vgv0NxAqUWVN+l4sEwgXjewJkKAQRQ4hLwkLskpmsiokBlig7cQWEuWIUovHmHziu-LE1DrFQSqgpOUd3E2A8SFvHYAVculJEJ3wwuAboqIZPq6j2cnAH6lZExZa4DapzEMD5860taHidAFRckWjWoLPHb3cgTEy6Lio7BbBZ19MA84pURzCDR9B7AKKBYO5DOci1y68CNhjYieun6juGEMKpRM-2F4L9pO1LfI4Sy4K2gLoegkIRk5l6JmzD1olKhItwpAtGwfKqYF7jd8fgp-BfZdaOXBQwaqN0ov1IgNuHWBcgMVjPxCauWpUgqYCnIxw0souBss4UlzRvegEktg8wPmTMS6WXYFCyTORLgxr-+ZbktCMgsYCVz+SPpUcS2InKcbKoY0gHykwAMPNJzykpUNckMxUCBVVl8EbOwwwMIpNqXx4FYCixtGUMryDdst4anLQMFyEfrKkyyDVbYACNNuQJswDfJiIiZetSjCckwIAo60bUITz+YSFIOjIy+NMbzXVz5iwX+1a1aVV-gZnCaDlwlkNfTB5TDFWwH0W0AEAEs39JhXmi-UJiqaoKVSzgQwMiYGzMwn+DUXdQoWHCLPybsOnXpmY7LkHX2ERSUh5cnRYFpww8YDD6W0ifOFwEso8KMiMwi9mMHryZhZFg7WpOGwBLgWoteGQljRcKCmAcsQmFEQiCMWDGMF4DBkFgnaLSkEanPCbhDmcNZrQfULWOCp1gVrhpzcQ4IXACDUyur+izowoBhaFVk-G7x6iObL+hYYE2XKgBIGmJ0DkUcALjAJYTUJ9iERRAU0gA0hVDqnRc0dIcKqGDdlW6j0+hsni64oUdtiU2FYCkj-yWiFlWO0wsH0TA+TUEpwMtG0CzBgMnUjR4OI9Hl3RjZJjl4KxQUsOEgYgyUB5Bg4dZbSGTWG3II5ElMMAlj9oqYD8L-IF8I4JEiyEHWpNKSBNgDIQ3CteKt5uSDP4WgIdlDD0xcBU+SLImeAqzOinQAaXvs5qJsp1sKWDDaqVivKBo9QwBT5mGQQLd7ArAI+iI5dEP8HYkzCXHgSicA0VSvySkotmJoz13EP-Ch1xpDrSmef8PYnfUELBdywQVvPWx4yZ6YYUZqfHHdQQWxWHdQ1FkzQH65IMRnBUNgatPQrbEzJaMS-QtZAoAZkbdBIyx6sYK5hIaYmsqgFpQLVZiiOAQr82EQf4LdwA4MSCrSJw6WSPGzYyKUAQixyohTDKsUAAhEhR25CMmxItkAE7bGFOl2Bb8WCb3E6uj+l6zZMKWb62fwzfIkh0AFmf6Rpk8Oj1BBcPmTDq7g55roYHKpeAGEJhQ9dAwkxycHWgw8UisPb8ATOfN7DArOWIzBoRCHQGr0C7FtBaaXrOdDjUq+lDitIXAuWU5gCgMPpuQjqJFSEsmUFwxBwAUbsAQsMFEsw6IHUbBAJJjsBEhvgpUD2B-uE-O5DeO-bOmGBp5sHgb4JwCFuiokfsP5REBPYCeAcA0ZqbyjghaBgkR15VEOa-REDMi7xgm0ChDd0FMBpLcQ54MKCbctiZPCwQIitADOAy4HhABNDYACWgwFrDWAZkieAGHXQcfJzjUBNnRhAKCWVK2rpgjYMCKpIs4GBBO8FkhJgRVRMOmAbc2iAmjgK+mSNCwWe+Ic6-B+CsVKf0l6JmlBw3UOeCigHyI9D2a6LZiSCO-4g6S1Ou7k3Td0vQMFAQqWVXY0rA56t1Cqufsq2lN032E4aBFNcOKjqIVpOeH0xUscDCjlrHn1Xxd8pH-SbBzyFsBRNVVWOhZcEjFKTrF+ZAuTqpq2L7E2aFQDjnYAAQjlTDVoWr2ysMvpErANgs9FoUTiVZqgB38YhNQQ5iuDk8osopmNZCUBlMFPDZE8ibkTYKpaadochGfP+UjqKVlZBaJ0LLqyHOoMAUTaSCZSEimt1LXGz0yN7oRHotVboJQzg5qFRzp0YEOdC-Q10r3C7USVFqTpyZkCsDBQp2CryQqYLObFkAqiQbFCQKWBzzYAqRijTaoHsKDi0WcrP1hkxaalSDAUhcflDkUZWl8qDJgbZYzFYMsDSlSckLQbFsAp+lLAc8MIBABp4sRIVBlh4ujkysB9hZMCdY7KsU2U+GEEWowA9xWAwhJSnHeQ5MUdAtCUkTuS3hkAHYDWDaUbxEOFlw0YO0hbA9bVwKNtLrPWzJxAQg9hsA+CO8VEQ8YDAgQhCypk4HZXYN7UdQ3XYHHzN+YF6TaIsJINg+Mt8E+SPGEEE3ZBUnXT2AcQ9RFDJ3kkwJzglk3fLUq5yUUB2AaCFQIpDZgLYn5yy4PxK37YAoAraEXQtcTLGC4mohAap8dAInhSizaG7zIo0PsWUDQ54f4Rp4b1MLi-EUML1gqNbluAIBOB-F8qotilgoAQdKpF2DQdRbHIWkdCOJZDU6kDDWjEE0LL0BE0VPdRAHxR8WYlvaKAufHMwm3UQYJUO3QRxNi6sDe4WKtRRYyh4datcl5Y4uSpl0APYG-ATcehF3LGVG3AUhsMVoQoD8KaMGjBLk9OH5Y75RBp2Saw36Y+wfgpUArA6FDnj8nFghEPwB-RZcGtjgcMsE5BFY0XNWBIoavC8LftMCHYhIGUyPVi2m9dRRAoC0YHSIE8QPp1yQ8TdmQxUu-OBFQiYzvpFQSQAKDdVgITlA6liMEhPaSUu4rgoyTOXrL2xoQdJa4zGySpFcyxdc3ZxQhIQ4rlQgZhsVrDbp1GgpmrFSvYGjjIrJF6RewoUNGayVFAOrgRk3gqlDFIT1DGlBqzijLLncg6IdAAQpjEPZiot8G-CvUkmI9k7srGSbhe50NEjU0Y1pIDCvYTyEOXYQARfRKjEwORuiVw0wLnJeFELKgAYQremBDqdsDUCURBCnGMFMN7COUzSy30LihR0XCBLzXwdEOmx8okwDtUi+Psfnwqkw7BOCPqkCHDmxgxbVFqAYZbYoNSQZMC42uF25JaR9AkUK2gaEn6jV6tqatjV2hUaPJmR1Rp6MCLyU0RLpIKAPHb5AcAf-F-5+Qs8Kow0pIFPLAbqGZNaE-IjAS5jZZI3JQKfYeMGmjPh-ko+o3xFCecoSEqTXTDzwGAkime8Z7WilcOGKaNAxEgOQfiu+PZLX4JkNKMuBkpiYBSky9TYm-wrDeLLYZ6EmwYkiJIuqJqmjEgBUnwp8u0G6SOqjIKzBkRbcD3VUUbuCOpsMTOVwLW9WwFJKs24hMEQA6jYLSPFYJxErDCg-WsMD0yFYNZjw62NMrkVGq1X1S-QjTDISL9-DJFUCGehG9ROQgFMnz+IbfGbD50LKGFCD1AkZrQbuCQGmjeaZANlr2YNBADQOeSEF1TrccAFB4ywXuHv1RU20aJbgDaujCRHerObggcACOA2B44ibE1ArQ3FFDQUWAfllicjQjFoz9cflu7ShaUehQK8UTQgnofILnf+izgEsLfaadKoHjVWOAuFmxLQL0G9AzYeAlrwv4ptFSMT0EVTpx74qbudYDoT1PaycAPMJ5DVg6aOJg+MKKDQDSydULmBwI35J2C+tUyDTwb9QPuV3jah9CLCtqq6mAOCoBAizgw8SnJAj5KzXa122N9jaQIAKOBDazOIwwP2hvgQYlliQEuQb-FV29Eh0wrco5DZRvF9qJHKlJ82vGAVJBkINI72krKrmqiu1M3wvdpUBuU9qL5oTBDxf0ABBPOPdgjRG9ZOUQiWJfuRFyW4NQj4QVUE1dYztASaB844EO1mpqdgEsHY1cZvMBUCC58OJmzEcsxUkp0GLhQARzGbmB7HDVBYIFqD0vFlVTR5v8m5E0wxfhC6MgW8M9XoVe6phXWx0RFOA6YdAqZ704wmlfSQog0AnG1JtmVVw1IYbBXWxJQCLnTbpS0E9EMcpedBY3uERbO4a4l2MigWRGEGQ6EQHzlRwtg8ODKnYAKCDGh8cTro0zdWk1nQhBNZPDOR3QJOIV05qF8APB-cxk7tBQCBlgIAF4cxtOZiW9iNfSesrI7SriNcSsgTnDKdG2BElCCJsK39iCYxoxwWoC8Ircl1KsOJgu9LjIbDHronTbDdFQDidt1KOCGsFVWQYG5IhEoFrYkDYOloYSRI5Kh9Y79VdQ1gJynQAiwRtaJN680gCxKQoC7BbR5YpUGYyAy6HFfDWkvnVRQuK8TisROYVOb1nNcNcRaaTAMQttCZOrdZR3hw1kOcR-SaaNFkKE0tIQCiJzgZZrpML6X0IDdW8m5gH8cxuqgL+qpj3gE+N7Tj7ZElEw3wH0uhqLJmgEpidXTAjYHoDaEWHcQC6x6BqGkvgZpmPFuWpQOdE08D8b1C9UwuXRiWaIAxEEGQn6OypkxPfGwwgtUAiKjzgX1N8l8lDYG2Dy8x8IN20UoneJ0X1UnXQBsALvv-Tn56wLo65gGUE-wvt6YNiL+8d6j3ZWAWBekOu5L4Gkzxg+KvDU6IaFMJo9qDyI8q1y5WGoIS050OAPUQkuMMK9A-bYwHpQLcuBCNkJNSZl4R4sPyhw1U8G3z-diiXLTVjqhAoWLen1BD1QY5DLqymDVIr-H0Y-ZFjjdoXAo3oIx8lW4UMV1gMN6kCDdHkSgw6PgdnywbWJ24xCBurTEzhnBqdwxpOPrGWrmUCSLSs5d2KwMTgegN9h3VlxYch+wIYSsSJah-auqPFFxGQOMjeYBQjM+8DBUimA2lGSmtIXtUAy6eaBA-SadnMbQ3uEYgEvV9CpA+9y9kHXIPS0C25ILTTGqUNi2mCqfgPbYobXjDDyOaMPkaEQeUHaR8gFMGPSAyryB4A1qWKO2QQALHHTCJIzxt2nBzBRGy36pFgKTweurHmlxBCsFjcjWR9iBzyTAGrjhwXcSuIQB6AAA0TNI5a-NZDL+wxDDBmgyWBiQUJFEOAYwiBllICjRMDFWT3jiMD3aZOUABZaUAYZKEZfSarORgbgqVAmFwAfsAqhcm5IuCMop57dCOYpBfNzKHs25A2AIwNWDUjIom4MIIzKfgJJXSVITnJWbCfgEqiAIi-WdTyw6qDpzLVr8UyhRSU5nwEuMqBdxDLglGGQR6EfHKQMWAn5gIbs9F0KwoBAMqe4RWAiYEJIRQm8G5Uu+nlS3W06Naq863ez6it4VwkHBIizZgCiNJcEBGgKB9UWDqZz16rSHBTWQMAC9lHY-eF+2YIv0OX5VTVXYvxPkvzCG5fZU4EhGtiFgLh3dKZcMXAo0T0eOAlQUUGt21VYkxOCty2c0-LMN9AYwGuMeqYcIlgbqB3BaErxbNDkohyKOn2xfQYkxkwgyLFNVuEmAzEZkhcDtpPQ6HAsg3YXtqFoRcaDtloIjRJbpQMYNagWAfTuYOqIEcE4lvOPKvcbUhy0U5TShRwUSPvZiaDiA6Q9zuYuIRiF0Zt+XioIBFSBNIOmMqR-Mk+djVuWLIv9JkAOyJTQxQbYD3yUYpti+C3C5ktRw7UN3PMDpaKNTSJ8QJ6XQAdM7SIRot8VgHQE9geRMuKtIXgi7Ew+dfb0TYAAxKnngQzHsaRkWb4URBUgg7KqbL0JcJ-geuCrFPpJx+nCRCw2H3kvPoirqdGB3lutPziSobmPqSGk4pCXBsEnebK1oV9ANtE7lUUI9jkAXwA9TCcFcDuwNIdBQU0dSnmj3aYS6Efuq0eYUFvzaW5VuYzeCZHbkS6ayia2r50crOCHkqAzHQD04dOM2Do0jSMKD3OVcBiT4cO5ajjRgQdWW204QI1-5sk1kNpSawh9JYTZIW0OOIv2-RDWrZoX0N7C2wpkxXP5QD4iLiD01mS138jSTMEThE-M72TOTqA4BBdk-+KwphY-C9LJBkn5jvh7lBjTERA+KEn2gucrNpzgzEHAMdWrEPhFg4eokw3PXHQEsNZDFgGiKfCkFe9Iuo+Mw4jRb+YZhJTqqc-gqxiakO027gqj1CJQyHOT5kcP+OmBKcPSA5w4pAC4aadHwlmbU5-V5CP9WeAiwmUJqvarSlK2wPi3EPnSQ8niHnIqYDpghkFxvCb1LmSEBKox7U30AtiEQL4rUXFgeiO5Iqh0VG4z6kRRJD3-YoMR8RF0FRR96FikDJ0CmABYDPQ1qWwDUJA+tLcHH7sv2JlD-Y5JrvL0AmlRYAcERMmpDaOlyy4jUQVgJ0zCN24FdSF4IqNUFSNh+D2pft8jSKMbUPiiUUQENUDdyHxvaVwRHiwfewAQRUqJFA2iW-GpK5YJOC8p6iuVMMJSFvQJ-AxGdUwjiJIiTGiZsmJJO9BwEvDHtBR0ZoHACPizWFABvyOnJaMOO-VfXAvKIyHdgY0oGrDZvsMcsKC7O384nC0x0+BwDFgU2LZA3WyUHmUZQqzNQW5Ts7gYBnoLngJBb8FiLrBeClsvuo-r7g7DkZwWXL7z9o85EJJLIF8GoVQhnCllQu+KmP-QI6q-qJNp+ohJ54fQYQrp7ga0wGC3W4CMfTWLg11UAg7WqniOMh4a0H+AwU4a0CgfKTahEy5i6fEd616HUqTguI4xnIRKcGFq9iLhaRLiGpyhiNQLUI-+PWCUuiSP1D+QQrFepmgyCthpAolGJQArcK9OhB8r93JQInqXhWx6bcebnBlt+R-CKTOaRCIkJTYl6AtMUQ8sNxBJ+yolHoewcrHyl7QWa23gCQhAOKJe21aH4LwAgWivx9wE4Ivyz48PqLgikQ7rIRltsuB0hOjw7MF30SoXbJZe4xUlOZeCwwJIGDjZTJi1gQYyZMIkagyN9JGoRKGIzI5nSDfjfY4SNRDgILiRpjmMpwiKTu84Ib8yOyxIgdizQCgNjA+lY0NFSl8+fEuxG8PfI943JR6xtS8Ip61NCI18wMkMGAblsDVhch+LrhuISpCnQ-NfzQ1ii0C8tERf+eujfFNiazbUbxabCxsL-4y4JfLFgFYAAi1QLeR2BcEvSxg4VADav6SUsIjnLRUu7OtNAbuByumypwWfl8w0A9mC+PRcWvGUxJZ7pAhVe4+7BzxwIeix5XdBhi-5h8gbBY1zLotZgJL86aOE1DpgzkEOJgVp4FChsFmVbwWTEgVHszTk2YApvGEPZqkjakZ+B-UdT39WExLr3sKuvWARBMizCg1Ceaq1Q0WP+jk0seLUw0ACaQnOkC5rUnEmZGtA4gOC26J9mjW1fk-JRQ4IlyvQsgtJjrbI+SBCo10zGS+GojUTHUoVxH7f3HftQ8afX-UVrNZAsZHlSjS0QSaOKqqmXrfSSDLHCX4ivrdFb6Qsj2aofErstMFG2FgbzhOSwWbmLO7Sc9kCZnY6U8CGhbLdYGQCMwN6GZBqQpbGwxtI8odpQnww4GUYXLVy36oxQOeFwQxJ8EMb5mmUXXlD0y7PQ6s+KWSHjj14YnRaO6tt-UKwlBdFfHpS0VDeBVlE8aZnpCQeuPYlPZSBAKqrYWaR-yud9UEBr4+0LMrHWZ05rATrEI0Ncg0opnCCZEu5YA73AiOLaAS-EJA4lRNChdt9Kcw0swQxHwZhHdgCbL0C6KxwjCtLAYSiJCFHIeTlGagnq5+h1DQyizouAkACOPTK7M32NfS0U8iLmVpQYEsthNK-mFthpSXYOnS8Dl5OHDiuttKehAYKBSQYrs2hHJvRVZsEOmH0006BqXOUMswQ7t7y5tDGRrrdoQGWndKND9cT0pXDaSGmLhTG05QgXzejGpbhLOaLEvGD1NvaMtwWk9sGOi7A-KCnyxuW2CEt8H0BXysqZW7iLCzgOroIQf0jMIvyoAfgOgkVg2aL8FQyqk9YDRoa-YJoHiRE6xhhIKkqmArAemNdWXL7REkjTZd1G4yLhmksg3iYCeh3VJZ5Ul4t+AHAHA5PZ-kk6qIIMorqJ-EYjtYx2A5sh0xGulFKsuR8a8OWyAeKaJEc-s3PlUSiwPO-3gp4e++AL-YGrkmjXrA7EOxSq4-aOtys25HYSti-DmT7YUurMuDV8cAOmARGducVDaQBlp3PjIgcsMREk1cFibYZDM9Uz3ctTGlBx8b6P+JEGE2DeDW0ZzT9Aw84hEW0rAJbeWt2AqTP2iZS32NMxZEa9VJw727h7h0woNIltDB9UAKH1uEulCf6co3LsRSIk7ylghQRotNwKMguC-xAVIxaISO0xVqhYS+Ln0rtC4FZorpAiwmK9mi+DLiIxqeqWODaTyUK3cks1VHFfTiJ6u+2jgOkalOr2RCgeBIo893Yt0AvMydoLTi4MZEQiigxYAS2LgvVv3YL50-XqjaohElERARZkgqiak6YMuh3Tx+40QSqpBE7IJmr1lfvFTAks-NF9wza9TXYcme7OPEpjHoULIxvgkBqZblruTOB60CnTpIS1AoLkUopvrypQJQlSyqc1CyBywobvFAAz8cOvPyc49pZM5SVHQgBzi+zVKfAkAxvNTi4Df6SSRfIrMIrwfQ0TAWCFc-Dqki5W4+nOKYI9B4mlMHN0NZC2Qjh0k2oUcYC7Ex4OQkPF7QqsYVTwCBurQo18lzCYfoiGBU9aiJ+ENO1WJptdPpALHwgKTAEBYOoMjpWgx4eLgSqErFcr9hYRC8rVkNzDQQrDL3AVAfR+Qri+Gsx1Adgv7VqyKUIhe3ziFSzDwVoEu6Q84euIkyYRb8zQANYHaoxzDCymn7N7EEzJsmW2QUzMruZxObKHdwpVqAHJaFQtRtSrIQHyN1Zd0LSEd5XYJ5T2QqZJBbqJbAzcHlL925Qmm3dWGndGYGWxbnMRLYtq-xR1zVbjUIJtm260c8SMwhm2GD8eCIDIY8cjSKAeD8sBdfIqjLs4f7JtQRgwwfgjBdwq8FwPHY0NAm6I92+yybILIBgiDBy7WPIoQK8H1GCwMYz8OmFXS8aG5g1BdiPdDgQT0C9CC4WmTHhzFfRYsUXCKxRC7SwmGyOivQMwoc75gmEKYCoEmC3DIJhNrIlQSbVIMilJ+ZSELnyWwwHzCLgjIE+ulmFZ1BDJFzPp56MaKoZk7+kMTAWqXQc4Ovq4IKhCqgbBWXMjkWM-ugWWfwmOZKy5wtRQ4mTmVwmMGAElmgQgvgTmDGX14IiIdWE0-FX96rgcgqW0bS05yIMZq+XE4bmMvC9aRt+5W2jAJq9UrjJ3wv0GExA+UgKKC5CbuBDgdgPaMAicQrDBiDDVlAppiZ7+cCUhJl1pNA7hInJAPvcQYITXCAE6MK5DgGn+Nhjj63sJSwgE02fUwcW+6pJziiaXFhhV2qejTAVVz2grjH+ouCWA3QZkGcjDEGGyigw2cNrcIcVCgVxVn4hOcRR7kdAPimKo1uOKt06oWNTp2N8vU0vijFIgPsoqx81wA5MbLVwiaUVbOMaSIBgHAYtgAuHOC5tZzfAzmAfKBV0ohbVdmJyQ2eOLjGkeAgqiJIs4LKLPqFCEmgTYGXX+7zK++LmLuClym7wHcEyj9heoayGuMFk8+J0BhsfVAWqXEgmiTNEIaUFNgVQ+rHnN5kMQgBtAcTxE3rrcsgLgWonjkIt2RNlVTE3UCViRPZb5E-hmSLoMlLqNla9aNUGVh+5QrN7l7NrNCvI82gH40y8qeEydANGX+B0Zv0KzmF+PxMDIwXe+P7AK1PomwAuoX4oXhMbK6EPzBYWAZJycRlAGIQTgOiIdUw87g5KoCJXANe3HIiSNZSu4Kk7zmGo2B5gld0lMu4IqhCnQATyGotoGSHo3dCaCbbbfBzCmAM8L53hYXxmjhTwKqFACZ9tPisBViM8LicS81LLKYaid8EeVy3w6DA0LyHvOvIBup2Hpc9gk1gzynD9xFumSi24NHAd9fkC8kfOYsZWGZQrevvYreUptGdQy2kPvqNMbXJy6soRUBmAs5jGR0rpLvsceAAcOSO7OhXMRmoxuiBSVSCUsGVcPo5UWXLNCRu-pDCzOBJhyTEbcnFQW4UWeoSVa6wP0g1AxMEovYbhnnYPTmxxwwDHBGIicYljkQbQhFUI5TdL8O0J-MxYpshVjuZn-zzYJwsGkLFZevsVuJvLMQoPUB8TTgjqPdsCQ2iIGkCgDzhpjDVEVceI2QXtYSdcxYUK2lQAGiM6ZNwnSzLJiQQ84NjIPU9ibJgQl7UTRwLhBGDiajVPcEyAE3PtCyYSCHMDOM5oMzWjgzFgFsCnE4xbnTOHzQGaipQ+6R2Czo1CCnDO5yUAFXAIDaBFW6sPYDsApBlsoNz1sozKFhyQVGNpYbUjZJ4uQi5xCkctESPs+T4+lt70am89CGOkqK9cFM-sh2CLQfp6CaYwcVczB8aR41bBOZlYENavVAXCbd0-4kxiCBUZeCOVHWF04GizHzqe6UH87BwTvDPiHoM8Nx7Gk3Q488STh+5r0ZVPzSBMu+gbqDA5epPbNDu+55f1xUsNaHlLp0ZRQYFEumKhtJkumtJbS1wGG9lxpEsXvRITNGpWo7TQ2AMEspdtIr+make2BqWe8osjmqg3fduYaDYedN7B1gNaMRy8s19NRaD424CMibnP6XgP-psiF2BR62aEecnnCZJKYutexjZAwkCAZOxfQmpAQjFo1dJuQVozdy9UIbs9KrAokWjLcd1g4CjxiEqCUjSjgYKC+ISfb322+66i3XQDuHsiRg1BUgWedxnngC6D2BSxJtWYS-o1yWBDp0zooiMCQCgOxnKsnvHeqTOCvGK28FkOUs9K4YUC92XODpJvCDU5HVNIVIaSPNr4mDuhxn-YITQzCBsYSc7S00E4iqTgGMDUUIqw-ENci-azVAno7UPj2xXXr-j4YavWo0CJXGTvq5Jz5DojgWohiNuUNe-a-eGsnrdK+Duw6JfVE4bmGsbepUJtWlUTKjkFiBYx16MB3FCDoF5VwJTShzOxdybpUFmW+HtlTWj2VgBDCB0wryG4w5qXrJdQeVI8Pn4fyp3GiIhEhzrNAqQE7GnSYw4pBdCUAWXLxccE7gkfwGw12QjgFQMuOCZEQGkwxhMohAJIURk75qYigw+3PoQmEqeailvkeAvgy9xJ0zHKblQUAYV68HGY9A0AksMy81wqMNngUk0W7dsOcOGvwxQAIBMAeTwJ8LnoJkmBMILTCDSKdz1pOtFUnBJtSQjjdCFrIAT0f3aZo3lbeWTFttUTuTa9ysbAJMxl3mEAEVAQuULQ+7Me-dIj3OqoNjTUQc1MKAE2p9E7cu5-8S+BuFXUW5bdBfeaCqtu80PVKzogDfLxHeWotS1UkeQ5zAWQFSJ0hCw84ADpowUEXFrAFKDpSYV1CrJ3MTYK-MJ4zYvxppO0dgM+hyj0pWGi+KcsjHvMJsNdNVETi9nMKCtovsGR-y0FH1JXU87hIRAKcyX8JCUivy70Cn0Y+4NAcJax5wR-MY9uBTgUWIW4Rvo0gALDb8hzAZC+8pzOcHLqd3FS00t5jFRXHwNUJK2Jg+9qOauAzrH+7Tg-kBs5CAkJiPf1EdFS23bQlo6eA8Oy7KP71v1hrJRuIiHz6TtYZuifOhz8tLvKro5Inz2y6NJbNBkzY0uULc+HiOmB0A1IgLajM2UDvbfJTPY4wOJqPkupc4oITAgwN4dOStxo+HNeSOWzkDSL+8LbGZP707QPVwv8c1FzMoC84Kt38gG6ivhRtzVBGMGETHxFx5Z5DJSyNgcgDa+HsKwFARNgn3yQSBUJMTmz9WM3otzUcASCbtdYiU+5TbEy3CAT3Js+GhSTOe6bZ431neyerxaCFnmhCQRnAB-jGjCM5Dyp3PkQGm8urBxFcRaMCvTHkq-pcJ5QApftS4wCDLbASCWxBcyw25YvwWzQW-KkRVvUPRJC2IpaysAtOgyWFA0w9sGwTlquizDy3wqMO89uwdFpgg-R68A0huqikFm0NgbAM8YhY9XM+fYAhAFEjPaihEwaGX46x0JfZy0pBwaQ-tBSRmwaHdQ8PI3MqVTpgU4LVg9DccHd-Fqm4LOBoYi4pYD05WHczm4d3yfh2vIkdtws2cXyOuZkAh3GEwbJI6LSN7LlWFqLpMo-GE9c8CcBnS1422D5kE+KJNX9bEsCEJAOpsH9iRXqrqeCZAEXKJ8yaYNPwOW+KI6r0YcfsgH4buEeMhxDewIMAjqjno8MtEnil8ILit6kmLSSAQTvA3t6ipsFsAM1JctMniqQ7-ClBJ9MsYi9NA8mhDQAswKSgSYukUJRhOIm9HGdNuFNoX+BOAxNCgxbOvERG0JyUWYNtFa5GfAO+v4h7OrtQ1JMnBXUrlBjDLnI12I+k-YEC4DCG5Y-ZuKQB2HQFnhh1Bw6Gg5e2C7FUMMnZ5FA7Z-ngmRiqj3ojEMioRoP1M9CH5BgREsQawJY4WUD6R7AnUx5Tp0hYIIXNqxjN4qIM2oBuPDs7UDbAPADcgq4CSRESMdxEbgsZBbBAIBLk+QNYmkx-QqYI8apdRAsjwNM2BmBcTg4Iq3GxA35Aa0vmGCB1oDaI5OFvl6JIQAT6K6kviFYVXiJnNtLHEIdxmthU8p0A4HG5ZdiFrAieNxATbCVhfZGZx1gNkIMUBwAhqLNAn7MtgveI2gZcJAhXnGrpOcKDIl5n2Nb8nedXMN7hw9AegG6loUBmFQ9L2OL5BAEfpZACVxrKs64nfokYmUAzMIADvgOeBMpROokxOkCXQZ6JtwbsFqRVRAR5SEAIhoQMfobaguBvmFgkBcHCUcqBGYewNCxwylBhIbB7sY4LdwjvvbcuplFQxaES5ZKGyYpaH1Rw9K3BstGhVCOND5HjMBR+GJFAGMJyMNagzBRsNyRfFH4RyntzBj7h7x0wJ149CAChggfKhyrIexJqO7RssNqQLOG098wJZpHUJ6pv7i3BSBmkQK5mzMpyhrpWGDN5LoBGwYiFWghhng9UImpgXcgsgHuE2RTVL2hvOJyQKSOBpzZImBj8NZRUwO4JlXNRpQkEjUjVJ0IKwJ+hGpBBBrEJ4gz+EPxbKmCooInFU4wBCCEDPHp88N71fel9R1vlBEL2Hv1nyAjoy2l3RU7OFB4kg15AYqfMR9EW46PHBMrCvqMG4C2IE4o9BpiBWAtRFR50PqAQl-HjYMxvBlq8JUh3tG5gUzLkC-YPpJ5UjNQShOvAbdpXAjaAkCMIANctYLfBJTL3kacii0lsDMJUilVkUCIWBUTvUlIIt2gh+EpxUiF7xURPjcMII6pZKmah9TsMBIeI4cJXIBs0GNuF0JsyDxdDSIKhNSxqIMd1U6Gsgb9gARpABOARbDYsY+CtwYEG11zoL3kzIIU4EpurY9DFrgdIltBfCHQF9aAjNFjrRAiRB8RTALpQKeKDBTJtGc+DDboOQFRgIzCTh0kBxV5LE7hE0N8lcEPDhNyKR0GFGRAhzDT4YjAYJ9cgWVsoA9pcYDABVir3cVMoc0NMBYAUGCZlJFmrxVbglxD-MECNfLBgp8O4g9EAYg-cjdgFAnMhEMnRZHCFgltCHP99gfzMgXq5hfsH6IlevwpOCGipeMM6wYMBFJXAFFIyaBJIu+JxA+ZLeM7qInhuCKgATNFm0qKBhAhypUI5oCgQW4PMRTUEFxhoNMhN4JlZwYFeBPEPUpU5GyYuAKYAvshpIgUGsCieDSUU0INQiEg7ofLGjNlYFWBhgIG4kzk3pFTFFkgQajBzPsmUmSM5dTgFihe0PygAKPQJcKgBpeNLlRBqJSx9WO-Q-wPaIezNZp+GCyhE9CwgKwIsgOAFkFWkDkFEBgCMdsLTFARmwRREt5x+lC0wYGqBDTaPJY61JSwIAMbATIjBCYyESRY8CbhhAQ0wLaDCQsQjIUPqLXhsKEntq+N0R5sDWhcutghjSB2Ui4lrxl0PxYytPbQ+ntZ0-VKKAU0NUJ-sG5h7wWFAxRsKgN6C6DjSGggaihSQHOK9QOWGmBEemQ4KQdA4dsDSDU5NmURSLSk2rOo4LOrGDu6B-hdqIBgPFhQcJ4A6RjRF0QKgMRRksvMUVUM+YDKBpCMntpChofIhkUs5ATcIahgwPhQnVNzJ0prehxiA6c5OMbBkUJrp2lETBc6MzRj-JMJ4Yi04xCG9hzPvwh7GEN9Y2t8Rx0ObBgGLeMa1DnArOOrUhwnFAj9L7xATLpxVSOmBSoOEhMRLVBiRL3Fb3qi0tCr3N5yFNAzbM1hlwBPwZflsQb6m-JKob4dGGJ1Ay4JRDK4FsgegLDxufJNZ+inmxo5PCxsANKpPENclzUNdAWJPmBjwL9NpBvCRQuBdw9Ml1lqxAUhl6F8hHsAOpe7qHhdnIPRESDhAnkBV8oIkk9aGi2IIirR9wBE1dsAJEJ6IFXpuRONppkL1x0kLlhPjGu5ZoP2hGyH9JH5Ff1ljHOA8CBpA9UKVA9Xi3BcofqRxfsOJiAHmcaAM8EBmHjUR4Bw1YtlWYhQVdg-kKUEa1saZIUMuB4GKAxH4OT8uqBxp14FNJPoRu5wtKjhPNP-BZKvfUKIMYghoFzMTMhns3EIMY4lAB8WAOuZ50HOBnSPfxOcJ0BeLulAMSLyVg-GRRC9tIxc5oShetGsAiDsLCgmmDhwlhAACjMh1V8MKF8aBoQZiP3wNmPGVesEUJTbDCRXMplBI4LGhj0IzkLwCJhBTBNlzoIjJhBqOBZoOkswkkiJXADVY4AGCwGABmRSkL0BP+N9AKuAnhusMllvsDXwItquhHWO4lXGN6JyGO3hWGNERUwGoJpKrNBRNj3hkWCQYJ2GpQiLg5pGAmRcboCnIj4M1ROvP4Q7uBnB-Shs0PeGGw8iMrpPECLBHYOFB+oOLBhICFhOcDroKYB3htIHsg2Ibl1KrEXF3+lNBvRPXQYqJJ46wOiQHSMmoThtdJ-4FSRV0CoQAPucRT4JSYrOASxmajl41OkBo5CBuBnYbRAM1HClbmJppk4KQA+TCwA0-iSw4iFRFqWDHxsNEVMmwVZAlSAvkrmJKgCfNz4xQCbB3fG2k5BLPVeoBfcRqkUxBoPSRPytstgDl-43WDmh1qm8D8ID8gxMN-DkFP1MtRD9AKgIyAOwMyCQIYllN6mcdIROUBmqNKJoWEOkO8EAtaGAG5fcgIl2cCTAB4UshTEKCwtwByxasJPooxCPoaUpx4y3HJwb3BrRb+oZ1pzJ7xSoMqw-Jnb5akEBAThqow9RBihSnqrQVMnHFowOEgCkMuBQVLp4SeJ3tRiMEk5xGXgAoGJR-KDAh5kN6oMaD311VqVgMaMZhTSIQQ9hEFBicDABE0EFBJ+FKkZUpiox7gqklUvnx8wLUhy0BihNdP3k3Pk-D36J6o5IAoRbDHPBw9PGhWFLPDqIP1BChNwJ5im2Bl-JFVE4H4iKkAH5HCMHAnDDQgAoDcw2cKdAz-tdJ3aPpg+YLER3jgB8RXNbQZvA2R4YTvYd1jq57im3w7oR9R8oA0C9SEsgQBDaFwBNkIioo3h8xIWIviHiQAhAB8YYPSgRGOIcrKHxwvyEUIwhIpAE7hIEw4PbBLqPtR4aJbhlUNVtOsGYcU6K2oD8A69RinsggGChcvbElwY4WXxtQs6RSXsyCeUDJxNkRqQlOG5hPeGaBp5I98qSAuwSYWc1U1MaBEBh2A7SMXCuwKVAy4U6QEmEeUSoJB9WzCIRqFOWBE6JawQlDsZzwd4d8Bu+AnKMEtx0C+F+ANmtZoBDABrJ2NTGHxJqNFwhzVqnJSeMH5jkHDkP6K2ACdHXMDWBtxqBNJ4A3Khhu+DMRagmJkAPn2l3kA0gwIOqw1bKqAKwOXo0mIGxrGA4oEGLeACwIeMOqPDBPIusgsCCUJhKDtVghHzhPUA54yCNTRhQL4c43gJBlwAjo7YCuJNJJGwlEvMsNfLE5ItKthfSOQpQCL0AO8KWCr3suhw0JGFSBjqF2lBfx8wNGIB4ehxI+qCw13EMDHZHRBylKtU-IIbBNxB5hFotx5ClIhABYXCDiqjZoiSCCxdWPvR-6DngzoC2jEsMipIiNERQZOzpHHEC4+rLicCyPl5yaNdUN6EQR5tLR8VJFURpaKkRP5A14jeAEITJj5o5bGBB+uJRgCwJPVZoGnIwhPmIXWhOxkFCnRqUGZwcDCiRmXvnBWFDjhQ3JmwdIsZhyKBUVghIvCRMBoQ3ARMo6brsBypI3h99LBDjSMZxjzi94RCJCIRHBwASIIK1L+F-Urkh9pEREWjzMs2JClEDEPwETRYbHxN-fGAI7QnHpKwDbgQoPA4UQpgI2cLFIVgIBpOCJDdlvvFoJTrn9vwLGAKKGkwQoGGCL0D6IVuGBJlcMQA0RtkJV0EOVE6DAcTNLBBkFNQkJuAlMyoNLIcDHAAp0HtRZVMg1cxtGZrpNCkFBJdZo0KGDuZH9xR1KQJLMdpVBaNjRAkOdABUL0BpjJIgPvAPDJ4HGg9+rERNsDvApvPMVViLABtYpjB1Qt9RwltSZhwPVAVVD5wRoeKdYIJKdcID5ptELs4GBIXCsQRNw5wQZYaUFARt2ugZ1wn1R4QZlcTjBrpU5GMNWyFmjKEVNAyABBFE0EzwZAhggJ6HIVlxKgiAPvYcKACzACkKNI91B+D0wl+DEMof5AAfZpXcLNwfcgx5+4C-En5Ei4DLNABu6DUgCVAzAZ6GCFPkKhtsxr-gSuJOwWkDq4GvNWAUUSpJmXhCVKdOsBLMU3hP4OqJHLDl5L2JTCqOLliako2AmBD2BGmGYclspFg1MPdRN2KJ1U5EvViqg4IYEQr59iDuwCyJ+ZqRhjQU0K2hFwJX46OoQhcTkVBIctzh94SmgBNFEcncCS9uZIQA88K65t0rXA1UBSI-jDAgd6MDUNUHRZoNrER3bAB8rAPDieoDikULlSYJoE5EinuxhRYI3hFIHvMeeKNBhvATdwVC0wd7FWN9MOEwH4PRI80JdixGAB9rAM8gRoBBARSEm9Y8Pzg9dDYBLRhtIbDkyFXXLRROcY18ZsNRRaIPfxIKG+hlxK9hUMHIIvBC6tJ5gB8n7I3hVGGJAPeIuEHTPmJrBjHBbBuYxmgFih6wPHkFCAJDQYK08oBI6hqBLDotGNYgQ2ANog0BsgDGLkRxSOSIQ1um9YpEXgj+HiN0cdlwd0E-JOgA4I1OHIBMZMYhy7GEJykWTFSoF9AZxP89CCP8g24OwBvEIc4-3BTJeapCB4WG9DR6B9D7PgHs8BJjF9tEthuoAI4W6DUw8ygydb8C0F+nj+gh+PTCcmMIjs0YNA-biViZAl9p0eLPpIEKmJs-p1JdALwga0T+wnckDEaPAVAKdE+xQUW2jakHR9YCBZxFTITxATKLwvsN5xE+iKRk+noRfGK4wCqMH5PoOQD51jtRflt1YqWObAwQBro9AY1BVQEJAjaI+xvcIBtdsYuUUQpHBVwCsAbmLGhtYV5YIIJwppJNMhg4E3ZCyOL4Shm1iqKMMBr4MpAJhABxrEJfAUCq64mDAGgFcf3YRXLQFaPilxaWDNgHvKzZ5sHqlAmMvwvgMnZ86C0U44JZJ7ijZMX4IU1vyLBl6tB5ADbmdtgOEVtE8VlQ+Ianir4Lb4+UCJxhcJCgV2CwBSBiFoOKCfBuhM2gy9C+Zl8vCxskMPUy2rP5zGHRBQsdCxucGtYa2C1pKoUPE4Ce3hqBKeARHAjtGoHoAaAC5R1QkSRuMcahLaOIVTeJqQ4eLK1jwDGkopI3wyIl3wowa-hDEHQAyNDlRBwNvhQUchRgEjfwqMP1xS2AOwMBHRhtMW+wm8NRZk6oLhNkbkUvsCytNsFqRx9q4BYdFYUpzJ1wJym6j7OCTEyLp6pqREkAN6CVgQIf6RRXiLwaAITYCCb2YLMrSIDxAfwo6HPhqBJFU82NYgfwAUlC4tDBobE1I3whgSLymtCjePciqmq843MLgSSNK6c9DDnlnsOHog8GVhCHEYg1sCUIjenoJRQJwQlgpJxVsA-9T4EkAWYITRX+HUYgPP15rskGj1nHnQCyg3V4aLUxnQrZ5rxBdR5eJph19GwAhALHhroVDAOLPDoBEHhUOkPN5-1iTEuEOKDvkq0g4wAH5oAit5qwJdRKIO+8+zvn4nrAUkkSdXDsmNuQNNlZBVsDTDwvsfsCiB7CjjiFhfEWtDWwFNiFAWYRGkFABPPF3xIOOgowQjmlUNn4M5CdCpmyGpiyaJpi3IAScO5qNhjEKpNI6ERgKZIqJdOEgxDrnlAKhDlA3ms5AIHpDiyfHNBrcOkwSDHrpt+HvQ5jF7A5elwIOeGFAoeCGMbOClwjdqwwVuCvjaTmvjZThviVIC1JRmsTAcUsrkOQLfl-8QF5erP2CiSlyIuuPrxtJKmBnRMNBtJMJBqSrSVCgU2QQcTYBd8NMIkZAeBQUfhwThjhBDNF0YH5P8RLHIK8LwBIgvXESUiSuwgUoHqYFNpHQucIShuoMVV47K2pYuhTAGmKVBtIlY8GYMQgiXFvxacDwxoqETBdWJSZ36K3MbliTVL8ALAUhLUh4JNAQMHIYhjjssY+iqT1oANnh4wXihfXEGgSCtyJcwO2AhxP5JMuAOxSaEjCy2o7DtwpcJk1OZl6oHQAxhlNxdTqHBDBOBixHF3i2qOiIcAeWwwnn2BsuKfQ5cGQkinv1ZF2Jk4r6PnEAUNaFDAqKjkivxB7lJbA+qImxxwO5gdYDLZHrBzJ4wnkQIipSwY6NlBYIA+BTepOp4LiHCLjjSVP8TikV1l5x+GPLRkmFW4uNNQhroLOBxSAFAtoGwA-CCIg8oDz50jk2j06I6pAtHyAImPExBoJmB6bgB805ISwqwEOpm1Ff1magbkydISUeYDR5qePYJ6oOaYLjgi1r1msgsiS19nAPhAJeOxoqmn4JJsgB95ICwU+iDtV6IbuAjvGMDFkARxHctMDk+F0RyKDHAsREOYwdpwJDUAFFhQJIhAYdjAgOrYQn5APD4avRhcHHhZrsG-JV+vBSGAqRdpiYvwWUNWJhCO6wBDE0gproNhdmBS1PDIDM+kDZRmgsbjXkFFogjNmgpGouhKoltA86AWR3hD8hfEhccLkGuUTMYTwtBPawXIC3iosCUJQwqi1ysOsBcWgB9e0BQhKBNuE0GAfhQPp4A00D4590ENBSIEjEQ1ITBYwH+DUyWYQyBBqVyUOnEXkPzIjEFtBZwM+YnsGZwiqQo92dKZwyyptgIIINQbDpYlLwHnRzEOahxbG7IsDlxTxwADgIEERBiALGVP3ipwtXFpB0AseIMaC756CUQgo6HDA-ALsBMNnmgyUj0BvYr7FvLAPBqwNMAL5gdgMwlAAs5mQdBYet9CyjvcbTmYRUSVYTboOxlJgKrAf2CgRaTLvRTeJ3sGEJ0i88ORChiE7wGAuAhGLBegAdDOAIOuOJciQxhRmiDhceoSjfYNlA7qNog0KGgwPEK-AewJwlSwFUQBpGx5YcSNBGctpDsAN+xdAGx5XqKOoZEWJEDeoxZoNmwwcNIe8+0FRxAAUU9bMCug98Tb8G4NOgZGi0gv4KeADVo2BtKNIQhwDtQsCEn5I5FTkIxHEIkoPIoBllbg3AmbCJBMlBy2L8VKTJzAXUT1tWzFWBAvIilqUqO1XZGCM-jA6YJEP48WaQTReSHfA8UiHCEwvL5m-vHlr1pLjKDBixo4n5ZZKv0QGyPMg8SKjhmFuaxbNrHpWqL0sT+EIBvBPbQXRCphQUTABhNI+EiaAMtyRJ0AQ8N6Cv2rUhkUDBlfZE1TwFDgAIsUzlZTEtRqJMDjWSNnhDFCUJQUfgpiOMNV1QhywfkF3AHdFyNHbk7kXcjBlaMIkIZ4G30lOB1BXEvGpPzLtAm7GxAyNJqJzYAVlIsLYloYG7gtGKcQ8sGNAb4n00AKMKAZWAmdEpgshVYYdgcnJQgOyQqMY4FrFckAEoL+OaxzIZZDiyH8QeRorANMJNSIwrlhUIdgppkLTFUiMOMtgOtB+5pQBaJMMjzWGGhhYDohO4OiTQUXBBpGJzgQ5l8B5wCidsoMaSWfm5hG8GFAUIQ7AvLK9Jh2FRAoxDUUTiWkROcM-MNXIFQHUfjSZIQ+AI2KM1sfCKg1HJ9JHsc4BQYMKoC4HOgmqb65NYJj5QFt1gOwloxSsB84o9JSw8uAJVQURnw2GP4I3dGiMkwOt8VuMUgx1g2R7oJTY+qErxwRjrAd7HkFQRDu0ThsqQo4FjowmEHjRcfJBG8OiEJTH0EcDApTuSHrwgNPKtOCDI5swJ6RPmG1AomKGQngj3s9NHoB0oES45BIiwGwSoiueCQRcKtWx10a2lb4FRx2VD+kmnrjRATLDhqOLUhVGLW0fepwJFQb7wpvG0w3oG8ke4BMJ5HgB8GwBShxQC1hUEHWDjoiRoX8JPxiqgBQVQi9BsCBAQvfjmgiRALE-jD9Ji3v-jBKQU8nGflx6pMxiD2KlAjmJpQV0D3YyLjUEUGZJ888OP5E8cMA-IADh4AKHAqmtuTjurcUF5BVA61Dj5OiaCiGwOeJqxCPorsLIAwWJdB7yPKkZ8HtZV+DKx3btMIQkO+Ti2FDxYutGicmLUgQ5m5BdoI8yboaKlqllBSUgrFS4KQFA44fyMWwauh1CLMtwsHBc60BoMxHnX1tCPbQgGJco1RM6JhxK5iBIDZxYnCxIhIP9wKYGGwL2DAA2Io7lncvJRreIwTUVE+AidskD+qGSgaAHIZVTCg4DIOUBVQFsAH5gB8TcGpAf+LswLOGEJT8JyN8ESCS8OH5AI0CuBXGGPZ2euUxx6YBStiJbQxis6Ym7Gdh6CC3SQyMikuYJNQGmDZSOoS3Bb+pQh0oW3xpAe1hq0ngtswjWhMybZ11DmcgtIGBE6AEEJt1LNBEhCKMyEETsyYEQxjpM3936AukCwCNAxoNlC-8R7jkoJghstFyg8WYhcTiFVR58En5myOPoZcNHA-ouyTcSHuploIqxfmPpgk-KtR9VH7wkEO+ImDCJVAqFKRrXNIRP0JXoDIuIgAaLUgFONqQOoB-Qnot95cgY7By1PgxXMVDB0ONLJYIP2xtoiNJzelZN1GKrdXSfmRtFEHJ1zBScLwBFBpRBBFJwrxp8+jCAcqEbsSGeJoZOBKyT4FoIsyFJUjmG35-eLswzZEUzH2CUycoR7idEsmz0yQhcwruI9tCAT0gGIFpu6BZCYWH012mQz9nZp1w4YHjA1cF9sT7snQ4mjqhP4I5EZ4L3xtwo9hI4H4IroJVQUCIXgVgG08w2Dzwdqg68J4DWtlwJYRRQKhId7FgSOkAu9SftQRmUPq9VKGpx6AKDIaBKdpiwK2huJG3ZmLBtB6oQB9xkExBrSGgIGdJNYTJr4QeTj8zPDH8zrkF3JzUMqhh9gMjSkFuyD0AYhrlAXxl0B-AKqJDifCP5QCkFmIcIXixeSHbUG4H4zgiE5BfLozkTiDtwLkGIRMTKqQT6bOgO8IBgBQB7CSdKhRlWLcVlwQylwlqzJZkfMRGYQz5vyOKSBLjUkPFk9x5yG3ZQwa1SuROOgmEPTlNRJCglwPRA1sN0MBqQB9ViM+APYJuJ7wbOy0kDgSOIKcgjaOUNpANrQvLPLAYVM7RZ5NSIF5EPxBCEd4YADphMmXRUF8qm0tgpeQbDpJh5oG-I7GnsgtWMeAwQizRScCJoL0C7Fe2M8hXHKfJ3xLsdWSfnF06fUk62GZArWtjQrODhICOA4sTJJYcUcevAXxkWpjGJyU6DOWiaEIZwW4ju0ZsNlxUMO1hBqLyQ-MEgRIcVDBzMj+wPAJBSTJr1igNH1Qu5H1h7MNpZAAQ94-YOcoogmhpYIMvNsNDCJAmARS7uJ8TKWXPAqxLzAnavgoc4IghfeI8YLmt9QiIE+R3KMZxItOogeIAIZfYtnQCYNIiizjP47AAmZ5HKmAMgOPIauSzgWUMK8EkNUgMEXnQlakTBCOLZ09CvdSeUOV1mdPvg74OThXBsMJQZregQLJF1DEIHJl6NjV0cD2h97kRwiKpQAgGGBzf2KfdoAEcgp8IsVWVAfCcAC1o3ooAQViZSpiKRCh5YKfIxrlZBdMtAx3WNespFslAU0Jx0C0nVSFkDbhA1Fx4UEAdhAEDRgWEGQAISOUN0fJqJpAEwju8awiAPkricZHqJG5FFQAeH4A8pKThT4PCwcWroU7qRagOLK3IlXr7FYUH5AYEMXBOnObsFzAEVg6JGdeKNhd9MF+5FlPhomEL8x9EeWsjEezj6oOr0WsOAgNgvRBfXHUylelkUOLLvIqBJMAdeVBhT8F1AyfNvwCiNtg1EECY9LGsJcKhMRKrPS5k2Z-AxcK6gKgCrB8fKbwjlkcJByQT1Ybr3j4MM7BOibkR3BHgIoiOYgWJKwgP8r-IUulpTsAObB1ejrAuetjySWMuhF3MTgSIFVk8VrNArke6wxcr7zgmMlB1EG5YiSq6xmDD6kFkGhBBwlARqaBTIJFJa5AYQyJRiDqdNOh7BU0KCicwJIh6lPFBzgJgQBpHV5rpGUYlSMEQdwNIgaPKDNUiIHIakjLI55KwhnzMEQBEO58EeFKpFkBsTvNDdzQePnibYLGAsqJrYbDl7xtyKYwVCPkRKsCKMuRIsxiuLvzAip0BPoINAJEO9BcchAYS4JwQfnrehfmtdCgIgmRBkl79kUK-TgGI9yqaRVx1ItGg7IDPQS9FF0+AqZ083PphpIuYSwuDjhrsDZRwBQ6Qq7DUIGudxShxDshwKBdAamlrBEwH7Ay4Kb9ksamyywZYlrGN3UkwNZUR1LdR8NPTBIcS8sssX9FmkfKkYAFjETIPm5QYC18rqowAkmtt0lECJAwQk-EU1CWBbis6odsjHQJhCKZWGApxzuQB8MoNFAPatz5j9glAq4TXCIImTFYKpuABSh2V0RCckbUT+A7UZ3BOSkDFuktdg-wKYB9Dg3xejIrxu6VfCpvF9lRHLZhtXnnQnJtdgTYDgB6oP5JwEHPDLRhRYU4Gft0aqHs8sHxU-kD8CagkAh9VCjRm-iqQ5kVzQqcozAaYAs9+LP6DaKND5pVKNAbOOwzvki-x6NicTdoMkxn5soRmkGJgZkPaQoaIvtMYoGo-4DhAN4nWpDYmIxPZMsU+AkplQIBXhyhpz0Vkq0TpMaIRqxD9RbTmcJ4uZTBvFgiJ-nuMhOgGegcIEyhoGDMpk5hFUzQHuC4qgChj9vbAgNLzAPGMxBy-CxIY4L4x-2jHgxYEMCdEDkwWFDdNGxJDjh9K4AhOB8QWkK7J6uOqw65jFBwmRbQdsIMl3MDMIwWICQnMFal0oHg85RgF4UHHjgDqXYBoJmKJ+ZklwpHtjQr6MqwqHHHZDuPQQQMjQ1QoFxNfZHIQk+LVByOoD1hgBzIPAGcRdoOawgXJFgXUqsyVUuHhgoJIgjgRKZMwHzRaIOxkOCDkcqICMgtEItAdOD6pUFACYS3mgQY4Ntk9+a3TMuOAKnDlFgbODHB+6e2wuKT9ygikchXXBtyx2DKi1ON89piFoKqmBupt2u-Im3tORIccIDV+DHB60AURpwBmEKqDnBM5nY1OPMZY+tAMg0GK9QSkMFlUYHnhEPAExvWG7yKuIwKNkOAKxcZiIViovgZhNEwwIL-JlfB-SioNXwCWLRAYrqhJKsR3AcBXmNvyjegM8CGR2lJitW4NkxIbrhzpYCepW+a3T4AOgYBjH1RmWcDAbkjBRduPTF8uM+pczrxTiOIYIvMgdlmkHKwMgAncA2StjKqNShWkBxlq2Hup2bpgh+8pldxqFOZa5FuFRTpY5ESDBAuGJykl+MDNRYJpp1IBNzU5B1QaUKIR1RVDJSQhNIiYJYInxOIQA-L4xMuJGwg4K0S2Vh0TYdOzh1uEYphxeFgoekShkUJpAQhT8RlEudVwcKzkFONMp96W0gJ+KslYEYTkNmmNk5bOOtWGOuY9lt4yzYZPBUJLNltCGzgShfjNa4eULYPpxFCAOwNsWDQFmiPbzzglAIP4gsgssJAzOgBZDLSdQQQiPVxj9oUpsrNFQYMoDNHWST8IUJFQS0c+piwAIZV+Pot96C3Vq-u+JI5LZgN2EDSgIn9AqhK7paRG4B6uPzh+lG6h58M1lWEEgJ-qKDBx3MfMihLqljpMDly2PbEfoEURwqaa4KYCTFrLL8LHiKtUPZqgdK6v4JiwFgdwBNggPwBKSxodKTNHAW4dHOILw0g+JLCDOBSaaDxzwC7EB7OdNWcc1gcuZARasHqTUYAaTLmYvxO4MptaHhNBBADYAlRVZAMJBHhFVA8hufMY1ElgeRAihEydsODFKAh5AaAiw0M9iaI-YfJgKgN7AuPMQyh+jyDchfnBfeDxJTeJRg3UNyF-EODEZhOHRwVCST1zHWc4YPFo-CJ15F2IJCNMVAIskBsEfLGqhegF-ZcYNQIdiZi9zlApQX6V2Yzms6wgNALALZFSI9TlZhpRCAYaECei8ZPDEcJB8kbNC7AC+OhQqIqn5QUfFBb+utBsgqpA3IRYojkODF5HKNATMkk0clpwCGOfWwHPN3RKMDHgDIVDK4oCiM+0RIdZ4V+RskOi1rJr0AZ4NcYLSIftvYSZEGdCdRl1AZBdDE3pBaAqFwBZG4CbJF1+uIQAUSAHAJBCRpQdImVYpR-AGCCkJbuGYRCwGmy32XX0SYp54k4E2ir5pj5aolBZhxbpkTxWLzzxYnc12J0A+sCUIgXIohLqDPA8ahaQnBM1A0MK4Iq9PKYAgNcoMOSLiF6b7BPssRwM8F7x7irQDk7gZQZCgwQ7TGbLJXMJp9qFOhbuDo0MgF3wqcFwR6WFqjLSexkduB8gWYPDRpMpWhGYNaYJMAjkaGm+BnzN0o3qNXAfKSF1-KdAghCL+hhBpVF8PpWopwAEL5oEEQAmN1hzAdqE2oqJ19qNuhLzPuhLqOVBzcLHBVzGtIYWHKINUNYhAKKESBIKThMdCSkVeFGkM4sNVMKhnIb4MLwC0QWgrUpeYLwIpwj0Cegz0E4y7SNw1EIPewQNob046I5cBICWRdmAmAO+jDx09uIkHqFkkCwPjM9UCUIiXISltEOWpFec+cNSv-yPYS8IONCZlBpJ9RM+MLBA8FzBMfnJxkzPbEMJXLAHTAfR-RGqhfCDuB5GMWUVZqYAkUkST5gBKDSSZFRs6KJYUuJCc3qQupPqYNgd8Hz5NOhLwBoLlh6mJFVPqmmxKBKMsGsJkwkmrFAnghoJfmICZnQjyRerOsg8YI7DJQEz5E0Lb9LmJJhUBWpoLmNu1C1ujc0MKpA1SNYAw8LHE+ArjZPfBnII9oQBZWPpI44K5gMBNd1w9JFVfDrPCeYOvIaAH0c0mBoJREO6FqqJbRepdCBIQDMBsII2BcYfqT58GNLXOn0E+ggPYLmFkgLEM2hdqX+hHsNbFC0OYNpgGgjGNFWR2mE5RvaqMdgmHlQY2dxU76MmoOGfMhQSRvRUiF3RwML9j0aMuhsaCXALRZzQmGFGkUMThor4FEIYGEmBtjDmBqFPAV3Nk1JIGO7wBRmiMM8PnR1mljBy7CLhuoBgguEHiwKIBmpp5HAAIirtQPcaNC6sSbBSqINRQNGCBv1M-Ax6P7ArEBUpQUYDJSeD5A1yH1ZtFKx5W2Cmh9eE1dUWcVULEKMydaKM07-JkhbeYZZZ3DDoIkX8wa0EWwKrkFATZOahUlHISJIPVplXJH1qqDV1FwGohFCGPCD5AfDKhgshq4GhQiYDoggIZuSQsKfJsAGI4IyK+1RyI+Js8GGxh-uYBDnCWR06TLBj8DLpIqNEMAuKkRGpUEZhgNxS+qOqhgYHYKIEOOA0-uOCQOozopxdZy+QR+BZwJ0hwQnV8hNihJAmBngVEuFThAUtRgIVaprqkBB4+r3IHqIjiKwGGRkcUOlVudZFZwYqxZ8NZQ60ATD+ntdgskuTB6AOKJ9MMlJxyUuN8gbzBz3C3AjwO75QyK+xK7IOgiaSVB+FDA0rPNpYZiU84f4m-AS9KeNYiLegRoETJ4wNQgbhN1AkUrUZgVTgr1iqdhJ4ICYpUCEpkUCMlPdrvRH9O+wpKtXAZApwtMGAIRYJT2oqmtiqCboeYjWTe59OBXEpVV7zqUqdVpkHQBsrBnZhCL8tK8PWB84Aggm5WpSzuHPJT0DmpTwNmUFwr5TIdsnR+GFdE8OLlQRjhQgu6FylpVSNAytNDhejIql3EPXIghJ3sZWDjZzWJDKgiPFotwl942oKoy8OGf9MnKNAe4Hlh+QO6xdcARppkBDBRceCoD6DWpAmFT0qxOnx6JPED+CC8xz5ZvBpjDIEC0KFpxYEzlA1H8ZoWEVA86L9AXWrQhCwXJBiwO4hYLJAwzIJORDxeukiaT9zsoCEh58LkJiqoeo3UNOgXlCNVpsgNAnYRVLPIrkQ3oKwo1QDGkaUCMIWAF2BmkNohAJCEp4tAJk13MIyJ4P1QQCHyhkWE9QkUGsATjKq5MAS+IhUKwx+yA-JLlOVBTBDckaIJPRCwTgkaijgAIkNUVEJtNBnMVolFwv6ITKBlULRU+xmpeEhsHrlRSoNe09RJMJn4CclNwIPIWfsEkfYj3o4vh-BLcH0JmwgFAxcKFop0DfwHyPSxTFeuqWmIohEmP1AwTCgSHIJqQaGWwVZbl4qMaNfR0zH4qqaRjgYmKUNUCudFRTrdwCWPN55tDX8L+AiJ28WwItwq8USYiJUHEeFSnsrcIo9slIUcKDBp0BfIsEhckl8JpBylZwQ-UgU1qeOtwxitzhWUm6hGENRhaEJ+gV2IIApngZY4SMWgUGLhVs6IDAkwYjB-qMWB6oIgNphHMZHcD9z9wMXU4bEolKZOGgDOWJq3MLzgH2OvpFwHWCbwIsNF2B7j-SHLBrSCZQzTCh5rFbF0U8itjT4FrhhQDyRPDALAKgFbB0KPDjc9H+gwYPJtWctBI0kOVAC1O4JoQPkRJUF8qAmD6khGPDoDusUt-WqbRyGtMhpAHuoztfkDvIO744AF3QAHKCpaVDYdsELfRq+Az0f4ppAwmivIt5koAq6U3lo9F3J3mgkwYzJdBzOJbQqshgZYGLGLhONyI1kE-AMEjyRzoJ102AC+Frwlkl4wBGxqIewwwyFUI2mJsjMuDbhMCC0x8tMWw46HtTgiG3jDBNGY60C+JOumvBwuLNwmuEPLk8NFRPcGIQTpuuAsoMaVUqKscc6EbpypB5jX4OfF3II0okaE+QlgfxCVgbAwp6D9J0kJNY+rHnB+Rtv5eSEpc6vqbAr+eQh32CxBufBUI7BUN8E+ci5ciCvwFKLXhFcC0wOxI9gDuKLgKuEsDpuJph32Itxjuj3w1bJ9J4krbB9lGoIhAHMguQdpJSZQo8WtOCIKAEPwPoJ4A3ANEhvFfmJufNPB-MAvlxUN4qacmx0IcKkgLaLQgqfnnKR1NkJ91CZK32OAhs8NCxy2NRAoeFfBFwl8xowDoETztJA7qO2ArmJaM35DJRhQC2JFeN8gHnCGDMCFNIySG9QNpIFpsFFicDuFgkaArqI8cDrABWVN5yRIWUR5bLqVuCuqlOeZBb5JbhxuNfzBcN7RsoKfARLOnlocEn5cJJNBy1Cjg5SfPgMShABs6O75OMnOJXTBzAvLDaKUCEE1-4NgoBAAJtJgNlB-BG4wHwWTLxRO0xG4IuIzmDtgF4I8hMwFp13KArBKqE+hVKevBZwPgo+oK0gMSF+AafLfBM2IwhReCOgwYgRyoxD0gk9uYQvvJVZx9ZPrwBcQgxir8QtCLxA1BJlwXwl3xHYVoRICIXSZDkRl8ost0P4Mkxo2GhQp4N1BHLCwgOAA+I+gCxlb4N+1ofD9Rjjk0gLwExz5oQJBP4GQ4h+P-ACUDDx7wQOg-WXHZFLJ546MJSgxrLh0NUKLIPFR-RuRr1FWiai0d7Avl98H3Q3omuxyqMmJREgI5IDo9sF6TJA2GALMrRcMIhzJ2BMCP14xcIewsCCOsTholMs2aQAsDMaY9yO9BbEOOhXGCsgxHFoRvahup7gp15uKS5JhlI2tQUQghWkCZlURIdxYEDuAvalxBXrJ4E7yMEIgUHwAQNm2BFyXvM-wOUwyNI9hi-OkhesopZy2AoUZ4O4x4pO-hnKPmQ98DUIadFSAZ4GPR4-gNczILF1EYIOx-4FtgUwNMJaov7wtPMBAkIS1h8bhkiw2K50NtecFOYNrkAKBSRE0BShs5NHRXiju1a8E8bQEJG4iOTP4+kjWonpNZBh-s5jrYA2A+0nMRE4KqBugAkxYiBWAvcHeRTkF+IF0lAh2AEfjXDVqwDuMH4aUpIsL4DsjXPtkJO4JS1uoG1R8uGbBOcCCobAL2LtsByhkCWgN8Kgux6wtJAhhjBRfXEvdN4nsByYFgwC5SjtTuGWBLqHnR6yTx0uoPpwx0PAxwIAZg4SK0gY0jKwYmPhUquVlwU0N3QpMF1knuNSIN4sNBZFi2IZwv9BfNd4QquUNBJ4C0wFCqEqW8DCRtXAJkG9C04NMcTQU9Sagt5LQEWZaEhYMfuQzkGcJbmTl5U0KhFLSMHBO4KokdZndiACIIBIQDYdzDLh1M8EVqernABQEP5QM+NiJgKGQBRpLeBW0IzlgDbtRccC7EdMDDpPeDgh7srk0MEOVJSCG+gHBFSA3JcHEipKCiWxL3kzsAvhziAYDdKCG4rRXQgeGFaJCElvS2WejADoG8Ri4BAApuGsAUpdLIf0P4IBGUD5a8Aax4Ln0QqqE7h3JBjZwqeMhXwBigbDqJw33I5Y3ebBI8qBX0z5fwpTeATRN+YyAWJIiwGvHcSr1L9B6FCQQBNnpSm0UCF0yuRQtgoOSDMBvFF9p0JEyNwKNwGBEShMwtCmOiEhWBtwQcNVTREO-k28gdBMRIdxq-vSR+lHnBhUNusbIWHg0oLcZcsLwwdcP0VwiDOJ+QL7BZwJQLK1EDEo0jycMQBxpdnOs5EBgPZphFGaBYBxUMjHbjuZGSIKIP-4ZshrFrKNL9UoFgoUOLKcPwCwVgmAI5vWJlIXKBtFBeQ1RQVAxBNLozoqWEzojKowAv-G7wSKemwBkJEj+AkBlrIrp5HkPtxkcAkKKEimoNCLqJO5HKqqKtvAVJLqjsAOVtSsBy9ZoIpBxfKNAIuPKki1OCoHtK2BP4EmL1nEn4yhX5z7CohVZTuUAJ3DNwoECmoFuGoRnibeh4aNllmLEHBialDhtImc1VQBmF-TQ3wcDNSBQsJppGAHqJnINchsoC7ALjk-xlxNqkRsqM040IoVNYOjzTIMfsq9C8ogAvawo0teI4cgZYx7mBqjUNbwOCpaSrAOLsWoMcxqOK2gkGGtgWgKi1dWNBYBSmdoJoNEpu6FwhvqO7s28CTgcBV+VdAIwxzCa6xTeHlAuGGKAxOikrutAzB2dChIZ6HphcFoWLrRmToNcCsB28EmBTejGAzcU8jDnEmh7qKiTCqOSZAvHmRheBUoRMOf4ZUryRTOJex0wgxU9yINQQVQJAxRgkxeGKcAXJL9Bb5GQwTTZuIL4A7YvqBtKuCNjAvxPdQ6ELidoaFkhnzNfBuIGlwxshiARHGDhr1hlqkmNcglMDk4HnE+S0MOAKsgi2C-AJuBhathgtwFap+4C503OtVSvfiE5JhOAN+oNExIECqR+yDohfSfvRksmiKoENCKDdgOxwBNzRPkCXyTDWZgb3DQxTorqIMUXQEFBMmA+rM0hMGESgQtMi4q2H2N0tJvFQNBlY5WMNCGQRbFvpBGxWqRjRx9Ai5foJSZesCJhzsJpxY1SiEXhEshLjmx5euE6hKMBfIM4PL8U0M0hXGLnpHxEcUV1iz9W9P9wSzkGJG8FNBskPpAwBtRrAyJrjToM0hxqKWB9iHOAk-AhqRMPMoJ+Aua87M3g9LXaQujYFpy7BiwLoIScOuCus3eOjzy7FF1zHjOB5IL-Eb3Mxh6oFbQoEMPR0wHkFb5AWkteHzA5IaLiUQhVQ7yPSQ13AhZF0L3y2qE1JsbAKUAkHnBQtGRIcEDghBjGaZjYEEJ0MMGA-0AWbntaErjzXeaoZOnSEKoExuBEJAIxOkwtpZaN9iHtSRoNAx6SF5xsCI3hHYeDhoQBbQpYvRMdwlqI6gonA3GHzFZoOLAJSEjDUODxIO4KCwBOtLQZgBNgd4KKlT8F6ZowgQg74LGF9cf5bmkPVkLEBVLO5N9IjmMOKibQuwcDIcg6MHVArsETICNOIbqKO7QN4lf0pkP9BFTPMawYATANglg4e4GjRMCHMhfjUcItYuALh9HZZ0WunQIEEP5IQAKy6RKhgBOoXhugNBBzqCggJXHf4RYLUhOWNgp2KRnJkCBhsEMFCxK-DAhpwMMAKDTqapAtul8OHQAWIHvzMGLtBING41FELnBBIcaYM6JCIYUHzhsRHHx5YDAwZZCXampkSV0kIZit5JY438WQ52wHRgIlDHBpoLq54iM7kwWEEQoWN5iCyhlZxvPxAcEPmQpsUU8cMt3TzcGmoztqJYEmD+w2mHI72mX8RSaI5ZldLLBFuBbQQ2AEl3KAwJX2pUU76HIVPzuGoH5DmwvlI2xCUvCEbuakxxYh-CPcaAE3hl7zhOLyKkFi60yANBYkuG5gvmBeA4mREgrRA+QV6OcLtkMxgbeCG5hgPGaieDABbmWMMFYJMA4AL0In7a5gaUKghD4J7hOUFGk5ICFQhJubJjxMbQy+N2BtFFUIhvJCZsaFl1paCvQM6LYAp2PpUT4BGI8SHEIFwnq58YK51nchxYvgF4IZ6B7jCqL80LRfHJZTGxBGLArBDoGTRqxPbBRCN3BU0Ic5JclM64AGOlzUOCwNfMOJljKAhzhuMRG4MbQWOEOYnKnVbEmH6VRCLtBnACvwKZN0N08rsB08sip7kS70-HLZhdiMuA01IVCZoorgywJNQyZjbhYyuDh3dpnh1eomBhVIxYu6DghjqhyAPwLYgZYF9tcoJCYA+LlArkYHz2lKDUh+sBAyJUOpMlQJB1WIajKyKIR7OJTZnkEa5J2ERw10LBiXoFdqyEgwB-RNOgMaJMB02Iz1NdIchesIOxW6C7kyUun8APqFBOaNNUyfO0AF2gRBrIkP4sWjlJ-BDoEgVKUNA2G8Qd2qgAlUI5zkCOjB2IjQQ4cOCIQVg8gFOZYAPnNM6+CVeAx3JmRisMVQFwofFj8KXklYkTIJ9dSYY8F2AeYLVh2kOmAdwLcJCaBg9FOJFQsuFFJZ6AasDSOcElOPkITIkWjYoHahUyQR5DMQARA+VGJVMNyQTZCGhTwPbBX4G7hu6J2B+7h-MEzOnw+aIgg4+FtBM0oYo2TNrA8BCrBrxCnQKwJS60cPHAcEDQQxipTDUwHfKCkNhgmwIBsncvtpuzRax4LtwJDYGSkkmoD8jvB4qViJHIbIEUg2OvlFFcB+BsrNjZVRNQLIcT2B7Yh5BvOLpQtXFghEUqhJ1VInQSoKM0x2EBo4bMgh5eOz11ULidjYExgKwAupJTC+B3dougccOnQXOb5gKwMW6UHA6ZpJPygZqVowQwf411wBLQd4BpircKGwHdMK0Y4JSxpEJHYu8SlV-KB2BstU65iwI5piAHODctTTBoVCgQpadkKH8DtkWMrihANo6oLOFHAO8NYgEyE1dsbEgtuMGn8LgqyQt0DEwQYMmoOwO7QOhWjx9GpPz7hSzAG4CTZbMJTJJiFtgbDOTQRPYdx+AJMBx3WhAPEB2BvEInh0aAkByIdQJoVGpRVdZxRA8H3JrQRSJl+EvMbON6I3MCDhfDsNRClJQgwWo3AqkMi4QwXWxwKAtZqMHt1UAMMBqWZ0Zfzp0INZK9hIEBqUfHMVUwgbTR5eCwhqoUyr4tUC5MyDKxXpJgQzJD5kFYGYRW-K8VNglsBrQdAwrkZaSRABYSZiLhQ08A3hlNicl1kLE5yNHJBUcCI4GXRuozuMshI1T4xb5Fxp9YAnE9Glgz1MOIwKjLSZnwA+arUNaCugDuwjwBJb2emIRGEIixmXh7jugAXwopCXwoaJeYmrsMAVKKQJXBNKkx4MJgLwIDErohWgWMnK7vCCiFIEBnxuZP70RsH0AfwA54sgj2wZ6PwxpXnwpHZFMhi0EdB+hBwBjup-S6wFBqH8Khx+AJEVIiKyKDdiLwMqq1BgwIcI9NWuRIbuxooIka5FkGxEromFBxIEMMd7DQhRiFDJmvXWg2hUbwtWgB8qyNbQp8BZ5Y8BoI4utrB7aD81UCgRoomK34vfkQxc9NWACknkRh9UeUTQNiwCqFqxkigTAXJN1ZCDL7S1pGQFb8gXRgVaG8dkAVB7NLZhZVKwo3ee1AuhE1clAF6KEjFmId4IRxjuDoEEYXqINostxKrKGkXOXM4U8KcQgfOwheCG1QJ9d0lrqqugjwB4rFxAWAwac0hftFBqpYqnRyIUi4edGdBo0J3s+rAxg91Nz52ehaBEwO965OK2xWgo8RrOoLQhEKDxLlquNOkLd5-JCZNzcJVg5CkEIMUBLQc8JuJGwOQwsdAmgYAANxatubgW7b3cRFNSZsFPWqmlOFgsHCIBRZDmDu+Fhg9APyAxYNSANJd7UMURzAZchRYEjG7I92l9BowCmhl3vPzVpKUN3qJYAcVayhuKDPxAoEkAwuF70PCC0AysPIYHIdMRUoHoZkXN4prOrVI2wJNYZILGdalHkd3IjcgEdXzA63MTU00fGBW0LdRMcJjh96BZDsmODgvkPcolMD4oqKhFUpsfoRAJCGxRpqXAO4GBplsBdBR4BeBS8KCj3FOShpEsQAYkLcsqyLkRJ+a+0ahIogI2CC1drS0haEK+0gYtSZddoAwEwC6svLJmwoAM1BOuDLBQUdFgIkMECV7DCqVgHwgOeEbRwRLig94UX1iCLQRINCuAoUMupSXBVUAkND4CysZAFwr4g7TFwh97swQnsM1K1vpjEMyOSsiRJS6OVKwwBNJqIHnDkw6oGnI00ITlWYInJvIOuYOQhVUvYRex1QhawZouvpssrEiVsdWpgwB1BAqIvgyHOBQidlUJLcBChQ8ivzhEoqa-mDNEVxEkohUGTwQMhNKroPuhJQKfCZ+BxrePna6YsFBrTenpqJsGNlHUkU9GuLUlJwMbAZIOjBqIA15YTYQAcTj9EYYMtgXMISlBqJeABQNJwp9TmAePWZIDjIYpqtApsYGv1N62O7QDtJQAQrlbQIJG+Q3JdtBJMBMgsYs60r+rpQ94JCUqcC84dPTmAmAV3QVULAjTogEw2hRhQIUF+IW4EwgPaGoge8HsJpEVdEo0lhhqIY-B6spOQjsIHIaAIkw4zKCj-xl0qYsDEgyjFAYJLlx4teOtwngrtQ5bHpabcJyUyAKcQwBsq4G4PbBSLJYkUqBjh68Lf1QUTbgnfKIROuiJY5OAlELOOj5+7Cnh+7J+wZAtfRczj6J7WEKxcoBmB0kOrJvHM6o1vhFhZ0EEhWZrNBfiMZwsGON5cZKoRO4H+gZJG5hbINMpIIjtZ+LK50wlNng9NdSx-4CSRrsi70rhBFALQArBGCRbQ1venTdmKV5I2MfgJCZvUdDFXBNOkVYa8qOQfSmgh7IhBJCcJWkc8gKlv1GRodEkfBTwF6wSCNuRc2Cc8J4E1B+hD2YVOC7FA+XdAc0ORBGMB9QsGHODrMadxtIicNulNw0npLqjg8jHg4kJotGQGo5XAAVAVYIIJtaOLZ5MBNgHSBUIMKAxBPwCnQePSbUF+Suh6nLgRtIgdwHxJXAERMw4NSqLIeJHwgEaBpblBFFhqKKHBKYRtRZybg5QoD6k6cl6hHoMmoTHCcYbcrkRH5HWg9KC5yBSr3wYkPZBymPQoa1vYwQYBVw2rB4q79M9o2OrGLMNrOhMcD6RD6GsQIDIypqcJ-BvELZ0U5OhaWcM1hE5bWIxRj8068clbZ8G4hPPG9bgEN5B1cN2b90pqRUwPwJhkEN8TJF3Q0KMeczJdIkvqLZ1-gN7QVxHDYLLN7VYCEsQquXkD5HYkhRmsdJXoFe9V5CyoYkKMxgKmGqULNAz3itxI82OmZNkEMD06mOA-EL8R3KOVILoE9wlTQ2hRkP+ZIUBEoFkOQ0dYOTQWEL4cqSPKlOoBhBowC2wQ0PnwiECC0MWIbBMiIn95YXiLc9CTBe0C+BNEqIgysE3pN4jpxWbDt54cX+5H2IDNBaN3QNPArTpGNRht+m-I1BHDAaAEN95UqTx2wKG18kLLcwSFKQo4CsQiDEP5kVBlYSqIugLGGmR2mBoGlUDegM+IyHrxJWA3wKDNqqVqIAijpwJwLSxpUsExHqFBqe4lxoFwr7Iq7O75e4PJB4aJpxCELUkHyG4xpiA7lKML7VDoJZJ4+g6Q8pP+C3+JxGjsBs4pMNjBLZMFkKjJDwUWBRAFwCMNvYPYVCqMQRajAE0hEKzRrYE1ZHBJrgCEERhRYNIlbEHHZGMAEBiwBaAJYKTJe+G7zP0OKSuCII5oINwJXrNu0-BNqQvbJqJOCJNNcKIwhZVGVgWUBXBjkE+ZGyJZISDOx6L4FUQ94I-oyNOkwugEDEduD1B79YcIxOlCRqFRTJp4JBofPo3hJED70CWMjgHeG9RFeGEghAK2jLWM2Ak-LGFEyCEoPaEIx1kJaCfmibUoYFa1F-B-gfokcJ6YihdIiMTgVMsxYBoBugzJNaDaPPTMeYCMxMAU1cNMd7VaPJ3JZ6LmAVMG5hOYBxVqTChwwEDCA1UEKhDIDtR4QmeB4oGQAoNXFAu+DuAaUJvULstQqQMkLAv0G7xHcJXB1UNCwfbJVEncpygJkFJBOCCVRl6MH5ciTpxh7WJAEMP-JiqKyQXYt8l3qHbJqhD3gVxJfF7Zo9tmqPH1UaaTBaYoFoRkHfAqWKFoJBBMhERS10fqLZ13MF9B8Kt9ANfMQAU5Kpx9IF7wXanmhLlFcw8YeTgTZCoRjLmjxqYnOCnDBnhegP8QzNu7s3SM1AiUD90G0MviUaJNpdPC+xLqGTQmclhhk6Olp2PXwgtgVRGywHHAsEAoIhvNIx6ZKYBfDk2AB0CE11cJ9hT4RPwwaZwYHbGQ4GdEJShjWVg2ACmoyYt8ljqtJxWxCsR0iv1M8HkWxMNqnl2XdUIkDRLAfCAhI1pDzA9rDOFqMJvUtCh7xxyLyQcwSh7wKFm1wKPnB+0ATZF0KfB+Kg1BW0EGJpyP+YK4q5Ia-uKSaAFBqQlbGBy9Pt8JrHODK4BAQhGDUlp5CcQBzBXFZ6FJxngr1gnlcqwfuV9hG5MbAnIFPYIJLBAUOMlwHGJPB7wbO6XeKrB8yP2w6jP3GhEE3QWmDPAvlBNBdTpvA2WOOsG8FSxphDf9UYvjRPPH2M2eNmVKrHMYzbETFkoxDBiqm6QFBHdAnorFJrskRV3mKnhiCAmFvCEM6a8mTA9CJqJqcORI02lRxvMUVBc6FZwJBFdEY8BCgpYD0hYTYc1qUBZC2AG+xufHQgahDLIBNBlYwuLwSo0EgRycPmhhlIDNNOgIhevkmB0mM5cVkoKgCoNZjkw+4Rs6LSwWYCgwBmOJBAusjgQ8I20hrtbaAmoz1gSj81QKW7h48vZBMSv9wfSFtBO0C276cKuA1ULOBXUinBval9hhqFIJusFNAisD2hlIE2InGGMhI4YGCJBJVhmwN4n4VGKNejNFgfmZBoKAKxhtatbbIkAKhHZDQBi2P1AG9NA8NBG5E2ZvRN7IANgyNFBrfBXOCkFo8o12EQZ68Ob1a8LXg1wJeYHIW-IhrohIwoer0V1mToWwPrtJ+TX68pAkZmY6nJfeIn8sILLpWo9PgJyNBteSKBo6AKdBNoMSIK8D4EEGJbJZ0HTgrWuMT0YGDZY4BvFugP7M-opppA8IAROAOV0oIBqUWfp0w0GMz4642ziBkG-AjorSMSwIQhR1FqsB2M1RRwZfB4ds5dWVLo4pSJyMBpPJtdYBbIq7IBA12QtwPjm3xl1O4Qb+OVJ+pu400RWfB44GKNqcO5IWgLgsXfDvZ4oNckPce3h5Fa+xcgQR1cwJxDa-IQ5paNMRVRP5I9eDZArHJ9gu3WsmIzN3w2YrGE9+vWwznCMnt-Oxl6YIwxfIDrxs-VRQv0GDhIUHqwagjX8g9u5BGwNUQG4NSSgYNGgo6AIgOiGmHEhMTgr3thADUHGg-cDfF6mNlxP0G4QfOKbwsChqQoNaQgm8IjA3ClsEvqIYkEzOBQ3oJaMo9F7hioC2B+TI8hOkLxoTQE4YIYA0g3cLX58Kkuop4PNRhUH6z7ShwBQWMzQAcOJVqiDRHOugXA2TLZ1-8PxC8ud+AIWCnBlIIeM7yrQ9EJDpxqBHvQlYl6hTwH1RRpKVRvRBtJ8KDZxwQji1malPBYGGPcyEp+lvIGWSvwEbBOoPxAFpDRGF+spAlcDomiaagRlwMlGmAYdwaktkJ1egNxc6nDgYAFLt14C1BGEKEhqIEsw26ZvEaUKnwyaLpBYEExzrGKNMH8MRR-kJCV1kAfHmU5WAQ9DUmb+COBmIAu1Q0ipkPYVq1MICaADASz9lXGk8gGE5CKALjRPwLhQkUodBxfKBoqZF3xOukTFD4j7EUsRu4UGMERaAkARGEDAhsTgumEYlpHReOx77ILmJHxOzp4ODzoIYIMwJYA6RusHlJkinBZkWBAhG4J4FOGC7kziNtE8RUQFDhOlHT6A0jaaJiwN1oAC6rdDIUulVEaCKtJt+MdVxcDbpP6YbFZVIWCMrGLl0OIhUGA6hw1sF7diIL3Aztmzqy+D6HYwCwVuMTTol8PAy-oiWQEcNJEfOJkg4LJPw32MqRokLAANJUFBLk9FQekNRBwBJZ8cqPWwOCL81cwPrto3nXMANqnIV5EjR3oF2osiC6gmwJxAwQqG8-0NpYwaVjh5kAJ1H5P1YUaAbBU5MQgXfDDxb+qYJvVDiq12Q1QVCM9GOwPaRvY30J98KTBXiBgJQHmqrYY1Wwgbo5wrOBow509Ch97MWBDuNfAxoCdMZZIZi+4D-AEoKWkOvaUAhg-MHOCIWsjJlJBntD4QM8PEQgYIwJA8IgHhvZCYssFExtoBFgviEuwW2OfpVXBqVlJOIR7IDGyF8vuovBK9ZW-N2g+wF9sIYJOQsYDtcb0M0A9QnVioCCiQ1AAmdsNKARloCK5UM27gQYAkhXXNJI7wiZoVYIhsjoIapz4wdxTfM0ivReTYOwIipa-DGy2xvTBz9AIBQxvgp7GM1xjoHPhiaMohnAq9EVZi2BrMf8HVxXUh8IGNACBCHpm4+4Q0RuJhZVH0FPwE2jUIl7YDSFxNlAxxlokOqFeqjeAytEOJozuBB-HCMk8CKV5S+GrZgc-EDQUyxJocJdR8KNWJa9HiKRSECttYBlYgxBVB+Zm0RBBEswUQk84-kKXhiAFBrqcCsVghWq4HI78x7ICrdOwPeHxwMEIzCFF17YksChqLuMpJHdiiwL2h+FAPooNeWBxvGt7K4Pm7yRC7FNsEvrpzC-FcOq3UAmP3QV+uAQZyHnHpsmRpnLrlN8+nPggEH1A-4H3ZQkMsmhALjhDYIcR5YwwhOun0RKIG-B8YHgI7sCuiziHHhTmOux3qHLnmIHyCHxIrAdaEejQ0prQ3ChFwRKu7Q1k0QosgvRI-4GOwahD5lC1sUmyoDEhh6mwxakj9hsMEEQBNAfC7sJnM6+vhQ02g+R7cRiYBDEpHws9KlFYHsVXsM7Am7OdxpJCPBWgiOwa-d+RroFtgKqAwJRULqiVg7GVkICVFe+JwQOVH9nllbKwMLNg5accMg1bOuxEkPFAGMB7wzuF1cKuBYBkzCTw79Pfw85AuwOiMqg-yNmBg-KahCcFF05NlIsRjjj5urARxT0KCor4C74GmJ5ABWfnxOgPc4GCKFpi2OjBOsEPx4aAEh0lnu5ooPWABAFwIf4ucpiwCNU9CPThZTD9FzYDKIcEKnhE9NeEXI+cpcEHqF9uMo6W+DdZx1hZAi4ghIPYABslEHBZzkC+B5MHjVtqNZA8jMWB5lMgptIgjhPIrhmR4gfYaEOZl3djvYwEP98ipCCs-AOPpZ3YVRjQB2AtVlYBU5AKRHYLiRUgZQJ6YNLQsYQ3tCIHkZosMZh36JrpYkVq4iOCwV7qNEgJqKzB2mFKhpoLXIHsNg4fIMLBnTOfpmfGfBqIOe5VaJZRbiohYlsO5gqwCZoEAvJAbcj2ZhiAgFaPEwIONJjEbqmx4SqHwBOIDdU5ULZhoHpVntIouJvgE3otwptAMaPbFQkDfpACD7FKrLvAEdPxAFOOe4nDAmRr6CbJRjvZBmwO0wG6En5IqKrAbwA1wcELDxOWH8G-kCl0iOEQZI4EihY4ERUYsM5BJiLNbXMKV4Q5HvySYsBAx7E3Y8SP+ty+vvYNtdlpTuB4QqIt3xrEPbRfYnThetIeMb0wlEFzHXjOWF9hOUBrq3cNohITCxkCyOOle4ipx32FaoH1i9Q5SBfZo030RG8KPAF+mI5MwJhIoBJZn9OP3ZJgBFgxRiIBvWHXM5CpyNvxPAxCxLCEu5HJ16IG6gklEC0vi2T586JFVliLQgomVWBSEMqhegAE5PpA3t+hNiwBNNgpNuK6Ym1MwRcjPAwYeLLAHTNO18mHLmC0J49q4YI9k8uWpD2L9Hp8HqIoZBNldPKdg1YmsdsMBYh+oHXNDhDnlshJKZWntjV7GINhk8uYxYoPLwCEPOQB2JpoyEGEJDGXiRMcM4EvXCG4GyJ9dCuGk83cAFSNdPZBWoxKNZ4aLxqFRiQlEJOwdqHdENnMdmB2BKYEqOhw3JRiNRYWoQqmOcFZRC2ARFGaAiOALVCNHHoa1vvA-CDdRXoCggHQi+EF0IG7R0UOIcUpGR+iJgGpFh3hWVGgjy4N7BsuIOS15AmB6YMyz0CnnRGxO+Qwmm24RaHiwnUD0gM8FLEIlMnEoIruQYWMt1KME3YcnOrhrYjWAFMToFe2J6gvOM5cQQqAQvIIht4GE1wKhD4Rv2NO0KYK4Jh9XxIWoP7iKZGTBSeL+gTpi2BpyGBFhIGT4OLL1JAIBGJ06oNJ6lPwJtIDMlXsOxTINOWpQ2uZwZIC71jutWxKs71ZT4V7ZriOExqWMGWikKhgIYCusfqKqIUWNJw5UIeMDIJBFurCWR-vtwLMA1+Blvt-gvYXlzxyNSxNbGWAQQi3BuAlqt7ECqh+OJZJWwMzUZKDsD8hNuQnGE-w7TNGhp8KpA8PdiVrNOaoQsGcxyaM6RAmCQNmHAOwfBBtF1OiLQ2qDGQm4L4pNYPRHGxDdUnDJHAx4GKNrvWbYsQjMB2wHwBLlOA52kGBAvLEfwyZtLJ6mBtwJ2AU0gODSx4YskUSIAwFSEJkrJ4PlBY4Ficu+HhEChtZVC4CpATJbvBNC3xBkii-wisJGwXMHBZNjRtrHZA2RPMERViWB7wVMs2BiysbA91MnQ7AEgtx1g3ooYBLBKIMY1a8GTMTMjZwIUCpkAimQRJkIOB9oNYr4AKTwztv2QE4uGUGwJ2QGAh5ULRQBwRoJGQ1CBFIsRI77SYNbwTIvDR0WnjARoLmdyutkQAYEVBrhDzBxfCUhcHOz0CNDTkrCcWU6RDtkmGMagydihA7oaWlvNNgJbvBnJsBOoFEUvnx4GC6JpKxxUuoKEg2-Os4u5GW49oGGliPJSR7aFmwgGucQrJnUh97hMoB1KkxfSN0IZZGIy7KP5QtkD5AVZiOw3ZD9yeSIHgDUBawOwHu42eL3lKKPlA4C11gjwCxxsK3sJlFHR8V5DKkMSm6xGaPlsveDmJCxJ1t9uOjBIEBVAvsF8gHxKuoNdC2AwULnVmHMYgzkAKBp8AMhaPFLgG-ci40kFDrSvLUkUSotFF8AbtzoIfA24PtxZTmLScqBPqrEJ2QWtLh0VCxKhCELjQPYDmDVUA4gt0Mzp7ICIhaPDrpnfG4U2o6DEyYoG61bGJ0UIX1BATLf1lwOUAIJLPDDIB3h3YPtBBaFVAJYMZg1PJ2BkCNukiGL3UYiLMilSCJWFU-JFZ8PmbF+F7YarPRghnZJgUwLWJEjA3j1wOx7w4AvVmLIgMoaCZoVEHnhnEGRAIUGQAjXL4oK4uaYxRpcJvOFPBufPTNOCCBlt0LcV1zLKojkJ-IzwEvqrEGQ5i-NarF+HSJd8E9UinmlgVIGnIGFHrwewC+BUydMhmfKnAhJrbRRtUTAFWErWdEoGQaIwOzQeb2Yp7MAdlA9YAu+O1QqQ2qqFOFx8QWkIBTMlmAmyPFowCPRA9RMBASCEQQdDNmVCmDnQPwMXVjuNngNnLXIJsNeAO3aQwImOYSa-QURC-lbBa4GRAJSIHX5oN7LCUn8RzlJXB3kNMwSqF6FOsPHkhCKiIXMCC01plhB3WIZaVIKQAtsBKJRnZNQULucMak5HAuSy9nTsMzUDARAheuAmAG9tWJ62CpIZgPTMfjKDIS0t9A4LDlIklOPJl1PhUBXHylVi2BEJpAWQveBuouwMQRrSBGtNILQ82TWoABFV8xuSKnIp8PXh4LqghcaGYJdqLxoaCDtYdYDnA4hFPBeQKfgSMGLQoeKAQ5UGRAvOE7JLYCZBXOvMpqcOx6ieOYQRwEeVLlIkwaWFmQ3WCjhW6dMBI5H+AN4oAp4QhyxbvLnoBcNetiDLzBH5CfR2lGmgUqrCFRZj3gj+B1Q8CFdAwoZJgvtlABdCNLI7qFgYPgdMRPs7DZeMAgEOPosg60EshISWMNJAvqwjwGdAahDUkboIUxZPmjheRDGN7OM6ZrMaGkiYnKwiOP8aM4nIBVGEw12hZZm-CNZ03GLZhICNRHrNAEVFCl2oroGTwHWDonisAfZpiMVx80GKBA8F9tykGTRM46nhzsPYUsGRhtw6Ob1COFao3eO7lPKAOpe0EnAZwFXo0LRmQLyo9A0cE4xdTgpxbaBwAq7EFQpSBhAJqJ8xjMDGAJYLfIo4lqIlqTWpUSeOI0aDmC5IfrBdqOu0NoMtgeGPZEx0jgkpI0K6mENwK5OCQNBpMuIfGLrRq2Cl0NPKnAEpCAQVQg85c2GgjXBBLBkUEQhVPDpWiEDwxp871JV0FEwuMDTQraFYU3GA36AxiixELPM5KxqAwaRKBAFsNkJkKGeAhsPFXOyP3wRRu+xWzAlRipJvA9OLAAePaYBQ+gjBtqJ9RAUIWIbsGWBXBNAIQW9nQiMF0AjIFHobwOtAOVI-Aa1hM3shD0QwYlmwnRq+B8xJa7qMB7iuAKTRXGCY5nSL1pHZCTxS8gsq7beDhzVA7wXJEtgR06s2gVPLBkuPIpkKFLAOwL9N+ACrBV5Qu1XaxmoUSGIBI2CMsBpCt4YdFKQadFKp97BrptLL1VLjgSwTJs3hxSb3CPIEQogFtNAEENlIohHsSmOUtQ7+CzBxcAMgteDkVksQyaseI4IMOfzAIcPrs6BjpWtcPqgtcBSIrhO+w+AN5pd8D44NMV3xNwBcReSMg0MwKVRaHqYwqeuYdOibUleM8TAX3fvdVsBKQVEJTBFIBCgGAxYl6tMt83fO0QdK1NBqUiNY4EIFQlJGlnYwKV5iAPvdNG2shg0JG4uPIeAGACahIIixkqwDogIxiKNyMN8QahEj4zuEzlOAOJMfkPVwziNkYMcPnw1kxBE8wCL5lUuPI1W1PgRxpegNaP08v-C2cb+DCBDNE0LsEAuxycAwB0YGKBm4PYk9+lkkG8CepIzQqmI0FoRfiLqQMyFI0LGJNscwRxBGLDtBsatTpd7DRHBoGpR+lK6hFYKXh4ILzBUkH6oDjL4dNG4upCbHgQA0FqsaI5yUCKHMRrOFHW1HJHJXrTHAVSF7UfIDLZyhrFIcpBeUAHChA-4CSk8oJTYvroSQiG-4JEUoADhiOAoxwCTBapEmBVEgG56MCbI13Ms2o4haA08NRhfFKBByFPottvhxVrYkU8mlPvZiIFWAWut3A+OCfQ9+iTxbIA9gS4BCwoEAT0S4Nd0Ki5wRUABvRe0GFBrKrhb2qAWpyYFmJHSlszc2NhhwHPc58BgIBPK9xSMEpAxlSCEowmmuzXiuYA1BC+Eqa8DHdUaowIGB16dwMtAAHCPoA0C7wWoCGa5OKqgPhCeBQZsnBlNhuoouksQnUOIX-HEGpNUG5KgCLQ8TMpBxxxNyQ6Pm4gfeoFkklI7zKrGVA7+CnQDjO77gEPmQ+hEsQgpCcQU-ZZJh24ZiOiHUZeyJeQQoJqQoeJhs8KFAgD+NODrOlrxt+m+EJ9QmAvIN004zte33oOLEbwFzMKSDSkmDLUkZUA2AHRRRM-Wcthv2BWBSBFqsXYAZB5anZQbULw7c2CqwLIakgLNrPD4fGzwLwL4RYyqfANPIAQC8GzqrWR8RlSI+Q9kOfBeoDj44tvEQo0+JQf4KcoW6CJwezHnRmQQJWjkJuxqI7QFa5GQ4myE9YcIMWAQMlW4YRFot7oKthMVOBXVYBCXosJmQkmznQnwECopFT3AiMCTFG0NZk2hQoU9dAjqHIXkCWcPLQm8K2obqMAdK4FKoyuwZB+hJBRhqjKlt+L1o0RlzA+4ALAdOJyMM0IfhvHBAQhIBehCAAZgiArwx7eojEwyITZc1Ki04LCghQZnlyxZt4QUhC9BT0B-COcJXB7XR-N5aI8QbdC3QIEJYBpkNchAoDphrwG-BINDbgkoFUR2lCuJKYzfhl6G4AXChVVf3W-JREovm2Oi0xdnJQZYnE9QyUvFoBUHditYslQ6EA2RljCt5sK9bFlFHZp0PgKz7cHKh4YenIViujXSeKRYzCBUAOvedwlkNOBuwAFhAmE8hQ6D3xOAIGpBNN0EikJfBnLg9gyHAcpbIIZg1jtSw-+IzRAnYG70-q6lPtT6QtRNUd+Kh16+oA6gQWIUn3xNJEUqicMXq2sgZ8L2wNcHPhjs8xhzzM4FKrC1IWmOr18tk-xX0a2D9CGHhggAhjfmOGgCwOmmcpNrQIYRUgpGpR4DtJQxRErTEMyED2+hL81Q6P0boqMMJqwEIBqaK51kwDQEzkB4sf+FzMKpUAwzOK8Vy4KIhR4A0b8xLxh-6F2oucBBA79JmAEOpXADSNYgcWn6lF1DUVyiL81JG1sRykHIQR4MYBCmOXAxoC7BJoOchVsIBs3JQGhERK5J3+ipRduBFgTSLFhDBKscxijcRntC7FQyyeA4zqAhmdAXhcEATJI0AmQm4EnR1RFghWGBGh1U7nHpm62AjmLZx-wJosUJPaxRiDPw0RUYlaEKYJOFmzggkDlJgoGJgQNgEgqRP+NR+AU1CmXIR9oG0gShv236ZDCgShP196ZolBxe-kcxQEgaSCpUUPqArXDMZWlDCyIAISxikupsdB8YMvxNsC7Ar4Cph5lKcpHcNgRjFPpIgpgKIvEaeI5BDOAxwHO2a1klB8IBfMHODeBjIIuK0yGZA00RoQvfhikxlrYR19EgbzZL5YS63nYuIxKh6vbcZ1etrQG-cvA4+JToY8F+APUMsgFFvlxUECOndRKgg7qKORluAR4jaCgglGJyxLiGVAdc9wLgwD+wuKSSgkmKnIj9NqQ-syc8tyHGc1kCCsY0O4Iv-C2IXq+GgtiLp4yNLmok6Fg5bhPTJ7SrGzJsCeImkD7QD4yJxegKoRIRIRxqxAGNVIETApOEUjf0KSFACNVph2BKIe6kGMh68PwGMHJxV+GV3S+LuB-4ufAw0IWCfpLQ8k4MHkUaJBoHOHhR3+BiRQELgI9IM-M-UvNh+oMIInIBx56YrlAXYuTRDUDcHcFQPps6L377IAMgGFBtQAaPaQDVlW4MaOYIcWp5AICstJqYCowiMspg6vhrI8RSghzwI4IsyBEwatTMpEMi2IdcGE1TuP44pIC2JA3ZHQTklx71OUTw63HYQBEOhwQWDUEYjBrERXGArNCyUhzhoTk-EE0gn5OpBTGAYDM4IFAPXLLA6nDToCyP1ZjMKnQ1vurNyaHqgV0NDJZwFAgg1BYlfCP8Qh-Ijm+Jta4-mEgRetDemnfCGhAATJBcjt0EELBiB+Zlcwr3g0xbCG0gyHHh6ahNtaM+KUM6saxgg4F3p5YDUFiIM0jAoDWpg-ELABNrLBQmCvRczviJwkDWYTYMtA3iN2AusJTYaUA4hKrOh2HEHXGuUCoxIEEXExCwWgi8tCxcUDbgCWEC4AYPlofohCoqmlth-qrjgdgBUIcnG0Lq1Pc4WwUfA9kMEIFsHWohy1JAl2AKU6yQ36PiKdEkcLOGVMg2HXu2DF2nEC0OwB5U8uB5VzWA+wYmIHXMSCXAXkBtr2lKfJe3ZtAWChVwjEGbItkNExiRP4RWYKiTaHi3gHvDFoSICuiaWFWxGYEQFuYOVRw0DdBrxMyzrINv4gGEQF7GBmE-BKARlBNMpITL4wmBMd0fCE6NxcOsAfIESh6KRFwbdO4gl4U-BsFDiqQYMyHSeC1iv7ExyF0HtQCoGKMKhCiWSUn1B6Ysq4fqFARP2EP5DIGUQWwMpt4OC-zDMehRNsKtBNSOrg-OuUQUoDmpuCFf1-LD0hIQNS0z+OYYR4N3wuwD6VYAS9AJTGQWZKDXJuZEB1jXWLl+jdZVgROeBaotSAwacNQF8CmAm8PoHQtYGQh-Adx-zJWAbmC61-KGdsvO7WIUh-pACPIfFFEEj56EJZ8c8uXpF+BzAIzOapZTkU9z3NhRIqLBiKpZF0WCl8gToG4JLaFvNSIOgVQCHep7OFZhXTMohU5EB1FOHityKDlXrMVOhswFAAE-s1Q0ntwIBcNcZ+BDZBpwSs2EwDdhFxHtBcoLlMQ9ND4EyNQgv4I9gLZEJMpnesSsDBnE8KOuZx0DEROiY56-oBhQIILsAb0KdAIGAv6aGPWArkMzBlSCggCC32AePQfgOwJtEMWN4gC1CPoWmYXhxfARn7CmVhl-PTBWoCqAnoj+AdEOLEe2MRAQCL6g1pjzAiZDWgG2O1hsWEUihrguB56aQx1MIvYSKTdBhiNyQmIxtRbtEpIxCCn7w9FT1DVE0IaAspBsiK2YfiLKpBvfVxzcgatCaKbwwoXNArgzoY56IcIEok5hACFuhofGu41GOVGrAuLYXwkthOwAQgeGM4FAxlUxesLrAokFjBpIkkB2pJOASkONRdgKfh5FOwg0ABYhqYMU4gOEpSQiGshoNtVES669ZRbFUI8uYIQ3nI8gUJH9AyIL9UkKOdxSeA0iWoGjg9DKwQIi2Cn5lJywEMMnUP5hORMmKG1s0MFl1ZpYA9kKb03B9mRxKiIQ13CvQH4M8FJhGZwIpGGgEyPahXAFT16YJrQuaFzAvrI1xIuh0guCFmcV+LpBKWDUQdsEQ3haEYgAbnHQsiuvJz-j4wq4JdQOYGlwr+X9mvESOwqkCFsdVD2Z5UZghhqqdheGNEhXTG6R4qrGByMBob+BLGdmuK1QGxxZAbqm0QhrgfZ-YA2ou4WyxA0GPBIqsYI-Y95pJYE7JBUJ3pdqUqRjBFyJcaFwRKbMegR7jQQlcAYxLWHfBbMFOK13G6xf3REVtIJ1whUNXAjKIXAz0NxOQGih6hyorhL61epQNL4w95oXAL2KrGvcBWgUQrvBXkBVK-iPjRo3mrZdy4-xt+P4gp7JnNTR2U9KdVdF6YpnNkqM2BOyOVZUfH0BfIFjBW6dIlJkHEo63KVRQYlJU4Cmega-azBJSPDjOIHpqGYioXG9C1G-wP6RkVCPKYiIww4YDGyPvRpgqxP4gaC5HBpJNJImcMpJD4NthKIExzK7MggWgLnHbtEOlZVIn9kKBgU3yJTp3CJxFAZmpIaclgzHSGyZTOkWx8ILBYmEEwwDuOUx362MMNZM6Yt8sY0oSHJDxi5XAgIMaQmcsNVHZMwRxQBfINS8VAR+wztQVJ2B5sH4AgGJR59EBgZumih7MkNz5l0D+kRwONR2XRVwVeCum5YPrsG+MlRKWiFsbiLvhe0L+6QWMZge2Jkx5+hWBoZKQAUUL5y8akN3BCNvhBqITyZ7tYhRCEGgUPYshr6BKZ6nMfh0WoRpNaMIi19JYk8WJCx44KAwLiPmhMmKGk9ECckWkH2N7Er8se7J1ArqPbRRwK2h5+4GgZYBCgd4HsB5lAvA0-XyDjxPTJoZL4xKBENd6tCUgoYIz1-k3vhNC8BBJp09g27J3IM4unRI4fpAXRHOB-COZwqyMmJoWL5ADlHgQk8AmRWYF0BL0C5BwRMLNGkCC3tCxFhKAAxgDjOYRT5NEQoIMWVKhNbEacvQiVkP9A3GsqQAIGNkwYBTA7LO4nakazB-EHlyoCO4xjfNToC6MxBXBDfEc2DUEPYSqAvlCum1IF5xmYL2H4wNT2WCi7ltYGdwUJFepRcDhpGTAoB0-niwWGk7ggUBtwFa8FAHyGMtJiLzBLPkUl+FCXWsq4il84nxpKUF71+0Fx8Q8BjhesU7lKBOWBckKJYmVWXArFEAGHDdXxvZSelNG63pgkqAQqoC+Excrswc2HKgHyGJQzwP0UboKkQIYB0RSLCTWZIFW4aKKV4UEP2wlXtSwRCAdBuoT4QLAJVFIKBShwBAEgctBIw95mfArVB-N0oN0RHPYwT2XbbQdUSWAMKJDc7qWggB1NShLZPdXNUFp62frmAMECb7reMwYO4L6RBcCggVIAWVuYOV1zWJ4hdOIkh8FGowb4s74t8l9RJyD5ByYLGUROOComfNMZaTA9QRqicuY2fYVC8MPowGG6wpynXHHOvD5vEyCFmfN7BAXlUx-wHOBjINKuquW3x6ZiUMvkMKoycl9sFrIFRgsEjhAEtjYvetYBEUnBZV+IhZTaBCWxchrgFOK-ADuAhY9BFLQ13DfFAILiRNSG-IgXLyJYdN8LKoXER2Ms757YFURR4PyYAhBXFUkC2IbDvNh2oAKv0OPkhMGEcxvnOy7GwedABsCTxmgGyFUYITyEMXixqqHisUhOVh+CNkxiRLSJswGjhI+F0AO3XbIwkLuEGduagKLNRxtFJMQ1IN0Rflo4RmgGfgpnl4taW5dAC1LrAwQq1QMBEvzlXIwTXzDpxqBWANs8PaRLF1bg1yEd5pwKiQt3NABokOvBQtEKxXTNRRNoF3x58MaYC0u74A+GH1KwGiL84o6hqWhLByiKxgD7L6RKswhA3EFLEnGO00REN0BjXZG45DL7IotFVlGVFxmedOWwL2H9BVEjMpN2vUx4INPBMnKV97NAlFD+o9RbPeUg0-q0xTkPpBKSDTxi9EJMAcPFBBUGkQNSrpQEc82ulUNlBJWCjZO9O-QWsESNvBHR8V1mxAtCKdExObVhTMs2gTajPAocLd5fLBTno05cIS4VXY0MHdBQmCHgb3jx7G8DlBxWRZD9YF7wERI21SaK+6WuvZBb7KMdpOJqI8opV3G+ZRRyqPmQIGJbRvqNmA6vtNkzfrfZ9dj3hUoBtFMuLF1qWgawadAWUVQk7lsXIs5tIqnwV7BfJHBMPri-COxdINBtjqriGx8YG5NYB7RdqH-BCaNaLl4LcwbWKjAvamwVsFPSRT4LMy96OvIz0yGS+IFM9BRpZRO9GtIewJWQMyO1QXmE9h5GFuBvEKqIOWBZ4aWPNh6mCPKS4XLBfCB4gIWJgCCoLmx97P1ac8nlhDiNgoDViqFwYuFw0ngVRYwDZQWo+xTjkH7VG+RDlXrAYBLjtHg2cOvoZwFLRhEb+Rf3eTAd6xTIG9jdBwmJVCxhvkosrlxScoFPZyMNHRUEM3r8uLogY0Biw8sCJmxOpFQLN8PVYUIBgferzBTxGIRdYHyhPcA6YUuGhB4mF2AnzIlBxvG3AiYIXx6IMUhWMPsoksJ5R-sNODW0vUw12TJQGwDrgquUQZReMLhEMkDx0tNVE+APNR6siioPOxfACIE6g4SLAgsIAdP4dLqRG+RYBKPBoQiYDrBNUEVg-6PCYRMPSQBRHzglUBUIdQjDoIqtkQUEC5gaRMEwBOvXAXmAvJluF8wU1Dn0twESMpVOp14hkupiIMYhxZbjRcEAOxAZgLhOyOHpAGB7w+gqCucEGzXQ0BSh19C0xv2PyYZsOO4V7Ncl6ZmCxSJTIVjokCsU8BaxIutKvOSAFFhRwKRi2fYwz0MLgqh4zR5HAX96YLyJYeL1U6ApQwi0WE07+NzBHtsIR1cN7BN4izZZdCZMZpJtAoDD+Aa-uNRmgF4isTi1AyeKnwi4D0Rv1E3RBmOONMfPKglYrfYfUkCto0AaxFWC712kBCXkGv+BnvFahKEGZw-OIyAjmKKJ6VBKh4hso791H0h7El8o95m+BYCANBNxKFp29JFhiVz8Q-mDWopLCbsNMRxPNOoKgR9BvQnMJzBQNMkxXaHVjKdGpJcSFItG4IQSIXemVNPtMoGmOb020ZaR7YucFAIKa2ncIIAWJP0oVtl9YpypzgThlpkw1bLpFLCg4nyL1xuCANhlEBxU2IAvh4l1REIR9Hm24PwkMUgzsJIN3QuAwatlBOUAa1DnlakmTNEMvDGMEJCxcsLE5JEEXAQMrlYtc1VBNFqNMIkAjEPeOZ8NqPRMZ-HR8+tJkxSYBp5syvlEvx+Zw-AKnAt4KYwewPEwRUFDAGABSgekIIAMqvZw2mGTxAsueBOIKJQsdNeMK24mh2gDMoHkAiIFU4quUqsdJnEGgjbCx-AY8I-wIi+XA+QQ1AwoBZtmkFtA7qMWwzsDggtIB4g1Na+gEtM+QPeERAmW4twvlEU9jzkxy3YBEhzVDYudwFdFpEJOBkiqqB3FNgovKy2AHMDhDEMhmP5MOKgS4GbZddvMoi+urA0AH3Zq-igglFf1gqRF64S6FAJXME5RQ0l8BqWMZgH8HO2GmP7wVeMYx2cF-BugF9obqGiNmIH3qxcpBATKFmj-iCFo5IIuIMgIzRS8FKo3okSgnoAb1vuOWAjDbd5+OO05fikAwteKmSAmsX4+cAtB3qJBAvtPVOipFSIAmtlpt+LvgCZC3JEwIgNje86YmkHqJ5UjzMj4BDApnUnMoInSI88AXxRCBUZNSBIxATAYQN6CVAveJwwgGJ6odOH2kcEBOBxqJyUYFA3Bb8gx0raESM79OFYd8N3QPXApRKY5NtoAB95u4FjFr2kR2uqdaRUYPRgxQDdh90BmRowr+g8SKDxyYEXEc2CiutCC185ADLgUVFZw6sfyB+TOMcYWNngEdKSs3nAdx2mKlQ4EF6hqkDeg-6OMYHbL2guI3IzZbibg3CodgCEP2tW1NAwHufkYSuDYZMFahQ3qFpAZAlWwOAFJgroHiQwmmeXuMVdF06AXBkqBRZqNY-wOQudABDmgR+iJKAkDX4QyoJKhdkLF1zMpFB50G4VyoCJViDKZxaPK2CgGCzg84WWalkMTBrwFd1+uH5wmfCJUlAA2o5z2El-XDDwDoAm868-npziDdVOmPZwHUInoVSKkDYKDvB9JGpQ0kBzA01PqhPmLKRisKmBFYD0QH0HvJbjKnAuNGTAKCy61LCA7o1LQJspUK-BrMkCoU6EAhWYFOAqwDroh1M1RGVxEWWV8rp4mIupzgi6ljQNCBWL0FA7uDSVSaEqhDnE8hNFt8lxwPuAZwoegIoAXxBUCMkM+E9FfT8JpugE3RdkGPZa5NqdqNdxi-BBLhgDRXE3+F5RLjoCgD+HOBVGCus4EKghm4MXB15B-RmwM2BUfKPRisJ6hwBFTDuBf3G1BK3k6DFXYDIFxNOsP0bEYfhxS+7jIyNJVhb8mgBUMJuRt0JcoJEB30JhKNg0oLXIG-WbBVoJ6g6cn7HjuLLd6tKQJRpMIJmFhbI8SJ-g9m3Dg1+MlRPjEcIM6KGkL5GhhuI96dmqA2US6Biht0C1piaJFRSBikF7ShgJpyFOx0WuKzYS-kpTJEkpymMIJNcE9783fEDzglCgFNv4RuGpMABQBtI5wsvQTIpWEeoJj4sIFzAnIy5hU-Cbg8HoqZq7dmBjxN5iRxvoRXBPbFerDgAwQmW10AEdBC-oNQ2dalwAnDgh0mPtBs8ARoXYDUJlXOMRSZJMJElx0FI+uOgPKgXwoUFGJMwKYxHiFEIDAV3jIShowSSDpw88FWwFzDUJKSF3NqdLSQSSMTcyze-wzJLnv0WtkkIzFRFy7POQQcKLI+iD6ROSlW4tEv+t78PrAwyOHp+FEEOBoNMoOuCQNfFIyBYLOpgOmFOLLGOgBZAAx0FNiBPF+OehkspVYsiErF3wMHB68KXg3LCBP2Miag+UMQXqtDBc-6F64teBiYFKHHRj0NiJBjNMQGArKwcoLFhWoHrPcID3xvHHQJ8lNOCSuAbapfYMZeoDHp+FMJgGBMO7uZJOQS4QjapILs5HBKgQUbEQYiKpiXEkBFAHFLihoGGshUaXViIlHHQppftAF2shhsIF-4LkP-F7AoIBZ3PaxoGHKJCcHqIBwOBo7eFRBHxHYAAhM6JEUnJCmrq2pm020U5aPyYL7MqgoqLFBuSOdeNqI+AgPH2MTkmRFKTI8huiIHWk6IMY5Y23BK216x+ZkPAWWNFQnHjkQoEJhXW26Fm+cj6k15IWQIpOKBG4OSsgUB9gSYLjBh9G7yuoH3ZP6WTwC+HnBzAMt1joopBTINvoIyFKRQakNXW2O+x4GC6l5eBbAP7ZTZNLn9E0LdMhKEKeB58vcoDAMixkMCTFJV+T5A8Cvwg1NXxSgAbBajN5BRmi8hA2IIJRjuAgCOGjAAF-NRYGBDh7EAkBsXEC4M0GTwrhJrRoBGEURkjBleGPcU0iHvRobFLIR5f0pdIF64bsE0IVYFWBAqEqQyBDdYG9nv09DBQavgAgxrsGTQuNLoY5EMW67pcNAUwHVOupp1Jt+N4mT6KgwGVKUAHRIBJ0RJWEyzScQ9TL2hGLGQkcAAkwZZHvI0oNmMwoQdwoWHkY5EC10Viun1RpNGAT6JlJQoGtjMypDwIRyvRHxQUgxHJnh1OgYIYmC7k3eezAoUF5YqRL+hKWFGkx4HdFik++xeINmB0imURV-BLAOuENRu8HfKGMJM6A-GExJyIdxUYBLwuTkTREYn9eZ4E3AcJMVgTJQAhh9STwA5KZxCGZ6hlJPkgQw11ApypUVG2jUhQ2Jp96cKb1MfAMwJeB2vO69fenGAwEdQr6eidmD3TOPPhbvO0hRpDmoEgJxA71qqZJnVNjnglEtuZIc5xSCaRzeqRqDUCmAG8QtAShnl2ncmdhFxCXQqNW5BXXCZoANuEsXzPMgIH0QZ7j0PAwoMpg1HAWIdvLHfNG3jJf3cTEx0gjpcUD6J4G7QlIqFa1dTp-hadNa5f495BKsJHw0JBhyuPKPAqZAdBhCdzI2CinBsbYDM7sOdFLlpWB-JL8QTIYFAi2PZBI4HbOvrtZpGcooVzcGmgG8SJVzuABBeWNaQOQoLQoFXMgLLFXZ4do3I29NWI9OCjQE3i61aHsnYdlQKlNYjvAQLPExG-GLhDwJ+k+Um24l1KwwBUloQw4BmPFIPfx+YL-KLsoWDJ2IFqnxSCw5kTLJlXMq9omHwgTHMVvXyQ3hcvj5BVqwNBS4MLgKBHshG+afI5iBs6i4h1QsdJBEaWJaxLIFWQGMa0w12KZJeay70O3Z0xnggagnyLshf4+8hdnDthdYIOgTZA2ALIC+NQavxw7SGoJ5wPQxISsCIdYBWhOIOvJ8uG3BYVlGJzzChxRbL1Y4CzfwckAIBUEFKRYwL81taWRpokJQgM4C-V5DKyeHEEOUMOb5YB9KOR99BEV+BIuFjpFWQ3GuYmw4A7pAkJ2gNy1cHxcJvEXcsueiRIvx06qagSDE5DLlB16uELvRjov-FakByhvVGoBsYDMB6cPjQ98BAx7aGOkYGoeN3CD0EX6nohSsNMBufCqQdvMP9XGGWM9QhEYUGNukc1EwI9qejBguFcxhWl8hWqF7D0KMgRYA5nGvoGu5AXcVUEYSyxvMTHBFuBcguELBi7ZDmB3KDbJdIG6nhERtRjYAPtblimBm8BxZiuA7YOg4I5fDi7FEUHv7uwK2AUuiC0HHEqg9QiuJYsFMh+TJruQMoMhpsq14PvPNpMYL8Qo6KB-A0lFoLaF6hLaKtI5iH-YGwC73c2BIwgkHSIZYHCJdqeKyXqwqxBCBjgV1gXxBNNFwsDBKNq2PL5WzJ9IDEzawxYJKYkLXykDWFpB7+BCxKHP+ZLqOlgPnBAxsoBup96LYAZ4IUwShG8OGYiZp68I3BqqZ+uiMN2uUhPfgyYgjbjoHHZuBGE1VMCcxqNfeCuPhGgrJqs22mEP1ioPN4IUPhQSkJKgWMlF0lmJNPsIIwQAHt4oo9M+RNGwrAdEgatmrYFkQ5IBJAZumAhOK64xRq8RV91RwYhHVi9BLohI5MWxpV0lB7nH5YH0JOxg8iiQ0GK9AuPKOjfEtv4ZAsdJiYOHQJ2e-IuMi0BUi53IpVOdBtqHVjQlbfQiMM6wS4AvhetMIWBuk+ZYsMljXyPAxRLNVoRNkgOpIL+6dXCjZugjNi0CJ0xW1MDVp4NSwc4PEu85fWAEJOYZwV9wQr1FwJntHYQgFuVAU0GwUkaJZt3xOrNNMAdBh9Oq5Lj8NSuP0fOXYilAvEfzEyjLih05GhaxJo8oCv5F16FPdh06jfwa1JtANUHqxkiljVqwJYQQaG5YHBFrgLkv9hqBfxwiILIBqRJRgvbi8gdvM17sShiZXkMlgNZB64yCE2RnjiE0IoBzwx6D-Fg1c-ykmGt+0LagAcIYkxCjEIAqIu5RsoE2ptZc+BdyK0xQyyZQKitXCooANIekCaPrkrxp+0L3Auproh5kE1dwRKkwNJedB4D0SQ9eEIR3EOsuWmAT1KwB3fWwW5gUh2yhMLiUXmlulgqaWfgLiA+JZwMEAiSqDET7ioILoHaZTJE0w4ls+YNfPUv4lwWB-RNBtesOEsiTcv5dOOnwdEnWSnMOnRYGCquUPbZPZadZxl0F-53CL4Q32Gyg2UFWRuYL1gTajhB7CldacJGDLezFrBpEisVEsZW7mXpP3eSLE5C4BjhyAOhRzVhq465n6lGVEJB6EJfATYKA5hNBRZHtvlA72xW9Cuy1JhqL50gWguARXNtRH+IuJKhAUQXYBcQQQtUhOaFXBv4ij1iYP9QbmHEQdDKcQuPsg0cUp1PygIEmL5hihkKOKSLYPog2iGdwvLEVIL+OznOkC+ANqOSia+CQMuPFqtqdEyEDxjf7Sg7wgZRE7k9oLDZeoLgt4zW0irCDWKt0QJxBEZHwA8tBeCJ4EpAxJMP-Q6MBJABhQvIjEwJe0UjRKxCz8rHhZLuYAWnomRPciR3igwCzgxkDdADYAoLBRRO2ST0DYCE9glLBfKMd0VtBTOpyU17T0or4oivBdwOVIKvC+yAcWe3AqhPlsGkjr6JBwtIyHoED2QKiPQLcUsKyfPnd2psCZzNMwG1DuMAV+2aBK9JcofSi2VDog7MAGsOloakDFJi7kewjYCNXC0NgQMKXAsFjjiDSIvsQvwCZI55QrFLs4FUAw1nvMHECMCNcY46xbyGnIgsAsQAKg4iTBAFLA+rAkGORAkpjmCNOC3gjkvCh6XCCQhlhEcMB6nrYQg0iSKtkIqnAaYrIkjeBrYOkUTYhvoNZwbLAXILUofMBiOFjg4xznlMvAtYJU5BnQmejYiBAwFEB1xvm6iyCl4Dmw5aiidL5grNgJsOWAoMwYCJomd0CNSCjQ5dh2-i5kLuTnYO7sGNCR2LwyPvQ-sGQw5fTaRBeUAhgBMNSwI6DUsFSES9wgQK6kBMjxMJjoHrhtMFEQ2DgJTDAA9Wgo0DqiUaR9wIe4FaRAIKwgveTh0HgQstx9gI9Q2WgkMK2CcJDoUJUIE0Ah6JtAOYIuFA8+oNT3cBFwHtACgH2ibWDH+J-g-KAGwOn87LrzeBLwiAb50BEoVga7UNhoiS69VGQQ7cAZYPewPOiVQikO7OhXgC2CTdjLgBUUcRBeLFjoJkAVIBu4ivATkPFo6LQLuOloJmTt6B4qVGp8SL-gkGjl2NugJURYJLKwJSC1ClUwbPCMys+oHFSAzGZ+HiC3CMUa-eDqdOWA9MB4QMsYN8AIBApQXczyYPugHboVVE9wkWCfgKGwGBgLQJqQY7APkOuYEABFYP1YXHreJmT4wiIpdDXIm0AJoDng1lRaIJFg2LotdBsgg1D9KNCoHLBPmFcwH-icsCIAXrp9ABawvcTqQPaUYox2+BBENYCa0Ma6k7B2yIwwOGjTCLrsH3gr8LQ8+uwoQBNQ7ABhcA0gkcJM6IXgOCDMWNWwEpDqdNpAA0AIuE1ICGBbzKFoFUqDIKWwk6AjHAUQ1EKafCNgvCR5YEpgvSCw3DWAFSgOtJyBnwIFEC7kWOD2YGBAvbC4LFvIofQKLCIgFiQrpoDAPEDHVAH617RfwDdU2P5MhGpIWCTyFG+wBKD5wLOggEBDqNLIliTAQMb49mKjQN-gLGS8IBAwzKYzUJfwmtDq4NuqZBCXHl5YmBBALPyiy0iroIv0LTjh-LsAxUAD2Iago2pAEK4ALQ7u7NiBGzBJcPuQ6PgwoHLA2ZCfwNw0BMhHsHUE-MziEMz4V6ABhJostCAhRI7g3Sia0EmAVcC57g5CfoK4VFGID1CSLPUwm7Aggnuw8yh+wJUUnnj1ZDSIzsCWjB4sk06dcKRABqzIEC3keIga+H+G3AiqwLtQFYBXIk+g9OBFIGkQsFhAdDegfKgh4KWk9kAP4OdAm8AWwD5A2DhmSIkwQYjZMP4IjvI8UEwYVw6rqIhs9LJkCPdCaaLKuOtw1FgmYOjQKJCseJNYYkC5Ag3s3STZzGT4yKjBQBLyeggq+A4g8qD81lRwobRAqDgguVBfwNlwWJx1uGxA-Ix9gH1Ye9DOXLsAaIrSRLigiFi6wLYg10Bi5N6oFhBKINRYJk5IMDv+zYAz0OQA6Wg1gN0OIGSadLdQGjAqIEKmKoZenETQINDKuMliM2Bd0P9wy8AkliRSf6AN7M8gwWABMJcekJR5EC5Aj2xLsAmwfySmZDhBvViaYIIQZhah4HGYPR7npFOUxtDmEgja7CANgPzMNayEGFFAqHZpkNDQiqSrNuIQEbSrIPdwxWB7gcgQ8tD6AOh8I8AagexoL7C3UMo68OpmcCGQDYAhkIG4ipgwNm7ArMDbUOKIChAVUJWA3ZqaiJTGY5QolNf2AlZAtGWBFiDJgKHQO3hKIBZwhaw9QHRgGKDrQHX00bz5bK+C2DiiUBJg-fD58Du0DSQgWHwo3EiUMNtg5RCpBJHAVyKJCExG7hDsegIAciDF1GzgtTjpLHJwKOCjln8QTOjraoc48DCQmNIgWgi9cAHIwfjaSE1AEra98JpgJcKi0KJ0QLjnQM-YOUCn8OSozTDdZOJQBTZtcJQwFHqIxLkCAZihYDYYXizx5L3kyyot0DhoYBDJMKvuLYglLM50oyRzXuIQMaQl1qR0dgqtqHv0eTjTtrFgQHDcCk1cQgBJQLXIm0DQ0IggTehUkJkwVRA3xHeA1BB2lpFUJKQHcCFQgMB9CONuWOC70B26DcA9wE2ASmZ8-pVC41AuQDCQ4WCPsJPQIEDNwHngobxy2MlktlSkdNfA74AwkNR01LAcoA3i7kYcqP5QiEAA4NFgcNgE2CFktiB9LrHAfKCXwNEQ7PTDeJLALXw44FRqD8jM6CsQe-T6VmMsbWD0wFx8st4RmEYaO1hPUNuA1ASt5MRQEYgyBD1BxiBEGDGyfRyTmCbUc6a0ruzgk4CU7I9AOGgIMPActHgoWKcAh0CUQFgg4AjmQJuIzDjocKWYTTrT4IyoJFJ0COCEJoj-4JpcOx6HwPvUGsS-LI+w0ohfZFdgoUACiK-g7Ogu8MwQHfTIEOUgH8AEcrTgxLTnwpR48Ojq1Oy6mBAoIHUMy9C4kOZ8I4C5AjBQy8BPyFrg3VgwqGW4ykgz8lCWdZJFYCkIrnRXUM6wDiAJGISWhmKHwFwBa7p8wfpgm9QupIZSWoDUsN0A9yi3oLHAbSBuoHz4vMCMEndQLqwU6KLw40DjoEOIacC8MGYQ2aa4oOrUI7DkUFWIH0C5EqGwjsj0SKl6thAuRlL+COTJFF6Kbkp1qKFA6TB1fKnI6SKiEGwUOqIwKHYQM+RLsIFkAOj51G5Y7OjseiYO+9xxoBewj3QqcF6Y5fQwIK50EOrmAM1ArWSgiNmIdgDI2OjAb8AdwJmko0grplOU04BziPJQyt6iAWrB2sBekpFQz5iCAVRwlowDHrKYxSDJwCxUN9TyomvwBYBJMCQMUsB41L5WQahyoChINLC98HJAYICV2CfQa8ArIM1gzajKIJ1Ir3iMYONQMighqORgoiSSqAOgpcDcyFZgyWBvEJqg2-Ty8CV4fYz-DmnAvbByKsNcUYivkl74GzB66Oe4II6L2KVQluAPTpS0GDiteOXA7CDUarmwze68ePlwCSLgCOFgARbAQAEwXvDdmmAgq6hMYDgkXpin0FZw9yK9YFN4jnrWAOCuVHDEYBOQXGglgHfKkdiX8DgAovBsRCVQT3AKpvyAx+zFYLI6Iejc+Hb4DGDjgCGCAJgk2BsMfoLaEJDAdHzaEGcw89KADpQISOC+KHhALrRk4rVEyyokGK1oLuQy2jt4IiAKInCQiTAhaA9Q7MBG0C3ev6DYVvMoxMBHeE5Ca5APgFuQDvBTIJrQOoSBQCh6VYCgzM74XrgY0KuoyuAFqGPuFBqUYBow4iHVgHwoYaCWSF8omv4KcN5woMy96EWALqRxmCf2-iCzImNk5nxEwMaggwy8ICjQUdISVh3AGfDy1DrAkcJFYNfOOyAb9CjQ77DQEBtEflY5eNNYm5CWEIAwv2g2sPrs10jD6mfa31BD9KF0Z-CPsGmQYCBecHJCWOjK-j8yzPgNkByADuh7NuHguni5WJNQQLg6BD6MN2DONm6QhkDWRGaYuni8QL2y6y5dGG0weuhKRmt8UMCkyJ2QJZixaFmUIZ6MYCl6HISgMA0itST4VJmQidAUIHj+c9iNoBegy4iPkGtM4LYjsBqUr2BJzPAwhiBYYBUUL4yKcC2CRPAG7KFo6UAonGLiAK7TkOYYhEioICGwosgE2Ksc2w5hwNiUcxjynPTAkRCKqBPq97Cd0LAgUKAhCgR4G1ADIC7wbfAmZDhAn+haQEpme9BCMOMQe+jWAFJgZXZAtOBormo2sGJ0aCAEQBxkBZCWfPJApZhB9j4QeECmIAtgKCA08N9Q1xgWIK8QifwaGluAM8C8MGyCDSK7kBy4ohBmtqTkiAy7yK9AgmiT6OeGltAiVDWA1gDiiihwQHAREovY+eDgIC3I-UyyBmD2hNCFUK6YNkDMEC+YsFiEONuAP7BDgOqmpmRMIqNqi4HGmOcEcaADYMqQrTBXMGfOSNA7tCwUJxidEuAovhzJmCkIpVBoYKDEIBCR0MqQaMCPQSXA4IgCGIZibPC7wKQMJQjmyFxMaODOZjUkkHAY0AKUXIiSgKV8fKALRvmAfcgIKnesYoD+-pBSUPC9sCCsTej-rFOY1xDPwO9Q16BycOD+AlbmoKOQY0DFcCTAqZLW0HRmmGxtCq3Q+SjRIK50wSSAdMbIseDZwblQwkBXwOVAfGi2wAAgCVBwej2oKgh6AK2oF8y6nD6UkziEEtXwxjT9BuM2K4CncCumXUBb5HmAPjgJgNBYxsABeDOgi+Ay4LbAXHxNcDk49WghuLEQ5iCm+ESU4sS9WKIQdpg4UJPooBC6ZNkIgGBEyPGu-8RT2NmUf4CAFgwG48hHgCoW6GF9MJvU27TeOHY0vzTpsE0ghyBNKLNwf8Dikj3gYnQG9CqEWUDcQPBwFUo3+vugr6ZXRB6gbTDCcMXAGaAbEHYK81Ye0FCwfRDrAO3gyAYMMtLQewiqcBKAbvKzKL5A2NaAEDIoBdA1+q9YdbjXoGpIM3grrJ9OqeDngAHIDGCnEJkgZDhvyAfC36idwPyAWKDR0J-o2BB6QDP4T7CF4JuA4eA3uERy7QrFlH0QTTrH7A0g04IqcKs2SzDREN8QPojTlgGg9aAicAWoH8CIQJ+A7QChoOeBsJaaLLDiaOC7modgfcCGoPvYvIAIYu9A+rDVaN3YR+6EcM+AoE6mIG3UZPhXasjgy3yy0KJYYaAJmHroFR6CCMAcegAyBIG4lBhJNBKI7Sh8pPOAuCDbhMEA8DDs9K3yFSBCUOfAlbrJ5H-gYDCjHJrYS8LeCCmgRqL3ULZgfqTlwNkQOiQCVvhApaQ8xnoITCALsG7IZ4B19JKA5ODq1FrwV07BCFHkozC6AD9ExaCLijlQgjjtAKA42cJFgCpQM3jHnFZMoWAvhOSIurAGMJxAbw6M0OOAvihVIk3YHnZjZNoivihH8HQIdHx50OJQoWCGvGDSajQS4JlwVGCEaFbgl5AfwP5Iblg1gChcd+hIGpiQIxyvQJo28RCTUMKofmDboCMgc4yVZioIzsDG0PSKgqAZVJzAYCD-jLggbKAzNjTot3ghEIHWOwB2EIIIrgBNCHtYslaVFOA4HUAqEPTAXkA0UO0KVHCaFtIw37CdyFoIQjDV-NKkyrDkrGxAMKBkpFREJQzVwGAgIehcYm0wDOHnQOMcudSXQGo0XHr5CC18EwgWbMqwEJ4bUPIwzZAMAIdiL4gtwHYKQ6hciFLEoXTOQAxgx8YrFJZILd4sDm4ImlwSCK6Y+HDoQGD2ngS-oN7KuQJsQL802ME+DPpAqpCRYNEsDigviF94ZqAniNwQkb4woNbQmqC1OCpwQPjQbKagB4DLICFuoSCAUKjS+SBmmNKkI+EwKFUQOuiFgipg+xA+aJ8On2ADMJeQiKR+EJCAEERQIaWkOaAJ6LhAlx4zUCSgFMCzdvbAHbpmEE683ERewtnQtJDrsJ0iYXCIQOKyMKrwHrig0jCTQBFwZwBaJCC0ebBvNLUkR+5ewvSYxbC5sIeU2CiIoLmAt+SlIM1AzahfbBQaRHLuNCnQORAWICS4NaC2IFu4kmCMMJnoI8oWyBsEToyqYPjcLMELmDJIKNDQMDKI8PhpwEtSKggCAOPobO5e-GnkFsDwwCxA9hiJsI8QWvDTCJNe3AhoitDQ-B7EcKHQe+CaXP6Ic+AGWF0QJyTUalu4PpTH4a3I4f6FKLnGVIik0BVwCZgO6DUUCZwWcGQQESAoSPeEKeCn0OzgpwAm7NS4fUAssoSwoDhUVh9AC4DsUpbAzkBAMFrAicACgIPQ54G81PEQXtxeuO74xSB5oGOgyVD98F7Y7FJYoH-Q91AhIF5Yv0BCoKzAJbwj3AR24jCP8LbAUizXwJUIDACjYCxUlAhmoHWAA2GIsBiQelhvqF2odgCIZDpg8IQwsAb0OWiRYLXGPEjp8MTaycCMMOYwQDCo4Fn0OnCzcCG4RDaaoOrMlDhrhnuolCCR0P5Ym0BI4IhI0qgVcENQOJzIsDoOpAwGQMTADSIHaGGw-B5NoqTkS1K05lci8igEoDogVtA5sJj4sOiqJK08ADz2QFSA4Dj7gNlAZ17NQMhgfQC0PJj4uuDXEEpmuHSXoJCYQ0DZEAwQV9BBEOnQfqgSXJW4oZaSmE3YeL78VOnw65hczGkwH3gXHMmY5JgIWAMhaIidkFhgVZAQPsiRUeJW0AKgjy4ByHUEC1yudEewhVBNwDX6UUhfKL9g+aDdDEch+9xFYIIAfhB0YASg0EjFJk3oEpgx0JhAAP7hcEQQM7ZzEBlUe9DO9JVQvCA9AOrg0DyaoqZQ4+i0iGT4pyBCkPyAYTBNwLnEVcAHoFdEjxBYoFoschRbYBJc9EyP6IhsyBJQIIYglULs4HjCoNQBCD8gi6Am4N5BQSirQB1IhJHnoCK24kBemHDYWYC2fJBQ-RTIoLCaMdCOWB9Q+sAYWERw0nCeInjhIZDYCC7wG0RmgJMgmRBsQJVQo2pW4G7wqEgAcCPA0CLFlkMc94IrgIsaKmBOYLXIzCzCYAlEgehOYMnwtsBDQDlIrsjvUEHACUjN4CQMrH55Xrpw0iAzeOJAampPIDCAAcrfULSIVyJsXk1IeAgioIJoqojBQHOCNbQ6IAmqWqxMhBEUFPy6kHDAPRDRsGG2RJQmTGggQCwfIICgSLirNuHuxkARSCigjnrDUB5URiDd8HIAbLBwIKfChYhI4IJoYLChzqPwwQCovrfK6ZhDoTBA1AhHeOWoM3j5wEoAiLBGiECsjpCOqIxAEUjw0Jz0mMQAwJggbljuMMIe9jAMYHsAO8BNkNDQ1iChdJQ4XRASoHykC4BoEJ-IC4CYSEE02LBFsASwtUioSLdKKgiqgG1g9MRAqMXAi+BY4PKiHipXPpuIXUzvUADoVtBDQNR23UCbvnqEWOgJvP6I16xTeJ4RyEB4inKIhcDkjkB0W6CBqB9ciliOwH3AozBFsEB48tT0zLKoU+BnQOuwDxHMvFCwBfr73DR458D8oIrwEoynJJCALGQlDBAweRh+4dLoVrQk2IRwxbD3IpceUzrC9PpA24AKFJj4EUg+EBFAyTAgWK8UXAD-AAYI-iFBUGTi04CuYFug5QA0pIAhOUDPmPvc3i4a+OUQRyA11IXAZOi0eISwV0BHCGeATAhqsAG+BHJUVJWEDHSoIFvAApApdBv0EjDGoNbGctDBcElAA8CHjBqwjpDc3lM67PStUCVAP3IkGCKMuQhL0jfyoGgaEMb2GNiZtkmOoZBD8KfIuwBnIfMo4sS2etvwRWBmwJKwERIjVMkg1OhSNs6IGhp8IDDArg7YsPaQnBgImCOAvOCAoDDoJDp-nuL47bCtQBTAx8ZQ8M+o7DD-cLxgs9AO8BLgt+TaypbgJ4Ag0DNgh4A4pPL4V6jbhLjQ39DgsMXUKsy5AnVir2DWgjcQwiLlgLFA1xBsXh7wezAqEJbswDgohOTQNfya0N7KS7DScApws+iFwJIgvfDp6kewbaKsXlXYp2DpIE+YC+AfzJNsMDRTSEOoIWinYOYSapFDUAnoseCi2C2CtFHDQI+QwebIqESIg2ARYAvA0OAS0MtwC4DyogXwpLgtdJjgyRG98MxgfKTTQGTAQ1weEGDGq0gtMAuYOwAGQHHQrkGQaCbUXfD2aCEgt4B4Tsro6+hqNGKAO9jWMA9QLkglwpKQImgsFCJwDdjJfqkOyeRSNuJQAFCKwNWBGYT0TMzoAfBCkERwlZjmZKggmAHdJPL4GjA55ItwN8SlAKhwGwTYaNggBYh9UN+w74iigV7AEiJD+HAgrugEwJaBm9QDQGx4FFjGICGgvVR0CPzAkPCDOGTEmuCleG1YqpB4ZtuE2TCUGOasWDIOOClUYuQ1QNKuqxyvku2wGhCpiGcQBiDyQfo07j5hQvrQSSh5MC103MAsVGVgN2DdEvwejhbgsH0IR2DcAHlhvGB4bPjcbJjmMKJI54C8MH3I43he2HKI2-AN+nJC5kBfYAXgckLTQFfQu4aBgd6IX2Bc0DnQTiFrkKokgSDfqO4gNeTokQTIqOAiKCbs82ByFDsC5SB5EPGgGzCn8AosXk7DUD-E+qieRGRA1Z75QEP4kcDtULHAuZy-xI2S4xzJ1CxklfijOrVqH-B0QIDMlDCcLFjg2BAWiEWaSfgJMD5YSUAayIII9nBgoLV+STRBUNl+8hixQMRYmKhc6nZQvp6O8PngLQAioNKum5gDQApQKaDMOMIio0Ch0BywuEBu+paBdvgmDjZwx0ggTog+ehDPkKcAASCL8FCwMyhiPsTQ5NDtIFz+1URt+J101ioHxq+S2GhdskvqQLi4oE7+LaB74PxAGwzf4iVQXEBE0lIs-IHB4edQfUjGMHvRfRDZ4BigwQi9WPhAydDeJsLA6+jRoBEo2liVRKhQmcCZzAlIbiGsQAmEE7B8IEXEhkDXhPWefIDrmJZ8VmKzIugAKEigMDIEu8gYmFzATwRLECxA5XKfmPogEZgD6D3RzOgVFPmA6+jigBPQxOD18HdAYNJmMJH08yC2wAuY6dDQIAikvCC5kS7ADHTDHqEwqkDWAAgE5VjtCrrg6Zi6iHb4u5j+-mKQTxDTgAwEa7qpcORg6ih+4Zk6zqi3CKO+JxhsRHZY1LALQMWgYeDOqLDoZZq5gA14aya5EDVY4GjEiFFoucYiVJUUAuDYODUIbjRT2AJsAaDCFk2ih8SByILAuMjHICTAcBSIINZkKkCWkOvotUCDcPKkoDi35IUYTeBsRM-EcBqoRA6YEVTisuPQ7LrUQYz6pnQYgPYYWQS-NCMkHRDa5O7QCqaLhOmUGaAVxHV8sISUYMJovqCuCAOYMkA86NOAndBK9Dw2ySCUCGOw2Vh8oEC0QEAxQAUQp1Du8ClULaDXNDSk4sA52uQAILCwhG2k2Bal4LrsWsI4TCkIMMCAoNuQGkDZaFrwzTAooKegK6BW4CBO-2AUwLg4DuiK8BXqgTKUeCgQE3R6iPeClsAy8LJ6CbB9jGdQCUTkAO1Om0Az4bgqB2C6cJQIawAaYKXkhNC+npp8luoN4JwhFUBqOFx8ISCFlP8RwtGbYEjQvXA4wuxoHbrEONwKecixYM0iPvQ7AnUEEBgoIKpgagJlgM709841MStOJAAegWGgTlC5iAPivQAf8IkwyCjnlIuE9WS9SJdADSL9gHUYXFLgdFokp4DeUu7wQ1y35NsYhmDmoNTqZ+AWeBLgjYgQSD0ugyDdAIWUVzEVKLtQDbCaYCuw1YHpoFvABLD0sPvogbASxPvYr7YK4P5IjvAJsCEoQKAFCJCYKXQmSj9MVJBbuJPQy0BVMBfAGNoe4gJsSDCwILQ8EiZrrlcIVIgkodrAoDAx4LAwgRS2OKsQ-RR+pJFgv8QfeCpAlLpvtg846HzYIOUggWgE+F5YbWCXELBEV1CNtFbgDui5wEDEe-TcYuTgXtwkEMN4hbT-VIHgrxDVwMBQELryMDmCd6igaGFws3oM6FnUaTxztqkSTlAMAAdwRcB7QJnoy3QyBJZQjcAyQH3enJB6pu0x43iQaKnQWsT66r2YgZCEaMYW2kHRQGYQCNCRyOz0XygZwEWAHPB2WFicUyD16BZwIYYoEOSot8jvIKhQg5aSlpYARSIsFI-IboE5eB7OiGQ6BGVR7WxnYAdoSEBuFIjA63AgnvKchJFn4JvEI8pALCmq4kBNKC1AFMABuHEQkVCu8PI4LLBN4Sug6fjyYMQOaIgKcP2gwBpFZD3gRDCE8nxI18R5EGGqjvCDMI7ykggGwCcMbHQO8PrAwqD-cI1IN+bGQB82r5JWiptweJC-TL1Up1E3rtVEvYDl9EMaKa7fFla0M8ikjr6Rp2AMBE7e0SBQsPqQMFCYWD1a2sB3qAGguZExPpcQ2uSbsDHQNxBmsQnEvLA+9OCo884OkPTMkwisXtOQvZB1zBmEoLxBqFRqJ4jmpiVElQjKIF70ETJg9kAwrGA2yO7sECCRCMkwVrqawAmYDXhMERYQ3sj+OKhIU5jmEgmOPeDRsGmgPdTIkXHY3OAmYLyIiySIsMfuoMSPUPSQrLBqcFwAuzgeTtrQc+BxgEWOzjbnYO4ogJDkMGoCGgh7sDB2XQARSCK4iEi+xLDYLTBdropKOtBEKEMm-IC6nASwKcC1iDmCV0Q6hD9AarC0iGzwyKAjqNPR1FA7VC8woaTRvOVhgtDm9BA805BglNkc12RSLM-ALBSNiPEwKDCjkFWAQGhKxAvkupy4OLiQHFS2cIWCiQiASBwRXUxc6krgEZgiOLnUzlxceocgG1D9FP64uhgjwJ1ILHJ-0BOQHIDghK4IlRRjnlGxH3jecLs48QKSxLwwOEAGwCjQfHHOhJF05qBAtJhIyKAI2vwwAohXhv3YdVYTsKKg6WAlOIQSQDDYYR7giFR5GLtQM9C9QBn82ljWxHoIvfqDbtLIoCDu7BRa7WDp-L3kEjBEyOO4rmCDsINxy2D5oANYeFDOXOfosCCcjI6gp6AjVCXC0kjcBhKAI7BcIJZIXnBPIMRQRFpBNFDwSdA2GEy4NSyRyMXUU5jCfr1I+C4swMuoZ2BmyEXoQHSSBP44RPLw+M0i-4yYXJkwhGgfIBoIj7AWILQGCggJINkIQ1AbQCDAo2oIwptg+2SvFJqQJsBI8bHA+eDNIia+-v4-RJp0gKBAMO+wKFGD-PSYErCyVrAAdgqiyHqg5yA1+qYIb1A0UJOAPQC+KAposkAqgDfAL4hBQA2QdQQycIFoXXBz0EUGaxCOwDmwKeBrsJRAW8y2dJawp+B6BuYgB2CpeuzBqLQ9sNXA3dAaCHeAm2AeTiusIow5gMMgZzFMcpQwV2CCwFRExVB1WooQdQQGsDGgw9SkuAHwwQK8JAFAdQYHYLrQozrBMPXgt1ZvUE64x8YKLKZI-jAy4KYIw-yeIh4sHGREBP0UIMD7kPQg8tRhoP4wNtinnsVgNnDkYM6QDZD2oDNQOeAwNM0wEXA6hN3Un8iXLEWwPdiDSLYAFFim8CQQxOHaSJyMqWGiSIng85ASjIYWwrRltGPAQgCK8BVEF2SdeNMYWWAu8MaAcMAiWG8QHlTeOHPI6og-BtMQLkZjZKNI6ZQHaEfAGFhFEWdslNgWEEvMn2CSLEQE-MDzKFgYdHxSQF0QayajHLwKpPBEiKZQKIQiUocgxdSFMWmgY2FJcIfgYtAEIJCw4rI25BpAp2BjwETSAQgL+iXCieCY6FmUNPDcUE7k7vZggIghFtBgMIHqksDd0soGT1B+QCpQlhBnbIThi4S-uhLwmAYSwHLQe8gLwBRYHEBSqDvo0Ahk0EC4JkRmgIKx-jDOmNta1IC1+M6KRHLsIB7A9hhaiA361pAeEGAg9kTEQBLwukDqYIFoozrViGDg8BBx0N0q2ZRR+C0AxshFYEf2MRhoilrUbqh6HNXCElGskIBAKcB4wFcwWDAfeHoAdLRuqAvkJtRHCEBApXwWEFGI6yCf0rYgs-EvKD1AATRcwGJgKKBmbEKwjvL0xIEmJdCqJKqgw+iDvgpsu5BfZH1OEwhWpFAhiFSYENcoZQwtdNTQLFRfULRS6SzF9lxM2-TaWGs+FSKk0CV4gTA72FlQSuDYOJQ4kzjh0CZKQKgJoJtA5jDPmn3xv2jlDNbQACDUWDQgmtAKEJ1AZFz92GAwc+BElKYkChCBXEn4ERifwOpW5ajViN0ED4h2UDkJToywrLokUpA9IASqMIDBEGOk5ph6QDmOXQCafJ-Id8BqIDTmQwxX0FmUukAsINwARNDPIKZkcFhQ4IgKoL4m4BkgI8q3UPls+DDXGvnQJEbOiCrBDtx44PQoeUgkQWC214DNIgZAe1LIIP4ISiCc0EP4dIgSwBmQfWCRUBcgOaFwwAOBLqw9IGjA9EjfSFIsv6xfIJDAq0ifSOiQiuDNkI7wLFSnAPggckAn1utANOTqoIxYLGAEOrE4afzGiGiMDbDq0KXAXdDQllEg5UAM7H-A+SBbEMvw8iBc-us4NFAooNUIIaC2mHOIOx5mSM4Edbjdmlg49Wi1yDqgJaImUOKy4KKsIJMQjyABcCt4afwhUDcQRmzU6HmAGkD1aICgGhDCQGsmCOQ5qFWgiAwvsHXMxiDxAsXA8yiNxvwQ2MBOUDeATyKLOA-AM-DOhPnEM8ALIL7WoUD73NwQtnQ-SMpgQmpQIJ5Aj9ASMHTkqcg2tgWkM4TzghcwF1A0-CMwe6ivIPIYRiCc4LsQjlh7AHIAiaCtgt0Ia2A6ovugeVBk0AEgbkoa+FBA-eBEyAwgP+wt0OKy-bBK4csQPrBEuDluEJZU4Dk4OEIsFNRwJ0wurJwsbqo9EJuA20SUmDpwF2SDYKpwuwDg4FvwAog3wObIbrBaLBOyCcRu4N9g5Jj-thqU9mjXwBbAgtAHeHuCFd43UNFcQGDOYhLxFpBvVsVQ3YBvUG0wGY7Z5hAQfSB0iA9Qgbpd8O9QQYaHmM420xgzCEvCX0Dc4LfAdkniymaYWjC0PKlwMFBxSKhIHhDDXPzg7vj8QNuQ2GAWgGpAnIw3MBtQcfAqILtE18TldFgUrQQk1Kl67AyVRP44MZpP8HwgbvAeuP0UBgLtMGXwAECumOjA-1B6QKXkSKQIFGIA5TCjNCsQlnzXoOyo9TDawD9AGQnhEBNAS2AFGNnqKSBLwh9g2UBmmClUDvYoOPrAPfDKSKOcsgCf-jawfWggbN4mn8C04KXgAbiOdLDiwFSiEMzyiBqvSA3AZOjXSIdAk0Ap0MBOU9hZ0TPQ327bhEZsCggYmGsg-ZDoCVggd0RRwDsAPJBkaM5iHlTZaBcgvhKKFGTibchkkK50nBjAHJCAVFRMMOwwfdiWULpAPqSiwnlIxmDUsMNQ6fzVCPDoMRgnDK1ACgiGxN+AfnTqdEUgyxBFBiICx3A-VL7E8LAvfnLYsNTuAN7Io2CGVmEw3qj9YD3R7LoakC3EveSPyJOg3ih6Fp3a0iB3YDzAyFDUatOgZETJmHViHrgswAPAMxKleKzi9gR8SPlE1LB4TKnIYaAyyGYQ1bCtmPI4SShWFLkQkJQbcLkSBDSYAZ2ALmBdAMmoukAm9lWAu9FSCGGgMGRIESzAtcg+9O1cvhzZIGgJcqDqzE0gmuCDvmQg3MD5GOrwHvCU0VcGP7AMzFHAZMQkxIkwMqxwNhFUSiDHiBhQ0MgFgBTA-3yC0BdQKBBOCd2g0VDR4GGgUixtUP8ADqCK4E06yRQlYPxA-bClgIWAqQ7B5AEU10C6og5wXNCU2GpoQagJ3OOM+mDRvEBo1LBjFLrA26AD6FAY04JawFYgQKzYKM5AIMCl4KfelJh6amTAdagJRDeAhmiSqPTMhdHyUAKgh-qHQNGwBBazIl1kYrImROLatKFT2J0S1LAOCBdkJ0AyKOhQWZQpULh0fQiBujDBtFAnzihcqfD9KI643sqfyAQg0bzyWO1gVWTUsCzAreSbyQxgJNjHxmdseVRK4L4elLBRcecMOvCm8A7+FOiiJEWwivA4aOQwhSAYJMEkfYwvTiUIoGg7ZOp0wXBMYHe+26DW8LoY3fD-wJAa7viLijIoACjM6MTgyRRZoqSEV0Q-9tckqoAN7Gjgj9DWxKDRcBSDgL5YJOA0pHu4KqBuIITYgdYPkKNAunBcTNmqDXjjuHiKfwZi0LwwdTgoCCCsTajQCI-mieiwAlyInET0wP+sJ-ZzGLuwaRChINqJRbAlXgOwbvANMAUQBuxdyJlI5hhEkM9oDMmsXl1QCZwY2GdguVDNYGTQXNC1JBCgC851gPbA74DngPPOp5BuQhikkfDtUEq8xaDFIEmgwcBRyUcUeWDboOYg8iAyrjA0l7ARkE-wDZCQaPTE3Vi14P0QTowcqJEg9TAmiOekNuT2kClQrOIPUHIYMoi3LKqgt9iQaP6QXHyYAnDgiSAlQCfweJAaoBxkiGRk4tbg-4yyqODA2VieqOpgM2CKsM6wRPF9aNxIt9gISb80wxBBiO1QcIjPkMsBWYmYSBlgECCtMOKAYTTN7q2oHnZluHzAJxjBZNOYmmg-NCFQvWCtQEZUJgIuavxoksARsBoaMwgXyen8heC7SH4IvjDrElWARMjzoCRo-+g3+l-AJEAYlFrCniBmQCmokJiQgEq8xSYy4EpGedCxhNwKnMDsCXmACAQZxCn+6SCTsClw8QLmoKJYNASKINZQddDecI8gcsG6cOy64rIUQDCgW8hYwE06xWBCAHqeUsAL+il61pCvwLLYihTJ+JFkoqDgwApWginfSPcU3nAfwBiMRWBF6HWgWUC20tfEJGitBPDoyrgI5GCgp0CFQOnIk9CaoKb04lD54DhAari73hzA17QDcBsEM4gocG5AabYE5sKCGmKWABBIk+i2YIuwFMDsaNpAPsTWdEKq1Goy8JM4o4CdgACgnYBhqhVUd5AISETIMDRVZPKBmkD5RD4w0iAZWObUOJzeiF6Yregu5C1ArjBgwGRAMbJH8AERegjPqKZIU5TuQHlw2UBWqNZ0acC0JEVgYLQ4GCgUB6AuxHjC4hBTQD3AorE5QB7A6ijMSQfI5KD3UPYEf+BjDCQUxoBEseMp1LDO+MtIPbpidHxI4OAUoPbglJhboEKwfWC6UMwQXvqXYEdA68C68eEsGKSNiFXo6ja4LCl097qZSICghVBeuOdEcTYKsGB8hVAlDAnEnCzzIFjAekpPYPtAxvAI8LbAeDwHYLQxhYK3wDGyPxAo7qLA5ehigKBoghFzULyuCrAIIKl6CGItfJPyIywF8HTC0REi0OYYWM4+ZCJwAjj2ZqjSlMaQQEgQwiIZWK1AfWjQADBwnUhXRE3gqEQq8BTAQ4BQRPhQpNqpek6Mlx5fEB92dvQ4JNjMD3jmCKlQqEj+kD5AfchViETadGCbcNi47vjEwdOAKQRPPjJIgKD4VLJW6qApCMJGmEBcek+YZkhEkNsgWCTJFJS0x6CftnAggTB3cn0AggG+IMbQCUyr1mWAJZCJwM3A-pF1uEyEnDQi0EvSX0D74E9g0EhsKE3Y0abNet3SGVhgoHmAUdAClAi4SkYF8N+QobwnqJVY0aAAKJSQLWBcCMo6oEB-Pl785Ih1oGAqqJC-run4PKEQlhpKRNAtMGW4v8SJoLjQIsA5gghg7FKmdEXAIBDmIGoCNcAj6LeAVopowJ-iXuDYaHLAMwlQGDSUnUGRuLSoAYS14I3AHGjBCHMYBCA82kBwGfBJwES46rBEyLzAcghZiQXQlMigaP1Gf-wn0FqAnezhEexg9uDJYmLAJABOjCZM3ZSFEeksbO6aoPBhhwiF-iQYbjAZoJOw2DgC4P5gK6aaFppgV4Cm+H6kNyDmEmZwuNBSqPTIQLiAAiFoK3iICQT0QhB07sYw2qA0sJZIhmJjQLFACZAHsflsXQh3vi8oq0gVVAWkS56wAopYDigQSLwMqnjmcTrgFoBZIEB4KEAKptPAoLAaxD1xjfKZcDWg7hBcAL1YFxDgICb63Qz54GggGVjhcDPguECdwAGM4XDgoN0I3sB70J+keBJyoM5ccfBhQubAYCBJ0AKu1yRg0k-AtxgJAMUgI8DZED+i82D7hPKcOrgVShFAzogpDndAVRBZFDhIfqg1iS9WMKoWMd0EsDAX7i9WFJDIoKWAlQjXCFyk71BmyGq4IlRDqHZMatjmIA8gyJJQCA6wqLTGKMJwqYi2VCLA2IhjpNAICfG3oGoAz5iRuF8QHqQqMJbgpqD0YD9ETSD3KP+sjxCPkLNwyyoVcCDQQKj-gClAr4BArKeIYpBQQIBAEaAWjNesH8AghLnAxKEcQA2QxcBt4DhoC1j5gK-etFSdINOY9mDC4IOxP0QpsZqOXEDJYOdAh0CK0JAwNUlqgEdgniCAKFCg11pt2GYgvpH1ZByEuqDqsOKSSfgPIFXWs6DmQFBAEaj40MVU5ILH4PLUOtLq0BO6qBQ4QNpE8hgAIJTIjXH1SAQgkcB4ELf0OoTzUIMwzGAl1iRSkHDXVKQMBMgprrXgYXxWYDu0D1YLmPUwKdA8kRYK8tTpsNZ0KUDB+CumZMD7QLfY0yBeWKXAAEANwLqcKkgcEGQwUEAgtpDAuUC67NmUj-CTWEPwn+hxrg2gyqCdgOUYhyAnGI-enaDbhIoE6dSzoA0QaiDw+GsAG8RHwon+sBCIsCwUa7KmZOQAsCBYoK6gwYCBUJ1guqBb6vtwvQBtyDkwhZRqCLWB2Ig-9lUIJxCukd5oBsCqYEqQ9OChtJBAVyEEGbvg4pLwmNSkhSgniJismpCIaUM6fkAFlF7YHRDGYMeIfECmdGmQXnBJDmE0uMBk0CWY7LoJRBoa6HDZcGREXnAMQDhAvhxlYGmg6wDqwFkUYeDuCD+AE2AKULgUUmB9ECcMkDBiUEz4ZsC-unU4HvBtpDBQL4hXIthAZPB-8IamJZBjwHBYAODHSHjgMtGHiW8pdeBWFO6wdTi56pkg7bASoDQgVZAnEHQIpHSrSOeUwECw8D6ko0gKFBA8IoxpPBZA1RYVAL-EE0B92JeA0NFM+Kcwd2Gu0BZCVcyacDlANmgPYBUovDCzSSigsTgzgInOrKiEEodA-pAZ0PaiOgS0mDnQTxDTKEZA2lAZ+ljgJMDl9Fgo6tQWQlvIqXCe4CKQ++CokI4Q2iCYiNQq5hgQukeAmiIsVM3goMAgtDHAw0BOEPBYkwhpoIFQPwF68M7kGFglRCrAtmDXoH1oFO6qoMYI3sD9IX5gxzK9mEKwPUBngF7Y62HF0sroH0Ap0GoAgfK3GT9y6ops8POQb7B3JikgemwlkN8BRcQyBJuwZ3AySAwQ7MLTMNWI9AABFC5gNUCvdrf0RUAxshGgEDBewndQShJ1YsWs17QGWLGE-khqEF78g0jMvD5ozrzUCHf4MkGPIHWx5UCpQP0OoMAV4Bq4kizCEJjovXCdgGUQ7igOoLmc5cD6qEsQzvicoGTsBZCf4H-whYCTsO405nCxQJZo4xjcyMLwtMCvSI4IgbDbhAD88DCSsIjqtyzRQDYAhGirgBImp4DtMG9AdcYf4E3gQ3xoQbmc2DHwMFQeAUCaNjBQlVjUQqOi3sri9K8g3+iYwKLIDphDYMYg7VBCwK8U85AK1h-QKsDnmHhQzYDRwONAwnz8gKVgozo-sIG6kGjBCGNkizZe2HoAh5IhMPggV0QvgCoIbaSRUI7IdOQniJBEIWgTqoPQMKh1gJAQlywaGlOKUSAauK9AYNJrgP-AZWByECgI54F+qjfE8eigyJdgIiDM0AtgzxjW0H5ASyAY2KXw1ahPQAkgRLiVCJsgOYDRwGYOSYnXGEgQypAicBhIiAxoiMvQ1bDtOsDAXHwiVDMo-ABeLDOgQMQqFlmU8jD1ERyo9mB3yuOIGchLMLmoOwKWJPCwWoCjqLQgBpC64MWw5hIEaG5gZNC1KE+QTBjO+DoYt5kLmLhQ4Swl1kkwH3g0QNvwx0jpQIeMJuxSNFsyt3id6CqqzSJaeslklKDVmg5utAQJQDgg3QR-eo9A5DBJgKeRyaDGugFwtiBiAAdgNOQroO04uUwRsF3izSC6AJGaHcBAqJnY+DArgMfgupCL4BnEBfDCCNX85nAHxvhUWYjq6hDgZjCAxHShNfDfqD6QXCC5WHOI1FB19Kfw5qhDfFCwPJz1cNesggDE1m805nyddAlIzOZTQNSA20D7EHesDTBpIBgIbdg7QJzA9xSQEDYYLUiaovhU4srdNN00ecDowImQ0shrTFI0JmA66Msq3EiS6h5kxClPRIPg1gC-NIDAMKAF5qH0QpDqILFggtBYnCt4NaBFjCKgDPzowPtwRvCWwJmAUdAyULuAq6gDSOPID3j+gvYELCD2GAdADGDJYgVQmFS6cGb28JiiyD6Us+AioNRQOahQoN6o5CiJAOXoaIzYAP9QISzddOlAlcCFwV9cvvDcYvFoNOjFWQIY13oTkBq47bBOqDkQfIJLEMOwmNTd8KY+vsBqsN9AqzavWBOOdYIU7hcQIeAzAPmsFUoTiKYIJqC2QM+c25APcfQoX2RDEP+Ac+DGgLogvEB5sOMQ44g3EJKAmxQ7ILOAC1giuDPktSgzgPTAjACeeFqsCUhFInpqdZZ5oBGg2ha9QMbAxLBtYJH0ihShtE6oK6yFIOEsBeDofH4QrCgPULgUOYCWfOsgIwB1WlUQlLDHxtEgwiRecPDC8vaDGLr2JDbrwE84SiBk6D7E8mBhsJhAy8DdZMXAYarzYNOgHVivoC1A6nR9gKeAYISUxsecpujTgjxAILREGM1EWJEo0FigqBDNjh+AZcLnqA4I7SjgvsuoX8SAId1ANOh8SPogQiAYWSZQ8MJOkHaQcEBR6ESgKDTufs4AOyB5yIiBkoAeuIUo1WjyIA3iJKQCwOYwXvCPQFPgoMgLoIZ0MaBDGpQYx5x1qIuI04B92N9I0yjisueYvcQeKqRAIUDINP5GVOAfzHh8Ewj6wPGZIWBoSP5A9GAcAPrw+pB9WCPAInDY0LxA9aoSMF78pFgNeDawEXDuAJMgJwwdSMYw-eD4DDA0a4BSVOnh4WCcEOtAMfDm-nzQBHaqJBoQJVqniPKgo2oTIAuAESiL+DzwyuC+wGjAkcgrltuEQ-AJ7qGWDbA3gE0gi2yvYLwg1NBEyK9IYQ6y6NYgWMS4dEEIWIRKoL1oRKA1qKyQ+raOuNyI-wD5GCZAlGDnmEwIDCDXMVg6oBBsoOtAOAAk8K8x1CpILITglxz8wI-QuuAVSvtQ7TqNSKNIDTBFPF1M9aL3OL3kuED5oIGMMkgDwDKkHGTTmFJwpiCHcBiU8HBkXFQg5uDxAk9gkdjnoEiJ0LBpqGOkUOA25HvCXIigMAfwtsDU0JVYY4IlREUkwwwE9KF0I4D4KMBUcgDmZOve5KAN0JS6aWaWfHDkCUh-SSogoGhoIO063hDoULuwpvjXIMXUwhb8KEVgNUD76A0ik0BJjlok6nFd8apa6MJczBrgwqjawENgg9TyKIDIG1C44FowInBmEOVgmhZoUJuw5mRNNmnAETAuRsnQpLi8iOSYc4A8wA026IhRwGjAd+ibdDN4ozBwcG7yaZAmZAKQsXSR0MPUxQIFEE6M7yBcaA6YbiFaJI6gxUCnwvCEEKjlWUQgSSi+uBtQ5rCuYPwwDziBZNpYJZCE5CNqeb5a4ByoP6CVFDiqDAQqkOVA1yT4MNyIgbpIiCEhPkBqeNFEyo4kQCigL4xhkN3w71CAYJNeFGKwIK0O6wJH6L1IwRCAYB7inmieICHoWiQJRANY5QD8CJro9OCzwqAQJmhlQPoQ+5DKoMfSDADAiKTIWsKUAPSYTmAWIM1wLkCPsDJQpiDjeO7wKISRaJFQf8lz4OCg5JhP2E6YGyCx+CcY2GFtogBAUSC5qONM-jhfTP4gdCCBut+Q41B5cGPYQ-Dl9IXgMyiQwHlwzKSqiE7gpCAGEJo2oiC9YNDYl-7HclRUfB73gVSitCRORpS6K3i9wDpwk4C2ACFEOnCSmIQcv2BTeCgIeNSmMMog1mhkEGHWedh0YL1YnECOoANIIei1+N-g5IjaSKZ00Pgz+K9gBqxrsIUg48iUINMIjABqaOEgluAJkMpAO1A3pipgFRiGabcYhmCEpGmAU0hbkFYgwb51PEzoIShXau2wbvASXAdopfCZIMYIJKGzINAQotAIYgE4YtAjABAMuYgRmLzAY9D3YFWeWITCrAEImPgj6KDwpVCz0F9ieLmGAsgQCcS1SBUYHY4swO4gE9CQ5Dl4vfCxnKkOpVC-xguEizioFFaK9tB6AIIQc4C20iuwihAndmdwkBAtcmOk7jDoUDaxCcBe8K3I1kAgQLX4XzjoGExApVCk8LXon8h9pP9wDTAeEIcQZoAF8IuEn1BAtEFpSpDaFhKYLkaKWBvQupA+RjEYM4C4oDWyokgyiGkgRzAEaDzR85D8COrZXsCNyB16r4AQoPng9aA-QLbQ-pBzRHIQTQh9AF7gE5B3ykIKdZKhdF3Ie8wcoH3YDBCEwN+cjKhEIHYK4oBXYJyMRzCIYG0g4+gzYPvYTwkf7EMaj5DRINIk8ML9EKqIpllpEIWUWWArcOPIEmB6WpqIYNJ1zNZqN0Aavp-gE5QakCPKPkACxucEWxCWwCMweY6u3n5gTUAGIBPqyxAQMJMIJoiHxAE26LTghMMgnmj0wBoaWnrI4CTYkmC0UAKgrgBt+OqwG2rHdK4IjXD8CNQgVaA6hORg5pLGCKyoupwzoJJgr36B1t4I+UQWwKscCNrvgKzY8LDl9m2ilDhaJK+AsPoVGDcQX0B-0OXAgMQ5MANYiBJElILACtZuQLO61QgSJi6kXQAI4LU49UDOBPJQMigqkAfGbkDqwOBAmqrngBdaXkAQlj3ACaBmwKygR+gk2LzgxiBxEKngmhYaygOAZHCOWDgYEa4iLl8op2DEbudwA9jk0IHyJkpYhAfYTuyHgPpgGVhpZh30p4AJxMNAtpipcFwOUEDlYSEo7jSlBJgCR0SV9DGAVXorrM0Aa0hNwKQIRHKY+NWwediWeYYYEOBy2GoCH1LWgbmwtCTXerR4Naw6dLyIM2ACoNzgLWAUoIzhx+z4XvFAi-iLoAkw5wRMcnGctfh9wPq2fRAW8FREb7Au5BOyfND-rNAQuBQmSOiQIahRGfc4WCjGNNsQ-B5iwObkfEissIv4pzD+EPbQIqDBJFzqngBGuG-IE0jiQLSIk6jUiBEYK3jVRCQACsBhsLO6LPyD0GLk2UCotErg7DBdVNkw-Ch5lOSg9BCOCOzoRkDUtCZo8+B9AJ4E5KCw2JIskzj+WAR42kgQwF0QeFCKQOLK94LM0NTQa9ZwwOsAfplFBqvwhmIbMCyoOUDNwDJJR5av5FVQQVCWgcggYZD9EA9QmkAymWhIgeCp4Dnkh3B8wP1AJvZNCEhAOdAjwCwUlfieGN+oTrh3UG0wFO76oMACC5jtACMkzyBLUCKMGzicjDfE9yLQqCiEHVCbsCpARhpoQqLYVWR+EF70o0xM+AUQ3VhA9H9EeDweoM0AJxnwAPwINKD+8ANIS8KYBqGg+UD5QKDEhLkJnMt0gqCIxJUUr4KEivyMLeAoMLqwSmZfoN-QDIKaYKwo5nwcQPsQLHD2lCqE-0HkMDpgCCDyge2A1GqE5P0URYAdQI1wlxxaEKvwYzKeGLJW4sDeQOEQGAhxoF-AF6A+lJzQpkA2aI8ol1BsdI2IG9DZEPZAllDFuT6Qj1AoSBiioBIiVEBwkzh-TnIYwSTixF7gQSirNg7w9EgT6vYk+0CC-r9MLci-MHYKOCCJQM5cq2Cw2CuI1oKtQJAgoMTK5O-w30iMEkGhAciUOGOwOqAoPC6xD+Dh0Prwwtg7eJOQtLbqXo+wQHQqkIdAgjgWWA6w-YpYIOSo6zjkiBdkRBgNwCoQxBA6wNOCCYRycWcR8JxQan4QR5QhYK7IurAOKrYQvhBDmKeGsZQcwDNQi3AFUCKQmSCNIBBIQ0ibsMdodHw34Ngg16TO5JUImEhvsPHIqfD3yj701mhENl78zCz9RjtA9pCs4lF08vA25OUo0uFtUJceYCA70kOkqHD0zJZ8yVAY4JyuGrgqvgKupYBIFOPI04CDgK3SvvBkpJAQeiA3UFM6SxBuFCAQ2kgcqA6gXvDvQCeAehDKSKAkACixQJygTUiIzl1MeIr5rMmomuB0YHeQRDiY6KLgowxkxCb2X8Bk+BImOBhWNgOor0CqgIoUgMAUkF1MDpjFSCg406DjuK+wkpD9sCRo8NDvUNoQbvBpyDdwVwhuIR4qJnT+WHwAoDB7zGscVhS6ID3AxgTJmKzYl-AEQOLYzsCR9CaglHiqwPzoaRBJNA5wB8iZkLTEDADYiSjgvhz6qNFga7rlbH1YJmT3Iq3SUTDqhKLwFRiorjSUxsCRaAos0UDIBg+AHFiPiD8Q9hiokN4IOEIHaGRI1nAYSDZwWxDgqM7kNfr0IBfISCDBcCAQEijw4jUIn5hsMJZQS+pHeEvgarDpaNQIweTc4HIIjYiPgGQQIywp4NoWKFxnYLDiXeKR9PRI0+CVYDt4nMBhqgHsX2w6wEOoCZBtQNfEaCBzpkXAsMJnbILQeuhFqLaYFAgaxBtGEjDwxEXQidBJMGGqb4Q0sFyk0BCo4DQE97CbiFW4Y9DURlvwTVwmSO5AZwiAUG-IYLDFlF+I7gC+JIagDuCekWuySBqKWGKMwsCvtPyMmFyHwNmAjhAoEDEmbpCYbo6oVRAsFClQIISsWOrM0DBSqJmw4xxc6mZw-ZA86Euei+G8eOKgiKSVQsfC-HAfwEVgt8hbYAjwatjaICGCHUAQSLtEIjjsqLcYh0CLeA44hHDboKngTqgUGpzAXvjq9MbIIWiw6JBO-sDb+LDi25BFYNyIlwgtMXBAqqHM6NoQb4SGYHi5MIgNwNGg3spo4FWQvyA8SPBAGBizwhs4eFCfgHjAsPqOqKb0JXg0BOCEXqCMNpT5osAmwMaYupCZ6NZoGHKhaJEQnCwpgGl0KyAhVJUUKITghPwAqYjWxvRAgWQ5QJCA0PjvsJ7ScuZ4TDZoXMADYcYwmpBd0I1IRtDyQHBY7rDl6Drgh0C5Eoc5RegATobE3KQniAYuyQoIBCEKxihFgJHwMgwgbB5AChTVsAUgC6hcUvSYqhDPzK8QvsAsFLAkYuQzeLwwCWgFIFKp-hHh6GJyeyBzIA14ivA5BdTQApR3UNEg+0CPEPn5bUCxnHtQ-8jtOkTsb6B4ihIw6sCN8t6of0QVVO-5GNgJ6AaQtcAHyAYIQXTGCISCtgLZEJdQuVDcEP2Qx0CNSPRg4XCVEKxsK4CN8pOAtjB+pAasT1gaEOJKfbbFYOHQFsDhLCbsl6AUAO2ibqihsKi0GBhvsFVkypBCofLwqNIlRoNIx0nkMPEGsFjGoHyg7mAcQJEIb5BlQG4ISECUGLx4LqYJMPnwmtAihFJg1AX0sCn6WyBIGuWgVZqBkISkmsCcLJFU4+idaTrorjBSoAeAYxR79BtAb4xzZn6YbLBnoOOBGyAGrKM6vNQM6Nuk-jBt8CHo0JZ9WNVEvNRTOvQw6LSz4NXwjWAn0AuYWUC3UA5+08CwUBsEc0D-rP-EI7CzIkmgzYBfOHPQg3Cnlkga+NAWMLx4aTBoIIbA+znZgZBoEEivwMPq7kjbhC0g4tiqMC8IAaB5MGmAuSCocMZwJeQPgPmAifyqoM7AabQ4wA0wJECpUCgQ0eAIIAE4O8AhKHjO2X4hQDYcRWDeYkwYHlROGGo491BhMEp2p0T3OHqEXsBoYK72MuDUwCZK3uxALOn4wnDwYE2IR0Af1u4ACZgUILogNXp8hu06CuCiWHlyMGQLoFBqJmD0QDoEYuDSqLtwlcDc4MvwZWA4KWPE1ajIKA2Q0iIuRiMkHBBfoD3Y9ACH4JHYZa5zoPAwlNhQjnrgJrqPUP2QsAi8gCioolJDQF2y6sxyRZFUFFgjHKWw3tQIMOa4S7BbzM7kqfjLOY9Aw0BjsHNSKNi93kBoi9KiECEKWMAedrXoZWCHQIdw48ik0A7oRHAcWPVAl0VXasg0RrjeOJtw6sygyQSwvyBGJPJQg9oTRAwI-UBTOrKoWYg4IBXuQ4BI+JMQFIi0jCz8KQR9CCJwyujQEOQFO+DO5N+AfsC2QCMgmiyvSAR2W8gM7Kxg-OhOyJceXpgfzJgwBGjwcOXAmAL5bD3RZWJFQF9kW-ClDNRqKq6qEPDg2yqjgiwU8igZWHpa4rIa6Jceo9BuQH-yZbR4UG+wcEAaqHjU-9C7cFDqAXDvUFZhgJCc4ORApiAWQu-QrpiVRHvAQw7doCbsE3CWuhDg8pyHsChA2WjFSMvAupy3oAOg0JbHQCwiDngnTF8QCa41BLsAIbjlYCz8a7IPOBik-5iTsJxEI6ZUVDHGFnAfIJYkGEhg0WPcS8w5oPD4cxBw2Nzge9TbRKzie1LMWBr4IYaQgBIwBvQdSDDwYMomZD9IUEALyDDB6fCe8I7IJsCOKA+ARaKLqOYwDHTdCHEIn7AWijdwS54qcARyGEixhC1oAjjCqDYAUAw4TMcgEOaeeP4IarASXBQgBYhVZEOIAOAqgPQQDOaswhpiISBuuY+AdECCECSkezDDXEWwZOIuQGbAhzanIIYgF+ZgTD2or-HGNCTY5EAduhpAvaC1SFsEsCAEyDqEFFgTjsmIkHCIQBggYXBkwKnQirBfUFuAdWIzWd4YdHw-gFegllBcEEAQieDFSJaQEZgnEPLw08B0cfDQIFi-FAbAL-AjJDBZYTQu2NkwKITxmhgheLDcANFwZEQpqLKchDjWkIxAtxgZVPIYr5L2lK3I1IBYJEUQOuCywGx0anhJxHOCObwtTl9QXEx80AGMnqhkMEKQmjY8kJM4fNBIoIfAlx58wJGanaD-VKf5RJSNSKagxs7DIJVCh4w5QMMg8eROQNl+LWDUUHJCOUilUK2gyRSw+ho6Unot5MP8vWAwsLigsVECZOqwkQit6MWw8DCbiL-IO3hJgJq2Grg6BHiglQjQ+IRI8RBfIN4m2spe3BUg0CD1LvoYDSJO1GAwfQQo2LZ68qKEEs+o4yl9YCeJc+CHcDZwsRCrQCMsrvAzhNQI8ABTlN9A35x-QF3Iiqh9yGEwpmQXICdoi6DSyHCQJuyUGPf5-OgNIm+wKUAm9kzkwTC8wGFwUEQcqEqgZzAzYErggyBjgLcYPpQRiD-wPMAdwINA44DLYF6gfch5gL3ItwiKwMi42qC45IiBGVTgaDUEUGrGcIyo7YCIIOTQ8rK30I002T7TtEWAZWAHaKtI+boM7Gdg8EDzkd3gEMBZooxAdIgSkP4IeEDwsDcwxcDw+fDR8vAgYZYmDLKW4AmYMPDHAcAa5ADUKk2QLwhHQCIoSKTbGM+YxHAchLZgI8oKcK5e3RDTgFUgLvSFKNBIV1DoiKhI-1DjiURAJmQpcK+wwubOqL4k3JDQ0GOkOQVIQKWkx-gpCHbGQBCaoCJUZWg5grfQuFBs4vUwsCDncPtwgroA-CTEcFgoMJpA9MwxIEq8-2E7IKyqZ6mCoKQAdpDbYG4acfA9mQpwxNTVsCIotMR5ciSWcnB+Ek4w5QwzYBmo1GiEwM54TDD1MJZ8JFINgBpAK8jaeniKypmbcGolgbDnKGCEeOABFLACMkjGIATQCaAGWEog+9yQoO5AoMhhJNSASTRToK7I6l4caDrAXIgCdIuuYCDZ4KcggfqKsFVQu3B6oLlAe-KXHIYgX1BpcOJUZMBLVq7wINAIMKOoQCwj3K7I6vQHMT+gvRhlwNBspeQMEEi49UUuYHFQibCRsGbAh0CacHeQHUgd4P9ApnCBFFFoHKgvJlkQLYiVuA0wbHgbaqwguyDqoMlkPeDQyNUcfZirEe4Q-v4aCOeoBHAl0LcU5OBaFHiQ9kTwxPyMChTXIPJwpyBJoFlw3v4dwGTQYKB9QLfYuzi9YGF07GA50NkwMTAlgL1uATRrIPRIt+TVjlusMfBsRO0KL1Y9HlLgWnoNII3yolCEaDogP8QW0CQYjAgYpa3SJmhs4KBkX2DAQDcwMshFsIMwT8Au8I3Ay3ClpFDq4Ka-xowg71B78txSeRiuFrOSBygAwNFBj5CWyPNQjeCtoCIQHvwWQu8uzNS8MHVAIBCrNuVgsOirqNVEOWiQoOrUhEhuIWdwuMA66JGwlwibpQE4j2DKIKsQkzjM0I1gZyoEJYNwGWA3phro4uB9SOhwnIhpwJdAzUCQlBQaOoXYEB8gpHSHEG8aKQT38CHodb5toqwgZDhi0FHQ3cCl4LD6USDHfInw9OAkUvkodASWEOn8eMh8KJhAxzLboPkgP0RAdBESCrCD4dBizcD2aIUoFyQsPH0OO1Ci2BakNuC0sJYwXEDynGsmpHTQeq2Yl9nXwEvMwMBKdpww1VJbrA4I6FnVsMN4sJqR2OC2LGRMINPF0wjv0GdAF14xgBUYRdDhYEuetxQ-9s2QMKafSIBIifAGCAE0-6yIunKIMPB8IFcGOGiMlvUwhwjnlMio65iTBuiIZ3BV2DcQGfBrfAEW6IgYUPls8QK6AJio67DEwC7EQ3wXJC-w+Nz6xgmYaNAikLOs2sqE5Pvc34URcAu0kcIkxHzAE2ADYQvgyYh66AH4LK61QGhaedAx4Jl8m0AOCFyk0+BE9s8EqhC0EAmAOoQZVMi4yfDWkAlQ++hZon8G6MBpPBxxWMTq9KYIqHBcTP-4rxRYhHmgaxydeLZAN-A18BYgGCABwDeCxTYpek8QAVKcMByoUgCQIFaoSSgqMOooDdhe9P44-DCy6NxI2kic7EwYKyRuFAfw3tRQ6rGEh9D0mBZsciAHQLXgyCC+kPYkVyV7qOaY-HCcoJVgwByYBu3elOhM+KXg6tghCipJ+tCk0PPgavHIYAggMYAO6BNQpMjkwLgg4soJxh5FgGwqQE5gPohowDEQzcDPIGwu6xrtKNZi1uBy5qZ0ORB8gHykwNTEwBYgMfARYCPcdu6mMBu4lEA64Of+1yCDgO8lGhqacGAqaUAs-G6w2JR79Duwr6DmMGa2rcCxwJqQKYDc4EoghSjGNKt61oI1+Nxi7bBuWTq4AqQgwIrg0iT1QLxotgCpyIhA-HC7Us6QsIT-QHvykIA-Iluga+qNcFzg4sq+VEnsfWgAIJZsg9DzoFWwlMZfgCzApLh3-CkgtOBHPLkStNA5QOlAFUDBQPKcQiDzeD3YjqS5xnOAGdAVIJgwsGJZWCAhB9DUKqHeNhjOsF6KamhNonHY-UyTYChU2ZCHhNMgBMjC1LwgOEjnoD-wEohFJaHAAXDp1NrAajgHWeXYDyA4pF9AB9h8QFDQVaAz4BCgs7iDsOA45qickF5537BoeTGg+YY-NMIQ3UBhCA3A6MDeeCIgSxAKsO4k3OBpYF7CqfBI0Cxw1iDy8ESUWGUiIMZgEtDq4HVaNPAEdgwQruhbuM5iZXK20vJYctC3ML1oLZ4GYGEwXAB7UvJEnBg2cEk0sK62EMps8PjnELO4r5zdJFKgfggAoFM6lCyjMCtw6ACBpHAgkVRNKPnQzwQXyMt0M-ANkDXkunAO8DwRRUbZkI34ELBokN84mSD1gtRYTSBNrNWAxFDw+LKYnnhKxF3Al2CZkE+Y-MDkUhKgz2gxpK3kWrh0QA4gnP7gwMpA-OhhCG7wAsCm8OIQJGjUEITwTdAwqBGYPahAbBpAFKCaaFMgTox5MJW4nXAs-ELEd3CdwFHEqMAZWOUMhBIKsIGwPSCH0LSQNxKXHMS6pVCZzDBADiDMGL-GFoBrfD9AmmBIMP9wJtS3wF3ihxCt5OgIy2AVadZQC7DWdFkeh0BNLgHI9EB78nDY8lCskGmiEmCmdMuoj9DmwMnUTvBjDCngrKh9CJZ8UMhBCBGyAMFdkIDAwXo08G84c2KhKv9A6fCXwObkeS61OLiQY7C4IBGwGwRPGcf2Q5iESKv4qnAI3gwGE0BkEOdw6fzr6PtA1kSWZuQ0YuREBL-E6u5vNDoYKDgySOqpOoSNiD80jACP9m3YSgBW0PEC0oEpBNDIM3gYkMfsJsBCIDpAXHi-aC8g0iKNiPloYQgEaPWw1QjZWNhQBxhNgFmiCegxsmKQYXDM7CsgLsRlYPfwEI4xQNXC8wAJRHFW-9B5GCcQM+R7MMpsb6i3LOqIuhju8DCIWoiPwO8g71BfKLEQT-B6hByg3fCvSOCFmlxbwCG22F4b0LXy8jANoI50MhT0YN0MT0RhRjoEf6B70CAu9uApIIUIV6gHgI2IYqB9EGaYU+BzgsY0IKypwIJFiOVBqG+wpMzHoOmwwNTIoOEsmcDyWHwAZ-BH9MLAUgASYEXkQLRkeuZ8YFwpoN5wsphE3GoCm8RoUMuo70ADcLic8Sh6GC5J0Dy6IAasQqAedhKgOyDONgzMSfiLoIRwKKgmTAjgi-itggFQslbawKs2mbDCwL4Q9gTBZGhIkMAo4PQov8hLgOp0syH20NxQlkgEFoG4r5mSrOVhUBCpUNuYEZjelYwwsgCw6P4ggWQpenWo-1De-szo6zR3kClUfqgAwK2ksFhAvkkotLZNSLVgRUhvODUUWYioUM+AOEialapw3EhF6ApwRGBmFrKIOECJsKG0M4iPGA3YLWhBNLEQLeRvsAIYRND5iW25qOAPIJuwForDsErgwKygfh52XlDKQOAw3AorFG7IC7CDkpUIo4LmEvuAyKgIxJ0wZhDgxHyAV0ZIyOSYoBqc5ZiQGjBzQFrEnMC-xlJwqBRBSAE4EEDYEJKm0jDikoMwPajJFDIoq2D2JEwIeQQ5SKkwvCAxoM6E3tT86LSYcyBKZprgHqAHoNgQtdbZxRFIyBAYsJK2EoA4mXWAbmDP7DBApeTJ5FDqvGBkJAuALri5YETwLPxhIDeyU6A3cOhwQPjmIAjwE2T-mBOCoTD3FBcw-8hnCCkEYCBsgkqE0AgjHK+0BKCWfOaozfwtoGpoMUBViMDAhYAlgDMQyuDWdMtWj7DcrBSQ5Jh5cGQQw3ieRANY1IgokGQ41OhcyOlAeggmwMzAycRpMDhIgOTcUNQQIZAUQD504oi8UtvwIUTyorR4PohT2KdwvfB4iiQQSxAjyjhCBSTuCCnA4DiVkGCg+AykALKoYMqeBSgUjMC1YFtgyuhXYGTMQGgv8LKo1mRf+C70WgjaoAEWmDClpKSEACiGCL9MBbFYOO7sW7gXWhpKW-BrSM3AFsj0IIWIXBxQQF6gJkwEIDOATdgKcBNYsXSp4HIYTLisMDeZOiS1OOMgGvg0wPm6-lDYEDrg-OAEwLZ265XWhM62PhhZOp3pe+DgUAfCHVA+OG1wkSAQsK2oVzDiMEbgV1DBCJHAXyieIib2j2yjTIhUv6CaotYwRLimIOnIC+QYsPLUhqgYONfAVrYvsGGkVIhYMLR4K7BJ+Bbwyq5gtIeggghx0FigtfgdMAhOUNDhmeYQ6qpU5NMCYQhDDOhQo2lvsFci3Ajc4MECCdzeRZEQCURL0UikmALdNDdYeXDQqPRAEBh1BEBARSLXJPwwVODNRAHwwIiumG-w3GYZwCl6EUCuYLqgOlDLoJBQ0WAz2L2AAvKw4jhIPDCxSDzwZDjM6OVh40CpQKDAlfhZ5gOwUgqUQCgwQAaWhY3AyEDBJBUR6EAKpuvoag7rgA6wFsiDYA+I+sBIQFPYsPq00INAvZjg4GpoyYAf8GTQucDYuDWACZhh4IZcgJCWOA7oaXCIwPzo5NBe-IYOizZeBaygS4brmKoQW65SxAWQpqCkuFWgqsDbWndgNnDy8JxE1yBaeuUg7lABAKHAzipEZBiYQhCbOa6YHqBPPJDAqcAxwKgQ9rBqqqXk56hRwNEofmDd4Bdk+HLpFJgGWUCf6NiGwFTYQHLEDezfsD0u+rCbQBu4dlCE4dUIbqidIHqe5wzw4n3Ysjp4kJxE8NCIxBnEibAAwJconIxMuGmQyAZfgFTIXUBsMMY0i3ieRJws4KD0MNOgD4i9QKkC5zDnBKmgzUCWBvMAOPisXihcv2C30AOoy-gFuNIkUcCGarJAThSMAKBpBggGrP8gWoA2oNmAN6COyETwz+ytoNZoo4JjZMIiPDDUpK7I24SYAh94HzgpqO8ovWDgCDOIucmLiofQzlCryqnwV6BqaGsAQpIr0BhQKKipMACxNLBwmqMcqEgpVJEIhLCO8GrFEaBJwPQAMigyyafAJ4CR8FcGocDxwE-V9hiuXmIAOMUiSQpsCZiPbOmEyxDaSBUU0JZw8Lik5piUeGFw2+7Y3vbFkdiuyLX4SzC4nFeomcxNKL9GMIhIrOZkYraJAKBo1SBHCFzMOiRbyAmgMaQ60A-AhqjBQDSkiEgXzC7AQ2BasNO0VMj38N9IEI6qoH2MJhg-9mcwBcB2mF3oAhjNgDqgsuF4wJwsThC70LiJp8LSIHYkxkDZlGKAEKg2aO5AOYjw6NOQvcCbkA0Zk1g7eNZkopqNSMTUsRBILLKI57gZVLSRVGAXQB4QVWRWTJQgERSjkKTovVgoCLUkTu6+wQ+QTxDx6BtI3eAiKNSgPjZvQLTgtlSoRNkw+1BNSMy8gDBWOMBUHmY6oCQUCYAPyKrAWECnMgoyk6iiyJX4av7A1GYgXBDUWKiQzSAEoPohiJaKQD7QM1nJmFEI+rCfYSh6eOCrHLXo4MTsqLkS6kDwcF7UZkjTMOaw0GwaYKZQ9pRcBjVFfPgfElGkg4ChkPBAInAi0OCwamDYaJfAaqDURjGgqESHgjegWhRSNjLwY8D38E3gagKn8E3oRhogTgKImODpmHgQQ+5fIINgXfDKNm-hcCBp-PewaEBkkFHRqQ5FwFAFyyq6QNJIzNCL2K-guSDh0HgIb0CUmNhCVPT5RLgU4eD6II+II6YzgLqiIGwaoOEQrmAw3kn4inAvhAq23sBxoAjainDm9BeguOBGTDrwIDL8mJuQXQAK1vTggGni4ANA5FWfwPQw0xiyALUYZNGiyKZQyBDynCt4iAyTipk494LWwfogifB9UNe07khW0OmEPJzhMLYE3tnxwOnIuUDp0PAwIxxMGAgwE1AbOKMQB6BowP9UpHQ98NX8UKAJmHNApbAL5K0EItAqCEd4O1wewJIgMygT0A5wVMgxgC+AchhVsDGguzje2croJMCSoDpgXAaZcH1o-aC4FPwAyyojMORoj2C7OIRIvXD9WS2gISBcxRNkCLghULyIkfRfKGpgt2ihsE0ozaCgxETa1mi0JM2oAVKjTC5IbaK20sDUk6BbhEtQJXjJ5FigjORmQjLCOGi7cJbI0XD0wMZYdeL8CLgsSxBtPOzo2Gg6hFLEbDB-Tu1QfQjcmL7Ap8EIQGEkZ4CIFTpg1LUm4JAgvAybgGGqI+i2VTA+pNACGKv4Ymit0teAlhDdEAE4QpBRMEygdahfaJ7w+5BxDhFUnD5ALBdk-Fgj3DikkSDPzFM6WbDl2O4I05xyEEFAjlgNsKzijyiIwAq12YB2yGdFcQjNqC8gZNAj6NrEK3Be9FsEqpY6bMpsTOSrDIaaHnaRmibmL1JKoPHogyR80PnAMkhCqsJgNCAXyBA8FSjxwEjQtxiYqGgldpi4nFoww1CjEKEe1USAYPygZRiVkCBYbJhgDBr435CblNzqGfBLnsiwSaDXgH3I8sDdQAZWwrTUQmygXyhi9NeE85DsMPVInuAoXF0ApODiEGLgsZTQlmCAu8jTJaYIvzB0KjaM2aDsIDtcZOg5oI-ovGis4hVUuQKlBlSAV1AbBG2sR-AaSBuo5VBHwDUU9pCfmN0MIJUaoDEYbVjQoenQfCDVydPI+NB8IC52isCOwsJipABA+N6or5KpyMYweQQjHPUuvvCm9J5qN1Tb8H+gDTAf4E2iaahbgCGw2PEsFBnI5nluwOOsj8A34mxEYhBxzsq4XWS-YC9AAVDeCEB0DHQu9MEhtFCa2AGM04IIgdn8nqhfXsyytcx8goHmehAwZH0cUYhnEJNO1BCfoEUQj9CKwF5Y3tBuCCngrDAbqJSg6vQmZNRgL0CiyJQA1xAHKCiQACDusCAQe8LWaL9AMIAVnrlJuSCcjLHgJtRXvKMcf6BpcCTgt4Bs6tMiiXbvIMz8TECKFP9UC04PmF7wV4CTQKb0q+UsQOVhnIzxoJG5IED-mJYwd2BEwFuAK6ypcPAwtOhM+LX4IrjxQDvgKQSXHGkwoWhptJCgJQyJAOLQ4soKCDoY1CqXHKbQwQKnREeAIbgXJG0Qt9A+EA-AMqRciI9g40D8wMi45nBmgrpJ0zYLtEWAE2QIQDcwBBbjeBLgPpTBYJKAf0BhcD7lj9B4QBPu68C7RINg8JjxyMPoIeiHcNWSrF4tIOUg+FRyFFgwWqwdwCsixSZvgP+A4EBoWmKggMQMGhzAOagvMEpwXeJqMFwApcBnILKwJOCp0Dpkg0jQ4P-EugDZhtwELECPELZgKhavkhq4cJClia9V4YC-QL2AnwJzGNEwevDAUJ7w56jjpmMMR+Dpya0E-VBPyIqwMxCyiGtMuUwdUE4QrJDWcIkwSCCDccX4g2Bb5E9gFaDQWOVhCOoYkOPwIA6N+LrQGUAtaDKIzNQtiOWAOcC-EL-gXWDxQLxoT7AhTIzkr4LyIFFuGWBPBDMSHsDIsCRACNAvdZAgghAE+B58AsDCJC8o2kRi4lp6yYA-RO5gZkh+wBBAsISncW0K+Aw74D5wjZBKAA3ATuTwXKq4zfwNGJTOEDbWkNv03ARpouQ0uyAe4KcQ58ZbZCEK5XTWdEXVvslRxPMoq-gWkBmQFFjXoIugAqHZ4ObAXcj6IO3Kq6ilDCcMESDqsAegAogJABxoKcBjpODEdsAhUARwDYDjeN3AwYBcTABs7WBx8O7wpi5CAEoA55QkkNespWA2GHsgGZAFqD2lDcCM6NyIeJDGkDgA1FiyVjPgRUDZyKNAPpqfUPhADcnU9rkg6aAGAmOgv2C6yWmRtRiaUBRY3YilsG+QU5RPmLPgk2wZoOKylWBtCgfYFXZ+cCFAtnou+D70oMDTiNfEPmgfwubI3spHCEZMA9hHgIwgleQNqkGow1Ar0ICYwCTSJP3gLkA3QEsw7PQRGZVgf5Bz4GschsSP6EfwxF68kOLg8yhuId1gVwaaoMjKsKxsRIno6fxTeLQkdvj8oE1ApvBJcJVEBc63EjgkVdgVABg4ViAhUEoghOHzkLxoyEAqQKkCKySt0inABeAd9MmIpZhk6PKig7BPgOrU8ADLKoMWdsgn0MVgt6BRxMxgfWgJ3IxgQMRnIAmY6mBwQJQIU5htpBJcozoWEC8wN-qjTBSIEpAu8D8g5ejp0BtJLMACGNIkjgh7IJmw07QgUXW4wCBTGkNIy-Cg1PA8FsDTKIBs3dJ12j-EJjhM5KgqtWC5sPneafzoeVHEHIAvjMX5r6DlSLswIsBrSHkErggWEGgwv0hfMDyQidyWbPweNRR9ILgUCnCYBmJ2LkjsDYRIS1I55MhQvfB7njsVgxmZgMP8TyDjoK2CjYh8+PVoEZCGYNdAkVAurjq4akDv0KLY8QJoiJpAS+oN7BFIA0iJQNRQZhYPOEoAd+gzeTP8o6J-oFOhMw0m4EZMQGjx9K9QXGgndGagbxCmdEP0uqLnDDhITUgMIGYEYgBzEMWUgEg25JFUvcANgAKgk6iBsETaYTnf1U+wEaCxOOzgQ8DbkK9+-QhkXChaLwikWMWgjvASoOyotkAXpM+AHFhFDcLUZRCddHLY9rCQRPBkYzEn9eRA68BfpppgqaBl0u04XNDRoEyg6WjncLmoGJgcZIeM9zjtEJQg41AXlIn8goLeRU0g8kCqwI50VPRVIMTA9kAocCyoFxg05IaotOKxQNCAoUB5UMCmalAWeIeMBFC+WNEwDCKQsF+gTvALtZtV1NBu8FAIohDFWQmOZRCxzgGgj-BaIB1a-lBzgHHwkvHAwBiwCa6REMzA4pLIuOSNRVaL5ScQhsThuTsClyLTgvhQ0KgyOdzIfsZzti4ZiqjZZLCa1nqb1KxehmLaSHfoOWisQMNUtGCU8XMgBc5lMBdAXcjUBPzAMuBuIdXCGBh7AN9Qfdj3cOQwl5hvUN2gKvDb9KxAn2CHxHoIWCB5vlYK8ilMqiBYb7iPdHkk8OjRoPEwabQ3QKNgN8C-NGuGyyCpINKuXkDVUqKokzgcEDVAD4i6AN4oUqjWRLyQwFAnJLEQM4jesMv4aTwCABCwNCAI6JEQ8igxwOiI7ijmyIpAVkxXxuRsADw1+oBQZ2xAMCZI5rBjjHlwW5AiIDkwzrDRMBngHISlDFLQhMDi2JYwRYARmHKIo4DKoI+QlZmXHmywUSDaFrlM2FBbyP1gkKDpLJsgYpBMoAc8Dn5IoMY0NuBwFDUMEEbuEF7Ud1CJQKcQ0NA6xpSg1sq1YN5wuMDeyCrAN-rVaAIgw7CMAKkgm56fIs1gRHJbzDOg0EAagQ9QrxDnINugT1DuZOcwlyhMYLI67YUauG+g4jDGkD4qm3Q2HBccVwYMYG5KbOrciBcglUSFKPYYW+QFlPORtcgzEmqAj9DmkHpYQDnbQIGox5zLYBMIrKhLoU4QXQAQjiKQWvCcsINQASBEiGuwSBCy8eEk2xAIxLCiRfRNiGlw3YAreND4D7AvgGzgzCyBurbA0TCo0kq8wgg6cAvgtlRldaXwaqAakESIu0C5IDJAQiDdiBg4geDi4VvMkw1UkEkoWECxQqkOMDWRwE+Z30hN4MpsJkAbqFxUU0AoXmPcOuX2lHdgVky6AI3yB6Dt4JsE1aDEbDcpLqx70I+IKJB3uZxqWDBnINGYrfj-VO+I+RzOXIHmTUAbaqYgQ7VCoKrUJqAmZM1AOLRyFFvM4pBjDA51ZvF5cvcqXeLHQKR0WdkNBTkg3SCuulpkfnDGNBzAvlh3gNjAGkBPENkI0PjHoESQ7mAS0BUgxyAKAjjCsPq57hYw0MgrJKzifECJ-BnQmhbxmpBE5XQS4AWU8tTUCD9y4EZM6DSIF1C5wKvE92Dc8u8QOgTguDfgw4DszhXeZhYqEPRM0bxOYKgUKBSZgIvgsdVycIGo+sW3oDdA5nzXQMahXvwrcLzUpcCUil3iKCVzpqghn2BqaE+gss70EMAkbkDC1Lp4OCBdqKkSKCB2kEIAMUkGMIUIoWi+WAvAHkA5qKtI47j1YIDAAfAW8BTl5qBdZBg4YODMODCqDajD6MMIJMAVVLHg2JWNMHzYMaByGI0umKjdZDSIeUASXKRRfzmRIECsLuRqeGC0syLaIMyyb7B92Plwy8B6GB3Y8vD0wMGgcBb3sBQaPaiysJDAUcTPxV0YRtBGQNVSblguiEPA+4C7yDqgbJjo+Iwwx+laenes6JTlAOOQXHymcJp8ATR9AOvAV-gyKE5UbvBcyF9Awfj2kDnkYuD0YB5AUam0VPVGbJHVREUiZRgRkOy6ZsgjqE9w+jRSAR7wdm4lkOcob6hElGLA-ADVHF70GkrUKlHQQQ0P4JM6ngBBiJDwbECfYNWcUUiWbFkQD4DGwBFNN8D8EPLUFnB5wAEgZthpMD0MtTDWNIpA8chRYNtQvli+kH4IJMCIWKTkQajBoETwiDnGuv+MUVD+EO4Ad+hFgIBsCyBKcBhsbLCxlGNAaXAw6J+AZKTOmPjQ7bCCEB1ASXC14NHQjvASYLx4ZoKdkHQIvThd4iG4VyIpVKrpOkjoQC9AqnC98Eyq2NDUxD+wXeim-Dqg--ggghZw14SvYC+EPkBLTkYaBaBzgNVQECAfEiMsw1TXDZVQvpAAzZxEFpBXBj4o2DZWwKLAraR-Br6QATABeKtIbLCO7NRoubCZcK4IB-AvKFDA3sqYQDHwY4BdTBroHkDhYLzA2-i8IHoikwgpribAaTzI9oEmXRjvxs2oirDXZLkCpNVqqtGwJ6iuoKs2YQ1EuNrEeOCdMIyo2-R2+BmQivAXsKtIIGnEcF3oVTTzQPdQe1LtgHIUjTKbINSYlLlDqOFF-B6aDl2o2bwreGgAdpDmQJ7IpNDBZLRlTwm+3LsQIODfsKFwoGXuRbUgF5y+IN0A1pqskNCofrI-INxi9MzpoCdMJmTQQB4slbhcIFq42NAOqnnAEykg4GQQ44AnoRYwOYJ0wT6QRQblKCK4r4CRUGLk5ySUsG3Ad4DhLAhYJkCO4B3A-xAhhggEADjnuKFAzfyQwIUgt-Ry0DnozUBUQFzA1MDtlhZcfWj6tWaY6sDHRG0++F4cqbkSSdAuYHngHICqkDRQJkDixOzAaagDTdLQByz+QOVAcMC1MNPgcuaWULFA+AUaoCNghYCQ5NbEIbCdEh64ohrFWYYY+6hR0ETO2sQCrtzgh4BBdLQ8BHD1MGFAJAApQLSYCCA7UJpQG0RxKEsQJpCPdHAWO1jnoKhQZk1BwPgo25AyKK4l-rjB5Mv49pSM5Lp4WvCN8YCY0aDKYEOAmtASwDRF9MAJ6A0ijPTwhOTNw3g7ZJHYq6ge8EikHV7WuaxeZKTfOKDEK6Y3lLB0DKgEupjobaJkkJWkTxBOmFT0Dah2VspIpQwZZTW04KC+yOLA+F4WyP-QeLDuALlg3xwixSbIbXCUtNi4nxhemBKiPxDKCMo6mpBeuVGIdhBfYKx4ZsCUxhCo2kBAePpg-ZCWbJVmhVA2aHJC3Mj5ICVEwCSJkK1GivBXwHQlCnD-jCpVKoBYhOeAXiJYKE2I5JIqEJcIpiD9WClAkci7DNcIh4DGYIGoRNKIZIVQkMCGYMjgOeY7cAgEHGFPWQ1FFmzd0PuA9dIZQKx4nYAAPJZs3GJrTJ60H8Kc4OhgNahiaNu00jzEcGbAYxSOdCbUgbhL-PvYM9BNXIvgQMDRKOHBxlizcEjQq4D+8Hqw50QjID806ojK6K+w1YAPyJDw8eiWfC6smZDjuDtwcnBsgsIeUECx4HLMKPinoA7ogWRoWsAQa7ARKJGhikA9QKTQLMA2zQRQ79CQcHdQNCAzEsFAOuCFkOOIVGCxdNBsZy1REITghmD6INXuweSSgISklpBewNcgknagyOVIUnCPyNkwOgS6cGj+vpCsqFdqVHAY2HVAn6SKWJR47yDLKofE-aA8pnwN8xCCAFrw7jAH2EIAY0Arpqi0FCCQEHHQ79CYqHYNUmAQuilqZ2x3cIuE2hB7wPRMNLBsdGKQTozEsF3IWrAvIDIEE7LTnJEQ6fiaoM4AIuE+lIpAcZzFuWygl5BsmISwqLQbQFNiISxs4JpoqIhgiadmRHCLigWJpFjIsMdIoyQJbMLAMBZcfMEAwqgu8NZ0OiRAYBWA8ABExG4gozS7QCXqG6hkCN5A2JR6sHtSivAPsA5hcdiGMcsBvxDW4KkOFrB+IBNOjWBX9JCYWCDLdNqhc4JD2dTQH8VDYNPgI8B6cOpAP0RPwPAwYZDYwFbQzQm7gMK0BcAycFciaACT8KJIgfLNAY2Q7SCjqB7C4lS3GKUgYLQdSAxACZxAaHpau8hiOscgxwHYwBUAtwjmwd7UC8gcvOKSAMDDgIBsqGDGDtkIY7BRiBUoIijKoMEk2XBlGNv4WYndYNTAqhy9WI0gHTADYPRgcrCQUNCox0Ar8NuQN9Q3YMBUElwWQpiQyCUo0Ght6CUK4NbeWIQ5iKEZNaC0sAeg82gqELTgaTCLism5QQhDwB1Q8hgzdkgQThj+uNBsRNDTnOeoD7A-cq4IiKBjpJWkEmCDyGCMn6BgMIMeREA0EHPgpIQNyd85GaCsENtgllAO2F7Y6wDYsNDIV7zLKojEt8i1KDtgQq6XyeL1sRC0wNdI8mC3booQeBDTmFjgzqj-mDokhOSAAqWKKKAt0OJUjUh+LZPgZiB+CD0eiGycRP16-ShnbJhAPkDNcCKg2kQ+EdDQAhj+-vqwdCAw8O747xXQyJhiQ3xHviFoPPBRdIqYOXihamW4sXQ3EEm1-cmhvHpgjQ3J0N0kfaQiYOnQ5YLYINSAblhsgjBcNrCmwLtwFADKuNVSVYjtKG+4VKCGYB+AU4r54ISwNmiUkBoQ6fj3gougdGDxFsKoNViaoEfonWBVFliEX8BTlJF+eGEreEZMFRiotLh0IkDngJKYjvJZYM9o0EhrgMWUsPoGoJkgtUDQQOiQeJSaaIRoDezviH5usUBbBMqQ1wSrSO9QYMCXkDOIO3AzSEC0hWLybEYks7qe8NmUQqoTZORCVODZQI2gkZBidLH5dZKZkB1QGUD2wNWAvcASKM6Y1kCfGN0MaybRYJot46A50DeANIjiyi+EX2ipDjQwgxgZkDNI5vT0-O9AE-Be2MaYsYif6FIsttIwkGMMcYDjyMxYoznWIFjgpmQhEGOgHSAbgGOkLHABIBrE3ABfQMyykGiqoKQt0FgKUEAwhKQjyqXik6g3UO1QGYA2bPgMk1jJYpX2bXCcVSy5KUAy0tv0Y16i8KVNCRhY6GmoG4BkpB8Sl5htWE64N8D-0MlgWIRpqJYAPjgEsEogToz5GBh5KEjqsG7ySkhEEA7Y-li8DMlgE1CqwHg8QHQWbGPY24B-OZGGokjIJeDgSuAGWNrKCDATQL8QuSAyLRUgOLRwGCZoaAAbQJSwLojKbNAgSSjR4IRosZz0EEz4qmDDhjTwZqB1Qd+EIr4mkGrAqcjcyNhgvUTckOG6GcgxgODAjAD3ZkbQOdB6WPgM8ABJcNdUlECuyGKAbsgalPggqxxM1e4A4lCzIRYkna5XYNToNlACZOKS+URLMFEsILDHoCcZF2REiIlANORJ6vnQI+hxdAm8+eB4QCQQiqT2JFIIY2TdCKuAp2AkQIvYC-pALKTgb4SudCg4NzDgoHUExWCl2LTEyfDUQkTs3Ej+duEhhhgr8HmAcYAvcKuABZBVEEbQhsBiEGo4agisMDZolgDYCOqw9yhoYKBeliQMBlgYmeAhQIrAUnC39OeBnKAikDdYhnE9EJpwxNQ8SDGAptCXLOEcfsAUyBf6zIJJgAyoTrj+kHdAUCCpoKJYjUjRYKsRN-BFSBmQSxCqmbMgY8Au5KrAFe1z+CfuEjBcpNZiSTBD8HGcTwkyqbsAvOD40DeAvlhjDARoMYB-wITySxCMYFW4OrhtogtY+iDYCL3A5mRTmOLAarABwDGAsyI3xLpQD4gz0Ga27gilpLzAb-D2lMWg5uCswAdw2JD-jPxWJuB2CuDA4eCtpKXg9aDHoPOQUYibkH9mKc33sCHg2liadMMIVOTDXAKGukBe2IhIqhBALPNAUhwW-l4IJ6i-LKiIbQpvgBvQBo0rIF5ZabSswHWtYuJUQGx0-pBvNNBspQy4IBbI7vg8MLBQvWiQsIIQu0Q3QLM6Ppk3QAzo-jDqzGpIFnDXiDSIwFQAbP5gKaASzRVQt-QGwFFQZESsqDCAycB5yAIYicD5gKgghRUGoKOoM0Tisi+Es+AvCMzUy15iwtGNeDwMQGDA57hgaBBIvbDJIPUuBFAHGFeozgT2kDUUxJ088OfoWrh6sGQwLYijJAEU-MwrEHS1I1Q18MAcheDGxTvglRSqxFvkTlQ7tPSYNBCUQNRgM6A-RMliZsC7RL05ffk-NAWgK6Axtc-t+4A7qhQgT-Au8AdZpZgAsSussZhk9pjo9S5SLLD6vSABIDHgx0R9CECQqqAAUJBohmhHYCusxjCvtLrA8PisEOqgfILh4FHQPS6TqCsgloGjHM1w7yBjPvKgHKJXUKRApfBfaPVQK1Ab8HF0u0CFrD9yIlRFIqFo0oh9dN8QNMAUyAG4WhAxEJJgwJmcLMvYvyDnYANZb4CL2DBUHXCaUMPU9pCRyFowfYZywFHERYCBsbXoeBA+lLLc2EDUaCDQUwJxoGAgd-rB5tTA-mDFMcWwHlRpcJOgjehOqIz0ikDRKFO8iSC35CmgzrCmTNRoXvT8CG0wbQpe4Cc64GD9QI8QrHg8nAEg5ExWcHvCvhiwIHsIiKQKLDCAg4QSkO7Q7mkxCCIuuiB6IEOYRHAnDMDURSDLdGEmKSAeKnygWhBIpBp493BHINwKLEBkaOEgwSQFIk0oe8Ax0Ni4OLQiOEQEmqT94HDwO4AkDBigbKDIIOb0XODYpTpgvUAPOGD2A3A7tKmIsUBHwHswGkqaLM-BOYIJRNWIcYDcUrCg5AAsVIfQRLVENgWoCtLVUos2xIlZwpxAJAWh0JGpwmRYiMjRQ1zxEFvIUXS70AdoZiDiiMvQ1kQ5uG0QlJgoOG1A2-A1jlsEVmACRqtAzQAgZD0eLkZcaM5iUB5oWq5IGNjv0ZM4AQgJsNS0uYizunEBSdCSsIKgCMQLcNzIL7CpEJ5Ee8JqaAjk5di5qAossKAjqJ0eyMVgKgJkpEAqzBFUTwRoIJ8YrXHKOr9VLmAiWPYkzakw6C18TdhvhFx8G4AM6BjYtjBe2F7x7mFusJk4iqSGkeMYymBViL5YaTy+QENlvZCw4igw27S+uCIQDdg3VMEky-iNcP5YctjD6Ifgw6ojsKV5SeU+WGW0WmSqkCIQEbAk8H3YpOA18EvMbGnigA-gY4AooHoA8cgu8IqVbyFxgJtAwFD1MOVQdBgmgIJozNC0kJrgC6gYoEgashZ9UFoI8TD6tBaKj8iddNMgGZAOkHiwpXxUcGoIPHKBTYwAfnDKQAdG2lAaSK4wTZCw8IbA8JhDiJmAxHkQEOSgHtB8ueCmbBReUAT0-xBcTKOiAxYWeAoUT3DjQC1g26QMIJHQLXQtII4Qz8yvKbQkWIS7MIFk4lE+xH9AlrEYIG6wTCCjYFtghSJw4N3QuZy4KaDwvCAG7NTQ92ClfJKoQ8CBQLON5lDZlNfQ-XCdQFwGa7JDfA+gUWjEQCrAc81k6OlJXygqgCDQaXDeaAcotDxpqMy8JEDNoGuAiMSc+uIwdWL-wGAgyLCjYOCg9zE8kCeAD6CaNsIWK6BUjpKwRcSeRMrt-RqLOGygRSI-EAvQ3AgDSB9QOUj9QFDQVhShcBtwAdbGcC8gL4AYmKYIIWgO-j5k7o6QsBZwHNVvNHuhEgJfEHWFsjqCCPSYaNDw6B1wk-C0JIGwBjm3hSnBe0Cm0PvQ0wDjUJNslRTDgJDw5M2AoF3IaybUtHjGODH0yEtSu1l-oJ+kaRDGQAtYZ3C0jA4CqIjLiKsQz5jQbgUQqnG0EA14x8aJ8e4Euux3yh3o0CDWRIxAM+DMYIG4ck21KAFgerAu+JzAmqB8xl+g-RSWjDdYhkpaQAnc71Bi5K+AZEDJUJWQH9CPiMa6DXKvqKgQW3aQlJIgAQC+eWpgm2BBIOCgnCyeIrXoItAocI3AbTDdJEIgTSBpPHgQIYK+kOcwvq1uIYhU9BBGJKqabg428eWAeNTNoDgg0EhSnk6mA6BcoIrgKxSJ5bVxe8xnnloIivAbUKIQg5LtQMbAunAA0AWUyxjJZJMgUixOHZhIXrBd8DkgiQiGMRiUGzmuyGCO3OC1OJYk40AXUAuo2SDJiNcQVEC6nGjghNhxmO1QqhA4+AXQTXDjUIUqOqIH4AWoIZIf8MXAsKycwMgGtvUSICigzSLi2GggamguiAPYXFIoeil01bB6ai2gFk14sECoqEivuFrgKySSkJ+gT9iFlIcdIR1BIPWq5NCMAB7C1vAo9l7c2q1XBuKySkZLnrog1KCKwKxYBBbgsEbwe9DBQIn8QSCYxDeAvxTuUKV40Xl8JYbI9bBDAhTA1OgBeCiwUJhkdlkEpemeGOcwUgDm4MFwEuAfOFAQqFBO8In8kph6sOgAkJiNkFos6wC2UtiU+9zq9KRANrDLKnkQRvBqoGogFAANLLj4uohc4P4wUSzT4DtkJPDRYFao8XCGqI6ow9R2UP3YyYB5gMvQY-qO8m-ILeBeuAGg16BRxMkgRUDzaCvBirAFYfPgptCnBboAWIRPPX2UicCMovqQDYCsQH1YcxjUalAQARZWFGTiISisMMrgK6bSyM8gOAD1gCLAzlwySA3sQaj54FfAKaDt6G84trH20PvNsyaxQB85sDCTbEn4WsCP8N1gpAwrELjgUlQYibDwrJAhRLgsaeBDmFHomnRsFJo2w3gCdL0gSKSB4MZFbuBO4K-K+uyumIEeh4Chlo6JRyBPCQbAyOHMENdIKkCiwE4YvRgPmFKQ3QAXjNEQIYKHxIOSPUFTlM70lMb-fGLAUPDixBDSsNihmiZQjDBoSEEgX2SKFFKQuxC8QJ4YfODWgnF0jBVfEGWVNfqX8HWgPKDcImoATAj+8IBg89119BK5BqzkUIkAS83p-GmJ48gODSFo5GiFiHpaYsAkUgLgnACfTYBApfCaNgvgafwC4Eyqj2BBUKVqj3QhqFvkjFgN2KlQqTDTKNuABHDxAkr2BqAN4Bp1O2T2BOEQ7+AnGJk4s+CqiDHw9sTqdMTAkUDWcipguUDygdIinJRk0DYdZDCgzKCwk1D4KARQUggPiCI4oGjAcKIQ3sCowMUggbBG0MtIrggvjGFwMKo8JKrAxbBrHGQOdgDqJuFwVMih4AKy81AvIL5Y-9DgxDNEDuDsinGgLCD9WGdQPS0u9OnI+SjnlSLhxsBk+GJQ1pXZoNJEH3jzkG6wTJUxoDX4VYhe3AYAgTB1vd+IwBzJiK8QJuDNxhzwNYA-9hRZg+j86JxEr8DlsErssZyaLLVI1cIQDLicgzndKERqqaCJQA7gAKDaWKUMGzADSM38F8wwqj4wPmQCiM8EYxTXQAH4M4R9pGgA5w23MGxEoxzhvq9+qkAlBZ5ow3y+WH8weMjBZISwKxTpmB52niJCqg5whcCW5htAvCDHoDKImuhpgAGgrcgxGOmtb0B3UKHg0BCeAJzA2YCQlIHgCW5HYJCI-lD34PVAyXBNOldNUeiE8OcQLqSJ9EXByOCGxHoKfghZIMvAYwz76LZ6dVrvULHFXsK1RBMobEQGYOyKKJJzQF9ottAjjokpzNATWKAwrSBkIAZg2OirEMsgY9xsRHnINRRPWHDwF8wE+NYw2kBAcFGk7iC8aBBE2-AssNRQOgSjOiTEEDAcyAZA-XCXoDWYNEZPYCFE2qBExPTM9w015KLAMECclHfwW8CsEBjQi3BXqNzgUgCq3frwPPB2+NHA1NC8QKtINQh8wDhAB8KYbC8gcbmVpGnItUQpoK5mwsDDeOLE22Bh4BwQu+Cc-kjg4sC5EKgQscDbgF6YNeT0QJww1KQLWMUmxjQCoHbAGMwy7qFAI+gO8NiEycLnUETI4VX2YCngJVDUCIfELSAeQCikjFh-EB7QUBDPwH9mLkgIBn89QKhUuRxUR4CNMJed+aAhoOzYzSIhQGeglEDtKCn6MIhpQK1A4pAo2AdAy3xkwWIwQGA1BONA0FiItWVov7oCoPCcU5QJ7RKAoaGK4WDEXoppgKCoa2CHwE8JCDBrAF5YAzSEriUgLHCO4C7EtUDVRAG+vJDMjYuE1sQIxAT073UPbrnUlEAVUEo5wuBNOsLgfrIrsN0oLzDZZE3oe5m9wj6QmnwlmEFQ2RCd0OxSKKhY-g8wqYhK4GogtJhxgEvChhi+nla0vcBy2AuwKKDBEDfgocAXoKwouvblAAP8BBkDgMVwo0h6CJNsgcWJsNA8y3xdyBZYYUBqMD+whOTnDN2A0h3kNIUFmmhqOPKgEXBtCgKy2SDboIlAf07l2ODol6Fe+ttaSzBk4tpIPzT0xC8Iy30TSDv+Q-gIYKA4HIQodYIIEc73UCgUIej+WDbkezAVVBs1XADkMAEAx3SxGchgMLD-xCeIH2JqeBQIxoBXULmo6zgPUB94rggw6MNU-B6aNso9OKoSuKLYtWDmMLlgEGVKZlIICUSAMCTgHlQjqBIwVqgeHZ0wf8AT6l1Mhay2VGo4AFC7UrAhhNj1SEmmtchbZPMgOPrvJR-Qy14viNTgmlxFfbqKXuA+lP2wVIDrwJFor5K50AMw6HzCqKMkwVFEMLuwHPDmwGRE5GQxeqcoIEC6GAJ0QCxNoYkILcBcJUUG06Au9BpiVIAWkMVU79BRdGIwqYjviCZEG0DXYFWgmTAfEJ1gD4FAuBRYKkjNzOCwmjoalPk9yagiWMaYFOioRHS1xHBuIMtwkxlF6LusPhDyIED0++hAeW4I2PaCgeKgrfijEAmYOw0WJDoY3sqfpCyg7eViYgJ05zAUwNFwORBJAPlso30j3PngyuhKRryaRcADoF9o-4y06EGIpWClIOmQNhijUblAobTnBJkgQYhmoHEVpYClNcAco-4FpJEZudSEpBzpbI4VpJYQvzTTQMHtLhTtCoQSq6DnsdaQung3MHvQfKCCoGUY3jifSBigVrS7EM6oPQbdDKFAJoD1ZCoImIg5eHwouUCQqBZsdgrm5NOgOnDMvInwV2AsoFdgL4AiLoWIZA3iEBYkXVBqsOfAQDC+wOkgDAZciIFQ-xDC2B16l9QdeorAwaBg0hiYrOKZgItwEXBIMHdgU0A8rmqSuwALIQVetywDcP2go9CeGGyCrvWaoMYgQ-CDXGcghCatoF3wFIhVuHVa6SylGtZoFhX0MJVQUMBLIFVyE5BxNiC0Taj6QOQFjeA5JuxEh4y0cZVgkzaSkAbIL4S6QDO2SKCJ-Hng93DnEEuwS4CfMBsAOXjkrFUQi7DmEONQ5pX3YDXARMjungPo16xkwJiQtwhMYHnAgXiaaPN4k4Cg5Sz8nUj4UByAWQScAPmgGvgQPFN0xtAxoIagPmT27U30G0Ch9IZoFOjUjRqUoYmgrQqmfUiV+EUga-iSIRikQ0hKAApsfSCIWNSYy8C7MCSQnnaWUPrOqFAbfKLAJVDSpO2wwnbAVAJov+AVFeZwK82mZCKm3FBRLOZwdATZWH3QRDpJQF1M0JbryNye0FhFYJgC5iDoYC7k+VYLoIqYPhBzgs+YR4C0iDX6MUUsFDOAAmj2FK2oHLA-UG4lxUBSkNWIXqAXHEXEeYBy0J5oh+AYJGTiIOC7cCItVBENyc24PhANaIuKl4A5SCq9qMBfaK3I4ojq1AwCPEh66FiEa0y14OPQYLCpnBjAZ4DUwPpwIFHLdCiUi7LTCEUaMFARoBkAUXQPOOe4tOboYHKImSCncP9weOCt0jtl5XRnIAwZvRhLnsQR+dT-IHnAHlTMOAGuCMXptt9QY2QchPVIURCrNsTUcmE4aBqQWZBlwNS0kWjL7aVgt9hpQA3Yt1CeaE5QJT3UKjBce6hvCLjg0z3cBPBk77BqpRYk-PlxBm2kEKgooFci23y+MM9oqQ5ryO1ggSHvFWu6YIBuAEOI4jAHwqhIAw3qzPVk8GR6ENyIaXDbtiR8xdTwQHgIDSjjuCCClJADqIBg+GzJIDVAZUAz2Eygb-CxdF0WKIPq1Ct4qVCbBLtATyDsMOOI8TCnxNRqLuTqIPvo3qhiNYlA2GhbzLKwx6AtfHz4xrr-fBdAMogPYO9ysfjA1CNgb8gyiMWUKIRDUMt8AuC4GXoIfKDTKMmAWZB4wnjyzPhhKRJJ4sBNXAdgf07mMEtpLXSmcJtAD3K2AFNi-RrI4ArYGCTsMKx4frJqML-g9uBnYIrS9t2gxJFoIyDuKD0GLXieRNs5OUj7Bcd0f3oGIFvk8pw1ICvgEWBBIMg0iiBqMJHIYIAtQCh68yAMxK2o8kCWjNckaHiMvoMYbuCGQIvZ7hD0ICJU8NAGENbGBgjb8NRCzNBKADyQydRsFM3u1mhcekNAAVBN4FgKBggJnBA857glgEVAf67BJDJAhqBM3arSZRQGxUggwQW-MLg9b8BVoDmAA2GDSTTwBRjdmmiM6FCjOq+0oWAp0H9R4sqpkuKM+rC39OMEZ2zdiEUQCZhE0jYYjsJ4wLCE+WwdLM1DJ+miSKQA0WCUxgNAQMCcFQ5+YSRimGeg8tCYiLRQkyCYxBrooTUI4HfKVJBivFa9bXCywFHAHsJ6cOAIVIAicG7AFUC3FAHwqrj4XvFoX1xHIE5AXcjWZP29T1jJ5MH+F5QPYNMYKvAqMLzUraBJwAWgR8EXZAGgWJyNkNeYnTClpPKcRUjq+h6gIImwoDkQ8vgxJU7gjygBQGzwCUTKgmYd44BZEDKEnMCJ-AEwDcF3UO4Aya22lXswLWCmFlaKNYBVEJ3IwXAvjJHYUOJDGkokdsDyUD1AqUDMWOs4w341+GgAEsClfJ14iTCKcBBEHlRecFcIkWhFojqRzIJmwHgFKHCBFJo+kfmzuO+ItRjdBLCaP0jh4ETsPkBdGJ8mq0j8TZ4ECqI1oFwgGIxHCI3oVIjYuADgBTKtUPHB+ZAjICCE-bBhQlOKhhh7yDCA3UCJsDkQGqCacFugpXgDQxuAY1lNgNGwToO3FM38O+ANeMOZOiC0BOy6ihSvgpTGteA66ARoMyileNFwnzBx9YewBT1voEKsR0NMctv0C1KYbPqg7iDvUFFgCZicMA4gOLTlDIbEHPAnEFmAbtiSkJk4fQSqkIkgb6j5bBU2k0B3+AVA-RTdAJBEZwidcIvwcogrFCsQTsgNaGpohSgVcGPQKYhIuPZEnkT+QHPIsKyMQEkAiFjbIOXo5GDaENg4jbTYECwgfYDegvVIjggreFvkiKQwXDlI2uSu6NEQOrhL6LX4gaTcUPN4Eib2JCFAFKD5uuqw0bCBuusANJQxEIqkCdy50Fs+u0CZgv0QQQhcUtDIKEhEyAwGbVgasMH4I6bA1FwwlBi-aNi+h8OwMC5A4DgSoK3kAMD05fqQqHBmmMIIydTiUFWwc9D0wI4o+5C87dhAEsD2GH8GM8NN0P0a+3BbgL4EVYAG9Hlwq4DHnJj4InAFIEEoeDxOGCxUcFitMPSQM-B6YOUM5nxqaDOIbHhUyLfIUjQn8MagV0RNQBWYJqgDIJz+82CUxtMoZ2xtyMjgzmKSqKsQKFzP8nWoYTQaDvTI+fmuCETSb8g7AEBAUQgGANPID8ivUPTE6AC+8CSQ5DSY6NFgzb34VDHQAVJJMPhU7CA8eg5CFBqHoDY2LZh6RTGySKSaXLqc8EDnUOb0zD5yEPmIA6DfQ4G6PDA1qGqATeDJOhyo6fBewIXMBHKzukRylcCbQEOIPpTwmMTARQbaEBIg9xTVsGJV1GiMIEkAyWCKEKOolACseAjE1irscsoIwfjqzBAwXHh+nQUYm0BoSF1kP0gggu4Q7xjVsKokFSASMBA8I8q6IAExj9DBJMY03ojNYBAQ9Jhe-FzM3tSw2EYa8vgayGMMeAgWsCTAchTGRPmgjOmokmDAfqR59hjgeDzv4DCAi+DmwNd6-4w7UH7VHIDgoCrMp4BU9JyoxrpSLSdAKlBbHqFwivCD0LlMk4DciPvQ78y1ONBAxsXz4MsBXzClDBOwFShwQI+I97DwsKjSmYAkkIzBisBmSJCUeOBD+P4wup0r2AzsDABdUIWUttBnbCnNjSy9VCI+fNBqNMAa-BDZkFfwnqhtCh1QWBhdTC5Ar7qNYP4IiQBEiBFI6Swb0JPAZIigIM0AdlApyMABaiJuFYHghMRrCo3A6sxNgECsf2a0JFoI1uCSkFKgj+bDVK7oKQhXYKkCSSi60KGWqjBiTprYiGBjI2mAEyMjsAwEvJCRPGGqMGgRIMyC9rIwmVrA+CgLWGmoP0BewL5AOwCyqCpkRQb3UBKYydQpeoVALPzUUJ5Ce7FJNOXoZMQ2GBpIYwwEchnJwPVeDHaQNQioRHLmVx4LYC5AU+Y3WF+gpQyLcEnA7ABo7snArkhRYF+IIUDplH4QiLA83X+QoMgtRoAwouCdoIDmOIOoELmo5hCLii9W0jDLqIzAfcYtg7-GiZBy5SHIu14utOvq-Og3EKf9d4DF3Q0pJkq2wBqUYapCqtiUk6CL2Md02xHsIEAskXQmiCHox7acoMliGchhXeYQUsT+EIgOFOh4QB7VySB3cNzIdlDecJj4BuygaLbSXOqUmCADuVDBMJmlezBoWla0vyyFMHU+lmZNAcnw4GAJsJaQokghaI2gsOKocI0g+ZDh4BtId-j2YIiQWBS9gPyAHSCrNi6IH-DbGAjkkJTc4N7IqTB3wIG6BgD5xPRI05BOiIkAndD3CXRAVL05wFqJQj14QEmOtmBZgG6wvJCOdA0jSODkNDdp5xAUALp8a0xqckd4sOhEcETEa7CVkOJA1NBCELAjrxDo0IWALqSHIK7onKDD6isQNRSDJClcSBq--eORyhYpqFwI1aDLYGmiESCPKFF0HMDgYJVmgsC1ILE4BfUicJro5W7XVPTM5RCFlMqgn2A5EKqIDX3bED0gjUgVUMsqzeAYUDx6sFAByLJA5EININiNhQi1QAuoUynOXHCQ34CRVN3A8mwZpuLAk5DnBJCgwrT7cAR4yuTpiIWQOeT0EK5IEB1U0RQgqEiFID0eYzkxEIPeYg1ZYEKwMiizoBtApyixSAbEYZAchIs491DmDiTAZfDBoPnw6ogwMOU+CMJZlNUg3PivYGxAinA6uCUNGJAUSOXhgcgswCskOE3N-BfAhG2pIL-Iw4A4AA6N2eA23btAw7wOOBmAzTD6zi-APnCkQGW0F4JKvt-g50C7yCxUu1KQMO7uu0TgIJ9NTnzfgO9AjPR3ygb0nF0QQBtIGhUQwKTINZh8WvnAAFBarOU52CP6IORA71BUiIc5oXQa+B0u2s0GrNIg27SDcP9UUnDBCDSwu1IwwChcZOjecGZaPCIs-G+CTLiuoLrgYCoUoGuw3m6qWaIFEoBjDHpwtUBpPNhALVZQ8IZoGOBnwMoIxBw1yLfIGlpq9EyYLSB3YJpcO2BVkMy18SUaeA6NegibgK0wQhAJvNe0WvpJrR0QkcK0mBfMjnqt6FmCmwRYhMKCRARUVK5ZRahjDGZBcFk3QjRAZFWSGsHkn4AryAE4iQBtyH9OuqK39LVIyqDHaHW4Wt2IbDXuaMAVVEc20oiBqFhgQ2ALHfCY5iA5gPTEhYhXMDPwhiANoGBohbZQEMo635C-FH6oov5RwLbAK9CY4JDkmnCfDXMgpsC6hrx8pvR7yNqdFsA8kNKVfgiUunvCYcB54ALlJjiJQG0QzClwWO4AN4D1oJKQPxBuIbrQN1QOQoXAqjAJrqHQqSDgxFS9uQKMqE8QGfC1yOCo7GCNUmiWUdAk8C7E0aAXzOlg6fyjgsQg3siHOMugI7U1QNPg8ITIKIpApfDocE4Qwn7CtFtDMNlGuMkgE-D8cGRAYoPuAPqQ1Qjw+Bgg8+AqkISkuqBzQEcIzuShwBmAWpCpyAR4V6AEGTqgYTD6PZSQItCvSK2oGuggtHIAKlC0UFqI-hAI0MZgn9qRYPqwT3C0JINQ1w6QRO0orBDXVHH86HCkyE8QwmgLoPl1koC7RPQA9-CCALWwWoDzkbAAMKohuOQACuCBuopwbjQmZHkJWXDzeOT0amjdINRCUNDcyP4QwQBZQNcOHMBJKJZ8aIoZ8Fx6d5Au8Iugx6DONr2QakjFuHlQsfj8EE6QcYAmhAkgeNQOKAOowtSmIONQ2aD1oMbQiUDcYv2QGviI4UbwECAdqVFoS2CEpJEIXKP+XXO+wiRNiA5CBiAcgNvg8RDwGM0wLyCBuiig3tTuCEpweHpvBXKUAVImUAWteTCzwuKQpcUVIBEwfdjZjJCIvVhVwPSYDejG0JkoA7ACGNgoWyCOkC5gatgreFne4rI9QO0Q3ia4LEpZ4jDj2UTxuDgOQp-g8RAy8DlQ1RyaoEikQlX-fANwxwgFELvNFWY+WHIQskCNEPLwb8jPgTfwIwD-yFKQ9+BJwM5AbhTTMDRGqcB38BQI8MKwWBCOiyCrNkQEUcQGsBBEOeA1IC6IajRmSIuoOsCSmPHobNE6osGAG9C-o0Qw8mm4OKLQ7OgI6C7ASQDVIGLu27SioNZNcrCD0CV4IbhiwHfwNV0AKNu0cFiIpE8tdjTb8I+QT+XeoZlwjOQuxP8KsWFEVevoXzB-4MlgCAPn6MEwTyCv8TNKGG49sIb8iCAVQCOm8mB-zEewRTyo4a7Q-4yWgRZ4FGGDMJdAnzAhKCBQp0ATsIUYkixk6KZkS54DMOv0CRi+Hghiu8BE2qnA7vhbuBGgxfhDhNAInTD5IMyCjPSa4J5AnqjwQNgoQGDIQKOiqBAm9iggaZRqQLwiLyyZmaGgvYDmmAWU+iD5rtJwCdwiIIoUQ3ywuvloraDZMH6yY5pg4AYwwWQSmCGCpjAAoDi0lsiDYWmQbti+WmxAf+BG-fbWdJWeBJHAdAT1YFzgtJhk0Lz9G1DCtNIkFwJ4yLYVtzCRLS0gxUivkt7ZnkCFlC-wHvCD3neAIZCXHtpC7AA2QBcgw0AqCJEIHiDtYK2l3mijJK3QYUAQqDUUGvjdIDDwtKS-IDIUs6CD1Es1uD42QESIfCgiVJp8CZAaGp9dn6Dlw3bFr7BK4JNQz9pb8AmALXywYrMiucaw2FvImMQJmAtYGpBuMBNY3YAeIEhAfKTlUNQK+kD+8BPqo-wOKDUE20jxMFZtxrrIEDjV1JhiECQQ-QPwQA2QVyI+ZBKcbETi2DqicNTzKNegBC593g7+zBCVUGk86oR-ZqQIyYDrAB30SBqssD5AM+qVhEOiDcmizHlyk0C5WLcUSiAu+NCAy3ShQEGIcBZluIGwpXiumPvojUipIJDkWBAI6GxEx+DUwCKhxsBeCJxEj6iymI3gllCeQPggvAzwZJfANWktiN1tEs33KA7JI8pvxJxAEMCOyMeD-ji8aAUZZGixSJApYZC7mpOJmPjBQOLYUgjqQOUguyCnKYYgA6hGQBUwp2Cp0EBg0PiY+GkgfrL6eR0glJjWkD5YWBCN6JwQifCyqFp6sNhbECV5-8QJxIcIltCpZLDYrZ0mkJ1wqiQQoDf62xiGqK4wxIg4Sb1A1FBe9CuEWuDDCB52uQJw5AHwJYSNLsbwUMj5IKV8pvRKE9dAj2jC4BWkAYwA3cll2XDyCKFoYhCGaGm0MPCEOG1gA0iqkNJIEVSMqNBuI5MooLsGWUBrICrw3+BPeibIgGClYHAU9vndAP1Yx1Q+QMgotINb7eYIzahuqLD6cfAezqDEt9CUyLfQmogpcGHgxip4ELqw2lwVQPrMN1h0QMaVaC3BQIs2U0jG0NZEBdzu5bGiClADYZHQFiTVwqNgwQgWWGYwSBBV2FlVN1i-NO0ossDTAO1Nc9EyncIk3IhF0GZwSkhdA5BwWBi6lSZgKQSf4Jo2M8jl8KqgZshyALmyCU3eOIhAEI7TggfINMC0UJtNuSARmGLQXNTiksxgxqC84DSknP43YDvAj-1YJO+AO2SQUINwEUgOTP6Qw1RlwEz9k04ZwLP+8+S7JrkImIiTza6YFmyvgFrw5DDQ4E-wY7CFINf54RBkCJKQ1cIiIGQIQTQCoLTgqnDHo2ggiKCn4Ai4srBojK84Dcla5dCWELozEECVQkA-IC7AEsBCAJEgOnBjZB30wfieqNmASBCwAMT2F8zcCvRgevClsN00u1L3U0Wo6HzNRBiYVwj1oZHwy+J5sJ4EVwiOuD4w5nkkUkDTj7A1CfOAf0BnqKEqIyyLoDvAX9gPIOmdwmjBwHfKqZJokH4Q5ODeyhdQxsIDXKip1sYGwN7E+uxEiMiUJ1Ob1IJQm2AreOjQ1GXG8Diq7CB6CO40zmxbYO7QCCBRxBtAS56iWFxS2-DJYuvIhBJe2AJonci-xin8BT2TThQANBqQlNdIRNKpaRFgPiOmQAI4yFAH5ZrQucAjQHWCqLTkmAgErfhkMDlA35C0fBgk-HBRNvnQMMCt6P0QuJDz4PvYzNDNRJH0-gjdDAHINeQGWFYULKgwgA7YKeAd4I5NEoAI8N3d3Ih0mk3QR+jPqFoIeVBUvfhQuehp4Mi4PQA+aCNyYeA24FvAD+CPaG6xqjCkuIqwBZTe4jEQOeRf+Dn90aYzEGQ4XjykCG80aaKpMIpARMiadu+IzNQAwOqw+fAl1nnIzyCV2KoNbQoSwAzs3MBQoFMgIrjUmJ0w+EBVCJOAXiXaCT80RCgOoKOAFb2ZIGgAofQijEJAlrwSiNckbiGVkPPgqJJdg1zM482nAJG4ZBDQqBgklC3ZIG+wCEC5xmrmTZ392KJkBgImKQdZUWg2GNitGNBcCGWADfpcBlDqrnQVVHOAEqAmzAsd2lBXMOfEAMCIxMWwkXStWh5AaWaiIFXo4CC9wDIEykgK1vc4fzByhA6wrOIhCj4QohANgKIQzn0fOG24iRjp5HxIU9iIpJqQUyQnlVM6peRKYDiqs+ADsAipsIRuyD7Ec4K1SK+w5WAiILllQorWKlhgOEOJLIUwM9S-MIZgPRBOQIsglJNFwMSI6MIH2BSg7iiUMPF95wRjY2Et4MDj+vTg53B4PP4wHFiyVp8YhTkH2M4grQ2FrBiYA4AWWZj4M4wlZpRAt+TF+AXgV+ohhjKu9AaFlAkAfRDSJBpK97AWkL-EE2Q26J4iQ4D6sLtArugp45k4cIhOGFvMffDXgHlZAVPtEEvqT3DL8tdgxpj4UHv0xsACsuRQ+OrNIPlQWZQCpcVgoMyWwPWwYHXWnOCgncqfgF940ZgY0Jo1YXTFuo8gw+JcaENBEESjTE7g0KhmVBEgeXKM9JOwKjAE2MgQ6BQ+kH2ZydRrfMJoUl1mQJ1gdbBIowzoChTssS1tZRA2ZQGgtMRwiJpc5WHKIGUULMK56MugXnDEKv9GCiZDXNBIrOF4rhiwXch-caRprF6lePFA-XBTYoF4pMg9EK25XcTsigdod-CzUrnonqACbP9wB8L1qgR4cqAkxIUkxLBz7Dj4k56whA9Q-jjh6MyyhTmOtK9IfWg6IMHkzSBdQxbADcmjSMRAvNQNoAz8K9hSXeBQ8-Ch9D3wq-CkAN+QUWggtMtg4e7WgvH00CB1xlgk-UCB6XjAnJT67C9WVwit0tjAtzC25CrAJAxwg+XAqW2u09ZA3GK3CNooVqjD1F9lK7DngT9NmqOVtdkwmEDl2HOC-3xLIOxgJpAnEFcIuahdYPKB5UCYiGk8ggjq4KIQzTCcLGNAK9gdMGLkEyhcaPbEqIhR6MH4g1BAqJ9RGfCAoCJY9pRe1L4dklHPIIWsRGRPUCPA7RDMEElq2ZRxdH6obRDZZPDCSMhVcrfNb6BExBUUzuFPwGjAQ1zIBrsQ8S5OVNWIJKQWgqWdQPh1oKDjllALgCu6kiD84HDkHlmWsOuw4SAohBIwDeBuyEmO8VMGnP7cVcBfEOzAQkzl9A7ovIjB5EBozGh-0H1gyCBJwLxglJBNQOXYMRDu7LOg8pxP2F+gqpCwICLlihShpO5QU5Q1-CMkPpS3CDQQkQif4O3ouomIgSZI9GAQPPMgbhS-aJlwRUD0YJwQvcQtiPOApmRYFAIghoxGTEVgjyh1sOlg5UjzaNCmobBngCb2UcTo0EjI0FgQRJH0BV0JkHB8c4L1MG84B11vgnLZ63AFwCXC0ACpwPpgRq3w7IjIdlCf6GmQVk3-0b1oW6zAyLtwbzgYUGiMPhAJmDBuqNJTir-E58ZWtDX6lfLhLDLgxroO6NrEqzbyGNVQVPS-NLVI+AVZokuWugB8KH8D4xjVgTY8m53rQMLg41DV-EigtIyD0ILgLPy5UDyc0OD1ZOQApYAhaI1gvfrlYTYtIyycjBToAmwvKJaQ8GQF47mmxbrQw0B53WDeyKwQlGCYbJ1wqDFcBpqIA14TYFOY+OV7QN+Q5egmOIup-mAEUIAwlsBIo-FRr0hYMJ69NrNvuIiS6bDMYAlMuQLgqPhU2DjMwHjAPHqs2NpImAbWghWghawrppHcMIinELnu0NintRMoXWPxjaZAKHDIEDPQkfT8MOHuU9kQoIUoDbg08JuN3Aq2mAFgEDzuAHeFXOqPZrTpAx7HiHqwnzLyoszEt1yWDloIZRK8INdUScCniJuQCvqt+CTEp1kD2KGQiGBZog2w0zDzBgdwa7rwmJgQ8UBjyKnA4rJq2L3EfnCzU23IcdhpwCzAQHhAoCAQVg7yY2o0Y6RZJMtgLEjZCEUgsjpcpPN4nwLotIhI-lS8gPwqonQ6hClAcOQzgCK4XWB8wP4wV8DURmlAze4SMCHOFxDwxDq4GvhDhP9g2kD9QO4gplAYpMXdyxg+kL8sgCiOqESQI67goKGwvZAxdIQSJPA5mfheb0AMdHUC2LgJgCrwY3WgxD-25x2zIqiITajVUgR40Vif+F1wFliDUMR8V0CX8LSwkPYGAleAKkBkSMggGzM5oPctagJ1OMvwY9DzeLToDdChIARAd2AVICGwiFhiOF9oe-TBgEhAPMMmkPSge-ROQE+A3DS9mBNAoLDNwOYYbxE55EFQevBfwB0QcuY2cIqkXD4t0GhAgJjOkB3ACOQsFOKygAIS1W+4FRiddNsD8rOPIIUImKg3QEZWd+gCGKTI-ghWwJR4Iaw2sAOAeDyZcKTgKIQEsB5O2xhQ0sfgvECB8mhg7V15cqtAO2BHCMBQliQ98Pe5b4DzENXCZWDELemUtYjkiKb0pxBO5H1R74P2cA44P0QG9BFIcsDhWE2IpvCiBSngiFSl9uxkPzR5BEeylWDuKCJtZl36NIZIvcF7uJljdgrSqI2QGEggrL2QIiA3oyXCAXgbxNUc8EAcgGk8BdBXanqwZ4D-QAzEgVUypKXAGahGJMVg+ZBYwOLYoDB6oBaAI6Z+WNTAjNDaSPVIzSLhIJSg94LzEBow41Aq6VM6zhT1KFRqkoBvgOXAlZC9wH4g37P5tWLAXRBfaOUoN1gT0IeEvrQZxBiU4CgMBNyI2YgISOqIgmjYILzUfKA7AkwIyki4FMmo++IN2HLAX9LUwlXYpAjSKWlgwTB6WmcwrbEkaEMmBhN0YKHegeC5ICTwuCANeA8gXzAbAvVkWDjViFgkBBayQF70C5AhoP6IIHSfdaTQcOSfSBZYMN1fgG+gY0Au9OWo7IpHsAgE+YDxMObIN5DoFPuKDij76GIAPxDnmGCgU2KQlGw6kxkjHF7Q2Ghd2LDcY7Cr8Gx0XNDXJBzA3ggg4CmAvR3xoIng9WQ2cGW4b6hmRCl6dbACdPaq85GN+N4Rw4hqoMRAxbAoXLpwL4jojCHowUCvdipwgFDa7QYAxx4fUm6wvIinA5mAvhypcAKk34AKCBsE3MCTbOn4X63UYA2AbpD5zLdwCIjWxji0Yaq9GEgQ2FA7oC6J2iCm+MHkGYT1qpygtAQwqhCg83h8pNtAMEA5eHoItRiT0NEwL0AWMFNIX-3rwAVQ+tCi4GBEwaAmyGMUKjDzQJOAHL74yOjAiUBFsMvQaghDqIvw+Nzy1HEQWZkblDhMQUjCJNhCCyKSLPciBfAwMBp4rJBt4A7g40C5sCHoFJyhufLw4xjCELHgwrSP6OhA5ABzQGu4YtCQYYbdUgBg4LIJsNjcUL8QUizIiAOhBsC-5D3wkG41rAXQaDXMEbiguCDaCWnAUXQGCPBce8CtfTEQfKD+wKngO0Ac8BmoXs3kQVMz34rHnGpgF-A44ElAu4BjQCOACgiQwK2CTuBY4MdEUdAb0BVUEyDCwC3g08io4EdEEKg4jBegRHDeyMihaniW4MTpX12u8PsQ-wDnhaG8kzo6IPEwKmSY6PxRaBApwVoUaPw54DbYyEA9LDLw12DWANgocqCutkYaNkCp8KtCgji7fJ4gi9yvSF5Y14gQuj0ccZwG9GpQdQSs4l4ilsCFCJoWVIjRQFqwIGRnbdmQT3rGCIDAdTgl7bmwHGRlYKMc-CiFlJkgTCD8KGuyCUzJQIhgtxjqKI+Tf3BtIFfAQLQ3nZngotjw6AEwM2BfrlDgR0Sm8HNAT9g1AStEZWCMYNZyXvwcEHJCDmH5tqdguJyg1BIwdYA9oBNgyYAUIPEIiZBdMwawgDAp+uPZ5hiZsGa2OUDHVIhY-chnUJJ2xNAITTVAUtCEcAIAJuxrYBGglryvtBKMchBw2EAwOuhnQSGgPnrkNL7Z5EDoiKYwjyBiYOr0JXDU9q3yxLoGENcu6JA18DX4bKAjINHQmJBNQ3-OQtLlCJKYZGj1qlxohUCQsF8o6iAeKicYpLxJ-b2wmOjaoBQ8fdhk0B+AVbhVNOOlQSDVRNTwNahKRmVgB-Chlui0kFD5gBrjYZDi+K-A68i+xEaISnDoGF1Ch+AWJOOsBuyQaMFA7LpfoHq5AQ3oQCTwEHGWOCrMm9RrsjOgoMhaJLic8RCcoMNo82Be-CiwbaI6BK5IWDL0dtgQraCfoJjE1iBPRNCwHXBmyHv6++i4RCowsAJVvIoUf6DBCMf4JKROEMaYDdiljH+gXUyvFFdAbaJuQMeI6Zg81aMc8PhCsP-AkqDs6LGMT0B9aESQ1PDezA6QK9UmZK7Q0iCWWkcwQezMYDJwnUiP45lI9eDjhtXJAPzQgDHNKYDpQK34vnL9GuOAfqh5wGmoh23WKuPI2ihm2MlFp6BuwD6Q5xBExAhgmhJIoL9ATPjj0xyEOSB8KhGwkzifqS9WGi37sEk06wAdENOCL-ArFMjauUyAxNv07kiE8Lx4O-ATQNaQLUblwBEYXWBrHKcg-WBOoIGk2lkDHnO64ohSLGGwfA4aYLcI3dDxDAVJ2DhP0X-g8cBncJNZmXBeil617RDRmDxATdiCoPoQemq2nkTsXHjIUDLelqJkVozo+9xQEKY++qgp4O5QCVDnoACJ3qi5QIMg2BALHfcUUaS4ULUo9XOHgMzapODMWNuOsrCo0pmQdBgO4DlIMJCXCHUEiTDu8ElAd2CrqFJw4mC3LF8QSMgLqPKBEyDDAgUkkrAsQGzguzDY0MOwCF0UyIWIY0B8oKAgRPAf2ojArtC16PlwrA7AiCVAJ0D0THbGWrBdCDQwQRDUQrxAY8AdUCGoXrDWUF5wOXhCBQF4C4SESEZsZ42i4BtACLgBoPlpi7D9YL4gQEBA+EH+NCB7uF0QoiC4FGHAHLAtAIs2uWBJAJCRA1i8ME9LxkC39DEtdWKzoPVotiDHIIaM+pB6CGNAB9ijai8IJsgTlCGgQkCZkJgQO1QyBAxg-5jC8gMsf+Cw8AKg5nXxZsq4B+D94L3EBFB7IC+M4EBJKhpK9xTVCEZMZvOdkArgEjAM7LVIcurUqTKw8pyUcvs6hPBZJFx6O2TEsL1IB7ogrH2MRGDdQJMgEYj92FzqDOgoqD2wV1AO6PjcEXCPiFJdXsLFGpvUOdDg6MAkx3T2Q8Y0FBrHApQIJQICgBfwhNDw4OjAm8KFwDdUOUiByOAoUSDMYCJUOTjw4lkoivDPqGKAumT3cBTIH-DcYmQQ-vDIVaDIfgYFHddkLmDwxG+492BAeAbsAmRSyKbQ3sgmli0wQYhMNHMgPaiGwLvO7YBkOJxqRbBu4n-jdjQ08BdVEKCcHZFQtUC-xmvISfgqSIs4okjGmFRUOD0+9AwGTOSZOFqsRUCTCJWkGhphQGPADSJPWMNAqYj67N+Ag3U1WNMAjvjz5CdM5QjQAJ8Y6WgmTAKxrCAskxIoFAbYuKwg7vCfpJFAC4S70G1g44D1cKDgkDIGIOnQ4E7DXIoUwyAreN7UbzSYbNekuQL-ADYcMrDh+j5oFtBYwFRqgGzRcAKkahT8oAF4CbyTsHGgFiAlQCnAbsj+SGOwZOgEGZnomqKPyCgG0BCYSHZQy4iWfBoQY9D8WCygYNLzFOudDZBZYDdgF6C1RCt4gdVRxLf0Ggj5kHjUiJD0oAzEN8ADgBnQLzCgg8dUxUgGMHQg0XREyDOEozrLGDP45bC67KLANASotJG42ijMLP8QZHn1MHiwirCpwDEwy1MVQH6kFAhfKKmI0Ja5qOz0WSTUIGJAFsB5yNsQpf11WqZ07bDiMJ4geMItwGBgd6yLsOVQTuTd4Hnc0Eg1-MWgX2gTpSRADOzjrNbQNfhSYAXOflhtcOsddsBXjoodLvUzSHCIyFh28LyQwMjWROgAGiQcEGqgjuAMzHesiqTePZgCgzDKcrpAVYht4PuQ8mxHCDIehmCpiObkkzoXJOSsGBihMI7Iarhf2BBEYKW0mGsASgDlKAjExUDSRDq4lhBIGtrk6WMkaDtYY1agQpwYgfJSoIpwr2CUOM68Mu4OsJY9PDCddFYKMqCMMIIQqCCyqJnAJEFp4PHp1VKvamdgj2yUIIqYAhgyQM-MBqwCoSuZWGA8QIuIe7hhsLZAM+ycLCjYXyh4wvVkVMglcMo6DqAqFguE+fhcemoNR2BAqIkAYES00JpAS2CGIOKQvSrVsA6TZ5640P440pQDwQ7wT0QN2IwwZ-DAGnxIlMZ2WL6NkoB9aNnQCWwRCyJYUegBTn+p+sDsWEXQ9-AVKRcQTOijHJGwHMAPUF0AhxCtgoKzWBz8Hgb0KUCX8GagVFTL+NJEAQD6kMaYYU5oIOvgvGgBhO06AKB0GG4A0zzE0Iii2YhTmJQY-8R2wB0FrNiQUlrLe3aIDMORnmjpyC9AKnDb4PgMI7CnwpKofUjVYfZw7YDk0Huu5bBRA2lAGDO70Mqr0cDVCDyg0xiiwJrAxdRkxJjAR4BLgJb5PxB5ctVcw+DBZP9gX-hKRigwRiDD4Oeg9zhEOQ2QWrgWsMAcIQoK6agQovWeeC4CJkCi4FiE3rATkKuA+rCa6PoURPAaMNwAxZQ18E-O3sD0EPgMKVQwqm4wmUgFUHpADMz1SMsBOCAqBatSYmiA467IjaDz5NcguwANwB5AN-oLhDrQT7A5eCumiEDGKDEIrNQgEKnQeekx-tKIYETREO1gPpVpIOxhW6ylDHYK-6yKUOHgxoCQEOtwuRIpyHfw0q4REsRQfb0Q4KBOThA0sL2wNSD2BPrA3Aju7CFQDyD7BCJg6q2qYLOwBNDAWc5A2zEvVrlQZOiCE+PTlshgwCh6TGVDGpVuE+BWLjLjQHn8nZcQ74DBcOXoMGTlYeOIr4BKkOQ0ZWDJOcPqE+q4QEkoM+T5jJS6ZOKk0P6QIbiJkH461WjTkPqwfWiTbCiWnvAqZJRAXDCBULeAHQVAuL4cizg1CHUEhEgUWO8VApBJMIJohMCT88NQYxQyeMY0cgDFMQXwM8BQEC1IUZkJvAagbaLdDFzApfBDpLcU5qyRQK50wxbaSGEgKinfJFxAxEYeKl7DbdBrHHeoPMCYbFeGzRQWMMa6u6BHIOiQPmgyQ3IIkMCzuCjsRiTN4ILQXMwSQDKrMUBc6pvUdbD0EGfwMGSTQJfwA0NQ4ADg9zgzSAZjHiz9M-MQmmhvzWQkX2TeCGLA5WzSiIMgemrQMIuI9rFUSPVkX4DJwIFAJNjFcIqo5T4fENogbcCoYJCieVB-0LLo+WyqMHpd3PhaxHjCYP4RdOWYOMDxAgdoJlBsRBJAUf75IDAwm1Wyqhtw0TCS0goQtFxgXQdgBVkbcHhQn4OyI0bJGKQy9Xz4ZJDnDJcejeii2I-IHzgz5GJg2GpJKAyowaAo0L8sGhCAkB9g2+KdeHvIOoQ50QJ02-RZ9cnQ-9AKOSqEAVIZ8CZQekCVuPZAgZ4kDHqwnOCQ8IuwHKAXQPbQSKSOI65I7UAyKASgmlAmkMt0-kDJwDHA11R7AJH0wmiDgIcQ2SBaIO20hRi1ODrpCUBPmD0eNXYFiETE2-jVHMIQa0zxQOh8FT0NkHjIiAwjJNtAVm0GAPNQH2DlEk6g2TAaSC7kHxBasNlAXsJnefSwVwYEYT6kUhD8EPdwzYDHoMUmARQPYFMhQGAWQi6FFaR7uP9yUPBt5Dogv2giYOhIEVRMNEwCZzAA-MX4yxDsMIuoayBfeJI80q4DWO4o2LD2GFZM-pBN6B31Ch4L3vZwciuf4OiQVXKT8Oq1JxB90JiDTjALYA7VmuhAwP1wQxooQLQ0ZtnFSPl0gZDtxdEQXvCtvRQWI6iYGsFw0UDMpmW0ycROYM5AuVDiVBOQxcAKUEKq-9CjgA+IDXjNcDCQYjgHc-oQcaDrmCuAegBYg5sEOYiXHiBYMig4ANxQhqCC0JKoyVBZIMLwKYBYoCV430jC1LzUoMSXmIeMVOZT4LkQb1CE7Ado0iAOcP-A4xC0mNiUamiL8IzocJAqFq1A1aCfpNuLiEAhIMFdEZBdqMH4suAnJD-2CVA9HZVmWZQx4AWkUqhTBpOg4sTlUCpwotgNyWdg0Yk7YMSIUWCjQHQIifwsIKODwMhoMCigrGC8QMFgD4CZSNmOokj8EGoSmEBcoE3QKkhuqGuysKzV-KBoHTCrqN9paALlSJhApOCFiHWg+NwMIAMwXuCeIKIunOAyiaL1JtRsRP-gT5CmILTQcPBSVDGy1KDK6B0dBHV0IMAc1yBOkH6kMMkOkMUUQQhIGqfAslZPCS6InWCl3EOJbUAtdHO23IjtsJM6hiAUkJ3IYMrw6D+k0bwxGGzg1UQ2rQPArsgK1g+QaciGaBeLh7DNRCfQyWT7QP6QKP4TWGmQwFTNzVusbhSTENTQ7L370AKg4mAmyIGkT0T+kDCq6NCncBmoKXo+dEXAE1B7yPGanXQt5jQw1fzBEDou8xCy6LPC1VKXKJFArlBWtIJoyui9YF0QXtREkLmcHXZTaK2Yu3Bx8GGwggDUYJMQdsg2oP44L4iclFJUNLNZBCMwmBaQUFHEPPCt5DmqVyKtMD9AHzArrITgmJDZWL1AnmicoIuwi1G1MKMjJdDAiGmAcfDkaPWWqLRbkP7e-6ynWoTYKP7eTVYgfzDJiNLorxT-QPJQlnmwIEwgCLilfMq4u6Y+pMeIE0jFsOHgLML7oC2gJkQLwMEIbzgCkE-wSmDNq-8QicB5GCUIQb0wwOQ0qBBDOvhwzFgDGLDczcAcxPdgnORXjFf0sZzw46LAm3DbkEoAb8C15RdAXAgpVNx5EwgJnGGqVgQqTLCalyCbiJWKUsT8PQ3A46wSKM4AsohZaYZAQMDNfTlRTZCPqHnQc0Gl8IBsVZ1uMOyopACEOC7A1ATFmDloBBbB+P5g7giM6BEwvIiWjN0omnRExGzgiEDJmK5xz5CDS4OAabpQRDGAAMDJZBQUMDRToN1Y1nRTmPegqv28IGlwUqjN4LtwxXBbIAXwI+g9AI8QlbVcpDjBUewtfMYIq6juMDsgmPg7sMMI1OAaMIHy2NgCZD6UE+q8iKwwz6ghKDGgU5hqANcYc74gsDsCy3Tf9RoQc6DlbIYII1ShtNKk-j1uoL2AX2StsYmTfCCf+rqc-aCPEPKcZ3DgIBdAXEWiyHvIUeTtUIZoN-hM6LzgbBTZjHpgWoAMBhKIoLDywGoAFiStqNw5LODkMILQgipjZFvIqkCFOQQgaxDGIHmgDOhe4NEw82jzEJhctUQTWFTkrkgXRo3IBaApQDcwV4b6kApwipi5ILBiR+hqSP445UwHQP0V1ICHQPPkM2DK6GIAeRD0oA5hVGDCCPOgWpn38BoQFOkTsqGwQ0h+xs38Bqy6sMWwtSDL0ORCqBAGsCkgrgilgHvClYC6nKhwNo1U4JQYdpDd8KZwdTj9sLBQRiBjTcnQe+CmcJTIq4CnwuQ2aZAU7ohDOKukWGbYiTBj2B9r9ilViG3IFEDfECKh4yDqdBPwx1SZ4Mi4yyqIOQ3Ys8l2mGsADthpYGuAelq8gEa4Ax62dMTU0iTIqO-wcArYIEkwj8BJjjk4sowN4rGUCZzWszro6BQsqIZoj3RiaD1A8qKFlPjAlYChcETELPyokqziUqjBMKOoBKAKsJ9QP0TOABeN6WBDGo-AvjAQsNLsvMDMEBqgUGoEUF5wzrCm0AfQn6CAYFMgfiAHaD70lAiaUFDgc8h6YJfJDv6SqMFkdCDGoAOoOIbh7tMoXcDrANuAx3RV6Fok56hJcPFAIsALQNQgkiOQoKmgYSTRprkgJMAxMNngREBYYMNAPqQayHAWVYhBphVccluZgBlYI0D05R1QZzT2wALAOyCQMFTodhDmmEd4r0CnAOhAqEgOsP0QKosXHH2kdHxj2Fu4WDIWwBhYZyCTEDMoXwBywNRo9CDp-ClQLeDRsOpARBjKIH5wHKDCQHoIDA0pVLwM9evyQPXqamACdIGoxjCiIEj4raSYIVwQEWAcqCqEW4Qw6QkTzeBtwBKM6BRCQDrwtJjACAagTxCokq9AbDFbYDfEBhDRmEuA8oFPkCCwONgOOE1AK6DkYuUg8lP-LT+w60CqeOpFwwid7EN830C5WG4UgaRVkBewDjyJqa0LGIz9WVU0hxCQwB8gcWGpcPGGuYiXmLTAe5DyMEGI6UBAQDAwTHJ9JDk4ypBFW1W4eAhsMF8oi-A9qGW0aSLv4JsgFRSOdG1wACiIDMioaWAsUIV0JsBecPdwULEBeCRSjZCeAGLQN1huoMEQcMsPiAZAlrCWMPso+AwchN1AFoAypCHolFaDGEvCe-KESNHQ5EDrpYBsFaBaLIwgBRz5kNTw4xY+xIUYfzClfHK2B0D8HiTgdZK6wPxCLaDbIGCES+rE0HgIaRAOHgTGb6AUAGlmuzA7gMrFFxwwwPmgBiDURr5aBrCmwJEQ7GhqMD4Qn0gl0OeA9EiLiFU0WpHNwAlIv2jfG-ty3SkuoNBxIyA5oA36YAvEQGjAjWv+YIIAkcDAVA2w0Ja-MNhFHfDdEAvkWhBCqqJ8JkplMCcMLkCaiMwYy14YskdAYMoCbOuAK3gZyI7yF9JCYy1gUzoN2IPROfnmwCskawD5kE7gzxjIqLvq08BpkHCIEuB8CAmEIRAzeI+IlKChKipIZApMhEk0rujGuiiE1MTc4E7g82j2GAmgXfAcQKM6qJhUgOY8UeRvZtfAKVAWeFNV05BVEKegSt0nkuG5PKDZ-eV0vbDO2KIQB9Bwa33YPnD+-sYwbPCK2easHxDLcNGmX3adYKFgIyB25Na4Z1AYUxjgXnSYMN4IGagqcEq8OUD-+P42dfTElIkNMrAXQMzA90BDYEA+LyAkzdzAcfAFWlNhPInxDTdU7ggcqCwtoMhRSPzgK3glwpVEBZC5yI4I1Fgx0BzIUpAPOEZsSYzbWnu6XyAm1H1g70AVpNDYAJyTEDsgEjBkxAfY6SDFwJVYXrh9WM-Ms3BocM0inhjckKOQf9CyVgNIg4B1gNdITwlaJIKg7Io9ALTANeQxMO+ITLi6kIGwSUBRdPtQQYjvICMkZ+CTvjhA58CRYNRChKTMm13IWrgY2IrAGODUUEgwnTD+kADgCOB5EBg42Wg0oJngOsBYFINTGHCSqPkoVL27EF0ABSSe4MJoyZgJGI1wlfgnDMX9OmjGVB1A4kCRaBq4jpCoRDfUkxDUwE+ANJT6qM3MrU1NcNXCNrDhCK6Jw9ycRIsghbGBQOvItehJ2QH4t2E4+Oh2dlgT6owSXgiyiPYUC6rcwOYgMaDD-DfE6bDAlIdw+sC1y5wsgfI5VVp6XxCjqMF8TYBcet5wJJZvkPVwSLjjQCMkCZjZiOs45zALtJ0QZzCUMKXIIRzrHZ7u9UBIMMNCgTAjJF5Af7iM5BGgeLCocNLzxnxoSKbwpB41Hp+L-Ix-jP4gDCAXoBFgnmgA4IWhlsh3+G-bT4UJXRSgvPPVIK6gvW71oBAg9kSvIAJ0XWSf0tkgtphDQBa5+4BfbJ3Q4B79oO8giQCm9MZRW0HXcqxe1PBqoE0bn8g3MIG6+HJYxaKg0iKUMew8VaCZINfACUhe9I56Rrj20G5AXIPYEMZYi9hIjvKgk1jpoHBb6HnotMxYWuBMQAKk2VjvQBneYsBhsHKwhqlHRD4wzrAG9MQQQHhPOGoA2NidEmFAt1VViBpIEiY9AM6YlHgNEN7ZOVA2cNuEhkDkrJmAwhZyQpne1CoCgPqgjcBlgL7IAoi0IJCUxoYvIDEQucDl6PQQbUADYJpcZ2AryISMW6CTWK3AeEALzpbAobCeyAwrDzijqCqFkcK+HDEQ2ZT4IC1AhhioYJxATHBYmQ94hmKXCGToXiVfEIzGfRCRkIc4CYAqwPSgs8D2cBu4QjBrAPDCzfjOAHU4tWCn9b4oGYHQav2RWRTLsNyID2LJMHWwBHhw5O0QF1CjJDaw0ACiSFkD-8C+HBgZXqDWuFjEhMDC4CgIIji6nDDoyeR4oO758li9sK50oswBeDUg3zoE2AQZ6HyAmOeYuAwDsC7ALkCNiKJe2SBj0Cxk1IgzkM2Au3DtQBtq04K3cP98cdCPYBBEOBjIQCygluGlwKIQZyAoCO0wh8AX8GpoDkIhu+OQ8bs1-IMgpROpUE-wZzvyQGoCLqAmoG6W7bC5EM4EiRj0AEXogyDUICQoMDA9sE9Qhmg88J4MS4DFuuOg4MgeKtSwxtA8nP8GUcTEQHsAl5DoFPco5KwoMFPANuBikJ7wmEiBvoCpVVBqMAmgYTDjGCuIeiCqTN9IY4CFgEAs-0CASFQuDrBQHlrw+uzK4JwYEXkvsHvgqOBAlC3gkJiWkGCERMA5ICsQaRPjmWm0osDF1ISw0cAiYC8wD6DYKBEUb7C9VGgAe7rUIPfwKEiHcK7oPUZyQNuQ7gC7mqngaJCywGoQx0CN6Nsg4sRHltGYB2g-9uVhI5PZjJ1wx4Gz8jygd6wG9BBAUdDnoP3wU5QN6DxIrKB-oAUYHyAH4MMlFz3x1H8GtnCwUGdgxMBnME7IfKCZIIBjzkDTKJxA1wj8gC5ITeATbOHg6+gVxC6kDcakIPIgcARZYA6gA4C8iGrY-pA-NJfAhxCe8EP4DOy7OLtQTQhArDfs1WjXEExAQKygyObAdQRsgmyLeUiGYCpQGcAvhBpgsGL24G6gAFAycBpi9TCbwFykGGyhWX+ghxAK4BjYWBRu8FUwB4B9pNdgi+BeuGCE1CC6iGCE-jAgOnXG8f2tS9LQrui3uJyw3cDYOjK5l4Ac-UEoBZQFNJ-SvpDWKqZrIVaHUaNAVVAPIO6bs9BcMMY0msAuwGjQbVi0PAXOZph5MBawp8IYgEBoABWGaCimVolPDQPYzxhvdqugL+vs65EgETB5vhvVfWBBiNnsa3z524hjvNResJBEkBClBr1+M1BtcJmx30AQPP6QW6V7ACpwPDODsRVlRYAHaGUYUlRqSCV4npASJs-AmGy20n-we-RGVLzAziw0MO3GzMF8K1ZwWmRpYKBQSTBpPNlNkWgutHzgJNixhKi0ZEQuwKwQzNSrHGjACYBYwOUwnBh92JDcLuT-mGng9BCGeAB6uuAf8L-EOXiESBtITLjURAsdrqB7Cs8xGJDwmfmdqBTmPuZkjljfsBggbliliPjAQqDODFRAvGAfwGygJRiKFFgkErj+WM2oLcjRwEtQ05zrmGCgw4g38P+YZRgFGGcIo0A6e-0oxVSocIhAOiAJQApQTlM4CbeA2dDr6AOw31Dg6GSItpiyHbDFeKBEwB4QDngioM6ouUB5cF7cjDBnNNfE46yDgJKgyDRbYEBg7gjiMWURWMTGNAXAVYhOMC10R7A+CQlIkzhE0NBAA6C0tmWAljh9gAQWdgAeKqVqtgCgsE1lLoXy3dC4emDGwMqwAcih0FwwjlggbG5UE0jN4KagDbAuQMJA9WRlQH1Ynnj6w+Po1THRmGXA-8gT0AuA0wCs8TMIFvCf4DkQrfhjoN00nWEqULnoutDswPIozLIBwP9wjKgKulVko0zNekQE4DjUoNVQq-gxGDdpmNixOL4cHnZGza92+sAMBD3w-euHwLGcafztOuRj9UA-cuGg5rCetU+YBNiY4NSA6k7Q0CbUbmD74KG8Y2RXCBKA6fBo0A3Jd5lYFKYwdXEqMHqww-yW4FWgbghi5Fp6Lv0-SONABOHD-J1I6-uRwNSwCOiCaLsqZMC7cOWwiei1QIvSe8KkIGDAS0AEFvDoaTzM1ASwNrCYSMECh76MIQNIkXRYMGmbeMDnEKUAUFUfwoTQZkgDoCDrjlgiLrqwxNQalE1wv8QkFGHg50QdUNpIKci0PKRAehqK6H9wNMCOWMag8Y6QUiLQyujwsI9RWiQDXNwI8MKJGCocXaraIKggee6XHEIQ51AqhETao4Kr+GUYO3gxMIRoevALFH0IbQrZcPVkshTLwFEs0iQXEKgKZYCmSKhAjDD1MDhoh4z8QjvAFQhYIBBEMem6ZNMA4TBOjHQY+pBijMbwWiyP1YkwWG18QMgGBmMUxEFQZF5cEHQI+8FCkAqmHvBvEJbg97Bg4CpJd7sgtM2QKoAoIHSIerDUgMKgd6yxYL4QWfQU6CDANiwZosPmA0jYQDZoDEBFw0-w5bA1mF+AoSCZIF6YgeAFqId5h0BjqZgGhaxuYKfgXvzkQBVQpACHQMFk3TTzYJ2QjyihdPyMXcBseBUA05wwZCbUBRpIEFgweoYaxOLgEmCWaDSIlnyn4wKUa7rWYr+gDcmnIHBATSD-rEmgVasV+NpDA1BmEIJo4lD0zo2pYtDygbO4OOB1OMioLUiJK2og5QAOeNmM6PiRIB9A0Eg72Oe4XcDU0GlAXrh+slfVTLhn8P4rMYBgwOEQrahXUHWA3yR7urXIYPaxZlWIyECSmGQQ7kBrIChBCFhV6ChrnIbocGng0j0GIdv0C2PyoNJmTdAqYAYQjXBe3OKAPUDw4LiQg0AzuI2QG4C8iJk4olClBgJoqiRRQJkQKUApwJPSAOCiWF7wXL3LiPVwi4QPoO5QoNStoKCwyXBftRsE2FBgKgAby3x-iaAgNtG0DKdhPiMhgjLIAbgO8hjgEBkOsHDWygiByEkwETA6hDFgFFjRUNfQi4q-oObghsTOdRwQ4OickL7IMPAwu5zAH1BIoF2oBvTNgEP4HqDRUKjah4B-oPXee6j5pi8ooMTngRroi-jBJC6ImAaSsAwG17SvFH6yWNSRuNzg8DBtEAQm-RQvsAw5PjgaMAMwiIgYlBqmpmy4kEB5wcCzwuQAvhDncH-gpQxVMEBwhPIswNhgSNCCaNV8N3C0iEUiAOj8Hi57XooaSoTkViBYMOHQXOQ-sC7kF8x0QNqt643TtJroMFCWjN3w8xXiEBkA1FhsOOCw9-Bw5DGyWKAGEJOArrjokGjywFArEAvOZoaxEFv8aIjXSGJy19sO2KWw26SHOIE1CyCb1PJYd3RRMEr2dYBhcIZgAbjr6KxgXsDt6DQwK3hXySKMQSDtQH5YLBRMQBOIDAbtsFusCMKy+gcYbiEWeaR04viJ0NRoqqMfODPbC8ggbF2o3UDSpAHA3zgwmwkgrug66KcAFvBDAlzQOUhd6Lmos+sAii8olACWkAG4t-TcUmsgUTKLIAkgTISIbErE3BBElM6QAWAbgG7I5sDw0IAwCix9SNHgVLCbxEOYCOQhqNukUGp3UBtIU0DSIKdAL4zBwI9QUD2XLHxi+fACAISkDvBwWITggaSwU9g4WwRQmN1kDOwIwmx4KnACOE+gT5D0xGOAp8IRphtqSkgxIB7CZ3BPsGPcM+AvsLs4VETYiKXIRJDJ8AUkXBDQqCjQJkDisv4gUOAqJZ0FI9xMCOas2kA55AxAK3gWeN8lCNBZQKwQudSKQG3IaWB+2KMwZFxOmh64yqDsqNqQUUhy5hiMnkTp5JS6rBAyRA6QB3q5IB8gpAjMLOdAJva8gKGWifzPzIjOWDJhQi4UDSMztjrQ9nCNyCBkkZoIxGW47kCkaO5gW65MIEsw1fA4qqVlKJb5kLZwiFTXGNCoKoTYdNmMaCCDYFzA1MTldJdgXCC4oPHkIyRkOAaBUaTRKF7YLyiBaIegoLDNW7fkKySWbEBofxC7IE4YC7QngCngaVnZWGD2Oui6wF8Ai-hg7ktgGEh+pIdILyDWglqwH33Y2MwttJh7wF3iJdArJJOokwj53kIgfgXoeEPAzqjcAE0IWAG0BDqivcjeOC7wvC5zGMkUtDwaQBegqBADYWdBfQQx8FL9aEgvViZKIWClsOq9hOQLwF8KTxDPmJNoDeibiPRAN4Fza9tAo36H0IugEghFIINAWhwvvtjAG+1NkMeIHJhiUL+6wiQ4qm9sO8XaILQWwTDcyJ5o7FJAgf1wMbLSRF1gcYxgsMgQS5b43Iag3xDyWJ-SklqysAHAq-BMciwU++AyiORAqVBB+nb17bD6wF3I8k6ckEgsZsBn4OuA1FDZiBggpFi+IJHIGcQ88KBgJdZltAdL9ED5GHOAIhBbyJ10UVANqBckuUBTpddkcrD4cNdULuQjpptgBvShMP-ExdRfbMPoarCPkPdwoBBRYLQg2xjlEMEAtSTBZGCAgvNyPPOEt-RE0kdgZOLh7lxMQ-jXCOXuIuueQBVAk4mIQNugZWBEBLhAbIg0lJpoH8wpQKwrCmwEUAYgeiCJ0ETEgPXqsDzAXExrJkP0b8gZoA9QXKSpe3+g-Qg1yD6k9NYU7hbQzrSqcMxACUCOknXL10CskHUgxaBnUDLjEUgfIB9SxnDesPNQkUDlbF9IJGjv0LnQOiA8QbDs7SAcQAFwAMGkQHBbr7C1KBC6f6BOYL-E-AjVyRxUG0jE7GoIJZARFOeAPR7-yKHg47iJ4PYEHzjGQO0omEhXCBmh3XZUVEq8SPVVCETSBRCcGGkuXrDIQEYaZPjixC18V1BOVG80W+698Mfs2JQTrvSwanjtAD7EH2Bna9kwdZJBqP7+lgC+xLfjQ4jFmcIWVYCSICBOM-CVYAo9R4DtMPrA8mzygYOA2C0UAAmY+0DfJCBAnqDXwPHoP+IHabRg9yJztvQw-CjCfq2Cd-AaeD0Qamh6GNhoEjDzaMeIHLA9Bm9QWQStmFAg05xmQChcyeQWkEmg4kCjMEkokDDTEBiUgKWuCOPQuBO8YDa1tgB8cH1IkQgvJs8YtTjzzjSUTWkGoKzAPyY4GGEkcOTy8NYOV6jDXBGYlUKUujvgCmxs4GQ54xDBcGgg6tacxtRQ5iBEuE7gEUhEuG0wD8hXwOyxncC2cD80hwjJ8BAg-wC9IijglGCjSEbQKmTVwreAd5aMwH+gifzlA1dA5yiYiKDAQHh05NFwAhiUuo1IV40eFoBsrChHCDmwdpj3IgbAfnAIMCTgs+BQZeSYpIyvoGo4ttAXzMfs+rBtWAmAFMBDOt0AaeDC4Pz7YSTaxFHEqJAbajtg4+itMBKgcQnciBEw2igJUKQI+kuHIAwG4URSoD4wgFD0YDj4A-ISIM9FRcTRh1RwpZKIoKWYMvCa0BQA8MIQMCVwGPBVNN7UH0AqzNzAz4B4oAtWQShYh00zHkDNRNAuHKDGyDcw7SBCkGyg5qCULHvIYCC6GL8wHsvx9PwAfCiFgEZMGNBawJBwJoCX+Y34R8CddChJ2sAS0EPwrbFeVH9OkfRXvBxoFTjnBONQFSjUB+WA46w-IMtgKoRsREgaiFS16Mfs-AjaKKnAGZAIWPmAc8gkDI8gB+AEeDmI+xD0bm087ehPkIEmu0QPBwPA7+sikDFg5iBA+JCwaOCjqTloSXBREFqA5qA8UUgavGB1gihsjFhACqx4TkBxdGwNUVvpoLjIPgJwQBxkfHB-EDk4KVaf0u0KOSB1IBgIWvDnIEKqmOB+wDoihm4U7kRUX1D-rKcoLoiost+o19oH4Ggw9JDB+LBwIIInDPZo3WRG0GC1HlQKbDsCARYREigIGhqDQMIbeKCr7ZPQbkrNRAXA05gGWIZoXHp1tgPAjUhvsD2ovDAlUCyoRGDjrAfglDhcmUI5ZkCTEHrw81BPBLegO7SEm0U7SJt6YxZOReOl4OUeeZGXgAMw9kQhsLBiN6CJGDlowMBMmmdsD7CyqLSI8lVGVSpl88s5OHu6LvBAwI1w8a3U4AXQempX9D3YPlic-ivwvlSEe6h2fEjMswUkEBjxwG84NA6k6qDI26BYXrqcFaDWVCmgcFisIGD22IjIQKQgFaTJIL8QCsDMENXmIiDSGKgUEDwEScXUgaLYEDy7V4aysDP4S1BkCBbIljPQ0H4g1jDAJOgYVEBqwaVQW0MqIGKQpPAQPaQDaZDuSDrg-+lawupA90DRUFx4cIgLyJZ8BPwoENPILuQTUIAwP4A38N7RukAgZC+wQSCyKvVo86CGYH-g6BQBCK1A-cXPgCwYJZB2C4HWpmTbkM2g2XA5GOO9rkiCwDqTgdZbfCusfaRWqEE0EU1awCm4YG0qQJKAqmC1cd27jfhccUvcq4AtoD5Hi+AnDORDeRiF2KJ0Z3BJgDkQkLDTMHvA5E5DgPBAyOC16OegkLD92O+wGNA3cBbBNw7eYqZQzvgjqF7gXtSqMEB5RHA98BeU5bAUAHZYP3is4k74uSAuI2sc26SVkG4gWnoKcClMW8wBYOEwZCTURk2+koDSJypkH-BLMKngTUgeTgKylhDnQFVkF7BokzIE7UAWsD0gt6E4wP8zTdjsMHmiOUhxKKeHdORhkL17E2B4wC12B2gj3FoUS8wVUNrE54H86LxA-VgyyGhQRNKgOJ4AlDjh3nXMFRS-NMBCZ2bFoPB67VAx4LdQKfpruIZLehDZEJ3IjOiyNLqQRiA-IBOwB8KgwOHoVnBZlJsgLPzf0BToZxC6ZHqSjnpiwCeLEEgo4OgUbjAu+KM6CZih-gBATSDrmBm9qXoe4Fp6RMSqeAsonzBsMBawVb7zAHnIM0h52DN2QShYhDMoIYbMghXNILQO-s8YeyAoe9pYtxgijJ1geLDQEAOA8qRQ0LhU4AjusL1g7+BFIGZI7DDce88EXVDJZD5kYZBwiF7CluAKujzwOtBH8PBALSCIQOn8uYjPDHyg5sjz4MQgTTqb2w1Z3Mh7UkNATahuWLlgLaNIpLkQZ0D4XpGalmwqQBroJZgN7OX0QUA5iHuoruisXposS9z+IAwGCtJUYG7ytwhExOqwTKAoFCV42EvoUJW4YdJrgBcgmpC+IK6k82gkoGiQL4gjLKRRkSspVPYUldhbhE8JgCjPBAjQYtCpMA2QabRmCfxYe1KwQalQ1xB9R-cU3WQCgEqgfnAqUFrCTEC2eqVT60R0COHoq4Ay4E9Y6fgSNLP486BxnMtgVMjGMLUw-6pZBCxI4Md8wE-wUYhRolggiyCxx7TAdRgUoCdVPHrakEEoKedyQsOIqJKfodAQH0CTOP3w1SBgRFKo2LDb0ROb+FQjQG1g-wD2kD2wkVRwQF9Q9eCpdBNrfKQhELtwMu7DgBZwbgoS4GjQ7-EooIlAJKQjgLUwoBAicGrYeHrmyIiwQhBDeAi1nKC2YOPIxjCuYL8sgMw7cGdAEhjsYEWixHA1IHu67Qou5EiJFMBB2yTAfUgkI-BWUqgREkvCTUiQRAF4scDTKF1QXeruKOasFiCk8PnnVnCokEeAbmAVGFLQQ-D5xHY07gAZ4Ko2gWi0JCQAU27QPNxQUXSKqHVnKVD1LlvkfFs-oNrkCuBs6kewTYBlB35w1HsO8EewC2BkaLzcjlgTCJ4ihRgfQPzgpAjWIEEg8wBhsFcV5nzTznI8TUgS4Mn4D1BgyoNU5yUtRl9L1HDXoBaQUyCfmPX+XEiUeL++vvkQXZAQ2kBcEOnQe0RyAMXAsTgVQG0wM2DB5AAVt2g0QM6Ik1CWOCEKGzj2kOCEcojXGM6QDeAyUKmSB6DWYoewrKgDYc6E7kAroNbQEBicRD9ImRA5eFqAuxSTOlwwCYdkMDHg0aZY4CyoT7BukK2YstxfgOcM6FAYjHIYhcA1-PJE+WxjpKM6ZiucwAy5ehAFpPIwu5CYSBMIqxP7QK9ABaDHcLh1tjBl8Bpix3AoCPmAxODLoCpwFKDtPc387PQpoAFwJKTrwOp04uDwwsIk0+ClmAqwg0gdMPCgoSpOlQBAN-ADgCZE2ZBeIvo0-gRUfg842kQXUOTAwufXZCagb3CUxo8QtMC5iMIQh6CgxJaMsPDneGrLDaiwhORAChBa8+awlJAQ6S-ABRBDAiBOBBl2+BVwiMT8AJ4E8t0mUDfgUei3gNwDgXjScG+4T5D3UHMjjuBoMIhgXAI9oHz4AEBEEKdALECMMyVEToF7UmwUJQxG0IMwVVDePg44K9jiqkgamragQPH0r4AVUENIoaBD9LIbb4T3KIqoHGggQFEIPojJZLC7oiBpYptwS1IRFJ+k7SDOfP3wCmw+9GyY-QjXIsAQOgQaMLqcZU6O4NMgH8J7MIhIJZhD9OA4JkrU4GmARBhLILTgR4MeVKnDU6DVsBYgGzjLXjJwyOC5sDkwckC-ENbEX9g3UAasqTKW0HnYXIh-cAiUYoDrmBnAQQhHh-NAQYhdrPjQrHhMGGJ0rgglQByXz1ZpSVXoTl6FRPDiMqQsSBOyTqgHcP3YLiiaqvD4B+CcMEd4ISAMBCmgn6T6SA5CzXqbiNeAz+4IWLnA18CV4atI5tOmZDOgiRggtGpQl1CAKIxYcdBaenoAJzlPwF-u53C9YMuhOoRy0ByGkIBsg5MQASBEEI6XodDigAEAKFytPFisxODdDJx9x+DHdDBkpFiYMKzEsefFQH3QF81AxHAg46Z4wtG8euu84F7Ul+5ysCZkdaCBZBngOYjRQA3s6oSAJTEQ64CQg7XgXEwEIKlwWYgjHP+5zNRcBlHoi8LTqzjg81vv-bdQ0ao31AR4Y9hKxMGg7YBbyERWycRcTCVAGFAH0DFAVZDEIE4JnKALhJC06FBpwNlYMdBY+fIYAVKh0M8gr4C6QEJS-ohNXITAByjwxL3wCNpe2OqgsxctwMEACCACkNgQ55dHYM-uWMCOuADoHKDwQDLuxLDUCtbLCmW1fmQ2+rDb8JNYyNE0eOudhDi14AosYWIvsFOYgu3kqDf6+cCcKhYQNcAXqHglY9CnYOTCL1Zc6lRUeuqYBuaw6ZipQGQIXyFuqFxMBqxauKV4DaAPOFEsaftFYKnwDhDyIuVIYZAoEMH5I4CYCgQg-kzjp2sAzDhzZvcURNqqVOyK8kDOYYQ41CC9xKj+HnaquGmAwWAoqEww+0Cr1rfkUpzXrA2o0iCRsO-QEPN3QJ4YAzBV2JZQBeDbGFZ0zPj7QMUai6BoUKLwHISPqHEoFRiGCL1oIoziYABHYsCr49FQdUBRxENQ0Eh9WC5GMIiPIGdsFQiBpGkQAZz8gBbIWogl1kN8e9iHOFxSxdS+1BgWVQhy0IAC2uS56ONQMLCyVsNAWCA-EH4Qk04vIYsVIqDzkTGkz4CgsCPoqnA1dE6o9TBXCBvQANAM-D0A2VjjeOYS5VNWiofEPogrJDNg4lRhCM0iTmDjoE8JDbBYZf+AirB9WHyk14jWxpQYS+p6uVnhlLozEFJgV0Uo1X-jrUokaQXABST8ALmTqUD2MFSwTPh-TrVE6yBe1HoAHEBMYPpwd8OoRPtL1USN4MVWuqCiJHVa+qBeCK6FndBioAKN1mITGIbAD0t1WujQyiDEQOOgnkTNehg4W8zIoMvQlZrY0PBc4jC7EFxATuDKYBSgagJsK464WGCyOmkwMeBeuOSoqHDGoDfA5WxWtJftdYBQyMVZvGiNwEqIqODJFIkgO9hrIEWioXB1YiOg8+AbOMNcF8gLgDwlnEulwAlRVmBVEGtIMRioFNMQUI7-EJJg4xxWtN8QAXBmFuNQLH4t5MKoPn0PAta+TpWk4LiQvbvwG+VQyAaPEC8od8AkVU3AW8bvIA05ulDJ0GyCWsQpyNtAGDgmRFN45VDlPseOA4AIBEkopjCZIE6M1iUmQFkgkBAyJvQI8WidEowgRHL5xBtwUb5zIEdEjcDD6rB1j3Qz+D+w9tBICmDBLqCp8N1k-WL2wOLK6lRWbXDAMaCjLpeAAfB4epKHln1+wHyA92YqQAhibBQ0wJggLTSywEAwlRTiylWAHuK0wIqo8WgjpkOUFRQBCJVYM-D5QLtQB+D0xPuAVnD3sH1nHioIYu0A3ViUIfSgJYAcxLps43M1oEP4s7B-cEFOo0hgwLiQLkBruHWgo4KtyE2QJkpkMMhgRUj1sHBb7gCRYE7lipcKbOHQT7B0INOgRWAf0HsDmZAMU7vghMCaXAjayWLMOOMcAGQ0IH1JOai3AiNZJtqoLZ10-Ux6CUPAUaPv0NYA6PgAFabGsNy0iBtACATb4BnA56DVqAlAFVAWMG5gYqAqEGkakcLzgGdwHrgSmFI0uMiNSCQY7sy6UFEr-5huyOZAQkApgNCwVgRtCuP90dAA-L1AyxycS4twm2edwPGgQYjDBaqIkbCpiIZiLCAA-KhwDdgvhPoQAohsRNT26ZjCFr36k6hpkA3iLBYtA6q4aTAUQAVQCUCgODbkocDboL8skED-ICI4VMh5EP0I-oc7WFsWrYKsXqA4BtomZENcpXEo+yeFuRL-YKhBqaBV-taCsZyD0PzoTahpqB2NihR-ZjloQ6TzIOOg2ECd7JM4lKDjiDLYyYidSMaYhOC-wfOR5QghuHykVOUtwNg4jCBt2HtQNvRueJKQ9Tdc4KUAZWDGgEUVoqAdQCWQV4DrmF7UAKDX0CFEAHB-QOdg+WxDYF9sd4AK1lOY+bpzUAYCKhahdE8gFIgHDaXwOVB92DMX8oFBUJTIobaTEGxdBSQDtC6IZyA72LEhEmBZUISw1Cp5wM3uU2gf0G5ULUb2BCRj+dCncLkQNmiHp1FI-B4UWEB5bQpBwKDECsDmfIFAXUz9Wqng0ShOEPxAD-CjJCcx4KAOINVoRyjxu2KRDeiBqFOK1MhZJOQ0Eyj68L9oyIz1ZPMgt8gRMDxIqcCPsLywDSjfvatdhhg7eP0IgbrW4FDQQ0jRMP44pvh72wJsn0jpWOQoiCBysHswp2A9sNSASdu3eCus3WBiODmgXFLtUDLgH1IlDQx0IbBXi3jmXAi+KY-IqMBNgIhkXtSi2PnA4Dj9QG4glkdG8OLKVMi5EpgGlNi5Q6BAIigXoHD7-vB3ozfUrMAT0L3whSASKIuwCUDRsJCw061NXeballCjomFwNgA05DGkfqRiEDlAdR14sI+oY7D9YLnGoMyRuB52-6ykhpgCFp7QqMrMVZywIGhADPxINLDifWBU5MAc5rA9QNlJN-Bx4YtwOSAIxKbwVuBk0IGQ1cDvNSOmn2AGwJtwyLiGIOAIewjbpAJs8UMioNUu35CD4PDC2RDoAApw18RHlIUIVYCssKl6BPRt4PfgRUj3OGx4aWZe-eqwDthCwDYcf2Te0DWYdASjME3gAsBciNggeUAz+MmIi4huMG4wkWDlQHpjMhSy8EwIiEApwKutjFg5IHmgacg5y07g6+hqoPAINfy6cHVix0RuQIY1BMgRsGvI2zS7UNTAy-hqXgqwiors9MsBesA3oL7IcnC2MNcgILqncJfwvZARQKlQnP4SmCbAI6Zjt8cCTsoy7pqinNDHnDAns+nXGBALUzzOqOwgbRC0PClATYinRMNkQeX8COdc7IphkMnQW+G0YPNQH8CtqDg6gsABcC60NSQEeOh85bD2FCaI8PhVUE9wDtiKcGp+5MDusPZACQQh4J5Ay6iZOHWg3iADQP4wSEeBaFogbXC4QK92bxcmSD9AqxBUgF64jcAGrMKoyaiOwPH0DziGxEwIkmBhPmhgQrDJqFrIDMz84E6Qc6ZvUIG4o2DmII6oWfwtoP9QFUBlQ6cAIiATkAHwQHA7sEdAoMgLwOpp5iC6wBOQXu0caNJEfljSlKqQKsCog1duACjYaDX80RABTuPIvYAJTMsQsZxa8GT731liZ90gmqRigDp9BBZZojzA2sALwOtAIhDmQDPk-2HhLMqgXsAI6j9pGHJR0DLuBeCvIHtSIiAWWBtQgdZQ0GlA6o25Et+AGchlzWm0z5jkYIDEIWAmQHQIf5BmMzNIayvuMFEgQxp-QEO3-RTRpmWUfqQySCLareTcAFrwsWDrsNGYi4pM5Iag6LSV9FosgVBj3PD4zaDFsBUAenBLMA8MjEy7kIhYYkIBcPUwUiWhQM0A+3Chls+Y20CRmlgUKM1+EA7mZ2AyBDgAr7A8MI+QjeD+iJmQg7DD16GQ0wASwIcQ7MAzJ5G4UBiO8k74iXhgsI9gAzDtOs56OXi1YO7sCUH1LpGQpQBj3PbgQ7zSiLoAmTB6hAZAH4TtgGUY-B6BaNo6eALtKDA0l77sZCxwIowoelwG1SDZ4LFE8Zo7Ze4oS6jaRIdj2RBHsFcLzpCHEAgwVbp1sHYQGzix2NbQ2It8cTT2-SiaXH2AZMycLGJoNFAY2BiU3xBJcGeUU4pn4BigEoC8aPwQoMi9VORQH8LQWDVYxcCSkMbpRiQzYIz0bcvtgL1YxsgQdb65fYwVFK7wGJDXCOMgO8f0IGgAYNJRxEhsWhD6sIdA+dBHMAE0-RoSCOgA-hCxRFiE4RDVoDlG6yAjHIRII1Rt+CCGd+jFcAqwKgjkUP-4kJgiWJGaf5B-MK7o0iAtaNkjarBh4OzbuMhvONDImbDnlMJoJzn9sNMwLEirNoqkzBCw4rkQj-DIoN5X4vg7F3eA40DVQRZARNC0bEvgS1KymPPO05woNDkwYkDYEKTI54BJwFgkGcjCaLPCZUD7EOeoy3xVZBIwC4C-uimgAsDSavyKp4DVrNeAe+BENrZAnEA-xPEwHydmSGXAvEAAUJC8yWREkPtw3SQ6IGXXkyA4wPNgnUhewLnA56D7kGE0ggD50OrUo0Ax8MEwZwieoMEAamAHQGsAB3GizCG40+BKSNQELkBuIFmIAjjdzEw0tNAjoJ1IUPDlwbGU0qRsdD6I5jxArP4gd8ogTnX0axyBuJP6okjfUDCwlADViPvc2LhuIZV8BhDeCdQEVHbzQHd881t+zmhSc1D8jAKUBHKIYMH4seANkGnZZKQ54NxIyLBsvNegCNBNaVusr4DdoIy3IdsHPFoIsNhJoPrAdzeXHPhQTLijTCvQedC7UEZAGKRkzHDkaSmN+CnQEoW8sJpQ9S7w4Fwt4TDq1BZ4kHCOCByAJFUAIJSwjfI+lGu60CCRsKTwSrxoMAXQSxD-jOzAHrj2FC19NSQDXEygUBAEhokI3pY6yf1gu1GxQD4wIpD-EHvAh3DBMLltCtJ4EGxnInB6AA2gSKA+xAKkm3BdZGmQ0iBoUB8S56D9FFzMcyBciAG4L-A5gsJggMi7yG2ijTDmEJqGvqBIS6TwkIB4uVowEZhziLqgRiA4wEQgwhZhkIkwC2IfIPxU52AtiCOAfgiNwLuAkCC5INv4Ii6T0B0QUVBHINX8b1ivgnNnIi5oYOLKnUi5iOCokpAvbgpQunhQRMtePdeL4OZZY6XVCF8G0whPONMI8RXYVEC0lKAPsQzomGykoD9EWghFwLfYIVBCOGag8sAXzCWA9UjS0E+AnniHoGVDEZBNKEBgQHSVl1wIHTBFqPKcbdgxdrdo0LD4CtEg-yrryEMaiRjXVEpw2Aj0wIEUTVwvQGE0slaECWiQlmbJcEwwH4q1MPm2H3h1qOhwxDFgRLMx6kD8yJ9Q9+CByJyUr7DHkzQJLSAvMGTEd8BuIeA471dxgIrALw6QcE-YUGpuJQ-I+DBmEDqipcASkDcQISgw8gyG3rA15FvLfOZmQB7wjhA1COQAG0OfyBVwjfHUgwawKagBwKjQOPjSYdkwAXBVkBdQqIgLoDAwlVhCoNdgx3BpZlxAvigJoCHgmZDphBUgrrgaQAwGxLDn6DvgZDAJQM7NM3hIQAUYvUjhLBQAn1AyBn4IFngLIKhtHx6LitPggKBu8qtgvem2AHDkrLBemJOw2-TM0LTouzhryPnEEsZ6GIIQhphDfAz8upAaSu2AElI2eMnA05iD0GuU5AZU9AsgbIJwIBpgRWAqFkkANfxmEGJgtYfmfKQpMuBfZLvQSMhbIGagS5qUyFrCLXQ0BI0qzpTDXAirfNDOsDWoBRjDeNyIDtifUO06wByQXqFAbkgUyFdEM0Qdfr4k8+S-LEDENirH+Ce++qCm+Cl0lMjzQGyCl0BiMaIgmVj38EMMJVDoh7SDRzBKRoBgfEit3WIgv93UAuUwxjCY6OqwnUVIyA0g5BXotJzgLhZT2G4gzqitBLdwicAUwAYI1fA2aImDskf+IM7kyPPy8BPQJZDs4ERAvIBrlGT4WCjAGunUleBvEGzqB2jJN+DcHsCoRCb29AyPsPNAdbi1YD203FJ6nn1Yupx0Q31QJ6r38CbIkMAmRIhgO2DkiCpQWlIZ4RhIwmBxoM4Eg3FZR2uzfQQxhDUFcxgI2j6U2sCN+A0id-CEwOC+CGDRILXKbHT2FAMwUOpvglvIsGIaSBSgOmDNRMOAfuF51SXWr4LBCFxYA0at6FNV4AxJ7IUoeYBPCcnUOTiUFyHgx8s5el7kENQpoIWAWMCIDNnQ1ag-syOmH830EDqgxXtVCH5O4pIBwHIUsjo4aEZAf6DGyFPY1CDBgEr0iFQVclgkzJRAGwWI1OiIYJ4AuRIHcOEQW2DF+IWsBY7F3EIg2QhV6GkPA8COyO0oryOSYGrajeiuCNVO9EBO5EGoCrDwcCPEMu5vsOOADbCcwEB0USzCqFZtutM2UNB7Z-AYSMzUtKStwASg6fy7mqFgwWR50GDEsOg1mIRoxWAZI4Cg5VCkyGdA2zT+PXJCsQ7b8IOX9pT2FIHIdKWCCG4AMuP25mdsGEhR-NSYN1jcUlu45wyzwu0gjvD5urGUfsa5fjOIzUSjqFWQg7GU6H0gsDAgmdDQtyylsCDFachZiRvEBZJaeo20QkxsFMOIYeOWOOJAXriUxiOm2qBPwEWrOrnsuG9ysZRRSDu1R9s25HLmAsBvwIogWBiojP-Qo0iWsC02dhBoWrywdTu7MICYBNA9VqkOk+hWIAasnKBOVC5uouAdUJwsmjYz1nzMUeQ-bNBY48hCEInAOgT09s0AheDnBOx6kGi7QOQ0vWiv4MUmDaj3YBTIxT69WBMgRiC14KTBVXK4FIjEjUhEZFSQIISt5Aatnjlv8KQgTSissGIw3GJv5GLSMnAcWK3oXtSRCPmQYLDVgVqI5+iddBLAE7KGYhK1-Iwo0K-keAigqFpA4OeqeNS0sKyQoBqQDMRWNxx7yDTUhWdMlMimUNjYBVjlgFWIShQ5MHeoCLgmOKLMN1SXgKSEnIxu8ICLHcDp+OLg21rjrLe2t8D-rMPDXUzUmB4QPji7o0B4U3gh6CGtyOB4uZEQ+jTJYgWIo8Rse5-AlhosKIikKNgtwKbQLEivtNcgX1r7qMFg2SAEwJS0n+hTiu5Ie9HkmFigyzKWaAA8YQhDXJMQtHjlqDfEurAKJ228ZKTBAAcoZMSQaAag-fBTmGLA5KDfWURkRMQJmPrs2WiD4AsgJBDSREueraBaJPCoMWA44JLLmwTJUAVW8sBuMF+AHtR7AFzVEZhFBk9Q8Oz527SYX4ANIJyU5Qo4tHhHMRhFwNYgalDBJGSwOCBENtkXL0AFxG80nIx-ZqRY-1T-fPYUnNDUQvls9IPhuT9EF-AFpCQAbPBAaGCAWiRhkKdgbyDI4JdD-llZbN9AgKC-3USIGjD1qpTGTZCHSSt4T4AoYrYwfgjGA6i3PtBod64KTqDjeMqwr7RlaOnkTTNbhJwQz2jynFM6rBBF9PxwBGgZgEFIqpD2FLkQxah8IOX0SBr-xA2obvCq6PVkfsB-QMlHvjM8ZKAg1DBaxPI9Ii6DJF4iEvBlYJ6gYmh1tilQBgC-uk2I26A5MOZC1OCE0N4I9-BFBi+huu1n4Gy4cOCUtIlA8owYOI-mI8ppe1kgTAglRL7A1yCk8HGMr6DUiA0wBlhyFOrAYDbJmICYWUk0lkTQbiFO5NuE71nBMDTwxigEeJ7wgTBhNC+YWRC3wD6kbjTTDbkg-ZXK5KCw36ghhnpwzYBvwOZk-8iDsFyREbAoe9nggJDhMM3gE0BgsHMEv90JwFiEn5QQ2-0oGeDuQOvIdBgp3p+kzUCNkIY+p9Cw4qRAaFpqaC3nkICeBInwA8AreDgkFlhnCHJCKJCKWA2ohiD-mLd4t4BkaM70D53d0NSk+AxY7XvChKQV4OvoF-Bx0IuI8TDKSBDsqcByAMrolWZV4Reyi+D8HgPortAkFLtwycSxXVT0vfo8ervjP7D9WOcwBqwIPC1AcnBQ0DloBSQC4F3MgEi44KIerTzAEUgaBHgrougW3UDSiAOAnzDJYj5AR0SUKzl48UCAwKhzR7AFlELA9AA1ILqwc4KgsJcselpf2NMQxGJ6avAAJFJasDt4OKR7uLuAzI0i0H9AbdjyKGTMmSBc0LPgG6j8AK0vkize4HV89MRQwPNZtUD1FwYCzrDUEHHY+iDsbgWg67DUtb3GC2Aoh9TAidCIZPLVkZCRyLkIGkD3OEP00Nhs8Cj2tUDRUChw68Aj6EmQbpDqolIA7kDEwN7UXvDpQGjQK4ChwN3AzeAuoMY0kcICOOI02hB8o9IiE7AlYBKYWaIu+A-IveSrNqlNrZj2xLXXaxChRPTAP3IzKFoUSrwQEK5I7WAIQDSw3WCTULaYGFgp0L1o-HAiOHk1bHQH68VQymw6YEOYmeDjkLzA4eDOXAFwKLBqYHuWtnroYM1XhORNkOal5iAiIMdANINSYCugD2CGQNsZqCB90LahPaFZFPzMcNiR8BjgrSACZH9w8LBokOPItlRXwIhUhmC95ClNRv3fkOG8QYeWALGcw8nDePYwQDDWYpuwI4CDMNbw8u4e0p3jNMB8KMiC6PgnEIhg490wIL4gx+D7PR3sP0gOQqhIi+CzuEru7Gg9sG7wcyAVSkWBYVPkNFJgizgPoFkEpFmqgJtAy8ALWDF1BSC3aJGe64CFkHpAtnuM9JR43ZreiIHWYTDJcPTgDKjp1heUhyWaXLyxiIF8NELAwYBg0uokekDYCL4k0x7aJJQH9TugMI3yhaz5cCcQBrNUU6owtu1tMHW4Rrh29+JUe8igOIJoqUCZkNVojcidEmoAeXBZYAK1ejw7eElEKKB+QIc4nXgdcD0gqojSpA9gzTAo0KA4QiAAKKGQiuAqoPNoTOTfpb4wMygewkTwzyeBupno1mJJgIfg6HBoSFd2WqMt5AmZIegWsDkgwaC4BXyapmOtguxgpIQ6cMWUTRXrZy2RtFB2QEKwRqsfUIoQ54D9QCKQqeD2cEWov8iPgwdZezApIF5w35ALqIqwgeNokKscc+BaiLLA3mK-up1IJ5cpgJuI4MBxEJ6KpXiaUMPoEGAg0cLURrjJ5ESgWuB6WuOgpoUJQJmAx3SYwITyrHjmPL3IQRCuME9NeMABYLTInnhZ+lU0xHCkCBpI+nBuhGHgOdC4kPuQlxyTOHnKL5jQfDSgVbAUCLopo9DqKBaKtUTs62kaxUAHKY1I9sDPY9-FtCtMQGGqirAeQDXAWiBAQJThOSCHkVBAe8J1uJKYA6D+CLz3lhCi8B-wekBVEPggJqARsE84NRSCoAwQInx1oFRAERJgu0CgSzA0IGW+X4FZYNSM00D3HqnwMMDy1Kntf0AI9jnkHFSleCcvS+AAR6ug5agPkKEgThSVWALgKovzgLOgqWso4Gw6hPJVuDGAfRwMemqgnXiqcKGrr5KFwDcOdWuDcJczw9QPoDaXnWBmLFSA7UDa0Ar30sgmfkTAVsOE0LcIWBdQWVfNm4t12mGqf3DTjZjdu+VEoA44IyyfUKmg7Z1oigpw7iDz6XropSC8wL-LQ-Rw8Gx0KeAgxVrAbPDCrEz+j2CgM4OwWBAl0B3gn9HbWqc2elh2kETENaynkB160cDehAshENw-BmEISY7F+AmgsFjaSN0oi7D4Cm+QajD8KSfQSI1NOilAIKxFTaQM1IDyYMOAAji7gD0Q8WhMgBnwayDlbCyumlzm4Gfwi4ot0A84gJLghEYkggATVBwQM2BaQKNqsgAalOOsQjAVVM5V1yQ3YlS9fxAI6GnAbuDG+DRGK3XhudBIuCwN0C3QcuZtCoGkKOz5qSAQOCRcnT-2AXh8gL5iaFpAuwPpjn5t4K849pBW5C-jthAoMADosIQuFH1IWoApQITgfCDnqCjg11TmmHhAF5Tr9dOQgAJH8JTYttCclNrARLi-FOgYzPgwMH-QeVDtEMN4V1CYIFzQgRT3OHyAkKCSM4YY74AcVHuoLvQOcKjS5bCL4FrEnkSPQDGk068U5XIQ8xXu3XyCbkrNkJCgrvC6ogT4mlAgTmVgGHJtRRXEYMSIxJ4EwuUp0EYJgDAhhgZAECC2wNcYgtDy+CvbjWCuYG1YJ6iC0M1Ai6j3QEyqinAGCESgr5J2UCevUYgxgMiI5yB7SqPxupz-gCnzo4B-uC60jhCuuKwg1wj8ZqxAoMjUIPbAURDm9HAtzgQRYDtYiTAfOx94TOhX9CeosNyIsE9QYKC9WB8x9Jj1QPQQ-bB4oDXkCcS06AOo86CkhKLQxGpPCaUGusCqtnEQF7DeyMsQRUC7sFF0lBinKNVEoMih0CaQSUCVCA+wTCv7EJCgt9DQloTwrnTFIPxUqrekQCmuaYCLNi18CRg5sNRYOeRxKNGmkMDJFFggc5oqYINwTUD-UFbgxpiC4NfQ13oVGMG3X2RnbIAoCpb38N1kYGjgwC9WOUArcNnQgWTRKP86N-BAcEqQkfTusCEb5n1TJNZwj6h1gtfE85dOkKUM1Hew2J+A2Nh12okq-3zkFUjI17SFgqcQoxC2VLjgvCDygXOmE-Aj+vWgj2CASBCoNBbkAPBkxXCRCOmgEKA4pEEoQWs9oAxA34CUuhQyIiCpAthFRaLKkK7Q1MTlUDV81F6cRETwVmCvgjJANfh3+GVQO0AwkOxg7yBMEuqIm2D1sMsQMhvXGJhsPv6KrAvgCL5NCJY4-ZDLSMYgaZBOQN0EXVSm+B-gPT4tQCQY1nR9YLLBApR1e7xgR7AIuOcw7-lZd2Gg5GB7uvxYE5DVCDxIqxyncAqmYkDHgDHQNhiZpErguMjdBFWIjvA3cJeizURUJrbXhTBPcQkYrajZCFoQYnQswPlhtgDxyHBIFECgyFeG2kghebzghwj1KEuVjUheuMevhgiJ8PewS+pxKKyavJD7UAcoXWRLEMrHGsQBcGbI9aDGNCzAahAMBFgoCnAT8CID8EBgsC0XpkD0AG40isCChtd6o4BHsOuwtMTmT21g1CDU9mIQddq8eCPc74iYAtfQI7BOIqdE-OgM7AfIZMQdMPa46zjhcN7QA0gLD5-2L8AmvL8FgKUf0DFgDjg34HfouuyWaLb7YTS+nmIwpyBaLLUgyKjcEPVIkbD-yPIYbkpvwBQgodDaQB3vCTChcEUGcuYwsIjE8mzl2IeMSyAYlCQMKaoiIE9EHzjBoOOblKBQwBs480nXevmAfeUhqOox14ru+E6oj6hioMh50aC0JGE0P0hgoFl0-iCoUC5LjFhAoH+QXzBL4N4glg7u7IxYGzA1gEswserofFq4KhaOw8ioqp9TSGdsHUBN4Gtt86DxwHd558DwQLveUOqUkGdQbBREZHO2RvAQoNMfYpDY2OuA1jA72KDIrKjVDiNA3GJ9gE06x6oAbMkykqixnDXkGpDBwB9SXgissGs1UgVpsQVQsgBbuExgwmA-8BA8GqA+cCkIQDAYgDoYwvBYyqevsRCUOUYISCyZIOcwVbjVUtvJJpBE2DwWYbAJ10naJqBEBFrAByiMqMLgTwlFopk4t6ASwDAw8WgcpCiEJkrw4ETwRGAEeOhARyDg0w4o5JhrAIBs2-TpmdfQOuDXuIfgfwYN7HlSC7A1rJqk-B5qGywgPqRbyF1w9EggTrB3KxSEEpPQveHfsFvw+5CQaDtAPRzCtGZaAR5k4q+AF1DMoSBsIGyvwCBO91DSSMdwCcSnYBU6WIiu8EygaZCQ8F0YIIJawCkEpQCc-snknIz7KJS0U9gMFBqgWhm1+C2IyfXIyeb0CNp7Ust07Tfj0CzAZBCST5xEPPBzQLTobQqiwHoQANBcbQ6wBsAaYmygJEFagKziIriRwiXQMcDRvJEg1YFTYslgmAKPsCnQT0QPiCvY4KC30EogDqDpsETsOJw2+D0HVTT4UMCSUO1cfKvVglszhL7I28M7oI56EtAjANIkLkCSwN8qZsAwsGdg1sbqzDRGIQrkYJSY357bUMlQATgRJRg4WcoXIGcSyyLo0D6UtJhlEMgQQ-SEEt5wsQ4ZqKvwdGCE-j4w-0A1IAhiOeTi2DU837AEwEGInezmqERA8EDyIIhAqkCjVmGgEiDjiBUUWiEedgi4I0pgtAdZh4CigiQfAcBDYJmCAChwIJW4H8JExK8URwg4ZFIAnUhKkJMg6NALmHdAw+D9LQGvy7cQ8JnASqAjsOrUl31yGESgTlVFtFSwsRCZIOjpxvCIZLyInEBQIMHHdwe7MJCUA2AVUCqEE7CHOFqxOKoA6MeIINDg4GfwW7iaUGUwZseR9IGk9yJFIBZsqYiafL9hrvCfD5fmbBQGkEZGFcR1BC4zl0DqAaZusxQnTJzQ9k6xkc6oocCOCAwE7-TeKBNA6wBWFBrIqdA8SP4QXnC9o5-I+-OjYJWkNZhbb51A-BCilZo23yTRmCRBzaAnDPGHvBZPWIegSKA3sgRwqppFiMfOPkAaYiBshRi7kKIgxSbcND0Ar87kwNl+NKW8YBCw9mA+ZERwObCdoEB0v8bWHmEwGaEsGJeA45Bikrdwe8KTOtZU-8hZsHmrm9SHjOORo6jtKITM8iiKH+rMYLSbkAtYLKgJwOxSXEDCqMOAigvcUg9GdNzcyFzIGzh1gtBP2Cg+OOWAhiDgOJTGFnDQgE0IBxiPsN7vzoTLfKu+w4il5JVmf9DXCCtwzojgoIVAz5hjsNuJKEh-cFa0guDg6O0QQ9l5BDfktUC60BEN5uTWcryw4pJuqNCWdOREIBPqj0A6cDoYLBRo6-RM2GgYpAAVj8CzsKIkLFSJoPPOyUDnuG9eywH2QB0Q9YBXWw2wF8B5qmqgdAgdwKrtRMR1gh-A+cD7oIRw12N-L+qGdYCRK3woHuI-cpwQeXD-fMGgYDAkUkjb8GSSqIEwkpCr2XQY5k77ObpkMbKvUCTwR3gDYXm+Q5R7ILxA82jn4NIi1AR9CPaQxZTXwk2AGAi6kHMFFiDPq9BYH8A4QIuIZlmVCDOE4eiWUFoU5bBhxZZmeHpkXLcw3fCcRNKkrJBTt-etXEwGNd5veAjJYKqQRKCrFCIgE+W4FN+QcyDgRoTgN9QQY3UEqcCRYI6oALj7OWKMaYDeY5m2MKoE+Bdko5ARFLdwUdBdCGcIERT5C0FICFg5SCqZDuHG8MpgOaC7kHCVAfgAKBIgw3mmwILkohSXkPsQxigqEt0QHHwtaHn63FKPUC5GdEUscE2oS4CZMLFgHGT-xDewe8jpsNzInWAbUG8Q44h2mFhgRBgZ92mA4MSAQJNOt8hd3X9z39CVuCFqo1vEKZS6+6h3gCgQsvWU8j3gghBDgLvjaeG8eFHoqnjAGhab0yjE0I3IWMZQIAvkRrzg6LQQUqgghCdM-mCFILcPx6BYEOBQsCCeBJEIAMBvyHjAAaC3yLpAYTAmaEQoCoNrsqQIFsgnGMN4WP7BwOuwOEJpQDSgKa43VNu0leCqJMxY+iDjQFjD2GiWbAYwjDoHxrD6XlHkYHGcplACroNQcORV2Ewqb61TOr1Ywy-G2UNchZADgPQg+MBmdT5kPMBTqBWgI6YqMPKYlT8P7myw4sQu4KyOYdyywMNyc7YMBg1Bz2jfsG3wdmaPyClwBIa9aNrykn7rMQOAF2RVkOcMMwBeItTwy-g0TV7Yn-fN4CWQDuBYMBSQ-1RPyIEUt3jzgLwwHdxghETnvxQvIPc4hYju+GoAtnS5QEeALyjD6oEg8TAhuFlAPxDryMTtmqSddJJgPMDLINOcYGjgFixUHSBqCKDMQT8kQfLrBjD5oJhsoZiPkKxqueggwLeA-0GfYIHmrBDgoBFI+ZCpQIUwA9h8wKYg-MytpEUgp0BYOAFwuFCsoIrwrmbIqsrg6Hlsl8sgT5i5ENw0aSB2ENu0YIqWwLZwgfJj0Jnq12QKcFrgXMANIAXQ4EDaq3wAKxD0lvha3YCRCNv0EWDKXAmQMcATKKf7q0gr8AwoJ7XjkNwIdfTIqNpTmIjU0HWoL3Xw6NbgjlgmgF1QNOT-EHov8iD+v5hIFmxWiiwUKvCbQCuIfhStyC74aNDkqK1Alki5sN+wU0CLNlW48ijxAs4EeVCkhA1bWFHDFoGwCQCKeC7AP4AVGPkgAmR+Rrp4f5CWgdTcZtgKLEIgQhMJMHyCZzhvFqWY9a-uABOQchAO6BhIGhoaSPWqyCgVIC6epsASCK2kgMiEsNQIPmJrTC0LywEijBBAaaiOpzJwU+BkEPJAk0CQiMDUT2DXiF4iB6AWMKLw8VnOYiGo9pR9hOcMqOUzePaCI4BQQEaK6rXjiAFAUCAqMC6sBMA4uXGACOYvMKFTjKOb1N6ogFAokDt6fYxGX5j4sIRbuF+IX6ABACTAlLrh4DikTqg72LGUr3Y25KiSNgDC33xIlZBhRDEY-ljnwE74ZCl9CMio92ZonZcoBqy20OcguWBDqNIsAQiqQM2ob++W6i5AU4mbiERwm6sbIflExx52kJaw7ShQH-NgM3iqyKEglbiMMIwgdOne2Uz410BYJEX7eJBNQA94W4SXO7x4mlzsMKR0WjDj6d7EuuBSxPhQeWBcoFoI1CoLQKTxHEBCPQYI7CfciLzUWG7Qa6lwITE6wIdEGahbwAlIXWQGCPAwahtGJHOAvsD8HslASBrX1YSw2igsVO+anXjO+fmgB6DRpnfaFQC9SP5gSCwN4uAodsgN0KYvawD91D+AjYgKFNUIHPClfP8AL-yTe9TwG9CokOuAxSQE9JtgbziwWOOQGVRjpLY5O8DakCRoJcBauHZYpAiXgOYI8tRqAijsi4TBQCDcqQKYqDzwvxDaUbua4rLuCP-htFCjkGxrawC64O5AwWQXsKpEXcgSMJS0GmKTQBImKUBzBFPAZth7wOwg4ODTkD+jZqApd0uetxh2rzF6wBqQ5J2AcMCJ0EBwXHyc0FjNVIge01mia8jotOmY4q21iKCwChBTwA+KpWymoPcUUMla8A0w50RfNLDw3mwokIUwB3C6eJZmI4z60AwA1Qgn8K3bzXp7uqnwRzBAcKnqRMTX5EGI+xmSILCaUiz58H-gThBSYNOABrA+9F5wx0gkEGBn49CnIJ584SwxsgNZY8zl+GYWKgjzK19AJpB9YDEYeQQsDGcQXiK9sIuITZB+smYO0SC6p9zTV8BsaWgg1yQZqOKedWMBFP4gyCig8BtT4ZzaRI+ojbQtaN0g3FIqhYRofSBVwGMUQXeGYhMg3aCtUkLh6pDKD724e9DiYy+w+tB8ANi1M4C6wC7EqXDLdb5AiMRptAV2RHBceqAQSBBIuKcoOrgAwBoaCoFThttAgaSlLDHAJrdjQFmUxjDqoOgYRLi-YEIAybz38Pyg+TejHKTAfm7TZJsE2iBcesw4F7BPesdUfOUtgu8p5IjHP1ok10BntikgTVxkMOx6+CBEiGFhciA1wL76LmDRQKagFXCIsGSkBPgyQOMg2yBmEICYoiSWZh0QvLCMQPPgsCCY6DlAB2gsSFx45BDu+LsDmOiIxOMxq0BnbzIE-1QbxAbwIlVZYgo4J-kAnml04BnEE5Iv6B7lAWcD54PAwX9ABvQ+giKvmAoBzzEjQazllJ5i0ie9JUAPD0lHgKuA0oGEHPnQaVIu8htKBaxAj-urMFpABLAa+5GGhr4AXADVwWsQ75QvH12ssYnQWg-3ByGjioBFgLZAHmAoN0cISiICjgC00N5ooxBK4CEaEb5BrIF-g5KhyWw6uXPzAasNFmbBQFwCd3T8QAUgNSwASBTEC9wnZ6HjUPzgnDAIIhVuAjYANcbgIwhBdiAxEHwqPKkGT+-dlEUB4sBIggUgFGwDdhFcpQ6lQoK+qJA0maRpjDONhd6BYkOCwmnAGIAgQyb0JnpFdAH4BusgbUGzACxkUxg7egXIDGIB28EUQDKwosg9EAqFgbQPCYBVg-s8KBDE0C3+umNN1w-r84T5iDHPUNrwJwge7gNkDi4HfoHF0ZEu9sUe8D74E5GGaXHbId1Bo0A34FIQH0cJLgy6hRzKGCD0sHDgALsn6R4AB38GpSAu0UPoVOQa-jOqGuHqpwCoQpNBVUQQWglQIZieZANPAQkC2ACJgMIWDjIDv5UEB-yz+iAwxEZgMGhKoTFUDTkBC6e1gvpBK1Jb-y34OOsOWstRZCjBSCFfJDx6XIEjFg3JRZcDBwOFwQJMrvA9ADcTjqtBNITbg1KQJxD9WHOjNViZLgOIkBsK5IGbirtERoyS6pcYDz1xIGLbQWfqMaBaYAO-gvmANIerIfKQE7hNcBoCPlADEoZwhBoBKvBFcDj4AdAH3hSqCuMBH1DIEWyya7A0sxjwBI0HjUDggxGompBvOF9gNvgTOAa7JLzCN4EpDoLAVTgzcBksRqAljwL3ABeQx1YxKBa3RCgGYIT1ouIUMRj+WBryBYgOdMjBJ8YBpWi5SI61LNEep43wCvtCEqsgQPuwozQ0YAxVjjvl4sHRAouAHbDqKDT+BEUJ6IE7B+YAZhF2IIZqY2Qj0BfYATkBBYILAWLofzBooBEMCEgGoAGXAlRRmeZRsH74CZMX+EgCgruh+xlbpJOvJgQKiBpmBeQCdIEFIS3A8ehpyD6iSubFIIaOuEqAuPQyKEO4EEVSacnvAzECLNkgoPLwQsA1kAJUC+yB4YMteKKQG0hsRA0IBTwtGlcNAm4gytBzAR6hoKWdjAqrhQZh8IBDDIHWRTg6UB6MAs0kbNLjgUHgEaBA-QSXG-INfEOcEClBH578AE5cDGANNQvD0RkCPqHacJqgFdKFlsUhBEuDqMD5wKuAG3Be4TLST7kN3eMoEX4AlYh3YAIQJ0fXTwpH1bDzoiARECZoS5YTEZJFirEDDVL+gCm4SBonzjb4AAcEu1AaAZ+BUqAI6l3wCHiQHu+gcWLzbRF+KG34f9YVrQWJCxDRwmHyiVHAqSAXcha8E94HOCCoA6yA31BX0Hf4JpcE3Yu8hTyD9YCDEPhQXSo65hRaCCaCzANX8dCKNyBaAjpsEMgA0ccQgbOA2dQdQAygA2gBugzrB+Khu9Ge1gi4WdwBc4TJiuSFw8vggLmAeoQ7kZl8F9GsIWYNWGY5Q8AikA2YPCwTuAINMEbSQiERnJrSbikaBAgmjbtCxCNhAE6AhSA96CFgCQNEWoNvwAXAnKhT2ErSMhlIuIggAHkDAJDzsAb0UnID2AlBzwGGpiEcINeQRaIx6DspwvQHvydmGlZBMnCNMFNoO1QfPUJkpyISupGGqNKka6QLXR5FCCTj44NCwY1APdRjaDViE9iPGgMY6FMg+LTC8H2vB99ffQh0BQJZMdTWQGnpGlA1jBe4CDMF+IJcQGVWkERjKTuswOsru9YyAj6hCNBEKGysAaQdpuSiA3MDSRB6AF1ACGQXllUiADYVecA7+YjSSfgUQj1LlSgA+IKpAocBc847QG6wAQgGE2kp43MBO4BcnhdkIDoyeQohCa6AuyI90AQ0+AwJ9TugKnsDIUZLQtJhpBaTOFgQAaUcWUrrg+4DQOXTLqMBGFmCUDxSSpIHcQLToRDYfqQSDBa4F1wIAoLUAL4QXwjcUhN9K6kGhA5DRP9CWqS6yM1AUbUVbA3EKBZAO0KkgHaAi6gD8ZQwGGEK7oSsgG3A-8D68BdSJYQYLIzBAc0CfSBDsgBAJ8Oz+xbKjgDHg5pWEa6A4xA3IAlUDnQK2wM8QjxAAYK98BpYK50cDAiIEqRBiwHW0iMsDioc6ZChA9zhlSLuQK+AjxBHwAmwC+AHwgajA2bcTxoqgG5vKGQYIgjYg8mp+QDZMNwQHk4K6A9nZbuFz3LKIFdgKBRHxDAEADkAIYEuspoUyYjV3TBQOYQK94RDZMiCKcHezsd0QEY6g5Z4QpBCqQHiTbJg8ABnHruMFsQDcgaDGTaIXIAiYCNpl+IL2E+Wwr0CTUBu5CXAcNyrYIBcCqq1n-Jk7S+Aunh6cBygMHJLqiJ7AieBwdCfGFDhpgGOyOIOBr2hQ6jHYEUgMrQh4w0mCcAGGuH0IaGQOKRjXTAiAuMjX8fR0uIkbrBwhEU4JmQAmwv5ZeBhTlGuMLGEESo2YxTIBwwFMyOUwb9g6cgiMg6j013HjAHzgjQoUt4uxEDkLR4NTw2GgFtYc8DCYBWkUcAfSBEEB8QEOcIoQGlAteBlwaLT3BiFqOZ8AFhBXnBfhWaQKxgPYAq5JK7CaoGjjqMwEMEvxArwCjGjyoCJYHNA8UBsBBnL1L4E0cTsg8RB+7CwAE2gCgFDRgDrBKdAI6BXRhwxbaIKCB-YDt4BUQHIYd3gWrgsoBEEy9qHYyYTgHw093DiMGHECeAGcBxyAekBbpl9iI+MKjggMwwyBPkE9UMfsBpgX0AoYAvsFqJurgGFUInAvBAKsDnEMP8bNAXKBq+AQ4H-MGFzEaoVFRnjC3FCAwPEQO5gkbspQSrEAzpi3IfBghKdGAAx8Gs0G08ePouxAShhEUQysIBICg0tsBeNAsqmUwB5camAQCx-gCIYAIQMoIbiQMgR2XTeyHksH5YO-gbBQjoA3clzoG+AMGU7Ght8CFglG9mToWR0XsJtwh8gGnBHwgfMQoWhT8CT8HHEIDEE6WWKAFkCi2DH-HO2CmQxshxMD4KG8EMP8DSU-Qh4GDXoCR8FxSYxQnGwoUCCqn5GH4QFs+4pA08AeLHcwOQAD4kTah8yDURjnwMYMAhAbERjLD4GkE9hpgdyAILQjcY1JEkXFbfIcAO7QhUCAz3D3Ps5MzqfDFOEZuSkWQKlDNbAOPh-KDTGRdiPwAa7AAFAZwg8wG6yGKAYXAPUs7sB12kEELzUc3AyCgmfCJYm4kJSgdlQ6JAJ2BU5GhoMsRVGkLcAHnBzpmUEA94OdADSBaTBfEAZbpMlIPgDthUKCFrBBOiMAZi0LXQLdTU8AAgEKtXSqDvBHsCgyFAcHNQfegaZpdUAkWmVcFXoCN0VmAe7ChoBgYAwPfoQ2981ABM31yQDggFbgvrhdqBuIXLANCoHaA5WF6FCh0BoCPHoD7w9sA17oP4BW8OeUV2QJcAEdSnQDBlFeALnAgq9yi4DIA5MGjWFdct6BjwCL+Ax8ARAIcQCtZk1J-4C5SL7wOu0SaB5LAaSiIwEnsQRwJqAMHCFOSloNckZSA5FBYUCwYgctp-oXYASxBlryCgxiEIYYXHAaABF7Bq5n5wMiweecJABEEB-kHPznplV3gB-BwliJ6FvoCN7EDY56BORiZ7VT4O1AZ9Qh8AZvABcC34FgwfVyfCA5HbqIDCgN7QCUwpOQyRBD+FP4IvgawAI2AHxZFqCNtkdAAxgKIR9OoW20MMFbQUioX6VDBAFqFagCbIOAENvlR4D+CARyONQTBAUY5G2jN7iI5JaQdLAljgYoDIUGoGOrMP1opaRgsgZ8H6ICQQaqIIahZxj8QllOC-AEg8o0hVpBex1ollwGWnQchgUJBqMBCpgXHAi8dH4lMBA+EZVq1QNq2ApAsEgUWFe7AV8B3AJohqSBL6EW4LsQJ1Q-rg8dKwICBQHfoWWAddocqDVRHb4FkUNZG-OAHPAg4CEsng-IugZCAbrDdNC6MCzAZaQbggeeqchB7wLR4VyeacgPeD5kEzwPSFMlINfoduDnqFcwG3IHdA57p8OAOcDZ4NckTAE-L0DUBz4FikA3JF3gsZxtPYEyGkMt2vBCAvxQcWiw3G74NckMoBjnQpkA+WBlkCOWCXgUnBMiAPUEqKOglXPQDOJQageDiGoEVIQpADXh52DUxAlGMhQKuAAXB6tDlVxLgLnARfA2LhQ6C3aDtbqpLcNm1cIPKjEQFGSJHIAToS2IGIB14i0QP-9C+YUix9iDaEAxMI-QfyglMZnjDtSE2QNg4dxQMRB0fAqgBfYKtgMHAwnBikCYBnq4CUIDS821ApACqwHKGK1QDUcCyBJEq0mDNQBA+JTMSKQe9QBFjkIo9QQww5gBHLBvkFgLnpwFHAg7kPFhYwGCCn8DApILKBoOggQHKgO3gCoABvQyRDvoNM4ITAU8QnXBMEwmiF1YBQaLrQh5J0-h5SC9wPciQdAd-hiRAAUASmFwYQSydQRjeDu5F6wEkAUvIf7g0aAP9hVMlUjM8GDeJI6DUmDtlI+rQzAngATjB2r1H-AuwWpI4tg3WCcMATQKPGakQkcJxwHiaHRaAF4BXA7vBoED2cGOqHzxOtgm2AqNRsggvgPYUXRIXfBRnSSMwYIDMQP1QihVHARceCQWFxoBv03dFCWDo+G8UH8QEsAe8BKPAcaCpkLOgeCsU3gCtaIQCsINkIJsSz7Q8KC7UEDrLBiOzetJgeJwDIGYgMJ1GPgluB7kpu4ECgFiZWzwT1giXCjSFjOGYWcjA+7cEgI9AB8YNToSgwtAQrTKC0HadCOwR5QHk5saAbqD0IF5mRtYiGQgiBqEHhCLKcSjAupxoaC8rHGOAmQdCA5OAMtATKCTAK1Ae0YegBKGD43E+ert3WrAnTAY6Cw2ArQXzABKI-kAFcBvhEQwNooCKoGWBzoii2D7GAXAXMQlmwekQvCENUFUva6Qe7prMhI83b0ASlBgQDrBA3QxIB-7EUQcwg5uBeW4okBmwFMgbMQIqAHcD7EDpyIeMbs0bdg-MBRxE-wAWoNJ4mtEV0xkOEc9JR9HuwrN1QYgPIBoCJyBIVgsOhiqBI+BB9kCgSlggCgTYAz4GNQNuEPFgI7AOpAMui9MI+oPnwQgB0aBa3gmyA3iFdY1SAJSBse1KDPZwKnKT4IF0CS1AzILqIeN2tehG+io52QDHTkQGI5Sg8SATQC64AE0MmgJPBc-RkzDdUBE5cLgA4BEiZDOktIAcodxgjvBqewryEAoAsgFmAzh9umDMQVREEF5Af2RMBajj-QwAOA5waKgarAU1BrVH+oIaoFTg0SVtrSarGTqKegMCI5DQR2DL7GsyNPmKVAkmAywBpohBbhFAbmAE2Bf0Cu3z+iGuNZdQS8IA3AcwEhYOxgTHwX2xbmAI6mdgDSIaN40TBzeahlim3NiUABwddo5cwWJAqlFwGAKg5DQ5xDW7DagOZ8GvIAbgj2CRkC96PyYcVm3VQUOD0xAbULXIQWgXKB4mABCEJ5CusLP0oBAE2BOMGMwMgoM+ox+w5YACoXdNsJoHaggyBw05Y8CiIF0ATcA1FAxQBOuGtwCagNyUJZAToCaUB10CBsaDYtehalAZxCsQH1gGaIdlgSeB1knAQBdVbU0EVcZwRw4DA0JpADkA6qAcqAA6HggKeAfVAizYvsBs-BAyMAaAPwYNJLsDNwHOQBRYZhYtiAnkB9QC6MM3gBuAvShf6QxwBa0L1AUuAQHlsiA1+Ga5EXOUtacYBwYDFWXVVjU0KIuI8p45olQFWNiLQQb6ZBAX4CGYnjyHkQb4g24ABh5X+CCjKcwY6QxmZ4fDWcGsYJYQcBO4OBOfzsqAJgNzgDycWCRYVhp-CjlFTgGsAhOA6DClpGxoHxoc-uTPggOinKG4InZYDRg2khB2Iy7ntIJioevAHosj2A3QD3hNoQBnQ49BmvTKOnJWEP4CMwvjB08gN+iIbMKgewwjvklS4Fk0wDCKMGXQaFAIHjbRAIoGPglTgHtBCmAlQAoAMwQU8Q-RoJkBlEH-gCpITKQyWB8I5UBXoAGsmRp4xrohricomjTNTAPuQu3xiqBzQTvUDBQdIo9MAiOB3QCPgN1gbCg5S8Q1AMICH8OZkQaWAMB78CHIFb3AYQEIUbbUNfDYOClBJthS4QcdATexx2Gk4InoeLO13p06AOeHzqB-MEeAFmxiWBLgDd5A6Qa3ASuBf0Ak8FGTHIISEAGzgQFoWIFjCFhgUXmwnYLPBjuAuODkgRNA3apl0A6oH5QH8GYZwQTQ4QJysH+qALtMdIxbAIHi5UHFwEpgUCAmSBQqDKQB4OtVQWwgO2ByoCLNi3Goc4PbyLqw+hBn1Ctvg14X5g5W5KZAxsk5GDNEZCAIZ4OeBExGYgG0KZY+1BA6+i0eBlYNUZRMgG1Fw0A2cAlMFLuU8C7gBAiiCLnhYLUgJeYfxFK3DrgDOYEvCPNgcQDjwALICvQPyASUgCZx3ABvUFS9PPgBgIPcAn0BD8D7sBzrMxAuahlECJCCmfNQEPTAjyAieCSohKwG3IJ4+p5APwDwTybXmhgUlYqXp-EAbqDnOqbDJxg2sBRwAqIHwvIqzTcgbfAi+hkpE7IHaYYBI9sAg1A5PxvQLGERpgYCBYKBXBluMH+QDmAiaAdqh5wHUgNeIBwQZWVYMSGYC5uvFFHCE8qAiAhZBAXzJvALCmI5wBiJYOCQNEbQamg0IBNMDgjXsgLjAP3BFl4yCqd0H5GIhkJpMUeDoBANMDb8O9AeaA84AxaRL6ll0FZgchQk7ACaCk8C51OksGaIuuwmhCKEHzoIyhFFgHyBAZAO4FKwIgeNqAKBNv6CDklluJ8lbMQ2EBWFDSrjHAEBgdMyB2hZ0AIaTMLOn4F1YOCAvbDHVAwFDRGfhg1bAnVDGcAoOnDwP08MygNZAFziwYK+wSAgiqRWPyVFCYgL4wJA0dLAupjcVlDgNwILqgKoAFFgXNkmsG+EbqAWrgo8YBuBEsOooVmAXuB0ijnMBPEFDqPsAl2B6nwzoGrgPEsRQgTEBw9zuSGxEK8sboGG3BdIDTgkjICOwaOgD1BVUC8sAOstUcIVGbERd4DTGCNTMPgf-wtDx+q4V6BvcGx4cGIz5hD9gjqAewLdFM1qB3M6RCNtBEIPh4PcgGnhh6iPnkE9AugOQQR6NaYiVWHFZL-gERwozBGdBwZi3cDKuC0UQWAoNTnwHfYBAgQtYlsBEhAAo3TqCCEFugrWpchLp5HLTDLuJeENIhyITAUBpVNegWls5SBT0C9xCbwLnoaC6wFBP5CU6Fu4Mj3Z+Y+NAuKTf4BSEJ1-QqggaRcgR4wCMSNOYEzQrjB80AHwjIrAUYLWIUlY6uwG5yEAO09ZFSndAwkAfQGPEJHwQsExHBfTz6EFkrL5ANTQ1ikikABuDFxNTwD6kX6AuKSUYCCENzgKtgQGA3WAYUDzYJeQcDAihQwWyg1GMtKM0KsA-iAF6D7qC0yCFsZLAScBzEA5nQi4AXjAWYkPImy65qF12PyDX5EvWhLjzWjD0IHoYfi8pfAleijOXb0GIwEgoVmBMuBQIFymIwAB+AXlA6ci8u1EkEJg7uADWZANhQGHUrvvoLbAe8JzcgaZA50EOYL8u2Ip+ISjQFCYKU0YaoKJRg-BBhhUEG0KS1YIYZFOCVWG-gU9wPuQIFggNBpPGzKCqEeDgRkxi3S9kC96AdOBggyeQ65hPsgboOWAWggOPVvaAAcAHUPtVe8EbTBoEA74DygJ4gCoorxQLApyeBoQWEHB+Q1KQn45EZHWAfDsB4IMnBy+gz7nFALLocXwkZBN1yotEBiJYwfColAhxqCPXjwgB9SWxgLMIHeBd-xV4EMMdz6j0Bv1AwqFTwrTLYxSn0gmhBnRDA0J6oY6IudQEAglgErwAZYbeuJkAaIyl5E7gX3QP2MKjBPeCcGGhwPL4CiE4YkDpZUkBZYEuANQEr1guf7tADdITbgfVAYhBi-CnoEBkjMQG6o+uxJ2CJZABwI+RETAk+gVWjLXhRINZoYqycYAF8JysDjirVnWQAd-hmaCV+DsAIUwfhQAz9DHCvYGYWPzvWBA4AhBcB-kFRfG+geX8rDBTiCAYHmIK77ed8RdBqxAWZGsoAMecegA6Bx1ikQFR8mowGXgNl8fCADcGoFFBJVUg2WR06AmYBu5MlwVJghhgNtQoXDIste0N7k2-RM0zNkEhAIGkB0w1AhQahQwDHgJawI+AJsAk8Z44E3gD8QGNI13ohpCGYjK0HlyCcQEggS2ohRFLAKMkFyMskB2PSUMAaYFawOTy5ChK4B12mOZLqceYgCCBz1CJIBMlGiQSNwQYZivz4wEzSMcyIm0GAhSzCGGCbwPvQC9gzsBFnAUxixEHWwKGwbxBduAmZFGSEeSbMMizh28DqV1TEHnfOPiYdl-cAhBz7SDndL7enhgrrgBFlMSAkAXYg7GgtCBk+BiECbgfPAsug1vi-MG-Vk1wAuKtSAV+CUGFF4AuEJiAivV-uAbzFOYN5HZNQoNNGBChjGpwLKtRZwipgENCRyAwIF1gJ5AJoh40JiMC0EPLQYBI1mgwyAPlkpICigXrgd5BJSyGxCCatdkZrGZEAmVTQyE-QB84QLQKQRJMDkrA9xIGkM6A2sRWMC5EmDABitdrAYm5GyAoOCysJFQEfQzvgv-ADYUhoOiQFZAJvZWGDJICzKPKQ7GAw4gnfDzQHKwufobWIO1BB6D8CH9gGwUWZE7+td8ClACwcLH4SjATQAjkAG7D1dJnvOywPaAlPLayi7kKzQwPANpFpVzAEPBiIFkN7KHNAoU4cwHHAIzoBJgYB9taGRwCUzC4rXsAzQBwcBtjlT4AdZAkO-kBsSikcyPsIxYXHWaeABrBHwAqqBiQHWg2IgBsCjJjdkPTABugsOgmrijahmLFRqQaQnPsnKi2QGlXJHHXaw6LhMJBbhA9bHwgfxgkWgAxg4TDJ8AE0fXueFAcAAbSGLgCvwaKCvGgCfDuSHqXMy8aig3VhvHCDUFjKK3Ie+60xBVEhuXCDvMzUQDAZiAnDa-RU0+FrgPOAkmB5yA3CzNbIq-A38VyJesACfltarhQYRIILQAqRpz193mrYRVguQIj2BHmRzgLDcJHKaTBLwAxe1fYCVAZVwx4gfFA5QGbUMUmLyw79A56DzYDcQnJCDAQILBlpCMIBM0KLIH+I2TAarAIMC1xgPoLbA3Mg32DRvG7oLF0D+YtegpKApdAw+oTAX6ObPBiuB5GGzXFZgFIQYNgASj0kB1wOSYZmGUgBcKywAlZoJRgZOo3EMc8DbwLIsn1QbQsOtB9MBSVF7AHpaM-ii65S1wZoHKQPgwVJgvbA9LDRQAPoG64HKQOc4EMBi0kJ5JCAGOg13oMtjlwQYIGLgf8w-WB-XAmUCZCDh7dcAaMAuZiwmluoPc4I-gNug24DKuE5xtukGNATKAWcB7wirfJj4a9Am3BSOiKwCxOL5AOSAbXAJ2Bhqi1wDCwNDA9mglsBAuDBYQBbOtAqngmhBarEABFTgWvYj9AlqTWIDw9D3IM2QvxAUFqU1ghwJBAApIwwg4hBnMBjSAG3c8ouEAwQgQQHEgMsYDMgR-BLEh1qDxYLuAIyOgEADApAUIMBDtkAUQ5cB8GDy8ELWJTGepgjFhyzwswDBaFRUMA2GFhOoDJ1GXJlAYCUggJgsCgClB2BNaWbDQdgplWBi4lIQKmIH2quNBM8AiIlnoNQKYggfIJ0fBRYCpkEk0Xrg7xUODyJ8FzYHLAPZub7A0RD+SCrQrqIelAkWgVZiEpDMIH9OBeoezAEMDmEheYXpaGhgG0h06ABew0EOnwNP4C7QKUCAxmVyEGHLywSUAx7DxyFdcJ4iUrg7NZxSR4oFfVuVhHVEfDDRwBDjU5wBGJRZsWDJINDMGCGuETvOAoJuxbADlAHIhNVSJeYarAEKGuCFdcJrbPakoNRUvTqsDgMEYaeQwQDANzLgIDMkPrsAne1FBjMY+WBnngIYeqANTs56BHCDoEC8odjgkixtmCWSHmUKjgFrod0BLMwrM18ASzLcFAJuBB2DUbWPEL-IJnIhShbwDseizYK+gLL250AMSBcMESWj7ERB6pnBMsqRVGojBcXUx8pzlfSDBr0w2KZTXC0AohD8T9KFh4P+MNIyloFsQbb8A8QB-gYIgY0Bk6gCsl2pmKgAgyQVAwFQJoCUnkFQQNQVcAeJD+SGVyH8wGMAPpRPjAeuD2EOYYDwgf0RBCC3CCP6qGQLcIpQxBAAriFEkIZoVP26ohB0CckEmcGwUA7QPEAfqAUACAQOqgcqAvbAgOjWuE-kL9gP+gyKhU6D+5glIIO5S4QfLp97CynCqoER3fkAzjsJcDR4ENQG5YAVI5+hw0CPkH44AHAN6AnkYz+5DsOHBMRwOCwP7w8ghyEGCPiumFgoV6ATIDvRx1QFBAQ1AY05CpDu8GYgDOAOYwN7g9QhKRldbKZkA4GFtAQYDKsBAyDCILWA2hYmsEXJAgeL8UTiI-DA1VQM6Bj4DvAJrubdgRLK1QFWIBgYUvAKahKapg9kwDBNQRgAvUMd4DXgH8IX8GKQAycQdUCZGBSCMuJQqABlgjogBUhtyERkHG2lmZhMH03DHgKTwMdg1GAa-C51HuUFGzXVEJKMCmgHQGEEh64EpAgfIi4D1DhajL2gaZATEh3Gg9r2RrC3QPkEXFIpMCBpAYwOYIFlQ+YdLHjeIFMQIbCUhAd+g8qA5oFjKPlwEpAb7BvRDRwBhIALAN9gbPBq4ClmEIcPzAYJAaTBk8j-mE9QOUiYIQGqAPvClDkpsLhUK6oGD5h9S+KFd0L+gDwgWMBMkD73F2pGoAbAEHiAxYCT0FFSDIoAeOQwxSOijMgnZMSQUXAAFceTiE8EpMAlIQ8YsFAZ+ASCDpyKtRZMQdQQ8RSiwBaYIaoKlIZGhrsTM+G8EOEuSRcY8B4wLRMDbrrllSBg6soMsAESUHAFqwVAgzXBw3LmEBMkFJAPwQt-dFkBrswAcNv4Iko2FBZMjQPCR1tBIWqAgmgB0BuQBhIAWkcVALdDk4ibgAATjKkABWCOgWfj8uksIHY0fCopkhouCI+T8EGLgF8IObB6GC6UAhtgpsKNIBcBugBPEHeoF4iMggE2B-+LGUMbgG9QMmAWGN1QQu5EgoLqQLKAFOhLjyvoEpaN4QLtG5bA0DCcLF3oKKkfp4VzBZ4T60ADcAugOMAFQgGCBq5X74HqeRos-TwXVgysFyEHGgCXhmuBKSxc0Cr0CkwG3sIGQOYB1uCaQDR4Ymo0ZgdMBIoAQxHpgV-A8ihCcCfyCxnGsgLys8m1LiLUcEoYPu9bVk4OBlkDJ0HGsqi0B3UBTR-eA-IAKMNkgZSAQTVBaAB+FnoFmAPVApWB4wKQEG+IHDABOAuEAGKgEQGWwP8QM5gYQgnDDhMAJgJ0gZFASSx1gF8+CvsvcUXiAjRgsFArFEGSCFjLAwwL0ZhCqQRyoEsQYJIg7FCZoyyAd4F64QFAWaJI4Cp8F3NK08dUW55hpsg6oAkuCXAceQlKBCWBlEF+WLTNC1gw+giIDXrEuOGOwFnAfVC6RDYiGXEK6YPagDrBEzguSRPUHDwflCAmCrwxmoBOGBgIBpgn8hKsxFT19kEAwPOgjwwUhxMJy4ILd4D6kloElWZe9H2oI3yJYO1nQ9+grpjB7D8kKRo2JQsRDPoWogX7GaBA8eQ2UDgiGsiI40WFAk4xmuDA0QAgB1INToBeBk+ASwATQAYtSEoKjBsxC0iC9uIpwQdA+qBerDo0BXWMcVJgwymNxwC3FERQJOQXsAUcpX+7Ez2wlPNQPBA9tB9GLIUBAOCigLoQE2R4aDnmD+iKStcBQzJg5AC+EB5gI+IO7AgSZDJDdwBOCtv4ZOAXiUL5AZhGJysskLkWIi4L5jY0CJECgQIDyhaxPKxA2UvCCaQQ+IqlMUODSMFDCpBg-mAb-A0-iOenEqAvkCmAN4BgsBIEH6wIqwFxIZrZ-BD3Ij9jPi+GvIYwwB1Bt9gmwGSIdD446wHEANIwYII2gU-ABRAysDVqHHAA7oKZqmToAcAiOEK9OUgXXYEzDhUDy0Ad4ED1SCAOGhMASJ4BrgLxoJJgkJh4TB7kFNQAo9c+AWhB02ZbkDXkOughOo4rJfljNMGOZA14MqAIBAEICDJCloIdAMggmcwqJpRA2GEDGLJ8AiKQKmh8KCRoHaYJ3wcRACUDnQAdxjLwOKhnnh06ApVFhsMMgMpgUsRvBonTBwBKDwbhQzlVWRqwhGHYNiIL6gIGwYiBDgCWEdYwFC4w0ABpDtID9SFDwXU4h9BP9Bc0ERgH8ASlAQmUOoDMYDMkBpIYiAlb5rYiLsGhkNxSCgACAQAuDg6G80LKoDzsHUAZlDgDHTMNBsUmQdVp7sAO-SkWM2IPYQi-AqOASkB+oMQyc1Y+kAU1ymwH6NKi0DbgwUBd2Bd0DUojw6ZboKNBPB46YGQIF+AQmEsIR7GCanWQaEg0AVAGwQG7DGUMwuBFgfWQOYB6UDyGB3CrhULFAaTwIoAGMB7UDJwb2oeLAXVy-MCxwAbibxwGGxYqSKsG6EA3AfMA1YAAqQgsEi6O4QLvKwBw6BK40GWQPNgGvIWMBUgRJrWeNm+IWG4xyFDCye8Ga+NS0etAsNgj6BmmB-YO4AMUgBVdkypI+F+FDXAdcwv31EMC-IEUsBzwXDoe-JP2ChvCegAhgC44TdA2CgZnDVAHbAJNAiFQVQjsMDqCMHAdpgk2wm7CWwG34DQSZZUN3B1QgolHQ7GdgEMYbOAAsAbqBdgCJUV9onkAgOjHMl8lDZracA0bk1NbRUHmIL8UO3wXQgHJpToHTKDi0Me41jB+Rj6gV6gMEQQ9gllA-eCydUbaH3Q0nIR-B-oAmSiegG5YThYhOQXYjF1GXQGMxRPAllAuNCleC9hDAWYIA5YB++Cw2Fc6B7wUUqrVBR0R5MGfQSEKEAgqGA68ST3yDUN3wOcAMytx6BkpC1iD9QL2wBdBSXA15BQuM2QSz4zoQcDCXsCmxJsEaSI9GBnci7ADJmJnoXv0ydR9yCZjw-qIBAd6gqnArgh9CGZgPDsU2AWDgbiCjkBfekxQaEss7pCbCVhF20vCYJgEUMBgwAKEHqkIRwANwKJYR7gZWFHJAYCYh+KUBzICT0CngI1wIY0T8BSeCwMQuYBdkLc62TQyBBbgGbAEXoQzEnZBDnAJ3CVIGmQaB4wXBkuDhoFBiJZ8SRY8lhk6g5QHXUKS4GHQa-AJYAkQz60OpgdyQ7ig+oAF1Fk5rHgVVAmnBfiB76wwoGIAaNg-JgoeBGYItXqeId3wjqAEaAbanYYGvAewoj3RJEDSIDqxIuEY7gDzUsqAZkDZ4BbQGnIoswtcAbxD3uhOQH2g8Ogoeb9gANYJToZ+YbDoThhF6FGwHbIBjAyYgZAh1klP4DnkbMYpUlQEAiOD7YYI4Slolugx4B5SGnkKUGSMgKAYUECBMBGAL2AU8AUk5liB3kh6IC0AenuTc8leguiD6QAnoLMQRbALEDdgFvuvxwEtWYdpEUBEwAaQMeDeUqDkJjTAuFCqIMvQCmA82gBrgmQBUsC43afA9rA+ophsAqQMTJYEQs6Aa-D4XiUjANsTTA17RxGB3vAikNMIN+6V-QJEz+UQuyDLgQFAF8shUBycEwIBFIVzAvYB+rCtIBXQFlwU3w9NsvsAvKDgjmkwBvAXql+sCaMX-ipvCXzAlLoNCAjQGYsLQEd2g6mx8n6lwA8nBa1W-IuzBl6CoiBxwETAfBg-vB8OCmCEkbKWAbWga4AvlD2XGmIBjgP3+2lkx4AdILTaPYYbfw0IA+0jyGGxgB6gceAisBajDusCWpKSEPymnP5z4BTJW4pBhyJeY0iQAHAF4HmUNSkBIOagIE1QO4DUhrRgEsgzEB4Mh3d19IMqw3Bw5VZ3CALWCYYNxiaRAVqgmeFbEBQQHUYctQue4ZHxNU1KoHNfc7gjSArRAb0FDQKEofSaAmhxQAkDFcuFM8fbgMEAOFoDxhdgKJYa6A3iA+tDOIBbyJPoRFg3iZerAxGA64Mr7L7ALWhkVJPUHVEcDIVlgUEQV2BKOBAgFJABVCWmQhSD-fDJHBEgFQQGhA-syc0HlROHQRgEWggwZQIYnOIBoafqAKyRQywalAbQBYwN1Aj6h8GBaxCnYvTEDWggfpYTQ+iAZdpdgZrgXthaEgvgByIPsBQQAoiAblorjU8RMhAa+IM6BKJzJEBzYLzgN+QHuID5CssEUaJVEdCgj8A0GBsWRUyFqNcykkDZaSBcADEwL1AWlMutBu1yZkHCQCvwXKAfrMbsDfMDNsLUgZMAsohjFahQAQxEJMY6IotgCGTrgEtkOBodcAe1ISlBKvChkF3IRhgrGAAij7-XJsHoAaCw10h6N4TQHkwGi6GcAHFRthHmyz0gBYPDWWoqAH-wvCGXEGAqfC8DBtWoDsMCYQA6Qb8AApZ+piTsBpQIwgasCb0xvVDguj6AMEwBeByagIsAXyGiQIXVG3I8qA-wiTqA+gMpgS8gu-CGAD3KEGSKIgZLEE0BBi7SMEFwGYWf4AHTA0MA6hAKaBKgQ8YRadA06tsHkwHR8PIwyiAw0DNkHP0A3KFlgFeA1i6MWEKYCTwczya5BMkAVcFSBOtWK8MQ-RJ9BZURBwPE5GNa1sRqMAedjzwLpAG-0iS46AhlGEAVBMgbGwY0BkwCJ8ED5CXWcXApXgQWzkQEABNtgOKooAIFqxUgHUeOVAKsAIqB1wA6InaCJKWBVOlx4kECSIEZBGSITLgXHh4mB+slSwBzwBM4wQJurA8elZYHExROgxSZKhDFSGgsHTkQYwL7BWEB8ADZMOBoegAmuhAYjc3m6IH3IKJYr3YAiFqUCnKDmwYfUgP9ymC6AAE0IdHVNAiJBhxA3oCrcGAwAn4-1AShhJoC26ituSo8e+AnKCm8HRIAhYaxAT5hYKB2TB3QHUEPtIgdDQ75oiB+iOSoVAgoxAhsCRuDXZFDgPKQ-m1JoDk4Ad0AFgRWAzTBWPD6CzDYJnoaiMVkxufCc4GpiiMsOkQI3AXkDriMCoITYfCA7HCLsjy1BvgFpkauAstFCHCNkQQkMLLZFgzVBEoC4yF-kgEUAlA85EipwWwEdvnnIGbwRUA3VBRWV82jzoWIgUOULshcQE4UgnSJ6QPSYGdw+5VyMANwe8EnhgnvQN2AxGGPAP2MDKhXrC6ZHZ0E6QdDAVZBnYAGQB-TK7Qb2AD+A7CIUyC3yCOcJxgdaQyEh92BKGD+WW6ArDlr1h1QDnbPV1CkgM1AqOB5UFFsA9xJnI2yAB9D2xEoMGDSJfUvzQbAAE9n4UMIWT8wC7QKYCpSDuEXGcCbAIfcBWRmHF24BYsZBQlQhHiC8iD8QAYgSRA8o9NuAwsBLrDNQVK8GzYGMBpoBFQCrMSkiHioA3A6uH6UAOgPaKDKhD+xOuCA8t-QKtwBSR36wI4B6AKpwrfIXUwzZCbcC7kN5AXVU1tBIUBBIFwXJUWA+gxsBjBBRIGqYhFIXNQTqNyVjbUCIQAA8Hdh5ghsDxiYCdUGGQeCAPpBR4AH2CgqLI6dyknqYr3hlJm80K3ADzsjbQu1Al0GLvGv9ZMAnhhyGgKdy40CKMM4gGvFOYAZsHVqK9IAqgACApxRwJFOAFBATRMAyAB5H9GnwYIwSPZg-CgtghagCyQBBEStwe+Af8LPBB3wGEwfPEMaAHyA6oiyCHykf74l7BnWCTpkRICQUckQgbpRsB5UGioJeYFJAZYBvIJmeRQQFvkTqQyggb8ADSByEezSTug-T4FaQMKJUYGm5FLo-3BqwKuYmjUeJUckqwvAHyCEPhawHctXhgvlALEAAoEzYEkwEtMzVBpaCdeA1KNJIE6AAV0vqAZ0AacpceB1RXqUuhCf7zxkqCwTWBRARboDm5kycLYHOgCqCBLWBfgGIgCk1OrEYTA9DCoKBbyLgsFGMt94u8R+JgMrFDgDaIajAgpD-rFtQrYTYa42uR8OBkaEgsESkMqA-oZ7ECQwEjNORCKpoDSJetANMEqwJYkd8Qqi48pCqYESgG8uA+M+cBsHDjoDi6EOUZn+60AQsBvNDVcHd3MGILY9ChBe1CySPduN6A3tBh+EMwH4PGmoRByj+hXoBpgHFACeIJNAsPoWxB-uD2TILgC7iv+A+fABNCg1FWgCdcfghJSD+IEhKOEQPX0uDgxKDNUDXYKkgX0g4ogeSL1N3OmCh6ekg+F5qtDZjDbsL3wVi8u3Bg0BY9hkvCEgEFotCAhCCZnx6PMseRcI934X2CoyI14idAWJwM1ASbDw0HwYJZ1Xjw9olvKy3wHy0HOANUAjpBtCwFNjWQGygXM+mEhBAADcEGoM-MXaAmnABsC9lhzAHkwU3gGVgisDKYFkgPSgfVgtUR1wCbYEqhLG7C6AIVB95RrYGsSjdQekgr0B5TgK4FzUKH0I5A4CBxd772HH0I7LN6u3HhVEj+MEegMdpFegsIQp4AoQBkgJDGcegtwhZ7Adggq4KiIEYAMZA0niHZSCgF7Cf6AgZAQlQjqBrkKLMZbAj4AEYiOwguIOeAUHgSMg+gAkO1tMK7gIbw2TRhCA3gF7zG3wMnwM4ADViIxFysGkwbQgK6BmQQ86BN2GINBaA6igmlD8phOMEAQVp4JnMXlAzSBnQHNAc2AZKROuj5axi+NgQU5AA6BP6R5GBdFETSJzEFVUBUAo4F95ikOLiYQ3hJkB1QCvAHoCBHA6pEaeDCCAKHBtECqgn+hxwC+8Hilq5PL1ilWADlD6oAVYC5IBqi4aA-YBedXeECEKWuQGahxcCGFk8ABjgF5QjqBnACWEHpiLAQPCgrTxSXAaoEIkM8EeyIBGgeiBg9kK4EGoG6wwkdUsrZCAxMO0KXKefjJqNSaLE3qNTETiI3ihANg9ABqCP-KRwaFMBMQj0wDBiKQosewyAlzor0wBj0edAEyIcgBvBBjFDeoJBoKpgNZhBHbo+ElAIv4NTAdOB9dhu4w5atFQQwQ1SZI2BbYAzoBY8NuA3iUodQf909kHk5azg5sAKSBqEHEwqziXkQiMRJnA1CDoMCCsSqI-B15eA88BYKFOKb7AR7By2D-mARhHSlbgQhLAv-D4mhJLIIQeJUGkAB4YlRDi6GUwZa69Zt4TAZkB-gKTINaY7egFUyZrhbAqLMWfW8cg1yAkylecGQQR2QqCBWmBFuRSgRGSerQe9Aq55rCO7EAgwPQw3HhQED5cDOwOXvIYYpaj+CBCsGH0I3oAXabqgHnRuNHwCuRoJUg6MBzspFYCKDEdEapy7kRjBAjwCg1GPcCFALFQOLCTCAJQOPIdOiX8VCwSVYBbwENALTIXdB94Rz6XYwEX0ZCAxFB6oyw4RiILqgdxMjyhoQBfgATUbPozaw8pFR+a7wGRupV1UrwkfQOHofyF9kA94KCSATRexSlsFZIEdEJNATjBAZiC8g4gLzgSuAGt9A6zzUDAVJKwAHROhgBrCnEFhCEUiduB1vB0YD7QGNICrME2QM4AZvAwoDbhhEghmYwiR3EAm9nfwCSkb4W6nFfBSVCLF0ZnolIcoEFflgVAHKximAEaoV6EWWCX73BEL9MNEUY+s63Ap0BLAA9dB7EelArUAI8DTQEM6CoAJJY5WBkpE7gLbZBcIoes+CIpUGQEbGUPHAsWptk4myAtgHjgTruXL5YsxYIG4AIWQD+qspwfthhNEe2A-IKXs0ohW5FAaDNQFLQfSsG1BhCxceAC8MhAA4wpCBySyGCFh4DGgIVA06AqshPED6YfwQIKg97BLiCgMDsVhGQcJYX9YHqCQICjgBMIBJcGxpczieyF8hFRgYJI3MAA1GXIlkrP3YXXAzPg+wCjQFeoIwwSsIzTBDVoPsHdYGsgBWsaah6mA7sA1cK6YBxARYB2jEsqCcYH0cYYgQjQfNCjqAUIE0dLWgrDAEzjW0C9wJVEaAKsmoSUjMLANWNToUzI2CAsvx8QBGAtiIcxgpI9xEKIIDaFAjgaCAKcB+lRp+gDcErEFoA1kQDUDj52T4A4oW6uj2xoGBCEBDrK+AX5o2YBzlDcIipACLYDvCG1BnTCpKlmgDtPFdMWCh6lAF0C0WGsQcbmYGg1yj8oGMgJDcIuADCBaYBnqx+QGEgBpgraB1zDuJlCgPaOX2kMaBXXA2HCJpByEGv0VZBOaApgHmAJOAT6g+RgERD72EZCjOAQZgyegnwACAFsgCZEElMzYAQyD60C91FBAaeQwp936C+ni4ICgIE2QAzAgUavSBi3P64AIo7eBU+AWsF+IFhGZrgr5xchCwcV7QKqhR3AEMIMiDeKF9gNv0WVQ5RA0E6vSGtcJegFdYqERaaBarA0NDOgCBgDdhXiByBiaQJgGAgx1OsJExiUFTJCkEfqYAHwHnD73D0IOdgDTqJmA+xhIKVsYIIQV6QmeAXMAZWBbwGJQGjwNrZl-AJAR4tIB8S1sXL0gXC5tncQCrAMbUdSdNaCUeDMAVrxRKAnn0IcBLzFIQNFKYLIEZg-CDNgT60NPgLAo2kEAPjFoA6kEIQSxwkyB9VC5AlvQP0QAY8b94z8BfCW2tAIgG4RzWBu1zx4R4kPt8OioNkB2pQBFGYpKS6LVwU4ps-BAYEjkHuQEUg75MWFxsmCtgGAqEUYx5iqKCtID0pOHQcsxWrBOxzaGSOwMdALeY09dty4GmI6oCnIDEiLUh1fQkAClMUxAOYwr1hHOjRoA+Ot2uAD4Zphj4wkUiICFZwRZsaSAMpZu4CgfAXOP6I4thftpoEHJUJ1wYmgM4BK3Ca2CcYORgOjAD5hvOrOyMfNIIIaaAluBc+7KQENQMNQchQmbARlhScF33pKgHew83gRLCdkA7wLV+EwcdYAcpBZ1CUoE8JUbUIkAHFAiKHcQLgsNfGqcAsyABOHPALOeKnIFiAfqCbsCewNMgANwqmBsaDuIE0TGuySOw75jK4D0OXmUDvgJRgCbBAIDZWAxQOOsEe4SCBFVCNCz1wHGgZ8grpgbWDqoCYITX6LCGPzRp2jxumlgP2tBQgCDAKLD9WHUPK0wIhQatA2IDCnz0sEQEPCAAOgLlDrAG-oP9UJV4rpgTMjAW3aAHlAfHsu609aSvYATiMSwNQg37BIIDUtEHIMVIfJAOGhiRDuYEEAHs2FuAMOgeICvQGmYFutKj6RNonSCL4FYUMHeXu4j+YVJEdIGuMS3gFpEoqR+pi3yFG1LbAcbcZIDIhDMqXytLxAXp2LeBbuBBIF9orf0TlSKDNQoD-QEx4J5QENA8ygjsCw6DeXNJwYzAEnhSXCpECWYKyoSFA-rgnnDQ2AmkGdAE4YW8BECqHcGSyCBAcaiS1iL7DAYOQQOB5eM0COonVBYKFcwPawYWmJKob+DyKAq4DsAK5QyBAoapAuB4kIAocaAqQ4sYSUwhYkDbgcJYmEAgGBu8HKINlAd8QxOAr1DUoHvYEDEJWIo2AUuhlaHOYNy4YtAFSB5yAwgR+wDwlDr0ChjSzAGz3KGKokWOAuyB1hy4oEyLLSQStwM-BzWARQKo4KyRdpkPIkNoCocArUquoQlg25Ab0BInhUGlfAKtg9hgzbDZoDHUTxooqAjMAt4CKQBYKKkCCUgoNY6EDfEHWrONgGnQ-EAf4gcyK5sKoZPIITHJcqLjrBDcJOwTl6p-B2-7CJDyCAfCDBAFMAYp7LAU0Cg8ydxMcOBdtANUF4wOdAHOgflE85BLYFbYOmgENQ5NA95CuoBZwa81LCxr0BcjJROliwFqOKAwPKB2XTkriqoNvwbag+NjGoBoQEmoLBXZxsiLBZVDkNF8SI7yJooGhpLR6eoBXYAk8bH8eBAyaD2RF-QD0sLrIv8YgmjFoC7UFM8R6AjzJ60BtOQE6BnsR+Qr8B3xABNjzHBA2VXQ1DloZDTwCv6OCCXKw2NBSgCWGQdTIJoKsSAs4+NHOiGAgjqaanQ5rAd4Cvdkg0ORQS5YV6gQhRcTGJECQMBdQyQ0dsjcUhJSOeAR6AlMY1MB6yk3RJrQT-An00B4SfyPTqFDIdFoGNAQcDBJDf8BlgNdkx3EXxB2bT-IHava8IRqtpgBnbFx1sGgAFAv2BYIxycF6Ir2Yfio07Q2UDNREmcK+gDrAymBkxANB2IQIDEBuSzgQFerkoB0bNmUcXAPhAziBMnFzAGk8a1woZZG+q7sGvaLgyaEA5EA3WqB4EjIF2XHOxywEEQLosScwNtaWmIVsBbSygohVID+gDSU2qAfuQ54HlRKF0bSwrktm-AkpAIoGDaUGACTBTlCwWCrAFosIGIPkAC4B92A1QIBIQKgIwBr2gkQCdyKokZnw66Q-8CP2nMmPxCR8oD4B4nJvKxNEdpQQVATVdCJDOACxwIXAj5wa8BMcBsmFJyI9APwO4LYzYRQ8AwMKmSW+A529h9TrdEe-BlgCqUwGhvExhJH8lI3IFroRdAGZI1qD2gJQAZvc5vQroiVQk+oIbAYiAlow99CpDns0HEYYBAADgckG4IGOkiHoHdKGHJO0ClIG8AowAOVAX-g1AA0Ik-AHTBElI-FRuKSLiDfkBfAQaAohAIUBMMH9uN0o0jo2YBzWDNREkWELmTzwuJxnwDuQFaYPfSXMApeBqaDAVyIbJewH-smDA1vhObBQUfIYFegdIELISvQAZdqqQB8g1ygGRHGWDHUR4IqDIHsJbrFLjkHJEXg88wS+pnUy1IEjJOAgD8AIZBGeggZF9PILgIcoR8BgZDt4HucF4uNLMfYBmawpMTYMWcwZCxi1pzGI-LCe4ESgbfgviQw8BiUCgQFAQNX0MTBQNBtWFpGG9SSrMK6jOJKDJBjkTeAOrhlDBpyDNQg+9MmACHaZCQkoAaQALFBP-JLsZhYpACOn1kAMbIeWooQ027BzpjTIF04dwg2whTdEzwHN0c3wWaAJyQFlwy8Fu8O3gB5+EMByRBTSgXwKtJJeEx1pckDoQGs0LicUr4EBgvSyRaDBpCl6Kpo+xARFDWuFaMR1wV8Es0B9dgCZDLhAgEPpxBhBJhDJUBpSLF0DsmPbB54iCfC8gEDzNCAWhBErGt6AFAFuASY0VscxHA94H5sb7wTSC3JAhAAhuDhqLNAVVAwA45CCotAbUMSBMMgmcxsXCD0D3kIrHTkBTuB2MCeQGFwMJwBeQjgtnAAbxlJrLGcTSg6iAzsbGkHaZJ+gEdQsNgaihq2C1cJQILJuR-ANuCNghIqpqQYJgTbtgzxpoF6kKFARFgXHggqCjyH7AGbYLTIB5wqehhS2PwkRkL0wmTAG-RgKiT8HlAADg2lgxQAuFDDhgWkMdg0SgtxHHxia1h2vIlw16pGUCpDmX+JVEbxwJmgvaBZQCZVL1IAugJdYJeCASDwTLZgGCiK3goxCivk14fRYlqgOW8tYSqED2dORofqw9Xks0QCOA0lNugDr0Z2B66QkDFIsAoUepwi+BgYDMahsznWAbxAW4AvDbK6ga8EAQBgAnJQ1GG2HX+4GmxUVgL4wD4Q-UBXkPecKCAAgjeSDmEncEQeATwRrahkKAAfGjYHLmQIosgDSQgLhDkgMnwE5ounc5hzf-ihprdoMRgCNoYKKhMDPWNh9aZAaTwcTBLDTiIPZgauAMwBTYDMvDDwEALQGAvp4Tpg1+kfBOxlfcAXvxW1AtdAL0TndEtibwIxQAe8BnMu7wDXASDBpEAk2EIcEdEaBA3tQGvDeqB9oAy7F1AZcBYoAAzQlETNQf5xafpRCggTm9thEUAOclsghBSRdD6fOl4cXAb1BSLBLnm3fnHQmJgIWgbwDdKKV8uRwftMq2B5LD1COmIAbgXMABrFlcDSaxa0F-ABsASrxGED-VHOgCgQVTgxSBOpBy2F8gCyLJSQ7DBYVg3gV5gJ+TKwofABw0B-JjAYPnAT0ieAgOXjLqAriMv6QZxZRBhnHOmDHuKkCL0wnvAfGCFwENXm5xE1AhLBTeDtMDjoL8TYgg9hQteBzoDRgLLrEYAfSBLjxsMH2yEGOT7A8pwa8iCuJXoDE49UQPEBM8CAJSJQDUEc8AwWBaKhy0Cf1MAgTQqefJKYjvKPk2BIIIBYGeBXiATCB1CDpwfg8A0B4ij00AeTJ10TpAl5CPCBOEDSYIfgfNA5iBooD+HEn3g3AP7g3AoDXJawmZqBY+Uqga+1v4QOIGlfBCgauEbNgZqHQQFj8ABsXJQN9UveBgDCpVFq46-ko2o+AD7QCICDnAC4g9kQNvzlYCEAGnIOGAhDE3TL+mO+BB1QXxQ1yhe26+g3MDrb0TJgGKBokBo10f0CIoEPQ5b438TQgDFQPxjDxA9bAR4C1cU3hAlAHLwG9YAPjUsBnbtcIHdKUWCRUDUCHHoPbQE5IMjCelxhQHDwG-YrHgNPA8jBXwEW9P3gQhw64BQGCyYRBWB5nEe4jpBCJBKwDgKCRNY3E4ogB1CTbBr9OdIptQu4BPSJ9EDGIdOcGOAelpFIBgKlEQJUmXu4eoh0fC9xE2wEFQDyAOojfUADJUZ0P6QAxArJAw9zZgAREB1udOkqZIY0AhsFY7JxELNgmnA5hYXwRGOOCgS4gd75mFhI0FbYEmhR-0woRhz7R4BegDOENRoqTA7SDxrnCwvxwQ58xbIMBDGhFmgICQdFiD8BlSAMxC0EG4gDvAj4hv8B5AgXANxCSHEpMhH+AgTgwdNaCREgmpAD6AM-Fp0BgIIJ8HXoqQDDIFZFImQQLkeLBkqBU9CA4KTQawsIeBoHjbRDRwJOgaRxYyBkoCjWJP4FAYHC6p8ATZBarEhgGM9Zn0qQ5K3A7IDjoQIYM+A7gMEmAN3lJgBTuLIg4VJ9dgdUBJgBr4iAgeUAIYDOAAshAdAQkOwnY7wLmUHgwliWG-Q-ZBBADBG2YcFyvC1E7tAzCAkGH9cPvQIKQosBFEBmTG7EPA4xGAG9A+ACfkWhAGlaeZQW8hbjCpEDoCLPQMOAmmB-DBiUAs4Fx4lsAK7l5NhysH5WIKgiLAvxAklAvsDT-DHwYiAn2A-IjtLS1iG-Y6nQDkJB8K-QCfbpaCaBglvtywq5QwLoIzQDAwVXjGoA5iEbkvCeDAoe0A3Bzm+wggAKyF8IycohpA3WHUkt8aYWSoKJjkByoHOwAUgSeA12ANuC2ICSUCoIB1+XIhlBD50Ea5nsmfRka1FwBQdenSrrIAFtaI+hxD5V2CIIG14AzAILZQUTUpFFkF+gFeQSUBOSCAKglAkDgifSp0QQ0QRWj76mvoy8AlDA1Gg16Cx0GfwZa8FWx8GDj4Ib2GXAAoY7XptCZVgDFBEBwGegFopDVDTNlMPDMreZQO2QJsgCIAgIHp2c50LYBxzxBeITQBQIMFRR4sL9b20AdYGVHDxUQ0QOuFjDH14Cc4gSAJmgNwDD-DEfj0gUoAFCAhgiyqDv8I4IC-SJ1jzJp9HHsgHlwZSQrSA4nTTmEg4KPAb6xJEiy-EY4Ey4FbQcpAQUAwGDIUHOUIRwV3xAkAUUCpkm9gE89erIj2E6jANsGXUNyeU9AC-R8VKupEHcRHAAgsnaBAGQXrDBAq6gLnUsQRK4AyiFHBLIE6yAWuBdUTlk3rQG0gdogI3VXrGmGPq0DmYsYs-ASAPjaIHI0MtgER0fEhC1j20C4+GCgOiIbuBkxARFkeZPVICoJnchwkDKCHvojMASZAn8Apnh78jCEOPIYKAvf5dqTeQGalDGgfK8XiISkDxmkI7gOgFLglLox6Cw8BfCKb0Q1QXUwAwhgN3-8BhsRCwsRAY6CNaS7PBLwUmQW6iqyBiEE8iDpgbJg5e9FmxnUAPjEFQb9QZEQQwTk4BTUCfQKPQCLgGzGjHAmoNPIbbAqJABSi0BHaQNwqAwg7UBTRBNqACoMN-N3gznYbICEpGFQKeQMXG49A8mANyWZgNIqfogcZxS8AaSBT9LTQVtAtSgDoqbcGuQOAKRIw66J7tBNCFLMo3AbPAnuAAeHgaNYYIiQaEA06A3CjOcMxEGJ2OkxrZhMSD78LSoRXgSCwAdo1ACJak2JrGEMAgdXwiMBv2KtaJtABuC96R5URf+EhKOJAW4wX0A1QCUWMn0kEIKgcjUA2QR6sHB0H9ARjAompnIDoACyQEPwH7aZTI91AoqHPjHa6MuAUGpFrzGwwDcFcIJhgjNAvxCeeDN8XJwVTw1rgljDYWKr0DQwMLgx1ZDxhy0AH2JxyZ2AA6A3wBjZA6kCz8bgAz4Bkgn8CBLAMZY1wyiwTq1CB8iqYLyQeqQ2NBM1w1ATbkBbmBYJkBAoNS99iNcDj4ABACZxaogRkGnABQIa9UySBawyQ4jrYB5LLxE5SBnnyFgjmQK5gXowWwRIShCQG5fIa8MqAK0gxkDVwEcERFwNqAUAg2sDp0GzfpDwMEANahhwAEyF7QCeoRKgAHxOWw68RCIJxcGigNEBVYzOQEhfEJAmyAy8MF8635Gs6FKQO9Yl5gTlS8YGvCJ4YHE4AzBozDVUjHuDmIOegKsBa5CDCNlSlMmUFE3iZMLjKuEb0FHoYmA7SB6JAxsg8gF1kGBAhyt+tha4HErHXANwoZ7FroTULGvWPKiOygT4BNOiWUBOGMfsIaEaIxG4Am4E3UOloMbALEgkIorYlGwF1MCXAOhRu6QwsBGOBcQNlgZzRzsB5TFBgLqcSRA87NksQ91G4CG1mQlEqzZnIAJwBFUTCwQc8WatFmxjQD5gDlAFP0lmgfGBOKEw2FoIH0gA8JI3AfwB8gAmAMGk1zNJhDnUGugON4XOMz-4EwDQMxvVFkUJlw0XZxbCgxh62IgggVkvYAT-DxLgdsIzkayAR2BkkwL0i+2JWEFsycdBFwi8xjnoP5ANJgcnASuA22LjgFDQItwNEEnDD-8Qz5AJIOK+kJR-WRdTG6aMw4IBgDewZYApCDfsQjgNIWbXABWTqQEiqGdwF74e3CzhLDsAmcaXYDQ0c0Bm9xAdC4IIrgNCAn-o4IDoGASYHLYctgE-AjoiWQBryPi42QJ0+BdYGU0lnEuhgWhIQ4luAj6NCFgIQ4Kjg5QAJg4rYjyYLX4K7AejwY1z84GpEGq0dGcggBn-zn4UTCY+CHfAZBAhlREBBNIJRgYIEvHghgTz4DzsPo0DlxhDhUUzp0jEHvogUhGmPgmXARwjr6Jk4D5w+FRj9iRdAGgAQgCGAKKgThixqkRSN2AGPy6LQAaCpQC1wO5IG-0bBRsiApsyegDqgOyy7TJPgFrEGtjJR3XGAJdAaUCqcG1gDVAOsEvihJYARQBmiMxmFsAWjAwUwqFVGkA+QIaA+gAfRBJjjJiKRxRo4cdhv8xg4HbCZ98UFudjRwkCBQCmkGkbaYgGGwiVJMRN7uLGceSwU0BAMAb0xbyCFAXFAtCgXdDT+ICBIDINdmLaBqBCe8EmdK3kGOwl4AzGbD4DEHpbuaBgreQeGBf508RNmAE3s16Z06SrgHWpu2wI4Q8qIdDBlEFJyEuwS444RV1KAl+3acJfAaZQFJAjsDJ1FnoHFEl0eD8hwRCHCBGYDtYEKImFJYXys2FV8GvAL0RywEZAihAnToIbENos2MASCAL9k6EPHACFQHfQVGDpoAG-p20CJgcwijaA1bDcaGygfgQDANQUTlEExgNWBVdQLdBHDIVsjjADlIKsQ+F4IJAlIGfUHOgPLkSFJYeBeLARhMPoQXxzig+CKPdAVLiAI4-YoJsRCrc4xvAHQ7O70ZthGkJZRIwEDWAUHgnD8ioCCQjOEOA4fqobzR50Drhi+2HYQagM9MhX8D51HEgGTEdzA-7w4kAXpjdCeJkOhg84BLyDa5FfgCIQATovvA5CDq4GtBAOwDZAXKpBiSdESswBjGUFEi7BLKDXOgQgN8QdVaTqBJyAQQAGkLXgK94CFhsEAfUgNgO5QJgQCsAtCw9rnjQOz0ZjUzYBTOi0zQAULlgKdaaxxuAhAgX6wOkkcwQZ6ATajMxIRwJTGU+Js0BcxAnkPfEI0gDVAK6Z6tDUegfkO06cIgevBU5BZFGYgFowNSQFvB0ZzG7VZoMhgMcJdJjFYBQCA8XFtgEpBBHhpZDmcB9qmbVJiA+8B6lzmPDUBKCid+gWUBTfBH7yRwB1yeCSS+BP-QxIBWxMZgSJGT5DnSDwJQMwEn4FMAgfJp2gFQC3QHw4XyeXkTe7jkAAiQG6QU1AaEBDYBFsAd-AnIZqAyjoRIC9mFTEDgkFUITOhNsDLYBzAKxeC3RlMIBVyuhiNcE+AfaIEJZH1Ge9V8sJokyxw6mBNNA9jSNcEIQFOAM1AG6DUsAoFH2AQsgSvoqBS0xHuIF4iP8aq1c28C0bwFHg+mM8ka4BbYmiSGIjE8gQiQvfplHQD2BtwJeDKP2uSAwQBCAHLUAjAEqAIYxKYT-jE61rkgLvg2NAJ+Bx2F1wJ3gtBg2-ArNA1gHGMNRqHBI2E8a-hxwiHgJXAXxgENAxuwO2HHEk+YFdhXCUZ8h9yFG1IEmWghiBVY-ylRPVCf-wCiAI6BAZqNLgMsHOAM+oWITm8BDvzFQKqIRnQT3pU-DZiAwzAPCAqAaSAzmgpyEbQJJgDo0-2APKjNcBxwBfwA4w42DZ0BtUBNwFvwRcQ9eBq3ig8kBiHm0F2JpnRwAzdiWKoAQgd+gg+i94A+4Xy0Ej4G+AbWAcQnDcUsYV8wOKJEaA0Aw3fVa2nIIK3ADk0aYDFQHfvEN8Jpg-1BGRjJ1GqoJYAaM4KAYzIR9wA9cGmoJyAtLBMYhwWVpoI+wMsAbsg8MSeyE0jmZsYcQvuYujhXoEQqIGtS8g4LA8DCRsCLuDy6ImgJmQcIQtiDhyFvzCYQu8hykBtGHZNpZEuOARBBNOA3UGRwBfAVxMy3Bc4DozkRWteqGqAvIBYIx2wDXwF68JSsuZDJECfyDVPJnGbsATrhFmY2dGjTIWsVKAgaRdqRArFZ1oNAMMJjKBamD81gAgBggS6gZRhzlD8CGywcymUygavoQ4R1QDaFO83MGkeUgnzBXBnnKpQwJHw85F+yBwWHBLmFAVvIQHhyViDaF+aI941sAwnBTGDdUlcEGEkMQgVGpsHY4nE1crCgOGxhSB3BDADAhIQTUQpcySAnZG+amsAL4yWOipbAd8DeiGW5hUIOEQ8DA87BNHUdkFgyUgY1YFfFDMQARStUIa9U-jgB0wWLDpyGDLTpAkJg91C7QC6AEXEfIwO1RqhC8j14+PA3eygVIg3c4ZyGkQFB+KUg68wTCAJkBH9u-QDIAyKhwXxNohXWNLIJ5AhJgQonkUEugPq6NRonXQKoDRMDsOOzoFNAPFprQQb2DugISZNlkifwKgi6cBLoOgYBXAExRxYio2OosOWUKLAzvhe4hmwgXoZrQH6AEBBP2CU6FfwGjoDZgkEB-zCUCEAKLUkSWECZArJhrRKsgGBUdSwkFBeRDhID4UHGZTsgNhx6ZjDXGj7PTAQbgRzAPIAuSBV4OPIYZRkzpCOB5ZiggG0YDIgFpAo-zayiq9urWC+Y13pOIAvhEkApWkemYKdAkxypm1rTEE0AJJDYBioC4QAEgKwcDWQUgAgYBNyWEwKl6ELAk1j5yJNKEdfKLwEJQue4kORUxIYTNoWULgfhAPqQo2BCQBCnacWIiAUOAE+I0xDcwCCQlOhREKg5TX4fk4ZqRT0gx4AMzEHJITovaxa+R6ZihJW1lOVsE2QmDskuCVgFcEEvqTWgLPtWczubBPENMINYgdUkhoAviFLYDKmMws3WJqLDH4AbCJOoGiCo85WYlp+i+0JDcEDIbsBEQJVNFrUSlGKFAD3hDKEL9zXgP1QIDymN5VsBWphcQP64ciGHGgspII6Fp5igITHwzDg7CC6yhzANqwbOJ0VoXJjXqnSKOZAeogTpVqrzn0DKovQAXWAzFh4TKjahZwHVANMA7iJfCABiwyyVtmGXA34SeyDsZD1nooUQ9g2JJ-4jWxm5wDBVIyYhUAVQjsyk6eqrQagUN1kwNDTGEJYF7wS8gpeRD3KWgV48ijWOJA-yAH4AlLlqVgKUabOP0iSADD-DJiKBAFqQUsB-zBKYCMmF3QDgBBVBmcAYpBkgMEk30grhMAICYDEDYFTAl8YvVg3ex6AiqOnsgQnu7ThPeA2eIb2JXAeWgAyAZCAMdFVEO0ADOIfKBngguwDDVE0BG4aYuQBoD7AiesMPaK8wgWQDUB5wGsVN5uT0R9KZUpyWhW0sEYkF2A359k8jLrWBURUgSNAMJsdgC5QCqYNpAH6Ae7ps0B0VDr6BFkvkEjuBYARoAErSYuKUDQosBe0r20AysEN8VJoy2ScwRI6WVvJHIs+sVrRasDE5M-8HpwJPKJsh8ECqJGUEG8TVAg94JH2A7VGMipyYf8AlaR12CtMDCSBcWSiAJxB6+DSqCsSZxQBzgMaTekIBUnhoAa-UpA1sZ2kBx4FIAHHYTqQwMhITBd8GvaFJAD-svcIpmAgbGYqlYUTnAV6gmuB-K1ekPtQQKgINAJMn04EDSEaoK1oQDAakjDoAjcirwI7UkOi1mjgaET4P44A3QPihWbCESHFADNgOsyyqsKgBUeRSieemV0JuuT8GBigEqwFWATggmUSfxCoIDHsMaYDDkeUBi6AAoGN8CM6YbJlQEPdBnwGqQD-APQgE4hwVyrNgTYAMwCHJksA7CAIJLEAIRoa7AGJ1sMC9IGGEPc4GMs4GgDrYW0GOiNMgcVJgkB+ODkzGjTCagLuAvaAVSwqQBHiXagaZgzCwxOhOoGhwAmYVZM08R+rACAGu6KeGPd0izZx5hseD1YK2AAgQkHA88xKwGgbnD-Wt8fzAuAyKFEOcDIUCzYDgodTBcehCwM2oQf8vmAiDCsxJugFNIc+AB-Cs2h9lTE7AmAeJJZHgocCSlV5IEYkVBCCQA+VqBMCiQGqwLdYOOBZVBJ7DHgC2APVArGBeEjEcOjxEAgdIoHvAJaDZoBCwGGqXpyjyhNuAWcAR2OBQdJCjCg8dYEkDVVJpjbGwE8FUayf6A1cItwCbAf0AAuF2NFSnFNAD7wU+hCyAQEBW4JecXsgvx4u-A8I3tQD95GzgD3h+igqFS8WAVCalJUMAnDA7VGEgNvYDCQm2A4CjBJAVgBOyJKgW7gZYK7kCI4utAPLBENBXijTGGQoGvwLdAhrpBVLhpVc7IGoc4Yw9FDuBsFHq4I20DcsPWgFoBUxOkXPWwcdq5fQpsnkHh7sGvAcoAHfQIFoCQDphokAACA2HtdOB5-lsdKtILT0BJB0+4FQFicJfDUngQYg0wQkaGWIBK4Klw2igcEiFoFJkAkcY9AFhEfox5eFwgPYZLKAKjBblj40huqHTTCMyqeBoXCYMKOwAHADvJYlAdMBQl26CNUoDXQdOS62BX9G1gNWAXwgQ1xzhggbCtgDSwt-JCYRqTDtOgpIC0wS6geOAG8ARkFYYKl6WqIa6QzSAYmA+knaQcdAMeAJsAiVA2CK6FY18E3BX4BSkDuiJRAM9AVOtQ74fwEhfIvsDqgoqQRRiHxCOQANIDeJ5RB4MAbuA7yXXaCvmjnU+FBXmErwBjQU8QDugkgwqQD3UF7CWDYXcxOKC9gC+uIrAewIRaMyCYpFLk4Gt8OBA6ro6jweSNhNAggaUR-YBxCDDkjmIJAQLjQdlA5wTdBEV4DnAbWA8xA3GhuAVK8LqcCyGoMxhdamrnHWLlGBnqaSVMlRE8C64CcU2KAFsC2loS4FPoPm6GfwRUgE4h5swmwN5wZh8gqh7cDYYBkKAOga2M+xBvRDrcGvWB1IE6EdqByiC4gL0LGMUazQPeAY0ia8EJ4DbE55grjACUAYgHVYFBEFGgunAzRyhvGXUAGEKgpXfADdhRyFUuDbkHLwtSILNhtGGSoIrwOwUGzBQ2CiWG3aGiMbLQ5XQ8qBJjjhuFGgcFgH+AvoIwUHxuETIcwQSR8cWj18CcqPo0WAEikBetDpmEOQMWwOQADclciQXHDUYA5mSvAsDBPZBjgGpvgcoRHI2JReajJUBbAJQgUUYPhBuJATJIFXFZMAugpkJIzyfYBygBIgTxI7kAXG4NgBYgKKMJsAhG8VmbwYBa0P3wc5gkbgdUB1wEg4M-MTxWF7CpdQ3sE88F8uYaoHk4g0BPn1nhMaTHuwxqA35BVbx+gOdAS2AjCgdIlmpOEhvLwMgujxlkMC9cE6WEkAVdAifB9DhboWyYFrwerggWRGMRpwFSgGpIUiAu0RkhCp8mBVnJwN-608B9AChwDEhIQSXowlnxI7gRwGNINlAe-gmohSkALaCXALNhVJQpaQtoyxQEbuK6bVTgcgAnnB6QH-FhKIBxgKyR2iCbwx1cCzAB1AXghd1xoiENiGzMUSws8AfSCuxkUsOOgVCQI9wpvB04GjTNMGN8hvp41kzO9EOcEj4AOAaZTfSDN4A7yQsgMogCSUOsRIyAgMBfwbVAlbs3iCepmVwNKuDKoj4cd2ARcF5wNRCXVK56YjO5T4BM0CQAAIQbsAm7BHQAMQCgQH+ASBAxcAMEBbAB7QbHQxfY0RiXYC1wG4gQow56g6+g-H2lXAAQFZIoiQs8ld4nH9DELIvMLvg1GBrIHVQPniVIgG6h7Ahi0gmEOUgW-IayB4GCqMFvyJTIXvJXqBLIm0xDbjMdgczII6AU9hQ7hQINSARz06TA7MEoIVh4LO6Db0IyQE8nspXlzA1gV5A12QVuAHKDbRG-AQdASY42P7ybGkiDTkd-Jj5BwdD1YCiwKleaAAlAgCEB3YiO0tkIFswa8ZoIA4wGOqDR4CbAx9hnXCBoDCgFVkBPJIa4PYS6yXWQNtAdAw+gANUBEeB60FNeI8pj-BP6DIlJmwB-wJ7Ab8hWSB7IGVop06TkYwkYYyCCAnYhqLUf8A+cBpEB-MDFyjVKHKA4libciAzES5iGCUaQ-OgkCwIRmCAHCDZIQsA0i+gQSAmwAjqVpga61L+DtQBmQIGwNKGUrFTORIIA1cN7ZLyAVqAFVoDHn7KYAQAaAlyBhNDvgHJENX0D-WgEBvCARoA2YN9AG7AbLApAAMuzGKb-wZ0KoP4etAFQAtzBLAGO2xSBgbqpUCJpCugRQoXMBRkBjwEqwJMgH6A+0BSBAwNF3XItwciECMBK0hDUFrwObBA-cIlhNUKQIDJSHHQU7A+ygA0AdlI69DHQVA+EVQZCkRwCxEITkYjwCyBoCCYXDXYPxY25gUXReRDQwC9YMEkfEa8NABUSBNzDYANkTWssZNCDDpFE7IN3QTSA0YgayxLqG-sctAKmkDYAQtA4QiUoPngC3MUMBLGCWOBlwFLsSl0jgheRDylC3gCmgVUgl7Q8AIuICcYD1mQ8YfqRfYAqrgdxlVBfGAf5S1pBUkEvIgxAIuAKa9rVEEqFcECAQMjmLzAvYTr1X3wH-AKcwyEDx8m9SDb8LjgBCAFQgW8DYlGVcCgQMzYKmh2gALsDMmCoWIuyOTh-IlfeDSQJ2gIBc-VA82AeICtFLvIApA25AaIC3wAgYETIFkUy0BWIDFQ22FlvADHRljhmcD4Ri4pBpgagpc+BbbGRuAvCXnQV9o15ITJDLQCvXsxmWb6tfjiUZidgbAOehTjYwVTQnwO8EjNIvsLfgV0BCDBWtAmoJP4ajgymAZeCpQFhjo5YGkQEDA+eGXwBhVDo5FsAJUBEwn0wHG8FeGODACGAAEnKuFEsIuKeRQJkBzPhKUDMkN+EhHALYho3gn0FUYP5YWyo-pRYkBzOURYi6sTCkAQgKDhVn0qwI9ADUskRAZCjrmHR+BLQLdAIyYBXyxOEfavQgBM4RiQccBhfEewPD4DCQlEJymAycFz3AMwBaAqEQ+uSIkkwKcNcIypmMZPsCQlMaDP4wY6I9Mg8OwiuCOiMNAcSAeE48FZy6P7AAn8eN0RbB2PQQ4CagHwGEVchKxwBjDEEjQNbcZuAwSxzVCSsFYYGp1UY4WqTCEB51Ngad4sU5QjaAqSDylHY9NXAJY+bHgmiK3vXlRN00BeAmYAGYCaLAH2NIEmeASmZjBB+QFDgFSwERw9Ex5IpUUBmoPLUGTQbHh255EuDhgPNAX84JuBIhCXlXcICQAR7wdWJBkgggm0sF9uTigSyB+QBxnHy2OyoE3hcrprspjPXAoIDIDqQbcgQ6FXQBTyNnQg9AyuhOW7wABR2HWAZNQL5gr0C5UHcwG3xZaA+UBvbKaJhr8CbgTUcCFg79B5GDPAG7gNJpkbhU0C0JAU0WUveAoPHosHD9QDVACioEiAtiBH9AtgA9xEczFgo+MB-6ry5M97JkQKmMys0h+itum9EFDGabARIgUiloih9EP00lyQ79BtEApTkxjFDARxmUUA4bArMwbABhQbB4ROxrsAyNIIxnWUotguWBSBjNVKiWM8we3AUpAZUBYYGtBOuwLRJuFBgiDghCuDICgS2AGUQhEADYCbsEn4EWAXvxD8DCTzfgEsYiuA5EBuMQCVgoyjGuXU4wiIR2DZ4Ehrg5mdmonBgHto1-F-OLokAwgS2ZVIAklguQOsyYlgxjBO0CA0PHgGCwdwA3ZoYBAwNBygLVEfGAsgA7LC3QCxXGV2XhAf9TgmAiwG1IE9wNEQQXEJYCPVlukeJkbxwCeSnKjHygaoIhYM++TzhtsDW4CCULwwFdALvAujjj6LU8A5CCYy0yAtQCFGFygIv4JcYk8Bw6AurDjsFgAyxcmdp4-hdAAkooRCEApaeAEeDCYFnQPKUfBAVTRIBL3SmEWNw+YiR2tBW0SMEiYiZqBJ6gFVRnGyGxD4gAtjLCp2qwJlAFEB7gEnAYJxX-hosACIEZgJnAQtU08ZX8CupiQNKlALNocJBgnyaIC0hPTU0sA9Eh5iCpQHCWOcMJqA7uAHbBeIjldLUYbMQ2KBb8ik5H8sM5ktHg3tQcmD-0B96LuRGhC4xh3imI5jXdFTGU6IzyBE+C3FOi4BW0mv0uJA-oBY6A2qUhADAQZKRSKB6Rl9zF6KDiobUB40CGxGngCZgN1QvEBzFgf+HgwGyYRfAIK4QgihkDyOORAV8EAlYxcQhUHWrMdIHZAMCBXKkfwk-AFuEDVAg0Bb2JYggSgFgyEtynCccmCAkCHABo0ysASdpJrA4QEUsL0YY844UAe0CWRPj6AasF8QdjRb2nHclZoFFgStBwrTJiADXGFaTrAcvQFix8KDheAI5FTGXBUn80GeZIjCmKIpAKykMMweGkqSDZ4FZAUXgvyAzGB2fgQ6UdgI-Qo2o94QcWDIiKhIgPw-jAdTQ15CnKBGgCkqqXAvbCr9TbwNXgV1sEyBj-BgwFYQPNgcUGPQVwoDOmHmADs4S0CA7lxbC8pPXMNuACGpkpBOwAr7XlSIDEFGwtpR3IiPwCqATmAajpAYZ-CBtwHUaWRcFWJ02AmrgtJXP0B92VhQF+lRZCgdKlIHIYIyii4RBVJugLUQDGoNwg0aAVMDvDh24LqgZhwuHRbODlCC1wJFYD70ORAC8CetNBkCCU2aG7hBKsAEIFXAHqIeZMlKZVMzIBiEBNhQaZsX2hkUBkDUtWlLAMTAavp20niVEFqWIAMIQ1IggYChMBWEpjgX6YEigPvT0YFIKRYsK3MisA7YCCz3FibQ5WzgfqRDYBFFXtQAkAEFglAoosAgsEG4LnUcdYmLlUoD0kENQFHoLVYv8AbwD75xx8IFQDqq5K9goSLqHPgPbwNCAiqAN1p5xmh8Cb3HJArChTGBnEBJiFbAIBARHJvnCmcDavOgAJU8L4h1vSnMDVTJG4QKgYOAsiDJRjvbC1gdxglDgOpC6nDJgPGgBa0VHBRwDe1Fw+idMGbAiIE3IAQqDPQJ2FAaQLfoxqKLsHToIcINNQPOBl1Ar2DygMeGU8gnP4khxjpyaTh8QLQgSLgLyhfLmToMeABvg1uAOKjGoEbgNZka9owHjyqBv0N7uJ6EanAvlgyZjgUGnQLVAeiAKtATezu0CkOO5sIiolWBe0B+MxygWToLQQvgtLl4kMCagDu0JlAY0BxqCrkR6qBHmcdcGXoEwDB5Dh6Sggb6QixVT8CgVBajpgQJHww6BMSA0lAwcDnAHQo65gQokNUDqMMiOG3xoTAPiAXdKZ8OBQMNJGixjXQfwm9gB7CfxADZV6GCYyxfEPkCJXArE4IpDYCCywO5QH9gi9hEykCiCXGI9sBWSF-BAKCQsDNQF20h0gGsYAkAN+jXYNGmU4APxAymn2oG6SJArS5YELE2sDB1IRoOnwf545RAUIB9NKKRHEoQBe7jQR0CIimhLJW4bqYeqTF0CnoCWaa2iKHU0zZuAh4QizIDSkT6gtQFCyBtJPRphKQHBIYVdQckCsjYybCEFtgfYBI2CYAk-YTCAGoQTZBOOpnCFhCNDxCNAYQVtjBhwxUKd-CfyhPSUoZBZBBRWPnQD567WCp4AWEAmkECmHsw7wSsUyNQGpwGqmGv0iZBjBCmGQwZDZwIoCvh1qoBDdI0OBsEXKAGuBrVRp+kW3MeAaOgwaiiMnJJgMEIHpejoM4hdMjawBxwOzuP6I81AURTGkHzyhfMP5RBuhB8hEoCnCeCeNV4NuRtECkIA-4IhAGugVRB-fxvwFIABxPCJQGVRKwgHiXCpN0MfgsVMgxsi4dlY-HvABuCeGTeBjQ+FSYJPAB04COAy+B-eL5BE3YJQpNhhE6kH2AX9MFkM24lah5UmYXAGuKYIceAsNhn0lW4BNkBfeOOA7iNfcwqUHTqANoU6BsHTCECaXFdDOA1CeSLEDWMCL8AJYGlgIBAZEBypAreAdOOS8KTAk6Ahoiw2G-IAbAeiQhQhHVDNdM36eBQU-g9DS4IwtRlIQAKyOmAF8AJDDItNzAHQIBf0eRwoYCMQEJyGjfaVQKdBT4QaQEC6RRCAcw9MhgEhksFjwEoM+eMr4B5Tiw4hhUPwwVrKzwRc3BmdFU4H80BsAEwCkBnrmCgMFTbT744lBc4yEEifQFosa6yO6I3axY2X3zrsHJ8gCaBaekDXCkwE8wMmAFws8qLaQBdaFusb6gZ6YoYBcoAmyE8JM2qiKB-uCV+BN+Ih0megzbtF7DUWHR8J+kf4gC4AnGn+lEpgObUpqQzcIXUicbSG1Mq1Jww80BS+BxgD8gPwwQqMl0AKUDUJBfCKNMRlcdI8TiC+IDjCdGcERQp9BukipyCcYHPgVmwE0A-6BUQH6EEImMnwt3TllE8pPR8Jmw970kfANYyYAkKYLjIWxI3iYRan0kD+Zk3YXowILF43gM6CcMHfwXZgvqBqVCpKFzXNxyHQIL6V2gALDLSzH-gTTgcGNVUAewGt4Mf4IaADBBSchAIDv4Av6bUg9CAmdB-cH+SVAQUucjKBICCoxiD0s8gNpAosxNV5pYClgIQ4B9MgEg7Ilg4C89k-aKsQ-1dX0DTRNAoWCANY4Ijhj5reEHiZuhgMmgayB99BTFJGTE2IYEZlsAv7jf4CcgITQamCc8STCAxsUXYLrgdJAbeAwuBkxBjwbu6ftgpj43Cg7gD8gNAQG5AI7Vx8mhnWmQJmwCTAYMAglBtYFMoM1KDOQtHxoLDynE9kT3GRkERlBdaD+uDxgGCAPGETdgIDB3qF8TJJwSCAAhIIEnEwHj0I+EyEAWdRHtjRmDMQQPYauAmLjCEDsADI0BpPaGw-UTD4AI6G1eGgQVGI3zTKhBxCDTUP-ISgAkzpUvRCAmSQDOgPQwevBLABJGmxYMFkPQAI1YjEyuJiJkLwwATo8thRDFzoD3oLlgXPpouJFwya0GO6LslMDm9sBc6BT5BdAoVWcfQbSAMgAomIyimu6SZkQy1LsCIkGP8DtYMhw9EhbTCVgF1oO5APmAUuh0kC+Y3eyd4QT6Q0DNK3DoUEhABVAOywoTBYpBRUCbBPjAFHYHyAHyD7oDNSUGgSQoOaATxCo0j60E60jNQaIggfDzxJZwLPgRDk3ABd5CVhFPorwgIy07hBw8AhQEqiOSoXoweoQYhl-cEXsCJ4Dv6MLAdoAByBOlNKkBWxE8ANYhUjxLWAv6CAwmgyskjotAG0EZAaWQjqhrxDlwB4tO40TIgrYA8GqeGGvoIVQTkYqZ44MAJkHVjKlAb2ob9QDOEhYAdeDLAGZQkTgRFCKWAP4CFQVvI3ggtIAFEAN0PH0cKYNOQzCBKbTggIqwIogbhBiqxfMH5MO40alITagEvKT8A7yOUACYZiCT8FBcDPIaG08QaACNAvYQoCHfwFKgOe6OYBfDg7WBwqYLdaM4YlBzHgvQCIQGrYQ6MsJpfIRbgG0gL0YE+m79Zm1xq4COBkC0aGJaIhlvgkEDrULACEBo8qJfpjNAHnIpkQPjREVpS0ivbUs+Hg8dTp+CAwBhJjE-0A6QHJJB4khtSg8D9adfQXbgWXQgOgaMEdcGW0GoofMTEYC7ABxaWlEj5MRLgIiSUwglgDUUDdQDZRjj5fZE1zjSkJ1AwSRKoigfhl3C9EoVUkVQR1C-QHSWJTCSRYdeJnTDkYBUUC+EVvw14QEtZasFuMKUGcSxuYAvRRTlHuRAeAD2gg7JUhzIYMTQJDwZqIGaAdPT6OyYjB4gRKA1CC1KAcoFmaVGkwmwGZ5bLbnqFwqISMqyAN9QNaDeJgCQLnAOm6pEB2mCNMBhSJ7gKpo0yh0zDKYXKoPX0uagUGpBhYtTMIcIkwCtp5RY-OY92D1PM7Im3IaOwP+B7kCKUErEMwgFMh8PgI4Fb0K1lTSiWkVs6AFDJGif2U8dYptxGUCMwBgafDsTBAw4hESDwMHNWCTlGv4fKAP6mcUCtwArSMBgeUByYlmwnPGT44RFA8kd5QKE0A9sAwmXnAuKAq9CQlFPwOaGbwg5fQywArbD8wCUMlsQ2AhOal1OLmmc1CJug3tB1vQycATuKQgaqgORBoWBMoGGQC3IW0of5AoPyIdIq8VS+OJaBKA-mjlgHIwOh8CEYpFh7CgL7xGSBuAWnpMnAImCdwVpIDu0EvcCOozmRMNEx0EXACA0xFBSBiMME6wF1QD4ENHhW1DRMHuic1EdpgoyF+qiYXA9xGh0hqgTPhCyDOKXuoEa9ErwXHpBHBmMHMeM3AaLpqoB5sCiIErsOvAUgAGKEQQRczDaSXuoUFaHQox4CbtU4MIiQcFhQ3hLNi+IEBercICU+KXAtEmIWBkkKk7OtwohBwMAwVHRIHwoXNQTdg1GDWtOp0Hm+ZYw-zxUyTtVPl8BiAK2AvEA4iCm8Fc6NeIJHwHOsKvBPCWfADUIBMMT4B3aB5US4mK4ILBImnBvpzJICbPLVEdMIFShYIyh4FUgAqmVbAtB4IkB05DScJwYJ7A3FI5smIWGsYNT2LRA1F8E4DS5UOicZYVSZdJiCbwr2FLccyqVlg9RpM3JNKEWQNX8SVQRKBHZ6J7A9oCPkgAgCghE8CjYH7EKIkBqyhEgQoAJBJRQP-UKjU7idMAQI0C3Gei4Shw2UBoHjBMC9hNRqMnQXHiU2lUBiRQHOIK6AZKQhGAK+DJxC7EBVMWfA80A5mJUyOC-DQQ2LhhxDbQEIJJTCSdQzfBcomQ2KUrP5YMnE+fIcEhydKIQMAWDKwLQY5KlSxAcYMQUgGpovAM0DuGB9ENIgNiITlAlmBURGIgMkUGpcWrRr6BrSBYKKhEfhg8DA9CA1IihgMdAG2JSnktyAJxiL2oIAa6QI7BMYgjjFVoAuEYvwUkISYjJBPaZKDxFsQuJwUvQeIDeYOwHP+gTLhC5kqcBhqTPAKWASRShxCDhRs0E-wDAwzMSt4Q-fz10BVAHWZIyxPZC6oglTriOYiAIQoqQGmKELKPTEPbQxNQ3EA4k3ksKIkB2wXcBe8S1+F70MQgfdxfVhdVGtHlAcJYkdygWBBKT5BUB9IpVmerQHzhwKktaB3Au40HbIfEhCNCY-FFUlwMlVogfo0AD1cF1Gh0aGYQ2ChbuCeAG+kKeINP0mtBLjxa8FN4EX0X7BFxxbfEqhKd+Fe8c1Ak7BYdCl8BdcKkNTugKlAhlgmkDngDJQVfw02Rkih2LCTHLBtbfmetJ7ihzQE4iJ4sr3Aa0UHEBNXHJUB7iMQgk6AKkDH6AEKa5sQjRUtBRnjLQFWgo7A55AlDBhDwCrg9oD6IfogGzB-eCNBLPgDZAeSw5FAc6D43FW6ZuWFmE1cB1UAXMDEoETwAGAsDAFCDJiFg3KBoHBIF6BELCTbGUEMymFiQFjBzaCSSAGkP9BMxgAHw8QYjmLXdLOxYf4tfhEgDBQFTgCoIA3ohgghxCg43d2JGgeNmNmhoWCBWP62JKgmfIGJJI5EEdkqzJMQMxAfOB4iAcviioAYCE6Y4OAe1AS8G4AHRgQeR8GAxHCgaFimXeQW7Qw3cONBLeNuMFp3PGQO1cV0yDYTCYBnOSNwEjBcs6DeUvStzgq6Y1LQXzCaiHtoB1BHi0s9CtCAuzOAUNRgKCAinB5pa+HCFFqKgcIQCyk9LTHkE7qX4klvAstSScDNVOLJAEEhGEXzB6DYZ8GD-h6Ua6QCsAOOn1sFVcHVAO7AdHxLGElRHWgGoAV0wceUCehHIG5RPhQbNUfrJZ6BrCWX6S+EGygzYBosBztkGlKAwTJwSDB4ZmgtkBmMrLUVZgL0kcAsSB84A9oV+8E4hnslUUDJ0Cl4dzY9lldgC0U2NkMCMjegEiYA16nYC0SF2PNX2izh1YAmmKpwPUoCRQkOcVQAwNJUgILQaRgxjQMqhtICM2ECmfMgraAPECEsDqCDhjOMZ7GS2sREFkJcme7bBQYQzadrjgA+pNJAlRgp8h7ICEOHkwCUgVIsldhIsBT5ESwJ-AdoxZ7tfTxIRXh2Maha0gv+B5TgfcIoNC+ALfgd5BN4iiWC+VOqbBIAi3jEsDsYF3wn6yT2ZucY-gxpZnhiCeoaEQe8gvoBt4HFgJxQX4oRiT8tg3EG5YcJgHeAKqzboBhIBNAC0AIpA8mxzVCqiCegPtw7kG6s0OpkPOFLmfPyO2Ac4g2-xQai4EGGErRAfMM9wHbRgvQC-UeWgcFhoCCNhNYUPhMvbp9jAI0karJaACJgSyQrvBgh7kJMqlhmoT+klOgr1lUcE2QBCwTtodazriA3hlb9NToBMwfrIgUx2gWWIGdQZ+AdAQfNCxEEqKJeIRVQSsAlMAKEDnGZFgcNpCjw30ntGO5IHd3JHqIsAV0w0DDLgF4szbolZBd2J2HkNgB2sKnA2rj9dhalED2hSQDdQLYh-qgnpKauF8gZmIaBAXwBowxoYFZwTNggeRejCOdPIggA8PQQAXhNVnYbP6mPdAG0ZQCxx5DWaBrAEgsIvmaggShjwMAw2F1QWpxgYQNqpW0DfAMmACWAwghYVglYF+KOr3RpA+9AUNlsqmuSBAgXNMXOpG1q8kD4kMJkgD4QpAcJaqgBDGIMYNnUucA31A15BPYM-MUPoFSA15DmZgHhCGGS4QYGzh-RhhO6CJw6BOZxbBzqBQ6msAEuwFVAGMzGgx21RFQNmqE0QGMYtyDTmHicKfQHtQK0zK1B05HK2RBsupAdA8FUDOnVpmrNAajgdOQ-YAYCH3wD9GRWADOwCwbBAGuwAN0xy6JZBa86XwBzwLOlUU0L+NKYQ24DVTEw0TtAAP59uB-MD3kCeICCIGcgvCovsClQGC0UNgQ3gZYD1sDvgIuoaYI7+BvWAV2k1oAPCMTAdTsCxC3cHZjBKBNjZk4BTEm2wGosCqEhJpllULEDKqyr0e+YoyRE9B31nCbNHLM3udEQbvJ4gS6wCw5FVkWKAwQJ8ICrVwN6A3YX08U9gGgwCwin0YS5c1Q3sZRtR1zFCQFwIGXgkThFIBYxBfEPZspuAsEZFIC1iFQQHigGZZnqgnDAVFPTqPxCO6Ap-BXXAJkF6sH1EEHWTUgw2BOIkS5G4gDCwhn4JkCPQGt4K0EaIgUeQ0RSUeAdwJa0V0w8oFWwRQIEOIHQIHD0CQAfUizbIn4HOCfPMh1SH+6lfGxmN3SWvAV1BXcDaFkd4JtgK8ROaosvJ5LPXDPvSJq46fBciRhpF77DMQhfAhaw6IRUanUwIsvHMxxaIq7Be-EO4KTQE8AN30EzhqNHovPOALJqVGA0GCxtWvkevoPGo9XANYjgUCUzFxtZJAk6BZdDjHCiWFVycWwHGhAtDbpCH8I+TFyQIzBzwLPgBH4Lf9DRgZUAm1AEoD0MsBUSfQXCdijD8CFMkNAIGEAYjBIYBvgFYwDE5DeKGhplpAwQDcaHxgebAAuAwYjrgAPupwQCmQfWRWJphJEvMMOARnQ+ChQHaLhCXiSaETOYK0km7DpdLbATOAfniVkCfGzjgG0sDWobVA-B49WRLeObgO2Ik0AWwt+7D+tIE5IdwYYQaZo9gA6cF5EDkQdvGiaAnuDZokKUKSyHzZiPYyEih7G9gO3jAmgFnkuAB5SF9QE9QHewVmliKC7wF7QMOLRUoRTweJByIAsht-CO-Q1jtu8C8Ni3yJ5vQ8uwFAOVAiSTXYAMwc00HxJJ0BpoAy9DmAEJQ9k4mnS00EQgL7mKIQ3Aoz2QyyGSKDYYO+8lsgICA1JCtFL0qcJ+5alrsBagFhuuIM-2QviBZ6AEaEfEG1QZxAtRhkoBA3AgYAUQNXcteAr+jj+hsAKGwDCgWBAtLi3hUfBMqnbBQ22AcdKu4E7QBbmUrwg0BsawgtLEAC3IUegpnAE7g+ZDhBhpAJq4dqSNSjnKAJ3MAgImk60B0kBfVIkEGDwr1gPsQ8Zx1YmsVDDwfqg-NRsMFnyEfYDRAFNAlyhWQZcZgitNcgVvIZzAG9Dbsy7ULd4dPcm9R8jAIhw6QJ-IHaAoiFReAMxGqQCywRgk5YYtYTVqndoMqgfkAEShaBYaMD2oNQQDpgUJJEEB-BiVKQfCQqgSSgyeAM6A7yVi44hpbKBmWRwwCSHGfkNOQEEgT6ABzmcRAqmQgwXyBZHHUCExriogdPgQRBQkK7RBDhCdMeeczK48mDQ4Db-sY0S1g84AgmjzkXdyInwKlxDABsIDkUCbMUQYBPQ58Y5UATSFhNCwUcwkCZgNqC1JGDgLEBEYuagJAJkAIT1pF5wfrQYlBwYnnKBr9BoQAsgryif0zoGDsCZDk+pQGMZ7SBk0AEyBrWVl21yCU5DrL1YgFkEDiwS7ZZoAvVlnygSQcdYImN84gTz2ZXCPoT1A3ttFwjI1IEgJuQd3g9QEoIBujOIILPQcCYQVBRwAmaF2pPAwL+w6Ig2GCr+GCcXcmFuAaGxj4TzKDrYH01SUAOuhnjlQ4AwibVEDCQ-v5eGzkONuMPE01GkgUBOfyHoF77nBYLFsnYB0mCfgGBEUOYAXpDMBJUCKHNY-BngPFkkWgv2EkRQQio-QYa4DnBtyCssDRSa4IJME-jgxuFnWR50PfgXWAxxVf3ROqBIMHoYKIQ2DhX4CdYBLYMFkZuStTpsBDULhsAADoJwI-DAViiZhn9-CNUTRMAPwOHzScBQYBtQEOEmmyzSkm4EPgKhIUyQkWAM8CCoE9em2s-XYsBB0-BmyGYgLPRAhKi1oAkAH5PcIBpgUtgCCAdMDtEzEoGKQMhwRYdHwCSeIHhBCoeVJblhxiARkCuDBr4cxA2XA4ujWel1EOkUHiaynozTDKuHyUGeAIbUCfo1UzuEBcspYM7P61W5CYBUcGpoHMQGnId5AkuL0JgyINDILyJsUAwWjCQBjAJQIazoO2BrxBgtDa2kOoVsAl2BITB-QHq0JDiCFgQ9jJIqZMDkIFgocroQHkPoDenO9oIVsaNAghAYpyzQCdcBxUf1ptMR3KkyLyjhN0oJyA64BxSSm0Hm7KgQKiIrHhNcBEZDOIJy45Og2WSMyBHlBjCEGVTOYSOBvenoanrYN16SgQy-oIVDjuHSsTPkXLAT7B5Kzu+HsYKygKzaoKgteBQHJLrOFSPjpTESdUBgMDBaIftHdAjAhAMAVVF+IIfEakw8wA32D19TcIKtIGXgbmTF-CdeFHUEy4J8wYmhfEjSqzcQFXxBVgmnB1PF7qAhVtYE2xgW4QCbCeRCiIGUwKHKsjoYnjvjWfWapcSM0deITNAmTDlgMigc9QxEA33CKQEpQNYyCcQNOgb0z19K3kNW0mLYMRAZJDngDjNsQwv3mnexnWDY0CHyE-7R8ElshqUl5gH3oLdPIFQkoAupg06HmgBbIJ3wwBw37ERQCrYF9cC44qxxj-4roG3QJDwXwgUWBqUgRcHKdI0EuOAM+Q72YNhDAGPxwaN4wIjvajUdzv0E6nLVYY0Aa5BfTlFxP5c8+M19BROj1SBnjHV8N+QyxAu1DlIAhmeO8T4wM3Z+UDQBWjeA2ge2g7RAdJjaz2FZrhySDgSYz3CDGwEqKBzwDSQTDAtWCZLKJ4GlAR4pJMQMaBstg3GbVgZqgEUgVwAfsHi7sR5EUEG1BNgiHjGv4t2c+2YT4yaYhFIiAii10M-gZOg-3BXIky4JpwYTQECYEql9oGloAV+QoQT1AUqirHHqemdwMz8fcg1wAg8gvSAMgQgwo8AvbBZlH53tLvHwglLoL973+IkEBgsg1hzuMNUDjrBIMMfNfhQC-Q3TkYOSHCFAgP7hXEE6gj1aBuAb2jT-00M4jLRVgGgiVkUbaIMhRjaS-4XaFJBoNhWApQLuQa4Go2RikONAn4Zwlg4QmvQIG4cuACjwPzRDhHTYJygNes6vpxwnCqEBgn7ACMksDA25AJoFcEETaPLkpWAOQBNjKpTG5KHbo0Fhe2AroF-Ocgoc3IFlhHsnw0AFwDAc2aAw0BxfhuWFm4GkgN1g+6BykB9WAFROnUasAO7Bk1DIMR8UBX9Tjk3idc9xb8BCwAYgH8ApvBASCrQCL0GjU7+E2pMErlQwG3SKxhHxQ6f9jZDCYF6gYbGPA5LmUsznDrk4RIMkS0gHioLRQ6HCrgkTaUSgoHSkMSqeAA6J8wS0Y-sFL+Cl5BlwAkZVtQEbCiPTtMmSYOFYPLgF6BtsDWDWuwPAA7qGMvAKPa+HWHsUHeNaJG0AzGB7a33QHIIQWyKmQ5xCtgndoEDSPFAoowbAC8DG3SGVoLUQf7gxYAy7i3fjqEerIZhy54CB1gjUJJCPKgaXAcnAaYkyxNZkeQwQ0SJSBfEgyIEz0QgwoMw3UBxEAeQH6ye4oTdgWkAcylQKPdvJFMU+oT+r1hicUFSQYxobiCm9BMGF8OD2oD6A4FAOQjw8magKwc9wIz5zEmD0pj14N+QWPAgKopOZdqAbsHgIIioAfhLwkNOlz3B7qGQofihs0QosBzQN6IKaW8NzRcQu2zI5llQCLgagJdqAjnJMKaNMMUWLQTiPD4nl3QK4wNJAedgqiA-Imh8HXXJCASBz+BBtWKp4WrmSygVx0DLD38B0pAfCYG5AkBqdCAPNHZEvCCCQnYBpkCzVjt8PVIGwwY2tjqS+8FngC+ISVgBlgOp7nlAtEk78enAbmSdoj8WF24O0wHzQ9apzyhDanZSp+gUMYdpBdzxQGBlbp1wejAo1yRPDzzjWiU4wSsZ6dc0+r+WCpwJ7gbFUHOFQUT1BjhBqXM+mIfFlZYYkQG3aPqwKeAbChk+CSslQ-mDEwLChJivnLYkiKCQFABwQcfAxKC93GsxNDk4i5raBqIScMEjkM0AeaMWsIEcAsIDNbDYU8hxSKR4ml2vwbYIzoBM5bEBz1BLEFoIEBAApoZgYMDCY-Ctetlk6gcbfgnKD6cLkKE5LL-w4hsqcgxVgA+O+IGvgRIwmMAmiDlYIkpOeaCUh-YDFJjJXlB0HBUTvdhLl7qAR1E-wRnwVfElLjCJCkqAfYBnQn8g+fDNoFFxMZmL649S47ajHcEHYhhYeRQAqtVYCVCGfbI+CGFqgNS6wQzhAtBjYYd+B++AXTFUizaxIiYxqMm+BX-7yyPD0PhwdRayJ4p6pDqBDhPwIbAQJGBkuBxKF+gNAAD+5QwwcpGVYA4yCKYQfCKzyTGEkYCySAE4QdisCBPUBNok5gBrgVUQ5EI-Uj3FlgYGxEKuJwCBQoB1nITIFlwT3q+bp9oK-UnuRNPIEQgWk5ebkOZhGgOE8mYQrbBHPT+MATQIRoJyEwvBruSiUAUAaCiLlIGVkShkRBSh1MEkcuudcYqKiKRAbYKXQ0FEBdBCpmp+BsZDhAG6gSqU3cD9zw-gHGcUrAMWBaEgCBK7cLnuAzKqfAxxH8Wk2Ob6gIionDB8KjeqDYiEnQQgJOtAO8nh4EV4FoIQ85LaYUQhV2HCIigIFXxycQ3Mn2OWjIkKQNWwrjAugA0oG0-qjvZcEkMByFTlkHNQMLUauEfysyiiidA2kPEQT+5C6DLMyUpkagF3oCEc9WBHwCQIHYyMEfOcAy-ALREdtnGgE8g7MAFYZ7+CgpIqQPXZV4opWA0swH8F+aH9wCdkCEohpBDDF9pHrqX8YZNQSWgVCBwkEdgeEI4SA+QAZVAxKOdE8dZT0BYoD+MEqzIggCDKkPAJBCR9GLKMuCBXRD8goSDiUHTyKLMdSAROwAEAokAKSI9QDEgIjh1wyFwB9oLPALj4Abgv-TQ4GYsL27dlQXgh8Dygok7AJcsGbseTBbICXKFg0qVmcFgxrzXnkuwHPjAmQTzwoMA8BLcUl1OGcwJiADqBjqgysE5YOSgHD0nYBmHAzdjcsOogMhgqUhPsCMMEzAExAFQQUgAZwh12mHwO0ycFQubyWcCYkEv4qVcqAQOtBINCPKHaJhSGHjJZqBP6C9oD+iLpQBhA1BBi9nLXk8AP0QbSIFtzZoaVXMLKSeFdgAraBXXBLzHYYCegDEwTLhGBCbvj1pN2aC3JtI5oABfKCMpur6DycZYhD6A0xFmgERySmMS0AavQ4GC9QKhgdj0LLy9BAzeETGWLQU+JHRAWwq7gE0WPRiFSQd5AiFCssGalMNQMX8QCA2qAxYHdBF0bB14CZAZFCyrACFricPOwxWBfCBg4Hz2qWYAwEAgSrtSf0CI5BLwTQsvJBoZC+WB8DrDYIqQZLgAPgIuB7sLnubMAJ-Br2h9jFMYN4oXQwZu5XZJN6DJIDDqLng+oxVPlqnMAgGLQTOYGkBj8HOBgEgCIoEfQQ4QxGAhCk7ACnIebQE3It4DE5LqMAKQZjkNzz1OiC5AKSBdyD90X1xlTkXnPcQKDKAawFy5tIkuQyHCGDAU6Itcg+iDC8FHUOcMIi51OhtrRobF1yoGoWegkEdyGigok2CLqIToi6Qg7ABd6A+QFeM2ugq6gEqkalEJ5H3IFuaz-YAPgwUAUzAreEPAlrxS4D1cD2gKAZYLJ4VJoWDOXETeVzqKDUEccOICd0BqvuHoVB4VkAxKAO9MnWL7M+TS81yIlAJkCEAKOiXfAMogtQBJ0GDiY1AbzE2OgMUin8BvLODoWy5XBByIS16GmUII8pOIy0ypYA4pD10NLvQKa64AZhD1cFBqA3sec5p+BioaL+H04eOsZpEDSAnwKf-HXcT4QWuQI7y5oAPiAQkEsk2MIusBmtmEEEMxK68yyQVm0JkBxCAKaLLoANWUPBJJ4v3Ot4mjgewge-JpGCVUCDoYLAMVArgVkig7gAKedRwQGICVSikT3YB-YNkQZ9aCCEcVYK7ySef8gAw5QgCbAAchlSYPkYG+ItzzfaQjJGdELwkMhgJBRuxAx4E1oODYxuATFSk4CaFn3eTILNbAmo9QUT3YBHidmc4vwCZg04CocGRYPxYbfod7TmfRS7OZ+dTwOfAqJAwZlw8HhAUNqY+MSBSbNK9gCldEeUCqskiB0-jYiDuwMoIEsg4VIi9BMVKy4EQobrASrwoWAnGCnNPZmJ34x4g7vlcID3hA8FCLgAXBs0A7cFeCcv6Ey2v4xReBH8D0wCnAdpkMMBLHnLlAmQMbIDZwhDha0m3CG76XHAB3Au61FIAoVX7YGiMA05BKBFYD5un4PG4AZ0gSpBiHmIJK1GW+I06IjpBgshPREwQCHGI8o9TAL0BTSERygB8NmoO3Qu9AFxmqOLwwGvwdQQRHBfQFBRAR4PzmUkBs0JVGnXOdtAVhQsUBrQR+CgDkKzEvToU9gfehtSig1OqXaCQ2BB4iCpMAI8AIErxEdZy5OBOjCveNRwKm8+MAL5im8D2BFdmP8SebzWoBToAFABOIXhAsOJZ3DXJARZsn+AD4JxZHGa3601QkpgTQs0qQqcgq+IdQMokmYQFmoy070xDYOjYAOCKNIhNSAleFBRJmAecgM3ZK4BMME5YNjANkwZ405WCd0AdrCWSKTAtfzdgBPcAwcJf2GZQ56hBexv2MzAC6gQAFaCAQl41WDJSPZgIQg7hAxYCfsCnFPbEItWoKJYzjAXKlgEFWclQg4BYwh-QGvaDvABtAyiBNUD24GPeUN8Mj5LKh-XCw2DnbKHQIGIrzhnIA1+EhxO+ANQZ304w8B1gntZoz0AIAlQh2fCHXJlgFogOGoIUiwcAE0B8UExzAIAzFgARn3tNb0Er6ekM5lVdEChli+QJNMLmYcwZ+lCOqFoFmbYIhQjhNx1jWakRHrhyX8QVWRuyCHnD0bChcODmvJpjwBuYVyFHjIZRJycRQ6DqsF-dKsHBgMwEAyfCVvMphGMWIQFvpAERC6ZFlgFwQKwodgBOCARSHpuZXAWCwIfyySAPIDbkHHUTmAgxZ8+CPEGMsRz85RJrmBW-AjACvgAbAYQsUiwoiD8jnewL3ILg5J-B6WAcuN4wNd+XqQB2Ba8J1y3RaOfASe5rbAR0AhKlVgKjGcJYd3ADADUIEfUNgIH3oeNZywAqBNTgIrHBVgyYBcqDeOFb+QB8Bv0jrAAHBLqCL0CzAWA0WNprYIdRn2su3gSlgo4INkbtuHakA7pS8wTdg5xJ9oC1IMYwfG4lUQjECZPicAYRobNUYxQNuDNAEZoKbDMXEerAWYBcCFXuG+4aFQveIEcD6NHF8EwwCBAwQgaHyIpEiIIqkS0YX2ghrhqSH74FDuLxYQqZSnkN6BrZEnQFFA8sAcQo51Kd+PpgWdwnZAgYDw1hFoP0WftAM-AEzClICLoN8kE8Ao0gEAgJhDnYfT-VMEC6AEoi6GFUILsfAiJ5SgquRHCDqBlkgLBS2XjF5HVIAJYOrAZwIaEgm0TYUFWeEWAZNkfJZWrmPyFtiYrAGjwI1QP+C2YGgsI4QSCOavomGDA1DHsA7+H1IXVAdUD-xJeEMVAQ88KAhpwQzkWIoPGxE15baJ7uBQnN1wHjCUvAIZkZQUiwBHYPNgQfCmmg2ZgaWEs+ETAB9g9Ch-VzzUCToPPORF5lxxZ9ImgCpkJCgVOgZfRKJJoMFyEC0gC6AmbBKWDkQhcyWLOPsA07Qc4AIMA0wJ78+Hg6dJgoCY+H4OiGGc9Qa3xYKAqsMn7HOKW7g1mRvWAnGCr3l3MakAaXAqQDXiAa6NtgTlg9WRQUR6hDBQBcgKGkM6Q-aoFEE1riXULcAelpQfw0wDgLGUwEk4CUx96DsZBlEA9QKwmb+zbTD4eSBQF1QS48xKcN1AwoB74PaQjS2j-AQ2CjRM4gN0AWKQ2GhH2CDIHBQM3TdOkkHBvgU3oGYMO1AHPA2uyWJA2QA8gC1oNqwGe83CiKwEsoCmoPVoqbl4GBU4EkHPsC3vEh8xbEAbHUDUPN4cNyzpAiUDG+gdSDt4XUQE4hxMAAwFzfC+YPOAe7gUaBB8FJoAlpMH6XUBMwCY-DBykIwfyAl1AiaTboE5oJrQYLg4kBBmA4GHaQCggCxggGBG+hYQF2+oCQOfUQqp6NI4ICGBMkgbqZAkBlryQ23b1MBAYmo9t0PcQKwBfMCRHHHwyyA0qIAg0dcJSweZJJog9+SSqEROsPUWAEl4ScqzdCAGQCfcV223FiLeni3T0tDt4XbgNYBVYly2DTgLZ6cz4sZQ6+gdwHzGfHgSvA4aBOfx3+FU8DuOGleo5AFCjp2DqcANYWEI4oVcJji+DmMOqEbcItmBq5lLMDtmkQcqAwvtIXfhywGdEFmiNwQyYLoEBUj3rQE7HCJQtywlqCB6XKIFjoasCcthACwWsH3sBESLE4B9AQ4QVIHCIPxwMNAoBAAdBtUGYcL4gSawMuBqKDOiDiIGtU3yAyOdqdAHGFysANASz4wDcDUB7UhaYIqkNGAFBoQ4R9gFuYE2AehQsBBjwAKwAtAGP0SLAmUh3MCYwEnGbPE-fi-gDEz5+pGWAvIoCgAU2JezBLHLaBmLARVIvcAK0quYH-wu8WZFQKnBjqjL0B1wNCALxYZdROoBH6CdIJM6B3QTwl7SjK5E7DDqgBmOwSQBUjXz0wmTMQcwgtgBU6CPcXy4MN4Pagx4hDwJ8uiakDWnJyoT-BflhflKsgExgRyw64APFA0iH3wHqgR8QjMwP5j+gpoYOG5DqQicQkCAuQEXzCXARwQjFgToBTmzXdIzBRlAKVB2YAnVQKIMNUOyw0iQQYBdTCRSA-VHcAXlgAkBqMGh1H6yHKgDIEjwBkEG8svLcukxzNQAmi-YBdaMEkTT4PUBqog4pGR7gcoBNAcEAtFi+kHhxCpIOoIvihTwWMWGuUJUUKWpAHwwYDOqBviOWPIqpdagPCDZfmUulNscxg4IhxLxbYD-9MlAPd4b7gboDWABu5JbsEjQYnQLEDRYCBeaa7IJo5DRdcSCYXwKjW8loAXjzjO7rWAnoL5sKWAnWAc1BeHIUNjYgaigXGgD5ko7FDYHe2GNSstwdYBawD5wB9QW+wFiAAJ6lBKAYW7AG6giRgGSLEjWDOl6Kb4gD3gc4BS-HPQMeAPWGacBkuAt4EsIAKAJygmsEzJi0nKTUhKQWIglIUQ3Bj0UABK7C6yJR+gLWAFpGgQMSNUWQcRBduCkuGQBcDUeagVaxRHzDvA70rwwP1Q1JYurFSwDCaK6gNjoOuALoCQrQBgJSubwgdlhFUgKbDj+sEkNhh4k11uDYYAQsNMYclo53AaWDqMULirveR+ANug2mBtYClQG4UEO8VdgFWAbanO4AP8pEYs7hRJSgMDA0KKWJ5Ala55pnw0EXCWZwGGArghXBDjEGjeIfQTFQDHo8uSleU3AEFCh3gnLiVMjkTwbYHdgQ05zls32CBUFCwERbXjSwIhnCRQlkmQC-AZ8gAcB5pH3ROM0Y2gEWgE3IlcCqEBKEP5YDjQplBEMBPQoloED4GmAkQgEJAw8Em2CogUGYuMkFWiHbzkgAtgFBgmyB5yCubgyIH0IKo+xGRrhIQzBiIGE0QOQYSwRlgm3F72prAyuAcyAX4Z5IOWMMXTC2QEih+DwzVLf2ZToMDQBSAkRnNQCJoJVQaQ+s9AoCATCA3UD-5Uq2DF1hETlEAU7tgcraKgHgZiBlFF4GOnSbCGqEgc5b0sB7sFtgIdIMALYQgPeHugP5xBdAxcLLQI2t2a8Qh7dUQxMA-Np60lRaLkgYxAgMxsxCJoB7QN7UJagACBzVBvyH-8E2IV4gikBJkD6wBrkCcMaIFzXoBmA95jEgOGgcCF3QwqWC1yG4xLOC6lgtUQQyA9fMf4K6YV9oSkYM8Crwr7AGKMJjAp2AEwLD1AUbFSIYSYacZZoBE0EHJBhQTFSqIDSpal+jEILg4G5ghggTNAbUGnOKMQW7QgeBEHhPCS4QKhIcGARFzr6A3MGCSHDwpPYvhwzRn98EV4PheEsgqT5csDofHcubO5Kzg7vg8O7aQFMfJTCfHKQTpumgLoDRUQYCcrATqgXUiKFBOEf2wERcAOBYdCh4BPPD1LfggATBPY6QiDmIOxCt8Sy4Jf8itQr-QHY8jmAjHoQWBvCJv4B1IMyCpiB9UCdyD8wPOgGTx58AgCCckAiUB3gKp+WwRwYgIWDvUMfGFdY-gILEnYwG-Hj70ZtANXSLiYcqCySDj4L1w+tAb3DSRHkYNi4AVIutBsIBqOH0AEmAYrg3iAFrCcMFZgNxmJ4SQBYFwjcUH9IK9QSrMf20AqT8HlWwMFkG8AAiB06SqmjdQHmwIBFukBShL8MDLLFSwa2Ir8ACmhMGEtkInwCtAzpAq0BzUHomC3kfyQBvQh4CzcAMsJgwJtQUkBXkAtwBv4BZuY-wCyBv-AS8Es+e9QTJgVacDBlLHLUEFxoAWAa2BSIDUmBFoL7EOOgOlIbkDWxBYQPUwO-4LPwvTD50GP8IlaK4Mw+oc1B-EJ7QDagJp0yrgZrCK1xwMJHCcHAX0B-uCdaxpyDggFIIYqKeLR1mHBCJEgJJyFeAqIjG0AP4IfAFPA9hQikDRIHMFohgBF+DZBhea+eL1YAzofdQjoSUdgN+gI9PAUMAkbVAU4BVLCLgCuge3MiKRvjLLglcwJoWQhBKQhJ2A3XLOoAv6TmAXyBhaKmcCKTG1wBtQkmw6ybYQDjPlbQQdgZQChxDGKHRApLI9SAfzAoZzXwoOUIfgQxA-1Qv7CN8ELYWI4Uy21yQyHAPeCGuOV0B0wp4A5Zw25DChHjCfLQNiLN35j3ASAKO0aDwOpwD7AE9ClnFkigusCUQj4B9BBULKWkErwqEQ0oBYnE6YPzoR1QzjZdzT9kHsKMTAIa4rDAc6BiZJp2O8gaaA5qAPIABNAkTLF0UgQhyDwkDgsB1wM2TNiAT5hnRAwKFG6BTc-38KggeyIUoEhEPDoUNmEiY52gArFmgFx8CCIFMB3qYtdEjoCvo2+w4FpwiApuNssg3oeHQbdhzzCnMMycDAwdZkCQA+x7ewDwEDJwa8Q5QgXrCVom7pGlVdnQo5AH9QDovCeLcbPrQefl6FDWVA18AiEYGyx+xfTykDDo+NSUXqAawSRIDJeHjgF1QJgRRKAV+A6JCZ8BuWaZgFiA7KCokExIfweEY4KagpFgVDQX6ZDk6gUF1AnyTz0UhYO1gd2gr74foAIFkaYFEwSpkOEIjKb7KDcQNJC8BwUQhf8DuNFikOVhZBQkGAt8hyFHSulq7elgyuQXFHvWLWgjZ8x2EbjASuDgoGmuSZMGEgC-oJgg3oGNMAcYP2S-cK9xByADMgFPmXHAOJxRpBy0Bs4ALAPQw29TJVDP1y+oHvQKeFFBovLyHAr4ACVwKW4ROxNPiz0HsSFIsQhBIgZClAhxncEJsTTAgO9g75RKklqQDlTDdQLvAAcA5UHUjKzYMSYW8BMsHpaG8UI7IATQ8mxs8DSIk9nI1AM12qOAh6hGIEKEOpIU8QkQp3ehyQELBIG1LBIr1ACcaZzH6sNYqNZMxrpRUDlsDzQL6gIBgk4BbMCbdEhqUVgavgQz4o3nswHpZDhCQjQAHxvYC00CqDE5gIYYR0Ai+jaWEeKc5AULQZB5T3jyOFLMHRAZOAPysD-pRTyBWMdUHJgi3zaPxiAF5IC0AUiJ9TBP5C2XloDMvAaVIpQYxOQEnKhgPyAGkQsFzDur+YHFsDhoCaQkJhAkz4cCMmJHCGYQowYziCohJBoFYhPjs4CAp0CFlEwIH2MDRg2Yx94UvVgHlgAoaupdQRzxaXKHCiSJ4fqa5qBxpS8EhRXrehTxA0ZgvmBUVGcxHdwGoIp0BF7Dc5jWAA6wIcgr1A+rC7GjSyMFkLygXbYp4BplH2RvUwAxg7ULJyAA6FBirdwGzh8hgQ4QJkGS4C0AAsoMPBQujToGlSCZQIaQhOQr6BPkG9kENcf08V6gTJShaAGPJQwSmwF8AqcjLAQuSLAQQJAm7AEQYVxAzHPlATbg2lAxIB+RjDVPo0CEs0EgHsDu+QLIHcCAeEbKB4mCrQDDgFZwGZQmF5sbC7MH8gP0aefACGBWwRDKVhxI3yU+gUBBX4BrHDwEMvAf7xe1QJ9T3mwlgCiQU2ARWAQWiFkG5kCkEAbCESBd4DigEQiODUuOAB3N5RjFVCz8AIaKsg2SBzGDjIBAgJBobs0JuwqsilUBQgO2ATeAbLtINDhtWi4GCEBJAHSBD8APwBB+BKAETYgMBhRA3osUKNXsMiI4qoLCa+0g21HvCBcaZzRE6DBpiwICwkgwE12B9EAwICCgJtAYf4X9gD5BCMGooC6sKsQoqA3eTVmnBYNeeIChyOBww7dxVGxbKoGcIHTAR1Awvmo0YcC58wpQ5lsCN-Lv0KwwcCAwBoU+xPkAO7hCOE0SzXAgPLTwASgNdgZ+YDbZtICmsFGkOlnf0QTsheEhMMG0EkjIFqARUsigxQah9BjLIatA2Cg0LnTMBdSRXXH5AuxxuWHc3izKE5bGQo06U-egBvAb0DCIMgg1yA7YANq2syCtGe5EvjBo0BWYA4SgfgdA4axB48DFwGnkF4IHkgS90LqAvopd4LXmT3gWdw+xKzQECoB1weZQrugi+gCgCVIJMIMFgqXp2XQqMG4IOr4DJ+peR6GC3aAv4IGwJCAGkpLjxdrAVrEnACs5GMpuAU68Gmjr4lb1g-OAmXBKRifAeuwIgpfaBJFh3YCAlBYwbrAg0h+7BTYhMlDHgYKA6ohNKBMGH8gNZUbgA2DhEUZm2SOYCWYJNSpmRxICr8E1wJ6oX4g0zB8GnSDyT2LlQekwiZAMrBe-CGGLGELAwCEgfVkYpA5QHiC0tg8vgQlCjJBK8GUQB-ANugWgCO4FaYDDwU7FKlBnSBmIDCQA44dgAm+Uh4Dg6DkIDpgBnhOYA9Lgl1VGkBYgUMoh0Aj9BP4SwMAieXu4LqQHUx78iN+ktgAwEOWhkkhrSDxYDmIfLYGIxTsUZdJp4AlxDUgpUQKpTGuEe6PnEf-A3rBxGBK0Kf4A54VvQ0wIu6CBuiyuVzwNeAorlBCDIYF+gKrGdVArZhHkHX0G81PRAJu5i3AyYCFiFbUPAALzZJoBljBe+k24GXYjSAw+or4Dpik1OjqmHCZ8lxbOg2cI4yBcYSmEplAramCEAMEArJasQkoBWkCbwDTAM1-anA16wK8ZQsHhiHqgUaA-wAJFDl9ELKCbsI7F5Qx-CC9YBhIKs8LuICggtwhHEqxgCTEF1Yp3B+VKTIFa8Bh8ggiJoA0fqbxE3DBXgB3Ai9yD-SJZEnsV6JR-F4DhUvQ-xBVNhGQTn8yYAXzC9WlaTFPgPj0j8BjOID-GxoCiEQLIpYAuCXv4HvwKfQZHSO1hO5BDwF0oJ6scUkxSBCcjVwAe8AT4PqAXzBB3no4CXAAK2MEIz6g+UjehJZ3MioXOMF8EKgBZIEb0H9eC3gcKL4bwVQAbwJWEVrFn-ldt7OhEbkMI-CbkCOB32DxfldMD+wTNqR5RRKA-RG6SBSSnKAWMBvBAcVErCFUwV7Ew7xNgioRCmUTcwaTQ-sBXZD7fPmYHMQcBwIzAhjSvwAaQBZYCFgO2BD0BXYFCwJIgb5wA1hllTRwFeoKA4Vlgupx7+AJMFywE5ou0wQHgBmJ6nO4QBNye2ZL0l++APICNcDSIDlQe7pGygFgoyqEghMyi9RFZb4PoBoiA2gVXF9DALSABUnk2Ew0axAO6A39mVgG7EC7Ebag0qQ46Cfu2b3N3gbrI7p41KB+IBTgIIIOdumISd7CB6EVmHQo2x23sBLZqvglpcchkUFEYwxqwJHMC49HzeBOIhsAaPDOsEV4DqEHCAdWJByUKsErCNPAdygAFL8YmLqH5qjj4PUIKsxrlAsBJsAPEvazAULBs0QXoqWwNDQd6il-B1IAK0jU0CRSLMgUzpmsDEiO7pH3AZhWVmBSgx-wHcQN84E0xiigP4BYEF-komwLug-JgVuC9lHmoJdQQjgqoANF7djlQQAPANuAXRYM+GPd2aiCoeaeQLvgCnlUUE5ILyICxg3TRAsqMElFQOzgM5oY+KOMhfaArvCCHMggqaAsyCBQEqhPQQRywbqDL+laMGIpdkwGXB22A2sDgUEWXNcYeklVjCFNh+EBqSH5pAQlk4Bj7aXLGyQFM00JUg6AETaA9PAFHzAFEI3RA6EAwnhqgKLQHtgc9AzIBMGEClrhQMW2GghgYBGbBN0deIa88yAYqch5cBVeHhjbdZGHyzJBUsFm4BzAUGISmAvODKDEuoLQpIfyqJBp0Cz0GRwmqAH+gqc4HfxlQBwhC-5B7ySxzg8J8NW7oHNzeXwhqh+7CqgEpIJPLTyO7GhntCTiUz8MuwbKA1MBAZBIUsT4CaQc6AdcxSIA3kviBaNAKKQ4mBsFCbkIhYInAD4k7ENOfwfLVqjG1wAmgyxgaUC2enKIJUqSDgGIBaHgzkDqNDuwNxgFVL99oCOH7QtJfS8geXVurxzggCADGAAvgvGA7GRqEHKINCAFGwwBD7Cj8thYCQKUcuwkIhURDNgTgsE-wGql4FBseTM1ACQCJYNcA1ZCzEnZIDMgAfgae2YUsFkA4wBAgPg5V1A1Fc38RFxE1aCLQIw0IqAWMFAeDJgAlQaSQt9hKBAOtCk4PQAOzgWTjdnkXGKswF7tc4IajgRRjten4EBzAFFQrBK6RBeUClSXsoeIgsRA55B8SEXkTYPJ70jCpLZDc4F1QvPkEDJvSAF1yNYHi0NJMqyAZtIdDAcEA72qjSfKIBZRZWgfIC+8OSS1HAG0BaMDy8DjoAYgAlAuHQvIBDDAI4FXAW+wINBd7T-cV6pZMgL5Q7OhZ0R8YqEAPRMeJcV9A+ID+uERYCaALxIKagcqDZsE6gLs80cgVhRE8GvgguyPaEqni7bzy+iI0rmFNA8POgecAbuChkBmwBaQQOsO6Am7BfiFIGA6PD+AXOp5aDaoAzUOYsvFgXoptJDgCkmQMXxcN5dtNI5BEBGIrqDMQFANe9otwuSBn4N7QaUQJEKsYgdMC94LtQNW65uAsQznqA2DLBYXRI4AoAFAI6mpYNyQVtADChSBAyyRzUBUUJmBZTAxGDkaG64DjgFugukAlKUEeBUpXzANSl15LQUQn0LIGilQNciWvAE7hAxAa8r9MkeUxUBtwQQGBjBB78jS8nj9DwBVZBT9B8QRrA54F1aXVeKEANOcQR+3AB6gwlIHN6OtzGSIfABANjnJF8QLLwnWATZBQNAP4Bn4PQQbpIhDg99ZR5DLsXX4+EIvXNX2hMMGdMG0gUOgiuA0QwgwGhwHrhKZeSShnQjFqzKKFpkQZgBkAwcUreBkTJ6S5qU+ByD8AJUEe2CxrJtmoSpGCQiwAisVTos+ABgIevkqkGkiAtMIUEGYRhmA2nPzELZHdVBfFKgAXLcDSYMBSm-gYTBQmBEuDa4FhAHWAa2AP4QBjAewKQIGaljvA5qUmCDXRVmUJvA-LpurBqyiVQILQPQAvJBUgTtRylSaLQDmA7vAVeBFIGfIFWoX0ekrBjZAz8FbSGKQb9gnNBS+C+HAfRcOKJLiZSF0kDG0HkYFuEfbuiCV2ABmEoFwGeoIWAE-BLhBw6QdJdkwcPQr4J+sBrHDmRaMeOve4Ao4MRw8BXsMVQXIk4+hkCCMMpQICpIICAolBMfD4eUcIECoPrACmwwZRN3GAgJ9IGYyXpFuYDREDZySwGMkgwiIPWDuADBwHCIdlQ0wA4eA3ECfXIocloACK9tICh0v9-EbwnGAHNLhDkO-gaCu16IUgyypcyluQHp4PhjeGIhlLsxCdEqFYPRMKLQN4ATSAikFHJW3YBTY-9xXeC5nDRmQ8GTvYl8BJti9Uq34ANFOcQBddsNDJ1BFGAcsl3wpMAuWAtyBV-rSYDdQ1Rx8iTHoFY3l5MNEgpnBm6mxuDuSJ+k4REF-BHpJIuFEIBfAOtAlnx7DDB5CM6dQIVYgtzBiRDYaRspbLAFXgeMhnUwz+DQGac49qmG0Qu6AKAq1cAWIe-gUNBLyDd4GYwM2mPQQisUjKZXtSmQL3SwCBYxL+jRZJFRgCygHBUafT8wWDl1fhHzAMqA0kRahQCpCGGAIYSMgBLK8aY0oBjHgpsa1FHXpxGp+wEGCocbIbACDKskULQEHEI1YOcQ3ZoWKgy7k1SB4QNGQARR19A+RU1hvtQPYsuwFDhBqABKwOHgCnQKlBIlGujmNxLbANVAPdUJ9RIEBFQBsyrPOHIQ2WVryH4RQnoFNQn6kaorofEzmFFgAmgAVAiak9YNKDIxAWQliYyKuDTnFT4LyQFSQrkg8iAJUHEwNoYa3gqwJc4W+CGlSBsgScgO6ABYAfOAI4DXi3eQPnRmfSrYADRUD4F2IFaAvIDOqBVmKqQbGAxlgIWC3MATMB7AfhQ54ly0TiVCRcEfARnQUaQx2BvhC5JY8yWe5osxX2iBUGdMGVARCwWeFAUDDAVfaOARIwEaDBSBDakEEAKdAMiin0gmXBqUDJiIWsTGI81AZvDNSn4EG6gDwgXWQYeBXoFewPRIX6YHTBukgsSGzoJWQUiwIBBGECJYIkxUUGKAgdlAU5yZ6DzQLrAKsgsOJuODQfIUeCiQSKouJAJojYCHC4L4ytkEf9wZCi-TGaYL9MQnINcAIDAz8EuWIXvCNg1MRftBdTAKIHt0+1AC1F7Yj5KFlOFi0GCA7PQbB5LXz4gBVxDaAETSr4CRUD5gLAQLbAXdBrvQwkH5gOGVRrgpAw64yXZhWxFmhCYm0LBX8HJQBjSLsgWz0WWBG9BIEHPgBtVUaQXTD79raQAzUGUyi90-OgR2CgUt3tEmEyuAfKQuUDLiAuoBCOQKA2ihPKUwIu92srkSrAChRA0g72GDANZwchKj8hAZAaMvbzkVIV2QFdLbgykADQUHOAdk5hJwgkBrgFNiNoYJ0GNrl1RAEsBPWdzAPDWrJA+FDlKAZOk5CAs5SOBaRiV5EReeAMfyQYhA1pizcFgzuxoeVlmkBUqUxQAMBIs2KrqeMICGUqbGvCKqAeGEXzAqSA6jkLBMIymXcX2APkCUYHw4FFoWdwtMABkB4DEBiCLc72oHKh6tCbYsQwGJoF-gMGQ85BmxPTdJR4TiA-9ys4IIhXKwmeM6CQ1mI6nCEwBfZdOAQmRzohi16Eh3pYNhpFOctYh0tBWYAMsFcGZXIGlLbICWfCpUH4g+EgmFwpVDrIGW6QcYRGB4+o58CRaGRQPNAe9g7SAcvAFlFbkP6IE7FVdhYuLTZH1gjeqABQJMQwQi+HBYqPLnU6IWSQoUCyiGtjFm7UGAQsAgmgBNAdMNkgdry3lIS6xT8G80AI4OsOv7z6lxw8BthNXfMWkmaR5iB-kkYxCrwG5m7VB0Ci+HDy2jOgaNlLrdhajwXAo-tEQaX4ZPBqvkiJO7oPayDQQfzA1aWioFd2r2Sj4kFMA4+BQalOgHIANEQHxIcxx8giFYIxXDii5xAlqS1WmsxG+5CVwE7AHTCymB+ZWLgx+At9gEjBicqqyHNJfjMckJxKjqdBIICjYG1gSCBqWg2coQ1JoMhSWKBBMdBnYtpEB8CO-sLGQfNC0BF5ylBqImQVERuAC-yCAIO7QI4iHRB4LjE0CTgGj0emIBMhmwAdIC1OurbYOCBgJkKD0xDIDvnkXYguqxXXBYMDfcF63NLM4KBM7CQpnWUOOAMkgs8JjThiUD01DokaOgEKAgMCRwj1iP7wT-QC6BFxTwRP9gP+YZrgAcAo6AbIBObA68cNyI6Ba8BHMH9gCxULdA2LBXUBrwDbXIBIL7QbhQnqRqYEfAFqcJLSrvBMyCSgH8rlDQd5AC6A9MVlPEn4HlIZcQw1wDtAJfMT0BiUYXgdYj0ICYiG4wETsM9ACNpdoh8dAlcA+gD2gh3AdgDIIg4mfkCMnwFNNrlBnwDYgDlQLgqsYQUZgDHi-DuhAexgNfK1gDcEBEYOeAcRgcYBRyB6CBkoK0wdpm-yLQPyqwlZQDX8E4wkwgbqgxmn6sE6gUPmeyATiDZIAtYFwgJBgvskhPBjFCbAISUC4gGuh2wCtwHiYJ1AXql++hYMR9pGJqCusbpI3FIQ9CGYAMQHAkENASO4voDLwDZwInAL7AjPRmjggsG58CRAWH0e7B13G04A08AWkU6AQHR-vhvNCT9CZgdnAg0h4cBLYH3QF3fMNA8psAijCIPrAHLmGEwQMRhMDzkRwAMeGZPAtJBMSCtwB5gCGGVHAOLQOuCmSHQMMB81CQJogY4CxIWWAp8wR5AMfBCeCfmFBkBnacpIq9oRoDvWVnsjEIEueIsAwBgpoFPQPxwQzEYaAqWAcZGmQPogZOON0AZCgRVVQiAIEELAXUSiEADWEUsHHYHaAq2BBmCiUHu4PZoDioze5zWCWogYQJjoNVAokgTahj0DlzHswAawkcIzhAFjEQuVjEAdas7gPjS5UGT4BigOr41CANMSVQlDQBR04UgBTQJLhmoEXoh9SHhgN1RrOgMCEy4NZQUGFouJ5kSiJETaXoVDiozZk9hADQHu9DqYwAx7KhfYBbuGzoO-QH1IYmAwmCWTAGwPpsx5kAnRqwJJeBMCVokExwjORmsCtmC-AMYK1tAqOB5vBWFH4RMKQMVoSfhUaCXHgtxN0Rdr0g0hb0SRkH9ILR5O1ElVAucA2aB-WOIQHQmw6JCSS2dA-5ZkiCnciEghF6wMAz4HR8MmUOmBkIEGICGgOUwPdwskh+uBgKPUgMPUWuQX0BD5Ir2AQwHvQagQ3dJjgpcTDSIITxJCAfBpQVBuFHo3h1mUjoJcIOKj5Nh12pMIQcIbkoJhQL5HBiNmQeagw1JmjgemLZ1P1YcnowcAjBRaZHTcoqBWpAfNBpEjqdDQwNagthgYtI35BAoAySG4ALcARHAYtCeTgxGPc4clQI2BY1TdEHjQMHfHn04nsrtRBKCioD4K+jC9kAjoDnqEoEJEIXmoLoQ+qA2GC5oN0kHcAcxgVeCIkGrALgi74EheA5CjecDrAJmVfABRehfXwfEA5YKMkGDkJUQZ4Dl6C44UM6Hxgi0A5Nh-cAKaKR0snEFVQLuR5gE5IEcYINUu41eNBSjE8QPxwcNy0grkxB7kAlcPsoUGABhBsuAxGBpQJVgKMQa8gXkD3cHHCXMQRIwZA1lijjTQQXFHkQLIKdB-CD8oGkINWAHFRwvBlryxkyaPh1aMqKxsByFDznNbkNLQGeAT5L2lAdqz5oCEQeVIl49jaI+MD9ePdgdIEYTQ2sDv2kwQCGgOmIAiADuCvtBigLH4J30+xA5YCn4D-cPdAT-QFVA8SDU2iKeOJTKPwSslg4BHQDtkKZ0WJ6yLBPUAxsgTOC18J8otGBlRW5Cm8DIxqLVgswl7oB1zETtu4wCmA-RQY4ByUrnTOVtYxQAHT2hX6EHKkPe-AqgDexDPlo8ARcNesKPIKyZhYAI2DKIEPwKlgdcwhWB163qgIPhFyA7HohPDJQAEATqEbW4aaIAZi-ikmQDP4GZWewB8uDYsEi0KfaGfwhoFUERpyGkYIKgOYa22BD0CMMGuwFoUHECyT9TfDV3OTwI7E5pAk6InhXb8vnACkKyHI5SBiOAs0G9kNHgPFAUWADHB5CuqQF9kZ3w3tlRZjsAxQKJ2GP98dXxWGAVCqMQDRQQpg+nAGkQrx3sSF2QFWYhwguuqn8AaIvDCDbOlaQtiJe1GjwL04QlEsc9A5Bu6IPsCZEOJQdgAAsAuEC+0JegEik0whvrBMuFACfCYOYV9gRirIeIl7-AB8S9AZfKBoAjqDvIAhAP6AYLQDIgtIE+8FJ8VTQWKAUVBE0A4sM7QYtA91JC8BH4LlEBiMMiAGZwavnTcpTwENcFnyQ5Rl0Ae0FBUJdQAAYLyBaMB1MKwcEzyNnAGagcYDoiEUFZ7wH0QzsI3eQJRAJnKLiFFQoiQjIojoLnJmiMakAA0AgXAAoBmJJTUfjULkhGmDJ9xfEOiKh5wnP540BMQTvgL+88tQenBW2CbcBTUIFBKIgC8hjKoL1XOGDyTKvAZOgcVEvKEzYCTgM5oF7BCyhlQFLgC7kH6AFXBk2VP2iufD70ISA3Ih8uCL+G8EL2UFcQA0BOoAGEBgoNXQehA4IQdYALtGdyD2yJGg6UB06A7VAJqOhKERAtJTvPyoUAZmKfS9EQmm1ALGpkh4gNh5SfWqOhVL5gsElUPw7D3ELchzom3yG+kOICTo5JMAk-BojHwHJV2XlgNjJjcB+YF-XiC0BS0OxzL5ZCoHCqqpdcdQRlp-eJ8gH+oERaKHg5DQ+aBA+AwcDumM2wGGwYMDIUDBlLVA+4ow9RtBbh4BhUeRoY7gtBBKADKZB+wH40dkU9UAWQpgmjA0C3gd3hFMIOyivgglEIHWKTFq6BnYS9VD44L7CWd0SxzkEIL5H+Ut-IeC4X2ATaEvRPWQJLAMw4z7h1ai2VE9KCLQZr0WYga-g3TJuYGuQQ8AtHgcFTsnkPwKHQfni0ZgcRgcwB9FAkoYIEteJUyQE0DFoB7wT2Q46w8ajYFSEhLdwMuAynLZoD0sHGoLqwQeYZIgB1A2+3bKiDAd7yJHwEkASIHYdJNOFOgljAuaBCsAL4LufX3gabkxZW9+nGoOsAQSEQ5QdP5TQCIgMzQXiOgJAxACRQFYZDA0JiAj3QvYTGYGsFYRmRa2qtUi6BBhnm0fUgdhgfVAhfJawAjYJbQGPl00N8GDmGBlYHlwWpA19AeJDUtDaIPvgT04Z3A3eT2aByxCBYVCyvtJJngXQHzgG6lPTUAyAR0xI8oqAIGiUh4YaAfFBHrUyoo4Is-AJx4IRz6GLiNiFQUVlZah99CSYHkuC10bFgJ-BP+puNBMtP3ozWgcggQCC+EFsIH8zUewXAgaIDJ8BqLuMCcJA6txnER6P0bwEIfWzgUsQM+D9KGjMB-CPaATZATiC84E68Ax6E72MKAe2CdeC53M5cT3g9mB-JVkaHLZUUSSdkMohyoA00oPFRNYOM46dLJ-604GMINRwEQuZWAMwC3cFaeN+wIg6vAxUWjJtzC8LNAZOA8MQ7pIfEC6mKjSMowqGBjeDuoFCzj3wf+kCAlsBW6GEAYHgKwX0x0gQwSwhEoEFdgXDk5Hg33A7GDrAPlwFlU-VK65h8Khf6AwGCmQnJRmCBZFCUrmqwaRwKBQ+aB5sBakBRifVlWLj+qXWQCAiseaKjAogqJdkSCsjgBaiCYmP6A50z5qE9DBfy1vIjFoGplIGi4jLmY3uIXtQl1AXHA3Fa6AtzyTyADCgWgER0DPwOskzBgDBK29GJYN2yCpurOJjxCjrKsgMdUWjADMQns5NtS4KnvINRACVAV0yT6BcwAkYAKALhR4gRsMT84PYYHVABdA8KDZIEOgKLgLHIL5h-IC-vKu-E8QO9QLQBJhDocEWQLNzOpQffcocS2Mg8IG+QYwQU2I+jjIFhWqLwquGAzpgBFWEIBZgF7wIUgx1Q9dA55A5mQeQEgAMCAWKjwyFncHA4YxgxUg2+D6IDqCLBQcQ2ZMAdgBAeQXcOooGllNugs6b60BDmBZsIMZw7cOkS-KFMYI0qnWg+qgoujLXl7AG80ajA3mJvWDhcGO4Nm86EsVLAfiB+Skn6ryIRjUE4CmYhhQDyoCGMGFgiK1DWJ7whqQAB0+NACM5+QArcAVgL+KTJAGKAxYAFznzEAUQcoYtUA1MB-oGjME5AfiANZg4hj74C1YLLAaiE1GBsshn4GToDqQFOIIaA0EDrjKSeWpoJ5ulsY6Ah6Cp9oMPIgaAN4AboD8gGAso3gMdAxnBheDBwCWpMnwUAVjSBomC6TmOqHxSp98Ek5jqjDnBrAIhAI6l9UBeuDJgDI0DPAH9gJlBoNijNHlwrpkH4gTR9eNSWLS+UNPdX2getJOuB+qAuQOHufkV2NhBRVX6EvYL-gOtAmtAPKgOkEqoD6IZeV+Nw3EBJQEVpGtqSFFZzQ+KVAQCRZl9w6mAmhZi+iGGHD3PvylTIfONuKQlwg-wDogIOFeMA63AFEB0QGc0YmoeqARWYKUDz5Q6gA-Ax3JokR5UAildvgUGAGco5iCn0SLiI+IE4wXKAaKj0SoJoHMICoo8gqZzSVWBnoNEQXeQkZpQ06IQHQ+vVAHz0lVhtjDEYHOIEzkRVIXghkuDTmF+IGdwImIoMBcNSQoGWMN1C0jU7MBX2ADWBUaNngemVz488BB6IHBSc3gUmA8mxshXg4B8VXEoQq8eWBA+R+FO-hO1AX2Y1aUw3xIGimQEa48iV8OBlFDH7FSQExAH0UHeBgVUN6GMwIvYHOggUAT6CtZC95A0wTRVjkIdFXM+GkumhgHTor6Bp4CCPAE6OdgGegsbJVCCNPSJcE6MK+A2uRulDnaj5xkTSWC0QHkfUj8CA3-JKYMfkczRkxA6RBzyED1E4wtVzCYCJijE5jrCUxgBaqhfmlDAn1GkQVVScRksoCmdD2YBjgcDyGkA1+iu4FeoHt5dAwxuBpMI3IlGzJKQR1QwMgMxxmwiGgGUKgiVGcRKhU0UExyLUK5PgyjpuACHYHBwCOqvyAWsAB4B+8DbgH9wD-ECGB8xX5Al3gAzwfLQHLBSLBVMBp0E8QNAAg0hr+aO5WS+caMORon4BCwRxdAA6WpAf7he+sRixP2hzQETscoYRvAYq4XsD3kJZIQEw6IwXQ4hLRUaCkEcigTOQqKh-L0J4DwqjYuy15RRm2HVBRFKgQnmeAhw+xKIFX4Ej4DjQncci4hEcHMMKhSU+5tlBH6C6fR2BJ9INxAZIg7BSP8AmoJVia6EEsAdsAZVFqwCVwCbA3kBbrC+wHqJIQ4RaAtOBbcTgxGNFZ8ZT6QEDAo4hMGFvyLFILKVA8JsxyTCB3VcawlzA2oxIhCIxCh6AUEdnQyOBUcAYbCSYGmqglgeq8s1UikCIMIuIXqA63BrqAmmNwouAID+g5xILmC7ICQzp3sLLA4qAU0AzYBCkSxwPB0RBgf1Ue4iygH1QcqQ9Er40DrIF0MArWZRQy4JJtgBFF7KGLkMqFE-ANsGlIGclUdgMw4fxAqchoYEn1nJcVS+2NA46AWAv5OoAoH2gwHKSbJp-Be3H71Hp6i-hH4AoXHRGJKQEJR-7RVRAocHW1fsA8xV4mBuZY+lWkRJhIHi0MsAquSPdFe5cgq8SgSArYKBqgGnaHQEC-lruBLjzSKungGvIQRw41BXwBOEDkZOcSM5Aj1BzonlKDd4BfIFOQfQKEoiFljymH5YB1gtmBfEg6GFk+NYqP9wYcq8BAaMHFEP5oSjAmTAIEAsYsm2f3g5boJmpFuC4OAAoPwwNdwf7h3SBPzF1FowSdOQQUAuaD3GyLRLg4PeQ3mgdsAJTCPAJ1YYRkPhA3ECWfH1sRUUZ0E3fABRDNRE2gdggWwEh6INogJAx9FCFEMUJSUji5UUGhDFW6iTNgTUhrjTJ0U2FaMcG-gZewANhyVU+uD3wZb4hSgbVHvdP8wFW4Z4I0RBTnAH4CXFTmAdE8d9wqul0EPSWNMICUADegnPQvIEhECXEUAgZ2xTOg8eFgYDSge+hifBNLqfmGvEAUbKsZ4UAzCrJyuvgKnKxbgS7B5KCZyvj5UWiV3QfnR4+YNipQEKMcNHALYqsQhZI025XHYG+ozDg6jTXGEtGPbEDrMrGrByRWIDYgNrAUNQ-bAlqStkHFZYhYMSVj-BChCSStRFbuaWXiiHT9SCDgDhgC9NJJQluBLHBrJgmUO6MGKAFVByIQrEIbDMiwctg4sBfsDzHD98HWAZmA-sjoSqIguAQB+LOr4I6gw+XbIADGGoCHVE47BwBC7kCs2lWAK+w83gMUAalDvWJawPAVeUhCqDVUFVqqUg3eUQaZyaDv6yg1Lj8OClC4AOpChYAa8DogA9Ah4xTEgtiHrFc3gGeATwRXiDWCrjOPVoeEIGcD6uDL8phgJ3sMIQAThGmDT8jDxk2ibAgo5g1sAJkAtAExGOQosAA8ZW6GCCVVQUEpAxFD4ODFQGqODcKyyk3DRwFAbMgn4AvKsGIlYrU0ACaDJcDygTda2TB4lzuQCQNINgDKVXAqbADvbGkni+MN05UAgm16RyS-EIV5FC4Tno4wBj0E5-FzoJ1Aw9tLBW29FqAtzec7gtSATpV4zJtwOUAdQUdUZzWAOYoCwCNAcSAzMga2Ct6vPUAfBOQAspw8YBUcCo1fGMPag-MApsURwGBEKBEqOAa6JP0hZogzkFiq82ViqcRXCtkC9VeIhe4olpAgxa-YAM+tzeTlVxdwFcBeas7gIVADvoB-orqAVUB6PGzgQLQLYI7kFyeypFYrAOl4rkh-HB+wG-oLPys-gA9IwuWUwkpARWqvzgyBAmZU8MA3AKzKipAbTBB0CywBVgFAgGX59ylMJCfsF7iBiQDvoKrgL5iwoAHhDugXQwhRg1pAu41X4HmwFVAH9JoIAVGpLQNUa5fgF1KP+AS0FanHBmGCAKoAiTj7fM9QERgAZg7OAlhUxsi9hNzAMiYoaBcKLp+EAIMEIOpwXKQxoATkAfIk4xHRAx2IzODWUGX5aZILqlwBAp5xwFgFKAGCtH4e-RA3CGYBl4IngPqgH6kshXh7gXgE5qxkpVqr3NV6njilUt4juAhgrlXDjAggkKfgEdMrqAf+ANoGQUNaguCV32AudWGt1WoJYauURy1LaHhRaCHlfMwIaAPjAiGwVQAk5RSqzHQ2+BqVWhuBPlSlSVp4e8hSgSlAGINeNAbAQBKLnnTqIDf2RYbJXY3EgAhA-BPVqHnAOnVzPgY6BPkF6kESQFHkO6h3JDW6rNhu+IF-AJdBUEDUASfMMm0geEOUhvBCvglr0LigUOAJsAFsCZzEXBEwsTGpx5tFYBfCj7oOz0V2Zit4lDW4yHHWMdIXsAg7A9MXWQD6kGCwCpV7YNvz76Ct-Hh3APGs2yAmV7uLV9gKAq3CQECr7SHuKEwgItVKuVOawANj-+HmwB+AdcwxBoWw460FSgHymTypgCANIBYCp2sDgKghV37ARkCiwEIFUnsGTIpAr-Yko6uggKLFaZs2yrWkCCA2dMM1sQ5k6TBd4C2ADf4GYakmqFirl2UjMEGwF6y26A7-BqqTy4TV4GgQcPApr9DVBaJG1BjuoZ0wqOBX0AXTkgft6EOtwsqROYBHQC7kGmod2Zn3xjujzeCSFQwGWpASCxpEhxnHSQN7ZZPg+WhiNV9LQjpFcKnFVLEBAtCJwAXgABQDFgGJID0IYCBYQFeU1DA2NhEQLoJHyMFM6HVwu79E4Aa0FC1fJsYImBiA1ZWD4THMU4gQxoefLI4A0lCtwLMUOtAvUgIqi3FCbsAUgBxQQrBpkLfYn3gBXgT5gUZqsUB1qAA6d20W7wpRw39l8ME6QEpwcoAvYA-ToLmyowLpAeokLd4ekTCcENQMYIMBVl-BtaBMCGdIGDENjoyuRyaBgzVmgAMQtAkLWhc6AGrBMiNPgZfgANB41WhuFLSDjANgg2IgHIrwQFbIHVKrmgkmAj2Cr4QnZOzCspg8vBANVYaLBaHqwC0UP6wDuEgHBGQE8wFZlk-LMuBPRB0sMca77mbkZTfBv7P3wCY4KyVZMAhgS2Sq64BwQbtoTkrjyB6EFscAm8K-oe3lPdH9UDZYGDgW9ukfFAYhpQFMkJTCYxg0TAWbDgIGAIFu4Hi4UOoISX9DVOiIfAGUEMlNfYBEKD9FcAUUuV7Ghi6hYxAwoLVgSmEvi0bDioIC+oH0gV7svsQyKYsypv9MNicqgCmB2MjdNEKUCPTbSgoWBacDixDFIJp0BhAsgAtfDtquAQOHoeHEdsdb5jdVizRIdicdY8S4aggQUWERH4gfrQdosSojbGAvoFMgKOINgANi4GMq7gCl6U9JzUAWsBa9PFABBEJA0DRMxmwh+A54GuwbikrYAS6DnoHWQGWQFsVZsKcMTKjy1ukSUfDlhCBtfaOipXlUdAM+AroqoxCtBBfADfKOq0I-F+fY4WtdNQ90wnBnprMfj-mAFSAWkH7V-3w-tU-sFoIGMUKtgeqB7iCGxEwYMMQBhAQYhjxB50tGaJHIRsQYLQZoj5xCUQK+0CfgGJqoYCH4ATuNiIQwQJnxZThVkCU4LHAKuYjJVrdYYSG+wJkQQpgaiAdby3IgA6ffwYqgXFJW0BlwGKtSqkLnAaTBBCCiGuBqLGgCCQMIBk+A98G2NdMQWFwQUBgKirUAtVRYgHxVyYhMATOkBE0fkCLKg3sAdSLY0EXaHYZKvcIJ14oAdKAT0NOsXFA82hyKA4+DqtP0IV70y3cmXC7wUphBTCQckxoAPcQQul9iIhAPDU2xhW1CDCNXXuwMf5ACtJ4tC9aDxYGTKyc13qgCYDw6EowGEa7+EvzAYRA7tHHWHIUVBAkcANMB9qsSNR-BfBQlCBBHg24DyCHxweKAOGgXYj+aAZbpDcdsA-RRihUnwBgYPKMHEVN2A9ECgyBuwLSwLsE7pBz-7PEAgRuDEOa146AxWgSuC1EEAKg1Z7RrZoDH7HyiNZUPfk+fRFU6J0BfMB3eXbi37Bp5DR0iqQMUoW6ge6Jd5FrsEnIIN8En64mrCdWswGrQCt4Kkqiegbfb9cA05MqwZCk3MBVwCuuAnIDeDU+41AhuFU2AGVEnroV8Eepg+JlPCQ5htxIVEg6qsuPCipW+dFwalgGS1IGYj4LDfmcZwdpg+eqWoyfSF6UEGoPGAvUgCxB6GD8ORnwHyAN8RpdW5izWmCCESlg+9xRpjMyFvQMRgSaiwcB45BS0DVPGda-vsd0pYFUOnBlgLwwLl0pvAKLBDCvQNUPGR5QYUBwBHBgmKQK7AuWkxsgxCCQKt8OLEqIEueOAFNhJPMb0HzAFKIrLB7lDWIF9iCSQNxom8BpMw5gmzALDRXUWeYA9yBcfR3YK5cimVHUBvOjD6mAlUtSMLgpNrD6BIEDENZTa1KgQpAnDAjyktBIeMHaAs3BkMAWOAv5YbAP9wCUA8bDzEAy9A8uKjU3UwRsDFoChFTfGOMV+DAe155gGFJGRcS4QSY4niAQGEwYHEcF4QiuBxoDmmD3hD9IN+lWBgTHBs6gTOLqQPNg2Ng9RnTmru4ABsZR1rmRRwQBUjeHAEqs2AqOBGYB3gEjkAma0MspTA8+UEaHfED3YFQlh+A8HUoMA0gKyoLggMwAlYjpMFI8NjYLogO6IOxDXZFd4DUkXUQOzcfpVBoCKRBzDZuAsasa0Di72FtRbwaS5r3ZAEAy8FywHIqyo08lABQCB+n5AGHAuUQU0gEMAyUCYuagQJnIhzQ01AfxzbTN2xSvlcnBfhVWsHIwMt0CsUvMc3BAXwDKwEAKrywtiqVUhdwAkUPVwHCAXEwNqhr8ql0FgQKjgBHBIvAXHHW4HpKk21i-gjnDAXl0QORoCLocCqqrhZNUNQHsAGEcOKptRSFMHUlYIQZmQW+QrWARIHBCNCsU7AGqAFjAWeF4YQiDKcwXSliulNgEZ0NQaHkUJ0BXsAauCQNOdwcQV7pBr6CTWtigGSITHQ2sRIeBZYDXZBJK2zA5WwZwBdQFFlQEEvywZRBRpAXiJL5Rg47poIkBHWDGWHqSFPYNggRuEjjEmiDBBC8IHtg7jQQnoo2HYYC8qy8JWjBugDRKB0QGHgcXw8tAjojbUEcsINgghwGkASHg3oHsMFwaqHgixk+ZVJcGloKLYXOgIZAE5Xx4AfkD5AJDsVWUx-61QGIoLVCJ9g5dl+IDiwFnZZ6vZ0QWpqa0DEIF1Nb-aFr4BprRZhjfhNNWSIROAZxAgiACsipkUuwBawAUBeagl0n95iGMMhgVhQgXBWFGTjhUgTO1ry0RCDaclsEnFAaHAEaruBAUAB50MSKuNVGghb8hX4BgoLJNTcgeVBWhb5qCh1alKucEn5hrOD273biERcq9QaJIziBZIC5QA-cz-0oqqRRXt5DNsKXABJAQbrxSSdSG2YA8Ia0QvEiImgEQBNMVggAfgr6ANXCiKsdpGIK1nV0KRE9BTYH19ODEb2wxoyezUwVhJwOjhQc1IPJtbUUWrHEO+AbyAILRgzVNwAe4Am8Slw7OhaRB4CDy9DvAFqQOjqwWBgsBeEO5wA3A0zB9uBMcgaQIF0ULATIQ0XUV8qdcIZgcjwGiBDYiipG0kJi7dcAgDBHti-FRycAeNZOUL5gz1U-ykdIO5AUSQJkwZnKcEmeZvKkJhAsZww+h6EDEsCyQzg1C0AZ4Rw2ASdSTEOFUE2rSgnbUGptDAgL2Ac8hWmDqQFh4GW4a4guLwl2DZgENiHwgF4x8ygJxWtKs6gBG7RiwQVBy5U9Kq9NZ5QQuAzkBVbUhzEblZUCKQQAqR-nWlkGcQOVQKxA-XBihz0MCiIPciWAgtAMr4DVwnQedPIF8ET7l61RUVBRUEtiop4AmgPISJIB54IdgSEQF5QXVIMQiaFMfgT3gGwR9lB-oG8deg8rVwbSAjEB28EX4CfwNJgZsY1CVPsAIwCrMEoo9Mgo4BoYDkMMEwR8A04r7ijS9Gs1ahIJpQSYIDszRdHD5REgK0U2kgF5Bp6rj5dnKp7Iurp7IA5SHQMMMKWpAupqoDW1QAOgMnkVY4IYJBeREEEM0IXy5F1p8JUXXl8oxdTm8Qe6bBAUtJ4uoqUIf4TNlxLqZXAYck7oEUqwBCI6hLRg98o9oJ9QJt0CcBOkAOmGH5RhQSL1zArY4AgECWdcbayxIaRAkFSr6oqKF1IbeVm5Y0CA7YC0ECtKiIo3jdTpxJGrMXEcEH0gZ2wxaD-yAUNVHK9JAmlw2zjkMC2FjCgCR1usxfpBRMGUvoIFJ3wiQBSpUdCDrUAX8W0wp6BUWg5CDYIEJq4nsWMBR0T4kA4Gc4K-wQHrro1Xeuqx0PGqv11BCBXoBVGs3IIUwXdgSUrkFIhuE+kFmKrd6uYrfUBxRNtMEXoM4gXDtmeTSMD9ZFs0YhAzNAvKCjYFkdALoSbYnZzA6xWisq9ZKQHRkuRquxUAEC7gBFUN1gGoqiRBGuCQgHv0T3abXg3yjWllfBLUa4vwm2ragKCQJqtTx7YhAQGAAPi9CqqYB7QJzAjawjbLdTllaQ9wb9QrRgTNBUgC6IOUSO2oCagmUCZOHlgHIUJokcUAdMBuFF1wJwQCBhk8r8HXbUEEhJZoiQQ2MUb0ydwAZ9TPAdAwGYAoRUbxA9xFuVZ6qS4rqYQi3CNhJgQedAcdhz1AOsB-WBvawA1n1xJtgzCGDgIrAFAQ99rIqEekPy2CZ6vGonIqbfhKcCS8I9QSUAH-B-WA1CtMMSH4VcwzxBjGAcZBaVWOK9pVzKSccBZkHH0IvpEFpQMBZpz8QhzyD3wMbI+JrmgDAiBYpTx6OKggzAwOAbUEUsOdQCmQdBhofD1SskwF2QDYVsnqrURDOgMVBPKoJ1bjRCcgNImCVWc+NJ4U2APXWdSG7gDVAaX4v3g-LTGgG4IFhMY8MhHBLjzUpBu5EVAKoQlJh+0KqeulFV3wDZG1fwPbiwWHtYGzgO-wOMACODiPGIfChiTNIXZBq3G5gGMYKrQ35ghUBWlUuioCwDHAZPg2YAwQCeRF1rHAgFUgf9w1vVqMG5EHfwKkQARYDLBwGoD9VuVBy+ayBvTaWOpCIDB63oxAxBNkD0sGcQG6wVJAxWqM1UuTDO4EPAePIhcDqtXBCCv5CWsAVIbeBQ6BvwGFuhK+OTVkQT++F37kcYFPQOtwQMBSOjl6F2vLdtcH1e8AKigm7C+oKPgTQ5-lgHkDXoBJwD+ADHA1aglwC8iAIwL2gY+wGwN7+C2dCOEB9STAgmIhChDKW3KwshqPjgxLBqNQZnIoEYwgLHY0ORrTWA6ukROWAQjgejxwBzjYrmQC6avmV51qPTV-gkx+DegVp4l6AeYA7ilL5d00Y51P6wtsBAUI8QEo+SyQJBBrJiPgtqlSGgYCoHuJQOZ-RAG4PpqxLAxpAJ9RJCthTuOsH4gn4AL4D92AoQOBgbfmpeBbVhE7GMwFYUEnVBdA8BUO6F+gLXIHLwlvrkKASIHtaO29RSwiphNYDJxHXMMeQDYwzYAqJUgUESAH-aAwgTE8xGAewinNnrodE1ZsJiEANOvBYE06x9gLTqK+WAkF9+BAIsIo2n8QWiIkHh2AzEKPIjqByuhT4kvQMM6y9A-yAvBChkFyoO1AFKgXHrgoA16F4JNYAFvA6eQ0cDlqF0lcbau2QSpIzbXk0DZ9Vba7Z1eYAhVSaGQnjpGZaqI0wge27usF-wBxMhBAiCREkBbhAN9fIgFdADSIKqCumD9aiiGBKgIWz-TQl41oMgnAYQQH4RqUAyKDKJtPXEX4XzgRjUmaChYKZ0fBQaZBzLXImoWOs3geLVkqAmYZUsnuRJMIBSV5MkZwrxWq0SPrQCywyGRIOCZKQdHIsgWL1BLqEvW2Wo64HHquioyghioDt2qq0F3a86gycqz3JIpFDcGRAPyVYz1ycBu8EbkIz6W7gWhQ1GAXKomoPpwHcAOHrw0jbIDdgNZwHaAOkKnbWjHAm9UeANU1JzFuFj4IC51XEoYaA46wWxDqoFswAuAQ01XiiwxmIwEhMMEkQy5ppRtSw+iCaFWQ4HJw1agboBNQA8pLHAKGQWnoGBBVbyRkBYa1BiIpBUTVYap-lCeQ5d1hRgJlaPEAlfBToZqI1q0fdCQyo9uPbgKBANRVbGS-xlOYNRoEEIqqBxQD8RhMoCDQH7AssADA27EAjMLdEZrgv5phXpcmu8UHecGyAGiAhwBX9FSYH70IUEOah15VcCCj4o8ofwESyUIHoMCHbet0kB0w-sqRbXamEoAACoKuAW8hMHwf8GagD5KyG6KgrLpX+mjSYDugUCIrOIERwBaszXGtIe8EZmwIoBRwGE8OmUROgKqBgDTg4DzkOnytkERBV+rDfWqW+VMMi6055hiyjngEgkJn3S7AdoJOsnCUWeIAggNbAIipmgB7QAkuAWUOAZVPotkCcwAR1ZFS+1AKD1PZVIcCwWd6CaN4XAYFTR+7BGgNHSBxAYSQQSY5iH8kEniAyA8qQ-YBkCAgJe5EL1A3mJNMCzatNMMAQa-1t9gQ-CsXCvsHJVAUipssRLAfIFMfGnANJA7DBzBD7CLugA8QJN45QBMURQ8EskLLqj+kfiB10DhYFs1XmALIg8uKY941zKgjC9AISVzIrpw2KGDyoD8QF+Y-QUXqzBOtqUKDAYX1pDwFECAQTYFR7iOYggZxX0bQICAIBs62WAR3gujg18Tumo8gCCVpFpV4lEwBglSBG7OgilBFyKPgDZwFciEygXzA1GD43Br+JQYUtIw0BaHi94mOqI3IXhgOeQxSBdShClFaq3-AcYBHlisKAVQD4QRCotIhe5B8wGwWM9qmoIUPAShBqAlrDCHE9JgS9z9VCR5JEIN7QyjwA7qzrCpeEeYNsQBmI7EgBNXKkF39QDoTVE8FwEnTK6ErNRNwIKQg+qh3hXEtH1SiEUV1syJfoAsA3GCNrkReyWrgOXVhwCSduk3cnVSp8+ghVwEcFZ7mOrEIPQveAVcG9lezASDgDpgAmiC4Ag1Sy481QCqBJtghqCPAG90d+gwUA+aBPICYsqEqPdQn8Yf-XlCBlkIkwHL+3NYV5zSJAwcKVQVAYscA5hhHjE-wN3QAR1SzTS9hAuBNgFTkdwA9TRxsBEiD0sNMgVUNXWR1Q0XsE1DW6K1iAjyxdEByRuQUOFwQ0NcOBjQ30StWMpBQPJJl7qhXVpMAgkHlwOhAO-UAoD8YEbwKTACS4yNr7IDm9FCmPZCvTgXCdWsVPOCDEOHgOVglMo-GQuIHD0IEiZiAVsA7qBQeJwDYpYX81JOBjkCG1PPQDt0DqQoXBG9CdeAUVSZgBKYpVBRHW2EHEdX3gXhguWBUuBTwHfAE+qeRliuAHsC-KGnkDhG4y5TGB4LizeqI5LWGmjw8EAgCAsZ1cxKWDbMQyKAZcCRyEOIMnwCsV9rQsuB9yFEeg2AA5Vv0b93QH3VaVURyK+A7V1EMipQAQjTxOEyYVuBeyVOUF6kKTwXCQfhYrrTZgGo4LYiBcgHtpsyAXEE68N8kCgQn0hJhDhgr1YGta93IXcBGNSFQAvgGHKeC44sosFDjyFDUBji-yNgd4TKBsMGQlXaEPC1rpgsuCwDGItTfUaSZS1JCWBoEhy-vb6biVBPhtwhqyppVYAhFI1iSAikT5KTI1aNAbrAa7IEzCYXFlYCky++kZEBZkSGaAB0NOYCvAM7FraKvWChYL5GrtQw6J9Y2GoGOFQjEE4YC8hXeCNSEuFcHACg1Q8qMoAxRq28OmwcwAnuroZApwAYCPiwv3Yuzh1w33QAp0F6YRnIerAF1B8yutoFvMJKAG2NuRBuNDLQBqUdWA1nRUCyswBhwN7g2zgTCxcnV8qG4dU9AWU4oMAlI1QpAcQEy0jAQOMBO9iCvg5jTcwefAfsABpBEyBGjepgNAAWD4dOhzEHDcDDMCooYaAfIAA4CaZRTAS+W8qRLBw-RBn3pQauio9KdqQCU2FK+Ej1ehQOLQX+CmSFD5kcgaLgarhgdjaICdkNKK5MQ9UA5RVSVGmgBq4WQ43ZzrICBeDymIUwO0gfp0wtIEaH6wIkYBWqD1RofBJjhyjcteYKwajRf6Wn4rb8LFII5gBJceMDMLASiOh1fSVrlr+3XW+FhoFRQEhAwngngiHCEVSP6qnoKgaqK0jHSBDVQJEKOxF6rFEpZJFr1exqiS4xDQIig06Am4FkBQVI31BzsDfUEYBcZgNroErg-ppptGjdb7ENwghxA61D+QDJiOC4I6A4og8vWVFHVEIURaZCoGrY4AywHr1kWapmy6lJxMDdBDLdUZARVgbUqGwhqsDp1aLABnV6TBVMBAst7yNDUW-IwOwyNB+WqhCpp8ZPgywaPqTmBqGBJVmIw0gvJofBPJ1J9cw4enQZwCW8BRUF5dBvG8qgSbqqREUoujgIGwEKAieB3y6gEQnYAogFxAaEBtkDgiCLoGFJG9VI6ZvMSJuHY1PqcVXkBYQYZg7WDDQP8sRXI155VQBPUAtKkIAc41fKxcEC1OHttftnMkNLtqEjVfbA-gi6PDAYOPs-LUIKt+WHDwHhVgeAy2jJUAI3Fe6sZYt8MmBDyiTPgJ7Ki+U4CAqbWhQC7mP9wJagGagGeCXgHVmk7kUM0CuArtRE0l+VKIRASsykBIYB5yFzccjS8fQdi91lDMWCjoPZEMzYsBAunXGCDvgD8gKeMDSIE9DKKUzwNlAZ4I9ABq5h9gFqiMEkUvg1uAIYBGuFrWGEgWzoLyAmKWXEEhdcmoTggdKCF+nHxjoIEkAA1ALQB9HF2ADcSAZYRpNZ9ZNaCBIhpiKLgZ8gzHsHcCEKt+WNZiYOAcOAQGi1gGH+Bs6bEQKJIP5g24B0ML2UevAeRBu-VUUDBgLLgbxAhutpRWRyG4pCbAQqJOdABrDCCCugKOs-tA-9A8phmQCA6CqgFOgwiI9QinYgtoCwDWaG9xRS0D0yCHALp66FgxCBFDVOUF5gIjqXsh-mAmTiXLGWVH9AbgQJBQ5HXckCvDbCsSpMCyAAVDiwHDvjQQZMNwyYHXVk4gKFWArHjAGrgVkCmlECoDpgPo1BJrMIB5tLBIEjueJwEjM+6DAKKeiFWIfNATfKe0AYjGyxO3ym0QfYBZkRi0BZYH1AM5lachLhCeBsydFliEwIfPBKpSHzB6IFNiAUA8jgLphRYEowDPAIyA1lAhXUn8GWVEMm480AcsDSBmGt76pc-CSAjKxk4gV+1W9eGgADpCmFkmBn3ASiPAoGM5jpjdABtEDbSHlQcCgTuBMdCPGtDUBVkmZwId5PuS2dA0kDUILdwhHBkm5gsxDBLoSnXVOzqdEqUkMoVBxoWNVR3rr-jGXCHALRQZlcfkIFSxagD2YHAUFuAoEBQyDBCBpyPJsAB4zurwnj2RFiVTzgBJV8Nq9o1I2vGIvZALVYnbww6zoGDmDdZUEJQTgahACU6rcDXGIF+AZAhGMRr+sKEK7yLggXMxPo1AIG80Ov6trwhLAY4DGQCWaOeUCINOCAXwzaIHDRDna384nURryQDWB7ONdK3ZhkEVgI1eLCeWAqgTZAhNA0Oj7KG-jemYTWVWZAV7CuZHyYIeAUdEFRRcUSwGLzgGRMs4QU0gYUoiuG5dv60tRoBdA01AAoDJ0GlweGEJSaCYAMCHKTdJG38gJshM25i0ungHZKnb2j1BVTXImD0gHjUYTwbSAMQC-QCLCPVLFaoZBArYAGmtGOFTkeOQCGbtYinhvbIdmUADQILQgUC8QDWOKFAOKgwaB0xEVIHm8HiQUF1OaBMoHUJrXdPydLj2i4qeMlWcBiEEQoYa4DngpA3heradQvUkv1oYxxfUBtkegH6671Nk5BNCznQHBgOVGX9KJJALWCCqvAgAKK86gi-heICqdOPIDr62eAWBh0DCkdHeVZeADD4f3BlECLiAwoE-YQBNH8wDIhQKIYQF9QEdR3urNMAYJATiB4sZ7MqkrXsj1YLfIDtwaTNJsb5QLMTU-MI3gCwg79Zx+GHcG3wFf0X7KVhQJrAf8rK6BSQKSA5vRq6DWADrqBbIAcARvqlqSMpqrEiTYRJeRKqf4DUcCXddMgPfkaoam3Srxq1De6K4WYj4gCAn74CqlYdwQ-I1qquLWDBn9EBKQaAAN2DlYCBQExIA1q6UQfrwErrTriYMLrAUWwD3Bqi5izDkKFMAxlQdUlp7J8ysCYEGBAxNv5xAWqNetz7qNdMgg-90BjxCsBQDJ6gHA06LhUJBhoDkVVCPFC4j8qAwZX4wyzVCWaf1S+BwEDaCtfJFaan2g7OAG+gmZuZqNVIehA1SIl5geesgNdqQIpEqFV62CnuDzACWAFwV0XRCCLajD4gEPGDHVE3BKHAllK48O0zSsNK4AuBB-4CrIDpgV+A8usH+SHprR4CJgUPAhcLqxCVCmWYcbHHj1TxqpIB9EFkmuNmikgkqbwDUNIhOIIGQATqlMg7JQRwAxwGYGtaQlUbtcVd6ESkZjQfuNyJhw6DFBHAqfXgfhQQAqqJTKuDlSCQQSjAEhcEI3x6AKaHfAeqAIDq0DWdSDSDZi6hsABudaBZT8H1UFiq+8SbzQ9mBs8G9ccVI55gN4NL04o2C1hLtG79QjVj9shh9F5NaZ4aUQ4kBSOgnuB-1Xkq3mA+YAVQAiWDo1SqkXn8URreGBptA8WDTkHVE5LAgYA+0EDfO65WvY4LFA6wJTAoQHctD+J5oq5xB1GBfMAU0a6F7Og5UAHyKT8AJoSrMoAcsqj3QCpIOUahgkLCrUXwHQGWvM6wcgNgyRIXU5EGZgCGoJ6gXKAXEBLIDjQGeAKWgpt1zIqXgFzYCR6pGNLOA8CBqpHVoAXOZFAEJZKNXcWqalU9EPTg1YBfzjmqCfMA3QaUOe0D08iY6ra1bkIZ0g1mla9gaeE2MMKUSzQ+xqymCCJqxDWmQcDQKBhRHCflgZdZIgJwhD7ATiBKmuZ8EYiwfOyJgJ+ir0BPoJpQbVAhSAQlAtircQNEgOcEo4BDCIoylaCD2sScsTcBOWBOkBctX26tbA1vgEmhp+A+tYJUAwQMKBKE0N7FszcdIW5gM9xqsAYSEqzFRUISyAZrDI1kFtSgEQmtPw6swvSDYwF4GJJmezA3AgT-EvVhIdNSkR2QdsAolXwaFBUO04IJwlGAepXVIG0zcXNZv4JGAQsokYGm+FkqlTg7pDD41kRv-WPhFHlV9HROCCdICowMvMD+EkpgpkCHBs2EPyYJqYtexOWCKRtb8FCkJkNX2RKICJAH0lWygJKgbDBCoCo6r01D-K4soXYa8YBn1hlgAxUcsgVcA6o7Dt021RYquxYeuhUxB41G60MfGMi4u5rcURhwGBlUear7OguBOwAJvDM2IQcD-oFHgUUCGwBKYFaaotgocBM41g2uhgI+IZqckwgpc0JvBlzQ8ayr5EhBofYgjFdQahgSVA5WV-bgU7l48CbozdhIdhaY0d4FVLjZwPQADbBuRAnGErIIBMytYF6QPsCyRGYtDMQCBEpAgVTDdslWKNRSOF1uYBEMi3wAD6u9QcRio6gQZXyWC-4LuK9sgsuhkmhAID-cB2msnN2TAMBB-Zl7Rng6CuIOKaoYCxlAPwPrQJzqGRDpsitIAgeADUznge7rV6A9wET+BNKkCKGAhzlXu7D9eChTe6Q-lhSlVuwEppNjQU-AhZMof4e4iAgBOsfUuUlr-8DlhrnTDiEPZgQKqXw2bxEe6Aq9adAHyA6cAn8D7oPs65AMcKqzSpO+C5wAEGqSADihXMhpBEMxGhgX5NStBrABsgiJKBMgHRAJXBrkj9Jp3EAOwWMo9uZyVgbZtSQNWIGV18fBeEjHMiHQPHocEQoBq75yCJpgmr2jQzABXs3xpTokKqJiQJtEjDTsNDzQLZNV9gcusP6xuTWO82TiFKiVSwWrAJ6CYRpj4FkWzq1LRDOPCHhph1GlgZLE9rQgoB-QG1IGNSwKgp+qzNgLDQXIBymo4xHMgXjA1khkaFQcsyAR0QJSCQcFG9RXARnQyES3lotpsnNYg9K6gZNQWcAjuDyzMt6tSAH6rY4DresOGQuwYGQx-pnFCbpjukn-AFBVRHr7ihWFpqCLn8RSAn3JqpA7oFO4AA4QOQd3BRC3nEHELUeASQtI5QZC0NYHp9FS6wquNhx+fXBOs68NdgYQVykBLAjluFrkFHkU0+pVARLBKIHXlaLAIMNHfLxZB4PFpKVB41Cg10gBDB-cH1iKZGostlZAUPV6kGnFVRrGOAsRadwDUBBhUEpQJhEFRQoRpk8GNoTRAc0akCbHcqeUFdKpwshmIsdhGomOZnJMLqwLWVsUglg5r0CBUEEgKZAEDDPPD0uttMHdQNF4cbBVCDOi1YSUayDrgWf4nfCceAvYMWwb9VF2bsahfbGKQDu0GIQbfgMJAfczwIADoMCYonRLUDHRrFTf+AdR1FirKMB-cFHAO0K7agKIZgmBLUHrVP2U-gy+uajmCSqBiEPpmgqAaHJrw1ooA47FawMiAniBmhVRauexW4IYnsX51uzQ9qHj0FcgEJASGad2URDiQFTBAbSAnpxnsx+wDRMDLI5b1yihAs2h0A3SDPbDIZ4aR+YrVwmiUOPKwfNAvrTAzCoHVwIaMWWAjABtiAZQCdkCJ6zCAqyQZpWqwDJgMLAbm84nt7UB8pDp1eCWnqU3zhXLJYYBO1XCWv-gVbCI6i2IFS4FOkeD+6Jbk6BXCDweDVTItg1YBCuCXLBMdWwUK0cGqaqK24vG1TSzgBpAlzgVICumDPbvoAbildOaD5CWJjCuGyW3O1ksA1mLt4j9NQYAUB1LObRzBcMFrAHLSThZxqBwQiThvUQHzmiSVeUhRAE72F5EZdmixJZkhMHXc4A3XiOYrj1L0ouZi6nGMuF9Ylyte7owuBfZqYsSEoX7NG6hbuXX5v7CGk6okNWhBfc6URmxKCMvHAgT2BMBSp+FywGsACfgasqPUCH2t1YE9wY6Vv2BF9jo2p6qICKUWAechv9WUeC5mOUIdsgdPIkjD-jH7TUZMRpgyg4R01h-w+wMGKvFYw+hl+DlUCIyFx3QvA7waqYLpMGyLQ2AagQ-BZRELfOHeEOum9-Anqbt00DSGiDX6mlvAymRVYQp0Cr0NVqSz4g5IF8DaEB80HjaC+wtPqslTu+sYSDuEE0NUqcwkRZYG3YDIkvKYpnQwE2t+wWUcj6rtNrYBFnCloA6ZGVoR8AjUSWVRrfCoDUJAF9gsNhJ2BPmAIKJvgMkQVIBIqArFHQZm7AShwDqbwKVEIBh4MR0QQG3LKJjWE8CqIaHkBAGcxqdShx8OVrMSbZeAKmQvI0XcG3SL-ACl+S0BNggk4D6OLdwX8ILkIJrDR4DywAjkMUABeb9dj72HpYIrgQawUJbRg1hsF8UBMGlNIa5Qh0BzUERYJja-ewE2BYsDfsHPZF14CIlemBHZA-wAXYAA4RuABn48wA6YBxaOV0IAwCcR+I7TErPLVJAfywMcBETWyhqsNY7m+woHiaRfCCvK4pK7IeAV-FbHrWCVuaAHVUOVYhSTRigGhuyYHFgAQNSDqTkgoOp0XolgL1AO3hDA0Z4upTqYGst1klohSDeEDfALC0b0QLVrQYBBOO0TT1AKtORHYzJUv5OvANZoV8ET2cIzCOGkkTHswB+1wutLUAGkAFuYkgKzgwcACmjlZW9oJuQRyMyZgRwCNYEYJNmgbdg9PqjmCfmChWrLpaEV-RQkKXvGDM8LdENX2ZNBaRCspACgFjG32NkoB5UhaIBrmajwRd15UhVs240GGjRtmsaNe1q3cgi5GlqPdq2qIreRIqhykUaeoZoEZgu5oLRgVJongLG8QqlZBAFQ5ClOmSKTAB2izMBXbh5gFzMFTUY886mrnBIdQG7QGfgYfN80rWkBTMH9gG4UXQwNEQhVTFGtM6PzG9EY-Gansg1rFQbQlMNRAmKgShB1xvdrbXgAvphjRhERkeFVELsAJgwzOhI+CUxhZOCa6m9A-5rOKASjGqkCla8UkP8QsyC4l2dZcroagCs9BDHVbaCL6Os4RNGLtIiySXgAa9UkocS1Unw-zhEMDHaKM4URwBZBBwC3bWN5VMGS7AylrlMjBoBvQLU4d6iZRB1IDuSBWQFuAaONRGQcCBqzCSMPFALf1OIRuKTnRD94HgoAm1aqoCBDjBD3tG0gCrW2ZDfmhKmtEQL3kWvAgjbMBhxrAqQE8EKxANEq9cA3skxUPL4eRAr1BckkUiGGCKcgECo7IohlVFSvphGDK7BYdiB5kAE6slgMu+VmkoQqE0nL8BBCMhgbLSe7gWwCE5D44HWSHYA80bg-Aj0zXAAMeBGUoLgTEz7sEVgGKAPFAYcBk40W0HOFenGt5E1wrRWXplFtpMnEVEu9IoeiA6WrDaWHAUGAHfLT5AZLChIJkQRewztbFhBu1v5lYAQhvQTDK+rCJUMLzaFoa7AThR-C07IBdWKTWiQggsBC9g1EEMMPYmgK1s2b-cLfiI9oOamxLA1QlWEgbRtaCMsiyxgNnQz6yzIHGOClgFCA2dAXo0IYFZbtOQN-1FWrP-XT3Sh9WVNRgk5gAV2Cijg6gB4KpbAWyAEJD4MFpEBa0AH16RBVCA7gHXANBMnGAU+qTwBt+B8gAZQbzoBuhr1hOiVVgB-wBs11EaqY3y5qAiBNgUzwc9Ar+jW0DHWgBAZetifBxNxPlmVwO5qkdQshb-a2BJin5aTK411R8AlABwrHWMMbwO42avBMfBZpBcIHnDT-0udQU8DTQFoQGtaiqAR0R2C1FsAlIFvm-TNbsAJaD4ttGQDYAS3NgYQ30zg4DhYiJYSmwuKrm4DIyv9EESUFS1lBTkIn34C9YL2kMC16zgvPY4wEbwDEIK-AzBAu8D-4FMkIxW7CgCDAiDVfbGyQOecXhxV5xeywJkELkMxAXnEMwBo9nqwGZpciYajga2A2jDXIADQYamhQVj8qxEQ-NEJYCyKhnY04aazDLIl8LVx8Scg1KQfnWlDjNvozQSOaBATzlAgD3iIBAwFNcM8Bl+CK8A-4KqA78gRlBY4BKcFOUOWwHe6a7qRVWZsGUIMKmkVwWRQGW1HsA-ja6SAtNegrvBDR4AQBvnm5Igtch3Zp3urqCPnwV1w+9AOmzQmtfdbp0AHc8TgnDBEqh42u2KP11vVRJiTfEEGSPWwcl18QKJrDJyqTkL3CFPVjkxsrCUYEobXGCh2t5GgU+VzFs55M9qhpEMcBli2pKFzwAFSIn6regRxKBmso8AZmvVVHSgzNhaEAPGKzgNgVxigGhVCavckPPkPfW4MAFoQcyCogI4IHyO6UBz00J5ozsVUSPMInOFN21yyWXldzW93geFqai44lp+adbalSAncAKDSxSLHSCRAGVIg5IwsVR6A9mDi0S1A6GAfYiyMEnIBhyf5Vfkr2nRzCuWmAHYobYV9aYHCHoAhUKwwRFIZ2r9BWdoBngJQ2vogVRqgEDY2FHVbVQKd1BfTE4BptH44DN4bNq8GBk6C+lTd1J+ADLVlVAstWQJuxcO2QAzK1UhN1Vu8FZBlJUY2Q1cJEHUcVDLrV7wVB1S4x7GBRUE+MOzAIMMj+broB8ipfzR1q9-NZpBZGAm4DecG6oI0Gc60RsDlVzMOEUKr1lq-KA7S1rMa5CAdHew5nBN8hREEy0NsgYw+fQAArVOJonfnnQL+wrnRQYBZtC8sMGW5tNaMAwy1+hM7TRIQTdVNdQl3wk4HPQJcq0Iw9Iaska5CI-mO9q3D00TBRAnqtqjFQLAHYtGDh6M2ubk6QM56qigpQB+YDREEWIMbIXz04xACBWHxBemCQKwNAiTADUDrOBKAluAd2gCbwYQ1NeuD4fbYeZooV8oSBg2AwrZRAHawcHIOiClsAHpMW627J-eB6ZVDOntsBTZHOAUUr7YAGkHhSI3gDtgn8BgKDrzORQBsELbVg0g10DfOFtgY5mibghxAZJrxyGl1TQKqOAroqFdVpKksSEOgRJgruhmDCPasiwtdIIpp77aZxBhdpa0DP4b9goWhIkASiHkTesaixQIfgezCm0B-yNCWV9giabd94MxGFqPzoWh4P0hupB1lunwEygDbiGghIGAaxCH4CQWOENz2hbmhbFVHcKYUUdVN-px8J86vyxquoPGA5VAaWBWcGZwJmdF4t0qR9prqxqZBqMHKSNRlASLCr0ABSGwK1jwxNBXJAKdv9-DycbJAnexubzUiHJcPlEFzNbdgtEiheoDGBu6iL1vwgwkAR1HR4DHAJp0J+bC9WFlBjZHjUBhEl2YGwC4VAhdFFmpZAMWbhVVxZqngHtAcai4va8ZCbpAFIHiKNNQTeAN1TxOouFVLVXc0CRFvCCMYAo7c6oPfVp+q1ASBIGP1QBAarN9HQv41LQFtMJ8dWxgvsRpkBstrirJTGdetXAYq5X-mC+oIHyJy5RzB5YCuSF2YIUwNgoAx54IA1fElqAKuVcov6ApW2gWuK7jo6glgWZQJMDwWsMtPygbgAsAqsFDYYsQFVnWlAVJcIVaBTOiOLWnYZJAAbY8Sp6r1BbeVq+PINZbpC1pVpNQGNkFlg1nA+YD0qpIGA+gdLQK4gdECroEp8P1QDXI0eK8O0q1wjaIXgACABNq9hBLjB7eRWq6BgpDbldDEUAobSmkLeNiTQdzKPgFHzKmIJTNDzpRmCaaDUJUN4CbgBgA1-FohtkdTVGw+tlmgTii9zCigCUESDKLwZHtXrzFfbRU3OIQotA0NUkSxnoOP0KrQoWAde2eZpf4MV2+Swn1xdEinEnx7eRQSVgf6AZow9QG3CHrobSAD8CY3Wk8lNQGbW+91i7a5oCZxvlSB6MTV08zRJFjpEHGQCJwA31MKoKEDbRCToBkAXgVghqIPD-UGtLZeQHwNtSBlWAvtHcYEAgaZgdUBjZgdehzdW4ACaYLFb97AFEA24GmsjbU8t4seDkMF5DTZ0QM1txhF1AUaJlrcW2TgpCAkg81ACtPFVHkc8V5Gr8Rq9ln-MIVAQzQoZBw42ceoXyHUGgKkHEBbEizAQ7YDugIJQWta7uCy+i8bQjQScgTuQ2GDiJtA-E9wZTA1RbqsyJKvBQK6cElkobgJGkjyEkCEq61iN0QJXa31xvc0ZQYL2tezapYAJMhn8BfwbgkkcIRCDajCSgC9AM3NMtaLQCARCAgCKM7f1CZbd-XE9jBQIWQAkwS5R9o13dLvIGOkDVtvzRt83KbERjQoob6N4B5MbD5IKtFNWAU+UIsshsDZZGrMYhUTug1CR10zS0EhDZ3asWk3drk5WYICAYJCUMnIqFaa6CXLBE4Olml1ImWaf40oMBAIMNMH6Vi-hsxhBtFxQM7kE4gohA8CCCCGPLdAmj4pXraKkCRzRjgGUlKSobiBTRVvAS2wElALGIsFQD6BVysXdePIcpApNBCTX9Zu0sF82xmpxXaiMildsmoqZwS+tafKb631hsmIPEWifSHiBQIln0KUDCGwz5thMB6JArPDVyEAa3RI5shumjCFs2gFUQADpQYRacB9QFrLe0aqGAMKAMPY7eCZeFCKrYV5yhapWdMByFBIILqAmWhflXaFvrPBJcYFVAdz5lA+QF9oAxWo7tU1p8EDJlTtlWlEtsok5ABbl+5rkNUbwVEVVRJcHDPtACgC+SWPImNgEGDCQGNoEOYPD4B9b8m1ADrM0AKwFTo4A75YBPaokwGwUWItImAhMTyxC48MTGnOAl1AVG3smumQBFUDSVdSRVBJXHCABZW4CaAy14DwZZMHt1XL6p3VtroyO0+qCiNSqAH-yd0AwhDLdH7VU0moAFNuR-dCqEG3smzgDBIxCB1c0ngAkwFBkL7AaGr0bXA5qUANDgFLo1YEI+iA4vpEFJAdDA7ZxVaAK1gFAH8O+3+I6aExCb-IDLeMEd324e5mfATlPMMCpKivA5dhNyEC1txkPmOogwxBAcASPhqEYBVWqSVOUAXYUobi-AG1wWPNaqAkoAB2kTzZh2-sAYNjGNBaIs8HY2q47Nahha-WBuLhdarCaZIXlyRmDKuHKEJZQYqA0jqq808qquCN1ERCVrkhESBkIObJASwPjgzsJtZR7onUyGUAx1gA7ASC1uWtPlTGG2xIADTHkgLQAfDZIVegtpoaK0gspuO6EjEQNAZ6wbDiBJj4rT32gzAUTSX2i8Fp3UMAkUdwh4ApxT4RX3jf0OnuV6NA+5WTFLPjYiS45kNnByrVromHAFVa9J1tVqm9AMZr54OA4QsIoWg2cD9NvaAFwQdEVwzbWWD7EABza6cmFCX6bKW3cUndYMn1DzstzRSYD2GEy0DW0N1NLLbuKDgUET4JMoTltXtwNYg8trTsD2oYuNLaaDK3SMBmoDoOjFNOdSaYDsaHDsBLANYAsGI9NQmssI0HKG+MYR-A9ABT5CDoA4qqgVlsgY0CT6HfEJz-Yigp5rsi0EpGGZMkQbrsOA7yuhXajrMe461Tw1pAh0jB8DgdNB4dpAmDrKbAwBjvUFZmAXt12AHurNbCDTEfMH7oC0BzQjPvFlOFzEHRNFRROEb6JuGraoQCLgycrJy25wAaGSTwVKgkybrQyMOCDGMDgSUdXFh0RXk4BcGL-gXCgHyBWa2O8zmgKqAP4JGbLTMg+iF7gPdAMo1O4BgpDJ0HPcAoYemQddoLq2RJoSIjEmptt63B5S2eoBrUU8QVJNRHqMk2uCo2YLAYLyg-XRsohArBwkD72yCRzmymqnbhDiEHpq8WwcBhMSAtMGXRNuEIGQjZAIGAv8GKOEKwHlVjMBsXVrFElgHvGP7MHhM4x3NcEKoBuoSUgKDADlD0QFHZNDIAXtn9I1Y2RYH3wm5gCR2NCADQh-kCEkFjwCDqNubg4BUSiS9lFQYfQb8AuYC3MBgUDbgHCAu5aR0ih4DMIJ2G0MgQRb5kjeYEIiH8QamtESg-YBmtpYgNLIU34ZOJaMCgfl+KPim+CAgGAiU3pJtJTSCsXsAvOh6XCNTtPgGxEJSuaSARHGfmHFiMSnJTtaFoybD9oBqEFymrSA9sRFGD8poulV6KIVNOXBcTFeEBIlgaGvUQRvrHE1CyDCYc90bYdC+RXxzVUBT0pfAbXINAqGYgI5HOkVVkIrw3aawCRAIGUgITQKSo28gIDUtDG7ZJceM6gBLB-PWyEDWIDLpFn4SI6Pm2W4EBHaV8HLg2iBgLJ2oE1IBhyYT+1YaOYRMiuPQHoGNkVrUqw+iNkFMEFA225gBYR483wNrNMIg2tb8HXoZQRRlsxUIKalWuRLgsa0nGBxrVXKxf8XarfuR-Hym5RtK1zciL4UsA9NvcgDsiIAVIs7Tp2QIFrTdYYuioWATqQB8FBSDQEgPqI6oRap2hBDhgI1O2CwfiATjCXVqHTTBNWhAt1bx01zhFJgH6kGeAQjR7YgEcjr1cxgVMgElqIgi+IFOuKzANdN3jdN03zLm1QInAX1NbfKIa3arB52ez60Yg1Yg96CzDsW7cJAZbtE3AZGDmjJQgOx221gPAqcrVppqo1KG2qXAVORgc2TlpooOgYcaAxjRJpypTvcCOK2g3QFmbG3UiVBoFaF0F8NrnFvVAFGE-DXB2KMmHsAaRBdUAFtZgGdqAPRr48gq0BtwGZmw1twH0mDCNGCfsH1IR5Abe0TZBikC9ZRhIQegoqBvBQPsBNlX1QM2V4GAwvAzZoswD4QAPgvAxozB49oOsDsANjoJBBq2DZlEjoJu+dn155gm7DYkgqoEuCvtVJcNQx3NRoRnRowDaApxBmsAl0HaVfVoZBdbealsAVnkjuJ6gVCgvZQ+sC6ZukiPpm0+VRmaV-UX2GTiGb4VqgYGaAY2ckHajbQgIFwZ3A-ejYOEuzMfGBdAR0RWPCKxktwCXar5tBiAhjXAIFpGmd4KKttnQ-YBhNAn7e-6yrV2sBIW0hbADkOa1XsgMNqUoCodpjAAPwQJMZfUcCBvZt20LXIKiAyzqqqDWGGbVSxSGqEAOBpyDGnWVQL6+YPelPbsnQ09ov4CagU9hwPgLEmP0Ey0LHAGVIzLadTVRyt9bHMQbAtC7A+cCUrmqMgGgDpATO4kJW7MHRdT0AUzYbMw4SACsD+kIaKySwoMAMyAxavFpRJgTwwoc9AwickCloIamJXo2vay+UVLoB+DQocOgeNjHYCZnUNFflPS4hLKBxMDQPAmrDmKiIoT3qKkDZ0poNa6kAQZtHgGDX2tCYNf6QWAweUBGUj0RG9EN72uqMkqzLaAAFrHoNWAIrotc0NPAHxOgTnFUXcambAO00RaJy4NGYHSI0zSn52oIDkvknsTFQGggJQB6MEsgn2ABPQsPBelIjqHClTIUPGE-NaDQiyP1lWJ-4dyAhyB4y0SCF39QHvENQfgkq5XD6DSIPTdO3gLMIVJWp8DEQE+wTiOvUgo0BfEH-ENKIZpAFSgrtT43As7RkjTuAFRgnxDRCvRcJXUkIdG+9pc1mQPqLbS2ysASyRsNAols5KB42s-43jblUC+NuBpJbARjUn9IL5DLERNgL8sbcAe1Bscjo9rSmEe0EOQXIgVSCPhr8pC+G6cwuDJP53Azt+IFvwIlAJW0bOiatsVMKLQIStRZAiDDikGqkOYwf2Auo6PkAQ9qH4GVAa7txMdP-A0wFGpSvqYhAu1AdsAu9sSzZrWODVZ3hSgCnQFx7fI4Gw4tM6hAALsGLlQ6wQegyukjvDF5vXHWXmrcdleb7wS7jtOQHCkGYYVZB2V0eVtUIC+Gko6j4dtqBkEGXoLQoB7wNnQrsAt8umEO0QNqgl+rRg6eWsp8BVwA8IhQheBjT5tHoLPmrvVNSBGkCNIEeEMvmohAjpADZmVZicnRT7aPlJUroLA0KAA4PwWt2s5fh1DosqvpkCcQN-1L8AQjXcqpywmTiUEFmDBa622eqfFTpcRhVysYikgjeCXfNA8OVVC+R+q1Kqr5QFT0SY1GY4+R0ndsFHSEoFcNgvj16jESGviKmq2ZE746ezUnwpegAA7Emw3tkWixmbBZgJo2fRYW1qXRVbZv8IJrWKiAeYTq1hSLH4dS8YAhAHUb5W0HcCgjPaCbfgZickFV-0AetaYIAHVjyAOA3AIDsKaO4EvSJVaW8BlVq7HTKFbEGG0hfUBujLsQNX8M6gt2b-MAHisVrSrMb6gN48Aji10CHMKRk40gACBidUIMBjNfwIbJA1nAPoACGs1IKoQalI8U76hSJTpf4MaYEGgWpAVaDUfDyuMzgcWAIUQ5BVGpp8ldEwQso-EIQQgCaBzbWZsOIg1SKUJDlABl1X92pf1KIZRkDU6EWugSQayAlOwm8BOFpUjdqQTXVOyAbgQcfn2IFLQVlCYbB0V3ZooMiII1MngRHhxHbrhqeyE5UTHw6EBu+A6Dr0FSUWoAVWcbVljbtB0wPdAIlwOFFoC0TkF2VRSmlVIZMx-dD1VHkcBJ-dotCLAbkS+louncZ3SDAtY4K1XjgGW6CZ+Po04q7c4CSrvjxBT4CBt0REuzUQ7AQnZjyjxERmw1iAclrWnEQW2sdOrgC12AxhenQLWuTgv+AqbDyRsLrbSoSzt70AApmj0DTaKLyU+AhjJ1Oh1BF2QG521rVZDgXrWngEF8VM6ZdNYUwnkAL6vaAcvq8H1QBB-PFXNFsOAiGQHR4JbpwCvwH44EZMb2yLtC-pCO+LkYPMCevg-KBT0BWFAFKAvAQGQzmrdWCuQPvXf54kKJVcAymBsbmObZOQX+VljBHsDU2p23d0OkVwE2BQg2n8Ab7d76lNASp8wrW2CTNWodErTtNUB4qbtODXkPp23LVwoQvUAKOB6AObYxnILFRIiDoppawJWQFGg-HIL+A5XGLvJp047g0w6PFgLdoRtKDUNcgJJQgIiYFyVGDfgfogtsqmIAg4EI7cOWjv+c91XkDj+QEHZgfbSwPbB8ojV5v9kJwK4OQ9LAyv7B5E+3efAQl1IZbkBibVumQnTpYu0XAhI5BEED1rj6KN9Q2Sb3cirnCzaJiQTdg7FqmfW0zoMQB7EciSfgrCOiO5GiIKWLL11yeQSRWYIHRENFQfCdmNgmR12OF9gAyG55ATqAjS3JzXFiJ+geLxq6hKF2+ODPHFjoApAxhDlWAD8oUTX5YJUg1QErh1GrtrkK7oPstOoRKd1DlspwhzwF5ALQskgCRtqylPuoUYtvsB8EDBSCWpF5wMLdXahN2Aoiuyna7wdPIoMAYEaLIGK3W14ALgYLBwcli7rcQBgsBi10u7fiC7ZipcLNwQBguGq-4BkQBcwFIAexcJ6rgKg1gGjUhCwa41GVRbEARpprNZ22pVCBuhR3KiTEfEA-AdTV-IbobahpDvUOUk0zoq0aRXCGwBn4PkGHmANHaR9zKBV-NQjaGhQU2qFHBwICigG3wZkQPqRfXA9QDeHAhgSHgWZRV-CyeXVLc4Ef6oQxaUuiFMC9cDegPIgYg654ANKsQ3cagaAAsFg5aSeqAzIN9u3rS14ganWyUB5IHzALGImvb3M1heoqXekG6SAzjYBWBhgtsAPDoQksh8aTjxGbEi+i2gKjgIKj780pyFc7c-mwbd--FSfDfqDQyGzMI-uE0ql9XL8Cq9bNu-2R9MQtzUkVy73UVGe9WdkrpVB6WoWbTaIcERF7hUOS0iAsVWPuPOG8hgRYDhIEh4KEmn-5FiBvHDc+HHAHVgP7MspxErWNIF6LdAG-8QocFZuD19uTSN765vtYxRkkHlgHsVflAPSdlBtDJ1uGsi5WncAIEugBH7R5IlH7SVq6cwNi6KtXT9sBiLCgBWVM-BH6Aw0reRC+IQQV+nA-9UIwjjwMMgSq400BPs23cD6rQg6-dQg1aK3XTnySaCfupPUzgQMcAX8C5wHM1TLdX4Bl+gTwG3HO+IL2N46rLHDuKHHuo6UNGAtexf5Br2p-aDLqvGEMe8-ODS7plgBQgbvIUMB3djUtAkhq8uj8dDErGC0d9Ee0XRgeSAYQhJ5SUsBZhClQROgH6qAqT4SGAsPfOqSA5nwbsAiKjRGMOGguAPjhT+DjhpGHbkgY8ACOBTsAw1u0sM2Wl3gksbNp37Fp2nWdcV7dV0BZV17rHDpJ0mmwAXEF+FUwbiGgBF22Oti0CDY3YrshzSCaOYgEKhiJBvDiXLW0qgwgFaA3lphXBGwWFAeyAvMBeSA6YB6Nbam+l1-zTjF11TqugI0kejox4lbA6zKt94BwGboI28Ab6hQQ0IcEWGdqAU5gcNoRcAcHQoXRvA9Q7IixQeDxgCZQIfd++EM0wngGCmURgFEgs2BpPhdZE6XUcOuCtpw6lwDyKEftUUq9ygmA7yN1ZCrX-GEkfKNu+tyFAwsDTXZGpcxgQcA+ma6sFVQAHwN6Asaq75RRUDTgBnqqmAqxB1NCTENHVVrAS45H0qPHQ8nApgOSIbsUYzcJyqqkDEcG8G1YRVMEvg02iFuePuYYTgunqtc0+xuTdArSLgA+3AYWBa+DpzVVyKddu3A61qzrrMDcIqn1ITdbBxgJ4mmdEmgSbdeB61KAzbtK+GgQCYgqFkhJg6wG5gJ22i2trlkBVyPHRfaHQYexA4oxQShUUAHsDQwGtQiO4Tt31SvwjZcoEJAQ1ArkQV-01yDSwf7AUqAG9Wx+EfUI2O254kuBrICO4H-EGhQD5CiQAld3OstIEFfQNXd9ChgDWKNsRHbOgZEdls7UR3Wzvg0E2ADfATU7a4WjHEhMIY2vndECAPNxcQGpXQTo17sC-bJNXL9plNYdAD98vQSeyCSLFlPXaKY4Vf6B5jgbdHCYLsgLjw+3aOvTSzvWNV3QL7oeMh8zradkkNTaIUQWfZ6fk0OpAFls2SQImGmq8qB1prRwCjYaJUKQhtFW7UF0VT9IfRVOdT6qjbdHr4B7asNA2-QZ83KSC71RbQROAvKKBIjsZH50MkWq8ptBBDzX4VAyLaZOyjgHPAF5BQNO0gCdAA+6PehmY1fKFWKCnQRHV9Mg1sD74Af8DFKGxtPdh9d3P3w0rS2AbzQcfrwCC2cBAtYzkdddWZA1GDZCD7gOG5DCQj5AmoB3TqF7Y9O-qAd6gC4m0UDGQM8HcbgJkggOBydoZJX-gJkVRqB2xR4X1LwIBAdJgCUxZKxngAPjNp2sPAy3BD60zmsr7UDZLHQvPA0RiJ-GJwBAiJvAZ+bLV3W5TcaFRsWnQqtqnOpuCAZdaFgZYwnIoHGCOhAN4EtSOxoslqw2A1IAuLU1ILBItlroUTediUzI166sU3eAPqCh4DoDZtulKg226mHCYoF6ELdKjC9UlQvgAGEGkZOyqf0tQCMfSC1RAKIOm5EKtK85NU3UVrg9S2AGn1UHhYvmp2tQLVV21BiuWbvnAsblz5UQQfG4T9hsngl4UsdUD4cuoR1b0Dg6lHO-t+uhlMawA-1RbzHbYM8CE7N-4xN4iX5talaryB7wnqhr428PzGJPfGur6T8bRbCUcALudOoHoAUUgKDS9gKeQC2KtjCfaRrHnQWvuwP7AeTVSc76GApzvoQcZIBEVbGQ5iDIioGsFIIfaV+ArBckwUGsVFB9cvV92BkGjMBqm3fCqgwVdKk8ayRVvnIJVcelgHGRqEBRSD-tG-u3R1i-p6IBGhDDBeBurBQZbRXySo0ketfcUROgCw7SfA24EYwBDCe0g+Nx3hDl9CRSMZgdIobggd033sAQQF8gduI+HA1CSJMHhxAKyArgZLbFcQWBu4FNoUiQUVIqMiDaxEFneDWOUis-LaMA9YtOXTTKtywO6AavAjSpTBpwwaUJc3ArkAG7HvUDfwB8AF0A+pDZFD5oDbu1DkQ5hAWAGEB3gDvY4qAO0Bc83EsBfMHVABLNTZBj62VgC9RPAoehAxt9hlFkXHOGM1EJL+gzqjdA16x3AnWwNW1lV5NbUg9Fl1PmW5bJT2Asj1dqBnMkGerUAIBBuuzVgSLYBOwHywOGKbKIE9H1oOkwLydK7lP8BHMGJne6ekq1o4rKKDjivpfi6sALg4CgYt3KIDi3aiIZAgMZy6BXKdj0sOxSfb8d6gj+DaQG7MD4QGXAj9ozWzflh7HXsKOXM3bIvLBfUE0XXmAHeAPhamOQN2Fb8FBup61BgAU0B75tzAEZ2iGEq1M-mAnLoMYAhOpPwUWAmPUoFEjsCGBUONx3BBz15TFC4OgequJ1rR+lDvxp9DTOACgQuogmj4PcWUjedgK7AehgJTCMakD5EHPFGgLyqqMD5KA2HZ8qyDRibAoGnZWAgePYGlvAkRAWxV7UHXgFgUT-0txhotQNeDnkDnLCXERfbwKAZyHsMNiuivtDjBuKXcLFJgCqEcUyfHB0agKQRYqPcEhQQYuCvTBUErEvjN2Jq4UcQUEAU6BbBDiCjMgmA5aWwFlHpuHW7b0QrOJu0DLdBtdAz8CLARUBzODK5BS6J5Ad+ahZRYKBx0HPAgbsOeJ50BPC0LQE-0O0QKc4yp8HxyqfAL4DMoGF8dpBtwBz4DTIHgG0ng6lJViC4aQqAKOgaGArnQjV3qJpBQRpAbbYBvUbE792HKkZ36VCIn011FAk8HJUPxwMdANLB2eirEGmcuGgchcod5CEBLWRWkInTOtQq94E7agtptkn9wU5Zqqq8UIkACPKH5gKMQIqALqD1CVVlbDwT1Qo5bOkCU1FZoGMMboAWFb+A1jDGQrJiQckQ97BYGCJkFpwClw-BAOyom0xEEAV9NVSKtguARN9WEsGHGJUecyAm0VpjARGCg9cgoZtQHFQ+5qQkHhwAfGYAYCcYLyVYEET+BeUCzVTg79V28YBITZkqJzAd0JAoqaikRIBqfTKQDcRuAA98HHEAYQeggsoRllTR4GaDcAcOgVU0AF8g7lyAXGRoKDwQm6U0oRIC-sHdwF5Abh7psiJoHiLSKgC+ASdB0OC1yBczW+wYmgg4BoTWVlrjwMVAZoNiWBGpAscOohDNvQ7WbzR+4Bf2ADcPVAW0wPUAfqDy1GZ0LX9NpgA2A7AB6rvvpBFAYkUkT6pMZdSRioT1hERAkkghACdTqCJs9OWPAoQ790VD9HO4LjII29XSJ7ECYxGnDjtMD7ATlQvRSjQFXQM2oTzsp2AgqxN2DzYL5tbgg4a96JDAaDuYKeIX90DegOWB0BBtENZAPiUSlA6rSfpGmNudSfOIfNAG1B8KrywBrEWnQ6YQFO4qzAcgiugCqg+vA1WChYEnAFvwBadF8bl13mMD4tpaQeIEFniE0CdgDf4DPAFo1vEiHjh-QDzWQncccx+D63VBanEsPXEYL-wpcg-zALtCJpDHbalgAcBNFhaMBEcBUAQVAfSBHtjy8GNQLQu8BAMO0jbLmmBLIB0gWAwvdR0lX9NIH1kDLKygrTBfvCaqUKoGDgZ1Q8j7HyAQsFhrKlAGbwUlRAIC7UC6lsIIYREcfbfMDBACj4CmAbXIKtEy2h7rljNQbW5yAL5hpEATKEYEGVe5mAJEB+ADzYG4FEzoEcAaLxx1jBxJuQOkoZqExsAJmTHQC4EAjQNRgfEgm0Q7WBw0MVOCjgcUtu4qdDk06NI8EkBpci7QSpTog8Btxc6w+sB6JjeYkmsDjQKd1BagcqDe1A21FJdIcw6tRKKmw8DclIIQDQ0U2Jm1C1SGphvBAXWA8Ox-ARpMGePebBS4g9MxSX0FzhSqM0cE9g3TIG1BIECiIJ5ALzBmb01kARmA8wGb9NBA4356VAenpuYMjSA3QblhwdDyUFJgIfENfyz1kP+AhYF3Yq7gPdwr8AUaDjuF8CM6CT19URANBDRDuAQEOUKmwwoQ3yBSqHdVf0zGKAuZxBmClUEjJPvoclA77zRAlibzHQCwgJP0D4AMgCPIFq3ZLAUot2NRzCFrrgXgBoQHGgC-z833uxSYMRBIZpAdbhcqD3gmZ8H1AIU4gzAqMD3sFBqBEHP2QAQJasCP2iVkoiBF4RC4RXb6YsyRZC60f38iaA6jBwiCBioIO0GQCOpATAdIAkTLQe5QU-4hmCARsDFyK92OQotLAqiJlgBOuCgk4TgkIh5KDlYCsoGW4DXQeVBiyimcCTojsSI1wiHwUCR9pBooArgC7g+Pb4tCLHuwgMt0S1g5UAAoAxCGiIJBYyKgZxBOH29lEnfXtsCbgUXQBbllPDWIFfjAjgKDAXbjIKGnVrHO4qASahYUCLilttcqPXYoCLgANivQHa4vZemogA+goPAdvFM4Iwg4DcK5rry5R8WeQBImNuAgfRIu0eNsiEEE0SOAS2B7pCQoRWkKG8FNFJbLMCCNtEvIMNNXCo40AiUB5E1JYc74VcMmqR9314wnuUEe+6XdlcB36kKGDNIOyKRXgFfAIXS1JxeaJpIH6QqdJpIj1cHCYCtsgFiVuAzA3GkAGgHHiR+YzoQ0hAZ8HkcDyWvwQhLBe3DaUQB0FwIdHw92Ab+CBaH4YBzIFFAsYQj5V0BDMZoZIbkIxchuiDRVqAiKpASM6sEMG+2uoBx8SOoFZgedpv2DFWUbmI9gVCIt9AM5C0wAJwM90H8QKDaNH3h6Fl7uvoN3gMBLW5D58BLgPYUW-InCwpVChAxpSB0wGWQngjekAPwBfKg1+mYEi36qpBlyDZBOCIYLAcFhSaCAYDiUI1wA4snEQ6wC+uX9wrhAN2QaIw8SiqJGNgINABfIR4AopAzIBnCh5+qLAXn6k5GQMGbzT2+ucEfb7hOBYQFUgHV9CxA7yASxUiuAPhElARUw9korE0AEEuIBbkuJAykbJ9DuQA2-cAQDFEDtoDbQfzEz5h+jBeQt3AkFi-Ai3BrOag9glJhnRh4yA-4GJoPpAmOkLRTOQDAYOzPR-FxtNQVAauDJcTi2fUIebB0IB+wDIcLa2Ar9vpB-TFbICxCBlUN5w-sAqIgi-tvkE9+pP6MBURli20nrZHbHI-g5gAq7DswGsiKeIL6AU3KFv1zwALQCUEvzVglFUvR4e0fkKw-aE4j7AlZhp-FXAE7dNXuy8x-9m7yF5IAPGtegBjBMtCEdGa4M+QQ99sDAVTBhWGHVJbAZiwTegkhIqSFAiPlwA3Yu1BR924liCaESQTF1qlwvfh14hbAMlwFP9V771AZyoOgnKiIF-gXch+0AQP1uWMdwbvAkwhCUjUgBnyGQ4cBoK6Yq4nEIEBdV5gK62Nz6yNo0lGZvusAJTAHiolr0pOKZHlLwsEJmT7UcDAHDWOMZ+qNdVhJxjB+zHtmPJQMUAm3gAq4JqGGWAMwIaQPsQj4DgaHDpPa0YTAtALc2C3WodYNBMbrATOhExAI4EXFEQwVEdmaxiX2rYE7gITkJ3IndBQnTrRSzELuQPEUBrAXJBpokJyKtAYTAlF6kRiEsG7yFRQPTAfNAf8W4VG8EMfgWH0D3hBISI2lsUMv4X6A7OBdgAwoH-AAj3Ztehbi9CAh2F6VHKDfPEC18l2Cvkj44HtALY4k2UZ-BVrsdQFvWKkArDAkXB7xUggNZEMnQcQggWXBbrG7IUkxTou6RP4Cr6j94J4EJ6IZljuRDoqvI0Jl-AaQq4AL4RDOi2CIe+6zQ8Ja-qhWYEquIAsKpEq6B9iCe8BaMOvYVEV0b7u0BBIGsyJaQaJAY9wAdCE4Ex0Bgka7AmRaFFiUcBNwC40c50aqBgTKwbiJcMq4F8ISQLrlA14v24Ax8NSQhggKgAtYGafU6JUmA+cBXUDw3oGqOjEPQE4qbtSD1OuAJbd4VzWmqlL+CdwGyYEoAcda9bAZ3ISJnxgMJ9Wq18nJBo1ofrPPa9uyuA1VBi9qNWGvra3IYF1VCqZwDmrGUEKEqN3RV0KaIxcCCKkLUkDIABOa0UCJIHcYNI4gY8pSBnQhPBF9IDPAVdQEvAuV5WcG2BgfYSBkaqBBABeAMmEPDCQ59NXgTn0BjDCmHWwEkQbMwxHCY6GOOAdAZOwjPQ9EAumNQ4I7mqJAVXcNGDsaER-Wu6dgQl8RS8j67stkI9sQ09nFAahiPeOJEAv1MlxJQgLiKnQHVYGmQNQQD8BkUBDET3lcagMsuPR4Lw48kFafYbEdp9XmBWCD-iEjgBiwJBA7SAzsiJj2QgA7uTBputd29Ca2H+oCRAQQAr8A-GikyraYPS+wNEt0Ab4gyBOAQL9oE6MUtBmDB+8FBeP3YVtA1ARyFAR6w+gCNANNoPlgTAOvdkuwESGgtkkr6XGB9gArUPBgYhAoL76AiStFJpor9W7graArP0mRCWoHxUu2OYaol2CtkCJQFwALH9FlhRy1QwHe5HbsXuAvTxnej0LF7cDUkeSA1jA8sB+YCKDDLJC+mJjgbKA-sGysPveHeA3AG07DsTvuKXkYG4Saf7RYi4nHlgCiEPRgKSAOWANoFVlYxwkNgVYhkmADurv-Si0ga49+ge0DJMCP3odwNSQCWgUbmwGgONcTqXSgCtJrGDYyth4MKqiJgrksB1DSBmyA+zoR7AK0gHSCxquOOBjkauEYww-mDo0DQhP-IevJo0xELD-foFZHR6jio3sokuB8wG7MMKEIhgvPAWPDywF1+Xa6rtQ1QgK+A7eBsgGSIfSQjgDMcjOkGcgDhKs3k6SAfNBWCDZMMyCYr9-yBa5A3jQ0QoRZTf8i3BMdrw0je-RsEdeQx0ExijKsBzQLp2yIQNBAF8h3SHluKheqRgvWB3hCIr0PiN0kb9g7c50zBJkXKABcwLvg+yhZAAiEArSGFwDWIDw6ZTZoapJmvYej6sEfVxICmfusyB8EJ2QbfgCWD0AbO2PRAAIoMLBzoCPIHVQOYgJsQfHAC0hSjAkFeFAOMDFBx+0BQED1EIEgNciCagGYgMhpaALXoK4M9Wh+4r+WC6MMH6tjoNOQUQhZYGZeKx4GlgUdB7mCJsAjqCjkHBIQVAmlCjYD3Qk0gFUASpJgFpmIEEOkAQbxQ4rJwWrp0DChN5DB+NwFQ7QRCXqbAChAIiDhX6gVBY-tbNtZ0EoQRHIinhZkFA5uoujri+1AxiihIFTiM3AS44k0AwoTCFkgYEZAAY8ChAjC1FcD9ePYgDFhpOR03advoAFFDkahAMRFO2nouOPOH8wHbw2UBkXB7UixQNgIJ6IqLQ6ySosBeEPiQfQ4jhA2qA2AFqYKlIMN93MJQEwoFjKgFYCQCQJEA6yTF-u8gKX+hjAJ5akRiaaEAiLMgGngDckuPi3cFhsCqYaAAkKAS6DWkDYKNtgIJ5e3q3nAEWSNWeHQG7AS2KJpCi4CdSN4QEwV8ChtjDFvhLtOQ2KxETshV7h2CnKFHMgBM4B3Ah+BD3DbsEEIdBmLBQMHADXCIaJcO5bJmmg8wl9mVd0GG45QQsoaWEAPyHKGNKuZAiff7k6BhyhAnGzqT+Ag0bKOAVEzN8CPERZw3Yh-vjM3rFpMWUlYhk5gT3BghG6mKfId8AE5rwKD85kAHd2c6ggQ3xKrhEIHnUJyQGJg+Pb64IPfsIpJL6mCAAoT6NZzoARtEC0fosKsB1gB06sw2IGRL6NiOZSAO+1t9kFdqJMDlhAUwN74D9ZCEoZKE6NBm5JxLHToC0AI2EkdBalASFMgYDFaOJ5RSrX0BR3pcYNlYGzQKVQWmCTuvvMLggAek9JhDXI6-rJiM60C8oGuh6JAf6HvpGmUCZEyXAHDRvgF3aAv4SzYLf9oXVbygR1AU0fO0x1R2UiBQaTHO0oPYAugbloDoGEtsJxQEWAYQheWCleSbsCMIebwakh81JRUFDAXMYfxA6bK0KCvUCs2nW+9ddtwhrwOwpGkceWodQx+1BFgg0bVTA-ZoGjwndB-5Dw0CGuLZeKQA2r6wz3vCKQOCZO+eGAabd4AfTuXKKsQV4gC4AZW0yPy5LD4Bh2gh3ApmwIvvAUOiE9liJZ6TF2kiBb1faIdTdy143oC2ADawCGCB7A5WBykBwVmfJNDJfJA9ABDnANPgWwBnQFUiaP6pKhkOHg4MkuqXAHoqqByXLgHAKgQEpshqAV-05NCCULdwVE16+gfKxhmEjNOaYUiA9EbzzA7Ei5SH7AFgpgFMcNCQ8CtfVxoBZdLKAVeDgiuLNlTBoFYEyJiqgQsBeEA6m35YHH51EDNqA4ID6IEqlbuAgdhtwcJ5KWwFuW0qQLiLdwEoGOagPKDF+kkkCBsC9PXEgRnQQj7HiCBTxy7paBOOgrzxyVjoWElwIAsAgJf1QuyWRAexgHTmg0D1VA-UghQcgA3PAY0AAKhlxUPOHkoOTY5YwkFBixI75tSgOne3XgOSAqvFkrAjMKI4HvgXzhTQlNKjRZbnBp7I4+bCECfYFyQBaB4Mok-IMyCt6HHIH2MQtxF7EHIBzUCg8CZY9oUGYLvWDboHtBHhgYCAIWBPz1qQa-8KGgI398hhp4ApVCXAO7HAwgyjZbAC9kpkXfnOEhAAJp+8BZvvY9CqEMuSCHYqRBFqAPWKBoNqMccA+jhnvscYG2+9gEZL67lpiAEXFKpjP6If1dgnG0kAwFYC2R8gS0HYAjHYzEyM5QAjkYv7OINAgcxA1GgREKpFhanDcCEjJoOSQVAX779Qir4DIiOqyKZg5bk-xyFUGXoCgwWu8vZgZqCX9Ejcf22lnAtlQmQPyxC5QL1AVdA6tzsrwLAXgTa9afGg+EgaiDuNAIQ2yYbpA0ZtDNa6ABrtYOST7F9Egg4NszFB8KHB5BUruhH9AoeJDIHogHfAJkHANUKYsMIIkwJLYiehRki0UBP1QikGyAqx8-VDXYHA1a08ANNdphdS3ykBsAEtgR1QDmVTwDGcEShauZNGQo2BBqkNgCh4JOO2MgGvg9oBRpGA3EnwPoQxXoWAMFNojgIHICGwgHwZAhlE39gEA0YnAc4Be5CBJtCFPdSxQwz9RFyBOLQPwMKQTTQN+Jv8D8zBwhCM+iVUi9BwSCIIftQObgRuAwAt5QMhQBQgLXCtdw4pBoyRXIA4pNAyO+Af18f8Us2g0IFDIDFAV778dUPEDppCMQeEwzzjIeBYGERILp4lFQjGoOQiRwCIA4YQBFwSWwFgU0UFPkGu+M6gPtAgsor8EkUagQItNMDI6iDnOgPkKWwDEgykbeWB2fg1cPBwfAkkSH+wNYHq2EATQNpQTCHZ0DqQFUgKiBBdN3ZyGwCvGsK4I0G6FQdu58Xo4dFJwEEgOq0tBY+qAcqAZHXAYLMolG6DKj4zhQYIknZ-tHixuGgqYDK0PvYLF9WwhGkBnQaNwgUBioAWMb5UOiIGcwNR+n99a+BoZgMwAO1ljoAToB6B8e2j0AVwB4QIpD73loYALQAPCD2YbgQKSBdqB92GvEHykIFY3BAcmAXQBN0B5CPbA0U1g5B3tm-xLvgCa2jSpQ8DpLB+oNfFSJtyeAZ+ALIZVCSaBzPdWOUVimlYBXAJSwG3IaH7lyj9kBi-YfANl99kQOX32cF0yOp0FKNfz6NISpYHpwBMiKzIlSHljAf4gTYPDsbGwBf7nGFfMvU3T3MX4QAcAgPKM5H2gFHGIfQGCBMGhKQvRlXZuwGCQAhuSA-waQfX2RHP8fdA9f2IkClfW9kFbVgKx0ABKzBEUQpcPnAQ4B-ID2tEPgLvQAqDPZhhxUBobcKIugA5D3oqVkjbGEjcIVXWHgi2r-kU6ytNIOxkXHAMcAK+XACuT4LGzG4y2Tpr+RZnBMIEewAPGUxM6BGRSiMjdb4F0D0MYcS1YllPgFFIQNO4sGqMLw4h1-WkweSATqgRqiS4EAgLQh8RYJpAiLKPge3QIzADNQNsHUo0FlH+RdyavsDQIG9TwNZoDVQbsSmMRMgTewWoGCJeaoBHYQYw+JBIr3nQOPIEeA8td1uSHkBTkD82rEDaywWLhBwE4MLihtcg7kAuEAjMCPbqeIPQ0-yLsxi3pqsgLJFUVoJCGp7Bhs0qyLH+-29LbBg0CrFF4oP2geGEUEHFPwEaEbQA3JTToMyGgB1UiJqXU9If8wvsgTKC3Qp1kO8I2hAjAhzcgDHiE3QbgI1wRwR5dF-EAow-LAVqg7ehZAAlkBFoOlg0+QsfbKOA1EARWP84rUV4wiUGBtyAuiDt4cNyXrhQGxTvqUgKL6v5AjZYzWwMDjHYPygIUgJBgfc1oLPMlHvBwD4PahlkPNRjHSGHgA+JMQgZcUhht3YOEEK7NnkRjP3vgF3aN2GDQ0GCRNMB1zFUg1YSFpY2xrw6mtgE-SC74NEQ7jTrXA94DW+AwONCSxAGQ5AlogLgwHIc9AOblDiiLiDzsK+vJFw9Ga54PFoGk7S1QbpQC5ziqAo3IgQGlE--oWyBAyIprjcw+igvqWN+gqNSHwaW+p4xNeuu1Jy0xe3BPdWgskdM1YATDRtQCT8JKgJRAk1hiUr+8AWsPwSosNlWHoCACbuZ-XVhjMAfWHG2gdMCB8ENh52EbhAQ2BS2HGw+hQasA71AtBARviwZDmoZmgvhw-VBGvrcw0XoEB44UAo8hW0C94NugJQMkLL7ighaDTvXOIEFUDYAzoC-VvIQPsoN-ghqAkOBTVnBNmJADSyOYFiIVVeImUJnhfQgXAhGEDOihdaKcQIpYmIgvYTVYFlYEyw9zYdtjHLBOytUNQe7OAUHLh6SzzxnSKKVm-PECZBtkCA8yGhudAJcAQcBOuDyJKpYH9XAOAILTvqAPVGn1JDXNVg31AdUwqzG2QMsBVEdZOhQ+jBOJcikn+lSARztpXIn+FgYJhcYpM5ZjA+QtQGEwBCOVvSNf6w-DTOlK8NpB5mDLTAyRDiiG-wGchtzoLOg3WlTZF+Dejgb2yhUQyS1OGBIhCcYJMAVH7wBliNh+wBE+vmUbVBLlD4VASvC3gHpACUx6X1rfEhEKRQPD4WJZVYQU2v04JsEe3NdpAohA1qGRbYfAEao8-NKIRfej7AwiGGBAn6RxD6nQAONeAMCqeQ0N9qBw8BbYG4UVsdvwhUuDdAACYG7wAuU9sQY+BO4HsiJG4tSgKJieFgGfqCLDlIbSAAPMK8RDXAuSJoqf79mAEHIDv8AIQ0ME0ZgqEKraBP4tFVJ1wfb97ABQYipEH8nb8IKKARq6JuCIoG5EHJqVy5dsZMZBseHojd7KPrQFiwmI0l4aPYCh6dPwM8GkFjO5EYJJ+wOk4caAGwA-wAQqKR4Va53IgOgN6sy62PwQSYDapBNOjx6qvlR8cKGQhYA90OwMCBiNcnScASkGbH1mMDZjGMgXqEUsAy4p8ixCwNbERqAcgdypB+sgnhhYAMIAYQBQwC6AH0ANQAVKg0ABwECegAAALpAAA + height: 200px + code: | + from shiny import App, render, ui + from shiny.types import ImgData + from pathlib import Path + here = Path(__file__).parent + + app_ui = ui.page_fluid( + ui.input_checkbox("show", "Show image?", value = True), + ui.output_image("image") #<< + ) + + def server(input, output, session): + @render.image #<< + def image(): + img = {"src": here/"shiny.png", "width": "100px"} #<< + return img if input.show() else None + + app = App(app_ui, server) + relevantfunctions: + - title: ui.output_image + href: https://shiny.posit.co/py/api/ui.output_image.html + signature: ui.output_image(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=False) + - title: '@render.image' + href: https://shiny.posit.co/py/api/render.image.html + signature: render.image(_fn=None, *, delete_file=False) + --- :::{#component} diff --git a/components/outputs/map-ipyleaflet.qmd b/components/outputs/map-ipyleaflet.qmd index 58026095..faccc467 100644 --- a/components/outputs/map-ipyleaflet.qmd +++ b/components/outputs/map-ipyleaflet.qmd @@ -1,5 +1,5 @@ --- -title: "Map (ipyleaflet)" +title: Map (ipyleaflet) sidebar: components preview: |
@@ -11,18 +11,18 @@ listing: contents: - title: ipyleaflet preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACASxwBs4obOzWZUxOnwDicYgCkAygHkAcniYBZNEyYBiJgB4tAHQj1GTAM4ALFhGz9BwpgEF0igK4t9h5mYvYA7iwAmAOZwZMbWQnzETmSoUQD6voHBinRwASzGFHTx-kF8Gtp6EPpoqLEuTAC8TC5YUEGxPC5+ABSR0XEJuc26YDBoPQCUA2qaOvrjEH5wNCZwdABuc80WMWSKbauKxnDGxiykA4j6amow2LF9qJXKaM2ElJkVzQCsAAwYAGwATM9fAJwAdgAHM8gX9ngCAIyKd4AZgALKDXn8-rCPr8EfCBooAF7ERgVWHDfJjCAnJgpNIZObZRJkbq9fr4JhnC5oYmjQoTErXByoZolMosLZzRZ0Ab6MAAXwAukA - code: |4 - from ipyleaflet import GeoJSON, Map #<< - from shiny import App, ui - from shinywidgets import output_widget, register_widget #<< + code: | + from ipyleaflet import GeoJSON, Map #<< + from shiny import App, ui + from shinywidgets import output_widget, register_widget #<< - app_ui = ui.page_fluid(output_widget("map")) #<< + app_ui = ui.page_fluid(output_widget("map")) #<< - def server(input, output, session): - my_map = Map(center=(50.6252978589571, 0.34580993652344), zoom=3) #<< - register_widget("map", my_map) #<< + def server(input, output, session): + my_map = Map(center=(50.6252978589571, 0.34580993652344), zoom=3) #<< + register_widget("map", my_map) #<< - app = App(app_ui, server) + app = App(app_ui, server) relevantfunctions: - title: shinywidgets.output_widget @@ -37,71 +37,73 @@ listing: variations: - title: GeoJSON and Markers description: Read in country boundaries from a GeoJSON file and add markers to the map. - preview: https://shinylive.io/py/app/#h=0&code=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 - code: |4 - # example and data from: - # https://ipyleaflet.readthedocs.io/en/latest/layers/geo_json.html - # https://ipyleaflet.readthedocs.io/en/latest/layers/marker.html - import json - import pathlib - import random - - from ipyleaflet import GeoJSON, Map, Marker #<< - from shiny import App, ui - from shinywidgets import output_widget, register_widget #<< - - def random_color(feature): - return { - "color": "black", - "fillColor": random.choice(["red", "yellow", "green", "orange"]), - } - - here = pathlib.Path(__file__) - with open(here.parent / "europe_110.geo.json", "r") as f: - country_boundaries = json.load(f) - - app_ui = ui.page_fluid(output_widget("map")) #<< - - def server(input, output, session): - my_map = Map(center=(50.6252978589571, 0.34580993652344), zoom=3) #<< - - geo_json = GeoJSON( #<< - data=country_boundaries, #<< - style={ #<< - "opacity": 1, #<< - "dashArray": "9", #<< - "fillOpacity": 0.1, #<< - "weight": 1, #<< - }, - hover_style={"color": "white", "dashArray": "0", "fillOpacity": 0.5}, #<< - style_callback=random_color, #<< - ) #<< - my_map.add_layer(geo_json) #<< - - point = Marker(location=(52.204793, 0.121558), draggable=False) #<< - my_map.add_layer(point) #<< - - register_widget("map", my_map) #<< - - app = App(app_ui, server) + preview: + https://shinylive.io/py/app/#h=0&code=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 + code: | + # example and data from: + # https://ipyleaflet.readthedocs.io/en/latest/layers/geo_json.html + # https://ipyleaflet.readthedocs.io/en/latest/layers/marker.html + import json + import pathlib + import random + + from ipyleaflet import GeoJSON, Map, Marker #<< + from shiny import App, ui + from shinywidgets import output_widget, register_widget #<< + + def random_color(feature): + return { + "color": "black", + "fillColor": random.choice(["red", "yellow", "green", "orange"]), + } + + here = pathlib.Path(__file__) + with open(here.parent / "europe_110.geo.json", "r") as f: + country_boundaries = json.load(f) + + app_ui = ui.page_fluid(output_widget("map")) #<< + + def server(input, output, session): + my_map = Map(center=(50.6252978589571, 0.34580993652344), zoom=3) #<< + + geo_json = GeoJSON( #<< + data=country_boundaries, #<< + style={ #<< + "opacity": 1, #<< + "dashArray": "9", #<< + "fillOpacity": 0.1, #<< + "weight": 1, #<< + }, + hover_style={"color": "white", "dashArray": "0", "fillOpacity": 0.5}, #<< + style_callback=random_color, #<< + ) #<< + my_map.add_layer(geo_json) #<< + + point = Marker(location=(52.204793, 0.121558), draggable=False) #<< + my_map.add_layer(point) #<< + + register_widget("map", my_map) #<< + + app = App(app_ui, server) - title: Render Widget description: Use `@render_widget()` to render any ipywidget - preview: https://shinylive.io/py/app/#h=0&code=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 - code: |4 - from ipyleaflet import GeoJSON, Map #<< - from shiny import App, ui - from shinywidgets import output_widget, render_widget #<< + preview: + https://shinylive.io/py/app/#h=0&code=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 + code: | + from ipyleaflet import GeoJSON, Map #<< + from shiny import App, ui + from shinywidgets import output_widget, render_widget #<< - app_ui = ui.page_fluid(output_widget("my_map")) #<< + app_ui = ui.page_fluid(output_widget("my_map")) #<< - def server(input, output, session): + def server(input, output, session): - @render_widget #<< - def my_map(): - return Map(center=(50.6252978589571, 0.34580993652344), zoom=3) #<< + @render_widget #<< + def my_map(): + return Map(center=(50.6252978589571, 0.34580993652344), zoom=3) #<< - app = App(app_ui, server) + app = App(app_ui, server) --- :::{#component} diff --git a/components/outputs/plot-matplotlib.qmd b/components/outputs/plot-matplotlib.qmd index bac6f1cb..2ff26ff1 100644 --- a/components/outputs/plot-matplotlib.qmd +++ b/components/outputs/plot-matplotlib.qmd @@ -1,5 +1,5 @@ --- -title: "Plot (Matplotlib)" +title: Plot (Matplotlib) sidebar: components preview: |
@@ -9,7 +9,7 @@ listing: - id: component template: ../_partials/components-detail.ejs contents: - - title: "Plot (Matplotlib)" + - title: Plot (Matplotlib) preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACGKM1AG2LK5oBGWbN14soAZxbcyAHQh0GzFhACu9bOKkRU8gGaNiMaVC7xGqSgHNVNCFMVNWPKABMA+pYg27E-YeMJAAs7TUdlAEF0PBZGSlc4RhjbeXk0VHdbFgBeFlssKCs4dz0uW1cACnkWGryaDDtUVTJ3CX4ExirIWXwWHoA5dQFElmI9FgFfHpiABhiARhm5lgAmGYBKPGra-OJmppbRMi6jns35ddSIeQTxiUSAN0SKxuaYvc43lnuJCRpSdaIbY1AACcQgHSwPGOpjI2R6ERYIQkZGIVkYsDOwJYt2k0IqgOxtRx41yLg8Xh89gJRNq7F+ORJwB6AmIrmw7npEncVh6AF0rsTiXoaFYYlAAB6MmQYCSqARHCQ0iBC2qSjDI45cmKvMgYCAEmIJew0MjYbIAFUYqjglxVqvEEtlcBaZFNXDgXQACqZzCwvdZbCqALKSH5Y+2q9X3FoSrhQYZcLqhhkVKyXMB2h2O50tbDxxNdAAilD+ZojtJqcTIqkYKpFvOuTfSjKiqAq6UyNBi90YTySOLgAlUVkt1tt8jAAF8+UA height: 500px code: | @@ -42,7 +42,7 @@ listing: - title: ui.output_plot href: https://shiny.posit.co/py/api/ui.output_plot.html signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) - - title: "@render.plot" + - title: '@render.plot' href: https://shiny.posit.co/py/api/render.plot.html signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) - id: variations @@ -57,7 +57,7 @@ listing: import matplotlib.pyplot as plt from palmerpenguins import load_penguins from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.output_plot( "plot", @@ -75,37 +75,37 @@ listing: "Brush", ui.output_text_verbatim("brsh", placeholder=True), ) - + def server(input, output, session): @render.plot(alt="A histogram") def plot(): df = load_penguins() mass = df["body_mass_g"] bill = df["bill_length_mm"] - + plt.scatter(mass, bill) plt.xlabel("Mass (g)") plt.ylabel("Bill Length (mm)") plt.title("Penguin Mass vs Bill Length") - + @render.text def clk(): return input.plot_click() - + @render.text def dblclk(): return input.plot_dblclick() - + @render.text def hvr(): return input.plot_hover() - + @render.text def brsh(): return input.plot_brush() app = App(app_ui, server, debug=True) - + --- :::{#component} diff --git a/components/outputs/plot-plotly.qmd b/components/outputs/plot-plotly.qmd index 3a3db69f..b08cdba0 100644 --- a/components/outputs/plot-plotly.qmd +++ b/components/outputs/plot-plotly.qmd @@ -1,18 +1,18 @@ --- -title: "Plot (Plotly)" +title: Plot (Plotly) sidebar: components preview: |
listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: "Plot (Plotly)" - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACVAG2LPewzgA9UjOAGcRLKONT8AOhABmjYjDZR28RqkoBzAK40I4ug2YtOUACYB9LRD0GRcxcpYiAFgewtjTVgEF0PBZhKEIyGgA3OCD9JyUVd08AdxoLbTgyI3pfFmJdMlR8qxS0jKDhCAs4RmLU9NYWAGIAHma5OTRUK30WAF4WfSwodKt5dn0LAAo5FlmBmgwDQrIrEXZU6unIGXwWHYA5XRgAI2rc+RZjhx2ggEY7gAYHoIAmB4BKPBm5vIKikvqWw4XB2n1mLTaEHe7QgciqFxE1SijEmS3yQV+yyCiLENFI70Q31mAAEKlUagCMuCWK0iSx4WxOGRJgS6XM2Dp9IY+mZiJYbJyHCy2XMRIQoGQKJomTzpBgPCIyMRtIxYNMIOzNXMLBKoKNVfBerZ7IYgvxejtjsQLNgrDBJCIrNobiwIFdDL00WQMBBhRqtSx3hhdKgdRQrOwoNhfuqA5rwtw4L0QDsKPwyDtEHswAAFQUagCyDpdO1kSBYDwwAFYAL5ff1x2bYKD8GiOhPsJM7ADCeXINxFWv4LbbVg7XbAACFrV4i2IWJNtND8IPAzC48IyLpGBqxRKpcCGhCYR10DyAqhJp1ujRsUjqtCIGAawBdIA - height: 500px - code: |4 + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Plot (Plotly) + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACVAG2LPewzgA9UjOAGcRLKONT8AOhABmjYjDZR28RqkoBzAK40I4ug2YtOUACYB9LRD0GRcxcpYiAFgewtjTVgEF0PBZhKEIyGgA3OCD9JyUVd08AdxoLbTgyI3pfFmJdMlR8qxS0jKDhCAs4RmLU9NYWAGIAHma5OTRUK30WAF4WfSwodKt5dn0LAAo5FlmBmgwDQrIrEXZU6unIGXwWHYA5XRgAI2rc+RZjhx2ggEY7gAYHoIAmB4BKPBm5vIKikvqWw4XB2n1mLTaEHe7QgciqFxE1SijEmS3yQV+yyCiLENFI70Q31mAAEKlUagCMuCWK0iSx4WxOGRJgS6XM2Dp9IY+mZiJYbJyHCy2XMRIQoGQKJomTzpBgPCIyMRtIxYNMIOzNXMLBKoKNVfBerZ7IYgvxejtjsQLNgrDBJCIrNobiwIFdDL00WQMBBhRqtSx3hhdKgdRQrOwoNhfuqA5rwtw4L0QDsKPwyDtEHswAAFQUagCyDpdO1kSBYDwwAFYAL5ff1x2bYKD8GiOhPsJM7ADCeXINxFWv4LbbVg7XbAACFrV4i2IWJNtND8IPAzC48IyLpGBqxRKpcCGhCYR10DyAqhJp1ujRsUjqtCIGAawBdIA + height: 500px + code: | import plotly.express as px from palmerpenguins import load_penguins from shiny import App, reactive, ui @@ -39,13 +39,13 @@ listing: app = App(app_ui, server) - relevantfunctions: - - title: shinywidgets.output_widget - href: https://github.com/posit-dev/py-shinywidgets/blob/main/shinywidgets/_shinywidgets.py#L58 - signature: shinywidgets.output_widget(id, width, height) - - title: "@shinywidgets.render_widget()" - href: https://github.com/posit-dev/py-shinywidgets/blob/main/shinywidgets/_shinywidgets.py#L213 - signature: shinywidgets.render_widget(fn) + relevantfunctions: + - title: shinywidgets.output_widget + href: https://github.com/posit-dev/py-shinywidgets/blob/main/shinywidgets/_shinywidgets.py#L58 + signature: shinywidgets.output_widget(id, width, height) + - title: '@shinywidgets.render_widget()' + href: https://github.com/posit-dev/py-shinywidgets/blob/main/shinywidgets/_shinywidgets.py#L213 + signature: shinywidgets.render_widget(fn) --- diff --git a/components/outputs/plot-seaborn.qmd b/components/outputs/plot-seaborn.qmd index a3cd885a..de7e0690 100644 --- a/components/outputs/plot-seaborn.qmd +++ b/components/outputs/plot-seaborn.qmd @@ -1,18 +1,18 @@ --- -title: "Plot (Seaborn)" +title: Plot (Seaborn) sidebar: components preview: |
listing: - id: component - template: ../_partials/components-detail.ejs - contents: - - title: "Plot (Seaborn)" - preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACAZzigCMmIWo27CGwA6EAGaNiMFqigAbeI1SUA5gFcawlnQbMW84lAAmAfRUQNW0RKky2ACy3Yd9JqwCC6PC0aVjcIw+mmJiaKimmiwAvCyaWFCqcKbi8prGABRiLHE0GFqo6mSmbPI0AYxZkCL4LDUAcuowXIEsxOIsXNY1PgCMfQAMAz4ATAMAlHjZuRjERYXFqIZkVUvEZDWTOQDEADy7YuOhEGIBHRyMAG6BGQVFPnNkCz4cbGw0pOOI0wACfhAVLDLLJ8HJghRkaI1DwsADKnB4jD4TjYZGIqkYsDafAsVj4PGMLhgAkEWhYGNgbAwNWm4x2+2mZ1kwK+9IOoLBsjUmm0sUMJnM3OsGSOHPBAA8YkIqSinsDjFAyFBorieWwfOKoWACdhTMS3qZVD1OtZoncyBgICLRZyclBxRgOMUyDQyPI4FUAAoKJQsT1C4Sbaac+2OuDFcXybhweRVACyJJYGVURzANttoadpmwUZasZqAGE5uQg2Kcn4yOokfxJSw9uzjuEpV5UBlwpEaC9AtcgiwAlx1KpogAVRjqODjMAAXwAukA - height: 500px - code: |4 + - id: component + template: ../_partials/components-detail.ejs + contents: + - title: Plot (Seaborn) + preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACAZzigCMmIWo27CGwA6EAGaNiMFqigAbeI1SUA5gFcawlnQbMW84lAAmAfRUQNW0RKky2ACy3Yd9JqwCC6PC0aVjcIw+mmJiaKimmiwAvCyaWFCqcKbi8prGABRiLHE0GFqo6mSmbPI0AYxZkCL4LDUAcuowXIEsxOIsXNY1PgCMfQAMAz4ATAMAlHjZuRjERYXFqIZkVUvEZDWTOQDEADy7YuOhEGIBHRyMAG6BGQVFPnNkCz4cbGw0pOOI0wACfhAVLDLLJ8HJghRkaI1DwsADKnB4jD4TjYZGIqkYsDafAsVj4PGMLhgAkEWhYGNgbAwNWm4x2+2mZ1kwK+9IOoLBsjUmm0sUMJnM3OsGSOHPBAA8YkIqSinsDjFAyFBorieWwfOKoWACdhTMS3qZVD1OtZoncyBgICLRZyclBxRgOMUyDQyPI4FUAAoKJQsT1C4Sbaac+2OuDFcXybhweRVACyJJYGVURzANttoadpmwUZasZqAGE5uQg2Kcn4yOokfxJSw9uzjuEpV5UBlwpEaC9AtcgiwAlx1KpogAVRjqODjMAAXwAukA + height: 500px + code: | import seaborn as sns from palmerpenguins import load_penguins from shiny import App, render, ui @@ -36,13 +36,13 @@ listing: app = App(app_ui, server, debug=True) - relevantfunctions: - - title: ui.output_plot - href: https://shiny.posit.co/py/api/ui.output_plot.html - signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) - - title: "@render.plot" - href: https://shiny.posit.co/py/api/render.plot.html - signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) + relevantfunctions: + - title: ui.output_plot + href: https://shiny.posit.co/py/api/ui.output_plot.html + signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) + - title: '@render.plot' + href: https://shiny.posit.co/py/api/render.plot.html + signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) --- diff --git a/components/outputs/text.qmd b/components/outputs/text.qmd index 58d86699..6af0bb8c 100644 --- a/components/outputs/text.qmd +++ b/components/outputs/text.qmd @@ -1,6 +1,6 @@ --- -title: "Text" -sidebar: components +title: Text +sidebar: components previewapp: | from shiny import App, render, ui @@ -26,25 +26,25 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhCbqNG1WlQB9JUwC8TJVigBzOLpoAbJdIAUqjaa6oFZXRQAeZJ2AAVOF9lfCZQgFFyOSYfMlCJUIAJOBsbYiYAZU5uUIBKPGd1UIBNYgUmSgopaUQEopMODHKyd084-zj81TyG4ohZGlY5ADc5BzcPCRa2iRY4FhYOUjy6tXUAASkBuQwu9aZB2OC-Vb71KTIFOjVJsgwg3wdeg-6dI1F0Bx19DjnRuR5MAAXwAukA height: 200px code: | - from shiny import App, render, ui - - app_ui = ui.page_fluid( - ui.input_text("Text", "Enter text", "Hello Shiny"), - "You entered:", - ui.output_text("text") #<< - ) - - def server(input, output, session): - @render.text #<< - def text(): - return input.Text() - - app = App(app_ui, server) + from shiny import App, render, ui + + app_ui = ui.page_fluid( + ui.input_text("Text", "Enter text", "Hello Shiny"), + "You entered:", + ui.output_text("text") #<< + ) + + def server(input, output, session): + @render.text #<< + def text(): + return input.Text() + + app = App(app_ui, server) relevantfunctions: - title: ui.output_text href: https://shiny.posit.co/py/api/ui.output_text.html signature: ui.output_text(id, inline=False, container=None) - - title: "@render.text" + - title: '@render.text' href: https://shiny.posit.co/py/api/render.text.html signature: render.text(fn=None) - id: variations @@ -52,11 +52,11 @@ listing: contents: variations: - title: Inline text - description: Set `inline=True` within `ui.output_text()` to have text appear inline with the text that preceeds it. + description: Set `inline=True` within `ui.output_text()` to have text appear inline with the text that preceeds it. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhFVpUAfSVMAvEyVYoAcziaaAGyXSAFKqYODHDF1QKymigA8ydsABU4H2V8JhCAUXI5Jm8yEIkQgAk4CwtiJgBlTm4QgEo8e0cQgE1iBSZKCilpRDDQwzKyNw9Yv1j43ggLLjg9Jn86BThc1RGIRwmwiFkaVjkANzkbV3cJRuaJFjgWFg5SXMRChwABKWm5DHbxxxmYoN8Do8mpMgU6cZWyDECfGzH1dB9MSoGwabQcTYLOS5MAAXwAukA code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_text("Text", "Enter text", "Hello Shiny"), "You entered: ", ui.output_text("text", inline = True) #<< diff --git a/components/outputs/ui.qmd b/components/outputs/ui.qmd index f1bd7fa0..c5afcd1c 100644 --- a/components/outputs/ui.qmd +++ b/components/outputs/ui.qmd @@ -1,6 +1,6 @@ --- -title: "UI" -sidebar: components +title: UI +sidebar: components previewapp: | from shiny import App, reactive, render, ui app_ui = ui.page_fluid( @@ -22,24 +22,24 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6cKITIcAbnAlSIAEzh0JAVw4AdCPrSoA+jqYBeJjqxQA5nGM0ANjtUAKfUy9WOGLqi0yYxk5UmMAI0CyUg8UVVUIqNJdfCYUkXimKCYAVQBJJjgnOHhyFIBKPE9va2JAgKCdWJ0AUWLSsgqqiHL9PrU4GlYNRTo3f0CJOrIGiRY4FhYOUnLEaq8AARV1OgwddaYt6VkFOAw4RXJxiAaMKHjEsmieg-Uh1vbKMjdVg+9JOBkLR0CA+Pw3QLGFhODg7WLQ2EaFISFIAYTYxGI8yyTAgWhg4SRqRgXHMAEYJDAoAAPckABgk8igLjg5gArJV+kYLKJ0G4jKYOHMRhpehAwABfAC6QA code: | from shiny import App, reactive, render, ui - + app_ui = ui.page_fluid( ui.input_action_button("add_button", "Add a UI element"), ui.output_ui("uiElement"), #<< ) - + def server(input, output, session): @render.ui #<< @reactive.event(input.add_button) #<< def uiElement(): #<< return ui.input_slider("slider", "Choose a number", min=1, max=10, value=5), #<< - + app = App(app_ui, server) relevantfunctions: - title: ui.output_ui href: https://shiny.posit.co/py/api/ui.output_ui.html signature: ui.output_ui(id, inline=False, container=None, fill=False, fillable=False, **kwargs) - - title: "@render.ui" + - title: '@render.ui' href: https://shiny.posit.co/py/api/render.ui.html signature: render.ui(_fn=None) - id: variations @@ -51,35 +51,35 @@ listing: preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6cKITIcAbnAlSIAEzh0JAVw4AdCPrSoA+jqYBeJjqxQA5nGM0ANjtUAKfUy9WOGLqi0yYwgteDoOQg9IUIAjDV18JgSAUXINJigmEJg4ukQEiQBGCRguc2KmGCgAD3KABgBKPE9va2JAgKCdKJ1kpzh4cgSm-Qb9cbU4GlYNRTo3f0CJdrJOiRY4FhYOUgb8iG8mAAEVdToMHRavdWne-sGyNz2rw8k4Mi06A+tFoJYnDhnKL-QHxRIJADCnxUwmyuXyiVKEHKJRq9Qk8igLjg5l+GDhGieIwM0HQFlE6DcRlMHHWsw0DTAAF8ALpAA code: | from shiny import App, reactive, render, ui - + app_ui = ui.page_fluid( ui.input_numeric("number", "Enter a number:", 1, min=1, max=10), ui.output_ui("uiElement"), #<< ) - + def server(input, output, session): @render.ui #<< def uiElement(): #<< return ui.input_slider("slider", "Current number:", min=1, max=10, value=input.number()), #<< - + app = App(app_ui, server) - title: Toggle to show or hide an input description: Use an input control to switch between showing or hiding a UI output element. preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6cKITIcAbnAlSIAEzh0JAVw4AdCPrSoA+jqYBeJjqxQA5nGM0ANjtUAKfUy9WOGLqi0yYxYAdw4yQjYPMHZiEOCnDnU6XXwmVIBlNjjWROTUgEo8T29rYkCAoJ1onQBRJzh4ckLiiAL9DrU4GlYNRTo3f0CJcrJKiRY4FhYOUgLEEq8AARVkjB1FpnUeuoamsjd5ze9eHsGISoxY+JY8jUOjiBPn7ykyLTon6yGg26T71J-fJpVIAYWyxEmTCgTAgWhgACMNKkJDAuOYAIyoqAAD0xAAYJPIoC44OYAKztAzQdAWUToNxGUwcCZ9DQFMAAXwAukA code: | from shiny import App, reactive, render, ui - + app_ui = ui.page_fluid( ui.input_switch("show_slider", "Show slider"), ui.output_ui("uiElement"), #<< ) - + def server(input, output, session): @render.ui #<< def uiElement(): #<< if (input.show_slider()): #<< return ui.input_slider("slider", "Choose a number", min=1, max=10, value=5) #<< - + app = App(app_ui, server) --- diff --git a/components/outputs/value-box.qmd b/components/outputs/value-box.qmd index 3451d7a3..b02ca459 100644 --- a/components/outputs/value-box.qmd +++ b/components/outputs/value-box.qmd @@ -1,5 +1,5 @@ --- -title: "Value Box" +title: Value Box sidebar: components editor: visual filters: @@ -275,22 +275,22 @@ listing: contents: - title: Value Box preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxMArhwA6EOag4BzJdgD6AIygQA1kwC8UjhgASAFQCyAGQAUcpkwDkAHhYA3JUwAeMADYQWfRkwNjIyVEQAekiAdziMGIBmDEElSIAmAAZsyPclYKY3DjgYgCFiLyCwTKYagEYANiZGgsJfKBZA4I0OJh6AWkUVbH6tXSYCljJsXzgqmg5fX0RCSTo6SjIAYWJfQQBuNjhlUMQ67IBSfYKoOg4ofs4AEyfKKrI6STgChlmqvnyYCYAD5nKgoGQ2EwnlULABWJgNDDpOFQDAAdjhGIR9Wa-TqGBxTGx2NqZLqzUJtQAXjACXVEgAOfEYAAsAE4GiIkQ0GYiMLzEmTceiMJzWUxWYTCAKGk16hhEplkpl2ejKYz2cl0ujEmisUSajVkYyGv0xXDGSJRQ1MukmDa7cKyaLxUxknDCObdRLMizWaz6cr+ukMOdQ+l2el9VTccadUjOelqcFQZFwZDgTI5GCIVCFkt+p8-sE4G5KMQXgUYcELK6GhKCXCdV7Q2r1X6DeiKQT0ZlWf0kYl7VK6ii2Oa4XCRD3nca6hSkYz0qzfMi4Y22Q0oE3KYbyWz0YzKSvEmxkQ1EjKPQyBYzGWKj5S6qyEQSmelfN7I0xQ6z0eiMb7sarIPg2dRsNGhKxs6h51OaiTDmuoHpCyiRwnUMqXlidS6pSiQEukDTqqGmQLheop9h2+H3uaqoIqR6TMsi6KfoSrJCu+rFAXOxKsg0WIEQ0kE8UaZKHsxDZwl+GK8iGhKZA0Wy3oyFLshgmpvlKCIPlO7LNNpDoYIp7KEH6YavnRmTouakZ0ahbIERe8Fhk2mTMURSJ9nC5oBlKBGCYpGl1IFS4hb5uHiek6SJJOyIxb5cnGURaLsliaW8cZ7K2VOGIYnOtl2uaUmErpx5ieZVF0eyD66lidUFYqmKEg06ReslUqnsZy5sg+w4ChuUChgu9rDWOzouSi6khVek6JAOoZygO2qMgO2lpYObKsqh61wtSFihhhTRIkRMqvj5pFyr+so2ckupCliAbMndiHuhZ8pMAaiRNGNEpfU02nbQeKIDgKK7XYGLLEW9K6MqJwrmo0X3SbK124XCE5ioy0mTtlBKgYB0HAcVdkmoy7VyoRsXvup6HZcNcKinTUBIlOx6s5aE3ySFNmKnC6kGo12GKv2MnNm+cGY2q7JrpesUM-DRqI7zcLzZKAocurDb6WJ8GEatLIbk2MFK1tZosRjk7bkTXNslGEWrjlA748JYqIYr4mgcxiRarSY5gy52OE3CAktfuLmqg+6S9v2GL9rb-ag3anqI-x1WI4zys+WGza2TFaIxSd30TcSC687hV7GRy9miu59n0reZFQVkEZOrrxKKaO7LsimYBphmbBpnkwKOHIACUchyGgqBqNIBhGFgUBKHAag0L40hPHYEAONIGDtNgxCSGQagkOvMAQGoMR0GgW8OHfC9uFA68rxoFS3-fH-BAA0gACgAkkwMwHAyCzGCHgewH977BAACQUlKIsXwHBSBMAACK7HaHQFgYCIGQIcMEAAqqgd0mQLhMAAGoAGUmA-wAEoAFEyF-wAPL4KoUqVBIgACaFDsHb1wQ4dgxAYiEA6HMIYqhNDaB0OAvh-DIRwHgFUDQSh+hKGvk8Yo5B+hcA0UoYggw1ioFAfgHBuCaCSCWGoFghANhvDMJ8OAMjIFjycUwCeEB3FT3QPPMQqAbDT1nhwCQLA4B0HLHQfQAA5UgcAx5gAAL4AF0gA - code: |4 - from shiny import App, ui + code: | + from shiny import App, ui - app_ui = ui.page_fluid( - ui.layout_column_wrap( - ui.value_box( #<< - "KPI Title", - "$1 Billion Dollars", - "Up 30% VS PREVIOUS 30 DAYS", - theme="bg-gradient-indigo-purple", - full_screen=True, - ), - ) - ) + app_ui = ui.page_fluid( + ui.layout_column_wrap( + ui.value_box( #<< + "KPI Title", + "$1 Billion Dollars", + "Up 30% VS PREVIOUS 30 DAYS", + theme="bg-gradient-indigo-purple", + full_screen=True, + ), + ) + ) - app = App(app_ui, server=None) + app = App(app_ui, server=None) relevantfunctions: - title: ui.value_box @@ -304,124 +304,124 @@ listing: contents: variations: - title: Theme and Layout Examples - height: "315px" + height: 315px description: Value boxes with different `theme` and `showcase_layout` locations. This value box uses multiple files, see how on [Shinylive](https://shinylive.io/py/editor/#code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACAMyhpIgGcAdCG0bEYLHgAsaEbCzoNmLAILo8LAK40BAtKgD6GlgF51NLFADmcXWwA2GgCYAKARow2o2YmrK6SdmBC6AO6MaM4QLCYYAG5QdlYARsQAHuGR6Sx8YADSAAoAkiwAKjRkNnBZeAIZkVkAJACMLABCNDY2NKQsACLE7VCM-PjVNVkAqqgsAMwADACkLABqAMosuQBKAKKL+QDyY6uzPYoAmsuVIxkSxEGEUDxwhhxcpDwYL4E80eaOAOSoNHM5mwAFoElAIABrX6qII0exkcSGLIAVhmqGSWQAlFUIjVEXB4MiwAlzCDzKF7DRKGQQVIqeZiCDUGpGKhypVIgBiAA8PMu6TYanauh4hEYcEohiKjDUcFxkRxI1csXiuiSqQFtRyBWKpQ5wzxGXqTVa7U6EV6-UGFyN6XGk1mCxWay2O32hxmxzOtpqYnENzuDyenG4bw+ou+fwBQNB4KhMJYcIRSNR6MxYCVdsiBKJWQoyVpFMlEE5LF5-Oz-sD9ys7k83mJZGIk0YgPEZDLFa17GFNlF4pL0tl8pGWciKricvVKTSox1hRKZQqhr9JpabQ6XSt7htq-nE2m8yWqw22z2ByP3vO+6uAdutZDH3D3EjP3+gOBYIh0Nh8MRxJohi2IKvi4iEo8WQsmyBqqOWfI9tcD4PLo9ZeGQxJJGQzYwF2CFVkKIpihKUoynKoFZliAhUdA6BGEo6CODo+g0KoDyMNEcCMIYABypBwFiYAAL54OA0DwNQEoAI4aBK8DkG8ZCFvgRCkBQVDIM8YbCQAukAA) preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACAMyhpIgGcAdCG0bEYLHgAsaEbCzoNmLAILo8LAK40BAtKgD6GlgF51NLFADmcXWwA2GgCYAKARow2o2YmrK6SdmBC6AO6MaM4QLCYYAG5QdlYARsQAHuGR6Sx8YADSAAoAkiwAKjRkNnBZeAIZkVkAJACMLABCNDY2NKQsACLE7VCM-PjVNVkAqqgsAMwADACkLABqAMosuQBKAKKL+QDyY6uzPYoAmsuVIxkSxEGEUDxwhhxcpDwYL4E80eaOAOSoNHM5mwAFoElAIABrX6qII0exkcSGLIAVhmqGSWQAlFUIjVEXB4MiwAlzCDzKF7DRKGQQVIqeZiCDUGpGKhypVIgBiAA8PMu6TYanauh4hEYcEohiKjDUcFxkRxI1csXiuiSqQFtRyBWKpQ5wzxGXqTVa7U6EV6-UGFyN6XGk1mCxWay2O32hxmxzOtpqYnENzuDyenG4bw+ou+fwBQNB4KhMJYcIRSNR6MxYCVdsiBKJWQoyVpFMlEE5LF5-Oz-sD9ys7k83mJZGIk0YgPEZDLFa17GFNlF4pL0tl8pGWciKricvVKTSox1hRKZQqhr9JpabQ6XSt7htq-nE2m8yWqw22z2ByP3vO+6uAdutZDH3D3EjP3+gOBYIh0Nh8MRxJohi2IKvi4iEo8WQsmyBqqOWfI9tcD4PLo9ZeGQxJJGQzYwF2CFVkKIpihKUoynKoFZliAhUdA6BGEo6CODo+g0KoDyMNEcCMIYABypBwFiYAAL54OA0DwNQEoAI4aBK8DkG8ZCFvgRCkBQVDIM8YbCQAukAA - code: |4 - import faicons - from shiny import App, ui - app_ui = ui.page_fluid( - ui.layout_column_wrap( - ui.value_box(S - "KPI Title", - "$1 Billion Dollars", - "Up 30% VS PREVIOUS 30 DAYS", - showcase=faicons.icon_svg('piggy-bank', width="50px"), - theme="bg-gradient-indigo-purple", #<< - full_screen=True, - ), - ui.value_box( - "KPI Title", - "$1 Billion Dollars", - "Up 30% VS PREVIOUS 30 DAYS", - showcase=faicons.icon_svg('piggy-bank', width="50px"), - theme="text-green", #<< - showcase_layout="top right", #<< - full_screen=True, - ), - ui.value_box( - "KPI Title", - "$1 Billion Dollars", - "Up 30% VS PREVIOUS 30 DAYS", - showcase=faicons.icon_svg('piggy-bank', width="50px"), - theme="purple", #<< - showcase_layout="bottom", #<< - full_screen=True, - ), - ) - ) - app = App(app_ui, server=None) + code: | + import faicons + from shiny import App, ui + app_ui = ui.page_fluid( + ui.layout_column_wrap( + ui.value_box(S + "KPI Title", + "$1 Billion Dollars", + "Up 30% VS PREVIOUS 30 DAYS", + showcase=faicons.icon_svg('piggy-bank', width="50px"), + theme="bg-gradient-indigo-purple", #<< + full_screen=True, + ), + ui.value_box( + "KPI Title", + "$1 Billion Dollars", + "Up 30% VS PREVIOUS 30 DAYS", + showcase=faicons.icon_svg('piggy-bank', width="50px"), + theme="text-green", #<< + showcase_layout="top right", #<< + full_screen=True, + ), + ui.value_box( + "KPI Title", + "$1 Billion Dollars", + "Up 30% VS PREVIOUS 30 DAYS", + showcase=faicons.icon_svg('piggy-bank', width="50px"), + theme="purple", #<< + showcase_layout="bottom", #<< + full_screen=True, + ), + ) + ) + app = App(app_ui, server=None) - title: Reactive Value Box description: Connecting a reactive input value to a value box. This value box uses multiple files, see how on [Shinylive](https://shinylive.io/py/editor/#code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACAMyhpIgGcAdCG0bEYLHgAsaEbCzoNmLAILo8LAJIRUAVzI9VAeR3bdqgMpwePGqVWNKAEziNVWmgIFpUAfVcsAvCyuWFAA5nBebAA2rvYAFAIsiYE0GFLGXjyRNI6M8ZB8+CwFAHJaMABGTizEbCwAQjSRWaT8hQCMqm0ADF2qAExdAJSqLADELAA8EwlJQQBuUNHh5cQAHvEQSVssZDRkkXB+BQDSAApqLAAqewcFeDPbYuLEAO6EUDyHHFwtqdwZcxCeVQNBCIWwAFpylAIABrO4sF7ZMjiI5gACsXVQqwKwwe2wWSz8QWIRh0XgoqzIeXKjWavFxI3GU3xWxRcHgaPKIQhIUYUHsNEoZAhUkFIWIEO0jFQt3wrKSbC0TQyhDslD8l0YWjg902STxEEG7ggAkctU+jDmTliaR0qlJZGMqk+lmsRsQ+IAAnYIDkMJTWGNJtN9YlzSxaU13TxYoNEIlmaHHok7GQtIxNmwCgASEB2sgYCBxgC+9Tp7pYABFiE0oIxWomQyaPOh-Ep0LFPD4aC6nNbGMaIGAS3hwNB4NQ7ABHVx2eDkHgBqn4IikChUZDfbg8EcAXSAA) shinylive: https://shinylive.io/py/editor/#code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACAMyhpIgGcAdCG0bEYLHgAsaEbCzoNmLAILo8LAJIRUAVzI9VAeR3bdqgMpwePGqVWNKAEziNVWmgIFpUAfVcsAvCyuWFAA5nBebAA2rvYAFAIsiYE0GFLGXjyRNI6M8ZB8+CwFAHJaMABGTizEbCwAQjSRWaT8hQCMqm0ADF2qAExdAJSqLADELAA8EwlJQQBuUNHh5cQAHvEQSVssZDRkkXB+BQDSAApqLAAqewcFeDPbYuLEAO6EUDyHHFwtqdwZcxCeVQNBCIWwAFpylAIABrO4sF7ZMjiI5gACsXVQqwKwwe2wWSz8QWIRh0XgoqzIeXKjWavFxI3GU3xWxRcHgaPKIQhIUYUHsNEoZAhUkFIWIEO0jFQt3wrKSbC0TQyhDslD8l0YWjg902STxEEG7ggAkctU+jDmTliaR0qlJZGMqk+lmsRsQ+IAAnYIDkMJTWGNJtN9YlzSxaU13TxYoNEIlmaHHok7GQtIxNmwCgASEB2sgYCBxgC+9Tp7pYABFiE0oIxWomQyaPOh-Ep0LFPD4aC6nNbGMaIGAS3hwNB4NQ7ABHVx2eDkHgBqn4IikChUZDfbg8EcAXSAA - height: "225px" + height: 225px preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMASxlWICcyACAMyhpIgGcAdCG0bEYLHgAsaEbCzoNmLAILo8LAJIRUAVzI9VAeR3bdqgMpwePGqVWNKAEziNVWmgIFpUAfVcsAvCyuWFAA5nBebAA2rvYAFAIsiYE0GFLGXjyRNI6M8ZB8+CwFAHJaMABGTizEbCwAQjSRWaT8hQCMqm0ADF2qAExdAJSqLADELAA8EwlJQQBuUNHh5cQAHvEQSVssZDRkkXB+BQDSAApqLAAqewcFeDPbYuLEAO6EUDyHHFwtqdwZcxCeVQNBCIWwAFpylAIABrO4sF7ZMjiI5gACsXVQqwKwwe2wWSz8QWIRh0XgoqzIeXKjWavFxI3GU3xWxRcHgaPKIQhIUYUHsNEoZAhUkFIWIEO0jFQt3wrKSbC0TQyhDslD8l0YWjg902STxEEG7ggAkctU+jDmTliaR0qlJZGMqk+lmsRsQ+IAAnYIDkMJTWGNJtN9YlzSxaU13TxYoNEIlmaHHok7GQtIxNmwCgASEB2sgYCBxgC+9Tp7pYABFiE0oIxWomQyaPOh-Ep0LFPD4aC6nNbGMaIGAS3hwNB4NQ7ABHVx2eDkHgBqn4IikChUZDfbg8EcAXSAA - code: |4 - import faicons - from shiny import App, Inputs, Outputs, Session, render, ui - - app_ui = ui.page_fluid( - ui.input_slider("n", "Number of Billions", 1, 100, 20), #<< - ui.value_box( - title="KPI Title", - showcase=faicons.icon_svg('piggy-bank', width="50px"), - value=ui.output_text("billions"), #<< - theme="bg-gradient-indigo-purple", - full_screen=True, - ), - ) + code: | + import faicons + from shiny import App, Inputs, Outputs, Session, render, ui + + app_ui = ui.page_fluid( + ui.input_slider("n", "Number of Billions", 1, 100, 20), #<< + ui.value_box( + title="KPI Title", + showcase=faicons.icon_svg('piggy-bank', width="50px"), + value=ui.output_text("billions"), #<< + theme="bg-gradient-indigo-purple", + full_screen=True, + ), + ) - def server(input, output, session): - @render.text #<< - def billions(): #<< - return f"${input.n()} Billion Dollars" #<< + def server(input, output, session): + @render.text #<< + def billions(): #<< + return f"${input.n()} Billion Dollars" #<< - app = App(app_ui, server) + app = App(app_ui, server) - title: Sparklines description: Interactive sparkline in the value box. This value box uses multiple files, see how on [Shinylive](https://shinylive.io/py/editor/#code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxMArhwA6EPgKGtO3AO4cAJgHM4ZFkyj6WquQsHDUAG2JlL2DHAAeqOnBb7DTVI9P9zXqAgNT09UDTl6RgCyNksOACNePyUABSgYuTk0MI46JgBeJjSYgAoAfTKaDks4CoBKLChXckzodDLpAqkORp1K6ssoeJqSuSZujC5CS0kNWsJ3EuyNXKYAeiYZMBYybBqWDAWWLbq8MYmANygZ2vjiR1GIcefNsAAVG2umAGVrt14ngBFABMWwkWwAJMCMAAWACsAFkwecXiAttNDMckK92FANMRVABaCCkOBbAC+ZyeL2UBMIhjg+WMGGIkjIqDZZXU2l0o22qCaAGs4hAyWBTijnuw6QyyoNsKyyPlpBhpap6SxajUaGQyoRKBQ6CVuTF8lsYQAGACkJ3OEupAo0KwgWnyFqp4yqlkGw1qMGI8WqjLedEkZIgdVacxorDgdAucZKXA5ZAkipTEk17g4pDqiHOAAF02zC8zmnM6FzNDoyOdo6wBXRhVw4CU85LxnASCSYBwFl0whhXHi9SwLkt0Cs8hsAORd0iMPsHBYXGeR6kvKpaAeODAi1vzntLiSOfIz4IUGcSbBn1AsKAJoRrjtMLcYSRhdK1Mh0KD6lglPuerENYdBngAxJaABsACiABiACMV5MEBJpsPkCESF6lhnmQxAAF5xsQ2DIdhJCgWedBaPEUAlFBMJ4AhCHusCMKYRaGDAnUyFsMQj5cDQxBmmA2C2huzxvh+F61I4UCOG4JQXBwLAJDU+RwdcmqZrxqhaHQmjqZpcDrjSr4cFo76fhQZTYHJClKSpvqGZYWm0rp+kaM5momTSklWVqUAKmyJRsHA5lsMIhRQe6TC8Y+-pzMJPj4EwMBNFoXD5CshBkCUSoxWBMU4TF8RuqcXjWLq8RaORgiUdRtHuk1eAWtxEgCqgcZlNVtVgTOVE0SUzVNdxPkvK4ZCSHQTxbq02RdGIqATqgHQcJmcaPuuYCUuA0DwNQh6LgshxjvgRCkBQVDINJeCoPqt3EKgt33o+qZhvw8AaHgkiivw1iiRAwIWsDhIWghoOYVBcIAMxwhg0N4MCAAcFoAJwAOxQXgcMMXDSPY+jFpI3IQMgxawIQ3gUFQQhqMYOjiNI0xqPujCGD41BGCYXCSM8yTwMWqD0OU9TvPs4zCGWqjeBs3CVME9D0P82TMIi1B6MIVzEtQwjcuc9zMJM8rgsWnCIuE+jGBY8jCFI+jDNs9LeME3zgMC6DUHmzC0MYNLyPAghwJY472P09jUMIcboPo+b9Fa-70O86HwLy3C6MwujUdE+bqN05h-s68nVPw9jvNK27ZOoyLSNI9Cfu16j0Mp7LRdwlBwJwlHzHVzXnGM03YMy1bxfczDMJd+Dg9QSz0IMcj0PwgjLf6+H0Oo13FNT6j8Jh-P0-B33WNtwvyuT2fVMYwz8+o0DQ-4870XAuXpOT5vkO587yNsdDDu+yPVNE3XhXSewst52z-l-WG7o4YI05ljGmbFT6g1VoPQmYM+5fx5tzUO0t24ayQabSmhMM7xyRobZiQ89Yl3bkHAhntUEWmirvXmjDm4YD1lTQ249gHRyIRadG0IU7IxhmjUO8DxZQyRs-YGk8kZEOYkjCBvM07uk5hzP+xDQQ8LRnwwO4thFkIRgzS2KcNYwi0S-Qk3dUFA0UXPJG0VUb4x9gxS2Rjp7cMsUxeR6slFQQXphNmmFLYMxRhaaRYMrFvzwGYkJjMoaE0oXgRRKda6u1Jm-eR6cS7I3VjXf+djkm2wscDTe0SBG2xyQ43OuNxaKIRrXBCncK6b1AcEp+JjGYaxZjg5JsJknQwtJ40pyCiGDJxl0teDNnaKOlrzXOytN5mxsbXZhmMn7FzlnTOWUiFktI9mMypQi7YOIYpzBiTEBmN0Wbw1BicOL2KZqbUOOy-67ItDc7OqDLSazlsjKR0VQ4MTmYM4Z5NQZVzuajfONcab3zDts5JHdI77OscE72HEr41zttAhFw8pH8Jud475cI6ZYuhYw0ODM6YNLhEDIl5S4R6PxsjRuCFdbsLwHTLGpyPkVzaUQmGPsYWoyZfCrZ+K6V8tJqAxlsMlEY0lmIrlnKHG22VqAtpMTSWFNZdC7mJcyXJJ5sTflozUHt3zizQOcsYGMQ4qkshJTwmg2WcE9uiirXhJhEfcWdM5miszmaxhRC8nD2BCzHmtSsZMU5TfamGrbnBPRonDBLNa6qJLsxQ1YMUUytBnI1BUiW4RuYgI+W2bMI11RlBRNOii2w0RtCpuBqU7ZtSTfPNwNhZopiWQuGV9oVp1qQjbNDE7ZN0TcS4JSNc7huhSjaZ-Ts20sxlO8pN86ZCJvsDeFFyHkDIQkG0mKDz7oycZbOenab7Y3tfin+0rgYoOiSjWm+ib7QygvfO9qSELq2VigrVi7rY3zboEv+7bkkwmhQB81VaiaKJA8Ce2TtDWqqPY+oZrrKZM38WmiNGNQ4I39UiwOsGQ2DyZiQ7dTcNnO0ubXBx5GY6UYDrMptC9-FEb6XM9ltaK4oMLVWjuwqOPdKLlumJudMMoMhVWlt8dG6KqHljblUnkOwd7VI7JIHzGDKSYilGNNNPnydRxXTPqD6YSNeeydAmok4fIZyiNPrt7F2loi2zYK3WOcJmm6DSqfbUv6fbMhytlkvrpZJiNTLnkuJVaYpxmHllAbboimLyMGY+1UyXe2P9wtweSfROGIG4TQfdKJ6WmMBEFcIZR+iPs-aBqGXgH2Er3VMtq-QqtAi2YstFY3a2f8qt0u80m5JDdnM1ttkN1J4t06MNq0JibTd+kRvopaRGeLTEL2aaTZZcmJti36+rfhW3QkhbhDDArWn43zunuW0TiGYmLxu6Zxuii-kYyBll1VnL0Zt34-thzlGa1qYjenaGmEgt9OMchoBpNuuU0jXTfrmMM5Dzm1jQm9Flb0OiSzFmin0a8wYmzFOecYm2zBfQrV0LgTQitUZ1mfdFHGP4c6+hp6uVHr602xjgS+muMDph+hbquUBzhkz6DWMfb40+xfFGeODmDxvpad9E7pauNyzI5X-Dke0fnbOmtrX+n4w1gDvXy3G4B3ffGhG2WhcxLRl2ijh3G5ld3h-MrpueVUzIce4Gnte2NxTWmpxjbHeW1wQIwPIbp1cvuX3QZwM3ONb6bAu2nOQfWdc617tm2YeWz1us5WLHz6ir-SXFPw7TcXaMUxIHwMWME7K2o-PRNyZDyrZy6eGmK4sbpzzKX+fmIByHsCrW6sodl8K9Ngdo+O5k9Z8PL9cJMMsfFzWpl1ewaGyXn0lO6sE0D5V9Z6mbjR8pulnLmJYcHsI+b+NjGaNh6DJPXX2HVPoOz6+dZgH6e7+Qcv24682jCceLG7u560e+eS+suf2xiGGs+IetcWW5Mi6puoBriHSyBFes6lszi4SpsDET2w8vWG+OeXK6a-SgyTcdsvuTu6Oe2u6EMyOjcFW4S6+8B1KMSa+yshaBOzaNB4SGs4GPexi0GcehadOA2wha8Z2oBxitczqha3OucNa4soKTEIBKqri-iUh2Gg8zEpst+oKTcRi82bya8zBXy3W9qZaf8oKV2vqWyxqluFcha5e9hQyYcoK56+MbMk+oSoe-BBalMxh28vhpsQycst+Rq28icoR9amExh3snK4ygyWuYckG2828oRIeNaHEDupsV2tScsY69q-CYKciCeTiQMmhpsJO4ik++MzEMMpqpMNRBOKamK+e0ULW5yd65RgcTGFccmyOJOphrCRMxcbavRIu6SqeoM3R1MfRloKccMwx2RrKHRSxLqquGsCugyki8K0seio6C8tCYxc+vWDReSDM7e7KWs7KZcyskKW+6c7GxxTioBba5OjEMI0Gj+9adhSWnMN+HOlKnMDMR6fcksFsbxz+ZCmsaBkOuCjEMaPqYMiJf+VBNM+emMScIcVeo65CYKkK7uNc8Wgy56PqvSsJrR6+aMiJBRUOjhRMtsqGFy7GTSsMzqVctR28HEsRRMbEpxjEqOjEdKtMLJghTi7JDiisvS9RKR6+Ti-MaK4RAsmshBVJsC8c7oTSQyTe1i0Sxhgyb+aM5MS6rRJGTSTE0i1iWqxhs6WsmRAcGxu8B6TSQMJS1i3OzETEdc+e0K0KnElygxDOzxMMHcGpJs4ugZUOIZn6dMJhMSiM0IpJZCj+1idhgZO+JBaMZWn2Xe4JiMcMfxGcwy1iXhgZZCURGMO8086iLKmZAJTKfpJsy2Y+yMyeaMga9MAO7miMKRPqhscZEKWprEN+gZmMsIqx0JiMRR7Z56E5vazEoKvhG5c6oq6i1smsfxTKJpgsCeG5nuWWbRoq9M9Exc+5UpHJa5Zp4SN8bpZaTM9Mzyls+cmsZx3s45bs06Wp3smxrWzEhR9M2uc8vyAJYMjpr8QFfm0OTEDp8MmMd++5zxic9KAFICWpV2wpoFgcUMsILWV80F7KKagexKAZps4CsuTE3snMT86ifsHEZx1hVFk8CZjCgchF0UlsMxZZtuMaicV2Gpk8eZjCn6mh2hYZDOFhQis8jEa87c4l42zE6sxehFucAl0Gd+CMDOylmMcFYRRh-CwMb+gcQMMC6sd+ily6ic6qOFk5ZlKanqoFrEEaXMtsxcrZyl28ux3i65-CMMr5QcgJXMpKvlS5w87KpK1Z4Mp5IViKUO-s2yGyV8HErRis5MalgcWp9sgioFKeZKvFBBMV5RmRjpmSZlDijOxVtswq56ySMVrR8OVFZSWpoqbWxVissy9sLVb6MJNs1VQsXVO+zi7KQJ8M08fS5RkmgcGso1WGZlGMRqUOn6vii1X+b6KR4VJpSyXVX6llicFpMMfStpEGQc0UGpm8kl28nMDuksYMxebmlO9RFyQcN8t16laM9syeksAcmKDih+jEWlRFbcP1uJTET6r5gJUZASg1hSgcGcXa+VyRjEGl0FUOY50JelKSjEiibVTEzB+V65YFkpONZcvsJOF1EpV1KNP1p5Dp7eUO6+oVipKqMJz2IupsTNZpDFBFbNT80IAObabacSVl6pAFAqRhIu0Ik17R2yoqxco69GrE+CMtyx4Rgca8llV2Kp3socrRnSzM6+GpmqOtDOX5oFgOgirE9JlsMaf6s6FthWQZpsNBTSTMBBV2xcFyNt2hN1WtdWKRKNbM9FOq2WPui5sJYdUM1ZoCeZRFRNoFNMGsGAQyR+4sR6mNAOaNoCtZgcGhF5-iPMg5e5GJcJ7KsMbt0N7KXlKcUOkiRRyGxcMJnMwx8Oddh2LNZZzdRmXMHc0VVeXdhMbt5NbElNGGUZbdj1Vdo6LNE958DFdFoFAivZ5M4iEtzx-CdsE9AtTKMBUO6csaV2kMy6l+zElo1Zp6OtHZ6RR6pKjWGV0Zy65MuVAFz6991MAN9sHNUi+lUpEG3qOZgGOtDW690KJi4Sd+Fy9G4SSuX97tM9llKMrpbGcDwD1KhMfpKCCZvOhSUOtc087Cn5y6EdXK8yGpKCydPtoFZCccPpWDTx+MD1j6ks6lM2QtM27cM15unKTx5+RMNDplYd28bMT11aQWINptwZA2YDLl4jacXt9OFZJul6yl-S8aeDViJse15MT1HuQWC8dlWjPK0mojp51lmsJBtMbc5OoiV9xGVpVjZpQM7coFjZ+sac6FjEwZdsR6GpPmRhQMdJUOucvZ9E2O2RPsHa4SwT2toTRMSlA8VR7ClyMBeicyNMHDKW4Rku9SrWvpFpTRLDqS6+1ZyyAZAcjcmhYT5MnEKtTtmNqqdKUE20eAu0sACAyAOwewbgJ0LAZ03Yl0ZA1AGA8QLAcQ8QhIVwNwhIdwjgTAGA8zYYiz9whIaoGocATAaIEAjozoWgiATAFopz5zCErgMAAA3HIOSHIJM9MwkHM9cOs0sys1YDYHYCswlHADRHQISKM1AC2HkPs+MCsCwFYIFCcySKKLcxAPcxAHIOBI8zMy8ws+86s683ABs44FszpDs4gGwIYCUFgJVHYHUHs8iy8Ic1wMc6c+wlc-C+BIiw8+wFwNgISBwDgNyDWISMWMIGC0wBC1C9gCczQDUI4PC56JKycwhEwPK1AGyMQEwAAIRmBCCBBkDStMBoRyvAxWjwussQCqgqCcvcvYC8u6D8tsgphMAAB8TAAAVFS9SCK-KOK5KzqxK04HKwqwYMqzq3qwqwa0a60Kaxy1yzy9WNawKw686-Gy60K+69C6+F6+cD644H64q4G+cMG8YYa3c+G+y9wFG5azG2QDa+yGyIm7W460m3WMpKK5604N67K-6zm3hEG5oDEPq9aEa9tAALpAA). preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxMArhwA6EPgKGtO3AO4cAJgHM4ZFkyj6WquQsHDUAG2JlL2DHAAeqOnBb7DTVI9P9zXqAgNT09UDTl6RgCyNksOACNePyUABSgYuTk0MI46JgBeJjSYgAoAfTKaDks4CoBKLChXckzodDLpAqkORp1K6ssoeJqSuSZujC5CS0kNWsJ3EuyNXKYAeiYZMBYybBqWDAWWLbq8MYmANygZ2vjiR1GIcefNsAAVG2umAGVrt14ngBFABMWwkWwAJMCMAAWACsAFkwecXiAttNDMckK92FANMRVABaCCkOBbAC+ZyeL2UBMIhjg+WMGGIkjIqDZZXU2l0o22qCaAGs4hAyWBTijnuw6QyyoNsKyyPlpBhpap6SxajUaGQyoRKBQ6CVuTF8lsYQAGACkJ3OEupAo0KwgWnyFqp4yqlkGw1qMGI8WqjLedEkZIgdVacxorDgdAucZKXA5ZAkipTEk17g4pDqiHOAAF02zC8zmnM6FzNDoyOdo6wBXRhVw4CU85LxnASCSYBwFl0whhXHi9SwLkt0Cs8hsAORd0iMPsHBYXGeR6kvKpaAeODAi1vzntLiSOfIz4IUGcSbBn1AsKAJoRrjtMLcYSRhdK1Mh0KD6lglPuerENYdBngAxJaABsACiABiACMV5MEBJpsPkCESF6lhnmQxAAF5xsQ2DIdhJCgWedBaPEUAlFBMJ4AhCHusCMKYRaGDAnUyFsMQj5cDQxBmmA2C2huzxvh+F61I4UCOG4JQXBwLAJDU+RwdcmqZrxqhaHQmjqZpcDrjSr4cFo76fhQZTYHJClKSpvqGZYWm0rp+kaM5momTSklWVqUAKmyJRsHA5lsMIhRQe6TC8Y+-pzMJPj4EwMBNFoXD5CshBkCUSoxWBMU4TF8RuqcXjWLq8RaORgiUdRtHuk1eAWtxEgCqgcZlNVtVgTOVE0SUzVNdxPkvK4ZCSHQTxbq02RdGIqATqgHQcJmcaPuuYCUuA0DwNQh6LgshxjvgRCkBQVDINJeCoPqt3EKgt33o+qZhvw8AaHgkiivw1iiRAwIWsDhIWghoOYVBcIAMxwhg0N4MCAAcFoAJwAOxQXgcMMXDSPY+jFpI3IQMgxawIQ3gUFQQhqMYOjiNI0xqPujCGD41BGCYXCSM8yTwMWqD0OU9TvPs4zCGWqjeBs3CVME9D0P82TMIi1B6MIVzEtQwjcuc9zMJM8rgsWnCIuE+jGBY8jCFI+jDNs9LeME3zgMC6DUHmzC0MYNLyPAghwJY472P09jUMIcboPo+b9Fa-70O86HwLy3C6MwujUdE+bqN05h-s68nVPw9jvNK27ZOoyLSNI9Cfu16j0Mp7LRdwlBwJwlHzHVzXnGM03YMy1bxfczDMJd+Dg9QSz0IMcj0PwgjLf6+H0Oo13FNT6j8Jh-P0-B33WNtwvyuT2fVMYwz8+o0DQ-4870XAuXpOT5vkO587yNsdDDu+yPVNE3XhXSewst52z-l-WG7o4YI05ljGmbFT6g1VoPQmYM+5fx5tzUO0t24ayQabSmhMM7xyRobZiQ89Yl3bkHAhntUEWmirvXmjDm4YD1lTQ249gHRyIRadG0IU7IxhmjUO8DxZQyRs-YGk8kZEOYkjCBvM07uk5hzP+xDQQ8LRnwwO4thFkIRgzS2KcNYwi0S-Qk3dUFA0UXPJG0VUb4x9gxS2Rjp7cMsUxeR6slFQQXphNmmFLYMxRhaaRYMrFvzwGYkJjMoaE0oXgRRKda6u1Jm-eR6cS7I3VjXf+djkm2wscDTe0SBG2xyQ43OuNxaKIRrXBCncK6b1AcEp+JjGYaxZjg5JsJknQwtJ40pyCiGDJxl0teDNnaKOlrzXOytN5mxsbXZhmMn7FzlnTOWUiFktI9mMypQi7YOIYpzBiTEBmN0Wbw1BicOL2KZqbUOOy-67ItDc7OqDLSazlsjKR0VQ4MTmYM4Z5NQZVzuajfONcab3zDts5JHdI77OscE72HEr41zttAhFw8pH8Jud475cI6ZYuhYw0ODM6YNLhEDIl5S4R6PxsjRuCFdbsLwHTLGpyPkVzaUQmGPsYWoyZfCrZ+K6V8tJqAxlsMlEY0lmIrlnKHG22VqAtpMTSWFNZdC7mJcyXJJ5sTflozUHt3zizQOcsYGMQ4qkshJTwmg2WcE9uiirXhJhEfcWdM5miszmaxhRC8nD2BCzHmtSsZMU5TfamGrbnBPRonDBLNa6qJLsxQ1YMUUytBnI1BUiW4RuYgI+W2bMI11RlBRNOii2w0RtCpuBqU7ZtSTfPNwNhZopiWQuGV9oVp1qQjbNDE7ZN0TcS4JSNc7huhSjaZ-Ts20sxlO8pN86ZCJvsDeFFyHkDIQkG0mKDz7oycZbOenab7Y3tfin+0rgYoOiSjWm+ib7QygvfO9qSELq2VigrVi7rY3zboEv+7bkkwmhQB81VaiaKJA8Ce2TtDWqqPY+oZrrKZM38WmiNGNQ4I39UiwOsGQ2DyZiQ7dTcNnO0ubXBx5GY6UYDrMptC9-FEb6XM9ltaK4oMLVWjuwqOPdKLlumJudMMoMhVWlt8dG6KqHljblUnkOwd7VI7JIHzGDKSYilGNNNPnydRxXTPqD6YSNeeydAmok4fIZyiNPrt7F2loi2zYK3WOcJmm6DSqfbUv6fbMhytlkvrpZJiNTLnkuJVaYpxmHllAbboimLyMGY+1UyXe2P9wtweSfROGIG4TQfdKJ6WmMBEFcIZR+iPs-aBqGXgH2Er3VMtq-QqtAi2YstFY3a2f8qt0u80m5JDdnM1ttkN1J4t06MNq0JibTd+kRvopaRGeLTEL2aaTZZcmJti36+rfhW3QkhbhDDArWn43zunuW0TiGYmLxu6Zxuii-kYyBll1VnL0Zt34-thzlGa1qYjenaGmEgt9OMchoBpNuuU0jXTfrmMM5Dzm1jQm9Flb0OiSzFmin0a8wYmzFOecYm2zBfQrV0LgTQitUZ1mfdFHGP4c6+hp6uVHr602xjgS+muMDph+hbquUBzhkz6DWMfb40+xfFGeODmDxvpad9E7pauNyzI5X-Dke0fnbOmtrX+n4w1gDvXy3G4B3ffGhG2WhcxLRl2ijh3G5ld3h-MrpueVUzIce4Gnte2NxTWmpxjbHeW1wQIwPIbp1cvuX3QZwM3ONb6bAu2nOQfWdc617tm2YeWz1us5WLHz6ir-SXFPw7TcXaMUxIHwMWME7K2o-PRNyZDyrZy6eGmK4sbpzzKX+fmIByHsCrW6sodl8K9Ngdo+O5k9Z8PL9cJMMsfFzWpl1ewaGyXn0lO6sE0D5V9Z6mbjR8pulnLmJYcHsI+b+NjGaNh6DJPXX2HVPoOz6+dZgH6e7+Qcv24682jCceLG7u560e+eS+suf2xiGGs+IetcWW5Mi6puoBriHSyBFes6lszi4SpsDET2w8vWG+OeXK6a-SgyTcdsvuTu6Oe2u6EMyOjcFW4S6+8B1KMSa+yshaBOzaNB4SGs4GPexi0GcehadOA2wha8Z2oBxitczqha3OucNa4soKTEIBKqri-iUh2Gg8zEpst+oKTcRi82bya8zBXy3W9qZaf8oKV2vqWyxqluFcha5e9hQyYcoK56+MbMk+oSoe-BBalMxh28vhpsQycst+Rq28icoR9amExh3snK4ygyWuYckG2828oRIeNaHEDupsV2tScsY69q-CYKciCeTiQMmhpsJO4ik++MzEMMpqpMNRBOKamK+e0ULW5yd65RgcTGFccmyOJOphrCRMxcbavRIu6SqeoM3R1MfRloKccMwx2RrKHRSxLqquGsCugyki8K0seio6C8tCYxc+vWDReSDM7e7KWs7KZcyskKW+6c7GxxTioBba5OjEMI0Gj+9adhSWnMN+HOlKnMDMR6fcksFsbxz+ZCmsaBkOuCjEMaPqYMiJf+VBNM+emMScIcVeo65CYKkK7uNc8Wgy56PqvSsJrR6+aMiJBRUOjhRMtsqGFy7GTSsMzqVctR28HEsRRMbEpxjEqOjEdKtMLJghTi7JDiisvS9RKR6+Ti-MaK4RAsmshBVJsC8c7oTSQyTe1i0Sxhgyb+aM5MS6rRJGTSTE0i1iWqxhs6WsmRAcGxu8B6TSQMJS1i3OzETEdc+e0K0KnElygxDOzxMMHcGpJs4ugZUOIZn6dMJhMSiM0IpJZCj+1idhgZO+JBaMZWn2Xe4JiMcMfxGcwy1iXhgZZCURGMO8086iLKmZAJTKfpJsy2Y+yMyeaMga9MAO7miMKRPqhscZEKWprEN+gZmMsIqx0JiMRR7Z56E5vazEoKvhG5c6oq6i1smsfxTKJpgsCeG5nuWWbRoq9M9Exc+5UpHJa5Zp4SN8bpZaTM9Mzyls+cmsZx3s45bs06Wp3smxrWzEhR9M2uc8vyAJYMjpr8QFfm0OTEDp8MmMd++5zxic9KAFICWpV2wpoFgcUMsILWV80F7KKagexKAZps4CsuTE3snMT86ifsHEZx1hVFk8CZjCgchF0UlsMxZZtuMaicV2Gpk8eZjCn6mh2hYZDOFhQis8jEa87c4l42zE6sxehFucAl0Gd+CMDOylmMcFYRRh-CwMb+gcQMMC6sd+ily6ic6qOFk5ZlKanqoFrEEaXMtsxcrZyl28ux3i65-CMMr5QcgJXMpKvlS5w87KpK1Z4Mp5IViKUO-s2yGyV8HErRis5MalgcWp9sgioFKeZKvFBBMV5RmRjpmSZlDijOxVtswq56ySMVrR8OVFZSWpoqbWxVissy9sLVb6MJNs1VQsXVO+zi7KQJ8M08fS5RkmgcGso1WGZlGMRqUOn6vii1X+b6KR4VJpSyXVX6llicFpMMfStpEGQc0UGpm8kl28nMDuksYMxebmlO9RFyQcN8t16laM9syeksAcmKDih+jEWlRFbcP1uJTET6r5gJUZASg1hSgcGcXa+VyRjEGl0FUOY50JelKSjEiibVTEzB+V65YFkpONZcvsJOF1EpV1KNP1p5Dp7eUO6+oVipKqMJz2IupsTNZpDFBFbNT80IAObabacSVl6pAFAqRhIu0Ik17R2yoqxco69GrE+CMtyx4Rgca8llV2Kp3socrRnSzM6+GpmqOtDOX5oFgOgirE9JlsMaf6s6FthWQZpsNBTSTMBBV2xcFyNt2hN1WtdWKRKNbM9FOq2WPui5sJYdUM1ZoCeZRFRNoFNMGsGAQyR+4sR6mNAOaNoCtZgcGhF5-iPMg5e5GJcJ7KsMbt0N7KXlKcUOkiRRyGxcMJnMwx8Oddh2LNZZzdRmXMHc0VVeXdhMbt5NbElNGGUZbdj1Vdo6LNE958DFdFoFAivZ5M4iEtzx-CdsE9AtTKMBUO6csaV2kMy6l+zElo1Zp6OtHZ6RR6pKjWGV0Zy65MuVAFz6991MAN9sHNUi+lUpEG3qOZgGOtDW690KJi4Sd+Fy9G4SSuX97tM9llKMrpbGcDwD1KhMfpKCCZvOhSUOtc087Cn5y6EdXK8yGpKCydPtoFZCccPpWDTx+MD1j6ks6lM2QtM27cM15unKTx5+RMNDplYd28bMT11aQWINptwZA2YDLl4jacXt9OFZJul6yl-S8aeDViJse15MT1HuQWC8dlWjPK0mojp51lmsJBtMbc5OoiV9xGVpVjZpQM7coFjZ+sac6FjEwZdsR6GpPmRhQMdJUOucvZ9E2O2RPsHa4SwT2toTRMSlA8VR7ClyMBeicyNMHDKW4Rku9SrWvpFpTRLDqS6+1ZyyAZAcjcmhYT5MnEKtTtmNqqdKUE20eAu0sACAyAOwewbgJ0LAZ03Yl0ZA1AGA8QLAcQ8QhIVwNwhIdwjgTAGA8zYYiz9whIaoGocATAaIEAjozoWgiATAFopz5zCErgMAAA3HIOSHIJM9MwkHM9cOs0sys1YDYHYCswlHADRHQISKM1AC2HkPs+MCsCwFYIFCcySKKLcxAPcxAHIOBI8zMy8ws+86s683ABs44FszpDs4gGwIYCUFgJVHYHUHs8iy8Ic1wMc6c+wlc-C+BIiw8+wFwNgISBwDgNyDWISMWMIGC0wBC1C9gCczQDUI4PC56JKycwhEwPK1AGyMQEwAAIRmBCCBBkDStMBoRyvAxWjwussQCqgqCcvcvYC8u6D8tsgphMAAB8TAAAVFS9SCK-KOK5KzqxK04HKwqwYMqzq3qwqwa0a60Kaxy1yzy9WNawKw686-Gy60K+69C6+F6+cD644H64q4G+cMG8YYa3c+G+y9wFG5azG2QDa+yGyIm7W460m3WMpKK5604N67K-6zm3hEG5oDEPq9aEa9tAALpAA shinylive: https://shinylive.io/py/editor/#code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxMArhwA6EPgKGtO3AO4cAJgHM4ZFkyj6WquQsHDUAG2JlL2DHAAeqOnBb7DTVI9P9zXqAgNT09UDTl6RgCyNksOACNePyUABSgYuTk0MI46JgBeJjSYgAoAfTKaDks4CoBKLChXckzodDLpAqkORp1K6ssoeJqSuSZujC5CS0kNWsJ3EuyNXKYAeiYZMBYybBqWDAWWLbq8MYmANygZ2vjiR1GIcefNsAAVG2umAGVrt14ngBFABMWwkWwAJMCMAAWACsAFkwecXiAttNDMckK92FANMRVABaCCkOBbAC+ZyeL2UBMIhjg+WMGGIkjIqDZZXU2l0o22qCaAGs4hAyWBTijnuw6QyyoNsKyyPlpBhpap6SxajUaGQyoRKBQ6CVuTF8lsYQAGACkJ3OEupAo0KwgWnyFqp4yqlkGw1qMGI8WqjLedEkZIgdVacxorDgdAucZKXA5ZAkipTEk17g4pDqiHOAAF02zC8zmnM6FzNDoyOdo6wBXRhVw4CU85LxnASCSYBwFl0whhXHi9SwLkt0Cs8hsAORd0iMPsHBYXGeR6kvKpaAeODAi1vzntLiSOfIz4IUGcSbBn1AsKAJoRrjtMLcYSRhdK1Mh0KD6lglPuerENYdBngAxJaABsACiABiACMV5MEBJpsPkCESF6lhnmQxAAF5xsQ2DIdhJCgWedBaPEUAlFBMJ4AhCHusCMKYRaGDAnUyFsMQj5cDQxBmmA2C2huzxvh+F61I4UCOG4JQXBwLAJDU+RwdcmqZrxqhaHQmjqZpcDrjSr4cFo76fhQZTYHJClKSpvqGZYWm0rp+kaM5momTSklWVqUAKmyJRsHA5lsMIhRQe6TC8Y+-pzMJPj4EwMBNFoXD5CshBkCUSoxWBMU4TF8RuqcXjWLq8RaORgiUdRtHuk1eAWtxEgCqgcZlNVtVgTOVE0SUzVNdxPkvK4ZCSHQTxbq02RdGIqATqgHQcJmcaPuuYCUuA0DwNQh6LgshxjvgRCkBQVDINJeCoPqt3EKgt33o+qZhvw8AaHgkiivw1iiRAwIWsDhIWghoOYVBcIAMxwhg0N4MCAAcFoAJwAOxQXgcMMXDSPY+jFpI3IQMgxawIQ3gUFQQhqMYOjiNI0xqPujCGD41BGCYXCSM8yTwMWqD0OU9TvPs4zCGWqjeBs3CVME9D0P82TMIi1B6MIVzEtQwjcuc9zMJM8rgsWnCIuE+jGBY8jCFI+jDNs9LeME3zgMC6DUHmzC0MYNLyPAghwJY472P09jUMIcboPo+b9Fa-70O86HwLy3C6MwujUdE+bqN05h-s68nVPw9jvNK27ZOoyLSNI9Cfu16j0Mp7LRdwlBwJwlHzHVzXnGM03YMy1bxfczDMJd+Dg9QSz0IMcj0PwgjLf6+H0Oo13FNT6j8Jh-P0-B33WNtwvyuT2fVMYwz8+o0DQ-4870XAuXpOT5vkO587yNsdDDu+yPVNE3XhXSewst52z-l-WG7o4YI05ljGmbFT6g1VoPQmYM+5fx5tzUO0t24ayQabSmhMM7xyRobZiQ89Yl3bkHAhntUEWmirvXmjDm4YD1lTQ249gHRyIRadG0IU7IxhmjUO8DxZQyRs-YGk8kZEOYkjCBvM07uk5hzP+xDQQ8LRnwwO4thFkIRgzS2KcNYwi0S-Qk3dUFA0UXPJG0VUb4x9gxS2Rjp7cMsUxeR6slFQQXphNmmFLYMxRhaaRYMrFvzwGYkJjMoaE0oXgRRKda6u1Jm-eR6cS7I3VjXf+djkm2wscDTe0SBG2xyQ43OuNxaKIRrXBCncK6b1AcEp+JjGYaxZjg5JsJknQwtJ40pyCiGDJxl0teDNnaKOlrzXOytN5mxsbXZhmMn7FzlnTOWUiFktI9mMypQi7YOIYpzBiTEBmN0Wbw1BicOL2KZqbUOOy-67ItDc7OqDLSazlsjKR0VQ4MTmYM4Z5NQZVzuajfONcab3zDts5JHdI77OscE72HEr41zttAhFw8pH8Jud475cI6ZYuhYw0ODM6YNLhEDIl5S4R6PxsjRuCFdbsLwHTLGpyPkVzaUQmGPsYWoyZfCrZ+K6V8tJqAxlsMlEY0lmIrlnKHG22VqAtpMTSWFNZdC7mJcyXJJ5sTflozUHt3zizQOcsYGMQ4qkshJTwmg2WcE9uiirXhJhEfcWdM5miszmaxhRC8nD2BCzHmtSsZMU5TfamGrbnBPRonDBLNa6qJLsxQ1YMUUytBnI1BUiW4RuYgI+W2bMI11RlBRNOii2w0RtCpuBqU7ZtSTfPNwNhZopiWQuGV9oVp1qQjbNDE7ZN0TcS4JSNc7huhSjaZ-Ts20sxlO8pN86ZCJvsDeFFyHkDIQkG0mKDz7oycZbOenab7Y3tfin+0rgYoOiSjWm+ib7QygvfO9qSELq2VigrVi7rY3zboEv+7bkkwmhQB81VaiaKJA8Ce2TtDWqqPY+oZrrKZM38WmiNGNQ4I39UiwOsGQ2DyZiQ7dTcNnO0ubXBx5GY6UYDrMptC9-FEb6XM9ltaK4oMLVWjuwqOPdKLlumJudMMoMhVWlt8dG6KqHljblUnkOwd7VI7JIHzGDKSYilGNNNPnydRxXTPqD6YSNeeydAmok4fIZyiNPrt7F2loi2zYK3WOcJmm6DSqfbUv6fbMhytlkvrpZJiNTLnkuJVaYpxmHllAbboimLyMGY+1UyXe2P9wtweSfROGIG4TQfdKJ6WmMBEFcIZR+iPs-aBqGXgH2Er3VMtq-QqtAi2YstFY3a2f8qt0u80m5JDdnM1ttkN1J4t06MNq0JibTd+kRvopaRGeLTEL2aaTZZcmJti36+rfhW3QkhbhDDArWn43zunuW0TiGYmLxu6Zxuii-kYyBll1VnL0Zt34-thzlGa1qYjenaGmEgt9OMchoBpNuuU0jXTfrmMM5Dzm1jQm9Flb0OiSzFmin0a8wYmzFOecYm2zBfQrV0LgTQitUZ1mfdFHGP4c6+hp6uVHr602xjgS+muMDph+hbquUBzhkz6DWMfb40+xfFGeODmDxvpad9E7pauNyzI5X-Dke0fnbOmtrX+n4w1gDvXy3G4B3ffGhG2WhcxLRl2ijh3G5ld3h-MrpueVUzIce4Gnte2NxTWmpxjbHeW1wQIwPIbp1cvuX3QZwM3ONb6bAu2nOQfWdc617tm2YeWz1us5WLHz6ir-SXFPw7TcXaMUxIHwMWME7K2o-PRNyZDyrZy6eGmK4sbpzzKX+fmIByHsCrW6sodl8K9Ngdo+O5k9Z8PL9cJMMsfFzWpl1ewaGyXn0lO6sE0D5V9Z6mbjR8pulnLmJYcHsI+b+NjGaNh6DJPXX2HVPoOz6+dZgH6e7+Qcv24682jCceLG7u560e+eS+suf2xiGGs+IetcWW5Mi6puoBriHSyBFes6lszi4SpsDET2w8vWG+OeXK6a-SgyTcdsvuTu6Oe2u6EMyOjcFW4S6+8B1KMSa+yshaBOzaNB4SGs4GPexi0GcehadOA2wha8Z2oBxitczqha3OucNa4soKTEIBKqri-iUh2Gg8zEpst+oKTcRi82bya8zBXy3W9qZaf8oKV2vqWyxqluFcha5e9hQyYcoK56+MbMk+oSoe-BBalMxh28vhpsQycst+Rq28icoR9amExh3snK4ygyWuYckG2828oRIeNaHEDupsV2tScsY69q-CYKciCeTiQMmhpsJO4ik++MzEMMpqpMNRBOKamK+e0ULW5yd65RgcTGFccmyOJOphrCRMxcbavRIu6SqeoM3R1MfRloKccMwx2RrKHRSxLqquGsCugyki8K0seio6C8tCYxc+vWDReSDM7e7KWs7KZcyskKW+6c7GxxTioBba5OjEMI0Gj+9adhSWnMN+HOlKnMDMR6fcksFsbxz+ZCmsaBkOuCjEMaPqYMiJf+VBNM+emMScIcVeo65CYKkK7uNc8Wgy56PqvSsJrR6+aMiJBRUOjhRMtsqGFy7GTSsMzqVctR28HEsRRMbEpxjEqOjEdKtMLJghTi7JDiisvS9RKR6+Ti-MaK4RAsmshBVJsC8c7oTSQyTe1i0Sxhgyb+aM5MS6rRJGTSTE0i1iWqxhs6WsmRAcGxu8B6TSQMJS1i3OzETEdc+e0K0KnElygxDOzxMMHcGpJs4ugZUOIZn6dMJhMSiM0IpJZCj+1idhgZO+JBaMZWn2Xe4JiMcMfxGcwy1iXhgZZCURGMO8086iLKmZAJTKfpJsy2Y+yMyeaMga9MAO7miMKRPqhscZEKWprEN+gZmMsIqx0JiMRR7Z56E5vazEoKvhG5c6oq6i1smsfxTKJpgsCeG5nuWWbRoq9M9Exc+5UpHJa5Zp4SN8bpZaTM9Mzyls+cmsZx3s45bs06Wp3smxrWzEhR9M2uc8vyAJYMjpr8QFfm0OTEDp8MmMd++5zxic9KAFICWpV2wpoFgcUMsILWV80F7KKagexKAZps4CsuTE3snMT86ifsHEZx1hVFk8CZjCgchF0UlsMxZZtuMaicV2Gpk8eZjCn6mh2hYZDOFhQis8jEa87c4l42zE6sxehFucAl0Gd+CMDOylmMcFYRRh-CwMb+gcQMMC6sd+ily6ic6qOFk5ZlKanqoFrEEaXMtsxcrZyl28ux3i65-CMMr5QcgJXMpKvlS5w87KpK1Z4Mp5IViKUO-s2yGyV8HErRis5MalgcWp9sgioFKeZKvFBBMV5RmRjpmSZlDijOxVtswq56ySMVrR8OVFZSWpoqbWxVissy9sLVb6MJNs1VQsXVO+zi7KQJ8M08fS5RkmgcGso1WGZlGMRqUOn6vii1X+b6KR4VJpSyXVX6llicFpMMfStpEGQc0UGpm8kl28nMDuksYMxebmlO9RFyQcN8t16laM9syeksAcmKDih+jEWlRFbcP1uJTET6r5gJUZASg1hSgcGcXa+VyRjEGl0FUOY50JelKSjEiibVTEzB+V65YFkpONZcvsJOF1EpV1KNP1p5Dp7eUO6+oVipKqMJz2IupsTNZpDFBFbNT80IAObabacSVl6pAFAqRhIu0Ik17R2yoqxco69GrE+CMtyx4Rgca8llV2Kp3socrRnSzM6+GpmqOtDOX5oFgOgirE9JlsMaf6s6FthWQZpsNBTSTMBBV2xcFyNt2hN1WtdWKRKNbM9FOq2WPui5sJYdUM1ZoCeZRFRNoFNMGsGAQyR+4sR6mNAOaNoCtZgcGhF5-iPMg5e5GJcJ7KsMbt0N7KXlKcUOkiRRyGxcMJnMwx8Oddh2LNZZzdRmXMHc0VVeXdhMbt5NbElNGGUZbdj1Vdo6LNE958DFdFoFAivZ5M4iEtzx-CdsE9AtTKMBUO6csaV2kMy6l+zElo1Zp6OtHZ6RR6pKjWGV0Zy65MuVAFz6991MAN9sHNUi+lUpEG3qOZgGOtDW690KJi4Sd+Fy9G4SSuX97tM9llKMrpbGcDwD1KhMfpKCCZvOhSUOtc087Cn5y6EdXK8yGpKCydPtoFZCccPpWDTx+MD1j6ks6lM2QtM27cM15unKTx5+RMNDplYd28bMT11aQWINptwZA2YDLl4jacXt9OFZJul6yl-S8aeDViJse15MT1HuQWC8dlWjPK0mojp51lmsJBtMbc5OoiV9xGVpVjZpQM7coFjZ+sac6FjEwZdsR6GpPmRhQMdJUOucvZ9E2O2RPsHa4SwT2toTRMSlA8VR7ClyMBeicyNMHDKW4Rku9SrWvpFpTRLDqS6+1ZyyAZAcjcmhYT5MnEKtTtmNqqdKUE20eAu0sACAyAOwewbgJ0LAZ03Yl0ZA1AGA8QLAcQ8QhIVwNwhIdwjgTAGA8zYYiz9whIaoGocATAaIEAjozoWgiATAFopz5zCErgMAAA3HIOSHIJM9MwkHM9cOs0sys1YDYHYCswlHADRHQISKM1AC2HkPs+MCsCwFYIFCcySKKLcxAPcxAHIOBI8zMy8ws+86s683ABs44FszpDs4gGwIYCUFgJVHYHUHs8iy8Ic1wMc6c+wlc-C+BIiw8+wFwNgISBwDgNyDWISMWMIGC0wBC1C9gCczQDUI4PC56JKycwhEwPK1AGyMQEwAAIRmBCCBBkDStMBoRyvAxWjwussQCqgqCcvcvYC8u6D8tsgphMAAB8TAAAVFS9SCK-KOK5KzqxK04HKwqwYMqzq3qwqwa0a60Kaxy1yzy9WNawKw686-Gy60K+69C6+F6+cD644H64q4G+cMG8YYa3c+G+y9wFG5azG2QDa+yGyIm7W460m3WMpKK5604N67K-6zm3hEG5oDEPq9aEa9tAALpAA - code: |4 - # see shiny-live page for details on additional files - - from pathlib import Path - - import pandas as pd - import plotly.express as px - import shinywidgets as sw - from shiny import App, ui - - appdir = Path(__file__).parent - - app_ui = ui.page_fillable( - ui.include_css(appdir / "styles.css"), - ui.value_box( - "Total Sales in Q2", - "$2.45M", - {"class": "shadow-none"}, - showcase=sw.output_widget("sparkline"), - showcase_layout=ui.showcase_left_center(width="40%"), - ), - padding=0, - fillable_mobile=True, - ) + code: | + # see shiny-live page for details on additional files + + from pathlib import Path + + import pandas as pd + import plotly.express as px + import shinywidgets as sw + from shiny import App, ui + + appdir = Path(__file__).parent + + app_ui = ui.page_fillable( + ui.include_css(appdir / "styles.css"), + ui.value_box( + "Total Sales in Q2", + "$2.45M", + {"class": "shadow-none"}, + showcase=sw.output_widget("sparkline"), + showcase_layout=ui.showcase_left_center(width="40%"), + ), + padding=0, + fillable_mobile=True, + ) - def server(input, output, session): - @sw.render_widget - def sparkline(): - economics = pd.read_csv(appdir / "economics.csv") - fig = px.line(economics, x="date", y="psavert") - fig.update_traces( - line_color="#406EF1", - line_width=1, - fill="tozeroy", - fillcolor="rgba(64,110,241,0.2)", - hoverinfo="y", - ) - fig.update_xaxes(visible=False, showgrid=False) - fig.update_yaxes(visible=False, showgrid=False) - fig.update_layout( - height=60, - hovermode="x", - margin=dict(t=0, r=0, l=0, b=0), - plot_bgcolor="rgba(0,0,0,0)", - paper_bgcolor="rgba(0,0,0,0)", - ) - return fig - - app = App(app_ui, server) + def server(input, output, session): + @sw.render_widget + def sparkline(): + economics = pd.read_csv(appdir / "economics.csv") + fig = px.line(economics, x="date", y="psavert") + fig.update_traces( + line_color="#406EF1", + line_width=1, + fill="tozeroy", + fillcolor="rgba(64,110,241,0.2)", + hoverinfo="y", + ) + fig.update_xaxes(visible=False, showgrid=False) + fig.update_yaxes(visible=False, showgrid=False) + fig.update_layout( + height=60, + hovermode="x", + margin=dict(t=0, r=0, l=0, b=0), + plot_bgcolor="rgba(0,0,0,0)", + paper_bgcolor="rgba(0,0,0,0)", + ) + return fig + + app = App(app_ui, server) --- diff --git a/components/outputs/verbatim-text.qmd b/components/outputs/verbatim-text.qmd index 8d5124ae..a541c9ff 100644 --- a/components/outputs/verbatim-text.qmd +++ b/components/outputs/verbatim-text.qmd @@ -1,6 +1,6 @@ --- -title: "Verbatim Text" -sidebar: components +title: Verbatim Text +sidebar: components previewapp: | from shiny import App, render, ui @@ -31,18 +31,18 @@ listing: ui.input_text("Text", "Enter text", "Hello Shiny"), ui.output_text_verbatim("text") #<< ) - + def server(input, output, session): @render.text #<< def text(): return input.Text() - + app = App(app_ui, server) relevantfunctions: - title: ui.output_text_verbatim href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html signature: ui.output_text_verbatim(id, placeholder=False) - - title: "@render.text" + - title: '@render.text' href: https://shiny.posit.co/py/api/render.text.html signature: render.text(fn=None) - id: variations @@ -50,21 +50,21 @@ listing: contents: variations: - title: Placeholder rectangle when string is empty - description: Verbatim text with a placeholder when the string to display is empty (see Details above). + description: Verbatim text with a placeholder when the string to display is empty (see Details above). preview: https://shinylive.io/py/app/#h=0&code=NobwRAdghgtgpmAXGKAHVA6VBPMAaMAYwHsIAXOcpMAMwCdiYACAZwAsBLCbJjmVYnTJMAgujxM6lACZw6EgK4cAOhFVpUAfSVMAvEyVYoAcziaaAGyXSAFKqYODHDF1QKymigA8ydsABU4H2V8JhCAUXI5JkDg0JCQgEo8e0dDYnc3D28PADc5ACMoMj4-HJCJVAsoQjg2YgtZOj0YugU4RKYAYgAeHtVE1VVZGlY5fLobV3cJDLIsiRY4FhYOUkTEVIcAASkIJoxyiEcmEaYcmw2tk8k4MgU6Y+myDFjfQbVodBaxVBsNbQcRbjOSJMAAXwAukA code: | from shiny import App, render, ui - + app_ui = ui.page_fluid( ui.input_text("Text", "Enter Text", ""), ui.output_text_verbatim("text", placeholder = True) #<< ) - + def server(input, output, session): @render.text #<< def text(): return input.Text() - + app = App(app_ui, server) --- From 8e6d0011d5c2d9b2034d20321356bccd32a358e3 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 14:31:58 -0500 Subject: [PATCH 03/22] Bring helper method into website to be agnostic to the shiny version --- Makefile | 3 +- requirements.txt | 3 + scripts/_add_objects_func_info.py | 206 ++++++++++++++++++++++++++++++ 3 files changed, 211 insertions(+), 1 deletion(-) create mode 100644 scripts/_add_objects_func_info.py diff --git a/Makefile b/Makefile index be3154e9..873100ba 100644 --- a/Makefile +++ b/Makefile @@ -70,13 +70,14 @@ deps: $(PYBIN) cd py-shiny/docs && make deps ## Build qmd files for Shiny API docs -quartodoc: +quartodoc: $(PYBIN) cd py-shiny/docs && make quartodoc # Copy all generated files except index.qmd rsync -av --exclude="index.qmd" py-shiny/docs/api/ ./api cp -R py-shiny/docs/_inv py-shiny/docs/objects.json ./ # Copy over index.qmd, but rename it to _api_index.qmd cp py-shiny/docs/api/index.qmd ./api/_api_index.qmd + . $(PYBIN)/activate && python scripts/_add_objects_func_info.py . $(PYBIN)/activate && python scripts/post-quartodoc.py ## Build website diff --git a/requirements.txt b/requirements.txt index e82131b3..fc5dcc2d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -9,3 +9,6 @@ plotly shinywidgets==0.2.2 ipyleaflet==0.17.4 favicons +quartodoc==0.7.2 +griffe==0.33.0 +ruamel.yaml diff --git a/scripts/_add_objects_func_info.py b/scripts/_add_objects_func_info.py new file mode 100644 index 00000000..5525c5cd --- /dev/null +++ b/scripts/_add_objects_func_info.py @@ -0,0 +1,206 @@ +# TODO-barret; Add sentance in template to describe what the Relevant Function section is: "To learn more about details about the functions covered here, visit the reference links below." + +import json +import subprocess +from typing import Union + +import griffe.dataclasses as dc +import griffe.docstrings.dataclasses as ds +import griffe.expressions as exp +from griffe.collections import LinesCollection, ModulesCollection +from griffe.docstrings import Parser +from griffe.loader import GriffeLoader +from plum import dispatch +from quartodoc import MdRenderer, get_object, preview # noqa: F401 +from quartodoc.parsers import get_parser_defaults +from shiny import reactive, render, ui + +loader = GriffeLoader( + docstring_parser=Parser("numpy"), + docstring_options=get_parser_defaults("numpy"), + modules_collection=ModulesCollection(), + lines_collection=LinesCollection(), +) + + +def fast_get_object(path: str): + return get_object(path, loader=loader) + + +class FuncSignature(MdRenderer): + style = "custom_func_signature" + + # def __init__(self, header_level: int = 1): + # self.header_level = header_level + + @dispatch + def render(self, el): + preview(el) + print(el.annotation) + raise NotImplementedError(f"Unsupported type: {type(el)}") + + @dispatch + def render(self, el: str): + return el + + @dispatch + def render(self, el: Union[dc.Alias, dc.Object]): + param_str = "" + if hasattr(el, "docstring") and hasattr(el.docstring, "parsed"): + for docstring_val in el.docstring.parsed: + if isinstance(docstring_val, ds.DocstringSectionParameters): + param_str = self.render(docstring_val) + elif hasattr(el, "parameters"): + for param in el.parameters: + param_str += self.render(param) + return f"{el.name}({param_str})" + + @dispatch + def render(self, el: None): + return "None" + + @dispatch + def render_annotation(self, el: str): + return el + + @dispatch + def render_annotation( + self, el: Union[exp.ExprName, exp.ExprSubscript, exp.ExprBinOp] + ): + return el.path + + @dispatch + def render(self, el: Union[ds.DocstringParameter, dc.Parameter]): + param = self.render(el.name) + annotation = self.render_annotation(el.annotation) + if annotation: + param = f"{param}: {annotation}" + if el.default: + param = f"{param} = {el.default}" + return param + + @dispatch + def render(self, el: ds.DocstringSectionParameters): + return ", ".join( + [item for item in map(self.render, el.value) if item is not None] + ) + + +def get_git_revision_short_hash() -> str: + return ( + subprocess.check_output(["git", "rev-parse", "--short", "HEAD"]) + .decode("ascii") + .strip() + ) + + +def get_git_current_tag() -> str: + return ( + subprocess.check_output(["git", "tag", "--points-at", "HEAD"]) + .decode("ascii") + .strip() + ) + + +class FuncFileLocation(MdRenderer): + style = "custom_func_location" + sha: str + + def __init__(self): + sha = get_git_current_tag() + if not sha: + sha = get_git_revision_short_hash() + self.sha = sha + + @dispatch + def render(self, el): + preview(el) + raise NotImplementedError(f"Unsupported type: {type(el)}") + + @dispatch + def render(self, el: Union[dc.Alias, dc.Object]): + # preview(el) + # import ipdb + + # ipdb.set_trace() + + rel_path = str(el.filepath).split("/shiny/")[-1] + + return { + # "name": el.name, + # "path": el.path, + "github": f"https://github.com/posit-dev/py-shiny/blob/{self.sha}/shiny/{rel_path}#L{el.lineno}-L{el.endlineno}", + } + + +# print(FuncSignature().render(fast_get_object("shiny:ui.input_action_button"))) +# print(FuncSignature().render(fast_get_object("shiny:ui.input_action_button"))) +# preview(fast_get_object("shiny:ui")) +# print("") + +with open("objects.json") as infile: + objects_content = json.load(infile) + +# Collect rel links to functions +links = {} +for item in objects_content["items"]: + if not item["name"].startswith("shiny."): + continue + name = item["name"].replace("shiny.", "") + links[name] = item["uri"] +# preview(links) + +fn_sig = FuncSignature() +file_locs = FuncFileLocation() +fn_info = {} +for mod_name, mod in [ + ("ui", ui), + ("render", render), + ("reactive", reactive), +]: + print(f"## Collecting: {mod_name}") + for key, f_obj in mod.__dict__.items(): + if key.startswith("_") or key in ("AnimationOptions",): + continue + if not callable(f_obj): + continue + # print(f"## {mod_name}.{key}") + fn_obj = fast_get_object(f"shiny:{mod_name}.{key}") + signature = f"{mod_name}.{fn_sig.render(fn_obj)}" + name = f"{mod_name}.{key}" + uri = None + if name in links: + uri = links[name] + else: + print(f"#### WARNING: No quartodoc entry/link found for {name}") + fn_info[name] = { + # "name": name, + "uri": uri, + "signature": signature, + **file_locs.render(fn_obj), + } +# preview(fn_info) + +print("## Saving function information to objects.json") + +objects_content["func_info"] = fn_info + +# Serializing json +json_object = json.dumps( + objects_content, + # TODO-barret; remove + indent=2, +) + +# Writing to sample.json +with open("objects.json", "w") as outfile: + outfile.write(json_object) +# TODO-barret; Include link to GitHub source +# print(FuncSignature().render(f_obj.annotation)) +# print(preview(f_obj)) + +# # get annotation of first parameter +# obj.parameters[0].annotation + +# render annotation +# print(renderer.render_annotation(obj.parameters[0].annotation)) From d9766b16e0bece26b7c5c8382987337fabcdcb43 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 14:35:31 -0500 Subject: [PATCH 04/22] Actually update the signatures, uri, and add github link --- scripts/post-quartodoc.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/scripts/post-quartodoc.py b/scripts/post-quartodoc.py index fa4635b1..5234bbe3 100644 --- a/scripts/post-quartodoc.py +++ b/scripts/post-quartodoc.py @@ -114,10 +114,10 @@ func_obj = func_info[fn_name] - # # Make important function API updates - # relevantfunction["href"] = f"{base_url}{func_obj['uri']}" - # relevantfunction["signature"] = func_obj["signature"] - # relevantfunction["github"] = func_obj["github"] + # Make important function API updates + relevantfunction["href"] = f"{base_url}{func_obj['uri']}" + relevantfunction["signature"] = func_obj["signature"] + relevantfunction["github"] = func_obj["github"] # print(relevantfunction) # Overwrite file with updated content From 83a14bd07886b616ceeac3b25c7a3ae3662e6bb1 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 14:36:26 -0500 Subject: [PATCH 05/22] `make quartodoc` --- components/display-messages/modal.qmd | 20 +++++++++++-------- components/display-messages/notifications.qmd | 10 ++++++---- components/display-messages/progress-bar.qmd | 5 +++-- components/display-messages/tooltips.qmd | 10 ++++++---- components/inputs/action-button.qmd | 10 ++++++---- components/inputs/action-link.qmd | 10 ++++++---- components/inputs/checkbox-group.qmd | 5 +++-- components/inputs/checkbox.qmd | 5 +++-- components/inputs/date-range-selector.qmd | 5 +++-- components/inputs/date-selector.qmd | 5 +++-- components/inputs/numeric-input.qmd | 5 +++-- components/inputs/password-field.qmd | 5 +++-- components/inputs/radio-buttons.qmd | 5 +++-- components/inputs/select-multiple.qmd | 5 +++-- components/inputs/select-single.qmd | 5 +++-- components/inputs/selectize-multiple.qmd | 5 +++-- components/inputs/selectize-single.qmd | 5 +++-- components/inputs/slider-range.qmd | 20 +++++++++++-------- components/inputs/slider.qmd | 5 +++-- components/inputs/switch.qmd | 5 +++-- components/inputs/text-area.qmd | 5 +++-- components/inputs/text-box.qmd | 5 +++-- components/outputs/data-grid.qmd | 15 ++++++++------ components/outputs/datatable.qmd | 15 ++++++++------ components/outputs/image.qmd | 10 ++++++---- components/outputs/plot-matplotlib.qmd | 10 ++++++---- components/outputs/plot-seaborn.qmd | 10 ++++++---- components/outputs/text.qmd | 10 ++++++---- components/outputs/ui.qmd | 10 ++++++---- components/outputs/value-box.qmd | 8 +++++--- components/outputs/verbatim-text.qmd | 10 ++++++---- 31 files changed, 155 insertions(+), 103 deletions(-) diff --git a/components/display-messages/modal.qmd b/components/display-messages/modal.qmd index 5c8ff868..28408475 100644 --- a/components/display-messages/modal.qmd +++ b/components/display-messages/modal.qmd @@ -48,17 +48,21 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.modal - href: https://shiny.posit.co/py/api/ui.modal.html - signature: ui.modal(*args, title=None, footer=MISSING, size='m', easy_close=False, fade=True, **kwargs) + href: https://shiny.posit.co/py/api/ui.modal.html#shiny.ui.modal + signature: "ui.modal(*args: TagChild | TagAttrs = (), title: Optional = None, footer: TagChild | MISSING_TYPE = MISSING, size: Literal = 'm', easy_close: bool = False, fade: bool = True, **kwargs: TagAttrValue = {})" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_modal.py#L60-L156 - title: ui.modal_show - href: https://shiny.posit.co/py/api/ui.modal_show.html - signature: ui.modal_show(modal, session=None) + href: https://shiny.posit.co/py/api/ui.modal_show.html#shiny.ui.modal_show + signature: 'ui.modal_show(modal: Tag, session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_modal.py#L159-L185 - title: ui.modal_remove - href: https://shiny.posit.co/py/api/ui.modal_remove.html - signature: ui.modal_remove(session=None) + href: https://shiny.posit.co/py/api/ui.modal_remove.html#shiny.ui.modal_remove + signature: 'ui.modal_remove(session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_modal.py#L188-L212 - title: ui.modal_button - href: https://shiny.posit.co/py/api/ui.modal_button.html - signature: ui.modal_button(label, icon=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.modal_button.html#shiny.ui.modal_button + signature: 'ui.modal_button(label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_modal.py#L19-L57 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/notifications.qmd b/components/display-messages/notifications.qmd index 8e6d7fe9..33533916 100644 --- a/components/display-messages/notifications.qmd +++ b/components/display-messages/notifications.qmd @@ -64,11 +64,13 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.notification_show - href: https://shiny.posit.co/py/api/ui.notification_show.html - signature: ui.notification_show(ui, *, action=None, duration=5, close_button=True, id=None, type='default', session=None) + href: https://shiny.posit.co/py/api/ui.notification_show.html#shiny.ui.notification_show + signature: "ui.notification_show(ui: TagChild, action: Optional = None, duration: Optional = 5, close_button: bool = True, id: Optional = None, type: Literal = 'default', session: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_notification.py#L14-L90 - title: ui.notification_remove - href: https://shiny.posit.co/py/api/ui.notification_remove.html - signature: ui.notification_remove(id, *, session=None) + href: https://shiny.posit.co/py/api/ui.notification_remove.html#shiny.ui.notification_remove + signature: 'ui.notification_remove(id: str, session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_notification.py#L93-L125 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/progress-bar.qmd b/components/display-messages/progress-bar.qmd index c9b37f2c..f373ce4c 100644 --- a/components/display-messages/progress-bar.qmd +++ b/components/display-messages/progress-bar.qmd @@ -66,8 +66,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.Progress - href: https://shiny.posit.co/py/api/ui.Progress.html - signature: ui.Progress(self, min=0, max=1, session=None) + href: https://shiny.posit.co/py/api/ui.Progress.html#shiny.ui.Progress + signature: 'ui.Progress(min: int = 0, max: int = 1, session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_progress.py#L14-L167 - title: ui.Progress.close href: https://shiny.posit.co/py/api/ui.Progress.html signature: ui.Progress.close(self) diff --git a/components/display-messages/tooltips.qmd b/components/display-messages/tooltips.qmd index c28b6815..86e7fd51 100644 --- a/components/display-messages/tooltips.qmd +++ b/components/display-messages/tooltips.qmd @@ -49,11 +49,13 @@ listing: relevantfunctions: - title: ui.tooltip - href: https://shiny.posit.co/py/api/ui.tooltip.html - signature: ui.tooltip(trigger, *args, id=None, placement='auto', options=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.tooltip.html#shiny.ui.tooltip + signature: "ui.tooltip(trigger: TagChild, *args: TagChild | TagAttrs = (), id: Optional = None, placement: Literal = 'auto', options: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_tooltip.py#L13-L154 - title: ui.update_tooltip - href: https://shiny.posit.co/py/api/ui.update_tooltip.html - signature: ui.update_tooltip(id, *args, show=None, session=None) + href: https://shiny.posit.co/py/api/ui.update_tooltip.html#shiny.ui.update_tooltip + signature: 'ui.update_tooltip(id: str, *args: TagChild = (), show: Optional = None, session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_update.py#L904-L946 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/action-button.qmd b/components/inputs/action-button.qmd index 365ec321..477e52f8 100644 --- a/components/inputs/action-button.qmd +++ b/components/inputs/action-button.qmd @@ -39,12 +39,14 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_action_button - href: https://shiny.posit.co/py/api/ui.input_action_button.html - signature: ui.input_action_button(id, label, *, icon=None, width=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.input_action_button.html#shiny.ui.input_action_button + signature: 'ui.input_action_button(id: str, label: TagChild, icon: TagChild = None, width: Optional = None, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_action_button.py#L11-L65 - title: reactive.event - href: https://shiny.posit.co/py/api/reactive.event.html - signature: reactive.event(*args, ignore_none=True, ignore_init=False) + href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event + signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/action-link.qmd b/components/inputs/action-link.qmd index 09a58fc7..497fb5a8 100644 --- a/components/inputs/action-link.qmd +++ b/components/inputs/action-link.qmd @@ -39,12 +39,14 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_action_link - href: https://shiny.posit.co/py/api/ui.input_action_link.html - signature: ui.input_action_link(id, label, *, icon=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.input_action_link.html#shiny.ui.input_action_link + signature: 'ui.input_action_link(id: str, label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_action_button.py#L68-L115 - title: reactive.event - href: https://shiny.posit.co/py/api/reactive.event.html - signature: reactive.event(*args, ignore_none=True, ignore_init=False) + href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event + signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/checkbox-group.qmd b/components/inputs/checkbox-group.qmd index a7f885fa..33b9e166 100644 --- a/components/inputs/checkbox-group.qmd +++ b/components/inputs/checkbox-group.qmd @@ -53,9 +53,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_checkbox_group - href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html - signature: ui.input_checkbox_group(id, label, choices, *, selected=None, inline=False, width=None) + href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html#shiny.ui.input_checkbox_group + signature: 'ui.input_checkbox_group(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_check_radio.py#L169-L237 --- :::{#component} diff --git a/components/inputs/checkbox.qmd b/components/inputs/checkbox.qmd index 7aa6c29b..1ebcfd4e 100644 --- a/components/inputs/checkbox.qmd +++ b/components/inputs/checkbox.qmd @@ -37,8 +37,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_checkbox() - href: https://shiny.posit.co/py/api/ui.input_checkbox.html - signature: ui.input_checkbox(id, label, value=False, *, width=None) + href: https://shiny.posit.co/py/api/ui.input_checkbox.html#shiny.ui.input_checkbox + signature: 'ui.input_checkbox(id: str, label: TagChild, value: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_check_radio.py#L32-L85 --- :::{#component} diff --git a/components/inputs/date-range-selector.qmd b/components/inputs/date-range-selector.qmd index d1cdce3c..2eb69c31 100644 --- a/components/inputs/date-range-selector.qmd +++ b/components/inputs/date-range-selector.qmd @@ -43,9 +43,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_date_range - href: https://shiny.posit.co/py/api/ui.input_date_range.html - signature: ui.input_date_range(id, label, *, start=None, end=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', separator=' to ', width=None, autoclose=True) + href: https://shiny.posit.co/py/api/ui.input_date_range.html#shiny.ui.input_date_range + signature: "ui.input_date_range(id: str, label: TagChild, start: Optional = None, end: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', separator: str = ' to ', width: Optional = None, autoclose: bool = True)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_date.py#L135-L269 --- :::{#component} diff --git a/components/inputs/date-selector.qmd b/components/inputs/date-selector.qmd index 818e9ba1..b0ec4c31 100644 --- a/components/inputs/date-selector.qmd +++ b/components/inputs/date-selector.qmd @@ -41,8 +41,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_date - href: https://shiny.posit.co/py/api/ui.input_date.html - signature: ui.input_date(id, label, *, value=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', width=None, autoclose=True, datesdisabled=None, daysofweekdisabled=None) + href: https://shiny.posit.co/py/api/ui.input_date.html#shiny.ui.input_date + signature: "ui.input_date(id: str, label: TagChild, value: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', width: Optional = None, autoclose: bool = True, datesdisabled: Optional = None, daysofweekdisabled: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_date.py#L17-L132 --- :::{#component} diff --git a/components/inputs/numeric-input.qmd b/components/inputs/numeric-input.qmd index a2217b09..848c2e48 100644 --- a/components/inputs/numeric-input.qmd +++ b/components/inputs/numeric-input.qmd @@ -39,9 +39,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_numeric - href: https://shiny.posit.co/py/api/ui.input_numeric.html - signature: ui.input_numeric(id, label, value, *, min=None, max=None, step=None, width=None) + href: https://shiny.posit.co/py/api/ui.input_numeric.html#shiny.ui.input_numeric + signature: 'ui.input_numeric(id: str, label: TagChild, value: float, min: Optional = None, max: Optional = None, step: Optional = None, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_numeric.py#L12-L73 --- :::{#component} diff --git a/components/inputs/password-field.qmd b/components/inputs/password-field.qmd index bdb8c4a5..1fd45285 100644 --- a/components/inputs/password-field.qmd +++ b/components/inputs/password-field.qmd @@ -39,9 +39,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_password - href: https://shiny.posit.co/py/api/ui.input_password.html - signature: ui.input_password(id, label, value='', *, width=None, placeholder=None) + href: https://shiny.posit.co/py/api/ui.input_password.html#shiny.ui.input_password + signature: "ui.input_password(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_password.py#L12-L64 --- :::{#component} diff --git a/components/inputs/radio-buttons.qmd b/components/inputs/radio-buttons.qmd index d8427991..5f0f4e44 100644 --- a/components/inputs/radio-buttons.qmd +++ b/components/inputs/radio-buttons.qmd @@ -48,9 +48,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_radio_buttons - href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html - signature: ui.input_radio_buttons(id, label, choices, *, selected=None, inline=False, width=None) + href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html#shiny.ui.input_radio_buttons + signature: 'ui.input_radio_buttons(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_check_radio.py#L240-L307 --- :::{#component} diff --git a/components/inputs/select-multiple.qmd b/components/inputs/select-multiple.qmd index 293cd66a..3371f09a 100644 --- a/components/inputs/select-multiple.qmd +++ b/components/inputs/select-multiple.qmd @@ -52,8 +52,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_select - href: https://shiny.posit.co/py/api/ui.input_select.html - signature: ui.input_select(id, label, choices, *, selected=None, multiple=False, selectize=False, width=None, size=None) + href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select + signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/select-single.qmd b/components/inputs/select-single.qmd index a1d7777b..a508c832 100644 --- a/components/inputs/select-single.qmd +++ b/components/inputs/select-single.qmd @@ -51,9 +51,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_select - href: https://shiny.posit.co/py/api/ui.input_select.html - signature: ui.input_select(id, label, choices, *, selected=None, multiple=False, selectize=False, width=None, size=None) + href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select + signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-multiple.qmd b/components/inputs/selectize-multiple.qmd index a3fcad87..76e0f5f8 100644 --- a/components/inputs/selectize-multiple.qmd +++ b/components/inputs/selectize-multiple.qmd @@ -53,8 +53,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_selectize - href: https://shiny.posit.co/py/api/ui.input_selectize.html - signature: ui.input_selectize(id, label, choices, *, selected=None, multiple=False, width=None) + href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize + signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-single.qmd b/components/inputs/selectize-single.qmd index c9aa55c2..0bb40321 100644 --- a/components/inputs/selectize-single.qmd +++ b/components/inputs/selectize-single.qmd @@ -51,8 +51,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_selectize - href: https://shiny.posit.co/py/api/ui.input_selectize.html - signature: ui.input_selectize(id, label, choices, *, selected=None, multiple=False, width=None) + href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize + signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/slider-range.qmd b/components/inputs/slider-range.qmd index 069833b4..b1218972 100644 --- a/components/inputs/slider-range.qmd +++ b/components/inputs/slider-range.qmd @@ -37,17 +37,21 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_slider - href: https://shiny.posit.co/py/api/ui.input_slider.html - signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) + href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider + signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_slider.py#L59-L234 - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html - signature: ui.output_data_frame(id) + href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame + signature: 'ui.output_data_frame(id: str)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: render.data_frame - href: https://shiny.posit.co/py/api/render.data_frame.html - signature: render.data_frame(fn=None) + href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame + signature: render.data_frame() + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable - href: https://shiny.posit.co/py/api/render.DataTable.html - signature: render.DataTable(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') + href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable + signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L122-L207 --- :::{#component} diff --git a/components/inputs/slider.qmd b/components/inputs/slider.qmd index 1c5876f5..8c88959b 100644 --- a/components/inputs/slider.qmd +++ b/components/inputs/slider.qmd @@ -39,8 +39,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_slider - href: https://shiny.posit.co/py/api/ui.input_slider.html - signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) + href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider + signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_slider.py#L59-L234 --- :::{#component} diff --git a/components/inputs/switch.qmd b/components/inputs/switch.qmd index 2e8c4b96..590bbdcf 100644 --- a/components/inputs/switch.qmd +++ b/components/inputs/switch.qmd @@ -36,8 +36,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_switch - href: https://shiny.posit.co/py/api/ui.input_switch.html - signature: ui.input_switch(id, label, value=False, *, width=None) + href: https://shiny.posit.co/py/api/ui.input_switch.html#shiny.ui.input_switch + signature: 'ui.input_switch(id: str, label: TagChild, value: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_check_radio.py#L88-L133 --- :::{#component} diff --git a/components/inputs/text-area.qmd b/components/inputs/text-area.qmd index 644e6a28..f0203e20 100644 --- a/components/inputs/text-area.qmd +++ b/components/inputs/text-area.qmd @@ -39,8 +39,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_text_area - href: https://shiny.posit.co/py/api/ui.input_text_area.html - signature: ui.input_text_area(id, label, value='', *, width=None, height=None, cols=None, rows=None, placeholder=None, resize=None, autoresize=False, autocomplete=None, spellcheck=None) + href: https://shiny.posit.co/py/api/ui.input_text_area.html#shiny.ui.input_text_area + signature: "ui.input_text_area(id: str, label: TagChild, value: str = '', width: Optional = None, height: Optional = None, cols: Optional = None, rows: Optional = None, placeholder: Optional = None, resize: Optional = None, autoresize: bool = False, autocomplete: Optional = None, spellcheck: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_text.py#L83-L187 --- :::{#component} diff --git a/components/inputs/text-box.qmd b/components/inputs/text-box.qmd index 13dd118a..a632c248 100644 --- a/components/inputs/text-box.qmd +++ b/components/inputs/text-box.qmd @@ -39,8 +39,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_text - href: https://shiny.posit.co/py/api/ui.input_text.html - signature: ui.input_text(id, label, value='', *, width=None, placeholder=None, autocomplete='off', spellcheck=None) + href: https://shiny.posit.co/py/api/ui.input_text.html#shiny.ui.input_text + signature: "ui.input_text(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None, autocomplete: Optional = 'off', spellcheck: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_text.py#L13-L80 --- :::{#component} diff --git a/components/outputs/data-grid.qmd b/components/outputs/data-grid.qmd index 6ff5604d..48613849 100644 --- a/components/outputs/data-grid.qmd +++ b/components/outputs/data-grid.qmd @@ -32,14 +32,17 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html - signature: ui.output_data_frame(id) + href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame + signature: 'ui.output_data_frame(id: str)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' - href: https://shiny.posit.co/py/api/render.data_frame.html - signature: render.data_frame(fn=None) + href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame + signature: render.data_frame() + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L258-L302 - title: render.DataGrid - href: https://shiny.posit.co/py/api/render.DataGrid.html - signature: render.DataGrid(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') + href: https://shiny.posit.co/py/api/render.DataGrid.html#shiny.render.DataGrid + signature: "render.DataGrid(data: object, width: str | float | None = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Literal = 'none')" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L36-L119 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/datatable.qmd b/components/outputs/datatable.qmd index f086f981..7276f1f8 100644 --- a/components/outputs/datatable.qmd +++ b/components/outputs/datatable.qmd @@ -31,14 +31,17 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html - signature: ui.output_data_frame(id) + href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame + signature: 'ui.output_data_frame(id: str)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' - href: https://shiny.posit.co/py/api/render.data_frame.html - signature: render.data_frame(fn=None) + href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame + signature: render.data_frame() + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable - href: https://shiny.posit.co/py/api/render.DataTable.html - signature: render.DataTable(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') + href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable + signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L122-L207 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/image.qmd b/components/outputs/image.qmd index 49977fc2..d1983ef2 100644 --- a/components/outputs/image.qmd +++ b/components/outputs/image.qmd @@ -33,12 +33,14 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_image - href: https://shiny.posit.co/py/api/ui.output_image.html - signature: ui.output_image(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=False) + href: https://shiny.posit.co/py/api/ui.output_image.html#shiny.ui.output_image + signature: "ui.output_image(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool = False)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L123-L234 - title: '@render.image' - href: https://shiny.posit.co/py/api/render.image.html - signature: render.image(_fn=None, *, delete_file=False) + href: https://shiny.posit.co/py/api/render.image.html#shiny.render.image + signature: 'render.image(delete_file: bool = False)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L341-L371 --- :::{#component} diff --git a/components/outputs/plot-matplotlib.qmd b/components/outputs/plot-matplotlib.qmd index 2ff26ff1..6368a995 100644 --- a/components/outputs/plot-matplotlib.qmd +++ b/components/outputs/plot-matplotlib.qmd @@ -40,11 +40,13 @@ listing: relevantfunctions: - title: ui.output_plot - href: https://shiny.posit.co/py/api/ui.output_plot.html - signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) + href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot + signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L33-L120 - title: '@render.plot' - href: https://shiny.posit.co/py/api/render.plot.html - signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) + href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot + signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L237-L298 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/plot-seaborn.qmd b/components/outputs/plot-seaborn.qmd index de7e0690..54ecfd15 100644 --- a/components/outputs/plot-seaborn.qmd +++ b/components/outputs/plot-seaborn.qmd @@ -38,12 +38,14 @@ listing: relevantfunctions: - title: ui.output_plot - href: https://shiny.posit.co/py/api/ui.output_plot.html - signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) + href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot + signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L33-L120 - title: '@render.plot' - href: https://shiny.posit.co/py/api/render.plot.html - signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) + href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot + signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L237-L298 --- :::{#component} diff --git a/components/outputs/text.qmd b/components/outputs/text.qmd index 6af0bb8c..cff7c338 100644 --- a/components/outputs/text.qmd +++ b/components/outputs/text.qmd @@ -42,11 +42,13 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_text - href: https://shiny.posit.co/py/api/ui.output_text.html - signature: ui.output_text(id, inline=False, container=None) + href: https://shiny.posit.co/py/api/ui.output_text.html#shiny.ui.output_text + signature: 'ui.output_text(id: str, inline: bool = False, container: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L237-L270 - title: '@render.text' - href: https://shiny.posit.co/py/api/render.text.html - signature: render.text(fn=None) + href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text + signature: render.text() + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/ui.qmd b/components/outputs/ui.qmd index c5afcd1c..8826191c 100644 --- a/components/outputs/ui.qmd +++ b/components/outputs/ui.qmd @@ -37,11 +37,13 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_ui - href: https://shiny.posit.co/py/api/ui.output_ui.html - signature: ui.output_ui(id, inline=False, container=None, fill=False, fillable=False, **kwargs) + href: https://shiny.posit.co/py/api/ui.output_ui.html#shiny.ui.output_ui + signature: 'ui.output_ui(id: str, inline: bool = False, container: Optional = None, fill: bool = False, fillable: bool = False, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L332-L379 - title: '@render.ui' - href: https://shiny.posit.co/py/api/render.ui.html - signature: render.ui(_fn=None) + href: https://shiny.posit.co/py/api/render.ui.html#shiny.render.ui + signature: render.ui() + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L540-L562 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/value-box.qmd b/components/outputs/value-box.qmd index b02ca459..f0b11198 100644 --- a/components/outputs/value-box.qmd +++ b/components/outputs/value-box.qmd @@ -294,11 +294,13 @@ listing: relevantfunctions: - title: ui.value_box - href: https://shiny.posit.co/py/api/ui.value_box.html - signature: ui.value_box(title, value, *args, showcase=None, showcase_layout='left center', full_screen=False, theme=None, height=None, max_height=None, fill=True, class_=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.value_box.html#shiny.ui.value_box + signature: "ui.value_box(title: TagChild, *args: TagChild | TagAttrs = (), showcase: Optional = None, showcase_layout: SHOWCASE_LAYOUTS_STR | ShowcaseLayout = 'left center', theme: Optional = None, full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})" + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_valuebox.py#L296-L459 - title: ui.card href: https://shiny.posit.co/py/api/ui.card.html#shiny.ui.card - signature: ui.card(*args, full_screen=False, height=None, max_height=None, min_height=None, fill=True, class_=None, **kwargs) + signature: 'ui.card(*args: TagChild | TagAttrs | CardItem = (), full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_card.py#L45-L104 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/verbatim-text.qmd b/components/outputs/verbatim-text.qmd index a541c9ff..c3ffb86a 100644 --- a/components/outputs/verbatim-text.qmd +++ b/components/outputs/verbatim-text.qmd @@ -40,11 +40,13 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_text_verbatim - href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html - signature: ui.output_text_verbatim(id, placeholder=False) + href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html#shiny.ui.output_text_verbatim + signature: 'ui.output_text_verbatim(id: str, placeholder: bool = False)' + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L273-L306 - title: '@render.text' - href: https://shiny.posit.co/py/api/render.text.html - signature: render.text(fn=None) + href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text + signature: render.text() + github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: From 58aeceb7016f6812f7315118a0184456d6a34928 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 15:00:22 -0500 Subject: [PATCH 06/22] Revert "`make quartodoc`" This reverts commit 83a14bd07886b616ceeac3b25c7a3ae3662e6bb1. --- components/display-messages/modal.qmd | 20 ++++++++----------- components/display-messages/notifications.qmd | 10 ++++------ components/display-messages/progress-bar.qmd | 5 ++--- components/display-messages/tooltips.qmd | 10 ++++------ components/inputs/action-button.qmd | 10 ++++------ components/inputs/action-link.qmd | 10 ++++------ components/inputs/checkbox-group.qmd | 5 ++--- components/inputs/checkbox.qmd | 5 ++--- components/inputs/date-range-selector.qmd | 5 ++--- components/inputs/date-selector.qmd | 5 ++--- components/inputs/numeric-input.qmd | 5 ++--- components/inputs/password-field.qmd | 5 ++--- components/inputs/radio-buttons.qmd | 5 ++--- components/inputs/select-multiple.qmd | 5 ++--- components/inputs/select-single.qmd | 5 ++--- components/inputs/selectize-multiple.qmd | 5 ++--- components/inputs/selectize-single.qmd | 5 ++--- components/inputs/slider-range.qmd | 20 ++++++++----------- components/inputs/slider.qmd | 5 ++--- components/inputs/switch.qmd | 5 ++--- components/inputs/text-area.qmd | 5 ++--- components/inputs/text-box.qmd | 5 ++--- components/outputs/data-grid.qmd | 15 ++++++-------- components/outputs/datatable.qmd | 15 ++++++-------- components/outputs/image.qmd | 10 ++++------ components/outputs/plot-matplotlib.qmd | 10 ++++------ components/outputs/plot-seaborn.qmd | 10 ++++------ components/outputs/text.qmd | 10 ++++------ components/outputs/ui.qmd | 10 ++++------ components/outputs/value-box.qmd | 8 +++----- components/outputs/verbatim-text.qmd | 10 ++++------ 31 files changed, 103 insertions(+), 155 deletions(-) diff --git a/components/display-messages/modal.qmd b/components/display-messages/modal.qmd index 28408475..5c8ff868 100644 --- a/components/display-messages/modal.qmd +++ b/components/display-messages/modal.qmd @@ -48,21 +48,17 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.modal - href: https://shiny.posit.co/py/api/ui.modal.html#shiny.ui.modal - signature: "ui.modal(*args: TagChild | TagAttrs = (), title: Optional = None, footer: TagChild | MISSING_TYPE = MISSING, size: Literal = 'm', easy_close: bool = False, fade: bool = True, **kwargs: TagAttrValue = {})" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_modal.py#L60-L156 + href: https://shiny.posit.co/py/api/ui.modal.html + signature: ui.modal(*args, title=None, footer=MISSING, size='m', easy_close=False, fade=True, **kwargs) - title: ui.modal_show - href: https://shiny.posit.co/py/api/ui.modal_show.html#shiny.ui.modal_show - signature: 'ui.modal_show(modal: Tag, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_modal.py#L159-L185 + href: https://shiny.posit.co/py/api/ui.modal_show.html + signature: ui.modal_show(modal, session=None) - title: ui.modal_remove - href: https://shiny.posit.co/py/api/ui.modal_remove.html#shiny.ui.modal_remove - signature: 'ui.modal_remove(session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_modal.py#L188-L212 + href: https://shiny.posit.co/py/api/ui.modal_remove.html + signature: ui.modal_remove(session=None) - title: ui.modal_button - href: https://shiny.posit.co/py/api/ui.modal_button.html#shiny.ui.modal_button - signature: 'ui.modal_button(label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_modal.py#L19-L57 + href: https://shiny.posit.co/py/api/ui.modal_button.html + signature: ui.modal_button(label, icon=None, **kwargs) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/notifications.qmd b/components/display-messages/notifications.qmd index 33533916..8e6d7fe9 100644 --- a/components/display-messages/notifications.qmd +++ b/components/display-messages/notifications.qmd @@ -64,13 +64,11 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.notification_show - href: https://shiny.posit.co/py/api/ui.notification_show.html#shiny.ui.notification_show - signature: "ui.notification_show(ui: TagChild, action: Optional = None, duration: Optional = 5, close_button: bool = True, id: Optional = None, type: Literal = 'default', session: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_notification.py#L14-L90 + href: https://shiny.posit.co/py/api/ui.notification_show.html + signature: ui.notification_show(ui, *, action=None, duration=5, close_button=True, id=None, type='default', session=None) - title: ui.notification_remove - href: https://shiny.posit.co/py/api/ui.notification_remove.html#shiny.ui.notification_remove - signature: 'ui.notification_remove(id: str, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_notification.py#L93-L125 + href: https://shiny.posit.co/py/api/ui.notification_remove.html + signature: ui.notification_remove(id, *, session=None) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/progress-bar.qmd b/components/display-messages/progress-bar.qmd index f373ce4c..c9b37f2c 100644 --- a/components/display-messages/progress-bar.qmd +++ b/components/display-messages/progress-bar.qmd @@ -66,9 +66,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.Progress - href: https://shiny.posit.co/py/api/ui.Progress.html#shiny.ui.Progress - signature: 'ui.Progress(min: int = 0, max: int = 1, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_progress.py#L14-L167 + href: https://shiny.posit.co/py/api/ui.Progress.html + signature: ui.Progress(self, min=0, max=1, session=None) - title: ui.Progress.close href: https://shiny.posit.co/py/api/ui.Progress.html signature: ui.Progress.close(self) diff --git a/components/display-messages/tooltips.qmd b/components/display-messages/tooltips.qmd index 86e7fd51..c28b6815 100644 --- a/components/display-messages/tooltips.qmd +++ b/components/display-messages/tooltips.qmd @@ -49,13 +49,11 @@ listing: relevantfunctions: - title: ui.tooltip - href: https://shiny.posit.co/py/api/ui.tooltip.html#shiny.ui.tooltip - signature: "ui.tooltip(trigger: TagChild, *args: TagChild | TagAttrs = (), id: Optional = None, placement: Literal = 'auto', options: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_tooltip.py#L13-L154 + href: https://shiny.posit.co/py/api/ui.tooltip.html + signature: ui.tooltip(trigger, *args, id=None, placement='auto', options=None, **kwargs) - title: ui.update_tooltip - href: https://shiny.posit.co/py/api/ui.update_tooltip.html#shiny.ui.update_tooltip - signature: 'ui.update_tooltip(id: str, *args: TagChild = (), show: Optional = None, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_update.py#L904-L946 + href: https://shiny.posit.co/py/api/ui.update_tooltip.html + signature: ui.update_tooltip(id, *args, show=None, session=None) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/action-button.qmd b/components/inputs/action-button.qmd index 477e52f8..365ec321 100644 --- a/components/inputs/action-button.qmd +++ b/components/inputs/action-button.qmd @@ -39,14 +39,12 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_action_button - href: https://shiny.posit.co/py/api/ui.input_action_button.html#shiny.ui.input_action_button - signature: 'ui.input_action_button(id: str, label: TagChild, icon: TagChild = None, width: Optional = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_action_button.py#L11-L65 + href: https://shiny.posit.co/py/api/ui.input_action_button.html + signature: ui.input_action_button(id, label, *, icon=None, width=None, **kwargs) - title: reactive.event - href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event - signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' + href: https://shiny.posit.co/py/api/reactive.event.html + signature: reactive.event(*args, ignore_none=True, ignore_init=False) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/action-link.qmd b/components/inputs/action-link.qmd index 497fb5a8..09a58fc7 100644 --- a/components/inputs/action-link.qmd +++ b/components/inputs/action-link.qmd @@ -39,14 +39,12 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_action_link - href: https://shiny.posit.co/py/api/ui.input_action_link.html#shiny.ui.input_action_link - signature: 'ui.input_action_link(id: str, label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_action_button.py#L68-L115 + href: https://shiny.posit.co/py/api/ui.input_action_link.html + signature: ui.input_action_link(id, label, *, icon=None, **kwargs) - title: reactive.event - href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event - signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' + href: https://shiny.posit.co/py/api/reactive.event.html + signature: reactive.event(*args, ignore_none=True, ignore_init=False) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/checkbox-group.qmd b/components/inputs/checkbox-group.qmd index 33b9e166..a7f885fa 100644 --- a/components/inputs/checkbox-group.qmd +++ b/components/inputs/checkbox-group.qmd @@ -53,10 +53,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_checkbox_group - href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html#shiny.ui.input_checkbox_group - signature: 'ui.input_checkbox_group(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' + href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html + signature: ui.input_checkbox_group(id, label, choices, *, selected=None, inline=False, width=None) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_check_radio.py#L169-L237 --- :::{#component} diff --git a/components/inputs/checkbox.qmd b/components/inputs/checkbox.qmd index 1ebcfd4e..7aa6c29b 100644 --- a/components/inputs/checkbox.qmd +++ b/components/inputs/checkbox.qmd @@ -37,9 +37,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_checkbox() - href: https://shiny.posit.co/py/api/ui.input_checkbox.html#shiny.ui.input_checkbox - signature: 'ui.input_checkbox(id: str, label: TagChild, value: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_check_radio.py#L32-L85 + href: https://shiny.posit.co/py/api/ui.input_checkbox.html + signature: ui.input_checkbox(id, label, value=False, *, width=None) --- :::{#component} diff --git a/components/inputs/date-range-selector.qmd b/components/inputs/date-range-selector.qmd index 2eb69c31..d1cdce3c 100644 --- a/components/inputs/date-range-selector.qmd +++ b/components/inputs/date-range-selector.qmd @@ -43,10 +43,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_date_range - href: https://shiny.posit.co/py/api/ui.input_date_range.html#shiny.ui.input_date_range - signature: "ui.input_date_range(id: str, label: TagChild, start: Optional = None, end: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', separator: str = ' to ', width: Optional = None, autoclose: bool = True)" + href: https://shiny.posit.co/py/api/ui.input_date_range.html + signature: ui.input_date_range(id, label, *, start=None, end=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', separator=' to ', width=None, autoclose=True) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_date.py#L135-L269 --- :::{#component} diff --git a/components/inputs/date-selector.qmd b/components/inputs/date-selector.qmd index b0ec4c31..818e9ba1 100644 --- a/components/inputs/date-selector.qmd +++ b/components/inputs/date-selector.qmd @@ -41,9 +41,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_date - href: https://shiny.posit.co/py/api/ui.input_date.html#shiny.ui.input_date - signature: "ui.input_date(id: str, label: TagChild, value: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', width: Optional = None, autoclose: bool = True, datesdisabled: Optional = None, daysofweekdisabled: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_date.py#L17-L132 + href: https://shiny.posit.co/py/api/ui.input_date.html + signature: ui.input_date(id, label, *, value=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', width=None, autoclose=True, datesdisabled=None, daysofweekdisabled=None) --- :::{#component} diff --git a/components/inputs/numeric-input.qmd b/components/inputs/numeric-input.qmd index 848c2e48..a2217b09 100644 --- a/components/inputs/numeric-input.qmd +++ b/components/inputs/numeric-input.qmd @@ -39,10 +39,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_numeric - href: https://shiny.posit.co/py/api/ui.input_numeric.html#shiny.ui.input_numeric - signature: 'ui.input_numeric(id: str, label: TagChild, value: float, min: Optional = None, max: Optional = None, step: Optional = None, width: Optional = None)' + href: https://shiny.posit.co/py/api/ui.input_numeric.html + signature: ui.input_numeric(id, label, value, *, min=None, max=None, step=None, width=None) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_numeric.py#L12-L73 --- :::{#component} diff --git a/components/inputs/password-field.qmd b/components/inputs/password-field.qmd index 1fd45285..bdb8c4a5 100644 --- a/components/inputs/password-field.qmd +++ b/components/inputs/password-field.qmd @@ -39,10 +39,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_password - href: https://shiny.posit.co/py/api/ui.input_password.html#shiny.ui.input_password - signature: "ui.input_password(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None)" + href: https://shiny.posit.co/py/api/ui.input_password.html + signature: ui.input_password(id, label, value='', *, width=None, placeholder=None) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_password.py#L12-L64 --- :::{#component} diff --git a/components/inputs/radio-buttons.qmd b/components/inputs/radio-buttons.qmd index 5f0f4e44..d8427991 100644 --- a/components/inputs/radio-buttons.qmd +++ b/components/inputs/radio-buttons.qmd @@ -48,10 +48,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_radio_buttons - href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html#shiny.ui.input_radio_buttons - signature: 'ui.input_radio_buttons(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' + href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html + signature: ui.input_radio_buttons(id, label, choices, *, selected=None, inline=False, width=None) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_check_radio.py#L240-L307 --- :::{#component} diff --git a/components/inputs/select-multiple.qmd b/components/inputs/select-multiple.qmd index 3371f09a..293cd66a 100644 --- a/components/inputs/select-multiple.qmd +++ b/components/inputs/select-multiple.qmd @@ -52,9 +52,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_select - href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select - signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_select.py#L111-L204 + href: https://shiny.posit.co/py/api/ui.input_select.html + signature: ui.input_select(id, label, choices, *, selected=None, multiple=False, selectize=False, width=None, size=None) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/select-single.qmd b/components/inputs/select-single.qmd index a508c832..a1d7777b 100644 --- a/components/inputs/select-single.qmd +++ b/components/inputs/select-single.qmd @@ -51,10 +51,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_select - href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select - signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' + href: https://shiny.posit.co/py/api/ui.input_select.html + signature: ui.input_select(id, label, choices, *, selected=None, multiple=False, selectize=False, width=None, size=None) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-multiple.qmd b/components/inputs/selectize-multiple.qmd index 76e0f5f8..a3fcad87 100644 --- a/components/inputs/selectize-multiple.qmd +++ b/components/inputs/selectize-multiple.qmd @@ -53,9 +53,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_selectize - href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize - signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_select.py#L48-L108 + href: https://shiny.posit.co/py/api/ui.input_selectize.html + signature: ui.input_selectize(id, label, choices, *, selected=None, multiple=False, width=None) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-single.qmd b/components/inputs/selectize-single.qmd index 0bb40321..c9aa55c2 100644 --- a/components/inputs/selectize-single.qmd +++ b/components/inputs/selectize-single.qmd @@ -51,9 +51,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_selectize - href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize - signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_select.py#L48-L108 + href: https://shiny.posit.co/py/api/ui.input_selectize.html + signature: ui.input_selectize(id, label, choices, *, selected=None, multiple=False, width=None) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/slider-range.qmd b/components/inputs/slider-range.qmd index b1218972..069833b4 100644 --- a/components/inputs/slider-range.qmd +++ b/components/inputs/slider-range.qmd @@ -37,21 +37,17 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_slider - href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider - signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_slider.py#L59-L234 + href: https://shiny.posit.co/py/api/ui.input_slider.html + signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame - signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/dataframe/_dataframe.py#L12-L39 + href: https://shiny.posit.co/py/api/ui.output_data_frame.html + signature: ui.output_data_frame(id) - title: render.data_frame - href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame - signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L258-L302 + href: https://shiny.posit.co/py/api/render.data_frame.html + signature: render.data_frame(fn=None) - title: render.DataTable - href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable - signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L122-L207 + href: https://shiny.posit.co/py/api/render.DataTable.html + signature: render.DataTable(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') --- :::{#component} diff --git a/components/inputs/slider.qmd b/components/inputs/slider.qmd index 8c88959b..1c5876f5 100644 --- a/components/inputs/slider.qmd +++ b/components/inputs/slider.qmd @@ -39,9 +39,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_slider - href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider - signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_slider.py#L59-L234 + href: https://shiny.posit.co/py/api/ui.input_slider.html + signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) --- :::{#component} diff --git a/components/inputs/switch.qmd b/components/inputs/switch.qmd index 590bbdcf..2e8c4b96 100644 --- a/components/inputs/switch.qmd +++ b/components/inputs/switch.qmd @@ -36,9 +36,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_switch - href: https://shiny.posit.co/py/api/ui.input_switch.html#shiny.ui.input_switch - signature: 'ui.input_switch(id: str, label: TagChild, value: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_check_radio.py#L88-L133 + href: https://shiny.posit.co/py/api/ui.input_switch.html + signature: ui.input_switch(id, label, value=False, *, width=None) --- :::{#component} diff --git a/components/inputs/text-area.qmd b/components/inputs/text-area.qmd index f0203e20..644e6a28 100644 --- a/components/inputs/text-area.qmd +++ b/components/inputs/text-area.qmd @@ -39,9 +39,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_text_area - href: https://shiny.posit.co/py/api/ui.input_text_area.html#shiny.ui.input_text_area - signature: "ui.input_text_area(id: str, label: TagChild, value: str = '', width: Optional = None, height: Optional = None, cols: Optional = None, rows: Optional = None, placeholder: Optional = None, resize: Optional = None, autoresize: bool = False, autocomplete: Optional = None, spellcheck: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_text.py#L83-L187 + href: https://shiny.posit.co/py/api/ui.input_text_area.html + signature: ui.input_text_area(id, label, value='', *, width=None, height=None, cols=None, rows=None, placeholder=None, resize=None, autoresize=False, autocomplete=None, spellcheck=None) --- :::{#component} diff --git a/components/inputs/text-box.qmd b/components/inputs/text-box.qmd index a632c248..13dd118a 100644 --- a/components/inputs/text-box.qmd +++ b/components/inputs/text-box.qmd @@ -39,9 +39,8 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_text - href: https://shiny.posit.co/py/api/ui.input_text.html#shiny.ui.input_text - signature: "ui.input_text(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None, autocomplete: Optional = 'off', spellcheck: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_input_text.py#L13-L80 + href: https://shiny.posit.co/py/api/ui.input_text.html + signature: ui.input_text(id, label, value='', *, width=None, placeholder=None, autocomplete='off', spellcheck=None) --- :::{#component} diff --git a/components/outputs/data-grid.qmd b/components/outputs/data-grid.qmd index 48613849..6ff5604d 100644 --- a/components/outputs/data-grid.qmd +++ b/components/outputs/data-grid.qmd @@ -32,17 +32,14 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame - signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/dataframe/_dataframe.py#L12-L39 + href: https://shiny.posit.co/py/api/ui.output_data_frame.html + signature: ui.output_data_frame(id) - title: '@render.data_frame' - href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame - signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L258-L302 + href: https://shiny.posit.co/py/api/render.data_frame.html + signature: render.data_frame(fn=None) - title: render.DataGrid - href: https://shiny.posit.co/py/api/render.DataGrid.html#shiny.render.DataGrid - signature: "render.DataGrid(data: object, width: str | float | None = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Literal = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L36-L119 + href: https://shiny.posit.co/py/api/render.DataGrid.html + signature: render.DataGrid(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/datatable.qmd b/components/outputs/datatable.qmd index 7276f1f8..f086f981 100644 --- a/components/outputs/datatable.qmd +++ b/components/outputs/datatable.qmd @@ -31,17 +31,14 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame - signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/dataframe/_dataframe.py#L12-L39 + href: https://shiny.posit.co/py/api/ui.output_data_frame.html + signature: ui.output_data_frame(id) - title: '@render.data_frame' - href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame - signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L258-L302 + href: https://shiny.posit.co/py/api/render.data_frame.html + signature: render.data_frame(fn=None) - title: render.DataTable - href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable - signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_dataframe.py#L122-L207 + href: https://shiny.posit.co/py/api/render.DataTable.html + signature: render.DataTable(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/image.qmd b/components/outputs/image.qmd index d1983ef2..49977fc2 100644 --- a/components/outputs/image.qmd +++ b/components/outputs/image.qmd @@ -33,14 +33,12 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_image - href: https://shiny.posit.co/py/api/ui.output_image.html#shiny.ui.output_image - signature: "ui.output_image(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool = False)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L123-L234 + href: https://shiny.posit.co/py/api/ui.output_image.html + signature: ui.output_image(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=False) - title: '@render.image' - href: https://shiny.posit.co/py/api/render.image.html#shiny.render.image - signature: 'render.image(delete_file: bool = False)' + href: https://shiny.posit.co/py/api/render.image.html + signature: render.image(_fn=None, *, delete_file=False) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L341-L371 --- :::{#component} diff --git a/components/outputs/plot-matplotlib.qmd b/components/outputs/plot-matplotlib.qmd index 6368a995..2ff26ff1 100644 --- a/components/outputs/plot-matplotlib.qmd +++ b/components/outputs/plot-matplotlib.qmd @@ -40,13 +40,11 @@ listing: relevantfunctions: - title: ui.output_plot - href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot - signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L33-L120 + href: https://shiny.posit.co/py/api/ui.output_plot.html + signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) - title: '@render.plot' - href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot - signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L237-L298 + href: https://shiny.posit.co/py/api/render.plot.html + signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/plot-seaborn.qmd b/components/outputs/plot-seaborn.qmd index 54ecfd15..de7e0690 100644 --- a/components/outputs/plot-seaborn.qmd +++ b/components/outputs/plot-seaborn.qmd @@ -38,14 +38,12 @@ listing: relevantfunctions: - title: ui.output_plot - href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot - signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L33-L120 + href: https://shiny.posit.co/py/api/ui.output_plot.html + signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) - title: '@render.plot' - href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot - signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' + href: https://shiny.posit.co/py/api/render.plot.html + signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L237-L298 --- :::{#component} diff --git a/components/outputs/text.qmd b/components/outputs/text.qmd index cff7c338..6af0bb8c 100644 --- a/components/outputs/text.qmd +++ b/components/outputs/text.qmd @@ -42,13 +42,11 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_text - href: https://shiny.posit.co/py/api/ui.output_text.html#shiny.ui.output_text - signature: 'ui.output_text(id: str, inline: bool = False, container: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L237-L270 + href: https://shiny.posit.co/py/api/ui.output_text.html + signature: ui.output_text(id, inline=False, container=None) - title: '@render.text' - href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text - signature: render.text() - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L77-L98 + href: https://shiny.posit.co/py/api/render.text.html + signature: render.text(fn=None) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/ui.qmd b/components/outputs/ui.qmd index 8826191c..c5afcd1c 100644 --- a/components/outputs/ui.qmd +++ b/components/outputs/ui.qmd @@ -37,13 +37,11 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_ui - href: https://shiny.posit.co/py/api/ui.output_ui.html#shiny.ui.output_ui - signature: 'ui.output_ui(id: str, inline: bool = False, container: Optional = None, fill: bool = False, fillable: bool = False, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L332-L379 + href: https://shiny.posit.co/py/api/ui.output_ui.html + signature: ui.output_ui(id, inline=False, container=None, fill=False, fillable=False, **kwargs) - title: '@render.ui' - href: https://shiny.posit.co/py/api/render.ui.html#shiny.render.ui - signature: render.ui() - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L540-L562 + href: https://shiny.posit.co/py/api/render.ui.html + signature: render.ui(_fn=None) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/value-box.qmd b/components/outputs/value-box.qmd index f0b11198..b02ca459 100644 --- a/components/outputs/value-box.qmd +++ b/components/outputs/value-box.qmd @@ -294,13 +294,11 @@ listing: relevantfunctions: - title: ui.value_box - href: https://shiny.posit.co/py/api/ui.value_box.html#shiny.ui.value_box - signature: "ui.value_box(title: TagChild, *args: TagChild | TagAttrs = (), showcase: Optional = None, showcase_layout: SHOWCASE_LAYOUTS_STR | ShowcaseLayout = 'left center', theme: Optional = None, full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})" - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_valuebox.py#L296-L459 + href: https://shiny.posit.co/py/api/ui.value_box.html + signature: ui.value_box(title, value, *args, showcase=None, showcase_layout='left center', full_screen=False, theme=None, height=None, max_height=None, fill=True, class_=None, **kwargs) - title: ui.card href: https://shiny.posit.co/py/api/ui.card.html#shiny.ui.card - signature: 'ui.card(*args: TagChild | TagAttrs | CardItem = (), full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_card.py#L45-L104 + signature: ui.card(*args, full_screen=False, height=None, max_height=None, min_height=None, fill=True, class_=None, **kwargs) - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/verbatim-text.qmd b/components/outputs/verbatim-text.qmd index c3ffb86a..a541c9ff 100644 --- a/components/outputs/verbatim-text.qmd +++ b/components/outputs/verbatim-text.qmd @@ -40,13 +40,11 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_text_verbatim - href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html#shiny.ui.output_text_verbatim - signature: 'ui.output_text_verbatim(id: str, placeholder: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/ui/_output.py#L273-L306 + href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html + signature: ui.output_text_verbatim(id, placeholder=False) - title: '@render.text' - href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text - signature: render.text() - github: https://github.com/posit-dev/py-shiny/blob/d9766b1/shiny/render/_render.py#L77-L98 + href: https://shiny.posit.co/py/api/render.text.html + signature: render.text(fn=None) - id: variations template: ../_partials/components-variations.ejs contents: From 19da1f0a7f6057668626424a1f5bc8e14b0d78bf Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 15:01:52 -0500 Subject: [PATCH 07/22] Try to detect if changes are made and comment on the PR --- .github/workflows/deploy-docs.yml | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 705ed20a..7d31e81a 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -56,6 +56,36 @@ jobs: run: | make all + # ===================================================== + # Notify PR of file updates + # ===================================================== + + - name: Find updates to components + if: ${{github.event_name == 'pull_request'}} + id: components + shell: bash + run: | + git diff --quiet -- components && exit 0 + # Changes detected + echo "has-changes=true" >> "$GITHUB_OUTPUT" + + - name: Write comment to update components folder + if: ${{github.event_name == 'pull_request' && steps.components.outputs.has-changes == 'true'}} + uses: thollander/actions-comment-pull-request@v2 + with: + message: | + Please call `make quartodoc` to update files within the components folder + comment_tag: make_quartodoc + mode: delete + - name: Remove comment to update components folder + if: ${{github.event_name == 'pull_request' && steps.components.outputs.has-changes != 'true'}} + uses: thollander/actions-comment-pull-request@v2 + with: + # message: | + # Components folder is up to date. Removing comment + comment_tag: make_quartodoc + mode: delete + # ===================================================== # Deploy docs to Netlify # ===================================================== From 1b30b363036755bc08eeceb1c4d97c689c09aa8a Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 15:10:38 -0500 Subject: [PATCH 08/22] Do not use a build matrix --- .github/workflows/deploy-docs.yml | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 7d31e81a..265f9f74 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -9,18 +9,14 @@ on: jobs: build: runs-on: ubuntu-latest - strategy: - matrix: - python-version: ["3.10"] - fail-fast: false steps: - uses: actions/checkout@v3 - - name: Set up Python ${{ matrix.python-version }} + - name: Set up Python 3.10 uses: actions/setup-python@v4 with: - python-version: ${{ matrix.python-version }} + python-version: "3.10" - name: Upgrade pip run: python -m pip install --upgrade pip From 2d711093adc84af59d8f69b4626892288889c6f0 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 15:11:02 -0500 Subject: [PATCH 09/22] Allow PR comment to be created earlier in action. (do not wait for site to build) --- .github/workflows/deploy-docs.yml | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 265f9f74..e8b41a86 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -42,15 +42,15 @@ jobs: make deps # ===================================================== - # Build + # Setup site # ===================================================== - uses: quarto-dev/quarto-actions/setup@v2 with: version: 1.3.340 - - name: Build site + - name: Prep site run: | - make all + make deps quartodoc # ===================================================== # Notify PR of file updates @@ -82,6 +82,13 @@ jobs: comment_tag: make_quartodoc mode: delete + # ===================================================== + # Build + # ===================================================== + - name: Build site + run: | + make site + # ===================================================== # Deploy docs to Netlify # ===================================================== From de6fbda85a19d71dffa9b4fa701f177238c4deda Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 15:11:31 -0500 Subject: [PATCH 10/22] Only let one job per PR run at a time. All all push events to run --- .github/workflows/deploy-docs.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index e8b41a86..967552a2 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -6,6 +6,11 @@ on: pull_request: branches: [main] +# Limit actions on PRs to a single job +concurrency: + group: ${{ github.head_ref || github.run_id }} + cancel-in-progress: true + jobs: build: runs-on: ubuntu-latest From 2acb8fb43f518514c8a0816ec6a58dc3ad44b8ec Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 15:18:08 -0500 Subject: [PATCH 11/22] Update message. Do not autodelete init message --- .github/workflows/deploy-docs.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 967552a2..88adeab1 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -76,8 +76,9 @@ jobs: with: message: | Please call `make quartodoc` to update files within the components folder + + - [ ] Called `make quartodoc` and commit/push changes comment_tag: make_quartodoc - mode: delete - name: Remove comment to update components folder if: ${{github.event_name == 'pull_request' && steps.components.outputs.has-changes != 'true'}} uses: thollander/actions-comment-pull-request@v2 From 247cd44b54135d253525a603fdb1a10cd2e78d93 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 15:24:29 -0500 Subject: [PATCH 12/22] Update deploy-docs.yml --- .github/workflows/deploy-docs.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 88adeab1..d1399170 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -77,7 +77,8 @@ jobs: message: | Please call `make quartodoc` to update files within the components folder - - [ ] Called `make quartodoc` and commit/push changes + - [ ] Call `make quartodoc` in terminal + - [ ] Commit & push changes comment_tag: make_quartodoc - name: Remove comment to update components folder if: ${{github.event_name == 'pull_request' && steps.components.outputs.has-changes != 'true'}} From fee9eda37a312bb19c2f2d7e93cca75a19bc79b5 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 15:24:43 -0500 Subject: [PATCH 13/22] `make quartodoc` --- components/display-messages/modal.qmd | 20 +++++++++++-------- components/display-messages/notifications.qmd | 10 ++++++---- components/display-messages/progress-bar.qmd | 5 +++-- components/display-messages/tooltips.qmd | 10 ++++++---- components/inputs/action-button.qmd | 10 ++++++---- components/inputs/action-link.qmd | 10 ++++++---- components/inputs/checkbox-group.qmd | 5 +++-- components/inputs/checkbox.qmd | 5 +++-- components/inputs/date-range-selector.qmd | 5 +++-- components/inputs/date-selector.qmd | 5 +++-- components/inputs/numeric-input.qmd | 5 +++-- components/inputs/password-field.qmd | 5 +++-- components/inputs/radio-buttons.qmd | 5 +++-- components/inputs/select-multiple.qmd | 5 +++-- components/inputs/select-single.qmd | 5 +++-- components/inputs/selectize-multiple.qmd | 5 +++-- components/inputs/selectize-single.qmd | 5 +++-- components/inputs/slider-range.qmd | 20 +++++++++++-------- components/inputs/slider.qmd | 5 +++-- components/inputs/switch.qmd | 5 +++-- components/inputs/text-area.qmd | 5 +++-- components/inputs/text-box.qmd | 5 +++-- components/outputs/data-grid.qmd | 15 ++++++++------ components/outputs/datatable.qmd | 15 ++++++++------ components/outputs/image.qmd | 10 ++++++---- components/outputs/plot-matplotlib.qmd | 10 ++++++---- components/outputs/plot-seaborn.qmd | 10 ++++++---- components/outputs/text.qmd | 10 ++++++---- components/outputs/ui.qmd | 10 ++++++---- components/outputs/value-box.qmd | 8 +++++--- components/outputs/verbatim-text.qmd | 10 ++++++---- 31 files changed, 155 insertions(+), 103 deletions(-) diff --git a/components/display-messages/modal.qmd b/components/display-messages/modal.qmd index 5c8ff868..7465455f 100644 --- a/components/display-messages/modal.qmd +++ b/components/display-messages/modal.qmd @@ -48,17 +48,21 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.modal - href: https://shiny.posit.co/py/api/ui.modal.html - signature: ui.modal(*args, title=None, footer=MISSING, size='m', easy_close=False, fade=True, **kwargs) + href: https://shiny.posit.co/py/api/ui.modal.html#shiny.ui.modal + signature: "ui.modal(*args: TagChild | TagAttrs = (), title: Optional = None, footer: TagChild | MISSING_TYPE = MISSING, size: Literal = 'm', easy_close: bool = False, fade: bool = True, **kwargs: TagAttrValue = {})" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_modal.py#L60-L156 - title: ui.modal_show - href: https://shiny.posit.co/py/api/ui.modal_show.html - signature: ui.modal_show(modal, session=None) + href: https://shiny.posit.co/py/api/ui.modal_show.html#shiny.ui.modal_show + signature: 'ui.modal_show(modal: Tag, session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_modal.py#L159-L185 - title: ui.modal_remove - href: https://shiny.posit.co/py/api/ui.modal_remove.html - signature: ui.modal_remove(session=None) + href: https://shiny.posit.co/py/api/ui.modal_remove.html#shiny.ui.modal_remove + signature: 'ui.modal_remove(session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_modal.py#L188-L212 - title: ui.modal_button - href: https://shiny.posit.co/py/api/ui.modal_button.html - signature: ui.modal_button(label, icon=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.modal_button.html#shiny.ui.modal_button + signature: 'ui.modal_button(label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_modal.py#L19-L57 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/notifications.qmd b/components/display-messages/notifications.qmd index 8e6d7fe9..b281c5b8 100644 --- a/components/display-messages/notifications.qmd +++ b/components/display-messages/notifications.qmd @@ -64,11 +64,13 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.notification_show - href: https://shiny.posit.co/py/api/ui.notification_show.html - signature: ui.notification_show(ui, *, action=None, duration=5, close_button=True, id=None, type='default', session=None) + href: https://shiny.posit.co/py/api/ui.notification_show.html#shiny.ui.notification_show + signature: "ui.notification_show(ui: TagChild, action: Optional = None, duration: Optional = 5, close_button: bool = True, id: Optional = None, type: Literal = 'default', session: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_notification.py#L14-L90 - title: ui.notification_remove - href: https://shiny.posit.co/py/api/ui.notification_remove.html - signature: ui.notification_remove(id, *, session=None) + href: https://shiny.posit.co/py/api/ui.notification_remove.html#shiny.ui.notification_remove + signature: 'ui.notification_remove(id: str, session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_notification.py#L93-L125 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/progress-bar.qmd b/components/display-messages/progress-bar.qmd index c9b37f2c..9d9d6a4b 100644 --- a/components/display-messages/progress-bar.qmd +++ b/components/display-messages/progress-bar.qmd @@ -66,8 +66,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.Progress - href: https://shiny.posit.co/py/api/ui.Progress.html - signature: ui.Progress(self, min=0, max=1, session=None) + href: https://shiny.posit.co/py/api/ui.Progress.html#shiny.ui.Progress + signature: 'ui.Progress(min: int = 0, max: int = 1, session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_progress.py#L14-L167 - title: ui.Progress.close href: https://shiny.posit.co/py/api/ui.Progress.html signature: ui.Progress.close(self) diff --git a/components/display-messages/tooltips.qmd b/components/display-messages/tooltips.qmd index c28b6815..bb19c9e2 100644 --- a/components/display-messages/tooltips.qmd +++ b/components/display-messages/tooltips.qmd @@ -49,11 +49,13 @@ listing: relevantfunctions: - title: ui.tooltip - href: https://shiny.posit.co/py/api/ui.tooltip.html - signature: ui.tooltip(trigger, *args, id=None, placement='auto', options=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.tooltip.html#shiny.ui.tooltip + signature: "ui.tooltip(trigger: TagChild, *args: TagChild | TagAttrs = (), id: Optional = None, placement: Literal = 'auto', options: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_tooltip.py#L13-L154 - title: ui.update_tooltip - href: https://shiny.posit.co/py/api/ui.update_tooltip.html - signature: ui.update_tooltip(id, *args, show=None, session=None) + href: https://shiny.posit.co/py/api/ui.update_tooltip.html#shiny.ui.update_tooltip + signature: 'ui.update_tooltip(id: str, *args: TagChild = (), show: Optional = None, session: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_update.py#L904-L946 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/action-button.qmd b/components/inputs/action-button.qmd index 365ec321..116a7ac4 100644 --- a/components/inputs/action-button.qmd +++ b/components/inputs/action-button.qmd @@ -39,12 +39,14 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_action_button - href: https://shiny.posit.co/py/api/ui.input_action_button.html - signature: ui.input_action_button(id, label, *, icon=None, width=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.input_action_button.html#shiny.ui.input_action_button + signature: 'ui.input_action_button(id: str, label: TagChild, icon: TagChild = None, width: Optional = None, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_action_button.py#L11-L65 - title: reactive.event - href: https://shiny.posit.co/py/api/reactive.event.html - signature: reactive.event(*args, ignore_none=True, ignore_init=False) + href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event + signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/action-link.qmd b/components/inputs/action-link.qmd index 09a58fc7..5ad57948 100644 --- a/components/inputs/action-link.qmd +++ b/components/inputs/action-link.qmd @@ -39,12 +39,14 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_action_link - href: https://shiny.posit.co/py/api/ui.input_action_link.html - signature: ui.input_action_link(id, label, *, icon=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.input_action_link.html#shiny.ui.input_action_link + signature: 'ui.input_action_link(id: str, label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_action_button.py#L68-L115 - title: reactive.event - href: https://shiny.posit.co/py/api/reactive.event.html - signature: reactive.event(*args, ignore_none=True, ignore_init=False) + href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event + signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/checkbox-group.qmd b/components/inputs/checkbox-group.qmd index a7f885fa..ecff3621 100644 --- a/components/inputs/checkbox-group.qmd +++ b/components/inputs/checkbox-group.qmd @@ -53,9 +53,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_checkbox_group - href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html - signature: ui.input_checkbox_group(id, label, choices, *, selected=None, inline=False, width=None) + href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html#shiny.ui.input_checkbox_group + signature: 'ui.input_checkbox_group(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_check_radio.py#L169-L237 --- :::{#component} diff --git a/components/inputs/checkbox.qmd b/components/inputs/checkbox.qmd index 7aa6c29b..774c53d7 100644 --- a/components/inputs/checkbox.qmd +++ b/components/inputs/checkbox.qmd @@ -37,8 +37,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_checkbox() - href: https://shiny.posit.co/py/api/ui.input_checkbox.html - signature: ui.input_checkbox(id, label, value=False, *, width=None) + href: https://shiny.posit.co/py/api/ui.input_checkbox.html#shiny.ui.input_checkbox + signature: 'ui.input_checkbox(id: str, label: TagChild, value: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_check_radio.py#L32-L85 --- :::{#component} diff --git a/components/inputs/date-range-selector.qmd b/components/inputs/date-range-selector.qmd index d1cdce3c..11853b85 100644 --- a/components/inputs/date-range-selector.qmd +++ b/components/inputs/date-range-selector.qmd @@ -43,9 +43,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_date_range - href: https://shiny.posit.co/py/api/ui.input_date_range.html - signature: ui.input_date_range(id, label, *, start=None, end=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', separator=' to ', width=None, autoclose=True) + href: https://shiny.posit.co/py/api/ui.input_date_range.html#shiny.ui.input_date_range + signature: "ui.input_date_range(id: str, label: TagChild, start: Optional = None, end: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', separator: str = ' to ', width: Optional = None, autoclose: bool = True)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_date.py#L135-L269 --- :::{#component} diff --git a/components/inputs/date-selector.qmd b/components/inputs/date-selector.qmd index 818e9ba1..ab133688 100644 --- a/components/inputs/date-selector.qmd +++ b/components/inputs/date-selector.qmd @@ -41,8 +41,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_date - href: https://shiny.posit.co/py/api/ui.input_date.html - signature: ui.input_date(id, label, *, value=None, min=None, max=None, format='yyyy-mm-dd', startview='month', weekstart=0, language='en', width=None, autoclose=True, datesdisabled=None, daysofweekdisabled=None) + href: https://shiny.posit.co/py/api/ui.input_date.html#shiny.ui.input_date + signature: "ui.input_date(id: str, label: TagChild, value: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', width: Optional = None, autoclose: bool = True, datesdisabled: Optional = None, daysofweekdisabled: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_date.py#L17-L132 --- :::{#component} diff --git a/components/inputs/numeric-input.qmd b/components/inputs/numeric-input.qmd index a2217b09..7445525b 100644 --- a/components/inputs/numeric-input.qmd +++ b/components/inputs/numeric-input.qmd @@ -39,9 +39,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_numeric - href: https://shiny.posit.co/py/api/ui.input_numeric.html - signature: ui.input_numeric(id, label, value, *, min=None, max=None, step=None, width=None) + href: https://shiny.posit.co/py/api/ui.input_numeric.html#shiny.ui.input_numeric + signature: 'ui.input_numeric(id: str, label: TagChild, value: float, min: Optional = None, max: Optional = None, step: Optional = None, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_numeric.py#L12-L73 --- :::{#component} diff --git a/components/inputs/password-field.qmd b/components/inputs/password-field.qmd index bdb8c4a5..6320e905 100644 --- a/components/inputs/password-field.qmd +++ b/components/inputs/password-field.qmd @@ -39,9 +39,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_password - href: https://shiny.posit.co/py/api/ui.input_password.html - signature: ui.input_password(id, label, value='', *, width=None, placeholder=None) + href: https://shiny.posit.co/py/api/ui.input_password.html#shiny.ui.input_password + signature: "ui.input_password(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_password.py#L12-L64 --- :::{#component} diff --git a/components/inputs/radio-buttons.qmd b/components/inputs/radio-buttons.qmd index d8427991..fce27e39 100644 --- a/components/inputs/radio-buttons.qmd +++ b/components/inputs/radio-buttons.qmd @@ -48,9 +48,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_radio_buttons - href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html - signature: ui.input_radio_buttons(id, label, choices, *, selected=None, inline=False, width=None) + href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html#shiny.ui.input_radio_buttons + signature: 'ui.input_radio_buttons(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_check_radio.py#L240-L307 --- :::{#component} diff --git a/components/inputs/select-multiple.qmd b/components/inputs/select-multiple.qmd index 293cd66a..be3c7083 100644 --- a/components/inputs/select-multiple.qmd +++ b/components/inputs/select-multiple.qmd @@ -52,8 +52,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_select - href: https://shiny.posit.co/py/api/ui.input_select.html - signature: ui.input_select(id, label, choices, *, selected=None, multiple=False, selectize=False, width=None, size=None) + href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select + signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/select-single.qmd b/components/inputs/select-single.qmd index a1d7777b..b492e59f 100644 --- a/components/inputs/select-single.qmd +++ b/components/inputs/select-single.qmd @@ -51,9 +51,10 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_select - href: https://shiny.posit.co/py/api/ui.input_select.html - signature: ui.input_select(id, label, choices, *, selected=None, multiple=False, selectize=False, width=None, size=None) + href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select + signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-multiple.qmd b/components/inputs/selectize-multiple.qmd index a3fcad87..4f0557d0 100644 --- a/components/inputs/selectize-multiple.qmd +++ b/components/inputs/selectize-multiple.qmd @@ -53,8 +53,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_selectize - href: https://shiny.posit.co/py/api/ui.input_selectize.html - signature: ui.input_selectize(id, label, choices, *, selected=None, multiple=False, width=None) + href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize + signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-single.qmd b/components/inputs/selectize-single.qmd index c9aa55c2..c8216126 100644 --- a/components/inputs/selectize-single.qmd +++ b/components/inputs/selectize-single.qmd @@ -51,8 +51,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_selectize - href: https://shiny.posit.co/py/api/ui.input_selectize.html - signature: ui.input_selectize(id, label, choices, *, selected=None, multiple=False, width=None) + href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize + signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/slider-range.qmd b/components/inputs/slider-range.qmd index 069833b4..a8fe20d2 100644 --- a/components/inputs/slider-range.qmd +++ b/components/inputs/slider-range.qmd @@ -37,17 +37,21 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_slider - href: https://shiny.posit.co/py/api/ui.input_slider.html - signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) + href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider + signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_slider.py#L59-L234 - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html - signature: ui.output_data_frame(id) + href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame + signature: 'ui.output_data_frame(id: str)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: render.data_frame - href: https://shiny.posit.co/py/api/render.data_frame.html - signature: render.data_frame(fn=None) + href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame + signature: render.data_frame() + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable - href: https://shiny.posit.co/py/api/render.DataTable.html - signature: render.DataTable(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') + href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable + signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L122-L207 --- :::{#component} diff --git a/components/inputs/slider.qmd b/components/inputs/slider.qmd index 1c5876f5..3bfbe7ca 100644 --- a/components/inputs/slider.qmd +++ b/components/inputs/slider.qmd @@ -39,8 +39,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_slider - href: https://shiny.posit.co/py/api/ui.input_slider.html - signature: ui.input_slider(id, label, min, max, value, *, step=None, ticks=False, animate=False, width=None, sep=',', pre=None, post=None, time_format=None, timezone=None, drag_range=True) + href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider + signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_slider.py#L59-L234 --- :::{#component} diff --git a/components/inputs/switch.qmd b/components/inputs/switch.qmd index 2e8c4b96..fec54bac 100644 --- a/components/inputs/switch.qmd +++ b/components/inputs/switch.qmd @@ -36,8 +36,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_switch - href: https://shiny.posit.co/py/api/ui.input_switch.html - signature: ui.input_switch(id, label, value=False, *, width=None) + href: https://shiny.posit.co/py/api/ui.input_switch.html#shiny.ui.input_switch + signature: 'ui.input_switch(id: str, label: TagChild, value: bool = False, width: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_check_radio.py#L88-L133 --- :::{#component} diff --git a/components/inputs/text-area.qmd b/components/inputs/text-area.qmd index 644e6a28..ede22d06 100644 --- a/components/inputs/text-area.qmd +++ b/components/inputs/text-area.qmd @@ -39,8 +39,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_text_area - href: https://shiny.posit.co/py/api/ui.input_text_area.html - signature: ui.input_text_area(id, label, value='', *, width=None, height=None, cols=None, rows=None, placeholder=None, resize=None, autoresize=False, autocomplete=None, spellcheck=None) + href: https://shiny.posit.co/py/api/ui.input_text_area.html#shiny.ui.input_text_area + signature: "ui.input_text_area(id: str, label: TagChild, value: str = '', width: Optional = None, height: Optional = None, cols: Optional = None, rows: Optional = None, placeholder: Optional = None, resize: Optional = None, autoresize: bool = False, autocomplete: Optional = None, spellcheck: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_text.py#L83-L187 --- :::{#component} diff --git a/components/inputs/text-box.qmd b/components/inputs/text-box.qmd index 13dd118a..5f8096c1 100644 --- a/components/inputs/text-box.qmd +++ b/components/inputs/text-box.qmd @@ -39,8 +39,9 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.input_text - href: https://shiny.posit.co/py/api/ui.input_text.html - signature: ui.input_text(id, label, value='', *, width=None, placeholder=None, autocomplete='off', spellcheck=None) + href: https://shiny.posit.co/py/api/ui.input_text.html#shiny.ui.input_text + signature: "ui.input_text(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None, autocomplete: Optional = 'off', spellcheck: Optional = None)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_text.py#L13-L80 --- :::{#component} diff --git a/components/outputs/data-grid.qmd b/components/outputs/data-grid.qmd index 6ff5604d..6ca34a08 100644 --- a/components/outputs/data-grid.qmd +++ b/components/outputs/data-grid.qmd @@ -32,14 +32,17 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html - signature: ui.output_data_frame(id) + href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame + signature: 'ui.output_data_frame(id: str)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' - href: https://shiny.posit.co/py/api/render.data_frame.html - signature: render.data_frame(fn=None) + href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame + signature: render.data_frame() + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L258-L302 - title: render.DataGrid - href: https://shiny.posit.co/py/api/render.DataGrid.html - signature: render.DataGrid(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') + href: https://shiny.posit.co/py/api/render.DataGrid.html#shiny.render.DataGrid + signature: "render.DataGrid(data: object, width: str | float | None = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Literal = 'none')" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L36-L119 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/datatable.qmd b/components/outputs/datatable.qmd index f086f981..0c3e0313 100644 --- a/components/outputs/datatable.qmd +++ b/components/outputs/datatable.qmd @@ -31,14 +31,17 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_data_frame - href: https://shiny.posit.co/py/api/ui.output_data_frame.html - signature: ui.output_data_frame(id) + href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame + signature: 'ui.output_data_frame(id: str)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' - href: https://shiny.posit.co/py/api/render.data_frame.html - signature: render.data_frame(fn=None) + href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame + signature: render.data_frame() + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable - href: https://shiny.posit.co/py/api/render.DataTable.html - signature: render.DataTable(self, data, *, width='fit-content', height='500px', summary=True, filters=False, row_selection_mode='none') + href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable + signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L122-L207 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/image.qmd b/components/outputs/image.qmd index 49977fc2..0695f719 100644 --- a/components/outputs/image.qmd +++ b/components/outputs/image.qmd @@ -33,12 +33,14 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_image - href: https://shiny.posit.co/py/api/ui.output_image.html - signature: ui.output_image(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=False) + href: https://shiny.posit.co/py/api/ui.output_image.html#shiny.ui.output_image + signature: "ui.output_image(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool = False)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L123-L234 - title: '@render.image' - href: https://shiny.posit.co/py/api/render.image.html - signature: render.image(_fn=None, *, delete_file=False) + href: https://shiny.posit.co/py/api/render.image.html#shiny.render.image + signature: 'render.image(delete_file: bool = False)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L341-L371 --- :::{#component} diff --git a/components/outputs/plot-matplotlib.qmd b/components/outputs/plot-matplotlib.qmd index 2ff26ff1..5f40510f 100644 --- a/components/outputs/plot-matplotlib.qmd +++ b/components/outputs/plot-matplotlib.qmd @@ -40,11 +40,13 @@ listing: relevantfunctions: - title: ui.output_plot - href: https://shiny.posit.co/py/api/ui.output_plot.html - signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) + href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot + signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L33-L120 - title: '@render.plot' - href: https://shiny.posit.co/py/api/render.plot.html - signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) + href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot + signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L237-L298 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/plot-seaborn.qmd b/components/outputs/plot-seaborn.qmd index de7e0690..afae9030 100644 --- a/components/outputs/plot-seaborn.qmd +++ b/components/outputs/plot-seaborn.qmd @@ -38,12 +38,14 @@ listing: relevantfunctions: - title: ui.output_plot - href: https://shiny.posit.co/py/api/ui.output_plot.html - signature: ui.output_plot(id, width='100%', height='400px', *, inline=False, click=False, dblclick=False, hover=False, brush=False, fill=MISSING) + href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot + signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L33-L120 - title: '@render.plot' - href: https://shiny.posit.co/py/api/render.plot.html - signature: render.plot(_fn=None, *, alt=None, width=MISSING, height=MISSING, **kwargs) + href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot + signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L237-L298 --- :::{#component} diff --git a/components/outputs/text.qmd b/components/outputs/text.qmd index 6af0bb8c..63303078 100644 --- a/components/outputs/text.qmd +++ b/components/outputs/text.qmd @@ -42,11 +42,13 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_text - href: https://shiny.posit.co/py/api/ui.output_text.html - signature: ui.output_text(id, inline=False, container=None) + href: https://shiny.posit.co/py/api/ui.output_text.html#shiny.ui.output_text + signature: 'ui.output_text(id: str, inline: bool = False, container: Optional = None)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L237-L270 - title: '@render.text' - href: https://shiny.posit.co/py/api/render.text.html - signature: render.text(fn=None) + href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text + signature: render.text() + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/ui.qmd b/components/outputs/ui.qmd index c5afcd1c..4b32750d 100644 --- a/components/outputs/ui.qmd +++ b/components/outputs/ui.qmd @@ -37,11 +37,13 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_ui - href: https://shiny.posit.co/py/api/ui.output_ui.html - signature: ui.output_ui(id, inline=False, container=None, fill=False, fillable=False, **kwargs) + href: https://shiny.posit.co/py/api/ui.output_ui.html#shiny.ui.output_ui + signature: 'ui.output_ui(id: str, inline: bool = False, container: Optional = None, fill: bool = False, fillable: bool = False, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L332-L379 - title: '@render.ui' - href: https://shiny.posit.co/py/api/render.ui.html - signature: render.ui(_fn=None) + href: https://shiny.posit.co/py/api/render.ui.html#shiny.render.ui + signature: render.ui() + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L540-L562 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/value-box.qmd b/components/outputs/value-box.qmd index b02ca459..06316cb7 100644 --- a/components/outputs/value-box.qmd +++ b/components/outputs/value-box.qmd @@ -294,11 +294,13 @@ listing: relevantfunctions: - title: ui.value_box - href: https://shiny.posit.co/py/api/ui.value_box.html - signature: ui.value_box(title, value, *args, showcase=None, showcase_layout='left center', full_screen=False, theme=None, height=None, max_height=None, fill=True, class_=None, **kwargs) + href: https://shiny.posit.co/py/api/ui.value_box.html#shiny.ui.value_box + signature: "ui.value_box(title: TagChild, *args: TagChild | TagAttrs = (), showcase: Optional = None, showcase_layout: SHOWCASE_LAYOUTS_STR | ShowcaseLayout = 'left center', theme: Optional = None, full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})" + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_valuebox.py#L296-L459 - title: ui.card href: https://shiny.posit.co/py/api/ui.card.html#shiny.ui.card - signature: ui.card(*args, full_screen=False, height=None, max_height=None, min_height=None, fill=True, class_=None, **kwargs) + signature: 'ui.card(*args: TagChild | TagAttrs | CardItem = (), full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_card.py#L45-L104 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/verbatim-text.qmd b/components/outputs/verbatim-text.qmd index a541c9ff..b032d046 100644 --- a/components/outputs/verbatim-text.qmd +++ b/components/outputs/verbatim-text.qmd @@ -40,11 +40,13 @@ listing: app = App(app_ui, server) relevantfunctions: - title: ui.output_text_verbatim - href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html - signature: ui.output_text_verbatim(id, placeholder=False) + href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html#shiny.ui.output_text_verbatim + signature: 'ui.output_text_verbatim(id: str, placeholder: bool = False)' + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L273-L306 - title: '@render.text' - href: https://shiny.posit.co/py/api/render.text.html - signature: render.text(fn=None) + href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text + signature: render.text() + github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: From 8fb040076fec19f7b6dbba1bf26cb67348d5670b Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 16:21:46 -0500 Subject: [PATCH 14/22] Output names of files changed --- .github/workflows/deploy-docs.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index d1399170..390d8588 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -69,6 +69,9 @@ jobs: git diff --quiet -- components && exit 0 # Changes detected echo "has-changes=true" >> "$GITHUB_OUTPUT" + # Output changes + echo "Changed files:" + git diff --name-only - name: Write comment to update components folder if: ${{github.event_name == 'pull_request' && steps.components.outputs.has-changes == 'true'}} From dd7bc098e54c43a40a7cdc65a244fccaad23209a Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 16:38:00 -0500 Subject: [PATCH 15/22] Use checkout that auto commit suggests --- .github/workflows/deploy-docs.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 390d8588..56f50232 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -16,7 +16,9 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 + with: + ref: ${{ github.head_ref }} - name: Set up Python 3.10 uses: actions/setup-python@v4 From 592a581c98a834b18a36e2e533bd721384707e10 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 16:38:14 -0500 Subject: [PATCH 16/22] Push back results via auto commit action --- .github/workflows/deploy-docs.yml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 56f50232..4d7b8a2f 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -74,6 +74,15 @@ jobs: # Output changes echo "Changed files:" git diff --name-only + - name: Push back results to repo + uses: stefanzweifel/git-auto-commit-action@v5 + if: | + github.event_name == 'pull_request' && + (! github.event.pull_request.head.repo.fork) && + steps.components.outputs.has-changes == 'true' + with: + commit_message: "`make quartodoc` (GitHub Actions)" + file_pattern: components - name: Write comment to update components folder if: ${{github.event_name == 'pull_request' && steps.components.outputs.has-changes == 'true'}} From 0e60bf8ba015683213e53e0d79e4af8aae607b12 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 16:38:33 -0500 Subject: [PATCH 17/22] Update deploy-docs.yml --- .github/workflows/deploy-docs.yml | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 4d7b8a2f..9c3b29ec 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -55,9 +55,9 @@ jobs: with: version: 1.3.340 - - name: Prep site + - name: Create quartodoc artifacts run: | - make deps quartodoc + make quartodoc # ===================================================== # Notify PR of file updates @@ -85,7 +85,10 @@ jobs: file_pattern: components - name: Write comment to update components folder - if: ${{github.event_name == 'pull_request' && steps.components.outputs.has-changes == 'true'}} + if: | + github.event_name == 'pull_request' && + github.event.pull_request.head.repo.fork && + steps.components.outputs.has-changes == 'true' uses: thollander/actions-comment-pull-request@v2 with: message: | @@ -95,7 +98,10 @@ jobs: - [ ] Commit & push changes comment_tag: make_quartodoc - name: Remove comment to update components folder - if: ${{github.event_name == 'pull_request' && steps.components.outputs.has-changes != 'true'}} + if: | + github.event_name == 'pull_request' && + github.event.pull_request.head.repo.fork && + steps.components.outputs.has-changes != 'true' uses: thollander/actions-comment-pull-request@v2 with: # message: | From b2e5a8d130374e769f98d91dc5a0fdceacf08ffc Mon Sep 17 00:00:00 2001 From: schloerke Date: Wed, 20 Dec 2023 21:41:38 +0000 Subject: [PATCH 18/22] `make quartodoc` (GitHub Actions) --- components/display-messages/modal.qmd | 8 ++++---- components/display-messages/notifications.qmd | 4 ++-- components/display-messages/progress-bar.qmd | 2 +- components/display-messages/tooltips.qmd | 4 ++-- components/inputs/action-button.qmd | 4 ++-- components/inputs/action-link.qmd | 4 ++-- components/inputs/checkbox-group.qmd | 2 +- components/inputs/checkbox.qmd | 2 +- components/inputs/date-range-selector.qmd | 2 +- components/inputs/date-selector.qmd | 2 +- components/inputs/numeric-input.qmd | 2 +- components/inputs/password-field.qmd | 2 +- components/inputs/radio-buttons.qmd | 2 +- components/inputs/select-multiple.qmd | 2 +- components/inputs/select-single.qmd | 2 +- components/inputs/selectize-multiple.qmd | 2 +- components/inputs/selectize-single.qmd | 2 +- components/inputs/slider-range.qmd | 8 ++++---- components/inputs/slider.qmd | 2 +- components/inputs/switch.qmd | 2 +- components/inputs/text-area.qmd | 2 +- components/inputs/text-box.qmd | 2 +- components/outputs/data-grid.qmd | 6 +++--- components/outputs/datatable.qmd | 6 +++--- components/outputs/image.qmd | 4 ++-- components/outputs/plot-matplotlib.qmd | 4 ++-- components/outputs/plot-seaborn.qmd | 4 ++-- components/outputs/text.qmd | 4 ++-- components/outputs/ui.qmd | 4 ++-- components/outputs/value-box.qmd | 4 ++-- components/outputs/verbatim-text.qmd | 4 ++-- 31 files changed, 52 insertions(+), 52 deletions(-) diff --git a/components/display-messages/modal.qmd b/components/display-messages/modal.qmd index 7465455f..b6d53cf3 100644 --- a/components/display-messages/modal.qmd +++ b/components/display-messages/modal.qmd @@ -50,19 +50,19 @@ listing: - title: ui.modal href: https://shiny.posit.co/py/api/ui.modal.html#shiny.ui.modal signature: "ui.modal(*args: TagChild | TagAttrs = (), title: Optional = None, footer: TagChild | MISSING_TYPE = MISSING, size: Literal = 'm', easy_close: bool = False, fade: bool = True, **kwargs: TagAttrValue = {})" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_modal.py#L60-L156 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_modal.py#L60-L156 - title: ui.modal_show href: https://shiny.posit.co/py/api/ui.modal_show.html#shiny.ui.modal_show signature: 'ui.modal_show(modal: Tag, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_modal.py#L159-L185 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_modal.py#L159-L185 - title: ui.modal_remove href: https://shiny.posit.co/py/api/ui.modal_remove.html#shiny.ui.modal_remove signature: 'ui.modal_remove(session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_modal.py#L188-L212 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_modal.py#L188-L212 - title: ui.modal_button href: https://shiny.posit.co/py/api/ui.modal_button.html#shiny.ui.modal_button signature: 'ui.modal_button(label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_modal.py#L19-L57 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_modal.py#L19-L57 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/notifications.qmd b/components/display-messages/notifications.qmd index b281c5b8..0f7a89e6 100644 --- a/components/display-messages/notifications.qmd +++ b/components/display-messages/notifications.qmd @@ -66,11 +66,11 @@ listing: - title: ui.notification_show href: https://shiny.posit.co/py/api/ui.notification_show.html#shiny.ui.notification_show signature: "ui.notification_show(ui: TagChild, action: Optional = None, duration: Optional = 5, close_button: bool = True, id: Optional = None, type: Literal = 'default', session: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_notification.py#L14-L90 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_notification.py#L14-L90 - title: ui.notification_remove href: https://shiny.posit.co/py/api/ui.notification_remove.html#shiny.ui.notification_remove signature: 'ui.notification_remove(id: str, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_notification.py#L93-L125 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_notification.py#L93-L125 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/progress-bar.qmd b/components/display-messages/progress-bar.qmd index 9d9d6a4b..fb117ee7 100644 --- a/components/display-messages/progress-bar.qmd +++ b/components/display-messages/progress-bar.qmd @@ -68,7 +68,7 @@ listing: - title: ui.Progress href: https://shiny.posit.co/py/api/ui.Progress.html#shiny.ui.Progress signature: 'ui.Progress(min: int = 0, max: int = 1, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_progress.py#L14-L167 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_progress.py#L14-L167 - title: ui.Progress.close href: https://shiny.posit.co/py/api/ui.Progress.html signature: ui.Progress.close(self) diff --git a/components/display-messages/tooltips.qmd b/components/display-messages/tooltips.qmd index bb19c9e2..9c0fe288 100644 --- a/components/display-messages/tooltips.qmd +++ b/components/display-messages/tooltips.qmd @@ -51,11 +51,11 @@ listing: - title: ui.tooltip href: https://shiny.posit.co/py/api/ui.tooltip.html#shiny.ui.tooltip signature: "ui.tooltip(trigger: TagChild, *args: TagChild | TagAttrs = (), id: Optional = None, placement: Literal = 'auto', options: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_tooltip.py#L13-L154 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_tooltip.py#L13-L154 - title: ui.update_tooltip href: https://shiny.posit.co/py/api/ui.update_tooltip.html#shiny.ui.update_tooltip signature: 'ui.update_tooltip(id: str, *args: TagChild = (), show: Optional = None, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_update.py#L904-L946 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_update.py#L904-L946 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/action-button.qmd b/components/inputs/action-button.qmd index 116a7ac4..f361a59c 100644 --- a/components/inputs/action-button.qmd +++ b/components/inputs/action-button.qmd @@ -41,12 +41,12 @@ listing: - title: ui.input_action_button href: https://shiny.posit.co/py/api/ui.input_action_button.html#shiny.ui.input_action_button signature: 'ui.input_action_button(id: str, label: TagChild, icon: TagChild = None, width: Optional = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_action_button.py#L11-L65 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_action_button.py#L11-L65 - title: reactive.event href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/reactive/_reactives.py#L736-L871 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/action-link.qmd b/components/inputs/action-link.qmd index 5ad57948..f069c5a2 100644 --- a/components/inputs/action-link.qmd +++ b/components/inputs/action-link.qmd @@ -41,12 +41,12 @@ listing: - title: ui.input_action_link href: https://shiny.posit.co/py/api/ui.input_action_link.html#shiny.ui.input_action_link signature: 'ui.input_action_link(id: str, label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_action_button.py#L68-L115 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_action_button.py#L68-L115 - title: reactive.event href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/reactive/_reactives.py#L736-L871 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/checkbox-group.qmd b/components/inputs/checkbox-group.qmd index ecff3621..bf77aafc 100644 --- a/components/inputs/checkbox-group.qmd +++ b/components/inputs/checkbox-group.qmd @@ -56,7 +56,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html#shiny.ui.input_checkbox_group signature: 'ui.input_checkbox_group(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_check_radio.py#L169-L237 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_check_radio.py#L169-L237 --- :::{#component} diff --git a/components/inputs/checkbox.qmd b/components/inputs/checkbox.qmd index 774c53d7..5ad82ebd 100644 --- a/components/inputs/checkbox.qmd +++ b/components/inputs/checkbox.qmd @@ -39,7 +39,7 @@ listing: - title: ui.input_checkbox() href: https://shiny.posit.co/py/api/ui.input_checkbox.html#shiny.ui.input_checkbox signature: 'ui.input_checkbox(id: str, label: TagChild, value: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_check_radio.py#L32-L85 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_check_radio.py#L32-L85 --- :::{#component} diff --git a/components/inputs/date-range-selector.qmd b/components/inputs/date-range-selector.qmd index 11853b85..973b78d4 100644 --- a/components/inputs/date-range-selector.qmd +++ b/components/inputs/date-range-selector.qmd @@ -46,7 +46,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_date_range.html#shiny.ui.input_date_range signature: "ui.input_date_range(id: str, label: TagChild, start: Optional = None, end: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', separator: str = ' to ', width: Optional = None, autoclose: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_date.py#L135-L269 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_date.py#L135-L269 --- :::{#component} diff --git a/components/inputs/date-selector.qmd b/components/inputs/date-selector.qmd index ab133688..978bcf6d 100644 --- a/components/inputs/date-selector.qmd +++ b/components/inputs/date-selector.qmd @@ -43,7 +43,7 @@ listing: - title: ui.input_date href: https://shiny.posit.co/py/api/ui.input_date.html#shiny.ui.input_date signature: "ui.input_date(id: str, label: TagChild, value: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', width: Optional = None, autoclose: bool = True, datesdisabled: Optional = None, daysofweekdisabled: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_date.py#L17-L132 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_date.py#L17-L132 --- :::{#component} diff --git a/components/inputs/numeric-input.qmd b/components/inputs/numeric-input.qmd index 7445525b..bf4152c4 100644 --- a/components/inputs/numeric-input.qmd +++ b/components/inputs/numeric-input.qmd @@ -42,7 +42,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_numeric.html#shiny.ui.input_numeric signature: 'ui.input_numeric(id: str, label: TagChild, value: float, min: Optional = None, max: Optional = None, step: Optional = None, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_numeric.py#L12-L73 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_numeric.py#L12-L73 --- :::{#component} diff --git a/components/inputs/password-field.qmd b/components/inputs/password-field.qmd index 6320e905..55c08ccf 100644 --- a/components/inputs/password-field.qmd +++ b/components/inputs/password-field.qmd @@ -42,7 +42,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_password.html#shiny.ui.input_password signature: "ui.input_password(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_password.py#L12-L64 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_password.py#L12-L64 --- :::{#component} diff --git a/components/inputs/radio-buttons.qmd b/components/inputs/radio-buttons.qmd index fce27e39..40176d86 100644 --- a/components/inputs/radio-buttons.qmd +++ b/components/inputs/radio-buttons.qmd @@ -51,7 +51,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html#shiny.ui.input_radio_buttons signature: 'ui.input_radio_buttons(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_check_radio.py#L240-L307 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_check_radio.py#L240-L307 --- :::{#component} diff --git a/components/inputs/select-multiple.qmd b/components/inputs/select-multiple.qmd index be3c7083..51f8345b 100644 --- a/components/inputs/select-multiple.qmd +++ b/components/inputs/select-multiple.qmd @@ -54,7 +54,7 @@ listing: - title: ui.input_select href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_select.py#L111-L204 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/select-single.qmd b/components/inputs/select-single.qmd index b492e59f..2ff117d2 100644 --- a/components/inputs/select-single.qmd +++ b/components/inputs/select-single.qmd @@ -54,7 +54,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_select.py#L111-L204 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-multiple.qmd b/components/inputs/selectize-multiple.qmd index 4f0557d0..1547404a 100644 --- a/components/inputs/selectize-multiple.qmd +++ b/components/inputs/selectize-multiple.qmd @@ -55,7 +55,7 @@ listing: - title: ui.input_selectize href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_select.py#L48-L108 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-single.qmd b/components/inputs/selectize-single.qmd index c8216126..9d6949d7 100644 --- a/components/inputs/selectize-single.qmd +++ b/components/inputs/selectize-single.qmd @@ -53,7 +53,7 @@ listing: - title: ui.input_selectize href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_select.py#L48-L108 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/slider-range.qmd b/components/inputs/slider-range.qmd index a8fe20d2..a21fdb3d 100644 --- a/components/inputs/slider-range.qmd +++ b/components/inputs/slider-range.qmd @@ -39,19 +39,19 @@ listing: - title: ui.input_slider href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_slider.py#L59-L234 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_slider.py#L59-L234 - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: render.data_frame href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L122-L207 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L122-L207 --- :::{#component} diff --git a/components/inputs/slider.qmd b/components/inputs/slider.qmd index 3bfbe7ca..3b38eca5 100644 --- a/components/inputs/slider.qmd +++ b/components/inputs/slider.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_slider href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_slider.py#L59-L234 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_slider.py#L59-L234 --- :::{#component} diff --git a/components/inputs/switch.qmd b/components/inputs/switch.qmd index fec54bac..ec20ca1e 100644 --- a/components/inputs/switch.qmd +++ b/components/inputs/switch.qmd @@ -38,7 +38,7 @@ listing: - title: ui.input_switch href: https://shiny.posit.co/py/api/ui.input_switch.html#shiny.ui.input_switch signature: 'ui.input_switch(id: str, label: TagChild, value: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_check_radio.py#L88-L133 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_check_radio.py#L88-L133 --- :::{#component} diff --git a/components/inputs/text-area.qmd b/components/inputs/text-area.qmd index ede22d06..16af4984 100644 --- a/components/inputs/text-area.qmd +++ b/components/inputs/text-area.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_text_area href: https://shiny.posit.co/py/api/ui.input_text_area.html#shiny.ui.input_text_area signature: "ui.input_text_area(id: str, label: TagChild, value: str = '', width: Optional = None, height: Optional = None, cols: Optional = None, rows: Optional = None, placeholder: Optional = None, resize: Optional = None, autoresize: bool = False, autocomplete: Optional = None, spellcheck: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_text.py#L83-L187 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_text.py#L83-L187 --- :::{#component} diff --git a/components/inputs/text-box.qmd b/components/inputs/text-box.qmd index 5f8096c1..a0b896cb 100644 --- a/components/inputs/text-box.qmd +++ b/components/inputs/text-box.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_text href: https://shiny.posit.co/py/api/ui.input_text.html#shiny.ui.input_text signature: "ui.input_text(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None, autocomplete: Optional = 'off', spellcheck: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_input_text.py#L13-L80 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_text.py#L13-L80 --- :::{#component} diff --git a/components/outputs/data-grid.qmd b/components/outputs/data-grid.qmd index 6ca34a08..0b1d6101 100644 --- a/components/outputs/data-grid.qmd +++ b/components/outputs/data-grid.qmd @@ -34,15 +34,15 @@ listing: - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L258-L302 - title: render.DataGrid href: https://shiny.posit.co/py/api/render.DataGrid.html#shiny.render.DataGrid signature: "render.DataGrid(data: object, width: str | float | None = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Literal = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L36-L119 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L36-L119 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/datatable.qmd b/components/outputs/datatable.qmd index 0c3e0313..af18fdf5 100644 --- a/components/outputs/datatable.qmd +++ b/components/outputs/datatable.qmd @@ -33,15 +33,15 @@ listing: - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_dataframe.py#L122-L207 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L122-L207 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/image.qmd b/components/outputs/image.qmd index 0695f719..ee6a1854 100644 --- a/components/outputs/image.qmd +++ b/components/outputs/image.qmd @@ -35,12 +35,12 @@ listing: - title: ui.output_image href: https://shiny.posit.co/py/api/ui.output_image.html#shiny.ui.output_image signature: "ui.output_image(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool = False)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L123-L234 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L123-L234 - title: '@render.image' href: https://shiny.posit.co/py/api/render.image.html#shiny.render.image signature: 'render.image(delete_file: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L341-L371 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L341-L371 --- :::{#component} diff --git a/components/outputs/plot-matplotlib.qmd b/components/outputs/plot-matplotlib.qmd index 5f40510f..bf37c64c 100644 --- a/components/outputs/plot-matplotlib.qmd +++ b/components/outputs/plot-matplotlib.qmd @@ -42,11 +42,11 @@ listing: - title: ui.output_plot href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L33-L120 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L33-L120 - title: '@render.plot' href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L237-L298 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L237-L298 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/plot-seaborn.qmd b/components/outputs/plot-seaborn.qmd index afae9030..7475327b 100644 --- a/components/outputs/plot-seaborn.qmd +++ b/components/outputs/plot-seaborn.qmd @@ -40,12 +40,12 @@ listing: - title: ui.output_plot href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L33-L120 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L33-L120 - title: '@render.plot' href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L237-L298 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L237-L298 --- :::{#component} diff --git a/components/outputs/text.qmd b/components/outputs/text.qmd index 63303078..1a86997b 100644 --- a/components/outputs/text.qmd +++ b/components/outputs/text.qmd @@ -44,11 +44,11 @@ listing: - title: ui.output_text href: https://shiny.posit.co/py/api/ui.output_text.html#shiny.ui.output_text signature: 'ui.output_text(id: str, inline: bool = False, container: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L237-L270 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L237-L270 - title: '@render.text' href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text signature: render.text() - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L77-L98 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/ui.qmd b/components/outputs/ui.qmd index 4b32750d..263df969 100644 --- a/components/outputs/ui.qmd +++ b/components/outputs/ui.qmd @@ -39,11 +39,11 @@ listing: - title: ui.output_ui href: https://shiny.posit.co/py/api/ui.output_ui.html#shiny.ui.output_ui signature: 'ui.output_ui(id: str, inline: bool = False, container: Optional = None, fill: bool = False, fillable: bool = False, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L332-L379 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L332-L379 - title: '@render.ui' href: https://shiny.posit.co/py/api/render.ui.html#shiny.render.ui signature: render.ui() - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L540-L562 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L540-L562 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/value-box.qmd b/components/outputs/value-box.qmd index 06316cb7..8e6579df 100644 --- a/components/outputs/value-box.qmd +++ b/components/outputs/value-box.qmd @@ -296,11 +296,11 @@ listing: - title: ui.value_box href: https://shiny.posit.co/py/api/ui.value_box.html#shiny.ui.value_box signature: "ui.value_box(title: TagChild, *args: TagChild | TagAttrs = (), showcase: Optional = None, showcase_layout: SHOWCASE_LAYOUTS_STR | ShowcaseLayout = 'left center', theme: Optional = None, full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})" - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_valuebox.py#L296-L459 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_valuebox.py#L296-L459 - title: ui.card href: https://shiny.posit.co/py/api/ui.card.html#shiny.ui.card signature: 'ui.card(*args: TagChild | TagAttrs | CardItem = (), full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_card.py#L45-L104 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_card.py#L45-L104 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/verbatim-text.qmd b/components/outputs/verbatim-text.qmd index b032d046..2dccf088 100644 --- a/components/outputs/verbatim-text.qmd +++ b/components/outputs/verbatim-text.qmd @@ -42,11 +42,11 @@ listing: - title: ui.output_text_verbatim href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html#shiny.ui.output_text_verbatim signature: 'ui.output_text_verbatim(id: str, placeholder: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/ui/_output.py#L273-L306 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L273-L306 - title: '@render.text' href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text signature: render.text() - github: https://github.com/posit-dev/py-shiny/blob/de6fbda/shiny/render/_render.py#L77-L98 + github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: From fb1e5255d18f20ad747510215f30836d50a4cbe1 Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 16:44:35 -0500 Subject: [PATCH 19/22] Update deploy-docs.yml --- .github/workflows/deploy-docs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 9c3b29ec..effdbe9e 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -74,7 +74,7 @@ jobs: # Output changes echo "Changed files:" git diff --name-only - - name: Push back results to repo + - name: Push back component updates to repo uses: stefanzweifel/git-auto-commit-action@v5 if: | github.event_name == 'pull_request' && From 5146f03f902ea897e67f422d60296cdc18203dda Mon Sep 17 00:00:00 2001 From: schloerke Date: Wed, 20 Dec 2023 21:48:29 +0000 Subject: [PATCH 20/22] `make quartodoc` (GitHub Actions) --- components/display-messages/modal.qmd | 8 ++++---- components/display-messages/notifications.qmd | 4 ++-- components/display-messages/progress-bar.qmd | 2 +- components/display-messages/tooltips.qmd | 4 ++-- components/inputs/action-button.qmd | 4 ++-- components/inputs/action-link.qmd | 4 ++-- components/inputs/checkbox-group.qmd | 2 +- components/inputs/checkbox.qmd | 2 +- components/inputs/date-range-selector.qmd | 2 +- components/inputs/date-selector.qmd | 2 +- components/inputs/numeric-input.qmd | 2 +- components/inputs/password-field.qmd | 2 +- components/inputs/radio-buttons.qmd | 2 +- components/inputs/select-multiple.qmd | 2 +- components/inputs/select-single.qmd | 2 +- components/inputs/selectize-multiple.qmd | 2 +- components/inputs/selectize-single.qmd | 2 +- components/inputs/slider-range.qmd | 8 ++++---- components/inputs/slider.qmd | 2 +- components/inputs/switch.qmd | 2 +- components/inputs/text-area.qmd | 2 +- components/inputs/text-box.qmd | 2 +- components/outputs/data-grid.qmd | 6 +++--- components/outputs/datatable.qmd | 6 +++--- components/outputs/image.qmd | 4 ++-- components/outputs/plot-matplotlib.qmd | 4 ++-- components/outputs/plot-seaborn.qmd | 4 ++-- components/outputs/text.qmd | 4 ++-- components/outputs/ui.qmd | 4 ++-- components/outputs/value-box.qmd | 4 ++-- components/outputs/verbatim-text.qmd | 4 ++-- 31 files changed, 52 insertions(+), 52 deletions(-) diff --git a/components/display-messages/modal.qmd b/components/display-messages/modal.qmd index b6d53cf3..77682d4d 100644 --- a/components/display-messages/modal.qmd +++ b/components/display-messages/modal.qmd @@ -50,19 +50,19 @@ listing: - title: ui.modal href: https://shiny.posit.co/py/api/ui.modal.html#shiny.ui.modal signature: "ui.modal(*args: TagChild | TagAttrs = (), title: Optional = None, footer: TagChild | MISSING_TYPE = MISSING, size: Literal = 'm', easy_close: bool = False, fade: bool = True, **kwargs: TagAttrValue = {})" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_modal.py#L60-L156 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_modal.py#L60-L156 - title: ui.modal_show href: https://shiny.posit.co/py/api/ui.modal_show.html#shiny.ui.modal_show signature: 'ui.modal_show(modal: Tag, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_modal.py#L159-L185 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_modal.py#L159-L185 - title: ui.modal_remove href: https://shiny.posit.co/py/api/ui.modal_remove.html#shiny.ui.modal_remove signature: 'ui.modal_remove(session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_modal.py#L188-L212 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_modal.py#L188-L212 - title: ui.modal_button href: https://shiny.posit.co/py/api/ui.modal_button.html#shiny.ui.modal_button signature: 'ui.modal_button(label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_modal.py#L19-L57 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_modal.py#L19-L57 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/notifications.qmd b/components/display-messages/notifications.qmd index 0f7a89e6..27827a82 100644 --- a/components/display-messages/notifications.qmd +++ b/components/display-messages/notifications.qmd @@ -66,11 +66,11 @@ listing: - title: ui.notification_show href: https://shiny.posit.co/py/api/ui.notification_show.html#shiny.ui.notification_show signature: "ui.notification_show(ui: TagChild, action: Optional = None, duration: Optional = 5, close_button: bool = True, id: Optional = None, type: Literal = 'default', session: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_notification.py#L14-L90 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_notification.py#L14-L90 - title: ui.notification_remove href: https://shiny.posit.co/py/api/ui.notification_remove.html#shiny.ui.notification_remove signature: 'ui.notification_remove(id: str, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_notification.py#L93-L125 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_notification.py#L93-L125 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/progress-bar.qmd b/components/display-messages/progress-bar.qmd index fb117ee7..d988d91a 100644 --- a/components/display-messages/progress-bar.qmd +++ b/components/display-messages/progress-bar.qmd @@ -68,7 +68,7 @@ listing: - title: ui.Progress href: https://shiny.posit.co/py/api/ui.Progress.html#shiny.ui.Progress signature: 'ui.Progress(min: int = 0, max: int = 1, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_progress.py#L14-L167 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_progress.py#L14-L167 - title: ui.Progress.close href: https://shiny.posit.co/py/api/ui.Progress.html signature: ui.Progress.close(self) diff --git a/components/display-messages/tooltips.qmd b/components/display-messages/tooltips.qmd index 9c0fe288..506f77f3 100644 --- a/components/display-messages/tooltips.qmd +++ b/components/display-messages/tooltips.qmd @@ -51,11 +51,11 @@ listing: - title: ui.tooltip href: https://shiny.posit.co/py/api/ui.tooltip.html#shiny.ui.tooltip signature: "ui.tooltip(trigger: TagChild, *args: TagChild | TagAttrs = (), id: Optional = None, placement: Literal = 'auto', options: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_tooltip.py#L13-L154 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_tooltip.py#L13-L154 - title: ui.update_tooltip href: https://shiny.posit.co/py/api/ui.update_tooltip.html#shiny.ui.update_tooltip signature: 'ui.update_tooltip(id: str, *args: TagChild = (), show: Optional = None, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_update.py#L904-L946 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_update.py#L904-L946 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/action-button.qmd b/components/inputs/action-button.qmd index f361a59c..0e421b6f 100644 --- a/components/inputs/action-button.qmd +++ b/components/inputs/action-button.qmd @@ -41,12 +41,12 @@ listing: - title: ui.input_action_button href: https://shiny.posit.co/py/api/ui.input_action_button.html#shiny.ui.input_action_button signature: 'ui.input_action_button(id: str, label: TagChild, icon: TagChild = None, width: Optional = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_action_button.py#L11-L65 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_action_button.py#L11-L65 - title: reactive.event href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/reactive/_reactives.py#L736-L871 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/action-link.qmd b/components/inputs/action-link.qmd index f069c5a2..95e16624 100644 --- a/components/inputs/action-link.qmd +++ b/components/inputs/action-link.qmd @@ -41,12 +41,12 @@ listing: - title: ui.input_action_link href: https://shiny.posit.co/py/api/ui.input_action_link.html#shiny.ui.input_action_link signature: 'ui.input_action_link(id: str, label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_action_button.py#L68-L115 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_action_button.py#L68-L115 - title: reactive.event href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/reactive/_reactives.py#L736-L871 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/checkbox-group.qmd b/components/inputs/checkbox-group.qmd index bf77aafc..91187d15 100644 --- a/components/inputs/checkbox-group.qmd +++ b/components/inputs/checkbox-group.qmd @@ -56,7 +56,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html#shiny.ui.input_checkbox_group signature: 'ui.input_checkbox_group(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_check_radio.py#L169-L237 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_check_radio.py#L169-L237 --- :::{#component} diff --git a/components/inputs/checkbox.qmd b/components/inputs/checkbox.qmd index 5ad82ebd..12e6392f 100644 --- a/components/inputs/checkbox.qmd +++ b/components/inputs/checkbox.qmd @@ -39,7 +39,7 @@ listing: - title: ui.input_checkbox() href: https://shiny.posit.co/py/api/ui.input_checkbox.html#shiny.ui.input_checkbox signature: 'ui.input_checkbox(id: str, label: TagChild, value: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_check_radio.py#L32-L85 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_check_radio.py#L32-L85 --- :::{#component} diff --git a/components/inputs/date-range-selector.qmd b/components/inputs/date-range-selector.qmd index 973b78d4..a3e12a11 100644 --- a/components/inputs/date-range-selector.qmd +++ b/components/inputs/date-range-selector.qmd @@ -46,7 +46,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_date_range.html#shiny.ui.input_date_range signature: "ui.input_date_range(id: str, label: TagChild, start: Optional = None, end: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', separator: str = ' to ', width: Optional = None, autoclose: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_date.py#L135-L269 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_date.py#L135-L269 --- :::{#component} diff --git a/components/inputs/date-selector.qmd b/components/inputs/date-selector.qmd index 978bcf6d..e2f0e508 100644 --- a/components/inputs/date-selector.qmd +++ b/components/inputs/date-selector.qmd @@ -43,7 +43,7 @@ listing: - title: ui.input_date href: https://shiny.posit.co/py/api/ui.input_date.html#shiny.ui.input_date signature: "ui.input_date(id: str, label: TagChild, value: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', width: Optional = None, autoclose: bool = True, datesdisabled: Optional = None, daysofweekdisabled: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_date.py#L17-L132 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_date.py#L17-L132 --- :::{#component} diff --git a/components/inputs/numeric-input.qmd b/components/inputs/numeric-input.qmd index bf4152c4..e2a4c27e 100644 --- a/components/inputs/numeric-input.qmd +++ b/components/inputs/numeric-input.qmd @@ -42,7 +42,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_numeric.html#shiny.ui.input_numeric signature: 'ui.input_numeric(id: str, label: TagChild, value: float, min: Optional = None, max: Optional = None, step: Optional = None, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_numeric.py#L12-L73 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_numeric.py#L12-L73 --- :::{#component} diff --git a/components/inputs/password-field.qmd b/components/inputs/password-field.qmd index 55c08ccf..2ee8238f 100644 --- a/components/inputs/password-field.qmd +++ b/components/inputs/password-field.qmd @@ -42,7 +42,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_password.html#shiny.ui.input_password signature: "ui.input_password(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_password.py#L12-L64 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_password.py#L12-L64 --- :::{#component} diff --git a/components/inputs/radio-buttons.qmd b/components/inputs/radio-buttons.qmd index 40176d86..1d151aeb 100644 --- a/components/inputs/radio-buttons.qmd +++ b/components/inputs/radio-buttons.qmd @@ -51,7 +51,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html#shiny.ui.input_radio_buttons signature: 'ui.input_radio_buttons(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_check_radio.py#L240-L307 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_check_radio.py#L240-L307 --- :::{#component} diff --git a/components/inputs/select-multiple.qmd b/components/inputs/select-multiple.qmd index 51f8345b..1d9e5dcb 100644 --- a/components/inputs/select-multiple.qmd +++ b/components/inputs/select-multiple.qmd @@ -54,7 +54,7 @@ listing: - title: ui.input_select href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_select.py#L111-L204 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/select-single.qmd b/components/inputs/select-single.qmd index 2ff117d2..48825041 100644 --- a/components/inputs/select-single.qmd +++ b/components/inputs/select-single.qmd @@ -54,7 +54,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_select.py#L111-L204 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-multiple.qmd b/components/inputs/selectize-multiple.qmd index 1547404a..98581edb 100644 --- a/components/inputs/selectize-multiple.qmd +++ b/components/inputs/selectize-multiple.qmd @@ -55,7 +55,7 @@ listing: - title: ui.input_selectize href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_select.py#L48-L108 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-single.qmd b/components/inputs/selectize-single.qmd index 9d6949d7..49ae558c 100644 --- a/components/inputs/selectize-single.qmd +++ b/components/inputs/selectize-single.qmd @@ -53,7 +53,7 @@ listing: - title: ui.input_selectize href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_select.py#L48-L108 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/slider-range.qmd b/components/inputs/slider-range.qmd index a21fdb3d..11e1868d 100644 --- a/components/inputs/slider-range.qmd +++ b/components/inputs/slider-range.qmd @@ -39,19 +39,19 @@ listing: - title: ui.input_slider href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_slider.py#L59-L234 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_slider.py#L59-L234 - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: render.data_frame href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L122-L207 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L122-L207 --- :::{#component} diff --git a/components/inputs/slider.qmd b/components/inputs/slider.qmd index 3b38eca5..7fdcb515 100644 --- a/components/inputs/slider.qmd +++ b/components/inputs/slider.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_slider href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_slider.py#L59-L234 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_slider.py#L59-L234 --- :::{#component} diff --git a/components/inputs/switch.qmd b/components/inputs/switch.qmd index ec20ca1e..2ee4f721 100644 --- a/components/inputs/switch.qmd +++ b/components/inputs/switch.qmd @@ -38,7 +38,7 @@ listing: - title: ui.input_switch href: https://shiny.posit.co/py/api/ui.input_switch.html#shiny.ui.input_switch signature: 'ui.input_switch(id: str, label: TagChild, value: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_check_radio.py#L88-L133 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_check_radio.py#L88-L133 --- :::{#component} diff --git a/components/inputs/text-area.qmd b/components/inputs/text-area.qmd index 16af4984..f90bc19d 100644 --- a/components/inputs/text-area.qmd +++ b/components/inputs/text-area.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_text_area href: https://shiny.posit.co/py/api/ui.input_text_area.html#shiny.ui.input_text_area signature: "ui.input_text_area(id: str, label: TagChild, value: str = '', width: Optional = None, height: Optional = None, cols: Optional = None, rows: Optional = None, placeholder: Optional = None, resize: Optional = None, autoresize: bool = False, autocomplete: Optional = None, spellcheck: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_text.py#L83-L187 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_text.py#L83-L187 --- :::{#component} diff --git a/components/inputs/text-box.qmd b/components/inputs/text-box.qmd index a0b896cb..85a6285d 100644 --- a/components/inputs/text-box.qmd +++ b/components/inputs/text-box.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_text href: https://shiny.posit.co/py/api/ui.input_text.html#shiny.ui.input_text signature: "ui.input_text(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None, autocomplete: Optional = 'off', spellcheck: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_input_text.py#L13-L80 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_text.py#L13-L80 --- :::{#component} diff --git a/components/outputs/data-grid.qmd b/components/outputs/data-grid.qmd index 0b1d6101..56634f65 100644 --- a/components/outputs/data-grid.qmd +++ b/components/outputs/data-grid.qmd @@ -34,15 +34,15 @@ listing: - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L258-L302 - title: render.DataGrid href: https://shiny.posit.co/py/api/render.DataGrid.html#shiny.render.DataGrid signature: "render.DataGrid(data: object, width: str | float | None = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Literal = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L36-L119 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L36-L119 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/datatable.qmd b/components/outputs/datatable.qmd index af18fdf5..167b9db2 100644 --- a/components/outputs/datatable.qmd +++ b/components/outputs/datatable.qmd @@ -33,15 +33,15 @@ listing: - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_dataframe.py#L122-L207 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L122-L207 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/image.qmd b/components/outputs/image.qmd index ee6a1854..65f5510b 100644 --- a/components/outputs/image.qmd +++ b/components/outputs/image.qmd @@ -35,12 +35,12 @@ listing: - title: ui.output_image href: https://shiny.posit.co/py/api/ui.output_image.html#shiny.ui.output_image signature: "ui.output_image(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool = False)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L123-L234 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L123-L234 - title: '@render.image' href: https://shiny.posit.co/py/api/render.image.html#shiny.render.image signature: 'render.image(delete_file: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L341-L371 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L341-L371 --- :::{#component} diff --git a/components/outputs/plot-matplotlib.qmd b/components/outputs/plot-matplotlib.qmd index bf37c64c..a2bbbcb4 100644 --- a/components/outputs/plot-matplotlib.qmd +++ b/components/outputs/plot-matplotlib.qmd @@ -42,11 +42,11 @@ listing: - title: ui.output_plot href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L33-L120 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L33-L120 - title: '@render.plot' href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L237-L298 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L237-L298 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/plot-seaborn.qmd b/components/outputs/plot-seaborn.qmd index 7475327b..947140cf 100644 --- a/components/outputs/plot-seaborn.qmd +++ b/components/outputs/plot-seaborn.qmd @@ -40,12 +40,12 @@ listing: - title: ui.output_plot href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L33-L120 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L33-L120 - title: '@render.plot' href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L237-L298 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L237-L298 --- :::{#component} diff --git a/components/outputs/text.qmd b/components/outputs/text.qmd index 1a86997b..0dfd80c0 100644 --- a/components/outputs/text.qmd +++ b/components/outputs/text.qmd @@ -44,11 +44,11 @@ listing: - title: ui.output_text href: https://shiny.posit.co/py/api/ui.output_text.html#shiny.ui.output_text signature: 'ui.output_text(id: str, inline: bool = False, container: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L237-L270 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L237-L270 - title: '@render.text' href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text signature: render.text() - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L77-L98 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/ui.qmd b/components/outputs/ui.qmd index 263df969..0e168f89 100644 --- a/components/outputs/ui.qmd +++ b/components/outputs/ui.qmd @@ -39,11 +39,11 @@ listing: - title: ui.output_ui href: https://shiny.posit.co/py/api/ui.output_ui.html#shiny.ui.output_ui signature: 'ui.output_ui(id: str, inline: bool = False, container: Optional = None, fill: bool = False, fillable: bool = False, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L332-L379 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L332-L379 - title: '@render.ui' href: https://shiny.posit.co/py/api/render.ui.html#shiny.render.ui signature: render.ui() - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L540-L562 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L540-L562 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/value-box.qmd b/components/outputs/value-box.qmd index 8e6579df..5585d140 100644 --- a/components/outputs/value-box.qmd +++ b/components/outputs/value-box.qmd @@ -296,11 +296,11 @@ listing: - title: ui.value_box href: https://shiny.posit.co/py/api/ui.value_box.html#shiny.ui.value_box signature: "ui.value_box(title: TagChild, *args: TagChild | TagAttrs = (), showcase: Optional = None, showcase_layout: SHOWCASE_LAYOUTS_STR | ShowcaseLayout = 'left center', theme: Optional = None, full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})" - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_valuebox.py#L296-L459 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_valuebox.py#L296-L459 - title: ui.card href: https://shiny.posit.co/py/api/ui.card.html#shiny.ui.card signature: 'ui.card(*args: TagChild | TagAttrs | CardItem = (), full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_card.py#L45-L104 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_card.py#L45-L104 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/verbatim-text.qmd b/components/outputs/verbatim-text.qmd index 2dccf088..f4b0debb 100644 --- a/components/outputs/verbatim-text.qmd +++ b/components/outputs/verbatim-text.qmd @@ -42,11 +42,11 @@ listing: - title: ui.output_text_verbatim href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html#shiny.ui.output_text_verbatim signature: 'ui.output_text_verbatim(id: str, placeholder: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/ui/_output.py#L273-L306 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L273-L306 - title: '@render.text' href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text signature: render.text() - github: https://github.com/posit-dev/py-shiny/blob/0e60bf8/shiny/render/_render.py#L77-L98 + github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: From cf46ea2b1c61d53ed083b8b41d46bd7d1ed3e4ff Mon Sep 17 00:00:00 2001 From: Barret Schloerke Date: Wed, 20 Dec 2023 16:55:29 -0500 Subject: [PATCH 21/22] Set the github sha to the py-shiny repo --- scripts/_add_objects_func_info.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/_add_objects_func_info.py b/scripts/_add_objects_func_info.py index 5525c5cd..6b710cef 100644 --- a/scripts/_add_objects_func_info.py +++ b/scripts/_add_objects_func_info.py @@ -88,7 +88,7 @@ def render(self, el: ds.DocstringSectionParameters): def get_git_revision_short_hash() -> str: return ( - subprocess.check_output(["git", "rev-parse", "--short", "HEAD"]) + subprocess.check_output(["git", "rev-parse", "--short", "HEAD"], cwd="py-shiny") .decode("ascii") .strip() ) @@ -96,7 +96,7 @@ def get_git_revision_short_hash() -> str: def get_git_current_tag() -> str: return ( - subprocess.check_output(["git", "tag", "--points-at", "HEAD"]) + subprocess.check_output(["git", "tag", "--points-at", "HEAD"], cwd="py-shiny") .decode("ascii") .strip() ) From e2b1c52d12eb1e70414b3284e41328a4d7fcfd52 Mon Sep 17 00:00:00 2001 From: schloerke Date: Wed, 20 Dec 2023 21:58:26 +0000 Subject: [PATCH 22/22] `make quartodoc` (GitHub Actions) --- components/display-messages/modal.qmd | 8 ++++---- components/display-messages/notifications.qmd | 4 ++-- components/display-messages/progress-bar.qmd | 2 +- components/display-messages/tooltips.qmd | 4 ++-- components/inputs/action-button.qmd | 4 ++-- components/inputs/action-link.qmd | 4 ++-- components/inputs/checkbox-group.qmd | 2 +- components/inputs/checkbox.qmd | 2 +- components/inputs/date-range-selector.qmd | 2 +- components/inputs/date-selector.qmd | 2 +- components/inputs/numeric-input.qmd | 2 +- components/inputs/password-field.qmd | 2 +- components/inputs/radio-buttons.qmd | 2 +- components/inputs/select-multiple.qmd | 2 +- components/inputs/select-single.qmd | 2 +- components/inputs/selectize-multiple.qmd | 2 +- components/inputs/selectize-single.qmd | 2 +- components/inputs/slider-range.qmd | 8 ++++---- components/inputs/slider.qmd | 2 +- components/inputs/switch.qmd | 2 +- components/inputs/text-area.qmd | 2 +- components/inputs/text-box.qmd | 2 +- components/outputs/data-grid.qmd | 6 +++--- components/outputs/datatable.qmd | 6 +++--- components/outputs/image.qmd | 4 ++-- components/outputs/plot-matplotlib.qmd | 4 ++-- components/outputs/plot-seaborn.qmd | 4 ++-- components/outputs/text.qmd | 4 ++-- components/outputs/ui.qmd | 4 ++-- components/outputs/value-box.qmd | 4 ++-- components/outputs/verbatim-text.qmd | 4 ++-- 31 files changed, 52 insertions(+), 52 deletions(-) diff --git a/components/display-messages/modal.qmd b/components/display-messages/modal.qmd index 77682d4d..265a3042 100644 --- a/components/display-messages/modal.qmd +++ b/components/display-messages/modal.qmd @@ -50,19 +50,19 @@ listing: - title: ui.modal href: https://shiny.posit.co/py/api/ui.modal.html#shiny.ui.modal signature: "ui.modal(*args: TagChild | TagAttrs = (), title: Optional = None, footer: TagChild | MISSING_TYPE = MISSING, size: Literal = 'm', easy_close: bool = False, fade: bool = True, **kwargs: TagAttrValue = {})" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_modal.py#L60-L156 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_modal.py#L60-L156 - title: ui.modal_show href: https://shiny.posit.co/py/api/ui.modal_show.html#shiny.ui.modal_show signature: 'ui.modal_show(modal: Tag, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_modal.py#L159-L185 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_modal.py#L159-L185 - title: ui.modal_remove href: https://shiny.posit.co/py/api/ui.modal_remove.html#shiny.ui.modal_remove signature: 'ui.modal_remove(session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_modal.py#L188-L212 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_modal.py#L188-L212 - title: ui.modal_button href: https://shiny.posit.co/py/api/ui.modal_button.html#shiny.ui.modal_button signature: 'ui.modal_button(label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_modal.py#L19-L57 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_modal.py#L19-L57 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/notifications.qmd b/components/display-messages/notifications.qmd index 27827a82..d35c51fb 100644 --- a/components/display-messages/notifications.qmd +++ b/components/display-messages/notifications.qmd @@ -66,11 +66,11 @@ listing: - title: ui.notification_show href: https://shiny.posit.co/py/api/ui.notification_show.html#shiny.ui.notification_show signature: "ui.notification_show(ui: TagChild, action: Optional = None, duration: Optional = 5, close_button: bool = True, id: Optional = None, type: Literal = 'default', session: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_notification.py#L14-L90 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_notification.py#L14-L90 - title: ui.notification_remove href: https://shiny.posit.co/py/api/ui.notification_remove.html#shiny.ui.notification_remove signature: 'ui.notification_remove(id: str, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_notification.py#L93-L125 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_notification.py#L93-L125 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/display-messages/progress-bar.qmd b/components/display-messages/progress-bar.qmd index d988d91a..39d9a242 100644 --- a/components/display-messages/progress-bar.qmd +++ b/components/display-messages/progress-bar.qmd @@ -68,7 +68,7 @@ listing: - title: ui.Progress href: https://shiny.posit.co/py/api/ui.Progress.html#shiny.ui.Progress signature: 'ui.Progress(min: int = 0, max: int = 1, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_progress.py#L14-L167 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_progress.py#L14-L167 - title: ui.Progress.close href: https://shiny.posit.co/py/api/ui.Progress.html signature: ui.Progress.close(self) diff --git a/components/display-messages/tooltips.qmd b/components/display-messages/tooltips.qmd index 506f77f3..76cca5c6 100644 --- a/components/display-messages/tooltips.qmd +++ b/components/display-messages/tooltips.qmd @@ -51,11 +51,11 @@ listing: - title: ui.tooltip href: https://shiny.posit.co/py/api/ui.tooltip.html#shiny.ui.tooltip signature: "ui.tooltip(trigger: TagChild, *args: TagChild | TagAttrs = (), id: Optional = None, placement: Literal = 'auto', options: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_tooltip.py#L13-L154 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_tooltip.py#L13-L154 - title: ui.update_tooltip href: https://shiny.posit.co/py/api/ui.update_tooltip.html#shiny.ui.update_tooltip signature: 'ui.update_tooltip(id: str, *args: TagChild = (), show: Optional = None, session: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_update.py#L904-L946 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_update.py#L904-L946 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/action-button.qmd b/components/inputs/action-button.qmd index 0e421b6f..cf3df7ea 100644 --- a/components/inputs/action-button.qmd +++ b/components/inputs/action-button.qmd @@ -41,12 +41,12 @@ listing: - title: ui.input_action_button href: https://shiny.posit.co/py/api/ui.input_action_button.html#shiny.ui.input_action_button signature: 'ui.input_action_button(id: str, label: TagChild, icon: TagChild = None, width: Optional = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_action_button.py#L11-L65 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_action_button.py#L11-L65 - title: reactive.event href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/reactive/_reactives.py#L736-L871 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/action-link.qmd b/components/inputs/action-link.qmd index 95e16624..cec4d6cb 100644 --- a/components/inputs/action-link.qmd +++ b/components/inputs/action-link.qmd @@ -41,12 +41,12 @@ listing: - title: ui.input_action_link href: https://shiny.posit.co/py/api/ui.input_action_link.html#shiny.ui.input_action_link signature: 'ui.input_action_link(id: str, label: TagChild, icon: TagChild = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_action_button.py#L68-L115 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_action_button.py#L68-L115 - title: reactive.event href: https://shiny.posit.co/py/api/reactive.event.html#shiny.reactive.event signature: 'reactive.event(*args: Callable[[], object] | Callable[[], Awaitable[object]] = (), ignore_none: bool = True, ignore_init: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/reactive/_reactives.py#L736-L871 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/reactive/_reactives.py#L736-L871 --- :::{#component} diff --git a/components/inputs/checkbox-group.qmd b/components/inputs/checkbox-group.qmd index 91187d15..d0dc786a 100644 --- a/components/inputs/checkbox-group.qmd +++ b/components/inputs/checkbox-group.qmd @@ -56,7 +56,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_checkbox_group.html#shiny.ui.input_checkbox_group signature: 'ui.input_checkbox_group(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_check_radio.py#L169-L237 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_check_radio.py#L169-L237 --- :::{#component} diff --git a/components/inputs/checkbox.qmd b/components/inputs/checkbox.qmd index 12e6392f..1532c122 100644 --- a/components/inputs/checkbox.qmd +++ b/components/inputs/checkbox.qmd @@ -39,7 +39,7 @@ listing: - title: ui.input_checkbox() href: https://shiny.posit.co/py/api/ui.input_checkbox.html#shiny.ui.input_checkbox signature: 'ui.input_checkbox(id: str, label: TagChild, value: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_check_radio.py#L32-L85 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_check_radio.py#L32-L85 --- :::{#component} diff --git a/components/inputs/date-range-selector.qmd b/components/inputs/date-range-selector.qmd index a3e12a11..c874069a 100644 --- a/components/inputs/date-range-selector.qmd +++ b/components/inputs/date-range-selector.qmd @@ -46,7 +46,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_date_range.html#shiny.ui.input_date_range signature: "ui.input_date_range(id: str, label: TagChild, start: Optional = None, end: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', separator: str = ' to ', width: Optional = None, autoclose: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_date.py#L135-L269 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_date.py#L135-L269 --- :::{#component} diff --git a/components/inputs/date-selector.qmd b/components/inputs/date-selector.qmd index e2f0e508..07512c9f 100644 --- a/components/inputs/date-selector.qmd +++ b/components/inputs/date-selector.qmd @@ -43,7 +43,7 @@ listing: - title: ui.input_date href: https://shiny.posit.co/py/api/ui.input_date.html#shiny.ui.input_date signature: "ui.input_date(id: str, label: TagChild, value: Optional = None, min: Optional = None, max: Optional = None, format: str = 'yyyy-mm-dd', startview: str = 'month', weekstart: int = 0, language: str = 'en', width: Optional = None, autoclose: bool = True, datesdisabled: Optional = None, daysofweekdisabled: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_date.py#L17-L132 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_date.py#L17-L132 --- :::{#component} diff --git a/components/inputs/numeric-input.qmd b/components/inputs/numeric-input.qmd index e2a4c27e..c03b45a7 100644 --- a/components/inputs/numeric-input.qmd +++ b/components/inputs/numeric-input.qmd @@ -42,7 +42,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_numeric.html#shiny.ui.input_numeric signature: 'ui.input_numeric(id: str, label: TagChild, value: float, min: Optional = None, max: Optional = None, step: Optional = None, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_numeric.py#L12-L73 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_numeric.py#L12-L73 --- :::{#component} diff --git a/components/inputs/password-field.qmd b/components/inputs/password-field.qmd index 2ee8238f..d7ebb4f1 100644 --- a/components/inputs/password-field.qmd +++ b/components/inputs/password-field.qmd @@ -42,7 +42,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_password.html#shiny.ui.input_password signature: "ui.input_password(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_password.py#L12-L64 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_password.py#L12-L64 --- :::{#component} diff --git a/components/inputs/radio-buttons.qmd b/components/inputs/radio-buttons.qmd index 1d151aeb..21c036bf 100644 --- a/components/inputs/radio-buttons.qmd +++ b/components/inputs/radio-buttons.qmd @@ -51,7 +51,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_radio_buttons.html#shiny.ui.input_radio_buttons signature: 'ui.input_radio_buttons(id: str, label: TagChild, choices: ChoicesArg, selected: Optional = None, inline: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_check_radio.py#L240-L307 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_check_radio.py#L240-L307 --- :::{#component} diff --git a/components/inputs/select-multiple.qmd b/components/inputs/select-multiple.qmd index 1d9e5dcb..24d66cc9 100644 --- a/components/inputs/select-multiple.qmd +++ b/components/inputs/select-multiple.qmd @@ -54,7 +54,7 @@ listing: - title: ui.input_select href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_select.py#L111-L204 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/select-single.qmd b/components/inputs/select-single.qmd index 48825041..40212270 100644 --- a/components/inputs/select-single.qmd +++ b/components/inputs/select-single.qmd @@ -54,7 +54,7 @@ listing: href: https://shiny.posit.co/py/api/ui.input_select.html#shiny.ui.input_select signature: 'ui.input_select(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, selectize: bool = False, width: Optional = None, size: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_select.py#L111-L204 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_select.py#L111-L204 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-multiple.qmd b/components/inputs/selectize-multiple.qmd index 98581edb..3db5e1bf 100644 --- a/components/inputs/selectize-multiple.qmd +++ b/components/inputs/selectize-multiple.qmd @@ -55,7 +55,7 @@ listing: - title: ui.input_selectize href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_select.py#L48-L108 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/selectize-single.qmd b/components/inputs/selectize-single.qmd index 49ae558c..028c13fa 100644 --- a/components/inputs/selectize-single.qmd +++ b/components/inputs/selectize-single.qmd @@ -53,7 +53,7 @@ listing: - title: ui.input_selectize href: https://shiny.posit.co/py/api/ui.input_selectize.html#shiny.ui.input_selectize signature: 'ui.input_selectize(id: str, label: TagChild, choices: SelectChoicesArg, selected: Optional = None, multiple: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_select.py#L48-L108 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_select.py#L48-L108 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/inputs/slider-range.qmd b/components/inputs/slider-range.qmd index 11e1868d..1c9f7f28 100644 --- a/components/inputs/slider-range.qmd +++ b/components/inputs/slider-range.qmd @@ -39,19 +39,19 @@ listing: - title: ui.input_slider href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_slider.py#L59-L234 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_slider.py#L59-L234 - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: render.data_frame href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L122-L207 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_dataframe.py#L122-L207 --- :::{#component} diff --git a/components/inputs/slider.qmd b/components/inputs/slider.qmd index 7fdcb515..3af6f525 100644 --- a/components/inputs/slider.qmd +++ b/components/inputs/slider.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_slider href: https://shiny.posit.co/py/api/ui.input_slider.html#shiny.ui.input_slider signature: "ui.input_slider(id: str, label: TagChild, min: SliderValueArg, max: SliderValueArg, value: SliderValueArg | Iterable[SliderValueArg], step: Optional = None, ticks: bool = False, animate: bool | AnimationOptions = False, width: Optional = None, sep: str = ',', pre: Optional = None, post: Optional = None, time_format: Optional = None, timezone: Optional = None, drag_range: bool = True)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_slider.py#L59-L234 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_slider.py#L59-L234 --- :::{#component} diff --git a/components/inputs/switch.qmd b/components/inputs/switch.qmd index 2ee4f721..9f7d08a7 100644 --- a/components/inputs/switch.qmd +++ b/components/inputs/switch.qmd @@ -38,7 +38,7 @@ listing: - title: ui.input_switch href: https://shiny.posit.co/py/api/ui.input_switch.html#shiny.ui.input_switch signature: 'ui.input_switch(id: str, label: TagChild, value: bool = False, width: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_check_radio.py#L88-L133 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_check_radio.py#L88-L133 --- :::{#component} diff --git a/components/inputs/text-area.qmd b/components/inputs/text-area.qmd index f90bc19d..c07bfa66 100644 --- a/components/inputs/text-area.qmd +++ b/components/inputs/text-area.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_text_area href: https://shiny.posit.co/py/api/ui.input_text_area.html#shiny.ui.input_text_area signature: "ui.input_text_area(id: str, label: TagChild, value: str = '', width: Optional = None, height: Optional = None, cols: Optional = None, rows: Optional = None, placeholder: Optional = None, resize: Optional = None, autoresize: bool = False, autocomplete: Optional = None, spellcheck: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_text.py#L83-L187 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_text.py#L83-L187 --- :::{#component} diff --git a/components/inputs/text-box.qmd b/components/inputs/text-box.qmd index 85a6285d..08f12816 100644 --- a/components/inputs/text-box.qmd +++ b/components/inputs/text-box.qmd @@ -41,7 +41,7 @@ listing: - title: ui.input_text href: https://shiny.posit.co/py/api/ui.input_text.html#shiny.ui.input_text signature: "ui.input_text(id: str, label: TagChild, value: str = '', width: Optional = None, placeholder: Optional = None, autocomplete: Optional = 'off', spellcheck: Optional = None)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_input_text.py#L13-L80 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_input_text.py#L13-L80 --- :::{#component} diff --git a/components/outputs/data-grid.qmd b/components/outputs/data-grid.qmd index 56634f65..214c1979 100644 --- a/components/outputs/data-grid.qmd +++ b/components/outputs/data-grid.qmd @@ -34,15 +34,15 @@ listing: - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_dataframe.py#L258-L302 - title: render.DataGrid href: https://shiny.posit.co/py/api/render.DataGrid.html#shiny.render.DataGrid signature: "render.DataGrid(data: object, width: str | float | None = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Literal = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L36-L119 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_dataframe.py#L36-L119 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/datatable.qmd b/components/outputs/datatable.qmd index 167b9db2..1a3c76cd 100644 --- a/components/outputs/datatable.qmd +++ b/components/outputs/datatable.qmd @@ -33,15 +33,15 @@ listing: - title: ui.output_data_frame href: https://shiny.posit.co/py/api/ui.output_data_frame.html#shiny.ui.output_data_frame signature: 'ui.output_data_frame(id: str)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/dataframe/_dataframe.py#L12-L39 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/dataframe/_dataframe.py#L12-L39 - title: '@render.data_frame' href: https://shiny.posit.co/py/api/render.data_frame.html#shiny.render.data_frame signature: render.data_frame() - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L258-L302 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_dataframe.py#L258-L302 - title: render.DataTable href: https://shiny.posit.co/py/api/render.DataTable.html#shiny.render.DataTable signature: "render.DataTable(data: object, width: Union = 'fit-content', height: Union = '500px', summary: Union = True, filters: bool = False, row_selection_mode: Union = 'none')" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_dataframe.py#L122-L207 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_dataframe.py#L122-L207 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/image.qmd b/components/outputs/image.qmd index 65f5510b..99348591 100644 --- a/components/outputs/image.qmd +++ b/components/outputs/image.qmd @@ -35,12 +35,12 @@ listing: - title: ui.output_image href: https://shiny.posit.co/py/api/ui.output_image.html#shiny.ui.output_image signature: "ui.output_image(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool = False)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L123-L234 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_output.py#L123-L234 - title: '@render.image' href: https://shiny.posit.co/py/api/render.image.html#shiny.render.image signature: 'render.image(delete_file: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L341-L371 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_render.py#L341-L371 --- :::{#component} diff --git a/components/outputs/plot-matplotlib.qmd b/components/outputs/plot-matplotlib.qmd index a2bbbcb4..08887c05 100644 --- a/components/outputs/plot-matplotlib.qmd +++ b/components/outputs/plot-matplotlib.qmd @@ -42,11 +42,11 @@ listing: - title: ui.output_plot href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L33-L120 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_output.py#L33-L120 - title: '@render.plot' href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L237-L298 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_render.py#L237-L298 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/plot-seaborn.qmd b/components/outputs/plot-seaborn.qmd index 947140cf..c7538eee 100644 --- a/components/outputs/plot-seaborn.qmd +++ b/components/outputs/plot-seaborn.qmd @@ -40,12 +40,12 @@ listing: - title: ui.output_plot href: https://shiny.posit.co/py/api/ui.output_plot.html#shiny.ui.output_plot signature: "ui.output_plot(id: str, width: str | float | int = '100%', height: str | float | int = '400px', inline: bool = False, click: bool | ClickOpts = False, dblclick: bool | DblClickOpts = False, hover: bool | HoverOpts = False, brush: bool | BrushOpts = False, fill: bool | MISSING_TYPE = MISSING)" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L33-L120 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_output.py#L33-L120 - title: '@render.plot' href: https://shiny.posit.co/py/api/render.plot.html#shiny.render.plot signature: 'render.plot(alt: Optional = None, width: float | None | MISSING_TYPE = MISSING, height: float | None | MISSING_TYPE = MISSING, **kwargs: Any = {})' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L237-L298 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_render.py#L237-L298 --- :::{#component} diff --git a/components/outputs/text.qmd b/components/outputs/text.qmd index 0dfd80c0..d43e56e7 100644 --- a/components/outputs/text.qmd +++ b/components/outputs/text.qmd @@ -44,11 +44,11 @@ listing: - title: ui.output_text href: https://shiny.posit.co/py/api/ui.output_text.html#shiny.ui.output_text signature: 'ui.output_text(id: str, inline: bool = False, container: Optional = None)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L237-L270 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_output.py#L237-L270 - title: '@render.text' href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text signature: render.text() - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L77-L98 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/ui.qmd b/components/outputs/ui.qmd index 0e168f89..e6966743 100644 --- a/components/outputs/ui.qmd +++ b/components/outputs/ui.qmd @@ -39,11 +39,11 @@ listing: - title: ui.output_ui href: https://shiny.posit.co/py/api/ui.output_ui.html#shiny.ui.output_ui signature: 'ui.output_ui(id: str, inline: bool = False, container: Optional = None, fill: bool = False, fillable: bool = False, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L332-L379 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_output.py#L332-L379 - title: '@render.ui' href: https://shiny.posit.co/py/api/render.ui.html#shiny.render.ui signature: render.ui() - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L540-L562 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_render.py#L540-L562 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/value-box.qmd b/components/outputs/value-box.qmd index 5585d140..788bbf43 100644 --- a/components/outputs/value-box.qmd +++ b/components/outputs/value-box.qmd @@ -296,11 +296,11 @@ listing: - title: ui.value_box href: https://shiny.posit.co/py/api/ui.value_box.html#shiny.ui.value_box signature: "ui.value_box(title: TagChild, *args: TagChild | TagAttrs = (), showcase: Optional = None, showcase_layout: SHOWCASE_LAYOUTS_STR | ShowcaseLayout = 'left center', theme: Optional = None, full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})" - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_valuebox.py#L296-L459 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_valuebox.py#L296-L459 - title: ui.card href: https://shiny.posit.co/py/api/ui.card.html#shiny.ui.card signature: 'ui.card(*args: TagChild | TagAttrs | CardItem = (), full_screen: bool = False, height: Optional = None, fill: bool = True, class_: Optional = None, **kwargs: TagAttrValue = {})' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_card.py#L45-L104 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_card.py#L45-L104 - id: variations template: ../_partials/components-variations.ejs contents: diff --git a/components/outputs/verbatim-text.qmd b/components/outputs/verbatim-text.qmd index f4b0debb..08c7abde 100644 --- a/components/outputs/verbatim-text.qmd +++ b/components/outputs/verbatim-text.qmd @@ -42,11 +42,11 @@ listing: - title: ui.output_text_verbatim href: https://shiny.posit.co/py/api/ui.output_text_verbatim.html#shiny.ui.output_text_verbatim signature: 'ui.output_text_verbatim(id: str, placeholder: bool = False)' - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/ui/_output.py#L273-L306 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/ui/_output.py#L273-L306 - title: '@render.text' href: https://shiny.posit.co/py/api/render.text.html#shiny.render.text signature: render.text() - github: https://github.com/posit-dev/py-shiny/blob/fb1e525/shiny/render/_render.py#L77-L98 + github: https://github.com/posit-dev/py-shiny/blob/a0df2ed/shiny/render/_render.py#L77-L98 - id: variations template: ../_partials/components-variations.ejs contents: