From bb9ad4259cf9e000c1d5ba7bd64fc721b191039e Mon Sep 17 00:00:00 2001 From: Rane <60792108+Elijahrane@users.noreply.github.com> Date: Sun, 13 Mar 2022 21:02:55 -0400 Subject: [PATCH] Diseases (#7057) * Disease system first pass * Renamed HealthChange * First working version of diseases (wtf???) * Fix the cursed yaml initialization * Pop-Up effect * Generic status effect * Create copy of prototype * CureDiseaseEffect * Disease resistance * Spaceacillin * Nerf spaceacillin now that we know it works * Sneezing, Coughing, Snoughing * Fix queuing, prevent future issues * Disease protection * Disease outbreak event * Disease Reagent Cure * Chem cause disease effect * Disease artifacts * Try infect when interacting with diseased * Diseases don't have to be infectious * Talking without a mask does a snough * Temperature cure * Bedrest * DiseaseAdjustReagent * Tweak how disease statuses work to be a bit less shit * A few more diseases * Natural immunity (can't get the same disease twice) * Polished up some diseases, touched up spaceacillin production * Rebalanced transmission * Edit a few diseases, make disease cures support a minimum value * Nitrile gloves, more disease protection sources * Health scanner shows diseased status * Clean up disease system * Traitor item * Mouth swabs * Disease diagnoser machine * Support for clean samples * Vaccines + fixes * Pass on disease resistant clothes * More work on non-infectious diseases & vaccines * Handle dead bodies * Added the relatively CBT visualizer * Pass over diseases and their populators * Comment stuff * Readability cleanup * Add printing sound to diagnoser, fix printing bug * vaccinator sound, seal up some classes * Make disease protection equip detection not shit (thanks whoever wrote addaccentcomponent) * Mirror review * More review stuff * More mirror review stuff * Refactor snoughing * Redid report creator * Fix snough messages, new vaccinator sound * Mirror review naming * Woops, forgot the artifact * Add recipes and fills * Rebalance space cold and robovirus * Give lizarb disease interaction stuff * Tweak some stuff and move things around * Add diseases to mice (since animal vectors are interesting and can be used to make vaccines) * Remove unused reagent --- .../Disease/DiseaseMachineSystem.cs | 29 ++ .../Disease/DiseaseMachineVisualsComponent.cs | 15 + Content.Client/Entry/IgnoredComponents.cs | 9 + .../UI/HealthAnalyzerWindow.xaml.cs | 13 +- Content.Server/Chat/Managers/ChatManager.cs | 14 +- .../ReagentEffects/ChemCauseDisease.cs | 32 ++ .../ReagentEffects/ChemCureDisease.cs | 25 + .../Chemistry/ReagentEffects/HealthChange.cs | 2 - .../Components/DiseaseCarrierComponent.cs | 36 ++ .../Components/DiseaseDiagnoserComponent.cs | 9 + .../Components/DiseaseMachineComponent.cs | 31 ++ .../DiseaseMachineRunningComponent.cs | 9 + .../Components/DiseaseProtectionComponent.cs | 24 + .../Components/DiseaseSwabComponent.cs | 33 ++ .../Components/DiseaseVaccineComponent.cs | 33 ++ .../DiseaseVaccineCreatorComponent.cs | 10 + .../Disease/Cures/DiseaseBedrestCure.cs | 33 ++ .../Cures/DiseaseBodyTemperatureCure.cs | 34 ++ .../Disease/Cures/DiseaseJustWaitCure.cs | 31 ++ .../Disease/Cures/DiseaseReagentCure.cs | 38 ++ .../Disease/DiseaseDiagnosisSystem.cs | 415 ++++++++++++++++ Content.Server/Disease/DiseaseSystem.cs | 442 ++++++++++++++++++ .../Disease/Effects/DiseaseAdjustReagent.cs | 46 ++ .../Effects/DiseaseGenericStatusEffect.cs | 67 +++ .../Disease/Effects/DiseaseHealthChange.cs | 21 + .../Disease/Effects/DiseasePopUp.cs | 38 ++ .../Disease/Effects/DiseaseSnough.cs | 30 ++ Content.Server/Entry/IgnoredComponents.cs | 1 + .../Components/HealthAnalyzerComponent.cs | 16 + .../Medical/HealthAnalyzerSystem.cs | 20 + .../StationEvents/Events/DiseaseOutbreak.cs | 62 +++ .../StationEvents/Events/VentClog.cs | 2 +- .../Components/DiseaseArtifactComponent.cs | 37 ++ .../Effects/Systems/DiseaseArtifactSystem.cs | 63 +++ .../Reagent/ReagentEffectCondition.cs | 2 - Content.Shared/Disease/DiseaseCure.cs | 24 + Content.Shared/Disease/DiseaseEffect.cs | 29 ++ .../Disease/DiseaseMachineVisuals.cs | 16 + Content.Shared/Disease/DiseasePrototype.cs | 68 +++ Content.Shared/Disease/DiseasedComponent.cs | 12 + .../Audio/Machines/diagnoser_printing.ogg | Bin 0 -> 59000 bytes Resources/Audio/Machines/license.txt | 3 + .../Audio/Machines/vaccinator_running.ogg | Bin 0 -> 70344 bytes Resources/Locale/en-US/disease/diagnoser.ftl | 20 + Resources/Locale/en-US/disease/disease.ftl | 10 + Resources/Locale/en-US/disease/scanner.ftl | 4 + Resources/Locale/en-US/disease/swab.ftl | 5 + Resources/Locale/en-US/disease/vaccine.ftl | 3 + .../events/disease-outbreak.ftl | 1 + .../Catalog/Fills/Boxes/medical.yml | 12 +- .../Catalog/Fills/Crates/medical.yml | 6 + .../Catalog/Fills/Items/firstaidkits.yml | 2 + .../Catalog/Fills/Lockers/heads.yml | 5 +- .../Catalog/Research/technologies.yml | 2 + .../Prototypes/Catalog/uplink_catalog.yml | 8 + Resources/Prototypes/Damage/modifier_sets.yml | 11 +- Resources/Prototypes/Diseases/infectious.yml | 138 ++++++ .../Prototypes/Diseases/noninfectious.yml | 18 + .../Clothing/Hands/base_clothinghands.yml | 2 + .../Entities/Clothing/Hands/gloves.yml | 19 +- .../Clothing/Head/base_clothinghead.yml | 2 + .../Clothing/Head/hardsuit-helmets.yml | 2 + .../Entities/Clothing/Head/hoods.yml | 20 +- .../Entities/Clothing/Masks/masks.yml | 6 + .../OuterClothing/base_clothingouter.yml | 1 + .../Entities/Clothing/OuterClothing/bio.yml | 12 + .../Clothing/OuterClothing/hardsuits.yml | 2 + .../Entities/Clothing/Uniforms/jumpskirts.yml | 6 + .../Entities/Clothing/Uniforms/jumpsuits.yml | 16 +- .../Markers/Spawners/Random/artifacts.yml | 1 + .../Prototypes/Entities/Mobs/NPCs/animals.yml | 15 +- .../Entities/Mobs/Species/human.yml | 2 + .../Entities/Mobs/Species/reptilian.yml | 19 + .../Circuitboards/Machine/production.yml | 41 +- .../Objects/Specific/Medical/disease.yml | 30 ++ .../Objects/Specific/Medical/healing.yml | 13 + .../Specific/Medical/healthanalyzer.yml | 20 + .../Specific/Xenoarchaeology/artifacts.yml | 7 + .../Structures/Machines/disease_diagnoser.yml | 24 + .../Entities/Structures/Machines/lathe.yml | 4 +- .../Structures/Machines/vaccinator.yml | 26 ++ .../Structures/Storage/Tanks/tanks.yml | 2 +- Resources/Prototypes/Reagents/medicine.yml | 23 +- Resources/Prototypes/Reagents/toxins.yml | 17 + .../Prototypes/Recipes/Lathes/electronics.yml | 21 + .../Prototypes/Recipes/Reactions/medicine.yml | 22 + .../Specific/Medical/mouth_swab.rsi/icon.png | Bin 0 -> 227 bytes .../Specific/Medical/mouth_swab.rsi/meta.json | 15 + .../Machines/diagnoser.rsi/icon.png | Bin 0 -> 578 bytes .../Machines/diagnoser.rsi/meta.json | 52 +++ .../Machines/diagnoser.rsi/running.png | Bin 0 -> 1938 bytes .../Machines/diagnoser.rsi/unlit.png | Bin 0 -> 166 bytes .../Machines/vaccinator.rsi/icon.png | Bin 0 -> 642 bytes .../Machines/vaccinator.rsi/meta.json | 33 ++ .../Machines/vaccinator.rsi/running.png | Bin 0 -> 1181 bytes .../Machines/vaccinator.rsi/unlit.png | Bin 0 -> 174 bytes 96 files changed, 2555 insertions(+), 39 deletions(-) create mode 100644 Content.Client/Disease/DiseaseMachineSystem.cs create mode 100644 Content.Client/Disease/DiseaseMachineVisualsComponent.cs create mode 100644 Content.Server/Chemistry/ReagentEffects/ChemCauseDisease.cs create mode 100644 Content.Server/Chemistry/ReagentEffects/ChemCureDisease.cs create mode 100644 Content.Server/Disease/Components/DiseaseCarrierComponent.cs create mode 100644 Content.Server/Disease/Components/DiseaseDiagnoserComponent.cs create mode 100644 Content.Server/Disease/Components/DiseaseMachineComponent.cs create mode 100644 Content.Server/Disease/Components/DiseaseMachineRunningComponent.cs create mode 100644 Content.Server/Disease/Components/DiseaseProtectionComponent.cs create mode 100644 Content.Server/Disease/Components/DiseaseSwabComponent.cs create mode 100644 Content.Server/Disease/Components/DiseaseVaccineComponent.cs create mode 100644 Content.Server/Disease/Components/DiseaseVaccineCreatorComponent.cs create mode 100644 Content.Server/Disease/Cures/DiseaseBedrestCure.cs create mode 100644 Content.Server/Disease/Cures/DiseaseBodyTemperatureCure.cs create mode 100644 Content.Server/Disease/Cures/DiseaseJustWaitCure.cs create mode 100644 Content.Server/Disease/Cures/DiseaseReagentCure.cs create mode 100644 Content.Server/Disease/DiseaseDiagnosisSystem.cs create mode 100644 Content.Server/Disease/DiseaseSystem.cs create mode 100644 Content.Server/Disease/Effects/DiseaseAdjustReagent.cs create mode 100644 Content.Server/Disease/Effects/DiseaseGenericStatusEffect.cs create mode 100644 Content.Server/Disease/Effects/DiseaseHealthChange.cs create mode 100644 Content.Server/Disease/Effects/DiseasePopUp.cs create mode 100644 Content.Server/Disease/Effects/DiseaseSnough.cs create mode 100644 Content.Server/StationEvents/Events/DiseaseOutbreak.cs create mode 100644 Content.Server/Xenoarchaeology/XenoArtifacts/Effects/Components/DiseaseArtifactComponent.cs create mode 100644 Content.Server/Xenoarchaeology/XenoArtifacts/Effects/Systems/DiseaseArtifactSystem.cs create mode 100644 Content.Shared/Disease/DiseaseCure.cs create mode 100644 Content.Shared/Disease/DiseaseEffect.cs create mode 100644 Content.Shared/Disease/DiseaseMachineVisuals.cs create mode 100644 Content.Shared/Disease/DiseasePrototype.cs create mode 100644 Content.Shared/Disease/DiseasedComponent.cs create mode 100644 Resources/Audio/Machines/diagnoser_printing.ogg create mode 100644 Resources/Audio/Machines/license.txt create mode 100644 Resources/Audio/Machines/vaccinator_running.ogg create mode 100644 Resources/Locale/en-US/disease/diagnoser.ftl create mode 100644 Resources/Locale/en-US/disease/disease.ftl create mode 100644 Resources/Locale/en-US/disease/scanner.ftl create mode 100644 Resources/Locale/en-US/disease/swab.ftl create mode 100644 Resources/Locale/en-US/disease/vaccine.ftl create mode 100644 Resources/Locale/en-US/station-events/events/disease-outbreak.ftl create mode 100644 Resources/Prototypes/Diseases/infectious.yml create mode 100644 Resources/Prototypes/Diseases/noninfectious.yml create mode 100644 Resources/Prototypes/Entities/Objects/Specific/Medical/disease.yml create mode 100644 Resources/Prototypes/Entities/Structures/Machines/disease_diagnoser.yml create mode 100644 Resources/Prototypes/Entities/Structures/Machines/vaccinator.yml create mode 100644 Resources/Textures/Objects/Specific/Medical/mouth_swab.rsi/icon.png create mode 100644 Resources/Textures/Objects/Specific/Medical/mouth_swab.rsi/meta.json create mode 100644 Resources/Textures/Structures/Machines/diagnoser.rsi/icon.png create mode 100644 Resources/Textures/Structures/Machines/diagnoser.rsi/meta.json create mode 100644 Resources/Textures/Structures/Machines/diagnoser.rsi/running.png create mode 100644 Resources/Textures/Structures/Machines/diagnoser.rsi/unlit.png create mode 100644 Resources/Textures/Structures/Machines/vaccinator.rsi/icon.png create mode 100644 Resources/Textures/Structures/Machines/vaccinator.rsi/meta.json create mode 100644 Resources/Textures/Structures/Machines/vaccinator.rsi/running.png create mode 100644 Resources/Textures/Structures/Machines/vaccinator.rsi/unlit.png diff --git a/Content.Client/Disease/DiseaseMachineSystem.cs b/Content.Client/Disease/DiseaseMachineSystem.cs new file mode 100644 index 0000000000..b910a07874 --- /dev/null +++ b/Content.Client/Disease/DiseaseMachineSystem.cs @@ -0,0 +1,29 @@ +using Robust.Client.GameObjects; +using Content.Shared.Disease; + +namespace Content.Client.Disease +{ + /// + /// Controls client-side visuals for the + /// disease machines. + /// + public sealed class DiseaseMachineSystem : VisualizerSystem + { + protected override void OnAppearanceChange(EntityUid uid, DiseaseMachineVisualsComponent component, ref AppearanceChangeEvent args) + { + if (TryComp(uid, out SpriteComponent? sprite) + && args.Component.TryGetData(DiseaseMachineVisuals.IsOn, out bool isOn) + && args.Component.TryGetData(DiseaseMachineVisuals.IsRunning, out bool isRunning)) + { + var state = isRunning ? component.RunningState : component.IdleState; + sprite.LayerSetVisible(DiseaseMachineVisualLayers.IsOn, isOn); + sprite.LayerSetState(DiseaseMachineVisualLayers.IsRunning, state); + } + } + } +} +public enum DiseaseMachineVisualLayers : byte +{ + IsOn, + IsRunning +} diff --git a/Content.Client/Disease/DiseaseMachineVisualsComponent.cs b/Content.Client/Disease/DiseaseMachineVisualsComponent.cs new file mode 100644 index 0000000000..2194cd1c78 --- /dev/null +++ b/Content.Client/Disease/DiseaseMachineVisualsComponent.cs @@ -0,0 +1,15 @@ +namespace Content.Client.Disease; + +/// +/// Holds the idle and running state for machines to control +/// playing animtions on the client. +/// +[RegisterComponent] +public sealed class DiseaseMachineVisualsComponent : Component +{ + [DataField("idleState", required: true)] + public string IdleState = default!; + + [DataField("runningState", required: true)] + public string RunningState = default!; +} diff --git a/Content.Client/Entry/IgnoredComponents.cs b/Content.Client/Entry/IgnoredComponents.cs index 6dddd30c5e..13abf71dce 100644 --- a/Content.Client/Entry/IgnoredComponents.cs +++ b/Content.Client/Entry/IgnoredComponents.cs @@ -37,6 +37,10 @@ namespace Content.Client.Entry "Healing", "Material", "RandomAppearance", + "DiseaseProtection", + "DiseaseDiagnoser", + "DiseaseVaccine", + "DiseaseVaccineCreator", "Mineable", "RangedMagazine", "Ammo", @@ -47,12 +51,15 @@ namespace Content.Client.Entry "ResearchClient", "IdCardConsole", "ThermalRegulator", + "DiseaseMachineRunning", + "DiseaseMachine", "AtmosFixMarker", "CablePlacer", "Drink", "Food", "DeployableBarrier", "MagicMirror", + "DiseaseSwab", "FloorTile", "RandomInsulation", "Electrified", @@ -62,6 +69,7 @@ namespace Content.Client.Entry "Bloodstream", "TransformableContainer", "Mind", + "DiseaseCarrier", "StorageFill", "Mop", "Bucket", @@ -122,6 +130,7 @@ namespace Content.Client.Entry "RCD", "RCDAmmo", "CursedEntityStorage", + "DiseaseArtifact", "Radio", "GasArtifact", "SentienceTarget", diff --git a/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs b/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs index 7d7bbc1232..25165ae0de 100644 --- a/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs +++ b/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs @@ -3,6 +3,7 @@ using Robust.Client.AutoGenerated; using Robust.Client.UserInterface.CustomControls; using Robust.Client.UserInterface.XAML; using Content.Shared.Damage.Prototypes; +using Content.Shared.Disease.Components; using Content.Shared.FixedPoint; using Robust.Shared.Prototypes; using Content.Shared.Damage; @@ -35,7 +36,17 @@ namespace Content.Client.HealthAnalyzer.UI text.Append($"{Loc.GetString("health-analyzer-window-entity-health-text", ("entityName", entityName))}\n"); - text.Append($"{Loc.GetString("health-analyzer-window-entity-damage-total-text", ("amount", damageable.TotalDamage))}\n"); + /// Status Effects / Components + if (entities.HasComponent(msg.TargetEntity)) + { + text.Append($"{Loc.GetString("disease-scanner-diseased")}\n"); + }else + { + text.Append($"{Loc.GetString("disease-scanner-not-diseased")}\n"); + } + + /// Damage + text.Append($"\n{Loc.GetString("health-analyzer-window-entity-damage-total-text", ("amount", damageable.TotalDamage))}\n"); HashSet shownTypes = new(); diff --git a/Content.Server/Chat/Managers/ChatManager.cs b/Content.Server/Chat/Managers/ChatManager.cs index b715facfd7..1062314871 100644 --- a/Content.Server/Chat/Managers/ChatManager.cs +++ b/Content.Server/Chat/Managers/ChatManager.cs @@ -1,5 +1,3 @@ -using System; -using System.Collections.Generic; using System.Linq; using System.Text; using Content.Server.Administration.Logs; @@ -10,6 +8,9 @@ using Content.Server.MoMMI; using Content.Server.Players; using Content.Server.Preferences.Managers; using Content.Server.Radio.EntitySystems; +using Content.Server.Disease; +using Content.Server.Disease.Components; +using Content.Shared.Disease.Components; using Content.Shared.ActionBlocker; using Content.Shared.Administration; using Content.Shared.CCVar; @@ -22,10 +23,6 @@ using Robust.Server.Player; using Robust.Shared.Audio; using Robust.Shared.Configuration; using Robust.Shared.Console; -using Robust.Shared.GameObjects; -using Robust.Shared.IoC; -using Robust.Shared.Localization; -using Robust.Shared.Log; using Robust.Shared.Network; using Robust.Shared.Player; using Robust.Shared.Players; @@ -208,6 +205,11 @@ namespace Content.Server.Chat.Managers return; } + if (_entManager.HasComponent(source) && _entManager.TryGetComponent(source,out var carrier)) + { + EntitySystem.Get().SneezeCough(source, _random.Pick(carrier.Diseases), string.Empty); + } + if (MessageCharacterLimit(source, message)) { return; diff --git a/Content.Server/Chemistry/ReagentEffects/ChemCauseDisease.cs b/Content.Server/Chemistry/ReagentEffects/ChemCauseDisease.cs new file mode 100644 index 0000000000..33a80795a4 --- /dev/null +++ b/Content.Server/Chemistry/ReagentEffects/ChemCauseDisease.cs @@ -0,0 +1,32 @@ +using Content.Shared.Chemistry.Reagent; +using Content.Server.Disease; +using Content.Shared.Disease; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype; +using JetBrains.Annotations; + +namespace Content.Server.Chemistry.ReagentEffects +{ + /// + /// Default metabolism for medicine reagents. + /// + [UsedImplicitly] + public sealed class ChemCauseDisease : ReagentEffect + { + /// + /// Chance it has each tick to cause disease, between 0 and 1 + /// + [DataField("causeChance")] + public float CauseChance = 0.15f; + + /// + /// The disease to add. + /// + [DataField("disease", customTypeSerializer: typeof(PrototypeIdSerializer))] + [ViewVariables(VVAccess.ReadWrite)] + public string Disease = string.Empty; + public override void Effect(ReagentEffectArgs args) + { + EntitySystem.Get().TryAddDisease(null, null, Disease, args.SolutionEntity); + } + } +} diff --git a/Content.Server/Chemistry/ReagentEffects/ChemCureDisease.cs b/Content.Server/Chemistry/ReagentEffects/ChemCureDisease.cs new file mode 100644 index 0000000000..3f34d9c254 --- /dev/null +++ b/Content.Server/Chemistry/ReagentEffects/ChemCureDisease.cs @@ -0,0 +1,25 @@ +using Content.Shared.Chemistry.Reagent; +using Content.Server.Disease; +using JetBrains.Annotations; + +namespace Content.Server.Chemistry.ReagentEffects +{ + /// + /// Default metabolism for medicine reagents. + /// + [UsedImplicitly] + public sealed class ChemCureDisease : ReagentEffect + { + /// + /// Chance it has each tick to cure a disease, between 0 and 1 + /// + [DataField("cureChance")] + public float CureChance = 0.15f; + + public override void Effect(ReagentEffectArgs args) + { + var ev = new CureDiseaseAttemptEvent(CureChance); + args.EntityManager.EventBus.RaiseLocalEvent(args.SolutionEntity, ev, false); + } + } +} diff --git a/Content.Server/Chemistry/ReagentEffects/HealthChange.cs b/Content.Server/Chemistry/ReagentEffects/HealthChange.cs index 593bd1e1b0..5421aff454 100644 --- a/Content.Server/Chemistry/ReagentEffects/HealthChange.cs +++ b/Content.Server/Chemistry/ReagentEffects/HealthChange.cs @@ -1,7 +1,5 @@ using System.Text.Json.Serialization; using Content.Shared.Chemistry.Reagent; -using Robust.Shared.GameObjects; -using Robust.Shared.Serialization.Manager.Attributes; using Content.Shared.Damage; using Content.Shared.FixedPoint; using JetBrains.Annotations; diff --git a/Content.Server/Disease/Components/DiseaseCarrierComponent.cs b/Content.Server/Disease/Components/DiseaseCarrierComponent.cs new file mode 100644 index 0000000000..e9280235f3 --- /dev/null +++ b/Content.Server/Disease/Components/DiseaseCarrierComponent.cs @@ -0,0 +1,36 @@ +using System.Linq; +using Content.Shared.Disease; + +namespace Content.Server.Disease.Components +{ + [RegisterComponent] + /// + /// Allows the enity to be infected with diseases. + /// Please use only on mobs. + /// + public sealed class DiseaseCarrierComponent : Component + { + /// + /// Shows the CURRENT diseases on the carrier + /// + [ViewVariables(VVAccess.ReadWrite)] + public List Diseases = new(); + /// + /// The carrier's resistance to disease + /// + [DataField("diseaseResist")] + [ViewVariables(VVAccess.ReadWrite)] + public float DiseaseResist = 0f; + /// + /// Diseases the carrier has had, used for immunity. + /// + [ViewVariables(VVAccess.ReadWrite)] + public List PastDiseases = new(); + /// + /// All the diseases the carrier has or has had. + /// Checked against when trying to add a disease + /// + [ViewVariables(VVAccess.ReadWrite)] + public List AllDiseases => PastDiseases.Concat(Diseases).ToList(); + } +} diff --git a/Content.Server/Disease/Components/DiseaseDiagnoserComponent.cs b/Content.Server/Disease/Components/DiseaseDiagnoserComponent.cs new file mode 100644 index 0000000000..9b2acc8410 --- /dev/null +++ b/Content.Server/Disease/Components/DiseaseDiagnoserComponent.cs @@ -0,0 +1,9 @@ +namespace Content.Server.Disease.Components +{ + /// + /// To give the disease diagnosing machine specific behavior + /// + [RegisterComponent] + public sealed class DiseaseDiagnoserComponent : Component + {} +} diff --git a/Content.Server/Disease/Components/DiseaseMachineComponent.cs b/Content.Server/Disease/Components/DiseaseMachineComponent.cs new file mode 100644 index 0000000000..e0535635a9 --- /dev/null +++ b/Content.Server/Disease/Components/DiseaseMachineComponent.cs @@ -0,0 +1,31 @@ +using Content.Shared.Disease; +using Robust.Shared.Prototypes; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype; + +namespace Content.Server.Disease.Components +{ + [RegisterComponent] + /// + /// For shared behavior between both disease machines + /// + public sealed class DiseaseMachineComponent : Component + { + [DataField("delay")] + public float Delay = 5f; + /// + /// How much time we've accumulated processing + /// + [ViewVariables] + public float Accumulator = 0f; + /// + /// The disease prototype currently being diagnosed + /// + [ViewVariables] + public DiseasePrototype? Disease; + /// + /// What the machine will spawn + /// + [DataField("machineOutput", customTypeSerializer: typeof(PrototypeIdSerializer), required: true)] + public string MachineOutput = string.Empty; + } +} diff --git a/Content.Server/Disease/Components/DiseaseMachineRunningComponent.cs b/Content.Server/Disease/Components/DiseaseMachineRunningComponent.cs new file mode 100644 index 0000000000..0315bfbfa5 --- /dev/null +++ b/Content.Server/Disease/Components/DiseaseMachineRunningComponent.cs @@ -0,0 +1,9 @@ +namespace Content.Server.Disease.Components +{ + /// + /// For EntityQuery to keep track of which machines are running + /// + [RegisterComponent] + public sealed class DiseaseMachineRunningComponent : Component + {} +} diff --git a/Content.Server/Disease/Components/DiseaseProtectionComponent.cs b/Content.Server/Disease/Components/DiseaseProtectionComponent.cs new file mode 100644 index 0000000000..e99e4dacc5 --- /dev/null +++ b/Content.Server/Disease/Components/DiseaseProtectionComponent.cs @@ -0,0 +1,24 @@ +namespace Content.Server.Disease.Components +{ + /// + /// Value added to clothing to give its wearer + /// protection against infection from diseases + /// + [RegisterComponent] + public sealed class DiseaseProtectionComponent : Component + { + /// + /// Float value between 0 and 1, will be subtracted + /// from the infection chance (which is base 0.7) + /// Reference guide is a full biosuit w/gloves & mask + /// should add up to exactly 0.7 + /// + [DataField("protection")] + public float Protection = 0.1f; + /// + /// Is the component currently being worn and affecting someone's disease + /// resistance? Making the unequip check not totally CBT + /// + public bool IsActive = false; + } +} diff --git a/Content.Server/Disease/Components/DiseaseSwabComponent.cs b/Content.Server/Disease/Components/DiseaseSwabComponent.cs new file mode 100644 index 0000000000..8fb7c1e6d6 --- /dev/null +++ b/Content.Server/Disease/Components/DiseaseSwabComponent.cs @@ -0,0 +1,33 @@ +using System.Threading; +using Content.Shared.Disease; + +namespace Content.Server.Disease.Components +{ + [RegisterComponent] + /// + /// For mouth swabs used to collect and process + /// disease samples. + /// + public sealed class DiseaseSwabComponent : Component + { + /// + /// How long it takes to swab someone. + /// + [DataField("swabDelay")] + [ViewVariables] + public float SwabDelay = 2f; + /// + /// If this swab has been used + /// + public bool Used = false; + /// + /// Token for interrupting swabbing do after. + /// + public CancellationTokenSource? CancelToken; + /// + /// The disease prototype currently on the swab + /// + [ViewVariables] + public DiseasePrototype? Disease; + } +} diff --git a/Content.Server/Disease/Components/DiseaseVaccineComponent.cs b/Content.Server/Disease/Components/DiseaseVaccineComponent.cs new file mode 100644 index 0000000000..5e3e4f7f93 --- /dev/null +++ b/Content.Server/Disease/Components/DiseaseVaccineComponent.cs @@ -0,0 +1,33 @@ +using System.Threading; +using Content.Shared.Disease; + +namespace Content.Server.Disease.Components +{ + [RegisterComponent] + /// + /// For disease vaccines + /// + public sealed class DiseaseVaccineComponent : Component + { + /// + /// How long it takes to inject someone + /// + [DataField("injectDelay")] + [ViewVariables] + public float InjectDelay = 2f; + /// + /// If this vaccine has been used + /// + public bool Used = false; + /// + /// Token for interrupting injection do after. + /// + public CancellationTokenSource? CancelToken; + + /// + /// The disease prototype currently on the vaccine + /// + [ViewVariables(VVAccess.ReadWrite)] + public DiseasePrototype? Disease; + } +} diff --git a/Content.Server/Disease/Components/DiseaseVaccineCreatorComponent.cs b/Content.Server/Disease/Components/DiseaseVaccineCreatorComponent.cs new file mode 100644 index 0000000000..f8353cb965 --- /dev/null +++ b/Content.Server/Disease/Components/DiseaseVaccineCreatorComponent.cs @@ -0,0 +1,10 @@ +namespace Content.Server.Disease.Components +{ + /// + /// Controls disease machine behavior specific to the + /// vaccine creating machine + /// + [RegisterComponent] + public sealed class DiseaseVaccineCreatorComponent : Component + {} +} diff --git a/Content.Server/Disease/Cures/DiseaseBedrestCure.cs b/Content.Server/Disease/Cures/DiseaseBedrestCure.cs new file mode 100644 index 0000000000..3f90385204 --- /dev/null +++ b/Content.Server/Disease/Cures/DiseaseBedrestCure.cs @@ -0,0 +1,33 @@ +using Content.Shared.Disease; +using Content.Server.Buckle.Components; + +namespace Content.Server.Disease.Cures +{ + /// + /// Cures the disease after a certain amount of time + /// strapped. + /// + /// TODO: Revisit after bed pr merged + public sealed class DiseaseBedrestCure : DiseaseCure + { + [ViewVariables(VVAccess.ReadWrite)] + public int Ticker = 0; + [DataField("maxLength", required: true)] + [ViewVariables(VVAccess.ReadWrite)] + public int MaxLength = 60; + + public override bool Cure(DiseaseEffectArgs args) + { + if (!args.EntityManager.TryGetComponent(args.DiseasedEntity, out var buckle)) + return false; + if (buckle.Buckled) + Ticker++; + return Ticker >= MaxLength; + } + + public override string CureText() + { + return (Loc.GetString("diagnoser-cure-bedrest", ("time", MaxLength))); + } + } +} diff --git a/Content.Server/Disease/Cures/DiseaseBodyTemperatureCure.cs b/Content.Server/Disease/Cures/DiseaseBodyTemperatureCure.cs new file mode 100644 index 0000000000..6afc92a2e4 --- /dev/null +++ b/Content.Server/Disease/Cures/DiseaseBodyTemperatureCure.cs @@ -0,0 +1,34 @@ +using Content.Server.Temperature.Components; +using Content.Shared.Disease; + +namespace Content.Server.Disease.Cures +{ + /// + /// Cures the disease if temperature is within certain bounds. + /// + public sealed class DiseaseBodyTemperatureCure : DiseaseCure + { + [DataField("min")] + public float Min = 0; + + [DataField("max")] + public float Max = float.MaxValue; + public override bool Cure(DiseaseEffectArgs args) + { + if (!args.EntityManager.TryGetComponent(args.DiseasedEntity, out TemperatureComponent temp)) + return false; + + return temp.CurrentTemperature > Min && temp.CurrentTemperature < float.MaxValue; + } + + public override string CureText() + { + if (Min == 0) + return Loc.GetString("diagnoser-cure-temp-max", ("max", Math.Round(Max))); + if (Max == float.MaxValue) + return Loc.GetString("diagnoser-cure-temp-min", ("min", Math.Round(Min))); + + return Loc.GetString("diagnoser-cure-temp-both", ("max", Math.Round(Max)), ("min", Math.Round(Min))); + } + } +} diff --git a/Content.Server/Disease/Cures/DiseaseJustWaitCure.cs b/Content.Server/Disease/Cures/DiseaseJustWaitCure.cs new file mode 100644 index 0000000000..dc44de16ad --- /dev/null +++ b/Content.Server/Disease/Cures/DiseaseJustWaitCure.cs @@ -0,0 +1,31 @@ +using Content.Shared.Disease; + +namespace Content.Server.Disease.Cures +{ + /// + /// Automatically removes the disease after a + /// certain amount of time. + /// + public sealed class DiseaseJustWaitCure : DiseaseCure + { + /// + /// All of these are in seconds + /// + [ViewVariables(VVAccess.ReadWrite)] + public int Ticker = 0; + [DataField("maxLength", required: true)] + [ViewVariables(VVAccess.ReadWrite)] + public int MaxLength = 150; + + public override bool Cure(DiseaseEffectArgs args) + { + Ticker++; + return Ticker >= MaxLength; + } + + public override string CureText() + { + return Loc.GetString("diagnoser-cure-wait", ("time", MaxLength)); + } + } +} diff --git a/Content.Server/Disease/Cures/DiseaseReagentCure.cs b/Content.Server/Disease/Cures/DiseaseReagentCure.cs new file mode 100644 index 0000000000..0568252768 --- /dev/null +++ b/Content.Server/Disease/Cures/DiseaseReagentCure.cs @@ -0,0 +1,38 @@ +using Content.Shared.Disease; +using Content.Shared.FixedPoint; +using Content.Server.Body.Components; + +namespace Content.Server.Disease.Cures +{ + /// + /// Cures the disease if a certain amount of reagent + /// is in the host's chemstream. + /// + public sealed class DiseaseReagentCure : DiseaseCure + { + [DataField("min")] + public FixedPoint2 Min = 5; + [DataField("reagent")] + public string? Reagent; + + public override bool Cure(DiseaseEffectArgs args) + { + if (!args.EntityManager.TryGetComponent(args.DiseasedEntity, out var bloodstream)) + return false; + + var quant = FixedPoint2.Zero; + if (Reagent != null && bloodstream.ChemicalSolution.ContainsReagent(Reagent)) + { + quant = bloodstream.ChemicalSolution.GetReagentQuantity(Reagent); + } + return quant >= Min; + } + + public override string CureText() + { + if (Reagent == null) + return string.Empty; + return (Loc.GetString("diagnoser-cure-reagent", ("units", Min), ("reagent", Reagent))); + } + } +} diff --git a/Content.Server/Disease/DiseaseDiagnosisSystem.cs b/Content.Server/Disease/DiseaseDiagnosisSystem.cs new file mode 100644 index 0000000000..148bdd8b89 --- /dev/null +++ b/Content.Server/Disease/DiseaseDiagnosisSystem.cs @@ -0,0 +1,415 @@ +using System.Threading; +using Content.Server.Disease.Components; +using Content.Shared.Disease; +using Content.Shared.Disease.Components; +using Content.Shared.Interaction; +using Content.Shared.Inventory; +using Content.Shared.Examine; +using Content.Server.DoAfter; +using Content.Server.Popups; +using Content.Server.Hands.Components; +using Content.Server.Nutrition.EntitySystems; +using Content.Server.Paper; +using Content.Server.Tools.Components; +using Content.Server.Power.Components; +using Robust.Shared.Random; +using Robust.Shared.Player; +using Robust.Shared.Audio; +using Robust.Shared.Utility; + +namespace Content.Server.Disease +{ + /// Everything that's about disease diangosis and machines is in here + + public sealed class DiseaseDiagnosisSystem : EntitySystem + { + [Dependency] private readonly DoAfterSystem _doAfterSystem = default!; + [Dependency] private readonly PopupSystem _popupSystem = default!; + [Dependency] private readonly IRobustRandom _random = default!; + [Dependency] private readonly InventorySystem _inventorySystem = default!; + + public override void Initialize() + { + base.Initialize(); + SubscribeLocalEvent(OnAfterInteract); + SubscribeLocalEvent(OnExamined); + SubscribeLocalEvent(OnAfterInteractUsing); + SubscribeLocalEvent(OnAfterInteractUsingVaccine); + /// Visuals + SubscribeLocalEvent(OnPowerChanged); + /// Private Events + SubscribeLocalEvent(OnDiagnoserFinished); + SubscribeLocalEvent(OnVaccinatorFinished); + SubscribeLocalEvent(OnTargetSwabSuccessful); + SubscribeLocalEvent(OnSwabCancelled); + } + + private Queue AddQueue = new(); + private Queue RemoveQueue = new(); + + /// + /// This handles running disease machines + /// to handle their delay and visuals. + /// + public override void Update(float frameTime) + { + foreach (var uid in AddQueue) + EnsureComp(uid); + + AddQueue.Clear(); + foreach (var uid in RemoveQueue) + RemComp(uid); + + RemoveQueue.Clear(); + + foreach (var (runningComp, diseaseMachine) in EntityQuery(false)) + { + if (diseaseMachine.Accumulator < diseaseMachine.Delay) + { + diseaseMachine.Accumulator += frameTime; + return; + } + + diseaseMachine.Accumulator = 0; + var ev = new DiseaseMachineFinishedEvent(diseaseMachine); + RaiseLocalEvent(diseaseMachine.Owner, ev, false); + RemoveQueue.Enqueue(diseaseMachine.Owner); + } + } + + /// + /// Event Handlers + /// + + /// + /// This handles using swabs on other people + /// and checks that the swab isn't already used + /// and the other person's mouth is accessible + /// and then adds a random disease from that person + /// to the swab if they have any + /// + private void OnAfterInteract(EntityUid uid, DiseaseSwabComponent swab, AfterInteractEvent args) + { + if (swab.CancelToken != null) + { + swab.CancelToken.Cancel(); + swab.CancelToken = null; + return; + } + if (args.Target == null || !args.CanReach) + return; + + if (!TryComp(args.Target, out var carrier)) + return; + + if (swab.Used) + { + _popupSystem.PopupEntity(Loc.GetString("swab-already-used"), args.User, Filter.Entities(args.User)); + return; + } + + if (_inventorySystem.TryGetSlotEntity(args.Target.Value, "mask", out var maskUid) && + EntityManager.TryGetComponent(maskUid, out var blocker) && + blocker.Enabled) + { + _popupSystem.PopupEntity(Loc.GetString("swab-mask-blocked", ("target", args.Target), ("mask", maskUid)), args.User, Filter.Entities(args.User)); + return; + } + + swab.CancelToken = new CancellationTokenSource(); + _doAfterSystem.DoAfter(new DoAfterEventArgs(args.User, swab.SwabDelay, swab.CancelToken.Token, target: args.Target) + { + BroadcastFinishedEvent = new TargetSwabSuccessfulEvent(args.User, args.Target, swab, carrier), + BroadcastCancelledEvent = new SwabCancelledEvent(swab), + BreakOnTargetMove = true, + BreakOnUserMove = true, + BreakOnStun = true, + NeedHand = true + }); + } + + /// + /// This handles the disease diagnoser machine up + /// until it's turned on. It has some slight + /// differences in checks from the vaccinator. + /// + private void OnAfterInteractUsing(EntityUid uid, DiseaseDiagnoserComponent component, AfterInteractUsingEvent args) + { + var machine = Comp(uid); + if (args.Handled || !args.CanReach) + return; + + if (TryComp(uid, out var power) && !power.Powered) + return; + + if (!HasComp(args.User) || HasComp(args.Used)) // Don't want to accidentally breach wrenching or whatever + return; + + if (!TryComp(args.Used, out var swab)) + { + _popupSystem.PopupEntity(Loc.GetString("diagnoser-cant-use-swab", ("machine", uid), ("swab", args.Used)), uid, Filter.Entities(args.User)); + return; + } + _popupSystem.PopupEntity(Loc.GetString("diagnoser-insert-swab", ("machine", uid), ("swab", args.Used)), uid, Filter.Entities(args.User)); + + + machine.Disease = swab.Disease; + EntityManager.DeleteEntity(args.Used); + + AddQueue.Enqueue(uid); + UpdateAppearance(uid, true, true); + SoundSystem.Play(Filter.Pvs(uid), "/Audio/Machines/diagnoser_printing.ogg", uid); + } + + /// + /// This handles the vaccinator machine up + /// until it's turned on. It has some slight + /// differences in checks from the diagnoser. + /// + private void OnAfterInteractUsingVaccine(EntityUid uid, DiseaseVaccineCreatorComponent component, AfterInteractUsingEvent args) + { + if (args.Handled || !args.CanReach) + return; + + if (TryComp(uid, out var power) && !power.Powered) + return; + + if (!HasComp(args.User) || HasComp(args.Used)) //This check ensures tools don't break without yaml ordering jank + return; + + if (!TryComp(args.Used, out var swab) || swab.Disease == null || !swab.Disease.Infectious) + { + _popupSystem.PopupEntity(Loc.GetString("diagnoser-cant-use-swab", ("machine", uid), ("swab", args.Used)), uid, Filter.Entities(args.User)); + return; + } + _popupSystem.PopupEntity(Loc.GetString("diagnoser-insert-swab", ("machine", uid), ("swab", args.Used)), uid, Filter.Entities(args.User)); + var machine = Comp(uid); + machine.Disease = swab.Disease; + EntityManager.DeleteEntity(args.Used); + + AddQueue.Enqueue(uid); + UpdateAppearance(uid, true, true); + SoundSystem.Play(Filter.Pvs(uid), "/Audio/Machines/vaccinator_running.ogg", uid); + } + + /// + /// This handles swab examination text + /// so you can tell if they are used or not. + /// + private void OnExamined(EntityUid uid, DiseaseSwabComponent swab, ExaminedEvent args) + { + if (args.IsInDetailsRange) + { + if (swab.Used) + args.PushMarkup(Loc.GetString("swab-used")); + else + args.PushMarkup(Loc.GetString("swab-unused")); + } + } + + /// + /// Helper functions + /// + + /// + /// This assembles a disease report + /// With its basic details and + /// specific cures (i.e. not spaceacillin). + /// The cure resist field tells you how + /// effective spaceacillin etc will be. + /// + private FormattedMessage AssembleDiseaseReport(DiseasePrototype disease) + { + FormattedMessage report = new(); + report.AddMarkup(Loc.GetString("diagnoser-disease-report-name", ("disease", disease.Name))); + report.PushNewline(); + + if (disease.Infectious) + { + report.AddMarkup(Loc.GetString("diagnoser-disease-report-infectious")); + report.PushNewline(); + } else + { + report.AddMarkup(Loc.GetString("diagnoser-disease-report-not-infectious")); + report.PushNewline(); + } + string cureResistLine = string.Empty; + cureResistLine += disease.CureResist switch + { + < 0f => Loc.GetString("diagnoser-disease-report-cureresist-none"), + <= 0.05f => Loc.GetString("diagnoser-disease-report-cureresist-low"), + <= 0.14f => Loc.GetString("diagnoser-disease-report-cureresist-medium"), + _ => Loc.GetString("diagnoser-disease-report-cureresist-high") + }; + report.AddMarkup(cureResistLine); + report.PushNewline(); + + /// Add Cures + if (disease.Cures.Count == 0) + { + report.AddMarkup(Loc.GetString("diagnoser-no-cures")); + } + else + { + report.PushNewline(); + report.AddMarkup(Loc.GetString("diagnoser-cure-has")); + report.PushNewline(); + + foreach (var cure in disease.Cures) + { + report.AddMarkup(cure.CureText()); + report.PushNewline(); + } + } + + return report; + } + /// + /// Appearance stuff + /// + + /// + /// Appearance helper function to + /// set the component's power and running states. + /// + private void UpdateAppearance(EntityUid uid, bool isOn, bool isRunning) + { + if (!TryComp(uid, out var appearance)) + return; + + appearance.SetData(DiseaseMachineVisuals.IsOn, isOn); + appearance.SetData(DiseaseMachineVisuals.IsRunning, isRunning); + } + /// + /// Makes sure the machine is visually off/on. + /// + private void OnPowerChanged(EntityUid uid, DiseaseMachineComponent component, PowerChangedEvent args) + { + UpdateAppearance(uid, args.Powered, false); + } + /// + /// Private events + /// + + /// + /// Copies a disease prototype to the swab + /// after the doafter completes. + /// + private void OnTargetSwabSuccessful(TargetSwabSuccessfulEvent args) + { + if (args.Target == null) + return; + + args.Swab.Used = true; + _popupSystem.PopupEntity(Loc.GetString("swab-swabbed", ("target", args.Target)), args.Target.Value, Filter.Entities(args.User)); + + if (args.Swab.Disease != null || args.Carrier.Diseases.Count == 0) + return; + + args.Swab.Disease = _random.Pick(args.Carrier.Diseases); + } + + /// + /// Cancels the swab doafter if needed. + /// + private static void OnSwabCancelled(SwabCancelledEvent args) + { + args.Swab.CancelToken = null; + } + + /// + /// Prints a diagnostic report with its findings. + /// Also cancels the animation. + /// + private void OnDiagnoserFinished(EntityUid uid, DiseaseDiagnoserComponent component, DiseaseMachineFinishedEvent args) + { + var power = Comp(uid); + UpdateAppearance(uid, power.Powered, false); + // spawn a piece of paper. + var printed = EntityManager.SpawnEntity(args.Machine.MachineOutput, Transform(uid).Coordinates); + + if (!TryComp(printed, out var paper)) + return; + + var reportTitle = string.Empty; + FormattedMessage contents = new(); + if (args.Machine.Disease != null) + { + reportTitle = Loc.GetString("diagnoser-disease-report", ("disease", args.Machine.Disease.Name)); + contents = AssembleDiseaseReport(args.Machine.Disease); + } else + { + reportTitle = Loc.GetString("diagnoser-disease-report-none"); + contents.AddMarkup(Loc.GetString("diagnoser-disease-report-none-contents")); + } + MetaData(printed).EntityName = reportTitle; + + paper.SetContent(contents.ToMarkup()); + } + + /// + /// Prints a vaccine that will vaccinate + /// against the disease on the inserted swab. + /// + private void OnVaccinatorFinished(EntityUid uid, DiseaseVaccineCreatorComponent component, DiseaseMachineFinishedEvent args) + { + var power = Comp(uid); + UpdateAppearance(uid, power.Powered, false); + + // spawn a vaccine + var vaxx = EntityManager.SpawnEntity(args.Machine.MachineOutput, Transform(uid).Coordinates); + + if (!TryComp(vaxx, out var vaxxComp)) + return; + + vaxxComp.Disease = args.Machine.Disease; + } + + /// + /// Cancels the mouth-swabbing doafter + /// + private sealed class SwabCancelledEvent : EntityEventArgs + { + public readonly DiseaseSwabComponent Swab; + public SwabCancelledEvent(DiseaseSwabComponent swab) + { + Swab = swab; + } + } + + /// + /// Fires if the doafter for swabbing someone's mouth succeeds + /// + private sealed class TargetSwabSuccessfulEvent : EntityEventArgs + { + public EntityUid User { get; } + public EntityUid? Target { get; } + public DiseaseSwabComponent Swab { get; } + + public DiseaseCarrierComponent Carrier { get; } + + public TargetSwabSuccessfulEvent(EntityUid user, EntityUid? target, DiseaseSwabComponent swab, DiseaseCarrierComponent carrier) + { + User = user; + Target = target; + Swab = swab; + Carrier = carrier; + } + } + + /// + /// Fires when a disease machine is done + /// with its production delay and ready to + /// create a report or vaccine + /// + private sealed class DiseaseMachineFinishedEvent : EntityEventArgs + { + public DiseaseMachineComponent Machine {get;} + public DiseaseMachineFinishedEvent(DiseaseMachineComponent machine) + { + Machine = machine; + } + } + } +} + diff --git a/Content.Server/Disease/DiseaseSystem.cs b/Content.Server/Disease/DiseaseSystem.cs new file mode 100644 index 0000000000..2933e7471e --- /dev/null +++ b/Content.Server/Disease/DiseaseSystem.cs @@ -0,0 +1,442 @@ +using System.Threading; +using Content.Shared.Disease; +using Content.Shared.Disease.Components; +using Content.Server.Disease.Components; +using Content.Server.Clothing.Components; +using Content.Shared.MobState.Components; +using Content.Shared.Examine; +using Content.Shared.Inventory; +using Content.Shared.Interaction; +using Content.Server.Popups; +using Content.Server.DoAfter; +using Robust.Shared.Player; +using Robust.Shared.Prototypes; +using Robust.Shared.Random; +using Robust.Shared.Serialization.Manager; +using Content.Shared.Inventory.Events; +using Content.Server.Nutrition.EntitySystems; + +namespace Content.Server.Disease +{ + + /// + /// Handles disease propagation & curing + /// + public sealed class DiseaseSystem : EntitySystem + { + [Dependency] private readonly IPrototypeManager _prototypeManager = default!; + [Dependency] private readonly ISerializationManager _serializationManager = default!; + [Dependency] private readonly IRobustRandom _random = default!; + [Dependency] private readonly DoAfterSystem _doAfterSystem = default!; + [Dependency] private readonly PopupSystem _popupSystem = default!; + [Dependency] private readonly EntityLookupSystem _lookup = default!; + [Dependency] private readonly SharedInteractionSystem _interactionSystem = default!; + [Dependency] private readonly InventorySystem _inventorySystem = default!; + + public override void Initialize() + { + base.Initialize(); + SubscribeLocalEvent(OnTryCureDisease); + SubscribeLocalEvent(OnInteractDiseasedHand); + SubscribeLocalEvent(OnInteractDiseasedUsing); + SubscribeLocalEvent(OnEquipped); + SubscribeLocalEvent(OnUnequipped); + SubscribeLocalEvent(OnAfterInteract); + SubscribeLocalEvent(OnExamined); + /// Private events stuff + SubscribeLocalEvent(OnTargetVaxxSuccessful); + SubscribeLocalEvent(OnVaxxCancelled); + } + + private Queue AddQueue = new(); + private Queue<(DiseaseCarrierComponent carrier, DiseasePrototype disease)> CureQueue = new(); + + /// + /// First, adds or removes diseased component from the queues and clears them. + /// Then, iterates over every diseased component to check for their effects + /// and cures + /// + public override void Update(float frameTime) + { + base.Update(frameTime); + foreach (var entity in AddQueue) + EnsureComp(entity); + AddQueue.Clear(); + + foreach (var tuple in CureQueue) + { + if (tuple.carrier.Diseases.Count == 1) //This is reliable unlike testing Count == 0 right after removal for reasons I don't quite get + RemComp(tuple.carrier.Owner); + tuple.carrier.PastDiseases.Add(tuple.disease); + tuple.carrier.Diseases.Remove(tuple.disease); + } + CureQueue.Clear(); + + foreach (var (diseasedComp, carrierComp, mobState) in EntityQuery(false)) + { + if (mobState.IsDead()) + { + if (_random.Prob(0.005f * frameTime)) //Mean time to remove is 200 seconds per disease + CureDisease(carrierComp, _random.Pick(carrierComp.Diseases)); + continue; + } + + foreach(var disease in carrierComp.Diseases) + { + var args = new DiseaseEffectArgs(carrierComp.Owner, disease, EntityManager); + disease.Accumulator += frameTime; + if (disease.Accumulator >= disease.TickTime) + { + disease.Accumulator -= disease.TickTime; + foreach (var cure in disease.Cures) + { + if (cure.Cure(args)) + CureDisease(carrierComp, disease); + } + foreach (var effect in disease.Effects) + { + if (_random.Prob(effect.Probability)) + effect.Effect(args); + } + } + } + } + } + + /// + /// Event Handlers + /// + + /// + /// Used when something is trying to cure ANY disease on the target, + /// not for special disease interactions. Randomly + /// tries to cure every disease on the target. + /// + private void OnTryCureDisease(EntityUid uid, DiseaseCarrierComponent component, CureDiseaseAttemptEvent args) + { + foreach (var disease in component.Diseases) + { + var cureProb = ((args.CureChance / component.Diseases.Count) - disease.CureResist); + if (cureProb < 0) + return; + if (cureProb > 1) + { + CureDisease(component, disease); + return; + } + if (_random.Prob(cureProb)) + { + CureDisease(component, disease); + return; + } + } + } + + /// + /// Called when a component with disease protection + /// is equipped so it can be added to the person's + /// total disease resistance + /// + private void OnEquipped(EntityUid uid, DiseaseProtectionComponent component, GotEquippedEvent args) + { + /// This only works on clothing + if (!TryComp(uid, out var clothing)) + return; + /// Is the clothing in its actual slot? + if (!clothing.SlotFlags.HasFlag(args.SlotFlags)) + return; + /// Give the user the component's disease resist + if(TryComp(args.Equipee, out var carrier)) + carrier.DiseaseResist += component.Protection; + /// Set the component to active to the unequip check isn't CBT + component.IsActive = true; + } + + /// + /// Called when a component with disease protection + /// is unequipped so it can be removed from the person's + /// total disease resistance + /// + private void OnUnequipped(EntityUid uid, DiseaseProtectionComponent component, GotUnequippedEvent args) + { + /// Only undo the resistance if it was affecting the user + if (!component.IsActive) + return; + if(TryComp(args.Equipee, out var carrier)) + carrier.DiseaseResist -= component.Protection; + component.IsActive = false; + } + + /// + /// Called when it's already decided a disease will be cured + /// so it can be safely queued up to be removed from the target + /// and added to past disease history (for immunity) + /// + private void CureDisease(DiseaseCarrierComponent carrier, DiseasePrototype disease) + { + var CureTuple = (carrier, disease); + CureQueue.Enqueue(CureTuple); + _popupSystem.PopupEntity(Loc.GetString("disease-cured"), carrier.Owner, Filter.Entities(carrier.Owner)); + } + + /// + /// Called when someone interacts with a diseased person with an empty hand + /// to check if they get infected + /// + private void OnInteractDiseasedHand(EntityUid uid, DiseasedComponent component, InteractHandEvent args) + { + if (!_interactionSystem.InRangeUnobstructed(args.User, args.Target)) + return; + InteractWithDiseased (args.Target, args.User); + } + + /// + /// Called when someone interacts with a diseased person with any object + /// to check if they get infected + /// + private void OnInteractDiseasedUsing(EntityUid uid, DiseasedComponent component, InteractUsingEvent args) + { + InteractWithDiseased(args.Target, args.User); + } + + /// + /// Called when a vaccine is used on someone + /// to handle the vaccination doafter + /// + private void OnAfterInteract(EntityUid uid, DiseaseVaccineComponent vaxx, AfterInteractEvent args) + { + if (vaxx.CancelToken != null) + { + vaxx.CancelToken.Cancel(); + vaxx.CancelToken = null; + return; + } + if (args.Target == null) + return; + + if (!args.CanReach) + return; + + if (vaxx.CancelToken != null) + return; + + if (!TryComp(args.Target, out var carrier)) + return; + + if (vaxx.Used) + { + _popupSystem.PopupEntity(Loc.GetString("vaxx-already-used"), args.User, Filter.Entities(args.User)); + return; + } + + vaxx.CancelToken = new CancellationTokenSource(); + _doAfterSystem.DoAfter(new DoAfterEventArgs(args.User, vaxx.InjectDelay, vaxx.CancelToken.Token, target: args.Target) + { + BroadcastFinishedEvent = new TargetVaxxSuccessfulEvent(args.User, args.Target, vaxx, carrier), + BroadcastCancelledEvent = new VaxxCancelledEvent(vaxx), + BreakOnTargetMove = true, + BreakOnUserMove = true, + BreakOnStun = true, + NeedHand = true + }); + } + + /// + /// Called when a vaccine is examined. + /// Currently doesn't do much because + /// vaccines don't have unique art with a seperate + /// state visualizer. + /// + private void OnExamined(EntityUid uid, DiseaseVaccineComponent vaxx, ExaminedEvent args) + { + if (args.IsInDetailsRange) + { + if (vaxx.Used) + args.PushMarkup(Loc.GetString("vaxx-used")); + else + args.PushMarkup(Loc.GetString("vaxx-unused")); + } + } + + /// + /// Helper functions + /// + + /// + /// Tries to infect anyone that + /// interacts with a diseased person or body + /// + private void InteractWithDiseased(EntityUid diseased, EntityUid target) + { + if (!TryComp(target, out var carrier)) + return; + + var disease = _random.Pick(Comp(diseased).Diseases); + if (disease != null) + TryInfect(carrier, disease, 0.4f); + } + + /// + /// Adds a disease to a target + /// if it's not already in their current + /// or past diseases. If you want this + /// to not be guaranteed you are looking + /// for TryInfect. + /// + public void TryAddDisease(DiseaseCarrierComponent? target, DiseasePrototype? addedDisease, string? diseaseName = null, EntityUid host = default!) + { + if (diseaseName != null && _prototypeManager.TryIndex(diseaseName, out DiseasePrototype? diseaseProto)) + addedDisease = diseaseProto; + + if (host != default!) + target = Comp(host); + + if (target != null) + { + foreach (var disease in target.AllDiseases) + { + if (disease.ID == addedDisease?.ID) //ID because of the way protoypes work + return; + } + var freshDisease = _serializationManager.CreateCopy(addedDisease) ?? default!; + target.Diseases.Add(freshDisease); + AddQueue.Enqueue(target.Owner); + } + } + + /// + /// Pits the infection chance against the + /// person's disease resistance and + /// rolls the dice to see if they get + /// the disease. + /// + public void TryInfect(DiseaseCarrierComponent carrier, DiseasePrototype? disease, float chance = 0.7f) + { + if(disease == null || !disease.Infectious) + return; + var infectionChance = chance - carrier.DiseaseResist; + if (infectionChance <= 0) + return; + if (_random.Prob(infectionChance)) + TryAddDisease(carrier, disease); + } + + /// + /// Plays a sneeze/cough popup if applicable + /// and then tries to infect anyone in range + /// if the snougher is not wearing a mask. + /// + public void SneezeCough(EntityUid uid, DiseasePrototype? disease, string snoughMessage, bool airTransmit = true, float infectionChance = 0.3f) + { + var xform = Comp(uid); + if (snoughMessage != string.Empty) + _popupSystem.PopupEntity(Loc.GetString(snoughMessage, ("person", uid)), uid, Filter.Pvs(uid)); + + if (disease == null || !disease.Infectious || airTransmit == false) + return; + + if (_inventorySystem.TryGetSlotEntity(uid, "mask", out var maskUid) && + EntityManager.TryGetComponent(maskUid, out var blocker) && + blocker.Enabled) + return; + + foreach (var entity in _lookup.GetEntitiesInRange(xform.MapID, xform.WorldPosition, 2f)) + { + if (!_interactionSystem.InRangeUnobstructed(uid, entity)) + continue; + + if (TryComp(entity, out var carrier)) + TryInfect(carrier, disease, 0.3f); + } + } + + /// + /// Adds a disease to the carrier's + /// past diseases to give them immunity + /// IF they don't already have the disease. + /// + public void Vaccinate(DiseaseCarrierComponent carrier, DiseasePrototype disease) + { + foreach (var currentDisease in carrier.Diseases) + { + if (currentDisease.ID == disease.ID) //ID because of the way protoypes work + return; + } + carrier.PastDiseases.Add(disease); + } + + /// + /// Private Events Stuff + /// + + /// + /// Injects the vaccine into the target + /// if the doafter is completed + /// + private void OnTargetVaxxSuccessful(TargetVaxxSuccessfulEvent args) + { + if (args.Vaxx.Disease == null) + return; + Vaccinate(args.Carrier, args.Vaxx.Disease); + EntityManager.DeleteEntity(args.Vaxx.Owner); + } + + /// + /// Cancels the vaccine doafter + /// + private static void OnVaxxCancelled(VaxxCancelledEvent args) + { + args.Vaxx.CancelToken = null; + } + /// These two are standard doafter stuff you can ignore + private sealed class VaxxCancelledEvent : EntityEventArgs + { + public readonly DiseaseVaccineComponent Vaxx; + public VaxxCancelledEvent(DiseaseVaccineComponent vaxx) + { + Vaxx = vaxx; + } + } + private sealed class TargetVaxxSuccessfulEvent : EntityEventArgs + { + public EntityUid User { get; } + public EntityUid? Target { get; } + public DiseaseVaccineComponent Vaxx { get; } + public DiseaseCarrierComponent Carrier { get; } + public TargetVaxxSuccessfulEvent(EntityUid user, EntityUid? target, DiseaseVaccineComponent vaxx, DiseaseCarrierComponent carrier) + { + User = user; + Target = target; + Vaxx = vaxx; + Carrier = carrier; + } + } + } + + /// + /// This event is fired by chems + /// and other brute-force rather than + /// specific cures. It will roll the dice to attempt + /// to cure each disease on the target + /// + public sealed class CureDiseaseAttemptEvent : EntityEventArgs + { + public float CureChance { get; } + public CureDiseaseAttemptEvent(float cureChance) + { + CureChance = cureChance; + } + } + + /// + /// Controls whether the snough is a sneeze, cough + /// or neither. If none, will not create + /// a popup. Mostly used for talking + /// + public enum SneezeCoughType + { + Sneeze, + Cough, + None + } +} diff --git a/Content.Server/Disease/Effects/DiseaseAdjustReagent.cs b/Content.Server/Disease/Effects/DiseaseAdjustReagent.cs new file mode 100644 index 0000000000..26c180a887 --- /dev/null +++ b/Content.Server/Disease/Effects/DiseaseAdjustReagent.cs @@ -0,0 +1,46 @@ +using Content.Server.Chemistry.EntitySystems; +using Content.Shared.Chemistry.Reagent; +using Content.Shared.FixedPoint; +using JetBrains.Annotations; +using Content.Server.Body.Components; +using Content.Shared.Disease; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype; + +namespace Content.Server.Disease.Effects +{ + /// + /// Adds or removes reagents from the + /// host's chemstream. + /// + [UsedImplicitly] + public sealed class DiseaseAdjustReagent : DiseaseEffect + { + /// + /// The reagent ID to add or remove. + /// + [DataField("reagent", customTypeSerializer:typeof(PrototypeIdSerializer))] + public string? Reagent = null; + + [DataField("amount", required: true)] + public FixedPoint2 Amount = default!; + + public override void Effect(DiseaseEffectArgs args) + { + if (!args.EntityManager.TryGetComponent(args.DiseasedEntity, out var bloodstream)) + return; + + var stream = bloodstream.ChemicalSolution; + if (stream != null) + { + var solutionSys = args.EntityManager.EntitySysManager.GetEntitySystem(); + if (Reagent != null) + { + if (Amount < 0 && stream.ContainsReagent(Reagent)) + solutionSys.TryRemoveReagent(args.DiseasedEntity, stream, Reagent, -Amount); + if (Amount > 0) + solutionSys.TryAddReagent(args.DiseasedEntity, stream, Reagent, Amount, out _); + } + } + } + } +} diff --git a/Content.Server/Disease/Effects/DiseaseGenericStatusEffect.cs b/Content.Server/Disease/Effects/DiseaseGenericStatusEffect.cs new file mode 100644 index 0000000000..af36ba9398 --- /dev/null +++ b/Content.Server/Disease/Effects/DiseaseGenericStatusEffect.cs @@ -0,0 +1,67 @@ +using Content.Shared.Disease; +using Content.Shared.StatusEffect; +using JetBrains.Annotations; + +namespace Content.Server.Disease.Effects +{ + /// + /// Adds a generic status effect to the entity. + /// Differs from the chem version in its defaults + /// to better facilitate adding components that + /// last the length of the disease. + /// + [UsedImplicitly] + public sealed class DiseaseGenericStatusEffect : DiseaseEffect + { + /// + /// The status effect key + /// Prevents other components from being with the same key + /// + [DataField("key", required: true)] + public string Key = default!; + /// + /// The component to add + /// + [DataField("component")] + public string Component = String.Empty; + + [DataField("time")] + public float Time = 1.01f; /// I'm afraid if this was exact the key could get stolen by another thing + + /// + /// true - refresh status effect time, false - accumulate status effect time + /// + [DataField("refresh")] + public bool Refresh = false; + + /// + /// Should this effect add the status effect, remove time from it, or set its cooldown? + /// + [DataField("type")] + public StatusEffectDiseaseType Type = StatusEffectDiseaseType.Add; + + public override void Effect(DiseaseEffectArgs args) + { + var statusSys = EntitySystem.Get(); + if (Type == StatusEffectDiseaseType.Add && Component != String.Empty) + { + statusSys.TryAddStatusEffect(args.DiseasedEntity, Key, TimeSpan.FromSeconds(Time), Refresh, Component); + } + else if (Type == StatusEffectDiseaseType.Remove) + { + statusSys.TryRemoveTime(args.DiseasedEntity, Key, TimeSpan.FromSeconds(Time)); + } + else if (Type == StatusEffectDiseaseType.Set) + { + statusSys.TrySetTime(args.DiseasedEntity, Key, TimeSpan.FromSeconds(Time)); + } + } + } + /// See status effects for how these work + public enum StatusEffectDiseaseType + { + Add, + Remove, + Set + } +} diff --git a/Content.Server/Disease/Effects/DiseaseHealthChange.cs b/Content.Server/Disease/Effects/DiseaseHealthChange.cs new file mode 100644 index 0000000000..af5a81cc88 --- /dev/null +++ b/Content.Server/Disease/Effects/DiseaseHealthChange.cs @@ -0,0 +1,21 @@ +using Content.Shared.Disease; +using Content.Shared.Damage; +using JetBrains.Annotations; + +namespace Content.Server.Disease.Effects +{ + /// + /// Deals or heals damage to the host + /// + [UsedImplicitly] + public sealed class DiseaseHealthChange : DiseaseEffect + { + [DataField("damage", required: true)] + [ViewVariables(VVAccess.ReadWrite)] + public DamageSpecifier Damage = default!; + public override void Effect(DiseaseEffectArgs args) + { + EntitySystem.Get().TryChangeDamage(args.DiseasedEntity, Damage, true, false); + } + } +} diff --git a/Content.Server/Disease/Effects/DiseasePopUp.cs b/Content.Server/Disease/Effects/DiseasePopUp.cs new file mode 100644 index 0000000000..beee93c52e --- /dev/null +++ b/Content.Server/Disease/Effects/DiseasePopUp.cs @@ -0,0 +1,38 @@ +using Content.Shared.Disease; +using Content.Shared.Popups; +using Robust.Shared.Player; +using JetBrains.Annotations; + +namespace Content.Server.Disease.Effects +{ + [UsedImplicitly] + /// + /// Plays a popup on the host's transform. + /// Supports passing the host's entity metadata + /// in PVS ones with {$person} + /// + public sealed class DiseasePopUp : DiseaseEffect + { + [DataField("message")] + public string Message = "disease-sick-generic"; + + [DataField("type")] + public PopupType Type = PopupType.Local; + public override void Effect(DiseaseEffectArgs args) + { + var popupSys = EntitySystem.Get(); + + if (Type == PopupType.Local) + popupSys.PopupEntity(Loc.GetString(Message), args.DiseasedEntity, Filter.Entities(args.DiseasedEntity)); + else if (Type == PopupType.Pvs) + popupSys.PopupEntity(Loc.GetString(Message, ("person", args.DiseasedEntity)), args.DiseasedEntity, Filter.Pvs(args.DiseasedEntity)); + } + + } + + public enum PopupType + { + Pvs, + Local + } +} diff --git a/Content.Server/Disease/Effects/DiseaseSnough.cs b/Content.Server/Disease/Effects/DiseaseSnough.cs new file mode 100644 index 0000000000..ce4d4099be --- /dev/null +++ b/Content.Server/Disease/Effects/DiseaseSnough.cs @@ -0,0 +1,30 @@ +using Content.Shared.Disease; +using JetBrains.Annotations; + +namespace Content.Server.Disease +{ + [UsedImplicitly] + + /// + /// Makes the diseased sneeze or cough + /// or neither. + /// + public sealed class DiseaseSnough : DiseaseEffect + { + /// + /// Message to play when snoughing + /// + [DataField("snoughMessage")] + public string SnoughMessage = "disease-sneeze"; + /// + /// Whether to spread the disease throught he air + /// + [DataField("airTransmit")] + public bool AirTransmit = true; + + public override void Effect(DiseaseEffectArgs args) + { + EntitySystem.Get().SneezeCough(args.DiseasedEntity, args.Disease, SnoughMessage, AirTransmit); + } + } +} diff --git a/Content.Server/Entry/IgnoredComponents.cs b/Content.Server/Entry/IgnoredComponents.cs index e70b305c39..d067ba81aa 100644 --- a/Content.Server/Entry/IgnoredComponents.cs +++ b/Content.Server/Entry/IgnoredComponents.cs @@ -17,6 +17,7 @@ namespace Content.Server.Entry "ClientEntitySpawner", "CharacterInfo", "ItemCabinetVisuals", + "DiseaseMachineVisuals", "HandheldGPS", "PotencyVisuals" }; diff --git a/Content.Server/Medical/Components/HealthAnalyzerComponent.cs b/Content.Server/Medical/Components/HealthAnalyzerComponent.cs index b7ba852605..733c4e8745 100644 --- a/Content.Server/Medical/Components/HealthAnalyzerComponent.cs +++ b/Content.Server/Medical/Components/HealthAnalyzerComponent.cs @@ -1,7 +1,9 @@ using System.Threading; using Content.Server.UserInterface; using Content.Shared.MedicalScanner; +using Content.Shared.Disease; using Robust.Server.GameObjects; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype; namespace Content.Server.Medical.Components { @@ -23,5 +25,19 @@ namespace Content.Server.Medical.Components /// public CancellationTokenSource? CancelToken; public BoundUserInterface? UserInterface => Owner.GetUIOrNull(HealthAnalyzerUiKey.Key); + + /// + /// Is this actually going to give people the disease below + /// + [DataField("fake")] + [ViewVariables(VVAccess.ReadWrite)] + public bool Fake = false; + + /// + /// The disease this will give people if Fake == true + /// + [DataField("disease", customTypeSerializer: typeof(PrototypeIdSerializer))] + [ViewVariables(VVAccess.ReadWrite)] + public string Disease = string.Empty; } } diff --git a/Content.Server/Medical/HealthAnalyzerSystem.cs b/Content.Server/Medical/HealthAnalyzerSystem.cs index 1c68f48deb..891dc2df86 100644 --- a/Content.Server/Medical/HealthAnalyzerSystem.cs +++ b/Content.Server/Medical/HealthAnalyzerSystem.cs @@ -1,10 +1,13 @@ using System.Threading; using Content.Server.DoAfter; using Content.Server.Medical.Components; +using Content.Server.Disease; +using Content.Server.Popups; using Content.Shared.Damage; using Content.Shared.Interaction; using Content.Shared.MobState.Components; using Robust.Server.GameObjects; +using Robust.Shared.Player; using static Content.Shared.MedicalScanner.SharedHealthAnalyzerComponent; namespace Content.Server.Medical @@ -12,6 +15,7 @@ namespace Content.Server.Medical public sealed class HealthAnalyzerSystem : EntitySystem { [Dependency] private readonly DoAfterSystem _doAfterSystem = default!; + [Dependency] private readonly PopupSystem _popupSystem = default!; public override void Initialize() { @@ -64,6 +68,22 @@ namespace Content.Server.Medical { args.Component.CancelToken = null; UpdateScannedUser(args.Component.Owner, args.User, args.Target, args.Component); + /// Below is for the traitor item + /// Piggybacking off another component's doafter is complete CBT so I gave up + /// and put it on the same component + if (!args.Component.Fake || args.Component.Disease == string.Empty || args.Target == null) + return; + + EntitySystem.Get().TryAddDisease(null, null, args.Component.Disease, args.Target.Value); + + if (args.User == args.Target) + { + _popupSystem.PopupEntity(Loc.GetString("disease-scanner-gave-self", ("disease", args.Component.Disease)), + args.User, Filter.Entities(args.User)); + return; + } + _popupSystem.PopupEntity(Loc.GetString("disease-scanner-gave-other", ("target", args.Target), ("disease", args.Component.Disease)), + args.User, Filter.Entities(args.User)); } private void OpenUserInterface(EntityUid user, HealthAnalyzerComponent healthAnalyzer) diff --git a/Content.Server/StationEvents/Events/DiseaseOutbreak.cs b/Content.Server/StationEvents/Events/DiseaseOutbreak.cs new file mode 100644 index 0000000000..8a038030be --- /dev/null +++ b/Content.Server/StationEvents/Events/DiseaseOutbreak.cs @@ -0,0 +1,62 @@ +using System.Linq; +using Content.Server.Chat.Managers; +using Content.Server.Disease.Components; +using Content.Server.Disease; +using Content.Shared.Disease; +using Robust.Shared.Random; +using Robust.Shared.Prototypes; + +namespace Content.Server.StationEvents.Events; +/// +/// Infects a couple people +/// with a random disease that isn't super deadly +/// +public sealed class DiseaseOutbreak : StationEvent +{ + [Dependency] private readonly IRobustRandom _random = default!; + [Dependency] private readonly IEntityManager _entityManager = default!; + [Dependency] private readonly IPrototypeManager _prototypeManager = default!; + [Dependency] private readonly IChatManager _chatManager = default!; + + /// + /// Disease prototypes I decided were not too deadly for a random event + /// + public readonly IReadOnlyList NotTooSeriousDiseases = new[] + { + "SpaceCold", + "VanAusdallsRobovirus", + "VentCough", + "AMIV" + }; + public override string Name => "DiseaseOutbreak"; + public override float Weight => WeightNormal; + protected override float EndAfter => 1.0f; + /// + /// Finds 2-5 random entities that can host diseases + /// and gives them a randomly selected disease. + /// They all get the same disease. + /// + public override void Startup() + { + base.Startup(); + + var targetList = _entityManager.EntityQuery().ToList(); + _random.Shuffle(targetList); + + var toInfect = _random.Next(2, 5); + + var diseaseName = _random.Pick(NotTooSeriousDiseases); + + if (!_prototypeManager.TryIndex(diseaseName, out DiseasePrototype? disease) || disease == null) + return; + + foreach (var target in targetList) + { + if (toInfect-- == 0) + break; + + EntitySystem.Get().TryAddDisease(target, disease); + } + _chatManager.DispatchStationAnnouncement(Loc.GetString("station-event-disease-outbreak-announcement")); + } +} diff --git a/Content.Server/StationEvents/Events/VentClog.cs b/Content.Server/StationEvents/Events/VentClog.cs index 6f39e8d841..c1c4a1cac2 100644 --- a/Content.Server/StationEvents/Events/VentClog.cs +++ b/Content.Server/StationEvents/Events/VentClog.cs @@ -42,7 +42,7 @@ public sealed class VentClog : StationEvent public readonly IReadOnlyList SafeishVentChemicals = new[] { "Water", "Iron", "Oxygen", "Tritium", "Plasma", "SulfuricAcid", "Blood", "SpaceDrugs", "SpaceCleaner", "Flour", - "Nutriment", "Sugar", "SpaceLube", "Ethanol", "Mercury", "Ephedrine", "WeldingFuel" + "Nutriment", "Sugar", "SpaceLube", "Ethanol", "Mercury", "Ephedrine", "WeldingFuel", "VentCrud" }; public override void Startup() diff --git a/Content.Server/Xenoarchaeology/XenoArtifacts/Effects/Components/DiseaseArtifactComponent.cs b/Content.Server/Xenoarchaeology/XenoArtifacts/Effects/Components/DiseaseArtifactComponent.cs new file mode 100644 index 0000000000..bcbe184030 --- /dev/null +++ b/Content.Server/Xenoarchaeology/XenoArtifacts/Effects/Components/DiseaseArtifactComponent.cs @@ -0,0 +1,37 @@ +using Content.Shared.Disease; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype; + +namespace Content.Server.Xenoarchaeology.XenoArtifacts.Effects.Components; +/// +/// Spawn a random disease at regular intervals when artifact activated. +/// +[RegisterComponent] +public sealed class DiseaseArtifactComponent : Component +{ + public override string Name => "DiseaseArtifact"; + /// + /// Disease the artifact will spawn + /// If empty, picks a random one from its list + /// + [DataField("disease", customTypeSerializer: typeof(PrototypeIdSerializer))] + [ViewVariables(VVAccess.ReadWrite)] + public string SpawnDisease = string.Empty; + /// + /// How far away it will check for people + /// If empty, picks a random one from its list + /// + [DataField("range")] + [ViewVariables(VVAccess.ReadWrite)] + public float Range = 5f; + [ViewVariables(VVAccess.ReadWrite)] + public DiseasePrototype ResolveDisease = default!; + [ViewVariables(VVAccess.ReadWrite)] + public readonly IReadOnlyList ArtifactDiseases = new[] + { + "VanAusdallsRobovirus", + "OwOnavirus", + "BleedersBite", + "Ultragigacancer", + "AMIV" + }; +} diff --git a/Content.Server/Xenoarchaeology/XenoArtifacts/Effects/Systems/DiseaseArtifactSystem.cs b/Content.Server/Xenoarchaeology/XenoArtifacts/Effects/Systems/DiseaseArtifactSystem.cs new file mode 100644 index 0000000000..520f953df4 --- /dev/null +++ b/Content.Server/Xenoarchaeology/XenoArtifacts/Effects/Systems/DiseaseArtifactSystem.cs @@ -0,0 +1,63 @@ +using Content.Server.Xenoarchaeology.XenoArtifacts.Events; +using Content.Server.Xenoarchaeology.XenoArtifacts.Effects.Components; +using Content.Shared.Disease; +using Content.Server.Disease; +using Content.Server.Disease.Components; +using Robust.Shared.Random; +using Robust.Shared.Prototypes; +using Content.Shared.Interaction; + +namespace Content.Server.Xenoarchaeology.XenoArtifacts.Effects.Systems +{ + /// + /// Handles disease-producing artifacts + /// + public sealed class DiseaseArtifactSystem : EntitySystem + { + [Dependency] private readonly EntityLookupSystem _lookup = default!; + [Dependency] private readonly IPrototypeManager _prototypeManager = default!; + [Dependency] private readonly IRobustRandom _random = default!; + [Dependency] private readonly SharedInteractionSystem _interactionSystem = default!; + + public override void Initialize() + { + base.Initialize(); + SubscribeLocalEvent(OnMapInit); + SubscribeLocalEvent(OnActivate); + } + + /// + /// Makes sure this artifact is assigned a disease + /// + private void OnMapInit(EntityUid uid, DiseaseArtifactComponent component, MapInitEvent args) + { + if (component.SpawnDisease == string.Empty && component.ArtifactDiseases.Count != 0) + { + var diseaseName = _random.Pick(component.ArtifactDiseases); + + component.SpawnDisease = diseaseName; + } + + if (_prototypeManager.TryIndex(component.SpawnDisease, out DiseasePrototype? disease) && disease != null) + component.ResolveDisease = disease; + } + + /// + /// When activated, blasts everyone in LOS within 3 tiles + /// with a high-probability disease infection attempt + /// + private void OnActivate(EntityUid uid, DiseaseArtifactComponent component, ArtifactActivatedEvent args) + { + var xform = Transform(uid); + foreach (var entity in _lookup.GetEntitiesInRange(xform.MapID, xform.WorldPosition, 3f)) + { + if (!_interactionSystem.InRangeUnobstructed(uid, entity, 3f)) + continue; + + if (TryComp(entity, out var carrier)) + EntitySystem.Get().TryInfect(carrier, component.ResolveDisease); + } + } + } +} + diff --git a/Content.Shared/Chemistry/Reagent/ReagentEffectCondition.cs b/Content.Shared/Chemistry/Reagent/ReagentEffectCondition.cs index ea5b2857de..13d1cb37ee 100644 --- a/Content.Shared/Chemistry/Reagent/ReagentEffectCondition.cs +++ b/Content.Shared/Chemistry/Reagent/ReagentEffectCondition.cs @@ -1,7 +1,5 @@ using System.Text.Json.Serialization; using JetBrains.Annotations; -using Robust.Shared.GameObjects; -using Robust.Shared.Serialization.Manager.Attributes; namespace Content.Shared.Chemistry.Reagent { diff --git a/Content.Shared/Disease/DiseaseCure.cs b/Content.Shared/Disease/DiseaseCure.cs new file mode 100644 index 0000000000..e933c9e591 --- /dev/null +++ b/Content.Shared/Disease/DiseaseCure.cs @@ -0,0 +1,24 @@ +using JetBrains.Annotations; + +namespace Content.Shared.Disease +{ + [ImplicitDataDefinitionForInheritors] + [MeansImplicitUse] + public abstract class DiseaseCure + { + /// + /// This returns true if the disease should be cured + /// and false otherwise + /// + public abstract bool Cure(DiseaseEffectArgs args); + + /// + /// This is used by the disease diangoser machine + /// to generate reports to tell people all of a disease's + /// special cures using in-game methods. + /// So it should return a localization string describing + /// the cure + /// + public abstract string CureText(); + } +} diff --git a/Content.Shared/Disease/DiseaseEffect.cs b/Content.Shared/Disease/DiseaseEffect.cs new file mode 100644 index 0000000000..bc40bfc978 --- /dev/null +++ b/Content.Shared/Disease/DiseaseEffect.cs @@ -0,0 +1,29 @@ +using JetBrains.Annotations; + +namespace Content.Shared.Disease +{ + [ImplicitDataDefinitionForInheritors] + [MeansImplicitUse] + public abstract class DiseaseEffect + { + /// + /// What's the chance, from 0 to 1, that this effect will occur? + /// + [DataField("probability")] + public float Probability = 1.0f; + /// + /// What effect the disease will have. + /// + public abstract void Effect(DiseaseEffectArgs args); + } + /// + /// What you have to work with in any disease effect/cure. + /// Includes an entity manager because it is out of scope + /// otherwise. + /// + public readonly record struct DiseaseEffectArgs( + EntityUid DiseasedEntity, + DiseasePrototype Disease, + IEntityManager EntityManager + ); +} diff --git a/Content.Shared/Disease/DiseaseMachineVisuals.cs b/Content.Shared/Disease/DiseaseMachineVisuals.cs new file mode 100644 index 0000000000..4254a436b9 --- /dev/null +++ b/Content.Shared/Disease/DiseaseMachineVisuals.cs @@ -0,0 +1,16 @@ +using Robust.Shared.Serialization; + +namespace Content.Shared.Disease +{ + [Serializable, NetSerializable] + /// + /// Stores bools for if the machine is on + /// and if it's currently running. + /// Used for the visualizer + /// + public enum DiseaseMachineVisuals : byte + { + IsOn, + IsRunning + } +} diff --git a/Content.Shared/Disease/DiseasePrototype.cs b/Content.Shared/Disease/DiseasePrototype.cs new file mode 100644 index 0000000000..d158045fa6 --- /dev/null +++ b/Content.Shared/Disease/DiseasePrototype.cs @@ -0,0 +1,68 @@ +using Robust.Shared.Prototypes; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype; +/// +/// Diseases encompass everything from viruses to cancers to heart disease. +/// It's not just a virology thing. +/// +namespace Content.Shared.Disease +{ + [Prototype("disease")] + [DataDefinition] + public sealed class DiseasePrototype : IPrototype, IInheritingPrototype + { + [ViewVariables] + [DataField("id", required: true)] + public string ID { get; } = default!; + + [DataField("name")] + public string Name { get; } = string.Empty; + + [DataField("parent", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string? Parent { get; private set; } + + [NeverPushInheritance] + [DataField("abstract")] + public bool Abstract { get; private set; } + + /// + /// Controls how often a disease ticks. + /// + public float TickTime = 1f; + + /// + /// Since disease isn't mapped to metabolism or anything, + /// it needs something to control its tickrate + /// + public float Accumulator = 0f; + /// + /// List of effects the disease has that will + /// run every second (by default anyway) + /// + [DataField("effects", serverOnly: true)] + public readonly List Effects = new(0); + /// + /// List of SPECIFIC CURES the disease has that will + /// be checked every second. + /// Stuff like spaceacillin operates outside this. + /// + [DataField("cures", serverOnly: true)] + public readonly List Cures = new(0); + /// + /// This flatly reduces the probabilty disease medicine + /// has to cure it every tick. Although, since spaceacillin is + /// used as a reference and it has 0.15 chance, this is + /// a base 33% reduction in cure chance + /// + [DataField("cureResist", serverOnly: true)] + public float CureResist = 0.05f; + /// + /// Whether the disease can infect other people. + /// Since this isn't just a virology thing, this + /// primary determines what sort of disease it is. + /// This also affects things like the vaccine machine. + /// You can't print a cancer vaccine + /// + [DataField("infectious", serverOnly: true)] + public bool Infectious = true; + } +} diff --git a/Content.Shared/Disease/DiseasedComponent.cs b/Content.Shared/Disease/DiseasedComponent.cs new file mode 100644 index 0000000000..6ad89a790c --- /dev/null +++ b/Content.Shared/Disease/DiseasedComponent.cs @@ -0,0 +1,12 @@ +using Robust.Shared.GameStates; + +namespace Content.Shared.Disease.Components +{ + [NetworkedComponent] + [RegisterComponent] + /// This is added to anyone with at least 1 disease + /// and helps cull event subscriptions and entity queries + /// when they are not relevant. + public sealed class DiseasedComponent : Component + {} +} diff --git a/Resources/Audio/Machines/diagnoser_printing.ogg b/Resources/Audio/Machines/diagnoser_printing.ogg new file mode 100644 index 0000000000000000000000000000000000000000..51d8863d91ad6a3627a9f06d525800e810160867 GIT binary patch literal 59000 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 literal 0 HcmV?d00001 diff --git a/Resources/Audio/Machines/license.txt b/Resources/Audio/Machines/license.txt new file mode 100644 index 0000000000..b81583c745 --- /dev/null +++ b/Resources/Audio/Machines/license.txt @@ -0,0 +1,3 @@ +diagnoser_printing.ogg taken from https://freesound.org/people/RobSp1derp1g/sounds/615419/ and edited + +vaccinator_running.ogg taken from https://freesound.org/people/RutgerMuller/sounds/365413/ and edited diff --git a/Resources/Audio/Machines/vaccinator_running.ogg b/Resources/Audio/Machines/vaccinator_running.ogg new file mode 100644 index 0000000000000000000000000000000000000000..604d385b8e0db43c0f92219046f786c5fd938426 GIT binary patch literal 70344 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 z znf4Z*D&39W4|v|@J0vX!$Ukq0$ho)Uceo2nl8+*9WaO_s z6dWhzDhEYQKJOG#3>VSs@eMRltS;VQr7*k|-$fU!VE&KJ{_b(GMlOH6#UVrpPn}w?d<9q>DqAOKIt9N9 z-){Vb|HCWS*4d!&h$W=fBUNUu#6joQi8twpvu)h-!09_H+BNHXx2;FdeKSy8E~jr= zM#q2fp6fP>DJ@fQ!WS8_BExHCWtPh|IBFS zm-OQzJQD?CpWj;KAH(05zr!HjP|A}R;6ZOl_-d)D5q3!?cSXb2&4*KE?50L|I3Drn zn2^iJ-0BWB?}oqiYw9|u-O;YFnIE@<7^pv=#1XW}9^ioO(A(x|i(U~8DFW^ilFUqD{-db0D zQL?UbasIr&;%?|vq1Q=qA#cPAJe2s$sq^4s%-*2)nIxe$7*g;v8NY;u-(6FQNkS#tH$YsAH$6UBLU10FOk*FAp3MZONfKP5U2TtLExZgXHS~Q~U-F}vuHt?0Y_Fm9 zV_yv8`Cmb9l3Vx7MiM_`_#IsIW451Ab?I;iN!5E?a{G0aLLO;6@OF2aJtdCsT^ndG z)NQ%l`^zXTF_ovxJ@VF7?;9GsysG?edM2B0+alMg6PQyH>lCm1)-A>&W4|+go_zU< zTg}bRN|xqJsuAsbdvA~&%VCf;?;x1R?w)Mm$W$n7@HIg}_CjSs-iJ_bHzzKGV#jn3_+4w9R%Sg4ri$n&A0v-fDNu7x5h2e@eQGmQ@5#=3- zOg!OEZ20lxYNPvRMwnd3lZlhvK85FAU#T{Gs9QIxM!qLs^y8DbqoB0epP79aOed!tyLl4<7$Vk(c0|ulb9dFaqeS+FO;<4trqmoX=uT+NEwQ~9jD&vyy=;Fm**DE`(1Nf^ou7lhzp94*pxT~fpnRj^@gFa~@R zEX;pulK1oSFimlJ+~}U=W}+fZ&yA^_=eOzKOf{bVX+wEwbla~tM=kb}$_+u`@<-`C zl$*6#+vP9OFVma5k0l?UZjffpS5h!dOgvphrp^}ER2AjwBm8*02`gLw%w=Gk`pV|d z(^i3lV}z`S?7>Z4C%o4B-xeQpui9Bq^_PeJdLVwWsqhmzT|jGUC5&R#L~#1pSl=C{ z(wTGBY;jSRdY$uW+^0Jlz{bKk%lguA*%uuZ_v^;?vlUCSDz@eO_1O}*biJ;+2OGM( z1PLQo<^^$M4Wf}}+J1*p5-&0yvwM=IEEDjFQHDn0=M$ec*7FsaXx7iAOjmIrfjgTUiG1S8V_=B1U>cFcO7S0chh~ zv!U>q+WJsL{YoLi{MhE`lE>)pZ?J-fR^vaHJX>$gpX&Y~L)C9`GWe#)`6YqJcl?HQ zJ~0tEx^J1FwX3c+ykg)j8o$S#GVA^NN0)6%mXmn6qE&~+@Tfl%WtB%sqN3qM9IH6< z?)-S)5bqxhTaU!6i#@@oc@8(6^rBV+Pqxa`hMkZ*R_r=yh{+AwV7;+@Oxi-WI^otW z$2W;YWeJOgd(Z*5UEEEO0HQg443ayFBYD;+~+v$*0*LzE{-VDc_>~ zN)yMXM}ysVS{YzcCQ;ls`kC*LGXocwb=nK9?71yM;1-$=&Qrt$A!Z z8|q6KhT_<4l34D?0@oRd2yn(JXmd|pW;h#Px2QOOxTw6RP>>04|`tw{y4_w-Ba#|A6Y|u zizNq4z!f{8ZOZ#RB>46H(M4lo%l<@;HjE9LG>NE`C=i5VVCJb7xL&yYv7S z=9t@5zjuC5a4OZcSL!J@YT`ia72#5p_S4>zU&6kbVe&P1(!MHaoXqutVhA>6Q+zaDS@RJnmxYL&_M&Zg{o?L&)t=_RL#a`Ca)Lv->(+X44gnce~W^nc=BV%v8FCe;UCAINjuwjTB#L;b8egrWTkk2qe zlY-jyi{Gq2S;k?GSvF1Gi=z%WOwbi+vUwf!^TNig>`9ur9^Hv~OLOL>W7maETe{V1 zgV)WB68V|NeH4EcwPbW~*wj-Mj$6MGZ4FyeBUiRG{d!o{Q-nymN2RIuaxfLA5_Q36 zA$coMrcD!fJQD^rB%2yNhIq-v>@&I_rj9~j_x*-`CM8x z$X7pO=e=&6^dStSbu z?Q`6eHFH}vJ0_=i-iUMQa?TUP@msb(a?1tmE)7wO^}f4%*ko#*6X9Kw{{+KblypVa z#!&B!=9K1~c&o&7dN3Npgk6n41Cx1T;ekrH#I|y|5YJ%$=!TZ%LH>7*XJ8Dv$7wFE zU!7(u`C|W2t_^YhQs5#}Lim4sqI@Kh{+vl$G{4vqMcaJ*N*S@`Zc=mQS*bY>RPxsp%vp0g1M_=4N z-rJk8%ClrKav)|zdx?=Y{avV!jNiRw8$7skYUVon153r4v3aD)ghMx`)!rVvsmgJXARpKU7#c)IBshG~!KN?xn51V8(TX zOy!YvWg=%=Od`QBh!~f_qO#^p9R&2(T5ET>Pk$67-|hJocQ1t2v&m$0>`P^nOqd}1 z(_aBWPMO;l=3EsGPUVQyTzOY(`%pKwk=m8Rt8?T=bAk77$jvw03s}92mpxm`Y0RUa z_t z>E{PYEf&3oIrp!wws1Q$iM;+8{);|OA?w)NuR z^RAvzR+>6h9F0m6t5EM62b^|Gs0XWu~ULp8>@kyRveMV7%CZhQ_aOa`sN2%ri@* z^cQgU>rgGlTjtTC1?MF}JR&KH`sF%k(}dwC8XY_2=7)c8Nw|LT7{Ntq%}G4^;P?Ic z&*>TE4gVL1TBTjmeLX*n{SzXv=*;pF_t$+rr_&d;sdVrCyz<`YscTB2;+}!H^85E! znfZl>cG(?uHI2;UuyTc$QrKS&C{ckI3}-4_E24CNqAQ7ytAB4`g8BUF826zM|A*f^(BHzk33M|V5w>FEMmAvB1mns=+*sQ>)M`RP>c(!;<7J zMlb}kk3}I)(X<5*;euF@FUE8(da2~80AhpDw4&H`Z+7Aro-Qg0me2?r*-|ZQX6Z<; zu)s%V$2XszPoeCNf8SxZ+^=a+jAppfBJ<3(vB@B(&R+j}I8(Ry)@S%9CH&0J$2o5Pl*J`4{dyjnd!c6(gTY`DJ3gW>QfK6L-Q1_?*zq?#?2Nzr zrguM8i)*24=X8G0J^c)0V0e$@B*E8sz?Dn75tQR7u5As}7|Te|FDq6C)KAIBl}(_AD`HahKnzb$2a%cO=${(&iR{^ss&@OQzQ-%C7IuZHsX$eOw3c97<<#>J z5MM@4UcUT;Ufmk?^GRifN5_X-v(M9P2^#6^(x$WO-}Zkv$l0r^-dUtIG(N`|EH<%N zz#x#$wpTlW#<-(Pd^<&G?PW+QA3usuWA?xMC|TmaMT;p3y*;DvV^vqrNm^(|_jNx5 zQ`izCisA0J?YZ!4W4dtZ3sGrsl+UL-%Edk@1p?{DS`)w52q7kO+Nl1ukD2OmuTH5O ztO!0WEof~QSXaQ8@|D0f@-%A=cW>lSX}o+&7gM-p>%Mhdu|YbhpEDvT=t95lX%C7l z^~IB<5t)301|}p=W(ech6D2TWz1iU+TjT zeS@1nTqsrft~3np&jnSt)5$!A$uN}OOMTI#`Nc`TrPjBuwwN(3ZlYZ#J@wwmC&dxg zn-`h0H&-+!Zz-8;E}v$gCAf*y95=RFzOJ~Nbyh^1`LcwnLvW+eh|QU}n!fJ+NH=Nj ziOdaaX_dNHFA4&xzT_(|n|8Ovd}S_^KmGFg5WoG6b4=%p0;Hw+Y_EC5>a(2wxgkDT z9Au@_RQYRNp?SNLAFO^k4gc-h&eqfxu(lj)I>C}$iX`qoy#@qmIjacLW^C0R-^Th> zEQRpnTrz7Atf>6pj*M#DEc1+@ErV78hh-6_41m)ZBLIt05EjMdyiR1`f)-Yhq-8Yu zb(0O>;BAFD)5|1=DKWiH{}Lbe;9IsS{Gv)XiZ>l!ue5c;eB2xSD(8-czY?en%PRPK zysp=3>HJE9sj4iU-8HADuUaSud+6U1oHY}|4ERNkEZ0g$*=VGrU21tS1Z|_mc z3YPtGQgS2Kr1yYe^p#U>)Hed=BetxVmv@w}cRBy*2FVRqbEC4}KGh=?W$av@V@g(F zq*rJ9(QcM!zRM}r;Kl1At|4%pqr*Jpbe2FY%t~wQSoc}M1VR4TT$5o@=?6{a)a3$! zR$t&(Qiay&AEK;Tj(m!neY6M=q;5>yGy|>LG58)azz_m@Vc;7zv0+_OTMn1ZXK>Qm zBmdF{;}ku#$mOl6Va{H9`XUmo9W`oc7=Fe8`QN-T#!rP-Bx-_?N1<(yRO+8<=|oh$8LMT6u?v--EPDrT+ts@ioN5|o%HCuQ zOZIbv_O=%s!z`|uF(!A*jEzq<>E4qs^fT6%3k)8lM^Jkx^WMEYE@ zvc{#2uqCblkCn$EXHDK!QD>hM_<2vQUnA}7zKj$HEa1VR%tvefyDyB@=rnofca3{Z zVee%Enq?2dP70bt9!UB~oM1x4G*j8qcsukc%JaXtSdriUqJZN8jR5Eu!_q6)d3l`w zHQ^I(#OxGdj65CIn2mSO)acfi>h98ySiSwSnIvDNrY-mw98@Pn6y4s-<48|Agq#Wd z%Mk}SP$s@pS4pCVsZf#QI$$&?QPBFlc9Sd7lh`;X*LW+W`Hl6XI&*CoiyqNY@`KN| z?`E%aW$NbY>oQm^O__>{N&=293|&)-O_;Y@80 z`8Ku4xnfbm3u7gqHxlM^YcvI z&BiY?H-ZIs7c)kjRm2p7?>&pY+56(bHSebz5=Q;SS+~Or>n^&Of6pfLHz%b4!M zwOY{NcjrU*pD%4C`e_xg`RYOSzYmK|YR|`3zqre&)f;zQqv)!dP0ZaBi2?y*wEl0O zM(gPG)FGu~7B%{9^Hw=p>8>E@S;V_Kx^(N5ymmOiJ@Plk`0A7Uc(I+-HXuSE7m-{#|1y#Bm;=(NHs zHo%)NG)8OsD_D%;^86AvI&$j+&7>&(0sw!=+HosrbVOkiil$OO|4LuzV>Kcpq{?E%T zr&7$CNncA^^OdBQ>~nk97Q`dhL~GxT`e)8X-FS%F{ZV*L_lI>&@EW0}?6b8-Dw5vD z{951R=NoWj@OPfkgS8C%L&^1o_U8Veh#|TDhN{inc8- zGUPrH-B@;)h(LtwON}U+36!L+1aVDwNu<8EK$;EB*{7D#r ze?xII0z$2LA&7^pbX|%zRc-fnH&26e1yDIqi^X}}f&=vd5xnLs>Ajh_4Y~oD4;`(W zXTlNx(1ABV+?n#gHsNxDlZ>^T+?T7E0}}CfB(2nVfhPkg7ql5q^8AjYo3yX4|4}Y1qDi7Y?iu)+rz!geNjs_ z7UiLH6#9h9=Vs5t1qfrBtTfFV)9&73FoxtO(yZ-`-eTnA3iax0$f#*u+K9&{27;~) zSywG2s+q@gm}D<4KJ{l33*_%JT|+e=%DrZK`3ozc>G*z{m2rfr>Ud_jug>onhxk-7 zXJ)L~qoyuE8F)O!^=2H);)=x%O~WMx;6ST)pA>s<5T=_vqek)a%UFRfp!66Z!O1=G zfpj!xg2rvE_kPz5DS|fK!A}^oJ~0#qLS*63Q(3(z15ef4$lmzQ+fVz=!F@@40ptZC zsDw+ki3`EPVWL3{%<$E1pw<&lO(lZ+0{t%_te6Cc^+u|!1+j2pk{Otl_q{n;c?zQ1 z-j*Emu-NXtcjDa79V5mHY~FV*Ij3Zo(3HZ&y44m@l>7rlmO3T&!zW{~vsdpLaL8B9 z9rj8xIt^xJqIKLxFP&|_oHFs#^msW{eN=(rJ?ix4(wEzcgzWexa_)ph_oFLE{OWaA3+X zTn!X7CeQcm4e!ptCgEZ}=Bv;NV=gi%975Q8v-fk49h4r@jra<)J_}AM8_>%wZ zY8;)dco6L8j6Kvo)H*zUsCIbj@9_yWCPbRYpdZ046TQS8<&kAMyZ~sn*gWqp-0TwDX&_1B9_&AS41GARWrd zCfVKc*=I`ccG?qp~S}Z@4 zNM{YvY}y3OZYrY!8(G7nBp&{=iKjVEF%Sdi|Gk>rs;|Ysnu6Tzurnn%KYI}(#6kFy z|ILg=s*ZAKX4pQ`$;^y}Vz;=^pQ^U`VnMBFarkS=zTjqG4Aqhk3(Rbs6TqK(!{ECU zc!1>wW_NfAl-sRRfOs%a8YCvd@KgwNx^w^{?ZF=;&<9H}VC_Qbl;7n{xq&EoxDwTH zE{AwfwxPEqh(e7cSh~%yNI}8X1?P4XQ8OGP^TOE?=tvwk3=E)&J3!4LiJD;v2b{Z} zwLBPVoqFi=y}xHZW!KE{fvY;t+|`<2vPthozoqO)Ev;VnpdqbO@`ch&ONvBT%|@RmHf)o9#GRQ%2%pW}Az*U@U3oh-X@UfF7bknH&kiCPm;2`^TGQ~Q{q z;BWCoc$V9K2CX#6Mtt1YgD`8!aM$b42zsWnzi& zQ;gOIMHZ(%nuGk?1XkTfjbvYnh?!7Uv(*9RpMHQn;&L0lvuMwv2z=o4g{io9!4`r8 zRKbiH9PEeCh{pd0W|H+V;!id}6ak5+$@d9X6^ioZ_+<%g!wK?B1tO9I#+xeC%lY&7 zOTUF*&^gHBp#?z{{#2eBjt9<|TS$AtE67dXD*{2gjpY%>6jH-dPDHG=72&mlcu~TT z3aP$ADl|Aw%sXev${<12V`rNCM$DkFSh~Dw&RT-;E04W_QjwE#3iA7;45^c8zsJq( z`oN5BMMw9wA`|tO5{a?Y;)Pg|)<+jZTVGtb_sFQ!yvjQDIJXxq>s|nco?rg6>QrjZ z$@;vFIeLCKSq3Q%K6tTjZqqS_3NmU^hXDKT$HbIr{e{iTvf{aCE+uPQ))^&oY#4lF5(ZSKJ`%*d=AKm+4^8NRwoqd6+w_`L3dkcz zVwY|v(oiNwVu%xiIvBm*wv=LsMi}@qy9X!!qz2BF#8!dF-GfiQ+>dwBh~lm5XwxEw z%EIroQiU<3wTT8Doi$QphE@^)8LzEnj9PWkN|Jy~8I>EMl7V93GL0d2@?nYV0J(4( z9;Pw`bUbZa!P$BB{tngY^k$|*g_>K&7EhzkSaM&|cb!ZClk=%;7pm}084e)4g^T^f+msXZr@ODu`Tb)}e?OUMOO zQ~~VbrB30c4a36`FDJ0uuZdn=F|33aDsYpl)dSv8f~iv&{QDIhSj6ljZ2*g+!;n8I zEI76QdJXWic~r>ne=q<)B0s+KI({k*7yV?D<>FnHEI8N-bO#IP00@AS;W%xIE7eq9 z21?03$AzEkoj^X2yKHW5=7R-@i$g`)!J=p-)GAp!Nx}?=Lm|lZ=HxjO1y!MuC1akplPW%hLU?V$I8S~fLxcX+U#_5~azCp{wQ0r50S`M@IHA>W~E_ z5yVu{t-Q zpIoYR;TNsEBD9du%$01G+3HS(t_YyRFSgbI@=aSnWV(GnP*tw&J3AnR88IQa&_1*h5SL(3ebYohF?Hoo9;wmkOWN~3%tyssyW%3<9`GQ*0{C4(Uldv;J8$$^tG zzn1zkqG_NS$C;jlqOTnBzM$WE;~x0q~n* ziS)IZ5o~u@!-&QbWDuHH|8ZXGORh)PzIaZ`8DZ6{q6^cO;4(LKoE3-zxFT?>7D`bH zqb!rl|9osOFm~;|sk@#q0?2x`6)jxgdHL?;%lOS9GCWcxVhziJR4fE4K|?TO?YISf zthxijtc@Dx%Mthj!y#hw(tXi2>+CYsnf6AH;{(+?ddIqRyn^>SEE0XlDns_8 z97S(F?QAuXx=73%vd@0fNFJKv41yOY4)^&&-HPtlyflh^GT0cK*q)nHg8wnl5?lS` z#qqA!&jfR4gG#r3Y=X_6<_Z!>$&zCHBVv<*DD*uOG-g3Py%@irkW(yF^jwh!2r3^- zp!@l)lAYMsixgGlBdw>lvK+`@h&>vuaV1TDYE6bbr8^N0V8%O99JH#!Fd2MoFseXv z(6^bQp#mys;BDamykP`Z{JRwg??^e;c;Ul6=S?coZ|J{MMhY_qG#PfXy2}em^-_|4 z=MMnij&UKt8p6%X3=4ns<)!K*q%^ab#EZ@Nq+S@Z&432``(-?;t4K3uL0=u~=R9IN z#D)klpKI0RP^n^$_Ra_EB$dzeA_=6j>BoNA z%oVQvr;wrpJ$k`!>EzCte124(lHEVA-g+-oL;%QNegKj#sTo{A#}{5e4sBmLfa`LK zc!jh7{WCDMoVL+5PkE@s{JhvO{2jl=O=fIz;2U!srb!Y>?mG2@3EkHN2YXF8@W7A)1R24A6XcZe z0JKAjS4DYt`^KNMh~Q0Op2Ta0f&;Xq=p+DM05TUeL!3-4(?KjDkj>Zk>X_FGg{`+Fto|-?_CujrI>8TPQO6-p`zT z*Ep8C+`f<^!8?H+pi-ljygGYN;MJYr?`aNBNm;+So}AX@YhW-lVD1B270yr1tw2j7!Aq;u<37w`yES0lDaQIh76$^) z(1G9Td?Vx;zQ>tpvrF?Lequ5o<$1NWnI~usky?7v%z$m_)&XoCK0s*k!-ZQf`5hFD6u9 z&p8`>S~4;BoeoVbMPG4u{2J6AQT^csEfdn`_q#IPwlnrwJ@N+Q_6zI#pJiC+^bVzJbs@!Rt2HVkSu+6uZ zsvY0(0~@rBsD!8X*aDhl2C(pg0klEuGb?KFz$v_T^TasqtvR+oE?3zng9PvJs|;O_ zXPdvx&2`g@Fz_{~pM@4|qrez|ae=u@?h)Npj3nxV3eP5F+ht?^-~|9}EKucZ$5aZa zMyZGfrQJX`tE*$fGH7{_rg8B^3Xn>nPc!(k<7If>5IIcw&nI`)_P7$cXv=rM&sMRQ z+!Clbu+v}3?!ElhvY6(i=F+JCB2(5?EmL2q8^#7VuVvi-5ag>?71v((J3C)QxJ-Bx zA1<{)FzfpAr=E2Aoye_due0=Il8@e3bF<|N*hQ+OQH7XdPI-4rt&T3wGFXt8c2MBL zsisOF?}z$qHke623~KHB6T{#&AtaOGbAKwawt53#li1Y9isbd&wZMK!ky@Y$??i&{ zhX5Zv@4W;H?eS&{d@LA12io4zV-~J>gaffefLS|)nc+Urg701>Kr4Ds2P|-cw!7zO z4V@29GXOL-=%?GJ;Q|L!InJL|yyX+tPExRbJ zSgFm+%PWlV0u_K}=A~xR66DsYAjlmtv~ARF$A8p!4f+XARWBPDpI>w29q$b7-4NM< zr4=$et_7%PiwT;_k*?W({iJ2c_vS6%kgFoz-Irab>Zh;Mv!I{z5?_7EzIsD@t*os^ zW6c$SytSh#`LH}wiVZJHYe7KjKGiF7VW7OUDL~~Z3^6%R3)W}JjREI$hnb0QMZw#-3n2X4eF_lL z$wtQgrUUH*mKen3J29}`Pl;aO25ks2pk6V(TfZf3Wz$A7Qi(ER`^5HD2M#V%1R+?s zz{ymhVP<5kJm>q98Gk~_z0;>`_KqP(h1&RCMgeNonSmuhD+Z3byEde%rs$;tgTcM9PshNI_izj}jq_<40o#JB4ma&YNYUqm|mx&g_+f9mG#oV5lsf~#jbQ`@FRX=Q%k zDc&#}AKlqUmQ%%|69aHW&iYwG?2d*_oB4SGBHP;s6u4~}Gh~CbXl+Bq9@PRNi2(}& zQWLdj9VpBe9!p_rE1yw0V3s6w`KgZAQ7m*OXu+EOU~P-Ml^AlY1o1_^CD^W~0dLPt z-4_V#yBW+-Faun*MXqHRe%jM_$*ouQ-y4dAUe#In^%Q_J&?_y&)Xq*sxuJg_9GQmp zRiNwWH5Dr8H$P@AoBL26dLu;+Iz9rurLuE)9QuetS>n(c64{eeLO(R><*d0TPXQ41 z0mt126qAS;lqVw(*9-?USEuHZ^PAx!&6fs51mqsKYR3^jVAaDWfm&h`B}Z++eop52 zov*!5qg&5@eXCa`U%%>``{J{9brx;l?TwDTq9-`f-3N&a@d1x7O?#AwZ%fzWSU1m} zEZYxZ@YF=Yo~hoCUEHUS_CUfBQT zq;F)f;7ftV^7fY!6aA#I#GVcS0{6hP=pXE}L7R@RvNCdfg+ik9QJm%_IUjz8E;B3C zR_5$j}wiY+bMzvto$NsdO64rDF)PsbMF!2^4XO>SFCM4rb2_W%L@WodEvF^sO*3 zHBF|$w0E$f%Wjm$5<}{BS&5GWVPGu-zHlz=BGr_98KCl!pdzZ1QjepTI&@*%7bw8@ zUTWZQ*c%FDb+O2^LJSxp-(xe-NI@(<2?z9_0MX|SgZfFCUl)(}ggaQM=&YsvslSW#0P>%4|_Z-vdi+*|AW&JYRGL=7WSmm|< zD+P|Vb%K-8%%`jF3Zq%V&d}G+TzakZ{}6SRVNpii_MKs1=tdd=>F$o9Qw1qSK)O>J z1cvTLI))TbP`Z&4Bt%;2R$4lw?(6s6``qEjJoEm6Ih=j=-fOS54jX2eXOg_}WuSiE z1kK$@erd7R$1Gx+m_cqD)K4dEWKq5)8&b?7_z~ep6!578Jn7;Q+FkD-04O>rBz!=+ z3-V%~92l2n1xPDwfGC{`C~#*DM|Oo{0!i4&E@vFDm|;PB9zAAm6DyqVOmh&xdEkdm z&jSN4A9lUB0vP`Z*A7hO(ej6wyOS}al;$+s9|Fi#LQVfjByvScinLjd0u#$uOsuOv z%omWlk&DEqp%UtXnDzui(H#LUcmkH9Z0A9)0xt8w>|(}8S+1;N1J|T|ZpV7ya^|YH zvD;DY%86I|J!;;DmO18+1eM(3q{Fj#3jgz>s%CwSm8RoIK#`3SgU2i-_MAW=XRO$Y zl96_e?}0<#VyUHCF=>KNU12AbZDjz$4ea#8faVNP?_}6aKK21hv{FF}Xf=U7q$oN7 z_VK{QycZH$@)Dr$qT46>_&9L7hA=LTX+_+~BwXfX;Y{^#EskMshCs%O))LtIdHhUnClK-DKPr1``%oBl_vIb0i`tAR$9j2!RB6#K93KSWn zt%Ua68Uonbhfah%(kBJ(aDZ|tIw-Iv3LtK`0H6*6>ZgHB^bcQ5dJj}6Ld1UrRH|`} zI%Rhmo1)nQGQ(tkutGR+2S(t)sXmgw{0BAu7*oED8i6U~@Atrm0lFuR6a|5@Lsjbf zZM8Nvk)FA;pvL#UP*GcMsK4)MhQ{~wieq?c50alFa%yN=cSatjCEQl4dAlw@ zhqBOYv%#sF?{l(6YPny$u0;T!R=VondLR6B&$PBR8$REl^mpC%*q4F0Ojg1yD4{pU z;Skj7o0su$ACB5=1%)yaSzb#Ft?zO5!m7$ zfz$&(*=^9!K4uwN}0fhS&kbnksD}xH*F()9e6h+DvINx%)r0M*AKC@PBxpGvFuh=R@H{b>CYY=rq+T5gL``Hk`W+!g6N5nXu| z>AhJ=A4jgIEQ)wqs(~T;>_rd7*`Z_y)HP28nWky$t@z^5i7(44Vzk)zXmsTRCUr{% zR#$)Q7ppnNST}Vv@=CWoT3-{<(+`bfenDF9?qbDJq(DF{FzlZup4G!`4x!$e*fsfeZ;^)5B~TSe#V#@EZ~ECU^x5A+T3K!oidRQ46U$k{aH;&d+y z_$rF!u!!M`2*!YS_0mewu)*=Lh3Z0W2D@E=RFKHPa#vWZa>XeZ`1O>h0cfwv9;h*4eVZmZV>JZH4VfEbr$rg%YE6oHIGYs2VTLn9Eg3#RK{rJk9bJ z3bJ(>taW!-;tXGy8%ZbN^x}PufA=oG_z?BmLD`_hoX_srPCb8S_g+NvE>pK|N0%#^ z_HUGj-1@USTXQ`-w-2K4Hd14hyE_7@FzxAX7c^-_o}2b2-Z#&Cgudl~&2f{gCvOqc z+g884Jqa75iUAt2Z|3uN<{R?rz!aoxp!QxK73c4N!Udw16UIN+5u5(9S+ zC6fPYR>sEnkqSG*>*+OZ(z#lVcWNX?E-vE;S8t1B&o8fM`kR-8OoSwMI3k@ENVzLo z)wHZ?`=^9Bh^EW$60~U)nc~%Y5sS;zWd4?1FRYS6D=V`fhekEiT0`RJERtW{&p7@0 zDc-=PvY-;3m-iwjg?x58x3hJwS~8T-Kv7ZWnIW7}Kl+jOzW3}Av$la(pY{MLtLR-K z1_>LdtR)>GQ_#6duAWC1B|ByB`9t={2<5l7^&Qq~qT0(9?Y4+boNtYk%W_`*e92@K zCoU#05wPc&Dc;J;LPD$Wg)QaKOe!~{$QE2Y=72x5XS(n`S=}s<*$uL;EIPu_Kfw!< zlHgc)*=S;7_+YPyfNZsnx-?%beSSdxuIExQclq+uZ&?$5&wkMeQI*a)u`gvnh?#YB zWCOD}BU&HEM3Eb+IEz?V`iwgotNN2(oAif8!(_wfs%>v0i<&RIDdjZW-cg$}yb*j9aDeOWhe{=yP{XUa?VmQ)^5#_uH z>WnjfeeqRjI*X7wN3C3YGZ^FB?-SGD^QYWQa@Pi7mLUa(i<)<@4{nhKcWA>dSMK3I z>CK}}=R@#q@vzhIf&3lj?u4Sxh4zs|e?U|RFclC-=EJ?|kLd9cp})o;QfOTOIyGY6 zlP+8jdRT5gmowF9;qLHpgs(-Q`&%`vY@y4f;<)Pl;7V*arO5cNjA#DDhbG)QdBkbn zb#D71lQOJKKJ!wSe(Gh_i^E!*2`{vQ*<6%WqZQaopD9c>vax)ufuc^mJd5|(u+%MH z7vb;&>g%j*A*87{_93B3={39ND&;0RJR1v2mh#KV;v(HUQ74&+jXrn;m`K{iz*U_u zRHx#GJ*kpaRBE&85#xW_*q#@sGk+{L-T2T^SJV^&2p(dv&UnovU+w~pp$a`s1jAi;VC%pMFA(|B$V&D!0 zT*+1-_ Yr`XnmF@`_XORM?@A*l*{gJ^ag0Zd??0!gIa0Fo!kB89l?=;Iej=hNMG z@IQCr*D+P7cKh6(&Um`&!NgQ|?{efW9ki_V`rhk#X;X;gtWg)l*V{P6Imz@P*H1Z$l-|GPj);tkur_Gn zU^u^guP%STXl^X@-Amt*{BL8;0|fJj=y?L#&^ zx+Rc9+DFc!fojI$!@OHTAn1hH#%NePz-5Dh`BB)o%VG;?Zgf_i#4oAfdwY2kvlV&r zh6Ugw%t>ezIDG+0=>d1ya&RcTU_(91~7_XQ(I+wtqyRMA) zuh!<%h@a7Esr$5Xtu=jWm_tITj|0Yc^upiL3KJRJJEqCi&^OhOte75Kr%Z?F4;y76 z*DmR2#>(k4Gz}O%mZ(!u^n$m}f%b)`D?`@r9_(s2ecQOfNdWXoX4Z{XEfPO=`d!R(&$WjqJZPDUR`+c}mffT1O2!TED+=+>$b5590R zwd5>&pWPF857mM`XCIatqVTQj>D=HFc4GE^8!oXB^LM3kX=?@^Rk-{Bqvv{W2=Siq z>`(^{PaEYqg2Q{V;Tj7hmzA3Iv&9aWxh)A)! z<17+-ZSix>s1(Wk8H!Hv>^?&J>dPapkw15tW>wPmxXq~)^jT~ktik(_Vw1ULhS3qV zQN*UnuQ;^0%e{p%fxx+NQ;ZulGXcJc3p8NN?1>;I4bbI^zR=wr>@|jxa|dC61^HT# zH`s+S=80G5L9{X;v9UQ4Kh>Q>e5G^z`1_n)FpgoU;izpefVSnFnIy2+RElqvKKA8! zxFo)rqnG?6^J$}p`uil^3MSI-3%rza!ggr^q6@;E6(Rp`EN^O_%buo zOQ@@xjA=%Aq+d}gMR0W=ym{3|Ex4a3)vtLo{`8Cd4Syq3;UV4YWciJ&z{m*Da=_X& zAuTU>o5%yB-=7n;N=PdKEDbiirM0}4qt0c>_%{TQ7kHt*0#rlbaNhIiI2QAo%eVBgzq_s(>I zu04B=k?_ozI5dXJV{i<8K_f$fE;NJWXW1jRC7)%!Bju0L#_r|vUepw%%_-VAm{!L; zDXyg6h1mYHtIScM#}Or3F`)qoZ>xDLZ0D&o#6P+@+_@Oss~jb7R0swd+GP;hT)Ru? z-!=+3$2;U3gk=b#?h6J1qIL2)tyxBwI>F7LwWJ^eF5Q0ZLy9YB0k``P9ZW3I@Bj4B z-!Ut2IL4wFO$qQU6(CDPUwqK#aEKp(2O%)hkGq1zK(B`A4|PApRE-LS@x2D%-`#)} zP>M#<+KGp9pwNfDX_$G%5;Z=>X@_sQ{-+_7(`_?!>X9U4KLb&n?o;LSx)reUn%1k# zLhF5J^&8(|f9jiHaM=Ar-c1wc7%j3}9T$LS;ju<6Cdb<%j&cp$vZVJDPh=g8jS6== zJoZzNFqg&`6$#awGhQ(> z!;@vjNEL3&s;pax<26o7YA`|UeEq~#{YpD_qK#bAa8*E0k6oBS(78{e{~J`3XnYE` zm*7QKq?36W`oNVb?xVsV)2^;p!C20p{eCw%YfuDnP*-$&x4Vq2NGZV|jjas=I3$^b zl;e*`kz3q$=(c!<3J~CKcJm57iXf~T3C1cwORd@iXUS2aUd4yeiD9yJnL)cC$PEAh zU1YXeBVsn8E8%MkKOQ`cdsn8G^SZ>VhJ?apc$FJVpjBhgTb|U3B(JAzA?x8(zOf$pcztT_zl^5<$a<2Xv+5xN>o z1@U1SBl_Vfoa{<@Z6f6lsxIlI=h3wun)U^!aF!$K@1Bq=8S4#=zJ&&nXr_heU@LK| z3v)wMf{)4UncrFzi`Ugf82TSgpf`Dj(s8Q)$RFAQ}zZ|{4Q z(sw0n@J#E`Xe#|lq+ya);3Y&Mg^1G6QEJePO7}_gSH(55w1}^7Z2G$%Bvbq-E~8^UjaG#vm>n^Ik-UudQ?FPhUCZ)qG+JgPPLtshMu?CvX5I)o(#X# z*0}g=R*qCd*2Ahq-k%QyoPBImCK`feTeM61ZE{3d?}hb=fvVXnY~&94iG@Bcsf#<` zqA~yX0!=?e(Z=70bI%n@L|;mdf54p1|Hb;EU>yq4{X@;^f;p`z$%vnq${!g3Yml#E z$G7ZxzQ;QDb&~0I^bjnj_Z6&0{bl({@u31ODqigBA|!|I*9u$I2?)$)r%;!A z|53d=jbC^-nb{%Cm3>PVJ)uPfmbgl$Som^txJC;gHqi^GCdLOtO_%DX8xAJNP>jVw zG#{`X_zCQL{0l+Q)x&}91GMX7-j9N~;dA@Cv;F=9YiAehqqN3vqt?5xQ(J$srBtkv zzF4D^RUV{PXU(`andwCtOVE zhkvb!RE{Jl-!fK)#2B}h8jshINS%+yXy|>y5_DVfr2wE})#eTI_0Fm&5FVdSsu`LLg}v#wMNJ@R z+e5#DYd<)XJejzq^FC+L1m}{58T-t!}kIWsHrRy!JY~*#o$Bx>51eMK-&t9MB7Bk1t0Jg zqOri)fX6?4>B4z{H?L2F<~Qd%sjP$UmT%OGijf`<`<_VfJpG>9?Aq>D77{y$V;tMw z<%p{GcK_~Pz!qKvki8?((7~c0OR*&!y1iCJp-ykUlOp*ehPUY=Y8+hetu#(jI$g7k z2dn8)=gGgPo3#{ntydz^Of+rK##?FgeepXcMa%y_(ooS9|c8koeld9!fT|!r!2$| zbg2gq4^B+Jz0l9`Zu#ALFmmB^YY@`gdQpNQA`;@$rptMsA8lR9_^D2g4W&QOl_lff z>3clwLroKQD&&J&f9$9(92K)5bCtb98wcmanJt?omw_fW=e}DX1|zhy>zD2;&#q(RZH-}dh24=EPr}EXhP}DK(k$~d zQCN^Ash@6p=WncsHpo*G8-y9gC&(Tk@*NGpM}|oOC`k{{RPCQTQER`2NL6O9X3qjO zSrBjaUj=b%RvDs86E>8}YP)9wz0XlgaD!J9Xua8YXG* zyurc&F?SW6v>lssRrXeMejz}J^($TPw8UAx^!|?ih33MnBbEuVRP7T^R=oi`JCfZV zxg81|G3JGFsGsoCNQ~`!bGUKATFAEJt%;JIPj#FYtXlVr6xI|h66j;i_yQKZ;g6gIKD=wrUK`I)3HyIND z0I?>wNsp5A-U3`{RR7Vp0nmr21kWK2`qy`fP1b$Cm*`HaW_pTd^Q2iw`|;sC|H6X5 zk83n7Y1RzZ?{Bn(<}@%FajEOGAW_mF!dw0{`UJt6XpGJ986$mN z1tXa;YCJ5hK6?2 zj)ZDR*~0aJMYEo6cL1v!j>6V^(YSg3kp#pCWz(@K?Oj?12nw5;xqYvHEZS}645R!h~`5-5CW$$DfW_NA@K zM1DKpEzr&fm6crGp7L2&$eCh$s>!? zLa}@$$RW6AbzGsB;kdW2B&}bJ4O2+(NNPUfceB+#XA1>1v% z^`@H{wjmb^1sAT@4fuy?w?=^e)mb+-Mru6oX{0~;PI^6QJagvW|00y7&~BxrX#C)* zbS__Qa8K^NZ_oEa;m#9L&$G9dIl?c$8RYQzNOuv|`slrU)LgkW#3TC6obQN{bcOj= zE0@0N#@SG#kV=o5{Mq<(4DGgQl$Ej{x4R+zGr1N$BBjBZhsLC2Zv6WZ%tapJrOd$( zGS@8?_D4MA>VP=hdev=8?lnu0Ha1)!n?K9i$&7A?siqWGNc)w(Y%p z@gqg}?o?jCoa+f3rZ9=Dr5%F(uWbiN-23Jk7(fExp=4PWu3TaJn;^tPwAy3ry1X$fAvdxSKGhv zE82E;Y0{PrKZd+w%i#C0=eqBsuz$B$@mkS~u=7;i6Yutm`*dhAZoKc|steWYFrHSLx_FaTNlYoqst|sA?N~BUS zpOq(0xR?uzjyXbKxcN|YqV@qjgT_!?c;!y4@GHvoihRoV&5xo z=3BjsuruJoPvyC~?JfPhU#w-yQWLWMFc>1+7JmIP1AC~%nH)QhUnV5x!q1&tx8&r3 zN)&WY6Pw;zj47L(Qg^3)uaPGCIGvB)7J)ANdvy-+OUkz<%rKO%?Pm(BdgO-nPu)5u zOZ$zd2Uz8b)4W;KjOuids7ykPezS91hF_QX=uAO(Wb`ZkiOi1z8%n7nls*8Me;SaO zb1;)irEQ^(BEgJqWXnYQ%wZuq57z4FNM5Bk2x<6uK8A3O;ssy#6H__Nt^kQ4f3y7 zN}I~0At0ubWZ6=|1OCa`Rkvv1P*(tJ3v|1E9?=Q)5s^9VQ&rRP@7xQ>>&|RlA?(bY zupJ{j`4!?_5T&?(G0Lw(IBi-t`h&%ow(Q*#Y95uLkR;DX=2gt)7m-E~%WvP_Kn|Sk zXFA(dDyw={&u!}!?P^A%Au)_n4Nt|mTm2>D(eb*4zq3u{RW|AFKUN&uD5w^*eI@mZ zyih&hxT=}t+$pcA()5ER>j&R6N8bYtzS?!TC!{AxrxyxgnY(k~vBE|Ft*n7|JQs?E zi>wS(i;OZtW2nlFfldOl1g~X~h&1u4v}Vk^uB?1nJGb&uYVg z9|ccR9JxR3g*Khzg}Gg!qz&u8IJ=g9x<`Ac( zLAMnC^}~|I>XrYs3{cP7E1)XsHyI@~dZK2OYtqs+F1CFzXFoK$Wc%z}^lUO0deltj zqPfHAvyqJR#o&ZYUd3(9ucz$_g;R%F0b2)UM6B=~ zlRVlhPg{xmUPt5@OFuJH5%jtj0za-`!zPZ0XkD>GLeZ|5-$LW$_D-}43+H-H%;nau zwWsL$Wa?Fe{>r zcr!@+Vr!t;chFIyJPR=wTfq{^i_Hota+2}~C!5ASL}J+Xg{^d&5=eOd!D|$0HrLx< zOCdjAb8oI~VvZZ_i?F&b5cTr6p<3*J^{Qp8Fj>~-zeTH5ox#Ey)n7nQI*icgH^8YJ z3&bI^p%;@6I~3|SDfzM2m$NdFI~b69Kh0y@8I;Isd;1g_1!h}1Kk@xZVv`OxVk#wcef))|Sr%|3w(#w`dT>KI;Y!h!) z_jr|8*X9ThvmjpzH{bZQ>*)0ncKUmHZa_3s7ih1`ISy*KvVtW9dJ^H;esXrt-)Wb? zJT-N+c}o@pxUmloI`Q?WrGb zB&mU(Y)w0f3=`1i?uUYC$hdu0uE+fkJ+8QXZ&B?;>ja3p_VZ@V?1 z&GIC-FX%m9eB+8Bq>H>8&?l~2Wd+NILE6(d^vt7!C;n4jAz_CPpU~lZ3ZPt(@OTRX zDOV4|F>w~v=NmqRT4MOf{-b|55C*c^>1UTL{%d$Ilr_}DpJy`1dTA>osBWYbuc|7-FkMf)cRLar18~1U{2vvy z91EO}9AlcNCm)u2%WaWx;zVU+M~tVCg|p?nn@Ldhew!2bD=H&)Q}s0Lf!IZLB=%QW z^zW=_j_}H<(pBW?bpJISAzZqRR@1Ez=Y4=SB+2cKnxhGQTa(mL(YipOYRm(U&Uy<{ zz|U~cJUBoHuqr>_Bs~0lcm0d#xR_-4$HzzQiY5_U(Sc;2VZ7uQ>7*E2@A6Yf)JX#| zD83T43{iD`s2)Is5G;#yAxsc2p$;ejbQsVZB%5oM%W^#eB|1#F(pA7fD6)TCjz?iN z(-lvdMiO8d2oCExqDS!qxc|JFN^!A~XI2B&)6W_?Z!(upOYJQ1c5II?PwQRzvbf!B zFWXWYJ>Cd8RG%&xOt5S>Rq>-jbY4x`LZSjRKVJq(;7dHIgq#0~vLmX%d|x;4QGcg+ z#?VrhSBa5{O}f)e`IXL|bRbz#B__X%Rk6u*cH(JrPlv%33mFlq-BTy3W(VP`OkpFv zE$BZ#(VdCc;r7JYTT16TivPOiVixr^xU0etUJ zv!siv5~ocaHwq#RP)B2uA5wX5&59@MnsCT$aU zYs&zVw7nSsSpWIKk63TVMA{E`(Zz-e11vJxdY80*`%!bKgp2WWo|3H~))yex3a%xF zEH84`Od1oTL-s&m9tmhDH!0Oj4{CVpsKw-+;bzWHxw%hTIWq?%vhGf-9ABe`|9Z2Q z?ro&trdDbGS)G@L5>*gzJ7^Lbj8UxmyOJ^tlloz|oKakp zq9WrO0|=Dk6ov6Sz8r&E_Ei_hJg8X4G}N-15SIN|KBHpr>@%5cZiyT_S}%JgBL*li zOZ~j=Ul;i*FIn z)OCdXY9`>30Efgwz!Wj&8Ey6WDTBCgVm;}r=YCx6^OO&BTiq?~am|E1)tm`<-p6?G z?%!a?G->G;kQf;iaat%9aD~<%X2lJisp9tC9K$ns7=NmxeaS&Og^W5PiX8W%jT7$1+w<%4<_VEr8X{V?WZiWYVNiu!N^LxiYOuGavEWn7wJ=E!OQ}} z$A-$QT`ExQ1G*5>|30P29DInYePAu{73787- zK*xP5WgiczW!n*6f;ic~bP1Ie+<|orr2CM$*HjmLl9B&!B|RS<{h6^G)U0zhZw z7uRl7TeL_Q2n-$C##7qTAfO3wY!(%;#QlIo_PEibKm%NUrWGGxtkf83mIq+)UYgr< za`HS`8U_E>yQP!^RlbfNfeqL(4qtwRPS`JU8i{%tZQ*E=%QPis4FK}nK{ZWf85YQ)6Z78XqvD8 z=+sn87>8+m5>M_iW`72j0%GyDXOUk^@AB{)G1O8qnM0^w#la(z*9~vhUT934IQKml>wyGl;`@kS#IAGu$8dw2)8ISFfm<_QWN3 z&`R{GIpUHWKv{%;^$dpP@v#YnEz3-Zf=RpBmSXc7YCie$Gb@l}3@D<=9siHj5&Hi? z$G^K$x^k$3X+X~oxqH%kO;Bti13HvS{l~*Y@SgP^xR(MUrEbXD8`B3YOBP>dp(1$! z6U!0u-PZ)ad$}n)TQxx?!$?;m+%&m(?PI z8B0NBAJZ=)%C>hf-+L!Fr|5B6jOA8SfJ#Kk96f|_y|HyZm&cbkQui*SC9cHb2EHvB zfk`PC-{$uP=De%{~>KM%Nzc4Jk@XSobUeqJE!~ zY0D{qmc~dK^(W}ClF!Uk)jZNu1x7_QY_;y>K++ijS-52Q3jI6gDxnP?j_?)Eh6{OD zp`!@ws9Lt{*@s_beD+>W&Rgqjwdj%_ar~)GkBlPB-FQO}da#Ef%srLzXj^a>N1t{l zeZRxb1zNtQ!jOJmIon+eb`<63JPNT;%1k_oz*cly^nFnx%wM2>9TV}&6ayQMuO;Sn zn1hY20>{cL4h0|@0eo~YO#EEnvckiZVBjL8d$T{bFWW?nXJ9h7f=UScEQSnoI}+Y8 ztQ?k`FQY?JMYp8T60=mclr<<{&niE$6`06cC}@s~_+{~&tP(FXs9?E)s6q8kP>u=P zf~K<*1#n+4v2bXW&eTOmNt#*ic*n*dzkWxN8kV1pD*^9_NwfWV*J4&QdM1L#?kgUD zIfog%_KF|IAV8;Ue)CIEd;@X)JE%^ns4l2q>XL&@VEl}@0Ztcq#Yh-c@^*S8dIY7S zGfNEIOkpy2r4wN>agb}Dn+>E+1HU|23H^k{nuYjq0GS=Vujsb2w(xuqHAk%QWt}Dn zOKmx7g1tnm&{%1Dj|9Z0@N)Bgt-+l|oGdwYR@Mug@FOnNPW4WcGj#FD{3dHTiAQVP zJoRgtGT!V#B6!nKj;kxLjnegY%t`K_jGP8;_s*$=N*6BeH&>hkIab&j--`Dz83_;& z4{J+Ho0+Iy16bQzoE9kvreP#+#$*6+BPk31#sORm89gF0nN()-v>;`ECyh|SxW)T& zlsYP*hzok^F}E#<_VdaGg~6w8IgZFY--NM>1r?zquY~fg3u$FU`LRa-Fk=Mg1Xy%Aq9M%=z3c-vI-p5Ghu!$^T{l*spgWzC2mCJ@ z2F5>S2>|w}{WW00;c@xz9TIN=hf@8EKd|_9lfvveq6ceZFx>(obROv_*vi$yNy$9r zuGOU6e7%fH{7!fcZE}hYv(u7%F}m58mm|Z~*hW_qhq2=nZB#F)#phcH-P!eN6c7u? zE*0-NPra3YaSFTDe`LWcgoYfIDn!Rz{903M5 ztt|I0qJd#X6T|YYtG*{nIqw~Qtu*^orI|hDr&ZEDJ(YVLR7LS`Njd$>O{s=9tlC1Zup4Yo1mjq2PgJRn+^f8*19HkTfSAdY;^D zTCM6*n?KrYm?e7}E{j>-?BCattLQ2hM6A7bKmOWMzr-)D*CrMHiHXaVOPe{UZbdY$L$GOsn~+s&`BbiR^d#R~w^hHoA!E(UQsndri?U ztAj84uec8Kao&#~duoHj#W4z8>} zaBC4`T$ywDV<)Wlk^Z&+CO+~U=h1{#sWSGrfJ|Gm@*DwE+@sBx6Wxm;*0sf!)&)|GkS7NR0k;+KjD`=nQ@=ysM9 zR89LyQS0$Strnx<&d+lW_E#0{K~~SS)lFMW`KNHSqw^7^IXiDZlyj)o&`sji#@1k) zOY!<%1`%Hi_fq62)9fDuMrLIFTG z*YFk1Jh0E+1={kDwo5`Kj3&nN9G5gfSe3$^23$iRo&gv@L-LGyrW^i*_|$xIdeX^n z93oEg*>9US<*vyuT+k}-I+x->QAn!XrUc+ZFmxN+Ig_xh4P`5}mI>zg;k7H&5ysa1 z^^)~59{RXpiU_P%LiVdhpp0!gXK%yMi#Z;3%(!I#NTrG+1eIhfmqz zT#0Lu@Ga?L8er?(1bu}lkP(f={|$VHK|8i97o;kL)xnl38lq`!2`H!&{<*z^Tgh}V z7>&Y2W!2{r8g4-VWdUJ0H^3Bxe*ti4>S5eV)dp<|i2gla%9N4!X5>xo;HILhiY4IguhX6y#ev*Ihj`0-m$N?6?fHpm$p(vhhoYsbyoZ5IF8hR$Cxv>X0sk61U9#K38y24m!^#k|i&K?MSa%OFPA((=<3*x{ANnfMzNH1G|WSxbF|GEm}lS(IgFT!M?@ofWyTP(=Wzao)+MD%E$3smtq_0F_bze zhU{+7Y{~}{&Kb{#4J0V5jo1tv8^-R4Ek{3z&VJ{yPkX^<|CkCT7rA@gjc(v1HOC%y z3MeVYoy4t>R$47MA4H*c4?9qp)$emO<Dqmyua?f-`F5+`McS2}= zHBf(8-dI-!7~!^fM9QXD8rH0MRMUhf-Q6bne&BT+$mK`{I2bv&XNfN}TCdVTM6ZNB zY~)-itgE;ziRNm+6|H1ANE0aAZ6O|Xyef!K+dHE6Pf~jnvxb+l63vFSg8o^VWhLWS zATI6HTNpTItO;?LMzFBZ&Hdxa5ZJDO5FA&xXg_GSgB2mSE(S=z0c@}U83cn900*9U z^!rjQvt*x^=4-#4rNy3Y?7sxemN9a2vGBnK%G`>$A|W`Xr5IqLbnSn(0zv_%Ql!fJgkm z-CnCny(|%xhiPa<|9Zxa8-dUjle@i@-FuF5_*#2S)Ppy}pEEm2_*W%bS&(Vwq~2JM zi3lIYGWY#z7Wpnz_)uBs8S^g-b=Ty&B&l$5HJa$xT{QW=q>0U8Lu?R2m!_N-2)nOu z$p;IF+aawF{F#uCj;dmNoD?A*M3Mu+));w3cN0ayT(H+3+ZWO`C^=n%iV)9v+EKm2 zw~aNJ$ce>bgd<+xm67KomM4dIy5X>}bDN5fg|LD9UJccdj7u~6d)l|SOJ2f%&4XH* z&}-o?9Q0%R5<$vIFj+G=f;?K6^4=fU(t#Xboeny0W6C{F4FtZovW7ZE{!G)X7Y7HO zD7kn0XV6qU@CKU~EZpeOt&66+1{rZd&TY}ikF2kx->I2oi_spjtu2>bcX;>RU1t3h zYqu-?9I4|lDsuc?lKFmzMFIAhqJljX-N(sZrL?W<>B30x)R5={N%a}D_D z=k>0iF&jXg*R3Nkk$m#>N!70~kjli<5a5lMqv^Vb2Xs2_E?Dcp#vtVR4JFvU#O-ix zO=buPM~0?*iw<`mwK4Jayj~>^%v-{DmJIA5##n*K%xzB7zPY0p9+eBbq#MkEt?rWw zm7$?%Xhe9qSD+H*U9_iA=)2y~US$Yc7esXh1zABrKS4HZ^$O-+oi%K{t@+Zw>KT~7 zXsmM*{Vj#MQ)4iP$^8ZX{)-&*?Upc#_gg0FaaBRF(A)1TXZ;$~F7<$$hXr%Uq(eqa z)3d~#G?&%{`BWtiX60{qS@~LxztWWDj47A$=A);WPSphK=#dEze+f~AquxK9NXFNT z{+!>d6n-4}nIr;=dFyBhaMV|}JlbLVP(!V)a+KfBRV22P{f1YWp)~12p%lsE6p((f zf{?U}Cg1Hd`odC9{cDd%<&`4|7PCjQ3t&Km8KKnzbH7Uv$?jy*ub_i?jDT z2CK$jgxXP6jBPPBBYoR^(V1pfS0satAN^uoq$BKE+QoTDpUCK|tb0B_{zBJ+c4I6< zp~z-$4MGmDLrT&})xCk7S@{+NsesXUn~NRWf2D#x6xp5dNU-ZdtJ@Zyd$h}!8qp}# z=c3pNl*qW17BXLxVMm=v>at-=w>f!`zB@h5EW|^2yeOT%9o47{96^om zibX=&j87$%i{I6U0cz0DTwC!_b)>myZ_=6yYGPrn0%kl#$WnY+CLjUA`qTHcp+4rxKn@^_z9$(e0l8s0Cq(rH|`8DUo+y z)K#xK#Kp6&QXU*oq>4cF$&3bW@Nou;U_{t^UyD9|>^C$}vIh35;`aeXycQ~7W*#4hH ztk}d}v14yyR1>Qec$ivdR^yvUgIHu6-*T}7mQ08he^Laas^QSP>*}*+*kbjHDzT0w+Mkn)Hrqi6p1otBO!Z$41R#{iT)dB8m$_~ zic>HrYhO@1Nv6+FO!ROLK&&L1sFet}>Ys*}HQ*0WN+xh4su#cVOeWym_U((`hgR>c zgILCFJs&qs`MiD|@5R`<+3fs=N$j&T?hqaLCue8r4?De44l7wr`-T6OML=qbmU^{a z_T!)zoB9trGBHL~kNVIwibat@)#!jkDVGZw~8)z#Koy~HDNlA_`gfVf~V@|6>FnYF_v`h9`)a>P6 zrJG4F`vYJ1NKlVd8(FHc!}^j2ir(>K5y{8C{P&FLk6wRrYqrvW(EQs6d(!@ynB&j~ z{Dh4@5v5S=s0%~W9KUFM(&B)<=!Y;O0|~?@tsKnBRTeP0jt|2EjEW@2bD#wFcem=( zuepN%Yn;@2?g~T5F}??uR>qNc53oIV;0N9q@HYSv3~vhhZ|LVFIA(>pQEq*$$^K{p z5hSm2HTME*gbqq)C!ViYXm1SnkoIAA)hAVMPlk-I>`;i#X*{Wmn2x3avsI7W6IFGC z2c|+X3|$Ts6m`@cvmy$$d4Dssmj{kh-68Xb0M9CHSO;3nQBkuii7G66+>i zj)7e-e2T4Kkn8@%NoWD1Y0le)n9}6s>B_xBH<%9t1&MOLF`Zk$)&0mBgQZ4YW_CUn zK=b`gqI*Fyl{l;jm7&lC%~sPqiP%+7w4U}A7ZIzm{i3Sr_lG-s|X13P1hOI zEPG1Txk)*s8lpU`-+!nH)Z+rVSsK0C$q@0zK)Xeafn@0j0tk1->44t*bo<+?L>Bcx z9G+!A$s^DF{nOP{FNg__Lpw|3>BgGzKR!S{P3$Fte*32 zrrO0>z}5NC7tNAE%{|-7D~slu#^xSKpqS@Y6L)O!y!zr>c@G;=S!($y3lDw z2-V35J?}8`S*vz|S(AGRQJQ`UFN-RX5x8w^^q?c!S7dvy1+!ufx5JNRHcbboX}bG! zGFgvOyOv#iMR@!oR`TT~_V*c(QMze>N)O;LCWhE9e{%{nOF8PC@L%N?pkZ6*CJ=KtlT8;HV;h+X*@ohdsL_gx^G74>Y|MN(md{ItaW|A6KYa2!s~wR zQi~xod%^l1U@H0}*P6y>bp4TTwQ9*vIXw;aWtkaR{dLiM#x|4ZZx2*COw=eUwp2tS z%dTs@mO2MzZKLi!8-Li|^tK@<9qO!-ss;;;@rIXE&|39(C$_E{UTE?!UDh_`Yupd} z{8%8PAKsY48$Z=jg1mDuCe^Q#q2{?L^rn&$3<H27fjXGh)CSkNI(|6_qS`>xqN_I!t= zJZ4s)jKy#9Qp(VijST(HR3JmY#FsqsiWuZ3;wk3-1KZ`i=Fj_3z)`Rqkfb~#l`~tF zSL^isxl$EbsR0{xrrEsq*80Gwsn`U58#6d9EnQ`#HnP3OmCBO^1?_mVmQ;m%{*qQN zKS6Q5n>1S$8uu%X6k6JEq9HhnK3`!Y6BHQz+tQRqd-Cw7pPSH*t`q@9Y}Nb*3N48I zcIjS~h0E*r;>MJj?E6LKK1~aR9O&e9-yGISUjFo?ng4T{n7aHrGv8eHo>=`Bv*An9gN0Y7)QO+RNRLh9eey{0hM*5cSPp0jdN@?>Y+`Wq z=Ja=r{j?Hd&zD?m71?tKKJie-$V6m@2I}W09cyS8G%xoH!%xIAu0Y{hg=8n;~RQ6ysMFItoYUBhX-Mb#h%+AG|BLb zR}bh!Nq_mhRvpEP6>_(ef4648ZMCj$`!s9XMM_Oe`Nc3-hlIydWr-TCSkWK-8tahU zFD~}#_q&hx<`D~*SpYEZ=QX67wnit~|7n&(05X&^0%HhH&rY};;vPG=y#p@^GoE38y8qKoo1jE%xrG2;UbHNx*jBc_V85MJ&aUCp zv&3a~Z*FRXl{?lnc&()Zqq-Os_A^T<&SNCV&y5yV{eazZ+GCNoYwwpEL)yR%D~lW1 z8eJw*rE(E~`_^3rOx~KX@0qkq_)=(dANXsMZe_%*j=m<`h@W@QX@0`;Yq?A0eokH^ zm`UUn4#ZE=M#_)BULbxs5L*v;RRRSdz+1Ls+Z=3`VTXjd5qG*fy5KUlx7j6Q8OwJr zS~^Aj=5^v_uKNpXWQaSIpl#yLZ3bDM%ArT+iR|2Cp++7qZtiqdY3(Jkp#IT48P?Cb zU$^+5XS{W0beD_XbvEu~`%+k^jY^~(j;V5cPT%ej5*awEUuN2YDb9$8Lt9kZ}*Kl>mA|v=TLNzs5JwXu}=V z=RI)eF)2Y&=+ESMD|TkK`X0&2M`?J+9-gha$>#wt@vsQ`?F+dZC6ag(SEBC?B;N5> zGQttKf&lmWqWkcv75E^)TsZ|I0_5G_7Ogd|8O+Jz6JCa5LSR(J92o-mfp0CHn0sNvPIq2EoZ z55G*ze^es>Iah=JP4>1g7OA=8YEZ~PBr^!fVa$U>K_dqSJnJ|9_zRe z;XK3^e4B0?`EJrnm^|j05IVi*Uc{Rf7)r91T0-;n_u_PKm7SH%E&QaluPW`+$j&MSu#bE<%*p7))7gkf}Z zP2~$Jng?>)$GYyJlO9fsuq;D2|K^oyJrzd;xr=ll!;a!(+H3ww`nB6|Cz-B^K*yfx z&dknLY#b_?=^#gi-Pa{X|B1n4`i@F?kmYgv6epl3fSzjCAg)pRw7SZK&MhcyGDu^9 z{bRo9%)sAu37uE8e;$BKdNw>Cr1mko88yt@KFlv+?o%^UWJ*-Lu{4&x`8_~>^1Ojt z;44CHfv%c0?wnB8}Y3D1_GWa$ct^(K0u;iL!h{jXmDu1Dqoh;b;Tv?>F9 zZ#uimArpjn4s%%3!lQ8l3;{rkK)>IfC@53>VXH}T^68=xr=p`c5!v%U-^&Lpe-zZf zrjs`IhDY2p9v2*_WzSGsOqGX8Fe24wBfdq-FyB0rd}$~`0qNtVwEoB-CS_23TD2zT zK;CRF$*l$RbD|G5Cv#mgewfXGCV!(d3;A^L#9NFk#xYQ`i3scL%Ay-wLa!;8?O`%_ z=hDkusb=lVkMW@>+R9EwQAZk$a81$uO;gK>zp6lHKR+dFjrWqdEhVvxD|J?XcgQSG zx4zm=p2D;}PosNtmnDcJ#(EC4y`#{de#d$4E1{VhpU4xueR0qw7fBj^&jV^UrTYXx^&CB8#}hoi-n zbZdwYjI%9!SE9*Sa}~nB!A~{SFHh~6mG%~||9mJzw6#7#&7tDQEj&V~pFTM!Uf7=e z&iC^|`XiH(h1p64G2yVR3UkH1hV?3?n)(lsY+_YqA07lFl0N3|&k8P2ofT1!vZs9H zOF@4}t!pj5MznqOyiedC`2J>xB)06Qej=b=@m#Ll8?_)Bph=HasRgmAI-Mm;I4R(gO|DvKsdslt? z9w3P+JflFg_?&kw1csTK2uIGr1mF*Ak?Uli31&$z%w>I6b9pZQ_V7!b?t5j!(0UW- zooZ{%-vf(TTzpY#Bb;br`rYGhiruv2OZ2VvBwBF5?O&74)bl{fyX^H~K*MUZE>g#I z?Tv-ayF^T=7>q?I%d%36-dlC)yV-0g*LSUQnpxg}99!Q*-xML)SF@ALA);`d0qq<5 zLE#$dEBmCvzAh+}kf3R2pwt{3&+!%o2YecJ8b62ZUyH6ysK?hmmi$M4$K ztN1`ZmQ5Gm^@C1-J}LBwbhLcYn)8Rf?34(mF=XlunP0qAS>5A`@u_oiOR0K)wp{pO zuWSJM)x#ABR3CF?ZqHKW>o0Hskd}V-Z5Dm*L9e2dB-cxb;tU`*6?JBr(ii~Mc{=;0G5wecqM%mER{Lz8!7RZJ*24h; zYGv8>Kwq)F>~7xPELvONw6@}7D5p#C+!^4{id5U(|9*2){rnCCtqK9oegY zUmf2Z?GBeN7>z$OSo3F29-u`_5}m-sL_dnKDShkIer|VdNJSWAy7IUu+r{WewaW^g zl)G2lkvc%472!*fErbdSsZ#YPq@}Zf0q)cHGTMYeq(j_)PhZqoO>5}%9QoXbK9yj} z<*?B~9_U<8ppiLgVc!U?2$ggysJ{!Eru|_hgom<8v=!=6e zRd(>kRlFI*+doL@IE4e!J93#=RfeIW4J-S2JtbCGR?I_sOP$TE6q#xl?uaDt7z+2u zNaF!XuidywgW0ZGzXM=T$%IFDn>j&kZ5Al1oAwHSLdgf}&64E@#h;9Th?@g9=EvJP zdERM&ECL|K9<3tWn+o5?MaB#R`SI#RVm5vfL?=E@<(uEH)cA&E;g`aNP_nc81%_)a zA~Ua^sKm=`+r~_F{yO4Qb$r7+md?%Pv7k)(91)lP;Cas9oU&?{MUsTmVu4GAx+LY+ zFj23<0zWe!+V!JSn?oVdelZ+W=Tmb-5}&ofSC!hLA}$f1&o({L0U4H2tviIZ1^#C5 z*qkg%YIDfOOAJxKDZ7g~IH1#U&+@CFY2lZWd<5c8ck?hRy^Z5ZJf9AF_dHx2s-xL$ zo{9+KYq>XodOmwE8HdGI^7WI6>IsoZ3%vL1n?NflKf4`{CjR8sRQnJhv2_r-wmA|U zPn?x}X2Fjx*;Fti4N|!vKalV~8|vo`nfOElYXMslk^=2sjx7?ODcZ|L1vlU`ka=$y zdA{YZpn8DBFUI;=+G6fh^*%Mifhq|knx=3s2#{NH805@>gOw}YOov|B&#fxgXDXYw zt`l^cUl+$Jsa|`D6Ar)p>&&V@Oya@xdD72}u3~WtTB4q?=t)#=wm$bb0`9J}RRdwa zA1h=Zb{R?Qj!P@F5{ju(NtVt0Ei0rEFq%*!QF$@IJzYM1rmXT;zf7v>X zYmn*I!sQ1;X)1)v8yo()Itu)Tj2D2u7ALrpl^~D<6o25$X09Rzzd4Tp02oSM;mgq(V9+Eb zM+n7D513RQNR40z`?C>J;wRRG|6zAzApUizTlf;0yJ_*_iM9jJxxZ7}%FUxj9rxd1 zZZksrhtAKpm7e=@D?zWGR7{ijSKhu_t}+n##YU;Cs_{^=-Y-rq)7+%g|AFONw3mB# zag7%E*@xgpHh>pnH=MA<@x+k!en~|}h+I5&}-k zcL7KOI4?hI52bxW3ZcC?HX0K;2`Hol+2ie|lz7YT7RzTG7&j=^>chTRU5J$R3liXd zQi^qXmZoo4wF+9~+o7s8&pQ3xooPv-b_cFbz0Ag;2&_aqY{6>gt`*?^HO}7i#R~;9 z#{9x&QPg)XmkiiQ>!)SJO(2uS?8Kxsu{%;%?^OjSb*^l6+`$5&%%;CP2a&+JdJ>Mo zF2>Y^&@oMK@ac_Y0s`vMr2#e@CCDM4Q~1}KsKmVV_TLk_(DjX$g~&apJy*F#MaJ3c z2g>rycH^Xdnv%)u2idfk$CW&wjJxwa1ke7Nixb3q-TUW2V21t&Oxu5cs%7-y!j(HC zeRY`7{-=cEP|m5TAK@xvc_dA=`{TgRy?}RkZ(7n|mFgLH2DSA8N72egRM-S0%W-iD z5YnkVe_njdwv_3FI>5WLj2?ZH$B(=3gtv4{!_6IsFFxm@H45g|Os7zHoM-{E)lzox zNqkJ;*%h84%-8qzx~3V4lJyCS4}H6Wmn?{--;Eh$?hz*&uzUz`Yiw0?Rt?d45KDIa z2k@r5_KP*$;z~&LdvKO*_k26tp=Y8`M<_~ul7|Lw%e!*=EBb`!PaRhcQBiYlC^7By zZ3B(H=EDfqbbH*3A*9sNQ(4OJuO1`2BUz5>Q?D9`{(iVC^`H)pe$p5`(?a`apZ@S| zz8Hx{>5D~Y(-EPR26GzQpYO-rTebhXu?@iff%7rHY zVt#-U#k&i^NCR*GNt6%1i~Si%%2G%~tC&g&ffMy812D|~)hy#dlyw9O0ssE3C zaOjCO>HQb&?nNvKDoze#g-2 zvMxQ5?6?=`+BvgPdf#X^dafDDO^ISy#zGXva#3j2+J+}W+|W;Ft>@*?Lvy;1IlM3( zTxoC_eL?ifpV0x7&t1p6kfe_VpKrSuylMsx#toYNZES+SS%P~#S`n&|tKB5lNs|bd zPccYA%7>j(6yng~-L)iI;?1(z3EE~h2h<rc=2^$&Xi14u{ zVn^iqyfQCS+{P|Y(#0`@!G)dDE!nh-KF}~>T-4E3MiKnw`8t2Hpz>-N`DiBKEzqu= zFM+T_1si!P69-}%w`+=$v(Tf|15i@?IUv~BlTm(Y2lipuXpjK1Z#@qSqy$m^1ycMc z!0(?@6riJIsm@m3y<`inji4rbe{=P_`1{gl$vkBGeVZ@OtWroBUh;0-+bT6R#kuvl z(9rj&%vF>#!G|F6f|uxfdBl zP=An%I760kl7LDL3p{Ttt-33!y*^+hF1*3K_*&NH5?*WJmXeC9w)cw*%=$5NnjDeF_Dl|DJO zo1!3NE(3jBL(q7~8;BUI`I`+(e5o?Y6lDx`hmOH~N_of~^*i4r#7l|UAHlJGGETQce#wOrT`Z1YbfLlOPD5AmUJ{_* zv*}HWz0agNs~)v(6ud-JfSVC~!uSCd(|@|JH(alodoYy5S`@ugz2HF<1;=tEh=mPL zRki?H#6S!IA%+4$fW+`|&{~RboQqmWYhCR2-}xhDfe|n4 za~)XIJ}?&hvmdgT$L2~yoO)UEjjt$XRT_JNK-u7UT# zL9OjGbFzAlj-ci#Wr`&K%-s)CG{xnbnSdz478yD&;}B__aADM1;(nG0@fC9}Q3>%33{mz!hZ6MfKMQyG$vhs+urCg-W6__PV&AxhI;bLU*@ z75POJAuowR!H$jNT8vn-M9dt(jxyjYuxrGujd1JkC&K^C6L)6iS*ZZ*1_TbF%Bk#3 zkw0NLI&(@rBOI?5f{hNEmV>AFq(PHSz#tJ3LyEs%3MaBA(P7y&$M-0U?jRfyMxBpp zyLV*SW&V^01e0zHp%b%hsv0-Ir`69}U-uo{jPalNeuQx&?3U-m2vbMvJ~;4|)-YK1+o9O{D;Nt&YV;jeGc0`Hn=I-h*}p>F z$mvbi3B38OpSTpw1 zk{^3Ss}aCJD4s7l6L^%=u`<#1j4bY8&kMRiS%CuG1aD@Mc5qDcE8w<5Wm=>3YsFB4 z4*|rK{s^Rja;oeW7J=W^$pOGyqDWs5;1!_%)j z8k7aYLp!(c)frsw+5h|SntD=??tJ_)tS;s8!EEho$Iyp*0)f%012ox_M0&%*C2fW` z$KMM_v(0O|$`2too>gG?!g~~M2`E{mWl=G8gpE;6qx~Z9Cz{O09TVvlpcg!+0 zC(zc0lQRgjAm`+h8BFm?iKgChTlBKmLV88d!B99M-5|=)&#Ek{ap+w&Ndm(zS1H23 zv?IIR$QpK}8kn@Umu6^@1v9;tX^h#o^zcj-@*AnMEgKqY7q zX4!rcoeg%E5;WG5ZsJDourUoGp|^99-&0ohY)~nWm#gC+`az#AejXBQ530*$qW^2d z^q;zYKx7bbMnDC@*F7o<0ayY`THe0|?3hd#FqIPjOcPTgCXvzqy-8hrJDYkg+V<)q zb3U4`XMD2ca4R^@0r|6R@Ua-qXy~Q-~KTyO-RJP8?~Y_RW_U@f5@0Y z>&Q$>W>&@Y^eI*ZuF4!T6xZfB8SFZxY@_?>(9BncMsa-I=QZ4iZ_Dgd^_kWkE zCnWqZw_D{)#P0hqOq;H*?O^Hb=DRsJ%2rT&O|x5wXFg4K1W%}P%B&uQj+#sgM3A5* zk__ncKxz}w0B&AxCNk@Fl8jy!K<=IcS#* zg_@MmhI!y-?hSej)zV5eEZg>brQc?jgQ zXw?%z7-)wzPbb;PX;Lp2rM-gFpC#l`#*##>Pfz=nW{FkgU1d#0;U*QQdc1bqIkL~g zd5VlGdOm{&=#4MpKZ(sKY}_>rV39r>>`A`mW<*`I#_`dTYF!D(1-qfe^1*cnR9O-w z>ET`jnTra~q9vmb;8kKUTDyD=d*C7kG6z$r&IiFF+qx1-~n+$vJ6-2@||ddcH2 zwR=amvgd&6k05_~dI3;G#LOtFSNtE8&c#`tgsg&($wuNHPD?j`yfA>03z$3)U-Ze4 z_$@#3Dgu@t{D++6%G%DJJbr33(``Z*k|ae%o~(VuI4G@M3P0}2qrP4Lo;Ny3Z^rE{ zc6EB+Uq|Cs))ZnA7FtUG3BNi-!ws0ih!ULrFN@-hgO8GQ4@I6gq`; z_7M4ioHkQX?D%4*y69pNhib!*2d!9q>R}U|rFS(jP>_$Tt@<_5zG`mIH;4ym!G&EO zO0eWCd%|zcE+I{xvO)+%+vJJMLY+SL6*&>I$q~;B&{J1xeXKmM35kEdU(Ow+%QriK z`gEST@y!R48!{;n#SQl?EAWBrD_>9+_El6m^wz3ebY*d?_Zrk8`252MY_m<;W^ME# zMWiF3P(1#{>^jsHWL{VxNdHUTV>Z1Pub*T2>6n_~Q*tQH*` z6C{xGC`KfI;W5r@hX1CCP49oU9YgD(4=0oY+9eHogZ{hy!f@u8@26iN06_&n5BrvV zUv)I5|Ij|lpW2%=!kz|-0Mc?08zC)K*N}L@8rBK0)t0cJ$Ke7 zEu)}@RgbY6H{X}_9g2R=UY*KWzpENgC|p;mg0Gh(D$`>@kiu0}_cIUthdNoLmXD4j zF!f#%8O&Z{krSA5H}3fYxvCfm{27f+x{SIixVtAWef2^;j9MHJUZY`8bU`+1|84y= zavmdl+x?Oc8AU*cA)wPkP#7WDi19}W3tJljyA1wz#Qj&Hlj7%|-!QFUx3if6%cY>@ z@;+rB1!ZMvxFw*U?;3dARdSi0BA=u|{EK|#(yL3+zmaVEPX2KX$CG5Cxi1|}BS3*H zW;(&>pnOY@2)=}@VnGSH&3Rrb2U{x zY|<=ZP(DY##OP`5#do|k#B(wt);R2QTbm}MsDnPXK_zzQcIV ztO++r1}KM|3-@WR1X=%H_M-|OV!APu{P@#Z48f7yBY~G`{reAEK(z9hSV)L*J!}Ac z0R)IieOY|GCZqIJb3eKA-FAS}(gxjq%^yGhBFSv=F?Y1;tW_gY(pt9k`)q$J1Y`=$ z-U=K3!q!d2GNmvfZK2Ha7wbW>MEb94ndX=~Kisy8&CvbLoAkb4NGLz*JoHe;r$##< zxF7m1hHzMy2i`}pkO@@Rv9*TWX_J!5w$P?GwaI1dDueRCl|BzRmy@K#laptC%;7U? zvv)ix$uUYk$}_Jc;qy1>qT>dwEqRY#8`kN?q!xf7x%tlp>-j`F5?vFqOdW6Tv2j;? z(}g@Nlo@-*`AzlVPGA44?qCgw$$@x=8H+4L12w!46W1a_8F#aps2)9NgVXSIQmMS8 z;qSlv_x#Vyeiaa}ssBW(7n+vx-?qRWf``2S)0BX92z!07(Q7aq@~#m8LBXq>O3I?8 zi}57bQYMP!{!|a$dth>GP#|GoyF@jdsg{Q!UD&H*cv@CkGi%o(H$<9P zNc<#O#eSWHymRC7cw6V^WVmErqeF<=WCD5y_*7@viq<%xJu61i-ncD}pQkc4gvQZI zs5_@Li)~z#y@KX%sO}aNK1Q`*p)R=0wqK$tSd>lqB&6IV$ttj?CsO0it5g_a(R~GS zZlMYvRwcpS?V}wrmmdOngz=lr74 zcy!bCl%n1{$~qcsr=t-RH5&k}i^L}eG!o6=!z8z`z3wm>6$A%)l>a0SgvX4KLNIAO z5O;vzP0j)+0JKx|sQz%yd^6AFDQ7`sXm03P>D4r1>YD6mTh5WcmuoFcXu$LEaoyX6 zng{>T@W^S!q%W@72=+%As9X=)ES=0>M#e=MU*5QcPZ&35Ejk7e9{x03q%@`947KCm zL*!k_5 zZj?3N!0R3`4*XwD2tojeA7dq>6M<&ekP@gYfcSuQYNnI>(j?tk(k0LyNGqfY8xBQl8?+r6@O`VTr~PF z^;0g~QBjlzTg)e2Cm9lThFMK7mSAYT%5p~6ISL=#nx=j-ag5!v*j4>nL zvb4qEpiP;z(tAGa@N)A6>xd|=*8(0YpYEE9qw61^5WVB0rnq^@mqNJ!o=OhWcQ{$3AKeO9{Hci$V;5r11oRd_M4h@!Bj84~cMrQd=%rVsS^X zS86MJ&6s+E&JWFUPJb&&x9kdJt-s)R6G@4n2dTfC9mKR=yiYyTXxLfp>s%YTHuCtdpb{Im2iBV+LwAt*xzV_5S#2!reS}Ki2QcB*PBwD#XxB z$%osWAIF#omXjt@F(g*ow1*!XfRgtUlzU;Il|I+BQpv8&2g!+j)m&(p=8bQ-mxK#d zx&jJ#W5styqrS_l$)mLzDl@(^6m zDQJj^d;97FU#_y$x5@an=VuVLX&=)-T^(8tc;Pn78>$!I61dwx9SG;=7^!PM4}3Z) z#q`L<(J0w8=_eCPa;Lt6JB7Bg%b$MUm*sgF>swHXpRc@8p$1>KUK3L7I$lApG&$gn zkCAHU$zT$`AQ-l0gHCysajUKlhM}Je8*Doca}W|0y-I$Whp6}_ISWEDXIrxAQkkqy zx4bjcCc5Q>2xxW&l*%hjVt>@Y1Ri>m`dO;VIY;M^vFi+{E6n8n=Ta}xf;o=Nk3sjedkqJ z^fWy7+{whn^JTZ1-yRodmIdxX4ncPLlJSuy)2H9i#!U=yar}Z3og^Y2Z00ErVml$b5HvuatS|NFA zU9;m;y`*tC!(uW~ZjNBpxt`?b9sm=76=226Y?kyH$0Tj9*oxD+BREKuBZC=7#Rm6g z@kX#wX<`vtXP9t%kT-}|kBuF${hw3+kx2Y(s{btRbnk1$vKTAKnvYJx)8O1y_S55b2GAlKqo`yzn{73N4Z`S>fk(Z83 zYD}v0d)s5*b(P5E@6ip0RKxlkM;4=z2cK?))t}mIJ)O5}uQ8$D_{|#$-bj#t$%oyr z`Te#i&tFDMr+J!?E5WU?7lz6BO`s`(hSHDl2$C4Dy=-x&$uD)D)PoKV5^K?-Y}&H? zct})FPHaf2H#EC-OyqU52&7*hF_$o9^O|*K2&p@TuYK^c7m7GE&EOsRaot?bwA4L5 zB&T(=W*|S3y}!<_&2;NKCb9hS2W#@ZZlE2J9f6(VpagIZ)lYqDwKfB~KC!gL3oNynYu%vEFhSaC5$B|1f2#zd_XEwvuU`DSH+B{yoKVDwgA8 z%4v%~I(GX5PR;th%jyGZH~$mu=?y%&7eca}j?c^3X3b=3eN58ancY@Ob=os|yl3 zz;WLz9e}1^iW@D&_Pj-%R(WCXkcmm3c-)md`S{-??1!sPzc z@+6X!|1rlE5aCS>Cc#_hdXzE5o^sU1(+?s#|Alq>Oh~P`@E6Qsluw10vd3EL-J@1>w^B$=J{;7lh0Gv22^q-Tv2;MS;Q5)D$} z$K+27quw-#sN1kIrE?3Gl`3xdG;es9UUX$<_h~3Pt^L8uq}jzDZjibq$}l*czo7O3 zk>zu%B_LdmlG?Bc%a;ky18tNo0$KP}_KE+5s=w=5d%@3dAZT*)B(1;KdDzWxICi|t z)S7{M2Ubehr|lue1CPwyfoV!GccZpo>qLz22KE9`6AnN2nD~Z!0yMrpI31e;5sk*n zqYaFrU-`M|$%Gs?Dpv4LrHo!#?MVsOJyeroNsZU}6 zB|tXl3m^~F%Y_7PB7uYkKtgigEo^i+Hk$HRPvp8cu7`pe0Rm%xzxh$1E-vp3S6zCr ze0C8YaX3Gymsop!H&nCb4)N*eM#JaG zYvMzpQs&m9Rs8nY9^*W}VoofwJH+YtNmFI)l|oO3)3cudt?k687#7;M1UJDN8!;t6 zU=FJhyqwuRH?KO>KM|19;%h*&fU2lAz$7Kq2!E3zS0#GE$30*=IlBK6B(Qjc9UwI5 zBVF?ELDZC7oYHB$%tU^~_d}QCtL09DiLXMGg6%oZp5Ao>6m!N$Zw$V-)Z1sVMCrxL z>1eZ=qyonpWe{%u^ZA3h7F2gr+k21s6W0C-l)wmlq9IMIiRU)f0jlxbLRxV-~X zNdgq@4au`lS0iBmL#dqCsNfw>jKNz+Q^80kfTEHo{kKD-KT4pI5qYXvJi*2M_uHHJJiWKDtH63iJWG`q)%nyH$Fx* z_1upK&${yYHKzKOe1-NAd>f0aS9xNvyrbpENih8Y1A&;*Qx$rzc7CLU`$c%AuqK!H z+Ai6+597AWJ3%y;}+g!O00D?2KKNOcyFmk^TX|?p`YqZQufqYz(FXQ&- zy1NQel|Uclz@;(N=SlEe&gz!}HQegu3==0Qfg>T^U;f2r?;o;=b=S^+NvzU4Y3-_I zsE`-@kZqC96w}tXzs098v<}XwJ*ko;D7^P94UjUYtoagSEps~y=+Ho5-i9~=n!zk8 zAuf$TpXeBeF4v|xP>sTIq%S2e+}i_&a)>8tApct}Xwm|L2*g1T z111H}A18gDhWVcrw`SM+9DS5s)7vbu)k$DHjbHeT-$nJn{jc1c7za-_#g}!$koQ*t z!gn`Is5jfPSPX65I2b$m!km~KV-(U?Y=q=VN| z)q))yw7s?1_N$Wh?W84rY?@qZq8rx|>FI{)AAQdQ#~A>a!AQtl)E;1%l(Ns@Z__79qaXa*B-guU5gzR4{zq@~%!-sho2rr} zvpn%ooFp%ai{=S%;eVmUi~oZb6nJRyvhhro1&=6n@foMOw^n$yh0d-1|9}fayo1H? zMw>5@bc?LFCm)~g{QrnL&!8r|Xl*~~p#_A{Tc}c{ONUUUiS%AV6_6%P6vTwy1qB2I z4OO~`ARveVq=-_a7sb#71u>u^Ai|gToHO%Heq=J4$xQa_XRm$V>so77Ni>|cR{~O# z^hzo;;AvHKGb|6nLha2of!&nVLENG4VTE48)wBd@KmilMK=UZ;rKZD1xSdwh@tbI! zIoh>IsqmoBjkPZK_s!F?}X~ucjBzneznD!!AuNiQP6nXURaTk`l33WBw;N z_*l^WetBB`>j3)?+#u%nEfc9^DW#x{H1g#?kektZ6ED_9!yPH+SQdUedDo-}LxpNX z0St@d+l8Q)#5{8jM&{N;v5d~1x{O3!wF1i1Y+LiRO@A%O?__K175?YYsuk1k?Zi|; zvy}U2bW?(nRrE8js~Khf{?VX(rWiC=8fW0h_uW~O^Q#A!s#r7cPn_efi#rJ^lf1m< z=sqVa%vrInBi|(SnpHk)fSuUK(^7tKBSEH0L-IN`_Z+SE@k2>|QB7)+u z;2v!NUk1<>p`b?8w2h6*v<~Py7DRO`7|^J9y{HDp9a7?D1PTvj$ABWJRg$>gDm2Bf z1=pa%DWe?xlU7Lj)vaf4tU5VQ#y?SzpY)1u*~O$;i9KfRKAw-@D89MNI%k=lZhd7& zQ_(OdZnzqq4|WSyRq4 zm_WlfMnDX$fXH|#Aq)BmjL%>+%(CxS&eAG<0o(pQ^;sn4a8q&5nl;Q! zg%SErie88-&q9W@k>9VM=?6!K=cZvBw$}tOi&W0z#2?E_lsSUuW6&IHF&Ph;_sm;L zh2RFT7R&u@VQwYz*B$O$pW}`|b(&vCpEp;XJU#Wt1Cr19v)&632CiyN| zWFX^%!%h8c-Bvj<-ft|A{6#vliBUj@HUK>E<3}(ns!*ArC@~yA5W%;FJ7*3Ol2wfe z#qn*CabJ6R`FKLH;6jkcqyxo?G1?<^`?D#upg{iB2zq4GW4|r3?wa@ zOgW=c1N1lzN6-1mr3b`htW)fA*}C$fT;20;yB-Kv*(5yrd6**dlGqWsub*Q3rca@& zLig%0^Y2JUab5Nw`n*+WLGf;8v6F^f2RREJRr2`}@koKWo~h`es=Vs?93sW@d>6>< zoJgSU6H1@7=iSMQmr?$I7~`rho7{S*yp1ZT&6OQN*4ufw?sdg6R&o>khZndMFNWN; zl2hce-*ms=L0LU?mI|+AYZFRJ=~~#J=gdUl+jPu&97WR3QMmJ<%lrWL0lvDQ0MI-k z08}kmC<=ThA*K4ni3x)q@u*!AlyMWF@Cg66mJZBh3>L(VA6jkGkzjL5TnkK1yr2Kz zk8Qs{nW&JKK;QV4{jFW?`Mi4rXwLISZ-eWg^x?Jd=e109k_1|Ig7$hjAtmrPPKZcWYvE`F_O{eeMh%{2NoTA{c-gj6zS|Er28{NeT|6*n!~YT@^?Nt(>uTl9iQq48L1 zGL7NGEzlNcoTJEFI3IQ5%r2EiGr>=6WAU^l5;X~2>NeDSCMP2vf%|V|&!y0aZXwiE z=FKQ65K_qh)Ra3=e1OA%iXwrg;;n-Eo`v0qIS08Tk7l-3!Y*>S(sgV8<*yK;WA^!% zN>@C^WVD>e`SJD#1LsAzNgm+nnn?%@F0?%7r7MgT(O0_)fNGu?ea~;yemrn!AMh$y^RisJ-m~U2UDiKFJF|Ot*l2lvd~Y^V;u?M4 zO)nIoCd`q;Q7-oEih{n2_kgjhB}uQud<|Te%Nt@yhx}Fj{e4f4s-Pn6^>^PeD1#@N zDygXz`Vg&V=evKEjZ$WJzPvM+{)m8ORYZ-v?MAOX{8O{2V(qr`4?T$KjJe5kFXu|3(LmpE?KioDw`5=PGu8L`lmr%_#v`E#}K; zk6D3jk|34J;DDCuArM~(n$aq}z|aaFuMHT{V>!fdo@-fO z*MJA;mUfaUv2x;V)&tN9ka$ps{I8L_iShUR%^&*c)_RMiJ5=iZBE9@~D0R(Hdh^ZH znWN4*@%rp#G-RN0?|!CJU*9}UCQ(tt`gFXLAee5@({cgMJI8gbtC~bNb-EOvhR0Pc zc`>(wH-8rpLq~2}eXdn>k@Xj4V>Q_tFEkQoQ1)g*J|QV*OomFZG7*N>BD(HC-j*EQ zl6)-3aVN~(!(|DmV*&*65aP>s0uL27!p`N?$`=2< zI8jn@;y7MmJeED?;`jvf^84V0uHT3oBcCpfebLAzS68IMM+-2!I)m>P)uS6og<-uI z%;IyJ+b>gJu8Ji0Y>D~#nRiJ{k#i0rreU4ZEcQ;uS6p9-e#o$EnpK14OS}xo zt}ioXt!p@PvO8Y3`c`L^x{UPIuhJ;|ELuHSTHv}PvC-7^1>$6}`_1ulU1NEQ+KZkv z`Bjjw;^LlxL6uyETwC`EuTPtjk^I}#ZFZ+sdBOeHX^Dd6N8e~2b5zzYUqP>`7SZTO z&d1jw@bXmdoSFr1)x?1Q!_wHB??ON%8VjsP3fLKpRky%WEpt$k9*FUjl#ue1s?MV+ zWJV1@;XfvWmK2}DOtR0_{%77N7F>-ozj}Ts`2z9LbwY^~9K?f`pa*qkuOx=FphgUvm;4(97+E>>+U14#n|1=;b< z`y)?P(RTMQ)qY>>4PALZ{xkrQV0ZrCsdCevVg3E(k58ce+~;{2?bzvyFMOM7Lt2%a zdRvKbd(n3wPfA zNyJNj2{N?ED}B~|6>6~H_)SwtOd@#Y)!p>?Xi@FkHfpI?_rI8Lyim?vJZ;N}%HT1r z?^vve=l<72bti>`SJQNOqR)evmLN=BSgHXh(g|N?Z{ZZHj@Et_YtI6$UbDlyAr%x= z7!)lwbDFn_JXCC797iuoJuV9oD4sx6;Y|wF@qiMqsl@T6ei6K+(kOGF*xtW-?ecpE z|L6SNhDmXLy*edt+GD0*K9+L!UExe(?4BnsQ#}opX_sEj=rW@f!wOUlixVDcElzja zg{RXTDd^iKj%`i(o1FVFHgU=1oP|bukbPaJ=>-1*UpMWO_r}TzH?BXGmn=@U>3sg? zCuDJpwPb(Fei0~ZZ`SzDDnYzgbM?CTC7Xf1JJ-ekSh3O#eS1SSI&4HjS1-F-FtHu6 zv6IBqEkD+WLSnvl*vt9e#-dHjD{l^_UYtbsEi>1sF&WI;s(8#F&1s5yin{9T_P(|h z7rLM8>?Zvg2bEm-`FaLgaVzi4EL)hh9>wT0YybnMGJWf{(G_!j923!L!cZA0wDay@#0~4m@^G|ttKQ( zDnszw)$6+^pFyzSVU}`FrSD6DXl&df0(P8gW?#E)Zy8SMPtMCH_2XD$XVw2ygPnA; zgN50lKO)_}hVuqV?8NRYlB#CRADf3= zGY~I6I><6nRW-jA^&l-mpe0o*Gj-U=@dT-J4*clt2Z{T-5mNh{8I$4~<7aI)Sn=lL zRgTO&OBSv9TSDYMK1p?2OBt(Q(#B7w^Yi1L;H-!mRxjk^nH;(MgXnca%jF(1MIv|J zv_B`Ccs(gDfaSpge+yCLVg3kWfTUA!E<^20%ZWm*hik{dP@aR=kXK4la#Glri3!RG z_lDtwnwzn09_j;%gJbm+09#wI`QbGC+7th4hA;9EpDO;)v8M7O;aF2^-( z>G6{+A4NeODi(_bq<6b4urn#9$NH@n_IF2zBWd6GH1sDhVWA&3U+7di*}8Wxbk(tS zaGf6)QL4N2`RS(|ri8T(QRWsmF{if=*{!UyJdF>NnxbLgf(=PSp6h#KcjWX1EoVly zozN!UeL7H&s`HFQzh}M@yezi%kB8flR-U_X-TU|I=(ALMeFEQQlU2;$_m2%^l$+dM zYkk%4SG+?oSdo}zX?BbeGtfDs5f$WQC#g@-br$MQ-}Fz$iLW@!j1}#6+$Mhjlg<< z<#;?%zuH#KP0X-CM=ftxnm%qPM2Dd+cE+|RrG;EB+I9F3W;qe&YBu#IhF~%Hl{q6_ zM~-bgh7)bs{7p|jUhpOKqG=J7P2;}TEHhW?X8r?ZwEaQRi=R9~RSqXEUP3#-^c{pfr zV>l`Qk^LVD&%xo-FTd-pMQloa%htruG^<{Nt-}B$uTFz#a)Zh27rn3(8;jG{#6jvm$0`((~ zpg^7D^jP&~q*{rbA2Ga;imJ0j%xiQ&LP_vM5OF(jw%Nf&eOY_RCz9zCsq(9Tp3H#L zdCN1dr6sRxHWu5S)`N8`23=1typyfd7nPGNE}vyH{cTl~Xo&16tc8mGdhzyF?>8FO z+E(D9i?NagQ?kC_*)+o53~lrA55Lrbt0Lv(vxoM@cMsKy)FJ`tnTcE4fLFBzmTGfztZ$2 zXM3oKQXWru#R>rp{JN6-g_u8VbJ+~6!#jHc^6NL8Iacbk*BcLyfv-u5Y$Ecx zj~^?pW(|(;Xqi}}S=xTlNFd7{(uiWEEtD&g5P_P_4rbS{XeHqnFrFcH_m3InH8e54 z27(vf|6Dd~QIz&69x%VmL{C3pM{kjL!At9V9ur6LJ06;jN!7Po7A1n(4wzLJMT=jV z9ZDhh^Io-ldUExY)Q`FO=X4l0N4PVL&bql5JEH*K5PyR}64LYq;7oM6pawcI1}!xa zGO~e&Hk4mLtGf9>TT6?uOEukACb0iwAB}NjlGZ1Bspcn?_adG;xq2+%FMZJ`n)6(_ z!;PXv7mM@1fRz8WZtuAA{~h-N&8M5g^!dVuOGZwk+ui5l zJp2alud_6DnAT1Qx>9=;IeKaJx4A%D@-Mctk*XR39wSXC$==Vtx;lJ2`tesvm-XKB zGbNtw3!#$(Mr;SeHE3%;M^r17nY`XGR4yhe(D@^cOKu~o;!%9Q=+T!nHApp&@;(C< z&{|Rtfnx>@;@a#zCO_|Fpi{qoI|)H1JpScwY+`1=sm%m`N})+32LA@5yX5~6(WiJ?kX#`&lxsZ(4uplLdW5FmsY69rL9`>K84LnK*`fU5>j;A(! z1DgF>x)0vb@*7+7&SWSBG-#c-wAGJ!u#*yTU1ww2aG$+q6^_j|*bp*>=~nflYf z58qmur4A%EI!xaA?m9Xt)O~qeDba6DgUVmvdhoMNRK%P)*zKB?Q;-%&LuEpk$*XAh z@8bt`%f*>YQwW?5jOE~Uy)8S3K=6yN#DkK# zP`Kj5*F}DCqi3YmalHhTdQkLsP^DAG#ozzX!>Biqvw0Hp0|6l-wjdB*L}+v{A5jy}O;BRuq1_^* zkQSj4p;+pzvmcJ@+U~46*ztSuCkvjGV*K*o6mh!2#4TM!WK_Z@WI7$HkgIJzHU_Vp z0$Z#i><0tXrsr)`IJs=Py<38j(k@HZs->5{J|wXx>mhD;##?$HO~xrcuC9BqBB5II zfWdIWz;*oULma?uA)}BB#m__@^45`nK(=p3Y#chX#`7mt@h}I|`Yat;aDL)(wJiE# zV){X!gT<8JKW3(+wxq=>y5+J1!W=yl%S%|#Rp<{=5cw9kn8pWk_c_cR(oT3FK4B)N zuA(l{3|}V6I1#BI{4NocDDcy1un%m9s7YUv@EW8YL~OuBk@{&jN!*kI8tNDLpB!$~ zU;7J^XQiLRzbCLWGcTJDgq=!9uU*L;vtU_61a0?CVlM9#01;k^CbX7 z1d4H*ltqH{mJv{=cs7k{>Cu4gRDCc{4y`Cxf3zduz$wCuctd+W?{2wDb5`#{?t z!?iUsUB}W4x;MB|VZaF+bN%+oy7&vo(dVr)ppG-fb_wBVOT^p6GI=E!j3A;`zmXdk z$#x|8dUy&iMT}B_ZU#TZ=b_Ze-dF(}2@3rLTra7G@alprh_4KFRiKa@)f_{uAKU~# z_)ct)_3hhb-~e;Od0JCMXu4o0+wqCIli<%$&H9vgM0jm`+02G98a)pp7!m;a%-f9R1y099eWTgEh1c=GAzW5nglk!qwFdYIP^bmq^stNk z9YC5FJt~$DDI5Qj45n{Q&?Lb~wed7|DjF7$xn4dVl&x$pFQE8wx)<^tdr5hP#{y85 zooDFCE!O^=AGjo|^l#R({btXr#20VNlb|!uR?B+TO@%gH?(&YuNGafm*P z+7%w2ND*E2B8=LrMJvihG?K*h?PdbZ0sTmWbvWLe(E9=p@*yle?mFfQMGogy`axR0 zlcvIxY)bqgqfgQ|37aW1Z#@`0u76u^*01u#nB6F}_p`$$wwx=36@MUGlDSn%2~Y8+ zq&9Ra90z$Oxej^&`<$0p+IP8k?Gg_Bk@e7<(E+5MLz4sS7Ebq2F%@&6LtZj{v}a$C zGYLGO5OU6e?nIHS&e)xx4Svll3a$Y8&}Gr=%4BIhkGMBs{VrgvcHt3IDzu!zKPoP% zoO;(0dCTd?=;!bs0muh%M3KQ*kjfyrcZnc@2ji~7T)^bsUN{-d2Lsfo#s<BINO}%f3(#8(V zDhCsryuo-)$xOj$wiCh7xx{>$&$OQ(q65oNdbYibKs(EFwjKk)k@jqngqq(VU}PC% z*-xIOwDgJ7tUZ9;B-2QKtZrtU|%^q@zT6(tw;P zuknOOXSeC|i{I2topo+bW>{v8=0{yl(o`xl@@k-!+duX-JjsNSy=F^$(5&VHF>snzUh~L z>WlCGn);P`V33x$A{~>Q(RDcK>h7wcu5)|O;&V8DKPSiNjT2aHKTIZipgpAK+^>@I z?qci((90*-1?2EKJhxHNj71nYiu^>e#+=0GaM*^N5M`@E@wMZhGQE~Qe1l?3lB4Ti zAVH(cZHyqn*vFt(%($xN5c1udx+1;G1dYOkG?HiEpS;x~QXu&?+D|m|qO1#DCHNuQ z?JZ+4c0rF{!W&!*R*15&Bbn#$;9yds-a!Ce4Q~y|0c}PXQID6#G2W}oVL`qiv%$D0 zK)5cf#TJ_w_k7FcjJn&_p8AWy{(tu-nwscz)wcF!?zQMB&;{0oUg z$3m%*pHYzq#&f7*aY-)uIT*^Z1rh_@>Z<^-2#4@Ps8VPGnM7rkKsSJiP%|Ey)rkn% z6(fK=pfpY&?&hF?(dLVLs`Q(!q-l=xWuoy+@U;7latrCd?~`Zl>$4N2E*LRkDn)Ie zuRjpKuIJMXKXmnN+Ar($G^tl0p}t#xg?N#cJjT z6p`Bd5$d6IC5C<}1b;Gv!xF72^I!(?2s(zpA)05f2akl#S2si0ARpn!-NWY>6h|A= z^nf_yByZRW9Ck>xmM%ho0m2oFfdo1rhVl%;3W$)#xLg4085{n$-Rga z+CmZt#FY&}2rx!WT)zaSK7v0Wzly9kKHbd?FK;{^(~wYQkUU?nUQ`*_yJbm(Dq*a? z@x0SRU}O0v7|e*;+I{_{6`W?n>*u6Wj8-x2gPsdp2k|A*gYuHJo+Y$V+aZMM11LNS z_d|#}5ZkHkb4i$qL=Fq5c4fbLC@20OqD=+#llD$o0bZ&WbA*Sazov<#8wl!ECho&z zVUM^}9+IT7Tp0V%YRrr2QOhz>;`3hj_Elxl82FiF59kD(z0~VTs_3VbV`(YowY3@~ zTCX^jf6!{eD7>do)>mhz_Y7iAf=QMv^)VB(!FEZSNg;%R@($J$af%}rW)9zJAzQd@ zt2=D*H!jS)Xyv=&b{9y6_YgQ0+u1Ds&mH;m|J@NrsylM4K~b3N%;wDg%=XNc3W!)z zU-ndY#P-aYiiueFsKWFUwv>%Xf01#qG!th9v5?YGo*Ybb1;Bup<}qqUGBQ%*+yoyU zOa@c=1~U}%G>Nqt3{8QO_;Y}46iN)C_LAmOJe)Fea38(q!ZjW7B`{b>S(-na3v>H- z@V)-z&g#0lzsKIDgG$W>5kCaDT?3#!-zH~ zK{>NICDVW60Ch6<5?(3H{L;1+_`x^j~dz5zEvb5aHA0^;tW_7__*#ShqKkejiAOFvUPAvx^_0twIwenPo` z#X$TnAUt*W2_k^lJ4R~(CSGsmokx^#`QefhpthkfGmMJj1OdW~=3zlrMgd!)d}07& zgFh~R5cKXhmjPQw58M3Ti=PHkzD>@uUy~3p(2)|Lh&#wVV=8OV_(jPxQ7M>M7thHv z$;lSR?$zv>kW?*f*fd6wPbfUV8?Xq`+hI z6F%VO7!UZERS;$gr$K@~gzNX4op`>m#$6n)YthF*US7sSXs_CJzX03Sa8F!?@6hcy zt~5g3AqN(XMD9>8YE%Okk*?rKZ06X7-ZecEI@Ea27i_0;8PkMDfo}-Lwx&FTM3LL^ zC8QX_<0vv4B?EIrxP%LWgnYFSCokdM@nRa_V7h}_O0TL%*?0d1Yx;iT4Ssl79$Tw8 z5r|3xQ4irf_)L_y$o2Fit*C#eUQB=aWj1LpVxq`^7@!U(!0~+q3587Zd%O%zOuZ0b z1kU#gMx&S&L%k+?S1hoI8(4figo#9eQ-N?Rq1httj)0oh?{%F^CVxA!mRu$eeu=)$ z`*iR)Z+rDw(!gW07O{L(BJ<6J=>kD-JlVDGp0RY^Vot)Q#n&n3H~XAh7JA)xSVL!1 zPTwv)34cdo$8mL(vc>m#TAa${z}jeiuDb7xsES9PHm7mm(-L0Q;S)g(a;f%Z41^(b z1u0rKiU!9N-2owA7b{L@HcRG&Sz;XathK6mVp*CO65B{weQTmM!Z=8GK_UxviI<%) zj4Dt!R7U)g&O%J1{eU9g)oY5^4Li)?0V6qa0L712(3P-r9QswL)?q00Gf5sjow*M;$RAK#Na70N`n!23jpDnb&(ghe#VtKTEzx#U6Qp2p$TbE>CfC)7m%$;JZ8vPJl#- zKEB3m#uBV=omsze*`8J0GcR<@^%hwC9IdFYyTCR$aU@QQP!-jn|E@)E_C9@*4=AES z2}6s8;rv13212^RgSuc20E)j&Pq>J`2U^aiaUe8UEg^bQDzNB3$UwN13Gcf;KazM~ zyDL^1FU}%wOT*?-lx!WLf(R}Oy~Ns%ynQjRv|lLHbZ@8{2dRWL36m=ixhc_?Ytc9+ z3LZ9w4u*DEmFbfSziChW_av{A--^BOeP; z=VF+~(@DWkcjK`@b+5vt2ik$T^~Mi+BLD$we?~nFL|_L8uxk8Le29ry1t=e${G5)N z6hz=J&vY!C#4oW5Qx`GVq8sE7n5Gazg=D{`KgBCrH0sH&RO{Fbu#*gHXF-x5(KQk! z0C$xbiM9)dCi65G=F#Ek)>QofK0-r27lW8H$KwPPTeMSiOVUGhO$23=;I`upG`%@h>E4f1llb2G ziM2Q7O@&DU=?ys!?;La$C~Mb7BR}O-y}2SH0>_cBzfUwT7)}3i8WPPm3~g)IRmMF- zt_cjVlQ|CwHldIaxK`Y!{0zK3mhT!N5hTo5^GX*LEpaFAs z?8c2kq&}TWx^u5G(C>lRp^v7gwZmwKO4Fz(J&gachLy-cy?>VUA<>mjqX%+8=mN{^ zfFutw4x02kpwAXDc4Cq>yu*sJRn+SPb#`z~1;(D0K1owD_9_-uvqUb0<0>K#aNr39d`Y!|^zmuV2E0o7Ya3@zctX z1)aBdMtW*vdw%9sUf|x4n{qDh>6Q3hdRe+l<6&YMGw`5C1cT5=8-!n65M%f)`iw6d z#haUZy#?upex*_AAaKn*+wGqdIVqk-xa@SC>K{lEHP|LVt)Rcx;4eWR;ID5JhLJoL z!&nXm52@&uC?im*@?KYzY*gyexwnY-kk9F+q8+Rfu6wbtD}*)}n{}=5G%CUlqJ;A# ze4?LbDunSoBlVD|o`DXCF4XusL$h^g3^IeHL18%UV{7iahw5S^sWva*>7tqoo9P95 zz=hx&3;|D?g|U<1OV9&CNYYRQ34TILL1xnS(gs5|58tud){K9ugg#RBAp*A&694A} zeF??>11JDADid!HM9fnS17`9Hm}J)*uLZ!UW`a2bef--MJUBQWrS(7I9v|-oPP6!L zlOiVoK8O1t<-V*dC&?9ilPaR{t3S=5iV*!?B zn(q?Bc;JPL_b)W!S)(Ctf|;UH3QX=`W$dgJ+2-NK-lVK+5DWy6(oIJYhM#VaJ#*5&NVx^$kIOl!v~k!O8gFD zS&b8KFg+?8jp;?V?z2}RV^?o0-Z?YEo_!`m`Yyg#$AI$iUQj#I0)Y!<0p59!X9QeS z=IQxLpu7#CDnx=alm&@`p{f2Lwfr5jSmuxGGsOGOP`G+TMXy8rZr#|tDAcnes4ptB0qVmnpg_=X9E=ZEC1CR@DNI_|Jy zBhgQrvT86&FtmoJC>=@(E-zF&Be`##_5nKsLV30+RfX}mQP(ys6ai1~S zaOJP+G*W|LvW`1X6<)sulFTr+m>E>F?t;!k_(i;Wy7sd^LD@$MpV2#b<*HyukN3Kx z@Y_b1dZr+Ns&R8b-Aer#WX;4sLJlB4GPlv8o%5v$kQ=8#jb|;daAqM@deOsx5#AiY z5YH<_21o-CGB|*Z`tYNHVKP^7s{pgjzR(yAoNnD@9W|2hI( zfExZK68-kuV;TDeyBp{qSlZSHM;=cs*j7GKw=7Tt3Cp6>F2^#1^YjQ@Bx%Z=!F9S4 zo>!D~Y#oWE>S7>BGV>u$z6MhkIzhTYn-A8MwyEpy#5>f=>2a#(fZmVwGBm#+H6<1U z4+xHID%Krx0#O5-gc~IL7qVOwj+LDrJnJDy=`FND_DjO2OH_61M}|qUiK*ATCaK~a zR+iWXQTISDkSG$>7fVPdb7LFiZT1GQoEet~MleTxINH8M3wKG*Oe9I_C3Q2_f_lU@ z@(h`Kgs!O|<<3ArGy^p?Wyd_dN2USnNE;9`h@&@!4tNDbHz#ZW?7&?Z3Br>C;p%{+ zcu)*d@#+|CzuX=wm4WyZnLP)ZwcaXz+@hy{X-c`tHAws`myY`H-sL7_{A7-t!Js~< zpnNBPEJniVNlfRlyl)Y*%4*M-&W0IFFIFals)^n0KWVjarxPadVD4IBMDQCx)I%@` zkjDK69E!*-SRP32W-6y$oHzNIQhuuk^Q4zhb zNipbVAPN*hKR`iAG0T58Ygr%?aKN&d$h59tR1Px9@01$-g#k@%zy*NuYfvw!cyo0N z!XO)<9z%p;g&DD+W|WF;Gct+?B}V3o4y6{%_VVZ8R;y7^-C)2KIy`48LFO_uQvp9$-ngqQQ1U43c5g>mk%aZ8)m*<)&DeN|y~s zK-lkVPM$^Mct4PzP6(XHjfaU+V+kmfh9u971HDTbRg}kb;_k1`-HUf7{p>w@O=>0S zl(n!qm^t|33Y|i$DSCUxS{&SmoHmmy@aP23#DTH{yi0Edsh#Aneh8=VXt*;Uprh=f z!z^mhWF|@#Lj!|@Jg&uR7;=%0{sp7~&znk>u2YHr&Y^UPI`Js@J@6D<<5`M{UGYJ_ zZ>PhabEL-@ar0o5j)|+Z6OZ?{!vb_Fvf=8^5OuFZgs!Jv!QE7rC48%z%_$ zDm}SB1Sa7~{FPIgRArVU@abd@>{b7h-ylu6598Pu3nD|^If1nVJe z9>_Z3J_66cS4q|oyQt=l;iGGvCj+Kj%NVIoo1b~&4Pb{$1O;p^V%8#e7E$G-J{YnXmbIdaU4fM7BPe@ z2%(Q0HtiMG0sZ{D>_tw`rQE!K?z4mFU9-k5ET2`XBPT74|8{|HB?QT+#Z?n79b64s zz0->kKe92v^#SAkXzk6g550oU?DSGt^Ki>=mq~Q@YnQS-fJg7p!3;-e?XL6mejF#` z;~e-0F@=kth=NZybHzC$Hmy&>Aaw02wje$lkyN3X_->9AVyed}bzo7iu+*!#Mi90U zNV6L8gEa#VKO9aYT|SpJNG&O+$lU+35*`{@-~#}Y>9lv{I6w18TFeD(B!!I5xYl@b zJa|6i&i_;+7n}HxtM~rc{AA)=`^vhCJNHWiWBtjF*7@!(R!!x20LT*F2OH zGF}+oei47qi_^!-S*Fjmw+7p25mBkwv3(H)S`}BS)w}M62FXcZ^ZdEvW_VC$*o589Mrdn&M zLyXpg{?S|So=OqxI($FeDvwjlmvM!eH0B(N)b3?D4b$CoC~8UhtaLc8rBf&=)mD)b z#3cK2(EPdUl%a@Fi+4KT%>vKu;=@5{TuNr{z@TvXKW#7nWegcp zF83(=UBiYE-Z1-w96U%yu9-f1d*!|@9_lA(tYg$nndwZ`Uy`}UZh3WIh!7uSWvZ*K z*emM+c|44vq_{t9<2*Im;UuS&Fsf(o3%=y|lwd~p2O(V(pPzpvEKm@X z_(R;*{Mrrd^^d{=szI++>nBrqv~5-b+J4g3LiZbyu#D@^qpq3Bg=Kt7a7$rKNxSIZkuIVlpU4E3{4+|U0uu7uMHTZiUYr`Lm&XUG zx5r1#g`d48q6+IZKvw+$dCY@zH+;>*1B^K08e~HP8MUp4$QrF(H(!--G#w=_u57Ud zrzFt0DT%MU)mM$&09Th41kOmWmZny(wnq@7DLf}e{+_Ilo8(0GWrs|wzNQvvYTZP7 z2E|4&{Zz_)WGia;hTrD=bK=Gbwe!oN@S&y@B3u@&IzBGTgdP7QPG~0>KRoilayd)3 z&Y0<(c}`>p?|iVy`gyhgcTnet=Q?3=!O1bkyKmAbg=TGyM@NjJ`(8&kyE`BtCSQX) zU<-Yz%V(LgG~pE2KB8!T$~Qjtmvs|UV*>Q=g}t1ftoaMAXCB{L09T`Q{%jo!4m8b| zUkCGMJ^E79H{?kY5z}~*eAb<50RNz_HIn?9|2%3&?D^){a@-g9LwdVbZqmOI&l(R; zs;u?2L6?k*`&_O0?YEiKaYMS`v`ZBB`_Z&y%hL3VB5qOOQ4KVdF`H;+^j~A>3pyS0 z+hE~*l`@So4k=)eG2o}HMnshSg{Cz&%_{?Hk!mIH!Ivw$Z5Q4DM7->-%QkF}3%>X2 zRO!~|dX}IYBZ{Gny1ma_7EScyG1D&Dg6>vsD|h<2^feQgR#p@0b>1|H#<26Q_}yTP z4sUld6N1oL3!+RPYeKkoW$)XZ)D~-d5`{qHYmTB4{hwPSM;PXO-t-ZQGfqo<+9c#h z^RGt|Zi(4Fmmd^zz?&t9+VeA9dOP!E@`;qefZY5I;p^B}T0`^qw@etgfVeH_iQ9V% zb=O7Tb&vnbvbTHzN&I?ii4R+`IDmaU^(**M(M3o1?z0_ytbeiu1DPg2#M-kq<^~6w zgiiNzR@`I3cPwGcmfwDkJ^dRUcS-0PLrC)J-^+n5TJ&-)_7D5fKODx|Ji~ANldvlS zfYDFI51zNajULJ*)70T!NoF!JKm52Ov6_|UGF_T_KE3(lyKAK%IFC2}j>f00cad9D zth^8_5oM0wFElJmu;p*XJXh0GY2&|U;-UF7zXIms{4yupjQDM~ao1CleKWj$^2_*s zPBVzFW4%F0A&)6vPcd`-b{Gcu*$S^@HYs>!`dUKdTI!&I#vhs%2q06!iu6sljY3#}i_dAcI$QZ)laHZw4p=?+ZURZ~rWR z5;WPP;binEu})ym+Si=z!t4FxS*bd-zO?;R=&QF})e9UMBGDFq&a$?Jjds6k#9Sk= zgeezKy{jG)s%SIM}t9C#3wNJg$?0ZI380r<%$*#@znh*IZZ22X9qAaeto$cy|Dr{;RX8d3oGY-8R z{kN+nU+3qwd6~sO`L*{{45<}yyKlHgoh$7m&JmL}L2a%o-7doOn%&@qE`7xC%{#Xv zX=ero-#kcXe%Sf0s^8So?4xVm1@+^pwV}ZK9ci|$EZrG>ft@iGVwY5EXp3ENBT~X1 zxL@`0!#LM!roTH0Mc-Kft&YSukNnaD=x;@+SUFGu80-SKwLi1bz3y2jbvS@mw*Gmg zMXToVgFmJP11&lwcY?MJ7_4e4w)a1uZO^EG-L+TYY9D*~Z|v4YWp8oV-;m#iV@Nj} zh7hB+%SK^Ws1$6B`nbQN!MDhK zpUx}Zb*{i`x7SfuiLdBNOb1>Z{T#XR2g9A+P;e)|xni>l5MRC~aSQUkMMy5FcPuQh zk%;)3m?kNAK~=CZVtSS*_4k&);jGf#f2L|{U*K9#=o^K2ApU}$F4R8;*Y)B;J*v+q za!pDM@Iio_M^}rt!)CoBJ4E?oe}fmoNEh7)AHT205b$gFOx+!FZ%2C%ydoa>lvRCJ zfQXdr-wj(?ukoJGZi`JTOFXx3iBg(;?UT~y=Be2{pfuq>lger*{#@UN&;K<< zm|6J){#tVHr3x*_cD0Ah7TtfN3p{^}U|$EvX{&f!%immyJ^rY5b8kOI4&_RC7V2*( z&60TSHCLq)P1~S&OoyRvbw}eP-A*>~5j$(H=^10*~CZ;F{=XrH02hYbq zGJevF2sNH|8jcsYd;Ry-UcsKh-?q0~-@?NK;_R5_e%}k+&Oft~3mdvJnao#9r1hP6 z87%QRzqc z1d!cF%oPg=@?5~oI4_ulxHDYV_8FTs|ts*}dn@oK`}K2#edCB33G~8+O0_T8&`f z5BFoLd=Blm`$bS&$URZA&GCkW*Spfz*mIEmmoJ4Xk&SGRN*vR!RS63kt*!-Z3n~lN zRTcnGXJ=CY1bkcr0000000|#m91#Ej0RO^fybR#R(8$OpCnhB)E;jx~B$XqrDM*u% zr}b+W3EEDgQUELu8zywYpFmZkwbF^AIBq%_>ocPf+i8E9bIn3?md)haveAI5=$HL< zA4{4pTm06~oiwkRFP@o+sTKIQmz9N7YOj)QFIzxa<#| zUicO|ZHK00eW!r7K`;7Tg`1mg+#P{ zxXlU*Pyk*>B#3SLt_bEPR>H{N&mbA$ zc5XBK+3pQ~-Q)AjlLB5$!foZ#VI@R2?a32n6^s;67UwHE- zlfan?TS-78c83O%TM{mx`iB~#jN1Mxs0wbFbb02_V?qx!J?Xm!3p1@GXJ}ell}R#o z5Fs1JeMJ^`-+2)o$JT>Ij3I=Q6CxP3ZHq_jK7i3~8ollW)udnvr*^dTrToXsOjKGa{A_U>-Oaa)PT#DH)vR>E`M1K4v7< z>(G`e#!)-)#N!rVTkcn&k#^Fq3ZxY^Yi%e%^LmPtS|AOp=MQ<41w7kEo6Tx!+TSe0 z`?G7MFJ>APu7I~3>a-ZRXAPE40oVO*zHgPBAaSIbe zfCYXdWyo8Wi|WA62Y3>MGhhL&bXHOlQdmYDAdX#UvVNAr>SBr6dl>aa}4Iixm9zfk-!KTT-WM^wPZo; zq7j14DSL)rS{C9AWSa^69Pyj|?;`5Q`I>!ck_N6Fd|)k)VTo`5&b}{FpYGS$*cEPJ z96Ndk0eL{S0gMHK@f-kvWRUm?gV z`Q7t5)1T|sf8buEIe&8q!>uCG1D&688-kxkGpL{5&M-lH=cK^DE!wXCH?b^Wlv>az YUDBncxLMNc6wsjzp00i_>zopr0N>A85&!@I literal 0 HcmV?d00001 diff --git a/Resources/Textures/Objects/Specific/Medical/mouth_swab.rsi/meta.json b/Resources/Textures/Objects/Specific/Medical/mouth_swab.rsi/meta.json new file mode 100644 index 0000000000..437c1de1de --- /dev/null +++ b/Resources/Textures/Objects/Specific/Medical/mouth_swab.rsi/meta.json @@ -0,0 +1,15 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY", + "copyright": "Created by Willhudson#4576 (Discord user id: 935437363180613672) in the SS14 Discord", + "states": [ + { + "name": "icon", + "directions": 1 + } + ] +} diff --git a/Resources/Textures/Structures/Machines/diagnoser.rsi/icon.png b/Resources/Textures/Structures/Machines/diagnoser.rsi/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..4ae4891b9fc334cc893b6d9ecf8d1b3c72d53809 GIT binary patch literal 578 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 literal 0 HcmV?d00001 diff --git a/Resources/Textures/Structures/Machines/vaccinator.rsi/unlit.png b/Resources/Textures/Structures/Machines/vaccinator.rsi/unlit.png new file mode 100644 index 0000000000000000000000000000000000000000..65199b874cb23c7668f2ed146331ea8dea639cdf GIT binary patch literal 174 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz#^NA%Cx&(BWL^R}8J;eVArbD$ zDG~_>EDn4#?y*WRVR3Ut5DdyJyZEdB>TkX4wtd3F*{(Zo$);E~%v$I&jd{h*E~(N3 z85})r4EF>Yo`27j{V%ymOXC0jZU4?|R83j6&@J@v2~Bx7Spz91hA(r46+^h|J0bu8 literal 0 HcmV?d00001