using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RepoHudPlus")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RepoHudPlus")]
[assembly: AssemblyTitle("RepoHudPlus")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RepoHudPlus
{
	public class HudPlus : MonoBehaviour
	{
		private class CinemaEntry
		{
			public Canvas canvas;

			public CanvasGroup group;

			public bool wasEnabled;

			public bool addedGroup;

			public float wasAlpha;
		}

		private class FlashEntry
		{
			public Component comp;

			public FieldInfo hideField;

			public bool hideWas;

			public List<Light> lights = new List<Light>();

			public List<bool> lightsWas = new List<bool>();
		}

		private class Notice
		{
			public string text;

			public float born;

			public bool join;
		}

		private class ExtractState
		{
			public float shown;

			public float vel;

			public float flashUntil;

			public bool hidden;

			public string lastState;

			public string loggedState;

			public object stateObj;
		}

		private class BarSlot
		{
			public GameObject go;

			public RectTransform rt;

			public RectTransform glowRt;

			public RectTransform trackRt;

			public RectTransform fillRt;

			public RectTransform textRt;

			public CanvasGroup group;

			public Image glow;

			public Image track;

			public Image fill;

			public TextMeshProUGUI text;

			public int owner;

			public int lastPct = -1;

			public bool wanted;

			public float slide;

			public float slideVel;

			public float y;

			public float yVel;

			public float targetY;

			public float layoutW;
		}

		private class NameLabel
		{
			public TMP_Text t;

			public string seen;

			public bool isHost;

			public bool separate;

			public bool lobbyChecked;

			public bool lobbyRow;
		}

		private class HeadField
		{
			public string label;

			public object owner;

			public FieldInfo fi;

			public string Name => fi.Name;
		}

		private class InvSlot
		{
			public RectTransform rt;

			public RectTransform iconRt;

			public RectTransform numRt;

			public Image panel;

			public Image icon;

			public TextMeshProUGUI num;

			public int lastNum = -1;

			public string lastName;
		}

		private class Token
		{
			public int id;

			public int rarity;

			public float hp = 1f;

			public float maxHp = 1f;

			public float lastFrac = 1f;

			public float healUntil;

			public bool inExtraction;

			public float slide;

			public float slideV;

			public float curX;

			public float curY;

			public float warn;

			public float warnV;

			public bool placed;

			public bool wantShow = true;

			public int phase;

			public float crossStart = -99f;

			public float inExtLast = -99f;

			public RectTransform markRt;

			public Image mark;

			public float phaseStart;

			public float hitUntil;

			public RectTransform rt;

			public RectTransform coinRt;

			public RectTransform warnRt;

			public Image coin;

			public Image tri;

			public RectTransform[] pieceRt;

			public Image[] piece;

			public bool cracked;
		}

		private class TokRow
		{
			public int rarity;

			public readonly List<Token> list = new List<Token>();

			public float y;

			public bool yPlaced;
		}

		private class CosBox
		{
			public object obj;

			public int id;

			public Token tok;

			public bool found;

			public float maxSeen;

			public float lastHp = float.NaN;

			public string lastSig;
		}

		private bool cinema;

		private float nextCinemaFind;

		private readonly Dictionary<int, CinemaEntry> cinemaEntries = new Dictionary<int, CinemaEntry>();

		private readonly List<int> cinemaStale = new List<int>();

		private string cinemaKeyName;

		private KeyCode cinemaLegacy;

		private object cinemaNewKey;

		private Type cinemaKbType;

		private bool cinemaKeyReady;

		private bool cinemaLegacyBroken;

		private bool cinemaNewBroken;

		private PropertyInfo cinemaCurrentProp;

		private PropertyInfo cinemaItemProp;

		private PropertyInfo cinemaPressedProp;

		private readonly Dictionary<int, FlashEntry> cinemaFlash = new Dictionary<int, FlashEntry>();

		private readonly List<int> cinemaFlashStale = new List<int>();

		private bool flashDumped;

		private bool flashMissingLogged;

		private float nextFlashFind;

		private Sprite[] heartSprites;

		private RectTransform heartRt;

		private RectTransform heartImgRt;

		private RectTransform heartPrevRt;

		private Image heartImg;

		private Image heartPrevImg;

		private int heartStage;

		private int heartSpriteIdx = -1;

		private float heartLastWarranted;

		private float heartPrevFade;

		private float heartSlide;

		private float heartBreakT = 99f;

		private float heartPhase;

		private float heartDist = float.MaxValue;

		private float nextEnemyScan;

		private bool heartDead;

		private bool enemyLogged;

		private bool enemyTypeMissingLogged;

		private static readonly float[] HeartPeriod = new float[4] { 1.15f, 0.8f, 0.55f, 0.34f };

		private static readonly float[] HeartAmp = new float[4] { 0.05f, 0.08f, 0.12f, 0.17f };

		private Sprite[] enSprites;

		private RectTransform enRt;

		private RectTransform enHpIconRt;

		private RectTransform enDmgIconRt;

		private Image enHpIcon;

		private Image enDmgIcon;

		private TextMeshProUGUI enHpText;

		private TextMeshProUGUI enDmgText;

		private bool enHave;

		private float enCur;

		private float enMax;

		private float enMaxSeen;

		private float enPrevCur = float.NaN;

		private float enDmg;

		private float enDmgDropAt = -99f;

		private float enHitAt = -99f;

		private float enAlpha;

		private float nextEnScan;

		private int enId;

		private int enStage = -1;

		private int enLogs;

		private bool enInfoDone;

		private string enSig;

		private string enHpLast;

		private string enDmgLast;

		private const float EnHitTime = 0.3f;

		private static readonly Color[] EnTextCols = (Color[])(object)new Color[4]
		{
			new Color(0.84f, 0.18f, 0.22f),
			new Color(0.7f, 0.14f, 0.17f),
			new Color(0.58f, 0.11f, 0.12f),
			new Color(0.55f, 0.1f, 0.1f)
		};

		private static readonly Color EnDmgCol = new Color(1f, 0.83f, 0f);

		private float enNameTop = float.NaN;

		private float nextNameScan;

		private float enNameLogged;

		private float enAtk;

		private float nextAtkScan;

		private bool atkDumped;

		private int atkLogs;

		private TextMeshProUGUI hnText;

		private float hnAlpha;

		private float nextHnScan;

		private bool hnHave;

		private bool hnDumped;

		private string hnName;

		private Color hnColor = Color.white;

		private int hnId;

		private int hnLogs;

		private object healTarget;

		private float nextHealScan;

		private bool healInfoDone;

		private int healLogs;

		private string healSig;

		private GameObject srvBtn;

		private TMP_Text srvBtnText;

		private float nextSrvScan;

		private bool srvInfoLogged;

		private float nextRefreshAllowed;

		private bool menuMethodsLogged;

		private readonly Dictionary<int, string> actorNames = new Dictionary<int, string>();

		private readonly List<Notice> notices = new List<Notice>();

		private const float NoticeLife = 5f;

		private const float NoticeSlide = 0.4f;

		private readonly List<TextMeshProUGUI> noticeTexts = new List<TextMeshProUGUI>();

		private float nextPlayerScan;

		private static bool kickHooked;

		private static string lastKickName;

		private static int lastKickActor = -1;

		private static float lastKickAt = -99f;

		private Transform specListTr;

		private float nextSpecListFind;

		private float specBlockTop = -1f;

		private TMP_Text blkHead;

		private float blkTop;

		private float blkLeft;

		private float nextBlk;

		private readonly HashSet<int> joinPending = new HashSet<int>();

		private static readonly Regex LateJoinRe = new Regex("late[\\s_\\-]*join", RegexOptions.IgnoreCase);

		private int joinSkipLogs;

		private RectTransform menuWrap;

		private TextMeshProUGUI menuPlayers;

		private TextMeshProUGUI menuRoom;

		private TextMeshProUGUI menuDeaths;

		private Transform menuPage;

		private float nextMenuInfo;

		private float nextDeathScan;

		private string menuTypeSig;

		private string menuWhyLogged;

		private int runDeaths;

		private readonly Dictionary<int, bool> deadSeen = new Dictionary<int, bool>();

		private static readonly Color MenuPlayersCol = new Color(0.25f, 0.85f, 1f);

		private static readonly Color MenuRoomCol = new Color(1f, 0.55f, 0f);

		private static readonly Color MenuDeathsCol = new Color(1f, 0.15f, 0.2f);

		private static float suicideStamp = -99f;

		private static int suicideLogs;

		private float menuAnyPageAt = -99f;

		private bool suicideHooked;

		private bool suicideHookFound;

		private bool deathsLobbyMenuLast;

		private bool deathsArenaLast;

		private Transform menuLastPage;

		private Canvas menuCanvas;

		private static readonly Color Orange = new Color(1f, 0.42f, 0f);

		private static readonly Color Green = new Color(0.2f, 1f, 0.3f);

		private static readonly Color Track = new Color(0.1f, 0.06f, 0.03f, 0.55f);

		private static readonly Color Rim = new Color(1f, 1f, 1f, 0.1f);

		private static readonly Color HpGreen = new Color(0.25f, 1f, 0.3f);

		private static readonly Color EnCyan = new Color(0.1f, 0.8f, 1f);

		private static readonly Color HpFillFull = C(8, 255, 0);

		private static readonly Color HpFillOrange = C(255, 123, 0);

		private static readonly Color HpFillMid = C(255, 212, 0);

		private static readonly Color HpFillCrit = C(255, 51, 62);

		private static readonly Color HpLineFull = C(0, 89, 61);

		private static readonly Color HpLineOrange = C(133, 28, 0);

		private static readonly Color HpLineMid = C(165, 37, 1);

		private static readonly Color HpLineCrit = C(142, 30, 75);

		private static readonly Color ShatterFill = C(115, 126, 138);

		private static readonly Color ShatterLine = C(71, 74, 87);

		private static readonly Color ShatterShadow = C(255, 190, 194);

		private static readonly Color HpHit = new Color(1f, 0.1f, 0.1f);

		private static readonly Color HpHitLine = new Color(0.45f, 0.04f, 0.1f);

		private static readonly Color HpHealFill = Color.white;

		private static readonly Color HpHealLine = new Color(0.4f, 0.85f, 0.5f);

		private const float HpHealTime = 0.6f;

		private static readonly float[] HpStopF = new float[8] { 1f, 0.72f, 0.68f, 0.52f, 0.48f, 0.32f, 0.28f, 0f };

		private static readonly Color[] HpStopC = (Color[])(object)new Color[8] { HpFillFull, HpFillFull, HpFillOrange, HpFillOrange, HpFillMid, HpFillMid, HpFillCrit, HpFillCrit };

		private static readonly Color[] HpStopL = (Color[])(object)new Color[8] { HpLineFull, HpLineFull, HpLineOrange, HpLineOrange, HpLineMid, HpLineMid, HpLineCrit, HpLineCrit };

		private static readonly Color BatDark = C(150, 20, 26);

		private static readonly Color BatDarker = C(96, 10, 14);

		private static readonly float[] ShardRot = new float[6] { 1f, -0.8f, -1.2f, 0.9f, -1f, 1.1f };

		private readonly Dictionary<int, ExtractState> extract = new Dictionary<int, ExtractState>();

		private Object[] extractionPoints = (Object[])(object)new Object[0];

		private float nextScan;

		private bool dumped;

		private bool inShop;

		private MethodInfo runIsShop;

		private bool runIsShopSearched;

		private bool inLevel;

		private MethodInfo runIsLevel;

		private bool runIsLevelSearched;

		private bool levelGenLogged;

		private float nextCounterScan = 0.25f;

		private readonly HashSet<int> aliveIds = new HashSet<int>();

		private readonly List<int> staleIds = new List<int>();

		private TMP_FontAsset fontAsset;

		private float nextFontTry;

		private bool fontsLogged;

		private const string OwnCanvasName = "RepoHudPlusCanvas";

		private Canvas hudCanvas;

		private RectTransform root;

		private CanvasGroup rootGroup;

		private GameObject ownCanvasGo;

		private string hudSource = "";

		private bool usingOwnCanvas;

		private bool canvasesLogged;

		private readonly List<TextMeshProUGUI> allTexts = new List<TextMeshProUGUI>();

		private Sprite pillSprite;

		private Sprite boltSprite;

		private Sprite glowSprite;

		private Sprite ringSprite;

		private readonly List<BarSlot> slots = new List<BarSlot>();

		private GameObject specGroup;

		private TextMeshProUGUI dhText;

		private RectTransform dhRt;

		private float dhAlpha;

		private float headMax;

		private int dhLastPct = -1;

		private RectTransform bolt;

		private RectTransform hpTextRt;

		private RectTransform enTextRt;

		private RectTransform batTextRt;

		private Image boltImg;

		private GameObject enObj;

		private GameObject batObj;

		private TextMeshProUGUI hpText;

		private TextMeshProUGUI enText;

		private TextMeshProUGUI batText;

		private RectTransform hpGroup;

		private RectTransform hpIcon;

		private CanvasGroup hpGroupCg;

		private Sprite bodySprite;

		private readonly Sprite[] hpArtSprites = (Sprite[])(object)new Sprite[5];

		private readonly Sprite[] hpArtWhite = (Sprite[])(object)new Sprite[5];

		private Image hpArtPrev;

		private Image hpArtCur;

		private Image hpArtOver;

		private int hpArtIdx = -1;

		private float hpArtFade = 1f;

		private const float HpArtFadeTime = 0.15f;

		private static readonly int[] RainbowArt = new int[4] { 0, 2, 1, 3 };

		private float hpPrev = float.NaN;

		private float hpFrac = 1f;

		private float hpFracVel;

		private float hpNum;

		private float hpNumVel;

		private float hpHealLeft;

		private const float SlideTime = 0.24f;

		private RectTransform hpWrap;

		private RectTransform enWrap;

		private RectTransform batWrap;

		private bool hpHealStyle;

		private float hpSl;

		private float hpSlV;

		private float enSl;

		private float enSlV;

		private float batSl;

		private float batSlV;

		private float breakAmt;

		private float breakVel;

		private float shake;

		private float shakeAmp = 1f;

		private float hitFlash;

		private float deathT = -1f;

		private float hpLayoutS;

		private int hpPlayerId;

		private int hpShownInt = int.MinValue;

		private int hpShownMax = int.MinValue;

		private bool hpDead;

		private bool wasBreak;

		private static readonly string[] HudTypeNames = new string[7] { "HUDCanvas", "HealthUI", "EnergyUI", "CurrencyUI", "GoalUI", "InventoryUI", "SemiUI" };

		private bool seenLocked;

		private bool lastMenuOpen;

		private readonly Dictionary<string, MethodInfo> semiCache = new Dictionary<string, MethodInfo>();

		private static readonly Regex CostRx = new Regex("^[-\\u2212\\u2013]\\s*\\$\\s*([\\d.,]+)\\s*([KkMm]?)$");

		private static readonly Regex MoneyRx = new Regex("^\\$\\s*([\\d.,]+)\\s*([KkMm]?)$");

		private static readonly Color ShopPurple = new Color(0.74f, 0.36f, 1f);

		private readonly Dictionary<int, TextMeshProUGUI> shopLabels = new Dictionary<int, TextMeshProUGUI>();

		private float nextShopScan;

		private int shopLogs;

		private bool shopPathsLogged;

		private readonly Dictionary<int, Vector3> shopBasePos = new Dictionary<int, Vector3>();

		private readonly Dictionary<int, Color> shopBaseCol = new Dictionary<int, Color>();

		private readonly Dictionary<int, float> shopHitUntil = new Dictionary<int, float>();

		private const float ShopHitTime = 0.25f;

		private static readonly Color ShopRed = new Color(1f, 0.12f, 0.12f);

		private Type shopMgrType;

		private Type itemAttrType;

		private bool shopTypesSearched;

		private FieldInfo[] shopListFields;

		private string lastListSig;

		private string lastTotalSig;

		private bool shopDumped;

		private TMP_Text lastCartT;

		private double lastCartTotal;

		private float lastCartAt;

		private static string hostWordCache;

		private static string hostTagCache;

		private static readonly Regex MarkupRx = new Regex("<[^>]*>");

		private readonly List<TMP_Text> hostTargets = new List<TMP_Text>();

		private readonly Dictionary<int, NameLabel> nameLabels = new Dictionary<int, NameLabel>();

		private readonly List<int> nameLabelStale = new List<int>();

		private bool hostScanSpectating;

		private float nextHostScan;

		private string lastHostName;

		private bool hostLogged;

		private int hostMissLogs;

		private int lastHostCount = -1;

		private float nextHostMissLog;

		private readonly Dictionary<int, TextMeshProUGUI> hostSide = new Dictionary<int, TextMeshProUGUI>();

		private int hostSepLogs;

		private const bool SideHostTag = false;

		private RectTransform lobbyWrap;

		private TextMeshProUGUI lobbyPlayers;

		private TextMeshProUGUI lobbyRoom;

		private Canvas lobbyCanvas;

		private bool lobbyInPage;

		private float nextLobbyInfo;

		private bool lobbyInfoLogged;

		private bool lobbyPropsLogged;

		private static readonly Color LobbyGrey = new Color(0.55f, 0.65f, 0.74f);

		private static readonly Color LobbyOrange = new Color(1f, 0.42f, 0f);

		private string lobbyNameCache;

		private bool lobbyNameLogged;

		private RectTransform upgWrap;

		private TextMeshProUGUI upgText;

		private readonly TextMeshProUGUI[] upgCols = (TextMeshProUGUI[])(object)new TextMeshProUGUI[3];

		private float upgLineH;

		private string upgKey;

		private float upgSl;

		private float upgSlV;

		private float nextUpgRead;

		private int upgPid;

		private string upgCache;

		private string upgLast;

		private FieldInfo[] upgFields;

		private Type statsType;

		private bool upgSearched;

		private readonly List<int> deathOrder = new List<int>();

		private readonly Dictionary<string, int> rankByName = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		private bool inArena;

		private MethodInfo runIsArena;

		private bool runIsArenaSearched;

		private float nextRankScan;

		private readonly Dictionary<int, string> arenaNames = new Dictionary<int, string>();

		private readonly HashSet<int> arenaAliveSeen = new HashSet<int>();

		private int arenaTotal;

		private float nextRankMissLog;

		private int rankMissLogs;

		private bool rankPlacedLogged;

		private bool rankTagSkipLogged;

		private static readonly Regex RankRx = new Regex("\\s?<link=\"rk\">.*?</link>", RegexOptions.Singleline);

		private readonly Dictionary<int, KeyValuePair<TMP_Text, int>> rankTargets = new Dictionary<int, KeyValuePair<TMP_Text, int>>();

		private int rankPlacedLogs;

		private readonly List<string> listSeen = new List<string>();

		private float nextRankDiag;

		private readonly List<Component> gunItems = new List<Component>();

		private float nextGunScan;

		private Type batteryType;

		private Type gunType;

		private bool gunTypesSearched;

		private TextMeshProUGUI ammoText;

		private RectTransform ammoRt;

		private float ammoAlpha;

		private int ammoLast = -999;

		private int ammoLogs;

		private Component ammoTarget;

		private float ammoHit;

		private readonly List<Image> ammoBarImgs = new List<Image>();

		private float nextAmmoBarScan;

		private int ammoBarCountLogged = -1;

		private static readonly Vector3[] wcorners = (Vector3[])(object)new Vector3[4];

		private float nextAmmoArena;

		private bool ammoArena;

		private static readonly Color AmmoLight = new Color(1f, 0.96f, 0.58f);

		private float ammoChargeUntil;

		private static readonly string[][] MapProbes = new string[2][]
		{
			new string[3] { "MapToolController", "instance", "Active" },
			new string[3] { "MapToolController", "Instance", "Active" }
		};

		private bool mapProbeLogged;

		private float ammoShowUntil;

		private bool heldApiLogged;

		private TextMeshProUGUI mmTitle;

		private TextMeshProUGUI mmText;

		private float mmSl;

		private float mmSlV;

		private float nextMmRead;

		private double mmValue = -1.0;

		private bool mmLogged;

		private string mmLast;

		private Dictionary<int, double> mmSeen = new Dictionary<int, double>();

		private double mmLastDamage;

		private float mmHitUntil;

		private const float MmHitTime = 0.7f;

		private static readonly Color MmGreen = new Color(0.45f, 1f, 0.2f, 1f);

		private static readonly Color MmRed = new Color(1f, 0.1f, 0.1f, 1f);

		private float mmLow = 1f;

		private float mmLowV;

		private bool mmOpened;

		private const float MmLowShift = 100f;

		private bool counterFound;

		private bool counterPreferred;

		private float liveLeft;

		private float liveTop;

		private float liveBottom;

		private float liveSeenAt = -99f;

		private float levelLoadedAt;

		private float counterCx;

		private float counterBottom;

		private float counterLeft;

		private float counterTop;

		private float trackW;

		private float trackH;

		private readonly List<TMP_Text> counterTexts = new List<TMP_Text>();

		private int moveLogs;

		private float lastLogX = -9999f;

		private float lastLogY = -9999f;

		private string parsedHex;

		private Color parsedColor = Orange;

		private bool badHexLogged;

		private bool lastSpectating;

		private string lastSpecState;

		private readonly List<HeadField> headCands = new List<HeadField>();

		private HeadField headSrc;

		private HeadField headMaxSrc;

		private bool headDiscovered;

		private float nextHeadDiscover;

		private float nextHeadLog;

		private int headLogs;

		private float dhY = float.NaN;

		private float dhYV;

		private float headPromptTop = float.NaN;

		private bool headModeNow;

		private float headAnchorTop = float.NaN;

		private float headAnchorCx = float.NaN;

		private float nextHeadInactive;

		private readonly HashSet<string> headScanSeen = new HashSet<string>();

		private int headScanLogs;

		private int headEDiagLogs;

		private float headIconTop = float.NaN;

		private float headIconCx = float.NaN;

		private int headIconLogs;

		private string headIconLast;

		private const int InvSlots = 3;

		private readonly InvSlot[] invUi = new InvSlot[3];

		private RectTransform invWrap;

		private float invSl;

		private float invSlV;

		private float invLayoutW = -1f;

		private Sprite roundSprite;

		private object invPlayerObj;

		private int invPlayerId;

		private bool invDirty;

		private bool invScanWanted;

		private float nextInvScan;

		private int invLogs;

		private readonly Sprite[] invSprites = (Sprite[])(object)new Sprite[3];

		private readonly string[] invNames = new string[3];

		private readonly bool[] invFilled = new bool[3];

		private readonly List<TokRow> tokRows = new List<TokRow>();

		private RectTransform tokRoot;

		private Sprite[] coinSprites = (Sprite[])(object)new Sprite[4];

		private Sprite[][] pieceSprites = new Sprite[4][];

		private Sprite triRedSprite;

		private Sprite triYellowSprite;

		private static readonly Color[] CoinLine = (Color[])(object)new Color[4]
		{
			C(0, 101, 79),
			C(51, 130, 182),
			C(91, 27, 148),
			C(165, 37, 1)
		};

		private static readonly Color[] CoinFill = (Color[])(object)new Color[4]
		{
			C(140, 225, 35),
			C(70, 215, 200),
			C(205, 75, 175),
			C(255, 190, 20)
		};

		private const float TokDiam = 0.63f;

		private const float TokHitTime = 0.6f;

		private const float TokPreBreak = 0.28f;

		private const float TokShatterTime = 0.8f;

		private const float TokHealTime = 0.7f;

		private const float TokCheckTime = 0.95f;

		private const float TokCrossTime = 1.1f;

		private Sprite checkSprite;

		private Sprite crossSprite;

		private static readonly Color TokLightGreen = new Color(0.55f, 1f, 0.6f);

		private static readonly Color TokLightYellow = new Color(1f, 0.96f, 0.58f);

		private readonly Dictionary<int, CosBox> cosBoxes = new Dictionary<int, CosBox>();

		private Type cosType;

		private bool cosSearched;

		private float cosNextLog;

		private int cosLastCount = -1;

		private int tokNextId = 1;

		private static readonly string[] HpCurNames = new string[9] { "health", "currentHealth", "healthCurrent", "hp", "currentHp", "current", "amount", "value", "healthAmount" };

		private static readonly string[] HpMaxNames = new string[9] { "maxHealth", "healthMax", "maxHp", "max", "startHealth", "healthStart", "initialHealth", "totalHealth", "baseHealth" };

		private bool cosHealthDumped;

		private int cosHpLogs;

		private static readonly Regex ScanFlagRx = new Regex("^(is|has)?(discovered|scanned|revealed)$", RegexOptions.IgnoreCase);

		private readonly Dictionary<Type, FieldInfo[]> scanFields = new Dictionary<Type, FieldInfo[]>();

		private int cosProbeLogs;

		private float nextCosScan;

		private float testNext;

		private int testStep;

		private readonly List<Token> testTokens = new List<Token>();

		private Sprite tokArrowSprite;

		private RectTransform tokArrow;

		private Image tokArrowImg;

		private Object tokSel;

		private float tokPulse;

		private float tokHitUntil;

		private const float TokSelHitTime = 0.22f;

		private bool tokKeysBroken;

		private static HudPlus tokInst;

		private bool tokHooked;

		private int tokPrepLogs;

		private int tokDiagErr;

		private int tokRectLogs;

		private static string HostWord => Loc.Host();

		private static string HostTag
		{
			get
			{
				string text = Loc.Host();
				if (text != hostWordCache)
				{
					hostWordCache = text;
					hostTagCache = " <color=#B8541A>[" + text + "]</color>";
				}
				return hostTagCache;
			}
		}

		private void FindCinemaFlashlights()
		{
			Type type = R.T("FlashlightController");
			if (type == null)
			{
				if (!flashMissingLogged)
				{
					flashMissingLogged = true;
					Plugin.Log.LogInfo((object)"[Cinematic] the game's FlashlightController type was not found: the flashlight is left alone");
				}
				return;
			}
			if (!flashDumped)
			{
				flashDumped = true;
				R.Dump("FlashlightController", "hide", "light", "active", "state", "toggle", "player");
			}
			object obj = R.Get(R.T("PlayerAvatar"), "instance");
			Object[] array = Object.FindObjectsOfType(type);
			foreach (Object val in array)
			{
				Component val2 = (Component)(object)((val is Component) ? val : null);
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)val2).GetInstanceID();
				if (cinemaFlash.ContainsKey(instanceID))
				{
					continue;
				}
				object obj2 = R.Get(val, "PlayerAvatar", "playerAvatar");
				if (R.Alive(obj2) && R.Alive(obj) && !obj2.Equals(obj))
				{
					continue;
				}
				FlashEntry flashEntry = new FlashEntry
				{
					comp = val2
				};
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (fieldInfo.FieldType == typeof(bool) && fieldInfo.Name.IndexOf("hide", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						flashEntry.hideField = fieldInfo;
						flashEntry.hideWas = (bool)fieldInfo.GetValue(val);
						break;
					}
				}
				Light[] componentsInChildren = val2.GetComponentsInChildren<Light>(true);
				foreach (Light val3 in componentsInChildren)
				{
					flashEntry.lights.Add(val3);
					flashEntry.lightsWas.Add(((Behaviour)val3).enabled);
				}
				cinemaFlash[instanceID] = flashEntry;
				Plugin.Log.LogInfo((object)("[Cinematic] flashlight off: " + ((Object)val2).name + " (hide flag: " + ((flashEntry.hideField != null) ? flashEntry.hideField.Name : "none") + ", " + flashEntry.lights.Count + " light(s))"));
			}
		}

		private void ApplyCinemaFlash()
		{
			cinemaFlashStale.Clear();
			foreach (KeyValuePair<int, FlashEntry> item in cinemaFlash)
			{
				FlashEntry value = item.Value;
				if ((Object)(object)value.comp == (Object)null)
				{
					cinemaFlashStale.Add(item.Key);
					continue;
				}
				if (value.hideField != null)
				{
					try
					{
						if (!(bool)value.hideField.GetValue(value.comp))
						{
							value.hideField.SetValue(value.comp, true);
						}
					}
					catch
					{
						value.hideField = null;
					}
				}
				for (int i = 0; i < value.lights.Count; i++)
				{
					if ((Object)(object)value.lights[i] != (Object)null && ((Behaviour)value.lights[i]).enabled)
					{
						((Behaviour)value.lights[i]).enabled = false;
					}
				}
			}
			foreach (int item2 in cinemaFlashStale)
			{
				cinemaFlash.Remove(item2);
			}
		}

		private void RestoreCinemaFlash()
		{
			foreach (FlashEntry value in cinemaFlash.Values)
			{
				if ((Object)(object)value.comp == (Object)null)
				{
					continue;
				}
				if (value.hideField != null)
				{
					try
					{
						value.hideField.SetValue(value.comp, value.hideWas);
					}
					catch
					{
					}
				}
				for (int i = 0; i < value.lights.Count; i++)
				{
					if ((Object)(object)value.lights[i] != (Object)null)
					{
						((Behaviour)value.lights[i]).enabled = value.lightsWas[i];
					}
				}
			}
			if (cinemaFlash.Count > 0)
			{
				Plugin.Log.LogInfo((object)"[Cinematic] flashlight back");
			}
			cinemaFlash.Clear();
		}

		private void PrepareCinemaKey()
		{
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Invalid comparison between Unknown and I4
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			string text = (Plugin.CinemaKey.Value ?? "").Trim();
			if (cinemaKeyReady && text == cinemaKeyName)
			{
				return;
			}
			cinemaKeyReady = true;
			cinemaKeyName = text;
			cinemaNewKey = null;
			cinemaLegacy = (KeyCode)0;
			cinemaCurrentProp = (cinemaItemProp = (cinemaPressedProp = null));
			if (text.Length == 0 || text.Equals("None", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			try
			{
				cinemaLegacy = (KeyCode)Enum.Parse(typeof(KeyCode), text, ignoreCase: true);
			}
			catch
			{
				Plugin.Log.LogWarning((object)("[Cinematic] unknown key '" + text + "' (use names like F9, P, Home)"));
			}
			try
			{
				cinemaKbType = R.T("UnityEngine.InputSystem.Keyboard");
				Type type = R.T("UnityEngine.InputSystem.Key");
				if (cinemaKbType != null && type != null && type.IsEnum)
				{
					cinemaNewKey = Enum.Parse(type, text, ignoreCase: true);
				}
			}
			catch
			{
			}
			Plugin.Log.LogInfo((object)("[Cinematic] key '" + text + "' (legacy input: " + ((int)cinemaLegacy > 0) + ", Input System: " + (cinemaNewKey != null) + ")"));
		}

		private bool CinemaKeyPressed()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			PrepareCinemaKey();
			if ((int)cinemaLegacy == 0 && cinemaNewKey == null)
			{
				return false;
			}
			if (!cinemaLegacyBroken && (int)cinemaLegacy != 0)
			{
				try
				{
					Type type = R.T("UnityEngine.Input");
					MethodInfo methodInfo = ((type != null) ? type.GetMethod("GetKeyDown", new Type[1] { typeof(KeyCode) }) : null);
					if (methodInfo == null)
					{
						cinemaLegacyBroken = true;
					}
					else
					{
						object obj = methodInfo.Invoke(null, new object[1] { cinemaLegacy });
						bool flag = default(bool);
						int num;
						if (obj is bool)
						{
							flag = (bool)obj;
							num = 1;
						}
						else
						{
							num = 0;
						}
						if (((uint)num & (flag ? 1u : 0u)) != 0)
						{
							return true;
						}
					}
				}
				catch
				{
					cinemaLegacyBroken = true;
				}
			}
			if (!cinemaNewBroken && cinemaNewKey != null)
			{
				try
				{
					if (cinemaCurrentProp == null)
					{
						cinemaCurrentProp = cinemaKbType.GetProperty("current", BindingFlags.Static | BindingFlags.Public);
					}
					if (cinemaItemProp == null)
					{
						cinemaItemProp = cinemaKbType.GetProperty("Item", new Type[1] { cinemaNewKey.GetType() });
					}
					object obj3 = ((cinemaCurrentProp != null) ? cinemaCurrentProp.GetValue(null, null) : null);
					if (obj3 != null && cinemaItemProp != null)
					{
						object value = cinemaItemProp.GetValue(obj3, new object[1] { cinemaNewKey });
						if (value != null)
						{
							if (cinemaPressedProp == null)
							{
								cinemaPressedProp = value.GetType().GetProperty("wasPressedThisFrame");
							}
							bool flag2 = default(bool);
							int num2;
							if (cinemaPressedProp != null)
							{
								object obj = cinemaPressedProp.GetValue(value, null);
								if (obj is bool)
								{
									flag2 = (bool)obj;
									num2 = 1;
								}
								else
								{
									num2 = 0;
								}
							}
							else
							{
								num2 = 0;
							}
							if (((uint)num2 & (flag2 ? 1u : 0u)) != 0)
							{
								return true;
							}
						}
					}
				}
				catch (Exception ex)
				{
					cinemaNewBroken = true;
					Plugin.Log.LogWarning((object)("[Cinematic] reading the key through the Input System failed: " + ex.Message));
				}
			}
			return false;
		}

		private void FindCinemaCanvases()
		{
			if ((Object)(object)root != (Object)null)
			{
				AddCinemaCanvas(((Component)root).GetComponentInParent<Canvas>(true));
			}
			Canvas[] array = Object.FindObjectsOfType<Canvas>();
			foreach (Canvas val in array)
			{
				if ((Object)(object)val != (Object)null && val.isRootCanvas && ((Object)((Component)val).gameObject).name.IndexOf("HUD", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					AddCinemaCanvas(val);
				}
			}
		}

		private void AddCinemaCanvas(Canvas c)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c == (Object)null)
			{
				return;
			}
			c = c.rootCanvas;
			int instanceID = ((Object)c).GetInstanceID();
			if (!cinemaEntries.ContainsKey(instanceID))
			{
				CanvasGroup val = ((Component)c).GetComponent<CanvasGroup>();
				bool addedGroup = false;
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)c).gameObject.AddComponent<CanvasGroup>();
					addedGroup = true;
				}
				cinemaEntries[instanceID] = new CinemaEntry
				{
					canvas = c,
					group = val,
					wasEnabled = ((Behaviour)c).enabled,
					addedGroup = addedGroup,
					wasAlpha = val.alpha
				};
				Plugin.Log.LogInfo((object)("[Cinematic] hiding canvas " + ((Object)c).name + " (" + ((object)c.renderMode/*cast due to .constrained prefix*/).ToString() + ")"));
			}
		}

		private void RestoreCinema()
		{
			foreach (CinemaEntry value in cinemaEntries.Values)
			{
				if ((Object)(object)value.canvas != (Object)null)
				{
					((Behaviour)value.canvas).enabled = value.wasEnabled;
				}
				if ((Object)(object)value.group != (Object)null)
				{
					value.group.alpha = value.wasAlpha;
					if (value.addedGroup)
					{
						Object.Destroy((Object)(object)value.group);
					}
				}
			}
			cinemaEntries.Clear();
		}

		private void UpdateCinematic()
		{
			if (CinemaKeyPressed() && !IsMenuOpen())
			{
				cinema = !cinema;
				nextCinemaFind = 0f;
				Plugin.Log.LogInfo((object)("[Cinematic] " + (cinema ? "on: HUD hidden" : "off: HUD back")));
				if (!cinema)
				{
					RestoreCinema();
					RestoreCinemaFlash();
				}
				else
				{
					nextFlashFind = 0f;
				}
			}
			if (!cinema)
			{
				return;
			}
			if (Time.unscaledTime >= nextCinemaFind)
			{
				nextCinemaFind = Time.unscaledTime + 0.25f;
				FindCinemaCanvases();
			}
			if (Time.unscaledTime >= nextFlashFind)
			{
				nextFlashFind = Time.unscaledTime + 0.5f;
				try
				{
					FindCinemaFlashlights();
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[Cinematic] flashlight search failed: " + ex.Message));
				}
			}
			ApplyCinemaFlash();
			cinemaStale.Clear();
			foreach (KeyValuePair<int, CinemaEntry> cinemaEntry in cinemaEntries)
			{
				CinemaEntry value = cinemaEntry.Value;
				if ((Object)(object)value.canvas == (Object)null)
				{
					cinemaStale.Add(cinemaEntry.Key);
					continue;
				}
				if ((Object)(object)value.group != (Object)null && value.group.alpha != 0f)
				{
					value.group.alpha = 0f;
				}
				if (((Behaviour)value.canvas).enabled)
				{
					((Behaviour)value.canvas).enabled = false;
				}
			}
			foreach (int item in cinemaStale)
			{
				cinemaEntries.Remove(item);
			}
		}

		private void ResetHeart()
		{
			heartStage = 0;
			heartSpriteIdx = -1;
			heartDead = false;
			heartBreakT = 99f;
			heartDist = float.MaxValue;
			heartPrevFade = 0f;
			nextEnemyScan = 0f;
		}

		private void EnsureHeartUi()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)heartRt != (Object)null))
			{
				heartSprites = (Sprite[])(object)new Sprite[5]
				{
					LoadLayer("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"),
					LoadLayer("iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6CAYAAACI7Fo9AAAgAElEQVR4Ae2dCbQlR33e+y5vm037rhntYpNAIEAbQjagYyyzJI6xWW2SY2KzGDs5GE4WcOyEHDuxsYGcEGISMBiwDxgbCBghFkuDFgTaQBohaaTRNtJImkWa7S33vXvz/frefq/ffd1V1X377vV/p1/37a71q/pq/VdV6T0nXBIUIaWgFNT1t9hoBPwhFb0rl3TpHuhaatSDin4jmMDOamm+5R1uNL+2m4m+8X7F/Mpz0/cVt+NmIt94t2IjeuYeuRo9N99EJpphma8vBlPlquJaD80341QK5vSe54lSJZit18K4T+qZsMzpd7VU1tX8VtEz3zCHnebzYmgmss+7hcaSvpdD7KKwNc03/V/U9ygsdeExVaqG2NWVDotKD36TLvoZ/ub9THkimG8sEqnwexTWKiklT8r64zu/ST/++E06EgfiTzx4XtD7Jbm5ErZmWKOw41dNYQSrGWFGfDDP++Yz7yf0vWlmWs+kIN+isGIfO9OyT6rxTApGYSH+TYmnddMM76OwRc/c4yZX0pgvyMpXXMH+iivNX5GZ5vfoXWiw9a/pvykfrrgdhHEinXGXdCTuS2E48Bnc4VFZbwhbdsFlLx4Bj8CII+CJPuIJ7KPnEQABT3SfDzwCY4CAJ/oYJLKPokfAE93nAY/AGCDgiT4Gieyj6BHwRPd5wCMwBgh4oo9BIvsoegQ80X0e8AiMAQKe6GOQyD6KHgFPdJ8HPAJjgIAn+hgkso+iR8AT3ecBj8AYIOCJPgaJ7KPoEfBE93nAIzAGCEQLeUc9qiwYruia1jWv6xRdvDtK1z5dLPLl+5Sug7qO03Wkrnt17dfFt/W6dutiIXdNF++WdHnpHwJRGkwoCOTlY3Ud0kW6bNJ1rq6ndT2la4Mu0p5v7Wm/U+9I+7nW93yLvmV5UKW6sjB+UIOYO1wk/oyu9Vqsf7au52jDgpdpUf8Ltab/KP0+Wt8wQ6uGhOVKauHU9T66yCGHhdkBbYZwh+479O1BXV/StUuXJ75A6KJA7BN1vUHX6UqDM3R/gTb12KjEW6dnhDSMrvBF7B/pCMm5eK4pDfdqT4d92lTjNm3o8QP9vlsft+sbBcYsZnQNjCh8ucJSZSePERKIC4FP1a4qF4rYr9OuNi9VJqB2psTPg9Iq8sutaQoJ7QBymtxD9DP4iO5LSoQndL9O12/pOqDLS+cIbJQTn9T1cu2Ec4LukB3pNC1J16oS7xQV/KeoAjhvsRG8Ve8W5fDT2u3lZhH/a0rTW/TuUV17dfWN9Ozc1Ek9QkTlwFALCQ6RjxK5L9eWRb8rgj9Xvyd15ckMspZJIj/CTKMEeZPC8Ca5QI1BzfBrunboekaXFzsCR8jIGbr+VtfZIveqgtZuvSMTpOWEGHGc0vCXRPyr9HtBhN+mbas+qlp/q37T1aM70DPiFMHRKjuaDalAZEriy1Rr/6KuVwt5+tyDEqGyav1z5xqLtylMDQWKGv7zun5P14IuLysIkJZ/oestIjY1+KCkIeGYUsXxwqXG0qf1Y59q+m/p+keVPtfr205dXUvLIrlZZYO9IRKAZ1DlRBH7rbVG/e0q7U7Vb95zDaqUVAhtUnjfyaVA0gSkdvgFXYu6xlHoSl2t63KRmy7XoAtpeDStNV1vVJP+0YlS+TPaPPOvFXDGZxjELaSWZxNONuUsUgR2sQ4WGbiYWwRyg0i9WbXkr2gQ5neE6DF6NxSBj8UjepxQQfWK2Ya2gG2S/oe609ynLzjKQqH8RV0XDQm5k9KCPCfSN7ZofOuDeniXdu39uIj5ZZH/EX3rkPDdydLDUJ0z+PUClaIf1DbDPxC4/0kkZxqlO4gkJW1334n0jZfN1hcfljcQ/2u6aLWMihAX4lQjjsRVz8NQg7vgTy1/LHmSvEkeJa/KItO4AyU0nwZZNgu892jP798SoMyLFkbuslyqqKVFSVdRci3Si27JhH7zS35qf3HtR69fmOV3OM8WM9uyUsQNL6uK72t17dczpP99XR/TNYzyXgX6v7dq7hVwuxCTstKLdMSTKK0mY2lYi6VXVe+X9Jt0xGydRO1c5GpwlFqa79MA3r/Wnvef1D7s/0POUsMPhIjoxcTUJTYcPOAoFEAvnW8s/ZWa6mfp2dlikvtYninXg6Mr9eDEiaVgRi8myhx2sJJBMEPiR8Lv8NK/JUEESsxwVPS7pjvf5pVhyET3zleDfUvl8Dmy3+Ed5ydVU3xUdwapfqDr5bqGQa5TIF+msBOHrstpk4vBedO1kLBkLzwljUirMM1iIaAwiN6R1mH61UvBrF7uqlWCvUrD2TqHJOQWCH+ECP/7KkR+WYdY/IZculmXdRymyY0OfLYEeRBr9BmNpF+lptBnFHa00XJlGGrsYypLwRYR+wgRnFp6Uu+izJCECxkhSaRV1JTWnYyETLWyzSXV5sAryTSrjPOIMs39In+8Jgkt5PtXUn/+clnFeaZ2js7nTNdtMc98lMJamEek2VlTi8FBlRmP1pKz6jFK2zB9ojRq+e5Sp1DrByrwAfakal2tNwrxUvCMCP+w0nDPUiVvjV+igtKMy9U6RebtGlz7hrxA665vIvTaEOpRUBJ8rchrzV8u/aFGpv+VnvmdYMwcwPWquU+bXApOqC4F65SIkDKzI2YvUr/iD34+S5mTC3lc08APLVSDJxdp/Hcmss/0IUy6QVdE/s4c7cw2Ud6q61KFrWOYceB4pRu19EkTKwXGrsVyKtE3iuidCv5SMExzKZU2qIKg5XdYhfYTSreHFirBIdX0GQVn16vC+luNzv8fzW79gX6jirusoabBu4xO5jeeXEzmdy+vTZWtjeerufdZlYTPkyOZEMAwxD5D5NokolNzU6MPgpBhT5pYWCb5Q/OV4M75ibCfmDN8quEbl802aosa7f1TufGBnO50au1P1P9+nxzJzIC4x4yPnDdVC06baub/pGR7WkRPEmr8aWrlgoUw0ErYVBHpy4vB5onFYL+IvkOtNIifwUecqqjieofOUbtUTflfF7lv17sMThQTuUEgOiS/UiXfXyv2mUbTQRGCnwPBVbL3svbOCj9hRU5XhuZCnlQG/uHhSTUPo6/ha9d/ZfUF3y+bvy0Ll+m609Vih+bOk/3r5TeDo7mEwbOL1i2o9narjQ+qZk0Smu1TyWVAkvFc76gwqOmnwjGehWC/mvX35SA8FZgOqqQp/1aR/RoFpqdk7zfRURu9WKeQflkRRyPKWTYI+PNmauEA20RyPnB2q18Gyeiv3dTsut0yOxHsVBM/a+rL/Cbh9xM1DT+veLyty3H5nPx6i/zIjDgWTlGT/EKlWRYBj9lGMpsZUM0ckCyex8ziD7X80UqzF1UW1JQvBffMTWSp4Wl7HEde16mwV4nsN8lJ6yBdLAgdPYroWbNWR/4tW275+lLV5AxUZCI5jhxUU+pm1YZnKfOcqWs6OS8s+zfoDxAgIsE1B6bUP8wUoZKm5N4qpY3nK54v0rXcDywo3oyX3Co/cD+TrFOBfOXG+Ux22g3Pp1T8R8ntfggVy5Fq1l+oVsnTquG3t2p4x7BsJM+rZv9Fmb+hVwVVP2v0F6p0owkTLS90xGnFGE3e+9TffVA14dlqvm9RX4qmXK/AWwlJsU8RMRgEuku1huvovZqHz1ff/TA1hkL03YJC9Ur1xb8pt9BHdxL6zs/TlBeDop1KTVyO6zjE3aNW7adQwx+jGv5I1fD3Kw9Sw7tUmzJDK+wapRPKQ6yF6LpULtqwueueJHhwvCJKBNGa6ljqovZuDZI83JqCIfnJbIMyIJc3gtQajD88e3ox2KX4Me/rIBXVvG/TwgvVd41/Yi1DcwKJ4frmkwbxVOU3a0O+y7xGnaVfLRyb048oCdX5/YfSZfiU/HSqEJjGfLW6IoSZsBch6Czct5BMIBrupxdQmHQSTlIknMoV4Yk/syvkRweZEO5vZkReZln73lVxSsCCQyCSL/1YbhZC8njYqPnuVqkKzCdpeuR0NemPUHafGIFa/uc2NJu//3RwKpznjcc74bmkGYwPqSn/Bn27QFfWFVbU3rfLjeckuL3mFRk8Ct+ajx2+QHstXIqd4A7N5kER8twJIvsVSidaYY9rHt5BNsCF6XLlxTL7pIP53EZUo2+RZYLZ/UvTQhp9aPyDahYyHx4a5fnTC8EWkZUmEs00x5IydPOA+rgoWeyrV9Scb2rBRYouRk8H/CM1GN2UB8KBOzOEqgxZV/3vVGs/qmjd7lij/0u1tm6SXTZ5MApTY1epBj+zNYtgNJzzIyqq21Wjpwn9ZQbIBkFoDTG1y0zQBuU5WmEWIQE3KYov1P1z5XAlKa+Kv3radFfD8d8o4zEdRExShXL6wnXzwebJejiXeZwSktr5KN3pr83pch1vRekBwtPs3ajmJAkx7EJT8VyRXRkk1N6yxKesAvZ1asqroGxcix1D0/0PVIt/REasOfRczX1ftn6h692jJzQF+ViKVhzxZrqLgm+QhPRhDh5lnl0KO5gbRMVl4wylz361wBiJ74qUfueES7vicIKjkxrUoS9i7C4A0gWqyU9VzZXESUA7IJVI+uSommZpvqE19+J1NfUfB6MGSMAo86sFReXqg9NOc/HKSPdrwO7smfKECr4mOaZKVant1kTY0nZ9O8sWAObAf2HDXDDZg1bzM0rn6w9NGQcjaVVcqfB0ez7dhkvSd/LqoxpQvX0OXYkkE6veLSpdUPnO2s1a5UjaDyUXIej+pYyFQoeR5BD7ZWFNnkxyIoEZSsszVYq/bP188BKZZ07dRVBjvEPz1aMkEO41aj7PlOwYtIhMZ5+1/JHwPO9CcvzAr16QfE7RYfrUNuNAeUMLbxCFUG1WhUWedghhtcmR7nCxB+VymARbqElsiXGxiHtkhv4Wfe6TpWL6cg2AvHDGrRlJC+DxFJVKW/gG9TuZ6MpN88LCaTqLlhU618x63NZ6tk6d4TZ+OGTYjmFiteCPZt10CViBGC5O6djX7jlAniZv26TFkS02c3m+l959wsV57GWyM19fYr804yg7866d9rXoj994aDJUpjEFsJujxCZ/e/HtYTUVb5u18jZTUChEt/RoGosVZHco/I85jFpT6JytsQIWEA3DQCuKNYzIW+TgVLmSWYHM4mZnCxJsjre+v0t3+h6pwqgpyxE7FVaOMb2BNpZJWErK/OwoCoS8TLUHYx2dCm7gVq9ITpJABheSE7cjlG/QihwGkhNe8rjDDAFcgTOFSumdx19UqIPtjmnlDoMLqcUYfYerNs0WmlgPqlajVkgTBnBepQGcYVebTYsf7xmk+74G6fL2X1kV9vM9GnQjvNqZJfix+uSsDnMRNNIuVt+XqddhErol39w/oxkQo9SkSJOegY1Wkz92u4/+aXlrHIBjGq3oEtmW+EzNdTviyXD37i0DZq/YOGdt3SSFiBYRdnsx6Ib/+zW6/t0D084kP0O1+CVDSHLiSl4nz1sEzsCdwqSsdbJSd+zOpdr81xXS1DKXQRQG04oWBmhMwlQHI/BmUyYXhuMbyiSvVFcmy3QiZrHTqxWBKELdotaXa8vjjMlacL4WABVdOfQyRcnzlgHEEtwpkpfdrNjuEXhG92kadkNcMinLQpmnpck4ykI/m2nIY9XUtQlmMFtE/97mF99pxrJw54CjKutzNWB7/sxies3h4umAmHHI+3AHDhUiRiJ24oOmCs4x2Wfuu1t9ZEbV6YebhBp966HpYJtGQQ+oVnFQaDA5N9DfqP0uFYHRLEwTvmGmlzUlA6KuW2yhicesTGrzMC1iA/qevG/T/7BxKEvUukX0bQqEMU1e2eEaZVMk8XijRuBtArl3SGd8qxaKsMzQbsPm4uB+B5OXi8inqn/bLrzjmzHB2i0V9Ntl9oM95FD57Uf4CopmojMOHCDKcKlj0bhV8fBpJ9Bnm0LmqNhhcsL6jS2AUZ90IS/aV9TsLEK4aGa+Z4NQ1kh0wcDzVDOeIuWXmloxCLu0HGmZjuxCMEInqdVsNQ3rHJ6rMPeypdGt+Ca5CxdM04mq1Z/NOoVOpXMX1obg2rWvVr95sXbm6LYw/WJqqib5v1cac9/TlBSjwKMqkOtEYYNqJhfP3epCuWDIHH0a2jRtXzziBa8jF6ycsmFd1okSmoss7lJtziqZtLTTpgS19I+20Gb8fqE0uuivZxFWuW1VS8BLbxAIN6lQYdOeYUi3l6hC6NUUX29iu9YX4g0nDMK+/pd2ytHKSzecavAj86ff1pLI18pWe7otO3T5hu7X5pFnjL6frLXBrE3Psgcb2W5WhI/vLR656e/FI4C2GEclcVrJjLoSz1HGf4Gm0AZxRVrxsdemAYr/PdoSzSAl7SnwhL6zYUsuKXSZ6ly9tkd94tSTRGhOM33Ta2EahyWtbNbgOpVDGF9/xGyvgzq2/jHNyXiKy9ToKIL0A7Ui9xgWW6nO2jtdnoivOswEQ5F9dG3dHJ4kkhqAS+0aQal2O/nAQA5HM+H/JSpozpTSBWvT0+aLeX++BvO89A4BtBnHleSgbONGi1tGLVNTalW1Eb/pe5Zvf2Uy3O/NGiFveOSOCH6s+n/naOMFVGGZ3mHXGubd0ajr58CUCT//bbQRIH/CEdP6e3EVjr0lDxKl95xwSR57a+xonzHa5KmK+Gg1MfDixSPgEUhGgBNgmOY1yIK2iM41UlxU050tiIwh9CQ3JJ//5BEQAg4cgWPW7b6SwFSLofM/bfjIhoJqfCQL/WEvHgGPgB0BC1c4kecjeRhbRI3OgQGvMkWhHyPtpvD4bx6BQUXAxpUW19wW7cciWQTRcWMm5uaqR6p5P8C1ChL/wyOQigBcSW0aN23Btcy8rUrrJtVTxw/vlrnUsG3IqJnm6Kc35hEYWQTgjEHfA005OPcXWQAoozDfyaUzut5k8vD5fj7aBI//5hFYg4CNM3AuK2czNwHaQjWhpZ4nt71b9dO25naVYf/DI+ARcFinHnLOOMvVDmPHRNdxMqlndOF4apu+PST+t0fAIxAiAGdMxGxxLhPRpbaKhnFuOVc2U9Xy0DYb9dVHuZHzFj0CJgRgezo14S3cu93kRPxbVQvb47+zPl9hssChhr5GNyHkv3kEmgjAQvbP+6k2ynQZHhdv4Z470TvZvUJnRTH6lyqbq17lNRUc/2HsEdit1Wo7taryUV2st8gii0H93Tog86OudlKb3Q4O0BpgMXtqCDkM0YtHwCOwggCHR27T2nMIXs9I7hVXglLIPe0Xo3dOtakM5ibjSfJkOub5qkfYn2U/8VWW/Q+PwAgiAMlvVdOcI79zs24FF3GvAQcfWXmV/hRqodMnyHFdnu6slrFpIM6LR8Aj0ESAHYcfqlW1uUQhJA8dFWcvd+VttZF/MO44UyKuZyAutVFvsum/eQRGDwH2PdhFc73AqIm7Rg7GvarmHYyTcj3NhlQprtxK9cJ/8AgMDQLsSs+x3lkE06Z2sb6dpL3knJzMOxhnDfFGvzTVKQG8ofFAgIrP5QgKxrWer40x4c/dc1Xtc2jVi7GVByHAeYmuJkjjRaYkotluLQ1MDvhvHoERQsCl3n25Drc8KrYIzNb1tXEwDp+L/3Hz0bN64KHqayqXXY5Eihzzd4/AqCPgctIMe8bFxcIhmQ456LQ2PS/RNYgXGAcC1jucfRaPlH/2CIwqAtD3h4el8baax2ui+6QG6+Ji41CLg06tcidDcc9bz+jabkh4v/zKT68tQ+EfxhABSL2g64bDU6a15auQKbcNvdk41OKgE4edDK0KTfMHLQHjbpTTbc2QBDf8K4/AyCFwy+GJ4AnNlZu2bU6KNNs9T7W1gh04BAedWuV5V6/RbF/dzoiFviySE3AvHoFxQeCHhybD03jzxndCtTmLwOICh+CSQVWWsTK4uD9uL+k5b42OW6klCSWA53kS3P7dqCEwLw2Yu6S7zpHbncjJE4vBTFsrGA7hqkHJJpWD7WFxNthmcUvb71U/8zq6yhH/wyMwJAg83jaIljXYzJ2fq8NNkkbmHbhk5GIUlrxN982RA0l3Tsb0TfckZPy7UUOAE1+X8q9CC47Xab/nS0EmaadkOASXOMo7TdR0N3Ixspe36W4ciBuX424jEP19vBHgLPenlxzq3hZMEBjNt4t16GcSweNowqVDhra7zBq5GLlVLad3tSMza+7abvbINS9jL9yjHLPkHz0CQ4rAFdJo+/r+mcR5cqbINqv/vUHDZpz9ztz4hrbRdVO0bVzSXPqRLutV8tToDBkcbwqcbf7PZNd/8wgMIwKXqXbeWWvOhM+InafomO51GQidFmcbl1pcpG2/esi+zcE8RMeJ9E6DPtoC1xYG/9MjMPQIHF2tB1xFiwOXjFyMwmNrGUTm2u/GJTULhsGDdof8b4+ARyAdAQcuGbkYuZyH6MwC7IkcSLovGRsRSTb8O4+ARyAJARuXWly0TuLnIfqSAmQc6WtfhZMUAf/OI+ARsCPgwCW4CCeNkofoGmJoHG1yleZG/h2qTC77bx6B8UEADtma7i0uWnlsNZAMa2kh+X3zbV1jdbZF8yb7/ptHwCOgEW+1y+GSWcxcjOzmITr+Px45kHa3rb1Ns+ffewQ8Ak0EXDjU4qKtNMihLaMwlEqlh0yJwTpcrwJrQsh/8wjYEYBDcMkkNi5GdvPU6IvaZvbEyIGkO476PnoSMv6dR8AdAThkI2iLi9bTWmzuJIWqVC6V7k76EH9nKYjiRv2zR8AjkICAC4daXOxK052CxriNFPpBVp8TIuZfeQQ8AisIwCGbrl2Li9YyIdcyVQXgkZXgrH1yGURYa8u/8Qh4BNoRsHEJLmqKrd3amt/Mief5e9Yal9pe2L1us+B/egQ8AqsQcOGQ2PssFwZXNeO9ynHHH/eZzDH/5hJIkxv+m0dg3BGAQzZ9FPHXyMUIwzyDcdhdpyu1+zCnM6ZsTY4oAP7uEfAIJCMAh+CSQeAgXLRKXqI/KpdTie5rcyvu3oBHwAkBC5fgIFy0ipruuQQVWBTpE5fIobZX0zXpG/C5wPWWPAIgAIcsKrBL4q9RHT1CUhtP5KL6AdmaV2kzHTkUv9PkSK3u4wb9s0fAI5CKABwydYHhoPh7INWB2Ie8TfcwDDF31jyaArjGsH/hEfAIrEHAgUNWHkaO5iU6zQVj9yFvnyAKmL97BMYdAQcOwUGnpnteomOvZkqIefNoocmq/+YR8AgIAQcOwUEnDjsZSkBdi2ZKuxPeL786IKIbq/xlk/keuul2vhB5Wx6B4hAgf8Mhk4iDbOlmNtRyIO8usNrYtnRvPWg8N82jA4wHZpCwDaIeB3dGG6PdNaKtdPZrg/zD2rlmz2I5mBUAkyqijigvBZu0X/bJOu2C3148AqOEgIVDDXHwHsXX2LKO8MhL9AVp5DwUOZJ0n1UwIKtNs+ee+WrwmM6ugrxLTCfAdBdRobC31Wq5Q+ZPm1wMLtDRNl48AqOAANyBQyZpcdCpj56X6EtaFP8zU9uc86LSOLsgkt48OxXsUy3tTGxTjPXtoYVq8Jypms6Ythj0nz0CQ4AA3DGduUYUQg46bAyJ2bxED/3hX5rMtZrh8e8E/sH5SrBNx8wuFrz3O018h1HKeHD8s0dgYBGAK3DIIs7VWl6ii6aln5kCwe6V7EkdkY+A71AzfZuuTk6fTPJznQ6su3KjdAe8eARGBAG4Y9sBtsVBqGUVHSLjZC7JITafQA02sbCgxj6sPsZUS0eOgYXtqs2LJDnDfZeunw+O7cJROEkR9u88Ar1CAO5YWr2UBRtYouoiOk01t/xUNtmrKpHoeH9YTY+jdIYE/fAnFzXgZhlcyBKSC9ctBKfqIDsvHoFRRADuWCis+acADjqJSJptGizmKvruhxWYRH13zDEldvKE1PJlcG+G86Njfqx65FD4C2YWdFKlvfOyyqL/4REYIgQgONwxCdxz1XPHncTa2ORB7FtNE/YPaxfKo/QusbR4JjaqbjtDKuZuUBGhOUOaA+Y5TfI4Nc2P983zOET+eYQRoAUMdwzSgHv67jyf3AnR5zRhf7f6+C9IC9B+9cshOMoskeJLmlnenz9dC7ZoPpwBPEq1xNLD5ID/5hEYAQTgDNwxCdzT9zmTmfi3ToiuHndpR9yx9uc5mbj+8FRwsG6fL2ez+uPV545G6c3RbPfJ//YIjA4CaIbOW1TYW9yjPnQSY/vA4sKimg/Xy0yqZ3ygr+GqFOOgxG8Jkv/sERhuBJqcsWqI0nSHe9aDGyI0OiE6Ki/3y6FCJrAnVF7QN/fiERhnBFB9RWPUIvMt7jkTxuqiyUNN2D+lJsQTJjOu3xh4W+eJ7gqXNzeiCDCftGdJc9IGgXNwz2BkzaeOiC7XDutImBt0dy5Z1oRAL6ZE8LOmFoOJTkOT5Lh/5xEYIgTo5lpXrTU5p+k1d+mUWvOVUmmru3erTeL5yRqAu0TabUyf+QG41fj4X+OHwFyoOm5mQotzmbrMnYy6h6mgJsRP9JCqChtPqrJq7vO0wuxYKbxAcubIJ8xxilv3zx6BkUaAZnGoe2KOpSbeQs6ZTbV97ZToDMg9omufAnlcm9vLP4/XxhAvlcpqxZN6GRP/4BFoR4Bm+xNSFTcJXINzMkO54CydNt3lUemZSql8qx5SPaaUsq3EcQ6xN+gRGFEE4MhuNNjTpdHkWumZdCPJX4yuJltZ8/aw+gx/t+Zt7AUL6J+x7H8VM+4fPQJjiQAcsW020eJapoE4wCyC6IvqM9wot4zqeA9pHXottc4fy3T1kfYILCMAN+CIReZaXHNWlIncK4LoGi0vPawmxY8jR5Puu9V8txwYl2TNv/MIjAUCcAOOmASOwTWTmbRvZpfTbK19P1stlf6vXqfW2Syi36OIpBpY66Z/4xEYCwTgBNywbDTRaHFsNg8oRRGd7Z+vZUTQFAg2cKz5peQmiPy3MUQATsANk8AtOCYzzktT4+4VRXS5WdpdLZW/pofUSvtplVqsZEs1EMURtGwAABy3SURBVA+Zf/YIjAECcAFOwA2DqDaHW+ZDUwz2CxmMi9zX6Hv5i/phrLPvV8mVZROKyHF/9wiMIgJwAU5YpN7iVubR9shdYzESGXK8s1T+bjUvHjWZf0LzhLYpBJN9/80jMEoIwAU4YRI4BbdkJvcmiWYfTL4nfivtURPjs/qU2jpnF1iUAlzXqCd64196BEYAATgAFyw7I9NsF6fCc9Zyx7pgooer2f5eoTEq3O+sqfmeO8jeokdgNBCAA3DBIvNaIQqncjfbcb9oojOn/pD6EzfL7dRanVKMVTpePALjjAAccFB5vRlOdYpT4URXgA5UArNKLCXAjvAwh06D7+17BIYTAQbh4EBqbdiKVotLBzqNZTeIXpM+7tdVX+83Be5RNVl8rW5CyH8bZQTI+3DAJHAILslMrrnzuNvdILrcL+1R8/1qPaQWWDVFdKeOS/aDcvHk8M/jgAB5nrwPBwzCSjVxqLNBuMj9LhE9OKSRwk/IE+OY20MLFU21RUHxd4/AeCBAnifvW2SpxaFDFnNOn7tFdHbBuFOjhXeaQnFYGkFPWRbam+z7bx6BYUSAPE/eNwncgUMyY6wsTW7Ev5l9i5vM/rxvolT5M1kzasrtkFaQwznQ2X33NjwCA4gAeZ08b5F6izvGtSMWN1Z97ibR0d79jgYTbpePqQ10dHxZuePFIzAOCJDXbXrtcAbuCI9CanNw7TLDSk+on/E/5U8q0QnEvfMTwYKx3seUF4/AcCNAHievWwRNOHGmmPMSIr+6TPSA89m+rf7Gg5GHSXeObdrnV7UlQePfjQgC1HTkcdtxyHAFzsi4sXLMCku3ia7wlB6rBGX2lDMG/GdzE35VW9bU8+aHBgEUZMjjFmk0uVJ6zGIu8+ceED1YUp/jk5oxNB4hw06xnDllLA0yR89b8Aj0HwHyNHnbcuY5B5g8BVdkvLC+eRT7XhAd/ffHNYr4cXmaymM+/Ez9l8VUE1GQ/d0jMFwIkKfJ25as3YAjcKUbsesJ0RVwtoT+rK1W36vFLo9o6sECSDdw8G56BLqCAHmZPE3eNkmrNv+szHS0Si3ND7PvabZyvS/t02jiN2XVyOO7teXtPoFiNJTLf29pXBHoVyuRPExeJk9bhJF2caNU2Lx5u389JDq1evkLCsBCeyDiv9kJc5uaOX67qTgq/jkrAo9ru9LrDk0F3z84FW7VNN+H6VvyMHnZsrsrUVtocaMrtTke9JLoqMXerJLrWvlrrLBp5jzla3XSx0tGBJirvuHQZHDz4amwNmU6i9HuW2YnM7rUmXEyOHnY1mSXMWpz7aBcYg+Hwgfholj0kuj4+Ywi9d90NyrqA9I2JY5XogEyL64IkG84BGFPwvoJ9Mtvm7VOb7l6ZTVH3iUPG2u0pissAIMTmc9TswYiZqDXRGcE/vrJUuVjCoMRA7bAfVDrdf0y1lhq+UcjAhrQMh47zKBYL4Q8S94lD1ukARfghMVcx5+tIenYh7UOzKk/8mfSALpXn4xkv0+DGPvtYK31wb8ZWwRMa7zJbL2o1cmz5F2LNOAAXJA547mFFnecPveD6ATsgOYM36e7cecMdsfcPgJbTv1QfcafzloT3inBvCEzAsdPmLu5tl1dzK7bvzIA18yztC+MUmtxoONtooy+tD72i+gc4bRVpdlWhcNYqz+uJtCwasw9qcGYrz4zE+xS/9Bht0+X9PJmLAicWK2jYZYqNKu7VauTkcmr5FmLsHvMVjggc8bKzuKO8+d+EZ0A7p8olf+tEsW4txyzIsM43UZmulHTO5H0YXYn8nrs7jNlM9oPq6/+NMeNFCzRdJrZd82Wt/K+vDfm/SKD10+iq2Fe2q7my58rQsZaHaUDEmdY5tbvnKuG4Y0n1JEVYxTjRv1zhwhcut6oqhG6frO6U0UKeZM8Sl61CKquf07el7meZQprqCyB7vQzSjQf16DE/TaH0C46oDOke4aMLUAp37eJ5PdLSaJdTp7IfHZ9uxP+tyMC68uN4Liqua8+qwXU99sHzJx8JE+SNx004ALyOnleVrqmHJMU6H4TnTCpCV/5gO7GvgraRXfOTQ70dNsuleb3JZCcSB5dsTXoMOWlKAQuXmev1X8mohdRcdDvJ286aMAxAEde71mTPcJzEIguepS+5TIwt0cmOXmyiMSJACjqfkgl+o+kjZUkG9Rn3KBaxkvvECirI3ykpXCFmHerBdaJkKrkSfKmRaIBuG/JXM+bd9bQWQJf1OfDGph7lxw7aHPwHtWYTwvUQaJNTYG5TSqWaco9p08uqclmi5n/XjQCL1KtboOdFhinmdLHzpqnME9eJE86yMFWHu9pkz0K16AQHY25HdIS+mMFzNjGhUw3HZ6U1tFg9NcJzwOGEr1cagQnW+Z2o8Tw92IR2KhWlMvYyE2aHbmzpXLtSnbMkQfJi2kFfCw2dfI2eTz2rqePA0N0xZoVPP9b69Zv0LMR7wU1uW7SqGk/ViS1pw6DMCYtKEg+7Zvt7bD17PeLZmrBMZpbt8mDKqxvVNfLYRFK6BR5jzxIXrSImuylG8jbMmcfOLA4lvfzIBGdOOzWYMX7BR2DFUayswH+D5Uw/dwTnnXO2zWgYzrf+mSN/lqzQt7U8/asCNBlunjdfLDJ0l/HIbZ6ulX6D/stc+zkOfKe7RAGOUkxwGDz+/W8Gz/6JYNGdJrwP5osV94rQKzFMPtj0zemj9wPYQDuMYMW1JSa7cc4ZLB+hH2c/KyKbZc6kh3yblftnibReIxlb/bIep28TJ6OXvTrPnBEFxAa3ij/g5bu/Y2erRR+Uuqlj/XhsEYGb8gQptLoFM2dV3x13q+8vcrfKeX0S0T2dRatOSw9rvxEId4u9MXJa+Q5B2Gd+d+Ql2W256Ps7eEbRKITxv0C6b+oJHxEz1ay/0QDKb0+7WWvWhM7DSU/kThuou6JDhADItPK7Zevnw+m1dIyCV2xpFYieYy85iByofQIeVhmez5nnhS+QSU6Tfh7psuVy1Wu7lXAjSlTF6y3avQzqRROinSn7+ibP6yS3RQo5s6Pdqg9Og2Lt58NAcj+sg3zQdVAdtKVPBUX8hZ5rP193EzrGZt7m3m3dE/C9768GliiCw3hXdo5Va6+Wc/sSGPiVcDB8jdqFLQXZJ+VXzTvTHKa5s4nBhldU+BH/BsqspdJH76SQnYoHi8IyFPkLfKYRcijh5p5trRTz8Y8a3Gr0M+DnhXZZ+67Au43FGujiiyoHNJAys0qdQ9YRk07QZC++VMiuWmkHVCP96PtncDcdbtozZ03lZylKAAoDBDyEnmKvOUgNfIqeVZmzcr2Do4VacQp9EV6mMMt9YxKX5fCwR/JrmnsK3SazQDvlqZSUh8rh99rrBCAByyH2G9UJprxc+drsBu0F4yhJAltNepu8hB5yXZeWssNlGL+iLyq3wNFcsI3DEQnnDVW/Ghw46t6bha1vE0RmtUMmjhoLKW4kPx6QT43xwLMsJ0kJRmmdLwMNgJpg3IRS8lDti5aK4aMsH+VPKrfyc2EPkNhzrF9Dlyb9ygevEPL/JzW8T6qEfGfKqFoahchuMO2wewWYxPbYgqbff+9NwhQFieVxyx2Ie+QhxyEvd/YV+EdMjsQI+xJYR4mohP+PWoe/TP1gZwGOlBr5Oq0Zsc+c+Y7HBKe/t06NduTMlBSAvh3/UOAmruUklDkGwdRkVDaSZ6U2T0O5vtmZNiIDlDbpsqV1yt9OL7GWl/fpZL5KfXb85Ide+hAOxx5GyYiy1Gn7MEKzfp//UWAtM2bLxRyxuD3kRf1vK2/MbH7PoxEJ1a3anRTNXvADppGsvPxFo2a5lnt9ogG3b5xYCbYLV09F0GverPvn7tANRBm7ItYU4MJyQ+QB2Xi1lRTA/TBLQcPUIDVVIr+bpIe8XsUNKt6IXt9oxPv0l/nhA02dvz6/hktcHBagriMzjGVpQC1V7/2fBmSgX6YT1BzdQzwInlPOfGmKDc62uubsaEjegwpbRld/pIGQf6X3iXPk8QMswjBNDhHzc9WUNdqbTKb/GVp0ql0D9ecX6SNDtC88jIcCORMqjp5jrynWA7kCHsS+pWLNmxOej8s7xY14vkdzV3WloLGzyvQcC5VWIbItNfRCXt/o/10h2pwh2N0VrmPBhVaVmdP+Zp8FTBD8aOhbaCcdNej2HCE0h9oKu1DetG3teVRYLLccxZqWbzoulnm2D8q8L8on4z9dUJytwbnOFih3eBTah84KkYsRwjFmKs2zYUFx/JL/zA0CND6ytDNYq78i+Q1RXBoavIoMUaB6MRFRzyVP6Da/S49t3M4imt45yNH6rZv5ve0m4pj6AbNhgtmFoJXaHGEsQkRmvb/BhUB8kDDmFuWQ85c+V3kMb1hAHjoZFSILuDD+cw3injW3WnCKTP1xanZI7GrwTRNspnEKzfOBSxa8TK8CJD2nKTjwHNG2Peryf5G8tiwxnglpw9rDFbCrQQp3auBkj/VKysLGb0joR9o7e09IQLbhP3fXq2merTgwWbefx88BEhl0py0t47gNoO/RJ4ib+mnPZMMXpTDEA37YFw7rHU1sX6kRNlQDxoX66O1Zc1uIWzwR19t71Jyvc63KzbMBWdOWcuP9vD43wOEAC05dnt13J6ZkHN80sfUN2cDifkBikrmoIwa0QGAkfhrdT9dZD9fdyvZmXpjrXHa2donaMnpWZ7kYDu0gg4FGzrutOwjEIsgg2+fF9F/T+/mYu+H8nGUmu7xBJhTAr3XZevoyJJpR888WnWRu/7efwQoyL93cCp4KjYmYwlVuEUzeUjmhp7kxHVUiU7c9k2WqleqVL5Gzx31rebp/eOil6FDgOOR2X/dVJC3RYqa/Bryjt6znmIkZJSJTgLNqlR+vaZFPq3n3GRn2SL7xHkZLgTYn/3HWudAQe0o6pOXP02ekflZRztDYWzUiU4izFVLld9UAn5Kz7lH01z05IcixcckkJygk2ELKFDR6Hr5U+QVPY9Ecz2e1ONAdOKr5ljlnZoL/Y96Rqspc/3cwUon/PfSQwQOi+TXq0/uuM8beaFG3iCP6Dlz3uhh1HJ7NS5EByBq8z/W0sK36G7dVRYLkXBQYpZFLpE9f+89AqxZuF59csfmOqRm11byBAd85m7x9T6m2XwcJ6JHyHxpuly9Sr22XXrhVHqzX4xp19fIYX/vLwLU5BkG3ui57yIvKNSsRBtpGUeik6BblcAXa9Xbg3q2kp3anDXqrFX3MpgIkDbsve64+rBB2pMHFJutgxmjYkM1rkQHxYe1ecCvaOLsMT1byU4G+t7BaWnRFZsA3rXOESBNSBtXkpPmpL18frhz34fDhbEiupYYSnGAOXGmW8L7bdrz6y369YReWClMv+87B6YDx5M0hyMHDHkoSQvSxLVPTlo307x0WysPhHmCvDHKMtqxa0u5pUZdCxka4V+L15D7WjXhLlUGeFLPVrKjJnuDmogoYnjpLwKkAWmRprrcFjr65E+S1np/rS6ldTMvkCfIG6MsY0V0Q0Lu0MjrFcoIaEI5kX2rmor3axWUl/4gAPakQQaSa8fW6hUK7Y7+hLi/vo4V0dub7kAfa8bfq4zwa65kp/xnJdStGqTr1vFP/c0ag+k7WIM52DvWwdTkkFxpy1LTsMvWilzzme6cb7oPZnp3I1TKEOGBjq9RxrBuXhEF4BFtJHm74w6zkR1/z4cA2olgDeaOAsn3i+RK0/DgQ7kwnjJWNXpCHz3spcVa62SEG5UxLlcG2a1np4zxmJY+Xq8lkOM4/YaCypyq1m6rCIMtGIO1o0Dy3aQlabqSltEYDa6MTx/duWgEljGSn06XJ86abyzeVm80zlS8lWfMsk9LIL+jPuPLtY8cp7WMstB85lCL+7SDak0ErAidY7Wn/Rlas9+N3XdYJnydVFod++NAzx5vD0yVqi8UlYdyj7ei889Y1egZwTugjHKRMgzH7Tgxl4z4fU31bJurulnIGKBBMI7yEOeScSAGhRtz12yj/YBIj1baXvc139boADpYgmlGkm8j7WTdk7yFsie6ObvtUYa5WOuTvyxjTmRngOg+nal9hwaMut2cNQe9O18PqTBjl5Z24gEOpL9F8S5CwA4MwRJMHYW15F8mzWR+oA89dIxPYcY80e1QHtT65Ddr/vUKGXVe+faQaj12NRm1fvts2CdP78mwwcNdqoU7ETADOzB0FMqZGmlEWun5oKO9sTE2dERvDp+Qrj0VznfbOlOunqss7jTXTujI9N9Wv32fmrajIvTBbTWs45HDiZCAFZhl2RGGNCFt5CB669az+BI9zvmyT/kxc2hHJwdmjnouC1oIMXG2+u0/lW2n0oZVbwwk3XK4mCZtrlAXaAmiz1gGG9mRJ09fHYzAKsNKQQbdGDg9W1F8sMBojpxTnujZk3Sf+oAXqi94taw6kR0vHq1Vg3/cPx1ORWX3crBsvGCaHoxZslSrTM+BDRhlEPrjV5MWskMry4sBAU90AziGT4vqC16lxRHvlhlbS3bZGfaP/7bOW39c57wNsxylQyqP0xbYJnEdiAQLMAGbDFIHe9JAdrKUKRm8GC2jw53j+psWWtNc/kspZPxzBYONBJ1qdwz9SIofdw/5FNzGsrl8m7DwFhzAACycgJN5CUZnwRzsW79578WCgCe6BSDLZ2qTr82UJ7ZkGaQjt96raaNhnW9nR1xOuDGJKWMRf+IOBjw7CnW+Bt0mtsj813T5mtwROIyZ0iODM2NvdLcGhE5Rn/FbQsI5725XRv+BzgBzbeYOAspEbpfm0U2bPJCpJlIG7IgrcSbuGYT++LfAWHZQTfaSEQFP9IyAGYxzOswvaTdRjvBZ0OVEeEanr5bmFyqlwyDU5o9a9M0ntZlmUl1NHIlrhhF5MFwAU7DV88htw9yrNB+O3NUrNDr3h4z5Mc3pbtZqqZ16diI7WmY3qq/KkUFOFjoPZ24X2MkFlVeTbKzUg8lYH504ETfi2K5RZ3BHPpV2gqXMfEzXoENjiEr/P5lTrP/hG9YQsJPJGWpuuqvOKhvfoCbtoA/SwV/zMJx0T3UqLWqy6MXDTuJE3DJsmR2qsoKhrLPzj5cOERja01RV2meOOlpMpVLTZtP22v+Ro0nux01H5sjIcbP4ISUO3ta1mcGXtanB4lLQ+LnQmP7ZhKOb96rG5Cx2jmseNKGm3q7dXZYM+IPJ4xqso/a/X4tdMs6P19VU/5AOU/hdOROWKbjXxLSJRjvmzbfN//G0ML1PMhf3I27X5TnJPRd7vTLja/TuIq1TOct/oumgt8kb51Hip0QSdL3nbVVnd8Oe6vrRapq7CLrqe7KNPSyCFZjJffjspSAEPNELAtLgDAT/gpqhKHcwmOSUgdH1vkY634OoXPPcmZpqWKdoGGBZ9QnH5loYfUHPzoXiKlf8j1QEPNFToSn8wzWaAz5GzcMdctmJJeh836wBLA6PcLJQeJCTHdyoqbNzJhe14UQhoUJffQfYyLdrkn30bztFwBO9UwSz2T8s3ewXaJDuK7LmzJKH1QTeqsGsQVryes7UYnDhzELACHsHwqDbV8BEbhzuwB1v1YKAH4wTQEmDbEmDK0nmYGvcbGwwbhn6ppllcwvqg/693DpO+4m/SIacCts5rQNnJPtUDdJVmwFZdr8fDwwUbqg0gpOk875J910WTbmEMHJM8Sc1P/6b+rZqfjyOJ/bALz5Q1o45ZiJpt5v2Pslc3I/Inus9yT1Xu70w55TJehGQMfOjplHld2vg6VcVb2c9+Vlp13/74EywY96sftorLClv0JK7Y24yi5fwFH31XwUDPduXwmVx3ZtNRMATPRGWnrwkw39FA1CcEvOMnvltFeaifyJiXaemPFpq/RL8JgyEJcv8OHElzgp3pu5Lv+I5Kv56ovc/JW9Xxn+Omo3bFRRn6oa7zkqd9Jk+HA2Fn5x3RhgyCINu24mr7NyewZ43WgACmVKqAP+8E8kI7NKA1PNYuKHPkN2J8CikXHdoOlRgSXa2+Lcoy+Cn46GGBCCMD3EjjvrNufReeoyAJ3qPATd4V9PA1GvRCpMZ5pGdyE6z+a7W0VBOFgwBMH3CbY5Cwq8sTXVZWyROxE3Pvj9uArmL3zLt3dPFcHinmwgsaUT+w1Ol0t3z9cXP6NV6XYx5WYVjip7SwNil6+c15VUs5Q+oqY6u+pxaEBmEQBzSoNvbpQbs++MZgOuG0VKj0cwU7z3xsm64X7ibTF8heaYzOJKpXdc91H9vucgtzf12c6EV/ePIXQ7piwQ/Kk1d9+hVaAYT7WHGbvM9RlfcaL1/1kJj6Ws6KeaclkMrBlov2m4AE/p85lQteN70YszFNpOOP3GQrZsfWNkgIvTDYj1MIPXH71NN/jr9uCeOT4Qwhla/b35Z+54jjRurDkFsx7wZnmbKtWO8Nj3j5prP+AkPVMhaorb281r315oZhDfLMfvYrusHITw+DCsI3KM+7QWaa/5LvQrz4sqnxCcKgrDYvl/E/M6BqWB/BwN12MUN3MJz3NblUtg0CDNhl/l7sOil/wgs1+jxoAxy7d5JCTpkNbpYVdIUGqvYylepKf93SqMpXSaytTgZpmZYu58kBZuXrGMfDHf50eFJ6dhX4gSPLNv8nldT/V/UG/Vvao5c9puptbrmbr4joKvfU5Ikm/c1egR/vjuVeCLRcW5Qyd7MCuR2U55LBmSIiS5SBGfO15e+p2brllbskgCIEx1joZkJ6aRfIHXVkyfWqqtGFjD4mHZk5Vji2OYQ0eeWl4mgh2ZE2oe1M+sr5MMDIrq09zzRI9D6eY9a6qlEJ3CDSPYxJrpSpDRRayx9ZbFRZ1ulSCLCt5My+s49NMMiFFRon6t92VlCyn7qHMjARhFPaE48dnCC1S25uWxGU2ff0Kj6L+sVh6tqVN4THdD7LRHJCYeR6FFAB4nwY0501bZqygel/6CBug8qfWy6p1EhECVl1vsymVMssp/bf1Yr48Miuow0j2vyRE9Bq0ev4wSPvFwejIteJN2TLCaZ8+96hsCHpWH2EnVfHuuZj20e4Tdh0OsPt33yP/uIQBpXnYhOuNMc6GOcxt1rnTlW3aya9BMCYikBjE5rc5xMckOrziqfwG995ww6LwOCgImjzkQnLiaHBiSu4xYM1nO/R6S7WIxkYUxXBT/wCz/lka1Z39WweMdXI2DjplMffbWTzV/96rf7PnrYRw/XZ0czD2Ci56r671/SQB1bVk3oSqqNk5LS9g5Ca1lt+Zuqyd8gvxbj/kqhJ1QI8n30ouC2Jcfq7zaCR6ZzEz1yoNeE90RPJXo4UCdllePnG0vXi4BnKY06zX2sOLt/qlS5rNaoPwmZW4VKmPw8e6I3GzZR4Rfxott3V4JH4ehY1z3ysNeEjyLg72sQYB/0c9TEftVcffH/6RklmzwyLzdeo9H97+Sx7O10B4GIb1ld75jokYdRADzhI0T6foeg09JUe7206j6n5w2xEFENsUKOGr89DxyUnbfJzldj5v1jnxGI+JU3GO2JnNedZXtRgDzhlyHp9wOE3UQgNOf978Xwo8XunWqSs/nDlJre5+odp8HuVe39XzHnZXAQiPjUaYg67qObAtANsvs+urWPrk0hliC1NN8WA9XOOgiCyjskejhUroE16ciF618YxCtpAC9cgCqih+YiO2q6B7xTH139/3rg++ghPKv+dZIfVzmU8KMokuN0pum1hLD4V8OJQHMEqRn2+PNwxsaH2opAV4leZIlkjYk34BEYIQSK5k5XiT5CuPuoeASGGoGuE73okmmo0faB9wg4INANznSd6A7x8kY8Ah6BLiPQE6J3o4TqMi7eeY9AXxDoFlf+P2p0Uoj/qDHSAAAAAElFTkSuQmCC"),
					LoadLayer("iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6CAYAAACI7Fo9AAAgAElEQVR4Ae2dCbAkyVnf+3r3zOzco9lr9t6d1Z5aWRtcEgQmjAySsMytCxvZkh0BGDAYbIzDBEYEGMvGYAUYY2RJBkKIQyBjrBDHIoNZaaW9752ZnZ3d2bmvN/Ou7tf+/6q73vbrqTyquqq7ql99EzVdLyvPL79/Hl9mfll9z857K2lQrVKtLLdblcXVZqXVXg2inKzVKxPVeqVR5Wvn+6TeodV2pVKvVoP38L92RY6Bz0oQR1XfO/8q3S+dX/zhzi8xE+q19/Za3L3upNGJXWkHb/pbDn1ZwFvgHsTXTT9wU5gwL6ealyo7GrOVhdWVSk3lmdBDPnCfqjUqc7XJyvGV+cqkyr6lMR18O9m8GLjP1CaCb/xuqU9VjsnftMJs1vuJlYuVWblv0jvhtzZmKmeaCxX8khb8ainTM/J/RX1abs3K/OpSZbvysqjvK+L7Vrk39ctDGOJYUb2sKtylwE+rsntiU+VcazEoK/GQFvVE2jWlwfvZbrrUHc9Z+aec0/JzWuXcVJsK8kE85OO1vHXyuk3pEgdpzbeWgrR3TcxVLugdGdkj9/N6J4/44ffi6nJlZ2MuqJ/zzcVAnviG+5LCwHPqjnKu6oEvYV2EdU0dhfVFmYM6Wy9mne89dR/KUOiNNMK6ht81feDvXvfwPZRFwobyFealrbB18Yy/+RrmLfhT/4Vx8/eyyoO8EB91R50tr7YCr8SBjPCddJNQB3VJQpZhSg6UHCgMB0qgF6aqyoyWHEjOgRLoyXlXhiw5UBgOlEAvTFWVGS05kJwDJdCT864MWXKgMBwogV6YqiozWnIgOQdKoCfnXRmy5EBhOFACvTBVVWa05EByDpRAT867MmTJgcJwoAR6YaqqzGjJgeQcKIGenHdlyJIDheFACfTCVFWZ0ZIDyTlQAj0578qQJQcKw4ES6IWpqjKjJQeSc6AEenLelSFLDhSGA43C5HSwjHJcuK5nRs+Snmv10Mjt0HNKDwfo4cWUnnk9e/Rs0/OknnN6CLtJzzE9TT3LenDrHBjWS0kj4UBYB5NKnfqj3qg/6uUKPbfrOaOHeqP+qHvqr7/uD8uNul/QQ9hkh74VMK/U4ND9mBKVP6tnswxh3NaqtO/QYf6vkXGMu2SQYIsO/W/RIX+EI2QAlRu+63WNcF/Vh6DyZQxjSTy7eKG1/GSjWj2kbwf1fEzPET0l8MWEDAlgX63nPXquVx1cp9/bTzQvzsnIA0ClkqhDgGyqy9C9LUMQTRnMOC9jG+dl1OFRGdz4y3ql+rjq+GmFv6Dnkh4a9dxQUrw2sPIxRgS4d+q5ToC+X1ZJ3rHUbt0toG+SACAkYSXHLXI9QDmh2u1JNRqbV9rLr+tGwqefUsSrssRyWu9/o+fdehgJlDQ4B+iZP67nflnj2S5mA2IoaV12Qut/NfR1Nfq79LJrqdK6UU7fokhbsugyP1WtPyJrQX9Qr9Soz0N6TuoZGeixyrMYDEaUiwTUCM0+JQiblyBU+HY9OwXur5e5pO9fXm3eoLF4b2+dZV4DgaMhkYmjXSut5W+eby2flSPTAXr5b9PzvB4agZLcHKAub9LzST1XC9whsN0hB/dRVT02ZMppq563XFxdebMSb07WGgdkZusX1ZB/TkkAeOqSBn4olAZGG9h1KygxVNun4fjXCeDfJIB/rYbjzMMC4I26TPQ8Gk1cKztw9AhtDRGZ//2unvfrGathlMozKFGXv6bnnQL2jH5zUYfkQ631hHrTW/X8kupwXoD/cw3zP6Ne/8/0/UU9mdVlmthsYGCvQIQAbNFzlYbl3yujge9Sy7tLoMI9L8IRxc6qGqFZTZPezaOMNuXpIT1frYf3jUiMuD6v5z6Bm/e8E3W4WXqBb1b9fZN69xMyAvoJgfG/KeMv6zmvJ5VeHmOcPGlSo98yZZqRpxgXIN4iC5jXyTLmu+ZXl/+xAA7g8wxuY/ElDQ2NQO7Xs9IF/WPy/E49h4yBxuPDdSoGo5o7Xy0GuKO4zvC+qmnaHlnG/cHGau17N9Umf1WA/4SwdEgBBgJ8VngsQks6I+XXnZp3/wMB/F15Gp5HSUFcN0Avc8n36jkg0DOvf0DPO/Sg9R0H2qxC/IGeNx9fuUg3VcjG2VARVXU4Vwjw/7y+Wv2gAK8evvHfpRmn4WaqlhvKO9Cv19zoR2S7/L0MfcW1VISESLDnjsVt3rHbjZ35kOr6G3ecmvpvVX/hl7+DRwsz/KZM9BR1KYC+Ts85pc+Q/t/o+VDK6Qwruh9XQv+2OyyHnZkQEVfFueBX72Fdaai6VoetnsoK6xon/Mr0ehp1GQzrz7WWPlBfXX6PbN7/j6la/eeVxEE9uSABvYcLGWcpvLzBIxkaoDefbS5+VIq2q/Q+kKAQeLLWrmyurVa21VcrU3JoSDgmusLQiRwgd97IXwhlGoTVLrDhFCb2m/qKzxU5NPXt5ZW6LlLgcoUwFDEMRIB+Qpc3/Ixi+Xd6vqznvoFiHF5gdA/3Ku+vMTOFtImsLq5sUj1eNdFaqz/qpKE6aXXrBH81+QPA0OV12qkjPof1t6Q/TjXrlTOt8LKFIGiS/wD8nC61+ODkav1tV9Sn3qdIGKE59TAdbHQznSRlR5g89uizmv/8/TOthV/RGue08p9IYGi5twjYuxqruoFkVYLREQiAa44wmtEIWC9NSnwgGgpEaYsaj86bFloF+BMSmKMCP41AClTVLSZvUDwkynAe3UQeibnpZm5cSYtojPcK1LvEXxpqGzf7IUo9d2h93fV2bMjEoqruyaWJoDEPQ6TwW6WDOtVa+KNt9ZkPSLH2O4pzpEP5kSnjGB73Eet8eyUoP6dre75d1ZNoPjctgdjdaK313LTulyfVl3JKf5LOlNK/utaqXC0BhU43a5Xj6i3ODt5bcIUP811alYf10MP3S7GchkoUmR78HuVtYDYTwVaBmvrbrgY6S3pkYVLXRA2cZVsWq3RUur7qN3Td1lt1jdaPyvNRPR3B0AvXWA2L8tKjM+R54/nVxU8srbZuUOETcYBAV6j33i5hmRHg8kAILE+Ym+Pq6V/UwzA/IamHb967uDrf3FKf/hXF8U8TxjNosP+i+fcHug1y4rgYLe1To7i72zAm5opHDg4vNyqviPdhXXgEucwL+YsRnrFgVUuq37nUbr5pS236XQL3g/GiuCwLiRzyAHQ0l2+X5vI30GCqFInrmgo41p1rXaONqjvrrUDRlogzKQcKC7WnK9QXV2uVJxcbiQGvstY0F/wnEpz3Katfo+dLKWfZFB3TiL9U2ihHExGjrFunmkHvnSiCmIG+eGlS8/GwBmIG7vHOaPG6yaYupYw9n6/SgZ1pL/xvXYL5PRrKf1rRIq5Do1EDnS24b9F8/H+qR08sOP3cWlalvrDUqJys1yrXq2Ly0rv35vNsq6O863VL8g7ftPvui5vrkyxh/b0kccQI83tKi6W/2KghwE4NyW8SwIdBTJmeW2bunU5qV2iUePt0R/+wWYBHgXdEI4QYCjw6tK3I+vb6zNu1s+4vlLPhMEMJNTqLRukwI04snQpov/l0a+HTcUCOwPjW3TnNix9bnKjs1dAZpQ7KnbzQJfXoKVJVO7a+RVfrPqs49+tZmwemlAb6k6eUxs1x40Nn8YaZ4Z0FeVW97SEBMI2aRtaYdt0ytV7BiByhyKPRYrUFxSuA9yFkHZkX2N+m9vJPURoPg0bZo99/qrnwvzR7ZZ+zk+DH1eqdt0hwjoixgNiHmAsH/lUhNyo8w68h8daYPfRWFy2KIPJ3g4QIYT287K+9156Dm4+tzi/oHnF69s8YMxDvwzdpLv57yov3XmmAsE9TJ5RqwyJWOGjUFy18teUFns9Jv3OlOgT4vk3nFftXW/rD832L/LHkd1QjCHp4nwYGsCP7qqe3KE7OQmROowL63tOtS3/qC3IEB5BuU+tKhdwixp7T0PfllYYVML3cu6CG4VFpWndJ+OjdRzmcZ7zGRhwToYzdJKGbVTn3dMHy6MKEyupu3BTtxMnmpT/UXPDDiv+HTWl4uv+C4vpB+YXtTgIod82s7/2cgVLwwKrGQYEs7jCdQiEP16lRcoHalE3iICxr+7P6fUH58FlWRfbBwM7G7E2KAm18pjQKoO893Vz4slo1TilZCSYC7n0TzcqkmBhKG8DfrknHlvpKMGR6Sb0e83IXsWCDsu6UQM+wCw39sIZOvXkjpxacB17Z1NNLIYA8AV+VcvOHdKaanp2hfNwTVoyynlIc1/fmwfQ+KoAD7MNq7Bmuu/jZm3fq/E2zS2vy1Pst6TvVxdLgnZrHv6g8nVEP78oTGAAL2xsz9yp4pmBXF0EWh/Mst1crmud9ShtidncT1U80kSOGrzd1h9v9gOT7hABPi3ynehGUbjQGPkSL+7SGeQfU+jLU8wvlE7OfHxoqGyHAKOuiCMC/aXbZqwfSMdnrj6/MX1Q83xcVl8Ht+whDWMP3NWd6MvISNkJrH4bwAo8Y0cUBOeOhu6QvuD9lkIfFRUaZGiKzyG50DYa+g18Ox+wGE2AjSxzW757duy7lLP/Q7OdfazPMe7olMiZFhdwsBchO9eb9AO8PBDPZfLNJcyV2wU1J+FhK8VlOQSF2XL076c3R5HnUTH/6Sf4mmZMaWdjyeFZ522MoPzxhqIhgnHcP52tad/9GKeo2Sag+y4r+XH1SWuOOwlfumhLQcNTUcNZ//kxr8acUMSyxEhuC0EK76scaScKPNJNMYw6qJ+9M5twRvU75vUON5OQQ6hieMO3iOdNyjjYA+9U6Lr6qOnjAXZJkPqrv3cmy6FBoip5ClWS1dAGTblCLyFJM0jqhx2YnGnvQfXc/kd61mqvRUAyD0NSiHbYR8/Tbp5vW3puyPqT5O/vxXSSDCS/LUMfVuyc2ScexGHi/oj6tdeF5QH6ke67AGg1r4PcJMK5RiTWSAT+iYH1Wy6fUsYvIL8NpQDdsIkUadEaOLv2Baq+leplTkLjTLK9iqfjD+adDDs+5QI6ovl49OcNxt9iay4cQAtw7p5eDpZFNmju5iAp5QoCZd/eQrqi8vqMQdPWG5OWQ9A82oqwMn30aqC6Q0ZYxdQqJ9xUfkJMGaY0S5GR6UYLkMZIJGkhAPirFKzKMLCPTLnkGGx2MZINHd5MIZwenGyVIV9uigRG3qVLmPEBpi6f3G0DaoeHvfs2XbhWzXXP4JfUUT2i32rDAfpWUjC46oQaIbZs2gnf3CoCU1UUSqIaWy16VPyydPs07bq5wxE0aLoF1xTPod0Yu8MPVQ1L3d3R78lHnGZlGtl356GLkxkF5FBW++l077o5yT9VN2ttL2uBv1bLv03CdNcwsiSEfPSTLMTZiuPd6DZkZOmdNPtszQ6WXT14o2wENawXeVAjhRLE0zDVxW8aXpDx9VIpU2xIWeUaemJe7wGVLK+1vNFAvOqZrMj29oKXR1HaJhmUYRo/+o93jpmGal/1uVovHUDZrAjAI7c16bESv8bR6dt/5vS0u17f9Hi09+WHTjw8ByLSUZPSKxJUXkNN4sdHIdSCIoTqK3DyBnLpDxpF1G3Wxwkm3VKn6rdvvSDXC/shk+pjz/cahIS3N39Jyh2u+2h/voH8zJ39OPZ+NhrU+zL581ygD4b0nxlZSNPqsufvsL4jiAdMcls1YwswLMVx/SUtqtqkM4ObgCYeH8gZ0+EgZvnBpKjhrbOKr8t3cVJ/03oloiqfXPese/ZMql7Uruklz52GDHAagrHPNaVl+Y0dd1sTOLBeg2ElnG67255H47hZQWdeNS4QhrCtPceMd1D9bplyadqZd7E/PI8gpP7KOzNuoixns2qdGDVlVTS2y/oikXHin3Iw8R5BcYOuPM82/2VZ7uhnai4mO+ZyGiputTVV0uDiuTCnohZ6TpRMTJemf0I7frZWHJzSn9VUwopd4vYbro2h8TWUP3ZeFAB4bcRYi4+qyJe/1DZmfUEEs+yiqGgm/U8uhXvH5eMqyu3pRdWKNfxQ7qnqZQuvP6SoT8QXlzzDoCm34saakzNj2x5vyCGBRLHLM0kX4wW8eQU7eaexc83NARL3mnVyyrxKAnRfTKocViIMkoi2U19jCM+d0LXfZwqfxDWC5NOsI/TDEhrkb+TGSPiYdeyH4KP1siiC+4acIIDHxiLrCAKiVj6bAQ3ZH9l3r+y4MxclyVkA/qEwY+c2HOIqlOAWK69fF7DlLjx83LZt/1gFcDUrHGKUtFvM3eM66Mhs4+gk3vhkrrD/AiP5e0OjKxiM29AzCo2EXCww4eM5nsDQwNdjjnDbpBpJ9tjhRluSFQrPAUfmBy8MadbgFtG2fB0UVIMKNbb4Mb0PFHvP4YTVmEdmJ5WSHeaUyo7IUjcDCKZ10M5F69X2678302dvdvr7kHc06j19c91ffH4CHAyt5IMTCtvzEIRd6CfKcNTl3eikDaYgxDdek9AFFJAw82AiT0EWbeoCF080pV92CqTfayu761uD0Upqk/br3KD4jNtj9ZvyYZkY84iIfNqADckwG5YHQv+YkKyNjB40UPDDBHS120XhEfsEEB7AMhF3/e7Y1rBtLDUFfczaPGV7zE+fth1UJxjgp1LVaRsoL0Yuym8dEaKGHdYDDZeIq6K2MIm4qwXi5o2yz1Qcbfy3VmVtmgAlbA9XF1EDWghpprtWdbF78SXHTmGeb1ncUtYB+1rKWWZke0rA9LDtCbBphcJVUSZ2plKnOFtSjF5XAxnnz5izZhl/8yZ2NuV9IWj5j75sgwkazc5NIZFCqYH9O5uZhBtl8YRIa/CTZVRbGneT3Pp0OiyIaAMwU5XV9OyrPWbntmTA3eKyxFxXqYMOW9y62Es+zG1gXSYk+ZYuH3V95E1TbNUnklR592ETj0mvJlN2Dt2kTS1E041nzy7UKQo3ZAJN1/pLGj7yBkXA1JCoeYRWMYVc/NjVkwiZ2oKgAMuz/VrkbeZz1EdSoPNncEAibVVUOtAzD7FB/Hu/SevbzOuTCand4YUC/n438NwpSE9HXGwXQFChH7mCEa6MMxLbYt+6awAhNfEpr6H6b2G/OofLVsXEWP4NZhcC2OjdpmijYM20RKlO4Qd1p1W8V2EuQR3PSprS0KVajY8uXKxixNVRdjN2WJNe1mqIe9LnYWvllJW7Mo20/eZJMpxGG+bmtR3dtjU0jD2Uc8TnABifTWjnKVdde+PgpDjeEAytVsJYMr4OXo651vq+yRcNpqDwRy2qc/9ZPJNFiORgeGa50zJ4DzGVNPYptl2P2OUsnBRdWulgzLrqbcpHG0F364PakKQEqxaVAMYXNyh1N+0nLtkOGh/0XKGSVlzLe+BwwnU+g4TY13vFTGU2IcFOQKfUu1mIDvaG9tKY4fd0xe2NqZJ0ndHwTSdMfU3MMQZpoC0tZhRcZU+mK725TkhYd6NQODZnFjFlVmAVzPx2nJhu6tieO/8v8yj74d1zm2OOAQYU8EXM4LKvaaHdwptnmo/w2Sg7MakXklGEDJgo59wGhUebenTaYeVLGQky0uLryHbLHHwvogw7dJ3Xn8x5ThnA3DbNsYbL8hiC8ahm2szllouzNs6yCgeO2XcZQdGUczHFhpos543Q5isG6qnAgAujbTDHQipgHyKZQ2bmjhDutbYY2YeCEVF4OsmTHiWLHbOudBpTnXDAGzFBG0+ovmFM5Abr3bjcNUgdize0KbRwHswxiO4QwbK6ihHvVMWzvbDUdiCfDLtaGS892pBdz0FuMElkMVoEZsGO6ZgvMCbe3qzQP+pZI+9NN7YZXFH/b5oshSF56dKB7QUKwbLEBR143u2y32QpcfhsKB2xLn7YtpEPJXAqJIIdg54LhRl2SEG7Bnj/QB1HG6W7nD5KoiXap3ckLscZ6TsN2W19dzs/zUlv2fNjAnC/Vr70ctq9gx2Zq/GJr+YO6V/1nbHH0frNNd3r9Rb0zGkARZ+y0bUqTqAizdvM1eZx1Psr4B+OATWiTWModLDfZhHZgp9rFXsM3dS1UaC6Q7LlG4YxrAKCfgyF5oc6OKlt/3jmy+qwOFQzLxHNeeFO0fHAewES2/RGmMHl0BzvGHlQZBnt6wKAXfmstzdETPl9vY1CelHBhPqdsXUHX07yG90/qIoUzjmF+GGf5O3wO2CAwTo20C0PC7df7Yjfoc+l3Ezzcq22k4JSRrUkyhszuwzW6ptgnS5wHf0YbFrjjy2TxJbtcljE7OWDu0CvUsOWzM+q8eMAwKRiykTC72xe3iXfGLaw2r7RlIo8rHMx7NjmUHGGZYDFng09p0nejrH8Q1qeRCMOXv9lxwHYtE0pXlqVsw/vscpZuzC4M6ebVK2c8jbt6DGYjM++UedfunshYh+B4jc782owX9GeBddnHFycrx8vevZ81I/vbfmq7+AdbQsZ6YsiJReJLCnTZWmvdG2Yo6pfUvXIQFThDNyy73qZjsz53kYXZYIPGAfXuT2s4j/kp24aNMEz5OxoOMBIbB827D35cGOytgaRAF1zauxSREcuerVFvXob2zjD85qmmrq9txroamN4dsB/WHd22tdyhFWSDJuSahR917H4sCtscGKp2Mega4QfFDab7tIIxnwlp+7bbGBZneGyLJ6tvGF3kjnTuHHudhvMsv/kQfDqqYfxjAjwbcErA+3AtXT8OAOjmk6T9V7r5HDQ2F4bAoORxwge7STnCHnnj1RFgBiDlncgnms190sa/Xgo3hvOeeA8stXKU8MXlevCe/9LmvTb888d5dFs90fiOQ32AIVs5uxj02jSTFOh1afyMm2WosiKdCaY3Rxt/i4bytwjwHGyxMbhXJDFJ9agA/5Lm8OXcvZcz2byz3PnUIneymIlv6FKKTi4MdTHoNXTXMVUby4ysep2+GBOoqiUqIpvZoLBdHNmigy3zmo+f0BDwdKvuBDDHXrk766SE6wYZDYgzMjByuPxwGQcA+aMLE9ZLN8JA4zClAkNgCYvFBpKktsHiWcP3NWevbn/Nd8+Lmgdj6kEGe/wW7RXAbxULt2g70ZUytfWKlG+cY3f12OzKQlm3Q3P/63Q9cRGmL0WoG7qikxo5vSB79z7dEptNxmEdHYCBJTbFRJENg/3+G+r++918/r7B5qnTAiSK1xbt0L8xpJ8T6G+cXKlcp3btgATNtTWWUiOUmJLGNnveDGMOnYkDJgg/udACnvoSFoJmVW/FJ/scnfIJv2DxaVdZkxqe2GeLuC6A0KqOCwF4DriyHLck+WHHnO06J8q9oN4dZd09M95GQMaFXamVg+H3QSk744CcHnCXRlQ2A5KpZTDjiDojE/uNv1LIWbEYZhG+JKEpW6BxHbIyHGQNng033Kbi2osM2F2GKG183Mjf0HswH48DcvoWLPju1bku0yUPeeYpDRvnLJgCUn4G2x5YsmIxLG+ia5OX2k2jnTgiTtp6hJkqwi/XGF8hsNPjoHk3EfNKepiS/DmA0u1hgdxm268/NmSOu8uu0lKp756I/jhG8TfHap/RKsJiAGyGwp3RI53IDsmYSy8kZdy2qapb1eb2cXnpq5oXWC2/bhTjivQaN2o4zwYOhvNqgC8j3JjXl/ebX8aaSAfuCH9ajWMckMP//Wp0XRtMIhMckSPle1IAv8wYigSGxd15mZHiyLSLAix2bouOEr+14EmATmBGSUaKFnmj98J/oCehcTsoAY3SkNruYC984VMsACB/SrYAXL1YmCRTqXtnVnyGt2GQXPyi33kGWRHYUyCvSBIBXU2HdbOM36nvFIqYoyh2a3jO/P3AUl23bLxmm46lujxZ2skRy9ZlBftoKC+t3VJPiH3ar5C3q7h7shf5StnQOfguE0ZG0ufowmLoPQnQ67rN8WQYQdSvb4scFbbIbtzAesf0auWcgM4++BD8RS7TMPLOYSGs+viAnF78bvXiRRqmw0PKxogFnY5POX353sUiSiKrXcwkQG8po1ZN3zhsVvBldL8/FEHMx8s5eT9nov9G+H17cnjKaofXWDU6uZG5Mn3jXEQc3YNPZrtYdGp7kwBdA9T2DlsmgkMFysE4raXbylt+S8YBzHWx49BFAPtmnUHYoV0fRSR6cOblTOnSpi4WidgK9iRAJ6/WXSAUrAQ5bCopigMsnz2i5TOf/eiMkO7VpqMi7zBE/0BvDi5cxGj4ail3uda7V9djCWfFYhguCdCrmhe8EkZg+mWxvwS7iTsb1x2hf8JT6YYi804N1YsIckB9TAedDuvxHa5zavJWjVzAzR6NXtBdPCftPA2jibpYNHvoBkwCdB0YqB40JYw7LXUJchuHNuY3Dvywp8CH5jRBvGN6uTCbXzB2gRIWBRZlBNyA3ZcwgnKjVhLCzT707Fz4yVFVmzFMFxbD9JMAvamZktUCLEUse/SQxeUvQv8lz6E63LpGAs/wNe/EdlVWC7jPLw6o+8vFyOValTcEee/3TszmDruLRavGnfiSAL1ar1Sf6M1M+V5ywMSBOPNxdrgV4RAQoA42vXhOQUy8Cd1RMnrsaQ+9r/vtYpGWwNrWJAE6nfWmdan1/eFvn6UvYPnn2HHgsJRQLqUbPdmbZpcKs2zGYSV2QVqR5VmT9OZcqBjVmxOFC0tdLDqz0mgB25gkBcAhW5D4MdpiK78VmQO2OTnd0Btmi6dR5whsGne8oa1A6YYZMxO5sAQWfTAsFYA5EVPicn+95Vv5qeTAGgcYjvff842i6U0CeFGJXngQooHjQFTntJ3rOgp7SsIvWHzA7ktzdI3xXX6ivlstWhBjxzbGYAyJSrh0KxYHbtXpvoM62celCnvUrRR100s/17ELyDZnHwIPNA4cfGKbNI3fVR7KRjDkQqfwa8VimD+ZQkxEs8pAoFiPCs1yQMJ4o6Ir3QrMAZRMWNYdN8JMGPsB2BfQK+sAkzIDZNbFATduaM9Zcubdl4jXtrSmuMDgrE98jVqyBe/Dipwxf2STRgZ7C++TkdJPyYGicYDRCtaCUTYyHWHtP34ldkoAACAASURBVM3NPR44WhV+waKTkmjdiXRJrYnxkBpDDjYOuOxSO3NXeig5kGMOMBzHWnBWBIY6U+DoFMCgvixFf13vqpFFnMHEWuBz1Wp1RQOHyTWXnhfGE9kVvyeh8rXkwBhzAAzZFsXAoPB7zocFkUNvj4C0JFZ1vfWjRwKll5IDG50DHhhy4jDkYVKgL6IICCOJ+jWbS4zyXbqVHCg50M8BF4a6GFzsDxf1d1KgKw9V4/5aWoAs7aRh0J/LFEoqOTDOHABD1t60g0FXexCwKClaajo1c1Zro8arkxeUSfbJJtIARNQemk3OMPce2Tur00JvKC9IiOBW6VR0DgBwMGQjraFz55pXZ+3lKSKx5YlK/QW5GxucS1p2SIvYmPDQpcl1ICduDN2XVHJgXDngwFB7ohpg0GuLYbCXHrjEfBbVox+2MZie16YxtIXt/cYBgqcxAdzr2PN+akwuve8pUvlaciDATu/oNYolYFC4RV/mxG/SHr1Vr9aejEo8dFsJ+nqykJwYrjMfNy7YK2rX6Z7kqZchSw6MkgNV6bns6Xcx6HVwPynQyYFVCRD06PZ8Wr8Cbu4nv+wmi55QZH5amxZKKjkwbhxAql09urxYMdjLk6RAb+t4nNX4BIcYTMPt3gyY3inkK7K3ZSMOB/BsVNq4JR//Ggc7YMhGXQw6fHViaDTbieG4WQNzOt5INGI+iDO7SSxnEPZV3WjhatH26uDAoEcGbYzM67dDOg12rHux4/0y2FDS+HEA7IADE4E9fdvsi9+kh1pI/yElxnbcSKDjYVFZ2ZRgzICt71cdvTkNyGYd+dtIhPkiDCz2NuFcfsBJqpLGiwNgx0ZgTwdaHrL56f2WdK87cZxXQou6zTF6v7s8LGidu92jLgsFlHaK9/AXpRuG9l4WuLGkaVO+KVhAO2WZI82TQmG8ef1lqaUf5OQVvpU0XhwAGx3smMsF9rTP/bzZx/ovSTfMEMtyo1o/2mw3N+s9UtqwS40gsg6OoLKWhyYRUzx842F4EjYA67Nm/ot4tlvsbJlDFvMLPHxscTKST1ssZoiKWdoy121hAmxYqA329N1rDZ14BgH6QqNae05x3EJEUXRemX10YXIgpVxUvDPV1eDm0qhv4+bGaCfYRxDRGiIKuzSyKWm8OMB6mWOzjHRTAfYWfEuOAYyk1K5XagdsgW3KBFs42zfyu2diNTjob/M3Lt+OaDrDpqEo2iaQbzQ9RRQfxs0NxZfrKkmwJ6mIaP6juZFAVbYW0cpEtfZAnMTWQg7wsllDVW7VjBb9ASLOYVAUkkcNSklWG67vudkjh9kvs5SAAyCX3ty2qxTMgT159dbCDgL0thQCz0ohYDzFlqCc1iCzWjPnRouNoISjF39xJXpmRSMHyDcCH6wCMYYfATibxGxdNZgDeyq+zds67iQ1DhlEogRf1Vzh1HK7tXddrCn+gVAj0FdPtiq7ZUV0IxDz8qfY32+oxj1q7Fh1KGn8OIDpKHRbNgJzYM8gHpFBo7uMSK+RjvNTtfoXllutt+mrPXeRwS93JBLWyKfUe9+gXostrmjZNwpReQd1u4npZB47AfdNDG0QtVHYnptyUv8mnUw3k20wp/f5OJkeRBlHOos6KsdcAaB7E7jF+CyAvkKbXrg1clIPVjRpeTBuvxGJUrOX4GR311s/D5hnYTp5IzV8/TwY978x77yqEZ2NwJx8eFmWCeMZtEfXtrjql5WocStsmFD4i1ncu7STix7bXpwwxMb5PSWAv6TtrVEEr24V39BTlDSeHKBmL7JhzFI8sAbmLF4iPw2ijCPCtixRHtRxuQuRsUc4sl8WM9AlyF9jTtiTc+m9ibhKmAsBShpfDqCIY5uzjcAamJMfxMabgv6BEEkfKQXOTFXrnGTzSrgegNzLq3chiu7xtI7jHjb05JSNa3z2lsq3TKr5JelDsHlw3DBdyiRRQ6TYiDvXsnaBbbAG5uLiddA5OlmWQq7xOxdXV77SkP91zuXQcx07KufVgj8nDbuJWC+/dbq5YfUWJr4M6s4RaBrXsMs5Kf0mDeoo5fOSgO4yqgrW1BTEUsTBK/s4wY+bTQ0nHtDZWOe+287NFuXwM2QrZwA4fRYKW+ge/tK27xfIy/XykCOD/8JrhsfoQnr5zjvnCUZFLKkeN2yOCvMExsCa/o697DLw0B0GKQMH1NJYDVGQ2c1KjcMoya57I4bxoRMaKj5lATklvUF3e9HLlJQeB9Bon9RUKYqraJQdS1vpZaQvJrTt5xzr52AMrIG5uE+wUkPPMeBzaabW+PVu+n1FeO1PrppF605aG5mYk7+geSGVZSK2+u4ssPLNNQQ1lTtrd5ZuL0mzbaIjht2IJv9puCMHF5Qnx9mQNhgTdi4lwaq5xPFKoCOrtc/KKqV17kBL6ihMvFQL6Ju9689oTm4DOVMcNgsVcT8BG33+5tJUMCXJY/UAEhvvz9uVYZkUCUwcX7FDEWyBMWXAOUWOymQqQ3cYJ03gsdnaxJ/o1chH1ggZGhk9ROVwTNwoM4dUMANlI6qbefkolUK2/Lm+PdndujuqIbArf3xnZGmipiTZtPXYFGYQd+QCXoENC7XBFhjDf5InraE7w/H5qWrj4/olH5HEh6Oam7p2/kQGLrAj5cY6zEEHyCnidQWel5+Rkiu0eGMUghzU4w4L0AH5MM9GggUwYeMXmOpia54RSZLH2ozErBNsWD2q4cVxW7izGhq57FXbwhftG9rUR2R8w7URgnLt0aGdIs/L2b7bS8PsGXvTdb2j/7DRMOWTtMCEjcAU2JKfxKe6Uhu60yJpaHFirjb5m3o1NlC0YOc1TMmrENgYHucbyigugvyirpLyGcbOSbvOCT2UlUUkLPbOq0cvCqEHMdFLQ1LIgYEOFqxAb4MpsEWOkz5p18y8Ntz/tiI1Hogno53lDWvhTHWQe3cUKwzRv6wLITHJTHldxOGeWzRkL/J6OUP2/rLmVfNOfWwJurjommFVZBjEFAEs9POtN22wBKbkZlV094aJek+9RBpiHJiuTTymxIz5ZzfYMIdHUQXPwo0W+lVV3PEYqwto1m8WyKctgpdFXtOOk80//ZTnU3ZX6ky/iRDcCxHlMflP6g4GwIKF2mAJTFn8eH1KUxkXKgnOaWH/U7bUYSQXNIzb8H1RvTl7pn2VjVTxnTqRZtMC2/iYl2/UJ41bP2H7LK/kuuHnacsBozTK1OkU3CM+sKSx7znGv4M8l9fO4KVYlj2rT2nd75ItKoYsrptYbOHz+I3hq8lgRH9+qbTbBHKXwPWHy+PfDNFZluqny136fYzubwbMtvyhRDXZ60sj18g+GLARGAJL8pNo7bw37lSVcTTgPFIcHJ+pTTzQ/bM3vbV3GHlKw5Zx69V9OjEE7FptiMEmu03Y1piV8xdskPfXI+XK89CdvLm07y/1rSKkVQ3wCtkHAxbSTriJB8BSiKtBfrMYuiO8F6arjf+sX+s6BsNcl1lbCyNy98lnnk3VcracOaK1mnNXOnOGTDbI3QNTc5zD+MLuQxuhWPVZFrXFEfUNmXcdiwU7XQxdQE4Gfexjh6hc+rlxf/qXNL943uadYW6UEscWpsjfWNK5e2a5cpVFEVTE8kVdbc3BpbyPV5g22ZbZqAvOJKRNyLxrigd2wJDSNmsNY2QsK6DTAp2cq018OKhvQ4YYihzTHt9xmauzXYSW10RchjgOc/Le8lGHS1HjNn0owp4AV6OLbPZPS3rLH/ed+JB5+GYiMNPFzkmTn7jumQFdGWlpR89n1DI9q3djudjjO4qDBHEZ5eMf6zkmgtFZMtuUbtbuDG+54vcykpPtEoLL/I/IgSmUq14eMdx7lyTLyLprXzuYATuKP5XenHy6ypikLGthpEh4WZvxP0Kdrzn2vfDhFe1EyvPmir4sG/+0tdNVDduxlTduRP1FDdHZPmPXa+eHE7sc9wWwmuI6jORTGmQcWTeCQZGAlQ5mqi/7xOnrJ1OgKxO69bH2h9rZw82PRkKZM6/HxgBj4Jx9MB0tZVhvawhyVgzv7DCsNfXcJl54Rz4kjxj4cLXBx6SB50kqo4RDxk2Ky7CoYAXM6O+kSYVRrfvNGugS7uphHZi3ZpwSHZGRPt+NJutKkKM/UEClr7rJUQEjssKcM1WJjEhjGE7c52cjysjWZrbHJpmzI9vIuINXGJf4QzBjy0uSb5kDXZlqac7xn9RKnbVlkHlL0Xt1egVTRZrcbTwpwjdMII0DYTPfpTykqBjy5Fgpa+C+Rccfsu2Ym3MV8lmwIu+pzc3DuslkwwwF6300Vz+yqTb5X7vOYdrrfvHPBgWUO0UmLqaIIko1jrbyFgz1xVTFNKSP4k8e3LjA0yV9gZyqZ39C9gXYpx5d2+tLg0wj2w6/bTACVvCX9jOMHp1Sz0/W6r/q6tU55nhCQyMHQ9ZzMWd/cVeciYom+KZy9Lqb1oPZiVW0hu11ArpLMUfZqWHm2s9qjd110g2/yLTrCC/YACPyPtApNYWPpGEBXS1l9aTmH59TLoxI4AMtH0wxeoosRn4cTUtsbnVPfsrgmxPqyNQH8q2IDRuKOdd8PeQPw/cD6t1Dqzqhe/gLD5Bln94cbICRMGzav1ltgQ2GQMFwVTnu/mJq6mNqWaz7DhnmHBbYi66YS7ui8hrfkqFFBuRF69HhMbKKbQCf7cz4B+wmE2HIMLLsmo6CCbChtBObiurDWoi5td+h9ejiCdtiP6/ztQ/q3SAesK5zFpiraayeOl4L839RBd/GYMpkGrqnrk2yZSTlbywLcnzY1xAIh3r6d3ciu8iwx7l2zpw/CDYUJDO2DRPoVMdpbQb4kA7SW698hUmHtbHAcbqH+HJH662mvZY9ylTE8rxWgsvfGLabFqWKqIzrLSF74O+Y8QM7fOg/e09dI8PUu43AApiQn9M2f4N+G4rWncKGBVbL9aeba1NWDTyFws7asYRrloMyZZDwNss5zZAJgySQo7C2u7zHoahT9OwC+5xhJSWsCkY2vT066+zIroetwDZYABPEBc+yeobdo1Oehela46d1K+ThbrlwiyQuwrvUHkUWI7Pj5WhSThHYo+K90siLJ9PohfwhsONADN9vnVpxnq3vHeYjs8iug7gZ9TBYkL8Fh9+BPw9TGbemGJDi4Nzm+tSP6NepmDuqkz5FUcwFrbFFwl0bJgauzSFHgPCYikudFVEZF8VCjHe6B+GdkJQbmXUp4JD9LgYGNhOluHqxFfk+qu6SWyE/JwsaDymPJlkJOHdau5AuaBhv9dThcS7+t51vXixKITw5ybwUIYsiiuoS9qhweXSLOrTTm094AJAoM7KKzDoI6zEPgQH5G9hMlCOt4POogI6AnJmrT36/y7Ycyh7WIYvQq1PhJuUU3HZY/MRLoQjB5omiAOhRHwroBkhs9YowM3pBRgNZdZQRmUf2wYDDa2qfRwZ0lUAzmepTUkZ8hHdbidh0gJXRJIcJbPGm/Y1CAHYToYm1FtQUMKfurvL2a6JzWgxntgC5rV5D8UVGXTvgFBUKuI8g+7w7E0/JwyiBThHmtYn/5yar9SO28sANWkr2VQ+NM7YMGb4hDLaNFgjMOC2xuU7qjcsIxmefJrvjPHbAaW2+fgSZlyhkstXVIJrZGp4wJRq6Aww9Z6SU+Jf6dSrmOPzfFtjzTK4pBpsoxoUCTa6lMFkYVrQkl9knymna2txJ1G8HHDLelfUzw5aCUffo8KmpDf2/76OYY5fRUQ2P8tyr9y6zREneSbeiJipYLt2oB5tm/bx6uXEhNO8mYh3dZ8iOjCPrisfaqZnSGcQ9D0An//Ob6pP/SEoK63oirD6i3UYXc3zoxQV0tLIbhRjdjIvm3XbVMnJpbgY6tY1sI+P6a6hD9lDWhrozLmRI/y+Z0arrs1JS/KJgYFVwopDjuhzmRC7mhoUc9q8Nygj+ONjHg6esLdtqgfo5JKsq40DbHRZobGVEpjuyXcVQaiC3/RjI+u+89OiUf0lKiv+onUKPdHmBWyQBlKdl6SOPgPEx5xxpNTWypPl2ZO46aWvVlP0Tmqr0bg/Nd4nMucOgiKOopsA6tNJ4BNmWhyWTp6zd8wR0ynpMVjZ+uLu2bu2w6dGfWWzkSogYbXDVjjXjKqTLQGDWlZ5m/Ft0r7uN4MVjukJ6HIbws46yRvChjSwj0/p2LOL70JwCxSktVV4e7Rb6yyvq02yPdeFFdrhqwU0aeViyIrOnW3UZALQvOsFn1zx+aLWfQkLXTNp293cSoEfnXHbR6S4dcIlDyDCyjEyPGl9569HhY1Mmb39Tigur5diQ4Vxvc1rPKDfTAHK0ri+4rXwGBgg5FTUuhDbaZCevt4yYSi76SAYZA7Ce1EaGkWX5H7qWvT+PeQQ6eTyrpYif1JWxx/VuRQUfDwpgF9S7j4qWNY14SgpC1xo6QrJVSh3XvHZU5Uia7v7gdJe1moJKfGxhMldTrbjlRcZsy4k98bWRXWRYblbrxz1hMn0dHTosxQIQYulj2xozX9WoVi/oT6sUAbDnu5p4S7SZfGJE8bCu7PGZg2JOmCuAXGaFM8lohpGyG3C/xyUIzOYf13x9lKOvpGxAJ4SMeeRdl5ZULyC7yHCMEUDSrHmFyyXQuzlnL/yhrfWZ93Yt0ljBzjzwKWniqZBhEJlh59dTMvvrUfnBeeabBAYfrfww8p92Gtz1vk/XELu4z4oDBhWtlZl25gaMD5lCtjxWD9rIaiCzkl0lm5ti1u+Z3TsgGzINDuOen6w2Di2urrxdKVkbJpRy5zW8QuiyvueMHW4Y8/epSTJ9k4a32xuuA4+Z8jLzyLHEgnbXtcf9UncIvLmeeMkq87KECXTMOk94GQ1R0VvbG7Pv17D9dxU+M/tvYd7i/OYd6JSFJYqntXVweqnd/Er9be00WFvnovmtEqJgSSEONzz9con9AQ3jfEDOMB1zRFcoP+NOzF83CewN/br2udMY4D/PYKfjOKSdmK6Gi3pVUValYf/3U7X6L+nPkSvf+mWtCEAnz1iQ/aJ+37jcbt2gX/HVTJhswnYbii9P5Yk5sr4vr0p7zNDTh5i73i2Q2060+cRTJD8B2NWo0Ve7FKQAiJHXXA57dqZjmHE+5Xc2gVtWPjdTn/gBFediHuvLOhTOWYbP6rD+u7tHWp3dIzuyOO3mM3/2LScVb7Lh3R/H1VK63TuzLEF2ZrU/aOH/phW+eqJZ2SseuAh+cttJnriEzCA7yJAHtZFJZFN+c6Fhj8pzkYBO/o9vbUy/TXOgE3p3ygZD7GN6BgU74Z/VfJze3EUI+X7ZBL9GiqmNTEybUM75XHGErgNjiq7lyWHwk7pGZpAdD2IZ7QQyKb8sBeeWigZ0GPmItJrf4rPsRkvwolrmc1L+JAU7y2ZcqHdKvY6L2PH2xtnlYMrg8rsRvtPo3SCwb3JsHaWeDquentfjodnOjHXICLKCzJAnBwXLaMii/HE+I9fklt58Zv+vt9VnvpWjf8qetU74GKyxC7BWjxHlRLH3Ja37stXWRWjU7xPIbcYhXXGM43d69tunm7KNbt8TT9lpTGlUufkkbl0NyjvSW1R9IyseaaMgXkAGFeyvB017GOGLoowLtG/0EDrOKm168BzR9sITi6vNb5SzFYksaiE8Oxv+mvjHJXDBHD9I2V4V16vXum6DD9VtHALsO8R7NPGuE4doutnSvFmKzEk91PkwiGkDt6MuetwjoDy1tjZm/pnk7/cli7IZxD+HhngYhbCkURigR5ShVavWnhCjr5Em/i4XnxkSujTxCOFj2uWGgshnCEnlonDbqt68JDsHAPtO8Skw8umALw0zYGeWzPJb1sSQnUb9jA4luUjFWJU5qI/p2OnP6H1kx05d+ez/XmSgU5amNJ5/zBr7oscaOxs1ELjetVuULuxuY46IQsj3JBzz8ftmdTeXep2S/DgQgF1LnscEKBfX6MsxRTUjPs9myGPycVQycFTr5R7U3qq1cu1h/yH5XZIoFYaKDnT6BtbYvyAher169lvEeSv/Wbud1ED/BWl66bnP6O+4+9Wu1TD9Vs07EdyS4nGAzTRYaznhCfZ5DaV9luni5aLjG5AznTjgt8OxvVmn0QC5inCJGIpU/da5bYcdhfj/nCrgB7Qr6YBya+0s+MiutiRHJgE2Q/WrPNaHC8G1EWWSHpoTbz5A4WSgx9XDiUpCvCybWgWmE3Mb2ULG9Oe5RImNOFChgR4KCr/aUPmitiB+GxY99KdH3cXj/M5Gq3L/7NKG2uUWj0PxfHMe4TbtNwjr0Baa+XraFONAUmAlBtlCxsL8hr9p5yur+NLnYFY5dcfLabcnZITvl1UJqWnHEMivmFuq3KyTZyWlywG2KLuG5bTYabbaxHVUupinpZfxERJkCZlCtlLOSrrMdMRW+Dl6X/mYr/+VevXXLbVb9+pb4oaXc+N3aJ/67lKj3sfidP/E2g4KURuYt6kOehWoSXOAdv1FKd1e1mNLryd+mYKa+vXp2sSPSZAWe9wL9+qlaixYqS6pYr5/tdLeeaG1/A7lPRbYr1Avc7uGlCUNhwMAzgY6Ko8TcbEqMSLrgBzLwRgK8SSUb3+ALMm/9b4Bz/hG6s271CPNZfzEF2Zrk++fqTUeVlCbHK2LmVNm18rYYUnD44Brfzun4QZdXmNn4yPaHxEH5MgOMiROFB7k1Oa4Ap2yndpSn/7q2drEX+ndC+yhCWl20RWN0CCzD6BoVNPQ3UYMsgcpFXWJWfAYlofayAyyo3ydsuWtSN/GGejUwyXtYvoGPZ/Uu12iurXGjjiWXJIsv3WjGNoPeX1YBhf/+uJUhS27HMZgr3iRyFUpnYsTXL6iSxxah/HZ5diNQcP1qU8iM/o7WCuPjrl4ruMOdGpkYa428Z1b6lO/rX7aR9EatP7PCOwYsMgrMQz98qXJy/LoYw0lT2VyKYmmElYBdUcd+vbkyAYygqwgM3niURp52QhAh08Mx96ttdAPqUJZJ3N2EQjIk+odl3IIdnbzBUYpDRIQowczxDBEZweQ0cczT49D1Bl15wlyjYsqTWQDGVE6TtmIk5e8+C000MMaCX8dTEXL9hMY79NBGJZKnMEAzJMxegVH+ql8RnifsxylxEad9+JRKjkaLBLX/NvncojeHAQNtOrMs7ELrLYiE4rjJ/Q4NbGh0IS/vWnn+b3QQE/I2I/uqM+8Q5ZBTiu8s74QHJZl8tCzI7wMR2025NFQD74YlZCzCYLRMNl6bA61+Hbo1BF15duTIwPIgrL90QRZL1SQjQh0KuizMrB/v06+HdW7E+zM97Dr7XuyLQsJYB34Jd1I41IS7tVWXZcmO4v8JY0TENvuoqt7opy6oY489SrYeTuKDCj5zybNe5HCbVSgU0cvaF72rWrVT+rdC+wPy9rMKMBO5jhK6bJjhn22ItqONxnQBOM+FnuoE+rGF+TUOXWPDOjZEFRooIeNffjrqjHdUy2rrDJooEd7l/Vb/X+q8PfoPPsZhXWCHcMUX/Y0LeXKi+93MnVGJpZe0tKZjQDLNdq268sLW1zD/MZIxSaErvKwGYY6cVmu6ZZJdt5qZ6hz6r4jA5icrumwkp2/IU/C/IS/oXvef208znve15DpRGi3JDI7JYFY1Rx3VetsQSj++5PtjZmv8AV7METUBoxhbaoB5M8J5K4ycugmruIqLxVsUpwxBbEp66iDp1QXnqOsAOTUNXWuR1LQDmQBmUA2fCish/DXJ0we/BQa6Cky8FkJwNf6WJYlTQTrcW1U4RRUVoQgYSzxBYHctU10t4bsmz2ML2aV10HjXTaghssdMFQRRfCeOvAHefUCday4no2Kb9zdCg30UAbCX1dl9Q/d8a+ePBjGaxj3uEz3vktDunk5G0TvtRTYecNONKyGegrba4E93ojzVc3LXXEzh+WoZ1Gt3dCbt/VEESfb+m+ehR/wHN577X5SXVKn1C11zHCdOofKoXsU18ffjaHdZ7ZruUWC4WW8gtaA2zy4osnV68ZlH4oln+nBHh3hnBYgikrcrmoCLJc29hI8htfwfP2XXl/r3gOjEdQpdasvnsHWxTEWfxS6Rw9rLfx11UjEHF095tp8neBE9WfaQPEWCQYmg7yiZoj9ZMo9O0B3NR6cttsTLKeR9WKS7URZ7xXT9OTw2OcijS4naLjPUZf6+8/0BHXJvJw6h8o5esCGDf3fQzsas9dprfUVccEL7JweQ/vrucTjZK7PstKVAnmRrdCicTeZiWIwHx5PhafwNobtONbJX6EOFc1DTmZvAA+F7tEzrp9z2lDxBhkFPKh0vMBOr/OoFESYjvYKYCmAj0UVerzo2a0l4hx94mYUhu4mYo4OL+GpS1fREweGHA9Sd3IrpCHHnrKk9loC3c7K41Li3LOpPhksx9i9dr4yKORc+EENM+mxkhK7xVzXLbPnvagEazhpZ+IRSrgXtRMwuHzRv5Bt6oo6U5BcX3roX6R0fJZAd/Pxgu6+ftuuxuzfUd/jdfINIeZGzodl1cRzI0dkLu5wmLQi7kHij0x0SI5tMQlLrCZiP38cpRt1Qx1RV4rzginejepu5nTOOAJ4eDoKFN6GSgD8s7sm5vb7Lr+ROw5ZDLKTjl7NNleHC88UtFdnD9+8+GOiGDUcLJ9RN4qLfet+O19MCcd0b6nFQibJb4w8x0xlcO+FAfrgRU0lhud3Nuaun67V2SPtVa/0TI9LkZR0mM22Vhu5DrnYwo7yW0vcizHvNmW1TV1QJ/LwvMlT6W7fZlzyJ5oDpzQH3C9LJP9Xn73AjqeTGsp/URZhTNs9o5PqXExo+oY7S3A+1zrb4hjFN3jixTxz5trUAXUhL2Nj281c3MG+lD16Mv41ZVfszdpS+S80+DTt97gsZubTXxLYT2vd3Zfo+cwD3E4sZ3Vxb9FokBUDeA7vqQOVe6hD9aLxOcyvv8SFIcrfkAOs1X5YGzLYWsn1uV4dFJ4wPslpNFcANNKYE+cR0gAACBBJREFUjRpHcpXdUGZu41mC5/BefhJGY4h9jJ1zKUUFqj16k9+SImhfHCUd5XtZS3Cu9fam+vJXHNs96cuxwlIkIreuskeUJ1S67dO339JTiJ48LzWTS6BHVHLenY5JIbRHc8bPK6NedYsn1ogxz2xaS2b5yWXCCq18/57wPDOLslLmmDbomY9/Hh6rbMfyXL685q0Eeno1s6A541u0I+tfqZelt/ECPNs6H9LOr/493yjtXlVDYCN68x061GIzxWQLP+xvlJGyxtnKCi/hKbxVfsfODPOw6kCbKDsSmZffYRU8o3Rg44d2T8xdK6slJ7qsdSbFMlN4L1hYD+wac51em9MZdC6DzPsRVcoEyCljjCW1NjyEl/DUl5dOZo/IQ1ivo/ote/RsKv6oDlRcFWvrrCQAW+0o6RiuH3b05vTiN8iqTN57cwSbMgV26PnDj4KtrPBQ3jHgWdKAHCiBPiADLcGb2o75d7fWp39Ow0+vJThwwNwVk862uTlD9tu0PTbvc3Pm49xDTpl8MQ6v4Bm8UzELoXCzyEBuPpVAz7YqtHOroUsjZj4gAbZvcevmA0C4drthUSbvmnb2DHCDKQrFGCBvwSt4Jjb4Bsu2BsckdpNJrqEWb8xrlF7p1zQMPX66eemT6tq5BZFOORERcJvucM/zvJwNQc9ruG67aKKv8Fofr6xoffzbtGv8033fxu7PxJU/ACeKe85xgEKPKOind01s2nGmufD0crt1pfKQqL6x9Mo57TwSuTqgQzYxTp1RjMBIhDTrt8k6L/b6SsqAA+XQPQOmWqKcl0Dvl5Lu/8hPIrRySUMercqgTWd9PC7I4QU8ET9KkFsEZ9BPJdAH5WD88Jxvf7uu6P2EunQvJV2YBEOALTm0KsN8/NGuqSff1ouywwN4oWKV58fDSs7otwR6Rox1RLusK3rfqznp+7R3e1l+vfCBJ+4Xc22kcaSd6mfy8iVtgrGZhOpLkP3qy5QdHugb5S8pYw6MFOhe0p0xA0YYPcX/+I6J2a/RPvmLevdiB0tWh6ToelzD5BjKrtSLGZyzVx7Ii2kLb0Si7Fe/SJkpu2+ZI+IpvJNXZadYypECPcVyFDmqB3c2ZvfrNNYRFcKr/vEUWp117Z7LgjGkGVpl9cpwJxMo3Y5QVv35YBb5KuM0c6AEupk3w/xyROvHN/UcivHCD3Pjx7VWHfOAyEDlIi3SJG1PoizBoRTKqHcatJKGzIES6ENmuCW5ZR3c+DrtCvt5QYjNNV5gZ9jMkU+uKfIKYMmA7RNxkwZpxRmqUxbKRNkURTkftzE5w28l0DNkboKoW9oV9mNSVP3DWrW6qPBe2MUTy1pYr3HtqkuQpyBO4o67dEYZKAtlUrpeOwOT5K8M4+ZA7TdOPFThKSk3HAC3H9Nc9v6pav0lvfO3D+DbHG3lsgMuIPQJ4CoxcRAXcXZt3flEi582eacMev8Yf+spaYQcWOvRS7CPsBaik35sqzaSaK35tzT8DcAT7W3NVd50Man+40rhhwXOQXp3whIHcXVRyg9p2IiZe5s8k3d5fMzmufw2PA6sAZ0kw949lKqsfodXvMKnxK2u36198t+uilrRexdz1nIB9vaigEpPjH26uEQYwhIHcfmmSx7Jq/x/tx7yXpIHB0IGZ/ULrtcBPczTR8uhfMiKvPx+aufE3F0yxIAZpVAeXHkLenduH/2C5temW0h7I+v1i7uo+9P5w/B/EAV5I4/y8ymDv9J5BBwIsRwJdPITehhB3sokoznwjHrLfVqC+4vu516M4hQFysAP+9DppR8U4Dl0wt8sk7HZ5Zh+n+t+w0/XAkx/3GGOetNY80OeyJs8PRN6LH9Hz4FeDDds2Qk9fs+u+2zevL/1Sol3oNJjLwdYnmIJ7mfPtxZ/SBvlqT8bW9fNqdnNxp1wPA4Kw0XFveamXqK5pT79H1baLbTqJQ3IgZDpA0YTqVw39ui9iZWKul5u5OL9x3ZMzH2FhssnR5Ub0iYPSr8E+agqISJdE1a9gE58pggi0iqdhsOBhzRc3iMN98fVE0Sdgkujg7gsDtIiTdJWMct12eHUtVcqNox6A52UbBF55aT0lDYH2joB9j7ZO39z92BM2vGvi480SIs09WFtCL/OU/nHSDjgwqZ1jh6V4zDCtObtUWmUbrE4AOD+aldjbtt8a/mPL64uf60cnJPwOCmoF2/N1Sb/XEYi3qprgkuDjXGYl7HfEI+uZGIDPYwwTOB9noq6y8aAYUTlb1ocAIDfIDvoe880F/9G5qqu1t+Dsj04cbatMX3/xdZKaXY5rZqyxOM7TAoV5Zao1n1KDPQwljBBWw/vm/kwzvJ3IA4AyGu1/fSbZYzydzV5j79jRhFoToexxneeby390UC5KQPH5oCtdQ472LiRDgz0MMEwAzbAh37L36FwAIBOSmn2XWdbC7+mIfdMmKoEibY3UOD1D/M1D1/QnePvP9O89Juh//J39BwI8ZU0J6kBPcxAmKES8CFHRv4LYAPQav39QzKnvL1WrR2pV6pozKdblfatq+3V66qV6umzrcUfH3luywys40CIp3WOCf5IHehhHshgCfaQG7n5DYCsk2XVZrtzqpz3he57bnJZZiTgQFogJ7JYy2sl/8eGA71qk973sSlgWZD1HMgU6Gm2SOuzXf5VcmC8OZA2djIF+nhXRVm6kgPF4UDmQE+7ZSoOa8uclhxIxoEsMJM50JMVtQxVcqDkQJocGArQw001aWa8jKvkwDhyICus/H8NQJKf9x565AAAAABJRU5ErkJggg=="),
					LoadLayer("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