diff options
| author | David Hook <david.hook@keyfactor.com> | 2022-11-07 17:30:00 +1100 |
|---|---|---|
| committer | David Hook <david.hook@keyfactor.com> | 2022-11-07 17:30:00 +1100 |
| commit | 146be77300207031b6b9477b8e48428278e841b8 (patch) | |
| tree | d7342aad04bca424b56229d1d5eba558bbb4afd3 | |
| parent | resolve conflicts (diff) | |
| parent | GOST 2012 private key reading (diff) | |
| download | BouncyCastle.NET-ed25519-146be77300207031b6b9477b8e48428278e841b8.tar.xz | |
Merge branch 'master' of gitlab.cryptoworkshop.com:root/bc-csharp
223 files changed, 20148 insertions, 2404 deletions
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index f20669e90..05eebfb3c 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,16 +1,15 @@ - stages: # List of stages for jobs, and their order of execution - test -net462-job: # This job runs in the test stage. +net461-job: # This job runs in the test stage. stage: test # It only starts when the job in the build stage completes successfully. script: - - "dotnet test --framework net462 -v:normal -l \"console;verbosity=detailed\" crypto\\test\\BouncyCastle.Crypto.Tests.csproj" + - "dotnet test --framework net461 -v:normal -l \"console;verbosity=detailed\" crypto\\test\\BouncyCastle.Crypto.Tests.csproj" net472-job: stage: test script: - - "dotnet test --framework net462 -v:normal -l \"console;verbosity=detailed\" crypto\\test\\BouncyCastle.Crypto.Tests.csproj" + - "dotnet test --framework net472 -v:normal -l \"console;verbosity=detailed\" crypto\\test\\BouncyCastle.Crypto.Tests.csproj" net60-job: stage: test diff --git a/BouncyCastle.NET.snk b/BouncyCastle.NET.snk new file mode 100644 index 000000000..589b817da --- /dev/null +++ b/BouncyCastle.NET.snk Binary files differdiff --git a/BouncyCastle.sln b/BouncyCastle.sln index 506e62ad1..b00aad57a 100644 --- a/BouncyCastle.sln +++ b/BouncyCastle.sln @@ -1,11 +1,13 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 16 -VisualStudioVersion = 16.0.32602.291 +# Visual Studio Version 17 +VisualStudioVersion = 17.3.32929.385 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F8F54480-386E-4CE7-8C0E-537922E2A634}" ProjectSection(SolutionItems) = preProject .gitlab-ci.yml = .gitlab-ci.yml + Directory.Build.props = Directory.Build.props + LICENSE.md = LICENSE.md README.md = README.md version.json = version.json EndProjectSection diff --git a/BouncyCastle.snk b/BouncyCastle.snk deleted file mode 100644 index f460ac3d6..000000000 --- a/BouncyCastle.snk +++ /dev/null Binary files differdiff --git a/Directory.Build.props b/Directory.Build.props new file mode 100644 index 000000000..6284136f0 --- /dev/null +++ b/Directory.Build.props @@ -0,0 +1,5 @@ +<Project> + <PropertyGroup> + <GitVersionBaseDirectory>$(MSBuildThisFileDirectory)</GitVersionBaseDirectory> + </PropertyGroup> +</Project> diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 000000000..ee9580810 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,13 @@ +Copyright (c) 2000-2022 The Legion of the Bouncy Castle Inc. (https://www.bouncycastle.org). +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sub license, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: The above copyright notice and this +permission notice shall be included in all copies or substantial portions of the Software. + +**THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.** diff --git a/README.md b/README.md index e7c8270a9..306cc3924 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ -# The Bouncy Castle Crypto Package For C Sharp +# The Bouncy Castle Cryptography Library For .NET -The Bouncy Castle Crypto package is a C\# implementation of cryptographic algorithms and protocols, it was developed by the Legion of the Bouncy Castle, a registered Australian Charity, with a little help! The Legion, and the latest goings on with this package, can be found at [https://www.bouncycastle.org](https://www.bouncycastle.org). +The Bouncy Castle Cryptography library is a .NET implementation of cryptographic algorithms and protocols. It was developed by the Legion of the Bouncy Castle, a registered Australian Charity, with a little help! The Legion, and the latest goings on with this package, can be found at [https://www.bouncycastle.org](https://www.bouncycastle.org). -In addition to providing basic cryptography algorithms, the package also provides support for CMS, OpenPGP, (D)TLS, TSP, X.509 certificate generation and more. In particular, the package includes implementations of all the NIST Post-Quantum Cryptography Standardization Round 3 submissions. These should all be considered EXPERIMENTAL and subject to change or removal. +In addition to providing basic cryptography algorithms, the package also provides support for CMS, OpenPGP, (D)TLS, TSP, X.509 certificate generation and more. The package also includes implementations of the following NIST Post-Quantum Cryptography Standardization algorithms: CRYSTALS-Dilithium, CRYSTALS-Kyber, Falcon, SPHINCS+, Classic McEliece, FrodoKEM, NTRU, NTRU Prime, Picnic, Saber, BIKE, and SIKE. These should all be considered EXPERIMENTAL and subject to change or removal. SIKE in particular is already slated for removal and should be used for research purposes only. The Legion also gratefully acknowledges the contributions made to this package by others (see [here](https://www.bouncycastle.org/csharp/contributors.html) for the current list). If you would like to contribute to our efforts please feel free to get in touch with us or visit our [donations page](https://www.bouncycastle.org/donate), sponsor some specific work, or purchase a [support contract](https://www.keyfactor.com/platform/bouncy-castle-support/). @@ -23,9 +23,9 @@ For those who are interested, there are 2 mailing lists for participation in thi ## Feedback -If you want to provide feedback directly to the members of **The Legion** then please use [feedback-crypto@bouncycastle.org](mailto:feedback-crypto@bouncycastle.org), if you want to help this project survive please consider [donating](https://www.bouncycastle.org/donate). +If you want to provide feedback directly to the members of **The Legion** then please use [feedback-crypto@bouncycastle.org](mailto:feedback-crypto@bouncycastle.org). If you want to help this project survive please consider [donating](https://www.bouncycastle.org/donate). -For bug reporting/requests you can report issues on [github](https://github.com/bcgit/bc-csharp), or via feedback-crypto if required. We will accept pull requests based on this repository as well, but only on the basis that any code included may be distributed under the [Bouncy Castle License](https://www.bouncycastle.org/licence.html). +For bug reporting/requests you can report issues on [github](https://github.com/bcgit/bc-csharp), or via [feedback-crypto@bouncycastle.org](mailto:feedback-crypto@bouncycastle.org) if required. We will accept pull requests based on this repository as well, but only on the basis that any code included may be distributed under the [Bouncy Castle License](https://www.bouncycastle.org/licence.html). ## Finally diff --git a/crypto/License.html b/crypto/License.html index d94209b12..37f79753e 100644 --- a/crypto/License.html +++ b/crypto/License.html @@ -6,17 +6,18 @@ <title>License</title> </head> <body> -<h2>The Bouncy Castle Cryptographic C#® API</h2> +<h2>The BouncyCastle.NET Cryptography Library</h2> <h3>License:</h3> The Bouncy Castle License<br> Copyright (c) 2000-2022 The Legion of the Bouncy Castle Inc. (https://www.bouncycastle.org)<br> -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and associated documentation files (the "Software"), to deal in the -Software without restriction, including without limitation the rights to use, copy, modify, merge, -publish, distribute, sub license, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:<br> -The above copyright notice and this permission notice shall be included -in all copies or substantial portions of the Software.<br> +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sub license, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions:<br> +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software.<br> <span style="font-weight: bold;">THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,</span><br style="font-weight: bold;"> diff --git a/crypto/src/BouncyCastle.Crypto.csproj b/crypto/src/BouncyCastle.Crypto.csproj index 44925aebd..8c77860b1 100644 --- a/crypto/src/BouncyCastle.Crypto.csproj +++ b/crypto/src/BouncyCastle.Crypto.csproj @@ -1,31 +1,57 @@ <Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> - <TargetFrameworks>net6.0;netstandard2.0;net462</TargetFrameworks> + <TargetFrameworks>net6.0;netstandard2.0;net461</TargetFrameworks> <RootNamespace>Org.BouncyCastle</RootNamespace> - <AssemblyOriginatorKeyFile>..\..\BouncyCastle.snk</AssemblyOriginatorKeyFile> + <AssemblyOriginatorKeyFile>..\..\BouncyCastle.NET.snk</AssemblyOriginatorKeyFile> <SignAssembly>true</SignAssembly> <NoWarn>1591</NoWarn> - <Authors /> + <AssemblyName>BouncyCastle.Cryptography</AssemblyName> + <AssemblyTitle>BouncyCastle.NET Cryptography ($(TargetFramework))</AssemblyTitle> + <Authors>Legion of the Bouncy Castle Inc.</Authors> <Company>Legion of the Bouncy Castle Inc.</Company> <Copyright>Copyright © Legion of the Bouncy Castle Inc. 2000-2022</Copyright> - <DebugType>embedded</DebugType> <Description>BouncyCastle.NET is a popular cryptography library for .NET</Description> - <EmbedUntrackedSources>true</EmbedUntrackedSources> - <PackageIconUrl>https://www.bouncycastle.org/images/csharp_logo.gif</PackageIconUrl> + <PackageIcon>packageIcon.png</PackageIcon> + <PackageIconUrl>https://www.bouncycastle.org/images/nuget_packageIcon.png</PackageIconUrl> <PackageId>BouncyCastle.Cryptography</PackageId> - <PackageLicenseFile>License.html</PackageLicenseFile> + <PackageLicenseFile>LICENSE.md</PackageLicenseFile> <PackageProjectUrl>https://www.bouncycastle.org/csharp/</PackageProjectUrl> + <PackageReadmeFile>README.md</PackageReadmeFile> <PackageReleaseNotes>https://www.bouncycastle.org/csharp/</PackageReleaseNotes> - <PackageTags>bouncycastle cryptography dtls encryption security tls</PackageTags> + <PackageTags>bouncycastle cryptography dtls encryption open-source post-quantum security tls</PackageTags> <Product>BouncyCastle.NET</Product> - <!--<PublishRepositoryUrl>true</PublishRepositoryUrl>--> <RepositoryType>git</RepositoryType> <RepositoryUrl>https://github.com/bcgit/bc-csharp</RepositoryUrl> <Title>BouncyCastle.NET Cryptography</Title> </PropertyGroup> + <!--Source-Level Debugging--> + <PropertyGroup> + <DebugType>embedded</DebugType> + <EmbedAllSources>true</EmbedAllSources> + </PropertyGroup> + + <!--Package Validation--> + <PropertyGroup> + <EnablePackageValidation>true</EnablePackageValidation> + + <!-- TODO: Enable this once there is a baseline version to compare to. --> + <!--<PackageValidationBaselineVersion>2.0.0</PackageValidationBaselineVersion>--> + + <!-- In case we disable signing for local builds, ignore identity mismatch with baseline version. --> + <NoWarn Condition="'$(SignAssembly)' != 'true'">$(NoWarn);CP0003</NoWarn> + + <!-- + We added Span-based variant methods to several APIs. Code that uses those methods or implements the + affected interfaces (or abstract classes) will not be backward compatible. + + TODO: Use suppressions for each individual case of a Span-based method. + --> + <NoWarn>$(NoWarn);CP0005;CP0006</NoWarn> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)'=='Debug'"> <DefineConstants>DEBUG;TRACE</DefineConstants> </PropertyGroup> @@ -38,27 +64,25 @@ <ItemGroup> <None Remove="**\*.properties" /> <EmbeddedResource Include="**\*.properties" /> + <None Include="..\..\LICENSE.md" Pack="true" PackagePath="\" /> + <None Include="..\..\packageIcon.png" Pack="true" PackagePath="\" /> + <None Include="..\..\README.md" Pack="true" PackagePath="\" /> </ItemGroup> <ItemGroup> - <None Include="..\License.html"> - <Pack>True</Pack> - <PackagePath>\</PackagePath> - </None> - </ItemGroup> - <ItemGroup> <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3"> <PrivateAssets>all</PrivateAssets> <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> </PackageReference> - <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1"> - <PrivateAssets>all</PrivateAssets> - <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> - </PackageReference> <PackageReference Include="Nerdbank.GitVersioning" Version="3.5.119"> <PrivateAssets>all</PrivateAssets> <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> </PackageReference> </ItemGroup> + <Target Name="FixAssemblyAttributes" AfterTargets="GetBuildVersion"> + <PropertyGroup> + <!-- Here we can override/use any MSBuild properties set by Nerdbank.GitVersioning --> + </PropertyGroup> + </Target> </Project> diff --git a/crypto/src/asn1/Asn1GeneralizedTime.cs b/crypto/src/asn1/Asn1GeneralizedTime.cs index e844c8ca2..139384c1a 100644 --- a/crypto/src/asn1/Asn1GeneralizedTime.cs +++ b/crypto/src/asn1/Asn1GeneralizedTime.cs @@ -11,8 +11,7 @@ namespace Org.BouncyCastle.Asn1 * Base class representing the ASN.1 GeneralizedTime type. * <p> * The main difference between these and UTC time is a 4 digit year. - * </p> - * <p> + * </p><p> * One second resolution date+time on UTC timezone (Z) * with 4 digit year (valid from 0001 to 9999). * </p><p> @@ -24,18 +23,18 @@ namespace Org.BouncyCastle.Asn1 * * <h3>11: Restrictions on BER employed by both CER and DER</h3> * <h4>11.7 GeneralizedTime </h4> - * <p> + * </p><p> * <b>11.7.1</b> The encoding shall terminate with a "Z", * as described in the ITU-T Rec. X.680 | ISO/IEC 8824-1 clause on * GeneralizedTime. * </p><p> * <b>11.7.2</b> The seconds element shall always be present. - * </p> - * <p> + * </p><p> * <b>11.7.3</b> The fractional-seconds elements, if present, * shall omit all trailing zeros; if the elements correspond to 0, * they shall be wholly omitted, and the decimal point element also * shall be omitted. + * </p> */ public class Asn1GeneralizedTime : Asn1Object diff --git a/crypto/src/asn1/Asn1Null.cs b/crypto/src/asn1/Asn1Null.cs index 9ea9b4375..77304c0fb 100644 --- a/crypto/src/asn1/Asn1Null.cs +++ b/crypto/src/asn1/Asn1Null.cs @@ -25,21 +25,23 @@ namespace Org.BouncyCastle.Asn1 public static Asn1Null GetInstance(object obj) { - if (obj == null || obj is Asn1Null) - { - return (Asn1Null)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is Asn1Null asn1Null) + return asn1Null; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is Asn1Null) - return (Asn1Null)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is Asn1Null converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (Asn1Null)Meta.Instance.FromByteArray((byte[])obj); + return (Asn1Null)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/Asn1ObjectDescriptor.cs b/crypto/src/asn1/Asn1ObjectDescriptor.cs index 9c99f441e..13521a744 100644 --- a/crypto/src/asn1/Asn1ObjectDescriptor.cs +++ b/crypto/src/asn1/Asn1ObjectDescriptor.cs @@ -36,21 +36,23 @@ namespace Org.BouncyCastle.Asn1 */ public static Asn1ObjectDescriptor GetInstance(object obj) { - if (obj == null || obj is Asn1ObjectDescriptor) - { - return (Asn1ObjectDescriptor)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is Asn1ObjectDescriptor asn1ObjectDescriptor) + return asn1ObjectDescriptor; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is Asn1ObjectDescriptor) - return (Asn1ObjectDescriptor)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is Asn1ObjectDescriptor converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (Asn1ObjectDescriptor)Meta.Instance.FromByteArray((byte[])obj); + return (Asn1ObjectDescriptor)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/Asn1OctetString.cs b/crypto/src/asn1/Asn1OctetString.cs index d34686134..8f7da8800 100644 --- a/crypto/src/asn1/Asn1OctetString.cs +++ b/crypto/src/asn1/Asn1OctetString.cs @@ -36,22 +36,23 @@ namespace Org.BouncyCastle.Asn1 */ public static Asn1OctetString GetInstance(object obj) { - if (obj == null || obj is Asn1OctetString) - { - return (Asn1OctetString)obj; - } - //else if (obj is Asn1OctetStringParser) - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is Asn1OctetString asn1OctetString) + return asn1OctetString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is Asn1OctetString) - return (Asn1OctetString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is Asn1OctetString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (Asn1OctetString)Meta.Instance.FromByteArray((byte[])obj); + return (Asn1OctetString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/Asn1OutputStream.cs b/crypto/src/asn1/Asn1OutputStream.cs index 59178ea31..163e3848c 100644 --- a/crypto/src/asn1/Asn1OutputStream.cs +++ b/crypto/src/asn1/Asn1OutputStream.cs @@ -1,5 +1,10 @@ using System; using System.IO; +using System.Diagnostics; +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +using System.Buffers.Binary; +using System.Numerics; +#endif using Org.BouncyCastle.Utilities.IO; @@ -73,15 +78,19 @@ namespace Org.BouncyCastle.Asn1 { if (dl < 128) { + Debug.Assert(dl >= 0); WriteByte((byte)dl); return; } #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER - Span<byte> stack = stackalloc byte[5]; + Span<byte> encoding = stackalloc byte[5]; + BinaryPrimitives.WriteUInt32BigEndian(encoding[1..], (uint)dl); + int leadingZeroBytes = BitOperations.LeadingZeroCount((uint)dl) / 8; + encoding[leadingZeroBytes] = (byte)(0x84 - leadingZeroBytes); + Write(encoding[leadingZeroBytes..]); #else byte[] stack = new byte[5]; -#endif int pos = stack.Length; do @@ -94,9 +103,6 @@ namespace Org.BouncyCastle.Asn1 int count = stack.Length - pos; stack[--pos] = (byte)(0x80 | count); -#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER - Write(stack[pos..]); -#else Write(stack, pos, count + 1); #endif } diff --git a/crypto/src/asn1/Asn1RelativeOid.cs b/crypto/src/asn1/Asn1RelativeOid.cs index a1997864d..3c4bf237a 100644 --- a/crypto/src/asn1/Asn1RelativeOid.cs +++ b/crypto/src/asn1/Asn1RelativeOid.cs @@ -29,21 +29,23 @@ namespace Org.BouncyCastle.Asn1 public static Asn1RelativeOid GetInstance(object obj) { - if (obj == null || obj is Asn1RelativeOid) - { - return (Asn1RelativeOid)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is Asn1RelativeOid asn1RelativeOid) + return asn1RelativeOid; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is Asn1RelativeOid) - return (Asn1RelativeOid)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is Asn1RelativeOid converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (Asn1RelativeOid)FromByteArray((byte[])obj); + return (Asn1RelativeOid)FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/Asn1Sequence.cs b/crypto/src/asn1/Asn1Sequence.cs index 1a123e26d..a8191de99 100644 --- a/crypto/src/asn1/Asn1Sequence.cs +++ b/crypto/src/asn1/Asn1Sequence.cs @@ -30,22 +30,23 @@ namespace Org.BouncyCastle.Asn1 */ public static Asn1Sequence GetInstance(object obj) { - if (obj == null || obj is Asn1Sequence) - { - return (Asn1Sequence)obj; - } - //else if (obj is Asn1SequenceParser) - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is Asn1Sequence asn1Sequence) + return asn1Sequence; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is Asn1Sequence) - return (Asn1Sequence)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is Asn1Sequence converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (Asn1Sequence)Meta.Instance.FromByteArray((byte[])obj); + return (Asn1Sequence)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/Asn1Set.cs b/crypto/src/asn1/Asn1Set.cs index faec50eb0..2b3810e43 100644 --- a/crypto/src/asn1/Asn1Set.cs +++ b/crypto/src/asn1/Asn1Set.cs @@ -31,22 +31,23 @@ namespace Org.BouncyCastle.Asn1 */ public static Asn1Set GetInstance(object obj) { - if (obj == null || obj is Asn1Set) - { - return (Asn1Set)obj; - } - //else if (obj is Asn1SetParser) - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is Asn1Set asn1Set) + return asn1Set; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is Asn1Set) - return (Asn1Set)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is Asn1Set converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (Asn1Set)Meta.Instance.FromByteArray((byte[])obj); + return (Asn1Set)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/Asn1TaggedObject.cs b/crypto/src/asn1/Asn1TaggedObject.cs index 46aa137a8..63ab6a5d0 100644 --- a/crypto/src/asn1/Asn1TaggedObject.cs +++ b/crypto/src/asn1/Asn1TaggedObject.cs @@ -21,22 +21,23 @@ namespace Org.BouncyCastle.Asn1 public static Asn1TaggedObject GetInstance(object obj) { - if (obj == null || obj is Asn1TaggedObject) - { - return (Asn1TaggedObject)obj; - } - //else if (obj is Asn1TaggedObjectParser) - else if (obj is IAsn1Convertible asn1Convertible) + if (obj == null) + return null; + + if (obj is Asn1TaggedObject asn1TaggedObject) + return asn1TaggedObject; + + if (obj is IAsn1Convertible asn1Convertible) { Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); - if (asn1Object is Asn1TaggedObject taggedObject) - return taggedObject; + if (asn1Object is Asn1TaggedObject converted) + return converted; } - else if (obj is byte[] byteArray) + else if (obj is byte[] bytes) { try { - return CheckedCast(FromByteArray(byteArray)); + return CheckedCast(FromByteArray(bytes)); } catch (IOException e) { diff --git a/crypto/src/asn1/ConstructedBitStream.cs b/crypto/src/asn1/ConstructedBitStream.cs index 49f54fc1b..f089dac75 100644 --- a/crypto/src/asn1/ConstructedBitStream.cs +++ b/crypto/src/asn1/ConstructedBitStream.cs @@ -33,6 +33,9 @@ namespace Org.BouncyCastle.Asn1 { Streams.ValidateBufferArguments(buffer, offset, count); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return Read(buffer.AsSpan(offset, count)); +#else if (count < 1) return 0; @@ -75,8 +78,57 @@ namespace Org.BouncyCastle.Asn1 m_currentStream = m_currentParser.GetBitStream(); } } +#endif } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + if (buffer.IsEmpty) + return 0; + + if (m_currentStream == null) + { + if (!m_first) + return 0; + + m_currentParser = GetNextParser(); + if (m_currentParser == null) + return 0; + + m_first = false; + m_currentStream = m_currentParser.GetBitStream(); + } + + int totalRead = 0; + + for (;;) + { + int numRead = m_currentStream.Read(buffer[totalRead..]); + + if (numRead > 0) + { + totalRead += numRead; + + if (totalRead == buffer.Length) + return totalRead; + } + else + { + m_padBits = m_currentParser.PadBits; + m_currentParser = GetNextParser(); + if (m_currentParser == null) + { + m_currentStream = null; + return totalRead; + } + + m_currentStream = m_currentParser.GetBitStream(); + } + } + } +#endif + public override int ReadByte() { if (m_currentStream == null) diff --git a/crypto/src/asn1/ConstructedOctetStream.cs b/crypto/src/asn1/ConstructedOctetStream.cs index 12aa14e74..d005f9fe7 100644 --- a/crypto/src/asn1/ConstructedOctetStream.cs +++ b/crypto/src/asn1/ConstructedOctetStream.cs @@ -1,3 +1,4 @@ +using System; using System.IO; using Org.BouncyCastle.Utilities; @@ -22,6 +23,9 @@ namespace Org.BouncyCastle.Asn1 { Streams.ValidateBufferArguments(buffer, offset, count); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return Read(buffer.AsSpan(offset, count)); +#else if (count < 1) return 0; @@ -63,8 +67,56 @@ namespace Org.BouncyCastle.Asn1 m_currentStream = next.GetOctetStream(); } } +#endif } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + if (buffer.IsEmpty) + return 0; + + if (m_currentStream == null) + { + if (!m_first) + return 0; + + Asn1OctetStringParser next = GetNextParser(); + if (next == null) + return 0; + + m_first = false; + m_currentStream = next.GetOctetStream(); + } + + int totalRead = 0; + + for (;;) + { + int numRead = m_currentStream.Read(buffer[totalRead..]); + + if (numRead > 0) + { + totalRead += numRead; + + if (totalRead == buffer.Length) + return totalRead; + } + else + { + Asn1OctetStringParser next = GetNextParser(); + if (next == null) + { + m_currentStream = null; + return totalRead; + } + + m_currentStream = next.GetOctetStream(); + } + } + } +#endif + public override int ReadByte() { if (m_currentStream == null) diff --git a/crypto/src/asn1/DERExternal.cs b/crypto/src/asn1/DERExternal.cs index 9fba95165..207930062 100644 --- a/crypto/src/asn1/DERExternal.cs +++ b/crypto/src/asn1/DERExternal.cs @@ -25,21 +25,23 @@ namespace Org.BouncyCastle.Asn1 public static DerExternal GetInstance(object obj) { - if (obj == null || obj is DerExternal) - { - return (DerExternal)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerExternal derExternal) + return derExternal; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerExternal) - return (DerExternal)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerExternal converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerExternal)Meta.Instance.FromByteArray((byte[])obj); + return (DerExternal)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DefiniteLengthInputStream.cs b/crypto/src/asn1/DefiniteLengthInputStream.cs index ed5bd2446..89f0d5a62 100644 --- a/crypto/src/asn1/DefiniteLengthInputStream.cs +++ b/crypto/src/asn1/DefiniteLengthInputStream.cs @@ -79,6 +79,27 @@ namespace Org.BouncyCastle.Asn1 return numRead; } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + if (_remaining == 0) + return 0; + + int toRead = System.Math.Min(buffer.Length, _remaining); + int numRead = _in.Read(buffer[..toRead]); + + if (numRead < 1) + throw new EndOfStreamException("DEF length " + _originalLength + " object truncated by " + _remaining); + + if ((_remaining -= numRead) == 0) + { + SetParentEofDetect(); + } + + return numRead; + } +#endif + internal void ReadAllIntoByteArray(byte[] buf) { if (_remaining != buf.Length) diff --git a/crypto/src/asn1/DerBMPString.cs b/crypto/src/asn1/DerBMPString.cs index a289eed1b..284a4b830 100644 --- a/crypto/src/asn1/DerBMPString.cs +++ b/crypto/src/asn1/DerBMPString.cs @@ -31,21 +31,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerBmpString GetInstance(object obj) { - if (obj == null || obj is DerBmpString) - { - return (DerBmpString)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerBmpString derBmpString) + return derBmpString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerBmpString) - return (DerBmpString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerBmpString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerBmpString)Meta.Instance.FromByteArray((byte[])obj); + return (DerBmpString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerBitString.cs b/crypto/src/asn1/DerBitString.cs index 8aab88353..44b3bb95a 100644 --- a/crypto/src/asn1/DerBitString.cs +++ b/crypto/src/asn1/DerBitString.cs @@ -38,22 +38,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerBitString GetInstance(object obj) { - if (obj == null || obj is DerBitString) - { - return (DerBitString)obj; - } - //else if (obj is Asn1BitStringParser) - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerBitString derBitString) + return derBitString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerBitString) - return (DerBitString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerBitString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return GetInstance(FromByteArray((byte[])obj)); + return GetInstance(FromByteArray(bytes)); } catch (IOException e) { diff --git a/crypto/src/asn1/DerBoolean.cs b/crypto/src/asn1/DerBoolean.cs index ad578ae80..6256db6e0 100644 --- a/crypto/src/asn1/DerBoolean.cs +++ b/crypto/src/asn1/DerBoolean.cs @@ -30,21 +30,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerBoolean GetInstance(object obj) { - if (obj == null || obj is DerBoolean) - { - return (DerBoolean)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerBoolean derBoolean) + return derBoolean; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerBoolean) - return (DerBoolean)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerBoolean converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerBoolean)Meta.Instance.FromByteArray((byte[])obj); + return (DerBoolean)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerEnumerated.cs b/crypto/src/asn1/DerEnumerated.cs index 920b3dc8e..b85c5a43e 100644 --- a/crypto/src/asn1/DerEnumerated.cs +++ b/crypto/src/asn1/DerEnumerated.cs @@ -28,21 +28,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerEnumerated GetInstance(object obj) { - if (obj == null || obj is DerEnumerated) - { - return (DerEnumerated)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerEnumerated derEnumerated) + return derEnumerated; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerEnumerated) - return (DerEnumerated)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerEnumerated converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerEnumerated)Meta.Instance.FromByteArray((byte[])obj); + return (DerEnumerated)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerGeneralString.cs b/crypto/src/asn1/DerGeneralString.cs index e6637732a..6a378307d 100644 --- a/crypto/src/asn1/DerGeneralString.cs +++ b/crypto/src/asn1/DerGeneralString.cs @@ -22,21 +22,23 @@ namespace Org.BouncyCastle.Asn1 public static DerGeneralString GetInstance(object obj) { - if (obj == null || obj is DerGeneralString) - { - return (DerGeneralString) obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerGeneralString derGeneralString) + return derGeneralString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerGeneralString) - return (DerGeneralString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerGeneralString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerGeneralString)Meta.Instance.FromByteArray((byte[])obj); + return (DerGeneralString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerGraphicString.cs b/crypto/src/asn1/DerGraphicString.cs index cb32d14eb..85330eb33 100644 --- a/crypto/src/asn1/DerGraphicString.cs +++ b/crypto/src/asn1/DerGraphicString.cs @@ -29,21 +29,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerGraphicString GetInstance(object obj) { - if (obj == null || obj is DerGraphicString) - { - return (DerGraphicString)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerGraphicString derGraphicString) + return derGraphicString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerGraphicString) - return (DerGraphicString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerGraphicString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerGraphicString)Meta.Instance.FromByteArray((byte[])obj); + return (DerGraphicString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerIA5String.cs b/crypto/src/asn1/DerIA5String.cs index a56879831..de2860130 100644 --- a/crypto/src/asn1/DerIA5String.cs +++ b/crypto/src/asn1/DerIA5String.cs @@ -30,21 +30,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerIA5String GetInstance(object obj) { - if (obj == null || obj is DerIA5String) - { - return (DerIA5String)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerIA5String derIA5String) + return derIA5String; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerIA5String) - return (DerIA5String)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerIA5String converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerIA5String)Meta.Instance.FromByteArray((byte[])obj); + return (DerIA5String)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerInteger.cs b/crypto/src/asn1/DerInteger.cs index c8d4e47df..05a790743 100644 --- a/crypto/src/asn1/DerInteger.cs +++ b/crypto/src/asn1/DerInteger.cs @@ -42,21 +42,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerInteger GetInstance(object obj) { - if (obj == null || obj is DerInteger) - { - return (DerInteger)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerInteger derInteger) + return derInteger; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerInteger) - return (DerInteger)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerInteger converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerInteger)Meta.Instance.FromByteArray((byte[])obj); + return (DerInteger)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerNumericString.cs b/crypto/src/asn1/DerNumericString.cs index 693ff7d6e..819d946b1 100644 --- a/crypto/src/asn1/DerNumericString.cs +++ b/crypto/src/asn1/DerNumericString.cs @@ -30,21 +30,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerNumericString GetInstance(object obj) { - if (obj == null || obj is DerNumericString) - { - return (DerNumericString)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerNumericString derNumericString) + return derNumericString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerNumericString) - return (DerNumericString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerNumericString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerNumericString)Meta.Instance.FromByteArray((byte[])obj); + return (DerNumericString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerObjectIdentifier.cs b/crypto/src/asn1/DerObjectIdentifier.cs index b10f8f8b6..cb5771958 100644 --- a/crypto/src/asn1/DerObjectIdentifier.cs +++ b/crypto/src/asn1/DerObjectIdentifier.cs @@ -34,21 +34,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerObjectIdentifier GetInstance(object obj) { - if (obj == null || obj is DerObjectIdentifier) - { - return (DerObjectIdentifier)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerObjectIdentifier derObjectIdentifier) + return derObjectIdentifier; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerObjectIdentifier) - return (DerObjectIdentifier)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerObjectIdentifier converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerObjectIdentifier)Meta.Instance.FromByteArray((byte[])obj); + return (DerObjectIdentifier)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerPrintableString.cs b/crypto/src/asn1/DerPrintableString.cs index 3c44a2d52..5830afa47 100644 --- a/crypto/src/asn1/DerPrintableString.cs +++ b/crypto/src/asn1/DerPrintableString.cs @@ -30,21 +30,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerPrintableString GetInstance(object obj) { - if (obj == null || obj is DerPrintableString) - { - return (DerPrintableString)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerPrintableString derPrintableString) + return derPrintableString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerPrintableString) - return (DerPrintableString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerPrintableString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerPrintableString)Meta.Instance.FromByteArray((byte[])obj); + return (DerPrintableString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerT61String.cs b/crypto/src/asn1/DerT61String.cs index a0e4f1d22..45f57ae0a 100644 --- a/crypto/src/asn1/DerT61String.cs +++ b/crypto/src/asn1/DerT61String.cs @@ -30,21 +30,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerT61String GetInstance(object obj) { - if (obj == null || obj is DerT61String) - { - return (DerT61String)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerT61String derT61String) + return derT61String; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerT61String) - return (DerT61String)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerT61String converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerT61String)Meta.Instance.FromByteArray((byte[])obj); + return (DerT61String)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerUTF8String.cs b/crypto/src/asn1/DerUTF8String.cs index d15a19d39..9472f5082 100644 --- a/crypto/src/asn1/DerUTF8String.cs +++ b/crypto/src/asn1/DerUTF8String.cs @@ -30,21 +30,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerUtf8String GetInstance(object obj) { - if (obj == null || obj is DerUtf8String) - { - return (DerUtf8String)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerUtf8String derUtf8String) + return derUtf8String; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerUtf8String) - return (DerUtf8String)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerUtf8String converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerUtf8String)Meta.Instance.FromByteArray((byte[])obj); + return (DerUtf8String)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerUniversalString.cs b/crypto/src/asn1/DerUniversalString.cs index e4e93bd7d..1183ed1f3 100644 --- a/crypto/src/asn1/DerUniversalString.cs +++ b/crypto/src/asn1/DerUniversalString.cs @@ -32,24 +32,25 @@ namespace Org.BouncyCastle.Asn1 * * @exception ArgumentException if the object cannot be converted. */ - public static DerUniversalString GetInstance( - object obj) + public static DerUniversalString GetInstance(object obj) { - if (obj == null || obj is DerUniversalString) - { - return (DerUniversalString)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerUniversalString derUniversalString) + return derUniversalString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerUniversalString) - return (DerUniversalString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerUniversalString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerUniversalString)Meta.Instance.FromByteArray((byte[])obj); + return (DerUniversalString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerVideotexString.cs b/crypto/src/asn1/DerVideotexString.cs index a5fbe0602..636af0499 100644 --- a/crypto/src/asn1/DerVideotexString.cs +++ b/crypto/src/asn1/DerVideotexString.cs @@ -29,21 +29,23 @@ namespace Org.BouncyCastle.Asn1 */ public static DerVideotexString GetInstance(object obj) { - if (obj == null || obj is DerVideotexString) - { - return (DerVideotexString)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerVideotexString derVideotexString) + return derVideotexString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerVideotexString) - return (DerVideotexString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerVideotexString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerVideotexString)Meta.Instance.FromByteArray((byte[])obj); + return (DerVideotexString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/DerVisibleString.cs b/crypto/src/asn1/DerVisibleString.cs index 359370040..77fe54c9a 100644 --- a/crypto/src/asn1/DerVisibleString.cs +++ b/crypto/src/asn1/DerVisibleString.cs @@ -28,24 +28,25 @@ namespace Org.BouncyCastle.Asn1 * * @exception ArgumentException if the object cannot be converted. */ - public static DerVisibleString GetInstance( - object obj) + public static DerVisibleString GetInstance(object obj) { - if (obj == null || obj is DerVisibleString) - { - return (DerVisibleString)obj; - } - else if (obj is IAsn1Convertible) + if (obj == null) + return null; + + if (obj is DerVisibleString derVisibleString) + return derVisibleString; + + if (obj is IAsn1Convertible asn1Convertible) { - Asn1Object asn1Object = ((IAsn1Convertible)obj).ToAsn1Object(); - if (asn1Object is DerVisibleString) - return (DerVisibleString)asn1Object; + Asn1Object asn1Object = asn1Convertible.ToAsn1Object(); + if (asn1Object is DerVisibleString converted) + return converted; } - else if (obj is byte[]) + else if (obj is byte[] bytes) { try { - return (DerVisibleString)Meta.Instance.FromByteArray((byte[])obj); + return (DerVisibleString)Meta.Instance.FromByteArray(bytes); } catch (IOException e) { diff --git a/crypto/src/asn1/IndefiniteLengthInputStream.cs b/crypto/src/asn1/IndefiniteLengthInputStream.cs index 1c8bd9a15..e192e9e8b 100644 --- a/crypto/src/asn1/IndefiniteLengthInputStream.cs +++ b/crypto/src/asn1/IndefiniteLengthInputStream.cs @@ -57,7 +57,28 @@ namespace Org.BouncyCastle.Asn1 return numRead + 1; } - public override int ReadByte() +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + // Only use this optimisation if we aren't checking for 00 + if (_eofOn00 || buffer.Length <= 1) + return base.Read(buffer); + + if (_lookAhead < 0) + return 0; + + int numRead = _in.Read(buffer[1..]); + if (numRead <= 0) + throw new EndOfStreamException(); + + buffer[0] = (byte)_lookAhead; + _lookAhead = RequireByte(); + + return numRead + 1; + } +#endif + + public override int ReadByte() { if (_eofOn00 && _lookAhead <= 0) { diff --git a/crypto/src/asn1/cmp/CertReqTemplateContent.cs b/crypto/src/asn1/cmp/CertReqTemplateContent.cs index b229cd28b..c25c71ad1 100644 --- a/crypto/src/asn1/cmp/CertReqTemplateContent.cs +++ b/crypto/src/asn1/cmp/CertReqTemplateContent.cs @@ -9,12 +9,13 @@ namespace Org.BouncyCastle.Asn1.Cmp * GenRep: {id-it 19}, CertReqTemplateContent | < absent > * <p> * CertReqTemplateValue ::= CertReqTemplateContent - * <p> + * </p><p> * CertReqTemplateContent ::= SEQUENCE { * certTemplate CertTemplate, * keySpec Controls OPTIONAL } - * <p> + * </p><p> * Controls ::= SEQUENCE SIZE (1..MAX) OF AttributeTypeAndValue + * </p> */ public class CertReqTemplateContent : Asn1Encodable diff --git a/crypto/src/asn1/cmp/CmpObjectIdentifiers.cs b/crypto/src/asn1/cmp/CmpObjectIdentifiers.cs index fa83841a4..1b3227c47 100644 --- a/crypto/src/asn1/cmp/CmpObjectIdentifiers.cs +++ b/crypto/src/asn1/cmp/CmpObjectIdentifiers.cs @@ -234,8 +234,9 @@ namespace Org.BouncyCastle.Asn1.Cmp * 1.2.840.113549.1.9.16.1.21 * <p> * id-ct OBJECT IDENTIFIER ::= { id-smime 1 } -- content types - * <p> + * </p><p> * id-ct-encKeyWithID OBJECT IDENTIFIER ::= {id-ct 21} + * </p> */ public static readonly DerObjectIdentifier ct_encKeyWithID = new DerObjectIdentifier("1.2.840.113549.1.9.16.1.21"); diff --git a/crypto/src/asn1/cmp/CrlSource.cs b/crypto/src/asn1/cmp/CrlSource.cs index 13aaa526a..9e2526ec2 100644 --- a/crypto/src/asn1/cmp/CrlSource.cs +++ b/crypto/src/asn1/cmp/CrlSource.cs @@ -12,7 +12,7 @@ namespace Org.BouncyCastle.Asn1.Cmp * CRLSource ::= CHOICE { * dpn [0] DistributionPointName, * issuer [1] GeneralNames } - * <p> + * </p> */ public class CrlSource : Asn1Encodable, IAsn1Choice diff --git a/crypto/src/asn1/cmp/RootCaKeyUpdateContent.cs b/crypto/src/asn1/cmp/RootCaKeyUpdateContent.cs index b1eaf616d..696b08b94 100644 --- a/crypto/src/asn1/cmp/RootCaKeyUpdateContent.cs +++ b/crypto/src/asn1/cmp/RootCaKeyUpdateContent.cs @@ -7,14 +7,15 @@ namespace Org.BouncyCastle.Asn1.Cmp * GenRep: {id-it 18}, RootCaKeyUpdateContent | < absent > * <p> * RootCaCertValue ::= CMPCertificate - * <p> + * </p><p> * RootCaKeyUpdateValue ::= RootCaKeyUpdateContent - * <p> + * </p><p> * RootCaKeyUpdateContent ::= SEQUENCE { * newWithNew CMPCertificate, * newWithOld [0] CMPCertificate OPTIONAL, * oldWithNew [1] CMPCertificate OPTIONAL * } + * </p> */ public class RootCaKeyUpdateContent : Asn1Encodable diff --git a/crypto/src/asn1/cms/OtherRevocationInfoFormat.cs b/crypto/src/asn1/cms/OtherRevocationInfoFormat.cs index 78354896f..f6335cdac 100644 --- a/crypto/src/asn1/cms/OtherRevocationInfoFormat.cs +++ b/crypto/src/asn1/cms/OtherRevocationInfoFormat.cs @@ -1,6 +1,4 @@ -using System; - -namespace Org.BouncyCastle.Asn1.Cms +namespace Org.BouncyCastle.Asn1.Cms { public class OtherRevocationInfoFormat : Asn1Encodable @@ -44,8 +42,8 @@ namespace Org.BouncyCastle.Asn1.Cms */ public static OtherRevocationInfoFormat GetInstance(object obj) { - if (obj is OtherRevocationInfoFormat) - return (OtherRevocationInfoFormat)obj; + if (obj is OtherRevocationInfoFormat otherRevocationInfoFormat) + return otherRevocationInfoFormat; if (obj != null) return new OtherRevocationInfoFormat(Asn1Sequence.GetInstance(obj)); return null; diff --git a/crypto/src/asn1/cms/Time.cs b/crypto/src/asn1/cms/Time.cs index 89f1e4dae..67c73285b 100644 --- a/crypto/src/asn1/cms/Time.cs +++ b/crypto/src/asn1/cms/Time.cs @@ -35,17 +35,15 @@ namespace Org.BouncyCastle.Asn1.Cms */ public Time(DateTime date) { - string d = date.ToString("yyyyMMddHHmmss", CultureInfo.InvariantCulture) + "Z"; + DateTime d = date.ToUniversalTime(); - int year = int.Parse(d.Substring(0, 4)); - - if (year < 1950 || year > 2049) + if (d.Year < 1950 || d.Year > 2049) { time = new DerGeneralizedTime(d); } else { - time = new DerUtcTime(d.Substring(2)); + time = new DerUtcTime(d); } } diff --git a/crypto/src/asn1/cryptlib/CryptlibObjectIdentifiers.cs b/crypto/src/asn1/cryptlib/CryptlibObjectIdentifiers.cs new file mode 100644 index 000000000..e7208bab2 --- /dev/null +++ b/crypto/src/asn1/cryptlib/CryptlibObjectIdentifiers.cs @@ -0,0 +1,11 @@ +namespace Org.BouncyCastle.Asn1.Cryptlib +{ + internal class CryptlibObjectIdentifiers + { + internal static readonly DerObjectIdentifier cryptlib = new DerObjectIdentifier("1.3.6.1.4.1.3029"); + + internal static readonly DerObjectIdentifier ecc = cryptlib.Branch("1.5"); + + internal static readonly DerObjectIdentifier curvey25519 = ecc.Branch("1"); + } +} diff --git a/crypto/src/asn1/x509/KeyPurposeId.cs b/crypto/src/asn1/x509/KeyPurposeId.cs index 1a564b97a..d0b9bb7e6 100644 --- a/crypto/src/asn1/x509/KeyPurposeId.cs +++ b/crypto/src/asn1/x509/KeyPurposeId.cs @@ -1,3 +1,5 @@ +using System; + namespace Org.BouncyCastle.Asn1.X509 { /** @@ -9,30 +11,86 @@ namespace Org.BouncyCastle.Asn1.X509 public sealed class KeyPurposeID : DerObjectIdentifier { - private const string IdKP = "1.3.6.1.5.5.7.3"; + private const string id_kp = "1.3.6.1.5.5.7.3"; - private KeyPurposeID( - string id) + private KeyPurposeID(string id) : base(id) { } public static readonly KeyPurposeID AnyExtendedKeyUsage = new KeyPurposeID(X509Extensions.ExtendedKeyUsage.Id + ".0"); - public static readonly KeyPurposeID IdKPServerAuth = new KeyPurposeID(IdKP + ".1"); - public static readonly KeyPurposeID IdKPClientAuth = new KeyPurposeID(IdKP + ".2"); - public static readonly KeyPurposeID IdKPCodeSigning = new KeyPurposeID(IdKP + ".3"); - public static readonly KeyPurposeID IdKPEmailProtection = new KeyPurposeID(IdKP + ".4"); - public static readonly KeyPurposeID IdKPIpsecEndSystem = new KeyPurposeID(IdKP + ".5"); - public static readonly KeyPurposeID IdKPIpsecTunnel = new KeyPurposeID(IdKP + ".6"); - public static readonly KeyPurposeID IdKPIpsecUser = new KeyPurposeID(IdKP + ".7"); - public static readonly KeyPurposeID IdKPTimeStamping = new KeyPurposeID(IdKP + ".8"); - public static readonly KeyPurposeID IdKPOcspSigning = new KeyPurposeID(IdKP + ".9"); - - // + + public static readonly KeyPurposeID id_kp_serverAuth = new KeyPurposeID(id_kp + ".1"); + public static readonly KeyPurposeID id_kp_clientAuth = new KeyPurposeID(id_kp + ".2"); + public static readonly KeyPurposeID id_kp_codeSigning = new KeyPurposeID(id_kp + ".3"); + public static readonly KeyPurposeID id_kp_emailProtection = new KeyPurposeID(id_kp + ".4"); + public static readonly KeyPurposeID id_kp_ipsecEndSystem = new KeyPurposeID(id_kp + ".5"); + public static readonly KeyPurposeID id_kp_ipsecTunnel = new KeyPurposeID(id_kp + ".6"); + public static readonly KeyPurposeID id_kp_ipsecUser = new KeyPurposeID(id_kp + ".7"); + public static readonly KeyPurposeID id_kp_timeStamping = new KeyPurposeID(id_kp + ".8"); + public static readonly KeyPurposeID id_kp_OCSPSigning = new KeyPurposeID(id_kp + ".9"); + public static readonly KeyPurposeID id_kp_dvcs = new KeyPurposeID(id_kp + ".10"); + public static readonly KeyPurposeID id_kp_sbgpCertAAServerAuth = new KeyPurposeID(id_kp + ".11"); + public static readonly KeyPurposeID id_kp_scvp_responder = new KeyPurposeID(id_kp + ".12"); + public static readonly KeyPurposeID id_kp_eapOverPPP = new KeyPurposeID(id_kp + ".13"); + public static readonly KeyPurposeID id_kp_eapOverLAN = new KeyPurposeID(id_kp + ".14"); + public static readonly KeyPurposeID id_kp_scvpServer = new KeyPurposeID(id_kp + ".15"); + public static readonly KeyPurposeID id_kp_scvpClient = new KeyPurposeID(id_kp + ".16"); + public static readonly KeyPurposeID id_kp_ipsecIKE = new KeyPurposeID(id_kp + ".17"); + public static readonly KeyPurposeID id_kp_capwapAC = new KeyPurposeID(id_kp + ".18"); + public static readonly KeyPurposeID id_kp_capwapWTP = new KeyPurposeID(id_kp + ".19"); + + public static readonly KeyPurposeID id_kp_cmcCA = new KeyPurposeID(id_kp + ".27"); + public static readonly KeyPurposeID id_kp_cmcRA = new KeyPurposeID(id_kp + ".28"); + public static readonly KeyPurposeID id_kp_cmKGA = new KeyPurposeID(id_kp + ".32"); + + // // microsoft key purpose ids // - public static readonly KeyPurposeID IdKPSmartCardLogon = new KeyPurposeID("1.3.6.1.4.1.311.20.2.2"); + public static readonly KeyPurposeID id_kp_smartcardlogon = new KeyPurposeID("1.3.6.1.4.1.311.20.2.2"); + + public static readonly KeyPurposeID id_kp_macAddress = new KeyPurposeID("1.3.6.1.1.1.1.22"); + + /// <summary>Microsoft Server Gated Crypto (msSGC).</summary> + /// <remarks>see https://www.alvestrand.no/objectid/1.3.6.1.4.1.311.10.3.3.html</remarks> + public static readonly KeyPurposeID id_kp_msSGC = new KeyPurposeID("1.3.6.1.4.1.311.10.3.3"); + + private const string id_pkinit = "1.3.6.1.5.2.3"; + + public static readonly KeyPurposeID scSysNodeNumber = new KeyPurposeID(id_pkinit + ".0"); + public static readonly KeyPurposeID id_pkinit_authData = new KeyPurposeID(id_pkinit + ".1"); + public static readonly KeyPurposeID id_pkinit_DHKeyData = new KeyPurposeID(id_pkinit + ".2"); + public static readonly KeyPurposeID id_pkinit_rkeyData = new KeyPurposeID(id_pkinit + ".3"); + public static readonly KeyPurposeID keyPurposeClientAuth = new KeyPurposeID(id_pkinit + ".4"); + public static readonly KeyPurposeID keyPurposeKdc = new KeyPurposeID(id_pkinit + ".5"); + + /// <summary>Netscape Server Gated Crypto (nsSGC).</summary> + /// <remarks>see https://www.alvestrand.no/objectid/2.16.840.1.113730.4.1.html</remarks> + public static readonly KeyPurposeID id_kp_nsSGC = new KeyPurposeID("2.16.840.1.113730.4.1"); + + [Obsolete("Use 'id_kp_serverAuth' instead")] + public static readonly KeyPurposeID IdKPServerAuth = id_kp_serverAuth; + [Obsolete("Use 'id_kp_clientAuth' instead")] + public static readonly KeyPurposeID IdKPClientAuth = id_kp_clientAuth; + [Obsolete("Use 'id_kp_codeSigning' instead")] + public static readonly KeyPurposeID IdKPCodeSigning = id_kp_codeSigning; + [Obsolete("Use 'id_kp_emailProtection' instead")] + public static readonly KeyPurposeID IdKPEmailProtection = id_kp_emailProtection; + [Obsolete("Use 'id_kp_ipsecEndSystem' instead")] + public static readonly KeyPurposeID IdKPIpsecEndSystem = id_kp_ipsecEndSystem; + [Obsolete("Use 'id_kp_ipsecTunnel' instead")] + public static readonly KeyPurposeID IdKPIpsecTunnel = id_kp_ipsecTunnel; + [Obsolete("Use 'id_kp_ipsecUser' instead")] + public static readonly KeyPurposeID IdKPIpsecUser = id_kp_ipsecUser; + [Obsolete("Use 'id_kp_timeStamping' instead")] + public static readonly KeyPurposeID IdKPTimeStamping = id_kp_timeStamping; + [Obsolete("Use 'id_kp_OCSPSigning' instead")] + public static readonly KeyPurposeID IdKPOcspSigning = id_kp_OCSPSigning; + + [Obsolete("Use 'id_kp_smartcardlogon' instead")] + public static readonly KeyPurposeID IdKPSmartCardLogon = id_kp_smartcardlogon; - public static readonly KeyPurposeID IdKPMacAddress = new KeyPurposeID("1.3.6.1.1.1.1.22"); + [Obsolete("Use 'id_kp_macAddress' instead")] + public static readonly KeyPurposeID IdKPMacAddress = id_kp_macAddress; } } diff --git a/crypto/src/asn1/x509/Time.cs b/crypto/src/asn1/x509/Time.cs index 1a6ac15c0..8260043aa 100644 --- a/crypto/src/asn1/x509/Time.cs +++ b/crypto/src/asn1/x509/Time.cs @@ -35,17 +35,15 @@ namespace Org.BouncyCastle.Asn1.X509 */ public Time(DateTime date) { - string d = date.ToUniversalTime().ToString("yyyyMMddHHmmss", CultureInfo.InvariantCulture) + "Z"; + DateTime d = date.ToUniversalTime(); - int year = int.Parse(d.Substring(0, 4)); - - if (year < 1950 || year > 2049) + if (d.Year < 1950 || d.Year > 2049) { time = new DerGeneralizedTime(d); } else { - time = new DerUtcTime(d.Substring(2)); + time = new DerUtcTime(d); } } diff --git a/crypto/src/bcpg/ArmoredInputStream.cs b/crypto/src/bcpg/ArmoredInputStream.cs index 1c5ebd7c5..4fbb8baae 100644 --- a/crypto/src/bcpg/ArmoredInputStream.cs +++ b/crypto/src/bcpg/ArmoredInputStream.cs @@ -1,3 +1,4 @@ +using System; using System.Collections.Generic; using System.IO; using System.Text; @@ -330,6 +331,26 @@ namespace Org.BouncyCastle.Bcpg return pos; } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + /* + * TODO Currently can't return partial data when exception thrown (breaking test case), so we don't inherit + * the base class implementation. Probably the reason is that throws don't mark this instance as 'failed'. + */ + int pos = 0; + while (pos < buffer.Length) + { + int b = ReadByte(); + if (b < 0) + break; + + buffer[pos++] = (byte)b; + } + return pos; + } +#endif + public override int ReadByte() { if (start) diff --git a/crypto/src/bcpg/ArmoredOutputStream.cs b/crypto/src/bcpg/ArmoredOutputStream.cs index 7f3bcc2ef..bfed1972a 100644 --- a/crypto/src/bcpg/ArmoredOutputStream.cs +++ b/crypto/src/bcpg/ArmoredOutputStream.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.Diagnostics; using System.IO; +using System.Reflection; using Org.BouncyCastle.Utilities; using Org.BouncyCastle.Utilities.Collections; @@ -98,7 +99,15 @@ namespace Org.BouncyCastle.Bcpg private static readonly string footerStart = "-----END PGP "; private static readonly string footerTail = "-----"; - private static readonly string Version = "BCPG C# v" + typeof(ArmoredOutputStream).Assembly.GetName().Version; + private static string CreateVersion() + { + var assembly = Assembly.GetExecutingAssembly(); + var title = assembly.GetCustomAttribute<AssemblyTitleAttribute>().Title; + var version = assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>().InformationalVersion; + return title + " v" + version; + } + + private static readonly string Version = CreateVersion(); private readonly IDictionary<string, IList<string>> m_headers; diff --git a/crypto/src/bcpg/BcpgInputStream.cs b/crypto/src/bcpg/BcpgInputStream.cs index 7a19a90dd..3b6f61bbc 100644 --- a/crypto/src/bcpg/BcpgInputStream.cs +++ b/crypto/src/bcpg/BcpgInputStream.cs @@ -57,6 +57,21 @@ namespace Org.BouncyCastle.Bcpg return 1; } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + if (!next) + return m_in.Read(buffer); + + if (nextB < 0) + return 0; + + buffer[0] = (byte)nextB; + next = false; + return 1; + } +#endif + public byte[] ReadAll() { return Streams.ReadAll(this); @@ -312,9 +327,8 @@ namespace Org.BouncyCastle.Bcpg int readLen = (dataLength > count || dataLength < 0) ? count : dataLength; int len = m_in.Read(buffer, offset, readLen); if (len < 1) - { throw new EndOfStreamException("Premature end of stream in PartialInputStream"); - } + dataLength -= len; return len; } @@ -324,6 +338,29 @@ namespace Org.BouncyCastle.Bcpg return 0; } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + do + { + if (dataLength != 0) + { + int count = buffer.Length; + int readLen = (dataLength > count || dataLength < 0) ? count : dataLength; + int len = m_in.Read(buffer[..readLen]); + if (len < 1) + throw new EndOfStreamException("Premature end of stream in PartialInputStream"); + + dataLength -= len; + return len; + } + } + while (partial && ReadPartialDataLength() >= 0); + + return 0; + } +#endif + private int ReadPartialDataLength() { int l = m_in.ReadByte(); diff --git a/crypto/src/bcpg/BcpgOutputStream.cs b/crypto/src/bcpg/BcpgOutputStream.cs index fbdd75bff..690686d88 100644 --- a/crypto/src/bcpg/BcpgOutputStream.cs +++ b/crypto/src/bcpg/BcpgOutputStream.cs @@ -164,7 +164,7 @@ namespace Org.BouncyCastle.Bcpg if (partialBuffer != null) { - PartialFlush(true); + PartialFlushLast(); partialBuffer = null; } @@ -215,19 +215,26 @@ namespace Org.BouncyCastle.Bcpg } } - private void PartialFlush(bool isLast) + private void PartialFlush() { - if (isLast) - { - WriteNewPacketLength(partialOffset); - outStr.Write(partialBuffer, 0, partialOffset); - } - else - { - outStr.WriteByte((byte)(0xE0 | partialPower)); - outStr.Write(partialBuffer, 0, partialBufferLength); - } + outStr.WriteByte((byte)(0xE0 | partialPower)); + outStr.Write(partialBuffer, 0, partialBufferLength); + partialOffset = 0; + } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + private void PartialFlush(ref ReadOnlySpan<byte> buffer) + { + outStr.WriteByte((byte)(0xE0 | partialPower)); + outStr.Write(buffer[..partialBufferLength]); + buffer = buffer[partialBufferLength..]; + } +#endif + private void PartialFlushLast() + { + WriteNewPacketLength(partialOffset); + outStr.Write(partialBuffer, 0, partialOffset); partialOffset = 0; } @@ -235,40 +242,71 @@ namespace Org.BouncyCastle.Bcpg { Streams.ValidateBufferArguments(buffer, offset, count); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + PartialWrite(buffer.AsSpan(offset, count)); +#else if (partialOffset == partialBufferLength) { - PartialFlush(false); + PartialFlush(); } if (count <= (partialBufferLength - partialOffset)) { Array.Copy(buffer, offset, partialBuffer, partialOffset, count); partialOffset += count; + return; } - else + + int diff = partialBufferLength - partialOffset; + Array.Copy(buffer, offset, partialBuffer, partialOffset, diff); + offset += diff; + count -= diff; + PartialFlush(); + while (count > partialBufferLength) { - int diff = partialBufferLength - partialOffset; - Array.Copy(buffer, offset, partialBuffer, partialOffset, diff); - offset += diff; - count -= diff; - PartialFlush(false); - while (count > partialBufferLength) - { - Array.Copy(buffer, offset, partialBuffer, 0, partialBufferLength); - offset += partialBufferLength; - count -= partialBufferLength; - PartialFlush(false); - } - Array.Copy(buffer, offset, partialBuffer, 0, count); - partialOffset += count; + Array.Copy(buffer, offset, partialBuffer, 0, partialBufferLength); + offset += partialBufferLength; + count -= partialBufferLength; + PartialFlush(); } + Array.Copy(buffer, offset, partialBuffer, 0, count); + partialOffset = count; +#endif } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + private void PartialWrite(ReadOnlySpan<byte> buffer) + { + if (partialOffset == partialBufferLength) + { + PartialFlush(); + } + + if (buffer.Length <= (partialBufferLength - partialOffset)) + { + buffer.CopyTo(partialBuffer.AsSpan(partialOffset)); + partialOffset += buffer.Length; + return; + } + + int diff = partialBufferLength - partialOffset; + buffer[..diff].CopyTo(partialBuffer.AsSpan(partialOffset)); + buffer = buffer[diff..]; + PartialFlush(); + while (buffer.Length > partialBufferLength) + { + PartialFlush(ref buffer); + } + buffer.CopyTo(partialBuffer); + partialOffset = buffer.Length; + } +#endif + private void PartialWriteByte(byte value) { if (partialOffset == partialBufferLength) { - PartialFlush(false); + PartialFlush(); } partialBuffer[partialOffset++] = value; @@ -286,6 +324,20 @@ namespace Org.BouncyCastle.Bcpg } } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + if (partialBuffer != null) + { + PartialWrite(buffer); + } + else + { + outStr.Write(buffer); + } + } +#endif + public override void WriteByte(byte value) { if (partialBuffer != null) @@ -370,7 +422,7 @@ namespace Org.BouncyCastle.Bcpg { if (partialBuffer != null) { - PartialFlush(true); + PartialFlushLast(); Array.Clear(partialBuffer, 0, partialBuffer.Length); partialBuffer = null; } diff --git a/crypto/src/bcpg/ECDHPublicBCPGKey.cs b/crypto/src/bcpg/ECDHPublicBCPGKey.cs index 5b6d9460e..e43100d3a 100644 --- a/crypto/src/bcpg/ECDHPublicBCPGKey.cs +++ b/crypto/src/bcpg/ECDHPublicBCPGKey.cs @@ -1,6 +1,7 @@ using System; using Org.BouncyCastle.Asn1; +using Org.BouncyCastle.Math; using Org.BouncyCastle.Math.EC; namespace Org.BouncyCastle.Bcpg @@ -51,6 +52,21 @@ namespace Org.BouncyCastle.Bcpg VerifySymmetricKeyAlgorithm(); } + public ECDHPublicBcpgKey( + DerObjectIdentifier oid, + BigInteger point, + HashAlgorithmTag hashAlgorithm, + SymmetricKeyAlgorithmTag symmetricKeyAlgorithm) + : base(oid, point) + { + reserved = 1; + hashFunctionId = hashAlgorithm; + symAlgorithmId = symmetricKeyAlgorithm; + + VerifyHashAlgorithm(); + VerifySymmetricKeyAlgorithm(); + } + public virtual byte Reserved { get { return reserved; } diff --git a/crypto/src/bcpg/ECSecretBCPGKey.cs b/crypto/src/bcpg/ECSecretBCPGKey.cs index 22e0a3473..eef632263 100644 --- a/crypto/src/bcpg/ECSecretBCPGKey.cs +++ b/crypto/src/bcpg/ECSecretBCPGKey.cs @@ -1,6 +1,5 @@ using System; -using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Math; namespace Org.BouncyCastle.Bcpg @@ -9,18 +8,18 @@ namespace Org.BouncyCastle.Bcpg public class ECSecretBcpgKey : BcpgObject, IBcpgKey { - internal MPInteger x; + internal readonly MPInteger m_x; public ECSecretBcpgKey( BcpgInputStream bcpgIn) { - this.x = new MPInteger(bcpgIn); + m_x = new MPInteger(bcpgIn); } public ECSecretBcpgKey( BigInteger x) { - this.x = new MPInteger(x); + m_x = new MPInteger(x); } /// <summary>The format, as a string, always "PGP".</summary> @@ -45,12 +44,12 @@ namespace Org.BouncyCastle.Bcpg public override void Encode( BcpgOutputStream bcpgOut) { - bcpgOut.WriteObject(x); + bcpgOut.WriteObject(m_x); } public virtual BigInteger X { - get { return x.Value; } + get { return m_x.Value; } } } } diff --git a/crypto/src/bcpg/EdDsaPublicBcpgKey.cs b/crypto/src/bcpg/EdDsaPublicBcpgKey.cs new file mode 100644 index 000000000..f3250b746 --- /dev/null +++ b/crypto/src/bcpg/EdDsaPublicBcpgKey.cs @@ -0,0 +1,25 @@ +using Org.BouncyCastle.Asn1; +using Org.BouncyCastle.Math; +using Org.BouncyCastle.Math.EC; + +namespace Org.BouncyCastle.Bcpg +{ + public sealed class EdDsaPublicBcpgKey + : ECPublicBcpgKey + { + internal EdDsaPublicBcpgKey(BcpgInputStream bcpgIn) + : base(bcpgIn) + { + } + + public EdDsaPublicBcpgKey(DerObjectIdentifier oid, ECPoint point) + : base(oid, point) + { + } + + public EdDsaPublicBcpgKey(DerObjectIdentifier oid, BigInteger encodedPoint) + : base(oid, encodedPoint) + { + } + } +} diff --git a/crypto/src/bcpg/EdSecretBcpgKey.cs b/crypto/src/bcpg/EdSecretBcpgKey.cs new file mode 100644 index 000000000..5b53f558d --- /dev/null +++ b/crypto/src/bcpg/EdSecretBcpgKey.cs @@ -0,0 +1,43 @@ +using System; + +using Org.BouncyCastle.Math; + +namespace Org.BouncyCastle.Bcpg +{ + public sealed class EdSecretBcpgKey + : BcpgObject, IBcpgKey + { + internal readonly MPInteger m_x; + + public EdSecretBcpgKey(BcpgInputStream bcpgIn) + { + m_x = new MPInteger(bcpgIn); + } + + public EdSecretBcpgKey(BigInteger x) + { + m_x = new MPInteger(x); + } + + public string Format => "PGP"; + + public override byte[] GetEncoded() + { + try + { + return base.GetEncoded(); + } + catch (Exception) + { + return null; + } + } + + public override void Encode(BcpgOutputStream bcpgOut) + { + bcpgOut.WriteObject(m_x); + } + + public BigInteger X => m_x.Value; + } +} diff --git a/crypto/src/bcpg/PublicKeyPacket.cs b/crypto/src/bcpg/PublicKeyPacket.cs index bbed941dc..40c696a37 100644 --- a/crypto/src/bcpg/PublicKeyPacket.cs +++ b/crypto/src/bcpg/PublicKeyPacket.cs @@ -28,30 +28,33 @@ namespace Org.BouncyCastle.Bcpg validDays = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte(); } - algorithm = (PublicKeyAlgorithmTag) bcpgIn.ReadByte(); + algorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); - switch ((PublicKeyAlgorithmTag) algorithm) + switch (algorithm) { - case PublicKeyAlgorithmTag.RsaEncrypt: - case PublicKeyAlgorithmTag.RsaGeneral: - case PublicKeyAlgorithmTag.RsaSign: - key = new RsaPublicBcpgKey(bcpgIn); - break; - case PublicKeyAlgorithmTag.Dsa: - key = new DsaPublicBcpgKey(bcpgIn); - break; - case PublicKeyAlgorithmTag.ElGamalEncrypt: - case PublicKeyAlgorithmTag.ElGamalGeneral: - key = new ElGamalPublicBcpgKey(bcpgIn); - break; - case PublicKeyAlgorithmTag.ECDH: - key = new ECDHPublicBcpgKey(bcpgIn); - break; - case PublicKeyAlgorithmTag.ECDsa: - key = new ECDsaPublicBcpgKey(bcpgIn); - break; - default: - throw new IOException("unknown PGP public key algorithm encountered"); + case PublicKeyAlgorithmTag.RsaEncrypt: + case PublicKeyAlgorithmTag.RsaGeneral: + case PublicKeyAlgorithmTag.RsaSign: + key = new RsaPublicBcpgKey(bcpgIn); + break; + case PublicKeyAlgorithmTag.Dsa: + key = new DsaPublicBcpgKey(bcpgIn); + break; + case PublicKeyAlgorithmTag.ElGamalEncrypt: + case PublicKeyAlgorithmTag.ElGamalGeneral: + key = new ElGamalPublicBcpgKey(bcpgIn); + break; + case PublicKeyAlgorithmTag.ECDH: + key = new ECDHPublicBcpgKey(bcpgIn); + break; + case PublicKeyAlgorithmTag.ECDsa: + key = new ECDsaPublicBcpgKey(bcpgIn); + break; + case PublicKeyAlgorithmTag.EdDsa: + key = new EdDsaPublicBcpgKey(bcpgIn); + break; + default: + throw new IOException("unknown PGP public key algorithm encountered"); } } diff --git a/crypto/src/bcpg/SignaturePacket.cs b/crypto/src/bcpg/SignaturePacket.cs index dd9cc78e3..a0e8588b3 100644 --- a/crypto/src/bcpg/SignaturePacket.cs +++ b/crypto/src/bcpg/SignaturePacket.cs @@ -10,7 +10,7 @@ namespace Org.BouncyCastle.Bcpg { /// <remarks>Generic signature packet.</remarks> public class SignaturePacket - : ContainedPacket //, PublicKeyAlgorithmTag + : ContainedPacket { private int version; private int signatureType; @@ -128,41 +128,38 @@ namespace Org.BouncyCastle.Bcpg case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaSign: MPInteger v = new MPInteger(bcpgIn); - signature = new MPInteger[]{ v }; + signature = new MPInteger[1]{ v }; break; case PublicKeyAlgorithmTag.Dsa: MPInteger r = new MPInteger(bcpgIn); MPInteger s = new MPInteger(bcpgIn); - signature = new MPInteger[]{ r, s }; + signature = new MPInteger[2]{ r, s }; break; case PublicKeyAlgorithmTag.ElGamalEncrypt: // yep, this really does happen sometimes. case PublicKeyAlgorithmTag.ElGamalGeneral: MPInteger p = new MPInteger(bcpgIn); MPInteger g = new MPInteger(bcpgIn); MPInteger y = new MPInteger(bcpgIn); - signature = new MPInteger[]{ p, g, y }; + signature = new MPInteger[3]{ p, g, y }; break; case PublicKeyAlgorithmTag.ECDsa: + case PublicKeyAlgorithmTag.EdDsa: MPInteger ecR = new MPInteger(bcpgIn); MPInteger ecS = new MPInteger(bcpgIn); - signature = new MPInteger[]{ ecR, ecS }; + signature = new MPInteger[2]{ ecR, ecS }; break; default: - if (keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11) - { - signature = null; - MemoryStream bOut = new MemoryStream(); - int ch; - while ((ch = bcpgIn.ReadByte()) >= 0) - { - bOut.WriteByte((byte) ch); - } - signatureEncoding = bOut.ToArray(); - } - else + if (keyAlgorithm < PublicKeyAlgorithmTag.Experimental_1 || keyAlgorithm > PublicKeyAlgorithmTag.Experimental_11) + throw new IOException("unknown signature key algorithm: " + keyAlgorithm); + + signature = null; + MemoryStream bOut = new MemoryStream(); + int ch; + while ((ch = bcpgIn.ReadByte()) >= 0) { - throw new IOException("unknown signature key algorithm: " + keyAlgorithm); + bOut.WriteByte((byte) ch); } + signatureEncoding = bOut.ToArray(); break; } } @@ -268,56 +265,53 @@ namespace Org.BouncyCastle.Bcpg */ public byte[] GetSignatureTrailer() { - byte[] trailer = null; - if (version == 3) { - trailer = new byte[5]; - - long time = creationTime / 1000L; + long time = creationTime / 1000L; + byte[] trailer = new byte[5]; trailer[0] = (byte)signatureType; trailer[1] = (byte)(time >> 24); trailer[2] = (byte)(time >> 16); - trailer[3] = (byte)(time >> 8); - trailer[4] = (byte)(time); + trailer[3] = (byte)(time >> 8); + trailer[4] = (byte)(time ); + return trailer; } - else - { - MemoryStream sOut = new MemoryStream(); - sOut.WriteByte((byte)this.Version); - sOut.WriteByte((byte)this.SignatureType); - sOut.WriteByte((byte)this.KeyAlgorithm); - sOut.WriteByte((byte)this.HashAlgorithm); + MemoryStream sOut = new MemoryStream(); - MemoryStream hOut = new MemoryStream(); - SignatureSubpacket[] hashed = this.GetHashedSubPackets(); + sOut.WriteByte((byte)Version); + sOut.WriteByte((byte)SignatureType); + sOut.WriteByte((byte)KeyAlgorithm); + sOut.WriteByte((byte)HashAlgorithm); - for (int i = 0; i != hashed.Length; i++) - { - hashed[i].Encode(hOut); - } - - byte[] data = hOut.ToArray(); + // Mark position an reserve two bytes for length + long lengthPosition = sOut.Position; + sOut.WriteByte(0x00); + sOut.WriteByte(0x00); - sOut.WriteByte((byte)(data.Length >> 8)); - sOut.WriteByte((byte)data.Length); - sOut.Write(data, 0, data.Length); + SignatureSubpacket[] hashed = GetHashedSubPackets(); + for (int i = 0; i != hashed.Length; i++) + { + hashed[i].Encode(sOut); + } - byte[] hData = sOut.ToArray(); + ushort dataLength = Convert.ToUInt16(sOut.Position - lengthPosition - 2); + uint hDataLength = Convert.ToUInt32(sOut.Position); - sOut.WriteByte((byte)this.Version); - sOut.WriteByte((byte)0xff); - sOut.WriteByte((byte)(hData.Length>> 24)); - sOut.WriteByte((byte)(hData.Length >> 16)); - sOut.WriteByte((byte)(hData.Length >> 8)); - sOut.WriteByte((byte)(hData.Length)); + sOut.WriteByte((byte)Version); + sOut.WriteByte(0xff); + sOut.WriteByte((byte)(hDataLength >> 24)); + sOut.WriteByte((byte)(hDataLength >> 16)); + sOut.WriteByte((byte)(hDataLength >> 8)); + sOut.WriteByte((byte)(hDataLength )); - trailer = sOut.ToArray(); - } + // Reset position and fill in length + sOut.Position = lengthPosition; + sOut.WriteByte((byte)(dataLength >> 8)); + sOut.WriteByte((byte)(dataLength )); - return trailer; + return sOut.ToArray(); } public PublicKeyAlgorithmTag KeyAlgorithm diff --git a/crypto/src/cms/CMSAuthenticatedDataGenerator.cs b/crypto/src/cms/CMSAuthenticatedDataGenerator.cs index 6c68bccd1..f6827157c 100644 --- a/crypto/src/cms/CMSAuthenticatedDataGenerator.cs +++ b/crypto/src/cms/CMSAuthenticatedDataGenerator.cs @@ -62,9 +62,7 @@ namespace Org.BouncyCastle.Cms Asn1Encodable asn1Params = GenerateAsn1Parameters(macOid, encKeyBytes); - ICipherParameters cipherParameters; - macAlgId = GetAlgorithmIdentifier( - macOid, encKey, asn1Params, out cipherParameters); + macAlgId = GetAlgorithmIdentifier(macOid, encKey, asn1Params, out var cipherParameters); IMac mac = MacUtilities.GetMac(macOid); // TODO Confirm no ParametersWithRandom needed @@ -72,7 +70,7 @@ namespace Org.BouncyCastle.Cms // mac.Init(cipherParameters); mac.Init(encKey); - MemoryStream bOut = new MemoryStream(); + var bOut = new MemoryStream(); Stream mOut = new TeeOutputStream(bOut, new MacSink(mac)); content.Write(mOut); @@ -97,7 +95,7 @@ namespace Org.BouncyCastle.Cms throw new CmsException("exception decoding algorithm parameters.", e); } - Asn1EncodableVector recipientInfos = new Asn1EncodableVector(); + var recipientInfos = new Asn1EncodableVector(); foreach (RecipientInfoGenerator rig in recipientInfoGenerators) { @@ -115,11 +113,11 @@ namespace Org.BouncyCastle.Cms } } - ContentInfo eci = new ContentInfo(CmsObjectIdentifiers.Data, encContent); - - ContentInfo contentInfo = new ContentInfo( - CmsObjectIdentifiers.AuthenticatedData, - new AuthenticatedData(null, new DerSet(recipientInfos), macAlgId, null, eci, null, macResult, null)); + var eci = new ContentInfo(CmsObjectIdentifiers.Data, encContent); + + var contentInfo = new ContentInfo( + CmsObjectIdentifiers.AuthenticatedData, + new AuthenticatedData(null, new DerSet(recipientInfos), macAlgId, null, eci, null, macResult, null)); return new CmsAuthenticatedData(contentInfo); } diff --git a/crypto/src/cms/CMSAuthenticatedDataStreamGenerator.cs b/crypto/src/cms/CMSAuthenticatedDataStreamGenerator.cs index b2c5cac28..6348431a2 100644 --- a/crypto/src/cms/CMSAuthenticatedDataStreamGenerator.cs +++ b/crypto/src/cms/CMSAuthenticatedDataStreamGenerator.cs @@ -237,7 +237,14 @@ namespace Org.BouncyCastle.Cms macStream.Write(buffer, offset, count); } - public override void WriteByte(byte value) +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + macStream.Write(buffer); + } +#endif + + public override void WriteByte(byte value) { macStream.WriteByte(value); } diff --git a/crypto/src/cms/CMSCompressedDataStreamGenerator.cs b/crypto/src/cms/CMSCompressedDataStreamGenerator.cs index 1594500cd..3669c0b3a 100644 --- a/crypto/src/cms/CMSCompressedDataStreamGenerator.cs +++ b/crypto/src/cms/CMSCompressedDataStreamGenerator.cs @@ -4,6 +4,7 @@ using System.IO; using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Asn1.Cms; using Org.BouncyCastle.Asn1.X509; +using Org.BouncyCastle.Crypto.IO; using Org.BouncyCastle.Utilities; using Org.BouncyCastle.Utilities.IO; @@ -118,7 +119,14 @@ namespace Org.BouncyCastle.Cms _out.Write(buffer, offset, count); } - public override void WriteByte(byte value) +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + _out.Write(buffer); + } +#endif + + public override void WriteByte(byte value) { _out.WriteByte(value); } diff --git a/crypto/src/cms/CMSEnvelopedDataStreamGenerator.cs b/crypto/src/cms/CMSEnvelopedDataStreamGenerator.cs index 6a362e13f..ad356a208 100644 --- a/crypto/src/cms/CMSEnvelopedDataStreamGenerator.cs +++ b/crypto/src/cms/CMSEnvelopedDataStreamGenerator.cs @@ -240,7 +240,14 @@ namespace Org.BouncyCastle.Cms _out.Write(buffer, offset, count); } - public override void WriteByte(byte value) +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + _out.Write(buffer); + } +#endif + + public override void WriteByte(byte value) { _out.WriteByte(value); } diff --git a/crypto/src/cms/CMSProcessableFile.cs b/crypto/src/cms/CMSProcessableFile.cs index 9444f885d..255c8432f 100644 --- a/crypto/src/cms/CMSProcessableFile.cs +++ b/crypto/src/cms/CMSProcessableFile.cs @@ -1,5 +1,3 @@ -#if !PORTABLE || DOTNET -using System; using System.IO; using Org.BouncyCastle.Utilities; @@ -42,4 +40,3 @@ namespace Org.BouncyCastle.Cms } } } -#endif diff --git a/crypto/src/cms/CMSSignedData.cs b/crypto/src/cms/CMSSignedData.cs index 3d4ce05a6..773e15be0 100644 --- a/crypto/src/cms/CMSSignedData.cs +++ b/crypto/src/cms/CMSSignedData.cs @@ -204,6 +204,11 @@ namespace Org.BouncyCastle.Cms return Helper.GetCrls(signedData.CRLs); } + public IStore<Asn1Encodable> GetOtherRevInfos(DerObjectIdentifier otherRevInfoFormat) + { + return Helper.GetOtherRevInfos(signedData.CRLs, otherRevInfoFormat); + } + /// <summary> /// Return the <c>DerObjectIdentifier</c> associated with the encapsulated /// content info structure carried in the signed data. @@ -308,7 +313,7 @@ namespace Org.BouncyCastle.Cms return cms; } - /** + /** * Replace the certificate and CRL information associated with this * CmsSignedData object with the new one passed in. * @@ -318,48 +323,69 @@ namespace Org.BouncyCastle.Cms * @return a new signed data object. * @exception CmsException if there is an error processing the stores */ - public static CmsSignedData ReplaceCertificatesAndCrls(CmsSignedData signedData, IStore<X509Certificate> x509Certs, - IStore<X509Crl> x509Crls, IStore<X509V2AttributeCertificate> x509AttrCerts) + public static CmsSignedData ReplaceCertificatesAndCrls(CmsSignedData signedData, + IStore<X509Certificate> x509Certs, IStore<X509Crl> x509Crls) { - // - // copy - // - CmsSignedData cms = new CmsSignedData(signedData); + return ReplaceCertificatesAndRevocations(signedData, x509Certs, x509Crls, null, null); + } + + public static CmsSignedData ReplaceCertificatesAndCrls(CmsSignedData signedData, + IStore<X509Certificate> x509Certs, IStore<X509Crl> x509Crls, + IStore<X509V2AttributeCertificate> x509AttrCerts) + { + return ReplaceCertificatesAndRevocations(signedData, x509Certs, x509Crls, x509AttrCerts, null); + } + + public static CmsSignedData ReplaceCertificatesAndRevocations(CmsSignedData signedData, + IStore<X509Certificate> x509Certs, IStore<X509Crl> x509Crls, + IStore<X509V2AttributeCertificate> x509AttrCerts, IStore<OtherRevocationInfoFormat> otherRevocationInfos) + { + // + // copy + // + CmsSignedData cms = new CmsSignedData(signedData); // // replace the certs and crls in the SignedData object // Asn1Set certSet = null; - Asn1Set crlSet = null; + Asn1Set revocationSet = null; if (x509Certs != null || x509AttrCerts != null) { - var certs = new List<Asn1Encodable>(); - + var certificates = new List<Asn1Encodable>(); if (x509Certs != null) { - certs.AddRange(CmsUtilities.GetCertificatesFromStore(x509Certs)); + certificates.AddRange(CmsUtilities.GetCertificatesFromStore(x509Certs)); } if (x509AttrCerts != null) { - certs.AddRange(CmsUtilities.GetAttributeCertificatesFromStore(x509AttrCerts)); + certificates.AddRange(CmsUtilities.GetAttributeCertificatesFromStore(x509AttrCerts)); } - Asn1Set berSet = CmsUtilities.CreateBerSetFromList(certs); + Asn1Set berSet = CmsUtilities.CreateBerSetFromList(certificates); if (berSet.Count > 0) { certSet = berSet; } } - if (x509Crls != null) + if (x509Crls != null || otherRevocationInfos != null) { - var crls = CmsUtilities.GetCrlsFromStore(x509Crls); + var revocations = new List<Asn1Encodable>(); + if (x509Crls != null) + { + revocations.AddRange(CmsUtilities.GetCrlsFromStore(x509Crls)); + } + if (otherRevocationInfos != null) + { + revocations.AddRange(CmsUtilities.GetOtherRevocationInfosFromStore(otherRevocationInfos)); + } - Asn1Set berSet = CmsUtilities.CreateBerSetFromList(crls); + Asn1Set berSet = CmsUtilities.CreateBerSetFromList(revocations); if (berSet.Count > 0) { - crlSet = berSet; + revocationSet = berSet; } } @@ -371,7 +397,7 @@ namespace Org.BouncyCastle.Cms old.DigestAlgorithms, old.EncapContentInfo, certSet, - crlSet, + revocationSet, old.SignerInfos); // diff --git a/crypto/src/cms/CMSSignedDataParser.cs b/crypto/src/cms/CMSSignedDataParser.cs index 78e29e6a3..c5dc795a8 100644 --- a/crypto/src/cms/CMSSignedDataParser.cs +++ b/crypto/src/cms/CMSSignedDataParser.cs @@ -275,7 +275,14 @@ namespace Org.BouncyCastle.Cms return Helper.GetCrls(_crlSet); } - private void PopulateCertCrlSets() + public IStore<Asn1Encodable> GetOtherRevInfos(DerObjectIdentifier otherRevInfoFormat) + { + PopulateCertCrlSets(); + + return Helper.GetOtherRevInfos(_crlSet, otherRevInfoFormat); + } + + private void PopulateCertCrlSets() { if (_isCertCrlParsed) return; diff --git a/crypto/src/cms/CMSSignedDataStreamGenerator.cs b/crypto/src/cms/CMSSignedDataStreamGenerator.cs index f934b9259..3f2da5f7e 100644 --- a/crypto/src/cms/CMSSignedDataStreamGenerator.cs +++ b/crypto/src/cms/CMSSignedDataStreamGenerator.cs @@ -783,7 +783,14 @@ namespace Org.BouncyCastle.Cms _out.Write(buffer, offset, count); } - public override void WriteByte(byte value) +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + _out.Write(buffer); + } +#endif + + public override void WriteByte(byte value) { _out.WriteByte(value); } diff --git a/crypto/src/cms/CMSSignedGenerator.cs b/crypto/src/cms/CMSSignedGenerator.cs index c16f6e83c..fd40de469 100644 --- a/crypto/src/cms/CMSSignedGenerator.cs +++ b/crypto/src/cms/CMSSignedGenerator.cs @@ -129,12 +129,10 @@ namespace Org.BouncyCastle.Cms m_algorithms["GOST3411WITHGOST3410-2001"] = CryptoProObjectIdentifiers.GostR3411x94WithGostR3410x2001; m_algorithms["GOST3411WITHECGOST3410-2012-256"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256; m_algorithms["GOST3411WITHECGOST3410-2012-512"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512; - m_algorithms["GOST3411WITHGOST3410-2012-256"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256; - m_algorithms["GOST3411WITHGOST3410-2012-512"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512; + m_algorithms["GOST3411-2012-256WITHECGOST3410"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256; m_algorithms["GOST3411-2012-256WITHECGOST3410-2012-256"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256; + m_algorithms["GOST3411-2012-512WITHECGOST3410"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512; m_algorithms["GOST3411-2012-512WITHECGOST3410-2012-512"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512; - m_algorithms["GOST3411-2012-256WITHGOST3410-2012-256"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256; - m_algorithms["GOST3411-2012-512WITHGOST3410-2012-512"] = RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512; m_algorithms["SHA1WITHPLAIN-ECDSA"] = BsiObjectIdentifiers.ecdsa_plain_SHA1; m_algorithms["SHA224WITHPLAIN-ECDSA"] = BsiObjectIdentifiers.ecdsa_plain_SHA224; m_algorithms["SHA256WITHPLAIN-ECDSA"] = BsiObjectIdentifiers.ecdsa_plain_SHA256; @@ -508,6 +506,8 @@ namespace Org.BouncyCastle.Cms public static readonly string EncryptionRsaPss = PkcsObjectIdentifiers.IdRsassaPss.Id; public static readonly string EncryptionGost3410 = CryptoProObjectIdentifiers.GostR3410x94.Id; public static readonly string EncryptionECGost3410 = CryptoProObjectIdentifiers.GostR3410x2001.Id; + public static readonly string EncryptionECGost3410_2012_256 = RosstandartObjectIdentifiers.id_tc26_gost_3410_12_256.Id; + public static readonly string EncryptionECGost3410_2012_512 = RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512.Id; internal List<Asn1Encodable> _certs = new List<Asn1Encodable>(); internal List<Asn1Encodable> _crls = new List<Asn1Encodable>(); @@ -588,6 +588,23 @@ namespace Org.BouncyCastle.Cms _crls.AddRange(CmsUtilities.GetCrlsFromStore(crlStore)); } + public void AddOtherRevocationInfo(OtherRevocationInfoFormat otherRevocationInfo) + { + CmsUtilities.ValidateOtherRevocationInfo(otherRevocationInfo); + _crls.Add(new DerTaggedObject(false, 1, otherRevocationInfo)); + } + + public void AddOtherRevocationInfos(IStore<OtherRevocationInfoFormat> otherRevocationInfoStore) + { + _crls.AddRange(CmsUtilities.GetOtherRevocationInfosFromStore(otherRevocationInfoStore)); + } + + public void AddOtherRevocationInfos(DerObjectIdentifier otherRevInfoFormat, + IStore<Asn1Encodable> otherRevInfoStore) + { + _crls.AddRange(CmsUtilities.GetOtherRevocationInfosFromStore(otherRevInfoStore, otherRevInfoFormat)); + } + /** * Add a store of precalculated signers to the generator. * diff --git a/crypto/src/cms/CMSSignedHelper.cs b/crypto/src/cms/CMSSignedHelper.cs index 8df9e8f01..9db39549b 100644 --- a/crypto/src/cms/CMSSignedHelper.cs +++ b/crypto/src/cms/CMSSignedHelper.cs @@ -2,8 +2,10 @@ using System; using System.Collections.Generic; using Org.BouncyCastle.Asn1; +using Org.BouncyCastle.Asn1.Cms; using Org.BouncyCastle.Asn1.CryptoPro; using Org.BouncyCastle.Asn1.Eac; +using Org.BouncyCastle.Asn1.Esf; using Org.BouncyCastle.Asn1.Nist; using Org.BouncyCastle.Asn1.Oiw; using Org.BouncyCastle.Asn1.Pkcs; @@ -85,8 +87,8 @@ namespace Org.BouncyCastle.Cms AddEntries(EacObjectIdentifiers.id_TA_RSA_PSS_SHA_256, "SHA256", "RSAandMGF1"); AddEntries(CryptoProObjectIdentifiers.GostR3411x94WithGostR3410x94, "GOST3411", "GOST3410"); AddEntries(CryptoProObjectIdentifiers.GostR3411x94WithGostR3410x2001, "GOST3411", "ECGOST3410"); - AddEntries(RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256, "GOST3411_2012_256", "ECGOST3410"); - AddEntries(RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512, "GOST3411_2012_512", "ECGOST3410"); + AddEntries(RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256, "GOST3411-2012-256", "ECGOST3410"); + AddEntries(RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512, "GOST3411-2012-512", "ECGOST3410"); m_encryptionAlgs.Add(X9ObjectIdentifiers.IdDsa.Id, "DSA"); m_encryptionAlgs.Add(PkcsObjectIdentifiers.RsaEncryption.Id, "RSA"); @@ -119,8 +121,8 @@ namespace Org.BouncyCastle.Cms m_digestAlgs.Add(TeleTrusTObjectIdentifiers.RipeMD256.Id, "RIPEMD256"); m_digestAlgs.Add(CryptoProObjectIdentifiers.GostR3411.Id, "GOST3411"); m_digestAlgs.Add("1.3.6.1.4.1.5849.1.2.1", "GOST3411"); - m_digestAlgs.Add(RosstandartObjectIdentifiers.id_tc26_gost_3411_12_256.Id, "GOST3411_2012_256"); - m_digestAlgs.Add(RosstandartObjectIdentifiers.id_tc26_gost_3411_12_512.Id, "GOST3411_2012_512"); + m_digestAlgs.Add(RosstandartObjectIdentifiers.id_tc26_gost_3411_12_256.Id, "GOST3411-2012-256"); + m_digestAlgs.Add(RosstandartObjectIdentifiers.id_tc26_gost_3411_12_512.Id, "GOST3411-2012-512"); m_digestAliases.Add("SHA1", new string[]{ "SHA-1" }); m_digestAliases.Add("SHA224", new string[]{ "SHA-224" }); @@ -261,6 +263,22 @@ namespace Org.BouncyCastle.Cms { encOID = CmsSignedGenerator.EncryptionECGost3410; } + else if (ecPrivKey.Parameters is ECGost3410Parameters ecGost3410Parameters) + { + var digestParamSet = ecGost3410Parameters.DigestParamSet; + if (digestParamSet.Equals(RosstandartObjectIdentifiers.id_tc26_gost_3411_12_256)) + { + encOID = CmsSignedGenerator.EncryptionECGost3410_2012_256; + } + else if (digestParamSet.Equals(RosstandartObjectIdentifiers.id_tc26_gost_3411_12_512)) + { + encOID = CmsSignedGenerator.EncryptionECGost3410_2012_512; + } + else + { + throw new ArgumentException("can't determine GOST3410 algorithm"); + } + } else { // TODO Should we insist on algName being one of "EC" or "ECDSA", as Java does? @@ -332,5 +350,29 @@ namespace Org.BouncyCastle.Cms } return CollectionUtilities.CreateStore(contents); } + + internal IStore<Asn1Encodable> GetOtherRevInfos(Asn1Set crlSet, DerObjectIdentifier otherRevInfoFormat) + { + var contents = new List<Asn1Encodable>(); + if (crlSet != null && otherRevInfoFormat != null) + { + foreach (Asn1Encodable ae in crlSet) + { + if (ae != null && ae.ToAsn1Object() is Asn1TaggedObject taggedObject) + { + if (taggedObject.HasContextTag(1)) + { + var otherRevocationInfo = OtherRevocationInfoFormat.GetInstance(taggedObject, false); + + if (otherRevInfoFormat.Equals(otherRevocationInfo.InfoFormat)) + { + contents.Add(otherRevocationInfo.Info); + } + } + } + } + } + return CollectionUtilities.CreateStore(contents); + } } } diff --git a/crypto/src/cms/CMSTypedStream.cs b/crypto/src/cms/CMSTypedStream.cs index d4ca62256..7a66f0c74 100644 --- a/crypto/src/cms/CMSTypedStream.cs +++ b/crypto/src/cms/CMSTypedStream.cs @@ -59,13 +59,6 @@ namespace Org.BouncyCastle.Cms { } -#if NETCOREAPP2_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER - public override void CopyTo(Stream destination, int bufferSize) - { - s.CopyTo(destination, bufferSize); - } -#endif - public override int Read(byte[] buf, int off, int len) { return Streams.ReadFully(s, buf, off, len); diff --git a/crypto/src/cms/CMSUtils.cs b/crypto/src/cms/CMSUtils.cs index 6800c1d2a..1a1577c4e 100644 --- a/crypto/src/cms/CMSUtils.cs +++ b/crypto/src/cms/CMSUtils.cs @@ -4,6 +4,7 @@ using System.IO; using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Asn1.Cms; +using Org.BouncyCastle.Asn1.Ocsp; using Org.BouncyCastle.Asn1.X509; using Org.BouncyCastle.Utilities.Collections; using Org.BouncyCastle.Utilities.IO; @@ -112,12 +113,46 @@ namespace Org.BouncyCastle.Cms foreach (var crl in crlStore.EnumerateMatches(null)) { result.Add(crl.CertificateList); - } + } } return result; } - internal static Asn1Set CreateBerSetFromList(IEnumerable<Asn1Encodable> elements) + internal static List<Asn1TaggedObject> GetOtherRevocationInfosFromStore( + IStore<OtherRevocationInfoFormat> otherRevocationInfoStore) + { + var result = new List<Asn1TaggedObject>(); + if (otherRevocationInfoStore != null) + { + foreach (var otherRevocationInfo in otherRevocationInfoStore.EnumerateMatches(null)) + { + ValidateOtherRevocationInfo(otherRevocationInfo); + + result.Add(new DerTaggedObject(false, 1, otherRevocationInfo)); + } + } + return result; + } + + internal static List<DerTaggedObject> GetOtherRevocationInfosFromStore(IStore<Asn1Encodable> otherRevInfoStore, + DerObjectIdentifier otherRevInfoFormat) + { + var result = new List<DerTaggedObject>(); + if (otherRevInfoStore != null && otherRevInfoFormat != null) + { + foreach (var otherRevInfo in otherRevInfoStore.EnumerateMatches(null)) + { + var otherRevocationInfo = new OtherRevocationInfoFormat(otherRevInfoFormat, otherRevInfo); + + ValidateOtherRevocationInfo(otherRevocationInfo); + + result.Add(new DerTaggedObject(false, 1, otherRevocationInfo)); + } + } + return result; + } + + internal static Asn1Set CreateBerSetFromList(IEnumerable<Asn1Encodable> elements) { Asn1EncodableVector v = new Asn1EncodableVector(); @@ -157,5 +192,16 @@ namespace Org.BouncyCastle.Cms TbsCertificateStructure tbsCert = GetTbsCertificateStructure(cert); return new IssuerAndSerialNumber(tbsCert.Issuer, tbsCert.SerialNumber.Value); } - } + + internal static void ValidateOtherRevocationInfo(OtherRevocationInfoFormat otherRevocationInfo) + { + if (CmsObjectIdentifiers.id_ri_ocsp_response.Equals(otherRevocationInfo.InfoFormat)) + { + OcspResponse ocspResponse = OcspResponse.GetInstance(otherRevocationInfo.Info); + + if (OcspResponseStatus.Successful != ocspResponse.ResponseStatus.IntValueExact) + throw new ArgumentException("cannot add unsuccessful OCSP response to CMS SignedData"); + } + } + } } diff --git a/crypto/src/cms/OriginatorInfoGenerator.cs b/crypto/src/cms/OriginatorInfoGenerator.cs index d7d24dcc4..ec6d2d8d8 100644 --- a/crypto/src/cms/OriginatorInfoGenerator.cs +++ b/crypto/src/cms/OriginatorInfoGenerator.cs @@ -1,9 +1,7 @@ -using System; -using System.Collections.Generic; +using System.Collections.Generic; using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Asn1.Cms; -using Org.BouncyCastle.Asn1.X509; using Org.BouncyCastle.Utilities.Collections; using Org.BouncyCastle.X509; @@ -11,30 +9,63 @@ namespace Org.BouncyCastle.Cms { public class OriginatorInfoGenerator { - private readonly List<X509CertificateStructure> origCerts; - private readonly List<CertificateList> origCrls; + private readonly List<Asn1Encodable> origCerts; + private readonly List<Asn1Encodable> origCrls; public OriginatorInfoGenerator(X509Certificate origCert) { - this.origCerts = new List<X509CertificateStructure>(); + this.origCerts = new List<Asn1Encodable>{ origCert.CertificateStructure }; this.origCrls = null; - origCerts.Add(origCert.CertificateStructure); } - public OriginatorInfoGenerator(IStore<X509Certificate> origCerts) - : this(origCerts, null) + public OriginatorInfoGenerator(IStore<X509Certificate> x509Certs) + : this(x509Certs, null, null, null) { } - public OriginatorInfoGenerator(IStore<X509Certificate> origCerts, IStore<X509Crl> origCrls) + public OriginatorInfoGenerator(IStore<X509Certificate> x509Certs, IStore<X509Crl> x509Crls) + : this(x509Certs, x509Crls, null, null) { - this.origCerts = CmsUtilities.GetCertificatesFromStore(origCerts); - this.origCrls = origCrls == null ? null : CmsUtilities.GetCrlsFromStore(origCrls); } - + + public OriginatorInfoGenerator(IStore<X509Certificate> x509Certs, IStore<X509Crl> x509Crls, + IStore<X509V2AttributeCertificate> x509AttrCerts, IStore<OtherRevocationInfoFormat> otherRevocationInfos) + { + List<Asn1Encodable> certificates = null; + if (x509Certs != null || x509AttrCerts != null) + { + certificates = new List<Asn1Encodable>(); + if (x509Certs != null) + { + certificates.AddRange(CmsUtilities.GetCertificatesFromStore(x509Certs)); + } + if (x509AttrCerts != null) + { + certificates.AddRange(CmsUtilities.GetAttributeCertificatesFromStore(x509AttrCerts)); + } + } + + List<Asn1Encodable> revocations = null; + if (x509Crls != null || otherRevocationInfos != null) + { + revocations = new List<Asn1Encodable>(); + if (x509Crls != null) + { + revocations.AddRange(CmsUtilities.GetCrlsFromStore(x509Crls)); + } + if (otherRevocationInfos != null) + { + revocations.AddRange(CmsUtilities.GetOtherRevocationInfosFromStore(otherRevocationInfos)); + } + } + + this.origCerts = certificates; + this.origCrls = revocations; + } + public virtual OriginatorInfo Generate() { - Asn1Set certSet = CmsUtilities.CreateDerSetFromList(origCerts); + Asn1Set certSet = origCerts == null ? null : CmsUtilities.CreateDerSetFromList(origCerts); Asn1Set crlSet = origCrls == null ? null : CmsUtilities.CreateDerSetFromList(origCrls); return new OriginatorInfo(certSet, crlSet); } diff --git a/crypto/src/crypto/engines/Grain128AEADEngine.cs b/crypto/src/crypto/engines/Grain128AEADEngine.cs index 174d010f3..c05cb0115 100644 --- a/crypto/src/crypto/engines/Grain128AEADEngine.cs +++ b/crypto/src/crypto/engines/Grain128AEADEngine.cs @@ -43,7 +43,7 @@ namespace Org.BouncyCastle.Crypto.Engines */ public void Init(bool forEncryption, ICipherParameters param) { - /** + /* * Grain encryption and decryption is completely symmetrical, so the * 'forEncryption' is irrelevant. */ @@ -62,7 +62,7 @@ namespace Org.BouncyCastle.Crypto.Engines if (keyBytes.Length != 16) throw new ArgumentException("Grain-128AEAD key must be 128 bits long"); - /** + /* * Initialize variables. */ workingIV = new byte[keyBytes.Length]; @@ -238,7 +238,7 @@ namespace Org.BouncyCastle.Crypto.Engines workingKey = keyBytes; workingIV = ivBytes; - /** + /* * Load NFSR and LFSR */ Pack.LE_To_UInt32(workingKey, 0, nfsr); diff --git a/crypto/src/crypto/engines/Salsa20Engine.cs b/crypto/src/crypto/engines/Salsa20Engine.cs index 1ccf68902..7c2c1e1f9 100644 --- a/crypto/src/crypto/engines/Salsa20Engine.cs +++ b/crypto/src/crypto/engines/Salsa20Engine.cs @@ -252,11 +252,12 @@ namespace Org.BouncyCastle.Crypto.Engines Pack.UInt32_To_LE(x, output, 0); } - internal static void SalsaCore(int rounds, uint[] input, uint[] x) +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + internal static void SalsaCore(int rounds, ReadOnlySpan<uint> input, Span<uint> output) { - if (input.Length != 16) + if (input.Length < 16) throw new ArgumentException(); - if (x.Length != 16) + if (output.Length < 16) throw new ArgumentException(); if (rounds % 2 != 0) throw new ArgumentException("Number of rounds must be even"); @@ -266,7 +267,7 @@ namespace Org.BouncyCastle.Crypto.Engines { Vector128<uint> b0, b1, b2, b3; { - var I = MemoryMarshal.AsBytes(input.AsSpan(0, 16)); + var I = MemoryMarshal.AsBytes(input[..16]); var t0 = MemoryMarshal.Read<Vector128<short>>(I[0x00..0x10]); var t1 = MemoryMarshal.Read<Vector128<short>>(I[0x10..0x20]); var t2 = MemoryMarshal.Read<Vector128<short>>(I[0x20..0x30]); @@ -315,7 +316,7 @@ namespace Org.BouncyCastle.Crypto.Engines var v2 = Sse41.Blend(u0, u2, 0x0F); var v3 = Sse41.Blend(u1, u3, 0x3C); - var X = MemoryMarshal.AsBytes(x.AsSpan(0, 16)); + var X = MemoryMarshal.AsBytes(output[..16]); MemoryMarshal.Write(X[0x00..0x10], ref v0); MemoryMarshal.Write(X[0x10..0x20], ref v1); MemoryMarshal.Write(X[0x20..0x30], ref v2); @@ -355,23 +356,81 @@ namespace Org.BouncyCastle.Crypto.Engines QuarterRound(ref x15, ref x12, ref x13, ref x14); } - x[ 0] = x00 + input[ 0]; - x[ 1] = x01 + input[ 1]; - x[ 2] = x02 + input[ 2]; - x[ 3] = x03 + input[ 3]; - x[ 4] = x04 + input[ 4]; - x[ 5] = x05 + input[ 5]; - x[ 6] = x06 + input[ 6]; - x[ 7] = x07 + input[ 7]; - x[ 8] = x08 + input[ 8]; - x[ 9] = x09 + input[ 9]; - x[10] = x10 + input[10]; - x[11] = x11 + input[11]; - x[12] = x12 + input[12]; - x[13] = x13 + input[13]; - x[14] = x14 + input[14]; - x[15] = x15 + input[15]; + output[ 0] = x00 + input[ 0]; + output[ 1] = x01 + input[ 1]; + output[ 2] = x02 + input[ 2]; + output[ 3] = x03 + input[ 3]; + output[ 4] = x04 + input[ 4]; + output[ 5] = x05 + input[ 5]; + output[ 6] = x06 + input[ 6]; + output[ 7] = x07 + input[ 7]; + output[ 8] = x08 + input[ 8]; + output[ 9] = x09 + input[ 9]; + output[10] = x10 + input[10]; + output[11] = x11 + input[11]; + output[12] = x12 + input[12]; + output[13] = x13 + input[13]; + output[14] = x14 + input[14]; + output[15] = x15 + input[15]; } +#else + internal static void SalsaCore(int rounds, uint[] input, uint[] output) + { + if (input.Length < 16) + throw new ArgumentException(); + if (output.Length < 16) + throw new ArgumentException(); + if (rounds % 2 != 0) + throw new ArgumentException("Number of rounds must be even"); + + uint x00 = input[ 0]; + uint x01 = input[ 1]; + uint x02 = input[ 2]; + uint x03 = input[ 3]; + uint x04 = input[ 4]; + uint x05 = input[ 5]; + uint x06 = input[ 6]; + uint x07 = input[ 7]; + uint x08 = input[ 8]; + uint x09 = input[ 9]; + uint x10 = input[10]; + uint x11 = input[11]; + uint x12 = input[12]; + uint x13 = input[13]; + uint x14 = input[14]; + uint x15 = input[15]; + + for (int i = rounds; i > 0; i -= 2) + { + QuarterRound(ref x00, ref x04, ref x08, ref x12); + QuarterRound(ref x05, ref x09, ref x13, ref x01); + QuarterRound(ref x10, ref x14, ref x02, ref x06); + QuarterRound(ref x15, ref x03, ref x07, ref x11); + + QuarterRound(ref x00, ref x01, ref x02, ref x03); + QuarterRound(ref x05, ref x06, ref x07, ref x04); + QuarterRound(ref x10, ref x11, ref x08, ref x09); + QuarterRound(ref x15, ref x12, ref x13, ref x14); + } + + output[ 0] = x00 + input[ 0]; + output[ 1] = x01 + input[ 1]; + output[ 2] = x02 + input[ 2]; + output[ 3] = x03 + input[ 3]; + output[ 4] = x04 + input[ 4]; + output[ 5] = x05 + input[ 5]; + output[ 6] = x06 + input[ 6]; + output[ 7] = x07 + input[ 7]; + output[ 8] = x08 + input[ 8]; + output[ 9] = x09 + input[ 9]; + output[10] = x10 + input[10]; + output[11] = x11 + input[11]; + output[12] = x12 + input[12]; + output[13] = x13 + input[13]; + output[14] = x14 + input[14]; + output[15] = x15 + input[15]; + } +#endif internal void ResetLimitCounter() { diff --git a/crypto/src/crypto/engines/SerpentEngine.cs b/crypto/src/crypto/engines/SerpentEngine.cs index bec459215..47f714a64 100644 --- a/crypto/src/crypto/engines/SerpentEngine.cs +++ b/crypto/src/crypto/engines/SerpentEngine.cs @@ -26,7 +26,7 @@ namespace Org.BouncyCastle.Crypto.Engines * @param key The user-key bytes (multiples of 4) to use. * @exception ArgumentException */ - protected override int[] MakeWorkingKey(byte[] key) + internal override int[] MakeWorkingKey(byte[] key) { // // pad key to 256 bits @@ -151,7 +151,7 @@ namespace Org.BouncyCastle.Crypto.Engines } #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER - protected override void EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output) + internal override void EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output) { X0 = (int)Pack.LE_To_UInt32(input); X1 = (int)Pack.LE_To_UInt32(input[4..]); @@ -197,7 +197,7 @@ namespace Org.BouncyCastle.Crypto.Engines Pack.UInt32_To_LE((uint)(wKey[131] ^ X3), output[12..]); } - protected override void DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output) + internal override void DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output) { X0 = wKey[128] ^ (int)Pack.LE_To_UInt32(input); X1 = wKey[129] ^ (int)Pack.LE_To_UInt32(input[4..]); @@ -274,7 +274,7 @@ namespace Org.BouncyCastle.Crypto.Engines Pack.UInt32_To_LE((uint)(X3 ^ wKey[3]), output[12..]); } #else - protected override void EncryptBlock(byte[] input, int inOff, byte[] output, int outOff) + internal override void EncryptBlock(byte[] input, int inOff, byte[] output, int outOff) { X0 = (int)Pack.LE_To_UInt32(input, inOff); X1 = (int)Pack.LE_To_UInt32(input, inOff + 4); @@ -320,7 +320,7 @@ namespace Org.BouncyCastle.Crypto.Engines Pack.UInt32_To_LE((uint)(wKey[131] ^ X3), output, outOff + 12); } - protected override void DecryptBlock(byte[] input, int inOff, byte[] output, int outOff) + internal override void DecryptBlock(byte[] input, int inOff, byte[] output, int outOff) { X0 = wKey[128] ^ (int)Pack.LE_To_UInt32(input, inOff); X1 = wKey[129] ^ (int)Pack.LE_To_UInt32(input, inOff + 4); diff --git a/crypto/src/crypto/engines/SerpentEngineBase.cs b/crypto/src/crypto/engines/SerpentEngineBase.cs index 0ce3a0e4f..44020f06f 100644 --- a/crypto/src/crypto/engines/SerpentEngineBase.cs +++ b/crypto/src/crypto/engines/SerpentEngineBase.cs @@ -18,7 +18,7 @@ namespace Org.BouncyCastle.Crypto.Engines protected int X0, X1, X2, X3; // registers - protected SerpentEngineBase() + internal SerpentEngineBase() { } @@ -474,14 +474,14 @@ namespace Org.BouncyCastle.Crypto.Engines X0 = Integers.RotateRight(x0, 13); } - protected abstract int[] MakeWorkingKey(byte[] key); + internal abstract int[] MakeWorkingKey(byte[] key); #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER - protected abstract void EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output); - protected abstract void DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output); + internal abstract void EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output); + internal abstract void DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output); #else - protected abstract void EncryptBlock(byte[] input, int inOff, byte[] output, int outOff); - protected abstract void DecryptBlock(byte[] input, int inOff, byte[] output, int outOff); + internal abstract void EncryptBlock(byte[] input, int inOff, byte[] output, int outOff); + internal abstract void DecryptBlock(byte[] input, int inOff, byte[] output, int outOff); #endif } } diff --git a/crypto/src/crypto/engines/SkipjackEngine.cs b/crypto/src/crypto/engines/SkipjackEngine.cs index 4a5355963..c6a3e458e 100644 --- a/crypto/src/crypto/engines/SkipjackEngine.cs +++ b/crypto/src/crypto/engines/SkipjackEngine.cs @@ -8,12 +8,12 @@ namespace Org.BouncyCastle.Crypto.Engines /** * a class that provides a basic SKIPJACK engine. */ - public class SkipjackEngine + public sealed class SkipjackEngine : IBlockCipher { - const int BLOCK_SIZE = 8; + private const int BLOCK_SIZE = 8; - static readonly short [] ftable = + private static readonly short[] ftable = { 0xa3, 0xd7, 0x09, 0x83, 0xf8, 0x48, 0xf6, 0xf4, 0xb3, 0x21, 0x15, 0x78, 0x99, 0xb1, 0xaf, 0xf9, 0xe7, 0x2d, 0x4d, 0x8a, 0xce, 0x4c, 0xca, 0x2e, 0x52, 0x95, 0xd9, 0x1e, 0x4e, 0x38, 0x44, 0x28, @@ -44,14 +44,12 @@ namespace Org.BouncyCastle.Crypto.Engines * @exception ArgumentException if the parameters argument is * inappropriate. */ - public virtual void Init( - bool forEncryption, - ICipherParameters parameters) + public void Init(bool forEncryption, ICipherParameters parameters) { - if (!(parameters is KeyParameter)) + if (!(parameters is KeyParameter keyParameter)) throw new ArgumentException("invalid parameter passed to SKIPJACK init - " + Platform.GetTypeName(parameters)); - byte[] keyBytes = ((KeyParameter)parameters).GetKey(); + byte[] keyBytes = keyParameter.GetKey(); this.encrypting = forEncryption; this.key0 = new int[32]; @@ -63,26 +61,26 @@ namespace Org.BouncyCastle.Crypto.Engines // expand the key to 128 bytes in 4 parts (saving us a modulo, multiply // and an addition). // - for (int i = 0; i < 32; i ++) + for (int i = 0; i < 32; i++) { - key0[i] = keyBytes[(i * 4) % 10] & 0xff; - key1[i] = keyBytes[(i * 4 + 1) % 10] & 0xff; - key2[i] = keyBytes[(i * 4 + 2) % 10] & 0xff; - key3[i] = keyBytes[(i * 4 + 3) % 10] & 0xff; + key0[i] = keyBytes[(i * 4 + 0) % 10]; + key1[i] = keyBytes[(i * 4 + 1) % 10]; + key2[i] = keyBytes[(i * 4 + 2) % 10]; + key3[i] = keyBytes[(i * 4 + 3) % 10]; } } - public virtual string AlgorithmName + public string AlgorithmName { get { return "SKIPJACK"; } } - public virtual int GetBlockSize() + public int GetBlockSize() { return BLOCK_SIZE; } - public virtual int ProcessBlock(byte[] input, int inOff, byte[] output, int outOff) + public int ProcessBlock(byte[] input, int inOff, byte[] output, int outOff) { if (key1 == null) throw new InvalidOperationException("SKIPJACK engine not initialised"); @@ -114,7 +112,7 @@ namespace Org.BouncyCastle.Crypto.Engines } #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER - public virtual int ProcessBlock(ReadOnlySpan<byte> input, Span<byte> output) + public int ProcessBlock(ReadOnlySpan<byte> input, Span<byte> output) { if (key1 == null) throw new InvalidOperationException("SKIPJACK engine not initialised"); @@ -156,7 +154,7 @@ namespace Org.BouncyCastle.Crypto.Engines } #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER - public virtual int EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output) + private int EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output) { int w1 = (input[0] << 8) + (input[1] & 0xff); int w2 = (input[2] << 8) + (input[3] & 0xff); @@ -200,7 +198,7 @@ namespace Org.BouncyCastle.Crypto.Engines return BLOCK_SIZE; } - public virtual int DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output) + private int DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output) { int w2 = (input[0] << 8) + (input[1] & 0xff); int w1 = (input[2] << 8) + (input[3] & 0xff); @@ -245,7 +243,7 @@ namespace Org.BouncyCastle.Crypto.Engines } #else - public virtual int EncryptBlock(byte[] input, int inOff, byte[] outBytes, int outOff) + private int EncryptBlock(byte[] input, int inOff, byte[] outBytes, int outOff) { int w1 = (input[inOff + 0] << 8) + (input[inOff + 1] & 0xff); int w2 = (input[inOff + 2] << 8) + (input[inOff + 3] & 0xff); @@ -289,7 +287,7 @@ namespace Org.BouncyCastle.Crypto.Engines return BLOCK_SIZE; } - public virtual int DecryptBlock(byte[] input, int inOff, byte[] outBytes, int outOff) + private int DecryptBlock(byte[] input, int inOff, byte[] outBytes, int outOff) { int w2 = (input[inOff + 0] << 8) + (input[inOff + 1] & 0xff); int w1 = (input[inOff + 2] << 8) + (input[inOff + 3] & 0xff); diff --git a/crypto/src/crypto/engines/TnepresEngine.cs b/crypto/src/crypto/engines/TnepresEngine.cs index 50f5a58c4..7751e20bc 100644 --- a/crypto/src/crypto/engines/TnepresEngine.cs +++ b/crypto/src/crypto/engines/TnepresEngine.cs @@ -33,7 +33,7 @@ namespace Org.BouncyCastle.Crypto.Engines * @param key The user-key bytes (multiples of 4) to use. * @exception ArgumentException */ - protected override int[] MakeWorkingKey(byte[] key) + internal override int[] MakeWorkingKey(byte[] key) { // // pad key to 256 bits @@ -158,7 +158,7 @@ namespace Org.BouncyCastle.Crypto.Engines } #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER - protected override void EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output) + internal override void EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output) { X3 = (int)Pack.BE_To_UInt32(input); X2 = (int)Pack.BE_To_UInt32(input[4..]); @@ -204,7 +204,7 @@ namespace Org.BouncyCastle.Crypto.Engines Pack.UInt32_To_BE((uint)(wKey[128] ^ X0), output[12..]); } - protected override void DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output) + internal override void DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output) { X3 = wKey[131] ^ (int)Pack.BE_To_UInt32(input); X2 = wKey[130] ^ (int)Pack.BE_To_UInt32(input[4..]); @@ -281,7 +281,7 @@ namespace Org.BouncyCastle.Crypto.Engines Pack.UInt32_To_BE((uint)(X0 ^ wKey[0]), output[12..]); } #else - protected override void EncryptBlock(byte[] input, int inOff, byte[] output, int outOff) + internal override void EncryptBlock(byte[] input, int inOff, byte[] output, int outOff) { X3 = (int)Pack.BE_To_UInt32(input, inOff); X2 = (int)Pack.BE_To_UInt32(input, inOff + 4); @@ -327,7 +327,7 @@ namespace Org.BouncyCastle.Crypto.Engines Pack.UInt32_To_BE((uint)(wKey[128] ^ X0), output, outOff + 12); } - protected override void DecryptBlock(byte[] input, int inOff, byte[] output, int outOff) + internal override void DecryptBlock(byte[] input, int inOff, byte[] output, int outOff) { X3 = wKey[131] ^ (int)Pack.BE_To_UInt32(input, inOff); X2 = wKey[130] ^ (int)Pack.BE_To_UInt32(input, inOff + 4); diff --git a/crypto/src/crypto/generators/HKdfBytesGenerator.cs b/crypto/src/crypto/generators/HkdfBytesGenerator.cs index 43cd66525..43cd66525 100644 --- a/crypto/src/crypto/generators/HKdfBytesGenerator.cs +++ b/crypto/src/crypto/generators/HkdfBytesGenerator.cs diff --git a/crypto/src/crypto/generators/SCrypt.cs b/crypto/src/crypto/generators/SCrypt.cs index 1a8d4a003..fef842be2 100644 --- a/crypto/src/crypto/generators/SCrypt.cs +++ b/crypto/src/crypto/generators/SCrypt.cs @@ -102,7 +102,76 @@ namespace Org.BouncyCastle.Crypto.Generators return key.GetKey(); } - private static void SMix(uint[] B, int BOff, int N, int d, int r) +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + private static void SMix(uint[] B, int BOff, int N, int d, int r) + { + int powN = Integers.NumberOfTrailingZeros(N); + int blocksPerChunk = N >> d; + int chunkCount = 1 << d, chunkMask = blocksPerChunk - 1, chunkPow = powN - d; + + int BCount = r * 32; + + uint[] blockY = new uint[BCount]; + + uint[][] VV = new uint[chunkCount][]; + + try + { + var X = B.AsSpan(BOff, BCount); + + for (int c = 0; c < chunkCount; ++c) + { + uint[] V = new uint[blocksPerChunk * BCount]; + VV[c] = V; + + Nat.Copy(BCount, X, V); + int off = 0; + for (int i = 1; i < blocksPerChunk; ++i) + { + BlockMix(V.AsSpan(off, BCount), V.AsSpan(off + BCount)); + off += BCount; + } + BlockMix(V.AsSpan()[^BCount..], X); + } + + uint mask = (uint)N - 1; + for (int i = 0; i < N; ++i) + { + int j = (int)(X[BCount - 16] & mask); + uint[] V = VV[j >> chunkPow]; + int VOff = (j & chunkMask) * BCount; + Nat.Xor(BCount, V.AsSpan(VOff), X, blockY); + BlockMix(blockY, X); + } + } + finally + { + ClearAll(VV); + Clear(blockY); + } + } + + private static void BlockMix(Span<uint> B, Span<uint> Y) + { + int BCount = B.Length; + int half = BCount >> 1; + var y1 = B[^16..]; + + for (int pos = 0; pos < BCount; pos += 32) + { + var b0 = B[pos..]; + var y0 = Y[(pos >> 1)..]; + Nat512.Xor(y1, b0, y0); + Salsa20Engine.SalsaCore(8, y0, y0); + + var b1 = b0[16..]; + y1 = y0[half..]; + Nat512.Xor(y0, b1, y1); + Salsa20Engine.SalsaCore(8, y1, y1); + } + } +#else + private static void SMix(uint[] B, int BOff, int N, int d, int r) { int powN = Integers.NumberOfTrailingZeros(N); int blocksPerChunk = N >> d; @@ -111,7 +180,6 @@ namespace Org.BouncyCastle.Crypto.Generators int BCount = r * 32; uint[] blockX1 = new uint[16]; - uint[] blockX2 = new uint[16]; uint[] blockY = new uint[BCount]; uint[] X = new uint[BCount]; @@ -131,10 +199,10 @@ namespace Org.BouncyCastle.Crypto.Generators { Array.Copy(X, 0, V, off, BCount); off += BCount; - BlockMix(X, blockX1, blockX2, blockY, r); + BlockMix(X, blockX1, blockY, r); Array.Copy(blockY, 0, V, off, BCount); off += BCount; - BlockMix(blockY, blockX1, blockX2, X, r); + BlockMix(blockY, blockX1, X, r); } } @@ -146,7 +214,7 @@ namespace Org.BouncyCastle.Crypto.Generators int VOff = (j & chunkMask) * BCount; Nat.Xor(BCount, V, VOff, X, 0, blockY, 0); - BlockMix(blockY, blockX1, blockX2, X, r); + BlockMix(blockY, blockX1, X, r); } Array.Copy(X, 0, B, BOff, BCount); @@ -154,29 +222,30 @@ namespace Org.BouncyCastle.Crypto.Generators finally { ClearAll(VV); - ClearAll(X, blockX1, blockX2, blockY); + ClearAll(X, blockX1, blockY); } } - private static void BlockMix(uint[] B, uint[] X1, uint[] X2, uint[] Y, int r) + private static void BlockMix(uint[] B, uint[] X1, uint[] Y, int r) { - Array.Copy(B, B.Length - 16, X1, 0, 16); + Array.Copy(B, B.Length - 16, X1, 0, 16); - int BOff = 0, YOff = 0, halfLen = B.Length >> 1; + int BOff = 0, YOff = 0, halfLen = B.Length >> 1; - for (int i = 2 * r; i > 0; --i) - { - Nat512.Xor(X1, 0, B, BOff, X2, 0); + for (int i = 2 * r; i > 0; --i) + { + Nat512.XorTo(B, BOff, X1, 0); - Salsa20Engine.SalsaCore(8, X2, X1); - Array.Copy(X1, 0, Y, YOff, 16); + Salsa20Engine.SalsaCore(8, X1, X1); + Array.Copy(X1, 0, Y, YOff, 16); - YOff = halfLen + BOff - YOff; - BOff += 16; - } - } + YOff = halfLen + BOff - YOff; + BOff += 16; + } + } +#endif - private static void Clear(Array array) + private static void Clear(Array array) { if (array != null) { diff --git a/crypto/src/crypto/modes/CfbBlockCipher.cs b/crypto/src/crypto/modes/CfbBlockCipher.cs index abcdca959..7bce9843f 100644 --- a/crypto/src/crypto/modes/CfbBlockCipher.cs +++ b/crypto/src/crypto/modes/CfbBlockCipher.cs @@ -129,7 +129,7 @@ namespace Org.BouncyCastle.Crypto.Modes #endif #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER - public int EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output) + private int EncryptBlock(ReadOnlySpan<byte> input, Span<byte> output) { Check.DataLength(input, blockSize, "input buffer too short"); Check.OutputLength(output, blockSize, "output buffer too short"); @@ -150,7 +150,7 @@ namespace Org.BouncyCastle.Crypto.Modes return blockSize; } - public int DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output) + private int DecryptBlock(ReadOnlySpan<byte> input, Span<byte> output) { Check.DataLength(input, blockSize, "input buffer too short"); Check.OutputLength(output, blockSize, "output buffer too short"); @@ -171,7 +171,7 @@ namespace Org.BouncyCastle.Crypto.Modes return blockSize; } #else - public int EncryptBlock(byte[] input, int inOff, byte[] outBytes, int outOff) + private int EncryptBlock(byte[] input, int inOff, byte[] outBytes, int outOff) { Check.DataLength(input, inOff, blockSize, "input buffer too short"); Check.OutputLength(outBytes, outOff, blockSize, "output buffer too short"); @@ -192,7 +192,7 @@ namespace Org.BouncyCastle.Crypto.Modes return blockSize; } - public int DecryptBlock(byte[] input, int inOff, byte[] outBytes, int outOff) + private int DecryptBlock(byte[] input, int inOff, byte[] outBytes, int outOff) { Check.DataLength(input, inOff, blockSize, "input buffer too short"); Check.OutputLength(outBytes, outOff, blockSize, "output buffer too short"); diff --git a/crypto/src/crypto/modes/ChaCha20Poly1305.cs b/crypto/src/crypto/modes/ChaCha20Poly1305.cs index 299387cdf..2fce81e22 100644 --- a/crypto/src/crypto/modes/ChaCha20Poly1305.cs +++ b/crypto/src/crypto/modes/ChaCha20Poly1305.cs @@ -763,6 +763,18 @@ namespace Org.BouncyCastle.Crypto.Modes private void InitMac() { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + Span<byte> firstBlock = stackalloc byte[64]; + try + { + mChacha20.ProcessBytes(firstBlock, firstBlock); + mPoly1305.Init(new KeyParameter(firstBlock[..32])); + } + finally + { + firstBlock.Fill(0x00); + } +#else byte[] firstBlock = new byte[64]; try { @@ -773,6 +785,7 @@ namespace Org.BouncyCastle.Crypto.Modes { Array.Clear(firstBlock, 0, 64); } +#endif } private void PadMac(ulong count) diff --git a/crypto/src/crypto/modes/OCBBlockCipher.cs b/crypto/src/crypto/modes/OCBBlockCipher.cs index 8cc701cca..e67b4e9af 100644 --- a/crypto/src/crypto/modes/OCBBlockCipher.cs +++ b/crypto/src/crypto/modes/OCBBlockCipher.cs @@ -13,7 +13,7 @@ namespace Org.BouncyCastle.Crypto.Modes /// <para>https://mailarchive.ietf.org/arch/msg/cfrg/qLTveWOdTJcLn4HP3ev-vrj05Vg/</para> /// Text reproduced below: /// <para> - /// Phillip Rogaway<rogaway@cs.ucdavis.edu&rt; Sat, 27 February 2021 02:46 UTC + /// Phillip Rogaway<rogaway@cs.ucdavis.edu> Sat, 27 February 2021 02:46 UTC /// /// I can confirm that I have abandoned all OCB patents and placed into the public domain all OCB-related IP of /// mine. While I have been telling people this for quite some time, I don't think I ever made a proper announcement diff --git a/crypto/src/crypto/operators/Asn1Signature.cs b/crypto/src/crypto/operators/Asn1Signature.cs index db2d0759e..ea8d28771 100644 --- a/crypto/src/crypto/operators/Asn1Signature.cs +++ b/crypto/src/crypto/operators/Asn1Signature.cs @@ -6,6 +6,7 @@ using Org.BouncyCastle.Asn1.CryptoPro; using Org.BouncyCastle.Asn1.Nist; using Org.BouncyCastle.Asn1.Oiw; using Org.BouncyCastle.Asn1.Pkcs; +using Org.BouncyCastle.Asn1.Rosstandart; using Org.BouncyCastle.Asn1.TeleTrust; using Org.BouncyCastle.Asn1.X509; using Org.BouncyCastle.Asn1.X9; @@ -92,12 +93,16 @@ namespace Org.BouncyCastle.Crypto.Operators m_algorithms.Add("GOST3411WITHECGOST3410", CryptoProObjectIdentifiers.GostR3411x94WithGostR3410x2001); m_algorithms.Add("GOST3411WITHECGOST3410-2001", CryptoProObjectIdentifiers.GostR3411x94WithGostR3410x2001); m_algorithms.Add("GOST3411WITHGOST3410-2001", CryptoProObjectIdentifiers.GostR3411x94WithGostR3410x2001); - - // - // According to RFC 3279, the ASN.1 encoding SHALL (id-dsa-with-sha1) or MUST (ecdsa-with-SHA*) omit the parameters field. - // The parameters field SHALL be NULL for RSA based signature algorithms. - // - noParams.Add(X9ObjectIdentifiers.ECDsaWithSha1); + m_algorithms.Add("GOST3411-2012-256WITHECGOST3410", RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256); + m_algorithms.Add("GOST3411-2012-256WITHECGOST3410-2012-256", RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256); + m_algorithms.Add("GOST3411-2012-512WITHECGOST3410", RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512); + m_algorithms.Add("GOST3411-2012-512WITHECGOST3410-2012-512", RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512); + + // + // According to RFC 3279, the ASN.1 encoding SHALL (id-dsa-with-sha1) or MUST (ecdsa-with-SHA*) omit the parameters field. + // The parameters field SHALL be NULL for RSA based signature algorithms. + // + noParams.Add(X9ObjectIdentifiers.ECDsaWithSha1); noParams.Add(X9ObjectIdentifiers.ECDsaWithSha224); noParams.Add(X9ObjectIdentifiers.ECDsaWithSha256); noParams.Add(X9ObjectIdentifiers.ECDsaWithSha384); @@ -189,6 +194,14 @@ namespace Org.BouncyCastle.Crypto.Operators { return "GOST3411"; } + else if (RosstandartObjectIdentifiers.id_tc26_gost_3411_12_256.Equals(digestAlgOID)) + { + return "GOST3411-2012-256"; + } + else if (RosstandartObjectIdentifiers.id_tc26_gost_3411_12_512.Equals(digestAlgOID)) + { + return "GOST3411-2012-512"; + } else { return digestAlgOID.Id; diff --git a/crypto/src/crypto/parameters/HKdfParameters.cs b/crypto/src/crypto/parameters/HkdfParameters.cs index 6d1465e4c..6d1465e4c 100644 --- a/crypto/src/crypto/parameters/HKdfParameters.cs +++ b/crypto/src/crypto/parameters/HkdfParameters.cs diff --git a/crypto/src/crypto/prng/CryptoApiRandomGenerator.cs b/crypto/src/crypto/prng/CryptoApiRandomGenerator.cs index 44a9c261f..dcd3baa1c 100644 --- a/crypto/src/crypto/prng/CryptoApiRandomGenerator.cs +++ b/crypto/src/crypto/prng/CryptoApiRandomGenerator.cs @@ -7,7 +7,7 @@ namespace Org.BouncyCastle.Crypto.Prng /// Uses RandomNumberGenerator.Create() to get randomness generator /// </summary> public sealed class CryptoApiRandomGenerator - : IRandomGenerator + : IRandomGenerator, IDisposable { private readonly RandomNumberGenerator m_randomNumberGenerator; @@ -18,7 +18,8 @@ namespace Org.BouncyCastle.Crypto.Prng public CryptoApiRandomGenerator(RandomNumberGenerator randomNumberGenerator) { - m_randomNumberGenerator = randomNumberGenerator; + m_randomNumberGenerator = randomNumberGenerator ?? + throw new ArgumentNullException(nameof(randomNumberGenerator)); } #region IRandomGenerator Members @@ -76,5 +77,14 @@ namespace Org.BouncyCastle.Crypto.Prng #endif #endregion + + #region IDisposable Members + + public void Dispose() + { + m_randomNumberGenerator.Dispose(); + } + + #endregion } } diff --git a/crypto/src/math/ec/ECFieldElement.cs b/crypto/src/math/ec/ECFieldElement.cs index 330708088..3afc843cd 100644 --- a/crypto/src/math/ec/ECFieldElement.cs +++ b/crypto/src/math/ec/ECFieldElement.cs @@ -785,9 +785,9 @@ namespace Org.BouncyCastle.Math.EC LongArray ab = ax.Multiply(bx, m, ks); LongArray xy = xx.Multiply(yx, m, ks); - if (ab == ax || ab == bx) + if (LongArray.AreAliased(ref ab, ref ax) || LongArray.AreAliased(ref ab, ref bx)) { - ab = (LongArray)ab.Copy(); + ab = ab.Copy(); } ab.AddShiftedByWords(xy, 0); @@ -827,9 +827,9 @@ namespace Org.BouncyCastle.Math.EC LongArray aa = ax.Square(m, ks); LongArray xy = xx.Multiply(yx, m, ks); - if (aa == ax) + if (LongArray.AreAliased(ref aa, ref ax)) { - aa = (LongArray)aa.Copy(); + aa = aa.Copy(); } aa.AddShiftedByWords(xy, 0); diff --git a/crypto/src/math/ec/LongArray.cs b/crypto/src/math/ec/LongArray.cs index 90ca49c77..aa36de215 100644 --- a/crypto/src/math/ec/LongArray.cs +++ b/crypto/src/math/ec/LongArray.cs @@ -1,27 +1,32 @@ using System; using System.Text; - +using Org.BouncyCastle.Math.Raw; using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Math.EC { - internal sealed class LongArray + internal struct LongArray { + internal static bool AreAliased(ref LongArray a, ref LongArray b) + { + return a.m_data == b.m_data; + } + // TODO make m fixed for the LongArray, and hence compute T once and for all private ulong[] m_data; - public LongArray(int intLen) + internal LongArray(int intLen) { m_data = new ulong[intLen]; } - public LongArray(ulong[] data) + internal LongArray(ulong[] data) { m_data = data; } - public LongArray(ulong[] data, int off, int len) + internal LongArray(ulong[] data, int off, int len) { if (off == 0 && len == data.Length) { @@ -34,16 +39,14 @@ namespace Org.BouncyCastle.Math.EC } } - public LongArray(BigInteger bigInt) + internal LongArray(BigInteger bigInt) { if (bigInt == null || bigInt.SignValue < 0) - { - throw new ArgumentException("invalid F2m field value", "bigInt"); - } + throw new ArgumentException("invalid F2m field value", nameof(bigInt)); if (bigInt.SignValue == 0) { - m_data = new ulong[]{ 0UL }; + m_data = new ulong[1]{ 0UL }; return; } @@ -93,51 +96,44 @@ namespace Org.BouncyCastle.Math.EC Array.Copy(m_data, 0, z, zOff, m_data.Length); } - public bool IsOne() + internal bool IsOne() { ulong[] a = m_data; int aLen = a.Length; if (aLen < 1 || a[0] != 1UL) - { return false; - } + for (int i = 1; i < aLen; ++i) { if (a[i] != 0UL) - { return false; - } } return true; } - public bool IsZero() + internal bool IsZero() { ulong[] a = m_data; for (int i = 0; i < a.Length; ++i) { if (a[i] != 0UL) - { return false; - } } return true; } - public int GetUsedLength() + internal int GetUsedLength() { return GetUsedLengthFrom(m_data.Length); } - public int GetUsedLengthFrom(int from) + internal int GetUsedLengthFrom(int from) { ulong[] a = m_data; from = System.Math.Min(from, a.Length); if (from < 1) - { return 0; - } // Check if first element will act as sentinel if (a[0] != 0UL) @@ -160,16 +156,15 @@ namespace Org.BouncyCastle.Math.EC return 0; } - public int Degree() + internal int Degree() { int i = m_data.Length; ulong w; do { if (i == 0) - { return 0; - } + w = m_data[--i]; } while (w == 0UL); @@ -184,9 +179,8 @@ namespace Org.BouncyCastle.Math.EC do { if (i == 0) - { return 0; - } + w = m_data[--i]; } while (w == 0); @@ -206,13 +200,11 @@ namespace Org.BouncyCastle.Math.EC return newInts; } - public BigInteger ToBigInteger() + internal BigInteger ToBigInteger() { int usedLen = GetUsedLength(); if (usedLen == 0) - { return BigInteger.Zero; - } ulong highestInt = m_data[usedLen - 1]; byte[] temp = new byte[8]; @@ -273,12 +265,10 @@ namespace Org.BouncyCastle.Math.EC return prev; } - public LongArray AddOne() + internal LongArray AddOne() { if (m_data.Length == 0) - { - return new LongArray(new ulong[]{ 1UL }); - } + return new LongArray(new ulong[1]{ 1UL }); int resultLen = System.Math.Max(1, GetUsedLength()); ulong[] data = ResizedData(resultLen); @@ -333,13 +323,11 @@ namespace Org.BouncyCastle.Math.EC return prev; } - public void AddShiftedByWords(LongArray other, int words) + internal void AddShiftedByWords(LongArray other, int words) { int otherUsedLen = other.GetUsedLength(); if (otherUsedLen == 0) - { return; - } int minLen = otherUsedLen + words; if (minLen > m_data.Length) @@ -352,18 +340,12 @@ namespace Org.BouncyCastle.Math.EC private static void Add(ulong[] x, int xOff, ulong[] y, int yOff, int count) { - for (int i = 0; i < count; ++i) - { - x[xOff + i] ^= y[yOff + i]; - } + Nat.XorTo64(count, y, yOff, x, xOff); } private static void Add(ulong[] x, int xOff, ulong[] y, int yOff, ulong[] z, int zOff, int count) { - for (int i = 0; i < count; ++i) - { - z[zOff + i] = x[xOff + i] ^ y[yOff + i]; - } + Nat.Xor64(count, x, xOff, y, yOff, z, zOff); } private static void AddBoth(ulong[] x, int xOff, ulong[] y1, int y1Off, ulong[] y2, int y2Off, int count) @@ -393,7 +375,7 @@ namespace Org.BouncyCastle.Math.EC } } - public bool TestBitZero() + internal bool TestBitZero() { return m_data.Length > 0 && (m_data[0] & 1UL) != 0; } @@ -439,21 +421,18 @@ namespace Org.BouncyCastle.Math.EC } } - public LongArray ModMultiplyLD(LongArray other, int m, int[] ks) + internal LongArray ModMultiplyLD(LongArray other, int m, int[] ks) { /* * Find out the degree of each argument and handle the zero cases */ int aDeg = Degree(); if (aDeg == 0) - { return this; - } + int bDeg = other.Degree(); if (bDeg == 0) - { return other; - } /* * Swap if necessary so that A is the smaller argument @@ -476,9 +455,7 @@ namespace Org.BouncyCastle.Math.EC { ulong a0 = A.m_data[0]; if (a0 == 1UL) - { return B; - } /* * Fast path for small A, with performance dependent only on the number of set bits @@ -571,21 +548,18 @@ namespace Org.BouncyCastle.Math.EC return ReduceResult(c, 0, cLen, m, ks); } - public LongArray ModMultiply(LongArray other, int m, int[] ks) + internal LongArray ModMultiply(LongArray other, int m, int[] ks) { /* * Find out the degree of each argument and handle the zero cases */ int aDeg = Degree(); if (aDeg == 0) - { return this; - } + int bDeg = other.Degree(); if (bDeg == 0) - { return other; - } /* * Swap if necessary so that A is the smaller argument @@ -608,9 +582,7 @@ namespace Org.BouncyCastle.Math.EC { ulong a0 = A.m_data[0]; if (a0 == 1UL) - { return B; - } /* * Fast path for small A, with performance dependent only on the number of set bits @@ -681,9 +653,8 @@ namespace Org.BouncyCastle.Math.EC uint v = (uint)aVal & MASK; aVal >>= 4; AddBoth(c, cOff, T0, ti[u], T1, ti[v], bMax); if (aVal == 0UL) - { break; - } + cOff += cLen; } } @@ -702,28 +673,25 @@ namespace Org.BouncyCastle.Math.EC return ReduceResult(c, 0, cLen, m, ks); } - //public LongArray ModReduce(int m, int[] ks) + //internal LongArray ModReduce(int m, int[] ks) //{ // ulong[] buf = Arrays.Clone(m_data); // int rLen = ReduceInPlace(buf, 0, buf.Length, m, ks); // return new LongArray(buf, 0, rLen); //} - public LongArray Multiply(LongArray other, int m, int[] ks) + internal LongArray Multiply(LongArray other, int m, int[] ks) { /* * Find out the degree of each argument and handle the zero cases */ int aDeg = Degree(); if (aDeg == 0) - { return this; - } + int bDeg = other.Degree(); if (bDeg == 0) - { return other; - } /* * Swap if necessary so that A is the smaller argument @@ -746,9 +714,7 @@ namespace Org.BouncyCastle.Math.EC { ulong a0 = A.m_data[0]; if (a0 == 1UL) - { return B; - } /* * Fast path for small A, with performance dependent only on the number of set bits @@ -820,9 +786,8 @@ namespace Org.BouncyCastle.Math.EC uint v = (uint)aVal & MASK; aVal >>= 4; AddBoth(c, cOff, T0, ti[u], T1, ti[v], bMax); if (aVal == 0UL) - { break; - } + cOff += cLen; } } @@ -842,7 +807,7 @@ namespace Org.BouncyCastle.Math.EC return new LongArray(c, 0, cLen); } - public void Reduce(int m, int[] ks) + internal void Reduce(int m, int[] ks) { ulong[] buf = m_data; int rLen = ReduceInPlace(buf, 0, buf.Length, m, ks); @@ -863,9 +828,7 @@ namespace Org.BouncyCastle.Math.EC { int mLen = (m + 63) >> 6; if (len < mLen) - { return len; - } int numBits = System.Math.Min(len << 6, (m << 1) - 1); // TODO use actual degree? int excessBits = (len << 6) - numBits; @@ -994,19 +957,19 @@ namespace Org.BouncyCastle.Math.EC } } - public LongArray ModSquare(int m, int[] ks) + internal LongArray ModSquare(int m, int[] ks) { int len = GetUsedLength(); if (len == 0) return this; ulong[] r = new ulong[len << 1]; - Raw.Interleave.Expand64To128(m_data, 0, len, r, 0); + Interleave.Expand64To128(m_data, 0, len, r, 0); return new LongArray(r, 0, ReduceInPlace(r, 0, r.Length, m, ks)); } - public LongArray ModSquareN(int n, int m, int[] ks) + internal LongArray ModSquareN(int n, int m, int[] ks) { int len = GetUsedLength(); if (len == 0) @@ -1018,21 +981,21 @@ namespace Org.BouncyCastle.Math.EC while (--n >= 0) { - Raw.Interleave.Expand64To128(r, 0, len, r, 0); + Interleave.Expand64To128(r, 0, len, r, 0); len = ReduceInPlace(r, 0, r.Length, m, ks); } return new LongArray(r, 0, len); } - public LongArray Square(int m, int[] ks) + internal LongArray Square(int m, int[] ks) { int len = GetUsedLength(); if (len == 0) return this; ulong[] r = new ulong[len << 1]; - Raw.Interleave.Expand64To128(m_data, 0, len, r, 0); + Interleave.Expand64To128(m_data, 0, len, r, 0); return new LongArray(r, 0, r.Length); } @@ -1147,7 +1110,7 @@ namespace Org.BouncyCastle.Math.EC // return t4.ModMultiply(t1, m, ks); // } - public LongArray ModInverse(int m, int[] ks) + internal LongArray ModInverse(int m, int[] ks) { /* * Fermat's Little Theorem @@ -1188,16 +1151,13 @@ namespace Org.BouncyCastle.Math.EC */ int uzDegree = Degree(); if (uzDegree == 0) - { throw new InvalidOperationException(); - } + if (uzDegree == 1) - { return this; - } // u(z) := a(z) - LongArray uz = (LongArray)Copy(); + LongArray uz = Copy(); int t = (m + 63) >> 6; @@ -1237,9 +1197,7 @@ namespace Org.BouncyCastle.Math.EC int duv2 = uv[b].DegreeFrom(duv1); if (duv2 == 0) - { return gg[1 - b]; - } { int dgg2 = ggDeg[1 - b]; @@ -1263,26 +1221,25 @@ namespace Org.BouncyCastle.Math.EC public override bool Equals(object obj) { - return Equals(obj as LongArray); + if (obj is LongArray longArray) + return Equals(ref longArray); + + return false; } - public bool Equals(LongArray other) + internal bool Equals(ref LongArray other) { - if (this == other) + if (AreAliased(ref this, ref other)) return true; - if (null == other) - return false; + int usedLen = GetUsedLength(); if (other.GetUsedLength() != usedLen) - { return false; - } + for (int i = 0; i < usedLen; i++) { if (m_data[i] != other.m_data[i]) - { return false; - } } return true; } @@ -1311,9 +1268,7 @@ namespace Org.BouncyCastle.Math.EC { int i = GetUsedLength(); if (i == 0) - { return "0"; - } StringBuilder sb = new StringBuilder(i * 64); sb.Append(Convert.ToString((long)m_data[--i], 2)); diff --git a/crypto/src/ocsp/RevokedStatus.cs b/crypto/src/ocsp/RevokedStatus.cs index 903e50ef5..a37bdade9 100644 --- a/crypto/src/ocsp/RevokedStatus.cs +++ b/crypto/src/ocsp/RevokedStatus.cs @@ -6,52 +6,49 @@ using Org.BouncyCastle.Asn1.X509; namespace Org.BouncyCastle.Ocsp { - /** - * wrapper for the RevokedInfo object - */ - public class RevokedStatus + /// <summary>Wrapper for the RevokedInfo object</summary> + public class RevokedStatus : CertificateStatus { - internal readonly RevokedInfo info; + private readonly RevokedInfo m_revokedInfo; - public RevokedStatus( - RevokedInfo info) + public RevokedStatus(RevokedInfo revokedInfo) { - this.info = info; + m_revokedInfo = revokedInfo; } - public RevokedStatus( - DateTime revocationDate, - int reason) + public RevokedStatus(DateTime revocationDate) { - this.info = new RevokedInfo(new Asn1GeneralizedTime(revocationDate), new CrlReason(reason)); + m_revokedInfo = new RevokedInfo(new Asn1GeneralizedTime(revocationDate)); + } + + public RevokedStatus(DateTime revocationDate, int reason) + { + m_revokedInfo = new RevokedInfo(new Asn1GeneralizedTime(revocationDate), new CrlReason(reason)); } public DateTime RevocationTime { - get { return info.RevocationTime.ToDateTime(); } + get { return m_revokedInfo.RevocationTime.ToDateTime(); } } public bool HasRevocationReason { - get { return (info.RevocationReason != null); } + get { return m_revokedInfo.RevocationReason != null; } } - /** - * return the revocation reason. Note: this field is optional, test for it - * with hasRevocationReason() first. - * @exception InvalidOperationException if a reason is asked for and none is avaliable - */ - public int RevocationReason + /// <summary>Return the revocation reason, if there is one.</summary> + /// <remarks>This field is optional; test for it with <see cref="HasRevocationReason"/> first.</remarks> + /// <returns>The revocation reason, if available.</returns> + /// <exception cref="InvalidOperationException">If no revocation reason is available.</exception> + public int RevocationReason { get { - if (info.RevocationReason == null) - { + if (m_revokedInfo.RevocationReason == null) throw new InvalidOperationException("attempt to get a reason where none is available"); - } - return info.RevocationReason.IntValueExact; + return m_revokedInfo.RevocationReason.IntValueExact; } } } diff --git a/crypto/src/openpgp/EdDsaSigner.cs b/crypto/src/openpgp/EdDsaSigner.cs new file mode 100644 index 000000000..0e15ac609 --- /dev/null +++ b/crypto/src/openpgp/EdDsaSigner.cs @@ -0,0 +1,72 @@ +using System; + +using Org.BouncyCastle.Crypto; +using Org.BouncyCastle.Utilities; + +namespace Org.BouncyCastle.Bcpg.OpenPgp +{ + internal sealed class EdDsaSigner + : ISigner + { + private readonly ISigner m_signer; + private readonly IDigest m_digest; + private readonly byte[] m_digBuf; + + internal EdDsaSigner(ISigner signer, IDigest digest) + { + m_signer = signer; + m_digest = digest; + m_digBuf = new byte[digest.GetDigestSize()]; + } + + public string AlgorithmName => m_signer.AlgorithmName; + + public void Init(bool forSigning, ICipherParameters cipherParameters) + { + m_signer.Init(forSigning, cipherParameters); + m_digest.Reset(); + } + + public void Update(byte b) + { + m_digest.Update(b); + } + + public void BlockUpdate(byte[] input, int inOff, int inLen) + { + m_digest.BlockUpdate(input, inOff, inLen); + } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void BlockUpdate(ReadOnlySpan<byte> input) + { + m_digest.BlockUpdate(input); + } +#endif + + public byte[] GenerateSignature() + { + m_digest.DoFinal(m_digBuf, 0); + + m_signer.BlockUpdate(m_digBuf, 0, m_digBuf.Length); + + return m_signer.GenerateSignature(); + } + + public bool VerifySignature(byte[] signature) + { + m_digest.DoFinal(m_digBuf, 0); + + m_signer.BlockUpdate(m_digBuf, 0, m_digBuf.Length); + + return m_signer.VerifySignature(signature); + } + + public void Reset() + { + Arrays.Clear(m_digBuf); + m_signer.Reset(); + m_digest.Reset(); + } + } +} diff --git a/crypto/src/openpgp/PgpEncryptedData.cs b/crypto/src/openpgp/PgpEncryptedData.cs index 5cdc0d533..bad4cb8cd 100644 --- a/crypto/src/openpgp/PgpEncryptedData.cs +++ b/crypto/src/openpgp/PgpEncryptedData.cs @@ -54,6 +54,9 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { Streams.ValidateBufferArguments(buffer, offset, count); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return Read(buffer.AsSpan(offset, count)); +#else int avail = bufEnd - bufStart; int pos = offset; @@ -73,8 +76,34 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp bufStart += count; return pos + count - offset; +#endif } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + int avail = bufEnd - bufStart; + + int pos = 0, count = buffer.Length; + while (count > avail) + { + lookAhead.AsSpan(bufStart, avail).CopyTo(buffer[pos..]); + + bufStart += avail; + pos += avail; + count -= avail; + + if ((avail = FillBuffer()) < 1) + return pos; + } + + lookAhead.AsSpan(bufStart, count).CopyTo(buffer[pos..]); + bufStart += count; + + return pos + count; + } +#endif + public override int ReadByte() { if (bufStart < bufEnd) diff --git a/crypto/src/openpgp/PgpEncryptedDataGenerator.cs b/crypto/src/openpgp/PgpEncryptedDataGenerator.cs index 589895522..69e0d5dbc 100644 --- a/crypto/src/openpgp/PgpEncryptedDataGenerator.cs +++ b/crypto/src/openpgp/PgpEncryptedDataGenerator.cs @@ -2,17 +2,21 @@ using System; using System.Collections.Generic; using System.Diagnostics; using System.IO; - +using Org.BouncyCastle.Asn1; +using Org.BouncyCastle.Asn1.Cryptlib; +using Org.BouncyCastle.Asn1.EdEC; using Org.BouncyCastle.Crypto; +using Org.BouncyCastle.Crypto.Agreement; +using Org.BouncyCastle.Crypto.Generators; using Org.BouncyCastle.Crypto.IO; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Math; -using Org.BouncyCastle.Math.EC; using Org.BouncyCastle.Security; +using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Bcpg.OpenPgp { - /// <remarks>Generator for encrypted objects.</remarks> + /// <remarks>Generator for encrypted objects.</remarks> public class PgpEncryptedDataGenerator : IStreamGenerator { @@ -99,54 +103,108 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp private byte[] EncryptSessionInfo(byte[] sessionInfo, SecureRandom random) { + var cryptoPublicKey = pubKey.GetKey(); + if (pubKey.Algorithm != PublicKeyAlgorithmTag.ECDH) { IBufferedCipher c; switch (pubKey.Algorithm) { - case PublicKeyAlgorithmTag.RsaEncrypt: - case PublicKeyAlgorithmTag.RsaGeneral: - c = CipherUtilities.GetCipher("RSA//PKCS1Padding"); - break; - case PublicKeyAlgorithmTag.ElGamalEncrypt: - case PublicKeyAlgorithmTag.ElGamalGeneral: - c = CipherUtilities.GetCipher("ElGamal/ECB/PKCS1Padding"); - break; - case PublicKeyAlgorithmTag.Dsa: - throw new PgpException("Can't use DSA for encryption."); - case PublicKeyAlgorithmTag.ECDsa: - throw new PgpException("Can't use ECDSA for encryption."); - default: - throw new PgpException("unknown asymmetric algorithm: " + pubKey.Algorithm); + case PublicKeyAlgorithmTag.RsaEncrypt: + case PublicKeyAlgorithmTag.RsaGeneral: + c = CipherUtilities.GetCipher("RSA//PKCS1Padding"); + break; + case PublicKeyAlgorithmTag.ElGamalEncrypt: + case PublicKeyAlgorithmTag.ElGamalGeneral: + c = CipherUtilities.GetCipher("ElGamal/ECB/PKCS1Padding"); + break; + case PublicKeyAlgorithmTag.Dsa: + throw new PgpException("Can't use DSA for encryption."); + case PublicKeyAlgorithmTag.ECDsa: + throw new PgpException("Can't use ECDSA for encryption."); + case PublicKeyAlgorithmTag.EdDsa: + throw new PgpException("Can't use EdDSA for encryption."); + default: + throw new PgpException("unknown asymmetric algorithm: " + pubKey.Algorithm); } - AsymmetricKeyParameter akp = pubKey.GetKey(); - c.Init(true, new ParametersWithRandom(akp, random)); + c.Init(true, new ParametersWithRandom(cryptoPublicKey, random)); return c.DoFinal(sessionInfo); } - ECDHPublicBcpgKey ecKey = (ECDHPublicBcpgKey)pubKey.PublicKeyPacket.Key; + ECDHPublicBcpgKey ecPubKey = (ECDHPublicBcpgKey)pubKey.PublicKeyPacket.Key; + var curveOid = ecPubKey.CurveOid; + + if (EdECObjectIdentifiers.id_X25519.Equals(curveOid) || + CryptlibObjectIdentifiers.curvey25519.Equals(curveOid)) + { + X25519KeyPairGenerator gen = new X25519KeyPairGenerator(); + gen.Init(new X25519KeyGenerationParameters(random)); + + AsymmetricCipherKeyPair ephKp = gen.GenerateKeyPair(); + + X25519Agreement agreement = new X25519Agreement(); + agreement.Init(ephKp.Private); + + byte[] secret = new byte[agreement.AgreementSize]; + agreement.CalculateAgreement(cryptoPublicKey, secret, 0); + + byte[] ephPubEncoding = new byte[1 + X25519PublicKeyParameters.KeySize]; + ephPubEncoding[0] = 0x40; + ((X25519PublicKeyParameters)ephKp.Public).Encode(ephPubEncoding, 1); + + return EncryptSessionInfo(ecPubKey, sessionInfo, secret, ephPubEncoding, random); + } + else if (EdECObjectIdentifiers.id_X448.Equals(curveOid)) + { + X448KeyPairGenerator gen = new X448KeyPairGenerator(); + gen.Init(new X448KeyGenerationParameters(random)); + + AsymmetricCipherKeyPair ephKp = gen.GenerateKeyPair(); + + X448Agreement agreement = new X448Agreement(); + agreement.Init(ephKp.Private); + + byte[] secret = new byte[agreement.AgreementSize]; + agreement.CalculateAgreement(cryptoPublicKey, secret, 0); - // Generate the ephemeral key pair - IAsymmetricCipherKeyPairGenerator gen = GeneratorUtilities.GetKeyPairGenerator("ECDH"); - gen.Init(new ECKeyGenerationParameters(ecKey.CurveOid, random)); + byte[] ephPubEncoding = new byte[1 + X448PublicKeyParameters.KeySize]; + ephPubEncoding[0] = 0x40; + ((X448PublicKeyParameters)ephKp.Public).Encode(ephPubEncoding, 1); - AsymmetricCipherKeyPair ephKp = gen.GenerateKeyPair(); - ECPrivateKeyParameters ephPriv = (ECPrivateKeyParameters)ephKp.Private; - ECPublicKeyParameters ephPub = (ECPublicKeyParameters)ephKp.Public; + return EncryptSessionInfo(ecPubKey, sessionInfo, secret, ephPubEncoding, random); + } + else + { + // Generate the ephemeral key pair + ECDomainParameters ecParams = ((ECPublicKeyParameters)cryptoPublicKey).Parameters; + ECKeyPairGenerator gen = new ECKeyPairGenerator(); + gen.Init(new ECKeyGenerationParameters(ecParams, random)); - ECPublicKeyParameters pub = (ECPublicKeyParameters)pubKey.GetKey(); - ECPoint S = pub.Q.Multiply(ephPriv.D).Normalize(); + AsymmetricCipherKeyPair ephKp = gen.GenerateKeyPair(); - KeyParameter key = new KeyParameter(Rfc6637Utilities.CreateKey(pubKey.PublicKeyPacket, S)); + ECDHBasicAgreement agreement = new ECDHBasicAgreement(); + agreement.Init(ephKp.Private); + BigInteger S = agreement.CalculateAgreement(cryptoPublicKey); + byte[] secret = BigIntegers.AsUnsignedByteArray(agreement.GetFieldSize(), S); + + byte[] ephPubEncoding = ((ECPublicKeyParameters)ephKp.Public).Q.GetEncoded(false); + return EncryptSessionInfo(ecPubKey, sessionInfo, secret, ephPubEncoding, random); + } + } + + private byte[] EncryptSessionInfo(ECDHPublicBcpgKey ecPubKey, byte[] sessionInfo, byte[] secret, + byte[] ephPubEncoding, SecureRandom random) + { + var key = new KeyParameter(Rfc6637Utilities.CreateKey(pubKey.PublicKeyPacket, secret)); - IWrapper w = PgpUtilities.CreateWrapper(ecKey.SymmetricKeyAlgorithm); + IWrapper w = PgpUtilities.CreateWrapper(ecPubKey.SymmetricKeyAlgorithm); w.Init(true, new ParametersWithRandom(key, random)); byte[] paddedSessionData = PgpPad.PadSessionData(sessionInfo, sessionKeyObfuscation); byte[] C = w.Wrap(paddedSessionData, 0, paddedSessionData.Length); - byte[] VB = new MPInteger(MPInteger.ToMpiBigInteger(ephPub.Q)).GetEncoded(); + byte[] VB = new MPInteger(new BigInteger(1, ephPubEncoding)).GetEncoded(); byte[] rv = new byte[VB.Length + 1 + C.Length]; @@ -165,7 +223,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { case PublicKeyAlgorithmTag.RsaEncrypt: case PublicKeyAlgorithmTag.RsaGeneral: - data = new byte[][] { ConvertToEncodedMpi(encryptedSessionInfo) }; + data = new byte[1][] { ConvertToEncodedMpi(encryptedSessionInfo) }; break; case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: @@ -176,13 +234,13 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp Array.Copy(encryptedSessionInfo, 0, b1, 0, halfLength); Array.Copy(encryptedSessionInfo, halfLength, b2, 0, halfLength); - data = new byte[][] { + data = new byte[2][] { ConvertToEncodedMpi(b1), ConvertToEncodedMpi(b2), }; break; case PublicKeyAlgorithmTag.ECDH: - data = new byte[][]{ encryptedSessionInfo }; + data = new byte[1][]{ encryptedSessionInfo }; break; default: throw new PgpException("unknown asymmetric algorithm: " + pubKey.Algorithm); @@ -489,8 +547,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp if (withIntegrityPacket) { - string digestName = PgpUtilities.GetDigestName(HashAlgorithmTag.Sha1); - IDigest digest = DigestUtilities.GetDigest(digestName); + IDigest digest = PgpUtilities.CreateDigest(HashAlgorithmTag.Sha1); myOut = digestOut = new DigestStream(myOut, null, digest); } diff --git a/crypto/src/openpgp/PgpKdfParameters.cs b/crypto/src/openpgp/PgpKdfParameters.cs new file mode 100644 index 000000000..c78448939 --- /dev/null +++ b/crypto/src/openpgp/PgpKdfParameters.cs @@ -0,0 +1,21 @@ +using System; + +namespace Org.BouncyCastle.Bcpg.OpenPgp +{ + internal sealed class PgpKdfParameters + //: IPgpAlgorithmParameters + { + private readonly HashAlgorithmTag m_hashAlgorithm; + private readonly SymmetricKeyAlgorithmTag m_symmetricWrapAlgorithm; + + public PgpKdfParameters(HashAlgorithmTag hashAlgorithm, SymmetricKeyAlgorithmTag symmetricWrapAlgorithm) + { + m_hashAlgorithm = hashAlgorithm; + m_symmetricWrapAlgorithm = symmetricWrapAlgorithm; + } + + public HashAlgorithmTag HashAlgorithm => m_hashAlgorithm; + + public SymmetricKeyAlgorithmTag SymmetricWrapAlgorithm => m_symmetricWrapAlgorithm; + } +} diff --git a/crypto/src/openpgp/PgpLiteralDataGenerator.cs b/crypto/src/openpgp/PgpLiteralDataGenerator.cs index 7672659ca..f9a9e7cad 100644 --- a/crypto/src/openpgp/PgpLiteralDataGenerator.cs +++ b/crypto/src/openpgp/PgpLiteralDataGenerator.cs @@ -141,7 +141,6 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp return new WrappedGeneratorStream(this, pkOut); } -#if !PORTABLE || DOTNET /// <summary> /// <p> /// Open a literal data packet for the passed in <c>FileInfo</c> object, returning @@ -163,7 +162,6 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { return Open(outStr, format, file.Name, file.Length, file.LastWriteTime); } -#endif /// <summary> /// Close the literal data packet - this is equivalent to calling Close() diff --git a/crypto/src/openpgp/PgpObjectFactory.cs b/crypto/src/openpgp/PgpObjectFactory.cs index f7bf89507..068b85154 100644 --- a/crypto/src/openpgp/PgpObjectFactory.cs +++ b/crypto/src/openpgp/PgpObjectFactory.cs @@ -72,9 +72,8 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } case PacketTag.PublicKey: return new PgpPublicKeyRing(bcpgIn); - // TODO Make PgpPublicKey a PgpObject or return a PgpPublicKeyRing - //case PacketTag.PublicSubkey: - // return PgpPublicKeyRing.ReadSubkey(bcpgIn); + case PacketTag.PublicSubkey: + return PgpPublicKeyRing.ReadSubkey(bcpgIn); case PacketTag.CompressedData: return new PgpCompressedData(bcpgIn); case PacketTag.LiteralData: diff --git a/crypto/src/openpgp/PgpOnePassSignature.cs b/crypto/src/openpgp/PgpOnePassSignature.cs index 2fab5137e..c14e72bf7 100644 --- a/crypto/src/openpgp/PgpOnePassSignature.cs +++ b/crypto/src/openpgp/PgpOnePassSignature.cs @@ -2,7 +2,9 @@ using System; using System.IO; using Org.BouncyCastle.Crypto; +using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Security; +using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Bcpg.OpenPgp { @@ -11,10 +13,10 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { private static OnePassSignaturePacket Cast(Packet packet) { - if (!(packet is OnePassSignaturePacket)) - throw new IOException("unexpected packet in stream: " + packet); + if (packet is OnePassSignaturePacket onePassSignaturePacket) + return onePassSignaturePacket; - return (OnePassSignaturePacket)packet; + throw new IOException("unexpected packet in stream: " + packet); } private readonly OnePassSignaturePacket sigPack; @@ -36,15 +38,14 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } /// <summary>Initialise the signature object for verification.</summary> - public void InitVerify( - PgpPublicKey pubKey) + public void InitVerify(PgpPublicKey pubKey) { lastb = 0; + AsymmetricKeyParameter key = pubKey.GetKey(); - try + try { - sig = SignerUtilities.GetSigner( - PgpUtilities.GetSignatureName(sigPack.KeyAlgorithm, sigPack.HashAlgorithm)); + sig = PgpUtilities.CreateSigner(sigPack.KeyAlgorithm, sigPack.HashAlgorithm, key); } catch (Exception e) { @@ -53,7 +54,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp try { - sig.Init(false, pubKey.GetKey()); + sig.Init(false, key); } catch (InvalidKeyException e) { @@ -61,12 +62,11 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } - public void Update( - byte b) + public void Update(byte b) { if (signatureType == PgpSignature.CanonicalTextDocument) { - doCanonicalUpdateByte(b); + DoCanonicalUpdateByte(b); } else { @@ -74,18 +74,17 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } - private void doCanonicalUpdateByte( - byte b) + private void DoCanonicalUpdateByte(byte b) { if (b == '\r') { - doUpdateCRLF(); + DoUpdateCRLF(); } else if (b == '\n') { if (lastb != '\r') { - doUpdateCRLF(); + DoUpdateCRLF(); } } else @@ -96,51 +95,57 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp lastb = b; } - private void doUpdateCRLF() + private void DoUpdateCRLF() { sig.Update((byte)'\r'); sig.Update((byte)'\n'); } - public void Update( - byte[] bytes) + public void Update(params byte[] bytes) + { + Update(bytes, 0, bytes.Length); + } + + public void Update(byte[] bytes, int off, int length) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + Update(bytes.AsSpan(off, length)); +#else if (signatureType == PgpSignature.CanonicalTextDocument) { - for (int i = 0; i != bytes.Length; i++) + int finish = off + length; + + for (int i = off; i != finish; i++) { - doCanonicalUpdateByte(bytes[i]); + DoCanonicalUpdateByte(bytes[i]); } } else { - sig.BlockUpdate(bytes, 0, bytes.Length); + sig.BlockUpdate(bytes, off, length); } +#endif } - public void Update( - byte[] bytes, - int off, - int length) +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) { if (signatureType == PgpSignature.CanonicalTextDocument) { - int finish = off + length; - - for (int i = off; i != finish; i++) + for (int i = 0; i < input.Length; ++i) { - doCanonicalUpdateByte(bytes[i]); + DoCanonicalUpdateByte(input[i]); } } else { - sig.BlockUpdate(bytes, off, length); + sig.BlockUpdate(input); } } +#endif - /// <summary>Verify the calculated signature against the passed in PgpSignature.</summary> - public bool Verify( - PgpSignature pgpSig) + /// <summary>Verify the calculated signature against the passed in PgpSignature.</summary> + public bool Verify(PgpSignature pgpSig) { byte[] trailer = pgpSig.GetSignatureTrailer(); @@ -171,15 +176,14 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp public byte[] GetEncoded() { - MemoryStream bOut = new MemoryStream(); + var bOut = new MemoryStream(); Encode(bOut); return bOut.ToArray(); } - public void Encode( - Stream outStr) + public void Encode(Stream outStr) { BcpgOutputStream.Wrap(outStr).WritePacket(sigPack); } diff --git a/crypto/src/openpgp/PgpPbeEncryptedData.cs b/crypto/src/openpgp/PgpPbeEncryptedData.cs index f43f2f512..7920f54ea 100644 --- a/crypto/src/openpgp/PgpPbeEncryptedData.cs +++ b/crypto/src/openpgp/PgpPbeEncryptedData.cs @@ -97,10 +97,9 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { truncStream = new TruncatedStream(encStream); - string digestName = PgpUtilities.GetDigestName(HashAlgorithmTag.Sha1); - IDigest digest = DigestUtilities.GetDigest(digestName); + IDigest digest = PgpUtilities.CreateDigest(HashAlgorithmTag.Sha1); - encStream = new DigestStream(truncStream, digest, null); + encStream = new DigestStream(truncStream, digest, null); } if (Streams.ReadFully(encStream, iv, 0, iv.Length) < iv.Length) diff --git a/crypto/src/openpgp/PgpPublicKey.cs b/crypto/src/openpgp/PgpPublicKey.cs index cdb8efd36..400cda071 100644 --- a/crypto/src/openpgp/PgpPublicKey.cs +++ b/crypto/src/openpgp/PgpPublicKey.cs @@ -3,13 +3,18 @@ using System.Collections.Generic; using System.IO; using Org.BouncyCastle.Asn1; +using Org.BouncyCastle.Asn1.Cryptlib; +using Org.BouncyCastle.Asn1.EdEC; using Org.BouncyCastle.Asn1.Gnu; +using Org.BouncyCastle.Asn1.X509; using Org.BouncyCastle.Asn1.X9; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Generators; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Math; using Org.BouncyCastle.Math.EC; +using Org.BouncyCastle.Math.EC.Rfc7748; +using Org.BouncyCastle.Math.EC.Rfc8032; using Org.BouncyCastle.Security; using Org.BouncyCastle.Utilities; using Org.BouncyCastle.Utilities.Collections; @@ -18,7 +23,12 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { /// <remarks>General class to handle a PGP public key object.</remarks> public class PgpPublicKey + : PgpObject { + // We default to these as they are specified as mandatory in RFC 6631. + private static readonly PgpKdfParameters DefaultKdfParameters = new PgpKdfParameters(HashAlgorithmTag.Sha256, + SymmetricKeyAlgorithmTag.Aes128); + public static byte[] CalculateFingerprint(PublicKeyPacket publicPk) { IBcpgKey key = publicPk.Key; @@ -30,7 +40,8 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp try { - digest = DigestUtilities.GetDigest("MD5"); + digest = PgpUtilities.CreateDigest(HashAlgorithmTag.MD5); + UpdateDigest(digest, rK.Modulus); UpdateDigest(digest, rK.PublicExponent); } @@ -45,7 +56,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { byte[] kBytes = publicPk.GetEncodedContents(); - digest = DigestUtilities.GetDigest("SHA1"); + digest = PgpUtilities.CreateDigest(HashAlgorithmTag.Sha1); digest.Update(0x99); digest.Update((byte)(kBytes.Length >> 8)); @@ -124,27 +135,38 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { this.keyStrength = ((ElGamalPublicBcpgKey)key).P.BitLength; } - else if (key is ECPublicBcpgKey) + else if (key is EdDsaPublicBcpgKey eddsaK) { - DerObjectIdentifier curveOid = ((ECPublicBcpgKey)key).CurveOid; - if (GnuObjectIdentifiers.Ed25519.Equals(curveOid) - //|| CryptlibObjectIdentifiers.curvey25519.Equals(curveOid) - ) + var curveOid = eddsaK.CurveOid; + if (EdECObjectIdentifiers.id_Ed25519.Equals(curveOid) || + GnuObjectIdentifiers.Ed25519.Equals(curveOid) || + EdECObjectIdentifiers.id_X25519.Equals(curveOid) || + CryptlibObjectIdentifiers.curvey25519.Equals(curveOid)) { this.keyStrength = 256; } + else if (EdECObjectIdentifiers.id_Ed448.Equals(curveOid) || + EdECObjectIdentifiers.id_X448.Equals(curveOid)) + { + this.keyStrength = 448; + } else { - X9ECParametersHolder ecParameters = ECKeyPairGenerator.FindECCurveByOidLazy(curveOid); - - if (ecParameters != null) - { - this.keyStrength = ecParameters.Curve.FieldSize; - } - else - { - this.keyStrength = -1; // unknown - } + this.keyStrength = -1; // unknown + } + } + else if (key is ECPublicBcpgKey ecK) + { + var curveOid = ecK.CurveOid; + X9ECParametersHolder ecParameters = ECKeyPairGenerator.FindECCurveByOidLazy(curveOid); + + if (ecParameters != null) + { + this.keyStrength = ecParameters.Curve.FieldSize; + } + else + { + this.keyStrength = -1; // unknown } } } @@ -165,7 +187,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp public PgpPublicKey(PublicKeyAlgorithmTag algorithm, AsymmetricKeyParameter pubKey, DateTime time) { if (pubKey.IsPrivate) - throw new ArgumentException("Expected a public key", "pubKey"); + throw new ArgumentException("Expected a public key", nameof(pubKey)); IBcpgKey bcpgKey; if (pubKey is RsaKeyParameters rK) @@ -178,6 +200,12 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp bcpgKey = new DsaPublicBcpgKey(dP.P, dP.Q, dP.G, dK.Y); } + else if (pubKey is ElGamalPublicKeyParameters eK) + { + ElGamalParameters eS = eK.Parameters; + + bcpgKey = new ElGamalPublicBcpgKey(eS.P, eS.G, eK.Y); + } else if (pubKey is ECPublicKeyParameters ecK) { if (algorithm == PublicKeyAlgorithmTag.ECDH) @@ -194,11 +222,39 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp throw new PgpException("unknown EC algorithm"); } } - else if (pubKey is ElGamalPublicKeyParameters eK) + else if (pubKey is Ed25519PublicKeyParameters ed25519PubKey) { - ElGamalParameters eS = eK.Parameters; + byte[] pointEnc = new byte[1 + Ed25519PublicKeyParameters.KeySize]; + pointEnc[0] = 0x40; + ed25519PubKey.Encode(pointEnc, 1); + bcpgKey = new EdDsaPublicBcpgKey(GnuObjectIdentifiers.Ed25519, new BigInteger(1, pointEnc)); + } + else if (pubKey is Ed448PublicKeyParameters ed448PubKey) + { + byte[] pointEnc = new byte[Ed448PublicKeyParameters.KeySize]; + ed448PubKey.Encode(pointEnc, 0); + bcpgKey = new EdDsaPublicBcpgKey(EdECObjectIdentifiers.id_Ed448, new BigInteger(1, pointEnc)); + } + else if (pubKey is X25519PublicKeyParameters x25519PubKey) + { + byte[] pointEnc = new byte[1 + X25519PublicKeyParameters.KeySize]; + pointEnc[0] = 0x40; + x25519PubKey.Encode(pointEnc, 1); - bcpgKey = new ElGamalPublicBcpgKey(eS.P, eS.G, eK.Y); + PgpKdfParameters kdfParams = DefaultKdfParameters; + + bcpgKey = new ECDHPublicBcpgKey(CryptlibObjectIdentifiers.curvey25519, new BigInteger(1, pointEnc), + kdfParams.HashAlgorithm, kdfParams.SymmetricWrapAlgorithm); + } + else if (pubKey is X448PublicKeyParameters x448PubKey) + { + byte[] pointEnc = new byte[X448PublicKeyParameters.KeySize]; + x448PubKey.Encode(pointEnc, 0); + + PgpKdfParameters kdfParams = DefaultKdfParameters; + + bcpgKey = new ECDHPublicBcpgKey(EdECObjectIdentifiers.id_X448, new BigInteger(1, pointEnc), + kdfParams.HashAlgorithm, kdfParams.SymmetricWrapAlgorithm); } else { @@ -473,24 +529,89 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { switch (publicPk.Algorithm) { - case PublicKeyAlgorithmTag.RsaEncrypt: - case PublicKeyAlgorithmTag.RsaGeneral: - case PublicKeyAlgorithmTag.RsaSign: - RsaPublicBcpgKey rsaK = (RsaPublicBcpgKey)publicPk.Key; - return new RsaKeyParameters(false, rsaK.Modulus, rsaK.PublicExponent); - case PublicKeyAlgorithmTag.Dsa: - DsaPublicBcpgKey dsaK = (DsaPublicBcpgKey)publicPk.Key; - return new DsaPublicKeyParameters(dsaK.Y, new DsaParameters(dsaK.P, dsaK.Q, dsaK.G)); - case PublicKeyAlgorithmTag.ECDsa: - return GetECKey("ECDSA"); - case PublicKeyAlgorithmTag.ECDH: - return GetECKey("ECDH"); - case PublicKeyAlgorithmTag.ElGamalEncrypt: - case PublicKeyAlgorithmTag.ElGamalGeneral: - ElGamalPublicBcpgKey elK = (ElGamalPublicBcpgKey)publicPk.Key; - return new ElGamalPublicKeyParameters(elK.Y, new ElGamalParameters(elK.P, elK.G)); - default: - throw new PgpException("unknown public key algorithm encountered"); + case PublicKeyAlgorithmTag.RsaEncrypt: + case PublicKeyAlgorithmTag.RsaGeneral: + case PublicKeyAlgorithmTag.RsaSign: + RsaPublicBcpgKey rsaK = (RsaPublicBcpgKey)publicPk.Key; + return new RsaKeyParameters(false, rsaK.Modulus, rsaK.PublicExponent); + case PublicKeyAlgorithmTag.Dsa: + DsaPublicBcpgKey dsaK = (DsaPublicBcpgKey)publicPk.Key; + return new DsaPublicKeyParameters(dsaK.Y, new DsaParameters(dsaK.P, dsaK.Q, dsaK.G)); + case PublicKeyAlgorithmTag.ECDsa: + ECDsaPublicBcpgKey ecdsaK = (ECDsaPublicBcpgKey)publicPk.Key; + return GetECKey("ECDSA", ecdsaK); + case PublicKeyAlgorithmTag.ECDH: + { + ECDHPublicBcpgKey ecdhK = (ECDHPublicBcpgKey)publicPk.Key; + var curveOid = ecdhK.CurveOid; + + if (EdECObjectIdentifiers.id_X25519.Equals(curveOid) || + CryptlibObjectIdentifiers.curvey25519.Equals(curveOid)) + { + byte[] pEnc = BigIntegers.AsUnsignedByteArray(1 + X25519.PointSize, ecdhK.EncodedPoint); + if (pEnc[0] != 0x40) + throw new ArgumentException("Invalid X25519 public key"); + + return PublicKeyFactory.CreateKey(new SubjectPublicKeyInfo( + new AlgorithmIdentifier(curveOid), + // TODO Span variant + Arrays.CopyOfRange(pEnc, 1, pEnc.Length))); + } + else if (EdECObjectIdentifiers.id_X448.Equals(curveOid)) + { + byte[] pEnc = BigIntegers.AsUnsignedByteArray(1 + X448.PointSize, ecdhK.EncodedPoint); + if (pEnc[0] != 0x40) + throw new ArgumentException("Invalid X448 public key"); + + return PublicKeyFactory.CreateKey(new SubjectPublicKeyInfo( + new AlgorithmIdentifier(curveOid), + // TODO Span variant + Arrays.CopyOfRange(pEnc, 1, pEnc.Length))); + } + else + { + return GetECKey("ECDH", ecdhK); + } + } + case PublicKeyAlgorithmTag.EdDsa: + { + EdDsaPublicBcpgKey eddsaK = (EdDsaPublicBcpgKey)publicPk.Key; + var curveOid = eddsaK.CurveOid; + + if (EdECObjectIdentifiers.id_Ed25519.Equals(curveOid) || + GnuObjectIdentifiers.Ed25519.Equals(curveOid)) + { + byte[] pEnc = BigIntegers.AsUnsignedByteArray(1 + Ed25519.PublicKeySize, eddsaK.EncodedPoint); + if (pEnc[0] != 0x40) + throw new ArgumentException("Invalid Ed25519 public key"); + + return PublicKeyFactory.CreateKey(new SubjectPublicKeyInfo( + new AlgorithmIdentifier(curveOid), + // TODO Span variant + Arrays.CopyOfRange(pEnc, 1, pEnc.Length))); + } + else if (EdECObjectIdentifiers.id_Ed448.Equals(curveOid)) + { + byte[] pEnc = BigIntegers.AsUnsignedByteArray(1 + Ed448.PublicKeySize, eddsaK.EncodedPoint); + if (pEnc[0] != 0x40) + throw new ArgumentException("Invalid Ed448 public key"); + + return PublicKeyFactory.CreateKey(new SubjectPublicKeyInfo( + new AlgorithmIdentifier(curveOid), + // TODO Span variant + Arrays.CopyOfRange(pEnc, 1, pEnc.Length))); + } + else + { + throw new InvalidOperationException(); + } + } + case PublicKeyAlgorithmTag.ElGamalEncrypt: + case PublicKeyAlgorithmTag.ElGamalGeneral: + ElGamalPublicBcpgKey elK = (ElGamalPublicBcpgKey)publicPk.Key; + return new ElGamalPublicKeyParameters(elK.Y, new ElGamalParameters(elK.P, elK.G)); + default: + throw new PgpException("unknown public key algorithm encountered"); } } catch (PgpException e) @@ -503,9 +624,8 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } - private ECPublicKeyParameters GetECKey(string algorithm) + private ECPublicKeyParameters GetECKey(string algorithm, ECPublicBcpgKey ecK) { - ECPublicBcpgKey ecK = (ECPublicBcpgKey)publicPk.Key; X9ECParameters x9 = ECKeyPairGenerator.FindECCurveByOid(ecK.CurveOid); BigInteger encodedPoint = ecK.EncodedPoint; @@ -563,7 +683,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp public IEnumerable<PgpSignature> GetSignaturesForId(string id) { if (id == null) - throw new ArgumentNullException("id"); + throw new ArgumentNullException(nameof(id)); var result = new List<PgpSignature>(); bool userIdFound = false; @@ -580,13 +700,48 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp return userIdFound ? CollectionUtilities.Proxy(result) : null; } + private IEnumerable<PgpSignature> GetSignaturesForID(UserIdPacket id) + { + var signatures = new List<PgpSignature>(); + bool userIdFound = false; + + for (int i = 0; i != ids.Count; i++) + { + if (id.Equals(ids[i])) + { + userIdFound = true; + signatures.AddRange(idSigs[i]); + } + } + + return userIdFound ? signatures : null; + } + + /// <summary>Return any signatures associated with the passed in key identifier keyID.</summary> + /// <param name="keyID">the key id to be matched.</param> + /// <returns>An <c>IEnumerable</c> of <c>PgpSignature</c> objects issued by the key with keyID.</returns> + public IEnumerable<PgpSignature> GetSignaturesForKeyID(long keyID) + { + var sigs = new List<PgpSignature>(); + + foreach (var sig in GetSignatures()) + { + if (sig.KeyId == keyID) + { + sigs.Add(sig); + } + } + + return CollectionUtilities.Proxy(sigs); + } + /// <summary>Allows enumeration of signatures associated with the passed in user attributes.</summary> /// <param name="userAttributes">The vector of user attributes to be matched.</param> /// <returns>An <c>IEnumerable</c> of <c>PgpSignature</c> objects.</returns> public IEnumerable<PgpSignature> GetSignaturesForUserAttribute(PgpUserAttributeSubpacketVector userAttributes) { if (userAttributes == null) - throw new ArgumentNullException("userAttributes"); + throw new ArgumentNullException(nameof(userAttributes)); var result = new List<PgpSignature>(); bool attributeFound = false; @@ -648,11 +803,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp */ public IEnumerable<PgpSignature> GetKeySignatures() { - var result = subSigs; - if (result == null) - { - result = new List<PgpSignature>(keySigs); - } + var result = subSigs ?? new List<PgpSignature>(keySigs); return CollectionUtilities.Proxy(result); } @@ -947,56 +1098,38 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp /// <param name="key">The key the certifications are to be removed from.</param> /// <param name="certification">The certfication to be removed.</param> /// <returns>The modified key, null if the certification was not found.</returns> - public static PgpPublicKey RemoveCertification( - PgpPublicKey key, - PgpSignature certification) + public static PgpPublicKey RemoveCertification(PgpPublicKey key, PgpSignature certification) { - PgpPublicKey returnKey = new PgpPublicKey(key); - var sigs = returnKey.subSigs != null - ? returnKey.subSigs - : returnKey.keySigs; + var returnKey = new PgpPublicKey(key); + var sigs = returnKey.subSigs ?? returnKey.keySigs; -// bool found = sigs.Remove(certification); - int pos = sigs.IndexOf(certification); - bool found = pos >= 0; + if (sigs.Remove(certification)) + return returnKey; - if (found) + // TODO Java uses getRawUserIDs + foreach (string id in key.GetUserIds()) { - sigs.RemoveAt(pos); + if (ContainsSignature(key.GetSignaturesForId(id), certification)) + return RemoveCertification(returnKey, id, certification); } - else - { - foreach (string id in key.GetUserIds()) - { - foreach (object sig in key.GetSignaturesForId(id)) - { - // TODO Is this the right type of equality test? - if (certification == sig) - { - found = true; - returnKey = PgpPublicKey.RemoveCertification(returnKey, id, certification); - } - } - } - if (!found) - { - foreach (PgpUserAttributeSubpacketVector id in key.GetUserAttributes()) - { - foreach (object sig in key.GetSignaturesForUserAttribute(id)) - { - // TODO Is this the right type of equality test? - if (certification == sig) - { - found = true; - returnKey = PgpPublicKey.RemoveCertification(returnKey, id, certification); - } - } - } - } + foreach (PgpUserAttributeSubpacketVector id in key.GetUserAttributes()) + { + if (ContainsSignature(key.GetSignaturesForUserAttribute(id), certification)) + return RemoveCertification(returnKey, id, certification); } return returnKey; } + + private static bool ContainsSignature(IEnumerable<PgpSignature> signatures, PgpSignature signature) + { + foreach (PgpSignature candidate in signatures) + { + if (signature == candidate) + return true; + } + return false; + } } } diff --git a/crypto/src/openpgp/PgpPublicKeyEncryptedData.cs b/crypto/src/openpgp/PgpPublicKeyEncryptedData.cs index 04fe3ad37..8c6fcda53 100644 --- a/crypto/src/openpgp/PgpPublicKeyEncryptedData.cs +++ b/crypto/src/openpgp/PgpPublicKeyEncryptedData.cs @@ -1,19 +1,20 @@ using System; using System.IO; -using Org.BouncyCastle.Asn1.X9; +using Org.BouncyCastle.Asn1.Cryptlib; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.IO; -using Org.BouncyCastle.Crypto.Generators; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Math; -using Org.BouncyCastle.Math.EC; using Org.BouncyCastle.Security; using Org.BouncyCastle.Utilities.IO; +using Org.BouncyCastle.Crypto.Agreement; +using Org.BouncyCastle.Utilities; +using Org.BouncyCastle.Asn1.EdEC; namespace Org.BouncyCastle.Bcpg.OpenPgp { - /// <remarks>A public key encrypted data object.</remarks> + /// <remarks>A public key encrypted data object.</remarks> public class PgpPublicKeyEncryptedData : PgpEncryptedData { @@ -139,10 +140,9 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { truncStream = new TruncatedStream(encStream); - string digestName = PgpUtilities.GetDigestName(HashAlgorithmTag.Sha1); - IDigest digest = DigestUtilities.GetDigest(digestName); + IDigest digest = PgpUtilities.CreateDigest(HashAlgorithmTag.Sha1); - encStream = new DigestStream(truncStream, digest, null); + encStream = new DigestStream(truncStream, digest, null); } if (Streams.ReadFully(encStream, iv, 0, iv.Length) < iv.Length) @@ -189,76 +189,114 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { byte[][] secKeyData = keyData.GetEncSessionKey(); - if (keyData.Algorithm == PublicKeyAlgorithmTag.ECDH) + if (keyData.Algorithm != PublicKeyAlgorithmTag.ECDH) { - ECDHPublicBcpgKey ecKey = (ECDHPublicBcpgKey)privKey.PublicKeyPacket.Key; - X9ECParameters x9Params = ECKeyPairGenerator.FindECCurveByOid(ecKey.CurveOid); + IBufferedCipher cipher = GetKeyCipher(keyData.Algorithm); + + try + { + cipher.Init(false, privKey.Key); + } + catch (InvalidKeyException e) + { + throw new PgpException("error setting asymmetric cipher", e); + } + + if (keyData.Algorithm == PublicKeyAlgorithmTag.RsaEncrypt + || keyData.Algorithm == PublicKeyAlgorithmTag.RsaGeneral) + { + byte[] bi = secKeyData[0]; + + cipher.ProcessBytes(bi, 2, bi.Length - 2); + } + else + { + ElGamalPrivateKeyParameters k = (ElGamalPrivateKeyParameters)privKey.Key; + int size = (k.Parameters.P.BitLength + 7) / 8; + + ProcessEncodedMpi(cipher, size, secKeyData[0]); + ProcessEncodedMpi(cipher, size, secKeyData[1]); + } + + try + { + return cipher.DoFinal(); + } + catch (Exception e) + { + throw new PgpException("exception decrypting secret key", e); + } + } - byte[] enc = secKeyData[0]; + ECDHPublicBcpgKey ecPubKey = (ECDHPublicBcpgKey)privKey.PublicKeyPacket.Key; + byte[] enc = secKeyData[0]; - int pLen = ((((enc[0] & 0xff) << 8) + (enc[1] & 0xff)) + 7) / 8; - if ((2 + pLen + 1) > enc.Length) - throw new PgpException("encoded length out of range"); + int pLen = ((((enc[0] & 0xff) << 8) + (enc[1] & 0xff)) + 7) / 8; + if ((2 + pLen + 1) > enc.Length) + throw new PgpException("encoded length out of range"); - byte[] pEnc = new byte[pLen]; - Array.Copy(enc, 2, pEnc, 0, pLen); + byte[] pEnc = new byte[pLen]; + Array.Copy(enc, 2, pEnc, 0, pLen); - int keyLen = enc[pLen + 2]; - if ((2 + pLen + 1 + keyLen) > enc.Length) - throw new PgpException("encoded length out of range"); + int keyLen = enc[pLen + 2]; + if ((2 + pLen + 1 + keyLen) > enc.Length) + throw new PgpException("encoded length out of range"); - byte[] keyEnc = new byte[keyLen]; - Array.Copy(enc, 2 + pLen + 1, keyEnc, 0, keyEnc.Length); + byte[] keyEnc = new byte[keyLen]; + Array.Copy(enc, 2 + pLen + 1, keyEnc, 0, keyEnc.Length); - ECPoint publicPoint = x9Params.Curve.DecodePoint(pEnc); + var curveOid = ecPubKey.CurveOid; + byte[] secret; - ECPrivateKeyParameters privKeyParams = (ECPrivateKeyParameters)privKey.Key; - ECPoint S = publicPoint.Multiply(privKeyParams.D).Normalize(); + if (EdECObjectIdentifiers.id_X25519.Equals(curveOid) || + CryptlibObjectIdentifiers.curvey25519.Equals(curveOid)) + { + // skip the 0x40 header byte. + if (pEnc.Length != (1 + X25519PublicKeyParameters.KeySize) || 0x40 != pEnc[0]) + throw new ArgumentException("Invalid X25519 public key"); - KeyParameter key = new KeyParameter(Rfc6637Utilities.CreateKey(privKey.PublicKeyPacket, S)); + X25519PublicKeyParameters ephPub = new X25519PublicKeyParameters(pEnc, 1); - IWrapper w = PgpUtilities.CreateWrapper(ecKey.SymmetricKeyAlgorithm); - w.Init(false, key); + X25519Agreement agreement = new X25519Agreement(); + agreement.Init(privKey.Key); - return PgpPad.UnpadSessionData(w.Unwrap(keyEnc, 0, keyEnc.Length)); + secret = new byte[agreement.AgreementSize]; + agreement.CalculateAgreement(ephPub, secret, 0); } + else if (EdECObjectIdentifiers.id_X448.Equals(curveOid)) + { + // skip the 0x40 header byte. + if (pEnc.Length != (1 + X448PublicKeyParameters.KeySize) || 0x40 != pEnc[0]) + throw new ArgumentException("Invalid X448 public key"); - IBufferedCipher cipher = GetKeyCipher(keyData.Algorithm); + X448PublicKeyParameters ephPub = new X448PublicKeyParameters(pEnc, 1); - try - { - cipher.Init(false, privKey.Key); - } - catch (InvalidKeyException e) - { - throw new PgpException("error setting asymmetric cipher", e); - } + X448Agreement agreement = new X448Agreement(); + agreement.Init(privKey.Key); - if (keyData.Algorithm == PublicKeyAlgorithmTag.RsaEncrypt - || keyData.Algorithm == PublicKeyAlgorithmTag.RsaGeneral) - { - byte[] bi = secKeyData[0]; + secret = new byte[agreement.AgreementSize]; + agreement.CalculateAgreement(ephPub, secret, 0); + } + else + { + ECDomainParameters ecParameters = ((ECPrivateKeyParameters)privKey.Key).Parameters; - cipher.ProcessBytes(bi, 2, bi.Length - 2); - } - else - { - ElGamalPrivateKeyParameters k = (ElGamalPrivateKeyParameters)privKey.Key; - int size = (k.Parameters.P.BitLength + 7) / 8; + ECPublicKeyParameters ephPub = new ECPublicKeyParameters(ecParameters.Curve.DecodePoint(pEnc), + ecParameters); - ProcessEncodedMpi(cipher, size, secKeyData[0]); - ProcessEncodedMpi(cipher, size, secKeyData[1]); - } + ECDHBasicAgreement agreement = new ECDHBasicAgreement(); + agreement.Init(privKey.Key); + BigInteger S = agreement.CalculateAgreement(ephPub); + secret = BigIntegers.AsUnsignedByteArray(agreement.GetFieldSize(), S); + } - try - { - return cipher.DoFinal(); - } - catch (Exception e) - { - throw new PgpException("exception decrypting secret key", e); - } - } + KeyParameter key = new KeyParameter(Rfc6637Utilities.CreateKey(privKey.PublicKeyPacket, secret)); + + IWrapper w = PgpUtilities.CreateWrapper(ecPubKey.SymmetricKeyAlgorithm); + w.Init(false, key); + + return PgpPad.UnpadSessionData(w.Unwrap(keyEnc, 0, keyEnc.Length)); + } private static void ProcessEncodedMpi(IBufferedCipher cipher, int size, byte[] mpiEnc) { diff --git a/crypto/src/openpgp/PgpPublicKeyRing.cs b/crypto/src/openpgp/PgpPublicKeyRing.cs index 4aa15384c..ebbb95634 100644 --- a/crypto/src/openpgp/PgpPublicKeyRing.cs +++ b/crypto/src/openpgp/PgpPublicKeyRing.cs @@ -68,19 +68,16 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp /// <summary>Return the first public key in the ring.</summary> public virtual PgpPublicKey GetPublicKey() { - return (PgpPublicKey) keys[0]; + return keys[0]; } /// <summary>Return the public key referred to by the passed in key ID if it is present.</summary> - public virtual PgpPublicKey GetPublicKey( - long keyId) + public virtual PgpPublicKey GetPublicKey(long keyId) { foreach (PgpPublicKey k in keys) { if (keyId == k.KeyId) - { return k; - } } return null; @@ -168,23 +165,24 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp /// <returns>A new <c>PgpPublicKeyRing</c>, or null if pubKey is not found.</returns> public static PgpPublicKeyRing RemovePublicKey(PgpPublicKeyRing pubRing, PgpPublicKey pubKey) { - var keys = new List<PgpPublicKey>(pubRing.keys); + int count = pubRing.keys.Count; + long keyID = pubKey.KeyId; + + var result = new List<PgpPublicKey>(count); bool found = false; - // TODO Is there supposed to be at most a single match? - int pos = keys.Count; - while (--pos >= 0) + foreach (var key in pubRing.keys) { - PgpPublicKey key = keys[pos]; - - if (key.KeyId == pubKey.KeyId) + if (key.KeyId == keyID) { found = true; - keys.RemoveAt(pos); + continue; } + + result.Add(key); } - return found ? new PgpPublicKeyRing(keys) : null; + return found ? new PgpPublicKeyRing(result) : null; } internal static PublicKeyPacket ReadPublicKeyPacket(BcpgInputStream bcpgInput) diff --git a/crypto/src/openpgp/PgpSecretKey.cs b/crypto/src/openpgp/PgpSecretKey.cs index 51a45703a..0103cc187 100644 --- a/crypto/src/openpgp/PgpSecretKey.cs +++ b/crypto/src/openpgp/PgpSecretKey.cs @@ -2,10 +2,17 @@ using System; using System.Collections.Generic; using System.IO; +using Org.BouncyCastle.Asn1; +using Org.BouncyCastle.Asn1.Cryptlib; +using Org.BouncyCastle.Asn1.EdEC; +using Org.BouncyCastle.Asn1.Gnu; +using Org.BouncyCastle.Asn1.Pkcs; +using Org.BouncyCastle.Asn1.X509; using Org.BouncyCastle.Asn1.X9; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Math; +using Org.BouncyCastle.Math.EC.Rfc8032; using Org.BouncyCastle.Security; using Org.BouncyCastle.Utilities; @@ -13,6 +20,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { /// <remarks>General class to handle a PGP secret key object.</remarks> public class PgpSecretKey + : PgpObject { private readonly SecretKeyPacket secret; private readonly PgpPublicKey pub; @@ -52,10 +60,39 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp secKey = new DsaSecretBcpgKey(dsK.X); break; case PublicKeyAlgorithmTag.ECDH: + { + if (privKey.Key is ECPrivateKeyParameters ecdhK) + { + secKey = new ECSecretBcpgKey(ecdhK.D); + } + else + { + // 'reverse' because the native format for X25519 private keys is little-endian + X25519PrivateKeyParameters xK = (X25519PrivateKeyParameters)privKey.Key; + secKey = new ECSecretBcpgKey(new BigInteger(1, Arrays.ReverseInPlace(xK.GetEncoded()))); + } + break; + } case PublicKeyAlgorithmTag.ECDsa: ECPrivateKeyParameters ecK = (ECPrivateKeyParameters)privKey.Key; secKey = new ECSecretBcpgKey(ecK.D); break; + case PublicKeyAlgorithmTag.EdDsa: + { + if (privKey.Key is Ed25519PrivateKeyParameters ed25519K) + { + secKey = new EdSecretBcpgKey(new BigInteger(1, ed25519K.GetEncoded())); + } + else if (privKey.Key is Ed448PrivateKeyParameters ed448K) + { + secKey = new EdSecretBcpgKey(new BigInteger(1, ed448K.GetEncoded())); + } + else + { + throw new PgpException("unknown EdDSA key class"); + } + break; + } case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: ElGamalPrivateKeyParameters esK = (ElGamalPrivateKeyParameters) privKey.Key; @@ -625,6 +662,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp return null; PublicKeyPacket pubPk = secret.PublicKeyPacket; + try { byte[] data = ExtractKeyData(rawPassPhrase, clearPassPhrase); @@ -655,11 +693,65 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp privateKey = new DsaPrivateKeyParameters(dsaPriv.X, dsaParams); break; case PublicKeyAlgorithmTag.ECDH: - privateKey = GetECKey("ECDH", bcpgIn); + { + ECDHPublicBcpgKey ecdhPub = (ECDHPublicBcpgKey)pubPk.Key; + ECSecretBcpgKey ecdhPriv = new ECSecretBcpgKey(bcpgIn); + var curveOid = ecdhPub.CurveOid; + + if (EdECObjectIdentifiers.id_X25519.Equals(curveOid) || + CryptlibObjectIdentifiers.curvey25519.Equals(curveOid)) + { + // 'reverse' because the native format for X25519 private keys is little-endian + privateKey = PrivateKeyFactory.CreateKey(new PrivateKeyInfo( + new AlgorithmIdentifier(curveOid), + new DerOctetString(Arrays.ReverseInPlace(BigIntegers.AsUnsignedByteArray(ecdhPriv.X))))); + } + else if (EdECObjectIdentifiers.id_X448.Equals(curveOid)) + { + // 'reverse' because the native format for X448 private keys is little-endian + privateKey = PrivateKeyFactory.CreateKey(new PrivateKeyInfo( + new AlgorithmIdentifier(curveOid), + new DerOctetString(Arrays.ReverseInPlace(BigIntegers.AsUnsignedByteArray(ecdhPriv.X))))); + } + else + { + privateKey = new ECPrivateKeyParameters("ECDH", ecdhPriv.X, ecdhPub.CurveOid); + } break; + } case PublicKeyAlgorithmTag.ECDsa: - privateKey = GetECKey("ECDSA", bcpgIn); + { + ECPublicBcpgKey ecdsaPub = (ECPublicBcpgKey)pubPk.Key; + ECSecretBcpgKey ecdsaPriv = new ECSecretBcpgKey(bcpgIn); + + privateKey = new ECPrivateKeyParameters("ECDSA", ecdsaPriv.X, ecdsaPub.CurveOid); break; + } + case PublicKeyAlgorithmTag.EdDsa: + { + EdDsaPublicBcpgKey eddsaPub = (EdDsaPublicBcpgKey)pubPk.Key; + EdSecretBcpgKey ecdsaPriv = new EdSecretBcpgKey(bcpgIn); + + var curveOid = eddsaPub.CurveOid; + if (EdECObjectIdentifiers.id_Ed25519.Equals(curveOid) || + GnuObjectIdentifiers.Ed25519.Equals(curveOid)) + { + privateKey = PrivateKeyFactory.CreateKey(new PrivateKeyInfo( + new AlgorithmIdentifier(curveOid), + new DerOctetString(BigIntegers.AsUnsignedByteArray(Ed25519.SecretKeySize, ecdsaPriv.X)))); + } + else if (EdECObjectIdentifiers.id_Ed448.Equals(curveOid)) + { + privateKey = PrivateKeyFactory.CreateKey(new PrivateKeyInfo( + new AlgorithmIdentifier(curveOid), + new DerOctetString(BigIntegers.AsUnsignedByteArray(Ed448.SecretKeySize, ecdsaPriv.X)))); + } + else + { + throw new InvalidOperationException(); + } + break; + } case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: ElGamalPublicBcpgKey elPub = (ElGamalPublicBcpgKey)pubPk.Key; @@ -683,13 +775,6 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } - private ECPrivateKeyParameters GetECKey(string algorithm, BcpgInputStream bcpgIn) - { - ECPublicBcpgKey ecdsaPub = (ECPublicBcpgKey)secret.PublicKeyPacket.Key; - ECSecretBcpgKey ecdsaPriv = new ECSecretBcpgKey(bcpgIn); - return new ECPrivateKeyParameters(algorithm, ecdsaPriv.X, ecdsaPub.CurveOid); - } - private static byte[] Checksum( bool useSha1, byte[] bytes, @@ -699,7 +784,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { try { - IDigest dig = DigestUtilities.GetDigest("SHA1"); + IDigest dig = PgpUtilities.CreateDigest(HashAlgorithmTag.Sha1); dig.BlockUpdate(bytes, 0, length); return DigestUtilities.DoFinal(dig); } diff --git a/crypto/src/openpgp/PgpSecretKeyRing.cs b/crypto/src/openpgp/PgpSecretKeyRing.cs index 637cb45f8..a070aa132 100644 --- a/crypto/src/openpgp/PgpSecretKeyRing.cs +++ b/crypto/src/openpgp/PgpSecretKeyRing.cs @@ -71,11 +71,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp // revocation and direct signatures var keySigs = ReadSignaturesAndTrust(bcpgInput); - IList<object> ids; - IList<TrustPacket> idTrusts; - IList<IList<PgpSignature>> idSigs; - - ReadUserIDs(bcpgInput, out ids, out idTrusts, out idSigs); + ReadUserIDs(bcpgInput, out var ids, out var idTrusts, out var idSigs); keys.Add(new PgpSecretKey(secret, new PgpPublicKey(secret.PublicKeyPacket, trust, keySigs, ids, idTrusts, idSigs))); @@ -119,6 +115,43 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp return keys[0].PublicKey; } + /** + * Return any keys carrying a signature issued by the key represented by keyID. + * + * @param keyID the key id to be matched against. + * @return an iterator (possibly empty) of PGPPublicKey objects carrying signatures from keyID. + */ + public IEnumerable<PgpPublicKey> GetKeysWithSignaturesBy(long keyID) + { + var keysWithSigs = new List<PgpPublicKey>(); + + foreach (var k in GetPublicKeys()) + { + var sigIt = k.GetSignaturesForKeyID(keyID).GetEnumerator(); + + if (sigIt.MoveNext()) + { + keysWithSigs.Add(k); + } + } + + return CollectionUtilities.Proxy(keysWithSigs); + } + + public IEnumerable<PgpPublicKey> GetPublicKeys() + { + var pubKeys = new List<PgpPublicKey>(); + + foreach (var secretKey in keys) + { + pubKeys.Add(secretKey.PublicKey); + } + + pubKeys.AddRange(extraPubKeys); + + return CollectionUtilities.Proxy(pubKeys); + } + /// <summary>Return the master private key.</summary> public PgpSecretKey GetSecretKey() { @@ -156,7 +189,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp public byte[] GetEncoded() { - MemoryStream bOut = new MemoryStream(); + var bOut = new MemoryStream(); Encode(bOut); return bOut.ToArray(); } @@ -165,7 +198,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp Stream outStr) { if (outStr == null) - throw new ArgumentNullException("outStr"); + throw new ArgumentNullException(nameof(outStr)); foreach (PgpSecretKey key in keys) { diff --git a/crypto/src/openpgp/PgpSignature.cs b/crypto/src/openpgp/PgpSignature.cs index da00d43eb..9b596f279 100644 --- a/crypto/src/openpgp/PgpSignature.cs +++ b/crypto/src/openpgp/PgpSignature.cs @@ -3,6 +3,8 @@ using System.IO; using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Crypto; +using Org.BouncyCastle.Math; +using Org.BouncyCastle.Math.EC.Rfc8032; using Org.BouncyCastle.Security; using Org.BouncyCastle.Utilities; using Org.BouncyCastle.Utilities.Date; @@ -14,10 +16,10 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { private static SignaturePacket Cast(Packet packet) { - if (!(packet is SignaturePacket)) - throw new IOException("unexpected packet in stream: " + packet); + if (packet is SignaturePacket signaturePacket) + return signaturePacket; - return (SignaturePacket)packet; + throw new IOException("unexpected packet in stream: " + packet); } public const int BinaryDocument = 0x00; @@ -56,24 +58,13 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { } - internal PgpSignature( - SignaturePacket sigPacket, - TrustPacket trustPacket) + internal PgpSignature(SignaturePacket sigPacket, TrustPacket trustPacket) { - if (sigPacket == null) - throw new ArgumentNullException("sigPacket"); - - this.sigPck = sigPacket; + this.sigPck = sigPacket ?? throw new ArgumentNullException(nameof(sigPacket)); this.signatureType = sigPck.SignatureType; this.trustPck = trustPacket; } - private void GetSig() - { - this.sig = SignerUtilities.GetSigner( - PgpUtilities.GetSignatureName(sigPck.KeyAlgorithm, sigPck.HashAlgorithm)); - } - /// <summary>The OpenPGP version number for this signature.</summary> public int Version { @@ -98,17 +89,19 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp return IsCertification(SignatureType); } - public void InitVerify( - PgpPublicKey pubKey) + public void InitVerify(PgpPublicKey pubKey) { lastb = 0; + AsymmetricKeyParameter key = pubKey.GetKey(); + if (sig == null) - { - GetSig(); + { + this.sig = PgpUtilities.CreateSigner(sigPck.KeyAlgorithm, sigPck.HashAlgorithm, key); } + try { - sig.Init(false, pubKey.GetKey()); + sig.Init(false, key); } catch (InvalidKeyException e) { @@ -116,12 +109,11 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } - public void Update( - byte b) + public void Update(byte b) { if (signatureType == CanonicalTextDocument) { - doCanonicalUpdateByte(b); + DoCanonicalUpdateByte(b); } else { @@ -129,18 +121,17 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } - private void doCanonicalUpdateByte( - byte b) + private void DoCanonicalUpdateByte(byte b) { if (b == '\r') { - doUpdateCRLF(); + DoUpdateCRLF(); } else if (b == '\n') { if (lastb != '\r') { - doUpdateCRLF(); + DoUpdateCRLF(); } } else @@ -151,39 +142,56 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp lastb = b; } - private void doUpdateCRLF() + private void DoUpdateCRLF() { sig.Update((byte)'\r'); sig.Update((byte)'\n'); } - public void Update( - params byte[] bytes) + public void Update(params byte[] bytes) { Update(bytes, 0, bytes.Length); } - public void Update( - byte[] bytes, - int off, - int length) + public void Update(byte[] bytes, int off, int length) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + Update(bytes.AsSpan(off, length)); +#else if (signatureType == CanonicalTextDocument) { int finish = off + length; for (int i = off; i != finish; i++) { - doCanonicalUpdateByte(bytes[i]); + DoCanonicalUpdateByte(bytes[i]); } } else { sig.BlockUpdate(bytes, off, length); } +#endif } - public bool Verify() +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) + { + if (signatureType == CanonicalTextDocument) + { + for (int i = 0; i < input.Length; ++i) + { + DoCanonicalUpdateByte(input[i]); + } + } + else + { + sig.BlockUpdate(input); + } + } +#endif + + public bool Verify() { byte[] trailer = GetSignatureTrailer(); sig.BlockUpdate(trailer, 0, trailer.Length); @@ -234,7 +242,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp // try { - MemoryStream bOut = new MemoryStream(); + var bOut = new MemoryStream(); foreach (UserAttributeSubpacket packet in userAttributes.ToSubpacketArray()) { packet.Encode(bOut); @@ -248,7 +256,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp this.Update(sigPck.GetSignatureTrailer()); - return sig.VerifySignature(this.GetSignature()); + return sig.VerifySignature(GetSignature()); } /// <summary> @@ -345,15 +353,15 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp public PgpSignatureSubpacketVector GetHashedSubPackets() { - return createSubpacketVector(sigPck.GetHashedSubPackets()); + return CreateSubpacketVector(sigPck.GetHashedSubPackets()); } public PgpSignatureSubpacketVector GetUnhashedSubPackets() { - return createSubpacketVector(sigPck.GetUnhashedSubPackets()); + return CreateSubpacketVector(sigPck.GetUnhashedSubPackets()); } - private PgpSignatureSubpacketVector createSubpacketVector(SignatureSubpacket[] pcks) + private static PgpSignatureSubpacketVector CreateSubpacketVector(SignatureSubpacket[] pcks) { return pcks == null ? null : new PgpSignatureSubpacketVector(pcks); } @@ -369,10 +377,39 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { signature = sigValues[0].Value.ToByteArrayUnsigned(); } - else - { - try + else if (KeyAlgorithm == PublicKeyAlgorithmTag.EdDsa) + { + if (sigValues.Length != 2) + throw new InvalidOperationException(); + + BigInteger v0 = sigValues[0].Value; + BigInteger v1 = sigValues[1].Value; + + if (v0.BitLength == 918 && + v1.Equals(BigInteger.Zero) && + v0.ShiftRight(912).Equals(BigInteger.ValueOf(0x40))) + { + signature = new byte[Ed448.SignatureSize]; + BigIntegers.AsUnsignedByteArray(v0.ClearBit(918), signature, 0, signature.Length); + } + else if (v0.BitLength <= 256 && v1.BitLength <= 256) + { + signature = new byte[Ed25519.SignatureSize]; + BigIntegers.AsUnsignedByteArray(sigValues[0].Value, signature, 0, 32); + BigIntegers.AsUnsignedByteArray(sigValues[1].Value, signature, 32, 32); + } + else { + throw new InvalidOperationException(); + } + } + else + { + if (sigValues.Length != 2) + throw new InvalidOperationException(); + + try + { signature = new DerSequence( new DerInteger(sigValues[0].Value), new DerInteger(sigValues[1].Value)).GetEncoded(); @@ -394,17 +431,16 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp // TODO Handle the encoding stuff by subclassing BcpgObject? public byte[] GetEncoded() { - MemoryStream bOut = new MemoryStream(); + var bOut = new MemoryStream(); Encode(bOut); return bOut.ToArray(); } - public void Encode( - Stream outStream) + public void Encode(Stream outStream) { - BcpgOutputStream bcpgOut = BcpgOutputStream.Wrap(outStream); + var bcpgOut = BcpgOutputStream.Wrap(outStream); bcpgOut.WritePacket(sigPck); @@ -414,8 +450,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } - private byte[] GetEncodedPublicKey( - PgpPublicKey pubKey) + private static byte[] GetEncodedPublicKey(PgpPublicKey pubKey) { try { @@ -436,13 +471,13 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { switch (signatureType) { - case DefaultCertification: - case NoCertification: - case CasualCertification: - case PositiveCertification: - return true; - default: - return false; + case DefaultCertification: + case NoCertification: + case CasualCertification: + case PositiveCertification: + return true; + default: + return false; } } } diff --git a/crypto/src/openpgp/PgpSignatureGenerator.cs b/crypto/src/openpgp/PgpSignatureGenerator.cs index c5309689f..12edf9f89 100644 --- a/crypto/src/openpgp/PgpSignatureGenerator.cs +++ b/crypto/src/openpgp/PgpSignatureGenerator.cs @@ -5,19 +5,20 @@ using Org.BouncyCastle.Bcpg.Sig; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Math; +using Org.BouncyCastle.Math.EC.Rfc8032; using Org.BouncyCastle.Security; using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Bcpg.OpenPgp { /// <remarks>Generator for PGP signatures.</remarks> - // TODO Should be able to implement ISigner? public class PgpSignatureGenerator { private static readonly SignatureSubpacket[] EmptySignatureSubpackets = new SignatureSubpacket[0]; - private PublicKeyAlgorithmTag keyAlgorithm; - private HashAlgorithmTag hashAlgorithm; + private readonly PublicKeyAlgorithmTag keyAlgorithm; + private readonly HashAlgorithmTag hashAlgorithm; + private PgpPrivateKey privKey; private ISigner sig; private IDigest dig; @@ -35,33 +36,39 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp this.keyAlgorithm = keyAlgorithm; this.hashAlgorithm = hashAlgorithm; - dig = DigestUtilities.GetDigest(PgpUtilities.GetDigestName(hashAlgorithm)); - sig = SignerUtilities.GetSigner(PgpUtilities.GetSignatureName(keyAlgorithm, hashAlgorithm)); + dig = PgpUtilities.CreateDigest(hashAlgorithm); } /// <summary>Initialise the generator for signing.</summary> public void InitSign( int sigType, - PgpPrivateKey key) + PgpPrivateKey privKey) { - InitSign(sigType, key, null); + InitSign(sigType, privKey, null); } /// <summary>Initialise the generator for signing.</summary> public void InitSign( int sigType, - PgpPrivateKey key, + PgpPrivateKey privKey, SecureRandom random) { - this.privKey = key; + this.privKey = privKey; this.signatureType = sigType; - try + AsymmetricKeyParameter key = privKey.Key; + + if (sig == null) { - ICipherParameters cp = key.Key; + this.sig = PgpUtilities.CreateSigner(keyAlgorithm, hashAlgorithm, key); + } + + try + { + ICipherParameters cp = key; if (random != null) { - cp = new ParametersWithRandom(key.Key, random); + cp = new ParametersWithRandom(cp, random); } sig.Init(true, cp); @@ -75,72 +82,68 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp lastb = 0; } - public void Update( - byte b) + public void Update(byte b) { if (signatureType == PgpSignature.CanonicalTextDocument) { - doCanonicalUpdateByte(b); + DoCanonicalUpdateByte(b); } else { - doUpdateByte(b); + DoUpdateByte(b); } } - private void doCanonicalUpdateByte( - byte b) + private void DoCanonicalUpdateByte(byte b) { if (b == '\r') { - doUpdateCRLF(); + DoUpdateCRLF(); } else if (b == '\n') { if (lastb != '\r') { - doUpdateCRLF(); + DoUpdateCRLF(); } } else { - doUpdateByte(b); + DoUpdateByte(b); } lastb = b; } - private void doUpdateCRLF() + private void DoUpdateCRLF() { - doUpdateByte((byte)'\r'); - doUpdateByte((byte)'\n'); + DoUpdateByte((byte)'\r'); + DoUpdateByte((byte)'\n'); } - private void doUpdateByte( - byte b) + private void DoUpdateByte(byte b) { sig.Update(b); dig.Update(b); } - public void Update( - params byte[] b) + public void Update(params byte[] b) { Update(b, 0, b.Length); } - public void Update( - byte[] b, - int off, - int len) + public void Update(byte[] b, int off, int len) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + Update(b.AsSpan(off, len)); +#else if (signatureType == PgpSignature.CanonicalTextDocument) { int finish = off + len; for (int i = off; i != finish; i++) { - doCanonicalUpdateByte(b[i]); + DoCanonicalUpdateByte(b[i]); } } else @@ -148,9 +151,28 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp sig.BlockUpdate(b, off, len); dig.BlockUpdate(b, off, len); } +#endif + } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) + { + if (signatureType == PgpSignature.CanonicalTextDocument) + { + for (int i = 0; i < input.Length; ++i) + { + DoCanonicalUpdateByte(input[i]); + } + } + else + { + sig.BlockUpdate(input); + dig.BlockUpdate(input); + } } +#endif - public void SetHashedSubpackets( + public void SetHashedSubpackets( PgpSignatureSubpacketVector hashedPackets) { hashed = hashedPackets == null @@ -180,15 +202,15 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { SignatureSubpacket[] hPkts = hashed, unhPkts = unhashed; - if (!packetPresent(hashed, SignatureSubpacketTag.CreationTime)) + if (!IsPacketPresent(hashed, SignatureSubpacketTag.CreationTime)) { - hPkts = insertSubpacket(hPkts, new SignatureCreationTime(false, DateTime.UtcNow)); + hPkts = InsertSubpacket(hPkts, new SignatureCreationTime(false, DateTime.UtcNow)); } - if (!packetPresent(hashed, SignatureSubpacketTag.IssuerKeyId) - && !packetPresent(unhashed, SignatureSubpacketTag.IssuerKeyId)) + if (!IsPacketPresent(hashed, SignatureSubpacketTag.IssuerKeyId) + && !IsPacketPresent(unhashed, SignatureSubpacketTag.IssuerKeyId)) { - unhPkts = insertSubpacket(unhPkts, new IssuerKeyId(false, privKey.KeyId)); + unhPkts = InsertSubpacket(unhPkts, new IssuerKeyId(false, privKey.KeyId)); } int version = 4; @@ -239,17 +261,41 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp byte[] sigBytes = sig.GenerateSignature(); byte[] digest = DigestUtilities.DoFinal(dig); - byte[] fingerPrint = new byte[] { digest[0], digest[1] }; + byte[] fingerPrint = new byte[2]{ digest[0], digest[1] }; - // an RSA signature - bool isRsa = keyAlgorithm == PublicKeyAlgorithmTag.RsaSign - || keyAlgorithm == PublicKeyAlgorithmTag.RsaGeneral; - - MPInteger[] sigValues = isRsa - ? PgpUtilities.RsaSigToMpi(sigBytes) - : PgpUtilities.DsaSigToMpi(sigBytes); + MPInteger[] sigValues; + if (keyAlgorithm == PublicKeyAlgorithmTag.EdDsa) + { + int sigLen = sigBytes.Length; + if (sigLen == Ed25519.SignatureSize) + { + sigValues = new MPInteger[2]{ + new MPInteger(new BigInteger(1, sigBytes, 0, 32)), + new MPInteger(new BigInteger(1, sigBytes, 32, 32)) + }; + } + else if (sigLen == Ed448.SignatureSize) + { + sigValues = new MPInteger[2]{ + new MPInteger(new BigInteger(1, Arrays.Prepend(sigBytes, 0x40))), + new MPInteger(BigInteger.Zero) + }; + } + else + { + throw new InvalidOperationException(); + } + } + else if (keyAlgorithm == PublicKeyAlgorithmTag.RsaSign || keyAlgorithm == PublicKeyAlgorithmTag.RsaGeneral) + { + sigValues = PgpUtilities.RsaSigToMpi(sigBytes); + } + else + { + sigValues = PgpUtilities.DsaSigToMpi(sigBytes); + } - return new PgpSignature( + return new PgpSignature( new SignaturePacket(signatureType, privKey.KeyId, keyAlgorithm, hashAlgorithm, hPkts, unhPkts, fingerPrint, sigValues)); } @@ -258,9 +304,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp /// <param name="id">The ID we are certifying against the public key.</param> /// <param name="pubKey">The key we are certifying against the ID.</param> /// <returns>The certification.</returns> - public PgpSignature GenerateCertification( - string id, - PgpPublicKey pubKey) + public PgpSignature GenerateCertification(string id, PgpPublicKey pubKey) { UpdateWithPublicKey(pubKey); @@ -276,9 +320,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp /// <param name="userAttributes">The ID we are certifying against the public key.</param> /// <param name="pubKey">The key we are certifying against the ID.</param> /// <returns>The certification.</returns> - public PgpSignature GenerateCertification( - PgpUserAttributeSubpacketVector userAttributes, - PgpPublicKey pubKey) + public PgpSignature GenerateCertification(PgpUserAttributeSubpacketVector userAttributes, PgpPublicKey pubKey) { UpdateWithPublicKey(pubKey); @@ -287,7 +329,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp // try { - MemoryStream bOut = new MemoryStream(); + var bOut = new MemoryStream(); foreach (UserAttributeSubpacket packet in userAttributes.ToSubpacketArray()) { packet.Encode(bOut); @@ -299,16 +341,14 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp throw new PgpException("cannot encode subpacket array", e); } - return this.Generate(); + return Generate(); } /// <summary>Generate a certification for the passed in key against the passed in master key.</summary> /// <param name="masterKey">The key we are certifying against.</param> /// <param name="pubKey">The key we are certifying.</param> /// <returns>The certification.</returns> - public PgpSignature GenerateCertification( - PgpPublicKey masterKey, - PgpPublicKey pubKey) + public PgpSignature GenerateCertification(PgpPublicKey masterKey, PgpPublicKey pubKey) { UpdateWithPublicKey(masterKey); UpdateWithPublicKey(pubKey); @@ -319,16 +359,14 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp /// <summary>Generate a certification, such as a revocation, for the passed in key.</summary> /// <param name="pubKey">The key we are certifying.</param> /// <returns>The certification.</returns> - public PgpSignature GenerateCertification( - PgpPublicKey pubKey) + public PgpSignature GenerateCertification(PgpPublicKey pubKey) { UpdateWithPublicKey(pubKey); return Generate(); } - private byte[] GetEncodedPublicKey( - PgpPublicKey pubKey) + private static byte[] GetEncodedPublicKey(PgpPublicKey pubKey) { try { @@ -340,42 +378,31 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } - private bool packetPresent( - SignatureSubpacket[] packets, - SignatureSubpacketTag type) + private static bool IsPacketPresent(SignatureSubpacket[] packets, SignatureSubpacketTag type) { for (int i = 0; i != packets.Length; i++) { if (packets[i].SubpacketType == type) - { return true; - } } return false; } - private SignatureSubpacket[] insertSubpacket( - SignatureSubpacket[] packets, - SignatureSubpacket subpacket) + private static SignatureSubpacket[] InsertSubpacket(SignatureSubpacket[] packets, SignatureSubpacket subpacket) { - SignatureSubpacket[] tmp = new SignatureSubpacket[packets.Length + 1]; - tmp[0] = subpacket; - packets.CopyTo(tmp, 1); - return tmp; + return Arrays.Prepend(packets, subpacket); } - private void UpdateWithIdData( - int header, - byte[] idBytes) + private void UpdateWithIdData(int header, byte[] idBytes) { - this.Update( + Update( (byte) header, (byte)(idBytes.Length >> 24), (byte)(idBytes.Length >> 16), (byte)(idBytes.Length >> 8), (byte)(idBytes.Length)); - this.Update(idBytes); + Update(idBytes); } private void UpdateWithPublicKey( @@ -383,11 +410,11 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { byte[] keyBytes = GetEncodedPublicKey(key); - this.Update( - (byte) 0x99, + Update( + 0x99, (byte)(keyBytes.Length >> 8), (byte)(keyBytes.Length)); - this.Update(keyBytes); + Update(keyBytes); } } } diff --git a/crypto/src/openpgp/PgpUtilities.cs b/crypto/src/openpgp/PgpUtilities.cs index f33969ea8..2642f3497 100644 --- a/crypto/src/openpgp/PgpUtilities.cs +++ b/crypto/src/openpgp/PgpUtilities.cs @@ -9,7 +9,9 @@ using Org.BouncyCastle.Asn1.Sec; using Org.BouncyCastle.Asn1.X9; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Parameters; +using Org.BouncyCastle.Crypto.Signers; using Org.BouncyCastle.Math; +using Org.BouncyCastle.Pqc.Crypto.SphincsPlus; using Org.BouncyCastle.Security; using Org.BouncyCastle.Utilities; using Org.BouncyCastle.Utilities.Encoders; @@ -114,7 +116,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp if (NameToHashID.TryGetValue(name, out var hashAlgorithmTag)) return (int)hashAlgorithmTag; - throw new ArgumentException("unable to map " + name + " to a hash id", "name"); + throw new ArgumentException("unable to map " + name + " to a hash id", nameof(name)); } /** @@ -152,6 +154,9 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp case PublicKeyAlgorithmTag.ECDsa: encAlg = "ECDSA"; break; + case PublicKeyAlgorithmTag.EdDsa: + encAlg = "EdDSA"; + break; case PublicKeyAlgorithmTag.ElGamalEncrypt: // in some malformed cases. case PublicKeyAlgorithmTag.ElGamalGeneral: encAlg = "ElGamal"; @@ -163,7 +168,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp return GetDigestName(hashAlgorithm) + "with" + encAlg; } - public static string GetSymmetricCipherName( + public static string GetSymmetricCipherName( SymmetricKeyAlgorithmTag algorithm) { switch (algorithm) @@ -301,11 +306,9 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp IDigest digest; if (s2k != null) { - string digestName = GetDigestName(s2k.HashAlgorithm); - try { - digest = DigestUtilities.GetDigest(digestName); + digest = CreateDigest(s2k.HashAlgorithm); } catch (Exception e) { @@ -368,7 +371,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { try { - digest = DigestUtilities.GetDigest("MD5"); + digest = CreateDigest(HashAlgorithmTag.MD5); for (int i = 0; i != loopCount; i++) { @@ -407,7 +410,6 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp return MakeKey(algorithm, keyBytes); } -#if !PORTABLE || DOTNET /// <summary>Write out the passed in file as a literal data packet.</summary> public static void WriteFileToLiteralData( Stream output, @@ -452,12 +454,10 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp Platform.Dispose(inputStream); } } -#endif private const int ReadAhead = 60; - private static bool IsPossiblyBase64( - int ch) + private static bool IsPossiblyBase64(int ch) { return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || (ch == '+') || (ch == '/') @@ -473,7 +473,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp { // TODO Remove this restriction? if (!inputStream.CanSeek) - throw new ArgumentException("inputStream must be seek-able", "inputStream"); + throw new ArgumentException("inputStream must be seek-able", nameof(inputStream)); long markedPos = inputStream.Position; @@ -552,6 +552,41 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp } } + internal static IDigest CreateDigest(HashAlgorithmTag hashAlgorithm) + { + return DigestUtilities.GetDigest(GetDigestName(hashAlgorithm)); + } + + internal static ISigner CreateSigner(PublicKeyAlgorithmTag publicKeyAlgorithm, HashAlgorithmTag hashAlgorithm, + AsymmetricKeyParameter key) + { + switch (publicKeyAlgorithm) + { + case PublicKeyAlgorithmTag.EdDsa: + { + ISigner signer; + if (key is Ed25519PrivateKeyParameters || key is Ed25519PublicKeyParameters) + { + signer = new Ed25519Signer(); + } + else if (key is Ed448PrivateKeyParameters || key is Ed448PublicKeyParameters) + { + signer = new Ed448Signer(Arrays.EmptyBytes); + } + else + { + throw new InvalidOperationException(); + } + + return new EdDsaSigner(signer, CreateDigest(hashAlgorithm)); + } + default: + { + return SignerUtilities.GetSigner(GetSignatureName(publicKeyAlgorithm, hashAlgorithm)); + } + } + } + internal static IWrapper CreateWrapper(SymmetricKeyAlgorithmTag encAlgorithm) { switch (encAlgorithm) diff --git a/crypto/src/openpgp/PgpV3SignatureGenerator.cs b/crypto/src/openpgp/PgpV3SignatureGenerator.cs index c7113e0ae..324dbd768 100644 --- a/crypto/src/openpgp/PgpV3SignatureGenerator.cs +++ b/crypto/src/openpgp/PgpV3SignatureGenerator.cs @@ -1,3 +1,5 @@ +using System; + using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Security; @@ -6,11 +8,11 @@ using Org.BouncyCastle.Utilities.Date; namespace Org.BouncyCastle.Bcpg.OpenPgp { /// <remarks>Generator for old style PGP V3 Signatures.</remarks> - // TODO Should be able to implement ISigner? public class PgpV3SignatureGenerator { - private PublicKeyAlgorithmTag keyAlgorithm; - private HashAlgorithmTag hashAlgorithm; + private readonly PublicKeyAlgorithmTag keyAlgorithm; + private readonly HashAlgorithmTag hashAlgorithm; + private PgpPrivateKey privKey; private ISigner sig; private IDigest dig; @@ -22,36 +24,40 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm) { + if (keyAlgorithm == PublicKeyAlgorithmTag.EdDsa) + throw new ArgumentException("Invalid algorithm for V3 signature", nameof(keyAlgorithm)); + this.keyAlgorithm = keyAlgorithm; this.hashAlgorithm = hashAlgorithm; - dig = DigestUtilities.GetDigest(PgpUtilities.GetDigestName(hashAlgorithm)); - sig = SignerUtilities.GetSigner(PgpUtilities.GetSignatureName(keyAlgorithm, hashAlgorithm)); + dig = PgpUtilities.CreateDigest(hashAlgorithm); } /// <summary>Initialise the generator for signing.</summary> - public void InitSign( - int sigType, - PgpPrivateKey key) + public void InitSign(int sigType, PgpPrivateKey privKey) { - InitSign(sigType, key, null); + InitSign(sigType, privKey, null); } /// <summary>Initialise the generator for signing.</summary> - public void InitSign( - int sigType, - PgpPrivateKey key, - SecureRandom random) + public void InitSign(int sigType, PgpPrivateKey privKey, SecureRandom random) { - this.privKey = key; + this.privKey = privKey; this.signatureType = sigType; - try + AsymmetricKeyParameter key = privKey.Key; + + if (sig == null) { - ICipherParameters cp = key.Key; + this.sig = PgpUtilities.CreateSigner(keyAlgorithm, hashAlgorithm, key); + } + + try + { + ICipherParameters cp = key; if (random != null) { - cp = new ParametersWithRandom(key.Key, random); + cp = new ParametersWithRandom(cp, random); } sig.Init(true, cp); @@ -65,93 +71,98 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp lastb = 0; } - public void Update( - byte b) + public void Update(byte b) { if (signatureType == PgpSignature.CanonicalTextDocument) { - doCanonicalUpdateByte(b); + DoCanonicalUpdateByte(b); } else { - doUpdateByte(b); + DoUpdateByte(b); } } - private void doCanonicalUpdateByte( - byte b) + private void DoCanonicalUpdateByte(byte b) { if (b == '\r') { - doUpdateCRLF(); + DoUpdateCRLF(); } else if (b == '\n') { if (lastb != '\r') { - doUpdateCRLF(); + DoUpdateCRLF(); } } else { - doUpdateByte(b); + DoUpdateByte(b); } lastb = b; } - private void doUpdateCRLF() + private void DoUpdateCRLF() { - doUpdateByte((byte)'\r'); - doUpdateByte((byte)'\n'); + DoUpdateByte((byte)'\r'); + DoUpdateByte((byte)'\n'); } - private void doUpdateByte( + private void DoUpdateByte( byte b) { sig.Update(b); dig.Update(b); } - public void Update( - byte[] b) + public void Update(params byte[] b) + { + Update(b, 0, b.Length); + } + + public void Update(byte[] b, int off, int len) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + Update(b.AsSpan(off, len)); +#else if (signatureType == PgpSignature.CanonicalTextDocument) { - for (int i = 0; i != b.Length; i++) + int finish = off + len; + + for (int i = off; i != finish; i++) { - doCanonicalUpdateByte(b[i]); + DoCanonicalUpdateByte(b[i]); } } else { - sig.BlockUpdate(b, 0, b.Length); - dig.BlockUpdate(b, 0, b.Length); + sig.BlockUpdate(b, off, len); + dig.BlockUpdate(b, off, len); } +#endif } - public void Update( - byte[] b, - int off, - int len) +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) { if (signatureType == PgpSignature.CanonicalTextDocument) { - int finish = off + len; - - for (int i = off; i != finish; i++) + for (int i = 0; i < input.Length; ++i) { - doCanonicalUpdateByte(b[i]); + DoCanonicalUpdateByte(input[i]); } } else { - sig.BlockUpdate(b, off, len); - dig.BlockUpdate(b, off, len); + sig.BlockUpdate(input); + dig.BlockUpdate(input); } } +#endif - /// <summary>Return the one pass header associated with the current signature.</summary> + /// <summary>Return the one pass header associated with the current signature.</summary> public PgpOnePassSignature GenerateOnePassVersion( bool isNested) { diff --git a/crypto/src/openpgp/Rfc6637Utilities.cs b/crypto/src/openpgp/Rfc6637Utilities.cs index 5d992ec51..e1405f481 100644 --- a/crypto/src/openpgp/Rfc6637Utilities.cs +++ b/crypto/src/openpgp/Rfc6637Utilities.cs @@ -69,11 +69,16 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp public static byte[] CreateKey(PublicKeyPacket pubKeyData, ECPoint s) { + return CreateKey(pubKeyData, s.AffineXCoord.GetEncoded()); + } + + public static byte[] CreateKey(PublicKeyPacket pubKeyData, byte[] secret) + { byte[] userKeyingMaterial = CreateUserKeyingMaterial(pubKeyData); ECDHPublicBcpgKey ecKey = (ECDHPublicBcpgKey)pubKeyData.Key; - return Kdf(ecKey.HashAlgorithm, s, GetKeyLength(ecKey.SymmetricKeyAlgorithm), userKeyingMaterial); + return Kdf(ecKey.HashAlgorithm, secret, GetKeyLength(ecKey.SymmetricKeyAlgorithm), userKeyingMaterial); } // RFC 6637 - Section 8 @@ -116,12 +121,9 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp // ZB = x; // MB = Hash ( 00 || 00 || 00 || 01 || ZB || Param ); // return oBits leftmost bits of MB. - private static byte[] Kdf(HashAlgorithmTag digestAlg, ECPoint s, int keyLen, byte[] parameters) + private static byte[] Kdf(HashAlgorithmTag digestAlg, byte[] ZB, int keyLen, byte[] parameters) { - byte[] ZB = s.XCoord.GetEncoded(); - - string digestName = PgpUtilities.GetDigestName(digestAlg); - IDigest digest = DigestUtilities.GetDigest(digestName); + IDigest digest = PgpUtilities.CreateDigest(digestAlg); digest.Update(0x00); digest.Update(0x00); diff --git a/crypto/src/openpgp/WrappedGeneratorStream.cs b/crypto/src/openpgp/WrappedGeneratorStream.cs index c54ee0b3b..6f96dc9b8 100644 --- a/crypto/src/openpgp/WrappedGeneratorStream.cs +++ b/crypto/src/openpgp/WrappedGeneratorStream.cs @@ -13,10 +13,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp internal WrappedGeneratorStream(IStreamGenerator generator, Stream s) : base(s) { - if (generator == null) - throw new ArgumentNullException(nameof(generator)); - - m_generator = generator; + m_generator = generator ?? throw new ArgumentNullException(nameof(generator)); } protected override void Dispose(bool disposing) diff --git a/crypto/src/pqc/crypto/cmce/CmceEngine.cs b/crypto/src/pqc/crypto/cmce/CmceEngine.cs index 10b08e708..96595ecc0 100644 --- a/crypto/src/pqc/crypto/cmce/CmceEngine.cs +++ b/crypto/src/pqc/crypto/cmce/CmceEngine.cs @@ -173,7 +173,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Cmce { buf[i] = perm[i]; buf[i] <<= 31; - buf[i] |= i; + buf[i] |= (uint)i; buf[i] &= 0x7fffffffffffffffL; // getting rid of signed longs } Sort64(buf, 0, buf.Length); @@ -1162,7 +1162,9 @@ namespace Org.BouncyCastle.Pqc.Crypto.Cmce { for (x = 0; x < n; ++x) { - temp[(int)x] = ((GetQShort(temp, (int)(qIndex + x)) ^ 1) << 16) | GetQShort(temp, (int)((qIndex) + (x ^ 1))); + ushort t0 = (ushort)GetQShort(temp, (int)(qIndex + x)); + ushort t1 = (ushort)GetQShort(temp, (int)(qIndex + (x ^ 1))); + temp[(int)x] = ((t0 ^ 1) << 16) | t1; } } Sort32(temp, 0, (int)n); /* A = (id<<16)+pibar */ @@ -1181,7 +1183,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Cmce for (x = 0; x < n; ++x) { - temp[(int)x] = (int)((temp[(int)x] << 16) | x); /* A = (pibar<<16)+id */ + temp[(int)x] = (int)((uint)(temp[(int)x] << 16) | x); /* A = (pibar<<16)+id */ } Sort32(temp, 0, (int)n); /* A = (id<<16)+pibar^-1 */ @@ -1204,7 +1206,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Cmce for (x = 0; x < n; ++x) { - temp[(int)x] = (int)(((temp[(int)(n + x)] & ~0x3ff) << 6) | x); /* A = (p<<16)+id */ + temp[(int)x] = (int)(((uint)(temp[(int)(n + x)] & ~0x3ff) << 6) | x); /* A = (p<<16)+id */ } Sort32(temp, 0, (int)n); /* A = (id<<16)+p^{-1} */ @@ -1241,7 +1243,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Cmce /* B = (p<<16)+c */ for (x = 0; x < n; ++x) { - temp[(int)x] = (int)((temp[(int)(n + x)] & ~0xffff) | x); + temp[(int)x] = (int)((uint)(temp[(int)(n + x)] & ~0xffff) | x); } Sort32(temp, 0, (int)n); /* A = (id<<16)+p^(-1) */ for (x = 0; x < n; ++x) @@ -1375,7 +1377,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Cmce { buf[i] = perm[i]; buf[i] <<= 31; - buf[i] |= i; + buf[i] |= (uint)i; // buf[i] &= 0x7fffffffffffffffL; // getting rid of signed longs } // Sort32 the buffer diff --git a/crypto/src/pqc/crypto/crystals/dilithium/PolyVecK.cs b/crypto/src/pqc/crypto/crystals/dilithium/PolyVecK.cs index facbc1f33..315ce6ab0 100644 --- a/crypto/src/pqc/crypto/crystals/dilithium/PolyVecK.cs +++ b/crypto/src/pqc/crypto/crystals/dilithium/PolyVecK.cs @@ -2,21 +2,20 @@ { internal class PolyVecK { - public Poly[] Vec; - private DilithiumEngine Engine; - private int Mode; - private int PolyVecBytes; - private int K; - private int L; + public readonly Poly[] Vec; + private readonly DilithiumEngine Engine; + //private readonly int Mode; + private readonly int K; + //private readonly int L; public PolyVecK(DilithiumEngine Engine) { this.Engine = Engine; - Mode = Engine.Mode; + //Mode = Engine.Mode; K = Engine.K; - L = Engine.L; + //L = Engine.L; Vec = new Poly[K]; - + for (int i = 0; i < K; i++) { Vec[i] = new Poly(Engine); @@ -25,9 +24,8 @@ public void UniformEta(byte[] seed, ushort nonce) { - int i; ushort n = nonce; - for (i = 0; i < K; i++) + for (int i = 0; i < K; i++) { Vec[i].UniformEta(seed, n++); } @@ -99,8 +97,7 @@ public void PackW1(byte[] r) { - int i; - for (i = 0; i < K; i++) + for (int i = 0; i < K; i++) { Vec[i].PackW1(r, i * Engine.PolyW1PackedBytes); } @@ -119,21 +116,18 @@ for (int i = 0; i < K; ++i) { if (Vec[i].CheckNorm(bound)) - { return true; - } } return false; } public int MakeHint(PolyVecK v0, PolyVecK v1) { - int i, s = 0; - for (i = 0; i < K; ++i) + int s = 0; + for (int i = 0; i < K; ++i) { s += Vec[i].PolyMakeHint(v0.Vec[i], v1.Vec[i]); } - return s; } @@ -152,6 +146,5 @@ Vec[i].ShiftLeft(); } } - } } diff --git a/crypto/src/pqc/crypto/crystals/dilithium/PolyVecL.cs b/crypto/src/pqc/crypto/crystals/dilithium/PolyVecL.cs index 58c286768..0a87c2070 100644 --- a/crypto/src/pqc/crypto/crystals/dilithium/PolyVecL.cs +++ b/crypto/src/pqc/crypto/crystals/dilithium/PolyVecL.cs @@ -2,17 +2,16 @@ { internal class PolyVecL { - public Poly[] Vec; - private DilithiumEngine Engine; - private int Mode; - private int PolyVecBytes; - private int L; - private int K; + public readonly Poly[] Vec; + //private DilithiumEngine Engine; + //private int Mode; + private readonly int L; + private readonly int K; public PolyVecL(DilithiumEngine Engine) { - this.Engine = Engine; - Mode = Engine.Mode; + //this.Engine = Engine; + //Mode = Engine.Mode; L = Engine.L; K = Engine.K; Vec = new Poly[L]; @@ -24,8 +23,7 @@ public void UniformEta(byte[] seed, ushort nonce) { - int i; - for (i = 0; i < L; i++) + for (int i = 0; i < L; i++) { Vec[i].UniformEta(seed, nonce++); } diff --git a/crypto/src/pqc/crypto/crystals/kyber/KyberEngine.cs b/crypto/src/pqc/crypto/crystals/kyber/KyberEngine.cs index bf9d5ee3c..e30115a95 100644 --- a/crypto/src/pqc/crypto/crystals/kyber/KyberEngine.cs +++ b/crypto/src/pqc/crypto/crystals/kyber/KyberEngine.cs @@ -138,7 +138,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Crystals.Kyber internal void KemDecrypt(byte[] sharedSecret, byte[] cipherText, byte[] secretKey) { - int i; byte[] buf = new byte[2 * SymBytes], kr = new byte[2 * SymBytes], cmp = new byte[CipherTextBytes]; byte[] pk = Arrays.CopyOfRange(secretKey, IndCpaSecretKeyBytes, secretKey.Length); m_indCpa.Decrypt(buf, cipherText, secretKey); @@ -161,7 +160,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Crystals.Kyber private void CMov(byte[] r, byte[] x, int len, bool b) { - int i; if (b) { Array.Copy(x, 0, r, 0, len); diff --git a/crypto/src/pqc/crypto/crystals/kyber/KyberIndCpa.cs b/crypto/src/pqc/crypto/crystals/kyber/KyberIndCpa.cs index b3be4770d..9400b776e 100644 --- a/crypto/src/pqc/crypto/crystals/kyber/KyberIndCpa.cs +++ b/crypto/src/pqc/crypto/crystals/kyber/KyberIndCpa.cs @@ -138,7 +138,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Crystals.Kyber private void PackPublicKey(out byte[] pk, PolyVec pkpv, byte[] seed) { - int i; pk = new byte[m_engine.IndCpaPublicKeyBytes]; pkpv.ToBytes(pk); Array.Copy(seed, 0, pk, m_engine.PolyVecBytes, KyberEngine.SymBytes); @@ -146,7 +145,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Crystals.Kyber private void UnpackPublicKey(PolyVec pkpv, byte[] seed, byte[] pk) { - int i; pkpv.FromBytes(pk); Array.Copy(pk, m_engine.PolyVecBytes, seed, 0, KyberEngine.SymBytes); } diff --git a/crypto/src/pqc/crypto/falcon/FalconKeyPairGenerator.cs b/crypto/src/pqc/crypto/falcon/FalconKeyPairGenerator.cs index eafd1a9eb..68f90c97f 100644 --- a/crypto/src/pqc/crypto/falcon/FalconKeyPairGenerator.cs +++ b/crypto/src/pqc/crypto/falcon/FalconKeyPairGenerator.cs @@ -8,7 +8,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Falcon { private FalconKeyGenerationParameters parameters; private SecureRandom random; - private FalconNIST nist; + private FalconNist nist; private uint logn; private uint noncelen; @@ -18,32 +18,31 @@ namespace Org.BouncyCastle.Pqc.Crypto.Falcon { this.parameters = (FalconKeyGenerationParameters)param; this.random = param.Random; - this.logn = ((FalconKeyGenerationParameters)param).Parameters.LogN; - this.noncelen = ((FalconKeyGenerationParameters)param).Parameters.NonceLength; - this.nist = new FalconNIST(random, logn, noncelen); + this.logn = (uint)((FalconKeyGenerationParameters)param).Parameters.LogN; + this.noncelen = (uint)((FalconKeyGenerationParameters)param).Parameters.NonceLength; + this.nist = new FalconNist(random, logn, noncelen); int n = 1 << (int)this.logn; - int sk_coeff_size = 8; - if (n == 1024) - { - sk_coeff_size = 5; - } - else if (n == 256 || n == 512) - { - sk_coeff_size = 6; - } - else if (n == 64 || n == 128) - { - sk_coeff_size = 7; - } + //int sk_coeff_size = 8; + //if (n == 1024) + //{ + // sk_coeff_size = 5; + //} + //else if (n == 256 || n == 512) + //{ + // sk_coeff_size = 6; + //} + //else if (n == 64 || n == 128) + //{ + // sk_coeff_size = 7; + //} this.pk_size = 1 + (14 * n / 8); } public AsymmetricCipherKeyPair GenerateKeyPair() { - byte[] pk, sk, f, g, F; - nist.crypto_sign_keypair(out pk, out f, out g, out F); - FalconParameters p = ((FalconKeyGenerationParameters)this.parameters).Parameters; + nist.crypto_sign_keypair(out byte[] pk, out byte[] f, out byte[] g, out byte[] F); + FalconParameters p = this.parameters.Parameters; FalconPrivateKeyParameters privk = new FalconPrivateKeyParameters(p, f, g, F, pk); FalconPublicKeyParameters pubk = new FalconPublicKeyParameters(p, pk); return new AsymmetricCipherKeyPair(pubk, privk); diff --git a/crypto/src/pqc/crypto/falcon/FalconKeyParameters.cs b/crypto/src/pqc/crypto/falcon/FalconKeyParameters.cs index 95a546994..bb1252706 100644 --- a/crypto/src/pqc/crypto/falcon/FalconKeyParameters.cs +++ b/crypto/src/pqc/crypto/falcon/FalconKeyParameters.cs @@ -3,7 +3,7 @@ using Org.BouncyCastle.Crypto; namespace Org.BouncyCastle.Pqc.Crypto.Falcon { - public class FalconKeyParameters + public abstract class FalconKeyParameters : AsymmetricKeyParameter { private FalconParameters parameters; diff --git a/crypto/src/pqc/crypto/falcon/FalconNIST.cs b/crypto/src/pqc/crypto/falcon/FalconNIST.cs index cce790734..0d2ba46e0 100644 --- a/crypto/src/pqc/crypto/falcon/FalconNIST.cs +++ b/crypto/src/pqc/crypto/falcon/FalconNIST.cs @@ -1,10 +1,11 @@ using System; + using Org.BouncyCastle.Security; using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Pqc.Crypto.Falcon { - class FalconNIST + internal class FalconNist { private FalconCodec codec; private FalconVrfy vrfy; @@ -26,7 +27,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Falcon return this.CRYPTO_BYTES; } - internal FalconNIST(SecureRandom random, uint logn, uint noncelen) { + internal FalconNist(SecureRandom random, uint logn, uint noncelen) { this.logn = logn; this.codec = new FalconCodec(); this.common = new FalconCommon(); diff --git a/crypto/src/pqc/crypto/falcon/FalconParameters.cs b/crypto/src/pqc/crypto/falcon/FalconParameters.cs index 4a9bc598f..10d22a241 100644 --- a/crypto/src/pqc/crypto/falcon/FalconParameters.cs +++ b/crypto/src/pqc/crypto/falcon/FalconParameters.cs @@ -1,16 +1,17 @@ using Org.BouncyCastle.Crypto; +using System; namespace Org.BouncyCastle.Pqc.Crypto.Falcon { public sealed class FalconParameters : ICipherParameters { - public static FalconParameters falcon_512 = new FalconParameters("falcon512", 9, 40); - public static FalconParameters falcon_1024 = new FalconParameters("falcon1024", 10, 40); + public static readonly FalconParameters falcon_512 = new FalconParameters("falcon512", 9, 40); + public static readonly FalconParameters falcon_1024 = new FalconParameters("falcon1024", 10, 40); - private string name; - private uint logn; - private uint nonce_length; + private readonly string name; + private readonly uint logn; + private readonly uint nonce_length; private FalconParameters(string name, uint logn, uint nonce_length) { @@ -19,9 +20,9 @@ namespace Org.BouncyCastle.Pqc.Crypto.Falcon this.nonce_length = nonce_length; } - public uint LogN => logn; + public int LogN => Convert.ToInt32(logn); - public uint NonceLength => nonce_length; + public int NonceLength => Convert.ToInt32(nonce_length); public string Name => name; } diff --git a/crypto/src/pqc/crypto/falcon/FalconPrivateKeyParameters.cs b/crypto/src/pqc/crypto/falcon/FalconPrivateKeyParameters.cs index c912a222c..12b055add 100644 --- a/crypto/src/pqc/crypto/falcon/FalconPrivateKeyParameters.cs +++ b/crypto/src/pqc/crypto/falcon/FalconPrivateKeyParameters.cs @@ -3,13 +3,13 @@ using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Pqc.Crypto.Falcon { - public class FalconPrivateKeyParameters + public sealed class FalconPrivateKeyParameters : FalconKeyParameters { - private byte[] pk; - private byte[] f; - private byte[] g; - private byte[] F; + private readonly byte[] pk; + private readonly byte[] f; + private readonly byte[] g; + private readonly byte[] F; public FalconPrivateKeyParameters(FalconParameters parameters, byte[] f, byte[] g, byte[] F, byte[] pk_encoded) : base(true, parameters) @@ -30,7 +30,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Falcon return Arrays.Clone(pk); } - public byte[] GetSpolyf() + public byte[] GetSpolyLittleF() { return Arrays.Clone(f); } @@ -40,7 +40,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Falcon return Arrays.Clone(g); } - public byte[] GetSpolyF() + public byte[] GetSpolyBigF() { return Arrays.Clone(F); } diff --git a/crypto/src/pqc/crypto/falcon/FalconPublicKeyParameters.cs b/crypto/src/pqc/crypto/falcon/FalconPublicKeyParameters.cs index 72bb11948..fa6b627ab 100644 --- a/crypto/src/pqc/crypto/falcon/FalconPublicKeyParameters.cs +++ b/crypto/src/pqc/crypto/falcon/FalconPublicKeyParameters.cs @@ -2,10 +2,10 @@ using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Pqc.Crypto.Falcon { - public class FalconPublicKeyParameters + public sealed class FalconPublicKeyParameters : FalconKeyParameters { - private byte[] publicKey; + private readonly byte[] publicKey; public FalconPublicKeyParameters(FalconParameters parameters, byte[] h) : base(false, parameters) diff --git a/crypto/src/pqc/crypto/falcon/FalconSigner.cs b/crypto/src/pqc/crypto/falcon/FalconSigner.cs index f581386ee..e77e84102 100644 --- a/crypto/src/pqc/crypto/falcon/FalconSigner.cs +++ b/crypto/src/pqc/crypto/falcon/FalconSigner.cs @@ -9,7 +9,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Falcon : IMessageSigner { private byte[] encodedkey; - private FalconNIST nist; + private FalconNist nist; public void Init(bool forSigning, ICipherParameters param) { @@ -19,29 +19,29 @@ namespace Org.BouncyCastle.Pqc.Crypto.Falcon { FalconPrivateKeyParameters skparam = (FalconPrivateKeyParameters)withRandom.Parameters; encodedkey = skparam.GetEncoded(); - nist = new FalconNIST( + nist = new FalconNist( withRandom.Random, - skparam.Parameters.LogN, - skparam.Parameters.NonceLength); + (uint)skparam.Parameters.LogN, + (uint)skparam.Parameters.NonceLength); } else { FalconPrivateKeyParameters skparam = (FalconPrivateKeyParameters)param; encodedkey = ((FalconPrivateKeyParameters)param).GetEncoded(); - nist = new FalconNIST( + nist = new FalconNist( CryptoServicesRegistrar.GetSecureRandom(), - skparam.Parameters.LogN, - skparam.Parameters.NonceLength); + (uint)skparam.Parameters.LogN, + (uint)skparam.Parameters.NonceLength); } } else { FalconPublicKeyParameters pkparam = (FalconPublicKeyParameters)param; encodedkey = pkparam.GetEncoded(); - nist = new FalconNIST( + nist = new FalconNist( CryptoServicesRegistrar.GetSecureRandom(), - pkparam.Parameters.LogN, - pkparam.Parameters.NonceLength); + (uint)pkparam.Parameters.LogN, + (uint)pkparam.Parameters.NonceLength); } } diff --git a/crypto/src/pqc/crypto/hqc/ReedSolomon.cs b/crypto/src/pqc/crypto/hqc/ReedSolomon.cs index 8e7fc664d..25a8c7997 100644 --- a/crypto/src/pqc/crypto/hqc/ReedSolomon.cs +++ b/crypto/src/pqc/crypto/hqc/ReedSolomon.cs @@ -28,7 +28,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Hqc for (int j = 0; j < paramG; j++) { tmp[j] = GFCalculator.mult(gateValue, rsPoly[j]); - int n = 1; } for (int j = n1 - paramK - 1; j > 0; j--) diff --git a/crypto/src/pqc/crypto/lms/Composer.cs b/crypto/src/pqc/crypto/lms/Composer.cs index b897f4b68..6ad044e34 100644 --- a/crypto/src/pqc/crypto/lms/Composer.cs +++ b/crypto/src/pqc/crypto/lms/Composer.cs @@ -1,4 +1,3 @@ -using System; using System.IO; using Org.BouncyCastle.Utilities; @@ -38,7 +37,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms return this; } - public Composer U16Str(uint n) + public Composer U16Str(int n) { n &= 0xFFFF; bos.WriteByte((byte)(n >> 8)); @@ -72,7 +71,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms return this; } - public Composer Bytes(byte[][] arrays) + public Composer Bytes2(byte[][] arrays) { foreach (byte[] array in arrays) { @@ -81,7 +80,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms return this; } - public Composer Bytes(byte[][] arrays, int start, int end) + public Composer Bytes2(byte[][] arrays, int start, int end) { int j = start; while (j != end) diff --git a/crypto/src/pqc/crypto/lms/HSS.cs b/crypto/src/pqc/crypto/lms/HSS.cs index 9c21198e4..4634088c7 100644 --- a/crypto/src/pqc/crypto/lms/HSS.cs +++ b/crypto/src/pqc/crypto/lms/HSS.cs @@ -39,17 +39,19 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms 0, I, 1 << lms.LMSigParameters.H, - rootSeed); + rootSeed, + isPlaceholder: false); } else { - keys[t] = new PlaceholderLMSPrivateKey( + keys[t] = new LmsPrivateKeyParameters( lms.LMSigParameters, lms.LMOtsParameters, -1, zero, 1 << lms.LMSigParameters.H, - zero); + zero, + isPlaceholder: true); } hssKeyMaxIndex <<= lms.LMSigParameters.H; } @@ -161,7 +163,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms public static bool VerifySignature(HssPublicKeyParameters publicKey, HssSignature signature, byte[] message) { - int Nspk = signature.GetlMinus1(); + int Nspk = signature.GetLMinus1(); if (Nspk + 1 != publicKey.L) return false; @@ -196,25 +198,5 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms } return Lms.VerifySignature(key, sigList[Nspk], message); } - - private class PlaceholderLMSPrivateKey - : LmsPrivateKeyParameters - { - internal PlaceholderLMSPrivateKey(LMSigParameters lmsParameter, LMOtsParameters otsParameters, int q, - byte[] I, int maxQ, byte[] masterSecret) - : base(lmsParameter, otsParameters, q, I, maxQ, masterSecret) - { - } - - internal override LMOtsPrivateKey GetNextOtsPrivateKey() - { - throw new Exception("placeholder only"); - } - - public override LmsPublicKeyParameters GetPublicKey() - { - throw new Exception("placeholder only"); - } - } } } diff --git a/crypto/src/pqc/crypto/lms/HSSSignature.cs b/crypto/src/pqc/crypto/lms/HSSSignature.cs index 7c4599835..21f0397c8 100644 --- a/crypto/src/pqc/crypto/lms/HSSSignature.cs +++ b/crypto/src/pqc/crypto/lms/HSSSignature.cs @@ -9,15 +9,15 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms public sealed class HssSignature : IEncodable { - private int lMinus1; - private LmsSignedPubKey[] signedPubKey; - private LmsSignature signature; + private readonly int m_lMinus1; + private readonly LmsSignedPubKey[] m_signedPubKey; + private readonly LmsSignature m_signature; public HssSignature(int lMinus1, LmsSignedPubKey[] signedPubKey, LmsSignature signature) { - this.lMinus1 = lMinus1; - this.signedPubKey = signedPubKey; - this.signature = signature; + m_lMinus1 = lMinus1; + m_signedPubKey = signedPubKey; + m_signature = signature; } /** @@ -73,81 +73,63 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms throw new ArgumentException($"cannot parse {src}"); } - // FIXME - public int GetlMinus1() + public int GetLMinus1() { - return lMinus1; + return m_lMinus1; } + // FIXME public LmsSignedPubKey[] GetSignedPubKeys() { - return signedPubKey; + return m_signedPubKey; } - public LmsSignature Signature => signature; + public LmsSignature Signature => m_signature; - public override bool Equals(Object o) + public override bool Equals(object other) { - if (this == o) - { + if (this == other) return true; - } - - if (o == null || GetType() != o.GetType()) - { + if (!(other is HssSignature that)) return false; - } - HssSignature signature1 = (HssSignature) o; - - if (lMinus1 != signature1.lMinus1) - { + if (this.m_lMinus1 != that.m_lMinus1) return false; - } - - // FIXME - // Probably incorrect - comparing Object[] arrays with Arrays.equals - if (signedPubKey.Length != signature1.signedPubKey.Length) - { + if (this.m_signedPubKey.Length != that.m_signedPubKey.Length) return false; - } - for (int t = 0; t < signedPubKey.Length; t++) + for (int t = 0; t < m_signedPubKey.Length; t++) { - if (!signedPubKey[t].Equals(signature1.signedPubKey[t])) - { + if (!this.m_signedPubKey[t].Equals(that.m_signedPubKey[t])) return false; - } } - return signature != null ? signature.Equals(signature1.signature) : signature1.signature == null; + return Equals(this.m_signature, that.m_signature); } public override int GetHashCode() { - int result = lMinus1; - result = 31 * result + signedPubKey.GetHashCode(); - result = 31 * result + (signature != null ? signature.GetHashCode() : 0); + int result = m_lMinus1; + result = 31 * result + m_signedPubKey.GetHashCode(); + result = 31 * result + (m_signature != null ? m_signature.GetHashCode() : 0); return result; } public byte[] GetEncoded() { Composer composer = Composer.Compose(); - composer.U32Str(lMinus1); - if (signedPubKey != null) + composer.U32Str(m_lMinus1); + if (m_signedPubKey != null) { - foreach (LmsSignedPubKey sigPub in signedPubKey) + foreach (LmsSignedPubKey sigPub in m_signedPubKey) { composer.Bytes(sigPub); } } - composer.Bytes(signature); + composer.Bytes(m_signature); return composer.Build(); - } - } } diff --git a/crypto/src/pqc/crypto/lms/LMOtsParameters.cs b/crypto/src/pqc/crypto/lms/LMOtsParameters.cs index e05b1650a..60bf28d50 100644 --- a/crypto/src/pqc/crypto/lms/LMOtsParameters.cs +++ b/crypto/src/pqc/crypto/lms/LMOtsParameters.cs @@ -1,3 +1,4 @@ +using System; using System.Collections.Generic; using Org.BouncyCastle.Asn1; @@ -53,7 +54,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms public int Ls => m_ls; - public uint SigLen => m_sigLen; + public int SigLen => Convert.ToInt32(m_sigLen); public DerObjectIdentifier DigestOid => m_digestOid; diff --git a/crypto/src/pqc/crypto/lms/LMOtsPrivateKey.cs b/crypto/src/pqc/crypto/lms/LMOtsPrivateKey.cs index e9df6fbfd..20b717af6 100644 --- a/crypto/src/pqc/crypto/lms/LMOtsPrivateKey.cs +++ b/crypto/src/pqc/crypto/lms/LMOtsPrivateKey.cs @@ -30,7 +30,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms LmsUtilities.ByteArray(m_I, ctx); LmsUtilities.U32Str(m_q, ctx); - LmsUtilities.U16Str(LMOts.D_MESG, ctx); + LmsUtilities.U16Str((short)LMOts.D_MESG, ctx); LmsUtilities.ByteArray(C, ctx); return new LmsContext(this, sigParams, ctx, C, path); diff --git a/crypto/src/pqc/crypto/lms/LMOtsPublicKey.cs b/crypto/src/pqc/crypto/lms/LMOtsPublicKey.cs index 09e8b2951..ef3d4aced 100644 --- a/crypto/src/pqc/crypto/lms/LMOtsPublicKey.cs +++ b/crypto/src/pqc/crypto/lms/LMOtsPublicKey.cs @@ -109,7 +109,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms LmsUtilities.ByteArray(m_I, ctx); LmsUtilities.U32Str(m_q, ctx); - LmsUtilities.U16Str(LMOts.D_MESG, ctx); + LmsUtilities.U16Str((short)LMOts.D_MESG, ctx); LmsUtilities.ByteArray(signature.C, ctx); return new LmsContext(this, signature, ctx); @@ -121,7 +121,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms LmsUtilities.ByteArray(m_I, ctx); LmsUtilities.U32Str(m_q, ctx); - LmsUtilities.U16Str(LMOts.D_MESG, ctx); + LmsUtilities.U16Str((short)LMOts.D_MESG, ctx); LmsUtilities.ByteArray(signature.OtsSignature.C, ctx); return new LmsContext(this, signature, ctx); diff --git a/crypto/src/pqc/crypto/lms/LMS.cs b/crypto/src/pqc/crypto/lms/LMS.cs index 3c17b0a1e..6174d3889 100644 --- a/crypto/src/pqc/crypto/lms/LMS.cs +++ b/crypto/src/pqc/crypto/lms/LMS.cs @@ -100,7 +100,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms H.BlockUpdate(I, 0, I.Length); LmsUtilities.U32Str(node_num, H); - LmsUtilities.U16Str(D_LEAF, H); + LmsUtilities.U16Str((short)D_LEAF, H); H.BlockUpdate(Kc, 0, Kc.Length); H.DoFinal(tmp, 0); @@ -113,7 +113,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms // is odd H.BlockUpdate(I, 0, I.Length); LmsUtilities.U32Str(node_num / 2, H); - LmsUtilities.U16Str(D_INTR, H); + LmsUtilities.U16Str((short)D_INTR, H); H.BlockUpdate(path[i], 0, path[i].Length); H.BlockUpdate(tmp, 0, tmp.Length); H.DoFinal(tmp, 0); @@ -122,7 +122,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms { H.BlockUpdate(I, 0, I.Length); LmsUtilities.U32Str(node_num / 2, H); - LmsUtilities.U16Str(D_INTR, H); + LmsUtilities.U16Str((short)D_INTR, H); H.BlockUpdate(tmp, 0, tmp.Length); H.BlockUpdate(path[i], 0, path[i].Length); H.DoFinal(tmp, 0); diff --git a/crypto/src/pqc/crypto/lms/LMSKeyParameters.cs b/crypto/src/pqc/crypto/lms/LMSKeyParameters.cs index b35ba36c4..aaddfb823 100644 --- a/crypto/src/pqc/crypto/lms/LMSKeyParameters.cs +++ b/crypto/src/pqc/crypto/lms/LMSKeyParameters.cs @@ -6,7 +6,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms public abstract class LmsKeyParameters : AsymmetricKeyParameter, IEncodable { - protected LmsKeyParameters(bool isPrivateKey) + internal LmsKeyParameters(bool isPrivateKey) : base(isPrivateKey) { } diff --git a/crypto/src/pqc/crypto/lms/LMSPrivateKeyParameters.cs b/crypto/src/pqc/crypto/lms/LMSPrivateKeyParameters.cs index 25ca81938..278cbb04b 100644 --- a/crypto/src/pqc/crypto/lms/LMSPrivateKeyParameters.cs +++ b/crypto/src/pqc/crypto/lms/LMSPrivateKeyParameters.cs @@ -9,7 +9,7 @@ using Org.BouncyCastle.Utilities.IO; namespace Org.BouncyCastle.Pqc.Crypto.Lms { - public class LmsPrivateKeyParameters + public sealed class LmsPrivateKeyParameters : LmsKeyParameters, ILmsContextBasedSigner { private static CacheKey T1 = new CacheKey(1); @@ -34,6 +34,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms private IDigest tDigest; private int q; + private readonly bool m_isPlaceholder; // // These are not final because they can be generated. @@ -41,9 +42,14 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms // private LmsPublicKeyParameters publicKey; - public LmsPrivateKeyParameters(LMSigParameters lmsParameter, LMOtsParameters otsParameters, int q, byte[] I, int maxQ, byte[] masterSecret) + : this(lmsParameter, otsParameters, q, I, maxQ, masterSecret, false) + { + } + + internal LmsPrivateKeyParameters(LMSigParameters lmsParameter, LMOtsParameters otsParameters, int q, byte[] I, + int maxQ, byte[] masterSecret, bool isPlaceholder) : base(true) { this.parameters = lmsParameter; @@ -55,6 +61,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms this.maxCacheR = 1 << (parameters.H + 1); this.tCache = new Dictionary<CacheKey, byte[]>(); this.tDigest = DigestUtilities.GetDigest(lmsParameter.DigestOid); + this.m_isPlaceholder = isPlaceholder; } private LmsPrivateKeyParameters(LmsPrivateKeyParameters parent, int q, int maxQ) @@ -203,8 +210,11 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms } } - internal virtual LMOtsPrivateKey GetNextOtsPrivateKey() + internal LMOtsPrivateKey GetNextOtsPrivateKey() { + if (m_isPlaceholder) + throw new Exception("placeholder only"); + lock (this) { if (q >= maxQ) @@ -264,8 +274,11 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms return maxQ - q; } - public virtual LmsPublicKeyParameters GetPublicKey() + public LmsPublicKeyParameters GetPublicKey() { + if (m_isPlaceholder) + throw new Exception("placeholder only"); + lock (this) { if (publicKey == null) @@ -276,7 +289,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms } } - byte[] FindT(int r) + internal byte[] FindT(int r) { if (r < maxCacheR) { @@ -290,14 +303,10 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms { lock (tCache) { - byte[] t; - if (!tCache.TryGetValue(key, out t)) - { - t = CalcT(key.index); - tCache[key] = t; - } + if (tCache.TryGetValue(key, out byte[] t)) + return t; - return t; + return tCache[key] = CalcT(key.index); } } @@ -315,7 +324,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms { LmsUtilities.ByteArray(this.GetI(), tDigest); LmsUtilities.U32Str(r, tDigest); - LmsUtilities.U16Str(Lms.D_LEAF, tDigest); + LmsUtilities.U16Str((short)Lms.D_LEAF, tDigest); // // These can be pre generated at the time of key generation and held within the private key. // However it will cost memory to have them stick around. @@ -334,7 +343,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms LmsUtilities.ByteArray(this.GetI(), tDigest); LmsUtilities.U32Str(r, tDigest); - LmsUtilities.U16Str(Lms.D_INTR, tDigest); + LmsUtilities.U16Str((short)Lms.D_INTR, tDigest); LmsUtilities.ByteArray(t2r, tDigest); LmsUtilities.ByteArray(t2rPlus1, tDigest); T = new byte[tDigest.GetDigestSize()]; diff --git a/crypto/src/pqc/crypto/lms/LMSPublicKeyParameters.cs b/crypto/src/pqc/crypto/lms/LMSPublicKeyParameters.cs index fa12b47c3..f8d0970af 100644 --- a/crypto/src/pqc/crypto/lms/LMSPublicKeyParameters.cs +++ b/crypto/src/pqc/crypto/lms/LMSPublicKeyParameters.cs @@ -6,7 +6,7 @@ using Org.BouncyCastle.Utilities.IO; namespace Org.BouncyCastle.Pqc.Crypto.Lms { - public class LmsPublicKeyParameters + public sealed class LmsPublicKeyParameters : LmsKeyParameters, ILmsContextBasedVerifier { private LMSigParameters parameterSet; diff --git a/crypto/src/pqc/crypto/lms/LMSSignature.cs b/crypto/src/pqc/crypto/lms/LMSSignature.cs index f5d355297..a1ae475c1 100644 --- a/crypto/src/pqc/crypto/lms/LMSSignature.cs +++ b/crypto/src/pqc/crypto/lms/LMSSignature.cs @@ -123,7 +123,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms .U32Str(q) .Bytes(otsSignature.GetEncoded()) .U32Str(parameter.ID) - .Bytes(y) + .Bytes2(y) .Build(); } diff --git a/crypto/src/pqc/crypto/lms/LM_OTS.cs b/crypto/src/pqc/crypto/lms/LM_OTS.cs index c3cd3da90..0aa5c580e 100644 --- a/crypto/src/pqc/crypto/lms/LM_OTS.cs +++ b/crypto/src/pqc/crypto/lms/LM_OTS.cs @@ -220,7 +220,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms IDigest finalContext = DigestUtilities.GetDigest(parameter.DigestOid); LmsUtilities.ByteArray(I, finalContext); LmsUtilities.U32Str(q, finalContext); - LmsUtilities.U16Str(D_PBLC, finalContext); + LmsUtilities.U16Str((short)D_PBLC, finalContext); byte[] tmp = Composer.Compose() .Bytes(I) diff --git a/crypto/src/pqc/crypto/lms/LmsUtils.cs b/crypto/src/pqc/crypto/lms/LmsUtils.cs index da3f457d2..e99dfe585 100644 --- a/crypto/src/pqc/crypto/lms/LmsUtils.cs +++ b/crypto/src/pqc/crypto/lms/LmsUtils.cs @@ -14,7 +14,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Lms d.Update((byte)(n)); } - public static void U16Str(ushort n, IDigest d) + public static void U16Str(short n, IDigest d) { d.Update((byte)(n >> 8)); d.Update((byte)(n)); diff --git a/crypto/src/pqc/crypto/picnic/KMatrices.cs b/crypto/src/pqc/crypto/picnic/KMatrices.cs index 64e6be00a..a6d280985 100644 --- a/crypto/src/pqc/crypto/picnic/KMatrices.cs +++ b/crypto/src/pqc/crypto/picnic/KMatrices.cs @@ -1,5 +1,3 @@ -using Org.BouncyCastle.Utilities; - namespace Org.BouncyCastle.Pqc.Crypto.Picnic { internal class KMatrices @@ -9,36 +7,35 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic private int columns; private uint[] data; - public KMatrices(int nmatrices, int rows, int columns, uint[] data) + internal KMatrices(int nmatrices, int rows, int columns, uint[] data) { this.nmatrices = nmatrices; this.rows = rows; this.columns = columns; this.data = data; } - - public int GetNmatrices() + internal int GetNmatrices() { return nmatrices; } - public int GetSize() + internal int GetSize() { return rows * columns; } - public int GetRows() + internal int GetRows() { return rows; } - public int GetColumns() + internal int GetColumns() { return columns; } - public uint[] GetData() + internal uint[] GetData() { return data; } @@ -48,20 +45,21 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic : KMatrices { private int matrixPointer; - public int GetMatrixPointer() + + internal int GetMatrixPointer() { return matrixPointer; } - public void SetMatrixPointer(int matrixPointer) + internal void SetMatrixPointer(int matrixPointer) { this.matrixPointer = matrixPointer; } - public KMatricesWithPointer(KMatrices m) + internal KMatricesWithPointer(KMatrices m) : base(m.GetNmatrices(), m.GetRows(), m.GetColumns(), m.GetData()) { this.matrixPointer = 0; } } -} \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/picnic/Msg.cs b/crypto/src/pqc/crypto/picnic/Msg.cs index 4a8c145e7..a9a13b383 100644 --- a/crypto/src/pqc/crypto/picnic/Msg.cs +++ b/crypto/src/pqc/crypto/picnic/Msg.cs @@ -1,12 +1,12 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic { - public class Msg + internal class Msg { internal byte[][] msgs; // One for each player internal int pos; internal int unopened; // Index of the unopened party, or -1 if all parties opened (when signing) - public Msg(PicnicEngine engine) + internal Msg(PicnicEngine engine) { msgs = new byte[engine.numMPCParties][]; // engine.andSizeBytes for (int i = 0; i < engine.numMPCParties; i++) @@ -17,4 +17,4 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic unopened = -1; } } -} \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/picnic/PicnicEngine.cs b/crypto/src/pqc/crypto/picnic/PicnicEngine.cs index 0e2a4b54f..5557ddcff 100644 --- a/crypto/src/pqc/crypto/picnic/PicnicEngine.cs +++ b/crypto/src/pqc/crypto/picnic/PicnicEngine.cs @@ -8,17 +8,17 @@ using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Pqc.Crypto.Picnic { - public class PicnicEngine + internal sealed class PicnicEngine { // same for all parameter sets - protected internal static readonly int saltSizeBytes = 32; + internal static readonly int saltSizeBytes = 32; private static readonly uint MAX_DIGEST_SIZE = 64; private static readonly int WORD_SIZE_BITS = 32; // the word size for the implementation. Not a LowMC parameter private static readonly uint LOWMC_MAX_STATE_SIZE = 64; - protected internal static readonly uint LOWMC_MAX_WORDS = (LOWMC_MAX_STATE_SIZE / 4); - protected internal static readonly uint LOWMC_MAX_KEY_BITS = 256; - protected internal static readonly uint LOWMC_MAX_AND_GATES = (3 * 38 * 10 + 4); /* Rounded to nearest byte */ + internal static readonly uint LOWMC_MAX_WORDS = (LOWMC_MAX_STATE_SIZE / 4); + internal static readonly uint LOWMC_MAX_KEY_BITS = 256; + internal static readonly uint LOWMC_MAX_AND_GATES = (3 * 38 * 10 + 4); /* Rounded to nearest byte */ private static readonly uint MAX_AUX_BYTES = ((LOWMC_MAX_AND_GATES + LOWMC_MAX_KEY_BITS) / 8 + 1); /* Maximum lengths in bytes */ @@ -28,8 +28,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic /** Largest serialized public key size, in bytes */ private static readonly uint PICNIC_MAX_PRIVATEKEY_SIZE = (3 * PICNIC_MAX_LOWMC_BLOCK_SIZE + 2); - /** Largest serialized private key size, in bytes */ - private static readonly uint PICNIC_MAX_SIGNATURE_SIZE = 209522; + //private static readonly uint PICNIC_MAX_SIGNATURE_SIZE = 209522; /** Largest signature size, in bytes */ @@ -47,45 +46,45 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic // varies between parameter sets - protected internal int numRounds; + internal int numRounds; private int numSboxes; - protected internal int stateSizeBits; - protected internal int stateSizeBytes; - protected internal int stateSizeWords; - protected internal int andSizeBytes; + internal int stateSizeBits; + internal int stateSizeBytes; + internal int stateSizeWords; + internal int andSizeBytes; private int UnruhGWithoutInputBytes; - protected internal int UnruhGWithInputBytes; - protected internal int numMPCRounds; // T - protected internal int numOpenedRounds; // u - protected internal int numMPCParties; // N - protected internal int seedSizeBytes; - protected internal int digestSizeBytes; - protected internal int pqSecurityLevel; + internal int UnruhGWithInputBytes; + internal int numMPCRounds; // T + internal int numOpenedRounds; // u + internal int numMPCParties; // N + internal int seedSizeBytes; + internal int digestSizeBytes; + internal int pqSecurityLevel; /// private uint transform; private int parameters; - protected internal IXof digest; + internal IXof digest; private int signatureLength; - public int GetSecretKeySize() + internal int GetSecretKeySize() { return CRYPTO_SECRETKEYBYTES; } - public int GetPublicKeySize() + internal int GetPublicKeySize() { return CRYPTO_PUBLICKEYBYTES; } - public int GetSignatureSize(int messageLength) + internal int GetSignatureSize(int messageLength) { return CRYPTO_BYTES + messageLength; } //todo dont do this - public int GetTrueSignatureSize() + internal int GetTrueSignatureSize() { return signatureLength + 4; } @@ -95,174 +94,174 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic parameters = picnicParams; switch (parameters) { - case 1: - case 2: - /*Picnic_L1_FS - Picnic_L1_UR*/ - pqSecurityLevel = 64; - stateSizeBits = 128; - numMPCRounds = 219; - numMPCParties = 3; - numSboxes = 10; - numRounds = 20; - digestSizeBytes = 32; - break; - case 3: - case 4: - /* Picnic_L3_FS - Picnic_L3_UR*/ - pqSecurityLevel = 96; - stateSizeBits = 192; - numMPCRounds = 329; - numMPCParties = 3; - numSboxes = 10; - numRounds = 30; - digestSizeBytes = 48; - break; - case 5: - case 6: - /* Picnic_L5_FS - Picnic_L5_UR*/ - pqSecurityLevel = 128; - stateSizeBits = 256; - numMPCRounds = 438; - numMPCParties = 3; - numSboxes = 10; - numRounds = 38; - digestSizeBytes = 64; - break; - case 7: - /*Picnic3_L1*/ - pqSecurityLevel = 64; - stateSizeBits = 129; - numMPCRounds = 250; - numOpenedRounds = 36; - numMPCParties = 16; - numSboxes = 43; - numRounds = 4; - digestSizeBytes = 32; - break; - case 8: - /*Picnic3_L3*/ - pqSecurityLevel = 96; - stateSizeBits = 192; - numMPCRounds = 419; - numOpenedRounds = 52; - numMPCParties = 16; - numSboxes = 64; - numRounds = 4; - digestSizeBytes = 48; - break; - case 9: - /*Picnic3_L5*/ - pqSecurityLevel = 128; - stateSizeBits = 255; - numMPCRounds = 601; - numOpenedRounds = 68; - numMPCParties = 16; - numSboxes = 85; - numRounds = 4; - digestSizeBytes = 64; - break; - case 10: - /*Picnic_L1_full*/ - pqSecurityLevel = 64; - stateSizeBits = 129; - numMPCRounds = 219; - numMPCParties = 3; - numSboxes = 43; - numRounds = 4; - digestSizeBytes = 32; - break; - case 11: - /*Picnic_L3_full*/ - pqSecurityLevel = 96; - stateSizeBits = 192; - numMPCRounds = 329; - numMPCParties = 3; - numSboxes = 64; - numRounds = 4; - digestSizeBytes = 48; - break; - case 12: - /*Picnic_L5_full*/ - pqSecurityLevel = 128; - stateSizeBits = 255; - numMPCRounds = 438; - numMPCParties = 3; - numSboxes = 85; - numRounds = 4; - digestSizeBytes = 64; - break; + case 1: + case 2: + /*Picnic_L1_FS + Picnic_L1_UR*/ + pqSecurityLevel = 64; + stateSizeBits = 128; + numMPCRounds = 219; + numMPCParties = 3; + numSboxes = 10; + numRounds = 20; + digestSizeBytes = 32; + break; + case 3: + case 4: + /* Picnic_L3_FS + Picnic_L3_UR*/ + pqSecurityLevel = 96; + stateSizeBits = 192; + numMPCRounds = 329; + numMPCParties = 3; + numSboxes = 10; + numRounds = 30; + digestSizeBytes = 48; + break; + case 5: + case 6: + /* Picnic_L5_FS + Picnic_L5_UR*/ + pqSecurityLevel = 128; + stateSizeBits = 256; + numMPCRounds = 438; + numMPCParties = 3; + numSboxes = 10; + numRounds = 38; + digestSizeBytes = 64; + break; + case 7: + /*Picnic3_L1*/ + pqSecurityLevel = 64; + stateSizeBits = 129; + numMPCRounds = 250; + numOpenedRounds = 36; + numMPCParties = 16; + numSboxes = 43; + numRounds = 4; + digestSizeBytes = 32; + break; + case 8: + /*Picnic3_L3*/ + pqSecurityLevel = 96; + stateSizeBits = 192; + numMPCRounds = 419; + numOpenedRounds = 52; + numMPCParties = 16; + numSboxes = 64; + numRounds = 4; + digestSizeBytes = 48; + break; + case 9: + /*Picnic3_L5*/ + pqSecurityLevel = 128; + stateSizeBits = 255; + numMPCRounds = 601; + numOpenedRounds = 68; + numMPCParties = 16; + numSboxes = 85; + numRounds = 4; + digestSizeBytes = 64; + break; + case 10: + /*Picnic_L1_full*/ + pqSecurityLevel = 64; + stateSizeBits = 129; + numMPCRounds = 219; + numMPCParties = 3; + numSboxes = 43; + numRounds = 4; + digestSizeBytes = 32; + break; + case 11: + /*Picnic_L3_full*/ + pqSecurityLevel = 96; + stateSizeBits = 192; + numMPCRounds = 329; + numMPCParties = 3; + numSboxes = 64; + numRounds = 4; + digestSizeBytes = 48; + break; + case 12: + /*Picnic_L5_full*/ + pqSecurityLevel = 128; + stateSizeBits = 255; + numMPCRounds = 438; + numMPCParties = 3; + numSboxes = 85; + numRounds = 4; + digestSizeBytes = 64; + break; } switch (parameters) { - case 1: /*Picnic_L1_FS*/ - CRYPTO_SECRETKEYBYTES = 49; - CRYPTO_PUBLICKEYBYTES = 33; - CRYPTO_BYTES = 34036; - break; - case 2: /* Picnic_L1_UR*/ - CRYPTO_SECRETKEYBYTES = 49; - CRYPTO_PUBLICKEYBYTES = 33; - CRYPTO_BYTES = 53965; - break; - case 3: /*Picnic_L3_FS*/ - CRYPTO_SECRETKEYBYTES = 73; - CRYPTO_PUBLICKEYBYTES = 49; - CRYPTO_BYTES = 76784; - break; - case 4: /*Picnic_L3_UR*/ - CRYPTO_SECRETKEYBYTES = 73; - CRYPTO_PUBLICKEYBYTES = 49; - CRYPTO_BYTES = 121857; - break; - case 5: /*Picnic_L5_FS*/ - CRYPTO_SECRETKEYBYTES = 97; - CRYPTO_PUBLICKEYBYTES = 65; - CRYPTO_BYTES = 132876; - break; - case 6: /*Picnic_L5_UR*/ - CRYPTO_SECRETKEYBYTES = 97; - CRYPTO_PUBLICKEYBYTES = 65; - CRYPTO_BYTES = 209526; - break; - case 7: /*Picnic3_L1*/ - CRYPTO_SECRETKEYBYTES = 52; - CRYPTO_PUBLICKEYBYTES = 35; - CRYPTO_BYTES = 14612; - break; - case 8: /*Picnic3_L3*/ - CRYPTO_SECRETKEYBYTES = 73; - CRYPTO_PUBLICKEYBYTES = 49; - CRYPTO_BYTES = 35028; - break; - case 9: /*Picnic3_L5*/ - CRYPTO_SECRETKEYBYTES = 97; - CRYPTO_PUBLICKEYBYTES = 65; - CRYPTO_BYTES = 61028; - break; - case 10: /*Picnic_L1_full*/ - CRYPTO_SECRETKEYBYTES = 52; - CRYPTO_PUBLICKEYBYTES = 35; - CRYPTO_BYTES = 32061; - break; - case 11: /*Picnic_L3_full*/ - CRYPTO_SECRETKEYBYTES = 73; - CRYPTO_PUBLICKEYBYTES = 49; - CRYPTO_BYTES = 71179; - break; - case 12: /*Picnic_L5_full*/ - CRYPTO_SECRETKEYBYTES = 97; - CRYPTO_PUBLICKEYBYTES = 65; - CRYPTO_BYTES = 126286; - break; - default: - CRYPTO_SECRETKEYBYTES = -1; - CRYPTO_PUBLICKEYBYTES = -1; - CRYPTO_BYTES = -1; - break; + case 1: /*Picnic_L1_FS*/ + CRYPTO_SECRETKEYBYTES = 49; + CRYPTO_PUBLICKEYBYTES = 33; + CRYPTO_BYTES = 34036; + break; + case 2: /* Picnic_L1_UR*/ + CRYPTO_SECRETKEYBYTES = 49; + CRYPTO_PUBLICKEYBYTES = 33; + CRYPTO_BYTES = 53965; + break; + case 3: /*Picnic_L3_FS*/ + CRYPTO_SECRETKEYBYTES = 73; + CRYPTO_PUBLICKEYBYTES = 49; + CRYPTO_BYTES = 76784; + break; + case 4: /*Picnic_L3_UR*/ + CRYPTO_SECRETKEYBYTES = 73; + CRYPTO_PUBLICKEYBYTES = 49; + CRYPTO_BYTES = 121857; + break; + case 5: /*Picnic_L5_FS*/ + CRYPTO_SECRETKEYBYTES = 97; + CRYPTO_PUBLICKEYBYTES = 65; + CRYPTO_BYTES = 132876; + break; + case 6: /*Picnic_L5_UR*/ + CRYPTO_SECRETKEYBYTES = 97; + CRYPTO_PUBLICKEYBYTES = 65; + CRYPTO_BYTES = 209526; + break; + case 7: /*Picnic3_L1*/ + CRYPTO_SECRETKEYBYTES = 52; + CRYPTO_PUBLICKEYBYTES = 35; + CRYPTO_BYTES = 14612; + break; + case 8: /*Picnic3_L3*/ + CRYPTO_SECRETKEYBYTES = 73; + CRYPTO_PUBLICKEYBYTES = 49; + CRYPTO_BYTES = 35028; + break; + case 9: /*Picnic3_L5*/ + CRYPTO_SECRETKEYBYTES = 97; + CRYPTO_PUBLICKEYBYTES = 65; + CRYPTO_BYTES = 61028; + break; + case 10: /*Picnic_L1_full*/ + CRYPTO_SECRETKEYBYTES = 52; + CRYPTO_PUBLICKEYBYTES = 35; + CRYPTO_BYTES = 32061; + break; + case 11: /*Picnic_L3_full*/ + CRYPTO_SECRETKEYBYTES = 73; + CRYPTO_PUBLICKEYBYTES = 49; + CRYPTO_BYTES = 71179; + break; + case 12: /*Picnic_L5_full*/ + CRYPTO_SECRETKEYBYTES = 97; + CRYPTO_PUBLICKEYBYTES = 65; + CRYPTO_BYTES = 126286; + break; + default: + CRYPTO_SECRETKEYBYTES = -1; + CRYPTO_PUBLICKEYBYTES = -1; + CRYPTO_BYTES = -1; + break; } // calculated depending on above parameters @@ -304,7 +303,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic digest = new ShakeDigest(shakeSize); } - public bool crypto_sign_open(byte[] m, byte[] sm, byte[] pk) + internal bool crypto_sign_open(byte[] m, byte[] sm, byte[] pk) { uint sigLen = Pack.LE_To_UInt32(sm, 0); byte[] m_from_sm = Arrays.CopyOfRange(sm, 4, 4 + m.Length); @@ -432,7 +431,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return status; } - void VerifyProof(Signature.Proof proof, View view1, View view2, int challenge, byte[] salt, + private void VerifyProof(Signature.Proof proof, View view1, View view2, int challenge, byte[] salt, uint roundNumber, byte[] tmp, uint[] plaintext, Tape tape) { Array.Copy(proof.communicatedBits, 0, view2.communicatedBits, 0, andSizeBytes); @@ -534,7 +533,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic mpc_LowMC_verify(view1, view2, tape, tmp_ints, plaintext, challenge); } - void mpc_LowMC_verify(View view1, View view2, Tape tapes, uint[] tmp, uint[] plaintext, int challenge) + private void mpc_LowMC_verify(View view1, View view2, Tape tapes, uint[] tmp, uint[] plaintext, int challenge) { Utils.Fill(tmp, 0, tmp.Length, 0); @@ -576,7 +575,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic Array.Copy(tmp, 3 * stateSizeWords, view2.outputShare, 0, stateSizeWords); } - void mpc_substitution_verify(uint[] state, Tape rand, View view1, View view2) + private void mpc_substitution_verify(uint[] state, Tape rand, View view1, View view2) { uint[] a = new uint[2]; uint[] b = new uint[2]; @@ -611,7 +610,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } } - void mpc_AND_verify(uint[] in1, uint[] in2, uint[] output, Tape rand, View view1, View view2) + private void mpc_AND_verify(uint[] in1, uint[] in2, uint[] output, Tape rand, View view1, View view2) { uint[] r = {Utils.GetBit(rand.tapes[0], rand.pos), Utils.GetBit(rand.tapes[1], rand.pos)}; @@ -646,7 +645,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } - private int DeserializeSignature(Signature sig, byte[] sigBytes, uint sigBytesLen, int sigBytesOffset) { Signature.Proof[] proofs = sig.proofs; @@ -1086,7 +1084,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return true; } - public void crypto_sign(byte[] sm, byte[] m, byte[] sk) + internal void crypto_sign(byte[] sm, byte[] m, byte[] sk) { picnic_sign(sk, m, sm); Array.Copy(m, 0, sm, 4, m.Length); @@ -1142,7 +1140,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic /*** Serialization functions ***/ - int SerializeSignature(Signature sig, byte[] sigBytes, int sigOffset) + private int SerializeSignature(Signature sig, byte[] sigBytes, int sigOffset) { Signature.Proof[] proofs = sig.proofs; byte[] challengeBits = sig.challengeBits; @@ -1204,7 +1202,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return sigByteIndex - sigOffset; } - int GetChallenge(byte[] challenge, int round) + private int GetChallenge(byte[] challenge, int round) { return (Utils.GetBit(challenge, 2 * round + 1) << 1) | Utils.GetBit(challenge, 2 * round); } @@ -1418,7 +1416,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } /* Caller must allocate the first parameter */ - void Prove(Signature.Proof proof, int challenge, byte[] seeds, int seedsOffset, + private void Prove(Signature.Proof proof, int challenge, byte[] seeds, int seedsOffset, View[] views, byte[][] commitments, byte[][] gs) { if (challenge == 0) @@ -1456,7 +1454,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } } - void H3(uint[] circuitOutput, uint[] plaintext, uint[][][] viewOutputs, + private void H3(uint[] circuitOutput, uint[] plaintext, uint[][][] viewOutputs, byte[][][] AS, byte[] challengeBits, byte[] salt, byte[] message, byte[][][] gs) { @@ -1659,7 +1657,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic int stateOffset; for (int i = 0; i < numSboxes * 3; i += 3) { - for (int j = 0; j < 3; j++) { stateOffset = ((3 + j) * stateSizeWords) * 32; @@ -1748,7 +1745,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic digest.Update((byte) 2); digest.BlockUpdate(seed, seedOffset, seedSizeBytes); digest.OutputFinal(tape, 0, digestSizeBytes); -// Console.Error.Write("tape: " + Hex.toHexString(tape)); /* Expand the hashed seed, salt, round and player indices, and output * length to create the tape. */ @@ -1949,7 +1945,6 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return missingLeaves; } - private void HCP(byte[] challengeHash, uint[] challengeC, uint[] challengeP, byte[][] Ch, byte[] hCv, byte[] salt, uint[] pubKey, uint[] plaintext, byte[] message) { @@ -1971,7 +1966,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } } - static int BitsToChunks(int chunkLenBits, byte[] input, int inputLen, uint[] chunks) + private static int BitsToChunks(int chunkLenBits, byte[] input, int inputLen, uint[] chunks) { if (chunkLenBits > inputLen * 8) { @@ -1992,7 +1987,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return chunkCount; } - static uint AppendUnique(uint[] list, uint value, uint position) + private static uint AppendUnique(uint[] list, uint value, uint position) { if (position == 0) { @@ -2171,7 +2166,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return true; } - static uint Extend(uint bit) + private static uint Extend(uint bit) { return ~(bit - 1); } @@ -2233,7 +2228,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } } - protected internal void aux_mpc_sbox(uint[] input, uint[] output, Tape tape) + internal void aux_mpc_sbox(uint[] input, uint[] output, Tape tape) { for (int i = 0; i < numSboxes * 3; i += 3) { @@ -2341,7 +2336,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic digest.OutputFinal(saltAndRoot, 0, saltAndRoot.Length); } - static bool is_picnic3(int parameters) + private static bool is_picnic3(int parameters) { return parameters == 7 /*Picnic3_L1*/ || parameters == 8 /*Picnic3_L3*/ || @@ -2349,7 +2344,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } //todo return int; - public void crypto_sign_keypair(byte[] pk, byte[] sk, SecureRandom random) + internal void crypto_sign_keypair(byte[] pk, byte[] sk, SecureRandom random) { // set array sizes byte[] plaintext_bytes = new byte[PICNIC_MAX_LOWMC_BLOCK_SIZE]; @@ -2474,7 +2469,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } } - protected internal void xor_array(uint[] output, uint[] in1, uint[] in2, int in2_offset, int length) + internal void xor_array(uint[] output, uint[] in1, uint[] in2, int in2_offset, int length) { for (int i = 0; i < length; i++) { @@ -2482,12 +2477,12 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } } - protected internal void matrix_mul(uint[] output, uint[] state, uint[] matrix, int matrixOffset) + internal void matrix_mul(uint[] output, uint[] state, uint[] matrix, int matrixOffset) { matrix_mul_offset(output, 0, state, 0, matrix, matrixOffset); } - protected void matrix_mul_offset(uint[] output, int outputOffset, uint[] state, int stateOffset, uint[] matrix, + internal void matrix_mul_offset(uint[] output, int outputOffset, uint[] state, int stateOffset, uint[] matrix, int matrixOffset) { // Use temp to correctly handle the case when state = output diff --git a/crypto/src/pqc/crypto/picnic/Signature2.cs b/crypto/src/pqc/crypto/picnic/Signature2.cs index 7659fb314..c6f44380c 100644 --- a/crypto/src/pqc/crypto/picnic/Signature2.cs +++ b/crypto/src/pqc/crypto/picnic/Signature2.cs @@ -1,7 +1,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic { - public class Signature2 + internal class Signature2 { internal byte[] salt; internal byte[] iSeedInfo; // Info required to recompute the tree of all initial seeds @@ -14,7 +14,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic internal Proof2[] proofs; // One proof for each online execution the verifier checks //todo initialize in engine! - public Signature2(PicnicEngine engine) + internal Signature2(PicnicEngine engine) { challengeHash = new byte[engine.digestSizeBytes]; salt = new byte[PicnicEngine.saltSizeBytes]; @@ -23,7 +23,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic proofs = new Proof2[engine.numMPCRounds]; } - public class Proof2 + internal class Proof2 { internal byte[] seedInfo; // Information required to compute the tree with seeds of of all opened parties internal int seedInfoLen; // Length of seedInfo buffer @@ -32,7 +32,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic internal byte[] input; // Masked input used in online execution internal byte[] msgs; // Broadcast messages of unopened party P[t] - public Proof2(PicnicEngine engine) + internal Proof2(PicnicEngine engine) { seedInfo = null; seedInfoLen = 0; @@ -45,6 +45,3 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } } } - - - diff --git a/crypto/src/pqc/crypto/picnic/Tape.cs b/crypto/src/pqc/crypto/picnic/Tape.cs index dd1a44de8..c433b3267 100644 --- a/crypto/src/pqc/crypto/picnic/Tape.cs +++ b/crypto/src/pqc/crypto/picnic/Tape.cs @@ -1,125 +1,128 @@ using Org.BouncyCastle.Crypto.Utilities; -using Org.BouncyCastle.Pqc.Crypto.Picnic; using Org.BouncyCastle.Utilities; -public class Tape +namespace Org.BouncyCastle.Pqc.Crypto.Picnic { - internal byte[][] tapes; - internal int pos; - int nTapes; - - private PicnicEngine engine; - public Tape(PicnicEngine engine) + internal class Tape { - this.engine = engine; - tapes = new byte[engine.numMPCParties][]; //[2 * engine.andSizeBytes]; - for (int i = 0; i < engine.numMPCParties; i++) - { - tapes[i] = new byte[2 * engine.andSizeBytes]; - } - pos = 0; - nTapes = engine.numMPCParties; - } + internal byte[][] tapes; + internal int pos; + int nTapes; - protected internal void SetAuxBits(byte[] input) - { - int last = engine.numMPCParties - 1; - int pos = 0; - int n = engine.stateSizeBits; + private PicnicEngine engine; - for(int j = 0; j < engine.numRounds; j++) + internal Tape(PicnicEngine engine) { - for(int i = 0; i < n; i++) + this.engine = engine; + tapes = new byte[engine.numMPCParties][]; //[2 * engine.andSizeBytes]; + for (int i = 0; i < engine.numMPCParties; i++) { - Utils.SetBit(this.tapes[last], n + n*2*j + i, Utils.GetBit(input, pos++)); + tapes[i] = new byte[2 * engine.andSizeBytes]; } + pos = 0; + nTapes = engine.numMPCParties; } - } - - /* Input is the tapes for one parallel repitition; i.e., tapes[t] - * Updates the random tapes of all players with the mask values for the output of - * AND gates, and computes the N-th party's share such that the AND gate invariant - * holds on the mask values. - */ - protected internal void ComputeAuxTape(byte[] inputs) - { - uint[] roundKey = new uint[PicnicEngine.LOWMC_MAX_WORDS]; - uint[] x = new uint[PicnicEngine.LOWMC_MAX_WORDS]; - uint[] y = new uint[PicnicEngine.LOWMC_MAX_WORDS]; - uint[] key = new uint[PicnicEngine.LOWMC_MAX_WORDS]; - uint[] key0 = new uint[PicnicEngine.LOWMC_MAX_WORDS]; - key0[engine.stateSizeWords - 1] = 0; - TapesToParityBits(key0, engine.stateSizeBits); - -// System.out.print("key0: "); -// for (int i = 0; i < key0.Length; i++) -// {System.out.printf("%08x ", key0[i]);}System.out.Println(); - - // key = key0 x KMatrix[0]^(-1) - KMatricesWithPointer current = LowmcConstants.Instance.KMatrixInv(engine, 0); - engine.matrix_mul(key, key0, current.GetData(), current.GetMatrixPointer()); - -// System.out.print("key: "); -// for (int i = 0; i < key0.Length; i++) -// {System.out.printf("%08x ", key[i]);}System.out.Println(); + internal void SetAuxBits(byte[] input) + { + int last = engine.numMPCParties - 1; + int pos = 0; + int n = engine.stateSizeBits; + for(int j = 0; j < engine.numRounds; j++) + { + for(int i = 0; i < n; i++) + { + Utils.SetBit(this.tapes[last], n + n*2*j + i, Utils.GetBit(input, pos++)); + } + } + } - if(inputs != null) + /* Input is the tapes for one parallel repitition; i.e., tapes[t] + * Updates the random tapes of all players with the mask values for the output of + * AND gates, and computes the N-th party's share such that the AND gate invariant + * holds on the mask values. + */ + internal void ComputeAuxTape(byte[] inputs) { - Pack.UInt32_To_LE(Arrays.CopyOf(key, engine.stateSizeWords), inputs, 0); - } + uint[] roundKey = new uint[PicnicEngine.LOWMC_MAX_WORDS]; + uint[] x = new uint[PicnicEngine.LOWMC_MAX_WORDS]; + uint[] y = new uint[PicnicEngine.LOWMC_MAX_WORDS]; + uint[] key = new uint[PicnicEngine.LOWMC_MAX_WORDS]; + uint[] key0 = new uint[PicnicEngine.LOWMC_MAX_WORDS]; + key0[engine.stateSizeWords - 1] = 0; + TapesToParityBits(key0, engine.stateSizeBits); - for (int r = engine.numRounds; r > 0; r--) - { - current = LowmcConstants.Instance.KMatrix(engine, r); - engine.matrix_mul(roundKey, key, current.GetData(), current.GetMatrixPointer()); // roundKey = key * KMatrix(r) + // System.out.print("key0: "); + // for (int i = 0; i < key0.Length; i++) + // {System.out.printf("%08x ", key0[i]);}System.out.Println(); + + // key = key0 x KMatrix[0]^(-1) + KMatricesWithPointer current = LowmcConstants.Instance.KMatrixInv(engine, 0); + engine.matrix_mul(key, key0, current.GetData(), current.GetMatrixPointer()); - engine.xor_array(x, x, roundKey, 0, engine.stateSizeWords); + // System.out.print("key: "); + // for (int i = 0; i < key0.Length; i++) + // {System.out.printf("%08x ", key[i]);}System.out.Println(); - current = LowmcConstants.Instance.LMatrixInv(engine, r-1); - engine.matrix_mul(y, x, current.GetData(), current.GetMatrixPointer()); - if(r == 1) + if(inputs != null) { - // Use key as input - System.Array.Copy(key0, 0, x, 0, key0.Length); + Pack.UInt32_To_LE(Arrays.CopyOf(key, engine.stateSizeWords), inputs, 0); } - else + + + for (int r = engine.numRounds; r > 0; r--) { - this.pos = engine.stateSizeBits * 2 * (r - 1); - // Read input mask shares from tapes - TapesToParityBits(x, engine.stateSizeBits); + current = LowmcConstants.Instance.KMatrix(engine, r); + engine.matrix_mul(roundKey, key, current.GetData(), current.GetMatrixPointer()); // roundKey = key * KMatrix(r) + + engine.xor_array(x, x, roundKey, 0, engine.stateSizeWords); + + current = LowmcConstants.Instance.LMatrixInv(engine, r-1); + engine.matrix_mul(y, x, current.GetData(), current.GetMatrixPointer()); + + if(r == 1) + { + // Use key as input + System.Array.Copy(key0, 0, x, 0, key0.Length); + } + else + { + this.pos = engine.stateSizeBits * 2 * (r - 1); + // Read input mask shares from tapes + TapesToParityBits(x, engine.stateSizeBits); + } + + this.pos = engine.stateSizeBits * 2 * (r - 1) + engine.stateSizeBits; + engine.aux_mpc_sbox(x, y, this); } - this.pos = engine.stateSizeBits * 2 * (r - 1) + engine.stateSizeBits; - engine.aux_mpc_sbox(x, y, this); + // Reset the random tape counter so that the online execution uses the + // same random bits as when computing the aux shares + this.pos = 0; } - // Reset the random tape counter so that the online execution uses the - // same random bits as when computing the aux shares - this.pos = 0; - } - - private void TapesToParityBits(uint[] output, int outputBitLen) - { - for (int i = 0; i < outputBitLen; i++) + private void TapesToParityBits(uint[] output, int outputBitLen) { - Utils.SetBitInWordArray(output, i, Utils.Parity16(TapesToWord())); + for (int i = 0; i < outputBitLen; i++) + { + Utils.SetBitInWordArray(output, i, Utils.Parity16(TapesToWord())); + } } - } - - protected internal uint TapesToWord() - { - byte[] shares = new byte[4]; - for (int i = 0; i < 16; i++) + internal uint TapesToWord() { - byte bit = Utils.GetBit(this.tapes[i], this.pos); - Utils.SetBit(shares, i, bit); + byte[] shares = new byte[4]; + + for (int i = 0; i < 16; i++) + { + byte bit = Utils.GetBit(this.tapes[i], this.pos); + Utils.SetBit(shares, i, bit); + } + this.pos++; + return Pack.LE_To_UInt32(shares, 0); } - this.pos++; - return Pack.LE_To_UInt32(shares, 0); } -} \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/picnic/Tree.cs b/crypto/src/pqc/crypto/picnic/Tree.cs index 50f844a52..80b2f87ba 100644 --- a/crypto/src/pqc/crypto/picnic/Tree.cs +++ b/crypto/src/pqc/crypto/picnic/Tree.cs @@ -1,12 +1,11 @@ using System; + using Org.BouncyCastle.Crypto.Utilities; -using Org.BouncyCastle.Pqc.Crypto.Picnic; using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Pqc.Crypto.Picnic { - - public class Tree + internal sealed class Tree { private static int MAX_SEED_SIZE_BYTES = 32; private uint MAX_AUX_BYTES; @@ -22,17 +21,17 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic private PicnicEngine engine; - protected internal byte[][] GetLeaves() + internal byte[][] GetLeaves() { return this.nodes; } - protected internal uint GetLeavesOffset() + internal uint GetLeavesOffset() { return this.numNodes - this.numLeaves; } - public Tree(PicnicEngine engine, uint numLeaves, int dataSize) + internal Tree(PicnicEngine engine, uint numLeaves, int dataSize) { this.engine = engine; MAX_AUX_BYTES = ((PicnicEngine.LOWMC_MAX_AND_GATES + PicnicEngine.LOWMC_MAX_KEY_BITS) / 8 + 1); @@ -69,7 +68,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic /* Create a Merkle tree by hashing up all nodes. * leafData must have Length this.numNodes, but some may be NULL. */ - protected internal void BuildMerkleTree(byte[][] leafData, byte[] salt) + internal void BuildMerkleTree(byte[][] leafData, byte[] salt) { uint firstLeaf = this.numNodes - this.numLeaves; @@ -92,7 +91,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } /* verifyMerkleTree: verify for each leaf that is set */ - protected internal int VerifyMerkleTree(byte[][] leafData, byte[] salt) + internal int VerifyMerkleTree(byte[][] leafData, byte[] salt) { uint firstLeaf = this.numNodes - this.numLeaves; @@ -131,7 +130,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return 0; } - protected internal int ReconstructSeeds(uint[] hideList, uint hideListSize, + internal int ReconstructSeeds(uint[] hideList, uint hideListSize, byte[] input, uint inputLen, byte[] salt, uint repIndex) { int ret = 0; @@ -163,7 +162,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } /* Serialze the missing nodes that the verifier will require to check commitments for non-missing leaves */ - protected internal byte[] OpenMerkleTree(uint[] missingLeaves, uint missingLeavesSize, int[] outputSizeBytes) + internal byte[] OpenMerkleTree(uint[] missingLeaves, uint missingLeavesSize, int[] outputSizeBytes) { uint[] revealedSize = new uint[1]; uint[] revealed = this.GetRevealedMerkleNodes(missingLeaves, missingLeavesSize, revealedSize); @@ -293,7 +292,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic } - protected internal uint RevealSeedsSize(uint[] hideList, uint hideListSize) + internal uint RevealSeedsSize(uint[] hideList, uint hideListSize) { uint[] numNodesRevealed = new uint[1]; numNodesRevealed[0] = 0; @@ -301,7 +300,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return numNodesRevealed[0] * (uint)engine.seedSizeBytes; } - protected internal int RevealSeeds(uint[] hideList, uint hideListSize, byte[] output, int outputSize) + internal int RevealSeeds(uint[] hideList, uint hideListSize, byte[] output, int outputSize) { // byte[] outputBase = Arrays.clone(output); uint[] revealedSize = new uint[1]; @@ -330,7 +329,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return output.Length - outLen; } - protected internal uint OpenMerkleTreeSize(uint[] missingLeaves, uint missingLeavesSize) + internal uint OpenMerkleTreeSize(uint[] missingLeaves, uint missingLeavesSize) { uint[] revealedSize = new uint[1]; uint[] revealed = this.GetRevealedMerkleNodes(missingLeaves, missingLeavesSize, revealedSize); @@ -454,15 +453,14 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic this.haveNode[parent] = true; } - - protected internal byte[] GetLeaf(uint leafIndex) + internal byte[] GetLeaf(uint leafIndex) { uint firstLeaf = this.numNodes - this.numLeaves; return this.nodes[firstLeaf + leafIndex]; } /* addMerkleNodes: deserialize and add the data for nodes provided by the committer */ - protected internal int AddMerkleNodes(uint[] missingLeaves, uint missingLeavesSize, byte[] input, uint inputSize) + internal int AddMerkleNodes(uint[] missingLeaves, uint missingLeavesSize, byte[] input, uint inputSize) { // if (inputSize > INT_MAX) { // return -1; @@ -495,7 +493,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return 0; } - protected internal void GenerateSeeds(byte[] rootSeed, byte[] salt, uint repIndex) + internal void GenerateSeeds(byte[] rootSeed, byte[] salt, uint repIndex) { this.nodes[0] = rootSeed; this.haveNode[0] = true; @@ -578,6 +576,5 @@ namespace Org.BouncyCastle.Pqc.Crypto.Picnic return this.exists[i] == 1; } - } -} \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/picnic/View.cs b/crypto/src/pqc/crypto/picnic/View.cs index d72afa9d4..cac47631a 100644 --- a/crypto/src/pqc/crypto/picnic/View.cs +++ b/crypto/src/pqc/crypto/picnic/View.cs @@ -1,18 +1,16 @@ -using Org.BouncyCastle.Pqc.Crypto.Picnic; - namespace Org.BouncyCastle.Pqc.Crypto.Picnic { - public class View + internal class View { internal uint[] inputShare; internal byte[] communicatedBits; internal uint[] outputShare; - public View(PicnicEngine engine) + internal View(PicnicEngine engine) { inputShare = new uint[engine.stateSizeBytes]; communicatedBits = new byte[engine.andSizeBytes]; outputShare = new uint[engine.stateSizeBytes]; } } -} \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/sike/Fpx.cs b/crypto/src/pqc/crypto/sike/Fpx.cs index 9ba332753..140b36afb 100644 --- a/crypto/src/pqc/crypto/sike/Fpx.cs +++ b/crypto/src/pqc/crypto/sike/Fpx.cs @@ -29,7 +29,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Cyclotomic squaring on elements of norm 1, using a^(p+1) = 1. - protected internal void sqr_Fp2_cycl(ulong[][] a, ulong[] one) + internal void sqr_Fp2_cycl(ulong[][] a, ulong[] one) { ulong[] t0 = new ulong[engine.param.NWORDS_FIELD]; @@ -44,7 +44,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // n-way simultaneous inversion using Montgomery's trick. // SECURITY NOTE: This function does not run in constant time. // Also, vec and out CANNOT be the same variable! - protected internal void mont_n_way_inv(ulong[][][] vec, uint n, ulong[][][] output) + internal void mont_n_way_inv(ulong[][][] vec, uint n, ulong[][][] output) { ulong[][] t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); int i; @@ -68,7 +68,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Copy a field element, c = a. - protected internal void fpcopy(ulong[] a, long aOffset, ulong[] c) + internal void fpcopy(ulong[] a, long aOffset, ulong[] c) { for (uint i = 0; i < engine.param.NWORDS_FIELD; i++) { @@ -77,21 +77,21 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // GF(p^2) addition without correction, c = a+b in GF(p^2). - protected internal void mp2_add(ulong[][] a, ulong[][] b, ulong[][] c) + internal void mp2_add(ulong[][] a, ulong[][] b, ulong[][] c) { mp_add(a[0], b[0], c[0], engine.param.NWORDS_FIELD); mp_add(a[1], b[1], c[1], engine.param.NWORDS_FIELD); } // Modular correction, a = a in GF(p^2). - protected internal void fp2correction(ulong[][] a) + internal void fp2correction(ulong[][] a) { fpcorrectionPRIME(a[0]); fpcorrectionPRIME(a[1]); } // Multiprecision addition, c = a+b, where lng(a) = lng(b) = nwords. Returns the carry bit. - protected internal ulong mp_add(ulong[] a, ulong[] b, ulong[] c, uint nwords) + internal ulong mp_add(ulong[] a, ulong[] b, ulong[] c, uint nwords) { ulong carry = 0; @@ -169,7 +169,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Is x = 0? return 1 (TRUE) if condition is true, 0 (FALSE) otherwise. // SECURITY NOTE: This function does not run in constant-time. - protected internal bool is_felm_zero(ulong[] x) + internal bool is_felm_zero(ulong[] x) { for (uint i = 0; i < engine.param.NWORDS_FIELD; i++) { @@ -205,7 +205,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Test if a is a square in GF(p^2) and return 1 if true, 0 otherwise // If a is a quadratic residue, s will be assigned with a partially computed square root of a - protected internal bool is_sqr_fp2(ulong[][] a, ulong[] s) + internal bool is_sqr_fp2(ulong[][] a, ulong[] s) { uint i; ulong[] a0 = new ulong[engine.param.NWORDS_FIELD], @@ -365,7 +365,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // GF(p^2) inversion using Montgomery arithmetic, a = (a0-i*a1)/(a0^2+a1^2) // This uses the binary GCD for inversion in fp and is NOT constant time!!! - protected internal void fp2inv_mont_bingcd(ulong[][] a) + internal void fp2inv_mont_bingcd(ulong[][] a) { ulong[][] t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -381,7 +381,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // GF(p^2) division by two, c = a/2 in GF(p^2). - protected internal void fp2div2(ulong[][] a, ulong[][] c) + internal void fp2div2(ulong[][] a, ulong[][] c) { //todo/org : make fp class and change this to generic fpdiv2 fpdiv2_PRIME(a[0], c[0]); @@ -606,7 +606,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike Debug.Assert(t == 0); } - protected internal static bool subarrayEquals(ulong[] a, ulong[] b, uint length) + internal static bool subarrayEquals(ulong[] a, ulong[] b, uint length) { // if(a.Length < length || b.Length < length) // return false; @@ -619,7 +619,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike return true; } - protected internal static bool subarrayEquals(ulong[][] a, ulong[][] b, uint length) + internal static bool subarrayEquals(ulong[][] a, ulong[][] b, uint length) { int nwords_feild = b[0].Length; // if(a[0].Length < length || b[0].Length < length) @@ -633,7 +633,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike return true; } - protected internal static bool subarrayEquals(ulong[][] a, ulong[][] b, uint bOffset, uint length) + internal static bool subarrayEquals(ulong[][] a, ulong[][] b, uint bOffset, uint length) { int nwords_feild = b[0].Length; // if(a[0].Length*2 < length || b[0].Length*2 < length) @@ -647,7 +647,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike return true; } - protected internal static bool subarrayEquals(ulong[][] a, ulong[] b, uint bOffset, uint length) + internal static bool subarrayEquals(ulong[][] a, ulong[] b, uint bOffset, uint length) { int nwords_field = a[0].Length; // if(a[0].Length < length || b.Length < length) @@ -662,9 +662,8 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Computes square roots of elements in (Fp2)^2 using Hamburg's trick. - protected internal void sqrt_Fp2(ulong[][] u, ulong[][] y) + internal void sqrt_Fp2(ulong[][] u, ulong[][] y) { - ulong[] t0 = new ulong[engine.param.NWORDS_FIELD], t1 = new ulong[engine.param.NWORDS_FIELD], t2 = new ulong[engine.param.NWORDS_FIELD], @@ -714,7 +713,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // GF(p^2) squaring using Montgomery arithmetic, c = a^2 in GF(p^2). // Inputs: a = a0+a1*i, where a0, a1 are in [0, 2*p-1] // Output: c = c0+c1*i, where c0, c1 are in [0, 2*p-1] - protected internal void fp2sqr_mont(ulong[][] a, ulong[][] c) + internal void fp2sqr_mont(ulong[][] a, ulong[][] c) { ulong[] t1 = new ulong[engine.param.NWORDS_FIELD], t2 = new ulong[engine.param.NWORDS_FIELD], @@ -731,7 +730,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Modular addition, c = a+b mod PRIME. // Inputs: a, b in [0, 2*PRIME-1] // Output: c in [0, 2*PRIME-1] - protected internal void fpaddPRIME(ulong[] a, ulong[] b, ulong[] c) + internal void fpaddPRIME(ulong[] a, ulong[] b, ulong[] c) { ulong i, carry = 0; ulong mask; @@ -769,7 +768,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Cyclotomic cubing on elements of norm 1, using a^(p+1) = 1. - protected internal void cube_Fp2_cycl(ulong[][] a, ulong[] one) + internal void cube_Fp2_cycl(ulong[][] a, ulong[] one) { ulong[] t0 = new ulong[engine.param.NWORDS_FIELD]; @@ -786,7 +785,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Modular subtraction, c = a-b mod PRIME. // Inputs: a, b in [0, 2*PRIME-1] // Output: c in [0, 2*PRIME-1] - protected internal void fpsubPRIME(ulong[] a, ulong[] b, uint bOffset, ulong[] c) + internal void fpsubPRIME(ulong[] a, ulong[] b, uint bOffset, ulong[] c) { ulong i, borrow = 0; ulong mask; @@ -811,7 +810,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } } - protected internal void fpsubPRIME(ulong[] a, uint aOffset, ulong[] b, ulong[] c) + internal void fpsubPRIME(ulong[] a, uint aOffset, ulong[] b, ulong[] c) { ulong i, borrow = 0; ulong mask; @@ -836,7 +835,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } } - protected internal void fpsubPRIME(ulong[] a, ulong[] b, ulong[] c) + internal void fpsubPRIME(ulong[] a, ulong[] b, ulong[] c) { ulong i, borrow = 0; ulong mask; @@ -864,7 +863,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // todo/org : move to fp_generic // Modular negation, a = -a mod PRIME. // Input/output: a in [0, 2*PRIME-1] - protected internal void fpnegPRIME(ulong[] a) + internal void fpnegPRIME(ulong[] a) { ulong i, borrow = 0; @@ -881,7 +880,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // todo/org : move to fp_generic // Conversion of a GF(p^2) element from Montgomery representation to standard representation, // c_i = ma_i*R^(-1) = a_i in GF(p^2). - protected internal void from_fp2mont(ulong[][] ma, ulong[][] c) + internal void from_fp2mont(ulong[][] ma, ulong[][] c) { from_mont(ma[0], c[0]); from_mont(ma[1], c[1]); @@ -889,7 +888,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // todo/org : move to fp_generic // Conversion of GF(p^2) element from Montgomery to standard representation, and encoding by removing leading 0 bytes - protected internal void fp2_encode(ulong[][] x, byte[] enc, uint encOffset) + internal void fp2_encode(ulong[][] x, byte[] enc, uint encOffset) { ulong[][] t = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -899,7 +898,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Parse byte sequence back uinto GF(p^2) element, and conversion to Montgomery representation - protected internal void fp2_decode(byte[] x, ulong[][] dec, uint xOffset) + internal void fp2_decode(byte[] x, ulong[][] dec, uint xOffset) { decode_to_digits(x, xOffset, dec[0], engine.param.FP2_ENCODED_BYTES / 2, engine.param.NWORDS_FIELD); decode_to_digits(x,xOffset + (engine.param.FP2_ENCODED_BYTES/2), dec[1], engine.param.FP2_ENCODED_BYTES / 2, engine.param.NWORDS_FIELD); @@ -907,7 +906,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Conversion of elements in Z_r to Montgomery representation, where the order r is up to NBITS_ORDER bits. - protected internal void to_Montgomery_mod_order(ulong[] a, ulong[] mc, ulong[] order, ulong[] Montgomery_rprime, ulong[] Montgomery_Rprime) + internal void to_Montgomery_mod_order(ulong[] a, ulong[] mc, ulong[] order, ulong[] Montgomery_rprime, ulong[] Montgomery_Rprime) { Montgomery_multiply_mod_order(a, Montgomery_Rprime, mc, order, Montgomery_rprime); } @@ -916,7 +915,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // ma, mb and mc are assumed to be in Montgomery representation. // The Montgomery constant r' = -r^(-1) mod 2^(log_2(r)) is the value "Montgomery_rprime", where r is the order. // Assume log_2(r) is a multiple of RADIX bits - protected internal void Montgomery_multiply_mod_order(ulong[] ma, ulong[] mb, ulong[] mc, ulong[] order, ulong[] Montgomery_rprime) + internal void Montgomery_multiply_mod_order(ulong[] ma, ulong[] mb, ulong[] mc, ulong[] order, ulong[] Montgomery_rprime) { ulong i, cout = 0, bout = 0; ulong mask; @@ -949,7 +948,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Inversion of an odd uinteger modulo an even uinteger of the form 2^m. // Algorithm 3: Explicit Quadratic Modular inverse modulo 2^m from Dumas'12: http://arxiv.org/pdf/1209.6626.pdf // If the input is invalid (even), the function outputs c = a. - protected internal void inv_mod_orderA(ulong[] a, ulong[] c) + internal void inv_mod_orderA(ulong[] a, ulong[] c) { uint i, f, s = 0; ulong[] am1 = new ulong[engine.param.NWORDS_ORDER], @@ -999,7 +998,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Multiprecision comba multiply, c = a*b, where lng(a) = lng(b) = nwords. // NOTE: a and c CANNOT be the same variable! - protected internal void multiply(ulong[] a, ulong[] b, ulong[] c, uint nwords) + internal void multiply(ulong[] a, ulong[] b, ulong[] c, uint nwords) { ulong i, j; ulong t = 0, u = 0, v = 0; @@ -1187,7 +1186,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Montgomery inversion modulo order, c = a^(-1)*R mod order. - protected internal void Montgomery_inversion_mod_order_bingcd(ulong[] a, ulong[] c, ulong[] order, ulong[] Montgomery_rprime, ulong[] Montgomery_Rprime) + internal void Montgomery_inversion_mod_order_bingcd(ulong[] a, ulong[] c, ulong[] order, ulong[] Montgomery_rprime, ulong[] Montgomery_Rprime) { ulong[] x = new ulong[engine.param.NWORDS_ORDER], t = new ulong[engine.param.NWORDS_ORDER]; @@ -1211,7 +1210,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Conversion of elements in Z_r from Montgomery to standard representation, where the order is up to NBITS_ORDER bits. - protected internal void from_Montgomery_mod_order(ulong[] ma, ulong[] c, ulong[] order, ulong[] Montgomery_rprime) + internal void from_Montgomery_mod_order(ulong[] ma, ulong[] c, ulong[] order, ulong[] Montgomery_rprime) { ulong[] one = new ulong[engine.param.NWORDS_ORDER]; one[0] = 1; @@ -1221,7 +1220,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Computes the input modulo 3 // The input is assumed to be NWORDS_ORDER ulong - protected internal uint mod3(ulong[] a) + internal uint mod3(ulong[] a) { ulong result = 0; for (int i = 0; i < engine.param.NWORDS_ORDER; ++i) @@ -1234,7 +1233,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Conversion of a GF(p^2) element to Montgomery representation, // mc_i = a_i*R^2*R^(-1) = a_i*R in GF(p^2). - protected internal void to_fp2mont(ulong[][] a, ulong[][] mc) + internal void to_fp2mont(ulong[][] a, ulong[][] mc) { to_mont(a[0], mc[0]); to_mont(a[1], mc[1]); @@ -1251,7 +1250,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // todo/org : move to fp_generic // Modular correction to reduce field element a in [0, 2*PRIME-1] to [0, PRIME-1]. - protected internal void fpcorrectionPRIME(ulong[] a) + internal void fpcorrectionPRIME(ulong[] a) { ulong i, borrow = 0; ulong mask; @@ -1276,7 +1275,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } } - protected internal byte cmp_f2elm(ulong[][] x, ulong[][] y) + internal byte cmp_f2elm(ulong[][] x, ulong[][] y) { // Comparison of two GF(p^2) elements in constant time. // Is x != y? return -1 if condition is true, 0 otherwise. ulong[][] a = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -1298,7 +1297,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Encoding digits to bytes according to endianness - protected internal void encode_to_bytes(ulong[] x, byte[] enc, uint encOffset, uint nbytes) + internal void encode_to_bytes(ulong[] x, byte[] enc, uint encOffset, uint nbytes) { byte[] test = new byte[((nbytes*4+7)&~7)]; Pack.UInt64_To_LE(x, test, 0); @@ -1306,7 +1305,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Decoding bytes to digits according to endianness - protected internal void decode_to_digits(byte[] x, uint xOffset, ulong[] dec, uint nbytes, uint ndigits) + internal void decode_to_digits(byte[] x, uint xOffset, ulong[] dec, uint nbytes, uint ndigits) { // x -> dec dec[ndigits - 1] = 0; @@ -1317,7 +1316,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // r = a - b*i where v = a + b*i - protected internal void fp2_conj(ulong[][] v, ulong[][] r) + internal void fp2_conj(ulong[][] v, ulong[][] r) { fpcopy(v[0], 0, r[0]); fpcopy(v[1], 0, r[1]); @@ -1368,28 +1367,28 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Copy a GF(p^2) element, c = a. - protected internal void fp2copy(ulong[][] a, ulong[][] c) + internal void fp2copy(ulong[][] a, ulong[][] c) { fpcopy(a[0], 0, c[0]); fpcopy(a[1], 0, c[1]); } // Copy a GF(p^2) element, c = a. - protected internal void fp2copy(ulong[][] a, uint aOffset, ulong[][] c) + internal void fp2copy(ulong[][] a, uint aOffset, ulong[][] c) { fpcopy(a[0 + aOffset], 0, c[0]); fpcopy(a[1 + aOffset], 0, c[1]); } // Copy a GF(p^2) element, c = a. - protected internal void fp2copy(ulong[] a, uint aOffset, ulong[][] c) + internal void fp2copy(ulong[] a, uint aOffset, ulong[][] c) { fpcopy(a, aOffset, c[0]); fpcopy(a, aOffset + engine.param.NWORDS_FIELD, c[1]); } // Zero a field element, a = 0. - protected internal void fpzero(ulong[] a) + internal void fpzero(ulong[] a) { uint i; @@ -1400,7 +1399,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // GF(p^2) subtraction with correction with 2*p, c = a-b+2p in GF(p^2). - protected internal void mp2_sub_p2(ulong[][] a, ulong[][] b, ulong[][] c) + internal void mp2_sub_p2(ulong[][] a, ulong[][] b, ulong[][] c) { //todo/org : make fp class and change this to generic mp_sub_p2 mp_subPRIME_p2(a[0], b[0], c[0]); @@ -1408,7 +1407,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Multiprecision comba multiply, c = a*b, where lng(a) = lng(b) = nwords. - protected internal void mp_mul(ulong[] a, ulong[] b, ulong[] c, uint nwords) + internal void mp_mul(ulong[] a, ulong[] b, ulong[] c, uint nwords) { ulong i, j; ulong t = 0, u = 0, v = 0; @@ -1461,7 +1460,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Multiprecision comba multiply, c = a*b, where lng(a) = lng(b) = nwords. - protected internal void mp_mul(ulong[] a, uint aOffset, ulong[] b, ulong[] c, uint nwords) + internal void mp_mul(ulong[] a, uint aOffset, ulong[] b, ulong[] c, uint nwords) { ulong i, j; ulong t = 0, u = 0, v = 0; @@ -1516,7 +1515,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // GF(p^2) multiplication using Montgomery arithmetic, c = a*b in GF(p^2). // Inputs: a = a0+a1*i and b = b0+b1*i, where a0, a1, b0, b1 are in [0, 2*p-1] // Output: c = c0+c1*i, where c0, c1 are in [0, 2*p-1] - protected internal void fp2mul_mont(ulong[][] a, ulong[][] b, ulong[][] c) + internal void fp2mul_mont(ulong[][] a, ulong[][] b, ulong[][] c) { ulong[] t1 = new ulong[engine.param.NWORDS_FIELD], t2 = new ulong[engine.param.NWORDS_FIELD]; @@ -1535,7 +1534,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike rdc_mont(tt1, c[0]); // c[0] = a0*b0 - a1*b1 } - protected internal void fp2mul_mont(ulong[][] a, ulong[][] b, uint bOffset, ulong[][] c) + internal void fp2mul_mont(ulong[][] a, ulong[][] b, uint bOffset, ulong[][] c) { // System.out.pruint("b: "); @@ -1559,7 +1558,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike rdc_mont(tt1, c[0]); // c[0] = a0*b0 - a1*b1 } - protected internal void fp2mul_mont(ulong[][] a, ulong[] b, uint bOffset, ulong[][] c) + internal void fp2mul_mont(ulong[][] a, ulong[] b, uint bOffset, ulong[][] c) { ulong[] t1 = new ulong[engine.param.NWORDS_FIELD], t2 = new ulong[engine.param.NWORDS_FIELD]; @@ -1587,7 +1586,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Multiprecision subtraction, c = a-b, where lng(a) = lng(b) = nwords. Returns the borrow bit. - protected internal ulong mp_sub(ulong[] a, ulong[] b, ulong[] c, uint nwords) + internal ulong mp_sub(ulong[] a, ulong[] b, ulong[] c, uint nwords) { ulong i, borrow = 0; @@ -1606,7 +1605,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Is x < y? return 1 (TRUE) if condition is true, 0 (FALSE) otherwise. // SECURITY NOTE: This function does not run in constant-time. - protected internal bool is_orderelm_lt(ulong[] x, ulong[] y) + internal bool is_orderelm_lt(ulong[] x, ulong[] y) { for (int i = (int)engine.param.NWORDS_ORDER-1; i >= 0; i--) { @@ -1637,7 +1636,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Multiprecision squaring, c = a^2 mod p. - protected internal void fpsqr_mont(ulong[] ma, ulong[] mc) + internal void fpsqr_mont(ulong[] ma, ulong[] mc) { ulong[] temp = new ulong[2*engine.param.NWORDS_FIELD]; @@ -1658,7 +1657,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // GF(p^2) inversion using Montgomery arithmetic, a = (a0-i*a1)/(a0^2+a1^2). - protected internal void fp2inv_mont(ulong[][] a) + internal void fp2inv_mont(ulong[][] a) { ulong[][] t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -1673,7 +1672,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Computes a = 3*a // The input is assumed to be OBOB_BITS-2 bits ulong and stored in SECRETKEY_B_BYTES - protected internal void mul3(byte[] a) + internal void mul3(byte[] a) { ulong[] temp1 = new ulong[engine.param.NWORDS_ORDER], temp2 = new ulong[engine.param.NWORDS_ORDER]; @@ -1686,7 +1685,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Compare two byte arrays in constant time. // Returns 0 if the byte arrays are equal, -1 otherwise. - protected internal byte ct_compare(byte[] a, byte[] b, uint len) + internal byte ct_compare(byte[] a, byte[] b, uint len) { byte r = 0; @@ -1699,7 +1698,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // Conditional move in constant time. // If selector = -1 then load r with a, else if selector = 0 then keep r. - protected internal void ct_cmov(byte[] r, byte[] a, uint len, byte selector) + internal void ct_cmov(byte[] r, byte[] a, uint len, byte selector) { for (uint i = 0; i < len; i++) { @@ -1708,7 +1707,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Copy wordsize digits, c = a, where lng(a) = nwords. - protected internal void copy_words(ulong[] a, ulong[] c, uint nwords) + internal void copy_words(ulong[] a, ulong[] c, uint nwords) { uint i; for (i = 0; i < nwords; i++) @@ -1718,7 +1717,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // c = (2^k)*a - protected internal void fp2shl(ulong[][] a, uint k, ulong[][] c) + internal void fp2shl(ulong[][] a, uint k, ulong[][] c) { fp2copy(a, c); for (uint j = 0; j < k; j++) @@ -1728,7 +1727,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Copy wordsize digits, c = a, where lng(a) = nwords. - protected internal void copy_words(PointProj a, PointProj c) + internal void copy_words(PointProj a, PointProj c) { uint i; for (i = 0; i < engine.param.NWORDS_FIELD; i++) @@ -1759,7 +1758,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike // GF(p^2) addition, c = a+b in GF(p^2). - protected internal void fp2add(ulong[][] a, ulong[][] b, ulong[][] c) + internal void fp2add(ulong[][] a, ulong[][] b, ulong[][] c) { //todo/org : make fp class and change this to generic function fpaddPRIME(a[0], b[0], c[0]); @@ -1767,7 +1766,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // GF(p^2) subtraction, c = a-b in GF(p^2). - protected internal void fp2sub(ulong[][] a, ulong[][] b, ulong[][] c) + internal void fp2sub(ulong[][] a, ulong[][] b, ulong[][] c) { //todo/org : make fp class and change this to generic function fpsubPRIME(a[0], b[0], c[0]); @@ -1783,7 +1782,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Multiprecision multiplication, c = a*b mod p. - protected internal void fpmul_mont(ulong[] ma, ulong[] mb, ulong[] mc) + internal void fpmul_mont(ulong[] ma, ulong[] mb, ulong[] mc) { ulong[] temp = new ulong[2*engine.param.NWORDS_FIELD]; @@ -1792,7 +1791,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } // Multiprecision multiplication, c = a*b mod p. - protected internal void fpmul_mont(ulong[] ma, uint maOffset, ulong[] mb, ulong[] mc) + internal void fpmul_mont(ulong[] ma, uint maOffset, ulong[] mb, ulong[] mc) { ulong[] temp = new ulong[2*engine.param.NWORDS_FIELD]; @@ -2233,5 +2232,4 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike } } } - - } \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/sike/Isogeny.cs b/crypto/src/pqc/crypto/sike/Isogeny.cs index 2d0ef1473..be9e3ba4d 100644 --- a/crypto/src/pqc/crypto/sike/Isogeny.cs +++ b/crypto/src/pqc/crypto/sike/Isogeny.cs @@ -12,7 +12,7 @@ internal sealed class Isogeny // Doubling of a Montgomery point in projective coordinates (X:Z) over affine curve coefficient A. // Input: projective Montgomery x-coordinates P = (X1:Z1), where x1=X1/Z1 and Montgomery curve constants (A+2)/4. // Output: projective Montgomery x-coordinates Q = 2*P = (X2:Z2). - protected internal void Double(PointProj P, PointProj Q, ulong[][] A24, uint k) + internal void Double(PointProj P, PointProj Q, ulong[][] A24, uint k) { ulong[][] temp = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), a = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -37,7 +37,7 @@ internal sealed class Isogeny } } - protected internal void CompleteMPoint(ulong[][] A, PointProj P, PointProjFull R) + internal void CompleteMPoint(ulong[][] A, PointProj P, PointProjFull R) { // Given an xz-only representation on a montgomery curve, compute its affine representation ulong[][] zero = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), one = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -81,10 +81,9 @@ internal sealed class Isogeny internal void Ladder(PointProj P, ulong[] m, ulong[][] A, uint order_bits, PointProj R) { - PointProj R0 = new PointProj(engine.param.NWORDS_FIELD), - R1 = new PointProj(engine.param.NWORDS_FIELD); + var R0 = new PointProj(engine.param.NWORDS_FIELD); + var R1 = new PointProj(engine.param.NWORDS_FIELD); ulong[][] A24 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); - uint bit = 0; ulong mask; int j, swap, prevbit = 0; @@ -96,7 +95,7 @@ internal sealed class Isogeny engine.fpx.fp2div2(A24, A24); // A24 = (A+2)/4 j = (int)order_bits - 1; - bit = (uint) ((m[j >> (int)Internal.LOG2RADIX] >> (int)(j & (Internal.RADIX-1))) & 1); + uint bit = (uint) ((m[j >> (int)Internal.LOG2RADIX] >> (int)(j & (Internal.RADIX-1))) & 1); while (bit == 0) { j--; @@ -106,7 +105,7 @@ internal sealed class Isogeny // R0 <- P, R1 <- 2P engine.fpx.fp2copy(P.X, R0.X); engine.fpx.fp2copy(P.Z, R0.Z); - xDBL_e(P, R1, A24, 1); + XDblE(P, R1, A24, 1); // Main loop for (int i = (int)j - 1; i >= 0; i--) @@ -116,12 +115,12 @@ internal sealed class Isogeny prevbit = (int) bit; mask = (ulong) (0 - swap); - swap_points(R0, R1, mask); - xDBLADD_proj(R0, R1, P.X, P.Z, A24); + SwapPoints(R0, R1, mask); + XDblAddProj(R0, R1, P.X, P.Z, A24); } swap = 0 ^ prevbit; mask = (ulong) (0 - swap); - swap_points(R0, R1, mask); + SwapPoints(R0, R1, mask); engine.fpx.fp2copy(R0.X, R.X); engine.fpx.fp2copy(R0.Z, R.Z); @@ -130,7 +129,7 @@ internal sealed class Isogeny // Simultaneous doubling and differential addition. // Input: projective Montgomery points P=(XP:ZP) and Q=(XQ:ZQ) such that xP=XP/ZP and xQ=XQ/ZQ, affine difference xPQ=x(P-Q) and Montgomery curve constant A24=(A+2)/4. // Output: projective Montgomery points P <- 2*P = (X2P:Z2P) such that x(2P)=X2P/Z2P, and Q <- P+Q = (XQP:ZQP) such that = x(Q+P)=XQP/ZQP. - private void xDBLADD_proj(PointProj P, PointProj Q, ulong[][] XPQ, ulong[][] ZPQ, ulong[][] A24) + private void XDblAddProj(PointProj P, PointProj Q, ulong[][] XPQ, ulong[][] ZPQ, ulong[][] A24) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -162,7 +161,7 @@ internal sealed class Isogeny // Doubling of a Montgomery point in projective coordinates (X:Z) over affine curve coefficient A. // Input: projective Montgomery x-coordinates P = (X1:Z1), where x1=X1/Z1 and Montgomery curve constants (A+2)/4. // Output: projective Montgomery x-coordinates Q = 2*P = (X2:Z2). - private void xDBL_e(PointProj P, PointProj Q, ulong[][] A24, int e) + private void XDblE(PointProj P, PointProj Q, ulong[][] A24, int e) { ulong[][] temp = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), a = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -192,14 +191,14 @@ internal sealed class Isogeny // Computes [3^e](X:Z) on Montgomery curve with projective constant via e repeated triplings. e triplings in E costs k*(5M + 6S + 9A) // Input: projective Montgomery x-coordinates P = (X:Z), where x=X/Z, Montgomery curve constant A2 = A/2 and the number of triplings e. // Output: projective Montgomery x-coordinates Q <- [3^e]P. - internal void xTPLe_fast(PointProj P, PointProj Q, ulong[][] A2, uint e) + internal void XTplEFast(PointProj P, PointProj Q, ulong[][] A2, uint e) { - PointProj T = new PointProj(engine.param.NWORDS_FIELD); + var T = new PointProj(engine.param.NWORDS_FIELD); engine.fpx.copy_words(P, T); for (int j = 0; j < e; j++) { - xTPL_fast(T, T, A2); + XTplFast(T, T, A2); } engine.fpx.copy_words(T, Q); } @@ -207,7 +206,7 @@ internal sealed class Isogeny // Montgomery curve (E: y^2 = x^3 + A*x^2 + x) x-only tripling at a cost 5M + 6S + 9A = 27p + 61a. // Input : projective Montgomery x-coordinates P = (X:Z), where x=X/Z and Montgomery curve constant A/2. // Output: projective Montgomery x-coordinates Q = 3*P = (X3:Z3). - private void xTPL_fast(PointProj P, PointProj Q, ulong[][] A2) + private void XTplFast(PointProj P, PointProj Q, ulong[][] A2) { ulong[][] t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t2 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -238,10 +237,10 @@ internal sealed class Isogeny } - protected internal void LADDER3PT(ulong[][] xP, ulong[][] xQ, ulong[][] xPQ, ulong[] m, uint AliceOrBob, PointProj R, ulong[][] A) + internal void LADDER3PT(ulong[][] xP, ulong[][] xQ, ulong[][] xPQ, ulong[] m, uint AliceOrBob, PointProj R, ulong[][] A) { - PointProj R0 = new PointProj(engine.param.NWORDS_FIELD), - R2 = new PointProj(engine.param.NWORDS_FIELD); + var R0 = new PointProj(engine.param.NWORDS_FIELD); + var R2 = new PointProj(engine.param.NWORDS_FIELD); ulong[][] A24 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); ulong mask; uint i, nbits, bit, swap, prevbit = 0; @@ -277,17 +276,17 @@ internal sealed class Isogeny swap = bit ^ prevbit; prevbit = bit; mask = 0 - (ulong) swap; - swap_points(R, R2, mask); - xDBLADD(R0, R2, R.X, A24); + SwapPoints(R, R2, mask); + XDblAdd(R0, R2, R.X, A24); engine.fpx.fp2mul_mont(R2.X, R.Z, R2.X); } swap = 0 ^ prevbit; mask = 0 - (ulong)swap; - swap_points(R, R2, mask); + SwapPoints(R, R2, mask); } // Complete point on A = 0 curve - protected internal void CompletePoint(PointProj P, PointProjFull R) + internal void CompletePoint(PointProj P, PointProjFull R) { ulong[][] xz = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), s2 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -318,13 +317,11 @@ internal sealed class Isogeny // Swap points. // If option = 0 then P <- P and Q <- Q, else if option = 0xFF...FF then P <- Q and Q <- P - protected internal void swap_points(PointProj P, PointProj Q, ulong option) + internal void SwapPoints(PointProj P, PointProj Q, ulong option) { //todo/org : put this in the PointProj class ulong temp; - int i; - - for (i = 0; i < engine.param.NWORDS_FIELD; i++) + for (int i = 0; i < engine.param.NWORDS_FIELD; i++) { temp = option & (P.X[0][i] ^ Q.X[0][i]); P.X[0][i] = temp ^ P.X[0][i]; @@ -344,7 +341,7 @@ internal sealed class Isogeny // Simultaneous doubling and differential addition. // Input: projective Montgomery points P=(XP:ZP) and Q=(XQ:ZQ) such that xP=XP/ZP and xQ=XQ/ZQ, affine difference xPQ=x(P-Q) and Montgomery curve constant A24=(A+2)/4. // Output: projective Montgomery points P <- 2*P = (X2P:Z2P) such that x(2P)=X2P/Z2P, and Q <- P+Q = (XQP:ZQP) such that = x(Q+P)=XQP/ZQP. - protected internal void xDBLADD(PointProj P, PointProj Q, ulong[][] xPQ, ulong[][] A24) + internal void XDblAdd(PointProj P, PointProj Q, ulong[][] xPQ, ulong[][] A24) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -373,21 +370,21 @@ internal sealed class Isogeny // Computes [2^e](X:Z) on Montgomery curve with projective constant via e repeated doublings. // Input: projective Montgomery x-coordinates P = (XP:ZP), such that xP=XP/ZP and Montgomery curve constants A+2C and 4C. // Output: projective Montgomery x-coordinates Q <- (2^e)*P. - protected internal void xDBLe(PointProj P, PointProj Q, ulong[][] A24plus, ulong[][] C24, uint e) + internal void XDblE(PointProj P, PointProj Q, ulong[][] A24plus, ulong[][] C24, uint e) { int i; engine.fpx.copy_words(P, Q); for (i = 0; i < e; i++) { - xDBL(Q, Q, A24plus, C24); + XDbl(Q, Q, A24plus, C24); } } // Doubling of a Montgomery point in projective coordinates (X:Z). // Input: projective Montgomery x-coordinates P = (X1:Z1), where x1=X1/Z1 and Montgomery curve constants A+2C and 4C. // Output: projective Montgomery x-coordinates Q = 2*P = (X2:Z2). - protected void xDBL(PointProj P, PointProj Q, ulong[][] A24plus, ulong[][] C24) + internal void XDbl(PointProj P, PointProj Q, ulong[][] A24plus, ulong[][] C24) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -407,7 +404,7 @@ internal sealed class Isogeny // Tripling of a Montgomery point in projective coordinates (X:Z). // Input: projective Montgomery x-coordinates P = (X:Z), where x=X/Z and Montgomery curve constants A24plus = A+2C and A24minus = A-2C. // Output: projective Montgomery x-coordinates Q = 3*P = (X3:Z3). - private void xTPL(PointProj P, PointProj Q, ulong[][] A24minus, ulong[][] A24plus) + private void XTpl(PointProj P, PointProj Q, ulong[][] A24minus, ulong[][] A24plus) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -444,20 +441,20 @@ internal sealed class Isogeny // Computes [3^e](X:Z) on Montgomery curve with projective constant via e repeated triplings. // Input: projective Montgomery x-coordinates P = (XP:ZP), such that xP=XP/ZP and Montgomery curve constants A24plus = A+2C and A24minus = A-2C. // Output: projective Montgomery x-coordinates Q <- (3^e)*P. - protected internal void xTPLe(PointProj P, PointProj Q, ulong[][] A24minus, ulong[][] A24plus, uint e) + internal void XTplE(PointProj P, PointProj Q, ulong[][] A24minus, ulong[][] A24plus, uint e) { int i; engine.fpx.copy_words(P, Q); for (i = 0; i < e; i++) { - xTPL(Q, Q, A24minus, A24plus); + XTpl(Q, Q, A24minus, A24plus); } } // Given the x-coordinates of P, Q, and R, returns the value A corresponding to the Montgomery curve E_A: y^2=x^3+A*x^2+x such that R=Q-P on E_A. // Input: the x-coordinates xP, xQ, and xR of the points P, Q and R. // Output: the coefficient A corresponding to the curve E_A: y^2=x^3+A*x^2+x. - protected internal void get_A(ulong[][] xP, ulong[][] xQ, ulong[][] xR, ulong[][] A) + internal void GetA(ulong[][] xP, ulong[][] xQ, ulong[][] xR, ulong[][] A) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -482,7 +479,7 @@ internal sealed class Isogeny // Computes the j-invariant of a Montgomery curve with projective constant. // Input: A,C in GF(p^2). // Output: j=256*(A^2-3*C^2)^3/(C^4*(A^2-4*C^2)), which is the j-invariant of the Montgomery curve B*y^2=x^3+(A/C)*x^2+x or (equivalently) j-invariant of B'*y^2=C*x^3+A*x^2+C*x. - protected internal void j_inv(ulong[][] A, ulong[][] C, ulong[][] jinv) + internal void JInv(ulong[][] A, ulong[][] C, ulong[][] jinv) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -510,7 +507,7 @@ internal sealed class Isogeny // Computes the corresponding 3-isogeny of a projective Montgomery point (X3:Z3) of order 3. // Input: projective point of order three P = (X3:Z3). // Output: the 3-isogenous Montgomery curve with projective coefficient A/C. - protected internal void get_3_isog(PointProj P, ulong[][] A24minus, ulong[][] A24plus, ulong[][][] coeff) + internal void Get3Isog(PointProj P, ulong[][] A24minus, ulong[][] A24plus, ulong[][][] coeff) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -540,7 +537,7 @@ internal sealed class Isogeny // a point P with 2 coefficients in coeff (computed in the function get_3_Isog()). // Inputs: projective points P = (X3:Z3) and Q = (X:Z). // Output: the projective point Q <- phi(Q) = (X3:Z3). - protected internal void eval_3_isog(PointProj Q, ulong[][][] coeff) + internal void Eval3Isog(PointProj Q, ulong[][][] coeff) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -561,7 +558,7 @@ internal sealed class Isogeny // 3-way simultaneous inversion // Input: z1,z2,z3 // Output: 1/z1,1/z2,1/z3 (override inputs). - protected internal void inv_3_way(ulong[][] z1, ulong[][] z2, ulong[][] z3) + internal void Inv3Way(ulong[][] z1, ulong[][] z2, ulong[][] z3) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -581,7 +578,7 @@ internal sealed class Isogeny // Computes the corresponding 2-isogeny of a projective Montgomery point (X2:Z2) of order 2. // Input: projective point of order two P = (X2:Z2). // Output: the 2-isogenous Montgomery curve with projective coefficients A/C. - protected internal void get_2_isog(PointProj P, ulong[][] A, ulong[][] C) + internal void Get2Isog(PointProj P, ulong[][] A, ulong[][] C) { engine.fpx.fp2sqr_mont(P.X, A); // A = X2^2 engine.fpx.fp2sqr_mont(P.Z, C); // C = Z2^2 @@ -591,7 +588,7 @@ internal sealed class Isogeny // Evaluates the isogeny at the point (X:Z) in the domain of the isogeny, given a 2-isogeny phi. // Inputs: the projective point P = (X:Z) and the 2-isogeny kernel projetive point Q = (X2:Z2). // Output: the projective point P = phi(P) = (X:Z) in the codomain. - protected internal void eval_2_isog(PointProj P, PointProj Q) + internal void Eval2Isog(PointProj P, PointProj Q) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -614,7 +611,7 @@ internal sealed class Isogeny // Input: projective point of order four P = (X4:Z4). // Output: the 4-isogenous Montgomery curve with projective coefficients A+2C/4C and the 3 coefficients // that are used to evaluate the isogeny at a point in eval_4_Isog(). - protected internal void get_4_isog(PointProj P, ulong[][] A24plus, ulong[][] C24, ulong[][][] coeff) + internal void Get4Isog(PointProj P, ulong[][] A24plus, ulong[][] C24, ulong[][][] coeff) { engine.fpx.mp2_sub_p2(P.X, P.Z, coeff[1]); // coeff[1] = X4-Z4 engine.fpx.mp2_add(P.X, P.Z, coeff[2]); // coeff[2] = X4+Z4 @@ -631,7 +628,7 @@ internal sealed class Isogeny // by the 3 coefficients in coeff (computed in the function get_4_Isog()). // Inputs: the coefficients defining the isogeny, and the projective point P = (X:Z). // Output: the projective point P = phi(P) = (X:Z) in the codomain. - protected internal void eval_4_isog(PointProj P, ulong[][][] coeff) + internal void Eval4Isog(PointProj P, ulong[][][] coeff) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -651,9 +648,5 @@ internal sealed class Isogeny engine.fpx.fp2mul_mont(P.X, t1, P.X); // Xfinal engine.fpx.fp2mul_mont(P.Z, t0, P.Z); // Zfinal } - - - } - -} \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/sike/SIDH.cs b/crypto/src/pqc/crypto/sike/SIDH.cs index c1d1714f6..8246291c6 100644 --- a/crypto/src/pqc/crypto/sike/SIDH.cs +++ b/crypto/src/pqc/crypto/sike/SIDH.cs @@ -4,13 +4,13 @@ internal sealed class Sidh { private readonly SikeEngine engine; - public Sidh(SikeEngine engine) + internal Sidh(SikeEngine engine) { this.engine = engine; } // Initialization of basis points - protected void init_basis(ulong[] gen, ulong[][] XP, ulong[][] XQ, ulong[][] XR) + internal void init_basis(ulong[] gen, ulong[][] XP, ulong[][] XQ, ulong[][] XR) { engine.fpx.fpcopy(gen, 0, XP[0]); engine.fpx.fpcopy(gen, engine.param.NWORDS_FIELD, XP[1]); @@ -23,7 +23,7 @@ internal sealed class Sidh // Bob's ephemeral public key generation // Input: a private key PrivateKeyB in the range [0, 2^Floor(Log(2,oB)) - 1]. // Output: the public key PublicKeyB consisting of 3 elements in GF(p^2) which are encoded by removing leading 0 bytes. - protected internal void EphemeralKeyGeneration_B(byte[] sk, byte[] pk) + internal void EphemeralKeyGeneration_B(byte[] sk, byte[] pk) { PointProj R = new PointProj(engine.param.NWORDS_FIELD), phiP = new PointProj(engine.param.NWORDS_FIELD), @@ -71,29 +71,29 @@ internal sealed class Sidh engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Bob[ii++]; - engine.isogeny.xTPLe(R, R, A24minus, A24plus, m); + engine.isogeny.XTplE(R, R, A24minus, A24plus, m); index += m; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_3_isog(pts[i], coeff); + engine.isogeny.Eval3Isog(pts[i], coeff); } - engine.isogeny.eval_3_isog(phiP, coeff); - engine.isogeny.eval_3_isog(phiQ, coeff); - engine.isogeny.eval_3_isog(phiR, coeff); + engine.isogeny.Eval3Isog(phiP, coeff); + engine.isogeny.Eval3Isog(phiQ, coeff); + engine.isogeny.Eval3Isog(phiR, coeff); engine.fpx.fp2copy(pts[npts - 1].X, R.X); engine.fpx.fp2copy(pts[npts - 1].Z, R.Z); index = pts_index[npts - 1]; npts -= 1; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); - engine.isogeny.eval_3_isog(phiP, coeff); - engine.isogeny.eval_3_isog(phiQ, coeff); - engine.isogeny.eval_3_isog(phiR, coeff); - engine.isogeny.inv_3_way(phiP.Z, phiQ.Z, phiR.Z); + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); + engine.isogeny.Eval3Isog(phiP, coeff); + engine.isogeny.Eval3Isog(phiQ, coeff); + engine.isogeny.Eval3Isog(phiR, coeff); + engine.isogeny.Inv3Way(phiP.Z, phiQ.Z, phiR.Z); engine.fpx.fp2mul_mont(phiP.X, phiP.Z, phiP.X); engine.fpx.fp2mul_mont(phiQ.X, phiQ.Z, phiQ.X); @@ -108,7 +108,7 @@ internal sealed class Sidh // Alice's ephemeral public key generation // Input: a private key PrivateKeyA in the range [0, 2^eA - 1]. // Output: the public key PublicKeyA consisting of 3 elements in GF(p^2) which are encoded by removing leading 0 bytes. - protected internal void EphemeralKeyGeneration_A(byte[] ephemeralsk, byte[] ct) + internal void EphemeralKeyGeneration_A(byte[] ephemeralsk, byte[] ct) { PointProj R = new PointProj(engine.param.NWORDS_FIELD), phiP = new PointProj(engine.param.NWORDS_FIELD), @@ -149,12 +149,12 @@ internal sealed class Sidh if (engine.param.OALICE_BITS % 2 == 1) { PointProj S = new PointProj(engine.param.NWORDS_FIELD); - engine.isogeny.xDBLe(R, S, A24plus, C24, (engine.param.OALICE_BITS - 1)); - engine.isogeny.get_2_isog(S, A24plus, C24); - engine.isogeny.eval_2_isog(phiP, S); - engine.isogeny.eval_2_isog(phiQ, S); - engine.isogeny.eval_2_isog(phiR, S); - engine.isogeny.eval_2_isog(R, S); + engine.isogeny.XDblE(R, S, A24plus, C24, (engine.param.OALICE_BITS - 1)); + engine.isogeny.Get2Isog(S, A24plus, C24); + engine.isogeny.Eval2Isog(phiP, S); + engine.isogeny.Eval2Isog(phiQ, S); + engine.isogeny.Eval2Isog(phiR, S); + engine.isogeny.Eval2Isog(R, S); } // Traverse tree @@ -168,18 +168,18 @@ internal sealed class Sidh engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Alice[ii++]; - engine.isogeny.xDBLe(R, R, A24plus, C24, 2*m); + engine.isogeny.XDblE(R, R, A24plus, C24, 2*m); index += m; } - engine.isogeny.get_4_isog(R, A24plus, C24, coeff); + engine.isogeny.Get4Isog(R, A24plus, C24, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_4_isog(pts[i], coeff); + engine.isogeny.Eval4Isog(pts[i], coeff); } - engine.isogeny.eval_4_isog(phiP, coeff); - engine.isogeny.eval_4_isog(phiQ, coeff); - engine.isogeny.eval_4_isog(phiR, coeff); + engine.isogeny.Eval4Isog(phiP, coeff); + engine.isogeny.Eval4Isog(phiQ, coeff); + engine.isogeny.Eval4Isog(phiR, coeff); engine.fpx.fp2copy(pts[npts-1].X, R.X); engine.fpx.fp2copy(pts[npts-1].Z, R.Z); @@ -187,12 +187,12 @@ internal sealed class Sidh npts -= 1; } - engine.isogeny.get_4_isog(R, A24plus, C24, coeff); - engine.isogeny.eval_4_isog(phiP, coeff); - engine.isogeny.eval_4_isog(phiQ, coeff); - engine.isogeny.eval_4_isog(phiR, coeff); + engine.isogeny.Get4Isog(R, A24plus, C24, coeff); + engine.isogeny.Eval4Isog(phiP, coeff); + engine.isogeny.Eval4Isog(phiQ, coeff); + engine.isogeny.Eval4Isog(phiR, coeff); - engine.isogeny.inv_3_way(phiP.Z, phiQ.Z, phiR.Z); + engine.isogeny.Inv3Way(phiP.Z, phiQ.Z, phiR.Z); engine.fpx.fp2mul_mont(phiP.X, phiP.Z, phiP.X); engine.fpx.fp2mul_mont(phiQ.X, phiQ.Z, phiQ.X); engine.fpx.fp2mul_mont(phiR.X, phiR.Z, phiR.X); @@ -209,7 +209,7 @@ internal sealed class Sidh // Inputs: Alice's PrivateKeyA is an integer in the range [0, oA-1]. // Bob's PublicKeyB consists of 3 elements in GF(p^2) encoded by removing leading 0 bytes. // Output: a shared secret SharedSecretA that consists of one element in GF(p^2) encoded by removing leading 0 bytes. - protected internal void EphemeralSecretAgreement_A(byte[] ephemeralsk, byte[] pk, byte[] jinvariant) + internal void EphemeralSecretAgreement_A(byte[] ephemeralsk, byte[] pk, byte[] jinvariant) { PointProj R = new PointProj(engine.param.NWORDS_FIELD); PointProj[] pts = new PointProj[engine.param.MAX_INT_POINTS_ALICE]; @@ -230,7 +230,7 @@ internal sealed class Sidh engine.fpx.fp2_decode(pk, PKB[2], 2*engine.param.FP2_ENCODED_BYTES); // Initialize constants: A24plus = A+2C, C24 = 4C, where C=1 - engine.isogeny.get_A(PKB[0], PKB[1], PKB[2], A); + engine.isogeny.GetA(PKB[0], PKB[1], PKB[2], A); engine.fpx.mp_add(engine.param.Montgomery_one, engine.param.Montgomery_one, C24[0], engine.param.NWORDS_FIELD); engine.fpx.mp2_add(A, C24, A24plus); engine.fpx.mp_add(C24[0], C24[0], C24[0], engine.param.NWORDS_FIELD); @@ -243,9 +243,9 @@ internal sealed class Sidh { PointProj S = new PointProj(engine.param.NWORDS_FIELD); - engine.isogeny.xDBLe(R, S, A24plus, C24, engine.param.OALICE_BITS - 1); - engine.isogeny.get_2_isog(S, A24plus, C24); - engine.isogeny.eval_2_isog(R, S); + engine.isogeny.XDblE(R, S, A24plus, C24, engine.param.OALICE_BITS - 1); + engine.isogeny.Get2Isog(S, A24plus, C24); + engine.isogeny.Eval2Isog(R, S); } // Traverse tree @@ -259,14 +259,14 @@ internal sealed class Sidh engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Alice[ii++]; - engine.isogeny.xDBLe(R, R, A24plus, C24, 2*m); + engine.isogeny.XDblE(R, R, A24plus, C24, 2*m); index += m; } - engine.isogeny.get_4_isog(R, A24plus, C24, coeff); + engine.isogeny.Get4Isog(R, A24plus, C24, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_4_isog(pts[i], coeff); + engine.isogeny.Eval4Isog(pts[i], coeff); } engine.fpx.fp2copy(pts[npts-1].X, R.X); @@ -275,11 +275,11 @@ internal sealed class Sidh npts -= 1; } - engine.isogeny.get_4_isog(R, A24plus, C24, coeff); + engine.isogeny.Get4Isog(R, A24plus, C24, coeff); engine.fpx.mp2_add(A24plus, A24plus, A24plus); engine.fpx.fp2sub(A24plus, C24, A24plus); engine.fpx.fp2add(A24plus, A24plus, A24plus); - engine.isogeny.j_inv(A24plus, C24, jinv); + engine.isogeny.JInv(A24plus, C24, jinv); engine.fpx.fp2_encode(jinv, jinvariant, 0); // Format shared secret } @@ -288,7 +288,7 @@ internal sealed class Sidh // Inputs: Bob's PrivateKeyB is an integer in the range [0, 2^Floor(Log(2,oB)) - 1]. // Alice's PublicKeyA consists of 3 elements in GF(p^2) encoded by removing leading 0 bytes. // Output: a shared secret SharedSecretB that consists of one element in GF(p^2) encoded by removing leading 0 bytes. - protected internal void EphemeralSecretAgreement_B(byte[] sk, byte[] ct, byte[] jinvariant_) + internal void EphemeralSecretAgreement_B(byte[] sk, byte[] ct, byte[] jinvariant_) { PointProj R = new PointProj(engine.param.NWORDS_FIELD); PointProj[] pts = new PointProj[engine.param.MAX_INT_POINTS_BOB]; @@ -309,7 +309,7 @@ internal sealed class Sidh engine.fpx.fp2_decode(ct, PKB[2], 2*engine.param.FP2_ENCODED_BYTES); // Initialize constants: A24plus = A+2C, A24minus = A-2C, where C=1 - engine.isogeny.get_A(PKB[0], PKB[1], PKB[2], A); + engine.isogeny.GetA(PKB[0], PKB[1], PKB[2], A); engine.fpx.mp_add(engine.param.Montgomery_one, engine.param.Montgomery_one, A24minus[0], engine.param.NWORDS_FIELD); engine.fpx.mp2_add(A, A24minus, A24plus); engine.fpx.mp2_sub_p2(A, A24minus, A24minus); @@ -329,13 +329,13 @@ internal sealed class Sidh engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Bob[ii++]; - engine.isogeny.xTPLe(R, R, A24minus, A24plus, m); + engine.isogeny.XTplE(R, R, A24minus, A24plus, m); index += m; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_3_isog(pts[i], coeff); + engine.isogeny.Eval3Isog(pts[i], coeff); } engine.fpx.fp2copy(pts[npts-1].X, R.X); @@ -344,14 +344,12 @@ internal sealed class Sidh npts -= 1; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); engine.fpx.fp2add(A24plus, A24minus, A); engine.fpx.fp2add(A, A, A); engine.fpx.fp2sub(A24plus, A24minus, A24plus); - engine.isogeny.j_inv(A, A24plus, jinv); + engine.isogeny.JInv(A, A24plus, jinv); engine.fpx.fp2_encode(jinv, jinvariant_, 0); // Format shared secret } - } - -} \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/sike/SIDH_Compressed.cs b/crypto/src/pqc/crypto/sike/SIDH_Compressed.cs index ca140aa50..cf69d0f82 100644 --- a/crypto/src/pqc/crypto/sike/SIDH_Compressed.cs +++ b/crypto/src/pqc/crypto/sike/SIDH_Compressed.cs @@ -9,12 +9,12 @@ internal sealed class SidhCompressed { private readonly SikeEngine engine; - public SidhCompressed(SikeEngine engine) + internal SidhCompressed(SikeEngine engine) { this.engine = engine; } - protected void init_basis(ulong[] gen, ulong[][] XP, ulong[][] XQ, ulong[][] XR) + internal void init_basis(ulong[] gen, ulong[][] XP, ulong[][] XQ, ulong[][] XR) { // Initialization of basis points engine.fpx.fpcopy(gen, 0, XP[0]); @@ -25,8 +25,7 @@ internal sealed class SidhCompressed engine.fpx.fpcopy(gen, 5*engine.param.NWORDS_FIELD, XR[1]); } - - protected internal void FormatPrivKey_B(byte[] skB) + internal void FormatPrivKey_B(byte[] skB) { skB[engine.param.SECRETKEY_B_BYTES-2] &= (byte)engine.param.MASK3_BOB; skB[engine.param.SECRETKEY_B_BYTES-1] &= (byte)engine.param.MASK2_BOB; // Clear necessary bits so that 3*ephemeralsk is still less than Bob_order @@ -35,7 +34,7 @@ internal sealed class SidhCompressed // Generation of Alice's secret key // Outputs random value in [0, 2^eA - 1] - protected void random_mod_order_A(byte[] random_digits, SecureRandom random) + internal void random_mod_order_A(byte[] random_digits, SecureRandom random) { byte[] temp = new byte[engine.param.SECRETKEY_A_BYTES]; random.NextBytes(temp); @@ -46,7 +45,7 @@ internal sealed class SidhCompressed // Generation of Bob's secret key // Outputs random value in [0, 2^Floor(Log(2, oB)) - 1] - protected void random_mod_order_B(byte[] random_digits, SecureRandom random) + internal void random_mod_order_B(byte[] random_digits, SecureRandom random) { byte[] temp = new byte[engine.param.SECRETKEY_B_BYTES]; random.NextBytes(temp); @@ -55,7 +54,7 @@ internal sealed class SidhCompressed } // Project 3-pouint ladder - protected void Ladder3pt_dual(PointProj[] Rs, ulong[] m, uint AliceOrBob, PointProj R, ulong[][] A24) + internal void Ladder3pt_dual(PointProj[] Rs, ulong[] m, uint AliceOrBob, PointProj R, ulong[][] A24) { PointProj R0 = new PointProj(engine.param.NWORDS_FIELD), R2 = new PointProj(engine.param.NWORDS_FIELD); @@ -85,18 +84,16 @@ internal sealed class SidhCompressed prevbit = bit; mask = 0 - (ulong)swap; - engine.isogeny.swap_points(R, R2, mask); - engine.isogeny.xDBLADD(R0, R2, R.X, A24); + engine.isogeny.SwapPoints(R, R2, mask); + engine.isogeny.XDblAdd(R0, R2, R.X, A24); engine.fpx.fp2mul_mont(R2.X, R.Z, R2.X); } swap = 0 ^ prevbit; mask = 0 - (ulong)swap; - engine.isogeny.swap_points(R, R2, mask); + engine.isogeny.SwapPoints(R, R2, mask); } - - - protected void Elligator2(ulong[][] a24, uint[] r, uint rIndex, ulong[][] x, byte[] bit, uint bitOffset, uint COMPorDEC) + internal void Elligator2(ulong[][] a24, uint[] r, uint rIndex, ulong[][] x, byte[] bit, uint bitOffset, uint COMPorDEC) { // Generate an x-coordinate of a pouint on curve with (affine) coefficient a24 // Use the counter r uint i; @@ -189,8 +186,7 @@ internal sealed class SidhCompressed // {System.out.printf("%016x ", x[di][dj] );}System.out.Println();} } - - protected void make_positive(ulong[][] x) + internal void make_positive(ulong[][] x) { uint nbytes = engine.param.NWORDS_FIELD; ulong[] zero = new ulong[engine.param.NWORDS_FIELD]; @@ -213,8 +209,7 @@ internal sealed class SidhCompressed engine.fpx.to_fp2mont(x, x); } - - protected void BiQuad_affine(ulong[][] a24, ulong[][] x0, ulong[][] x1, PointProj R) + internal void BiQuad_affine(ulong[][] a24, ulong[][] x0, ulong[][] x1, PointProj R) { ulong[][] Ap2 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), aa = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -259,8 +254,7 @@ internal sealed class SidhCompressed engine.fpx.fp2add(aa, aa, R.Z); } - - protected void get_4_isog_dual(PointProj P, ulong[][] A24, ulong[][] C24, ulong[][][] coeff) + internal void get_4_isog_dual(PointProj P, ulong[][] A24, ulong[][] C24, ulong[][][] coeff) { engine.fpx.fp2sub(P.X, P.Z, coeff[1]); engine.fpx.fp2add(P.X, P.Z, coeff[2]); @@ -275,7 +269,7 @@ internal sealed class SidhCompressed // if (engine.param.OALICE_BITS % 2 == 1) - protected void eval_dual_2_isog(ulong[][] X2, ulong[][] Z2, PointProj P) + internal void eval_dual_2_isog(ulong[][] X2, ulong[][] Z2, PointProj P) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -288,7 +282,7 @@ internal sealed class SidhCompressed engine.fpx.fp2mul_mont(Z2, t0, P.X); } - protected void eval_final_dual_2_isog(PointProj P) + internal void eval_final_dual_2_isog(PointProj P) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -306,7 +300,7 @@ internal sealed class SidhCompressed } - protected void eval_dual_4_isog_shared(ulong[][] X4pZ4, ulong[][] X42, ulong[][] Z42, ulong[][][] coeff, uint coeffOffset) + internal void eval_dual_4_isog_shared(ulong[][] X4pZ4, ulong[][] X42, ulong[][] Z42, ulong[][][] coeff, uint coeffOffset) { // System.out.print("coeff0: "); // for (uint di = 0; di < 2; di++){ @@ -340,8 +334,7 @@ internal sealed class SidhCompressed // System.out.printf("%016x ", coeff[2 + coeffOffset][di][dj]);}System.out.Println();} } - - protected void eval_dual_4_isog(ulong[][] A24, ulong[][] C24, ulong[][][] coeff, uint coeffOffset, PointProj P) + internal void eval_dual_4_isog(ulong[][] A24, ulong[][] C24, ulong[][][] coeff, uint coeffOffset, PointProj P) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -365,8 +358,7 @@ internal sealed class SidhCompressed engine.fpx.fp2mul_mont(coeff[2 + coeffOffset], P.Z, P.Z); } - - protected void eval_full_dual_4_isog(ulong[][][][] As, PointProj P) + internal void eval_full_dual_4_isog(ulong[][][][] As, PointProj P) { //todo : check // First all 4-isogenies @@ -384,8 +376,7 @@ internal sealed class SidhCompressed eval_final_dual_2_isog(P); // to A = 0 } - - protected void TripleAndParabola_proj(PointProjFull R, ulong[][] l1x, ulong[][] l1z) + internal void TripleAndParabola_proj(PointProjFull R, ulong[][] l1x, ulong[][] l1z) { engine.fpx.fp2sqr_mont(R.X, l1z); engine.fpx.fp2add(l1z, l1z, l1x); @@ -394,8 +385,7 @@ internal sealed class SidhCompressed engine.fpx.fp2add(R.Y, R.Y, l1z); } - - protected void Tate3_proj(PointProjFull P, PointProjFull Q, ulong[][] gX, ulong[][] gZ) + internal void Tate3_proj(PointProjFull P, PointProjFull Q, ulong[][] gX, ulong[][] gZ) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), l1x = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -408,8 +398,7 @@ internal sealed class SidhCompressed engine.fpx.fp2add(gX, t0, gX); } - - protected void FinalExpo3(ulong[][] gX, ulong[][] gZ) + internal void FinalExpo3(ulong[][] gX, ulong[][] gZ) { uint i; @@ -432,8 +421,7 @@ internal sealed class SidhCompressed } } - - protected void FinalExpo3_2way(ulong[][][] gX, ulong[][][] gZ) + internal void FinalExpo3_2way(ulong[][][] gX, ulong[][][] gZ) { uint i, j; @@ -463,7 +451,6 @@ internal sealed class SidhCompressed } } - private bool FirstPoint_dual(PointProj P, PointProjFull R, byte[] ind) { PointProjFull R3 = new PointProjFull(engine.param.NWORDS_FIELD), @@ -580,7 +567,6 @@ internal sealed class SidhCompressed return true; } - private bool SecondPoint_dual(PointProj P, PointProjFull R, byte[] ind) { PointProjFull RS3 = new PointProjFull(engine.param.NWORDS_FIELD); @@ -612,8 +598,7 @@ internal sealed class SidhCompressed } } - - protected void FirstPoint3n(ulong[][] a24, ulong[][][][] As, ulong[][] x, PointProjFull R, uint[] r, byte[] ind, byte[] bitEll) + internal void FirstPoint3n(ulong[][] a24, ulong[][][][] As, ulong[][] x, PointProjFull R, uint[] r, byte[] ind, byte[] bitEll) { bool b = false; PointProj P = new PointProj(engine.param.NWORDS_FIELD); @@ -668,8 +653,7 @@ internal sealed class SidhCompressed } } - - protected void SecondPoint3n(ulong[][] a24, ulong[][][][] As, ulong[][] x, PointProjFull R, uint[] r, byte[] ind, byte[] bitEll) + internal void SecondPoint3n(ulong[][] a24, ulong[][][][] As, ulong[][] x, PointProjFull R, uint[] r, byte[] ind, byte[] bitEll) { bool b = false; PointProj P = new PointProj(engine.param.NWORDS_FIELD); @@ -724,8 +708,7 @@ internal sealed class SidhCompressed } } - - protected void makeDiff(PointProjFull R, PointProjFull S, PointProj D) + internal void makeDiff(PointProjFull R, PointProjFull S, PointProj D) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -749,8 +732,7 @@ internal sealed class SidhCompressed } } - - protected void BuildOrdinary3nBasis_dual(ulong[][] a24, ulong[][][][] As, PointProjFull[] R, uint[] r, uint[] bitsEll, uint bitsEllOffset) + internal void BuildOrdinary3nBasis_dual(ulong[][] a24, ulong[][][][] As, PointProjFull[] R, uint[] r, uint[] bitsEll, uint bitsEllOffset) { PointProj D = new PointProj(engine.param.NWORDS_FIELD); @@ -809,8 +791,7 @@ internal sealed class SidhCompressed makeDiff(R[0], R[1], D); } - - protected void FullIsogeny_A_dual(byte[] PrivateKeyA, ulong[][][][] As, ulong[][] a24, uint sike) + internal void FullIsogeny_A_dual(byte[] PrivateKeyA, ulong[][][][] As, ulong[][] a24, uint sike) { // Input: a private key PrivateKeyA in the range [0, 2^eA - 1]. // Output: the public key PublicKeyA consisting of 3 elements in GF(p^2) which are encoded by removing leading 0 bytes. @@ -925,9 +906,9 @@ internal sealed class SidhCompressed { PointProj S = new PointProj(engine.param.NWORDS_FIELD); - engine.isogeny.xDBLe(R, S, A24, C24, engine.param.OALICE_BITS - 1); - engine.isogeny.get_2_isog(S, A24, C24); - engine.isogeny.eval_2_isog(R, S); + engine.isogeny.XDblE(R, S, A24, C24, engine.param.OALICE_BITS - 1); + engine.isogeny.Get2Isog(S, A24, C24); + engine.isogeny.Eval2Isog(R, S); engine.fpx.fp2copy(S.X, As[engine.param.MAX_Alice][2]); engine.fpx.fp2copy(S.Z, As[engine.param.MAX_Alice][3]); } @@ -945,7 +926,7 @@ internal sealed class SidhCompressed engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Alice[ii++]; - engine.isogeny.xDBLe(R, R, A24, C24, 2*m); + engine.isogeny.XDblE(R, R, A24, C24, 2*m); index += m; } @@ -976,7 +957,7 @@ internal sealed class SidhCompressed get_4_isog_dual(R, A24, C24, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_4_isog(pts[i], coeff); + engine.isogeny.Eval4Isog(pts[i], coeff); // System.out.print(i + "ptsX: "); // for (uint di = 0; di < 2; di++){ @@ -1043,8 +1024,7 @@ internal sealed class SidhCompressed // System.out.printf("%016x ", a24[di][dj]);}System.out.Println();} } - - protected void Dlogs3_dual(ulong[][][] f, int[] D, ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1) + internal void Dlogs3_dual(ulong[][][] f, int[] D, ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1) { solve_dlog(f[0], D, d0, 3); solve_dlog(f[2], D, c0, 3); @@ -1054,8 +1034,7 @@ internal sealed class SidhCompressed engine.fpx.mp_sub(engine.param.Bob_order, c1, c1, engine.param.NWORDS_ORDER); } - - protected void BuildOrdinary3nBasis_Decomp_dual(ulong[][] A24, PointProj[] Rs, uint[] r, uint[] bitsEll, uint bitsEllIndex) + internal void BuildOrdinary3nBasis_Decomp_dual(ulong[][] A24, PointProj[] Rs, uint[] r, uint[] bitsEll, uint bitsEllIndex) { byte[] bitEll = new byte[2]; @@ -1071,8 +1050,7 @@ internal sealed class SidhCompressed BiQuad_affine(A24, Rs[0].X, Rs[1].X, Rs[2]); } - - protected void PKADecompression_dual(byte[] SecretKeyB, byte[] CompressedPKA, PointProj R, ulong[][] A) + internal void PKADecompression_dual(byte[] SecretKeyB, byte[] CompressedPKA, PointProj R, ulong[][] A) { byte bit; uint[] rs = new uint[3]; @@ -1120,7 +1098,7 @@ internal sealed class SidhCompressed engine.fpx.fpcopy(engine.param.Montgomery_one, 0, Rs[0].Z[0]); engine.fpx.fpcopy(engine.param.Montgomery_one, 0, Rs[1].Z[0]); - engine.isogeny.swap_points(Rs[0], Rs[1], ((ulong) -bit));//todo check + engine.isogeny.SwapPoints(Rs[0], Rs[1], ((ulong) -bit));//todo check engine.fpx.decode_to_digits(SecretKeyB, 0, SKin, engine.param.SECRETKEY_B_BYTES, engine.param.NWORDS_ORDER); engine.fpx.to_Montgomery_mod_order(SKin, t1, engine.param.Bob_order, engine.param.Montgomery_RB2, engine.param.Montgomery_RB1); // Converting to Montgomery representation engine.fpx.decode_to_digits(CompressedPKA, 0, temp, engine.param.ORDER_B_ENCODED_BYTES, engine.param.NWORDS_ORDER); @@ -1155,8 +1133,7 @@ internal sealed class SidhCompressed engine.isogeny.Double(R, R, A24, engine.param.OALICE_BITS); // x, z := Double(A24, x, 1, eA); } - - protected void Compress_PKA_dual(ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1, ulong[][] a24, uint[] rs, byte[] CompressedPKA) + internal void Compress_PKA_dual(ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1, ulong[][] a24, uint[] rs, byte[] CompressedPKA) { uint bit; ulong[] temp = new ulong[engine.param.NWORDS_ORDER], @@ -1231,7 +1208,7 @@ internal sealed class SidhCompressed // Alice's ephemeral public key generation using compression -- SIKE protocol // Output: PrivateKeyA[MSG_BYTES + engine.param.SECRETKEY_A_BYTES] <- x(K_A) where K_A = PA + sk_A*Q_A - protected internal uint EphemeralKeyGeneration_A_extended(byte[] PrivateKeyA, byte[] CompressedPKA) + internal uint EphemeralKeyGeneration_A_extended(byte[] PrivateKeyA, byte[] CompressedPKA) { uint[] rs = new uint[3]; int[] D = new int[engine.param.DLEN_3]; @@ -1363,14 +1340,14 @@ internal sealed class SidhCompressed engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Bob[ii++]; - engine.isogeny.xTPLe(R, R, A24minus, A24plus, m); + engine.isogeny.XTplE(R, R, A24minus, A24plus, m); index += m; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_3_isog(pts[i], coeff); + engine.isogeny.Eval3Isog(pts[i], coeff); } engine.fpx.fp2copy(pts[npts-1].X, R.X); @@ -1379,18 +1356,17 @@ internal sealed class SidhCompressed npts -= 1; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); engine.fpx.fp2add(A24plus, A24minus, A); engine.fpx.fp2add(A, A, A); engine.fpx.fp2sub(A24plus, A24minus, A24plus); - engine.isogeny.j_inv(A, A24plus, jinv); + engine.isogeny.JInv(A, A24plus, jinv); engine.fpx.fp2_encode(jinv, SharedSecretB, 0); // Format shared secret return 0; } - - protected void BuildEntangledXonly(ulong[][] A, PointProj[] R, byte[] qnr, byte[] ind) + internal void BuildEntangledXonly(ulong[][] A, PointProj[] R, byte[] qnr, byte[] ind) { ulong[] s = new ulong[engine.param.NWORDS_FIELD]; ulong[][] t_ptr, @@ -1456,8 +1432,7 @@ internal sealed class SidhCompressed engine.fpx.fp2mul_mont(t, r, R[2].X); } - - protected void RecoverY(ulong[][] A, PointProj[] xs, PointProjFull[] Rs) + internal void RecoverY(ulong[][] A, PointProj[] xs, PointProjFull[] Rs) { ulong[][] t0 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), t1 = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -1497,8 +1472,7 @@ internal sealed class SidhCompressed engine.fpx.fp2mul_mont(Rs[1].Y, Rs[1].Z, Rs[1].Y); } - - protected void BuildOrdinary2nBasis_dual(ulong[][] A, ulong[][][][] Ds, PointProjFull[] Rs, byte[] qnr, byte[] ind) + internal void BuildOrdinary2nBasis_dual(ulong[][] A, ulong[][][][] Ds, PointProjFull[] Rs, byte[] qnr, byte[] ind) { uint i; ulong[] t0 = new ulong[engine.param.NWORDS_FIELD]; @@ -1545,9 +1519,9 @@ internal sealed class SidhCompressed // Move them back to A = 6 for(i = 0; i < engine.param.MAX_Bob; i++) { - engine.isogeny.eval_3_isog(xs[0], Ds[engine.param.MAX_Bob-1-i]); - engine.isogeny.eval_3_isog(xs[1], Ds[engine.param.MAX_Bob-1-i]); - engine.isogeny.eval_3_isog(xs[2], Ds[engine.param.MAX_Bob-1-i]); + engine.isogeny.Eval3Isog(xs[0], Ds[engine.param.MAX_Bob-1-i]); + engine.isogeny.Eval3Isog(xs[1], Ds[engine.param.MAX_Bob-1-i]); + engine.isogeny.Eval3Isog(xs[2], Ds[engine.param.MAX_Bob-1-i]); } // Recover y-coordinates with a single sqrt on A = 6 @@ -1563,7 +1537,7 @@ internal sealed class SidhCompressed // Bob's ephemeral public key generation // Input: a private key PrivateKeyB in the range [0, 2^Floor(Log(2,oB)) - 1]. // Output: the public key PublicKeyB consisting of 3 elements in GF(p^2) which are encoded by removing leading 0 bytes. - protected void FullIsogeny_B_dual(byte[] PrivateKeyB, ulong[][][][] Ds, ulong[][] A) + internal void FullIsogeny_B_dual(byte[] PrivateKeyB, ulong[][][][] Ds, ulong[][] A) { PointProj R = new PointProj(engine.param.NWORDS_FIELD), Q3 = new PointProj(engine.param.NWORDS_FIELD); @@ -1621,15 +1595,15 @@ internal sealed class SidhCompressed engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Bob[ii++]; - engine.isogeny.xTPLe(R, R, A24minus, A24plus, m); + engine.isogeny.XTplE(R, R, A24minus, A24plus, m); index += m; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_3_isog(pts[i], coeff); + engine.isogeny.Eval3Isog(pts[i], coeff); } - engine.isogeny.eval_3_isog(Q3, coeff); // Kernel of dual + engine.isogeny.Eval3Isog(Q3, coeff); // Kernel of dual engine.fpx.fp2sub(Q3.X,Q3.Z,Ds[row-1][0]); engine.fpx.fp2add(Q3.X,Q3.Z,Ds[row-1][1]); @@ -1638,8 +1612,8 @@ internal sealed class SidhCompressed index = pts_index[npts-1]; npts -= 1; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); - engine.isogeny.eval_3_isog(Q3, coeff); // Kernel of dual + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); + engine.isogeny.Eval3Isog(Q3, coeff); // Kernel of dual engine.fpx.fp2sub(Q3.X, Q3.Z, Ds[engine.param.MAX_Bob-1][0]); engine.fpx.fp2add(Q3.X, Q3.Z, Ds[engine.param.MAX_Bob-1][1]); @@ -1650,8 +1624,7 @@ internal sealed class SidhCompressed engine.fpx.fp2add(A, A, A); // A = 2*(A24plus+A24mins)/(A24plus-A24minus) } - - protected void Dlogs2_dual(ulong[][][] f, int[] D, ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1) + internal void Dlogs2_dual(ulong[][][] f, int[] D, ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1) { solve_dlog(f[0], D, d0, 2); solve_dlog(f[2], D, c0, 2); @@ -1661,8 +1634,7 @@ internal sealed class SidhCompressed engine.fpx.mp_sub(engine.param.Alice_order, c1, c1, engine.param.NWORDS_ORDER); } - - protected void BuildEntangledXonly_Decomp(ulong[][] A, PointProj[] R, uint qnr, uint ind) + internal void BuildEntangledXonly_Decomp(ulong[][] A, PointProj[] R, uint qnr, uint ind) { ulong[][] t_ptr, r = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -1714,7 +1686,7 @@ internal sealed class SidhCompressed } // Bob's PK decompression -- SIKE protocol - protected void PKBDecompression_extended(byte[] SecretKeyA, uint SecretKeyAOffset, byte[] CompressedPKB, PointProj R, ulong[][] A, byte[] tphiBKA_t, uint tphiBKA_tOffset) + internal void PKBDecompression_extended(byte[] SecretKeyA, uint SecretKeyAOffset, byte[] CompressedPKB, PointProj R, ulong[][] A, byte[] tphiBKA_t, uint tphiBKA_tOffset) { ulong mask = unchecked((ulong) -1L); uint qnr, ind; @@ -1807,12 +1779,12 @@ internal sealed class SidhCompressed engine.fpx.inv_mod_orderA(tmp2, inv); engine.fpx.multiply(inv, tmp1, scal, engine.param.NWORDS_ORDER); scal[engine.param.NWORDS_ORDER-1] &= (ulong)mask; - engine.isogeny.swap_points(Rs[0], Rs[1], unchecked((ulong)-1L));//check + engine.isogeny.SwapPoints(Rs[0], Rs[1], unchecked((ulong)-1L));//check Ladder3pt_dual(Rs, scal, engine.param.ALICE, R, A24); } engine.fpx.fp2div2(A,Adiv2); - engine.isogeny.xTPLe_fast(R, R, Adiv2, engine.param.OBOB_EXPON); + engine.isogeny.XTplEFast(R, R, Adiv2, engine.param.OBOB_EXPON); engine.fpx.fp2_encode(R.X, tphiBKA_t, tphiBKA_tOffset); engine.fpx.fp2_encode(R.Z, tphiBKA_t, tphiBKA_tOffset + engine.param.FP2_ENCODED_BYTES); @@ -1820,7 +1792,7 @@ internal sealed class SidhCompressed } // Bob's PK compression -- SIKE protocol - protected void Compress_PKB_dual_extended(ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1, ulong[][] A, byte[] qnr, byte[] ind, byte[] CompressedPKB) + internal void Compress_PKB_dual_extended(ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1, ulong[][] A, byte[] qnr, byte[] ind, byte[] CompressedPKB) { ulong mask = unchecked((ulong) -1L); ulong[] tmp = new ulong[2*engine.param.NWORDS_ORDER], @@ -1876,7 +1848,7 @@ internal sealed class SidhCompressed } // Bob's PK decompression -- SIDH protocol - protected void PKBDecompression(byte[] SecretKeyA, uint SecretKeyAOffset, byte[] CompressedPKB, PointProj R, ulong[][] A) + internal void PKBDecompression(byte[] SecretKeyA, uint SecretKeyAOffset, byte[] CompressedPKB, PointProj R, ulong[][] A) { ulong mask = unchecked((ulong) -1L); uint bit,qnr,ind; @@ -1909,7 +1881,7 @@ internal sealed class SidhCompressed engine.fpx.fp2div2(A24, A24); engine.fpx.decode_to_digits(SecretKeyA, SecretKeyAOffset, SKin, engine.param.SECRETKEY_A_BYTES, engine.param.NWORDS_ORDER); - engine.isogeny.swap_points(Rs[0], Rs[1], 0-(ulong)bit); + engine.isogeny.SwapPoints(Rs[0], Rs[1], 0-(ulong)bit); if (bit == 0) { engine.fpx.decode_to_digits(CompressedPKB, engine.param.ORDER_A_ENCODED_BYTES, comp_temp, engine.param.ORDER_A_ENCODED_BYTES, engine.param.NWORDS_ORDER); @@ -1941,11 +1913,11 @@ internal sealed class SidhCompressed Ladder3pt_dual(Rs, vone, engine.param.ALICE, R, A24); } engine.fpx.fp2div2(A, A24); - engine.isogeny.xTPLe_fast(R, R, A24, engine.param.OBOB_EXPON); + engine.isogeny.XTplEFast(R, R, A24, engine.param.OBOB_EXPON); } // Bob's PK compression -- SIDH protocol - protected void Compress_PKB_dual(ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1, ulong[][] A, byte[] qnr, byte[] ind, byte[] CompressedPKB) + internal void Compress_PKB_dual(ulong[] d0, ulong[] c0, ulong[] d1, ulong[] c1, ulong[][] A, byte[] qnr, byte[] ind, byte[] CompressedPKB) { ulong[] tmp = new ulong[2*engine.param.NWORDS_ORDER], @@ -1990,7 +1962,7 @@ internal sealed class SidhCompressed } // Bob's ephemeral public key generation using compression -- SIKE protocol - protected internal uint EphemeralKeyGeneration_B_extended(byte[] PrivateKeyB, byte[] CompressedPKB, uint sike) + internal uint EphemeralKeyGeneration_B_extended(byte[] PrivateKeyB, byte[] CompressedPKB, uint sike) { byte[] qnr = new byte[1], ind = new byte[1]; int[] D = new int[engine.param.DLEN_2]; @@ -2114,13 +2086,13 @@ internal sealed class SidhCompressed } // Bob's ephemeral public key generation using compression -- SIDH protocol - protected uint EphemeralKeyGeneration_B(byte[] PrivateKeyB, byte[] CompressedPKB) + internal uint EphemeralKeyGeneration_B(byte[] PrivateKeyB, byte[] CompressedPKB) { return EphemeralKeyGeneration_B_extended(PrivateKeyB, CompressedPKB, 0); } // Alice's ephemeral shared secret computation using compression -- SIKE protocol - protected internal uint EphemeralSecretAgreement_A_extended(byte[] PrivateKeyA, uint PrivateKeyAOffset, byte[] PKB, byte[] SharedSecretA, uint sike) + internal uint EphemeralSecretAgreement_A_extended(byte[] PrivateKeyA, uint PrivateKeyAOffset, byte[] PKB, byte[] SharedSecretA, uint sike) { uint i, ii = 0, row, m, index = 0, npts = 0; uint[] pts_index = new uint[engine.param.MAX_INT_POINTS_ALICE]; @@ -2153,9 +2125,9 @@ internal sealed class SidhCompressed { PointProj S = new PointProj(engine.param.NWORDS_FIELD); - engine.isogeny.xDBLe(R, S, A24plus, C24, (engine.param.OALICE_BITS - 1)); - engine.isogeny.get_2_isog(S, A24plus, C24); - engine.isogeny.eval_2_isog(R, S); + engine.isogeny.XDblE(R, S, A24plus, C24, (engine.param.OALICE_BITS - 1)); + engine.isogeny.Get2Isog(S, A24plus, C24); + engine.isogeny.Eval2Isog(R, S); } // Traverse tree @@ -2169,14 +2141,14 @@ internal sealed class SidhCompressed engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Alice[ii++]; - engine.isogeny.xDBLe(R, R, A24plus, C24, 2*m); + engine.isogeny.XDblE(R, R, A24plus, C24, 2*m); index += m; } - engine.isogeny.get_4_isog(R, A24plus, C24, coeff); + engine.isogeny.Get4Isog(R, A24plus, C24, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_4_isog(pts[i], coeff); + engine.isogeny.Eval4Isog(pts[i], coeff); } engine.fpx.fp2copy(pts[npts-1].X, R.X); @@ -2185,11 +2157,11 @@ internal sealed class SidhCompressed npts -= 1; } - engine.isogeny.get_4_isog(R, A24plus, C24, coeff); + engine.isogeny.Get4Isog(R, A24plus, C24, coeff); engine.fpx.fp2add(A24plus, A24plus, A24plus); engine.fpx.fp2sub(A24plus, C24, A24plus); engine.fpx.fp2add(A24plus, A24plus, A24plus); - engine.isogeny.j_inv(A24plus, C24, jinv); + engine.isogeny.JInv(A24plus, C24, jinv); engine.fpx.fp2_encode(jinv, SharedSecretA, 0); // Format shared secret return 0; @@ -2200,13 +2172,12 @@ internal sealed class SidhCompressed // Inputs: Alice's PrivateKeyA is an even integer in the range [2, oA-2], where oA = 2^engine.param.OALICE_BITS. // Bob's decompressed data consists of point_R in (X:Z) coordinates and the curve parameter param_A in GF(p^2). // Output: a shared secret SharedSecretA that consists of one element in GF(p^2). - uint EphemeralSecretAgreement_A(byte[] PrivateKeyA, uint PrivateKeyAOffset, byte[] PKB, byte[] SharedSecretA) + private uint EphemeralSecretAgreement_A(byte[] PrivateKeyA, uint PrivateKeyAOffset, byte[] PKB, byte[] SharedSecretA) { return EphemeralSecretAgreement_A_extended(PrivateKeyA, PrivateKeyAOffset, PKB, SharedSecretA, 0); } - - protected internal byte validate_ciphertext(byte[] ephemeralsk_, byte[] CompressedPKB, byte[] xKA, uint xKAOffset, byte[] tphiBKA_t, uint tphiBKA_tOffset) + internal byte validate_ciphertext(byte[] ephemeralsk_, byte[] CompressedPKB, byte[] xKA, uint xKAOffset, byte[] tphiBKA_t, uint tphiBKA_tOffset) { // If ct validation passes returns 0, otherwise returns -1. PointProj[] phis = new PointProj[3], pts = new PointProj[engine.param.MAX_INT_POINTS_BOB]; @@ -2264,23 +2235,23 @@ internal sealed class SidhCompressed engine.fpx.fp2copy(R.Z, pts[npts].Z); pts_index[npts++] = index; m = engine.param.strat_Bob[ii++]; - engine.isogeny.xTPLe(R, R, A24minus, A24plus, m); + engine.isogeny.XTplE(R, R, A24minus, A24plus, m); index += m; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); for (i = 0; i < npts; i++) { - engine.isogeny.eval_3_isog(pts[i], coeff); + engine.isogeny.Eval3Isog(pts[i], coeff); } - engine.isogeny.eval_3_isog(phis[0], coeff); + engine.isogeny.Eval3Isog(phis[0], coeff); engine.fpx.fp2copy(pts[npts-1].X, R.X); engine.fpx.fp2copy(pts[npts-1].Z, R.Z); index = pts_index[npts-1]; npts -= 1; } - engine.isogeny.get_3_isog(R, A24minus, A24plus, coeff); - engine.isogeny.eval_3_isog(phis[0], coeff); // phis[0] <- phiB(PA + skA*QA) + engine.isogeny.Get3Isog(R, A24minus, A24plus, coeff); + engine.isogeny.Eval3Isog(phis[0], coeff); // phis[0] <- phiB(PA + skA*QA) engine.fpx.fp2_decode(CompressedPKB, A, 4*engine.param.ORDER_A_ENCODED_BYTES); @@ -2296,13 +2267,11 @@ internal sealed class SidhCompressed return (engine.fpx.cmp_f2elm(comp1, comp2)); } - - /// DLOG // Computes the discrete log of input r = g^d where g = e(P,Q)^ell^e, and P,Q are torsion generators in the initial curve // Return the integer d - void solve_dlog(ulong[][] r, int[] D, ulong[] d, uint ell) + internal void solve_dlog(ulong[][] r, int[] D, ulong[] d, uint ell) { if (ell == 2) { @@ -2449,12 +2418,10 @@ internal sealed class SidhCompressed } } - - // Traverse a Pohlig-Hellman optimal strategy to solve a discrete log in a group of order ell^e // Leaves are used to recover the digits which are numbers from 0 to ell^w-1 except by the last leaf that gives a digit between 0 and ell^(e mod w) // Assume w does not divide the exponent e - void Traverse_w_notdiv_e_fullsigned(ulong[][] r, uint j, uint k, uint z, uint[] P, ulong[] CT1, ulong[] CT2, + internal void Traverse_w_notdiv_e_fullsigned(ulong[][] r, uint j, uint k, uint z, uint[] P, ulong[] CT1, ulong[] CT2, int[] D, uint Dlen, uint ell, uint ellw, uint ell_emodw, uint w, uint e) { ulong[][] rp = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), @@ -2628,12 +2595,10 @@ internal sealed class SidhCompressed } } - - // Traverse a Pohlig-Hellman optimal strategy to solve a discrete log in a group of order ell^e // The leaves of the tree will be used to recover the signed digits which are numbers from +/-{0,1... Ceil((ell^w-1)/2)} // Assume the integer w divides the exponent e - void Traverse_w_div_e_fullsigned(ulong[][] r, uint j, uint k, uint z, uint[] P, ulong[] CT, int[] D, uint Dlen, uint ellw, uint w) + internal void Traverse_w_div_e_fullsigned(ulong[][] r, uint j, uint k, uint z, uint[] P, ulong[] CT, int[] D, uint Dlen, uint ellw, uint w) { ulong[][] rp = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD), alpha = SikeUtilities.InitArray(2, engine.param.NWORDS_FIELD); @@ -3158,9 +3123,5 @@ internal sealed class SidhCompressed } engine.fpx.fp2copy(temp, fout); } - - - } - -} \ No newline at end of file +} diff --git a/crypto/src/pqc/crypto/sike/SIKEEngine.cs b/crypto/src/pqc/crypto/sike/SIKEEngine.cs index 6a825fe44..12f468340 100644 --- a/crypto/src/pqc/crypto/sike/SIKEEngine.cs +++ b/crypto/src/pqc/crypto/sike/SIKEEngine.cs @@ -4,43 +4,42 @@ using Org.BouncyCastle.Security; namespace Org.BouncyCastle.Pqc.Crypto.Sike { -internal sealed class SikeEngine -{ - //private readonly SecureRandom random; - - protected internal Internal param; - protected internal Isogeny isogeny; - protected internal Fpx fpx; - private Sidh sidh; - private SidhCompressed sidhCompressed; - private bool isCompressed; - - public uint GetDefaultSessionKeySize() + internal sealed class SikeEngine { - return param.MSG_BYTES * 8; - } + internal Internal param; + internal Isogeny isogeny; + internal Fpx fpx; + private Sidh sidh; + private SidhCompressed sidhCompressed; + private bool isCompressed; + + internal uint GetDefaultSessionKeySize() + { + return param.MSG_BYTES * 8; + } - public int GetCipherTextSize() - { - return param.CRYPTO_CIPHERTEXTBYTES; - } + internal int GetCipherTextSize() + { + return param.CRYPTO_CIPHERTEXTBYTES; + } - public uint GetPrivateKeySize() - { - return param.CRYPTO_SECRETKEYBYTES; - } + internal uint GetPrivateKeySize() + { + return param.CRYPTO_SECRETKEYBYTES; + } - public uint GetPublicKeySize() - { - return param.CRYPTO_PUBLICKEYBYTES; - } - public SikeEngine(int ver, bool isCompressed, SecureRandom random) - { - //this.random = random; - this.isCompressed = isCompressed; - //todo switch for different parameters - switch(ver) + internal uint GetPublicKeySize() { + return param.CRYPTO_PUBLICKEYBYTES; + } + + internal SikeEngine(int ver, bool isCompressed, SecureRandom random) + { + //this.random = random; + this.isCompressed = isCompressed; + //todo switch for different parameters + switch(ver) + { case 434: param = new P434(isCompressed); break; @@ -55,239 +54,236 @@ internal sealed class SikeEngine break; default: break; - + } + fpx = new Fpx(this); + isogeny = new Isogeny(this); + if(isCompressed) + { + sidhCompressed = new SidhCompressed(this); + } + sidh = new Sidh(this); } - fpx = new Fpx(this); - isogeny = new Isogeny(this); - if(isCompressed) + + // SIKE's key generation + // Outputs: secret key sk (CRYPTO_SECRETKEYBYTES = MSG_BYTES + SECRETKEY_B_BYTES + CRYPTO_PUBLICKEYBYTES bytes) + // public key pk (CRYPTO_PUBLICKEYBYTES bytes) + internal int crypto_kem_keypair(byte[] pk, byte[] sk, SecureRandom random) { - sidhCompressed = new SidhCompressed(this); - } - sidh = new Sidh(this); - } + random.NextBytes(sk, 0, (int)param.MSG_BYTES); - // SIKE's key generation - // Outputs: secret key sk (CRYPTO_SECRETKEYBYTES = MSG_BYTES + SECRETKEY_B_BYTES + CRYPTO_PUBLICKEYBYTES bytes) - // public key pk (CRYPTO_PUBLICKEYBYTES bytes) - public int crypto_kem_keypair(byte[] pk, byte[] sk, SecureRandom random) - { - random.NextBytes(sk, 0, (int)param.MSG_BYTES); + if (isCompressed) + { + // Generation of Alice's secret key + // Outputs random value in [0, 2^eA - 1] - if (isCompressed) - { - // Generation of Alice's secret key - // Outputs random value in [0, 2^eA - 1] + random.NextBytes(sk, (int)param.MSG_BYTES, (int)param.SECRETKEY_A_BYTES); + sk[param.MSG_BYTES] &= 0xFE; // Make private scalar even + sk[param.MSG_BYTES + param.SECRETKEY_A_BYTES - 1] &= (byte)param.MASK_ALICE; // Masking last - random.NextBytes(sk, (int)param.MSG_BYTES, (int)param.SECRETKEY_A_BYTES); - sk[param.MSG_BYTES] &= 0xFE; // Make private scalar even - sk[param.MSG_BYTES + param.SECRETKEY_A_BYTES - 1] &= (byte)param.MASK_ALICE; // Masking last + sidhCompressed.EphemeralKeyGeneration_A_extended(sk, pk); - sidhCompressed.EphemeralKeyGeneration_A_extended(sk, pk); + // Append public key pk to secret key sk + System.Array.Copy(pk, 0, sk, param.MSG_BYTES + param.SECRETKEY_A_BYTES, param.CRYPTO_PUBLICKEYBYTES); + } + else + { + // Generation of Bob's secret key + // Outputs random value in [0, 2^Floor(Log(2, oB)) - 1] + // todo/org: SIDH.random_mod_order_B(sk, random); - // Append public key pk to secret key sk - System.Array.Copy(pk, 0, sk, param.MSG_BYTES + param.SECRETKEY_A_BYTES, param.CRYPTO_PUBLICKEYBYTES); - } - else - { - // Generation of Bob's secret key - // Outputs random value in [0, 2^Floor(Log(2, oB)) - 1] - // todo/org: SIDH.random_mod_order_B(sk, random); + random.NextBytes(sk, (int)param.MSG_BYTES, (int)param.SECRETKEY_B_BYTES); + sk[param.MSG_BYTES + param.SECRETKEY_B_BYTES - 1] &= (byte)param.MASK_BOB; - random.NextBytes(sk, (int)param.MSG_BYTES, (int)param.SECRETKEY_B_BYTES); - sk[param.MSG_BYTES + param.SECRETKEY_B_BYTES - 1] &= (byte)param.MASK_BOB; + sidh.EphemeralKeyGeneration_B(sk, pk); - sidh.EphemeralKeyGeneration_B(sk, pk); + // Append public key pk to secret key sk + System.Array.Copy(pk, 0, sk, param.MSG_BYTES + param.SECRETKEY_B_BYTES, param.CRYPTO_PUBLICKEYBYTES); - // Append public key pk to secret key sk - System.Array.Copy(pk, 0, sk, param.MSG_BYTES + param.SECRETKEY_B_BYTES, param.CRYPTO_PUBLICKEYBYTES); + } + return 0; } - return 0; - } - - // SIKE's encapsulation - // Input: public key pk (CRYPTO_PUBLICKEYBYTES bytes) - // Outputs: shared secret ss (CRYPTO_BYTES bytes) - // ciphertext message ct (CRYPTO_CIPHERTEXTBYTES = CRYPTO_PUBLICKEYBYTES + MSG_BYTES bytes) - public int crypto_kem_enc(byte[] ct, byte[] ss, byte[] pk, SecureRandom random) - { - if(isCompressed) + // SIKE's encapsulation + // Input: public key pk (CRYPTO_PUBLICKEYBYTES bytes) + // Outputs: shared secret ss (CRYPTO_BYTES bytes) + // ciphertext message ct (CRYPTO_CIPHERTEXTBYTES = CRYPTO_PUBLICKEYBYTES + MSG_BYTES bytes) + internal int crypto_kem_enc(byte[] ct, byte[] ss, byte[] pk, SecureRandom random) { - byte[] ephemeralsk = new byte[param.SECRETKEY_B_BYTES]; - byte[] jinvariant = new byte[param.FP2_ENCODED_BYTES]; - byte[] h = new byte[param.MSG_BYTES]; - byte[] temp = new byte[param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES]; + if(isCompressed) + { + byte[] ephemeralsk = new byte[param.SECRETKEY_B_BYTES]; + byte[] jinvariant = new byte[param.FP2_ENCODED_BYTES]; + byte[] h = new byte[param.MSG_BYTES]; + byte[] temp = new byte[param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES]; - // Generate ephemeralsk <- G(m||pk) mod oB - random.NextBytes(temp, 0, (int)param.MSG_BYTES); - System.Array.Copy(pk, 0, temp, param.MSG_BYTES, param.CRYPTO_PUBLICKEYBYTES); + // Generate ephemeralsk <- G(m||pk) mod oB + random.NextBytes(temp, 0, (int)param.MSG_BYTES); + System.Array.Copy(pk, 0, temp, param.MSG_BYTES, param.CRYPTO_PUBLICKEYBYTES); - IXof digest = new ShakeDigest(256); - digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_PUBLICKEYBYTES + param.MSG_BYTES)); - digest.OutputFinal(ephemeralsk, 0, (int) param.SECRETKEY_B_BYTES); + IXof digest = new ShakeDigest(256); + digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_PUBLICKEYBYTES + param.MSG_BYTES)); + digest.OutputFinal(ephemeralsk, 0, (int) param.SECRETKEY_B_BYTES); - sidhCompressed.FormatPrivKey_B(ephemeralsk); + sidhCompressed.FormatPrivKey_B(ephemeralsk); -// System.out.println("ephemeralsk: " + Hex.toHexstring(ephemeralsk)); + // System.out.println("ephemeralsk: " + Hex.toHexstring(ephemeralsk)); - // Encrypt - sidhCompressed.EphemeralKeyGeneration_B_extended(ephemeralsk, ct, 1); + // Encrypt + sidhCompressed.EphemeralKeyGeneration_B_extended(ephemeralsk, ct, 1); -// System.out.println("ct: " + Hex.toHexstring(ct)); -// System.out.println("pk: " + Hex.toHexstring(pk)); + // System.out.println("ct: " + Hex.toHexstring(ct)); + // System.out.println("pk: " + Hex.toHexstring(pk)); - sidhCompressed.EphemeralSecretAgreement_B(ephemeralsk, pk, jinvariant); + sidhCompressed.EphemeralSecretAgreement_B(ephemeralsk, pk, jinvariant); -// System.out.println("jinv: " + Hex.toHexstring(jinvariant)); + // System.out.println("jinv: " + Hex.toHexstring(jinvariant)); - digest.BlockUpdate(jinvariant, 0, (int) param.FP2_ENCODED_BYTES); - digest.OutputFinal(h, 0, (int) param.MSG_BYTES); + digest.BlockUpdate(jinvariant, 0, (int) param.FP2_ENCODED_BYTES); + digest.OutputFinal(h, 0, (int) param.MSG_BYTES); -// System.out.println("h: " + Hex.toHexstring(h)); -// System.out.println("temp: " + Hex.toHexstring(temp)); + // System.out.println("h: " + Hex.toHexstring(h)); + // System.out.println("temp: " + Hex.toHexstring(temp)); - for (int i = 0; i < param.MSG_BYTES; i++) - { - ct[i + param.PARTIALLY_COMPRESSED_CHUNK_CT] = (byte) (temp[i] ^ h[i]); - } + for (int i = 0; i < param.MSG_BYTES; i++) + { + ct[i + param.PARTIALLY_COMPRESSED_CHUNK_CT] = (byte) (temp[i] ^ h[i]); + } - // Generate shared secret ss <- H(m||ct) - System.Array.Copy(ct, 0, temp, param.MSG_BYTES, param.CRYPTO_CIPHERTEXTBYTES); + // Generate shared secret ss <- H(m||ct) + System.Array.Copy(ct, 0, temp, param.MSG_BYTES, param.CRYPTO_CIPHERTEXTBYTES); - digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES)); - digest.OutputFinal(ss, 0, (int) param.CRYPTO_BYTES); - return 0; - } - else - { - byte[] ephemeralsk = new byte[param.SECRETKEY_A_BYTES]; - byte[] jinvariant = new byte[param.FP2_ENCODED_BYTES]; - byte[] h = new byte[param.MSG_BYTES]; - byte[] temp = new byte[param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES]; + digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES)); + digest.OutputFinal(ss, 0, (int) param.CRYPTO_BYTES); + return 0; + } + else + { + byte[] ephemeralsk = new byte[param.SECRETKEY_A_BYTES]; + byte[] jinvariant = new byte[param.FP2_ENCODED_BYTES]; + byte[] h = new byte[param.MSG_BYTES]; + byte[] temp = new byte[param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES]; - // Generate ephemeralsk <- G(m||pk) mod oA - random.NextBytes(temp, 0, (int)param.MSG_BYTES); - System.Array.Copy(pk, 0, temp, param.MSG_BYTES, param.CRYPTO_PUBLICKEYBYTES); + // Generate ephemeralsk <- G(m||pk) mod oA + random.NextBytes(temp, 0, (int)param.MSG_BYTES); + System.Array.Copy(pk, 0, temp, param.MSG_BYTES, param.CRYPTO_PUBLICKEYBYTES); - IXof digest = new ShakeDigest(256); - digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_PUBLICKEYBYTES + param.MSG_BYTES)); - digest.OutputFinal(ephemeralsk, 0, (int) param.SECRETKEY_A_BYTES); - ephemeralsk[param.SECRETKEY_A_BYTES - 1] &= (byte) param.MASK_ALICE; + IXof digest = new ShakeDigest(256); + digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_PUBLICKEYBYTES + param.MSG_BYTES)); + digest.OutputFinal(ephemeralsk, 0, (int) param.SECRETKEY_A_BYTES); + ephemeralsk[param.SECRETKEY_A_BYTES - 1] &= (byte) param.MASK_ALICE; - // Encrypt - sidh.EphemeralKeyGeneration_A(ephemeralsk, ct); - sidh.EphemeralSecretAgreement_A(ephemeralsk, pk, jinvariant); + // Encrypt + sidh.EphemeralKeyGeneration_A(ephemeralsk, ct); + sidh.EphemeralSecretAgreement_A(ephemeralsk, pk, jinvariant); - digest.BlockUpdate(jinvariant, 0, (int) param.FP2_ENCODED_BYTES); - digest.OutputFinal(h, 0, (int) param.MSG_BYTES); + digest.BlockUpdate(jinvariant, 0, (int) param.FP2_ENCODED_BYTES); + digest.OutputFinal(h, 0, (int) param.MSG_BYTES); - for (int i = 0; i < param.MSG_BYTES; i++) - { - ct[i + param.CRYPTO_PUBLICKEYBYTES] = (byte) (temp[i] ^ h[i]); - } + for (int i = 0; i < param.MSG_BYTES; i++) + { + ct[i + param.CRYPTO_PUBLICKEYBYTES] = (byte) (temp[i] ^ h[i]); + } - // Generate shared secret ss <- H(m||ct) - System.Array.Copy(ct, 0, temp, param.MSG_BYTES, param.CRYPTO_CIPHERTEXTBYTES); + // Generate shared secret ss <- H(m||ct) + System.Array.Copy(ct, 0, temp, param.MSG_BYTES, param.CRYPTO_CIPHERTEXTBYTES); - digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES)); - digest.OutputFinal(ss, 0, (int) param.CRYPTO_BYTES); + digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES)); + digest.OutputFinal(ss, 0, (int) param.CRYPTO_BYTES); - return 0; + return 0; + } } - } - // SIKE's decapsulation - // Input: secret key sk (CRYPTO_SECRETKEYBYTES = MSG_BYTES + SECRETKEY_B_BYTES + CRYPTO_PUBLICKEYBYTES bytes) - // ciphertext message ct (CRYPTO_CIPHERTEXTBYTES = CRYPTO_PUBLICKEYBYTES + MSG_BYTES bytes) - // Outputs: shared secret ss (CRYPTO_BYTES bytes) - public int crypto_kem_dec(byte[] ss, byte[] ct, byte[] sk) - { - if (isCompressed) + // SIKE's decapsulation + // Input: secret key sk (CRYPTO_SECRETKEYBYTES = MSG_BYTES + SECRETKEY_B_BYTES + CRYPTO_PUBLICKEYBYTES bytes) + // ciphertext message ct (CRYPTO_CIPHERTEXTBYTES = CRYPTO_PUBLICKEYBYTES + MSG_BYTES bytes) + // Outputs: shared secret ss (CRYPTO_BYTES bytes) + internal int crypto_kem_dec(byte[] ss, byte[] ct, byte[] sk) { - byte[] ephemeralsk_ = new byte[param.SECRETKEY_B_BYTES]; - byte[] jinvariant_ = new byte[param.FP2_ENCODED_BYTES + 2*param.FP2_ENCODED_BYTES + param.SECRETKEY_A_BYTES], - h_ = new byte[param.MSG_BYTES]; - byte[] temp = new byte[param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES]; - byte[] tphiBKA_t = jinvariant_;//jinvariant_[param.FP2_ENCODED_BYTES]; + if (isCompressed) + { + byte[] ephemeralsk_ = new byte[param.SECRETKEY_B_BYTES]; + byte[] jinvariant_ = new byte[param.FP2_ENCODED_BYTES + 2*param.FP2_ENCODED_BYTES + param.SECRETKEY_A_BYTES], + h_ = new byte[param.MSG_BYTES]; + byte[] temp = new byte[param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES]; + byte[] tphiBKA_t = jinvariant_;//jinvariant_[param.FP2_ENCODED_BYTES]; - // Decrypt - sidhCompressed.EphemeralSecretAgreement_A_extended(sk, param.MSG_BYTES, ct, jinvariant_, 1); + // Decrypt + sidhCompressed.EphemeralSecretAgreement_A_extended(sk, param.MSG_BYTES, ct, jinvariant_, 1); - IXof digest = new ShakeDigest(256); - digest.BlockUpdate(jinvariant_, 0, (int) param.FP2_ENCODED_BYTES); - digest.OutputFinal(h_, 0, (int) param.MSG_BYTES); + IXof digest = new ShakeDigest(256); + digest.BlockUpdate(jinvariant_, 0, (int) param.FP2_ENCODED_BYTES); + digest.OutputFinal(h_, 0, (int) param.MSG_BYTES); -// System.out.println("h_: " + Hex.toHexstring(h_)); + // System.out.println("h_: " + Hex.toHexstring(h_)); - for (int i = 0; i < param.MSG_BYTES; i++) - { - temp[i] = (byte) (ct[i + param.PARTIALLY_COMPRESSED_CHUNK_CT] ^ h_[i]); - } + for (int i = 0; i < param.MSG_BYTES; i++) + { + temp[i] = (byte) (ct[i + param.PARTIALLY_COMPRESSED_CHUNK_CT] ^ h_[i]); + } - // Generate ephemeralsk_ <- G(m||pk) mod oB - System.Array.Copy(sk, param.MSG_BYTES + param.SECRETKEY_A_BYTES, temp, param.MSG_BYTES, param.CRYPTO_PUBLICKEYBYTES); + // Generate ephemeralsk_ <- G(m||pk) mod oB + System.Array.Copy(sk, param.MSG_BYTES + param.SECRETKEY_A_BYTES, temp, param.MSG_BYTES, param.CRYPTO_PUBLICKEYBYTES); - digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_PUBLICKEYBYTES + param.MSG_BYTES)); - digest.OutputFinal(ephemeralsk_, 0, (int) param.SECRETKEY_B_BYTES); - sidhCompressed.FormatPrivKey_B(ephemeralsk_); + digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_PUBLICKEYBYTES + param.MSG_BYTES)); + digest.OutputFinal(ephemeralsk_, 0, (int) param.SECRETKEY_B_BYTES); + sidhCompressed.FormatPrivKey_B(ephemeralsk_); - // Generate shared secret ss <- H(m||ct), or output ss <- H(s||ct) in case of ct verification failure - // No need to recompress, just check if x(phi(P) + t*phi(Q)) == x((a0 + t*a1)*R1 + (b0 + t*b1)*R2) - byte selector = sidhCompressed.validate_ciphertext(ephemeralsk_, ct, sk, param.MSG_BYTES + param.SECRETKEY_A_BYTES + param.CRYPTO_PUBLICKEYBYTES, tphiBKA_t, param.FP2_ENCODED_BYTES); - // If ct validation passes (selector = 0) then do ss = H(m||ct), otherwise (selector = -1) load s to do ss = H(s||ct) - fpx.ct_cmov(temp, sk, param.MSG_BYTES, selector); + // Generate shared secret ss <- H(m||ct), or output ss <- H(s||ct) in case of ct verification failure + // No need to recompress, just check if x(phi(P) + t*phi(Q)) == x((a0 + t*a1)*R1 + (b0 + t*b1)*R2) + byte selector = sidhCompressed.validate_ciphertext(ephemeralsk_, ct, sk, param.MSG_BYTES + param.SECRETKEY_A_BYTES + param.CRYPTO_PUBLICKEYBYTES, tphiBKA_t, param.FP2_ENCODED_BYTES); + // If ct validation passes (selector = 0) then do ss = H(m||ct), otherwise (selector = -1) load s to do ss = H(s||ct) + fpx.ct_cmov(temp, sk, param.MSG_BYTES, selector); - System.Array.Copy(ct, 0, temp, param.MSG_BYTES, param.CRYPTO_CIPHERTEXTBYTES); - digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES)); - digest.OutputFinal(ss, 0, (int) param.CRYPTO_BYTES); + System.Array.Copy(ct, 0, temp, param.MSG_BYTES, param.CRYPTO_CIPHERTEXTBYTES); + digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES)); + digest.OutputFinal(ss, 0, (int) param.CRYPTO_BYTES); - return 0; - } - else - { - byte[] ephemeralsk_ = new byte[param.SECRETKEY_A_BYTES]; - byte[] jinvariant_ = new byte[param.FP2_ENCODED_BYTES]; - byte[] h_ = new byte[param.MSG_BYTES]; - byte[] c0_ = new byte[param.CRYPTO_PUBLICKEYBYTES]; - byte[] temp = new byte[param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES]; - - // Decrypt - // int EphemeralSecretAgreement_B(PrivateKeyB, PublicKeyA, SharedSecretB) - sidh.EphemeralSecretAgreement_B(sk, ct, jinvariant_); - - IXof digest = new ShakeDigest(256); - digest.BlockUpdate(jinvariant_, 0, (int) param.FP2_ENCODED_BYTES); - digest.OutputFinal(h_, 0, (int) param.MSG_BYTES); - for (int i = 0; i < param.MSG_BYTES; i++) - { - temp[i] = (byte) (ct[i + param.CRYPTO_PUBLICKEYBYTES] ^ h_[i]); + return 0; } + else + { + byte[] ephemeralsk_ = new byte[param.SECRETKEY_A_BYTES]; + byte[] jinvariant_ = new byte[param.FP2_ENCODED_BYTES]; + byte[] h_ = new byte[param.MSG_BYTES]; + byte[] c0_ = new byte[param.CRYPTO_PUBLICKEYBYTES]; + byte[] temp = new byte[param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES]; - // Generate ephemeralsk_ <- G(m||pk) mod oA - System.Array.Copy(sk, param.MSG_BYTES + param.SECRETKEY_B_BYTES, temp, param.MSG_BYTES, param.CRYPTO_PUBLICKEYBYTES); + // Decrypt + // int EphemeralSecretAgreement_B(PrivateKeyB, PublicKeyA, SharedSecretB) + sidh.EphemeralSecretAgreement_B(sk, ct, jinvariant_); - digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_PUBLICKEYBYTES + param.MSG_BYTES)); - digest.OutputFinal(ephemeralsk_, 0, (int) param.SECRETKEY_A_BYTES); - ephemeralsk_[param.SECRETKEY_A_BYTES - 1] &= (byte) param.MASK_ALICE; + IXof digest = new ShakeDigest(256); + digest.BlockUpdate(jinvariant_, 0, (int) param.FP2_ENCODED_BYTES); + digest.OutputFinal(h_, 0, (int) param.MSG_BYTES); + for (int i = 0; i < param.MSG_BYTES; i++) + { + temp[i] = (byte) (ct[i + param.CRYPTO_PUBLICKEYBYTES] ^ h_[i]); + } + // Generate ephemeralsk_ <- G(m||pk) mod oA + System.Array.Copy(sk, param.MSG_BYTES + param.SECRETKEY_B_BYTES, temp, param.MSG_BYTES, param.CRYPTO_PUBLICKEYBYTES); - // Generate shared secret ss <- H(m||ct), or output ss <- H(s||ct) in case of ct verification failure - sidh.EphemeralKeyGeneration_A(ephemeralsk_, c0_); + digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_PUBLICKEYBYTES + param.MSG_BYTES)); + digest.OutputFinal(ephemeralsk_, 0, (int) param.SECRETKEY_A_BYTES); + ephemeralsk_[param.SECRETKEY_A_BYTES - 1] &= (byte) param.MASK_ALICE; - // If selector = 0 then do ss = H(m||ct), else if selector = -1 load s to do ss = H(s||ct) - byte selector = fpx.ct_compare(c0_, ct, param.CRYPTO_PUBLICKEYBYTES); - fpx.ct_cmov(temp, sk, param.MSG_BYTES, selector); - System.Array.Copy(ct, 0, temp, param.MSG_BYTES, param.CRYPTO_CIPHERTEXTBYTES); - digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES)); - digest.OutputFinal(ss, 0, (int) param.CRYPTO_BYTES); + // Generate shared secret ss <- H(m||ct), or output ss <- H(s||ct) in case of ct verification failure + sidh.EphemeralKeyGeneration_A(ephemeralsk_, c0_); - return 0; + // If selector = 0 then do ss = H(m||ct), else if selector = -1 load s to do ss = H(s||ct) + byte selector = fpx.ct_compare(c0_, ct, param.CRYPTO_PUBLICKEYBYTES); + fpx.ct_cmov(temp, sk, param.MSG_BYTES, selector); + + System.Array.Copy(ct, 0, temp, param.MSG_BYTES, param.CRYPTO_CIPHERTEXTBYTES); + digest.BlockUpdate(temp, 0, (int) (param.CRYPTO_CIPHERTEXTBYTES + param.MSG_BYTES)); + digest.OutputFinal(ss, 0, (int) param.CRYPTO_BYTES); + + return 0; + } } } - } - -} \ No newline at end of file diff --git a/crypto/src/pqc/crypto/sike/SIKEKEMExtractor.cs b/crypto/src/pqc/crypto/sike/SIKEKEMExtractor.cs index 3c523ba8c..879f1d8ef 100644 --- a/crypto/src/pqc/crypto/sike/SIKEKEMExtractor.cs +++ b/crypto/src/pqc/crypto/sike/SIKEKEMExtractor.cs @@ -4,6 +4,7 @@ using Org.BouncyCastle.Crypto; namespace Org.BouncyCastle.Pqc.Crypto.Sike { + [Obsolete("Will be removed")] public sealed class SikeKemExtractor : IEncapsulatedSecretExtractor { @@ -26,10 +27,10 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike public byte[] ExtractSecret(byte[] encapsulation) { - return ExtractSecret(encapsulation, engine.GetDefaultSessionKeySize()); + return ExtractSecret(encapsulation, (int)engine.GetDefaultSessionKeySize()); } - public byte[] ExtractSecret(byte[] encapsulation, uint sessionKeySizeInBits) + public byte[] ExtractSecret(byte[] encapsulation, int sessionKeySizeInBits) { Console.Error.WriteLine("WARNING: the SIKE algorithm is only for research purposes, insecure"); byte[] session_key = new byte[sessionKeySizeInBits / 8]; diff --git a/crypto/src/pqc/crypto/sike/SIKEKEMGenerator.cs b/crypto/src/pqc/crypto/sike/SIKEKEMGenerator.cs index 76689496f..5e4bd41eb 100644 --- a/crypto/src/pqc/crypto/sike/SIKEKEMGenerator.cs +++ b/crypto/src/pqc/crypto/sike/SIKEKEMGenerator.cs @@ -6,6 +6,7 @@ using Org.BouncyCastle.Security; namespace Org.BouncyCastle.Pqc.Crypto.Sike { + [Obsolete("Will be removed")] public sealed class SikeKemGenerator : IEncapsulatedSecretGenerator { @@ -22,10 +23,11 @@ namespace Org.BouncyCastle.Pqc.Crypto.Sike SikePublicKeyParameters key = (SikePublicKeyParameters)recipientKey; SikeEngine engine = key.Parameters.Engine; - return GenerateEncapsulated(recipientKey, engine.GetDefaultSessionKeySize()); + return GenerateEncapsulated(recipientKey, (int)engine.GetDefaultSessionKeySize()); } - public ISecretWithEncapsulation GenerateEncapsulated(AsymmetricKeyParameter recipientKey, uint sessionKeySizeInBits) + public ISecretWithEncapsulation GenerateEncapsulated(AsymmetricKeyParameter recipientKey, + int sessionKeySizeInBits) { Console.Error.WriteLine("WARNING: the SIKE algorithm is only for research purposes, insecure"); SikePublicKeyParameters key = (SikePublicKeyParameters)recipientKey; diff --git a/crypto/src/pqc/crypto/sike/SIKEKeyGenerationParameters.cs b/crypto/src/pqc/crypto/sike/SIKEKeyGenerationParameters.cs index 353587637..f595032eb 100644 --- a/crypto/src/pqc/crypto/sike/SIKEKeyGenerationParameters.cs +++ b/crypto/src/pqc/crypto/sike/SIKEKeyGenerationParameters.cs @@ -1,8 +1,11 @@ +using System; + using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Security; namespace Org.BouncyCastle.Pqc.Crypto.Sike { + [Obsolete("Will be removed")] public sealed class SikeKeyGenerationParameters : KeyGenerationParameters { diff --git a/crypto/src/pqc/crypto/sike/SIKEKeyPairGenerator.cs b/crypto/src/pqc/crypto/sike/SIKEKeyPairGenerator.cs index 3ba67faa9..20def8a32 100644 --- a/crypto/src/pqc/crypto/sike/SIKEKeyPairGenerator.cs +++ b/crypto/src/pqc/crypto/sike/SIKEKeyPairGenerator.cs @@ -1,8 +1,11 @@ +using System; + using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Security; namespace Org.BouncyCastle.Pqc.Crypto.Sike { + [Obsolete("Will be removed")] public sealed class SikeKeyPairGenerator : IAsymmetricCipherKeyPairGenerator { diff --git a/crypto/src/pqc/crypto/sike/SIKEKeyParameters.cs b/crypto/src/pqc/crypto/sike/SIKEKeyParameters.cs index 5d515eb1d..759c8dd5d 100644 --- a/crypto/src/pqc/crypto/sike/SIKEKeyParameters.cs +++ b/crypto/src/pqc/crypto/sike/SIKEKeyParameters.cs @@ -1,7 +1,10 @@ +using System; + using Org.BouncyCastle.Crypto; namespace Org.BouncyCastle.Pqc.Crypto.Sike { + [Obsolete("Will be removed")] public abstract class SikeKeyParameters : AsymmetricKeyParameter { diff --git a/crypto/src/pqc/crypto/sike/SIKEParameters.cs b/crypto/src/pqc/crypto/sike/SIKEParameters.cs index 3aa332341..d18797067 100644 --- a/crypto/src/pqc/crypto/sike/SIKEParameters.cs +++ b/crypto/src/pqc/crypto/sike/SIKEParameters.cs @@ -1,5 +1,8 @@ +using System; + namespace Org.BouncyCastle.Pqc.Crypto.Sike { + [Obsolete("Will be removed")] public sealed class SikeParameters { public static readonly SikeParameters sikep434 = new SikeParameters(434, false, "sikep434"); diff --git a/crypto/src/pqc/crypto/sike/SIKEPrivateKeyParameters.cs b/crypto/src/pqc/crypto/sike/SIKEPrivateKeyParameters.cs index 0666ffb72..ee7116b68 100644 --- a/crypto/src/pqc/crypto/sike/SIKEPrivateKeyParameters.cs +++ b/crypto/src/pqc/crypto/sike/SIKEPrivateKeyParameters.cs @@ -1,7 +1,10 @@ +using System; + using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Pqc.Crypto.Sike { + [Obsolete("Will be removed")] public sealed class SikePrivateKeyParameters : SikeKeyParameters { diff --git a/crypto/src/pqc/crypto/sike/SIKEPublicKeyParameters.cs b/crypto/src/pqc/crypto/sike/SIKEPublicKeyParameters.cs index b567e979c..3300ed438 100644 --- a/crypto/src/pqc/crypto/sike/SIKEPublicKeyParameters.cs +++ b/crypto/src/pqc/crypto/sike/SIKEPublicKeyParameters.cs @@ -1,7 +1,10 @@ +using System; + using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Pqc.Crypto.Sike { + [Obsolete("Will be removed")] public sealed class SikePublicKeyParameters : SikeKeyParameters { diff --git a/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusParameters.cs b/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusParameters.cs index e8a95fd2f..8cde7cf7f 100644 --- a/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusParameters.cs +++ b/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusParameters.cs @@ -1,3 +1,4 @@ +using System; using System.Collections.Generic; using Org.BouncyCastle.Crypto.Utilities; @@ -265,9 +266,9 @@ namespace Org.BouncyCastle.Pqc.Crypto.SphincsPlus * @param id the oid of interest. * @return the parameter set. */ - public static SphincsPlusParameters GetParams(uint id) + public static SphincsPlusParameters GetParams(int id) { - return oidToParams[id]; + return oidToParams[Convert.ToUInt32(id)]; } /** @@ -276,14 +277,14 @@ namespace Org.BouncyCastle.Pqc.Crypto.SphincsPlus * @param params the parameters of interest. * @return the OID for the parameter set. */ - public static uint GetID(SphincsPlusParameters parameters) + public static int GetID(SphincsPlusParameters parameters) { - return paramsToOid[parameters]; + return Convert.ToInt32(paramsToOid[parameters]); } public byte[] GetEncoded() { - return Pack.UInt32_To_BE(GetID(this)); + return Pack.UInt32_To_BE((uint)GetID(this)); } } diff --git a/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusPrivateKeyParameters.cs b/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusPrivateKeyParameters.cs index ed5195da2..55757b927 100644 --- a/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusPrivateKeyParameters.cs +++ b/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusPrivateKeyParameters.cs @@ -53,13 +53,13 @@ namespace Org.BouncyCastle.Pqc.Crypto.SphincsPlus public byte[] GetEncoded() { - var id = Pack.UInt32_To_BE(SphincsPlusParameters.GetID(Parameters)); + var id = Pack.UInt32_To_BE((uint)SphincsPlusParameters.GetID(Parameters)); return Arrays.ConcatenateAll(id, m_sk.seed, m_sk.prf, m_pk.seed, m_pk.root); } public byte[] GetEncodedPublicKey() { - var id = Pack.UInt32_To_BE(SphincsPlusParameters.GetID(Parameters)); + var id = Pack.UInt32_To_BE((uint)SphincsPlusParameters.GetID(Parameters)); return Arrays.ConcatenateAll(id, m_pk.seed, m_pk.root); } } diff --git a/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusPublicKeyParameters.cs b/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusPublicKeyParameters.cs index 96e9324cc..b34843998 100644 --- a/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusPublicKeyParameters.cs +++ b/crypto/src/pqc/crypto/sphincsplus/SPHINCSPlusPublicKeyParameters.cs @@ -38,7 +38,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.SphincsPlus public byte[] GetEncoded() { - var id = Pack.UInt32_To_BE(SphincsPlusParameters.GetID(Parameters)); + var id = Pack.UInt32_To_BE((uint)SphincsPlusParameters.GetID(Parameters)); return Arrays.ConcatenateAll(id, m_pk.seed, m_pk.root); } } diff --git a/crypto/src/pqc/crypto/utils/PqcUtilities.cs b/crypto/src/pqc/crypto/utils/PqcUtilities.cs index 1f1da5e74..67e58fd28 100644 --- a/crypto/src/pqc/crypto/utils/PqcUtilities.cs +++ b/crypto/src/pqc/crypto/utils/PqcUtilities.cs @@ -15,7 +15,7 @@ using Org.BouncyCastle.Pqc.Crypto.SphincsPlus; namespace Org.BouncyCastle.Pqc.Crypto.Utilities { - public class PqcUtilities + internal class PqcUtilities { private readonly static Dictionary<CmceParameters, DerObjectIdentifier> mcElieceOids = new Dictionary<CmceParameters, DerObjectIdentifier>(); private readonly static Dictionary<DerObjectIdentifier, CmceParameters> mcElieceParams = new Dictionary<DerObjectIdentifier, CmceParameters>(); @@ -25,10 +25,12 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities private readonly static Dictionary<PicnicParameters, DerObjectIdentifier> picnicOids = new Dictionary<PicnicParameters, DerObjectIdentifier>(); private readonly static Dictionary<DerObjectIdentifier, PicnicParameters> picnicParams = new Dictionary<DerObjectIdentifier, PicnicParameters>(); - + +#pragma warning disable CS0618 // Type or member is obsolete private readonly static Dictionary<SikeParameters, DerObjectIdentifier> sikeOids = new Dictionary<SikeParameters, DerObjectIdentifier>(); private readonly static Dictionary<DerObjectIdentifier, SikeParameters> sikeParams = new Dictionary<DerObjectIdentifier, SikeParameters>(); - +#pragma warning restore CS0618 // Type or member is obsolete + private readonly static Dictionary<KyberParameters, DerObjectIdentifier> kyberOids = new Dictionary<KyberParameters, DerObjectIdentifier>(); private readonly static Dictionary<DerObjectIdentifier, KyberParameters> kyberParams = new Dictionary<DerObjectIdentifier, KyberParameters>(); @@ -132,7 +134,8 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities picnicParams[BCObjectIdentifiers.picnicl1full] = PicnicParameters.picnicl1full; picnicParams[BCObjectIdentifiers.picnicl3full] = PicnicParameters.picnicl3full; picnicParams[BCObjectIdentifiers.picnicl5full] = PicnicParameters.picnicl5full; - + +#pragma warning disable CS0618 // Type or member is obsolete sikeParams[BCObjectIdentifiers.sikep434] = SikeParameters.sikep434; sikeParams[BCObjectIdentifiers.sikep503] = SikeParameters.sikep503; sikeParams[BCObjectIdentifiers.sikep610] = SikeParameters.sikep610; @@ -141,7 +144,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities sikeParams[BCObjectIdentifiers.sikep503_compressed] = SikeParameters.sikep503_compressed; sikeParams[BCObjectIdentifiers.sikep610_compressed] = SikeParameters.sikep610_compressed; sikeParams[BCObjectIdentifiers.sikep751_compressed] = SikeParameters.sikep751_compressed; - + sikeOids[SikeParameters.sikep434] = BCObjectIdentifiers.sikep434; sikeOids[SikeParameters.sikep503] = BCObjectIdentifiers.sikep503; sikeOids[SikeParameters.sikep610] = BCObjectIdentifiers.sikep610; @@ -150,7 +153,8 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities sikeOids[SikeParameters.sikep503_compressed] = BCObjectIdentifiers.sikep503_compressed; sikeOids[SikeParameters.sikep610_compressed] = BCObjectIdentifiers.sikep610_compressed; sikeOids[SikeParameters.sikep751_compressed] = BCObjectIdentifiers.sikep751_compressed; - +#pragma warning restore CS0618 // Type or member is obsolete + kyberOids[KyberParameters.kyber512] = BCObjectIdentifiers.kyber512; kyberOids[KyberParameters.kyber768] = BCObjectIdentifiers.kyber768; kyberOids[KyberParameters.kyber1024] = BCObjectIdentifiers.kyber1024; @@ -203,7 +207,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities hqcOids[HqcParameters.hqc256] = BCObjectIdentifiers.hqc256; } - public static DerObjectIdentifier McElieceOidLookup(CmceParameters parameters) + internal static DerObjectIdentifier McElieceOidLookup(CmceParameters parameters) { return mcElieceOids[parameters]; } @@ -248,17 +252,13 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities internal static DerObjectIdentifier SphincsPlusOidLookup(SphincsPlusParameters parameters) { - uint pId = SphincsPlusParameters.GetID(parameters); + int pId = SphincsPlusParameters.GetID(parameters); if ((pId & 0x020000) == 0x020000) - { return BCObjectIdentifiers.sphincsPlus_shake_256; - } if ((pId & 0x05) == 0x05 || (pId & 0x06) == 0x06) - { return BCObjectIdentifiers.sphincsPlus_sha_512; - } return BCObjectIdentifiers.sphincsPlus_sha_256; } @@ -272,6 +272,8 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities { return picnicParams[oid]; } + +#pragma warning disable CS0618 // Type or member is obsolete internal static DerObjectIdentifier SikeOidLookup(SikeParameters parameters) { return sikeOids[parameters]; @@ -281,6 +283,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities { return sikeParams[oid]; } +#pragma warning restore CS0618 // Type or member is obsolete internal static DerObjectIdentifier BikeOidLookup(BikeParameters parameters) { diff --git a/crypto/src/pqc/crypto/utils/PrivateKeyFactory.cs b/crypto/src/pqc/crypto/utils/PrivateKeyFactory.cs index 7db65dbfb..6ad9bdb0c 100644 --- a/crypto/src/pqc/crypto/utils/PrivateKeyFactory.cs +++ b/crypto/src/pqc/crypto/utils/PrivateKeyFactory.cs @@ -81,7 +81,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities if (algOID.On(BCObjectIdentifiers.sphincsPlus)) { byte[] keyEnc = Asn1OctetString.GetInstance(keyInfo.ParsePrivateKey()).GetOctets(); - SphincsPlusParameters spParams = SphincsPlusParameters.GetParams((uint)BigInteger.ValueOf(Pack.BE_To_UInt32(keyEnc, 0)).IntValue); + SphincsPlusParameters spParams = SphincsPlusParameters.GetParams(BigInteger.ValueOf(Pack.BE_To_UInt32(keyEnc, 0)).IntValue); return new SphincsPlusPrivateKeyParameters(spParams, Arrays.CopyOfRange(keyEnc, 4, keyEnc.Length)); } @@ -99,6 +99,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities return new PicnicPrivateKeyParameters(picnicParams, keyEnc); } +#pragma warning disable CS0618 // Type or member is obsolete if (algOID.On(BCObjectIdentifiers.pqc_kem_sike)) { byte[] keyEnc = Asn1OctetString.GetInstance(keyInfo.ParsePrivateKey()).GetOctets(); @@ -106,6 +107,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities return new SikePrivateKeyParameters(sikeParams, keyEnc); } +#pragma warning restore CS0618 // Type or member is obsolete if (algOID.On(BCObjectIdentifiers.pqc_kem_bike)) { byte[] keyEnc = Asn1OctetString.GetInstance(keyInfo.ParsePrivateKey()).GetOctets(); diff --git a/crypto/src/pqc/crypto/utils/PrivateKeyInfoFactory.cs b/crypto/src/pqc/crypto/utils/PrivateKeyInfoFactory.cs index 806eae8b7..53b34b3f4 100644 --- a/crypto/src/pqc/crypto/utils/PrivateKeyInfoFactory.cs +++ b/crypto/src/pqc/crypto/utils/PrivateKeyInfoFactory.cs @@ -93,6 +93,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities PqcUtilities.PicnicOidLookup(picnicPrivateKeyParameters.Parameters)); return new PrivateKeyInfo(algorithmIdentifier, new DerOctetString(encoding), attributes); } +#pragma warning disable CS0618 // Type or member is obsolete if (privateKey is SikePrivateKeyParameters sikePrivateKeyParameters) { byte[] encoding = sikePrivateKeyParameters.GetEncoded(); @@ -101,14 +102,15 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities PqcUtilities.SikeOidLookup(sikePrivateKeyParameters.Parameters)); return new PrivateKeyInfo(algorithmIdentifier, new DerOctetString(encoding), attributes); } +#pragma warning restore CS0618 // Type or member is obsolete if (privateKey is FalconPrivateKeyParameters falconPrivateKeyParameters) { Asn1EncodableVector v = new Asn1EncodableVector(); v.Add(new DerInteger(1)); - v.Add(new DerOctetString(falconPrivateKeyParameters.GetSpolyf())); + v.Add(new DerOctetString(falconPrivateKeyParameters.GetSpolyLittleF())); v.Add(new DerOctetString(falconPrivateKeyParameters.GetG())); - v.Add(new DerOctetString(falconPrivateKeyParameters.GetSpolyF())); + v.Add(new DerOctetString(falconPrivateKeyParameters.GetSpolyBigF())); AlgorithmIdentifier algorithmIdentifier = new AlgorithmIdentifier( PqcUtilities.FalconOidLookup(falconPrivateKeyParameters.Parameters)); diff --git a/crypto/src/pqc/crypto/utils/PublicKeyFactory.cs b/crypto/src/pqc/crypto/utils/PublicKeyFactory.cs index 5d55a73aa..9eea279b1 100644 --- a/crypto/src/pqc/crypto/utils/PublicKeyFactory.cs +++ b/crypto/src/pqc/crypto/utils/PublicKeyFactory.cs @@ -82,7 +82,8 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities Converters[BCObjectIdentifiers.picnicl1full] = new PicnicConverter(); Converters[BCObjectIdentifiers.picnicl3full] = new PicnicConverter(); Converters[BCObjectIdentifiers.picnicl5full] = new PicnicConverter(); - + +#pragma warning disable CS0618 // Type or member is obsolete Converters[BCObjectIdentifiers.sikep434] = new SikeConverter(); Converters[BCObjectIdentifiers.sikep503] = new SikeConverter(); Converters[BCObjectIdentifiers.sikep610] = new SikeConverter(); @@ -91,7 +92,8 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities Converters[BCObjectIdentifiers.sikep503_compressed] = new SikeConverter(); Converters[BCObjectIdentifiers.sikep610_compressed] = new SikeConverter(); Converters[BCObjectIdentifiers.sikep751_compressed] = new SikeConverter(); - +#pragma warning restore CS0618 // Type or member is obsolete + Converters[BCObjectIdentifiers.dilithium2] = new DilithiumConverter(); Converters[BCObjectIdentifiers.dilithium3] = new DilithiumConverter(); Converters[BCObjectIdentifiers.dilithium5] = new DilithiumConverter(); @@ -197,11 +199,11 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities { internal override AsymmetricKeyParameter GetPublicKeyParameters(SubjectPublicKeyInfo keyInfo, object defaultParams) { - byte[] keyEnc = DerOctetString.GetInstance(keyInfo.ParsePublicKey()).GetOctets(); + byte[] keyEnc = Asn1OctetString.GetInstance(keyInfo.ParsePublicKey()).GetOctets(); - SphincsPlusParameters spParams = SphincsPlusParameters.GetParams((uint)BigInteger.ValueOf(Pack.BE_To_UInt32(keyEnc, 0)).IntValue); + SphincsPlusParameters spParams = SphincsPlusParameters.GetParams((int)Pack.BE_To_UInt32(keyEnc, 0)); - return new SphincsPlusPublicKeyParameters(spParams, Arrays.CopyOfRange(keyEnc, 4, keyEnc.Length)); + return new SphincsPlusPublicKeyParameters(spParams, Arrays.CopyOfRange(keyEnc, 4, keyEnc.Length)); } } @@ -223,7 +225,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities { internal override AsymmetricKeyParameter GetPublicKeyParameters(SubjectPublicKeyInfo keyInfo, object defaultParams) { - byte[] keyEnc = DerOctetString.GetInstance( + byte[] keyEnc = Asn1OctetString.GetInstance( DerSequence.GetInstance(keyInfo.ParsePublicKey())[0]).GetOctets(); SaberParameters saberParams = PqcUtilities.SaberParamsLookup(keyInfo.AlgorithmID.Algorithm); @@ -237,19 +239,20 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities { internal override AsymmetricKeyParameter GetPublicKeyParameters(SubjectPublicKeyInfo keyInfo, object defaultParams) { - byte[] keyEnc = DerOctetString.GetInstance(keyInfo.ParsePublicKey()).GetOctets(); + byte[] keyEnc = Asn1OctetString.GetInstance(keyInfo.ParsePublicKey()).GetOctets(); PicnicParameters picnicParams = PqcUtilities.PicnicParamsLookup(keyInfo.AlgorithmID.Algorithm); return new PicnicPublicKeyParameters(picnicParams, keyEnc); } } + [Obsolete("Will be removed")] private class SikeConverter : SubjectPublicKeyInfoConverter { internal override AsymmetricKeyParameter GetPublicKeyParameters(SubjectPublicKeyInfo keyInfo, object defaultParams) { - byte[] keyEnc = DerOctetString.GetInstance(keyInfo.ParsePublicKey()).GetOctets(); + byte[] keyEnc = Asn1OctetString.GetInstance(keyInfo.ParsePublicKey()).GetOctets(); SikeParameters sikeParams = PqcUtilities.SikeParamsLookup(keyInfo.AlgorithmID.Algorithm); diff --git a/crypto/src/pqc/crypto/utils/SubjectPublicKeyInfoFactory.cs b/crypto/src/pqc/crypto/utils/SubjectPublicKeyInfoFactory.cs index 39d437320..b88834e50 100644 --- a/crypto/src/pqc/crypto/utils/SubjectPublicKeyInfoFactory.cs +++ b/crypto/src/pqc/crypto/utils/SubjectPublicKeyInfoFactory.cs @@ -89,6 +89,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities PqcUtilities.PicnicOidLookup(picnicPublicKeyParameters.Parameters)); return new SubjectPublicKeyInfo(algorithmIdentifier, new DerOctetString(encoding)); } +#pragma warning disable CS0618 // Type or member is obsolete if (publicKey is SikePublicKeyParameters sikePublicKeyParameters) { byte[] encoding = sikePublicKeyParameters.GetEncoded(); @@ -97,6 +98,7 @@ namespace Org.BouncyCastle.Pqc.Crypto.Utilities PqcUtilities.SikeOidLookup(sikePublicKeyParameters.Parameters)); return new SubjectPublicKeyInfo(algorithmIdentifier, new DerOctetString(encoding)); } +#pragma warning restore CS0618 // Type or member is obsolete if (publicKey is FalconPublicKeyParameters falconPublicKeyParameters) { byte[] encoding = falconPublicKeyParameters.GetEncoded(); diff --git a/crypto/src/security/DotNetUtilities.cs b/crypto/src/security/DotNetUtilities.cs index 3a7c5f0cb..08853e45e 100644 --- a/crypto/src/security/DotNetUtilities.cs +++ b/crypto/src/security/DotNetUtilities.cs @@ -5,9 +5,12 @@ using System.Runtime.Versioning; using System.Security.Cryptography; using SystemX509 = System.Security.Cryptography.X509Certificates; +using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Asn1.Pkcs; using Org.BouncyCastle.Asn1.X509; +using Org.BouncyCastle.Asn1.X9; using Org.BouncyCastle.Crypto; +using Org.BouncyCastle.Crypto.Generators; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Math; using Org.BouncyCastle.Utilities; @@ -50,23 +53,11 @@ namespace Org.BouncyCastle.Security public static AsymmetricCipherKeyPair GetDsaKeyPair(DSAParameters dp) { - DsaValidationParameters validationParameters = (dp.Seed != null) - ? new DsaValidationParameters(dp.Seed, dp.Counter) - : null; - - DsaParameters parameters = new DsaParameters( - new BigInteger(1, dp.P), - new BigInteger(1, dp.Q), - new BigInteger(1, dp.G), - validationParameters); - - DsaPublicKeyParameters pubKey = new DsaPublicKeyParameters( - new BigInteger(1, dp.Y), - parameters); + DsaPublicKeyParameters pubKey = GetDsaPublicKey(dp); DsaPrivateKeyParameters privKey = new DsaPrivateKeyParameters( new BigInteger(1, dp.X), - parameters); + pubKey.Parameters); return new AsymmetricCipherKeyPair(pubKey, privKey); } @@ -93,6 +84,62 @@ namespace Org.BouncyCastle.Security parameters); } +#if NETCOREAPP1_0_OR_GREATER || NET47_OR_GREATER || NETSTANDARD1_6_OR_GREATER + public static AsymmetricCipherKeyPair GetECDsaKeyPair(ECDsa ecDsa) + { + return GetECKeyPair("ECDSA", ecDsa.ExportParameters(true)); + } + + public static ECPublicKeyParameters GetECDsaPublicKey(ECDsa ecDsa) + { + return GetECPublicKey("ECDSA", ecDsa.ExportParameters(false)); + } + + public static AsymmetricCipherKeyPair GetECKeyPair(string algorithm, ECParameters ec) + { + ECPublicKeyParameters pubKey = GetECPublicKey(algorithm, ec); + + ECPrivateKeyParameters privKey = new ECPrivateKeyParameters( + pubKey.AlgorithmName, + new BigInteger(1, ec.D), + pubKey.Parameters); + + return new AsymmetricCipherKeyPair(pubKey, privKey); + } + + public static ECPublicKeyParameters GetECPublicKey(string algorithm, ECParameters ec) + { + X9ECParameters x9 = GetX9ECParameters(ec.Curve); + if (x9 == null) + throw new NotSupportedException("Unrecognized curve"); + + return new ECPublicKeyParameters( + algorithm, + GetECPoint(x9.Curve, ec.Q), + new ECDomainParameters(x9)); + } + + private static Math.EC.ECPoint GetECPoint(Math.EC.ECCurve curve, ECPoint point) + { + return curve.CreatePoint(new BigInteger(1, point.X), new BigInteger(1, point.Y)); + } + + private static X9ECParameters GetX9ECParameters(ECCurve curve) + { + if (!curve.IsNamed) + throw new NotSupportedException("Only named curves are supported"); + + Oid oid = curve.Oid; + if (oid != null) + { + string oidValue = oid.Value; + if (oidValue != null) + return ECKeyPairGenerator.FindECCurveByOid(new DerObjectIdentifier(oidValue)); + } + return null; + } +#endif + public static AsymmetricCipherKeyPair GetRsaKeyPair(RSA rsa) { return GetRsaKeyPair(rsa.ExportParameters(true)); @@ -100,17 +147,11 @@ namespace Org.BouncyCastle.Security public static AsymmetricCipherKeyPair GetRsaKeyPair(RSAParameters rp) { - BigInteger modulus = new BigInteger(1, rp.Modulus); - BigInteger pubExp = new BigInteger(1, rp.Exponent); - - RsaKeyParameters pubKey = new RsaKeyParameters( - false, - modulus, - pubExp); + RsaKeyParameters pubKey = GetRsaPublicKey(rp); RsaPrivateCrtKeyParameters privKey = new RsaPrivateCrtKeyParameters( - modulus, - pubExp, + pubKey.Modulus, + pubKey.Exponent, new BigInteger(1, rp.D), new BigInteger(1, rp.P), new BigInteger(1, rp.Q), @@ -137,17 +178,18 @@ namespace Org.BouncyCastle.Security public static AsymmetricCipherKeyPair GetKeyPair(AsymmetricAlgorithm privateKey) { - if (privateKey is DSA) - { - return GetDsaKeyPair((DSA)privateKey); - } + if (privateKey is DSA dsa) + return GetDsaKeyPair(dsa); - if (privateKey is RSA) - { - return GetRsaKeyPair((RSA)privateKey); - } +#if NETCOREAPP1_0_OR_GREATER || NET47_OR_GREATER || NETSTANDARD1_6_OR_GREATER + if (privateKey is ECDsa ecDsa) + return GetECDsaKeyPair(ecDsa); +#endif - throw new ArgumentException("Unsupported algorithm specified", "privateKey"); + if (privateKey is RSA rsa) + return GetRsaKeyPair(rsa); + + throw new ArgumentException("Unsupported algorithm specified", nameof(privateKey)); } #if NET5_0_OR_GREATER @@ -244,6 +286,18 @@ namespace Org.BouncyCastle.Security return BigIntegers.AsUnsignedByteArray(size, n); } + // TODO Why do we use CspParameters instead of just RSA.Create in methods below? +// private static RSA CreateRSA(RSAParameters rp) +// { +//#if NETCOREAPP2_0_OR_GREATER || NET472_OR_GREATER || NETSTANDARD2_1_OR_GREATER +// return RSA.Create(rp); +//#else +// var rsa = RSA.Create(); +// rsa.ImportParameters(rp); +// return rsa; +//#endif +// } + #if NET5_0_OR_GREATER [SupportedOSPlatform("windows")] #endif diff --git a/crypto/src/security/JksStore.cs b/crypto/src/security/JksStore.cs index 30b21fad2..9f4aced96 100644 --- a/crypto/src/security/JksStore.cs +++ b/crypto/src/security/JksStore.cs @@ -10,6 +10,7 @@ using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.IO; using Org.BouncyCastle.Pkcs; using Org.BouncyCastle.Utilities; +using Org.BouncyCastle.Utilities.Collections; using Org.BouncyCastle.Utilities.Date; using Org.BouncyCastle.Utilities.IO; using Org.BouncyCastle.X509; @@ -216,9 +217,7 @@ namespace Org.BouncyCastle.Security { var aliases = new HashSet<string>(m_certificateEntries.Keys); aliases.UnionWith(m_keyEntries.Keys); - // FIXME - //return CollectionUtilities.Proxy(aliases); - return aliases; + return CollectionUtilities.Proxy(aliases); } } diff --git a/crypto/src/security/PrivateKeyFactory.cs b/crypto/src/security/PrivateKeyFactory.cs index d9d855c45..e66224a67 100644 --- a/crypto/src/security/PrivateKeyFactory.cs +++ b/crypto/src/security/PrivateKeyFactory.cs @@ -2,8 +2,10 @@ using System; using System.IO; using Org.BouncyCastle.Asn1; +using Org.BouncyCastle.Asn1.Cryptlib; using Org.BouncyCastle.Asn1.CryptoPro; using Org.BouncyCastle.Asn1.EdEC; +using Org.BouncyCastle.Asn1.Gnu; using Org.BouncyCastle.Asn1.Oiw; using Org.BouncyCastle.Asn1.Pkcs; using Org.BouncyCastle.Asn1.Rosstandart; @@ -128,29 +130,99 @@ namespace Org.BouncyCastle.Security ECDomainParameters dParams = new ECDomainParameters(x9.Curve, x9.G, x9.N, x9.H, x9.GetSeed()); return new ECPrivateKeyParameters(d, dParams); } - else if (algOid.Equals(CryptoProObjectIdentifiers.GostR3410x2001)) + else if (algOid.Equals(CryptoProObjectIdentifiers.GostR3410x2001) || + algOid.Equals(RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512) || + algOid.Equals(RosstandartObjectIdentifiers.id_tc26_gost_3410_12_256)) { - Gost3410PublicKeyAlgParameters gostParams = Gost3410PublicKeyAlgParameters.GetInstance( - algID.Parameters.ToAsn1Object()); + Asn1Object p = algID.Parameters.ToAsn1Object(); + Gost3410PublicKeyAlgParameters gostParams = Gost3410PublicKeyAlgParameters.GetInstance(p); - X9ECParameters ecP = ECGost3410NamedCurves.GetByOid(gostParams.PublicKeyParamSet); + ECGost3410Parameters ecSpec; + BigInteger d; - if (ecP == null) - throw new ArgumentException("Unrecognized curve OID for GostR3410x2001 private key"); + if (p is Asn1Sequence seq && (seq.Count == 2 || seq.Count == 3)) + { + X9ECParameters ecP = ECGost3410NamedCurves.GetByOid(gostParams.PublicKeyParamSet); + if (ecP == null) + throw new ArgumentException("Unrecognized curve OID for GostR3410x2001 private key"); - Asn1Object privKey = keyInfo.ParsePrivateKey(); - ECPrivateKeyStructure ec; + ecSpec = new ECGost3410Parameters( + new ECNamedDomainParameters(gostParams.PublicKeyParamSet, ecP), + gostParams.PublicKeyParamSet, + gostParams.DigestParamSet, + gostParams.EncryptionParamSet); - if (privKey is DerInteger) - { - ec = new ECPrivateKeyStructure(ecP.N.BitLength, ((DerInteger)privKey).PositiveValue); + Asn1OctetString privEnc = keyInfo.PrivateKeyData; + if (privEnc.GetOctets().Length == 32 || privEnc.GetOctets().Length == 64) + { + d = new BigInteger(1, Arrays.Reverse(privEnc.GetOctets())); + } + else + { + Asn1Object privKey = keyInfo.ParsePrivateKey(); + if (privKey is DerInteger derInteger) + { + d = derInteger.PositiveValue; + } + else + { + byte[] dVal = Arrays.Reverse(Asn1OctetString.GetInstance(privKey).GetOctets()); + d = new BigInteger(1, dVal); + } + } } else { - ec = ECPrivateKeyStructure.GetInstance(privKey); + X962Parameters x962Parameters = X962Parameters.GetInstance(p); + + if (x962Parameters.IsNamedCurve) + { + DerObjectIdentifier oid = DerObjectIdentifier.GetInstance(x962Parameters.Parameters); + X9ECParameters ecP = ECNamedCurveTable.GetByOid(oid); + if (ecP == null) + throw new ArgumentException("Unrecognized curve OID for GostR3410x2001 private key"); + + ecSpec = new ECGost3410Parameters( + new ECNamedDomainParameters(oid, ecP), + gostParams.PublicKeyParamSet, + gostParams.DigestParamSet, + gostParams.EncryptionParamSet); + } + else if (x962Parameters.IsImplicitlyCA) + { + ecSpec = null; + } + else + { + X9ECParameters ecP = X9ECParameters.GetInstance(x962Parameters.Parameters); + + ecSpec = new ECGost3410Parameters( + new ECNamedDomainParameters(algOid, ecP), + gostParams.PublicKeyParamSet, + gostParams.DigestParamSet, + gostParams.EncryptionParamSet); + } + + Asn1Object privKey = keyInfo.ParsePrivateKey(); + if (privKey is DerInteger derD) + { + d = derD.Value; + } + else + { + ECPrivateKeyStructure ec = ECPrivateKeyStructure.GetInstance(privKey); + + d = ec.GetKey(); + } } - return new ECPrivateKeyParameters("ECGOST3410", ec.GetKey(), gostParams.PublicKeyParamSet); + return new ECPrivateKeyParameters( + d, + new ECGost3410Parameters( + ecSpec, + gostParams.PublicKeyParamSet, + gostParams.DigestParamSet, + gostParams.EncryptionParamSet)); } else if (algOid.Equals(CryptoProObjectIdentifiers.GostR3410x94)) { @@ -170,7 +242,8 @@ namespace Org.BouncyCastle.Security return new Gost3410PrivateKeyParameters(x, gostParams.PublicKeyParamSet); } - else if (algOid.Equals(EdECObjectIdentifiers.id_X25519)) + else if (algOid.Equals(EdECObjectIdentifiers.id_X25519) + || algOid.Equals(CryptlibObjectIdentifiers.curvey25519)) { return new X25519PrivateKeyParameters(GetRawKey(keyInfo)); } @@ -178,7 +251,8 @@ namespace Org.BouncyCastle.Security { return new X448PrivateKeyParameters(GetRawKey(keyInfo)); } - else if (algOid.Equals(EdECObjectIdentifiers.id_Ed25519)) + else if (algOid.Equals(EdECObjectIdentifiers.id_Ed25519) + || algOid.Equals(GnuObjectIdentifiers.Ed25519)) { return new Ed25519PrivateKeyParameters(GetRawKey(keyInfo)); } diff --git a/crypto/src/security/PublicKeyFactory.cs b/crypto/src/security/PublicKeyFactory.cs index e0c7ce950..8c3e9db99 100644 --- a/crypto/src/security/PublicKeyFactory.cs +++ b/crypto/src/security/PublicKeyFactory.cs @@ -2,8 +2,10 @@ using System; using System.IO; using Org.BouncyCastle.Asn1; +using Org.BouncyCastle.Asn1.Cryptlib; using Org.BouncyCastle.Asn1.CryptoPro; using Org.BouncyCastle.Asn1.EdEC; +using Org.BouncyCastle.Asn1.Gnu; using Org.BouncyCastle.Asn1.Oiw; using Org.BouncyCastle.Asn1.Pkcs; using Org.BouncyCastle.Asn1.Rosstandart; @@ -211,7 +213,8 @@ namespace Org.BouncyCastle.Security return new Gost3410PublicKeyParameters(y, algParams.PublicKeyParamSet); } - else if (algOid.Equals(EdECObjectIdentifiers.id_X25519)) + else if (algOid.Equals(EdECObjectIdentifiers.id_X25519) + || algOid.Equals(CryptlibObjectIdentifiers.curvey25519)) { return new X25519PublicKeyParameters(GetRawKey(keyInfo)); } @@ -219,7 +222,8 @@ namespace Org.BouncyCastle.Security { return new X448PublicKeyParameters(GetRawKey(keyInfo)); } - else if (algOid.Equals(EdECObjectIdentifiers.id_Ed25519)) + else if (algOid.Equals(EdECObjectIdentifiers.id_Ed25519) + || algOid.Equals(GnuObjectIdentifiers.Ed25519)) { return new Ed25519PublicKeyParameters(GetRawKey(keyInfo)); } diff --git a/crypto/src/security/SignerUtilities.cs b/crypto/src/security/SignerUtilities.cs index e6210dad7..6500cdf13 100644 --- a/crypto/src/security/SignerUtilities.cs +++ b/crypto/src/security/SignerUtilities.cs @@ -379,14 +379,18 @@ namespace Org.BouncyCastle.Security AlgorithmMap["GOST-3410-2012-256"] = "ECGOST3410-2012-256"; AlgorithmMap["GOST3411WITHECGOST3410-2012-256"] = "ECGOST3410-2012-256"; + AlgorithmMap["GOST3411-2012-256WITHECGOST3410"] = "ECGOST3410-2012-256"; AlgorithmMap["GOST3411-2012-256WITHECGOST3410-2012-256"] = "ECGOST3410-2012-256"; + AlgorithmMap["GOST3411-2012-256/ECGOST3410"] = "ECGOST3410-2012-256"; AlgorithmMap["GOST3411-2012-256/ECGOST3410-2012-256"] = "ECGOST3410-2012-256"; AlgorithmMap[RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_256.Id] = "ECGOST3410-2012-256"; AlgorithmMap["GOST-3410-2012-512"] = "ECGOST3410-2012-512"; AlgorithmMap["GOST3411WITHECGOST3410-2012-512"] = "ECGOST3410-2012-512"; + AlgorithmMap["GOST3411-2012-512WITHECGOST3410"] = "ECGOST3410-2012-512"; AlgorithmMap["GOST3411-2012-512WITHECGOST3410-2012-512"] = "ECGOST3410-2012-512"; + AlgorithmMap["GOST3411-2012-512/ECGOST3410"] = "ECGOST3410-2012-512"; AlgorithmMap["GOST3411-2012-512/ECGOST3410-2012-512"] = "ECGOST3410-2012-512"; AlgorithmMap[RosstandartObjectIdentifiers.id_tc26_signwithdigest_gost_3410_12_512.Id] = "ECGOST3410-2012-512"; diff --git a/crypto/src/tls/AbstractTlsPeer.cs b/crypto/src/tls/AbstractTlsPeer.cs index 4e1b28e58..6d7c88f1b 100644 --- a/crypto/src/tls/AbstractTlsPeer.cs +++ b/crypto/src/tls/AbstractTlsPeer.cs @@ -157,5 +157,7 @@ namespace Org.BouncyCastle.Tls { return HeartbeatMode.peer_not_allowed_to_send; } + + public virtual bool IgnoreCorruptDtlsRecords => false; } } diff --git a/crypto/src/tls/CombinedHash.cs b/crypto/src/tls/CombinedHash.cs index 71151d2a5..360b9d426 100644 --- a/crypto/src/tls/CombinedHash.cs +++ b/crypto/src/tls/CombinedHash.cs @@ -43,6 +43,14 @@ namespace Org.BouncyCastle.Tls m_sha1.Update(input, inOff, len); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) + { + m_md5.Update(input); + m_sha1.Update(input); + } +#endif + public virtual byte[] CalculateHash() { if (null != m_context && TlsUtilities.IsSsl(m_context)) diff --git a/crypto/src/tls/DatagramReceiver.cs b/crypto/src/tls/DatagramReceiver.cs index 5ab605ac4..a689515f6 100644 --- a/crypto/src/tls/DatagramReceiver.cs +++ b/crypto/src/tls/DatagramReceiver.cs @@ -10,5 +10,10 @@ namespace Org.BouncyCastle.Tls /// <exception cref="IOException"/> int Receive(byte[] buf, int off, int len, int waitMillis); + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + /// <exception cref="IOException"/> + int Receive(Span<byte> buffer, int waitMillis); +#endif } } diff --git a/crypto/src/tls/DatagramSender.cs b/crypto/src/tls/DatagramSender.cs index bf14c18fe..c2a987b51 100644 --- a/crypto/src/tls/DatagramSender.cs +++ b/crypto/src/tls/DatagramSender.cs @@ -10,5 +10,10 @@ namespace Org.BouncyCastle.Tls /// <exception cref="IOException"/> void Send(byte[] buf, int off, int len); + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + /// <exception cref="IOException"/> + void Send(ReadOnlySpan<byte> buffer); +#endif } } diff --git a/crypto/src/tls/DeferredHash.cs b/crypto/src/tls/DeferredHash.cs index 82f7899a5..e6397ab1e 100644 --- a/crypto/src/tls/DeferredHash.cs +++ b/crypto/src/tls/DeferredHash.cs @@ -176,6 +176,22 @@ namespace Org.BouncyCastle.Tls } } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) + { + if (m_buf != null) + { + m_buf.Write(input); + return; + } + + foreach (TlsHash hash in m_hashes.Values) + { + hash.Update(input); + } + } +#endif + public byte[] CalculateHash() { throw new InvalidOperationException("Use 'ForkPrfHash' to get a definite hash"); diff --git a/crypto/src/tls/DtlsClientProtocol.cs b/crypto/src/tls/DtlsClientProtocol.cs index b8c09617a..0a4a711ae 100644 --- a/crypto/src/tls/DtlsClientProtocol.cs +++ b/crypto/src/tls/DtlsClientProtocol.cs @@ -173,7 +173,7 @@ namespace Org.BouncyCastle.Tls recordLayer.InitHeartbeat(state.heartbeat, HeartbeatMode.peer_allowed_to_send == state.heartbeatPolicy); - return new DtlsTransport(recordLayer); + return new DtlsTransport(recordLayer, state.client.IgnoreCorruptDtlsRecords); } InvalidateSession(state); @@ -392,7 +392,7 @@ namespace Org.BouncyCastle.Tls recordLayer.InitHeartbeat(state.heartbeat, HeartbeatMode.peer_allowed_to_send == state.heartbeatPolicy); - return new DtlsTransport(recordLayer); + return new DtlsTransport(recordLayer, state.client.IgnoreCorruptDtlsRecords); } /// <exception cref="IOException"/> diff --git a/crypto/src/tls/DtlsRecordLayer.cs b/crypto/src/tls/DtlsRecordLayer.cs index b93253146..bab6892b7 100644 --- a/crypto/src/tls/DtlsRecordLayer.cs +++ b/crypto/src/tls/DtlsRecordLayer.cs @@ -1,8 +1,6 @@ using System; using System.IO; -#if !PORTABLE || DOTNET using System.Net.Sockets; -#endif using Org.BouncyCastle.Tls.Crypto; using Org.BouncyCastle.Utilities; @@ -244,6 +242,9 @@ namespace Org.BouncyCastle.Tls /// <exception cref="IOException"/> public virtual int Receive(byte[] buf, int off, int len, int waitMillis) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return Receive(buf.AsSpan(off, len), waitMillis); +#else long currentTimeMillis = DateTimeUtilities.CurrentUnixMs(); Timeout timeout = Timeout.ForWaitMillis(waitMillis, currentTimeMillis); @@ -307,11 +308,85 @@ namespace Org.BouncyCastle.Tls } return -1; +#endif } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + /// <exception cref="IOException"/> + public virtual int Receive(Span<byte> buffer, int waitMillis) + { + long currentTimeMillis = DateTimeUtilities.CurrentUnixMs(); + + Timeout timeout = Timeout.ForWaitMillis(waitMillis, currentTimeMillis); + byte[] record = null; + + while (waitMillis >= 0) + { + if (null != m_retransmitTimeout && m_retransmitTimeout.RemainingMillis(currentTimeMillis) < 1) + { + m_retransmit = null; + m_retransmitEpoch = null; + m_retransmitTimeout = null; + } + + if (Timeout.HasExpired(m_heartbeatTimeout, currentTimeMillis)) + { + if (null != m_heartbeatInFlight) + throw new TlsTimeoutException("Heartbeat timed out"); + + this.m_heartbeatInFlight = HeartbeatMessage.Create(m_context, + HeartbeatMessageType.heartbeat_request, m_heartbeat.GeneratePayload()); + this.m_heartbeatTimeout = new Timeout(m_heartbeat.TimeoutMillis, currentTimeMillis); + + this.m_heartbeatResendMillis = DtlsReliableHandshake.INITIAL_RESEND_MILLIS; + this.m_heartbeatResendTimeout = new Timeout(m_heartbeatResendMillis, currentTimeMillis); + + SendHeartbeatMessage(m_heartbeatInFlight); + } + else if (Timeout.HasExpired(m_heartbeatResendTimeout, currentTimeMillis)) + { + this.m_heartbeatResendMillis = DtlsReliableHandshake.BackOff(m_heartbeatResendMillis); + this.m_heartbeatResendTimeout = new Timeout(m_heartbeatResendMillis, currentTimeMillis); + + SendHeartbeatMessage(m_heartbeatInFlight); + } + + waitMillis = Timeout.ConstrainWaitMillis(waitMillis, m_heartbeatTimeout, currentTimeMillis); + waitMillis = Timeout.ConstrainWaitMillis(waitMillis, m_heartbeatResendTimeout, currentTimeMillis); + + // NOTE: Guard against bad logic giving a negative value + if (waitMillis < 0) + { + waitMillis = 1; + } + + int receiveLimit = System.Math.Min(buffer.Length, GetReceiveLimit()) + RECORD_HEADER_LENGTH; + if (null == record || record.Length < receiveLimit) + { + record = new byte[receiveLimit]; + } + + int received = ReceiveRecord(record, 0, receiveLimit, waitMillis); + int processed = ProcessRecord(received, record, buffer); + if (processed >= 0) + { + return processed; + } + + currentTimeMillis = DateTimeUtilities.CurrentUnixMs(); + waitMillis = Timeout.GetWaitMillis(timeout, currentTimeMillis); + } + + return -1; + } +#endif + /// <exception cref="IOException"/> public virtual void Send(byte[] buf, int off, int len) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + Send(buf.AsSpan(off, len)); +#else short contentType = ContentType.application_data; if (m_inHandshake || m_writeEpoch == m_retransmitEpoch) @@ -340,7 +415,7 @@ namespace Org.BouncyCastle.Tls // Implicitly send change_cipher_spec and change to pending cipher state // TODO Send change_cipher_spec and finished records in single datagram? - byte[] data = new byte[]{ 1 }; + byte[] data = new byte[1]{ 1 }; SendRecord(ContentType.change_cipher_spec, data, 0, data.Length); this.m_writeEpoch = nextEpoch; @@ -348,7 +423,51 @@ namespace Org.BouncyCastle.Tls } SendRecord(contentType, buf, off, len); +#endif + } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + /// <exception cref="IOException"/> + public virtual void Send(ReadOnlySpan<byte> buffer) + { + short contentType = ContentType.application_data; + + if (m_inHandshake || m_writeEpoch == m_retransmitEpoch) + { + contentType = ContentType.handshake; + + short handshakeType = TlsUtilities.ReadUint8(buffer); + if (handshakeType == HandshakeType.finished) + { + DtlsEpoch nextEpoch = null; + if (m_inHandshake) + { + nextEpoch = m_pendingEpoch; + } + else if (m_writeEpoch == m_retransmitEpoch) + { + nextEpoch = m_currentEpoch; + } + + if (nextEpoch == null) + { + // TODO + throw new InvalidOperationException(); + } + + // Implicitly send change_cipher_spec and change to pending cipher state + + // TODO Send change_cipher_spec and finished records in single datagram? + ReadOnlySpan<byte> data = stackalloc byte[1]{ 1 }; + SendRecord(ContentType.change_cipher_spec, data); + + this.m_writeEpoch = nextEpoch; + } + } + + SendRecord(contentType, buffer); } +#endif /// <exception cref="IOException"/> public virtual void Close() @@ -434,11 +553,13 @@ namespace Org.BouncyCastle.Tls { m_peer.NotifyAlertRaised(alertLevel, alertDescription, message, cause); - byte[] error = new byte[2]; - error[0] = (byte)alertLevel; - error[1] = (byte)alertDescription; - +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + ReadOnlySpan<byte> error = stackalloc byte[2]{ (byte)alertLevel, (byte)alertDescription }; + SendRecord(ContentType.alert, error); +#else + byte[] error = new byte[2]{ (byte)alertLevel, (byte)alertDescription }; SendRecord(ContentType.alert, error, 0, 2); +#endif } /// <exception cref="IOException"/> @@ -452,7 +573,6 @@ namespace Org.BouncyCastle.Tls { return -1; } -#if !PORTABLE || DOTNET catch (SocketException e) { if (TlsUtilities.IsTimeout(e)) @@ -460,7 +580,6 @@ namespace Org.BouncyCastle.Tls throw e; } -#endif // TODO[tls-port] Can we support interrupted IO on .NET? //catch (InterruptedIOException e) //{ @@ -471,7 +590,11 @@ namespace Org.BouncyCastle.Tls // TODO Include 'currentTimeMillis' as an argument, use with Timeout, resetHeartbeat /// <exception cref="IOException"/> +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + private int ProcessRecord(int received, byte[] record, Span<byte> buffer) +#else private int ProcessRecord(int received, byte[] record, byte[] buf, int off) +#endif { // NOTE: received < 0 (timeout) is covered by this first case if (received < RECORD_HEADER_LENGTH) @@ -704,7 +827,11 @@ namespace Org.BouncyCastle.Tls this.m_retransmitTimeout = null; } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + decoded.buf.AsSpan(decoded.off, decoded.len).CopyTo(buffer); +#else Array.Copy(decoded.buf, decoded.off, buf, off, decoded.len); +#endif return decoded.len; } @@ -716,9 +843,7 @@ namespace Org.BouncyCastle.Tls int length = 0; if (m_recordQueue.Available >= RECORD_HEADER_LENGTH) { - byte[] lengthBytes = new byte[2]; - m_recordQueue.Read(lengthBytes, 0, 2, 11); - length = TlsUtilities.ReadUint16(lengthBytes, 0); + length = m_recordQueue.ReadUint16(11); } int received = System.Math.Min(m_recordQueue.Available, RECORD_HEADER_LENGTH + length); @@ -758,9 +883,16 @@ namespace Org.BouncyCastle.Tls { MemoryStream output = new MemoryStream(); heartbeatMessage.Encode(output); - byte[] buf = output.ToArray(); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + if (!output.TryGetBuffer(out var buffer)) + throw new InvalidOperationException(); + + SendRecord(ContentType.heartbeat, buffer); +#else + byte[] buf = output.ToArray(); SendRecord(ContentType.heartbeat, buf, 0, buf.Length); +#endif } /* @@ -770,12 +902,20 @@ namespace Org.BouncyCastle.Tls * be possible reordering of records (which might surprise a reliable transport implementation). */ /// <exception cref="IOException"/> +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + private void SendRecord(short contentType, ReadOnlySpan<byte> buffer) +#else private void SendRecord(short contentType, byte[] buf, int off, int len) +#endif { // Never send anything until a valid ClientHello has been received if (m_writeVersion == null) return; +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + int len = buffer.Length; +#endif + if (len > m_plaintextLimit) throw new TlsFatalAlert(AlertDescription.internal_error); @@ -793,8 +933,13 @@ namespace Org.BouncyCastle.Tls long macSequenceNumber = GetMacSequenceNumber(recordEpoch, recordSequenceNumber); ProtocolVersion recordVersion = m_writeVersion; +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + TlsEncodeResult encoded = m_writeEpoch.Cipher.EncodePlaintext(macSequenceNumber, contentType, + recordVersion, RECORD_HEADER_LENGTH, buffer); +#else TlsEncodeResult encoded = m_writeEpoch.Cipher.EncodePlaintext(macSequenceNumber, contentType, recordVersion, RECORD_HEADER_LENGTH, buf, off, len); +#endif int ciphertextLength = encoded.len - RECORD_HEADER_LENGTH; TlsUtilities.CheckUint16(ciphertextLength); diff --git a/crypto/src/tls/DtlsServerProtocol.cs b/crypto/src/tls/DtlsServerProtocol.cs index b42f97b64..5edd5595e 100644 --- a/crypto/src/tls/DtlsServerProtocol.cs +++ b/crypto/src/tls/DtlsServerProtocol.cs @@ -381,7 +381,7 @@ namespace Org.BouncyCastle.Tls recordLayer.InitHeartbeat(state.heartbeat, HeartbeatMode.peer_allowed_to_send == state.heartbeatPolicy); - return new DtlsTransport(recordLayer); + return new DtlsTransport(recordLayer, state.server.IgnoreCorruptDtlsRecords); } /// <exception cref="IOException"/> diff --git a/crypto/src/tls/DtlsTransport.cs b/crypto/src/tls/DtlsTransport.cs index a41cb7866..033e0af0b 100644 --- a/crypto/src/tls/DtlsTransport.cs +++ b/crypto/src/tls/DtlsTransport.cs @@ -1,8 +1,6 @@ using System; using System.IO; -#if !PORTABLE || DOTNET using System.Net.Sockets; -#endif namespace Org.BouncyCastle.Tls { @@ -10,10 +8,12 @@ namespace Org.BouncyCastle.Tls : DatagramTransport { private readonly DtlsRecordLayer m_recordLayer; + private readonly bool m_ignoreCorruptRecords; - internal DtlsTransport(DtlsRecordLayer recordLayer) + internal DtlsTransport(DtlsRecordLayer recordLayer, bool ignoreCorruptRecords) { - this.m_recordLayer = recordLayer; + m_recordLayer = recordLayer; + m_ignoreCorruptRecords = ignoreCorruptRecords; } /// <exception cref="IOException"/> @@ -37,6 +37,10 @@ namespace Org.BouncyCastle.Tls throw new ArgumentException("invalid offset: " + off, "off"); if (len < 0 || len > buf.Length - off) throw new ArgumentException("invalid length: " + len, "len"); + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return Receive(buf.AsSpan(off, len), waitMillis); +#else if (waitMillis < 0) throw new ArgumentException("cannot be negative", "waitMillis"); @@ -46,6 +50,9 @@ namespace Org.BouncyCastle.Tls } catch (TlsFatalAlert fatalAlert) { + if (m_ignoreCorruptRecords && AlertDescription.bad_record_mac == fatalAlert.AlertDescription) + return -1; + m_recordLayer.Fail(fatalAlert.AlertDescription); throw fatalAlert; } @@ -53,7 +60,6 @@ namespace Org.BouncyCastle.Tls { throw e; } -#if !PORTABLE || DOTNET catch (SocketException e) { if (TlsUtilities.IsTimeout(e)) @@ -62,7 +68,55 @@ namespace Org.BouncyCastle.Tls m_recordLayer.Fail(AlertDescription.internal_error); throw new TlsFatalAlert(AlertDescription.internal_error, e); } + // TODO[tls-port] Can we support interrupted IO on .NET? + //catch (InterruptedIOException e) + //{ + // throw e; + //} + catch (IOException e) + { + m_recordLayer.Fail(AlertDescription.internal_error); + throw e; + } + catch (Exception e) + { + m_recordLayer.Fail(AlertDescription.internal_error); + throw new TlsFatalAlert(AlertDescription.internal_error, e); + } #endif + } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + /// <exception cref="IOException"/> + public virtual int Receive(Span<byte> buffer, int waitMillis) + { + if (waitMillis < 0) + throw new ArgumentException("cannot be negative", nameof(waitMillis)); + + try + { + return m_recordLayer.Receive(buffer, waitMillis); + } + catch (TlsFatalAlert fatalAlert) + { + if (m_ignoreCorruptRecords && AlertDescription.bad_record_mac == fatalAlert.AlertDescription) + return -1; + + m_recordLayer.Fail(fatalAlert.AlertDescription); + throw fatalAlert; + } + catch (TlsTimeoutException e) + { + throw e; + } + catch (SocketException e) + { + if (TlsUtilities.IsTimeout(e)) + throw e; + + m_recordLayer.Fail(AlertDescription.internal_error); + throw new TlsFatalAlert(AlertDescription.internal_error, e); + } // TODO[tls-port] Can we support interrupted IO on .NET? //catch (InterruptedIOException e) //{ @@ -79,6 +133,7 @@ namespace Org.BouncyCastle.Tls throw new TlsFatalAlert(AlertDescription.internal_error, e); } } +#endif /// <exception cref="IOException"/> public virtual void Send(byte[] buf, int off, int len) @@ -90,6 +145,9 @@ namespace Org.BouncyCastle.Tls if (len < 0 || len > buf.Length - off) throw new ArgumentException("invalid length: " + len, "len"); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + Send(buf.AsSpan(off, len)); +#else try { m_recordLayer.Send(buf, off, len); @@ -103,7 +161,6 @@ namespace Org.BouncyCastle.Tls { throw e; } -#if !PORTABLE || DOTNET catch (SocketException e) { if (TlsUtilities.IsTimeout(e)) @@ -112,7 +169,48 @@ namespace Org.BouncyCastle.Tls m_recordLayer.Fail(AlertDescription.internal_error); throw new TlsFatalAlert(AlertDescription.internal_error, e); } + // TODO[tls-port] Can we support interrupted IO on .NET? + //catch (InterruptedIOException e) + //{ + // throw e; + //} + catch (IOException e) + { + m_recordLayer.Fail(AlertDescription.internal_error); + throw e; + } + catch (Exception e) + { + m_recordLayer.Fail(AlertDescription.internal_error); + throw new TlsFatalAlert(AlertDescription.internal_error, e); + } #endif + } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public virtual void Send(ReadOnlySpan<byte> buffer) + { + try + { + m_recordLayer.Send(buffer); + } + catch (TlsFatalAlert fatalAlert) + { + m_recordLayer.Fail(fatalAlert.AlertDescription); + throw fatalAlert; + } + catch (TlsTimeoutException e) + { + throw e; + } + catch (SocketException e) + { + if (TlsUtilities.IsTimeout(e)) + throw e; + + m_recordLayer.Fail(AlertDescription.internal_error); + throw new TlsFatalAlert(AlertDescription.internal_error, e); + } // TODO[tls-port] Can we support interrupted IO on .NET? //catch (InterruptedIOException e) //{ @@ -129,6 +227,7 @@ namespace Org.BouncyCastle.Tls throw new TlsFatalAlert(AlertDescription.internal_error, e); } } +#endif /// <exception cref="IOException"/> public virtual void Close() diff --git a/crypto/src/tls/RecordStream.cs b/crypto/src/tls/RecordStream.cs index a97d34698..a5926d05b 100644 --- a/crypto/src/tls/RecordStream.cs +++ b/crypto/src/tls/RecordStream.cs @@ -258,6 +258,9 @@ namespace Org.BouncyCastle.Tls /// <exception cref="IOException"/> internal void WriteRecord(short contentType, byte[] plaintext, int plaintextOffset, int plaintextLength) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + WriteRecord(contentType, plaintext.AsSpan(plaintextOffset, plaintextLength)); +#else // Never send anything until a valid ClientHello has been received if (m_writeVersion == null) return; @@ -298,8 +301,56 @@ namespace Org.BouncyCastle.Tls //} m_output.Flush(); +#endif } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + /// <exception cref="IOException"/> + internal void WriteRecord(short contentType, ReadOnlySpan<byte> plaintext) + { + // Never send anything until a valid ClientHello has been received + if (m_writeVersion == null) + return; + + /* + * RFC 5246 6.2.1 The length should not exceed 2^14. + */ + CheckLength(plaintext.Length, m_plaintextLimit, AlertDescription.internal_error); + + /* + * RFC 5246 6.2.1 Implementations MUST NOT send zero-length fragments of Handshake, Alert, + * or ChangeCipherSpec content types. + */ + if (plaintext.Length < 1 && contentType != ContentType.application_data) + throw new TlsFatalAlert(AlertDescription.internal_error); + + long seqNo = m_writeSeqNo.NextValue(AlertDescription.internal_error); + ProtocolVersion recordVersion = m_writeVersion; + + TlsEncodeResult encoded = m_writeCipher.EncodePlaintext(seqNo, contentType, recordVersion, + RecordFormat.FragmentOffset, plaintext); + + int ciphertextLength = encoded.len - RecordFormat.FragmentOffset; + TlsUtilities.CheckUint16(ciphertextLength); + + TlsUtilities.WriteUint8(encoded.recordType, encoded.buf, encoded.off + RecordFormat.TypeOffset); + TlsUtilities.WriteVersion(recordVersion, encoded.buf, encoded.off + RecordFormat.VersionOffset); + TlsUtilities.WriteUint16(ciphertextLength, encoded.buf, encoded.off + RecordFormat.LengthOffset); + + // TODO[tls-port] Can we support interrupted IO on .NET? + //try + //{ + m_output.Write(encoded.buf, encoded.off, encoded.len); + //} + //catch (InterruptedIOException e) + //{ + // throw new TlsFatalAlert(AlertDescription.internal_error, e); + //} + + m_output.Flush(); + } +#endif + /// <exception cref="IOException"/> internal void Close() { diff --git a/crypto/src/tls/TlsPeer.cs b/crypto/src/tls/TlsPeer.cs index ef2837135..04d66d38f 100644 --- a/crypto/src/tls/TlsPeer.cs +++ b/crypto/src/tls/TlsPeer.cs @@ -119,5 +119,12 @@ namespace Org.BouncyCastle.Tls /// </remarks> /// <returns>the <see cref="HeartbeatMode"/> value.</returns> short GetHeartbeatPolicy(); + + /// <summary>Indicates whether a DTLS connection should ignore corrupt records (bad_record_mac) instead of + /// failing the connection.</summary> + /// <remarks>Called only once at the start of a connection and applies throughout.</remarks> + /// <returns>The value <c>true</c> to ignore corrupt DTLS records, or <c>false</c> to fail the connection. + /// </returns> + bool IgnoreCorruptDtlsRecords { get; } } } diff --git a/crypto/src/tls/TlsProtocol.cs b/crypto/src/tls/TlsProtocol.cs index 3461e9b58..437a51447 100644 --- a/crypto/src/tls/TlsProtocol.cs +++ b/crypto/src/tls/TlsProtocol.cs @@ -707,6 +707,9 @@ namespace Org.BouncyCastle.Tls { Streams.ValidateBufferArguments(buffer, offset, count); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return ReadApplicationData(buffer.AsSpan(offset, count)); +#else if (!m_appDataReady) throw new InvalidOperationException("Cannot read application data until initial handshake completed."); @@ -733,8 +736,42 @@ namespace Org.BouncyCastle.Tls m_applicationDataQueue.RemoveData(buffer, offset, count, 0); } return count; +#endif } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public virtual int ReadApplicationData(Span<byte> buffer) + { + if (!m_appDataReady) + throw new InvalidOperationException("Cannot read application data until initial handshake completed."); + + while (m_applicationDataQueue.Available < 1) + { + if (this.m_closed) + { + if (this.m_failedWithError) + throw new IOException("Cannot read application data on failed TLS connection"); + + return 0; + } + + /* + * NOTE: Only called more than once when empty records are received, so no special + * InterruptedIOException handling is necessary. + */ + SafeReadRecord(); + } + + int count = buffer.Length; + if (count > 0) + { + count = System.Math.Min(count, m_applicationDataQueue.Available); + m_applicationDataQueue.RemoveData(buffer[..count], 0); + } + return count; + } +#endif + /// <exception cref="IOException"/> protected virtual RecordPreview SafePreviewRecordHeader(byte[] recordHeader) { @@ -850,6 +887,32 @@ namespace Org.BouncyCastle.Tls } } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + /// <exception cref="IOException"/> + protected virtual void SafeWriteRecord(short type, ReadOnlySpan<byte> buffer) + { + try + { + m_recordStream.WriteRecord(type, buffer); + } + catch (TlsFatalAlert e) + { + HandleException(e.AlertDescription, "Failed to write record", e); + throw e; + } + catch (IOException e) + { + HandleException(AlertDescription.internal_error, "Failed to write record", e); + throw e; + } + catch (Exception e) + { + HandleException(AlertDescription.internal_error, "Failed to write record", e); + throw new TlsFatalAlert(AlertDescription.internal_error, e); + } + } +#endif + /// <summary>Write some application data.</summary> /// <remarks> /// Fragmentation is handled internally. Usable in both blocking/non-blocking modes.<br/><br/> @@ -869,6 +932,9 @@ namespace Org.BouncyCastle.Tls { Streams.ValidateBufferArguments(buffer, offset, count); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + WriteApplicationData(buffer.AsSpan(offset, count)); +#else if (!m_appDataReady) throw new InvalidOperationException( "Cannot write application data until initial handshake completed."); @@ -938,7 +1004,82 @@ namespace Org.BouncyCastle.Tls count -= toWrite; } } +#endif + } + + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public virtual void WriteApplicationData(ReadOnlySpan<byte> buffer) + { + if (!m_appDataReady) + throw new InvalidOperationException( + "Cannot write application data until initial handshake completed."); + + lock (m_recordWriteLock) + { + while (!buffer.IsEmpty) + { + if (m_closed) + throw new IOException("Cannot write application data on closed/failed TLS connection"); + + /* + * RFC 5246 6.2.1. Zero-length fragments of Application data MAY be sent as they are + * potentially useful as a traffic analysis countermeasure. + * + * NOTE: Actually, implementations appear to have settled on 1/n-1 record splitting. + */ + if (m_appDataSplitEnabled) + { + /* + * Protect against known IV attack! + * + * DO NOT REMOVE THIS CODE, EXCEPT YOU KNOW EXACTLY WHAT YOU ARE DOING HERE. + */ + switch (m_appDataSplitMode) + { + case ADS_MODE_0_N_FIRSTONLY: + { + this.m_appDataSplitEnabled = false; + SafeWriteRecord(ContentType.application_data, TlsUtilities.EmptyBytes, 0, 0); + break; + } + case ADS_MODE_0_N: + { + SafeWriteRecord(ContentType.application_data, TlsUtilities.EmptyBytes, 0, 0); + break; + } + case ADS_MODE_1_Nsub1: + default: + { + if (buffer.Length > 1) + { + SafeWriteRecord(ContentType.application_data, buffer[..1]); + buffer = buffer[1..]; + } + break; + } + } + } + else if (m_keyUpdateEnabled) + { + if (m_keyUpdatePendingSend) + { + Send13KeyUpdate(false); + } + else if (m_recordStream.NeedsKeyUpdate()) + { + Send13KeyUpdate(true); + } + } + + // Fragment data according to the current fragment limit. + int toWrite = System.Math.Min(buffer.Length, m_recordStream.PlaintextLimit); + SafeWriteRecord(ContentType.application_data, buffer[..toWrite]); + buffer = buffer[toWrite..]; + } + } } +#endif public virtual int AppDataSplitMode { diff --git a/crypto/src/tls/TlsStream.cs b/crypto/src/tls/TlsStream.cs index 01b990799..5c07da2bf 100644 --- a/crypto/src/tls/TlsStream.cs +++ b/crypto/src/tls/TlsStream.cs @@ -58,6 +58,13 @@ namespace Org.BouncyCastle.Tls return m_handler.ReadApplicationData(buffer, offset, count); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + return m_handler.ReadApplicationData(buffer); + } +#endif + public override int ReadByte() { byte[] buf = new byte[1]; @@ -80,6 +87,13 @@ namespace Org.BouncyCastle.Tls m_handler.WriteApplicationData(buffer, offset, count); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + m_handler.WriteApplicationData(buffer); + } +#endif + public override void WriteByte(byte value) { m_handler.WriteApplicationData(new byte[]{ value }, 0, 1); diff --git a/crypto/src/tls/TlsUtilities.cs b/crypto/src/tls/TlsUtilities.cs index f12198082..463928ba6 100644 --- a/crypto/src/tls/TlsUtilities.cs +++ b/crypto/src/tls/TlsUtilities.cs @@ -747,9 +747,16 @@ namespace Org.BouncyCastle.Tls public static short ReadUint8(byte[] buf, int offset) { - return (short)(buf[offset] & 0xff); + return (short)buf[offset]; } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public static short ReadUint8(ReadOnlySpan<byte> buffer) + { + return (short)buffer[0]; + } +#endif + public static int ReadUint16(Stream input) { int i1 = input.ReadByte(); diff --git a/crypto/src/tls/crypto/TlsCipher.cs b/crypto/src/tls/crypto/TlsCipher.cs index 4c2147bf7..53a8141fd 100644 --- a/crypto/src/tls/crypto/TlsCipher.cs +++ b/crypto/src/tls/crypto/TlsCipher.cs @@ -38,6 +38,11 @@ namespace Org.BouncyCastle.Tls.Crypto TlsEncodeResult EncodePlaintext(long seqNo, short contentType, ProtocolVersion recordVersion, int headerAllocation, byte[] plaintext, int offset, int len); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + TlsEncodeResult EncodePlaintext(long seqNo, short contentType, ProtocolVersion recordVersion, + int headerAllocation, ReadOnlySpan<byte> plaintext); +#endif + /// <summary>Decode the passed in ciphertext using the current bulk cipher.</summary> /// <param name="seqNo">sequence number of the message represented by ciphertext.</param> /// <param name="recordType">content type used in the record for this message.</param> diff --git a/crypto/src/tls/crypto/TlsHash.cs b/crypto/src/tls/crypto/TlsHash.cs index 4732fc280..6fbaeceb9 100644 --- a/crypto/src/tls/crypto/TlsHash.cs +++ b/crypto/src/tls/crypto/TlsHash.cs @@ -11,6 +11,10 @@ namespace Org.BouncyCastle.Tls.Crypto /// <param name="length">the length of the input data.</param> void Update(byte[] input, int inOff, int length); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + void Update(ReadOnlySpan<byte> input); +#endif + /// <summary>Return calculated hash for any input passed in.</summary> /// <returns>the hash value.</returns> byte[] CalculateHash(); diff --git a/crypto/src/tls/crypto/TlsHashSink.cs b/crypto/src/tls/crypto/TlsHashSink.cs index a1681b0c8..3401eb60e 100644 --- a/crypto/src/tls/crypto/TlsHashSink.cs +++ b/crypto/src/tls/crypto/TlsHashSink.cs @@ -29,6 +29,16 @@ namespace Org.BouncyCastle.Tls.Crypto } } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + if (!buffer.IsEmpty) + { + m_hash.Update(buffer); + } + } +#endif + public override void WriteByte(byte value) { m_hash.Update(new byte[]{ value }, 0, 1); diff --git a/crypto/src/tls/crypto/TlsMac.cs b/crypto/src/tls/crypto/TlsMac.cs index a898a9bcc..511e29d10 100644 --- a/crypto/src/tls/crypto/TlsMac.cs +++ b/crypto/src/tls/crypto/TlsMac.cs @@ -21,6 +21,10 @@ namespace Org.BouncyCastle.Tls.Crypto /// <param name="length">the length of the input data.</param> void Update(byte[] input, int inOff, int length); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + void Update(ReadOnlySpan<byte> input); +#endif + /// <summary>Return calculated MAC for any input passed in.</summary> /// <returns>the MAC value.</returns> byte[] CalculateMac(); diff --git a/crypto/src/tls/crypto/TlsMacSink.cs b/crypto/src/tls/crypto/TlsMacSink.cs index e7d5c70d7..fbb2e5893 100644 --- a/crypto/src/tls/crypto/TlsMacSink.cs +++ b/crypto/src/tls/crypto/TlsMacSink.cs @@ -29,6 +29,16 @@ namespace Org.BouncyCastle.Tls.Crypto } } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + if (!buffer.IsEmpty) + { + m_mac.Update(buffer); + } + } +#endif + public override void WriteByte(byte value) { m_mac.Update(new byte[]{ value }, 0, 1); diff --git a/crypto/src/tls/crypto/TlsNullNullCipher.cs b/crypto/src/tls/crypto/TlsNullNullCipher.cs index 082dff358..13fe092f7 100644 --- a/crypto/src/tls/crypto/TlsNullNullCipher.cs +++ b/crypto/src/tls/crypto/TlsNullNullCipher.cs @@ -31,6 +31,16 @@ namespace Org.BouncyCastle.Tls.Crypto return new TlsEncodeResult(result, 0, result.Length, contentType); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public TlsEncodeResult EncodePlaintext(long seqNo, short contentType, ProtocolVersion recordVersion, + int headerAllocation, ReadOnlySpan<byte> plaintext) + { + byte[] result = new byte[headerAllocation + plaintext.Length]; + plaintext.CopyTo(result.AsSpan(headerAllocation)); + return new TlsEncodeResult(result, 0, result.Length, contentType); + } +#endif + public TlsDecodeResult DecodeCiphertext(long seqNo, short recordType, ProtocolVersion recordVersion, byte[] ciphertext, int offset, int len) { diff --git a/crypto/src/tls/crypto/impl/TlsAeadCipher.cs b/crypto/src/tls/crypto/impl/TlsAeadCipher.cs index 046e6883f..594981210 100644 --- a/crypto/src/tls/crypto/impl/TlsAeadCipher.cs +++ b/crypto/src/tls/crypto/impl/TlsAeadCipher.cs @@ -161,6 +161,10 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl public virtual TlsEncodeResult EncodePlaintext(long seqNo, short contentType, ProtocolVersion recordVersion, int headerAllocation, byte[] plaintext, int plaintextOffset, int plaintextLength) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return EncodePlaintext(seqNo, contentType, recordVersion, headerAllocation, + plaintext.AsSpan(plaintextOffset, plaintextLength)); +#else byte[] nonce = new byte[m_encryptNonce.Length + m_record_iv_length]; switch (m_nonceMode) @@ -229,7 +233,83 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl } return new TlsEncodeResult(output, 0, output.Length, recordType); +#endif + } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public virtual TlsEncodeResult EncodePlaintext(long seqNo, short contentType, ProtocolVersion recordVersion, + int headerAllocation, ReadOnlySpan<byte> plaintext) + { + byte[] nonce = new byte[m_encryptNonce.Length + m_record_iv_length]; + + switch (m_nonceMode) + { + case NONCE_RFC5288: + Array.Copy(m_encryptNonce, 0, nonce, 0, m_encryptNonce.Length); + // RFC 5288/6655: The nonce_explicit MAY be the 64-bit sequence number. + TlsUtilities.WriteUint64(seqNo, nonce, m_encryptNonce.Length); + break; + case NONCE_RFC7905: + TlsUtilities.WriteUint64(seqNo, nonce, nonce.Length - 8); + for (int i = 0; i < m_encryptNonce.Length; ++i) + { + nonce[i] ^= m_encryptNonce[i]; + } + break; + default: + throw new TlsFatalAlert(AlertDescription.internal_error); + } + + int extraLength = m_isTlsV13 ? 1 : 0; + + // TODO[tls13] If we support adding padding to TLSInnerPlaintext, this will need review + int encryptionLength = m_encryptCipher.GetOutputSize(plaintext.Length + extraLength); + int ciphertextLength = m_record_iv_length + encryptionLength; + + byte[] output = new byte[headerAllocation + ciphertextLength]; + int outputPos = headerAllocation; + + if (m_record_iv_length != 0) + { + Array.Copy(nonce, nonce.Length - m_record_iv_length, output, outputPos, m_record_iv_length); + outputPos += m_record_iv_length; + } + + short recordType = m_isTlsV13 ? ContentType.application_data : contentType; + + byte[] additionalData = GetAdditionalData(seqNo, recordType, recordVersion, ciphertextLength, + plaintext.Length); + + try + { + plaintext.CopyTo(output.AsSpan(outputPos)); + if (m_isTlsV13) + { + output[outputPos + plaintext.Length] = (byte)contentType; + } + + m_encryptCipher.Init(nonce, m_macSize, additionalData); + outputPos += m_encryptCipher.DoFinal(output, outputPos, plaintext.Length + extraLength, output, + outputPos); + } + catch (IOException e) + { + throw e; + } + catch (Exception e) + { + throw new TlsFatalAlert(AlertDescription.internal_error, e); + } + + if (outputPos != output.Length) + { + // NOTE: The additional data mechanism for AEAD ciphers requires exact output size prediction. + throw new TlsFatalAlert(AlertDescription.internal_error); + } + + return new TlsEncodeResult(output, 0, output.Length, recordType); } +#endif public virtual TlsDecodeResult DecodeCiphertext(long seqNo, short recordType, ProtocolVersion recordVersion, byte[] ciphertext, int ciphertextOffset, int ciphertextLength) @@ -271,12 +351,21 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl outputPos = m_decryptCipher.DoFinal(ciphertext, encryptionOffset, encryptionLength, ciphertext, encryptionOffset); } + catch (TlsFatalAlert fatalAlert) + { + if (AlertDescription.bad_record_mac == fatalAlert.AlertDescription) + { + m_decryptCipher.Reset(); + } + throw fatalAlert; + } catch (IOException e) { throw e; } catch (Exception e) { + m_decryptCipher.Reset(); throw new TlsFatalAlert(AlertDescription.bad_record_mac, e); } diff --git a/crypto/src/tls/crypto/impl/TlsAeadCipherImpl.cs b/crypto/src/tls/crypto/impl/TlsAeadCipherImpl.cs index 4c69c0b72..0cd2923c2 100644 --- a/crypto/src/tls/crypto/impl/TlsAeadCipherImpl.cs +++ b/crypto/src/tls/crypto/impl/TlsAeadCipherImpl.cs @@ -41,5 +41,7 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl /// <returns>the amount of data written to output.</returns> /// <exception cref="IOException">in case of failure.</exception> int DoFinal(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset); + + void Reset(); } } diff --git a/crypto/src/tls/crypto/impl/TlsBlockCipher.cs b/crypto/src/tls/crypto/impl/TlsBlockCipher.cs index ed9d68649..64a73bfea 100644 --- a/crypto/src/tls/crypto/impl/TlsBlockCipher.cs +++ b/crypto/src/tls/crypto/impl/TlsBlockCipher.cs @@ -199,6 +199,9 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl public virtual TlsEncodeResult EncodePlaintext(long seqNo, short contentType, ProtocolVersion recordVersion, int headerAllocation, byte[] plaintext, int offset, int len) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return EncodePlaintext(seqNo, contentType, recordVersion, headerAllocation, plaintext.AsSpan(offset, len)); +#else int blockSize = m_encryptCipher.GetBlockSize(); int macSize = m_writeMac.Size; @@ -264,7 +267,80 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl throw new TlsFatalAlert(AlertDescription.internal_error); return new TlsEncodeResult(outBuf, 0, outBuf.Length, contentType); +#endif + } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public virtual TlsEncodeResult EncodePlaintext(long seqNo, short contentType, ProtocolVersion recordVersion, + int headerAllocation, ReadOnlySpan<byte> plaintext) + { + int blockSize = m_encryptCipher.GetBlockSize(); + int macSize = m_writeMac.Size; + + int enc_input_length = plaintext.Length; + if (!m_encryptThenMac) + { + enc_input_length += macSize; + } + + int padding_length = blockSize - (enc_input_length % blockSize); + if (m_useExtraPadding) + { + // Add a random number of extra blocks worth of padding + int maxExtraPadBlocks = (256 - padding_length) / blockSize; + int actualExtraPadBlocks = ChooseExtraPadBlocks(maxExtraPadBlocks); + padding_length += actualExtraPadBlocks * blockSize; + } + + int totalSize = plaintext.Length + macSize + padding_length; + if (m_useExplicitIV) + { + totalSize += blockSize; + } + + byte[] outBuf = new byte[headerAllocation + totalSize]; + int outOff = headerAllocation; + + if (m_useExplicitIV) + { + // Technically the explicit IV will be the encryption of this nonce + byte[] explicitIV = m_cryptoParams.NonceGenerator.GenerateNonce(blockSize); + Array.Copy(explicitIV, 0, outBuf, outOff, blockSize); + outOff += blockSize; + } + + plaintext.CopyTo(outBuf.AsSpan(outOff)); + outOff += plaintext.Length; + + if (!m_encryptThenMac) + { + byte[] mac = m_writeMac.CalculateMac(seqNo, contentType, plaintext); + mac.CopyTo(outBuf.AsSpan(outOff)); + outOff += mac.Length; + } + + byte padByte = (byte)(padding_length - 1); + for (int i = 0; i < padding_length; ++i) + { + outBuf[outOff++] = padByte; + } + + m_encryptCipher.DoFinal(outBuf, headerAllocation, outOff - headerAllocation, outBuf, headerAllocation); + + if (m_encryptThenMac) + { + byte[] mac = m_writeMac.CalculateMac(seqNo, contentType, outBuf, headerAllocation, + outOff - headerAllocation); + Array.Copy(mac, 0, outBuf, outOff, mac.Length); + outOff += mac.Length; + } + + if (outOff != outBuf.Length) + throw new TlsFatalAlert(AlertDescription.internal_error); + + return new TlsEncodeResult(outBuf, 0, outBuf.Length, contentType); } +#endif public virtual TlsDecodeResult DecodeCiphertext(long seqNo, short recordType, ProtocolVersion recordVersion, byte[] ciphertext, int offset, int len) diff --git a/crypto/src/tls/crypto/impl/TlsNullCipher.cs b/crypto/src/tls/crypto/impl/TlsNullCipher.cs index 5b6b5663a..9bb08110a 100644 --- a/crypto/src/tls/crypto/impl/TlsNullCipher.cs +++ b/crypto/src/tls/crypto/impl/TlsNullCipher.cs @@ -81,6 +81,18 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl return new TlsEncodeResult(ciphertext, 0, ciphertext.Length, contentType); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public virtual TlsEncodeResult EncodePlaintext(long seqNo, short contentType, ProtocolVersion recordVersion, + int headerAllocation, ReadOnlySpan<byte> plaintext) + { + byte[] mac = m_writeMac.CalculateMac(seqNo, contentType, plaintext); + byte[] ciphertext = new byte[headerAllocation + plaintext.Length + mac.Length]; + plaintext.CopyTo(ciphertext.AsSpan(headerAllocation)); + mac.CopyTo(ciphertext.AsSpan(headerAllocation + plaintext.Length)); + return new TlsEncodeResult(ciphertext, 0, ciphertext.Length, contentType); + } +#endif + public virtual TlsDecodeResult DecodeCiphertext(long seqNo, short recordType, ProtocolVersion recordVersion, byte[] ciphertext, int offset, int len) { diff --git a/crypto/src/tls/crypto/impl/TlsSuiteHmac.cs b/crypto/src/tls/crypto/impl/TlsSuiteHmac.cs index 9f43f4382..b4edde760 100644 --- a/crypto/src/tls/crypto/impl/TlsSuiteHmac.cs +++ b/crypto/src/tls/crypto/impl/TlsSuiteHmac.cs @@ -55,6 +55,9 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl public virtual byte[] CalculateMac(long seqNo, short type, byte[] msg, int msgOff, int msgLen) { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + return CalculateMac(seqNo, type, msg.AsSpan(msgOff, msgLen)); +#else ProtocolVersion serverVersion = m_cryptoParams.ServerVersion; bool isSsl = serverVersion.IsSsl; @@ -71,8 +74,31 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl m_mac.Update(msg, msgOff, msgLen); return Truncate(m_mac.CalculateMac()); +#endif } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public virtual byte[] CalculateMac(long seqNo, short type, ReadOnlySpan<byte> message) + { + ProtocolVersion serverVersion = m_cryptoParams.ServerVersion; + bool isSsl = serverVersion.IsSsl; + + byte[] macHeader = new byte[isSsl ? 11 : 13]; + TlsUtilities.WriteUint64(seqNo, macHeader, 0); + TlsUtilities.WriteUint8(type, macHeader, 8); + if (!isSsl) + { + TlsUtilities.WriteVersion(serverVersion, macHeader, 9); + } + TlsUtilities.WriteUint16(message.Length, macHeader, macHeader.Length - 2); + + m_mac.Update(macHeader); + m_mac.Update(message); + + return Truncate(m_mac.CalculateMac()); + } +#endif + public virtual byte[] CalculateMacConstantTime(long seqNo, short type, byte[] msg, int msgOff, int msgLen, int fullLength, byte[] dummyData) { diff --git a/crypto/src/tls/crypto/impl/TlsSuiteMac.cs b/crypto/src/tls/crypto/impl/TlsSuiteMac.cs index 6e4942928..1a28eba81 100644 --- a/crypto/src/tls/crypto/impl/TlsSuiteMac.cs +++ b/crypto/src/tls/crypto/impl/TlsSuiteMac.cs @@ -18,6 +18,10 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl /// <returns>A new byte array containing the MAC value.</returns> byte[] CalculateMac(long seqNo, short type, byte[] message, int offset, int length); +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + byte[] CalculateMac(long seqNo, short type, ReadOnlySpan<byte> message); +#endif + /// <summary>Constant time calculation of the MAC for some given data with a given expected length.</summary> /// <param name="seqNo">The sequence number of the record.</param> /// <param name="type">The content type of the message.</param> diff --git a/crypto/src/tls/crypto/impl/bc/BcChaCha20Poly1305.cs b/crypto/src/tls/crypto/impl/bc/BcChaCha20Poly1305.cs index 6b87c100a..06a09bbb1 100644 --- a/crypto/src/tls/crypto/impl/bc/BcChaCha20Poly1305.cs +++ b/crypto/src/tls/crypto/impl/bc/BcChaCha20Poly1305.cs @@ -96,6 +96,12 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl.BC } } + public void Reset() + { + m_cipher.Reset(); + m_mac.Reset(); + } + public void SetKey(byte[] key, int keyOff, int keyLen) { KeyParameter cipherKey = new KeyParameter(key, keyOff, keyLen); @@ -106,16 +112,23 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl.BC public void SetKey(ReadOnlySpan<byte> key) { KeyParameter cipherKey = new KeyParameter(key); - m_cipher.Init(m_isEncrypting, new ParametersWithIV(cipherKey, Zeroes[..12])); + m_cipher.Init(m_isEncrypting, new ParametersWithIV(cipherKey, Zeroes.AsSpan(0, 12))); } #endif private void InitMac() { +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + Span<byte> firstBlock = stackalloc byte[64]; + m_cipher.ProcessBytes(firstBlock, firstBlock); + m_mac.Init(new KeyParameter(firstBlock[..32])); + firstBlock.Fill(0x00); +#else byte[] firstBlock = new byte[64]; m_cipher.ProcessBytes(firstBlock, 0, 64, firstBlock, 0); m_mac.Init(new KeyParameter(firstBlock, 0, 32)); Array.Clear(firstBlock, 0, firstBlock.Length); +#endif } private void UpdateMac(byte[] buf, int off, int len) diff --git a/crypto/src/tls/crypto/impl/bc/BcSsl3Hmac.cs b/crypto/src/tls/crypto/impl/bc/BcSsl3Hmac.cs index f26a50d46..a0378e334 100644 --- a/crypto/src/tls/crypto/impl/bc/BcSsl3Hmac.cs +++ b/crypto/src/tls/crypto/impl/bc/BcSsl3Hmac.cs @@ -66,6 +66,13 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl.BC m_digest.BlockUpdate(input, inOff, len); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) + { + m_digest.BlockUpdate(input); + } +#endif + public virtual byte[] CalculateMac() { byte[] result = new byte[m_digest.GetDigestSize()]; diff --git a/crypto/src/tls/crypto/impl/bc/BcTlsAeadCipherImpl.cs b/crypto/src/tls/crypto/impl/bc/BcTlsAeadCipherImpl.cs index 0b2781326..4965c92bd 100644 --- a/crypto/src/tls/crypto/impl/bc/BcTlsAeadCipherImpl.cs +++ b/crypto/src/tls/crypto/impl/bc/BcTlsAeadCipherImpl.cs @@ -57,5 +57,10 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl.BC return len; } + + public void Reset() + { + m_cipher.Reset(); + } } } diff --git a/crypto/src/tls/crypto/impl/bc/BcTlsHash.cs b/crypto/src/tls/crypto/impl/bc/BcTlsHash.cs index 0b35831f3..0ad2576cb 100644 --- a/crypto/src/tls/crypto/impl/bc/BcTlsHash.cs +++ b/crypto/src/tls/crypto/impl/bc/BcTlsHash.cs @@ -28,6 +28,13 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl.BC m_digest.BlockUpdate(data, offSet, length); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) + { + m_digest.BlockUpdate(input); + } +#endif + public byte[] CalculateHash() { byte[] rv = new byte[m_digest.GetDigestSize()]; diff --git a/crypto/src/tls/crypto/impl/bc/BcTlsHmac.cs b/crypto/src/tls/crypto/impl/bc/BcTlsHmac.cs index 7a2318a31..dbe7f4c69 100644 --- a/crypto/src/tls/crypto/impl/bc/BcTlsHmac.cs +++ b/crypto/src/tls/crypto/impl/bc/BcTlsHmac.cs @@ -32,6 +32,13 @@ namespace Org.BouncyCastle.Tls.Crypto.Impl.BC m_hmac.BlockUpdate(input, inOff, length); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public void Update(ReadOnlySpan<byte> input) + { + m_hmac.BlockUpdate(input); + } +#endif + public byte[] CalculateMac() { byte[] rv = new byte[m_hmac.GetMacSize()]; diff --git a/crypto/src/tsp/TSPUtil.cs b/crypto/src/tsp/TSPUtil.cs index a9402ac6d..1ba289ae6 100644 --- a/crypto/src/tsp/TSPUtil.cs +++ b/crypto/src/tsp/TSPUtil.cs @@ -145,7 +145,7 @@ namespace Org.BouncyCastle.Tsp ExtendedKeyUsage extKey = ExtendedKeyUsage.GetInstance( Asn1Object.FromByteArray(ext.GetOctets())); - if (!extKey.HasKeyPurposeId(KeyPurposeID.IdKPTimeStamping) || extKey.Count != 1) + if (!extKey.HasKeyPurposeId(KeyPurposeID.id_kp_timeStamping) || extKey.Count != 1) throw new TspValidationException("ExtendedKeyUsage not solely time stamping."); } catch (IOException) diff --git a/crypto/src/util/Arrays.cs b/crypto/src/util/Arrays.cs index 936e510be..bd2a4faea 100644 --- a/crypto/src/util/Arrays.cs +++ b/crypto/src/util/Arrays.cs @@ -6,7 +6,7 @@ using Org.BouncyCastle.Math; namespace Org.BouncyCastle.Utilities { /// <summary> General array utilities.</summary> - public abstract class Arrays + public static class Arrays { public static readonly byte[] EmptyBytes = new byte[0]; public static readonly int[] EmptyInts = new int[0]; @@ -884,6 +884,17 @@ namespace Org.BouncyCastle.Utilities return result; } + public static T[] Prepend<T>(T[] a, T b) + { + if (a == null) + return new T[1]{ b }; + + T[] result = new T[1 + a.Length]; + result[0] = b; + a.CopyTo(result, 1); + return result; + } + public static byte[] Reverse(byte[] a) { if (a == null) diff --git a/crypto/src/util/io/BaseInputStream.cs b/crypto/src/util/io/BaseInputStream.cs index ebe256632..eaaf9556d 100644 --- a/crypto/src/util/io/BaseInputStream.cs +++ b/crypto/src/util/io/BaseInputStream.cs @@ -45,5 +45,9 @@ namespace Org.BouncyCastle.Utilities.IO public sealed override long Seek(long offset, SeekOrigin origin) { throw new NotSupportedException(); } public sealed override void SetLength(long value) { throw new NotSupportedException(); } public sealed override void Write(byte[] buffer, int offset, int count) { throw new NotSupportedException(); } + +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) { throw new NotSupportedException(); } +#endif } } diff --git a/crypto/src/util/io/BaseOutputStream.cs b/crypto/src/util/io/BaseOutputStream.cs index dad9b19a4..0fc8e9681 100644 --- a/crypto/src/util/io/BaseOutputStream.cs +++ b/crypto/src/util/io/BaseOutputStream.cs @@ -21,6 +21,9 @@ namespace Org.BouncyCastle.Utilities.IO set { throw new NotSupportedException(); } } public sealed override int Read(byte[] buffer, int offset, int count) { throw new NotSupportedException(); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public sealed override int Read(Span<byte> buffer) { throw new NotSupportedException(); } +#endif public sealed override long Seek(long offset, SeekOrigin origin) { throw new NotSupportedException(); } public sealed override void SetLength(long value) { throw new NotSupportedException(); } diff --git a/crypto/src/util/io/FilterStream.cs b/crypto/src/util/io/FilterStream.cs index d9bcbb8ef..38077edd2 100644 --- a/crypto/src/util/io/FilterStream.cs +++ b/crypto/src/util/io/FilterStream.cs @@ -10,10 +10,7 @@ namespace Org.BouncyCastle.Utilities.IO public FilterStream(Stream s) { - if (s == null) - throw new ArgumentNullException(nameof(s)); - - this.s = s; + this.s = s ?? throw new ArgumentNullException(nameof(s)); } public override bool CanRead { @@ -27,6 +24,12 @@ namespace Org.BouncyCastle.Utilities.IO { get { return s.CanWrite; } } +#if NETCOREAPP2_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void CopyTo(Stream destination, int bufferSize) + { + s.CopyTo(destination, bufferSize); + } +#endif public override void Flush() { s.Flush(); @@ -44,6 +47,12 @@ namespace Org.BouncyCastle.Utilities.IO { return s.Read(buffer, offset, count); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override int Read(Span<byte> buffer) + { + return s.Read(buffer); + } +#endif public override int ReadByte() { return s.ReadByte(); @@ -60,6 +69,12 @@ namespace Org.BouncyCastle.Utilities.IO { s.Write(buffer, offset, count); } +#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER + public override void Write(ReadOnlySpan<byte> buffer) + { + s.Write(buffer); + } +#endif public override void WriteByte(byte value) { s.WriteByte(value); diff --git a/crypto/test/BouncyCastle.Crypto.Tests.csproj b/crypto/test/BouncyCastle.Crypto.Tests.csproj index 3c9b88328..77a873a2a 100644 --- a/crypto/test/BouncyCastle.Crypto.Tests.csproj +++ b/crypto/test/BouncyCastle.Crypto.Tests.csproj @@ -1,12 +1,12 @@ <Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> - <TargetFrameworks>net6.0;netcoreapp3.1;net472;net462</TargetFrameworks> + <TargetFrameworks>net6.0;netcoreapp3.1;net472;net461</TargetFrameworks> <IsPackable>false</IsPackable> - <AssemblyOriginatorKeyFile>..\..\BouncyCastle.snk</AssemblyOriginatorKeyFile> - <SignAssembly>true</SignAssembly> + <SignAssembly>false</SignAssembly> <EnableDefaultItems>false</EnableDefaultItems> - <NoWarn>1591</NoWarn> + <NoWarn>618;1591</NoWarn> + <RootNamespace>Org.BouncyCastle</RootNamespace> </PropertyGroup> <PropertyGroup Condition="'$(Configuration)'=='Debug'"> @@ -28,7 +28,7 @@ <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> </PackageReference> <PackageReference Include="NUnit" Version="3.13.3" /> - <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" /> + <PackageReference Include="NUnit3TestAdapter" Version="4.3.0" /> </ItemGroup> <ItemGroup> <ProjectReference Include="..\src\BouncyCastle.Crypto.csproj"> diff --git a/crypto/test/data/openpgp/eddsa-pub-keyring.asc b/crypto/test/data/openpgp/eddsa-pub-keyring.asc new file mode 100644 index 000000000..b2a74fc86 --- /dev/null +++ b/crypto/test/data/openpgp/eddsa-pub-keyring.asc @@ -0,0 +1,14666 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: SKS 1.1.6 +Comment: Hostname: pgp.mit.edu + +mQMqBEd5F8MRCACfArHCJFR6nkmxNiW+UE4PAW3bQla9JWFqCwu4VqLkPI/lHb5pxHff8Fzy +2O89BxD/6hXSDx2SlVmAGHOCJhShx1vfNGVYNsJn2oNK50in9kGvD0+mVACfy5MyPV8mtMcO +M2p18wWVuMd2geYbdNYgArfn/DNpU/59M6eCUphXkYEDcECBqZRKjSB1JNEnqHAM+gc5fc4V +lYdZ+HYBrEZTX/ZLPZg5kffR7XyA6IgqWPSY0PrYxDOxGujyeStpyZhmkT7ezVzoKBI+ylj3 +bpKOrkuKLjB3W5TngCLLYvTR/g7yzNygt/+urpzNO85KsGLBVDkkShSswiPIett0ZFB/AOD8 +DawpLNUTX2c6zM6d0gKfS8/DTrxX6PS5A5ZzB/4xEBpnjnCr2RjnbTi4lcNLg+b25c9lrbT1 +SXytrUifUQbcOEkCefk+X7JPoU/x3Db1DuC94LAaMFfU2o6GWPTzBNtEBBtGpg4Ms5Q1w1g1 +gDREpKM3mGIPycLKXhB+Jfi8pF+qvBqRiA3xnWZALZP009ZfLY+8nMB06u/59zKcLyz+h/zj +CmpIJdFr5xQotm6ztK8Qms1GG1MOVPQ1vCUCHiSwIa7V1KtllYIIsHqR7sIXuTSmiLJ48Tq1 +NY59nE1hD7JicccghyPeX52onFfEw5qHEPJoXhcOjxSua2x9U9i7cpJnzLKnIBhdZa7TQht7 +/jL4C75Sy+fExeESng8PCACUBT+zUUzALezGOZGvxn82OM6rR/l2mV9WXepKEB+IDPG1JBwq +fl1f80/mI8hhwkr2LYryhd5u+cecRy71993dPSnAYDaysG/+sIVxYz9M4doWQVhSe9EOJngW +cvYP5bCWDybmlBYQJgCkrFUqMvQTJOCklpqbjQm/uxXaWum9dSAxp5YeHCKqBILUnjBVLoar +mV0bcWXwotZiXFd3WpnBHjE/QSnycFh334+brR8KTSnmS+v6I+B6W+VOcyzHt+8WpXuo1YS4 +okCmZv6fzIlf6HcVJOJT8dpqpzyMhqn4YYT0LbRC9orc2Kox0hzaios9K0EoKf5MRQEMsAHA +dM0MtBpXZXJuZXIgS29jaCA8d2tAZ251cGcub3JnPohGBBARAgAGBQJHeR3nAAoJEF3iSZZb +A1iiUoQAoJNEdsXUc9r5Suo20PsAtUEIVyFiAJ4wfm4VrByDPWpBWwRx5+Kow1oeeIhGBBAR +AgAGBQJH2roXAAoJEAeoNRFMU4b3lRIAoKJEpkU4nrqPwH9oiSu56N/kwRL5AJ9oM3w13y/H +eTXEpoSA60wybHq2h4hGBBARAgAGBQJH228QAAoJECbj3TnrOFAkbHMAn2/T0+bn/Ogm4RVL +lOb+WRS7yD0OAJ9lO0qSQt6B+TUbrYlH0jykZUmXSYhGBBARAgAGBQJH3To9AAoJECjdsP0Z +yba6cacAn3Tte0iepAZXbdr4p2vBQUYAHIpaAKCK3zuAWo7Bujc2bYR+aqDzed9+F4hGBBAR +AgAGBQJH3tNbAAoJEDKM1rPrwnUVcasAn2BbG/9kIgj23vWX/+YxLAapNlHwAJwLUCBKi7Vj +SdKa8QJMpF+Vh3zGkYhGBBARAgAGBQJH4ZTgAAoJEGpOVkX0ZUOA+FsAoIV9MzMgxT5X9L+K +Pj4m1JJ/OWfgAKCS4WJRyi/Nk2jhwOe4tnTJZsPbkIhGBBARAgAGBQJH4ZdbAAoJEB29XnWD +meG76nQAn3cyLV/pe02xBYws8QelhKvIc8g4AJ9ll6UtKv8Vm8vm0Huesex2vES/R4hGBBAR +AgAGBQJH+RFwAAoJEMlnNNgRt8YvSd0AnjZSEUyXEvS5TBAOAyI/feLeY+mkAJ9ZghaBsX6D +Mbx+bJpoyx+V19++xIhGBBARAgAGBQJH+gWRAAoJEInhPhCW6sXYORgAnA6qzVjWMFEQfAT9 +WJivKCx4NnE9AJ0cqoKiokEuvVEuvaHPTPuh3+YU3YhGBBARAgAGBQJInYAqAAoJEBJ2JBfP +BQjsz8MAniMsvwjgvSI9fCIySw6W4uyMMGO/AJ9ut4xidHAhxMwXfCIM/pYvdyEDyohGBBAR +AgAGBQJI7whTAAoJEHfWhFBrJ3plExAAn0qEXO8t3SYObM4BhHLFEnpIEbjmAJwPPCxRDXtG +XUM5ao7oXTI6XUxE64hGBBARAgAGBQJI+h0uAAoJEIzFQNLUwxu0k9MAoIXgX8d2t7uBLM89 +AgpURIjVUcLBAJ9kRhqmQZKe29lI9YfV7Odkn+Re84hGBBARAgAGBQJJCj2xAAoJENAH0xZh +uVyBxzkAoIO6oD/cBbmZjL1573ivm/Ihtn+CAJ9O4R//aDFVZ74jgvq1dJ7DuVR/e4hGBBAR +AgAGBQJJfEHCAAoJELRKND+o8jtmr4EAoKm8OQXjqGqf1xUaFeoum+Eh/kWJAJ9LT2iGzmO5 +62nJtgVCTbcgFYCwvohGBBARAgAGBQJJhHEeAAoJEIfWoN3aShEWv70AnRFEFMD1U+343xmq +e01Rv/7OhvzfAJ9yboHDeuwyxIhdk7ObpZxjj9g2jIhGBBARAgAGBQJJh0R4AAoJENLwolOf +iErI+zoAniu/IM22Yw5es+LZSKI5Le83Jz8NAJ956sMasRB247W8yy6cS8Hm6/IEaYhGBBAR +AgAGBQJJu4eRAAoJEDuOpB+C9hJAmCAAn2NspRTGyLP69maoSu8DO8LfhBysAJ4h0c1iGkkv +cndTCIH5OhMg+ymNyIhGBBARAgAGBQJKSJk7AAoJECUUKpDbVyxwEuAAn30Xr8bSqnHzCk/i +lC7Ll4/F/Oy5AKCE6TmqBJPwQPpMiaz24Jtk7jaOWYhGBBARAgAGBQJKSoGRAAoJEJzL2hYB ++otK2b0Anj++Do2lC7lkbIv8wk98gPfY5EYhAKCDmUagnl+rEj6F183ZBrAkIEVaRohGBBAR +AgAGBQJKdt7RAAoJEDMlX+ieeD4FI1MAnRdMPfdkQFD6svt29qrFp4Ix85BwAJ4jIIFZlYyB +DxG2Gn2i42VdDNDpS4hGBBARAgAGBQJKec55AAoJEAZOQqbv3+tXBTUAnRBhuiRvrnC/baHX +9McBdS4hhDayAJoC6B6rhlztF5yAC6IA5aKYrTuhqYhGBBARAgAGBQJK/AcUAAoJENG84OKP +oRoVKMsAnRX9m3lVNGGrwq/WOD+NDim6oQ5HAKCgOw2+XxJFcSYKUEDOVB9ST3OICohGBBAR +AgAGBQJK/BgUAAoJEHJZXrGBcEuTNi0AoNzrL3zRvJMtNcTEx54+kDmjKao3AJoDCvcqvkIh +F9v+PQtEfPXNoavSYIhGBBARAgAGBQJLAA50AAoJEPG6TB7RyLqPGcUAn2dVF+tJYrh5P7KF +mKlaAdKZfM1ZAKDHK6CO0ySm7Hlcd8LyBVcvqu5hz4hGBBARAgAGBQJLAStUAAoJEBgFUbrZ +Wjw1K2cAn32vNmvfdcekiWei7Lu4q+xh2tDLAKCBjvifrM8in225shtjwkY48yg8YYhGBBAR +AgAGBQJLAZwFAAoJENsmMCSB3bBljbIAniguVJQxxC1L5JSQak/bWcPVaDWjAJ9RMl3U4Ddc +UuEtoEOCUoZMunJq/4hGBBARAgAGBQJLAsbuAAoJEFB4/VGsulDH6z8AoNWHVuMl/FwiSz7m +zyCQ2Sv+/cMlAJsFhDuRm1npD/BaHm9Sa+QMNbbzMIhGBBARAgAGBQJLBn4pAAoJEHfdleLq +Uuz08lMAoIRCl8MDX2IEQY01ZLpN8tYNIw+FAJ9aR1CcEDV3GFA2dklhBHRu+C9Hn4hGBBAR +AgAGBQJLCQJzAAoJECmflZArdNqyTUQAoI4cuXYtFZiaDgvTOxjlbKpjPqu/AJ95v8jkzBIT +IgsPpRiVa7FdVvr1g4hGBBARAgAGBQJLDboCAAoJEI53TMap06PgNVkAn1ufsp7r+QD95NrZ +vjF/jzLTbUolAKCmdKAGKOqPjqdQ8dl+IftcIExUjYhGBBARAgAGBQJLDplvAAoJEG4hb+1k +Bp1cGdMAn2zAXdg0VF9dxPS25DX7r6NZOs/KAJ9unZZhT8JqZIjsUnyWuQNStT8WI4hGBBAR +AgAGBQJLHGdYAAoJEMcaTGXwWbHR6V8AoIGQZjUQzKNaO0F1vE5wGo3JWpWXAJ4iqzRJZsI5 +LRugJumRDQ4shJrYT4hGBBARAgAGBQJLMKawAAoJEMK4wKy+MmP+e7wAn10q4K+swRBoNKCb +5NWEdJ2nAyW9AJ4lpsavrESGU/XKpaEcXXq9/RS/SYhGBBARAgAGBQJLepWlAAoJEIjq2qqI +Z5tJOJUAn3qXZMUJ4Z0yYKtf2khGqy5VioU+AKCWjHzIXrsfD4KGfPBoGgkZC6oT7YhGBBAR +AgAGBQJLev+JAAoJEE6mlUJSgFLELxMAnigiTRgWIaqmXNaZSdhD7FEjsEIZAJ0TGAymKGYh +VFU6lB7BUBH7A/p6uohGBBARAgAGBQJLe8fUAAoJEDYAaQ6qWWq0n7gAn2/reBssQbnpCGAC +CMZEBeQ+JRtaAJ4wDnS+8TfwD5LIEbpQ3+ltUnkTm4hGBBARAgAGBQJLe+C+AAoJEHIYvL3g +mppnqhMAnir2yPbF2FXwaIdQAgSo3Ybq2ctZAJ0bu7jUBRJdUMdNCxejnklgNdP7JohGBBAR +AgAGBQJLgU/NAAoJEH7RMqO5O52IZCkAni9oGJnzCdXYCWWg3sMCldUpbb32AJwP3gif0JXC +UyBsMeQYrOJPtI09R4hGBBARAgAGBQJLguKeAAoJELnjbqQR58S5mu0AoLg03rcy9u03Gkp0 +QB28DtJOIh2nAJ4lrTx+x/RBNtJMWrc9yItFX5x2+ohGBBARAgAGBQJMSwtnAAoJEIMSIJCi +6IJe3hEAoJTawpHKnKCcxiT9DNN+H8Ps1tmxAJ452qvW4Tr4ghjJKVlJcN8ukzCrg4hGBBAR +AgAGBQJMTexjAAoJEGUd81I9I/Jd8p8An3RWScuKNSlgpz1R6n3W4SKBy3A9AJ9nVL/nGEB/ +NbDJ8fbmbY1YaTP3a4hGBBARAgAGBQJMTffFAAoJEL9gcItIQmx+/tUAnRy35uKDnWXEshre +cp2zFOr1gqGrAJ45oHo3PuaFwznnWs8QLNFCt/1WyohGBBARAgAGBQJMXG2GAAoJEOb6axWj +krwv6CIAnAuFrkbOU7PgXPeFIqA/WOKb5pIgAJ9451VgbrbQ3H6wqJV2bOWNjgRPTohGBBAR +AgAGBQJMXmyqAAoJEDJBm3hdDNz8PrMAnRBgqIRDNfPdIpqaQNwDNKvkdnMxAKCQcR7mF9tk +nie3yXddhnuLZTCBSYhGBBARAgAGBQJMcmEbAAoJEISAc4An/PEu49wAn1rGfP25WWhu+0u1 +qzdOI7jM8gMqAKCSBkYubiMQEw+5ckzyC/CPsQP/UIhGBBARAgAGBQJM43BdAAoJEI+6d0TM +hxDQB2IAnior+BoZJiRYZ3MM4DfPfTr48IXXAJsGBRdBPPpQrnAjs9pdZxuRhfI8O4hGBBAR +AgAGBQJM47/3AAoJEDACjSRIE7X+VToAn3p7msDXK21rcpXpaD6zFMcyF3XEAJ9R1zAeWRfE +/RXBSFl5tjBiRJxjzIhGBBARAgAGBQJN0/DqAAoJEAalIsEfKJatWBAAni6a4WHQxZB50DXJ +xuRf6cvPc2sFAJ4439sovktZiLxvqxvLPiDjeNjhRIhGBBARAgAGBQJN8rDPAAoJEOVQtZ9Y +38YIYacAni25nNcjZRKFpsaSHOiYKd5m1NRyAJ4iJoBEbs1EY98PljDPhGrkBwQxLohGBBAR +AgAGBQJOv4xJAAoJELW0d0l5skq3XOwAn2zccW8l30xDU2daxzWZc9XHgDkuAJwL69D4O9O2 +YQYEMbICXITRGI7CU4hGBBARAgAGBQJPRpyxAAoJEA8mVjp2uDN64XYAoKZk8m+9TzGUQU/m +nNe2JODCcXBcAKC2wYeTLgtie6H63t2UteNAIKxOy4hGBBARAgAGBQJPVSW4AAoJELkN18nt +YZU9KJsAn1wtXkNYZwtdij7Nsk+F5fJ/gf3WAKCA58voBxSIVkFKcbwAPbnY6IdG2IhGBBAR +CAAGBQJLArryAAoJEDlgZk+V6iPdRsYAmwWNDl8VzBhSDKO9EsHnxvI0xiJ1AJ9uOsVFAtDA +pfRdW8fmiabb/cJnb4hGBBARCAAGBQJV1KuMAAoJEMWvd0pYUQta9L8AnjMUZq+TEIcvQTwz +CyfdcocCqZ+ZAJ42ch1K5StfChIhLHpdy2ayxVw3sohGBBIRAgAGBQJLZXPPAAoJEPcpr9mB +gClU4QcAoNkPfUmcxwAk7VKrpHkp/BDc4k/LAKDZpMjWBpiyN6YPITY/JHaqgu5ILIhGBBMR +AgAGBQJHqu+pAAoJEKvyrWfMCu8+EvYAn2Q2KipuJyXOoYkfrSqcsV855eVmAJ960EnKD1bB +8Y9wXhP1Ng0W4QWt3IhGBBMRAgAGBQJH3uLNAAoJEI2fCBHtSI5usaYAnAqoiKxnyV5Kn/xp ++OFrXdL6nHYHAJ0fJWydEKG7F2sX4r1WgHl2F1Lj/YhGBBMRAgAGBQJJ65YnAAoJEPXBMydn +XiKiolcAni0UhbS4GYjvkRhAxWEzMPPn96PMAJ9ZACTiKHmgjshrHwHWwszruc1fvohGBBMR +AgAGBQJKTQnNAAoJEC+VFQiq5gIuXxsAoIQUnIC5+ecgnhdnAfzWKwoPoDOHAJ97hNCLrTia +aXlOXrkXNGj7qwN1+ohGBBMRAgAGBQJKfwQCAAoJENumiZyC1vKWzfAAni0lvtXKDzBjFI38 +rel8GSVABAW7AJ9rYtDedAEVARNJiRExiS7MZ30QAIhGBBMRAgAGBQJKiAa2AAoJELnGX4dT +s4krUvYAnjyK472HBpcPfW9dJsoJI3kF9jPpAKCILTDDbfZG/UARdgj422eXd4LEXYhGBBMR +AgAGBQJOvwotAAoJEP6kW/2ohoL9X1kAn3UVsj5Ql7mCBKucAZDeEw8tqA03AJ9JKNsavEsR ++TuPo0MRkA0cHwy4E4hGBBMRAgAGBQJOy+74AAoJEAvgqvm1LMtStAsAnRSwIlbQNF+Q/jW+ +dCN53wv8QqaKAJ0b0X0a2PFfc3PmplzKo6eEtE4ogohKBBARAgAKBQJTdhI5AwUBeAAKCRA7 +b4rxQ8IfO0wHAJ9o/4ljgESeRCGzzo3Z+f6Q8KEf8wCfXb437eJxfXG8FqVBjJM9tuYFDbaI +XgQQEQgABgUCR9vwqQAKCRAJVS1c8ylXkdXCAP9zNyT95qPdF6VmMVVDqPCJqJj9xjt9JIR/ +Meff7JDQAAEAplZpNR2of++X2Dt2ucTrWmJdRN8/ReEECAjX4hAFw7+IXgQQEQgABgUCU/ur +EAAKCRDol3WoMrZzBRcXAQC3/JD/ZdgewuF7c4y20nF3yb7/tAeVAbtz0gTVGny+qQD/W+1K +f1EAUaN/ABGV7cMgf4AFgmxtanlJYvlzBVYYXYmIcQQTEQsAIQIbAwUJFLCKjQIeAQIXgAUC +R3kaKgULBwoJAgUVCAIKAwAKCRDyrYWsHkKzZ0G9AODUHnY6va9Hn+jHchtAzJVEliT5PbX8 +mHfcLEAiAN9m90tWZ03BjiJMYnMiAJdoufBaSYbKCjQj4cwuiHMEExECADMFAkqJv/8sGmh0 +dHA6Ly93d3cubmF0dXJhbG5pay5kZS9ncGctcG9saWN5LnR4dC5hc2MACgkQBk5Cpu/f61cT +QQCfUhmXGdviNJOc57Z+fT+2ihz6dKAAn1MJqBRRXcclLDI+j9xt5YcK8MbBiHQEExELACQC +GwMFCRSwio0CHgECF4AFCwcKCQIFFQgCCgMFAkd5HpcCGQEACgkQ8q2FrB5Cs2eXYwDfUNqv +I0xrFP47l0+sBBD5j8Z9H9FygT4ZuVZOxwDePf9XYQuNja+MQUqZEtZbvilME5zf5wUMo3sV +tIh1BBMRCwAlBQJHeRfDAhsDBQkUsIqNBgsJCAcDAgQVAggDAxYCAQIeAQIXgAAKCRDyrYWs +HkKzZ9A6AN94mshuxLoZe6RlDMw9lBu3+Bp5/IxmC2cHcUwxAOCChhg8x9VMshBmGFD5MrRe +G30vWcqoH6Suqb5XiHoEExECADoFAk7C+a4zGmh0dHA6Ly93d3cuaGVucmlrbm9yZHN0cm9t +Lm5ldC9zaWduLXBvbGljeS0yMDA2LTEwAAoJEOdekMA5zDPbpvQAnjxdofyit2U94xDhG54H +EIjjNhQcAJ9a+4ILABpwvi2TV3zeN+R3zL+wIoh7BBMRCwArAhsDBQkUsIqNAh4BAheAAhkB +BQJSxYsnBgsJCAcDAgYVCAIJCgsEFgIDAQAKCRDyrYWsHkKzZ98ZAOCKv8GCOKFm6fFyyJRH +R3BAXsD4JI/j3x/8ufuXAOCIXAV4V3lt1j1L+lAN6PIDmKIin70dwq3sHLl7iI4EEhECAE4F +Ak5neHFHGmh0dHA6Ly93d3cubWF0aGVtYXRpay51bmktYmllbGVmZWxkLmRlL35tbXV0ei9z +aWduLXBvbGljeS0yMDAzLTA3Lmh0bWwACgkQ3oWD+L2/6DilpACgwV8tWEG3e8lCQmCdkEFW +VjQ4bqMAoNBiOFpZF63h3ScjN52hTOnUifIliJsEEAECAAYFAlZ8K2cACgkQxQjunPo22Mcg +0wP43puRIx2a/21FCv6HA6sYRYCdOXRzG/Rx7IuIScm+6Xyoe7S8qzSb5MbE6YVD/B0BKnMu +jvl91mk6LmwbowpV/g4gRUqMC467oABoLrNuIkmNSoMH2WzfaUFFEAxuaFC/eTvYRMRvurAj +KLj6SS/b55nA3rbOirTADM9bXj97xYibBBABAgAGBQJWfCx6AAoJEBvvDaCVV3PcdCsD9375 +qGS1wQdZowa9MTwITYbP/1xa0Ja2DRYMOnncJU6OzR+B4O/nlM3grJ8rN6qc3hK0CrIRkH4x +sPHYV0F8EzvMOfhKYFo8G+jXVTWIE3LAc/3XackbEP+t6/x5MCn6i+ZeEMArQhoBhZ6uHcZq +HFHFC5AAQTi+uhoMU8WK/dqImwQQAQIABgUCVnwsvwAKCRDcyM3QCdGy0FmWA/i0BcbWipSd +Hd/J/eM+wDVnNXBBnvcK2lJm+qYP5x7Gf7f+YT7uY+TXc6VNFz/cJqIQ5h6TDQi4/bFrzdU4 +oZDrSWYP/3HIdb6+BMmjH4TiJgGKX+SjFUm4MMA8IXbT8fm3OEX+8psYV8S476F6hfwICfIt +HYrTamGF5nHpxCkpiJsEEAECAAYFAlbpjNIACgkQ7fzaqWVs5XqpZQP3X/wC/YZ+T5RsOWbY +A+U3l55jM0Pnk7cIR4RtfOI2gArvICHkFizPMEZyKSpzgPa770Gui6ntBuj/26fb9bFxhM8/ +lJdrYYCnLWTItTjMeTqiwsYaT4gv4uZWisYAb1YVG/gWpYEVKZhe8zEJQHz/r4+jJfCfRCqz +zMr9Pz9Tt4ibBBABAgAGBQJW7TrkAAoJECDWTOA522fd7dcD+PIBvPaAhy4gVlJmbMQn5U68 +YZ64QoBNwEoIlVUARwjhsaKzwG1+gGQO6gny4lcKU6noTRcwAltB+yxJ14WRTNNnWNpv/OVp +KNCsaKGylucukMUGGpjbsYk1tARQQBq8S69tqbsCQvmkMB6iOUsxXktEHo74AO0kb+XCWVwy +2duImwQQAQIABgUCVu14IgAKCRAQf6QB3EXGRVDSA/i6VEI4LWNImV+YtVkH3s6qVIeumxlH +nL+Xclaby5YpApF9BRgiXdCbx+sUYipbJ/M7Zg2q9xHPA27R53U9yLBqBxVJW7BWseZjsKAf +kcH8lci2pcgCSKV4PeG2CPwIkLiZip/k2/6R53ZCHKK550FETV2Aj4GwJ6Jn11Rv2d/tiJsE +EAECAAYFAlbteKEACgkQeeiEkMVfIggj5AP4+R2kypZlBNiZcB4m871X84Y2mRDVBVE+1Wnp +l5bq3EUv2gy0C0Dq86n06xicvRCbgtmevmRFURrcJxGMd/PQCRa6NLnk5nO52dowRQz1e++3 +7fCrBYmTUDI7eqhSNW+XLYGJuTjlSnMrTsnxT+CpuykbLqKkrcBA+Ob6P3kt94ibBBABAgAG +BQJW7n5kAAoJEMmOJBOla282HLID+N0D7RVPCKmumnT/1FegjSusw8WkMy5fl3ixuHtwWTX3 +xiHfjMbTe9i/HNZPhZd87bGT0FbUzJUEXT8hTlRM+PXb1kJyUma49OqxMlr7P3NJ/WsUq1LI +6VetXMIjm/ocaYkphA9Ry1JHBh7rc+AsqCC51SAvs6xBJatOx1ECBeOImwQQAQIABgUCVu5+ +9QAKCRAP72MTWmEvNbtgA/jg32L+lGrrtDbmxUoR6SQxVEmWQY91i6UH0wJ6VyPdFd4uJNR9 +RXALif+FYpU64AtSQPnwjBXnYa7ByT6yZMxLvmZEnw0/pNaiVq8WEpE0xoonevozJJX5cEpf +bDeBHCyziti+3+SH2ImTr12rrqFf1DLElMa5+dE7gIZgOLBpiJsEEAECAAYFAlbugC4ACgkQ +uakkoTg/7hY+PAP4mJt/AaC6YZxRYAatJfXhukQPMgaBs8OR0hyzJmID5IyVBFLy0c4OvdOy +0fOyd+yK+JZg7TFGVmttw1dAhIp/P1mdWxG541btvLgXQ4OrGFrFK9NMcqLfSYgN6WQ67PVh +KfZmDhB0XqHpIhWui8TtNyhOTUAgkoZM9o1SeZVHhoicBBABAgAGBQJH3sowAAoJEOUVKCUz +HNpdxYUD/R0jNom1oNezNUXXGqrRnd4ZYVb+tjjgOCiNyxfEUp4kDEM3hoiQbPRWyr+VmNwG +UZpH/5pnmrQBB0jwUuxULk+4GhkAU8jkpjZO+eSQiIA8wThVnwYTnVVCMk8Ww5ziY7n+pJAF +8cQqTm894xkRQUc/yHJMLKDc1o4ZZz6O6P8GiJwEEAECAAYFAksOmUwACgkQ9U2K2oCCH+rr +VgQAp8Opm//OxS4zYAH6opvESIUglbDzlx7784albNBPwHftLNrQt+RHBZ+T4eZ1OyJKwvQU +yQQ/dmuPejgNf2aM2dhvfZIu2yO8m8R2V87BkXk306hG97dzXFIgZjjXBEa0T11FfRRZbpSZ +1lsDYS5XTR0RZo69t34+yUD8qTjvdReInAQQAQIABgUCVnwrGQAKCRDbfJ2P1xwCh67wBACi +kOcdIXcGUxTMFlGXhGG/eE8fbGFwbOFM7lTAju+jXEAXHI8ZuGSLou5EnEz1BgW/m3aTlRS5 +zi4eD32jFgPjuxMtQ4Hn26Lcq32AwRmeCA5Xn9tpDaxXbbusRBeEIv4xdE/p+qZdc5zzlnGl +CDoOnJxCAEwXfbxT27JRZY6uloicBBABAgAGBQJWfCsbAAoJEOH2BecyTben7b0EAN9za6YT +jTcoOoqOI15zWyVhskaMLtjRdFxPb5De4+QNXVYnnHMPri6IBwu9c4+KgfJeZn7QiPKFMP99 +w/MR//CFcmFZuN0+nheskw2Qc7ANIZ0TJn4Zzl8Q8c2KDdeaIcrowI9d/ma/iEeQpY7vGtRe +Nwebd2Mf9umRt9BJjL79iJwEEAECAAYFAlZ8Kx0ACgkQDpcviudNWPiOgwQAnaxPqZf0dYJB +niLoLBkmY26mSa32xHNmF5b2Qs1NM+iyQqDdwXeJuIU4GbZRXOyB40ujPbjPlANvHXOBvFIU +Ii1h2s1KfrvZz1rnsI5xLWnllCBQ8+3J5cJ/QBqOy8Lfa97YwatfyY3v/ex/IwLY4j1Sz/gR +dpF+5OKGd3HLtOCInAQQAQIABgUCVnwrIAAKCRDydeFOiMchp8sAA/4xa0jPJh2MztOP25wi +juOnKVZWcu65R7gjDP3mVNNBcgP3Grq1tfzLtuX+4ce76FiATWhc41a298n3WWmhsH90ImBS +E4z0/UmH+R1wLxBEn+q4sY6WSfhjsa8M2Pqr6M70aDQp47lz/i/+tZnobo4ZWlHzr77OKvE7 +i3GOpL8fGYicBBABAgAGBQJWfCsiAAoJEE111NXcvws8BBcD+wROsw8RZgMAc6ZcXhrTLVzo +aC+cxfGsN5OZ2BgN7+6oBVwjdXQdSEOlH+RwM7rDRSM6LiiYgx6M/poNufvOr78oKFBYJjdI +rAnQ9GkoxtaIHz5hkhZdnaUk0hkWVxyACGR1qTm8r8Vc1yWbppWJYkvS3cNwcv1KBah5nBdo +BxgfiJwEEAECAAYFAlZ8KyQACgkQ4MEnGKPqovkr6AQAnqxZKq5Ki2pC+sa22cl9AajhcLx2 +MYmHBoZ5VjQx57Hv+bVYHw4BdEHOEFTxbImCiCndVzA10BZfZy150/dcMPWIEDIgP+nczauQ +/qOTOTWiEO88gOTP0A79NXPlstktyyBEPiNhzXv/9A/y6lt00a3PoGTjlZVrLNmKKxxr7dmI +nAQQAQIABgUCVnwrJgAKCRBKGZqG/UrI/qQFBACokwXrmQv8okJAzVyLl5sUbUhsOD1QOPXH +c8iqEsLmkUWx0hqHpHU5P5robrjdte6n3oWqJOIl745YepvOh0Zmb+TzST3CKIo+Dpo4MrrZ +Bb4nrE59FfeNaznfDAQmdK1EkFSj03//u/8G4xxrqiEX5ej4L6fXhVx0NE8ZAlTxP4icBBAB +AgAGBQJWfCsoAAoJEAsSMFnezH6OD88EAI3VgSaoD+mOfJpkQe98AQiMsntzZvoABZKdeCK/ +FQjsPJ6kNPGij7hFVNLBNjg15dQG8JxUKbbdr2088itSbHxlJ8aRwN2NcnQCmfIK1j+0LL2a +ZFhYbqCA8Q2rwk6h94TPFr3x1xHyzX4kENBWiflQ/HHYwQ61TKVXcfGMUCajiJwEEAECAAYF +AlZ8KyoACgkQmwGTMemukDmSygQAuatHNHHzp5gLqGzMB+u9fIImgdpzKGi+EQOckESdPzym +z0dy3tEwRFu02DL5I2hw8UwxXEtavL5uTR7cZxlfPdLpJnPveplzKYL02e8dZz5kEL5DTCZS +fe9/G5ftKg/N7COA4Z5ehuWT1km2aWGBhHY5CCSUQRNaRHmqgRDedNaInAQQAQIABgUCVnwr +LAAKCRCnWUt0gGhD5sxuA/9Uky+si3n3wbBOEQetsVFtGdVbxH0AVsxzU+VVTGMjXik0gl2X +2RLkaI4RAXl8Ej002EuDdlxGiKdHvQujWgpLA3SZtIHgzaeqMRGB0bDjd5iXVmqemGdCFk/Q +Wu6tgwD4UWHFtjTBbYqOrk6oqSpb7RgO6qxGdnboKkekIGNFzoicBBABAgAGBQJWfCsuAAoJ +ENyAxDPH1VDJyVsEAJ0FNcrtYa+Jd290PEcgahAqDCn7lvT+qoPhv0fd5omMmjUTgetA3R5V +dpcER/jO/Er2zdW+4uFRwlOxY4ND3NFs2mqo7Df4aMn4KTrUWdKA7Z+FoGLZJnsz8zUy+4lD +Z33jxfxmjB0YjY8ShgcWc5E3r+y5G/0QfQz/4Hnx8lUfiJwEEAECAAYFAlZ8KzAACgkQwnlc +h0wh40L8twP+MTccit80YgVUbGyBLVu+xbPLwNzO36hq2L3Lftnofhza/wNAVQaEje/nB74I +xjTCpPMtY8jfGPoSEkHGHOUBlgbUnpLVQomf+CkO9MOR3DJFC5E+JqqWpZrwP2P8y9UcUqJf +VOZQIN8u9BiDoko7/GN2K4SnT5xFRkM2koJOQT6InAQQAQIABgUCVnwrMgAKCRAi8Hk+Iz+G +T8TUA/9qYqIND0DJ/DCEThE6pqJH92pcUs0amNOBVhmztrxE1q/xVZLGU0drNvSYiPGGlwIT +CsokMB3GLWIRSysy0s9qESBCMQ9DCfdxuVZqtj2lOf12jT6LxMucVsD698hQaVewSZbffd0P +camyPbJH7c07/NuhGlY4supHyMAO0AyVhYicBBABAgAGBQJWfCs0AAoJEOqrkMDzIcq1LpQD +/1zNPtxysVgiygo0g1+x1XR4gSsq1WQ/ll+xfupsRtit6hJ8d2aOKFh9aam4J2gaA0z+xIpf +fSMMRWjSWeszcDEEeftIqfSd1q6GBP6YY738vEVC4FNdbu92n3k95HO2YXc+eIl3j+I4sJmv +4fg3oNqHRDTSKRhKGxbUU0Tf/nqgiJwEEAECAAYFAlZ8KzYACgkQ5JjQiu9cyzZ6NwP/dQe2 +VworAlZdFo2TqNvBHPuHYmmGXydYoTcWzoxrlptaQaGu6sMkYXj3i0P+/3ScWtpeMYjpArNe +X+Ad7Fy+Wa7Pp3W7Lj+ctQe62C7xlClZQLaURdT8x699ziLqN4ssuczgH+5+OHyP3LZSdNf+ +ZpLyFNhEIbeeok3HQLlCpf2InAQQAQIABgUCVnwrOAAKCRCouyXYOhVSlLPHA/93dotlaIgi +KnWWkI1CAuCR9jvve4BJOTu/G8WfvPZZ7hnV8T9ltbxO9cw0NZdA6s5/qcELKl/ceWML/m2H +peIlUUT5J9NCXFUz3WKBSrgvUygpubGOMv7uEp1K0BmFwrWdEESkp/QLIv6fD52NYf3kNIpe +VA8kzn1MiTHq3Kbqf4icBBABAgAGBQJWfCs6AAoJEFDeenArAV5IhiQD/Rbs6trAaxfmsjYc +QJnh5rd12iEGpn/sPswYa0E/m5U3dl4PqAiNwsB/vKEbzoqwQrNU0fozCy7mJB+bk8LMxBHd +YsoJfPa/xyuYNmPzSjHkNsbwS6K9HSdK/Rzknglaks253gTyp65ArsZoMKNu4qlEkSezLy6I +wytZrL0aAo8iiJwEEAECAAYFAlZ8KzwACgkQTCn16jYFE4WoxAP8D3iHxntp9tr3/cE+h12g +G8Oju4u0voEXrI5xoLvEPimnd42oE9JhcoLs6WFJCeEQM0zeNFFdl3XVlLgsxsA6o2wln60u +AeywU8MU3m9T1FRbPN2N8Q1ZAKyunSyfXVb2ZRnFo7fXeN3WT4FX3glrACbbU8QbXbgy+uSl +dqWELzuInAQQAQIABgUCVnwrPwAKCRAlMQ+lLmvoVeBdA/9xT3wr8OX5RjFpF2dFALL7MDIv +Jy5QZNej5dnwACKOWBq0gpJgm1pkHlep6/L8PQZKk1UMGskAw+NY+4RoZzx9EXc43Fzaxkrd +mU8w/lsMyTUXbKUzh8r6IHePfQfccL6+anee06PYj7M/4MtzYvZj/ebmBf/PAhW8L9Joru15 +GYicBBABAgAGBQJWfCtBAAoJEJRlpCKhH2AoreMD/28ZqM6V2q1jGZPHoXl2+6CGFCE9EcTM +bzAS20rEe1z2BvgmjtVdtz00SGu2wtc/z2ZL853DC6vjVstNtLhYk/Fr3L4j21LYFe3nzjFv +TU4hwQLK9tzVcL4Qz+a1eIzKZ+WEkFYgi/eyE9q6DTdNlTICwQRycvQIhBv7TBkTQzpiiJwE +EAECAAYFAlZ8K0MACgkQN/WG9VJnqV1LqAP+MdFJJu4tTvzBqbdDIPnDYzwlz+9uFCbkO7sX +5/b2oChPKAwY1r4AmHZYqAG7N9ewd0IfaWT+3Rm97cX/LmrF3xG/+wmb6zLHuvbjfwx+QGyv +T8I6KKllYQtsG0ALlVQaAtge1pn97OlDinWkJvkbB7kgQCec2xZ2IdlXo6tYetaInAQQAQIA +BgUCVnwrRQAKCRBrnwqRNEuovsJMA/9gO4W/Y5xZDspmTCPS78v61zziaVXKIwoSQLBjYwQd +TdJM1K/VIwwE1cgTagUyilp3BFxY1uuVkyI6z1bNJ9NuQgyi8HvwsvoA0YRN1cRiTMeJPfIJ +fpBDQn0+Xpn/r35MnPhDSkah0PoBZbZ6yvwzXh++l/dB2WmFm1pTweu/uIicBBABAgAGBQJW +fCtHAAoJEGPwLXghGOqVtfMD/3jfAFW2zcg/tJbFi7N8RqKrfnlSyj88gkgB/3L8OVHx9qdU +sPUiVdLgLKXlHsb/M4LuXI/rhe03U5U7uZUTI1+xctOk6/ZfOXhOUY4Bye3ZFF0IxEE1MFgo +mU+ZpnctIKru2/iffrEFQmT3rre1xxj1L4ktIl/7Op8aSJJs8LHNiJwEEAECAAYFAlZ8K0kA +CgkQZyqzFf9gLnGHLAP/fHdJvv3aWgjpg4v87V3JJUzFjw7HoTzCRxuFhY4xMrz0t+p1cfUj +UpTklfvjfeFZbHGrw7xCkdkoyu3/m25WdLv8VVV1/grxcifxMkK28PhM6mS9JTOqKIkZaXBt ++iuIjD9rufFrSNRJ1hWXcWQJiMUcR7t86AwCuP16pWMaar6InAQQAQIABgUCVnwrSwAKCRBy +b6G0NXKrfzu3BAC8oNOuVm3PI0s6cHktmpI0W6/HoUM6GdX/Mzal3Beemv2j5qRzFTzIX/mu +epwfUtgY+Frk+t0Gw2fWq3ylfljAvKyMmpXjbW4upngL1U0+udwKbQcJw+0kfnL2rkB30bU4 +9yHgZFxVJ8PksYU4+IQtNjdgpB8Unks69RIZ+aRaBoicBBABAgAGBQJWfCtNAAoJEJeM6Fmf +Cu1o+X4D/iKJ8H775Rq+ht92B+0nNXZ6sMUKJuubYlBobl/c2t20hAgoApAtVLmXVaC6mgTn +vjCsJHgpPdd3n9j1GfU2y6qFrKs0V3XurO4dXHZWMXENPwshzmHHQVYCucKGDQ0iv+t3MiO6 +skU69MlBQSKgJgi6zFP0jYiM+l06WHOV6vUxiJwEEAECAAYFAlZ8K08ACgkQbgQ4GNtg4xyI +6gP+NoudMNhpqw1G2fc2UeR0Tub99jTFRwxgBrRyz/pfktNoL5Rsjv+g2/3OfAn1xCn+RfMF +yM/lc01dLtQAbbUxy2v5Sp0KpPPlYXaaqsEQt2C/D3k7wlmy1Blnp8TjPu1VIw4+B9fnogop +hbyDViT9RZ/UmR9RWxdTUxnI5xO5MvmInAQQAQIABgUCVnwrUgAKCRC6f2b1uds2sm3mA/9j +D/Y78jLlzbPIBHnd0hrjzn/pZC+sjNbpJySzmTRb0yyBtFJYGdhjnIDNSvR8whzS38lMq+vS +4UbohYVM3dMI44z0BMJbjm32XVBjcY4O683y1rXBNDpCBm/nvpLSSPOiazIXBv4kICGLx8TJ +CHrfvMGbuYu0v2TCokUuNBTq6oicBBABAgAGBQJWfCtUAAoJEOckpuAU02tm/6sD/i3wLPVP +66rTb/jnbMYg99DHkD1YiRaUDmEgrrPP8g05cAsI5nc2fMeJ2Z/tZnXB2nTgfdnluDIeVftF +evr25ldvIjtPR2/dMToq2Mgw2MTFkyCF8DYFsJ8aJ1eKIAeYI4KRDqeopbOGAfcvgel7JNe2 +h0Csm5WSZuFyjG8XJ0DliJwEEAECAAYFAlZ8K1YACgkQjoj1Affzuzh8sQP+M6aGFvf7bHNq +YNrqnRyaobP1TjLfaBfiEs9DhSUJQgiZ2VMHvwlf/5bxaM8ZarQ3LgzjkmGoPrChlKpssXci +z/Kb7E7G6m48TlQMEPZPriApVYudmdb0OahLeAYnYzgSh0wHsAVWrPpyd+2wkl+kFZLXxUDo +GkSZwOFbRlv9ccOInAQQAQIABgUCVnwrWAAKCRC8vivzX6Nunq8cA/9NlwRZeaseRZTflCL2 +glSadOjCMa2uvKxRWtUe3JxIpqxYKLDs4KQAJBToWUc/DIHrUo88/IMQ+DAEyRZrPKUQjk9I +84I+jYBj4yvJop77sXFuOUTgvSAE/HctI23BUG+9JI3pbB9nTPsl48e530R/aZnhQXu/746M +75fpfmUwgoicBBABAgAGBQJWfCtaAAoJECis7i0+cOaumocD+wYQ5sOjBMLhS4jnRTu/GeeB +pXxDLte6RcbPiF5jJJjJmPYaTzoeRlfKa4GqQPPfVvVfqzaH5NjOvYj8LA3Ca7eebPDwAx2O +GBQWHwGX3hDdsEbafkvHcRmvD0MGSjzNlU98QUnpleMwZCIvIQ7UldLugHo2bJtL+qWTrewY +KxDdiJwEEAECAAYFAlZ8K10ACgkQCypqfpYSYpOIaAP9GIM0wDwC+8QIbi6tBtUyKDD9tUNa +TA9floRZDxSpM3CsxQCQ4ajREMHACnYpMGpyoy4zy1uOL18uU7przZLJIxNrDBnkXgu+0G6T +clP7SnDcNjFKXcKueygkUKsdPVuvQn6fIIm6FrPd99YeBBMQTeYdNX2StF8avy8U3WyG4dKI +nAQQAQIABgUCVnwrXwAKCRApmAEZK7tG2kKlA/9gfTF8fnkC9+DwlyohalOxXPUgkEeaVWW2 +VZeuWJAeXanOyltnBrzE0ETy6rl5boKTlGtaRlrJ1P/27qkQoM0ES7UlqvUcsG9XgdIw7OY2 +4tEhvSFvL2Fk1OaLFO4KhEA7VOPGpYCQUvz1ioAIX4oxjVy//8SyqBSH44ZepYiLO4icBBAB +AgAGBQJWfCthAAoJEF8yyjaYz1nEt0EEAKusKqaa3UvrY1vB79wwDgo1GdK/8zQfzLtmZ+L6 +ucT6xJLUYPkf8kxA2eGU2wHAKVuS/+WMuSSdFmz3EZ46yspY4aCP5sqWhVCh+HF+1/xZ3JUx +n5ESTJMzTWyGqTE897p/pJKJKjQg/8lwtyYckkfB0wcWlB0EzLRQOlAMcx4PiJwEEAECAAYF +AlZ8K2MACgkQJxNVTwQAd0wSuAQAielXCApBDdh/oXmLjLvJElLNRHkCbB/Vqqkuv23D/7Xv +vrVhH5BaNw4MnV3aiv0skeA2xfH4RmjtCJG1aUIOsWR1Ybe2VswwmSMNLws5iRUaOTzN/Uh/ +aXZ6CTN5LPGJKm626htpy6GX8Nwvhqdp+A/DM4rlXWcqj+WdIoWmmzWInAQQAQIABgUCVnwr +ZQAKCRBsEhDdE/MyaQvNA/47ChGJErO90KE8fZ6zwR77qBNmeGJPKnBL6Bf+icnhYrVo+oip +RpnoZM1P7ck1DsBmyV092h6uzPnxntXzPrxxUHrpG+uiW2v14jJwFj4N5tca0Qe7PV4GU345 +KF+T1sr9hRZ7sB4Bhp62DaCWEtOXTN6bKOiE/zGcTGiAx4JFZoicBBABAgAGBQJWfCtpAAoJ +EGtl02MmaCG0BS8D/0GCfJEVQE1HdxmaofMiXAvH+kuh4gql33wixYxatTm+kSPFwNQEUWbz +duoCYv3Y6mroXbxj2ErYR0H/jeHBhW7JjrjaPc2gEeOD/uP9tobSII/i0pOQa26D9DIKHg29 +O12k0QGcV1gvI1HYYI064xpZ7Itk4QUvfT77KxiKhO5tiJwEEAECAAYFAlZ8K2sACgkQyOHA +/43pgnwO6QP9EDO96A9q5acNqJqYDCOovL9pWTnjnsiQ1UF/PyfILnksFNv4Ee1zL4qByEPJ +oxH8Ss1ps0AobNTjY7vEzHwV7xUAyDrdvwmdt9DI5/H/dqpKKWXANQPh6ZlS7A9+NGbx0LWP +sS7gsvF5QVbid06zix4oxItYjAExdAxXKYpY4XSInAQQAQIABgUCVnwrbQAKCRAL7EsqCsZi +t7VSA/9dSBInhXiNg6NYcizfc1g5XxFBO/5ktchh2r9EuFlQIW43DwjIqx/0aiTDB2VTrY7N +O4bRhrN0cLzpSnTaRLgtHI84m/Dkmq1BL6C/8i4xwba3he+0tiLLUXYIwt1FDSgocJx4kUZk +qPsLkHdwzYxrhX/3qE+7NU1Loy1sd5RxWoicBBABAgAGBQJWfCtvAAoJELVI46DqTYi5JvcD +/0NEC2X3oFrcvT6UvhaKL6K1/4aEjmksLpexWJiYzXZJH+lWTFPJIHWGnjID2bk3RwA5/ujD +Ot/EEq+fxEpcLfbGzpwSCnQZhaUcMGLOP9vZiRQHqnEx4/IumbxxiZPmnElLldJ2LYCmA3NE +/cNecN0eFbVvco9d3aAMwD1v2912iJwEEAECAAYFAlZ8K3EACgkQsOakg/IgMgP/8QP/e9QJ +FeA2tIbmOKvKxMs9mk0cxi/CJaZX9KM9sZ9i3qSwI2QPHsUNy6AiMZn3RqSRgm9dyEazal7M +OrbnY0D75KMvXN55BJGR6kohHn7yE7CFJ8R7ucwhLnwBuKsgX2Q7z3RdGMG1ibzSlryoByll +9J/rRzY3IF88EqwAydnLqAaInAQQAQIABgUCVnwrcwAKCRAUFRCC7vbFXqzbBACLQwcB+eXo +9M8mxC7bLcvikEaRCRqI/BjSxfJUHpexBeQ3p/n3VRaq1HuxmdIM2wA5jJ0ZxDg0Vh7haK1E +JagPSt0PoQeRidPJdw9CUlwtYaAvFwmfNncX63MK2h7DSZV1OzrdZqVmyyC9PdQFNTQRwgt+ +aSb/PR4Z60nqPG8P+4icBBABAgAGBQJWfCt1AAoJEBPgpXqc8H+z5hsEAOHQjffTXqUOQIUq +wELPaabYjsN2rL9Ir+pHa25plrOGNqVYax5yEOz87ocb82EDs2+Yo5OP4DvUYE0lEECUHoSK +jYfBbbCxPRPld1/xt5n3bg/XmH0sFarfgIQtlk9Nc6eC7O/3utCeECoQzleE7ssUTj50tsq1 +erKd3jRxwxiAiJwEEAECAAYFAlZ8K3cACgkQNCs28Xa3WFwPNQP/TC+WnddRGxvD/SlanCfZ +iCDvin6KyhqICcgEwsVeUdt8qRUx8T576dmoiYF+a/VamBB9CaE0KfFoL7y5zu9dFJmycPx8 +Ti8P3SYkSXaASch16PHIKhrmeqS7i8DBcOfHH06Jzi7Shq/Jf1WLL9fJbmdb3/43PdvwsVJ+ +WIoGjQSInAQQAQIABgUCVnwreQAKCRDU6KCBcL+oeqM/A/kBGZU31loS3ODiGIafaGFSj2Ac +/1WALyHs47UiYE4XugCqR5c8UVe/Hkn+JtlPFF68dYHltWCveYMFN4JwEIVaxUNYJI7tUVlc +4XuXEYuU2y82T5ZM86WXPZ82wEgahtnyKlQv7iWYLZMlw1vA9QaxzcYo77f2TCRFZDsAxYAn +OYicBBABAgAGBQJWfCt7AAoJEPtydZobHMeGRKUEAM48kwiZdENmZ1VV3XuPxw5XzeithXxg +wfVEg7kri/R4aVpXysVngsO7vrUJtMou66qzMVp/aMnnzl9E8Jxo0x5FH7m3gDN+Yh5oYNgx +06XN+uXmKMe0OOFd4071yYzUkqyzRlXuVpy/A3lJZrmNqL7EMrHN/K0kjbNIWwFD+quyiJwE +EAECAAYFAlZ8K30ACgkQZs0qhUhQ2h4xAgP/Swr37RvRSkQPBOxxOHwCe40QnlkY0csGXNH/ +ZroKKAzXPMxl8uqYR2aGvEAPg1YOWspx7NKUSfAMrYUwu4VMMLjMmyPs0Vqma0EJ8Gf19yY2 +1sT+GW4cH610RBuAMmG6/L60KJ/pUJqgxj6Y/4VjK/0I2TZcARPgVGgsaAiQJ6OInAQQAQIA +BgUCVnwrfwAKCRDZ6i+jbCttO9gYBAC3a6ehd4u2HxIri+VAoF7coa/3aBGPderErt9jfdLM +Ubc4tr/PqC0O4rhlAg5e2cKhggHGo/OiKJAa9ywEMtzZrZ9tUuT1OBNtqgywlx5Rl03VnENa +cs91ZrvqiuyxZRqoivhgz8wmIvQAa8mf75Mu/L4eJ9LmklI+LQYli74304icBBABAgAGBQJW +fCuBAAoJEPuvP8AEIB8dV0ED/jmDNiLDXMsCvl/UxzyED60FeDWSMCde1gEnTDfJoc4ACHHG +UPCIHJXZKAVzvpjjRBigk6t1ExrILjdu7dAjvBN8eDxo05rMFyKQ3sKNCIIiZHzLYcHtJxry +Ezd4ymKiMWAHocKZXZ2VLrziBp5dGrTwDB0Mftyipwgzl/eTWw3HiJwEEAECAAYFAlZ8K4MA +CgkQwBA1GuvBfXed6wP/SKAM4/y/fmVvIQxoL2V9GifwbO39DL1MeSa/p9OhHdO+WorybHWp +MWm2NbY8xdF32584wJ/qmcOiYjonTfadjX3e9Z7cTxuYAmfaFGuI3iUTF36jDoReJjYBvDdr +MQCid/QGZ1e2asYpdU1VUeEvE+m9JziZJTd0oV1BAQYmRl2InAQQAQIABgUCVnwrhQAKCRB6 +Ww65TwNW0ecJBADwXVIGLdJeqKuHFdrwTSx8K9tBdMdRVZi3mcFgS4s7NEtN+hASOYyDgF5T +D3oTepmEfRxQVVg/O08fFvxM+RcU62GcLSogkp7NgO1U/2TjqVsXoUDabDZplgkzq4KI4rJm +ULEV1NbIl7rcaSPYZT9JptZAFT9vIDUA34UkWmff34icBBABAgAGBQJWfCuHAAoJENJ054fx +PMidJaID+waSk0Kzx9cljG07yd5idt2D1ntnazRY5EHXQiKAz6p1TM0/m2w+jMYMc+ATxPHh +m95AE6ZiqVoWFNkVCGxWy43TeC0K/A6/DYLZvGnKj2dwZmiW++W5jYjcFxU7nZGGRKaVrVEE +lIew74oWwvphyRFi644CRDtSZis1zkkAaND9iJwEEAECAAYFAlZ8K4kACgkQCfEA3tOO5XA4 +OwP+KpWVO3m0C29KUk2Vu8yUWLL6yGkxB8wZ21ERjKV8WAVrapBDC91is+qtqsQhl0hssaEv +4IarIZWzqpphxduPylaGYhHhuAa8RF077zkw1mR7wiMb7K1sGOcg+tdOdKtK9C46SV7IUW7d +hQ4++WBd9PnNf4WGvEFThLRJbo5dW6OInAQQAQIABgUCVnwriwAKCRB88GhVSssBdvRXBACo +o2R77L1wcK2X5imhY8oFg6H4FY6j39debSBn7TkcLxUS9Gpywq5CNFFlYPB54So6ejctXXgj +YeFFKhJ6APRU0WnB6JIs5c1zCWF9JbWW8tJrZrDo4dQW9xdzizPfLst42dZjMRrZAW4rTijf +8aC4G7ieVQB1o2QAu6Wt7UaotYicBBABAgAGBQJWfCuNAAoJEJ0EfDGGyczGpuQD/2yy721C +5utLfED5MOvQYJSpY0HD5uB50VilRlBoQ7JQmLVplwCYuGy7Y442FBQDsQenTLKt0FY/qaRI +1tVfyBukx5NSnm0qqjip5wTMN8iN4PNoI36w8KNTMEeo5KKWFzBcJjnpDy/yheFOVgN7dkq4 +oAEk7zMzwbDkgWOugeJYiJwEEAECAAYFAlZ8K48ACgkQ8NEzoVsPUi3lqAP8Cezgyoes7Az+ +NHSRyilNpFks1NiKK6CAn2CjW8ZlnXhQVDxizy8lds7TC2mmulamf6DZ0z94M0pJ5g6LWAxJ +AL8c+SvsJ/R6YJHOKxPGM0+qvHUCPFpeX+TaIF+y6nB4zCx34M8+ttYN2iJxsOK0UgpEcIvc +t5s7bLanB04s7a+InAQQAQIABgUCVnwrkAAKCRARBVlIDilMXRpeA/9UZJ843+wPZZ2xbES0 +UEi0uFOOa9IGP/F7qhSDS0ZJglWDByx9cp3Aexcrm6iS5pYDcO8pC4g4/Z6dVlVkK6fAnUeJ +hkVl+RNa4fAB2w6nv3W87uacvDEDNoVH4FJXOr9zDgo+tZnqwOJLve4y/unLAXapWuUkal/Y ++0hr/3mLb4icBBABAgAGBQJWfCuSAAoJEP1+39vcr3s3vc4D/0Q4xJGl8c4DKBWbWnmJeTHo +Vogjpc+UMPY76/0ngeaS7lqLa863zzb6qLwqmEIyDOPRFOaPtowkIroEAw2vpJQOcFfTshpT ++zuRZuHAdnDRfewobh6N8Y3Cazln8KLKLzTOjIyEanN5c0iF+lF1AhxAppdoGfuqbQCieWzp +lOXaiJwEEAECAAYFAlZ8K5QACgkQuFgxExNz8b65/QQAp+FXtEnCIm6EUvF+61cuwlIkV07T +MaW3hmz7m6w1ptukbzRSBI0b6OCYP2ngC3fcJddGlr09TQrA3VW8ybC8jPx1QnOqLwrcYBHY +YGAHw1CFgCmxylvuwKj79xXIGN9Fv5wJjumO+3B2o79v+6R+3r+U53/pEEjtuVm9NELQ4bCI +nAQQAQIABgUCVnwrlgAKCRCuncLFLyUbCbIKA/4pgVEYIcwPmqoQwAX8Jgp96BAQZthmxBRo +i61Qwi84ikTb2FsSKHcLzkiD3cbt/nlJtPQH4/J38nK1DP/rNqdQg5gg2ooxkZM2j+ITmFIl +XuSeDrJHlqZlWRV9yGhAoO4feuwNNvLEwEfxqfwDGj3IQmzrHGDCrJUDdpuUyPjTl4icBBAB +AgAGBQJWfCuYAAoJED3m/FS48Ka8c3kEAMP88foRf/EJknjCqH3DNPcfffumxixF1Dp1Hq+Q +SYWqaR1zNZS3Zv13N7gfbXPkxnCWESe5dVkaR1LlF9Bp+AfCFQvM+YLp57dnLXr8sAXkyDo8 +rTtyylNoY96AiHSlj0lmexC04vqjlki0TWzz9HKmhcmhuOd79V5k6qiEi368iJwEEAECAAYF +AlZ8K5oACgkQKfHWNk7ngAyldQP/ZRgo2B+XYxelIOd7BVPzxsa4JB2RdsD9/hTTybgN+hec +qZcx9BWSks9/VSojKvlXuMX2kFtD67bzplhThCJPKjWWK9ZmW4qpTenLGjq67w13FmbaJEtB +3GmfjUq/wXEaXnql2xynoiXOOmj4m2jWQFfi2JBIDTZ7b4E8Mwh2C6SInAQQAQIABgUCVnwr +nAAKCRBUOd5VlfKtEN0UBACPZWj7Vx1DbGURicCWXQlHWyI8Cpd8AHz82sssaYMnTgnqaEka +xpa67rLTmy98ILb7VQWGBooIqXpph93nBK9GIo8xA1khvkTSLiNwpvBJUHjoB5L3xm/urmQC +s/c8ctOUQvRUB8VZye0E4VAiOFpbPbkHO8b+mATAHFMuK/DztYicBBABAgAGBQJWfCueAAoJ +ELAoMpoMFhG2Kp0D/1nGaGRHXonHsplKBYHM1lBuPDEu0qMZqnuPPhvDnb9YrbvSnsXQTem9 +JqFVupCnosCG9sHui+uyviSilZa5Y3QMY/AOo+p5H9MQqSwLTtzqGuL3W4Tf/iktyBplRnXg +v76mfvUsIepdZERxyW+ctsOg+/HaE6HDCDIaahH83J3BiJwEEAECAAYFAlZ8K6AACgkQKP+Z +H1D+O90yvgP/Xn53cjXTSPAE6n+KB7fdAv0Rm+8oFFiJh9pLd1tlGBu/yRFNJmKKaiEYNGIU +ptajZsbCayobqcayc30Vi69zUN+gML3usBo3L5aWbqfVUs0q+FbO0HLGQlSZpJP2QWG7tg/U +eyaNAB0CfXVNMMUIO1pLVWqaCF0clR2jqltlc6yInAQQAQIABgUCVnwrogAKCRA0IYPfO3Vh +kdNiA/9L875pWTUrXJ9qMsrUQmfLKg0ACGFjxYAFvFlRdLWiII5QdF7sxZ3ZRtjc90cTUvJG +2Kt34KgjtCL/xvsEcbRCZxh8JTXq5IK5YH/iNegybYVFsJ2ZBM97ERZRAJY/TKNTVoQTHBhv +wxo1xZypfsE1g/EZJUwCbmCF5JKJNcqvDoicBBABAgAGBQJWfCukAAoJEKT/uzvnRvkNbc4D +/A6SvxbNmsPtAXh0nBT8wmtMMhsSLujXlK+Du1Jyp3+x05eVM3KK6J8/kcOnL3YHPFW3My8j +AeoByq2oBaEZnjo42Qj4LgZacRzzXog6mLQtZzPGxOO6mI/bWWvsAMigD6hdXgX6iBoLGaDS +fwT3tLon9gRGafi9V6Ylj4Vuyan9iJwEEAECAAYFAlZ8K6YACgkQUNBFE9kTuScTyAQAwFJf +0gpukTQZoIC63XTADOWPJlT+v6UQ9yzcVMbjI52D83fwGswNqH62Z1LFPWnXWTeZGPSql/iJ +eEC5Eu/8GEMzfEiKKoyJI+MmG+QNUgHB3wmJI2XnDfIvbF5JbZhg+HTHoUiqupGd9R/NcEii +vaxlUHbC5A+Dfn6Rrr2jI56InAQQAQIABgUCVnwrqAAKCRD/LBTzJuX37e4vBACQrOSYtNik +dNsJ6fY40rpL5ImGnnkAfFmQo8cayg6apS8JP0q8L8GzykT4aBnbmjv1MHzPCJQb1OnSRNJC +VXj4cNTT4e7Rq2eK7ny1nwfg1VwiZZwto6C8vo+keoyeixwKIADwl/j68N3KaHf3ARPnESC6 +HxXnHo9ZGSgiQtVhSYicBBABAgAGBQJWfCuqAAoJEHN04S67dYq6JcgEAIgUvQkftuRlsWlw +6HHi5rHELeRIIy6BC1JrVzsdS5d7olPGdc10eXXle5l2xiZkS2epqge0wJsCcZRgU5IB3V1z +RgMmqoPe0Zl46bgV2BfDwFyMKDqcw42T2RLo1AfiEpu6FqSNqktZOrx/VjjPv7y+eRAU40Ne +qoLziKzqYeQViJwEEAECAAYFAlZ8K6wACgkQ5DjRfcUpUVr12wP9HCDa0c83d4IzZTmm2UGz +hddGTE8QhCbAVBcDIxta2ZVDX51SGzCdEfcV2PpToZzsHNHiTNFIH9fRcD3F7VEFDOy0QGR8 +0ScQFfcpkxoSztEZRSSzb0/WNn1XwlqGeyUgFTQSpvbVvcj0pBVWorFMuUw0QID9hetABi+I +VqS4DRGInAQQAQIABgUCVnwrrgAKCRDxnnj4RSzZHW3cA/9y9UUnErm9kjlkL2WfXxTp6Unn +wT8WTx5nd2uCQMqKA+cX410DrwaibXTZayMR3p8vVN8NzyHQcMHCb5D67QWQ/BlWOGvt8ADR +fC8YbH1e1YQd1zWDWXNrDAGleM/Q6m4Zb8JGfF++/AOKn0YXs3xuQY+bzh2HSKjrKGSlCNs2 +5YicBBABAgAGBQJWfCuwAAoJEFznmH+4d5okFpYD/0z5HZ6kwmOBxFifbCS58iEd09lcfO5Q +K6m5e0y1K+XRCvKsA2SYucJMwWUQet60KUV+M6SQEH/msAl6Byf6lTOc3y0RvNMW4rVT60dN +XpEkDk08M4FpQsqE0/lSbQ3NIxytFayNTUu4JAV7zYfJfwAFTRMS+5XMtWBPLEHxTXMJiJwE +EAECAAYFAlZ8K7IACgkQ7aHPC6dRfO4vsQQAjPBjQmQM3QEUwpT2u+uCGWVTtEs7PDUt89ha +KDEs2bTS/VRU1ugI66azXdPqEM4bXf/Yt8S/fo5vQYGRfbzXD1it8vTFuGYw3dMCx+kcjUWr +lIR6xFihBvgeB8pfiCaRnV5eFFB497VwJEnLSXKvp+/IfLMbPembrsJQLTNirnyInAQQAQIA +BgUCVnwrtAAKCRBAtP8OGbTj1EX8A/40632wuh09a+oHR5bzy29xQrmA2FtUkUyUR7pmzODj +DYiP/cN/QaWelBLGspAi5WtAfmNA+bsNjrO3qbX31wVG+t6kyVNemlx3uOPcYkGkULUeVpU0 +Qt2LC8EakeoQcYODw44r3MLDC0l/XlQFw13iw14QWsIZHz3HEtdrd9C31IicBBABAgAGBQJW +fCu2AAoJEDmypKrI+8OBe1AEAMRS3/dpg+oGKnpa6zpZrORa2/tf+ls1uYd6ATibNkqTIYlv +Mg2oO/c6G5fWxrprBnvqq5h1TqcE1InVaDcH8T63q6gDxbiv74wgPK808oCjBcs5kX+EAwiK +MegDLhFeAn8znKMWpN00lmlSDBZ1MlXVc8LG9Nwpoqx/wEBPdBmOiJwEEAECAAYFAlZ8K7gA +CgkQqG16CIEVhmDqAAP/brV7YinfdgcJqnhkfLKiMocZPmQJ+JKMWAVjZz4UIwipCSfJ5Nst +Z6x+3cj5h5DQnqBd97YrXgok2VHsu/GgbnBjqXkYHZvWCa/L05zf1xaTPJpJ/QmFnzdf6FPX +jKUInyRQZ/nqw6aazfft8HzZqr6TvWwjSiwNu//Bx5yWhbKInAQQAQIABgUCVnwrugAKCRAs +Pl/UO48xPAF2A/0SZn0f6tS6UaSbuE1wVA65g0zC8A9wWirRyL8NwPZvC02L5ppt4oHX4/Q3 +33fY53DEjrSsHDp8ig4GCIwbRjMMPEG3KQk4BOSHBKMwpQIrPrwpe0qsrfW/bSaWrH1YgQnQ +5iMmIlbICZnMWIGYscOv9ByUfVF+wvyg4//1S20ToYicBBABAgAGBQJWfCu8AAoJEB5eMB7W +6AkWWMUD/07wOYFrmJ8OFxe5Sq+Lqfpw5sVgUTn2UUAvjB6jPunAHY7fgt1q7kU47hzZ3uhR +BSnkYP4WReTPVO1uXsvAKFNj3DQvMWSIyuMeA2jiaZ6u49atrLHbVEOyCh8BLGvwEURIZIie +FzQkBIxtV/8Dq58PExqJ+uyg7EBK7VfOIGjgiJwEEAECAAYFAlZ8K74ACgkQlFGJ5VaGMK1y +LgP6Akg1w+4RY80XOoL3bM1KAeXt++0Ev9PcLwTPdShbmo6nTmVqO+UNz5kr8qL+3Aacy13V +WUB+7CGOMaR3l5KNsJvG48CHXjpdxy6DVfpvo5BlA/H005Ry6WwFfkO5NhNN1KqxaxWYn3VH +1/Ny6XqXzJolnUcBReP3/EfJgn2NfhyInAQQAQIABgUCVnwrwAAKCRAYCUBUb+pjp9pFA/9u +xnOzQNnjK4I2YdXVPaHBbUpxK1cmlO4JVoIXxXhqUn2Wlae8zhj4QaH8tOAVt2sCYwelaUum +XF4ObXBygZK6gk35/Rybn3Hp38DM3jtXsY7gb5nBbfJY5NalJiKam8A8ReQqPQHxeAqKSGLN +cU8iwmlv2QgoIH23nWkEbfNEXYicBBABAgAGBQJWfCvCAAoJECO0v9SnxsA4y0wD/1eLA5A6 +eJOCPi2s0XLd7/7Di0V13WXLkmEVUT6YeYoiku5wNfs2Lk6IwiAJwWpxkTmxkEg0b7OhwpY6 +scPY7WQism9Kdd4F32+8mtpni/CiJEHOmvJEuAHsN4mlR4yoAoFnABM3Zdm96yVjQP9N4vTe +ME/7hot49PDxeI3nPda8iJwEEAECAAYFAlZ8K8QACgkQQjlzyrFZaaJRtgP/W1fvu9jkhHnm +891Bzt2khMrMrygz61i2kUM7kPsmoIJLwn2L/tXvBzzZJMA8pEz01G6Hy8xF5t1/oi9XMxt3 +e/4O8TIiRzh6+xJhfC2IPJjbnx55aonShyOUGAFvjOz+4fsqxvMh4p8LN3BFGIOj9wMTkxA6 +0GZ8oavdcEAkDxKInAQQAQIABgUCVnwrxgAKCRCPMh25pzHAXzfxA/4+t0woSYH3cwnXOYlk +bf4/NXX/Ql2IUojj8Q5Nyx0ixbrRT8EZLEohZgHOK+up9uEHwBrwWQmGLjm/fHtYRl3Ssk0w +OkYB460oihaz/OnCj9vSDzashCb7Vfib+4W6cA9n76v2sj0ou/EOiKkCqXkjkhPjfUiFioiu +ZwyGO64P2oicBBABAgAGBQJWfCvIAAoJEDzEdDNrVNvmG4gD/iqr0jh9v2bZ5XUreioQWg1C +9gPzipapMvDVtyoRBFe6VQ/piZzLkS5ky8Pf9QijJfnabyrdMvE8i03uRFA+l6A3jF9eQZMQ +RLJlIdZoGb29ndQbPiWX7PsNuj2gfqbPrHnSt385+Ag3MSGF67dz8gwIZUJbcr8NZTVFEtwW +CyG6iJwEEAECAAYFAlZ8K8oACgkQ2drtE8juJ8fFwwP/eRQ+SQLoy0520DD8gmEU3O6WEDWJ +FDqgzLZbk8u0fSQsmtDc01SCV/eYjHH1WMB1Q0+s6llfh/ZOnJeTJhGLb1B9XUVs9XxO4Jiv +s+yg60DW21hNqF3t4xlleNZyqfwYPpwfByMO30Mrk8wq4ubBPz9QwMbpP0EnT1tAj9vbQoiI +nAQQAQIABgUCVnwrzAAKCRCKr/bvbmS4z8PjA/91p8+2FBKKw1j5mWHE3Fyy2CVZw1FfgNis +584yeEsB1uRG+84pqJQl8skqplBN83lrffew2kaKfX4VZZfHZB0S/Klr7291OaFpPevubeDC +XBilI5r+qb3MEXShwB8l56ZNXuZbqO08rNBltAnFFuYEZPN44lGdBCl9QG3ilGHbAoicBBAB +AgAGBQJWfCvOAAoJEOzdWoeF7awNYHAEAIYhDZ6mcdYdzsEpyFiy3jIdWiukFnouUaznxUw0 +jhxWHwZdgs40iBUVwOeJx52TStH+rnLBtfROsmUUkgf2Lfb8q4gIXVRN8e84SeGPOomW4gpX +TW5WskCG+9gW2DuOLyygBwU/AeuUxoy6QoSJ55xJIhKQusvdf1mCl+vna4NciJwEEAECAAYF +AlZ8K9AACgkQUn/Nnvgft/uURgP+M+DEHj1RWqwF/If2Xt9ZN5idOCGSkDkNwP7+k1u36s74 +LVuv16OgTzdlpPJxqrlDylUUgRHT4xLuhaIbTOUnL51+XQQ1D6nayrRX/aJJHNRFyy5zJpLv +u+0g+A34diG2/Tpx7S2d8gcxp7hvip6T2/BJB+qtXMLgOHpUu0HGVBmInAQQAQIABgUCVnwr +0gAKCRCA3kencVfXYUHpA/9npT/mmaYlk5do0KPYGq36L9UtPQRsr9rBRluFbG+MsyIW7eVm +uaPs16U+qgEwxguBKk6GB6iEKBLXR3fTKqbWUEOlpjCjoYrVbkGK17dhrL/HyoWcGfHN/NQJ +fdCnOyf5eOgpnaC68ZDsdGQUnXsaTY6jb+0eE6tP6sV7bo9nU4icBBABAgAGBQJWfCvUAAoJ +EJ6DT9tAaAX+VLkD/RkYq9tlAEDmErL5pUnKd0Aotkf4ANrwo+PFvHILhIvnQSBsBEL7CAmJ +pWHmX5iTkfPnvlz3IkxW/WRDoLuZ2H4DyRWVru5YpPSJOfvRfx+CHP/ufKt/UQqjxWSn3/vU +E0H+DnUlfccVSAOOd87dqzZuMio6AF4nEwipXTrcASFNiJwEEAECAAYFAlZ8K9YACgkQNdK/ +zHDXOG8VggP/chgJjDLRWo7r7D4AChIaxF4VuXyqUxJkpKWC8o/2LtD5gKQkPfExzIOh+do5 +mujkIgCOrWDtd9oHMHpzhRcGXV6vvk36cV102YuY7SOXqKuxEG5/hiuuwacH8x+PzVeJP1Ge +G2fBLXOl6cJfbhG0U8WYDV9963O0d7DieHPJyQqInAQQAQIABgUCVnwr2AAKCRDsf2ULUcas +l8EZA/0dpYsDzrN3sPug6P8t3DjCtZNUUii0xBJxAKvWLKtqj7B4wIewNatehOZNbvDlwBgS +u7zQlmeAJ1Lfps5OlaKYaPp73nTELI4ytoD8YhAk6ssGlbuDRlX2rURopEhJOWXaiBt71ZRQ +vZ4M3Fzvc7iVelZAVoftjFV3EuqadnDmS4icBBABAgAGBQJWfCvaAAoJEMy4HqT2cCRA2akD ++wcpd4XHtNO3ubK+zX0xGnTAgQjx4ZhADgxR9lbZa0IBlijJXN4u9v9OXJdTqU5zZsG3vUKL +5kXB8JqoLY97T9ZJW62a8SLSIFAuU5oW4WDpP3s36808DEemzLVgH6U4YfJXAYbrIjdN3tCY +OvZ7VnC8hboGHrLDJzshC3vkcrQViJwEEAECAAYFAlZ8K9sACgkQKrhGpw/2NsBTVAP/dfpK +PMaPuo0OyUeEwMUAJh6tGV4HJTw9vOGn0w9/JLxb3AYm2CU1qCHCVlRZSO29LK33dSzt7zcy +myX/RSd7KpfLv5jrlrEeZvX7+HLR98vZrR566v0EH18VUThuSqfBAOrQwptdmMrB5fKvoFU4 +ewXgukLghmqwrCVEs0HEaSWInAQQAQIABgUCVnwr3QAKCRBFLPr9F6yqggEeBACcGwesK5UE +wDxzC7mvfOunSU7Ic+SJZ6V85nPLxg5oVhwj/PX4TFoeQbF/aawQ+qTqOUhMR3eRsaPyRkr2 +8YOc0wU+flpAf0WckCAS3nmDTM3ZNiTzGmZBQUvCLf4nomx5d9jqva1kgUqfx7fWnCv3eRqG +iIzTPhq52kHMYU1uI4icBBABAgAGBQJWfCvfAAoJEJ3D92XqjC61VF4EAJt55z9rebR+dAuz +lgmE5OU7+Esc2hhB7/O6JGMQVzF0VUPJhorHUusqYuZyjTzhHoWZn4yNrKOPCwpifcN2bFlX +GV03aWlsjAeFFLdAmjkKCIKsgIwYUehoRifKR02PPVhnw6heaQXuQhUK2pUqAl06FEwucKXL +LiVJn4/mxhyhiJwEEAECAAYFAlZ8K+EACgkQSPO0H0p5wn6zNgP/ai6Qw3Xcy0YcRcqKZqUk +U1ybQiKscEiAPvpWKFFqiFAEpNYb61MNys4YKie6Gxyj16V9ezL7O+mmryzsKWhX7n2tx/GZ +Th+idGNgBz3iWKv4HBDBMQUo6W5RKZJ38A7UbjPNqIaLChm/o1Vs6+78HjrgtABc/RhsWKTZ +YAoFDf+InAQQAQIABgUCVnwr4wAKCRAS8ANPvtKNooXAA/0TcQ5XytWgcBLad4oiY7gjk+d7 +ailgl6JBDUgWcEZF6jwt0q4Za8RyX0oHexFij6tH9CKlgjr9EeeoxyYFB/ba6n39gBEu7/0P +itQ3ZKI88JrsAD29OZZAvZ1ocMRiilyF2MLgZNRV0oMsPbSoxxYplTXzk0yTd45U4N1xdfXr +zIicBBABAgAGBQJWfCvlAAoJEGN69jdnP2wvi9UD/i3SuEsXqbRWzAP27OclQ/sZE5T/n9qx +VaFFhf2zYXb50XBEfhs6uZgl2R5fmIyxjS5DAgzX1qSeFmlVQo+6bTpncMRQOe96GLBiRucJ +ZF0oYZvFsAcczmO9JY+L2CNNno8kWs7/TTplAYnWHdsHVhrEXefFl9tZ4V8mkz3TXmiBiJwE +EAECAAYFAlZ8K+cACgkQZB2e45iWZMwHwgP+I/1r1uorucFguZFbZHEAhASOPFgEauw5j1MX +URYUZsxdgwanERdlbOh1hCdDwB2kCuqAt0t/J+E1ygLe1YRkJsjVyxlQJiqe5X58LtRY9JQ4 +KDOTFfoykqOVqu/nDsI0DA3yNImStdEA6/JjxeKEJhMtxvdtCiPHKc9E+CLDOWuInAQQAQIA +BgUCVnwr6QAKCRBJ9Ki4GKtOthXbA/wOHSMFwWi1mloNq3yJJIHHJ0Zh5QlhH4Pa8QNtmg5c +ZBqGuYH0Wx8ouaEbYfz02cgoGcHig91jF/1MYFRODIZ6kM8H846LK2aF/ERPQtOhuleXCosa +qG2Ai0G7xcYdTmF9PnokcEkO5ad8YJds2YC72PSjRH2LiQw3QH9OXvD21IicBBABAgAGBQJW +fCvrAAoJEBzNrlpoqh96FycEAIaXVE8+OHLiXBRCV8qaDNt/M4XuVothCcWGdn1CZZ0QCq+P +mKFFiXjgiZdNkd/R4HrY/5/O76765lCdKjjLxalOXUCdCG4BQL28fmqNiZmtPsQD78PaxDdQ +H1siP/UrgLyOAUfw5ugCe9EEMasC/Xr94Kc9qEX1H5HHdbNmRmW0iJwEEAECAAYFAlZ8K+0A +CgkQ/xmvsPEygxojEwQAovUBpDN8dFRUMzoL7xjGH0/9o5o9NJcLOzrZA81jS8ebQNV/wnBw +9NePDgpP/pDgo5fg1RcQqYn1+qkpGnHTTKwQeafiY8eqxHclTrY/fDkkQ0QEFtU12lajDBpI +JtnF+0w/zVguKQQ3kYlmgmjcl+015HUiKWbTBFcSVymbz0GInAQQAQIABgUCVnwr7wAKCRAu +lTyM3DTssHypA/4iEJWiChDNcZnmubhVvTPkb4eXlnvtMDM/aHfZDmdybzOU3fq8gp42J1/9 +TxfIUQCWNCr+x+Xu/Ko8h1nQshKGIYYOR+b0/qsdd75fdm0c3amKaaEJukFm6Jp7iy5towkv +I2yxt4/gL6DXUDRugVSIqqiutRjqSRJ9RiiM75FaB4icBBABAgAGBQJWfCvxAAoJEDURn5yb +kksUNnQD/iWR6tDBDKux9ZJj2yPvhn9SZ7j6LcqvX/T4IeHTS9bpv46nVA6OVQqharCPqvyT +hhiUeoSYQWlC1aiV7RC7qm6cAVrD7feec+ju3/PCzq1erl7lkKg9Ri+3AP26SRg2rufmrcKe +qIYafnDdx7BvWRxrdqfwZfrBcQdjUoKeOfDZiJwEEAECAAYFAlZ8K/MACgkQcf6LKjx6KP+B +egQArRcgBq+UkWY/+CeM9isfxvWxUBAv4bR0mYQwnrYrF6uQITAYSqwP74k6Ktuqz9rXFUQy +963mPiqX2qZiG3aHL3OdwhDuaznEP1Sk6Pz/AGJzL1xIDTaksqPpB8LlxBoT11HrwwZDZszB +KsY8/npMNXEgG/k51rh9X3Tbv3DtVWOInAQQAQIABgUCVnwr9gAKCRBxO5eApFAmJoy1BACV +YS/+8XbnCrZLHC9d9HCC+4uZd1Jwp89W72EPPE2d6nwc16ruMad/13uYWLDJ6ea0cza3JbYN +1X9e4/eVRIn7a1sxb4IGLCWu1nBfAWhkaONF11ZchhInhrmi82vuUeJZzHn7pEzrumaBJyoZ +AunAR4V58YK1W9nV3jZC6NUlpIicBBABAgAGBQJWfCv4AAoJEAtmb1uF+ym6KY8EAJE4MeAP +ev+DC8sucO7dheBQj/fQsGvSa8W1eERL53GHHstJ04EyxkcyTW1mVsW9PFVDSA+Hl1LMI5+L +f6+xtjzzvoCyT3qi+zjx38NsRfjcYi9cX+4kUhM5RZ0HZbgJkh3V8UmuEQAm7eDfoF0XQXyX +9DBFTkwp63QLLCucHCReiJwEEAECAAYFAlZ8K/oACgkQB00xiHkBJFjSNgP/c+D/ACIhRHjd +mDRcENhke9pKnwRHGebXEiBZZd/9t0dvPZdg0/E1zvDZe9FlyC5EYJGtlXI2gJE1Hzwtva5I +oVrEsrIU9ifKZRgY4D8DXZELFY5EqJo6LHwgLcVSyHpsOmxadBSjpoMdexOTAs48YoLogKMI +KdG9R07TKj3hLneInAQQAQIABgUCVnwr/AAKCRBjHN9cYP0o/E5xA/9nowMq7gELnauYec5l +7ai1iWB7TsEOzsP4ogn09TnY+qh6lYiVm4hyPzizpDDtSM/P9G7uivlPLkjz9cuOE+P3vixs +35o4hZZwgCQCSnTMdCduKGw9YZD/PVgifTdD8dilajwx8rLNrOvUiORjeuCUVCc7snAy5THn +KPRgwMKbkYicBBABAgAGBQJWfCv+AAoJEJFbLW6MagNtANMD/is8iaBKlmYqzL5ry+LyFq6a +JGNdXVzFd//u6azplIc/L2EbhA7tXrCeWFhblF5JvKUG4tq0JE0jw2y25K9WLzoOhj5uTSO7 +rIrFK3Z1ilzxu4AJlTFmk9kXeD6BZKa2uWgTGWSx2fluxMu0JfZoQftv8Bd0RSXL268UGlz6 +rEoeiJwEEAECAAYFAlZ8LAAACgkQZE8zfOFoZPnCfgP8D7h1eJnJN8wGYUsaOR3KmwEqD5UL +d0KVVfp4NsITxqhMwsC3txL+Dp3BqS7T4lFA8DdiShCjgTbPQB3maAYyKwiImTG78YpMX3mS +Uaa9qz6mq243WRpAFi1zjY8fYGscyH6Sw2GTd763hANeJaFGnH621OGKiFphLSWn4siMV3qI +nAQQAQIABgUCVnwsAgAKCRBgeCieEhsuExlAA/9xfOigPttRBeF2bH05KKj2NN0/vUYY8Ofp +kL+rBSnjJnLiFLOouzx9qcdTPKdOOyU2IXdGyLSBZLirv449K7MSrAGAp6HNCskCZo+P3QB1 +f0vGZDARMaFbJKD+V4xG6xhSCmxZVLXN8S0oWz163w9sU37qXPJgQT5JSK5nlCXZyIicBBAB +AgAGBQJWfCwEAAoJEFWBlRW8Nfhv2YUD/jgcQOWRkevD4wXuBbzRmh2bBhcncPPvaRIB/8OH +WjOQEWUWY+nGnnYexBOa/+RSFS/DIxuJA6iC+IcM+MHLkPk8kccP4ZV5DY2esdasYxsFggj8 +fPN4o4s8/Pu//2jO1wzN5xFLTBn6RRPYbuhh29c/5uEaugk7hLMwMIbGVVEaiJwEEAECAAYF +AlZ8LAYACgkQjmgwuPrSRU+sZgP9EEAGJkfbpyDjeI20NkkyCiBZS4em2Trh8dRHeR2/JjlU +ZwPVe6cORi3oKsmQhtkiA2iLvnzwtf/c/SsK4tFwFBvz//RtB1nSu27uPSWmjDDFRuh9k4RF +e3voxFAvVGBOLxJsqnkFhqQ/46Q2NIA2iWIXdw5Ih62e7kHJkjDZIROInAQQAQIABgUCVnws +CAAKCRBbINpBBKwKLhsiBAC8GS7kcn7HvnYKPcNpmQp5CsCtzxcL8PlJfSerZUtFXcYeyaYY +zjd+0cyZrNEkiObEfI5i+HU+cCtYULL8hR8fbaaD6Og/Wg8WfNExYBU/BBDwKo2P32wIOKx+ +2y6f7KNncjVziDGx8YWCm2znGWKskBWG1a1i3TX4mKa6E47D/IicBBABAgAGBQJWfCwKAAoJ +EA6TbujYVqf/vCAD/3e72XFFTuXz/h3Nc+dJHw0RpIe5bsbSmdwRNVdWMwc2uT057hAHKKzb +2ZVtAQObshA69rXnv722ROQWe4tBrKhsLbcElEIEa5+9qgI4xfDFcjEH77ujhCuGam4Jm+is +StIBYwxAk7F16p0WbRiDyFPs8nd4VsTZ1Z18htRyhhSDiJwEEAECAAYFAlZ8LAwACgkQ7cMR +ftZ5TltR0wP/U/D/xK1xxDACujjXXdqa2vUyUEI/MjsbtIo0BgkftbnNiRKhbjnOkEd0Elve +XNviEUIpc21fdOx+aG/mj4rOyQQRflc+zJG735tjBxBJdFyQyxA0Mj6Tjpe0tC6mb1v49iDy +DF+wp/U1SC45Zyb7NU4V++6N/svp7TGNDAaup5+InAQQAQIABgUCVnwsDgAKCRArXuCZ7AFM +RNIDBAC1e9ZpoUOhrekaoqkOt+7J+ciN4jTx+TpZKMABvw4NvS1uQlEGtz96gmZmcl8cxriS +QvykHSzsD0qTyS/fibkX4WrqCmcSnHdn1rlyV+f4YC7AFGFBLz/7v9YmPxb/gCIkVbfwzhSA +h/N55gIPs2i312OH+xTrMCTmAx+sthdO1YicBBABAgAGBQJWfCwQAAoJEOzqThWar0/At7QD +/Az3Mkr334ReJouP/4/ygNiQf7bOseH0j0O1PQr31K+4NUPEibO3U23N+qa8q//Iz3dgTDRP +6NUG4g/ThBGpiY48vtTi5qgPo/9/9UCEBNADHJkFQeyRx7cQpk47W5wNRqHJKiV91IwswS5g +88KRjpvxWZTA7mwvRlE35W8l6KmLiJwEEAECAAYFAlZ8LBIACgkQ1uwfTlg8r/dLdgP/bDKM +AHJ1wH+aKRkQPxxaNY2xCnyBTLlJbv4rhuGg6cAvbFaP4FVfps7azKZ7tkEvieCue049Juqw +pGVKqVvZLLXLtBmPVPNm0AGw+rpYh0f5TQXIbQiBxnzjuvPezpwNuDdZci+xUv4Ex81NVefj +WJ2Tb4rET8ptqusOhcPn5TOInAQQAQIABgUCVnwsFAAKCRA0KsqZnKm46610A/0bHCrusmyp +44i+1iWXxr0rLCnzaG43wum+MMxG+NufjmGubLX3IEu7GuZcsjcKqllgx4/egZHVY2d8w6TJ +BwqZHjCwPI1hFAZacG3FUYw/e3OjiZohH/gWPTNF376KmZkgImoU/E+i+sWdhrMmU1aMwb+8 +5R7GQJIKP2BP/TGp3IicBBABAgAGBQJWfCwWAAoJEDsSRZGjyQPgwkUEALAYYZKEwmh5GRwX +wokdH6nPIW66xqZTuW32iyplHzC/Wz+lAvXm3qNJQPx/NeFHqEn3SykAgSFUI0UKKWIlqSCB +ifySEriNosPCnSeyBD3G5zwSWE0IougRv05U/ZnKRu+Gv6adtevzAV9FdQBlf9oe3L6o+Rkz +jgaxKpAz3kyHiJwEEAECAAYFAlZ8LBgACgkQBa1DpfjkrQqoOQQAssZ/Nf0j7WInXKogms3Y +a8vavLEENA0jQY5yIsCSJxtHfzt3rX5QcipTXIz+t0z0tYAPz2G/4u0hzJPklvFTPrcQhQSV +ekPKZnZW9ZLuKukigJ2+ONK5p6QDA8VuetX1N00rIpnhtV3HkoXqy00uY8H9SZ7PEVP6y96E +jywOUZOInAQQAQIABgUCVnwsGgAKCRBwESDDLE22jUquBADSsbBulNL8X4Nywnzdciil7f5U +zOkTlNvM8kgOlJFyOA8V+KKC06oSZRgxWdYn1+7ltplb/Po5a1Zzuef9xCUK+dR3cD1s0FjV +4Kdn/wCA2vMsLkfTUDtdS8+/C/tgFeQXZ9vQYb+5CCc13B8XF7dWtO8Gu5/cepa0lJzBOPSW +UYicBBABAgAGBQJWfCwcAAoJEPSj/6isxrYsAUsEAKS7RNY+U7bFZnHl+LD/01LzetQKa0Xl +TeniBJQNL1nzayBGNzB4p5zcGpnMamDoPj3auOEVBQs43Y+4FsieT9svbqTG7hMfTqL1V7Ue +5w4UDqcmeocB3nu4PLoZlxkBzKSAHmp5SUZRpXFyTCYajACd+L2NZ4U9281yl4ShvQ+AiJwE +EAECAAYFAlZ8LB4ACgkQTz9q2tp5fgzaigQApAee2ffRVjAdy8JnoNxKZWi4wLk47CFqRXIN +clgLxl3cJsbZtePiO9bHoXXlMo/i1x7VO6ThQDh7me2G78U37ajrrPc+2Q9smRs0oYrrsgcj +diy2Y7GQnEc+bk7SxBNiILW2iIHkpt2nbBiHumpY246JMy/B/2YcxyFeBa9KpqWInAQQAQIA +BgUCVnwsIAAKCRC5UXIOb+PoMFykA/4xrqwraU31EBbnwSzHsMoNPmlhVYyr/ozKam/Ha/0g +jjV4CRxe4MaucGnUbY3O1mHRy+vkSf0xGaTT9R3+68RxRDSkmCTVB3C2c5NwH6+ypqhMeb3i +RvBHPwwdC4Z4X6SrNbJIQtNn5aeajDtT4vPTHadh0hwQqo95S1kKgxwvXoicBBABAgAGBQJW +fCwjAAoJEGvVSZ++MeBG2XQEAJP4stZI2csodseqXcdLYv7aMPwlFCmSOW9Cof4ssBn4y7n4 +FzSADwkBqU/8HAUl45LSaBLqbSP1Pzn/pfuhcwru6CpQP89KTXM3mysBzXh5dqqXqo4169kG +fvi5bfOGeau1eq1TI4aBhOzWC/3tvf87ccqIg8CwCvc00Ea8l/OjiJwEEAECAAYFAlZ8LCUA +CgkQa8jWI4aMXpn95gQAiShoZKtHFyoJTZqlbuX270kbTFm2tpa2Bs2Lif7WkmWGLL+rZDuq +vmA9BmZidHoiLMCQnUQnDjD6+9Jlku+9e9oTyQkmUTcKFWFVyCHX+ndRnG+n7PRa0aFb1Jtc +BqzeFGduA8gYnNTzkcVmSewvnS2njeqM3N9BUTUzlOxnkAyInAQQAQIABgUCVnwsJwAKCRAK +qAaDtJbi69skBACO2Uc4mvuDJR5QFJVjxPwcQHDSWxsTRKQheWgT9xYMWvneUKjO/Om7hCV1 +59Alc+D8j3w/dWcwbQ9GoqndtK9oebulyzRB6kEni8kIrFcUaxrBpzNeXEo6cQHZbP+WwhKL +Is3tWVx0CFYJScUqtec1G5sC/HQsCze1tLEUDJ94hoicBBABAgAGBQJWfCwpAAoJEGV/yL94 +Ii9yn2kEAIwlvv5CqP4Lhj07xGMt7QbqOV1GPfTW21feLLr+5S1j+Lr1Vc4upogUKpXOZL1b +t23ret3UAKpzuq1V26AFlYb5xXjacd9jr4weuYQOsKsSNPWS2E7cllKxf1SGJjuJ/KfA15OK +29omXm+NX3/Q8kQMHSgRSVu14zwmNUhBS02AiJwEEAECAAYFAlZ8LCsACgkQHSG2aXdFnfjF +8QP/fGjztJDVVr2zOTBjkjCrLzF3X2aGWfi+EkU3IuvCbh+HbMiPcm4drUD8IqDKM3c0WrMZ +O15X4yQOsH8fawM8kKdQglLsxo9iI7V2DwGw+xiJ8lALi6AuUS/5kgvTiM9Dh/4YK7hAJAVf +13Ts4c/IDPRzksqzpVqAdvsM0flXNPqInAQQAQIABgUCVnwsLQAKCRACIY7DfDSvNk8ABACN +AO3uFBRrbFc3UpDNllW2a6Fq1Rsjr9shGcu0v7sNG2iFawd3r/QPYjUOvCvOMofdl21hBaMO +rlHtdRKuxVpnizDtuCbbfgXWFm3Qqe1USJykc6WFjqdmWgYuxllMzT639x9/LUblLuw7oq0t +m/pfxzAHTbyhaJktimshTkwOioicBBABAgAGBQJWfCwvAAoJELjfihEI9Oo+cQMEAKnxG28a +SbJwuWgHaHyEh2xsDcuoSJTkYpx77+xkS5vMTcNRb6KN/z6hXIaBMptIRmwHWuZen8+fjdUs +ig0akqaJd6zswNMTDxIwfwE50M4eXbBoxCw4eBFapCic5zdBG8X1S5cDqKxGg9cZpb6bafYR +2B/Hb6qRvKCQgPRMI4+XiJwEEAECAAYFAlZ8LDAACgkQ+X6vKLAMQj0qQAQAqGvfDx6YYG22 +3xTGOEWzQltw4aJeZKgow4Od/eFjvcE4WDobK+9Gs3TKxnxlc6ctB9OyIEMKFnTZPhLo1UXx +PE2ex7TnrYIePLMdy/eNBoHwSxyAPyfc535OCjY936nH5LsqwhQFPIGNHGuaLUCMN44doRp4 +0CxmAZuALdbccxCInAQQAQIABgUCVnwsMgAKCRC7SRPdtY0FYuZeA/9tOBaN+khld4yBaZ2L +HMk6ZlEF3/f7uMufZ+TkUnKtW9Uj98CjOmVLnQorYDCX8UrKt/dUjJlVAUcfMhIzihwnmvS1 +RkISif/pPP9C1B/j+8dp0jXdmaWYF9CFFD/hoj29r5t91KPveeaU5pNJgg/hW7bKv+dQ3NER +CXxOnNZYk4icBBABAgAGBQJWfCw1AAoJEAWdlpVmjgN4oiUD/0LjcUvg1jlNrEHYyx1miVS6 +hwwVdFj11YmmZOyL7JIPBt9tskDJXJGP1cZbMMoaGFEgryjHxZkPJCkouxyRRCVc2ZYj7m2n +gt/NftiZY7O8572frATCs8Igy7Vxb6zAyfGLfpJ2hE8im2YcOGTzghLwJl0xPNt9RhrTk8XE +5qowiJwEEAECAAYFAlZ8LDcACgkQwzIZM0CflMwn2wQAi62EKLS/U/LADj3b7QKX3wrYrgJq +Qveq6mpLm1aFLQ0eALJQq8PfQDLLSdGCQrVfM7+kb3GCWX6Hd7jO8RapaWIB/dBCn0JJHPjY +us0eakX5IquBpltVwjc9Yn77yDtIW1XLcSSMaU63L9hANZ7+2HZHtz055JTXMv7UwI1He9WI +nAQQAQIABgUCVnwsOAAKCRBEZQ6ywTD3TJxUBACHSkX/l2eYqZYFaWPbS5XMkfnxPb/kw13C +C9AdD//lPHrSq/1cdlvLaxLYI10P1JJmW/Jf5H8fksteBcV8kCcZOvK2demtATwP4DIlkITX +2QyZaLkyv8zDTmyGIthzbXrjZScKFloVjKEaGBPqa/LUKyCcFjbBAnNnfc+S9Xl9R4icBBAB +AgAGBQJWfCw6AAoJECMSOA+rXaHowFcD/0E8PXEz+a7skAwi4QCcMFMFvB/PJhr1kUdBQhwF +s8fP4YZH7I0/zU1ElfTgzn9hHOa7qzJj8zzwrKeGEL/qOmr/VnHcLk9z11Ry1ts+RhIs5lzY +5lg9S/LvHoVlaLFipJzOmtzm7pjkSl1GctlSOlHhWLWPOHKLD1QD6IAllAHXiJwEEAECAAYF +AlZ8LDwACgkQg8y3f2cDq5n46wQAsj4mAWNACqHQdl65cp2Ksv3VLW6q0Oxbnq5/ERhPtTnm +Zof2m/r5dMnLmfM9D3uXjhKC0MSdbfIS9ZaL/gyFLkdJVhlw6rCUrc/bwyF43D1KaGdgVGVY +2H6sfTEO9daUtF37xHOY4BAhOEBvgvg0ZheMdzi5RJiiy2sxOGPkmdOInAQQAQIABgUCVnws +PwAKCRABDPG/Zkl+xUMoA/0VwqipXuOWWw7k2bPXItO0S6dDDQHgok4GEgG4Ei3OEbB+jPOO +Atp8MXPkbg0Kzv/SMf+8bv+TQFrKfoEHUg8hP55wua3Z7VqBJsEVue3rkBmcY7xSDa1Ds3r2 +4ehJ5X4kw7jjkRg6b9gMk2KJufUQIe2byJgR8Wgu8yUvWKnEzoicBBABAgAGBQJWfCxBAAoJ +EAfLU+KUGfzCXC8D+gLsQybOpXYTcCW9URwu3B4KsZjD2Pmp6s4CReTtv+y1t6LeEagtypZ8 +HP8VZ2KDIwW6zFX3v77E7Wj2BMfiwIeaBoevMYEFBdWarQUHfAyKqagjhd7q47y0gG2+8jDB +xJNozUicwey8soC51EHp7+8Q1kHH+DtfbhJzJ3iq5BgxiJwEEAECAAYFAlZ8LEMACgkQvw02 +nht0EFPpNwP/UoRxYWkS9d7ltSibZeGR82p9OTdqlh1of3fgR//7aPIQvSV+OPLxiD0gadOU +mCStueCGaTh9wfW+PkTTCb4VWU2qoWyS6AP2Nl6GBGvWmBByOyJL6tRgGtx6xb3VVAx66yT5 +2Hm4qllhO32bglyEVrJ+geRyEV3sTIwJ62UsLn6InAQQAQIABgUCVnwsRQAKCRBkhJKSBwBR +2yNLBACoFmLykgEwAUXSohsnkTLgQWsJvQWweHhDGehBMgz3SSz6DxNl5a/PB2ccGaaX6Dnp +Cv+NoHWjoyOqOqAxUX3WHYQdDhje775NlZQ0YH3FbShokdUDeC2MpvFznGK/Xb2qK15O4soF +zjm1yZyBOTtqUrVFWyCvssGQDD4wFoHncYicBBABAgAGBQJWfCxHAAoJEIWcWR0wQheYDh8D +/2+GiGBL4xs2pS/oygysmhLuDHd4LMxfwcuWUWDhKLz0eeQZiq+1uhCJ8ts6yp9zxw2Avf0O +OUm8Brq3eHHxyRI9kXR49YuuGYwo8qpJnG7kL5hemXTWLiV7GXJ+GEBiQE/xNoaKU/qgEIae +LXjT63/Gb/aUZnvfmRPEHllyB1YDiJwEEAECAAYFAlZ8LEkACgkQ+44xcuywQxgIdQQAinm4 +lx6Q06UQQm5S3q7ni4FDNemsAJSkjRLXXFCA3ExOtFS/7JnthgbmpZQ0c57qqQy9JftOjZP9 +fXJNpEod08WtiHlaHKXJh+G13KVaHAeGKP9g7Hyb0rGwIU2MsgcOncW6ayP67ukSlzqysfYF +U8kuT/Bh3C1QeAtc6Z4LV46InAQQAQIABgUCVnwsSwAKCRDYw2Tjp2TaCFIGA/0SitAv3+Om +O7htTG9a1PIs7qrA+tbr/RDRv+bTrPtZWNhK+8IEdybD428cwX5FBZuN7pNviaXBALgEA2zU +N1vW/jhDQYL6h9VsLMV52GLuJAt4sY08OuWKYFEV8XM8qTpKIKKlZ0EaY1eBgB7yCUUhiavg +JvWGBCFwbT1rCgXcMoicBBABAgAGBQJWfCxNAAoJEDz9XLHwYwfviWQEAJKv6igeKkSSI4qX +2r8AYQk27EefhFzIN5EbqN0gNBtEKX83MhXjFsS/x4VZunDA2j0f+3c9KZbsV3HP7ujeFXxV +Wpzykf478vYlr+2zkaC22UVpNScszJj3JRlFS4UPoEMGvzTn3XGO2knj5gE8orQkmjEkB3Sj +aUp7ugYsMVJTiJwEEAECAAYFAlZ8LE8ACgkQg3eEXguQJhCMqAQAmtfk0QWKY/81n6xHPZNz +ZWHmP30tHNkKGI09ortcDGyZEGOuKR3bg1jkQIySH2upiU1NQZgJZnPFdKyA8UBynzrX6t/d +K5ejfb1DeVexpVsOVU5K3uxDQgi5bYUd1/Ga9BlHtQ92adWKDr39USb4EQ9oXoUoxZAXc0Ox +xepuAEyInAQQAQIABgUCVnwsUQAKCRAZzY0egAOW/o22BAClkg6Kq3NgO80gz0LB3jfcsyur +1l+tKaIrvkoz+J58dr7BzUjN7suoJviKEirMvS8w1KfWkdNtX7mcJJbm3tpyXTC5e+DNr/ij +1zR49ldU1OAyMyweUPsecbnPAXLQOxGZ8zAFVrdKllWjX5gXe5kz1zjeDAT7NO5Zl1t64tIV +E4icBBABAgAGBQJWfCxTAAoJEFvErm08SK9zXE8D/AxYErrThThE05Ouellzyz2TOFCznJ3d +H2yyQ+c1JmyX0glWJALUPfozjg3HLBCbPZOEhkgV1AnmgOTN8m6kLmofmcE3iwyE7K2zF7Qp +DJ+nObT7N52oT/9XxUfzY7xpEh6Trdi4fNJrk0J7Qim8/+92kkm+hZMYMBnwkJOvPflhiJwE +EAECAAYFAlZ8LFUACgkQYhpADOVOrJr9twP/USfHYYATjuAeB9OEgSuJIZhxiVHMPCZQZp9k +SAK/kKiSHycRHM9LZZG9gRnAbcAIUstziS4v3zsKDP9Oh6CUm1m2U+wzs+P4Tm87pPcbSuPs +BQBQl9aWFSM/ZgG0Bs+wSYmnpGUd4M9ddnLtS39MuC+e/FpX/oiHy21lo/RbNjaInAQQAQIA +BgUCVnwsVwAKCRC4FIf+YvPqAppSBAC1yclbR2BeIjo/RqfIyeHG+qOF14iHChB2iKgXYJ8r +AurL76lPykCpzaKxwsU6Bvq4lf1/J87qORgsQoWuqYWAYECjgOKW4cTSOOdxaZ6ZMEoWhi4F +wZJNTVOoAECA9n26Him8/5ey1zy0rV8hWjh37s1IqWglrQC+CA6/BzoLPoicBBABAgAGBQJW +fCxZAAoJEKC2XPO1BxRoqL0D/ibeCYUrGZ/qdonlNLLw1i6my4roDLuLXrMVF7/OgmfOmBxL +Pk0jcnCx/3q9+XR9eJEwzewdbH0aW257RCVbA316Woox3bbzDdO+VCFQQQTygNBCrBwKg3zt +gKMA5O2vxW0ZfG/elv+GeNbSCCz1bPpUQZYYb+ZnIT4xrC2Bc776iJwEEAECAAYFAlZ8LFsA +CgkQQYhphB/RrxGAbAQA01oAVg79uK+SVFR/0PCI+SD57U+zbgv7DeiWiGaXVPK4SciKlhNu +mvYmFolSiTGNdqqT+BBuMLmyJlhhPdJya9bzDw2/5+3MZ1oVGlbyHH3nDxnaWEfKujFMVQiR +ilSzm/ZHbs8TzChX6AontsYo8X1SUbFw9akLu6HqqlMRQpCInAQQAQIABgUCVnwsXQAKCRB7 +h2kZKb5RB6CwBACbYSh0MuK2z0SF/ZOuNhYoLsSAse7nzlMcic3YHjTPejAZp4jNAUERTF8c +P/m5ubQ+eQblWxXyEYgPuPEaogL+kIYwy9lrDGpw0tq+jBBHyozNBq1T5LbQIdHR3OR31sGY +tvekMzXN9Lsa3v4k4tb0ufm6P6S0Ts+oA+CcTAyUQoicBBABAgAGBQJWfCxfAAoJEFSVV9fg +LY1zhOED/0wOGE+xMVPrHilegdvcudIrGTAM8n/RhQyS8bXXxF0Lh/YGgRzjV06EVb1DauNE +tya/NNQRjIJZWjk2iOylYZ6PmTGdjEXkPst2muvpaR/Z5kyPlpa1CJD8d2zLLRq4yEeLfAk9 +R8+niRQ+pnqRY+THfO0qSunhqlj9U3sfIbUriJwEEAECAAYFAlZ8LGEACgkQJObC7MtXOzPs +RwP/SZpeaeqcXJyFYdbTczvdQH3lCOdGs1om81xxAH91uNwqI+yYfPBU+qHItAbsGVM1AZk8 +wZo59cwJiHdgSzYYD2leR4cnmENfClOZN6mC78r2mCu1h9PyucVbqPSzeas1j+0TZXv+4chK +UqLgwIIcIcf7ZUQriX6UlDZCjzeG72GInAQQAQIABgUCVnwsYwAKCRCwEJj6tldlyJBrA/45 +OlW9vDs0X8ZeX4qhDQgGMnW6+T/MGmK/jEG5ZZZpwuIv9AOidzto+lK6n6UPoiE4KBqNd3OL +35L3wOG0Rs/ChioEWPQmeRMs6m9lfiPWOhxozDCWCa9i55atEutlUKFUHtZSIWwew+SZSNjJ +KxURrRzSKuKe+t/dC8Q9vS/LooicBBABAgAGBQJWfCxmAAoJEBntEb4NCPyAXWMD/A6L1pXn +safrBAJzolw4d/hUDbY1Eekbc6iIz/YnOG1sABsXnBOcvM81mXHxB2RtL7Ht2TJLNrjCNeT4 +7cpGLfxIR+ZpwAThDaWCzQhwVQXvbui+Iz9FGXWXu46RT7k9z/trE2I+G92SO3SZhiL0covU +kV0V1SpDinEkScliNdeliJwEEAECAAYFAlZ8LGgACgkQLcNyDqJtT5UmBQP7BqRb31woA7AS +xY0lIR0pMT68EVe+vbPZROGiZGITSDGFbJV0GXsckpr3g9t7KpGH1qNCwZAS8Vowlo1bEpA5 +c6FtBH8NJF40Tk+35AarkOM0MkogBbMf/Tsz1Vh43YLJPStG53mx4j5h5hBgheE3Hbo7Lbbi +V2XaD7d81PxgDMiInAQQAQIABgUCVnwsawAKCRC6Vrnydq2UdlpxBACEUmJj+DWqO/Gdtkl7 +MPiic7obclQx6iapmUlzOVZDoWb2TYMSpjJJCo1K5icZ/tRAUoj/CcSGkvwRjMnMyZLghNYK +saii3RvoM26vxs2cBTbvqjEUlzHQqiu4v3Nik7fh/e1xqhX79n6Iw3/EmerBV5QEq+4aqxg2 +Iy0MkqIQBIicBBABAgAGBQJWfCxtAAoJED6RQ2KJVCG14uUD/1+5fah1uRNZ0gnS6XgdQj5c +DRVueJw9w/BJmHv1s4tM7lBIWkNNCD0rgHQWTlsBcICSI3ObFzOdD3G5QGfA2Oba5Tkq+sEo +SwqSppwNio6tAwPt2M/gHqEOXa7G9i8sFxqNp6KkrBET13T0f0eHb4s+IAklpcWc3X9BDQLe +PQjTiJwEEAECAAYFAlZ8LG8ACgkQWcPkoZjijB8fhwQAxnDW5TVNOwopLXzwqS34pUdtycEh +jPhRABPfoWKKH0G6qJAPa/tE88rGyvDgPspgyJeFuFpq5xGQrGrnCC3teyIUQ30msWC29Rv0 +DkE2keOCkKmWqiF6OonXD0MC2zYlYXnxGN6SAWAqAnmBZ9qlwEetONmLOhZwb4lw6PywPZaI +nAQQAQIABgUCVnwscQAKCRAqmrRjK4deMM4iBACUiHvXep93+LS0O2QoSyOoNxuKGsFVnR4B +Ir/1VW5chc51XAikRZtemJKrFPTv4Jw27LpRT2p5OBTE3PEP+l0DrQGvJvMfDblETHRRfRJC +8G0VucgaKCtnv/R8/LC7GlJPLsRn9+7jgnGNbZx8vsm2hundm+rP5bKqjPCMEfxk/IicBBAB +AgAGBQJWfCx0AAoJEIprlefWJYIaPIED/iFsEhZCPNiqd9YhohpiTzYqajfYpvsyVUxt1dhE +d+VaFJmeoaB2BDtQiFXJ4rUAFpSxS37tdKbeJulPXpkhln2cLbVxY6aDK6sDRn6KEfm+hqrk +f+cUeTlM/hTVgDl86SBCPy5JM0wAF6Rj5rRU9Ukt8QgyoPbVXh1znSwDH6FGiJwEEAECAAYF +AlZ8LHYACgkQGPXSilUfGEK0eAQAno5hJLhQmW+bFWtVO2Cr46kLchVcFIMGBOn209lZDSkm +AYuPgs84x6M+W2aVxb4BYK0PpsRD/A+ECMc9k0KSCwjESZvBnMAVfX4ILJNRaKyeRMBwfwPb +U8/zd4rxiUmeaiJAmyquRHtDW1Nn2XHj1xiE4TqQp9TruSpFtUxm+KSInAQQAQIABgUCVnws +eAAKCRAqu/7kyAWpmQWqA/kBlbWqpNeTcjNxjJiiSKkx5qHWDlm6hdlvfO36J9lv4lIooTdH +TESwOhUUwwNCY54rBtdFYtDv8f6dggRtsf0fzuFIqhtSRpvmjSxLGsu/bMxU83MwFgOuHKX4 +1RaSNKLIy2d9fLkgkcy1ulj1ykgzPezIDloTFqPUG3iF1jHbJ4icBBABAgAGBQJWfCx8AAoJ +EJYdjBpKN02abNQD+wdHn3qhf0JDsdP4K/j+BP4chEC9VEAIwArQ5UMEMFAQOpcGbV7AErJ6 +kePMkkhUsFQdgIEjM1Lua4EbzOCguJ6hsu4v584I6IWb2hY7OXLb7Xzui/M6NKTDSIgQWqjN +n56fxIfFFMjPm7MTNhmutvKBiT4DX87ygHRqD2XvuMqhiJwEEAECAAYFAlZ8LH4ACgkQEhZ0 +NM64uRkqvwQAjn4gso+RpAi6ed6WjSpXDElkYZwPJt3yd245lO2Eaxl24ys4cdMFJX165L5U +r1bKfqPBiQGGkcr30biNxhlu4lNiSZ976ODbeyMBYSQ9HcukAcHeE4Fgo0OGxL+u8YtgHFGx +8bTLuOSPw7rJdooLlK8qW6gVp8N3A4ki+a0QcVKInAQQAQIABgUCVnwsgQAKCRAPed9FPsKd +NXu/BACJmLpvM0dbBRUBwhjPYRPsMCn4DZRUg/jA/jOHEx7MKZ+lX/H1tAjZIwNW9HS68ljn +nmV+pqK5ZH/S00GRugbze39ZYZJyAkMQyO4xv6EuZbwsABD1Doy+po5jZA7VBkJfGtg5o8aK +OBw42xeD/2Oep3VRoX6d1SGGLejVkzRTyYicBBABAgAGBQJWfCyDAAoJEGtb2TNs2llKwjQD +/3MjSRGIsMNz76Y53HlEkvJfuW+9OSoLP/p7Huoh2IK85XSl/LqqDL/kUVuQtp1eahZ8+vSM +E6U50gTIJHo8UEsmShikZ71UWhsMqJzTS8VleOLLuc15+BdCptY3ZndvGamh4QjzmV61C2j5 +Al3JHvye4Biiy8K6cQ7zToEfhT3JiJwEEAECAAYFAlZ8LIUACgkQBjgCIiY/ApyqewQAhqZx +QAuBc5nLACU1RP31ouFw30lC/AOWeR/VwdC6ewh/hwDKwSzJhm7ZrTE//rACnuiQ2CISaPSU +9kNtMzL82HCJDZ3fcia0gtyKomYdVX69mL/qkdSN9t1gnImWVS45rdtwYtP62gJY+WIZyAii +m7vVW8foIJX013td8VdPo0CInAQQAQIABgUCVnwshwAKCRD1Afspvrcza943BACN3RBTipXs +c5Ay5GDWafQ3DeRyy7zJZpCbdbNbAiC3HEtAhXBwNFJMBdgGQZxkxfFoVCoBKFs/sFbtJ87F +cncZehaO2p53b66PNa1QMeibt/iZYSNsNxTLl4T77jFMIDnNQrllFX11xZTlz3WKFYHwvgIf +Y2g6mE3xleuNWKvjVIicBBABAgAGBQJWfCyKAAoJEAZwy4Gzf4mIENYD/jBypKuusV02169z +yJQKJyCujw0HGohmDQ9fK3/4ZyA+RgaP/MQDa54mMbVsK1sDDkRn70uBcM2TNcpyobwat+jQ +mkrTJzupD/ajJUngA6StVYlL7PwmpuZyJvONKz/H5l7y5opgF3X0hLrQAYqaoUjZiB0SqmHO +T+d3AFrSg67GiJwEEAECAAYFAlZ8LIwACgkQ8JeNvg55s52fAwP/Y9hJCPFiWklwmLJbyWzR +A6ago4RJxzuXsepP2wyh/TqyrYVNGY7ZfX3TEHiqVVH3D9/DUfv4PHMkLUAg4yjqhezJmnfD +U4qX/wSwW5QtiFrtITMo2zbgOq6xAL1VogCseh66oxlgyh4QVW2DIL9cluY+OUZjt6OFb8Jq +uiNBixeInAQQAQIABgUCVnwsjgAKCRClT3uBi22I4GWgBACBfcTQEH5T95noNild0MFVhBqt +NCYtpro3C53ZXcm3lNFRHx7epAzizyG6EgbGg45V5SHPrHg6V/AjCALEU5j5sPgyTghprrI9 +9blTnHlkhQhJd/VJQOBPTiM5+qVPtRmZBlhZdSqgqnbDzMXwazaHxv3m9Dd4t6f+Qu3JfeqS +soicBBABAgAGBQJWfCyQAAoJEJW3N9E6FwTQPm4EAKkYbJx+UtuSA8gG7BisqQHjzEsdtgXK +r/Mg8XTcGQRherPllB5DthhP3kTf6M4CMYNYdvuNAhlsRLG/GtA0ymNV6Jo+fe0RHw+RvrUM +x4F0B8t0HiltQZnzuwR1wER6JHJIUIPlDSUtTne6ThKbEUVJXfxH4HzSof6rQU2PGlqciJwE +EAECAAYFAlZ8LJIACgkQemE6xvT9wrpTHwQAq3io0Mm+g+ZX8RmUXc+d0RIwx6CBcqYkWeM5 +cuFCR4bW1KzEK7hPdJ907nd9fU0/8YmBz4OTsR7Sk+YF9GdTxEhtcpyThB1tNOBH8dMR7Bld +cttTZkH3J8YTW6OX03A9GiDLEyTlz2api7A9pTk1wjdR5NM2uLZaSgJSzOgzmBSInAQQAQIA +BgUCVnwslAAKCRBAF12208rV7yIBBACt+K2Kz546QDwE2cKdRe5HR8gy4EmiAbG28vZr7rrq +1OjVWtMRnFB/lga7QkJ8GEo+h15FW5cXADbEHviKoSAdUKqXwWNx05ItLu1VrYiSEwcqpyNu +QB3MOcE+1ro9dnjQ0rfAlcWteeltNB+b8QsujhI4CfchA+imiP7S/8wXaoicBBABAgAGBQJW +fCyXAAoJEGjfFsa8FxCh9j0EAMugts3B5+lDrSii5e/FB24qPtzvlM0ZPO+1idGVTJKU0MPK +htUY0jjLAMSMjgF2LTRnsOYOUtNy14kZa9/9Ea0xMX1nHTyZvgZAIBjuc78vBqyGtmPTmiBl +UxrRrcTzPlVZiJdQC07nI3NDUS2vjH3h9zOfYIHIXBOYeetXPdVTiJwEEAECAAYFAlZ8LJkA +CgkQ2KBqqf+wc1S1OAP/ZDB8CX0RYBrpl3mmPmEEliAHoCBWp7fXrMT6KmDNKvrK9+3saGKH +0EPSI98ZeiACdbrq4+hYCn2mB6gEHhbGwVcDOJ1T2X8ng3BSIcosV6tU4/th1ivqrH9nQLas +5qY8TN1659owKxkqLKYjgvYIHsS7UpIvF4W6MXsrn53tD7uInAQQAQIABgUCVnwsmwAKCRBB +Cc/Hjo3g4Ne/A/9lFr78GTnOwkamdeJCzsWf189RZ9CAhvlCdw1sNtkmMRBejEIF6/5GQb4p +vhsDK6+uBBxlL4r9SRNj9seC2GLn0XusnF/Uqsp1ooo2AlbGOvAPvqyF1DaOjz3CluazzAWC +5M1/TGMiWospPXAvGEAj/bw1f4qKd5vt1gYNvVUU1IicBBABAgAGBQJWfCydAAoJEIW1rdMp +NEL4ZxED/RQ2YYz4v1f0WvLgVDUl7G2htzORDUcFUO2QqTX1LyhrKCjHczR3cSkmMt4CWjAG +eedetwrceZZ0V5RClkAO65Jhcl62Zk6PoWan5JVNXkd8TwHkxtjG8nMFNH4Fld9sYYhuSKpQ +TPOzRZX1qMub0j21/1pYg4f5bFlHgev4cHm7iJwEEAECAAYFAlZ8LKEACgkQZ1ILuv/n5YPf +SAQAvJx4PttQCuSwiHsXf2VxcZ/qBzSCpoU6WLRrZNgMcwQgiWAg6aiSRwGMUHKGMiuxmd1o +FdRztdZ2nHpupPQu9pQn6dvCAmG04qES3ZjLTBbvqFThUPBvGWilU9LvWsL2LfCTkFNvAHus +UqG4TXfRDXpOQ4MPbxMEnjbtiYdkbMWInAQQAQIABgUCVnwspAAKCRBaSYIGHmgCDmqWA/9Z +JaaYAhZMpTL726tREWz8NFPjm8tuQWgsMs0d2DQQVxcZD1mlqLsXPBza1qTlcXv7dIFuguBs +KePuJr9tCk8EYjf9VSWy6ynbQqZ/wYeCY63qVfZ/koiLdrZXeslqL8Un16DJ/4JV7jVjTxxX +eLRhxwMAxnYDuQlRVXWwogXBj4icBBABAgAGBQJWfCyoAAoJEC6daK2d6w/I0WcEAJUXBdgF +qDb1DmWsJMoHdm3qnJ0Ej5tckD0w6cBhp2J2WTkAbYeEYqAJDM+MCKwehk2zQli6k7Ttb0kv +bzzivwXz1P+PW6wyArRQL5v4fq70a2pNzkB/qev/hOeLsoLaicgweSBYqM5yEMNRdd2MY8W3 +/lQeMma6l6depSqiojEGiJwEEAECAAYFAlZ8LKwACgkQ/saqXN3Rapq6gQP/dlC1GGU9ugoW +O94MDiz1ymwbBKItgSVauqHndAF4E+nWJaoMsAlAxvTxsMaDRHk8FdDwLpvisn6nA+Qhis9+ +jT/1mOcXeK6OlzZjyECCM5gP7rphbyC+eScRDYov5/o5g18+ChgFWpmUqK2lSapIBPsYmxBO +cv2DMwK3YEqn4OaInAQQAQIABgUCVnwsrgAKCRBQT3jRgxaLXdPlA/93enMusuJcyqwGN4y9 +JPp/oWwHPm4G+OOh3aCLJYwoGxDFmiF9Y4MEN1yRiv/YcO8lNdBvtDSGBQ5nm8lLvlizJE/b +uXdoGTK+x+5sEqWdKq0+gnXQzrKJOBiU6XIDBL7FRGUObc9ErhvgynLv+WFfjW8JYawQv7K0 +SVXK8y3I54icBBABAgAGBQJWfCyxAAoJEK6lQfWqnhyFi6gEAKk5nnRyA/6RXCkyTw6mKEnV +OKLeKaThesh8DLTuGtINHsF5+ZotvF1ZcyyWzswGvF06nOfiTMOYp5eSmbVStw1cVnrDUcRE +HJhA2QqQ1q+fKKX9IubqWqqJUJik+ZcR43Cj0WvoWDm0F9WTHuW5TQzhJ0fQDLcG7KCCFrKz +Mz1YiJwEEAECAAYFAlZ8LLQACgkQmVmZtrUya6UBwQP/YOhGfnihbxGt0LTIgQeBdv6ZzvIr +1QvSua2OzkBnwzaxVg65FYnS6eHHQutmNoZHSy3Uczb1SbJZQqIHeOGRxD7ATbb0ZknbzDUp +b9+zgugEreCCIrqjMORM2ywpKIZ2qhJ2XnLly3fKGin4hrCv+dM8vt4a47gxneYcmcaScEWI +nAQQAQIABgUCVnwstwAKCRAFJijn0VQHUajXA/9ZG08lrKE66MfnlE8xNSKylndxuPDfrYuM +SPaF+wwokwdW6o2Shdem1MJdW86nOWWuEwFSH85Z5wUJhVKmeUQ2DWfaOdGJ/o99y3iqHUk9 +xV9BkJq4QiaGFIbwXBeTmYZIK/47VYp74uQqMeqIZRglbwHXUaJsZKL4wGDOKmKhooicBBAB +AgAGBQJWfCy5AAoJEO1iJ3MZ+T9KP+4D/R8pCOvNLgkpFyroiPAQXiK6Q+qMguhm1Mrh3w2c +wHcY14Am6l4KpOY4GJ13osvsuBre5E+sTBSnfznMSJ/6ydlgVq3iDHXvRYsbMHWL1vnGgYit +HFSms5K1jFsIEhqmw6O0IJYM1KuT757haIdaOLGkRI8N/COERLOrOMR/KpOfiJwEEAECAAYF +AlZ8LLwACgkQesNavPoM4S5QdAP/bCm5dQk6qp8fU1e8iMZveCMnQrKLOJDxlt6o+uaqNhMo +RtM1iktCdgfK7/6ShVc0eAFzi0IpQqYDsKn0wQFs6pdrwHYbbngYn5l9UvgSel5dgeRWzNgi +3oxHmuTaLf+1k1dfuTOsT3ldnUCoScH4TLUIOnUwleRZ8ptNQi21CUyInAQQAQIABgUCVnws +wQAKCRDJDeRrpePwLHbPA/9FJ001tDN6LzCXYtwZSHQTuEPVp46fcUDiu+gMT8ZDRZtFQMH0 +QeHnR0ecavJTCIni7WO3Y+tDgtFlOIsCHl8hmWZ4pjj5QH8WUyR4ZYtdr6yHkFW9GZgIZ8DP +Jo5r/aMHyyh+uYz/dtFmuCQDeYvGhkkpiPim14yHHere6xavZ4icBBABAgAGBQJWfCzEAAoJ +EAM4kYD9a4+tLoUD/jbdkSptlVSO/RA2UZmPzNPLtrCD2BPR/4kcBVxELgDA/G4Mz7Kp7igP +msLWeNJHU0dSq3j3F056ZL5KJHBE4swYYyPtIpCK7uHwY0xK9I7LsTQ+Llku7+7CnCQOcbqO +H6qIUEbHnWKvP8kihO0tJBbDN2Zo4isiytmnBKdPoAggiJwEEAECAAYFAlZ8LMYACgkQfFL6 +AVk7oQMR0wP/RWOZXRobDoYgZBPRAjH+qJtF5NPYNwBUni9Xrm9jlP8LledSzNw1cQJD54GM +MzmjWSNLYQKdNrfx7pKsqgkL6Wu02isjtXKKa15IBKb3GMrhO/IhRum6cWeGZ8g9a69cLmrG +n3xY/MqF6TKL6Zd0r5GrIdIdITX4AELXW+PPc1WInAQQAQIABgUCVnwsyQAKCRDObViToP/q +Dw7HA/0XRcQwGqFY05xks6ySV5zBUN7yJglhopuAAHuQzUZ+/MjwQVTAiJDLJyc1JQLXDOJ3 +rLOtWaa3vzJMIsniZo9AXQ5iGms2C+n9Zju60pJ0pH99y1fa7yKZGHOpIXOPZ/d1sUaFMi9i +RvPBt/oxh+9GfwYc8Z2NxJCFCWUMciRYaoicBBABAgAGBQJWfCzMAAoJEH4VCiMIHSRKhX0D +/3WbtPt6JtWH63kT5tz7YR8anEqThDaRZHGtlWo6vkPy6oecwmp2j0WrYUmp8pCYQ7EsCIrY +WG7UHESjXYyZLfauzEAY+AeEoDzHhVt9oVhjUW7Ai7yLnHB7lE0GwGEgKbimooOIkKPFeO4K +WDLB3EamJs5ITGSzykzQRqugCNWqiJwEEAECAAYFAlZ8LM8ACgkQo7pCBdNfxIirgQQAj8HX +Hx9gRPmsyrwiPIy3bVIAAiVbm5+ZgsstxePZhwhKDCoC2BvuLKmUVYkvrLj8mMfVfNudRQFO +24ZQqsDOqNtfH+oxUVRq8QW/Dt7LHI8YgfvAWzEuRoml1jrsFUCk65xT11FGuecd8vhh32MR +E3xnNF+lftc/DGroVlPck0mInAQQAQIABgUCVnws0gAKCRAiqkD8VYISt38SA/oC3nCMeyuD +glT6aS0Szb6l9yzRJ+L02J37XJO4RwBdml4yRXA/HlGFjgtWZUjKljq/ide0xzjvrgqTFMc1 ++dLU63E3Ys/OldB6GWUDpIoYR7DseXqbLzI1ibkab1hONgNLKo9yG0fquj0euHmsLekGHoky +zJWDsiGGYzTZsS9jRYicBBABAgAGBQJWfCzUAAoJENzU5P4zIS+XixID/RBrlmZr6zntomdu +dBNkxiY0HfOyMXLozhO/JECg+bxq1P8n5av9440oePl3C+lnrS+kcppyHtjpK2OApM8co4kv +LMzwIHjHo5Qvgjz6/+F+1HGTn+swDXwfnoEFMhOaYVVsH3IZ0+rKHZX4qUBmdxSKpkhkD0DM +ESTYDyR8VZ55iJwEEAECAAYFAlZ8LNYACgkQdbvE2u4TpERlWQQAnCBO5GIGW9Kl4wual6Nq +txrI6zCA3/1nl2DLEQTKdXoiyOXlZXHeh5VdMucqurOcQ9hfXVeksbFmKOhYC91TD84QAPve +aL6QKw4+ReXX8oA2aibKs75t9x/88AOsRLQ+BFbiIoTtRhHyuYkle98Lo81itumozRrv3oDO +pKvQKsWInAQQAQIABgUCVnws2AAKCRB+7WIH8bBX7d3UBACEa6v/FWO2lNRundMDOzjKRJXM +nNjtiNU0fs41vk/HE78FE7lp85tuGmwilYz0KSzEXCe+rnCRFicrwN/U9zRNfMpazqZdn6pG +y97z4SIk/0L0PkUc0Ej+EBaNivRDx2jlm7QRIIcNvtwN+BZt7pU7k5o7Dy00VrPTQgng4hHc +IYicBBABAgAGBQJWfCzbAAoJEMP2sOS78GyCqQcD/ijkb9c0CqlJiI8cpuD6Uts0T22T7Vvu +CYQbQAEthajaxCGx55yEQt/0pivvrCyS/56yf9zWVvDbxQaPvCoGf3NcY3MdSlvWat/Olx0I ++rLa1gEMRtCOSrECGIstJH0c7YMUq+DqCgJCOAeP3+Ytz39CfftOX/Fv5hmWr3amzuROiJwE +EAECAAYFAlZ8LN0ACgkQovmpkuDF2GJjeAP/fhNhe0SsVVvs/b0nkSQBmN1yGIpq/fY2D126 +c8Du0a41xROslQx2BhJoJCkGBcHM1nxwdK9hmDsOvxc6LsthYRLa8NEO8+dsQnqdLmkq8NYM +uJTpelpzNSkuef9gUjYhEfFO76qURhR1ZQb8+XIvkSpQYtQpZzseEpuPa7MK/1aInAQQAQIA +BgUCVnws3wAKCRDcgPJgggmqHK2ZBACOaYZbSoCHSX0JNFJgDH9IMpBD9AncVRvVJ7KjLhO3 +/AADcKqgnCokKdXRo7gv7AM24qCrAKNe+tc4DPWQOleAdkhYKMIVWKAhZnvmNgrDQrnm8FGJ +aWklJPKasyXcCut8WYUMBUTRqfH7T6CTWaBOQXLuFmNcV1hKKSGkcQzMF4icBBABAgAGBQJW +fCzhAAoJEPcVvommFM4iU2oD/2tJb7chMoJrR4BkLHTEO5IYQV//G4FiK9QWNL0SwWeTM2bK ++COqgwPliFXYFrVUZYS3/pheNJ0kEKnW/1lOdxX6NA84ZMSNDeBHG8gSi+VvAaYogRINSwc1 +TJW1OHJ+2yS84NABUCegJqkLBbzZIHtPfgu745uSvCMPW4DDncASiJwEEAECAAYFAlZ8LOMA +CgkQ7Pml4ikML6uwZwP/dkpfRbZCptRTkqJswuodw3zMGlhIxsLP3Wi0oLUch1YCFwo1iWGO +KTV2UF31q1YiCt43bnyRp32Ya7qtxuYNcm/q8RMiBYQ+RRT9GNjshj94vXInRpkWQnq0eHuJ +2zyJTbT2fkVYknqukpeq0GxC5Ac5cfu8sEDQyaPe+ifkNJuInAQQAQIABgUCVnws5gAKCRC8 +B15ni8k1ZbZcBACr1I58KXETJxAv4UDgLO7RglxhAQf7M0MewpJylv5RUkGcOGak/9KcajqL +DGgyDhv16n6v7eWc7o7P1N13EOxdC6Qf+Puz/VegEstebyc9oTwyOmlpCBBT8YQqZTrR3sOk +nrR8PHdicMVP6F9prwwPXc4ptljtFA0+eekpCrTudYicBBABAgAGBQJWfCzpAAoJEKxZbkKC +Sbnyu4YD/RV1A3KgHNhOm+j66BqeEhLMqUAeAXEN0xwwoye+MdTdxOjfgFrgAjkmrYYsYOzu +kf+9l8X0d7OPvV+PKUU6fgseOMqqK++S9NaL4d3j8UusFyrFBwwKUKXUIGgLxQM7BP1J6o7/ ++5CJ2MXvsmALhJyQudoMxJTxENlzAHA/DVibiJwEEAECAAYFAlZ8LOsACgkQl7yRcghfVFlp +0wP/fMRXb00UEgMpEuMd//eeED7OGWEZTlwdeznIhpcWuxl9jmz3pZnZh/xp24vtx23PqRe2 +uCh+inOh3CsYKFdvqJXYufkb0nyZdixkgVvAdLrCzPXUeS4du3SZ/vMndGfua09diOhIGpgh +Pfbqrsh0FaLouPRIsgkS0v1SJeXE7/+InAQQAQIABgUCVnws7QAKCRC3wzrBGbAeW+fOA/0W +anIxaQBKBj6F3/5Qf0vjV/7xTHqz7marTFR2QSSBLRLwqXtipplmpVpnjZglfDRZHWatWCg8 +bEbG/t6RdTPllHVgRsb084nb9DBpfvOrxhN5kSU55viTrLKkfMLqVPAp94vJoZxX247kP55E +XdsMH6lT5WyEWisuykygddNG+YicBBABAgAGBQJWfCzwAAoJECjW2EIFXkedrFUD/1O4u0Pz +pyh/MNItl55WF8pRDqsq1FC4qWXLEfUGjdwV6boOrAl+LgYrFf2brBer3c+FdGA7aCtKCYD5 +MlKTCALijOkJJrh2kHDXmim3EYaUMZXOULXr+9L0SVe2z05MtMeE1koRJSyUxxUshPYVoGOv +BJtc4brxS5TWekPe/HseiJwEEAECAAYFAlZ8LPMACgkQ8bBnmYzJskbzZAQAqO/b0IQzPch3 +wp/whTNN2avRPJ2xRAzBuVIElYJIRMSoOotOSk3eHaFAnjB93EwJ/TIO8pnaeIbSR5uvNuoZ +CjRnWpDvHiZcD9JDzriPNoIKpvzzcjotUnQNebAMR3pFQ8yeJT88rUJ20NWB53B+it3ssESf +ER9NTQwPvC/Ok2eInAQQAQIABgUCVnws9gAKCRASF+gJvnVnB+liA/4mOoNlVfsuxEAfo4lC +MTRizTNWHhm1vOYBuwpkaQmaW/d4MTY2qHsYDd7XP/S/ZUbNHnUiwO2AlH7h8GJk7tjHIfqi +GToNvPdMjHL8Pi2E7yRkvsYgvG5yvQLmtr27yv3ttGZSIQE+VwTRwkiaJPRd5bPErbw5Ja/U +oEV27+O3cIicBBABAgAGBQJWfCz5AAoJEFNzS15HeUu8AGYD+wTwbh9Nz8Ze9QMTG4HUSHuH +fTZZIYt7af8u0wgj+jzEUZ7lBckh4UsP5Ca7LOghOjmtlRDZJAt391WKbryewKsPWU+brMAJ +ZPtzcHAp7E4uaQo9pbrBlFFcUGoToEfDC8RQGMo+AKj7zdPTZ72EbOU2S/M24rmuyc3/WsnB +oYiHiJwEEAECAAYFAlZ8LPwACgkQo4HVZ8KbdCdLrgP/UdVl/k7NLz0UAdcqbpT5PPfdelGV +Tw/ijWBMyhn5ULS1OtEgLDJqQM7NpeR9YRmSQkA9TJoli8ytoIu708L9W7wSrodpFi0HNhOF +OXtwbjysThaiTFoLi0pLjLmFWlNQdFXiEfSFGG+reW2VPAzW4R5Qq1VcQdyaVhZtr4YkrnCI +nAQQAQIABgUCVnws/gAKCRDDvwvf0javYTlkBADQYsBRey60nGw46R/7M43oMwOTfKA6cTlj +Kh1TXEMq3Gvu2X2LRfO9TikbFBydFnilPoQuDQy9APAaw69m9QWFhIuIJ2mts2llabyHMUET +g4XEmA5uGm8Wp6d3ECS70j4hYzouMEnUvTFzQQg3GF0dnqJU4Tw8B44q1QZ5EVorVIicBBAB +AgAGBQJWfC0AAAoJEOusSeLbjPd4TeMEAIJ6hK3TsjylRoLCGft4X6CRzYYcUW1dgegH7WQE +mdhGGanafX+IX9tEPyCNnuxoEB3Y+KS/Q6luxqW3AOgmvYqSuS3ywx5hGEyO5CyYt4bKm5ZX +jOAam3H0Qm/IuZp8jFFrykiIo084s1pLkkA+PloVtTSm1HiSogvoMUAyCWC9iJwEEAECAAYF +AlZ8LQIACgkQg22gAQjt0Mm5AgP/TUdSqQrWlha7jOVXKKlCgoLRPpTjjIwELIMckd2PTD9m +sCzzdqIdXfwDtdBwJQB6tFwDElkiG2FhpLqGzj3EZopYqiLvwIfFmK2K5cnQLOneXnPT4AJj +V6JvnmJ3IVDjSjMTYVqRPTh/Q6/IEqnGGPX+EdANfrZCShO8ruUoo56InAQQAQIABgUCVnwt +BQAKCRCVaq98VpTzYsN4A/9rDOE2hbsd9upHkmF1Gc3HHiji+rmOsvYAHVWd7VK+VV5R93G9 +VkqT+o8q8iW+UrdXFha8BPOuUkiqDi8fUiw7VL5A63ZBNQK5EluPU/EQNyRI4LBACBmACuBb +l5+9LiIaPw5fP+dQOoXl5LYSx6NMT1cTVXkOSHa5yDsMPhzujoicBBABAgAGBQJWfC0HAAoJ +EFssQ7evm3qZQyEEAJBC3CvD41/PyQE/05JfjWaJ3PLN4hfctQO+k+lsVz8R7P6UONHJcggi +d8l/ctTY8dcMrY1dnexkjehAyuPr491IJD71hPfctsVnb0zGX0FO6pNx2tJeKxJpa+6zlVWM +dvSqavdllbmAVQbBCSWoxaAS1B0I2/WPJ790OHoeI7N+iJwEEAECAAYFAlZ8LQkACgkQSEyD +QZ9DOSVI1wP+J5LZWhAI8I7oe6d3+e7lrPCoHJLv3PPgyskWvAuTSWtuy/zAlvrOrN+DvHI5 +o6Shmvt3HT+SV9qtsjOvla9XNBbVaH6BnjiLLejKd72PYijrmD4qgKQxP7vdNurZ6cnujIDV +Rla6MFZv8fzDAQZABrE/cYwHFaLeneRveK/5Gk+InAQQAQIABgUCVnwtDAAKCRAd3jvc4dcv +UeOqA/oCplXb2HfhLad+DrnFplPl6OLMXRw5SAkCLW/T6Y/00/7F7PgiiJnn50DtezwOeufa +aDxKTSFmKFLrcUyoNKjZULDmalU94ne2h5b1Q4ys/h5PkpAbaQc6yRaW5tqUtyCFJvRIjYsW +7otnkYx2m+j7HZp17SVajGiwqXvMizk9PoicBBABAgAGBQJWfC0OAAoJENG253uIptur3FAD +/iSKzwtwmZ+SWpkjgifhbJOUMsN1R4fYIDT746NzoFmHhm9PiWr7F80av8/fjnY/aWmRggCs +SbiXG0OVj2LxqKVuuqnwnwWH7auSvkykzpyDTxSzyAnXVwF31ovoQ04SY8A3D6GAmIfjgiMd +8Dm7fbqFyngMcIEhfBw+I7g3MDSHiJwEEAECAAYFAlZ8LRAACgkQ7TLIe8kPn1fOBwQAoR3U +ise0mC55aIcfC3oMzm4CB7/+JcbcUGFAKqnIR90m9RwaBf3sEQdGH5zoQaehhiGrN5HR1aXd +W8xPzJRp2uXibBukduXotU2B9sbpVDtBW54i/5tWH0gN3LNB9C2dX4q6kRrrdbrlTb/Kxbz6 +WqmA1YjP2PVZoWZ6yuaUklWInAQQAQIABgUCVnwtEgAKCRDP04iSyPROI1i0A/sHfj2cJzwd +3txpgyH6fdNZpi/fduAIbqkVOBMItM0flCWWRYW2nJFOT9VWZGlD06cO9msNmbsUTAAQTIO4 +Keq6MzKlMJ55XFuUHXbzikG/RkS8qOpzhdL4bA1dj34DGKEXu4i7/dozL8rgN7AlUBYeR/ZJ +8W6fylAsxqFqeBFm9YicBBABAgAGBQJWfC0VAAoJECeA3SKnyGG5shAD/1jlEfkZHFsmivcO +bPL87IZ7iUttcPxg87atE7RU19f0wG15iS+K0sneccwj834hVkrjHUAySQ5sZq5Ph2qoQ+pG +XgiEvqimtCtVqEovIyojW2G22tD247TH4Rxu7PvOwk3jz4BY8IcoqNsw44Dr6YwJ5Xej7AsT +98HidM+f9L8fiJwEEAECAAYFAlZ8LRcACgkQev3IpsQTcmSHEAP9HR/6FswwmmXU6kc4ynmb +uU92zA1irFR9J+JsJlYvNX9god9jn+XyJAyCl3dl7gKJbjPnNzNEVStOXDNw6EeZtbMU24M3 +gY8HZqEOMrJP7oT1eDIBCiLXyshPcuC6Dc2lkWl/5gTB3aNs8ZyLzVrv7VdRl1FXVML3BwuM +BQnY0xiInAQQAQIABgUCVnwtGQAKCRDHzzvAtVEl3Bi8BACPbS/bTxa/K4LsoTjT5CxDXJGI +TyToj5ghM0r0EqQp5B02mtdnsdD+OO0nuFUBwSrJ0mNyltluptGAc9FMcSd4xjHwz+zXINBI +LjrgEOwKQ15cBkHMmiorxQDwj10BPsG9f3m6+khNDuPy6tTp4eRuK7+DA7Yz1wNGan+9v8Cg +VIicBBABAgAGBQJWfC0bAAoJEOlfGouqFo8X9eoD/jTqPpaiWE8LyttPbwu6W7Mf417CRsqT +mROsF2CZVXLuWPdznyFx1wOa28O0Kqb+B4o9HHsE02PRL3lbtJXRIX6Z0Lag/Q3yrUkE6r+4 +bcy9ZXGMzSLMoCea/LrzI+aXe1fiokevJELwak4z5nIT78/y2Uhsd+ANqWG5Wrbhcu7TiJwE +EAECAAYFAlZ8LR4ACgkQ5NszzXuZhwi33QP6A3i4TJjNlfWNzhUnZEz/rhGcFRTLNxQ37RDu +5ystcvP+I2c6YHtxB7VQ8R+qtw4HKxweADuSEXPpyvC0qE8D/q4Z3exW7KCFv+BNhFj1PYft +7LackCOWBjENVYg+6RByx0qgQt42SXjmMKtyR73xEhEfEXtMMYxEjGy9m/nuJ4GInAQQAQIA +BgUCVnwtIAAKCRBNvbF70hUAVTg2BACgC4hZxyQGTwRtkw1xj0eEPszIJbQAjlbUlK7P+46M +fOwZO+H73/jLXOK3uSjTnd9XEm6/bZb158yBa9LGRuBGJxRfEtiGPDtolFn5kZAht8C9eNsm ++0QlkCeBgrC0QFkYANS2C3HqNrXwsCHVnxmyA1SpEXGbCgouMCr72cWeGIicBBABAgAGBQJW +fC0jAAoJEI3pq4xNa2P9em4D/1T/NFaHIq7Eyx/jKFKzGbwfzmKAqbPo+ECVUAMOa/bSWDAR +YEEvMkJRb7uC1arfCjwv9RT59F2DHo0sdS+hBzw4kqBX6ZgQkcMgVc5q6MzD1JM8xGqziC3T +M6SFrB/c4SapSUSMIX3TXYBn4I+lYzxJuoTUgIL7ZlCGGSNICtkbiJwEEAECAAYFAlZ8LSUA +CgkQ6Fzo1cHagd363wP7B+wnZN91BvQtDDe/mJdzJTFn1M4U+w2TB27F4HDygCn4lndpcsd0 +SodTOEZ1QPO/M0zFLycKdrNZU5+We/sL427KWZFNnhYs4syvbRt0SdGDmTdy8JSuBBwJNE5z +54h1TE6SwvV4b4cMfUXab9bygCiAuT40sM5xKV0gRDd6g9qInAQQAQIABgUCVnwtKAAKCRC2 +QyZPF0hCvRI8BACDiAFU+FQyTD5OdWLBhYgzAdLLf3LBtE1LGWqDV3g4DLe6rjJ2FQR/4K4i +kIgvnkw4lv3D1F33LZjyupHYpdZD0WH0Gp5Ym8QKSBOSFSi0J6oLHoUK1exbk5z1Kd983yIy +cReloKVfTBWmZMWKf5nWDgt8rV0Gb9Y7lX5uhy/114icBBABAgAGBQJWfC0rAAoJECz3ff3J +op9IW+IEAIgLSOmkl0H0O6c50Dpniqk/QlsheUFlhw0P9f0s2KIGXb0FOuBv9teO7x9dKah6 +fpiRas5mVpBFKY+vs6Rqch9DYu88DXmNSf/iGInONXCMErmy5TeorCGZbjPPa2cWd/RxYfTS +SjVcIfIU5y7PBpT5t0j/8IvuJwtoBnkpSXWjiJwEEAECAAYFAlZ8LS0ACgkQg2hHyWnJPy91 +cwP/dxK20+eR0V29whuIytVkyeUDiqYC3fWCsfVUUnP2J+GpeeGOQYFZ2lAkDEwwYr2xdt5Z +W6exIkhYeNmyialPxx5UH2ojuGivuO+C2ji6DZAD8RBipAn1oqIoSHoU1kuc8bDCcGzfpsNx +npKDfU0XnpfjXTh3FN0tU88bAcc3px+InAQQAQIABgUCVnwtMAAKCRA+Ghg4jVhyMNDRBACW +lCvP+o9YZOmmOefSSNscR3zjN0u/gU5uwSy9RNF7CjNzPqsKbUg6wfDOvqS10ldJ3kIQQGxl +0BJaWrOKzjQt6ZBtGKyD0QVT028SxhQ8Wpx9miwBm9mmDzqJZ/DYivkY6Y6YY8A7JlQIy0FF +5dqOncfhayJoDqRqBFxC13eEHIicBBABAgAGBQJWfC0yAAoJEBI/iwQFTOUvcpgD/3K1nRKg +7U9KwY5+lHgrfpyP9qx0NRq7nTe2w/TmiJtIXCLe+xOwWlK9Jq/K5JDylkqTa+MrNgX4Rnld +NUMB0PiTdA3fAMBI1k/L7xW4h1NZG8m7bWVwDbqBeypB8OSMyabXBsSJwUGVjg6xYiwS24G8 +diDLaXyEVkXl+4WhQU0qiJwEEAECAAYFAlZ8LTQACgkQF0EacrSIH9uH6QP9FOhgEKOE5+fb +9vuC9FnemnXbF7hcsuXN6E8fP1lRs/N7LGnzNtf/axIYWo8PKzEPwYmHCO51MNBU/1ZUv0CN +c8TwEbnh5RHAwNnuM+BSqq7X03HkaP5BXaKItaXCaEYyS58LXwzku/q2H2DWTWivxQFvNq4M +ldMm+xZVOiS37y2InAQQAQIABgUCVnwtNwAKCRDKb98Us8GlaearA/9WajqTUbNn5itFsizX +bniIexCq9VZwjYqvldqVpQ6CnM8/qxVdkb/Jedo0cyxGLVI/zHB0w/isOgBDdK46oDBXmzw4 +0qy0jZlIYPGrFCu/DZD0R4gg0thBbFrAjZ6WPxym9v7Czvb+MrTlNH2WB+JdZObkTyUY+mGF +cuELUt/gRoicBBABAgAGBQJWfC05AAoJEDZxsOg0m0dxqCoEAJRCFnsWPIeZle/gg1o6BpiX +FQpHwaqrmJeDV9AtJe2LssfjnbJ88n8gz+Q7VqCg1lgUS30uC75UvcDL3mkEmC+jF3haP87q +UEeSiGBxICtUIn/0/HT9P4WwLTsCr32mpH1QFbX5EzIpe15Q6xt/9iePuonpIlCN5uNPTTqz +5PXEiJwEEAECAAYFAlZ8LTwACgkQptO0Z38puKUkxQP8DHbfCOF91B8tcW1NchzHWNgsOn+y +HieJJlejh8FjF2IjhMXHtP5Xzh30WvpTYrxKLbOCpvuZ16uMs/xJvXVvwxcjrlmzxLQkMWdT +gz+elkiEAWqN6iKjA8+1dxzYdg021bWRjc9CwB2u6CgBGuPDknO5JrUINwZBfa7Shy6KaSmI +nAQQAQIABgUCVnwtPgAKCRAbGrsWSJxXdz9jBACFxgCr84WhGm84cWvg4CJrB6uqWZ24OFk+ +ggn2x6ILekAw+nzZCIj0w+Jlx+brXeGO6/pyGtDaOTf37g7D14pKKRjGljA1J0+S11zMnK5p +vV3OBbi9rt/HGiLHb4M/AzorGJ1qZ9a6VNuwiw2YYpOgwCMBjZwiEwCh14kEgKZHoYicBBAB +AgAGBQJWfC1AAAoJEFxsOPxwmC2ZZrgEAKcJoUv8iVAFxCP/slV010ZHzijgmEhQrtgyZOhz +QD40R5f2OPNHU5BP0EEXZGT4NA5L6Jb+CiXCq6t3QXluo2z1L5muIka1FgoA/dDS6HAcm3P3 +xdHXwonfmZ4FSst+yRZGX7tstiR2R01Ky3ZWhTkccngINmKl3VKmbvv2AvkniJwEEAECAAYF +AlZ8LUIACgkQlfAVfvrvVTLUQwP/WMJNd5sbc/bTOYGnihczGt5ieKXS3lhaF3zuTM+qlWK3 +5v/tYi1M+FIw1gqGlMDO8ASw4fodkyq8mPxb7TkFP59s8anpRzEiXJyZoiwY7wJsTWfK3BCS +0xEEUARdUw3zpGS3t3daMVw6SOPSNC30QrclcXsKN8/1IHgG7a2bX66InAQQAQIABgUCVnwt +RAAKCRAuj1X5VaDGL/GzBACyi9ePaPPugSYnTt0pMCVFQaFtQWJ4NEuZyl4TSOca2yYlvrJA +/9GcG+nbCECK4KwtqRA3cEoZDWaTTLiNBfUum7F4Pw75Hkb2WCRrmyssPSrPhVm3NTXItePU +Bu5lAFYyxk2mYIXkSew899HEjUEjuk7RSx/Mnpa8Fp7FikqTJIicBBABAgAGBQJWfC1EAAoJ +EC6PVflVoMYv8bMEALKL149o8+6BJidO3SkwJUVBoW1BYng0S5nKXhNI5xrbJiW+skD/0f// +//////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////iJwEEAECAAYFAlZ8LUYACgkQxp05 +gJwOBJn4lAP8Dxwxp8XveeT5vZKlth8jN30vo4sw/maFfVZhZRfvEpdXdEp9MIXfKvKZgCCY +rllHWXP6Fxfk0fg6g1ascudZoh6eBwwlBsZHOJmQAYkfi8pwTZtckFMlRx4zozhOvDiVrjxg +i3YLibO4UwW0DvX0s4dnT3uSzxODeRZJI6kUNauInAQQAQIABgUCVnxCSQAKCRAp1gmHCXhp +sIpMA/4zU+Fmh25kAdAzS1di5IWZEbJ31ygT0oomAePOr2PTlIdlaue61S+JePOtFi0kha3f +WZu/EQSWseXMv83P/QeUe+hJ+oIcog4ssLPgMceQ6ROk3S+XcqOgF7fi+6I+RjrJuUpo3b90 +HwBgyBvjg3ApR6vnDiSqn5HAp0+DGsfQr4icBBABAgAGBQJWfEJLAAoJEF/djRUd+19E+hcD +/1E7eyG8p49hOxtJmIgErnuBb9aEgyRa1Kebdc9cCqd9vjvrbpJiuPPlb6gbUQbaxza71zIO +gpxIGRbY5lRNv6LAQVIR8qaVnjjesKGB9x6qYDfMC2pBKxyXPlsbmQJaj5EGoiyB9HTc1BMS +NX3ON91vEjrDM5rjBDJmRsZqEWmviJwEEAECAAYFAlZ8Qk0ACgkQxMP/whvVk7XteAQAvHvA +mq4YS5X9KCUPO/jaCGT52+87zBz2mL0i6TfXX3zhMRXPWBocTdqokPUr0JKRWQYYgDBUxj6T +SfdtSAMGLIQubXzn6NUGOdblb+zZJ+/3SNIuhm4s60PEt2sdbPUxuAgGLjhYh31S0GhijNU3 +vf6MdLIxFxySTgRHu0ttS/qInAQQAQIABgUCVnxCTwAKCRCTTWRpjIpqKZJ/BACCMzr5Gr2I +39Hzz07mE5gl6WmHxSgxCqsDzRAkSAYoLyCz3+VY5TEBA0u76GZ1tk0sYcpUY8QVIu+w6vYX +3ZKeY93Eosh7aql5oa8dIo/Y8X8tVLUW6Hutp45v29yLd0qL1MT3LQENn/qKnpfE/odT5fhK +BShfZbNEdRTii3Z4DoicBBABAgAGBQJWfEJQAAoJEARZCoxrm1Qy+70EAIOBpHnT9TJibkNh +bqcHWTAOY0+ioLW3+criTBasUrziB6/OdR5NLBnw3ZH/kLvDKfwEcxHmSYPodRnMuNO0U02A +eivIEr5A9/BXUUzWxhNJBdFI9dQZq5lnFASfPVJ/Bf1wYUyScUD64ZuVTt7S97EDT7Rj5/rA +IfIdvEaSnzdziJwEEAECAAYFAlZ8QlIACgkQb5obj5xcdzxk3wP/UaPUx86Of6b48+FicmTz +PsqNn9Lp9lln1NxXhwmfHRbwAEmD2b2LHRaPTo4O+1Ok+bo4tul97htUUbTnBL6N9BBNq6tA +8X+ety/6o1BpcCr85AZ3uy7RGAaRyWPGFw9HCC1mAsqEZRQdx08zHrZb3T4s3jwdBSa0KFUC +pxFvtbmInAQQAQIABgUCVnxCUwAKCRD4AZWQioZuDcBABAC4UHhQscyKykslVcFmHZrYpj5T +ZocICpEJwxSCZr9N37ShAwzSDkNHUAgA9RoF91YmT25lPa1/B649dQOenM0t2fAUNaTtbSHj +w5OxPdLtFkfgO1rmbfFa4AWpKH8OKAPdEp964GJWEqCq2UN4x1EE8UjK1YM4PvQxjb6EAqmp +L4icBBABAgAGBQJWfEJVAAoJEE8+zqN0FOQgx4gD/0fgofqX64Xk7O5NKBG3tlpVLI4S9I4H +3cmSQulzW+iCQalvJad+5B8VvaERu8K18uuUyZI/etIMG60Pq4mwRpGNhJpgs0x3beCLmx3W +vWvN0s0PHTlPir3D2RcxS74xbGNShS8Bk9IajAgG0ItdwhxbLXNRO37zSTY3XIeCO1nUiJwE +EAECAAYFAlZ8QlcACgkQaG9V91lmkKM11AP9Ejkb1TeHbIxrv2sVed1cSBvo7j/NcVbO/u/L +fn9usebsWP7zhKtvH0wAPvyIsVv9Fu1XlxDJED630wV1Ud3yFyISpnIYhFT5wCHXSiR8jjqV +S1090/NwBmdwh5ZqdltQDzuEOzH6jePvn6hxkyOok+CdI/SYlil7reAcpBKaS1+InAQQAQIA +BgUCVnxCWAAKCRDGJjMUnX05ToydA/4uRQvnPhGGPG0XaoAhpsLUKriIxNKovaYFSgGErANs +37LOSVyoWorNvPdFlSTmDniRp0rRM2l9IcG1MhRNeHSxOxRCIit2+BXZ0tIJC+kRrh2bD9zj +oeqLFkaszIJF1JFg8NWKFagzwDd6CfexlBjg38IR2vSZQagkOKLvWB55kYicBBABAgAGBQJW +fEJaAAoJENnhW343PA2yH9EEALnqgvfvjXFXyq3LA9lOdKo9njHKybDUnl2UKa3/C6J2zouw +Zjn6TQGG1eWkS5gYNE9Ll0Cc4gM/RLS/Bax+K/mTgxHuBZQeTEwuN+wHzeBMER8jvO+fTYNA +upBkIpYE0qMbZdp0Utd7F9GjZHV4gGDkUPTTMmHKJ6n9Yzx4cgB1iJwEEAECAAYFAlZ8Ql0A +CgkQDo6RJsBLWNPRngQAjVpy83g6EJFzDOdV5WATNY2jaPoy/+gh0pVCZxClxQmWZPVFCRkV +pmBC8gdOWT2rC1daZ0Aeehs/lz0KicQXGVqQYCQ8oDdkPid+AXhJrbmptd8byNMpaeg8Wx7L +K8nhqcvu1fmoywtRaLfW92sxakBkSFExXYzV5hb7Lq/FRoiInAQQAQIABgUCVnxCXwAKCRCW +Nj7Q4NB9AEFTBACOifMkvj96V+2955wqxygbzwbLO+8nSJmKXYOCl89hYPwOsOc7mk4mskQ7 +ADCkZ0cxDtBtUfBbndppwE0W88c4PqrBgITwExC/qKa2eZec08eybwtPSeS+DmUBzfZa5Q1Y +sBdoKj6BhoMl4ynwRr8wvmE7Ik0j4HMaznmeaZ6HaYicBBABAgAGBQJWfEJhAAoJEFVaiejk +oNY14wYD/jVFc8Ugwji3zNMm7+QUTkLKGUOQeIsIdFT0sxHvC1xVHUgtrZ0HAZG9wnIwkCAa +mGBI7Eb7TWPjedXuUKClUXykIckkIkyQirbgIGaJULqsCjXhcXrHqVH6SyhcHaW+LheeGGl+ +JBXSaXFCU1E0CnLQFtt2MegtAftC/ZM10AaQiJwEEAECAAYFAlbphXQACgkQG8nv7XJuY4u0 +mgP+MxieepC9XFEzV8hmvf/AMX3TAzVW6rKrwoBvKseHiggRRRaleQzaHVqrMXc0zszKn8Kp +qMlhk7GE9/uot4JAbaWnnQw+cqtppy1Di81um8iCECdsFPpT66zykGjkWKH2fWPK2Bp1nDRT +KkCj8/Xct9riwWHCRc0g8TWhVOcKeWGInAQQAQIABgUCVumFfgAKCRBT+Gu0v0l+JTK0A/9i +fdHBNC7166ciY4C9BYbKVpidswGD/Hl3SPdD7JHQiEkqVCLfdKM2ietfrmh2ZWMecaOzTIuI ++7skCoZUjywrthr5dFtvZxf4Dv/pYkv3yHZWBgEuy2Q10O7aIlK3CL4E+MB9QXNHJk+D0/Qj +VCJcb1gX13r5ViOPiNooCcDi0YicBBABAgAGBQJW6YWHAAoJEOBo+HF5GE4CwtsEAMo65hle +wH4aQLgRjWv/3J4XzX6QaWwFBXWX1JrabsJ4LnML59SWcqPdIGscjIjdR++KwK6wdXhSanFG +beRza/K8jUciHZ+81QWf5UtZjyFsxdaeA7W/h2vxt/wNnIYfby2VlxHSNHJcxyaDoG6o8wuf +t1NSl+2AHjVM+UEBMk/xiJwEEAECAAYFAlbphZEACgkQoRl2k6c9snTrfAP+MtxTEksmiRMj +JWX7ZkzejMnfQ5IhZtcU87r2s/20/sUiXhdWtYgVxRn2tKRM5/B3TMvI+DEwHHz3Hyf6pm5f +jTyXmCJa8uyz+1PLROBtyxWYc8hgDVOu89zIDVAgdfBdqQta5H3tNiW5UgdTOKW2vTsF5cWO +L+3veaGZ8LWQuGyInAQQAQIABgUCVumFmgAKCRAbWyG3rBBGNqVyA/9Jqw7OSmR6caaUoHFQ +b/oedF8HwGJsSnjMdBaEENsNnfl/fvNDrRgyHDVKbx+ZjbnDojDmHbzZy4/VnktUj5W67LuI +0V4/1tM9mhFxlDvE3z4AqRPeavzUpyk26rJi7lQPWrt5yc5ZKRdiOQ5xkRUUxeczV4sqxaUR +BbBRBksKWYicBBABAgAGBQJW6YWjAAoJEKNwEILmGvS9EicD/1Y7V2GMLte0OEl9CACkxybB +Iyar7XQLm9d86fXPzVWEZw/QD1Pk2woJHgFKKGHWxU1Z6n0IZtuQPv40ABUf8qZ0iVDqqTdt +VJWbHR12e+EkDVJlGAJwpewffjaflimg48h7daKTPV957S3Tkf2dyosxNgT/pCkrU9gxR8v+ +WlA5iJwEEAECAAYFAlbphasACgkQgW+gR4QjR8rq6QP/U7AWmRccVDh0+0D/mXqDRk2kdpE5 +iCiD8aLZuHoBRWZL2b/bSiq7r3l+3DiraJ+BwJOzSvziKdTPMc4pa4Dm95XVYLptRzYP91bU +NV1jzkY2KpNXltOp72KKrw+luJwJreIyzzltV9FsZMNEBlO3BokW1QX4RAIWEMgWhDWl0+iI +nAQQAQIABgUCVumFtAAKCRDt03J6j078F1LLBACoF69onlqgpNcUkhr/d5RlTldzPlVy9eBc +kiDh7nY5FAhDy89SNvBiqFOeapqiZAJ6DdgA1q7hJn81tCoFoZTb+ZkMsSiuEFauqVgwF5T2 +0py+v9GUSEqV2py87A/eOh+2uba/f+7XW+mruCwsYpvM7LQtapo72+kTiXT9HZh314icBBAB +AgAGBQJW6YW8AAoJEATfLpzcs8qzlYAD/3CA3gzSD3qsROYA5Dp9i6StdkS4rYMPDfAZNh9L +IvdnFKiBQUnzDrwzQc7DCjrYiF46CfFu5BnmODc2BBBVyK6jjWqd+JmokJDGA3RHl/804fmT +f3szrzrYN+aI7HJUfmGnFWNXvJksdhVh9TrknSc6Cb/MV7hciF662zSpvgFYiJwEEAECAAYF +AlbphcUACgkQVInMlqluqM08fQQAjHGKwkVkjcyeuxhVFH1XGITvb1rptgBNfV+eEgpHXngV +j0GfUATf+hu74nti9LRM+wroG95/YkldIGdrq4B99xNEI6BptrKvdLSQAQclKCQKzbDKbmIE +KUbm2sDGBKxqgCz4CbIGgEeSCekEXcmqH/ViCdTc2ed+VqtMqc3svvuInAQQAQIABgUCVumF +zgAKCRBJ9pseUBL3E+QVBACkWbGAltMy+R/YXQeU9K3pxtXNfV4UR0NyVNT+KcLkGzfUZ877 +QxkdaE2GK926x+YHIEBNyTAFAbhzunCBe5/x9k3AotkZ0JKNKol6c/EljtZImwkf7nakNuTj +8FK/CEniNh/Gd9FjqylRUITECV/LkJSQlQhMG+8KvuNECh/KGYicBBABAgAGBQJW6YXWAAoJ +EPY7MwpPtHy6yocD/RP96lzfyHiMSkAECMoAc8fO7t0QMytkE9I5rOTr59xMzeemP4iVTAcm +APL1eWZIM7onhxYnrQj2NymBxku5mD0n3+spFP2pOhvhYPtZTIIozgmXjY5s5/IZPoQ+h3VH +mY/sMgRc9RqS7/lNcPyv0qwKUi7ssGfOvO0OXAJ5W09ziJwEEAECAAYFAlbphd8ACgkQaKS0 +byRiMMY/iQP/WnO4mAE7j4H2LP0rQB/Ejo7FOr/bZ5aUucAlViKeBTOjL2Dz8M3lvCOfVbSy +iOX7oeVRjxU248aPtrkTFkXScwL81Bzsrg8amUh00+rsJ0sRJKdKPs9x2Hc85wcqoQWmG/3P +1QrMzKv+XTxrP/EUyyAaDGfxLGmIdFwyTk3K4uSInAQQAQIABgUCVumF5wAKCRA8emUfI/fR +ipI8A/4nLVPc/Mjvt8q7JV/TDgKKBV+ciOymxPMQmqgoGxjEwtSnDlUtcNC3Lh5LxRxW3fhW +NUVzRSUdai4aixS7ib/gJWdtPSC4vRBrdKGx1Exl4Dfd3R+CTbAsYg/jyMDVxXQdwxf2vxP1 +tmcKCYu01ksW9mBUA/0KD5VJBTpwoxPF9oicBBABAgAGBQJW6YXwAAoJEFEsZet49/mygfAD ++wRYD4FyDNIb/PdMj4XgJvtVlLOf8pevmXqfoyd7JSNXZjWxOTqomq8Bvi3n17QTENTlRiiD +zpauFEilwbCgiDlrtucHwjW0EsWh+oeCDwWSXhNdSYSlbfdoO79wuSp4pOSE7tSGXxcvOBnj +EGDMmr0Sywn12sCh3H9pm+XaIPBSiJwEEAECAAYFAlbphfgACgkQhcEEciSMMU+JpgP/VD2V +iJjb5JLmYZJmf9ywhRu7Aj8bZs3Xxw2RI88rwrfo2bbJgFT1TsneZrp/gORArUJD/0AsSF6r +Mo2KwIGbfS4K+N6nI4YZcgozYCxxJ7fGi7R0J64v4m9kdv4I2xgkdFSvd3GxzDFt47Tzol4a +5LytLI9gaeHY10xIPv/mpS+InAQQAQIABgUCVumGAQAKCRAU1TAtjvJFHTLnA/9C2f7PQdJx +WYW8cgOD/W0NHHyLjvkaQg2aeNVts0iqR7VR1byvOAogb9JLWOpmqz81o822jKy2ofx0tyGO +SSU9LaEcnkHjECQ8CprOCLGrGOFTkefhvlDnDHo//HCwOb5QCcXMiMPKGjBlTTC9xWGM0ywn +5/yuFhLHmzqICcInhYicBBABAgAGBQJW6YYKAAoJEDZawL5S+KmF4qQD/RjNJNj8t9mmUbID +HLcHEph3tjy7fmwJk9U7UjneUaCAjC5uN88yPezEwrNawW+DZ9DqOjzSCj1pp2ANPz8YurgJ +G4TCFOQcDxqaw5O0VCssgqKooxzceor+0IYO1bUR3hsjJRjxglSXdKAiTB8xJold+dXNhlSs +1uIlh53qouBsiJwEEAECAAYFAlbphhIACgkQyFxFytmCeUR4hwP9GQa8wDvWpameYfWsGwQl +1t03hZSJhEJVQsWjO6sbHnbjBDRMpivJ6yi1o5O2y+c0bENPqt+10+jvjdwTwHx2eQO56SXh +vN4VlFeLKfSMvC+9VrP7QJHGWsaZ4Ff8K15Mr9mTEbMCcjf6Zqn762orMC4Ys1WmrQS9ZPFe +qLFfgq+InAQQAQIABgUCVumGGwAKCRCQHUZCpitE1rAoBACsIxtw4HDocTG/LwxWY5rLPohH +EE8rvLRCcT7eaKfECwRPByRqvAWMXMmMSsJ1eQiAR5oJ9qW5HRzCrDBhzyqQ65PPXpLQhfln +V1XmamqWHOufzifur481JbR3i80uuNx/NFG8gkK0+Qv+SLAsKU32M7R7xl9xbb8MzTZ69YAk +EIicBBABAgAGBQJW6YYjAAoJEP7mFLw4K403jF8D/1EzmTcQQ7S4yEGm0M/oCTWORgZpFvdF +dYJKTgEtI+rz+UaP4r2eCa16YhgT4cadYb/e1kcjwWggidyOxDGJl1GOqRqcuxuQHFYdj3ep +IE4w7MklJuTzd6j7n9dbVrDRdtLaCKrU6YH+BoUIWN9igPLsO5eW5gRK4NNiKun/6Jj4iJwE +EAECAAYFAlbphiwACgkQfeHHXqcHZUN3QQP+LinowuU4m8IDlSOce4O2jfLv2NIviMZspaXo +f5aPxO2FnJhKAYjvpQDL2qxAQUB/LNePZtdkOKUFWsHS/U0LBAog0z+ibgl1sLl9Q3q83p4h +4CLa2IM9Aham+x0p7tVVirF4sHz2ONwbzTuarXPzDZJJlbYOLDrTRsJ3JFCUuj2InAQQAQIA +BgUCVumGNAAKCRDbUpsXASGCJmVfBADnIqufrC442zHiEJLh4ym+Yix3zi2F3jMHr42+09px +ZKfu80a/o77HkU4JL6ym7+70bPV6M+Vj4G2ZbsZg67Yt84QaPWFho8mN5KkTJUp9wWe56I5S +y6Zt0hFudHKv9r555WGU1olj7MFESz2cjIZg2rdFEO96xBPGs2gyv9dGlIicBBABAgAGBQJW +6YY9AAoJEG75nLUFUbRYDOgD/A6YCoSvl2FArHisc6nPj9IfYNUMFTjUP5xfNo4igZZ6L+tZ +ADU97WWhNm200lNIOC77Fj+07z5M3hVNW6hpIlgP+ncv+ovg3Qi0zqQ0AaNzcwI6tjK0IZrE +NaRh47XXpK+xML4Uy+OFCXGlwkoAdWbifKQZTxcOpv3WB8PYodm6iJwEEAECAAYFAlbphkUA +CgkQeAm2/FWcMKSLzgP6Axe+vUaNH5M014RKF818PmY6A/qtRvZockhvYHLlGnETCyb/bZaY +vYii3I7uqwlxPP2xRNeaQmbrWyEMDr1+xZx7fg2VIhN5CEZeHZjdU9pl0XPUxKDunWaL396t +llwWNkHF2hSnjWg18AFejcakdSG/4zY9Y5I9ljuaZSEbitKInAQQAQIABgUCVumGTgAKCRDN +fM+BY7kboBJFA/oCTvtH2GwmAyoOTwgLJt9fME5oaX25+Kz3/nMW7zsEftIcnKMOzQbR2Xeh +wmDxW8FxK5dZ7n6PkUrdG1Nu+3Gvm9EJjtFTZtSH0LMkYSTi78IBkMFA/b3VswnU1tEUxibR +I4NYnDnN0VTz/h2JxwXlPsAqkqB7B1tg4QqceIo7hYicBBABAgAGBQJW6YZWAAoJEFgcTV0p +vlBshbAD/R1X+BG4WP3D31CoMEWr4sLPY3H+dlCNfUpKiuY01M1nMdaWfD0C7vOfVwM/Xd+S +hYhAwJM3qYNii3WVHjX4vl5TrPTqnN6wQpuOEeIktcDsLvGpHtfKnSCNdH8c1glF1HiF/c0e +OmXTJJ2fFF03d8+J43DM7O8FrvUVMCDXPEfliJwEEAECAAYFAlbphl8ACgkQvP5le60J2MBm +hQP+IVBglOaJZfnpFwqY5VjrLLYAmAunwU41PJI610v5XQ4VL/W5odi87OSIi4rCRyTZqHGn +l3lr5hwmG4ZUXhbxc9c2NgseilaL2zHedO/0Gsx0jbwpOLeqx/kLibLGnvFM1v6i4UXYbQHr +XNedXm9e+9EO6ym3PhRFW8uqA8HxsYmInAQQAQIABgUCVumGZwAKCRCOV+I3bClQnAxUBACH +kU2TtqeC00vwShnta3wsZbN73K/gcQV78X24ryFFZ5pZ1afNm95BItBhA4/CyTywEgZLo/7+ +HHDGX5woQDAE8DOev1ccD3U7x4smfbaFcU0WO+tEntFB0HFldfJwyRERbf/TAQP5ZjtDBeLQ +cT/VRU4K6Xu0PYp9OsckrIwXRIicBBABAgAGBQJW6YZwAAoJEIExGSggZ7qm+t0D/1RDXmZA +3qDMsJ3ZG+2MxqbmRnOI9qTxkur9Y/0K9esc/Rdl98uHtew1fsYm1O0jSVlhKwNdfwWCkAEb +vYbVTGr7nwoV9LD7n4B/tB/tW6zdfPifTe9hQ9W8/pelRGpzgGg5ItxptiyMf5tKiRoEC7WT +PDTATmODhMg+BrXOVWxPiJwEEAECAAYFAlbphngACgkQohCEENdle+pAeQP/euSe10QvLLEH +hFLuMorjPV/ouaM4OXXgFqq6+53q8E5QKf4+vCMduGPCAWBAAzruRFztacL84YfNwIa5P051 +P4w6ElOrWnpzy2Wu3pD6IBvKAck/0DgW4cCvobJkWHK9XvPx2BBaddsdn/g63f1fTW1diS8/ +39iXnXA/H1Kl2OOInAQQAQIABgUCVumGgAAKCRBZHtmCxkKMqZcmA/9w/0L4ku558CP2cnt2 +KoCBO7L97CfUK9Mzh/3sfSSvrsGX6vL+85a5JCzwKS0zIoTy4i3e2FFMd9bhtEqc25W8krP2 ++Fd93acvKFdPWXYfRm7ryxC3XNR/GxeeAundt/oazhICQh38jqtmm1wwoKknkzdTrqLvz5Bs +rQa98JlwfIicBBABAgAGBQJW6YaJAAoJECy6FzQI/mBxnMYEAKl3xmG4nk20qYW+sUc5f0XR +YZtZAZjK0e0os+O8L5kZ04QT92uQoYBhMUpGNVTT5N+lWY24JM3nTwfqX+Fxd5gqC0nEXkPM +Q/Rr7ELw1eK/rRISAXfVeLrv9srvbCbpYGC1jBHxbjzLYj8SsZkvSrK9z5x7FLZWz8c+Tx8J +b7z5iJwEEAECAAYFAlbphpEACgkQBdufcT0tf63e7wP+J/ib9W290FavHbl0Shq3Bfupv9Tn +T1h9HEaUZnA5Isa0UV4pb+/aeEYNXjTG2WkreRwCF4C9Bv/7U59qhdKj79XiXL4pvY+RPTUn +w4BKVqyw7VL2mc12FMXDmPG/0r8bIkimihLpiFezytUbW2eNzY+7C2pB5t1M9c20ZePaJWqI +nAQQAQIABgUCVumGmgAKCRD4IQd4/zh5Lv0EA/47yZFuhkYFty4zVCCgl65/rmmxFJqxRA4A +YU+3cE+vTGcEoHOGU961iahTVT7FG/yEQp5VLNPfemV3/cgHRUiekQvOPfPWaHIfE7QDh6xM +LAQjEbvRmLUjYxiybhCujjruI+vPg28L9YjiT4NguhZ5H+S1Mfa41tK8nNe9AusOAIicBBAB +AgAGBQJW6YajAAoJEEUrrfauzXZGM6gD/ioVqXII/X/nI9FQfsTNdKARBjTSc91ZN4Q24fHR +5VAlQaQoRLB8VjkKxbvmLr8r7phsJaUOaC2zi3b3EKc13Z1CeyC7nVPEvTsrvUZ2XBCZUfOm +beZFv8MPxf41SvN4V9U1KmDb3OwqXVYGm7DQuIUKgxl7c4kyNukt5lXWAQCliJwEEAECAAYF +AlbphqsACgkQrz04ml1BOwap2gP/VHi61AIE8pMKgx4+U/yA6Ln9b7ceuMuL4xiYw5XVQS9g +e2lSV/YxmIuAnDBEy/W10RunX4G/kIOaG0waJmJWbuSHSAwxOmdETP2GFjP92biCEmB2Zw+N +8DafYrdAk0y5VoyRCzGY0oA7VlEcj4ZCFgk0LcX1NdfjcNzIHAbaqOSInAQQAQIABgUCVumG +tAAKCRAzU0viHeaZyPf/A/oCS3Df8OWD9nDPmyWFR4qC7dUO+N/4AqyCCer5BwG3ZWwY62fM +pjI8T1CGOc9eA24/vAISsMe39ZqY3t7Z7QSgUjTWr53XT8vqzhP8cLFky0w46OWskbCyC3zi +IME02GvTseyahoz4yeN8pp+fIrhz0SZGhT6F+PdQbC0F/qlcoIicBBABAgAGBQJW6Ya8AAoJ +EEqnIl/+Jzs0tYgD/RqyQRKv/crLhAvyVs3sDoc1b3iZWfL8gc9lNVfbKOvqvT/+NX/U+oHm +kk46WCQaFwHTtZd3X4yuG+c5q/jKyMvTo0UUIFGRISHJiGe4F/x654nQcTspIRr0m3BfeOZZ +gICywA8GzcT2GAcXmf/JgNtgxqQQRmKuGs0aZnsHYNvWiJwEEAECAAYFAlbphsUACgkQmVen +gt8kbUjlXwP/WTj9s9o5zYmS+VD9ifRf87L9MuOpjv2QlJc+oVbeliRO3GBgtNRxSswvOBQU +0Q2HvldmXpVBYgK5RHbGAEOfZQL0Oy0i4uLtW4aGh4jtK7EesC8n3YZaRhQfPe1wSDrufoZi +ds/ud/qoN13kFS0Z23sLgKh6GwXTBfQZqaKGFe6InAQQAQIABgUCVumGzQAKCRBW0PezLzhD +FP+eA/0SFCsN8AniIul/AJ+743WpthzbZ2gHhFb6MT6HKtFICHsVv3/BXgBGfbCqeBx4FyZ7 +sc1NN0vHOxyq2WnfMg65SXDP/u6o/Y6GLpxlxFFOQkgTa32YODmYM2ZPejIgsoxwkWzsxYE4 +YliKOktov0KUtIthVdPWb7bcvzfMaVs7wYicBBABAgAGBQJW6YbWAAoJEFGkDp75uZuJq04D +/j16AbqVP02jRI8ziMIdToLxfLhmFA1M7avnIJ7yckpTGzsHTKIek+LJ5O8Nf1gq0Us7YOcl +IMEYaRJo2s/flvAHT9GSqhSr9KOrV19ECz/s9OXtu2fs504ruod/6vwjOsp6bxjPEim/qt/g +Pttvq1T5Qha53DN7dBmP534Aq7LZiJwEEAECAAYFAlbpht8ACgkQrXwV/gEuJdD7TAP+JDdu +DpHv2Qqs1mZ/tTlVDf3Y9D5VCyEqzs6vyv7Ur5S6NccybFEaY9EAUZixEW7kSgncVMenXANL +CKhChI9JdOgd66L2gM3sn7e8s2XUkrUkF4naBiA4tYX9gaIHUC1JE02Xs2RImlOc9YQoIz2X +uukediW6PtJEXpdovITPC0WInAQQAQIABgUCVumG5wAKCRALMajtN01LB033BACK0cVjtpRw ++JmtM2mr17o9BXl4jUxmZNwpGlu3zycS+awVA5a9xMmIVL7zkMvXJ+11K8GZ3Klwss/LqHA5 +MwIS+5cXDh97QbuvM0MBZ2IQHKf/A+GOpFQXGPFcMDPccZ+b6byR2Y/zv2IEIJaD4ZZ8jn2W +MUXNm5nlB8dXQnIE1IicBBABAgAGBQJW6YbwAAoJEK1L7HttcIU7N5sD/RAdzDbzJCesNtU7 +b1y4e6cYVKyUxqn9jfziutJ8h4ntOBRW3DRExNiQu3zuk9v8Lf3jQ45DSP3DPlj/esWaTv6U +Ph/pB3ezLwKYZw2Pw79KJ581/8/XtauDHS292ImwJSUY5VC16DhgaSUNbP2EuiaduGIycqE4 +QxtSqM2E3Ie7iJwEEAECAAYFAlbphvgACgkQsxKSdVLvXlw6zAQAkf7BDEnHYI4QaW2oCc5o +9+dhORLhYbV+z7+sbURYy508ipBhBs0TUERdT8NPspcJAWhXRE+oaHmkp3TZnKYzNyrXa97S +qn8pOe6PbKR2I+4VLerAGxwnF90usnJN68GvbSmrpDsGFI44+rq51MmGe1WHMztpFRkl36ot +9CBpFhqInAQQAQIABgUCVumHAgAKCRAh1ZtJrfwP1RkDA/0Z2nzy/P0UcR3WUKZEO5f9z5ni +T4ItfzeGizqm89RbY/7JCmqCRpE51IdTIJW3o021wlyiuE17ptxkLnmhxEI671yd0DYx9NvY +JtDHvreFGjgQnEkNzmEPRAG/tnhzD4Kq3Jw4K804B+uwShAJkYmA5vglMFvAimNK8ECtQuJ0 +5oicBBABAgAGBQJW6YcKAAoJEHn7YMIxMS21wWMD/0KyA7PWdQJbyJYaCU6+NQRXjSgkrtxf +G6nxQ0cAXYBouz0dRRbpBGrcyExM7cQshXXe+hHzyZUZy08r5P2ax5o9suLthKQpsjpuI+kw +fnIXlUeSDNYGJt4hsurQ5L7t4vRcHJiiZwchkbkQbDQBktS2V5y8a4QCDMdYz05+x2wPiJwE +EAECAAYFAlbphxMACgkQ5LbSYyXnsAT9ggQAoY4CtoNszR8S84gxs0ZMOxB4hip3kxT92Qhy +lZiOB0Wi0R97w3E6YBSMcEleT/5f0dsGKztX7Wi3/+ooUXMM6tUQENeyC0IzJHsTaO50TnLu +vJ6tC9VQNCzwccJhZ0D463L8F9gMdfGG3vcFmjzXWlxx9yl5cEpBboeHLSabJceInAQQAQIA +BgUCVumHHAAKCRDVwrh7eLTjH596A/9SLT7caReLpoqSrIn777ZmhTgboKP1jPEFqEwalf4K +qHh4iHEuF15u87xdT2XQoCgrwHMdMngvUY4o/6gmqzMON+vdjxlpFEudCThefvPbNO2fP2cr +uu0AYMUSxOTX9UG1Edr4uhRcDH6qSro8m3yi47U+QZB5Z7wjCfplq5tdBYicBBABAgAGBQJW +6YckAAoJEBd0n0vyh5bPLxkD/1hJMh9rUUnQBoFJkFnj1WF9OYTAu6JlyVB7c2a7yI8Abfui +/r5reYPyNe9ZWK9/yTeKkSqwOX/7oV19oOvCSFRmry35UNtK0KD9I6sJSN47vjR6/GAO6HLG +EOAQ79Q5A0k0kf0KrcS229+z3zE9sk1XzbeCERDv0LZa7x7ObklZiJwEEAECAAYFAlbphy0A +CgkQ4FLJ7ytm7J6hSQQAtvtVTzHN1Ex1FMZDMozaqs8bCgVKHZCnxSjC8EXuXHC9kzlZ/0BT +bPwh4w+q+FfVKeQuNkg6sa+ZJK1eV0Jk5ssT17t1wT8aWvPWfxqd0y4j7iaxDSp4rYp5V5IR +somSN6GpNKV2nj82T0aYrUKfIXyd0BNceVF7h9kpfEWWSjqInAQQAQIABgUCVumHNQAKCRAr +ioeeRhIINwdHA/4mFCIvh6DOkSrjn9O7dD2eKKM6FkSDeOIqQnzA/hmzXUSYOOets/RFOfzD +GfjEsKxkGBJoCgJvFcu78ugDamqJxT5VZv2mRUvRgUitQGMYWFvqu8l0URMcepdsclkf1x29 +JnmXAOxxHpeT/jZzjmApUrORyL449TVa9vZtjMxEyYicBBABAgAGBQJW6Yc+AAoJEHGtmfV0 +nrdUWj4EAJ+LM1lFhWQUk+xBEqBXG2dLgMuip2a09zeG79t/uucbhToE2vs6K6phu2Sdu4Ez +Abr8Iojqq0Gq1VekuPB4lC0Z/vy6AtHL24wFKknbI1RntY50kOzNb1RXuscW4TNdl5b2Q9EP +c0h7e2W5Y3rLh7Bxx5Gwhu3qamcUFFnjPufUiJwEEAECAAYFAlbph0YACgkQLyrUoViuSEzZ +UgP/X3n5ifq0AZFfAcVJD8FkiFf7umieQspumE3nsVrWTrTdyqZ8WVyHiPpLOTX80r31bOPP +u2M0zsBQX81GI0StFCu77Ih3XL1ue7qOuRjh9P04nx6dMqshrypfH8UL7M/oJL53Biq0h0r0 +Y1OISMV0u4yo4/ZC3s64j6ueGWy9ieqInAQQAQIABgUCVumHTwAKCRCfbqh0ERZKgOTDA/9/ +AyFlFz41kWSX8Ka+DCixd0K+SmCSoXpAtTrW+VQntqLr/km8CTDx70sP/YVDPfdBvBrPIUDc +nObzSLhIDbmnV/5w94qlx38t72ka9oBGkDVGyP7amZ98raDRxDhgOlI9mtC2Om5IfjZwuo0C +vFXeA4DUKmyztLeSCGHm2FU3boicBBABAgAGBQJW6YdYAAoJELmo2Jvsf0hKwEED/Rv9WJfA +/SXne2efEXYN11hB3x03r0/Jays/DLm4rCFNZH1zHPlhs363+j3oFUwY9yLj6ElTLQBuiqJn +zSLQSNXWKnW8NCwbe8Clc7hk0yli+7ZpT7ySYPSuAo+BRL89Led5XCcf85oGmEzpSXlAgOuH +0xHCaDe21bfa0IoxdbRAiJwEEAECAAYFAlbph2EACgkQ5pf+oeD5v1VrvQQAkvCs0Nl93aao +zkMkh8Oby0jRpP2VBUTQYP9urXH5rD3pDoG9M73mdXhvNd3yuWsOW4VRtkhP7JIAEhYAWF2P +1LNsF3D3oC4CwswelAWs59HyWlotP72SROOPWEJNEYkgDXklP3QelJazyI4SeKuc/fGRf1bS +iA9jFboxfn6mnfCInAQQAQIABgUCVumHaQAKCRAf4bLu6cUcz1uhA/9nXW84Ug0ebOPuUhnr +3qcOoX92j3HRbrEypMvTJ4zh0Re8TelM+e5ZwaLzO9i18ap8RKhfwo68Z1IcUEG7jRXw9jOC +kNWmOdYQmDZHNhj02y1nRQDyXepQd3mZT2EqK5SwMcg6fUUUWK+WOV4lDlq5Ldwuff0Gw3h3 +6pSGivTswoicBBABAgAGBQJW6YdyAAoJENv00VoRE65R5roD/idjxWKZc9QCRBWrN83V2X0w +KGGAaHtAAibOM9Y7S6C5Wh+vxvBF5+N0jbLM0kvzYtgSnQTkZ7IXM0sSGy0/KisyrGO0B4mX +1RfXQI7b5i6RVNyESGs+iXzTqYbjwBHkxxssrKo5/KSYdFO0ZJh2QenIF1aAZ08Hs627TbMY +6vJNiJwEEAECAAYFAlbph3sACgkQI5+HoCyrBOYiDwP/R2TM2321o9x2EQHJepiwPEpT0bJv +8thjkRT7RfSOs3bI8aJYbLaWriQwrszTTn1PFg7dgF7NVyPQtAj9RAg3t19MAnXoxcswGH2j +KYS2ttKZEMg2n4gm5gf4ibad08yGn3AfiftZtI2A/MWvuZdPKtNsOQDkaSmSUqGS5H4YENGI +nAQQAQIABgUCVumHhAAKCRAfLidktS3Y74zSA/9bRoGum4fJe5jW8Q8AfPvASViig3Eo7Uzl +KfPDfIhNr/SVuybQ54N7kRq3lFYQEhvg0Y1z6BuKbb5OkqkQLMPIzQ0H/nO/aO2kdd5fdKrt +hVlICXAqr4jYPI9Gpr6M5+mAMRmHhBBUzBYOEVTJR2nn9BX11a7ogv9C7h1uzEMRfIicBBAB +AgAGBQJW6YeNAAoJEC0RBf+kirBdodAD/0wZv4yVww250BobxJgfXDKB4NbSqX2O0uNcWa1K +qKdVGtkYqxcWs9G4hXZe+xDHBkwWJm5MBuxMcbBvyPDTQdnqiiJzsYBdicTN/SnmHueNnIRT +15j/twFE2BG+qH/KWbhEZIn6QwmIIw/avBZ+q8t6WRe1XUa1zQcEZwGsAjiIiJwEEAECAAYF +Albph5UACgkQpDWobpPa9RvsOgQAmAMhAbtIwuNgVjyNNf19/MApQGeBRoM4nyWOWs3qeVc8 +qT293zYdGDSkwdND9ElorDMknNVpSyqllvjZ6HwEAX+pwRgSujAhQVHp/u/FzNELETIz9CDZ +mPab2OPCaLeIx9ZEjxokDBpcTK9kITjWVhAL1a/n3YjjABCoThsUfbmInAQQAQIABgUCVumH +ngAKCRBFqfvNBUTx5NgfBADFA9Oa5R6rcDWl10XJXNH8P2gwCTCI4Rv3bUctbdVfdAEWyQhZ +KCfx9aF4Y2dNgz9FOwDtnaPm/VluE1bcgj9kfN9R61H8Z+eC421JlS6chZVSHB6wgXp7Uwvc +aqI/Stsc+oijlVFI2fZxn7mz6UmKD87qx0r9xWrIy8KxZftyf4icBBABAgAGBQJW6YenAAoJ +EEg8xBwpONPEFuAEANy2CN9xS+Emd+QCZNVqh/fcbPuVkoyAhHd0C1lX4JG+VfivLitBxhhN +ZwprbkZfn0h9Z9f4m858WMXUVL+06LEm5evDH/4imshYPnfUXvKI2Ofmd/DILPcTatq7WrvJ +SDXxmUlTGTVyriTPPFnF81fLtBQdSJKwDkAfNiamQaBXiJwEEAECAAYFAlbph68ACgkQFn+Y +PclpPnirHwP8CkZOrTSHl1WkiwZQivBph1tToaSo0XrZ/dGOcdkKf5w1nLFl+KlwIroC0Ve7 +7MQyWm9AUIk5WREzm/+WLvTIwzZ6f+Q05WuKKdhZRjZ/S8IJxuAjngVvCEV7L05Mfp69S3j1 +16lZFtYnESxZTkmzTtdnU7k8ZSMFkN/e2tITbX+InAQQAQIABgUCVumHuAAKCRAZFqZPec4R +5yd5A/0a2/HL5BFAxMKVZirlTXYgyYw29VFcetp7qB3h4igdxUdm+Pop2JzNSow5Naueadav +vwr3BfgGu9n3H2JKiAevHDgQ/iDBmJEHfeigCwD1m1fix5g4cQjvYnii3XhyUBPoSWuZBoRr +y7v3N05zKQ2Rftefos5o6yrPDd3OiYJ4dYicBBABAgAGBQJW6YfBAAoJEJ+nvuvafOUEIWME +ALsTqFhV/aSjk3yXBQ20WdLn8YfDNrbtdgrLYc7Li5VYjJHeBTG/I+lcXeD+AMOPtmZ5XcVo +MnbE90Nx8QggnUYu8GqB3yk/QIw8fSly0Gjk1WyBD4Hul+gnSJ3rNG8s3PzIVS8AqH9AXEyR +zzGAfUZEvYW01OLxqMAmmYOyg4tUiJwEEAECAAYFAlbph8kACgkQWW1qWdaZuUotdwQAvG4Y +A1ndjdOKXG0ZthuppPORXFKa8nPxsBh5dpO/BoSkUh+5EwcKxKLs0sgX2Mb+JM9MuvME1fnT +yzOXYq8aot3q5EEy+HTs7KYs9JsOj6FsJboGLoi0sCj9ltjmoolC53hUiau35jSeK5VPNB4+ +NkGKKHCSmFGnbi3YKtlnuxSInAQQAQIABgUCVumH0gAKCRDqqJGImKZsovEaBACN/lLZwoX0 +Jo9ZOHHqJ+ZRkYdfTe311A7W6tv/ZYr245E3YHRqB2ORcIXlMtWet6WgmeJEUerQvYxvwRYY +EUwtNGx1D1nEsTS/XychiotUXai6QzR1ttUN8o6XbzVPJWtjoGXBK9s9pfaSlAdAIHR9VFGv +2ExG9hsjOXcLxMC/o4icBBABAgAGBQJW6YfbAAoJEIDl15axnl8eE0gEAJ/ZeuD6Oq7/Dw9f +7zBAeSrWnuQgsn6yY33eJyx7AbeocXE39tSZIGbZfHpTCnOicaTioIJQYvbphFEsEYzd6mWD +8cMpkLfuHx1jIroVp8HbM0zI/QV0o+ZTnOjrnzbx2Ay9r+8Z9+FBx3px8dr3KFMb2qS3ZBTS +KIaOri/LJo2niJwEEAECAAYFAlbph+QACgkQ96AfO9tFF7RJugP/Yg9CP0zcTa1UvoMZtjw7 +R1CqOlXul8ZmCJ8Py1Efi5OZT7hTxEUQ91bStBKhNnAiSB9Xh+pAuPG4fOHHsnt+ewHQqNrm +a+uFXJQKTTrO8FTrr8X3Jlmgo1QpwIaIAESs/b/X8SAIRLJjc88hWWxenRIPbyYDF+I/PmYe +hqgrLZSInAQQAQIABgUCVumH7AAKCRAIamgQ2aRSOr8UBAChLe4fD6BOF1wJ7zWD52pHD2ZL +YJyTHMaYSAUAoJZTDsjGfUBxYLdlb3axvbOfhbGhuoCsGaGYsAB7odjvF5pc3IC54akYxxS/ +a+uZSUjln7u+D/jBLvN2aF5pxNPQFZcDzP6bLCZsIkGguOH2gu/nRCE2DB4jOBCeU2vBIrKa +hoicBBABAgAGBQJW6Yf1AAoJEMO7zGxJhS0tQOoD/1GLv5/cy+sQ8qYb4KjIy0Hf/UTit/EO +BQYz1e5iZ2qSs8CjUVbfLiVtjJgrwNNCg2182aqKoZIqJr1V+gG/DAbz+maP7aC0bZE2+swi +6QtMRP/YDH5EQFVEEXUGJ/hH+5/wlaj47nvtRIxrYu8cIFnMbZVGat6OQ+VTWY52CXSOiJwE +EAECAAYFAlbph/4ACgkQiyIbt7XNaKpqPQP/QeAKLdKoZk3DBuVYd2ugBCiSdp4lU1uulwGh +MCFIfiWqelPLO9FukllzGrMFPz57/ZCvKwf1SzTgZnAA4LIuHUKhMv+TFhpyv5MABoON94qi +n7If0pWpCS7OmWbyGIAFC9/PTis7sFVsAjXKMCj0XrlEk0938fXstPqnYDktSliInAQQAQIA +BgUCVumIBwAKCRCiL0Hsfnhk+OWcA/9lbVoHb2PDgsYYF7B6+9M8crb0aFSZHW5vVt0ylBgf +GFjefju3AZ6eZqRtFLh/szrngpzb7/WPMGgCakk50EcD1fGuw3VBYwt3AFwGFYFvBH66ORc4 +u7WNtRvj0TVLFvXS7rr66xkjmQYxDnywBi+e7WozTwxi7PB7WeO8COQWtYicBBABAgAGBQJW +6YgRAAoJEJ3yO3ba/LrY3zoEAL1PGsZJylbu541sU5X3wCMAcxo8lgtRaVHxYui0w3AwVEr2 +NR3o/8LtcmJb2on14+LUtQg39LivOyZUWpGxL9cIIwQBZ785c/MdTIaOQmkCyGfWCJtTgpIt +1VxoRPI0Xy6h1SPg9SRTc27M15luuZWLkf71sGKTMdF32YczpzPViJwEEAECAAYFAlbpiBoA +CgkQf3Atw/QEIn+HEAP/T9E/tbshEcGyRX3OGbaoecn07pdbvCat4t1PiWLcVq/cH7L2jPqt +LEbIf3fOFKcVmWhN5sLKQrwJAn4hN9BpX1UlTY3QeK8q4VutJrp/5WrLFBNAjE/p7MVFRcTM +A4VgozRKq+qwxqQTfn3jJ3RpwnbD0aW2DDfl2TPBbJyH6hCInAQQAQIABgUCVumIIwAKCRBE +inZGLq/Y0L6iA/4+hNcexaJMRxOCyeUHtMCyeERWIOxY/sYGTsO4DJH+IL9I1oOF5G/GPvPR +NhYJeSWhesSrPzY7PF3IK7x/yuYjqdzErdDlRRgmZvPNQCi46Bt0cQP3mUS9ef5/ugWLRuDq +UfSOv0SgtaTNIHdp0ed8VApL4J4zRVKDIsjqKh6tw4icBBABAgAGBQJW6YgsAAoJEOdssTKR +IhAkCjYD/169nEmG0HQ7V2hZVWHgyBkIJ1Mpkbmy4OXhQbPF3qHMhraZmnwVFnXrauO/1NA2 +AEnhOS6XNtqx/MEkSHEs5DlK6ETOitzZCZb9Zv/fLfBkLThTD/AMbUyLzD6GpifUNmV6HJ/+ +/Eki5pL5AsjpJFsdYi5LAM9vUBivoDLwQA0YiJwEEAECAAYFAlbpiDUACgkQQTI8fqFrAe1p +dwP+OybFC1e8zlMmMHcdkbeLzVjr52gtMmRG4ZPF5fJu0jtKML/FEp7r6bivotTYzDgUs8Vp +204/pMQ4xdlrYK+jozBacorf6KGeOPw74UZkKqLtCSxDPYij0mt+SpZwztZ7m/bXPrRjxMcs +zvnkFzTCezWeUAbJU+14Pcb/UxMAZfSInAQQAQIABgUCVumIPgAKCRBfsQUkU0uxsDmgA/4+ +mlwk4mgj469JJL2ok/S9sZ0s6gUdgIIpl4YSvxXLbVCiUMPcU2tLQBTeDfh6Tt2PvZITdkzx +EuxA4iqfyqBw1EUITqdEHWOW9i1CQEVoDJieov2u6ySYbck1TwCDznEXRucruQGz+DUsPEGe +6VJQ0CDgXQ/dwo/pKxGJo5Z6yYicBBABAgAGBQJW6YhHAAoJEOSElRu+sHOOPLYEAIMOqtSq +4zrIpxaTpgBF3kM+KFcXNX9RS2n2ve3pSUSMcFsC+h/I1AVjSGDb9tcRtLLVax8IEwScAz8E +EOI74pooq+58GZR8GJ3v4gBYyHAcZ0GX8Z3OVby1T/knEfPFmZdV20oBe0PCI+ImqVt1XLXB +bjv4TjTs0HsBonN7+bmJiJwEEAECAAYFAlbpiFAACgkQdpxpBZR0QD0C4gP/aJkoi7RpEl8V +wR7aj/IrqvcUeAI8t/KXRlHS6Na9VNQag8ulE00kaREFJyHZtaq4wT+0q/r8PXnmqu9Qa08S +g6sQjW6G7QOIRywFWfJ9HH2hrOTNviIE+NSyiLQJqj+ODo/OYY9TPdMC5pP9ocUjKlTKjUv3 +A+mfez/MfCfEGyuInAQQAQIABgUCVumIWQAKCRDaO6yObNOhTWXqA/9dybG5kiqmEajI34lz +osRGRJD6BOXK3bTYg+7CmiCrF5TLFizk9jsfouJT28MA3nCqJ41msgvlAPlRb4P9D+dkI67G +Lj7qvXr/fxicRLde4kZVSf2iEFHljtFcNI6P4UOZ5ICMg6YY1uP5yel1Vjo0SZZvVKWEkbcv +D/mgmzFY8oicBBABAgAGBQJW6YhiAAoJEA5TzeSpZYdtvlsD/1/1YGdsVZJf5VrBxwKfCUlt +GYnAEopoqHU2TgJx0fRuP5TzOeLPa3CODYNv+SNq2dVEZn8+XOfT7j4YPnMEZPzqsXT8M8ox +0OypphvuwzzT1ZWPeU3d4fZ8uAQ6r2wXx2k+MFm47Y875F0UD0VQNooSZnc2T/E5jHz31zRg +7w1oiJwEEAECAAYFAlbpiGsACgkQObIsFWcq+snLBAQAo3XBDBKT5wrm7ev0dVkBa8Cc9fIJ +fktDsk9wXu180T5kMb4doNQ5II/Zh92yJORO9yOkptWMDgVbHIjV417u7shIqlKiRHfa0ZyT +JHGOqszH277oYUwlosbWv2D8U0Q1j4Vo27HC0G1KVdgyVfyZ7opn8b4PLqDDSP8E9uemvNeI +nAQQAQIABgUCVumIdAAKCRC0EoRfFYFDPRE1A/sECEG8WxX4bhIOsTxNLbvI1p6EJB30R87p +F81klhalAxT2onBa+dyvP2QTyZ9ypLQDOwRWUfR4zbnOs4gB/rtVf5F2l5sQsekcEf8sZGaH +uzvBlW26ol6QfAPm8hUyZqkOmYpcTczdFM8rhydFxbX4DZUvxT4IzOFwkK/X1b7XeIicBBAB +AgAGBQJW6Yh9AAoJEIeEt4D/hj2eyXsD/jnT/Vnenb0t1MWC41iDXLrB2uaPi/uzQKEN8b7G +ytND/ATLJI/+R7jHJCWXD2VnshrSxROzTkAAEMunuWLTPm+eJxgyKO8DRkZCdodoxPKVi+OY +yvJMcFlp17UHSVeL+UIsz9AlRU8X3UAraH3QTJbJQw+0lO3XKK4yetMlJRQhiJwEEAECAAYF +AlbpiIYACgkQqmaC/tBpX6/xcAP9F8dq3ynAZJ+rVFJCZSq1KDbP/8Nfgc2FB1aw7KZakMY5 +kF0QAQJX2gLnNcDimCq2/e99AAoMr5E6jV4e5I/cveTRPndxjBqzcvZV30DnbPzOoIo1t0Nk +nJKDeWEQyeMjScn2DpiOJY2RaJ2PbAJTMtAyJa3LWv7YH7tZIIBn2VuInAQQAQIABgUCVumI +jwAKCRBEMygf1P/LnIW2A/9phWRfSzqQb1sXtmzDd70JETjDJQTiJa4fIedvDb15jNaXdQdI +JUx1cqK21GaoqW7ZnniUOGGQ9whiGKd8sha75hE+bpfzaA8h8DdgdM3brQmZfZkS31VpJdIy +k7Q2rnAcE5Pukht1FYQDYI5y146HFsDf/AfvC3Rbs64OcZIpL4icBBABAgAGBQJW6YiZAAoJ +EOFHUrvyKrajL/cD/AgOahq4kCjGf2wr5bCX27HBXgCj1aqt2gcUtyc/RTP+uJNfPgGBzSu/ +B4nRwNgtnQWiUXgJYDsigBTTIQ8yadlOn4/QWWnYVdZVVZnLeX1NZqvTwAmUT5Tkn9kLw8fC +4L4lroaL7+cDWKiN8falxOdAr1nQk7OMVHPmH3EB5BYBiJwEEAECAAYFAlbpiKIACgkQNC54 +2LFRws/J1AP+N6D6kkWsYOqAHodO1N7KCa7XTtC1MZEJ80RpHNsSamGtrHL9IFrSHGDwbSKP +BQ3FEU04Wsq0u/rBlcD1PJZqPc9kd2sj9yWC3tmyyhsEu7PGeYR8Hg85QWKUmtchWyGuK0bx ++cgh0heXZjx3Yhgq7lDG5tLzvd5BnEHUnrSR92OInAQQAQIABgUCVumIqwAKCRAW/ksqE3Rx +GkaMBACGZQwJg/mZ0Mduf8c3Tw7qeON+s3jccGlmlU+XR6xG8C1LmFyQEf1Uh0InHJCi4ocI +Cgs/ON3yh6nm6Jpe+4ZU1htDQcxdVWKr1t4F4N1ZKAfv9qbf2uIrlv1XFPZCVLozhGIdqqE0 +NsXXdazwBAd+wukhFEDFA/QbAi20DxWHsYicBBABAgAGBQJW6Yi0AAoJENLrNj2wsCSko0wD +/3c8NFR0eJXY/DgojiLD+7iUi8NqRPEzZZpzb9mfphf7w6QqUpsHqUcNctvBxQKfxnhG+RJy +d0Kdx4wcW9thWmLpSdvUExFdXprJ5qSWa0gIjCTrK+CXisJEU4gFVNM+CgQpW2RgVRtSq4VM +et4bz2UXWaJp7wjOQJo/OTgXOwAaiJwEEAECAAYFAlbpiaMACgkQMNPLjy6kbG2g2gP/d9cW +7jA/9TsiLJR/AminRzcK5jsRcMff8Mtd5OQJ4pUs3EqxgfVUbJB6G9z2mTrODstn9Gihe01k +Nqxgco6S0XaC8HRjkliPZ0sf6+1gSeSid2cb15YOqksi9dW4sYJHZi+9j56ooELZX4ao0ZKW +UWfz6t+f74Peea2xVtXWYJOInAQQAQIABgUCVumJrAAKCRDRmvjJzsqSGPoyBADBosbnJH7Y +IyypXL27fu8V16BmMAiU43G4zNRivcOb9Uh7lNbFO7OfwCLUvNuB8zi7RocWQJ8qj9mseGZJ ++Bcvl1afvy44wki8mwuw6cOoNr+6BFnxU/1vXrw80AfB1YyU6qo894+FOF616mq31x5gN0ki +ufg1/tziy0ilgpVqFoicBBABAgAGBQJW6Ym1AAoJELkTLRYOeU+dqi8EAMXN6O0a4WQ9ChfJ +OFO//AZe21Y2FGKmWjV2gfCuUY9xHKTqAzolMzkodojLK6+sKKwhxLQj0+J4VR6NzWeWgvVx +MVp8VAtdWjlhBsiGc2qVdUO/GpKxHvIhryM1a89GftCz6QsGuHXmpRN9sHCIBhhQqRmaJiki +mQh8gEPj2l0ZiJwEEAECAAYFAlbpib8ACgkQKm/qsCD77PZACgP/XPPz5E2jPhuPDdv+YZWq +LcD+xSqm+iy+zYBW/Aq8rO8RmIx3wEESChJEJvgNJ9ElEmd7uqx/D9p3p4f1E8A5IGZ+8FOg +uq/ItuAHIfE33P1TCsTMFBIocOcx2GmeCPzBFlYsLxKl1fcPJof25yMqzE9HrkfgfD/KzTRy +e0btZ4+InAQQAQIABgUCVumJ0wAKCRB0FfMpLVLQN9vNA/9j+eDMC8yfcAMXC8J7ld8dlibO +qGtH+ZeJN1SimmF4Dj3imvSo0NdrFQ70vZF+Sf3Z07w9oI07WC5RI4DEK+Tsqz7cCNw+CvQl +lSGEcrBsMSuLLIfPyfjWxLvyW0AaNNbqEkkuqbiOIW10lCbjYca2mCfA+rMJ5tI1exsfQfJD +UIicBBABAgAGBQJW6YncAAoJEKQsPViF/GOd/DcD/2wVeeJT+oaQdC/P74RefkKlUYozs+nV +pP2PBc9QoSVc6ZWaewLZ59vChIw1f73/PIVWpK5ZEb7QdxwrQFQs6FD1hT1uajM4IP0XwcwK +MxfD98PbgLoiz85A6EPVs54Y8KD0mJQG21V/22W3lKbb7meGREUrqYlMcj0C8FedOJBuiJwE +EAECAAYFAlbpieYACgkQaZLqEtoHXWJ2GwP/RH83GURyx+2c/VKml+bsfvIelYT9mEMhvYjy +dPozfxhrqAKZb3sOfsgpjCkE5mZJ7UPXSDiBNKJBbqkoF7xW06iFvezw7P3UWnCjnDzQ9JJB +U9+qO47VZ/SuW1QAHnsDZL9CwKS5TB+BUOyBiTKoyGbqBKhTM1FE4AjLIpoctBCInAQQAQIA +BgUCVumJ8AAKCRCqAgkebJJW1cLDBACHhnxN3FMdOP4087ncUV241z6IgErOKx3rlkMcem7p +WAw7SKEzOblUwdklq1g4WwKrhi4OoNFmO9J36a70K3jUFxs87KGtXgfhqZhC+7j+9d1mvRHx +bbduOo5S1+xebx6gpXs/YSG6Bfdf29LKFbIBIH3OvsrTQ4qrUNL8gEu5tYicBBABAgAGBQJW +6Yn7AAoJEJmte3LckaOncT0D/Ai+0nfyZtgUjhxG/dO9DM1jWvFsPj1f9JWhWQCcOG7rkJzv +eeahaPhvjJucBsVIVfsP1NYMB9Bg9uUUjw+QGTE0oQhW4uyGel9PE5wLSYWqZvw7zziWAXbg +xV2518Jkf0zm6zzqzDC6Kxi4ksK3JTMGmnTOdwGwLcLQZ8vPXaIEiJwEEAECAAYFAlbpigUA +CgkQ2QXR+IKR2jqduwP/UaxIdXnOo7Z9KZ0uC/F266htEzukoBzq2ZqHtXtzgGBAfjqUcW5S +stJbzgArz9vDjeEquPS3F7TJyaMSNaK4gVyTjTpXLwZJD3AHLc+eueR7rQc4n5Z8iET99JWX +KQfhvW+2NcnEXLgb4akKpTXBbxie/vllwmeiXNVTfBuv4zaInAQQAQIABgUCVumKDgAKCRCF +rPQQDz4mK8ENA/wMPexGMGmnhz7NVXOcsOOOooq7JM/Emeu34V45vOKyRp8t1hmjt9jXmSIl +tJAbZo1XX23Aj5BFbD7fJA2Ej/qBPHgv4UcOWdqrdAA+9Zd+2Hfv0Nw9gzpEN+kAuPBseWBg +cXlI6H/poxTadeI04jQ0DFAgH01AApsfpgxGdwIi/4icBBABAgAGBQJW6YoXAAoJEO/hNLQO +uYeccTAD/0pC0Gm31vOIjKJ9gjSy7gFu64tCLAXylwTWN/xDic7wu8KOF8KlI8/WEauShnNS +2cXHT0vSoHZ3JIQqcbuEMMPXQVVWNQQkvCvz3R9WxJJq+lw/6m8ApaNYkwJzS3ynIc2R1MXE +hTOGUjlYNQOyDp2sc0uT49ij0fzUCMTfofFMiJwEEAECAAYFAlbpiiAACgkQRPisieWWzRI6 +3wQAtEhgx/7hDFH9JH073ecR4i3fnPhwggUa2QMwXGT7YHTEMBI72JPA15tQqQqlCRu8EgpX +lgJcOh85tUO9QVT+Cs9hxzehJHQqWwXTFIU18TWKlKMWVJMHdR9AWPAKfKHO7pbPap06AMIq +c+YW7qNnaVXAITRvIsKXEfLwkNMtz7+InAQQAQIABgUCVumKKQAKCRBQAnHtT6GePJf3BADD +iRqwxR04/holSrCDzZiBQxKS6lSdbRWNEk3Chqdf72SgCuZ0/7R0j/GuiLJnubchuzneaUGj +RLO7khIsuNFn2KVQHkom5v5B0yQtjEi8iEmbwUatg3a+Y4thIGOujWHoQQ0/Cc+agvSU+DU7 +cSwddnL5Ly2CDRCBYw4woW5K4oicBBABAgAGBQJW6YoyAAoJEFZ2WQT9ZcwxSd8D/RcDPjqn +MSh+atRQNPXmcz5zdGVDJU2BDon4zGSWjd/xnVINYFL+Mbx5fMjSkZHw4LsgQRlEkXYMiXBp +n6rR7dgmRWsBq40mHc2JLH/vtRr6R1o+4dPoSev50XhOebzz+n7DBgQzhWMnoZrLJF+BcVAz +WlgRWobBAREQgK7JYXq7iJwEEAECAAYFAlbpijwACgkQIEeChfXHwsa3qwP8DNPYczdb469N +qtAVWxIxJx9voOWViA3U4THXpN6j/QAY4DdFnpg6hve+ToiMiq2wZgyNI0TtMP22XHLlGWO5 +Pox51Wl21alKbuDRkT4YbJsKHvsdXtWDrvo79C36BPQ4ZN+o+BxqMvzXct7KmU8Ig78O8Lb6 +XB9Ql9Wz5t0WIp2InAQQAQIABgUCVumKRQAKCRAZ3WLtWlqzKvRNA/9h4JOJqB63byx6he28 +ytgbQzRqmZK2+8HsS15ePJWme6a0UsEQSA9pzzNgvAiT1CWcDU+csFsUsyusF3tIataDkvD5 +bV1Jo2d33uKjDnGTlPzMI0BuuB+nYPqK8d6wnl6ZAmlNqZto9XsRmP/Q2APlhQdz/QHWQpvA +iERRf0mdtYicBBABAgAGBQJW6YpOAAoJEGDwWfWNnK2rFxED/2VGzPXgtawFxKpPWxWJ6I38 +dGqKeN7lcxPJHAUBlLDc4d4Rk3UBBRedWtxB6qMvaktevYxMp56w19X+iZGRVDLkKDy4spwe +jzp6zxxXM2ydy/NQSXbpYJaT85SoUKJnEnQClZjn+vz93YC5YwpuaSZNx9Rfpch4H0g3bQ4H +MBFliJwEEAECAAYFAlbpilwACgkQlcQqk2qXpqtlCwP/ZBFeJIRsAJQwYJ1JCO6iJkuBeIg9 +8eP0x/KPsQG+qCGHAZbm4+NgkYpjZpFPkK0dTBHqaRvM40rmSoj/bqhscm8mDiUUt2Ughbmr +Gn3qRu4oNUtZBPiSHb4FBfC6K3eEYpPNasiUK3IMA7EIldggtS5e/C5N0IiY7lo2hdAD/amI +nAQQAQIABgUCVumKZgAKCRDI4+JN8rgmMcBbBACAz/islqTPDiqcRgdFA3n0dYXgy/dra1T4 +9Z9GIRid3G2RVqRBon7UM3A/AI0DExt0kQoOyux62jEpwSQshP6IJ9BuIhFz4QnhGWlMrVtd +8FIDEyWMb3AB8XRxl5dkaMY9ddIPpTPfy6HNRMPV+sH7rH0pa5qxBbVTLfLzzBx514icBBAB +AgAGBQJW6YpvAAoJEHDdKljL6Mh8xxoD/jk1lnqjIVwOfAorBlE6Yp06gvjcuyoL4usIpA6V +stMCoJvXe2j25XkRIBcnh3cjjzj7+2PjuQNvUCEu6pHkhLnlumY/QAf3iL4DERTqjxQmQONA ++ve/FUsTzn8WmKUhKQ//d714DgPp/n+uz0Af23lkUV2mgEVfknmCE0zb19TUiJwEEAECAAYF +AlbpingACgkQU9dZNxEfLvdKJQQAj0Ibm42tSXiId9ANNZoJir/JpTpCtirp0+yzuaaZH5Bf +HDBHc+kOCpH/emIy0YW9ID02wTmB3FcBKn1Y/mPsjKcK7sxXbH6v7DiUeUmrHuY4cqPcQIsM +vxwrc07E4BC5egaHLnOTXn6AjCFvtlNOH1AcNB2FooaVXoxxoJOBauiInAQQAQIABgUCVumK +ggAKCRB+HgDc5M+8OCKuA/97i6I6UHQumUmrF9siGZM2NzzUy4mR08/jyPEqxg53pzcJvS3v +FxGxfaJYEch+nCHUWNZ+7rnaULhczfeuT8LxYEIkY5aYr/H7xD5Fio62FHkpLT/T/PXvfZyf +ivFGbCH8VgR5KifLJpfap59pudDWNIsQ6NcaISgYrJIYs5zmxYicBBABAgAGBQJW6YqLAAoJ +ELh8bx7zTaKytcoD/R5hawkO9S0s7WJu/x87ateovY6ZvuitimT5howphcfdbzzeC60h2H3y +8eLMLbNdh0xDNieX0BoB14Vx0UeLIGlSzqjuOhZq97ZXHEFUaIMm6AMIkFgT5FqvgeUxm0pn +pv2ZN1wLcmRm/CMOcUSpte7iIUf9W6OWVII4iS8vVUWOiJwEEAECAAYFAlbpipUACgkQd3En +WNcjkmkG+AP9Hz0WMJ4R9VK0zhUZ1aE4fRgvPpmDJfEXiGubNryjV+THrUkCwJFrZPT2PDQr +eo+3pHGfy1WP07/mWnaXh658znsCBZk7TFCKhqDAdT/1iaB0vpfOfOYJCCy5Rz4z36uV/s56 +iCbw4iLEugtNqAUZkOb90mDT5DMZTooV+JtdTOqInAQQAQIABgUCVumKngAKCRBYAdr+95LL +dSNFA/4gg5SKJTSb6XB5GnPmyLrQvAjfjkrinwjkbsNhLwbDwuKJBZPNJwjq0pA/x8HT6ruN +bNvANBwWx/bLOui7sFjmiadhnWTVKjOxwhgZ0bv/jDWEyo3b9Sj2YV9oQWIfvR98qbwNxzE6 +3v0QWPJc1Kh+QVptHtLVOS6SNSGrZIA/WYicBBABAgAGBQJW6YqoAAoJEAnAL2746tSlkEME +AJpzIpW/wN1KzPOeRZHM4WrlD4fIkc/ux+H7tYSkGaj+wd9HO7eAhBebKJzQKiNyNw39VI3t +rWw42TACoc5+0ywD/43pSOCJhdjdxKMmygBHd6UOB/KGN09mo4zaBrc47SpGgAF7Fn2GBc+t +l9sEG3qo/ygkbO91nO94IZHL9MIOiJwEEAECAAYFAlbpirEACgkQTTOAcQAmKT6KXAP+OQxz +a3zSBntBnnTmOarqkItRUYyNp7Ii8W8/ff92XnZaM9UcQpOXhhspESB2adtZSXT6SEJ+9QQ0 +Wlsd6fC0nF/PK6x1eh8vA9ZbWyXhG/Ozgxoczi0L8VVwIfcO+jqkj3pn6JVN/pgWgUfmhyYa +xnrVDNMrJ4Mea7rEh8rfIoGInAQQAQIABgUCVumKugAKCRDtl7IU2xTFZWpQA/4wIgJsXj8x +qwaBuArFB4fxIMqW2yR+76ox4283Bqb1TJTL+WP+L30e7PRZwxfMhi8x0ZG4o3P+lTRYBpW2 +c7kx8SqRbsdPiiFI/Km5W1J+MRJTXRfJWXWQ/ouFZeK7+Z/B+4QVAq2MYuhQydJ746uYC/Ml +XFTskq8AzKEscv3z74icBBABAgAGBQJW6YrEAAoJED/Sn6b/9qwxD0YEAJl/JnwL7TzHc3sz +UcM6mZwEn259j09SdZCvD+WFylzhT2wVN8vZczjJz9y6zJHG4ArZr54FA6fvlGYryr4fO8SZ +uJMLz81lc9e2t7HX+A6ARCbBr9Jh3eZMyQ8KbKugLWTS+sMWoytBWKERMbEWqByO6VM22aex +A2TfUi7BDkx+iJwEEAECAAYFAlbpis0ACgkQvcPDrYZms+9ddQQA0KPtM+Uj9hDJCMXr+fyg +DboOWkxnt6F4+nTgnu8IM3NBSPZuqK9yq2Ww+fUcARvon/oHm/qJs1Ijrdrm54BBztXvnVNW +BLS34dR54wDo50nuSNZxgUmbcU6AS5kNUTU/BphG/duAmytbXbS1Q/+lnqCqejBHOAVyn+tS +iO+f1gaInAQQAQIABgUCVumK1wAKCRAkdxeLUUQLPrIVA/sGtJKvofPb3pc610g63IfPTOJ4 +veTPsdwh/XV+Qcx9j8CM7IfZMZR1d/vvdwb6OYd1gjTGirqIIng9q1zHXvn1pOho4ErysfuD +5q+GvB43o2xwrPzJCotmzuGFFK5bGKvqBJjTpA//d8Ps4ICdq3DsBded5Uph0VMgy8kau+PI +pIicBBABAgAGBQJW6YrgAAoJENWnVOmfWFowvFAEAJ9LjJEiuMseNaW9jXnWf9+TH5PlcefJ +HcO7vp8iML7S1FVUjIHVwR3yT2gnIVUEvAMRIvbfHkwDbUGNF5oL1THQJvuOGixvZiXhgwyV +dWLHvlw62fbk62U5bMbu0+nMaW84rDxjuVEwYDpqrzZMTUrGH3FAAb0YN/k53rBD1+CaiJwE +EAECAAYFAlbpiukACgkQCB+sDV01G8jmKQQA5A39sHPghU5EGHlDYQczwO+Z2RAfWnQMXius +NjORj2gozrq5Ch7UA9QCWShzjuq+ENJsSgnLBa2YCw1B6PwgDeXdMk1a7PcA6H0WNZZTp8LI +2ftSvdLw3TCl0E6B3gf8TEz1epUgLCQtTn2ef/41KR8F++Edl0/1wqgmIfxsa0+InAQQAQIA +BgUCVumK8wAKCRBODSaDK1z276YQBAC6w48Ebz+P1f8o2MIAritsD76JhFBbUJeekQSLVhep +hjGzJUxGdWP5xJAd/SU6Li3XUuqNHIscLT9IdPawHct/ShvwfJpEb+4XBjYWwo64ge93apwc +N10Wx5FRX87fp1qLUJRO9cLpN5IrZxHAW3n9Pzi6zt5bQMCfHRD5GiW4Z4icBBABAgAGBQJW +6Yr8AAoJELA+/COgOxvjlAQEAIA0QSXkc97+46h8rCSzrN9YeCSRZ8DHo2w59nCboe5LQxIA +l1oZqQ8dz40uuEl7O4OvfKPEgcl+xZd1qsyvYyRWGLtF6aVSZwJXcIj+vXbDY/7T460OLTQz +Dv5WYWHYK+OdAXeqavHF7wtNWHHrpYb/BL/ALI/XTC0IgNLLdBfqiJwEEAECAAYFAlbpiwUA +CgkQZt3N2w6bwC9rEAP/UPgcFs//TP+VWThx1Z8pQuQi22S4760qab24RalqqUL7AnvNLa47 +Lp6eVg+oVwsB46NCALBFDstDEWYj05A/FjOYiU+UVkOHOeY9HeKZC3VAi5IxBDrDipC72vNQ +WCtBi8WKhTustQIYhy1gbXXz1VC02hyMy33aIjzKejaNg5+InAQQAQIABgUCVumLDgAKCRAK +Zcu+3GB3KOQnA/9XEzsI78JgZ1jPS2wclon1w8lZ1FSAnUSRSc66vv8AVS9pP3gotVfCQHDD +MHofSPCZXrDjhcWEJxjxzwK2waalP3eof5v+IxuOLLgSRDY59mUUe3JmTHLXY3IFr0VgU5re +K7BkgXPji2ucGXIAn77KzMcIoIBAtzR7ZYA1zBhuWIicBBABAgAGBQJW6YsXAAoJEND/Rgq5 +1LBXVIkD/iIqQ25ABC4/KbauB8gjmc0sk5w4XCDdrWgTULe7W+9r4ELAKh203mCAObxSfy0B +6FlBrEyJwlur7sXXrUhnMgGcuWJP0KjYp4S0aNKms5FdPCVrPTEzHaq38rglY7ekzQMQKyMu +ERQ9tN/2eUIqQLjOosz3mm3CFAbb/ZECqcH9iJwEEAECAAYFAlbpiyAACgkQ8TCPKajG0DGR +rQP9GwqWMaVmEewCcRsowIjBZztBJFTUMsuKraDlylLNKkTNd0pJb0o8yoByD4xZ2Xp/z74m +IOTRuJQKW1cU69JoueWQC0Ii9hOss8XmjQmwITo93lXeTRhmfLbQEzcwWWCwMSRflu39wMZY +aVHvikxbw0DiQ4DOuEvC60KyhPJTK6mInAQQAQIABgUCVumLKgAKCRBy420OLTpRa4vnA/wJ +ouUuyf6el1M84fcnxpBxH8K6jUw1hLg3t50Hmwbvo4Rfdd+56TphHo61fLPXY2KIjYWcWj5C +yM9SE1CFb2msr+Lwqmv2ASXjfK1uwHWtw7x5aFIWxJSfU0rnXublVqIS+ZDhVCs95oEgpuUH +slF2nAFgF0xkKrZxGduPcGm7VoicBBABAgAGBQJW6YszAAoJEKklEZ6xWy0dkxgEAIL5WVbV +CJ7skHCc1y3JMDKpjTbzBvDhaU6n98ZCMD5yqH4Ximn9i72YYK3G1EvELsHRNFk8yW2akEb4 +fhPJJV4qPJ3/rIlaJuwcZWe5zdA5Tpwk8DZIlRqneHgfKBM2JkJsKEZ9EIx5a9xS0nYEBTlh +exXKXrU9FiyTG1OmTdLQiJwEEAECAAYFAlbpizwACgkQ2gcMejGFqUK/9gQA1iiw/ZMjH+2Q +zIvgS6CUCx0ypWtt+Cg4FZH/bB5VxnEd9xNkIMWxWptqLvZT05n8f8gmVJXsDkaHqnxbgw5R +mKGCKI+D37zvDlPY3mpKqRPdESqShdG7Gd5pokl5KEPYr1B930LF4Sl2fvanrH/zn+Y/tN6F +tMnOLZbZOXVFIL2InAQQAQIABgUCVumLRgAKCRAjgV5ImRwOTjZUA/wMekDgRFlFCo9q7Xh6 +KoJPGCH7a6QGznMX8jfl9nA4V0T/tWBg88V9pULr8HK/EWXudK3CdgjjFX4/r1ZzpnIj00EU +io9gAnbMNU+erWi7gdOgEo41Ncu1rYNBvwghrXGbIltdX9cW9IpUUoVBL/X0UGNNGNgX5XlT +7V8mV6qX/4icBBABAgAGBQJW6YtPAAoJEIBtT9uN7egSeq0D/2iQ4S8GAtZ/7me3biDV1XUR +78hYZRk65feGr3BkYkcQTLqWwtWVIKM73IdZwFkMA4ROvhrygTkOoma7nioI+KV2w6S05aXj +KNDmAvi98HcDIHCOoYmiCHqjChAKk0T5nBSPfcyHO09ILHflpfRfFjFDJ+YQLWAtmp+pyvVZ +DUjhiJwEEAECAAYFAlbpi1gACgkQ660xnOWxSnaCfgP+KQrhs7rKeBU68U0pUzWv4RY6PQm3 +bMxbS31tl2MP1H7C2bxAqjlNxdzdwHj2VOwrddC8pTwtc/dI3cYWb6WKdKmHBE1iUoyTtDta +Dulzy2LBmL+Q/3uXS9K0kbewbLVvC1tG83K4bymUqtJKjCFMi55t9bYhWkDI1qV0NySQWhCI +nAQQAQIABgUCVumLYgAKCRC2dfqIMgRcNHn6A/wJwv49FA2bBnrsUzuvmL1/ZZXjzTKmv5lh +kG2hRHF1PzyXYTwsZP6bTi2bOg4q5baA9+Xk+ixs0xcbpMi0rUE0CGCagVrGQDnQsCcAD7uB +6vkl7wVINplo30ro6penER6KbOzvQ4d4QOny3mlQ9u30ntXSoCLLPGsEO8lfIvNC2IicBBAB +AgAGBQJW6YtrAAoJEIWzHW6i+I3/cb8D+wScKQOZ9gNYCX+Y4SvLNmXeuuWeeXYptyd2szAq +7YbXchh6Psj20l8p6lqwhOqReP/f0Vsg+RABHllDsg9ilmV6Ci/Key0w9FieOiaj9qMknrcK +KP4P+HG8XgTBYiPMSY3zJRg0sri4TM/ti03Rv0i1a6R1Ozms4RuviR5gWHDPiJwEEAECAAYF +Albpi3QACgkQy+uWGbWIATPtNAP9HYtGtf6VCgxu2b2hdYCmae8SkMKWlEa+6qH3A+g/Jx86 +LCkvrBZZcm20kOH237hsJq4Dyr0Gq86KDlWldQ1ORa/8iKbCHCm1wFyBw7EBmkLDurU9s2Kn +2xIJN0PPZkTJ7Dg69moeENN26MErSlVbfFP8BFctO0r+X66AfygCpMKInAQQAQIABgUCVumL +fgAKCRAvwWTeNqoCuZGcA/4of/32aezeopI4AS0CZ8yZWUI30tL8wFiQgyKY7w91ZeLsg5hC +memwVX407amj3ViRhS2wqbOfoobtR/AqrcJhLPciKzIyTor8cBFpEREU+91euGiZqqkgAp2b +PJRTFRAnwfL+rde2awtx0uuapj5Oc8hG9kje3jLAoyQn0IE3LoicBBABAgAGBQJW6YuHAAoJ +EMUF/ox317bH6s4EAL2RjvFVrfFUzCLs9Vkm2LKr5NrB98dXUhHygG263037x2m8j8l39KOl +05jHBgv2r42UmGwz5MDlr9oqWO2uzn7NR3wq3syw3GqeqyUdWh0KHL4OjA+Ggrw65roR7seT +6S2t15DK/0IZ309KSo7MTc4JqahbGRI8R61vLxOmyqwdiJwEEAECAAYFAlbpi5EACgkQ6/hq +Kp1Zh+lNpAP+O0pZvbJFfpX0eEgggvl3qWW6WPzOCA+CP8j5gtkECx9nCoecdF1RAFushUpQ +4QwCgdEwdXMROtbBBZ6mUV347JqTnGFLZcd5RzSK+b9gNivqyG8Djr1lbloiznvEZH+9iMhH +rYS9FXZX8KtJnggesglEzelYaJ93HcwTkN70B9SInAQQAQIABgUCVumLmgAKCRA9KQgSZa52 +Ock7BACVY/+FbSRhVLk/MgkS9L3pDJiGWT4zeJ4atnjkK0T8dUEhVSn3OvOCJlKkiovArCFL +jh87gmH45t4rlxC1MQMh19IR/l+gWalRNe5C1CL/hLzbSMABetJi9Ek/bIqEM9PEVm730EUG +trRnDjp0/qdyTi8faJkiyRLg0WWL4pSbhoicBBABAgAGBQJW6YukAAoJELL80I0PrLei3ZAD +/RSSU+MoZ/pt2HuOTXn5Jrg0qiwXD1NqoExe6RPxC+JXt25vytpE8dqkCzUKTWrHxQoDUvwH +2bkqpn6OUzjE0bnODdET09Ou64Zwchyw1OkCYVoaeGBTr++p7tSS27npNVq1/hBkja3frSgn +HVzCbfTjUfk3AblnJCKZ8oZxSDQdiJwEEAECAAYFAlbpi60ACgkQH2ml3/jMp4dFdAP/b7DK +BDaAbfWbJbpvouCsHuv0jKdSfT5GSdRcIBmABZ+2nZPK4QbFNNCAGI4kZZQpPlQzYDhoTc8t +/9Q5ztd2+MyN7gYZfNZ19kyauSd5GFFqNb1K/2P6zSz14F4LUP8oEffXwHy3ItGYabf6MiaN +YumAO4QQPk010JO6wAUmE1SInAQQAQIABgUCVumLtgAKCRDL73y5qG6DOqTsBADDwNQmNNno +Y1/APHhEC9EfzTiWYImS7NQJ/hGJ7v++oPNEyyJu+XW/uiJbklRLhd/28TYCrI9/bj8JIkPg +hzEMupTxpM6hQOPwtW8lf6JslNJDYPmmhgnJoyAVGuyoa4mLK1IjKeX2lUf8C1Kg3YAYisnZ +CP3o0waEPIvh/u5YyIicBBABAgAGBQJW6YvAAAoJEMkkITuwp+gyty0D/3fI3VdfU40qhFRZ +JD1nQRdNmGscEJ0GJoUzfIkSQztp1jnURU6aqrw9DwLc7RTAoDv1DLGuzht1tMnCgGQfkAc8 +InQzx87/+xe9D+A8KKt0yGGp7yHljGL6Dj8NqQL0SCRUzaX530KUCz8R4JbTi/CwXd/vMg4q +OngJB3V6Z3awiJwEEAECAAYFAlbpi8oACgkQt9aMQckT1pKPogQAm77jSaDyerfmq9HqopmM +PUleTWv8+HUE36PQfCUvJPltNZbLfadxeJvAQaJwzmbxFzt71yV2qWukNVhVwXrAf/ccBAQq +u+mRSnEoIkv65tLwTVFsY6QmCa8jwTMdv8mX0G1of3z2/dyl9qkMtZ1C4w/0nFrORfYYzCDc +Y8zMdpWInAQQAQIABgUCVumL0wAKCRCUM0On086R8cl3A/9H7Ws7sdIh5eYA70F3+b3R5A0y +OjO00Er2TSdZkFJn219Rf2AH67JL9e5NJkEN3zfTzxiD27yicZQlNiUCcZrcugzlNh4V9CTr +t36RgdWjdUCfJ42AqHASgAUQaicnHF43n9BZ56OoHZCf7P23RmkXOz1APyCy5odLoVA1/Ll7 +14icBBABAgAGBQJW6YvdAAoJEEZzjToFF4BozzEEAI6QYaPQpxZ2W4vRc3KZluR1nE3YUA6i +DIOZ98E64LozOX6bxugcvPPBTeNcquk9immrAS+htNpZiGvkuJ/Bg+VitQi1gDGSDTTuzEfc +ZPBKDvxmTnGPYBO0ZxZ8hzPNUSgLnYOGJj7TnPhjV/F9NSxRbBdBEFXcyR71HgvugJvliJwE +EAECAAYFAlbpi+YACgkQoDi0juqL4+Jf9AP+I3cZeWPT35dwFaDjFd/0FbX/lQ0zcZElkwdZ +UkEjMWd0M/qAvhEHu+c4vwxqxdG7g7Mru16DDIsdHz89vvQmAvOHrNbPGjCpVaLOkfdkWenV +JZsDPiXDzC2tp7dwCmO6lLqIt/ihu/f5OyGX9KVjIic4jmhuqcZw1v/SWFLnmhmInAQQAQIA +BgUCVumL8AAKCRBsB3RJlQehw1X2BACKupfvenQYP+uN7qQDUdFjAHIpTTsRHT/BgwJcB2c8 +hTC32nuBjXwk5Fu7mkdbGHyzho2tC+AT7za4Z4jGW1ps1L0slkHdwG15cgl0oPPMfikV/j5D +6mF0re3aEuPXOrRSUqml01uNuhwrLTgNReaePGj27eWjhBtlu2t7GNN6ZYicBBABAgAGBQJW +6Yv5AAoJEFhtFFWi0sjF/c0EAJ6fINEKtAH3NjKLmhG6MoJIUiGiBpNZryXWUXDzEEepHBlJ +YB/5mhvWMeRtGVGKn8efC67AMPlm+I4BHjHlj09DE/9KcLlY3kTiqYku49OsQyZFKZLpyS4f +0Zc0wcVW0H2wsOH8i4+fMx4zjS8ujW/6+g8aMu2RUMND4R12AwsIiJwEEAECAAYFAlbpjAMA +CgkQgWyjEx9VKiva4gP/W9mZVOF/dVRXdE+IPXOCszZxMhtgTvchYvLS78YdGj3rcT1PpY5h +KRbcZGwpnSu9QeieteWunsz2xsz3ubIXZqJUNOF8p2+SPOmUxya186rTxmVZfb11uE2Hn/q0 +IC5H1AklhuaHr0lIBmPzUx9Qn9h0l9LPJR4AZ6oQZvVBMQOInAQQAQIABgUCVumMDQAKCRD5 +JUoslK6JAYaEA/9yRNDUoakb4Vza4PBHld61HTSaTxnWQ3f91NOubpRmhbaP2aihDz8unYI9 +EatZHkvftfQXefuzaYxbmU+C/FR7m6ojf4TSl1sPZr9yJq917z/zAb8/W0ZThWedg7g6q+C5 +ty6jhc0PPr5YnUPXhBnnHuJkyjCQJI3rS6b0RJtyy4icBBABAgAGBQJW6YwWAAoJEGPN4gOL +lOfjxrkD/2FoOuxHPpN7DcafCEdNQjC09Xfl4LYNiw67oBxNCtcF10KQu3HoPElEyCGi7bdm +XFlO+V1Rh5fV/iPb6LccqDUkz0mHxj0oBi8uG3sU3fCcS9QJ6BcAv8fn1zt0YQSsCYeBxoAM +ElMxIl1SQHVc+2gsZIFokqgEKSrHFXo8jL5CiJwEEAECAAYFAlbpjCAACgkQQuafi/4GOubj +lAP+JBzreZOlTNXaMIyLCulFANQZ25JeTRiT0YxybHmiO6nIKhFjrP2tqdiGlXnffn6uGkW7 +RmzsUYRcPEvIwjMZVOFV+KD21HSfBxd/9XTzcXsziE8guaGXRnqW0zf94fMrmfUXwsWhBr7d +WGky6WcVTrt9k+CkO51TPm77FBm+TZWInAQQAQIABgUCVumMKQAKCRCh0CsbKvpi5fZRA/9q +hVoPnggRnapudYXQm852q+8Gzo5ViRpcUz1XcLvERPeMrplc7BF/u1LWXgKpoMhzav4LvXLf +1rz6hj9Xj7vYgoIHupfrVcjUXms7tyASpkDT4BaNVKYEeFb+dkcIUaj0aFkNVjY7AEnW9gkg +qeEv+3DgV1lI5AwghMJOjwSWyYicBBABAgAGBQJW6YxTAAoJEJy7SPeklZL1FGAD/AjL/7sj +WV39K9HbPQzHQSqXsdPllwLZzo4f+l01Ux4OqlJj4od2qXMYtkddIKPNvzg0WJ7vuI0u3IjO +IDIDED95mim6BVEZ8A7CbFeRfz/3GWoXY6/aU5bD7Mls0OvK+ja0xEbBf+XpNaRH3xtDvq1j +q8w/ahUOUIzc9klY4NkziJwEEAECAAYFAlbpjFwACgkQIhluML+63pxDLAQAvQBt81Js9mml +RwM6qmeL6XsjmGhTH5T3NglCn0m5ti0rFOTHf2XwIRBzdAWFm2ys+dOTqZDtgI8V4foeMhMA +N6s34zcBxLJxoa1cxh3616OrwOb/LDoqf1n0oVbYSsM0QRQen7joxZZu6zkEfnI1sJC5Wvhn +3vKXiMCRzlFyZhWInAQQAQIABgUCVumMZgAKCRBXowuE2u9GHhvwA/9u7hGJShmkVDOXEjbl +vydltcBYbkKLVnysBDovtBhhXBX57xfVhBFlXukcrclclZOZeHvf7B7nNEqGPQ9US0gR4dJe +BOFVssrJIu709hja+g1ANtnFm0w4B7zM20snu8UjWw0VCe+a1Ehl+6ax9E9Aph434kACxAkm +hkrdrBDk4IicBBABAgAGBQJW6YxwAAoJEGJd9Vgbl/LkclYEALNxgkaZdn7DRDqFdwhn1smh +GAlAaRgGux+Jvcf1yzpXEkYllS+NiY+Fy3psOKU2GEPBn30bYoJhPleJX5b3IlVYXsb1Wwvd +iCtJz1sXapYaZBj0iAxBSxFNHibBH1rSvQQ/04550LK7ERLbnHBUMUIfK4ZptyCGxozg/cwT +dG2yiJwEEAECAAYFAlbpjHoACgkQZmFDYapMABOQsQP8DkFo7/qnYagSihgrP79ZHGkf7bwI +OAsOGW+0UgpJMeQdC8TibF4GvSxd07EU6g5su1vkwpzUHPoOk9UkayUP1u9qOLuSUGN6QVYP +T0KwJxc3RTK6WMTyCv91kz/x3uHKtVFlmcGaBmQuQmrFtHX/BXNYHHhoRpEbD4kGPmaxlnmI +nAQQAQIABgUCVumMhAAKCRCWycVj6vtdsNUfA/9rbQifG3eNjFUeQSx1VwxtENipK/EZvWZU +RIulsnNmUqawJ8zEhNuD6NAqlyhzNUTLTN7e00yWXad++lRClGN25+2Tf5rmG8v1Zd75aBiK +oxstB3xJh4pr65ZUTmplexiK0Msr4qVRvXvgKX2hxwcBLpewXIu4c8A6zE7NmHkASIicBBAB +AgAGBQJW6YyOAAoJEIQ5BUA+9I2IvCYEAKrZqbmdPdToNx4XotsltFI02rjEPQ4yMmw35LdO +Wkfr120mXl9V91Tdatp5xXzJFiMLF3dOQwnGb34Ruw1grn8Okj547xhWshwknHC/VCRFcbly +XUDsfHOzQof6U3E/cnQoiAwXFtfy/9RVmTMP7K8ZoWl/9SaPIgj5R0Uged/TiJwEEAECAAYF +AlbpjJgACgkQA+7cs79RWLo+zgP+OkG3JZiczmfAZpAWnf1Xcs2iEeJ0yAtvt4/RDiBntcSn +6ptz+OoKwhDZzPtdsT7hONK+kfgapn73GHnWbER7ommR63M+OFT8nQjXqzQ2HQsiS+C17oqq +1c0N0UIrLisI6XL3ImEqblhAtBMqQB+l2qh6aBjjt6vs/ZW2xhixObyInAQQAQIABgUCVumM +ogAKCRDCg5jbpF0CbNv5A/9ykgOLF4Ja3sbHdCt08+AtIc1bKI8eytAtYL+sqq3cg9JPTRUb +K7EjzVIz/5UyPrnkVbfQINXWQAwaJowrEPIrv1y9StK/un8TMA8Q8deojAj1yogx/F48Y02Y +JPbEUr7aLCNS3gnbs7sbdd1i+dtNdlERLaTh+y+6CTHdaTq34YicBBABAgAGBQJW6YyrAAoJ +EHLu5r8rtHhR7OMEAOREf6CetuTubMs79ZqNjdkqw/6SLGCcvBl5eh/QjHNTb5SoNpLwuMTm +2JXStV3LazafLT5zCCNo4iQuGxvLiSTMpLuvd5BX2RqBuAJ+/Qn7Z1rdrZiDObqlooSzq2lP +8t0SjbgdSAMU79PC9YNbWrdpAAx9lSMYuyv6o0zwHm24iJwEEAECAAYFAlbpjLUACgkQIY3J +yM3xhxYNLwP9Hg2snBksrmwTsPjgFOr7oU3l8DChGYcuoIedIpOQ/c2WhtKaqEI/K4JVJmYO +mZAcXJE9q26fOVJFX9covBUCDpu5bUrm+s/Oo/aIUcRDAoBxUSgZhCx38asYgJH/5FEX5DtH +yXKuD3DvTAHmE5ReZWcXUrfgDy5OVcaJULg+QPaInAQQAQIABgUCVumMvwAKCRCZTzCrrWOh +1MiMBACV5UPX0XU/AXO1LPBluI4Qou9Eqg7J2SeGbH6GupOUMi286Q/xdHaXxPQVSM9qJYLU +jxy0BbLHcXozr1L4KkdHEMdZZkV/nvuM+0DfAwGpunbiTLb5JF67UVV1EmrxBCqvaj5ZQ1R3 +Sx8uRfzmy3+PwwoQBUa5WF8I3TnUw/v4eoicBBABAgAGBQJW6YzIAAoJELW/yv72ngI2H2QD +/jv8a9IuHT33Vmp4xa2hFe/bxeLm1r3gje037roZcSLLYScRWX3mPjVoAEu63MkIWEGwVA4W +nBf9GmUpVGfBVgN6Mwem7Q99Nt1Jv4TFJiAqCCgeqrWZLx21jgSZgJkoCWdhv9g3pQvKwHqO +JMOmmOs9n+HtbCsmJZiVPDCNHuGtiJwEEAECAAYFAlbpjNwACgkQWELm726lqbDs1gQApMbI +lj7ccGS8o70KEVoRJ2ngxAP43KsMI6EkH/03dGz0j811g9nM8ZlA+Ossemg9sHLqmvkHjeRv +BzjEi0HeI2bE0dGwB5NPTyaRnqqq/iXkmm4smtxr0po6pxjKBThK6/9IoMCa5efFDwnn7Dhb +zaSSRN6mmVlc8/1OxZUDor+InAQQAQIABgUCVumM5gAKCRCGXdyWiQgtMJVhA/9iFQRZrxPA +xapsmaukNf/hrVpwXqPRKfTzhIJ85x0sDBdvDxOznUFGZOzP2WLNG6yfXsnNFv5zPE2nSUNc +TzMvyfbWHz5GRZw3UE6e9cAEDCA0RafrcAU9co1JsEOifIUMG+YQyxLmRH09mGEJ1lOznUZz +qN3PPBCdDoeWZbR8iYicBBABAgAGBQJW6YzwAAoJEPhPE+B7I++YDD0D/2BsmZQUNufF3h2j +exdemTVBWZY9SH1KeqY1Z8mrnAtZCF4OG2EYPQLqPR6TKYIz4o+9TzSh0cMqy0PsE6PTjvYE +Iqv1cYvnsFbdaQCQlSbOn7KXI18V0NVnKu2wWl79mz77WgZs2jVYMfpJ1GnETdylC6o1vxVr +6ONhIZXBrHEgiJwEEAECAAYFAlbpjPoACgkQM7K1eCROws68iwP+MeO23OeAwNQMM89+KoaL +IEmVPtP11h1RKa0nKq9c/9AXw2o+5aB7ib4nb9FmZFGVct5wQVEYk6LgFbBwmeeLyb3Ia4tk +9+/Oaocrk4x228svV3oVTY9LclX929reBmgyy6SPKSWaIZxnKTDkVYkdjLfrMb6B+7ooFzRa +O6wXXlqInAQQAQIABgUCVumNBAAKCRDL4kxGzEzr5KM3BACHyJd8BriEHwyJVTJanjjIb2s/ +kodQcdkRL1fNPNQBzYkoGPLAdj79BPELuIiqOeSr/FB4FOTT32biVt7vaUfkU3RW7JlbnHna +sUkR5ARmGUhAMOa7+4iO7LDwcEqLJEBAwbAz76rXl+vdUmypF8WKM0jQaeyoU+MaoMmQNaVN +s4icBBABAgAGBQJW6Y0OAAoJEOkyzkuu934/RlkD/2C/+n8GfvhmvqUyBgl1iFSQJOaEPnDi +hKYYkVF8OYMbOHykTnrmDPc46BJGw6HLxOk6GCq+VnW8TqgKPGEZ/xvZfEyAPIjRyMsK7az7 +VTByBT4zS1CW3aSLn9mnmxg3PrkeWOq/evu9zhWtpFQhNLmW7Nk6WQycDQtXa5zQmhbBiJwE +EAECAAYFAlbpjRgACgkQGFaFTgk7iY0XdgP/S08tJSLqo24sJ6zlOMQF18puu45pJIpS4ug4 +Ith3LzLhLUvJcyRGhInWBBRfIsvZuVttd3ExgiZBPNQ6ono5cWGAGzGfOzpXTQMpRSLfSVZj +h4AV1nK4Pz3WW7UYynqtYWaM/1r+AB/mu73rIpO7MO37xUzRrSLPPh7aYVpNLBiInAQQAQIA +BgUCVumNIQAKCRAFY3UWH4BmcXZEA/4xCDRocJgkSpX7Ro/30plz6Q6PqLfVQ4rzFVKhOL+e +TZKY+7NqjAxQ/TlsagYTTR7+uJ6B/RH2QDo5xRu2O2MoBTPW4it/qfNIHf/s6G656hbnvoyD +TStBGSs9989sQ+MLDkPRN2SymPtwsP3GoMu/ilTy5CPjZ7VAQsHcjlzmVIicBBABAgAGBQJW +6Y0tAAoJEDVZzQ1y/Ok2nEgD/RslDCVhg/xBtdgCzlhebNxaAcncXRsWQXArFcycIJ+rC0p8 +JADYs1rcNhK6/0s9Z+rGU5T7UUBbqf5n2DQLNOuHgumZgEDr/fV//JfieQ2sVHrXcPced0Aa +mgx7Jxko0Ojuxa8E5NA+HVTraARvv7amWOTiY+u8XBi+rgNc5OyxiJwEEAECAAYFAlbtOOQA +CgkQ0bGrbInUDba0AAP8C+HNR40DuAfvJ0vUSKWf+J4kFR9N5mkAOK9siu56NIAJpZJ6F4Ud +DME9ld1p7xW+qT1QRtipELLLti3JqfchhXSFmPxYFfLiNXYGxw+VrJBTL6uK5aGfL9N3J3Hm +BZ2bDCYv0Wy+uccR+bX4ZwhQbBDpUZt5mFzk9KMyXMGgQIyInAQQAQIABgUCVu045wAKCRAj +P0aGi69eOzx6A/9PlwSq6ccO3qaiBpmFLYRpIld1hvfOzH6c+FIIDDdQckLw0GHrGI9cGgxy +1nq8KnS+pPC40AUNTS0ah9i6q9dQGHDd7RiDYJSAJQD29FbG1ZYWxykoIaZI9/PXQR1PLdoZ +P5GglNS+l21RbGHzd35aRsjd9d3n0a+PcDeV12L4G4icBBABAgAGBQJW7TjpAAoJENBy7Uua +ti/WqjYD/jvnnbWo2roxXC0pQ65pX7z0tcOLi9or3Yqrm0Xz/hcuOMD87qhWI5oiwBaRtrHu +mPFZ60ALug5Q7ayddAQSCUGKC+P6cbKFBKzrxio4Y3StvtMgjC8j2k/KOA3mAudwsHhDrOU6 +XtlTzS4qVAgyusmjOsYD9EiBE8EhfHNI/DnTiJwEEAECAAYFAlbtOOwACgkQ3+TMd5jSMKLQ +wQP9G6mhW5heIaPf1LIlRhmkdMhj2HQXvioaVbCmRFXv2EXPLQ/3xYXbP5fFuKIBjinoUQd3 +9mqXh7wNDQXnbEzKTGtyFbELZ65WX9AHcaGlIBrzQVVj/ZLhQ/ilq45KOwhTfKpvNNQArvPI +mSCpSeIOvXKXHaN6RO3Pfplm1RWDkFGInAQQAQIABgUCVu047gAKCRDxpZ9aY4fJWgfDBADi +yBFoT2StCSFSsOpbq0LULu4BxFQC3AqcRoKPHWLI0VIIiKrZVFzArSrLnUTl4SrOt9Cq7nM3 +yI1L0mr/v+D6hvzzkz3/EgFUyBZS6JUzwoGcQZpJDC4cMSyn3/bO8ercCDrljfJ0DODYl+4a +YpLk6QxlUABs25LUiFDRTTobc4icBBABAgAGBQJW7TjxAAoJEJ/c8olN0VgNt98D/1ytluUW +xh5IepeOqsw6YvQ/LH4AvvjTqEWClqyNys0cLZZW7d7AYnwhm0ICgk4UQkS35s2dOSm6Mrhd +tXxXN5wsH4W6AzD19+/2eyT+M3hZNvFnqw6l3DVim8DO32kuXCym2EBZOXbpa19Bacmu02Nb +O+/2PxeaQbmeEqZqxQpgiJwEEAECAAYFAlbtOPMACgkQC9ne5zmYLjZ3fwP/XDwOxhHUUlAO +1aPLznz1sYLXxnNAnMfcJpL+ciSM0iToPQNREWntmpjec5SwMIpaWt+jSDSGonT+axmZw04H +5fr565YXdOBXTIlhGVDSat4tuwg9UFgF4GXME214DUSXnQytCNSZx2tJ6w5SLVYWaiL6568D +gUf6mUgvC2fVGTyInAQQAQIABgUCVu049QAKCRCtkp0vDBepQIj+BACj96nXlAMrxoUhcVL/ +yHdK3CPyCLflXr0kXDJuF0JOmQwedWhx0vbTD5e8/DpkYF1hkIBO5e81tClPFCOeMWRKq1p4 +qGN8T1ROLWC6mQ5nP7DBeFocW60z2jXqGFHzFx7uMYRFAc15Rq+Ttw0q81LESWJawuQzNb1Y +un4O1usDEoicBBABAgAGBQJW7Tj4AAoJEDuwQcu1FYG1spsD/3B132XmZw/4hEARKXyn7j8p +mflehhuBZqj13PKFac6b+9/FGqqEywWa9e1PwaVknQ0HwQ34/hGYkHqBjiLm9vbXCAOLsH8y +FNza3e/4Paa7XmmbfmsV5oyyn6+ggO+TuxX9Z3lNRVibTC1i0dF4N1HnFFwa1dh+OquAM3+i +BlmiiJwEEAECAAYFAlbtOPoACgkQeupMbHLLAaZdIAP/cgv1f4NZTbefOGV9Rc5egZ11N60M +W3E6Cryo1Zp320rol21IMZuHoKMo5UCuCBs5/TMr1snpdKRnEoHydrycCzYJ0Gu1nZp50wZJ +Qovc/rskaywTklFO8cUkdJuMnx1+mGkvLy5EoASq4Wh0kQT4YZLiMBaqsWkMVPK+8h0ZzmSI +nAQQAQIABgUCVu04/AAKCRChR4lGL+H36KHpA/4iQls+EnAkoduJlbaaZUxIyj6Y21wbBqv3 +K3VPVWIHnq2nVth0ZOWEfHEpw12IytvgF1EYKhimHiDsYRxOu9eQqhA0FIMS9T2zI0czE0je +R8iNH/L61rHajRJZf7lC5YmUCrxlvjFIYFK7+hnqR0BLrMMr92K3viu1KeqD4km6FIicBBAB +AgAGBQJW7Tj+AAoJEMuJlKzSudtwJhcEAJ3ot3Q+iTOPPj9eI1pKi/x0OkDn8ooCzBr/Lvnj +NQLlA31pqq7x1w+mRcOyTLPbwpxZMwnStc3V01twd3ufsUQUaAZzIZ6/3D9lhOPyNDl8MMof +L6YTjDOSF0E6T1qm4qhVkrwejjb3cn2/2iwxhO/VlUYKOU1JAH08OW4inCsyiJwEEAECAAYF +AlbtOQAACgkQehsDdCfOKt8wuAQAhUKUBznJyI4rF8E6j8CXfWWcTMS5IMrveza5cLvFXqd9 +Lnt7HKuNmwyJunh3VqOwl8BpSP1BEbGYFWlczFU7b8LgK3WNe30SwkvzjzWMV4q4Rs7AIGbz +3e4AYsOG8ynuDYLpPVyoZdJFOvaWjtJrpZ319ABiD5ab54AxuxlSuq2InAQQAQIABgUCVu05 +AgAKCRB25RtrHqHCoRbzA/0Yb069znvIXdFPnOT3g7uO65CeSToWWTarpP+ckwBzL6FCeDpz +GvHg9Uh51xII6Qzc5++DSOSGXHDWzmWg/qfFyXyWVL8z0rFDnVjVtsL8vuy4+RgIvk/VH8Om +KY+FmMnF3ExMA64MvoIItw0ef5md9rDKgORpD3bLp0UWl0pwxoicBBABAgAGBQJW7TkEAAoJ +EDGbnCRVkt4EuVoD/0xd4VDcHLl4lbSBUp0p0E2hiVs7r4PevhAbsyaoVihvRgonFrP15ibK +2hiTaWDKFoVb2dAWC21EXk/HRPMAGZ+0R8OUj4VJ2uvX9NC0lTIK+jeR/NxSAO5Jb0CenG+W +W2YaUwyaCNu8SyJsl6iX353NuimiBaCipat0qGzf9cldiJwEEAECAAYFAlbtOQcACgkQErcP +B47cT3JGSAQAo0or+y6I+O256U0NuBGx387s3pblc7nEZUeSzo8lZ2FrwQikEMl74Ly5G/g6 +C+w1UWdL2qMumhYeqFQGnWfGE5MwlMQYzW0iRENWGXM5zeyQDIghZ+RCDyETpmf2LOWI3Q71 +laSscb81VU1Q9r0I1giUuq4MeWW9TYiiFhB/WleInAQQAQIABgUCVu05CgAKCRB5LrB8CwF3 +hWnRBADEmzTqBaQqRzBoDx2CjgiwyF46fEl9aplQgNcB9UHNJbaPkajrpGWNey2SuhlmoKi0 +JJVXzAxM1NacfmWzMVRbiKLRvZ34GryzAiiqGnNDYkjfBWYLkUYrV6Tn5NHIvWjQmCwGMj2d +5jDPnCQXUaONIQyUNMgNnNfYu9cceVhGxIicBBABAgAGBQJW7TkMAAoJEFov/TIEocR8+DUD +/1MWvl5T/AFVjSqdCpBqlBVz1FaKIwef+L8v7uq/Ijovit5HHfaD/sEdvql+/vHr2w/4sGx8 +ePeUkgewNC4+OM0Zc55v8lb2VpijoQtsO7qEDptpkK3s9pgX9emZlb26We6b/zDjfZChPQH6 +XOPd/dIgHHjwV/5ULki08ueqnSg+iJwEEAECAAYFAlbtOQ8ACgkQuD5GF4p8DSdebgP/d4E0 +Wa8LdxarZr0ZfFKil6nNDbHbDynRzt/Iuweam7jJYsFmxmsYS5kEpwniOPvOXKLbUMkyhe+1 +iqB7oLQ8muG0/XNgCmzWxGe1zdeGojl3V1coiUFrMKR/HxRa00j9n+mjtj9kvB0Rmh46qIMW +jWJlu5ui4NYNKNE3SFUtFx6InAQQAQIABgUCVu05EQAKCRCQd92j6A2xlXffA/0cEzyNoecJ +IV0fjD9TuKomWY6L1vqnskCPQ9vNope+SgaFbjst9DmhDHoITkfPb/eRTsYvlnMArWiQ4T8j +1OGKhkCUhv/830uYGE2pkLKzfCCs445wSLDfVKGfhhBTMPE74K3anhtrwmzg1mXI/tku/iYU +cueTWrvKjzPzNX/R3IicBBABAgAGBQJW7TkTAAoJENO3Zv/WKtd5I/UD/20OGZX+NNZPPZwg +a+UgWo9WDC7c7axUaWf84Xrq41wEuHI923hXUp5NfoC8E0GEeu2cydLHPh8HRxjUNnX2GgZU +8PFp2++78Oc/eUrITJsTwjGPqE1oCs6cM/R2rxlg5IqIHlU+nACmcYAaX3mCK+LtBQS4Sc70 +fkjvSMARZjHbiJwEEAECAAYFAlbtORUACgkQpqyrX7mfDBrCJAQAjP2FN3F2fGRKSfrylKRR +nZzeURfZnRRiEmwf9068mHciSTgHilTPWYGsed6ZwVNwACOBJ97P+zSYNH0JqnKGGsvWTCzZ +vTwrmgTwYZvgehabsYkN/75nkvNRziBRySZt13U/TNH2nm4n0J1BbbPZ0xxxDOOaZa4uc4Mv +tfHFpfSInAQQAQIABgUCVu05FwAKCRDiaJfTmxHhOrZvA/9HwEkWi213h7RPDq2Qzr0qbWI7 +UsC+7jyHJhwplQfOZ2XZuzC7UK9izWUyHQD7t5rKuude37mBg1A1BaoI6KdbapEO9fsFqL31 +5WYERNgnASXdEnVAlQnzoCNTOJxccoPjYXdkSQrjadFsoO/v0G5tpeSgJXiMRNKMoLHJgTDs +4IicBBABAgAGBQJW7TkZAAoJEDcQiLfjqQYyoGAEAOCHSIrVMoHRDl3EzDgnIYHKaROBdKxm +d7yk23qaCgc0BvMAxYIhj4bDm8bM5HJjFXVYJFinYj5jT5KtOsuCLAagQnu0kgYe96Coj7vZ +zoN+HEfqe4JM09cev9ESwqzR5chDOfTADzfd66EiXIdzuWDkKKRJ3QC8RTyGNOa2CYriiJwE +EAECAAYFAlbtORsACgkQyS5UIGoY0B+L9QP/SRq43CVD9myuOj07/SOulR4d7A5SRYk9KCW5 +TXP8gopMTFHLGEGZV2XAr3Axqk8iw2danZLo4u7Eaf2rGu3gUFkimrWe7HUjB+azsd1rULGN +IumuteEQI29OjB1JCrFWluxgYdgzPBxI9D8uyLHtprglc93bvCi7rrzVX4x3x0aInAQQAQIA +BgUCVu05HQAKCRBAjsdy1wrhhhMFBACWLyno4dApdMrJhVfD05S6HP2e1nqGmWlKMCpwK1m1 +dkKUC2lrG+gaCwsUBg6WJsKMX+fz0KzcioyJkG6yFTdFEcvK2kuB2FtCXjV+6Cc0JObtXeTw +hHUjStLB8LAxWUp3yoqaFc26ELiBPXbLilB4oBUjxJXL+Nsbb8VxDtSI8IicBBABAgAGBQJW +7TkgAAoJEP+Tb926o09v3T8D/1/3BnhKU+y3xyIitATIWsJVO6tZrhdSgcMDly0Q/EfnYV37 +4ITIn2njK+c/m5egD9DWheoZiG/S5l3wD4+3N8Nqrb2Iio+d7DL4hOp8mw9yHnCm0/lPhq6c +SyOmPKVBm3C3ttMljQt/VUZ65C6PCpf9AExfzNmeM95+bWGGxh7wiJwEEAECAAYFAlbtOSIA +CgkQkBtZ3M5cBplvxQQAiW9i5j5wEgZ7xz8A0FZ6A2TKe/HHQD6bWYSLC57oRioB1+EuudRI +HJqEPZUf336dIurlHhkeyawo9dK3LEd8csTl92lhf/y3SyNi6E+/WuMTJNvxAkwanWB96rg5 +5vO8JZZWvHllxvq/q09RbMQAz1Jv/TBf4/dc4UKfrn4sXDuInAQQAQIABgUCVu05JAAKCRDj +KuPPKahUWHdUA/9Z9IXLyKey6HvCr4ZG311pkA2GA5Mm6C5GNVIut2iVkRbiQSZCnyLj/Nn9 +4O2PL6rtg8sNFAQTOehZROWYV5dY0mo3cdfUNvwY6mUA+751uC2CVOqBRRjNWO/k6sj3mOo6 +JEAtg13cfuvYloxK3Ox9DTmTHsVUoQs+Hx74dw9Wc4icBBABAgAGBQJW7TklAAoJEBCXsrqS +zEaMW8ED+QEf9lLGwrlOI+UFhnUAgB8h/0aDqVHNSR6qEiBopdc6XIJdPF9Pp3Hx66PTubvg +V5u157WKAFdKx5vCD+PC3esjEo5qbcQxY+CO7o+qWzgs1gTFew2zz8F+VWKPgzul8lRaK2Dt +odZzJqxoYXk9T3mnvSDQv99+rQyJLKj9TAIWiJwEEAECAAYFAlbtOScACgkQiRDog/moirQl +fAP/XCMoNFZ338ye/OJTl8OxPtAfVF5ABx+011HRenumymIVILtdCZNwKIljQ/FndUOtO64G +pYGlTuOwXQFIMpuEEPucpK3BU0xuyYm44NkGP/zb2fnOTbEwgYsz6RcOSeuHIkcCGoKU66+z +sr8lUyt39J05KLNE3PpVpC6kpuSB3i2InAQQAQIABgUCVu05KQAKCRB9/OYdUKbqk3TzA/9n +yK5WyY9yfPP5JR2bLCadc9hu+2INWUnVV+duSGt66kk7cRBvqGh4+yU6LRmemUACNf1vScBL +WaRqq+d5fIXy3ccl8eTum9UdpmY61iNkiTHnqnBrZJacu/A6K+cq89QQSqIyFYPXieZr+8vb +O3eBL9VbhMf/WqHTS/uobapP5IicBBABAgAGBQJW7TkrAAoJEPXrgomPhN/S0AIEAMXW7ue4 +cXxhhDoxLSxC7oguoKgQw+vTv5/bJ5cZF5QVRl/vqIz0nJWGgaZSzXU+LQaCkRVV25PyvDWn +PIn5/j1gfWEA2VFSjp0nI/3q4Yoj/V6WMFRWFTxxnTwwQWXERkJvM1taHO5svuVbEXbhjzE/ +zWJPqcB9EVgDiXPc7gseiJwEEAECAAYFAlbtOS0ACgkQC4IjhBg3UtFesgP/QIIYIeIH7j7l +zqLTK83rZT6xycqW0fQ/fC8x7CcRc6mVQUhsZJBuHTZkTXbVnKEhrl2Gb5dC4o6+YvzGUfQF +w1krC4NqBfUDm1ig8IQgl15oNrP3Xd6vmK7DVPYIcArY9EWEW4zmicNJ+oHm7FBkN14Fo/j4 +oknc5CWv3jzxPHmInAQQAQIABgUCVu05LwAKCRCjPLJwx7wUVGd4BACZvfJ2heiR1Uvhbagh +8RLY1/+OzekNTDmP4tVQ4zDKppgZLZrbTHt3BoMmXeAxs4dqVRUSnoRc7QUbBCxQVY2Xv5qv +oGzvYMQlKL0cNMzFDBsamY8j17sQ0+JQCSuM8ynfBrNZjwASQtu+IMaUnj/ivkzBPkQI8FRd +yOwvsE25G4icBBABAgAGBQJW7TkxAAoJEJYF2YhCGJUAw2YD/3JVicgPxwlI7MD5re3tikqe +O3isVb+l/AqfJ5hpwRUle8Fi359WucPb+fntSfvWPtI5vLSLFVg6eQR/GqlAyz8E3qmEZK0O +oSBw+CQUP2hZGu4vXpH7N4xDVIkPDeTZieAmVxMspJn5JCrsQLS2pVg5MVDM4fSJsl7EJDXA +iQmciJwEEAECAAYFAlbtOTMACgkQN70KrTmVSpDPwQP/SQMHCUtWD8H920XbkmPjZgDBC58c +xb0E3Yl/xHcSAo1uu1DfxNProVwBDeEbjPEE8sSmUajAUGklnSODT6XJEpASrEvyyEZue2uO +UDEw7EBUA6H9l6jSwdVk5Y0ujQ1YjSOWF/CeysH6K9VB8WO4LQp8nZDzMROAQxAUWgS2OBKI +nAQQAQIABgUCVu05NQAKCRBccnHXC54F538PBACfqMsSHRuNTNhjB3mdNKQA0PKUZf/Mj2Sw +PUE3MEnjQKL/P+XjWkUa6PfH/JR6FtgIsVQlU9iqityHQY/05R0h4WYd8HC2wroRAGQZH80x +M2WVGPGALjOXFZ6yCsHMfbVEJ9NbmOfI4v7PYaIEViqJ3jiiHhLTrPRRCN77Mbl10YicBBAB +AgAGBQJW7Tk3AAoJEKJqTckXfigTCsQD/iYSUrsRxq7piNSXUF/X42Pw9M8X7F+B6p42IVih +IZbJ/lYR879pAEaIrxjJKDiJM0Vr6E8YvDUXXn4KYj9nhOMm9QffKMPdDYfC7sFcEJQIA256 +oPt+IiG5eel9G1Iy28wpYFbHPQeEKPAaKleUUIJnE5HpSeGMRpPkGH4GljRViJwEEAECAAYF +AlbtOTkACgkQ1eLqF85/s38LHAP/SdgeMCPn7KUURNaEoTnATroS8W3Wx+LAtwssY87T9AYI +9+KXxrMqdFgJqcYOtz16iFSRGmPukzuXtJqXkJDYK9yP3A5ghVgKQv+GZB3RXCnA+jX/WHof +vrrzWf64xkC6nS8B0qGV3Y7436aZq/vguvcuW9JNJDMBesdbR+HnFPaInAQQAQIABgUCVu05 +OwAKCRDBfmFNn/nnbDs1A/wI5SmJt1BhAYs5XWqRQRw18UGNsGMIs447aobwm8E/KtgWG4aj +Ipo+8ABNbuw5aAIHxC2rh7WvNgdXzIm3sXkrhMg4Mj7KM29BaLTxQSlkHKkPnvgopnuotjBd +xzyeVhTDAygVpu37jpAMT6H5c5T3qc4tcUPO1mWuXNWR3iP714icBBABAgAGBQJW7Tk9AAoJ +ECSZ1fdiB8M4e50D/jPA7WxlpTkkBaxXjIrAIQZk1xmR1JwUo7v1aw8p4Z9mN1uoKnoRJbxl +vmFA0sBak6qAIpYe2++eDfjC/MStCLWj0oWvTf5HumTv8xhO0cG0Z+SXN9y9r8onMHEM/hC+ +IWvOvANeWqVDSNHNQOPLDUAPMYDts02yq2+2ZWLQZMb0iJwEEAECAAYFAlbtOT8ACgkQUfqU +rW+MsLcAzwP/aMtWdZb49RGTn6JrAyIf9j6fH76URcAM6lGE/gXdh2UPn/imPJivXU6H/56Q +mkMDHqiFzx7BUnyMoev3aPlcl5pUs+V1kHpVBvfA6m75QZu3KJq9xMZSvU9Dcsejl4707xHB +foHTraoiX45UY4AW9wzl5G+RBJBMJ4iIqKl002GInAQQAQIABgUCVu05QQAKCRCumvmBmieq +6YzOBACEnNqMDL36eedbLEj99Fj0kMBs24sbjWJ77e/A4/TR/zaa+uC/UxS3cEY9H9CM3z7e +urLsfFSmerbamZXehTeSMuvHWIOyALsfTKh6YZrZo69hVnh3c0oLtCMj7giF0lEyhr3hIvV+ +QBlK44aEd7MVW06Xa0ONrcnX7cV6xC6dHoicBBABAgAGBQJW7TlDAAoJEOBNDm8f5jWSLoIE +AMu1fgjkVpCCQRF2sHAFf1bIrvKJPvANaADBiN3m4PPPxK8gZF7x27AAHbb8Sk2anIy9o4DK +HOjO8TmrSZ6vUAoE3kwPygYIJy0TuQpLwJmiAFJNxNbU9Npy7vA74HmLmwVptFOjba1m+xOl +c0CZvueDkggBEH3TFmXDQ3VAMy6jiJwEEAECAAYFAlbtOUUACgkQZT/y56mVOejw7QQAk42s +5a3xOP7wQyxakzM0z24wkKvcIqLO9H4TONRF2ZsNeYJ/VEBTwivcWi4qrJF1Tp3S1DLnqFIP +0PatXYxcDGSbBkNbzLgJef2BaYWlXbQIxQmFqshMOrmdPSrEiE1Gz1sKsDc6Wlfx9AKzx764 +DAPpK7O8biHW8ly3Dn6vrJuInAQQAQIABgUCVu05RwAKCRATiheR2yPJJoLdBADiwn7SDTfX +k5yZSt+OED0nnzm3/nQnoKuBBWl106KR4pOpb3AImyxE0cjniS/T9/dib5hd2XpYvBdh1XS/ +AFkAcq82aQ2i1Eg/LrWk0iGFErgLnsHAtHlS11397JpFtp84B8GK+xa4Tdewj87IKQ2Rch0/ +faiAWLe1Al5ZVvEjl4icBBABAgAGBQJW7TlJAAoJEGxGQ+RJVEKrk1QEAL9t32rLfg2GM30Q +fpGdUs5eWyIOmZSxzlbE6QUl2OWRI3WywoD9J9RJx6/Ycvea+O2ajYQaGg3WByH7KCgMDLJV +YkjweCHvmHlMKpWcu/dkE7Jybkk5LkaDJH35KY+2aclvezTfyqC1tcRGJhnWwHBG6BXnjHqc +/86a4iUAyg/aiJwEEAECAAYFAlbtOUsACgkQUXGEWMyNnbtd/AP/euc1jN++o6FepcM59rNW +VA4LppMJFVumMW/M7HQZECvP9Jj/iqECVBr6oTWWschHfcNwYUoN9ncs4oh5YEzHPkWH52P6 +SBODR2pib6opVCYpJgIf2VS6f4wgaIeSstEqmRzQAbkd5a/BebGnsMCaOJVqwteVvxFYTrsO +fKh67QeInAQQAQIABgUCVu05TAAKCRAtYZJFV6eokRJ6A/9teyPOn6vchzac8IMItz0iKVQI +4LsxQoFQUzwQ2vEs/BsxtRHv3iEYPxJYJgser2h8cnOtJmJ27Lr3W6q5bAQ4dKD4VY56Iavl +uhSYZAgau/o2O+9qKvBoRU5OpsiAMNdl77bSjplsbcnJ9oznJSovDKzI2jIR9ydrHgDQLRcv +rIicBBABAgAGBQJW7TlOAAoJEPlfbf/lN7f+n2oD/i0Scw6t8Wl/4TO0hD/QA4rF8xWsFnId +Z9tiELMLuLJdFw0BPI+8ukoRAfu3gNiobGmx1xt5jcE+pcTk3Ksv9xOj6q8u4wTlHI6mxjeo +IvLW1Bpm4HwpnYV04CuPtne8ATU0oWn3WZkuOGDaI5Tf57TEcbe0KR6RC6pUXVVEeA55iJwE +EAECAAYFAlbtOVAACgkQ8sbOFoQnMXBcEAP/RzGMgkCNyHpNUcJhe5LJBtMos1kcnXLhaN2F +8IR4Qi1pxn+og3sPVaYoXO+Zxz9xwY2g+iH3BmzAuly91os5nQsn9WbZEb4E4m+tggDHzM+K +4jtg4G8NPOaVv71GSTNtYiu93oAg47pu6U7Pqls3cMLsdHdDPDQfdd9RUAhIz8CInAQQAQIA +BgUCVu05UgAKCRDarijHtrI0tD5sA/sFodfaMrrQ9OZuBQRB/QVMkuvnQBalKvkpA8wPrjEV +cGw2Ki0zo3fmlhdad+yW5Z9EzluR2OBX3Ym45RUZeE8APONectvjQiHjH44uAtao6zVyA53w +nmYVczgrjBqffYWSCvaaLMnjWup5el1O5bNzbbaShrkSLJfYSN6UGaZdE4icBBABAgAGBQJW +7TlUAAoJEOvCaLBHGdejbwcD/iW7qTzHdpKMIqbJSmpes/UYQvk8kJ7cxAN7fGcIsynXHJHU +M+RhWsZDk3t5RqmWkAZ4qtPguAIbtK/8bJpo6/6VcJQp8zRyRiObuZHzE7iCUmFyhFj04n4C +BTz6s1a/47VYJ/dkTeGrLO40d2iGDsh3LANvSY7fzBQyyVoDYh/piJwEEAECAAYFAlbtOVYA +CgkQDDE/cpSTSBX2hAP+Jg3ZOT85VQNgaxKDdTxlrKpTSB2RrPv+Awsd42qDCPNYZ4vPGccf +sHgikRJbRLZKg455ht+kkpTw1hTBmgWtiesxXrEUpaAn1pJ9aBFcUGQzYT7IOM1uapyqQkpR +IoZlHKjrXCBuEMiWeNsk8DEbT73wY6A2llc7UnoNFDGkfYeInAQQAQIABgUCVu05WAAKCRCV +Fy9dNbU6Jvi7BAC22dJ5IGe7Q8VwNuYObnPbCX2cOdG7Y1G0o/S3haTTj+lH0uKTfaCjFETm +krnKJTesVcm/oUxSlmxOxv6nv5XYE36bE5wXvvK7EbAWHGFWEnD3eoM+c9CH7KFxpJgNKnb0 +b0hjuCS+yDEf1jwMs+9G8YUV6wE6fMuncA4M95AK5IicBBABAgAGBQJW7TlaAAoJEN6shw1b +kcVt34oD/RQvzPdRppVvjMyyfT1uu7PG6l0OkGhTwjypAKuNAC5h6rPD3dc7rvmULHq+7crR +8jw1aGBlrVCiA6q4hq6SzaSIl0VvN0J+pLRC+BT8n/pdS35heb8xrj02wx+E5QVm0cAR9qNT +he8z2LaCjmMnaCHD0Jr9zM65/N19cdTzx8KriJwEEAECAAYFAlbtOVwACgkQx0Hk3MtSvKIk +agP/UsuCy4XqZgqIqM7pYRvZ4Tc9ZSGz9qmwPk+N4UmRA2jqCTFyQEB3NSbqhNQOJ8OWieT8 +Lc1fyZyF1fBPPIfGi5Mr8NZ0RJq+eAjrc2/x1DAJcNplq0qVFWEU16WaR3fM9zJGClP08dcB +SAYoj/vUsG26jPazQt94BW0f+LcmiRGInAQQAQIABgUCVu05XgAKCRCmhgYmc4F7c7e4A/wK +MyTuj8a8droVY7VEhn4fyX1SMV6Z/vXI7jVVFNZqz+SDCCClNYBgF72gZZ1C4ngRPqa4+kWy ++zcLcuO0IL98IrkdLnaBalQxKYjEKvDV5LexoLrIfq/35tb8B5w6uzIbnxRhpcjiFZFh84el +Umfo1UmMTcZ9OuLPqsv9ifmYf4icBBABAgAGBQJW7TlgAAoJEOhL6YXiHpPzduEEAIH5u/28 +nohOCgeY4+qWFQa5Y5DONLkOrk26oISbSh57/RqNkL9UQrBQlIMK/T3bJk3YGh9Acb+LXm16 +01tjAxLwrD5Lq2+Bu260aGXSr+jAeohk48n7nufurhiCBAHhJSSuUBKdjJTgt9TPIkY4bHGt +O0QvAGqzCrhscxIB9qW6iJwEEAECAAYFAlbtOWIACgkQSJ34FFLCWiBuhgQAgUnSxNPCQ5uK +CF+6Ypv4ub6vtU9MuVh056Wo5rg6DrkyW1hlLCJ8W7fM0EY6exkvIIe/Dk8tp3vp8t0y4Xgb +p1qiOKDtZ6t0Pt6zv6vnhexPFXCSnTX1+vTNBx9SP5R5kU9oW5nlNXxFs8+kJf9Q8Xj/56D3 +DwaRecarJffCZb6InAQQAQIABgUCVu05ZAAKCRDshigG/pBuvJ+VA/0aeHr8kqxI9p5rkO/J +f/nVsFFZviTR8+H7xEmYalFnFS8mh2UCUxAfwyq/5XWI83RBCtsdE73NhZe7qo32fjjtgJHy +1bpikZHN6S8R1Lm2f/Hbd2Wy4xJgVVE2y3KSK3IeZTLXjTOMx3IsVWKsmwJO6p2r44OCiNxY +tbBTs8q5p4icBBABAgAGBQJW7TlmAAoJEHO++gxLfxA77QkD/0iGRggVqa9/mc/D4kSI/sAK +n74BruvhF5LrjOfiuImp/LS4CU24hkK1vkB5451lN1pFvEgh2nS73kBkYEyxQRwEqMkV2qPH +Aaz6J9Nb2p3YWv36bvZ7fpCozn9TP4d7Kq38efgMHbM0Eoikg5hSTOcqlvUUGJMm0f+1xmxB +usVKiJwEEAECAAYFAlbtOWgACgkQhCPPpSl711wgJwP/ZV5AZ5CF33MS9iffItcuW3OaXcdJ +PZNXkon453AwQaSKeod5H3ZAMAvDeJuqkwJWgdmzsVZUprps2hjkklwwbyijPTIXX1WDyEsY +qXgHj4jB9Hkl3xTH4+rtnKeBlB6p/npsWbjuv6bp9i0FCUwKjsK0hdkxrLNxN85mmG2WfJGI +nAQQAQIABgUCVu05agAKCRDbH6afawDeIycZA/4iJs24FutK5mlXAlKTrNZgYbT6NOxWQDaY +jOll/KYckwbzhOI7Lt6cSfUhNPDrGHcxzcsBSx8kSxum1adCoVHfKTb9RwmdygwcTtpikJjl +Pqx3AsMtp/bBTFWYCEgGvG345Ooub8ddr1adi2bYpVzndAe7HulZkN8yPxaNd8BvEoicBBAB +AgAGBQJW7TltAAoJEOFMZ7eg0kqwtmsD/jdtmB/A59LN7VHkxww8kND3rbCmtZLsX/HA10xd +p2YSrX5urPgECZnXZkwF65WGSRMYWqpBGAzsYRtmwBRY9xCUttqtFSV1QdfakuPZrr0i8w/U +kYtbAqGJ6XLfWfBM4yBpvAQBspx/dq1O64bcqj9Pny6mLIEg3Gvn7mkz+JTiiJwEEAECAAYF +AlbtOW8ACgkQlB3AGTjJ2A7Y9QP+PuPpRx2RHuIZyfEqs0gQy3y/ZhuRfOlMw0v4Oz20wwGe +uZyOquuNeCQ6YMUDSlTtlf+mZLw8WnyVGCQFxGyAfgx8ns6jAMHc2AUcSZSJGnEQmjyQlCFH +8ZyZkYOYdj6JdEzoz7ky9KGDGJpZMwjAlMUCQ0w2kjLipEP90UjpYgGInAQQAQIABgUCVu05 +cQAKCRADoltw5EK8/WT+A/9eUFl2ouaqkDWacZlVSGYCgPWP6baXSWysgIU2CiqQh2YCPb04 +oAt5Y0BwS7A2CoBvcw2YDvGI7c3YQFB8s+169DPs/Ar9Yi32EN5WVj52I4i+DCobH98NNoLW +aivhKf+tbJfyq0mzHH06ipim2DmbYZuP9wDNd/1QtTLuCn3wX4icBBABAgAGBQJW7TlzAAoJ +EBDo/O4d/MI0XOkD/jXODeh0XdnYPAhrM4/UYkODDiV2L2W6WFK+50d5NDhTgeHzOkT5T/s3 +2QbdAgefWWpt1PDFYsdCsK4HedH5Mn7hs75FJ7KwUwg5NwhONbn649E+2tZyGSAICU2lTNGT +0hflTv5rkjV2BxeeIcRW/wqOV7ONfyzF1TK5R+ldSrMZiJwEEAECAAYFAlbtOXUACgkQfqIh +I/Rp4zSNNQP/ePXL1WhraFaoagUKACWEzei7D8MZldwP+5U1093eGTZhbLBi3zzOQX0uGz+x +0sHhCwV7y49z7NuKSzp5UYL4IBljk12DXAKSnCtCo8LjANXYqyTTcuNTf/TULKtV0SNx6RzZ +YTJCNFf2LaVM1Fpx4UVm2c1Vcw5f1q/UQg5rz3yInAQQAQIABgUCVu05dwAKCRCI+9IYsI/k +stmLA/40KuErooVpEZTqM+geBIf+pGpKJo0TK1UFR13dwBwiL6Djnmkic1ogLj6g/dGIpTfH +JkGeF1GWlktD62QNJkmEe1XOJKgHTUF7baHssT6XJCS1mPpLvJJnLmWgBv/37J7osnYR9Xrf +0rYW5F1cDgPp7KcxYMEsI4fAS///IlMoP4icBBABAgAGBQJW7Tl5AAoJELu7RkO2cvuDyDMD +/ic/6mk2lDQCmSYikw0mFm3aGN75vuW6U7FUooS3jpAJ/02/wre0hsgR4sn7qetb8ycX/UDl +0C3/3xfRWzLMp9nOBfAH8e8Jm3cHoaNcYfN6b1nGpU3J612BwuhEstioyHqLy1ANU0EeBWvw +Gh1BAjqYGik1cndE6atUNFLCFn9XiJwEEAECAAYFAlbtOXsACgkQlRYMgNkDkHEVxAQAg5kc +aX63E855WQVA72kHD3EzV3ToZNwrMNL3p9ooaJ7Q5HGsKv2+8kZG88xyNReo6Y2Sx8KLivla +L4GtftyLxtJFxwtBghNwvYafDfheGMrMhZksOQrnQ9XJ+NuRZPObfRdFY78YHawkgOtq3Qrk +TtMDvE6zGe6q//Y1hanyS1+InAQQAQIABgUCVu05fQAKCRB5xr3X7xws2b+GA/9sQqXGaYH5 +BARWd6O2RR/AH5yPlitHIdNHU9k/QLI4ZbforjdZEzqjEXEZ9+ge6q5ysqKghWxZuMeTqICB +oBmmhidRd7PPJWDS5SyNZ9lCQ/ufyqAJKfKkV4+XUYM1ueQVyhZJ0/y2XrcOB6J5E8NKt0QM +Ca6Z+yBFZz8P+HEXwoicBBABAgAGBQJW7Tl/AAoJEK4k0rilOYenCHED/iJEUQldGprVcYEF +kR9uGldSecpjfWYYz1obdxvX5SnIqLlHOlO5hAabAB1N1c0EKWo/zn5wJRTQT6YSNTD9lSPR +cxqGZ/nyA5Isk2nltoAdw+D6MsunGVcxyyBGo5wzT/wjnEWMbxW4FC9rhe9mp93uArSd5LdM +fBSdiRVuv+CgiJwEEAECAAYFAlbtOYEACgkQLl3fsDhIwn5uXwQA347ltqgQl2SCtZKAuSoo +YAbdy6SBC485XrzPiafzJQeeQ5bgH6tci6COTtVifqqqe3DW/3vc9mV4SNgXczmkDYzz19LG +0/lQ8XbMUsEGGKyS4xZIvDcD66Rs6CMTItlKAC5ypMwMDii5thLe9lF3bPg3nIc57pQmCQYJ +4IuENbGInAQQAQIABgUCVu05gwAKCRDtJ7zrseoRXXOxA/0QMXf3iniYKgVoFgBhW2+CpH3Z +yExOTI1gXjiSvcYn4gDn+CUIZpUICGoGxEpnoqfUUd6FrzYGevyCJRd8PVenOZ6fc0XBMrSE +m7vetzTGM2U4HbAxw2uSVtx+9/1wqZP2ULqkCYqVZUy9YCleSLsPXR77oWZTDAcYI/wp42R7 +s4icBBABAgAGBQJW7TmFAAoJEGeXyhyJCj0vntwEAMLrIVdvEvYFNm0/umjnKd+9ygxFgfgM +B/TsoT36TxyL1W12Gm6mcSp9OI/7gOSFV5mPr0sgoyymGypLDp44I8oetElhPlWJbaUTdzCH +qRMWjJd1l6t6CKMT8O67YzwFODL0u9kLfSle2H1DGVP/IGD9WlSEolLQNhAxhJx9Z5axiJwE +EAECAAYFAlbtOYcACgkQ5WOKuaiKe4gX1gP+J2SBx33ia0f33ENjoCwwfINm2HsAgna4nQdq +CIHeInI7lne6HcmxF0rnqo/N1N6A4JRadVOPf4mWsfxFuKAkyySrwgboNyoVvXDdcnCJ6HYx +w7Thb5I7y3Nb4DZSnu+9pIs15Ej17vDSiAm1wkXMujUk7Ol74crq5/INRE2ZOH+InAQQAQIA +BgUCVu05iQAKCRB3IeHZcPS6QdqDBADDZPCXBsUUuxHqsOWyVMDLRtMyymmdtjsDzqzEjwWR +pNPZ7dYde+LiALHCkj6ZuQqwoO5rW5/sJX4cuJkMBLWuwDlqU8QFa7kebqWEBUmJFF3v0P/k +AiuSYn22hTWqYGhDqoE68M47n4qXz8Hqf9SYagQAXV2yK/z658KiL8gJa4icBBABAgAGBQJW +7TmLAAoJECV+TuAuepA2XS8D/AvUIGKLXT/nSsiu996h4TKLx3Dz1CeEE/Q/Yv/wLyIm9ZqR +ts/mcirJAw+0CeXvewIw3lsWlJYPFkZxAJLFjUnQB5ImsEypngUA7JkIMjzgOstX/G9GC4wx +0m51/xO+B8LGtRs62l/UWHd1h4mTTqNNTGN4FuvRxRyrdAQLVOZ2iJwEEAECAAYFAlbtOY4A +CgkQJWmW6rsLJf5RSAP+Ix3KSQnYOrjpCRfzgYNu97Ee08BdVzgO8XKlWAIYCs+KCXMoQTZB ++y7bC6t6AZ2RkdVeaQggsfqUYGLGNEmotenYHRNUDFVxpECwrGa6oOJ3aQXj1NuAkgjN//ek +6gQ44G1JznHj+eAzo/TZlyQlqkMbj3EeoVRAbFmi8vvIk1SInAQQAQIABgUCVu05kAAKCRCM +Nw8HdxgD4LQIA/0bYp2y1MmSEDn+S0hWpPp12cjywOlasfsqwicdCVSV2pneAxJk9nwISYBY ++vr7QRlyHBEryO9MMLzTNOliGtV5QLX11e2IZGV48u7BziovrAXerNCu9OPHn2w5/YZwf4MR +cfoNVNDGRdSczbBmyfHlOKTBQHaLtL16vudR8Omoz4icBBABAgAGBQJW7TmSAAoJEJQzD0lv +dJsthtwD/0UcOawQ9a8Tjz0M7xCxJ8AlB01t9PAV53fJR6y2Do+85+lOTEiKi/MeLaDLo2lq +yT3xVeNPSH1F/0kfdO4zXBEibI3oDdWvXrG/GGuis+UtLAv5pHvvqRBE/w2b7hefXZdZJB9p +im3ozYe2c+TkIOOWlTgBTT6Y5PhNoGgsjxp6iJwEEAECAAYFAlbtOZQACgkQIh56x2VCnYWb +wgQAhs9N9kELQ5GRAzFNNJfmilVfRY22ksbNZ9cexXefKQXBuXa+XiBov4JGj0RmlFLpwSc8 +SuHz2z+KO8sGv1V16XTvLCd21Xms6ZJfEPj+OkAD6eoxjSBi50SQBC/Kmqb3dYB9GxtYogOk +b9lBcuMWv4DljJbPfIkiwLKtI+jPcN2InAQQAQIABgUCVu05lgAKCRDBwH9vSTUqJpfuA/9s +rJhDzZKphtaSry6zhUh2l5sfrvlVbBC/P4INCv5f63ksI7ZfUCtXzsZ+/F+yNt4Gar4OIN0w +vcSmwmCsD5WqohUMh/PUAXmqKlUzpCA0vrzz7B2wOeI1/vl9dkRIIUddXfi9Xs+VDDq+0fUv +EjRVj4SRVrG0yospq9TW+kU5FoicBBABAgAGBQJW7TmYAAoJEKz6ZZYq5Hjf6p0EAJZpDNrc +fDQ6dtrplKdIogqSim+KSbR9tzxezm9ZBu9bOoJadbdnD0nF5TH2bClCJbMVhztK9vF1Hp1x +7DzA6eIWAm4Ghd63f6ztDbQhfxoOuiHAkrkFI87uAGRzGYAmbIo2JoPKpgUsXbJ9z8wEYsWc +AVNeMsobGd5zEFxgsFe0iJwEEAECAAYFAlbtOZoACgkQTCF/TpKOET5szAP/aATsdlOItaIO +GPAWJItlbqQ7BurLGMX8YKoEdtuRdsOGaFBcAkR7UCZ3szgTnzLRsYqn578K0pZ2f2U0Pblr +CCu9wNhG3sS1MXThCzT/WWaHtt+6Cs5Qb2/jrhlaO1OsJq79JvfYqR+5uz/Etw4K/SiT/vLI +9Cz3mFNjSlxb4puInAQQAQIABgUCVu05nAAKCRAneBSsG+/5NfZaA/9LO1ykMf68NIxyvjBZ +ps6xyC4148QihcOktuY4JgeCTQ+7ouHHEr7cWwDoz+9rAMo3lMY+OfHzcEWbfWUgJdnaAiNB +IqdkrAtT2u2C2Q6wOVDmVe9FwRyWXbTkoEfK3etzz1QKainuEU/OsQEMa+Rcg0xIqimU7Odn +6zX90PL42YicBBABAgAGBQJW7TmeAAoJEPvbP/s6n2/rQloD/1QMXhrPv2RKPSw8JWXBkQF7 +FBNol0r4Ve8RWYiYZ2ruPhe9EfO4SUKTlZM1t9vrLTP//uuWuJ8uLpJxjviyJqY7rHWw4IWW +2Ux7Tvbl4Tg5j2uP0FJDA15fnug/jDGqd4pZSMJiOjiAYvTOFUih5wF2lGMwzItpxEJMHBv+ +Jn42iJwEEAECAAYFAlbtOaAACgkQF7B93kkmZIzqKQP/S5WPlIgwwSxMqhvvjYsQo88/pvaj +74QawsLYrWSlf8Q8J0uJkQVigVuahlcakrZ8tRY4B5QzODHL2ibJfbP5w4kG3NLwSxgVpIye +lyReYHWrPVFW4LIJU7oHx9+x3b4K30pYL+cKXzuJkcoM0rrKSySLU05ooZcNcnagtuSxGfKI +nAQQAQIABgUCVu05ogAKCRCL3DoPfJHs7YCDBACT1+ytoO4Ks6992OrSQABixbZJ8BtrLRUO +KbuqUbV88FFUc2zMQwmgd3KTRF/OMar8JXvkxf2X/dVJZE2H7pXBTgtgPSrRbNscdjbrrIjq +5MrHjjc6QkSN6ypAuLDOA6EgEKHrAG/RaWrQkXyh3iQWVwZpFcmfn0srvFcH5oMmGoicBBAB +AgAGBQJW7TmkAAoJEJUs4P8sVCtLzxED/0PaGYvleGcC9DWGT5qomCyY1aD0J/sE1Q2m6MXH +qR7PsdnLZ8Wg2VN9Qk2tl/o1bUR2uuz2R8MknnZELwe6LL/e03ElRgxu0mcvWJYKUM+u6kPF +oiQrCEgPRy8mepOVi9Zvs0TbLrbajcPa8vuJQw/lxGk3TSrZ/Te82UNeFkFoiJwEEAECAAYF +AlbtOacACgkQv08hXYl/UUjzBgP/TSVyyxGZS/IeuLxBHvytZJ3hjeV52dBGSXNYc19Mw0QM +ujmgtu8jAt9/P9SnSqAmzNp092eU6/832UUBZ/wKcm8EmTXkk5f+si1MLeyPn0ZAq4EQE3jX +6qJHlXm7jyANyfwMzZBR6+cneNetQybod7qZWJl5fEeRDv0Cm8+kAueInAQQAQIABgUCVu05 +qQAKCRBTuTr0qNsmFmQ+A/9rDkssPRTCTr/tliSrkMzBe7NXBgf5lHs3q5Vx4n6CaMdS4igA +5azoDSl4zLsOc3qoYT9FEVconvloBYWyQGgVaKTg2br6iOsmtEgXiwSRyO0dIqW8zrZVtHlk +x9wuxoWITUuScMwxFQzzknMnoy/gO4KduFkcBnbF6ctpT/zHu4icBBABAgAGBQJW7TmrAAoJ +EOFPsc2lEy1PwR8EANRkzZhdN1ZQeKlvWy4bJ7Snc5KYhb8Du2reiPWvSQcjco+t/d6hFsQ8 +nB7DCmJ8wvjPQ6WAnlDyBIwZO1r8k9qFSmIAd8VllsnK9DUU1dgOah+7N1A30xQDU3DX+Czp +6gZ7pHhK9tLIJ6MmsEU1mg7ZrwKUc/L+Qrb3gUcCEf34iJwEEAECAAYFAlbtOa0ACgkQWj2X +OR52jFelHQP/fBU54jIAIYWLmeDNkHZnPtD0u801Rl+/8+RrsBIJi/V7ti0ijFr9miq0gK+O +7cym/suQ4iApgR2w56BZR4anSTKxKRCroXAw5g1IY6uJmo24zlNUpE65J9tW5sjuNWQgqKM7 +Q8Ket4TOu4zF54SMzFlwZBgzxPgv2J7n3HJyOLiInAQQAQIABgUCVu05sAAKCRBSER4tDo5j +j5RYBADciwaajhmj/5ukeWEsga8k7XjqWh5oFHqoQaJnHPxRq/j9KA3vbMHp5JU7B2jvWSR5 +KLJYtGV4OsK8IJxI62z8bbmn2a3X5Az8YdJ7VieYgJXIWLd43JJaWB8aO6ng9bRHe8m5sN6W +qz+NlUJW8gUe5fXjl9BjHxbKF/8ElVUQeoicBBABAgAGBQJW7TmyAAoJEEwM3zGb+b9yg68D +/jj2UKoogp24ZkiitY0BHH+UuR3wnfCBYnaNmTlz5WMX2xgS/TEgdeMJthteHHKu5lKfkO/Q +gLtIP0wFhSzBpqnfuX5M/g/A7LCE5QzFkvSHZ1zUYlURKIvqihi9rdaHXLOTJLhLIuoqhTIP +Iv+0PyfLk4/WSXZYVKTGje07JFsDiJwEEAECAAYFAlbtObQACgkQtBQFR1U02gp49AP8C7vZ +93Q2Zf3c2wkkKgIC0kfBJ5IWtW+WzOTKS5e1447z2jE1dj+7iU0m3Hx/IV1ZP2bRO/fQQIVV +qMNYO5fLJyVB8N6kfNqV6nNUcJllSD4VKLrqwIUsvueXzsmmDxkvH5tql/0Nlbo17ForqLr1 +8+DhFxYAtiA8FtzcQ1/DkkmInAQQAQIABgUCVu05tgAKCRDf6OAx7Fw993RdBACq+oxMdcBp +lQEvCbU7cCajA6ibEnFJtzICulrO+mDMr9lU7+zJY6M0SYxs6jV0cdlEL3lTCzHiySII3H80 +U0ojXPqvEqKnbgM1bcRKlirUIgjeF/6GfHuUrDCzo20S5XgHKM1HtZrBRPCNcRV9ukv7ENlE +S3UCU6fvX6NZMSIL/IicBBABAgAGBQJW7Tm4AAoJEDeAJOuujFPoMbYD/3vn9K8FkSmo5Org +3PUlQqC99lGKuXXJeM7liRSSlllSzmKkirpTyBMKTqUhKpPFExX/FlKAGRjhqPo+cPT3T4P2 +4+prZ9OO5laCm/DHIEWSBQm4S/Zn2U+vTPBn4Dun+aHCWveXQGL4yrgIfdXJQJhqA4hG4Agz +eTdx9Xy4RcSdiJwEEAECAAYFAlbtOboACgkQz3uQaX8QzXJKpgP/Y3fetUku4+KjaRHUZg1S +/QkFwtcGUPpVGe0VUKR2MD0sL3kTb7wtYka7SEm3W039qTkFXXsMy+3H9goNXMVrQ5N6t7vF +V9RmA3nDi0YccLxhleacOtQgx6sPaOiJlKRWHO8o0/IrC7VeCe+zbVhAGkI0CLgXIHE1vgKh +xRYOGn2InAQQAQIABgUCVu05vAAKCRCxeANHWDn6xCQZBADv14kOy/AvdNE8b5rQ16BUAbmf +1PN+fjObHDTIZoQ4Wsw4ZOEUplGEEtCcpdivGgYZmS3IBU+TVugARFDtfbTDBSbRa2LF+M5A +eI3mA8oNCKJ+zPxDeKcn0FFZRDd3gOZS9Md4agcOSviQbxYZN90+5zEbb+jvvZch+V17dm1K +ooicBBABAgAGBQJW7Tm+AAoJEGSDF2VeZXVK4f0D/j+QgNmNyOMHsSeTQPpZK/87bkCeyXN7 +1hnEL1FLk6KiF/0Qfc4tsV3CeLNTIl90ZibsEv5yzrWc7WinXfL82wU6h8/To2WFx2ZRldZU +AMt8fY2Z2nTjXuzvLPfULO50k+f21lunTv0re90241z2qav5eOilAw+BVag7Hvpw+2JjiJwE +EAECAAYFAlbtOcAACgkQX3YauAM8sJVitAP+K8grcvI+Q6oxGEAxcSKJZprIeBEQJCFfSO7r +jXzrOVQrbN7efhajPLRTdoxM4W7egkFkMMgUK2uajvcDfP5rN9OzvrXWTz6dyO2hpJNwpbCJ +S+cGKnUtQD2ZOZuVoLlP6vhBYEo1+Fxfc29HwPnv9VKL7rAHQpLT4oyMP3VovfKInAQQAQIA +BgUCVu05wgAKCRA4c7u/OdAxlWrsBADBOtTQzhND4fB8Or7AHZ9Avi7P9sgZfSEBL+UkvYaw +8mhIaubQzPSBm1B/gz5nJz3thjlrlWaQGLQgIY79Lt4gJ7hB71wSixBO8q9l4TgtkdSMQaIa +L928weMdUK+e+yjnJRN4g1iBqZ6WPcfTPRla2cAN/itO55nRsZ5cxW1thYicBBABAgAGBQJW +7TnEAAoJEHPip8mpd1KQ3KYEALF2FBMk/WxTepwfbeptjflO2fw/hv788InjNN8JpVjF/Rjt +jPOFsiIP6uDo0pu9gNxx4J9XQTI560fd3xWGS9ZStIRU2s+lq+Eh0xWKPBZvL4atbq6guN3T +87w5SZcK2zyNSGt/y8PfGUaRUjbK12rZC0XLuxS08hisswWaBjqTiJwEEAECAAYFAlbtOcYA +CgkQjTKvVizOvYbu2AP/UFlkEe6lW5WxA7L3CbTBjPhsDWg2+fVrhmNFqFoXFHn3a1r9LdMi +M/LiZIrtCz7DTrf7gjnjkCsc96/1lGzRsmh4sNTHRUYrp+KZHH0fKLUynv+aUxtqtPmImH7C +N+ahuxk5k5jT0tnNpB9iDA3GLDjC8mupswXaEV9rYQEcQsuInAQQAQIABgUCVu05yQAKCRD1 ++X5GPOgTaiooA/9XoiQ/vHlJCF5bDS1K5HTBUQ+5Qeb1Og4A7keXxdO/njPrNQOvCjzQx82o +2rDTbrVLCzelrJD5j6w6phW4+YNHumkMY+MrbequQU14//gTBWduweQevUE1KK81nniTeph6 +J+Vz6WCVoyQY2dQnMwQaw0JXIwmyDVBQcdVWdMs8SYicBBABAgAGBQJW7TnLAAoJENjgpV07 +baMMNQwD/0GZL04JzLWytwHJWpFnRj5teWPLvUsQk6VHuLAA5N83as+e7PGSrC5zTgkjiANE +xcX8R5pIiYkMb4d6h0Emgzjb0hBt/5mGMxpsW41M7hyMLwmIadjyVQNL+Ak8+gSZycksGgsY +JomBrsHBKdihBic0w6YsSrPPy5IwYsPUDzzGiJwEEAECAAYFAlbtOc0ACgkQuGeKvRqqX5UA +3gP7B1gqF43RdH4WAb0H/nfnKdpLZ+TqN5Hs3h4XmD2BQJbpwtUioeJJK3C7xtd1sHgq7iN+ +yE9qGf+5CBQxGVfgPwUm0jwTwpMaCuxIGBKPPZsVJHB8o68MVdGuRJiKdXjbSLJV4lwwW39X +LJ9rWMcFqNsVEy/ejmxSVVz8I8WUQLWInAQQAQIABgUCVu05zwAKCRDkpiieVggJ/9ueA/93 +9cXGFsWCoupL9O8kda/inCPmq0OZ2z8IG68y3Bq72UuPc9v6ox/E1PGNnlPmbhlhYBM5iEAt ++jN73qnLqo9w8JSxyOeoDEKtMpWg8jObS6+nhnk1WQL/PCKgtzR8qDT1trHOhR1iVthwkCwo +ws3jsbq1BIet3ikr0DJ2a68p3IicBBABAgAGBQJW7TnRAAoJEB2u6so73+AISEYEAKaJo4cL +mfleNW2arMQhyRZQcT+IbLB5PCaujNQDtOVdQLJe2cxQmPEADJm2B4ur3+IBsslSQe41/SBS +PIxHYAtJIpdy45F9Sg8mk6Wc/TMiNwe1Ugbnnu4U3ebIUmNm2/HYs2oBnR+lso2wKX9oRZgY +AAMtMaupUHFzgAmphpyPiJwEEAECAAYFAlbtOdMACgkQqdEZMetZMVrmkAP/ZRwO77v8Eubk +IepE6ua+XMXtqcw9C+Gm7aFs3JJchmwKuBmddHuP3mdEO44BfdYpXMbWKh1QFE+NRiRQazs3 +dRW+k8hpzcCQW2/ocE4kretWmIKzU8J8017/9bE9rgbr1A67q+g6zOMaYs68tcrfn8R86IWA +eMeGDCto1ESlyL6InAQQAQIABgUCVu051QAKCRAoNHPoBV/HdCV7BAC6ohOUb9mRvIf0K6NG +aj2F9cNmnzHVq5Z5g8Al3gx0e8yWpwBc0sFV2pfLHssB+a5tROMPsOKuqXqRM4rJeE3jAnDs +Kbkzqn2VaKZZdVeC1ez1lg/jADmNos9tr6VaNYRcZTDqDBvq7ALjCugitdVllGEIyj7wXzeQ +kdeYHQ+i4IicBBABAgAGBQJW7TnXAAoJEN0xTRMBJ1Z93k4EAJdh2zquAyCicsduUrogK7EW +OGtWgXS3t3sqRAzrLPkOS7LLt3/FGE/cdbpn3LKXNJnlzL8T5C5ZYf0+RoD+Q+qIXllTGA4W +kEHyh5Alea42HeozKHFYWjjxTSNxqK6VlNMnzovh3vkZTOcPL1R98a/vFZr+RrMJzcunraxo +XYpIiJwEEAECAAYFAlbtOdkACgkQSI2JAIlImd75owQA0YBrrT9K8FL2oU9/pLdNTW1Cd4OP +iDZCvXL96ptaBrBxbVkxeLkDd7M/imU2wnWrn3Xu9DKfjQ4wHmNs3bumBY87Vs75nn3SAgtA +obN1YTZLumktGPmiLG1Ow8hWIUtNRCB3O6u8hrFXVAtQWA38auArHwvkF+ReCivBRcxyOGqI +nAQQAQIABgUCVu053AAKCRCJpq/+QCiPyuPSBAC7LGQ/sAyeTuTumEpq2SKuLFKLoZVfAQj9 +4HIQYX3RSx3u73HYR2swoHKNmKAV7MISanU+HzwkpGFAqu1baXpSp2BpQSxchNmopQVmH3SL +WUMhmQCDPz/DO70mD/zNGm7Oe242i2bzrRQaAB1TFLfmYmCyG9AByyLeERUAecel8IicBBAB +AgAGBQJW7TneAAoJEPIsbW1sTpzSeWoD/1wUGf7TSnjtUxZcBndSbQRFDv8VfECGJDw+Xunb +yCTbCFLFn94IXNGx5oMf1oKAmn4Gksn0tVzUBA1k8EL03dR8y6w0Awbx9K/Nkz6B9cnIaKPG +cF+GQoTalM5YK7CkcMUAcD/jXMhs+K/t7x0lOEEylzvUEvxxFi8fNpmG/KXOiJwEEAECAAYF +AlbtOeAACgkQd3EYq6IdVKokKAP/ajQ66eOrPqt4vJU50pVSFeUTlCJkXctINRQqwIoHfyYv +xlKpx8WbN/CTfm+xbGZ8sOqs5dIreeS07nXmaSI65k+kWtFc3G5iSSYWeIOJvELbB9EOcYhl +LFcQAoQd5lB7UNq5zi+JZ8MhQL+gksnAOP5GKW0/ynR1ck4LMgOjIK6InAQQAQIABgUCVu05 +4gAKCRDbYa9Wl4zaStLzBACGJIxGqn/dpC6XtTALywIqUV0xDdJdlCdwO/sbqCtNgHgtrUqv +8PGr0MwzdudfJAPKKbddNoeF7TzrzDToLQruigwTiB0ORJ0FEmYa8jWX+LaqzRT3IYM1deQN +VARv/+gusShLay08hXbQ+3psZCv/0ck8vS7sbdOpJNS2ngkLsoicBBABAgAGBQJW7TnkAAoJ +EOuQj8+mhV+lpRQD/21j/fDtXhmucSPZKZD3mvDuA5fMcX4WrsIScRkUXEZPeCPKoRBXGuiK +DHzT1OEGvP/l+huC7T7+/1xpgYHhxTIe/aLtTeirNuWiA7h/+I+bA/6WSt+dJ1CLTykwwGr/ +dAyHjJYK/3G9/BSFbfdofRvmuh1zv0WBZMBHQdFTnXxDiJwEEAECAAYFAlbtOeYACgkQea6R +CSaUkyED1gP/XHiXLJudQsPiL6K0XwVDayV0VaZLQheG1NInGBZVFUPQB43jME+VQbaiZbOP +dJt3MGdBiNoxGCGQRT9uNZuOg7gYDTesPqJHmljAEXDpBbHWcAPgbO8M16c7DABMS3WrsbWe +5FBeFg6wj+pjIT+nbOYdKTLXfpd/ENI4A/Bi5hGInAQQAQIABgUCVu056AAKCRCk+lU9p6jS +g4IUA/9RPvOG4IvvnmiskYd9S2wGoUEnKTzenKuauX6mygqerTIPVOHkJfQZyrhYOBWSD6hQ +rQy0XfsHUSflux1q2f3yVDZur+wBpkulheAuQrghjqbcMUo+21Kl4IAaMisqip2dV0aYH+1A +Bt7ELP+e1gtVIAYkicGR/+UGN2JincWYJoicBBABAgAGBQJW7TnqAAoJEGv6CUnqe3Nmbi0D +/3tLGdrmLlo5yXo49IDLCD43GeB4ZyoXghndW834u74PibTMoKxQm7b3+31aj/wQ01Wmk7Nh +WTIlgLbzbSirtLkK+k8tHJArfjOx6OiL5wHBMMBKJdd9hJDIXXdQtfizVavZsuHTJ5qO6CMf +2LQ9U883VWmwJ9ruyCAmMGra8X7yiJwEEAECAAYFAlbtOewACgkQteyorYxEyjUh8wP/RN0p +bxxp044uq/NUUXH+XWLNEkSSVTKFPEAs/ZJLNifgzgUPBWRi3yMOtNKEJWBUgurQh7h09IZ5 +d9u/xRHfktU81ejfdiy3H9iggzEYVMr2I4VakRp+CP7bggAOUDq/Jydqdy35UqhKad9G6Fm1 +FH9MfVXUv3dZjjjSG41EfheInAQQAQIABgUCVu057gAKCRDA2JjcqBn9Ss4AA/9767bte3/b +nwtfizMlk593wgAuYea4JZxS3YjRCPbYObAv34Y5cojUVXnnENpQgw6Q4xH+LsmLNty9mkfO +89xLofiGF4S+lE+GtJzu9FGdf0x1JXIFTbUvmTkX6XLaJSRxnERdOidvmmEA15o0QlYs09iO +5AYWG8ajYf6H10aqAoicBBABAgAGBQJW7TnxAAoJEK0tMtA6L1rHyp0D/0UlUy1w338Xvy8L +chgOE6GddGdZsB/764uFJBkcgbBPBxnTE1cJsYsVTNBL61XnagMZmHrXctQZqN8vLzDn2CDU +hv7PQmwz/BLOzv5qL9DQLYG5uQZ7srt7TT7SqD2MSwyFcmUJ7wmadtPZv1ZXdbYxK+oOJ8cF +cXu8SLtJ2bXNiJwEEAECAAYFAlbtOfMACgkQFjD/7KP/Vi+ETAP+MfGvd8NTOnudTLYzhI6F +jdcMaiv+ntECuGwtLKX17hpO5XTvxGW4mdfX6VTF0c7SrAPa8rO9ZsqG5PK/PuUdMODuR91c +ixfHe6Ub6pCId64uSBM5LuytdV1zaT4tcxA+qz3NcD/1UOHeFTckqd3XXFlWNc/61OOXzsC4 +kfeMbGSInAQQAQIABgUCVu059QAKCRCuUSQM7rvK7sRCBACOGG7hPuCnS9F5ZiTGwSE+oj/D +fvtNCMXXq80Il5OmszxT2coLAlhl76BAAOruauqAB261eZybrW2i1QdDCEmJDqo7lfEasbqd +yOhGM+z/46EqEWc3pMWbo6OWM1Ry62PdHBW0y6lxUvk/+p1BBNDRw97qkT6E42JWrZENElTm +OYicBBABAgAGBQJW7Tn3AAoJEFhZ+iWYslJQ7fsD/A7J1Uyg1PHO2sWD4r2SxOoICPZoA1Xp +NOpb5+MjJtmryqlSoxfVV9f1rsrbh7OLVtTdza0r7GubcsioPjHVDmUiShNmacIuyuq3UstQ +mhn2o6p89wePnYAkH8P3jQcb1cjtFT4lnwHYN9E60nNxaBBeOZA4OXs3XdcaAXE+NKB5iJwE +EAECAAYFAlbtOfkACgkQTj6laYdGcYRfAgP8Cl/e5eenrucRBvE9tEIhZ6V6ONnoYhxQ0GoP +AsHqIjcjQKnyy9s+ZYdqrOhPO7V+LAW3+8ZeB7TeGf8MM+ZBPjlX79OtxwY9LoKbTIG6VBQz +30TJCZK5rNWf6B938mIp6EYWAClhyXF5ICppCd5aB2fikJ99wtGo542wvElaIUaInAQQAQIA +BgUCVu05/AAKCRDcIA8JW7jP5Q4tBACQmhGx5gzAyYXHzteVU11/rLSP/0viQQK5RJ/u/1iD +HEWS1zfDaPKFlqUEe75U83pP58Af3Yx3LPe3hbRCi/DpkNhvjiraeaW8g1B2aicmUBe5t4x7 +6M57kP9/GseG8OOiKif0rRY3GVR2odhsV66pIjyeAWBnlIjSuOJkdOwHRIicBBABAgAGBQJW +7Tn+AAoJEKfzLzsDOtA9u74D/3QZNhPRyD+Te4ykeDxd5dVUeDoqa48X2Tqb54IIxWzGmzo6 +FOeAyz2EfRCTk6lEyyvkdhuAFMWFon9Scr3Wf4qeWrrT+3RCKUYJL2/uoIB158mF/U81sCIO +Is0GvrYTXovRWk7LJyFzAGHHZE/oW/qNs7Pk7TFBoiXozvRzZyrqiJwEEAECAAYFAlbtOgAA +CgkQeL77IXzCpN9fyQQAxYaQDQM2KtbLM3HQnzc/sLv2+7Mc4DnWQpoba9pg3V3NtWdcD/7N +DdHWuPMSCPSWrxekWEnkOwS3Fn82fYui1nU2CfbkfK5hWiLbOoIavGWunlfyxG1jafkbonmj +Z6fn6H/F2uZCzwXKE6XqCZAtw/NSgOPPjdFVQbSuDTpE5P6InAQQAQIABgUCVu06AgAKCRDN +cflMSS75XtW3A/992JO+E9j6gJ9X9h8emOGIiQof0slCS/k/E51bsbOUSvmSEMx/U2vBc4pj +DR0Cm1jV44upjXc36EnDayq0ULa27JdnIeLb37T2xh7eWlVz2Yjz4lOfwdww4+ZcD8xO7Pjj +iA9eNE5eZs4jY4QHxJXHcCgvD8HiWNmQshDCJzuN34icBBABAgAGBQJW7ToFAAoJEPJUwFgf +ojx9ougEALDNdT1y/uUcG3GRWrdKC/g89374B6a2uxa6xDKlrNbyfYlFmxJrr/pfWkEQaFFl +tJMlmN6FW+x9Pytg/eyxrhK9/bMsrxnt7Xn0wZUGeXESdofjyBjWSsba/YoPNFruAG1LcERT +61SEoR4XXesnbghOaGRdoUJ82D5CP+NSPSiniJwEEAECAAYFAlbtOgcACgkQTE7obTD2pB5d +ggP/fKagb1Cx8xEPdceuVKusoRGdaP02/eU5PWso0b+/j0auPpjYUX+DREBF+pZP/ejOMcjs +uxyoENuwUgJ2pCRfgYOm6zf5cksfrae6eUS5Z4xh1lSLY6EgtwhhQXWXZ2+93PTLb0/DwLss +9odM8mggWr1xnzhT/6QXnCr9weuk3k2InAQQAQIABgUCVu06CQAKCRA8k1vS45wfIYipBACb +gdPXxaG3AqhHsCBhdAMdxA0KvsQWVyd1uhhzrW5RBvdQn5poM5jqytJtT5pv2kATF+faWGL+ +0GH960q2zQD9gKkcUD6NkXVGP2NMDB9Y7qa0Iz4PuPki/PGFfXuLZ/DqEmEf2O0mwmzzW5mj +5oCWzrBKNGnkYtTpSVvNWlfFQYicBBABAgAGBQJW7ToLAAoJEMYkhj+wEUvxV2sEAJGUm5Ik +PWMMjN7gc8GGaia6LuS1zvnaiD41egWycw3r1bSVzkLFz2CCHAGWalQmvEOTktlcxwqHYmEI +UlZHjhPp+6uDeTvQNL8RGqXFw0+nz0AI5PS8gq3t41HMdY60naZLjVQO0yaVATl7khtQItuo +HTbCJJUzJY2/t+BXKJAEiJwEEAECAAYFAlbtOg0ACgkQL/AJopB/fQRVYAQAochfYjms26XQ +IA9qGM/M27If7MOfELMGuhK1pUTJqWNca2LkRBhAqX3eMueMet1N1QvrU5JeouBb/x1WnZo9 +5E0QfX2dSsDHCuAjEZL2DSST0CYIzKs7fALJcpUEWbodG2FyljBx6ZxvDaZvRXD1f/FzTCXs +rgfXTejEdBj0twmInAQQAQIABgUCVu06DwAKCRADJbD9e2pm9jqFA/9kcMstSYSrjE8jbepu +YeV/pY6TSQPv/+h5ne8I+DJAF7cS9QluaEuNQH9RqStrLuRtv52+M6GslRzVbwel/srK1SMp +L6AnDsf241JPx/tCEGA1yIED5A9ho6i2YLMo5g+3QcjGYvvva8LKZpT1QK0r7k7CzGTtbKpu +iCSjinIJKIicBBABAgAGBQJW7ToRAAoJEB3SeZLfKxlBcN8D/ivkH52QQw6n/e7gMAUdkvf6 +PCnIId/GI6tkNLlX/RUau4x7XQoXV820yyO56P3AKgKUUPKYytutCVsLPqrldLyv+hcToPjw +dn556KW/dzUx480UYv3DkgyhlQQvgbnKhTU23Un3b1/b0tEHFQiJmv7LvzpmiTi3JmtP7V7U +uVNTiJwEEAECAAYFAlbtOhQACgkQjmRO5bxQabjp1AP/fOR5skGHfPk6wqRtFPL48R7iCtHZ +V0K9m5P8r2xARLniE7TgWjAlur6whQzl9G5rxQcUQplQmL6vuOIJk77Pyn4ugCYvzGilHzpS +amJi2e0qtHvekplNdM28ylzx/khleXQySapIIG1oNo2WDcc88vSHMTgVLI4ylPApZ3KxlA+I +nAQQAQIABgUCVu06FgAKCRDZ8HDsbnBnzVUkA/9wMM2VQIZa6gPRBFAVUMN48EjXF2iDgkK2 +EeAu3Ti52loVt4jMdmY9yeIkQx/9fCEQWEK5XrnKVhNACvqFeA1NYEMhsIWXNCzYi2GWQJZC +gir4sXqw4+9BDx+DPBCxEsNHH4q7IvHrmztQpuLVpbYC81OIWcg5wvAN/Rl8E5NVOYicBBAB +AgAGBQJW7ToYAAoJELr2xrvrfyuItcsD/2MO8z6bsO5nFo8qGPFd32qrhrCJzNF7XJ6uN587 +2PIg8wt9TxH4toxTAk75Q4CO8XQdnlbk/rhVpQH1qGg6jfLi9pVpx2/o98R/gBfab0M7FLlr +vdkuEuxhMRUVlAco0Q7vHLhGORAiUgkvZEP137HrXeiJIfPWZLMhO2S+MUgdiJwEEAECAAYF +AlbtOhsACgkQlN22LC6IiHhUiAQAhVgaE+hvpxrm/UT0rCQzH0KQfysLUbiycF6TBS2XH22M ++Nleg6PuMNdLZQ5pe+0oBTcIKaLxTNF0KEW4QHhDu5rbpNYWYAUsXStZuWbsnsEhf2SXRluJ +mO7ISGylom615/G/JBpCc7/8nC0RfeJ2d4lXVk39/ovwMHSamHy78gGInAQQAQIABgUCVu06 +HQAKCRA9vOXt/lFMA1O1A/9vq2X4+ZuuyPgpvu34yfdrbida+3bL1rTaM4IK2mrxeYGKK/zk +H0IedhOAidjDMUj8uojAuFi2IU4aaKsAVTtmyWukp9uSSVaL4Ccji3O1wWk15cDsbPA5vwya +cokLcBkoTo2ZXW6ZJtkDOM5tXJa1X6C/WicvHhW4unmeh4yqOoicBBABAgAGBQJW7TogAAoJ +EFRGp5VUgN/o8vAD/jqVIlOiZ7hUQAoBFX4wYFEkuUu2E9Mk6eg48tKP2a7KljuyZjpwvfPd +n0muw5CxaO/9gF6CAvTb1XG+t+wh9NNhawjBy4UMIKxFX0f4MFNMXO/TJSa24bzRep0MD4o5 +Adzg05aEb1Myui0VCxCFDlW+FZTIPVyn6JljHpYNFJF0iJwEEAECAAYFAlbtOiMACgkQE2R2 +YRcvNKupmQP/VIMmDsd4Cvf48KD4curX4sNm8wlifWzd8xxypDCu9gAFk2qvqTswmz+WA5MX +hsWaUHI1i1/5dHn9xcalrf78IRyx/LGKN3/NAVOztuzMll/VqKpkUz14ABD0FlOIcv4GybM9 +EgsU4wOkibx5M8bq4JMjnpI95Ih1xJs2JlSpMh6InAQQAQIABgUCVu06KAAKCRAJhPqmnee9 +uUgVA/0TN4Lb5XlEz/4xPUI7s4zc1Ka/g9fS1DCnuFf6feK3HWiM59CMVh8RF2Pu+rwsNr4N +XCpVuFfMippoK0RnySjiSTXJ/NOZGd7MPSDa8d4o606/wZCU0HhNG5bBj5lXpqRN/EiqivrK +KqVmYQ5ApsN0KxagYDeCZGM0JunzC6iz1IicBBABAgAGBQJW7TosAAoJEEcuKrAxOOencdsE +ALEq8+A0rJQ+zx+8YpN5LBpV3rc1IS6EdjokkOOJHwrjZOMN5E+0E1O+45A+fPb/d4gIjb3l +/j4KObWnTaxrs+FDXlyc6xx/iR4RF99eICxYqLpjw03SqBKfyQ0R1wRFmQbeG1Wx6PCFJVP5 +zhjGULpqOcg8aVpuiyBC5gpyjIUKiJwEEAECAAYFAlbtOi8ACgkQvjDTxL0eplYOcwP/R5uY +hUSqF+YlERf4PQnaS2Zw4UF8+nGwo8mJ7KGSwImZdzHHoogKfoDQ/oN/d47JaJMb7TGMrJF4 +iKQFnhpUNAEdDcxBOlKyCgZ3i6v4BaFsHO2fhmKDEaIRZWhsZPOXX4gPjJc2HzDgGwYfG7XM +p8jN0E9rdLetryOm6O5CQy2InAQQAQIABgUCVu06MQAKCRCQ14v/WfDpNmoOBACB8NHw8sYA +xL86QtvMH3f73HUShg1GiU6Upt92rJqgKwaVO/9zw6npScaJ0GSz+LJFzbX9OsO8X9uFi8ec +5xgY1aj7xkzhNA1aOykK0teU1p+QnXoRnRebRXnmJ4B9kRk4TJXc5fLdgwZRCpRL7yn6FDOq +saB6lSgiwAM+If1rQ4icBBABAgAGBQJW7TozAAoJEALrLzCsuhu704MD/1NxAIiBgWHeQepx +4CpZx8+mX/zRvFIMWVhOD/KKD2aStZ9lVuC/g0c59Zg9QGnqh73c0gvOrcEp+DiDf0uYC4Qo +RwtHQqIX0EsS/oMD18IxYtjWXjIyUZEIn94dcAWfXNf/Yyw/5janTm+QTQA/X9ewLpKfL0o8 +JTWbaUcisStEiJwEEAECAAYFAlbtOjYACgkQRgH0Ug0n4bDuBAQAwKbAX5IfWBuH8ph+j9YN +cE2KJoD+xgk2mJojs2EllShel7gXyPjpbGKhxucaYdcNgJTzBG2hbPo+x/OOYQ4DQb5hKbVE +RP3QsZ7ePDbsVpY+YxoHX9WhZtbZde2gw6NvVzkTON7EyBJv50deeUPGZyR0fb4q7QCC72gw +wQZwBH+InAQQAQIABgUCVu06OQAKCRDc7ONDPqT7KUuDA/0YupwbH7g7hZC4OPkLXWZ6brq/ +3PGijk9QzWSR1Stg0uBz4HSJCbrOyWlKXaKhr8XFzlfmtw1GVEUy329kgdT6AbRBhmJn5DQU +HFUzZvF+HJkBPXshyxSe2TaKDYBPLrs+k0xC6kXv/yur7JgI5Hjs18kbQ9OojZl8SBMppcd6 +UIicBBABAgAGBQJW7To9AAoJEN62ZJq5kSgEf+gD/2gn5gHx/FrPh/XZDcOnMLKP+ZOsLx3f +/GTL9IRtsgeGi5cA5WjlRVgGkzIZlcwrLZ4W9jAUl0G1ioYIvlMGDK3QkOXUNC1AnklwRPHi +Nmwrr0wZH02qG8er4p4Oj2+L372DCEhxiZzg2j6rd9NayVbwYF0mLKYa9seZaNKXQgxyiJwE +EAECAAYFAlbtOj8ACgkQ7FG1C5vrJPXX0QQAkqkUgZNrPIzj8QOJLqcBZB2xNxKfKrLfEYWA +lw5mgFvKZokVJQWpLkCxE5AdIl/trRU9+sv4X7NMLLOiDl3rJUoQePoUvlwVnkPiCGxszo9j +TqgQv9IW4koeNoVih6eAF7zm0tBRKnVm9X/+R8nUofLSo17+zm85TJLK5UY2OiaInAQQAQIA +BgUCVu06RAAKCRDygo1mWM5hemMVA/4p2Nnw0AMkxp2hlwAVAHhgHd9+34cKAV7omQIMvaKa +O5harPMbc0tUse2ToUSZQIYUs349drKXLFthqX7ZxukpNk0PwOKvoifZ6lVlCai4gep1pq9u +b4zZk43MhbHiWSi7IeABe4pcp8EAF5kcMAcY4ceYSUyUMyIU+inwcJwn7oicBBABAgAGBQJW +7TpHAAoJELbRJqDJXJaZvwwD/3XsFk+HQCGDBnnIkXB6mUgPmC1+OIiPom3Yk1JQm3DlQMnC +pYJKwmi6Fw0NavS91+fp/Oz8cHy++R1OPWn2P59RqjU4+TQ6D9HN7jXleAdH3hoWUz+XtG5L +Jf6VUC8ixsR8Me44W49kiFNf4/BusLr2TfWjP/DM3JJ3vlRZIV3fiJwEEAECAAYFAlbtOkkA +CgkQStCxqzyitTh77AQAqZQuAgUdlURCLyMSjKmJkfnW/0UbDwk5j182gTFXEARZTDT7ywID +NIjTnDSQwLBLvw+guBXL+XmAr9niuNDzWbWosmHTu8ufwowv2vwr0LfXU8gLvqMy1HkU7Q2a +9z+q9DlnKcCxjbeZqG72rcfBCZ12lgFfuiKIH9mu0dCr0TGInAQQAQIABgUCVu06SwAKCRBr +LBHdHrtGt1NpA/0WNR8//lFBZHZkLElF1ZHfL6EdXcuuqWBYiF/ZDHW/S2MNaFs5ovVjqZXO +Ohnkr4Fg3AnrkCIRmqb7bgIsgZkIx5HdB2y1gDSTdoUUk7WZ9RpacOD8gny5RSgpFh/2JjTF +PSr3oU24vLRlyAka4PaJLp5MH25IyCn96WjLywrtc4icBBABAgAGBQJW7TpPAAoJEJswJIIv +g2eRyDoD/1iqqofyO5QLBq2GlX9OyypeL8sXW8O3ij/dSDWezLtWt9iNKLB8UGvq9m+nIR+4 +q1+20V4FerI87eWTE7igFXTDR49AVLsg5AGB9RB3/2zWszGi+0hPAsEsKPDFXk5ljpV8cDK3 +jxHKsR6anqWr8GGlR3AxfXkevie8ira22t6viJwEEAECAAYFAlbtOlEACgkQCJksnO8Querq +nwP+O+mEkGW4U6D3OtgBU18A2UI7IEkaZOfcMXzGvr6kZ9oD1KvLwkhx3sXcyla6cquslPYM +9+RI9MPzWiiiyOwskz10BqfP7DT6d0kzAijAU33af2EI0uO3f6BAlWr9nUCZn2mqZGDeUx52 +h/A6vQG2VvUeo73/y6kMtsqaqy1x2/6InAQQAQIABgUCVu06UwAKCRBDAFgefjlZeBnSA/wI +ljAtKjAmWHALvuOpul0E0qxbsgyToaAMx7fPGUMUcJ8AHadKqVipO9r+LADFG5Gz6Sl7K0zn +8HKXoA+nAIxlsk3frQVoUQcViijvC80+G7dbYzZ3TG72RpJJPxC8EbjNmc5IddUF+RKylKLA +UgGQEzlCX5AYLxl6sBr4LI1dA4icBBABAgAGBQJW7TpWAAoJEJtvHcGXL4u2AMwD/0W2u6kq +ZqaCkIFybP03dt36SWbXn+LxcVbW1kGngltxwFSRz7l+mvpk4H8/NS76a2yrqxF8EuZbLBIV +Y+xPWjxIpJu5bet2SToe2TPYUo2k91JcuQJtXiIwQpvW+JQU5I4kZVCQOSbwvgYqWgxhS9Kl +85hhYnesYVrlD1ltbBg8iJwEEAECAAYFAlbtOlgACgkQvQdm/jzqurDFvwP+MQXkcEvCouIf +/fniOTejFdtZrxTvvDdBkwKwowOBVD9GtnSybqQSSxse8HU1L/l3FS0+UgEtJWvIWetZzDBA +r3dxp66+FIjpU3jWdFrjtaF/gPMNrx7wbqwSdlSZFTdqMxpjFCnJNbgdPpkVE/7lgLczwXO/ +IMFLlUvs5dPpol2InAQQAQIABgUCVu06WgAKCRC/kJ9D9+xOWDo7A/0TAJfEo7d+2OJnQcLb +HO6xpEHyzR/9sAum1Au++mcBAJiPbpvgJSz30uZ3YMDXKWTodh/XiEGVmeNZ7szgy7LRaTMf +lR1XsyyhtNQoQNHhppqW3kDvDDY2Bcp6YY8/NVcz95XN+D3P54AEgiB+HMdjRpFVQuZBBfOa +8wdeehdRkoicBBABAgAGBQJW7TpdAAoJEEv2f6/rdW8fOmoD/i7Aud+XMRjWfYfXl/r3bH/K +tvVuYzMPhvcG+yBKKDQv26x+JLaKuOuH0h4PYozdRYM2Mx8e4nwa4U0Y7cb+rZZ9cgxAJQqA +GWzEoDvmvtS8F14lNByC2g+A33GRCo55cJ5QoSnkq1HlkxEEGHxWj2pJwnD/oB8uvhZZxNLL +MQbQiJwEEAECAAYFAlbtOl8ACgkQahHcetp/UFTUMQQAo7CkslD25V9HMpaEUJbm82c/bhu/ +f/OqZIF5UpjNTHyHImzhdsRWZOl2Xg1oDpb9paHjpxOH33ot4/QcRQ+2DdfUNHcwDwNjyvs9 +2cIgNt43dPqTqlZ4/+zdVnrXMFIBrExDEYDaKzrkUdJNT5+JCYXtaAdbUl6GHnVP1SXsdq+I +nAQQAQIABgUCVu06YgAKCRCuyeShnW9hRG6sBACRwTJQFr7yzEADEUuBuFq0p0ZO3jrTRyDY +gNJolbhxsoMLSQ0MQDtNO61g1vt86t5stLpzF18KgJlHIUv7oH5/7OM0fiGaMOiS5tfMINVV +tHbqWwbMsgsMn5EsDXF3PayUo3jLJc5Kj2T2GFYe4oZnEONRzJVrlgg8J1agUBDEJYicBBAB +AgAGBQJW7TpkAAoJELyDTyR7/1SmGykD/R/NnaB5TjMJvGuFABzSCM0TapZHychKFixfCcYu +rIMk2MgE88/kCJ4CwNV/a7EU9xo4187pHp1z6nZ3qhKhDNuz6GG9kp9El/sAEy8WRQO9GfIu ++kjLJF+EJJAu6juJwz+uJcfX70KYX6piCcJ1+Lzz5Dz/e63wCqYIDgSLP16HiJwEEAECAAYF +AlbtOmcACgkQ8UK8d5+QdydzxAP/X70RcKo9shXbZByVq0+kmiAfqUmKNNuTruzDLyL8b2So +uOGqSewhWmPgRnuZrsWr3A+Rud9k8yCuSJ2/agPtUN76HMBbnDa3qi30oM0omycJ/A4/KTKz +SYSm+vy7HlQVzw5PaTv8XEZqr2paUGV/FiWsZt7mEkI3AEfCf6QtNMmInAQQAQIABgUCVu06 +aQAKCRDI7tu0EBYQFKPTBACc0BbZyPqggqSNNQs9Iourq1FsPCJyeVMl6jVpUxzddtVJJPQK +SW+aeShEDObyYd8oV0o24L56faFyboJIuxDr4/WSyS1LlV+VRQU68nIO7NRqpGfwgJT1BldP +V/rvvqkC1LjkweTG1IPe+XBSARcHpgvs56C5cCUGpsSSME4IRYicBBABAgAGBQJW7TprAAoJ +EJEo5kA92s1mJK0D/Rm1+Bpxp/dDeoGOGsIBqrKZWt9uTiaRADmluShTRWDPmRcgJgt5N058 +h6xAFKlBQ1mz8jgPWYy4FftTRXTDZFbLQoveiP+ljAhNmWVk+OZx2zMICbTq+exFxyqVS+qb +CCL3NezcGt17dtjbWxgcNHqtRkYzrkTOCuYawCZBTwW9iJwEEAECAAYFAlbtOm4ACgkQAy1U +3HwDN4hLqAQAhv5HW/WtI0mOo6Z6wSxBRbOlk9QuvvCa3PCAgevJKJ2HcZQXhU9/37ZU/TKR +4UHVX2bjz7JQAlQcDruq9IJ3zBF3S/sVF/JfyOUlqfOspyfmOs95ExafEuDegsBM5Emcbh0s +OXtLQlgM+d19Ufeyq/HyMQSsIO6UQJ4O0eJFwPWInAQQAQIABgUCVu06cAAKCRBMoYamxm1h +ox2UA/9xtF4W6H/6WdCUZKfcSVc0mJ8qUt47Isc858Xd6vuURriGTJQYTu7EWo9gvtztwOpD +bHn3AyVlDbaBibxLVkXr430JJbBs0OeIDsNLVo92ozAdt7wSjT5VNCutYJjErVjE3Zx/ko0y +KLxVIxhgX7AfeChigrcRCQHykcz7UiIHeoicBBABAgAGBQJW7TpyAAoJELZmWkoHfUB/5NsD +/3V5aqOmC9UU3AZDy39/ZDkMUWCjOLfsHcoNDXu3Hgdbix94qqbO4UWlOEGLpti+a/+Oc4Fg +xJffy3byGxQpKXuubZyqcNNHJNIlyNkW9+PO7k4JkXPwN4sNWeczg/C6aR3qchCqZQdMoCAo +nJFAq+eABAugWSkzr9F3EL95Gch/iJwEEAECAAYFAlbtOnQACgkQS7KTQsnTkIg3iQQAmSl0 +8RfvF4MjqcJXl3OHoCqIh9ESJLYkwSTEYTsyr8ku2Gb2ysFhEAkWajLHQcMK1CniWf80huLJ +lYLLehiVWYahgsyM1eaFri+ewn2NblyzEJS2pFFOlTdJvoxDs3jO4DtXj9je0n3NP4duLJRl +MtzSS7RklxOYcisWKrSnjyGInAQQAQIABgUCVu06dwAKCRC7/byNnz/VVciUA/4jmv4u1WXa +/OVx7Vqs9f0T2uO7PF7Jr+bRRxXSCgfNMz3kqipR7vnEDgDimlsyx6nTISdOn4eTXRGc+EEq +fiPq5VVHFtSlZl/Tm50mw3d2Co89tMQGUDBhw/zV8K40JKcfBNaDZBhJ4TIQikYgbEP5+s5P +pPPhv0+e9cJBJyKxUYicBBABAgAGBQJW7Tp5AAoJEGBaFPxwao7xudUD/0Z9kck0+hjhrSZc +HYdY2AEc+HZgTDRtc0oA8FsENlvci1OB986oLwd+1U0mEQN7mc8yTL5YS3WTqWqcV7xNa35C +mecpasfhMPcngO60angbNlycVjnYsFF9RKk2bnbJCfLxezFK4S5oAa5mMlGflbVrK61pk5xT +i1kQw+WIDhHGiJwEEAECAAYFAlbtOnsACgkQVRyntPWUGqgdUgP6An9BkFgLyFk/hdcCiYt0 +nmKPWbmVsYsCHbvtzqe5O1HVqWiPVsVNJmgjh1MWRWDPRvOaEQb0tNAVxxpa5lKg7eYp6bBO +8Bf+Ymebd2yir2YxhCi6XegvuXnbypfuuKwfn+tPx0OtSryUrlE3/xANbSdPRwIZ2WNew+kF +kV/piB+InAQQAQIABgUCVu06fgAKCRDRjxYrS5kxAtaTA/9GaVhj28RgaCZLuSQhzZMf5s8R +hIJZJAPWLiafB9UAGkGsEiCKxUKqY7JUUnJhIfxBGy/Mh/xP0Z8v/MCkm6W4Uum87uQ3Ht/B +nDBK+bYHIkJ0LPIXAyIXcjGFfJGIyAPTrEH0+4riGqvFUdtaXpLjDuyjPaj5TUvhDE4TqSim +44icBBABAgAGBQJW7TqAAAoJEExyswoS76FJWSEEALsYPyTKEJMsmcldEaKpfb16PhNDSWTj +ikuxMeUVpy5PcncyT+VSFOuP8KCqQPY/gIsVr6A21fyaq2LQZioro7de8ddi4Rtn2QASc+nu +H4nO4FupERv/Svvu5FipyF7E5yfFff4gOmvEem3Y3XmUWXVkhwQGS+j9JJXXbUlbMafoiJwE +EAECAAYFAlbtOoMACgkQcxFq0TgGIp4vtAQA1o6ry30+VMNSQPz9xEBUka+/emjJVLdL+IQj +gXfSffoYpSNYK5C1Ry3f7FvHrHMCYorVObaydfcmdWbOejZESw7BEho4s0nzYsnqe2zFsld7 +sZ5DYLaKN5GUia6eiZOQs5p0JYbQ1C+9EtnSRk5Nq9VgeY2s3LThmj08ov9XJ/+InAQQAQIA +BgUCVu06hgAKCRBIAWm5oY6wdwHtA/48xzcQ/aEZ1OW9W7kD1A83kaX6ByLEnlbdHh2RoKpI +Iaf3n/ENr6aWXsOS0NJ1oqUqBf+vcFHwDCXSTB0RnSk0iiGXhM4VlP4R3ErKOC9cVLLD9KU1 +6i0S0zwiRCysAjFRr1jh7PczFRxxKstPrquTYy5m5hMyjSnxo2PP4LWeNoicBBABAgAGBQJW +7TqJAAoJENlTH2kzxXRxmbUD/2abFnhHYNBKGnGQFuSymTiWt7x9DKXVZ73MnN+HteWH3pz7 +UGsIZbfiBB5Y/yGYdCrhNM/gMQKBg+meKKM2O6tk7gXSss3IkGXqBgUx/ePISkXhx2GT8tGw +G3bqKKF28/FhNDLIINefcaLAUcPj/wf6bbYNAG1xuoDmYAaaAWVdiJwEEAECAAYFAlbtOosA +CgkQ8cFHSfXZ2UaTKwP/VZ8sZXsmRXhGOikYesIvSjbDnCBnNzt0OudOUf5eE2XggKCHkGVq +byxid9lVp95gwZI+tbcSQhVJyaO4wQzD0YLi0hap84NigujTd/QgwuZCaVTCveqwdGqjiJGU +6VBjLhKWFmHiXQhakPZv4qqfPjDwmHd07bcHxiuOKDLztaWInAQQAQIABgUCVu06jgAKCRA4 +GNCL4xh3TtQ5BACqfc/Bf9pIbQd0ACgjE0bFue7umoT0ZKD1LzI4BThdCEcLdtpF4AbQZE50 +08fG39Kh3VfL5+pxqFE3ppTR+B5MPSRSp3TDpWPoJ2ivg/i/B6B+DAbz7P6K5hcd0O7K4lnH +NqodXloXWUS8IfOnHIXD1ldIpkOQDPhrKSNDPfW/6oicBBABAgAGBQJW7TqRAAoJEJwhV7gJ +C2AVdggEAKw9/FVWg7zZNdVqiUwHYL9EyxBqH4/354yACHj4/d0QnvMqOnxR9qLran58+XgC +Wbb4xPsy9cZ3/q67uAN7taEV+a/F4Z92Zd0k0lNeZn6TW/S63XAOFNjQmwAkCmReZVJgXjG4 +Sp5A3VJaedFe2+l0RhUMramo6zJ8Y1XezckGiJwEEAECAAYFAlbtOpQACgkQpX6185Izc7yx +2gQA4usXvYyt/NVnbrc6FtYMxXsmiF8DrDb3hNGv5ao0h7kw+oUa77CAmjNDnUIWW8vRAiMW +0O/vTFlpo+9rgQI+3CJDgraI/Kp+tpgljSVbSzP3Lz3hxMZYwMOA01JS1z0KQfvtFoCJY6q9 +vdx5dY3xXJAdNBMbd/TTianfyHd80fGInAQQAQIABgUCVu06lgAKCRAtXO+S1/NL2WHLA/0b +9TPIv/ovumMBUdwtVuxQylvmOzZFHVHEd/QEq5Pz0cAQyw+yJwICk3XLcJ9lQsytMCz/UKXt +z+SjM1cV5Z2uuxCTFl9d3DWf2j7R4oVK1Zy7QCDuomfjH1vZy2cbzQo433QIaDSs73umc+jk +5+nKZrsoaGx0/2gJZhj1Dwnn6oicBBABAgAGBQJW7TqYAAoJEJyIBI8lee2+fhkD/1yVA4Hj +0JNKQwsUXpcWgdMYG+Kxv6jrrQ2bYiLBbUF67vEDF8nNX7SoH9C2LapLg5FpnxlWoawJnEqe +3gj81eF08YkT/YnWtOpMeYJ0hrhVeIcIeca6ndFFdXlMGyk5r8H3tXW8CNbfXn9Ne9a491gp +RdwZUZVRdWpXvpA9CwMbiJwEEAECAAYFAlbtOpsACgkQ/LV4QtZQFL1vlAQAmhPu8wAyRoNU +cgyuDlCAVAZ+r9Io7bFV+HTlQqRcHn0Rwqcd1m2sdS0ed2LNa9Mb4ntqzyvh+4g8YqySy23l +4dELa0KuBfOBsSj6aQRtBq5cxjb+we7HPbyIJvssNKDe8m6FssW/x+Dc1EX/VmjBQv2xAqD7 +LULzvTgU+jgVC4aInAQQAQIABgUCVu06ngAKCRDCsxSn+iO+6/FyBADBJEpXZGJ4ZGLWdknk +rBKV5++6TUjGBtIimoKNLQbn7C2NYdEkCnK2jz4RZU3Vhq8JC1wz7ychJriUSch4QLD/xo+n +FYC3JPFBdV4FBeINdNZJQkUK9mfoWvuGKj5p9X5cnsEvRoVH8mCQ3X40D6orS3SPNm8YxWJT +YUBILGEqUIicBBABAgAGBQJW7TqjAAoJEEnHXVxXMlnMY/4EAJ6wKuMehgEtJkGecv78FgPn +PR9Q0b18pvQsltqYlnAfK2vMOKJNeyp7Rqy4jIIpXwjKfceqCE1myJoYpx7nGEkc9xbGk7Qh +M1KdYXBBZeHkZfxJdy9/xodhl6CSVoPGJU/sEMf9W6Lrbckqrrw+2T62YzjFsmE6d87FXXQh +BTEZiJwEEAECAAYFAlbtOqUACgkQwN8p3sc9KvFelgP/eAtD0R0Yb7YnIqyZSJYCjQNr2FqA +Lio/2IRZxdhCoZ0EH7LNmeql35kPYnfsY/GLpHBIr7EQiHGHtWfigiuo7y8QNDJkuvtzDWZg +cJy6GoUgmG2rTUu/5stS6qmqC8hB1ZaFJQXt+fZpAa3K5HEy0bCReAAT/ICGw7ob9A6RzJyI +nAQQAQIABgUCVu06pwAKCRBIrp1Wgmk9TOTwA/4i8LVCRle29hP13r8gE0s+HldOw/vV6GBo +EYu3bsLMWEgxwKeNcWWO8xMeNsCx4DI9sbVG3j7EiLts+hTe4rXjfD19ZD9kb8DCJn4wPuEo +jfN+3pBsoB8QI8V8iPj/PbPlxDjptBqQ4GxqNpVGMz4tAgm/qKCpcaWypvZ/MN5XM4icBBAB +AgAGBQJW7TqqAAoJEDgjgetOhi8/7NYD/1VCeZ4vBi0w6ZiuHM53zJXRUChX+8rcdPNE1z3I +yCUduE75NbvC9wc9N/iQPktwBkzsitExjGo6fVtJwvIfAFUobSRNmTstwszsixVghrAeNjeM +OERWaiKSlUP+OFvd0TEgcin8ZWni/G3e3GNFd4I07v01v7f0V2BZPVlxUHFWiJwEEAECAAYF +AlbtOqwACgkQgrlg6kLZvlhNwwQAv487i9MzDh4gElgDHxjQdC2wFWI2YlpI97jCTrvUNq5l +Dmhx+6HS1CiBELY2DGmSNuFYhA0KtvGiZaidenr0uTk+52TBpH67kiXfHuYHw8365SlVRWnk +KQyo9XFZpn7yTgght/4mQJh/OvZvg73wzvF/8OMdlDEHMBEN8ARpZK2InAQQAQIABgUCVu06 +rgAKCRDm1DjgTCXOW+JCBACfOfB6GObEqQ29NsDGGFvMp6MCzQFP0xe3MK+Rk6Owan26qmq6 +JOIzK3yT3sxWAEe7gZ69/qjCAazaP2S/JucEA3lgS//aRugtFcyHZSUSHMncsttCUDaR+lYo ++zZuzXMeU6E054DtqtJcs+NNcIA7TG1dybqhdz9d4vCvH+WoMYicBBABAgAGBQJW7TqwAAoJ +END/jC/BMGPAfOAD/AlkDBbcir4Ce/nf7n2/V8uV8cYton/wdfPN5nnMjkwd5dyvOaov7EeW +bIbdTdmwhOaHJx6/cf/n/2+4DhPoMPpeC8bIjVbBBw2+IV9tEzaCXl4Bv73rP0XSiScy05le +fWvjKVxuZxMMmsUHW/F+5b6vaeghKlemfoElEiqqV8qaiJwEEAECAAYFAlbtOrMACgkQ1s7L +2CYosKFCxQP/ccUUwtsXNI27GXB3Hx8qM4InhTP1xe9mgq7g6+J3E+F1tJrW2bK7vDDRYpOM +B6lreFtZjV+/9R1sQxVusXY5n2dy0Vu7WlHy0/+KkT2OyCS7+BawT7xiEFvKrk54CW3y146l +KpmGZ6pKS7P++HOyUcBkO0iIDiolSyU57pdtRl+InAQQAQIABgUCVu06tQAKCRDAwBEIVnac +bB8NA/984Ds4uoy5QttK0+40e6gwvD6bTGIhMuuSCqFH1pmpmdiSM1iq1HRotr8rrE7TH/kZ +dXgBmsOS5dQgnAIhPYvQ19+IghjqTQqFQm6knaPviI6NpyM0SeBiP6SLMj9SmHD6hP81ltvE +miQ5wc6xxpShE9AlLj4o09/kIv5WBRHxjYicBBABAgAGBQJW7Tq3AAoJEGXcTBDkjohy8wQD +/jnUNnjh4qfdxIOElc0FCkWMIYBQuT+7owTva32IjUNLck02JslJWBCg2ydMmkJtXilWrK2y +AvpLf1KqE+O6WWo17HW854rSmY/jcuQW7EWKraXZeZ93f2Jfhk+yEOKDWPGmfZ3eYM2+zWrn +azXnqpV1O/CgCVUzF4xIknHhkotviJwEEAECAAYFAlbtOroACgkQfZDir2q5e6nraQP+L40C +Kfq4ZJNVqnhxLGNVDDzpeDQr7nI3xMke8lZXLyZz0vjHVm18TYVih9gvrv09/ynB6PNy04Mm +KOF30UxGrIk87Ci8ZBuxqg9vOaBFYlUmCSL0aHOho71q7lfZS0EKIRLcW3+v9R48lU0Kf+g4 +GNjiUcSapUaQRJUjxxHTaquInAQQAQIABgUCVu06vAAKCRCXjvvLptYtjy2BBACbuIIYuXd3 +KNjRMXkpsIUsE/phQIi4pEJIAYo8PMOzS8z8SaT+VpxNPve4Iduv0ndNH+GIbWM4pL/G+Z7t +nuAV9WxrJllGt4NvKMzc6RBCa7qW46NQ3jtW01uRSv7HGtYg0Iy1D+F/YXCVTLR/DNhzjl8N +fRSMh57JddU8nw16sIicBBABAgAGBQJW7Tq+AAoJEEL843cqBlIUxCUD/0uACqKkDwBBheeo +Qcwww9a9nCbpQWqF65Co7qIfghkW3ZzWNs8bRHsxOBqfBop5Vjpdp3jiMV6FpWOlps1Dy/6k +7b+ZkFHoNW+7hPpkOxh55JWkMhI33m7W6syV59+EeuS7p5DqUfe5IKDPoihUugtgoh9bFn/I +51BnAxLzaTT3iJwEEAECAAYFAlbtOsAACgkQ+MoUFmuLxYTYqAP+MkktEZ+hXr6lEvG+Knpz +EdB3qECKh/kDLxotmUakkar6I6OZru5KwtPO5yMQIobl9ckScy0W3d/7N/t8/7UaWSa7tSoH +/umQRHdSq3/MmYJIybFZ0ISFaAPqFVl9VCS7r7RQ8D4258yyZdXvNp2jlhkuDVah597HK5mB +I+wSdXeInAQQAQIABgUCVu06wwAKCRCfol+g+Ad+ykPxBACn1qW4OlSdbwroFuznugrILV0Y +OL+NzU8HbAYWy2c0wmHH/19w438yvY03anSUqXT6/nONT0VlfVzYNWy6dLYiHdO35PX8GSsM +f5uihoyzYqJNgRw/WcR6P+WS0bt68F3Svlf9bCAPpZRHW6AIQemfNpFYiOuG0dMdPMoj3OFA +poicBBABAgAGBQJW7TrFAAoJEGAzy3cgQR/48RUEAJBKM0h5IZHFINa+1HVz8waIuvXGFqUf +ccvCwONyzDIXLYUaT7xf2/vD1BojOpw3+Ssq7Xl8J7jreP9+RFBAyzh9w1st2JLSxU09lEIA +Flox1dJLEhVaJfH1y3es2KrHgMjChsdxyqf7jjnai+1uHAW282ivOPa/W24vm3dtmQIciJwE +EAECAAYFAlbtOscACgkQweWlldwl965HPAQAv+q4VuuLI1BqBEEhjlTfqmiT3/pqx2JaFiDB +/7YC0zwymtfe4bUqmp5UL2EM1WKKct/RD1Y1EAnvJauYfiwuUOyVcNB/5IiO4mCx1Lq1DiGV +9Ne0qyKTOyLV53TC3dRU3VKG1z3F0jf3FjYDgAaWrkKrGIpfQY+AglxKeCOTPJqInAQQAQIA +BgUCVu06ygAKCRDwhs++UwIYSn9RBACWR0xKbHwoyzp1kyYXutnJuq8rTaqrNGwrhiQ4dnwc +0Yv1GO7iKZcK5vp3aNzE8nQuUOEGaakvUyfmN7wInImXKHEB0GP86B4eYlTKlWSIZHk5+Pwj +pjgoFt8+0X4widDg8n9bXMzIiwwTpXlmNfqO3VDYxZVxhO2rp2gddKZUBIicBBABAgAGBQJW +7TrMAAoJECN+153RMIkNkSMEAJ6FQ6ckcmKZpcjWXWW2f0HD8chlf0tPsu7Qeo1d3GnHyqET +qwfZuM/u2gPsM5S7ejDq1AR/RFq8xpx/ueOZmEZ0C8zuxMA8BTLL2ScHtRPUXKk0H1/SiXkM +5rHhHNL7S9xj/lrOi/8l6SMXoIlZpib97EEY0K4KScsBS5lgKOq9iJwEEAECAAYFAlbtOs4A +CgkQXJ2Wr+GmvozchQP/TRLfFF9z8NYpRYkdfO6hTVM0LndMSYD9fyZ1SORXtsTre8yUG9U7 +ACrmCeQyrU/k19TqmipP8vP/UYe8vUEc6WI9B0nLotFAp/6gePQemYXV5nq40MaAAVXnuh1p +rJIp/gDY/pFMGwNdOAA0nfaeFnkpoxdfcCjYb5PEtPbBS0WInAQQAQIABgUCVu060QAKCRCv +aSUK0M4+tah/A/95wQtUz/z5D9Pa6zkNEowmlHTO8XD/vu1Po0RCAL7Vk4fmyITQc80oi257 +KOw/G+FEdPpT3vT1I8PuoFj1p5A19OmEJ/t5EqT74JjgTj2KYtv90167OHAZI9AoQ+Fbote9 +zkKK13nInkLlx50sbvDV9pllzFtRbK/5ZU9WbZDbMoicBBABAgAGBQJW7TrTAAoJED7zv5ds +05Ygu4MD/1OVZr2ZbmcgjP0SioUyqk/XrY9bCtK5u2cMLGjBUBcs6UAlzzu79juuTVwAHMIl +7XXis4Dic2LqioQirtJnmVzeB743cUtncVj7wAR4Py0sXzjLHKWrSLkNd0FzDBCTBgxTt4Mv +CHkNYjmQJjI+A7RRKnRq0thm4lB8LPIRs1rziJwEEAECAAYFAlbtOtYACgkQp+Zhov5iXPNh +sAQAwrCTh46MjBVbLHUL5Uw4o3j7Z+Q+K9GWzQHWFIOzmuz8M49GAuu4isFWrOtTJ6tg8lb4 +g2zPSvV/KCQr8sWDrNIHDasfmtZo+DGDWt0ZfU+c+89U6EcbNUaimXo3U3gr3R/WbUV6itW2 +S1D7m5l/9ybQh+c0ALjQ1V9maC+Iol6InAQQAQIABgUCVu062AAKCRAWR0nu4xzLGyeTA/sH +5ok+rfabSTqkdmq4p/GVe4yyr97Eluh+IuvMvWY7kJc80PT0hY0M5bie4ZjrmQn8YoTdcU9o +EzhsKqHfCUpljyfaKhIu2SyXMBXtqOyM+jjFXDBp6M1JpJnq/he0hNVQ1h/fRJ7KZnizpQed +8JDIN4HhjtmEoXbfg+1RvO1I2IicBBABAgAGBQJW7TraAAoJEC39o/7IS9Bd6MkD/jRPf1QB +JjUo2BH9VLZBzBcBbGkrHBrINR4PxwBusQoynG/G8w2L6yu8UaErEw0pRAdETb8BgZcVBK1o +/nGjSqBrvwXvfNoqbL8WI7qo2CpPP48K0ioFijKwt2RdW8RQgdzzXslf+Zuv8ewR4bMsOKRi +szChE1vzLNM3L25uUVS8iJwEEAECAAYFAlbtOtwACgkQys/TbcXgYwRxjQQAhLeu41FcP+QK +st4mGh2lXSaF4sMaog1ST03T6PrrpGC6Cy4AbRb4/IVgNR2TVb/aVX3AKdWzAjBzV89ooeLc +UdKZoy5EtZr0nAsoN9KPE9Ach++1MdRKGVmyxM3ocXFeMCaqrx9P7MWdShxRL9D+8Qb3e04q +4cQXXMV63cSGlGKInAQQAQIABgUCVu063wAKCRBiL2ixV4p7+BADBACx3DeQC2OeXrAclVi0 +OqXi/QSdBFuMSznLIOG/rZ4+1Zx6tPXtr4ikmxzGls2CyFL7NmqGocRMRCbE2Rxo71FOpJIg +qaImNSlEEht2URgVyMm+L4el4/2SNuv1jTt3xM+4RUxyYwYQU5C0OZrVVYCzzAbV5tqCT3q3 +H3pa4ql7G4icBBABAgAGBQJW7TrhAAoJEJxycxAubktvMCkEAJ5GohXNKREgj+5kru0ytMTj +4zA/5BrlOGVP9n6XjMEOqbaGT38Dzn2v0LfG5Sn72MczGPw3r26dHhzFx1k6/YPGTwnYLP7l +yybasXQgfn1WZaavExgF8sqvqeuzHie7QehOnOY6MIQmXQL76UarqgIKUXzicyh9eI5uCfFx +bejIiJwEEAECAAYFAlbtOuYACgkQXtQS/TsR/d8B2QP+PYRT0SrnKhfwl2V9z7P5qhVxCC+d +jFf8rt2IZcIyMYBiK1zQR5XjqUhvM0murY/O21GGQzi5xmVEv91iqIadqU0xQTq2LDtKmvHl +8RmYPw37IJ75zg3sib/aUFyrTF/+8elgocyBxgPU0Ca9VTfBycNgywv4Z8iY+ov8f6dw2DOI +nAQQAQIABgUCVu066AAKCRAEnKC7RWi6OGTeBACSn/CIHFo+8T35VB0oCwl0AyjIcn4fCTtR +tfeDuj0wQmgnHXIgZOHdfTLXPfmVhtm6Pxd81QFZdL8/S056YSNQznzihTqM8u9fndGKxAXx +Xku1xhPXNUhvGWvsPRjgGJTbPv/dS98WTn7PKHaZOH4dN12Rd477WPbe+R2JZaQkEoicBBAB +AgAGBQJW7TrrAAoJEP/kyr4ZX2rj0oID/2QOj9uUwPXTGNfPOUqSCAc5HTSa1VSFUkol7Vvx +2feMoYtcrmVgmoN56YMQtHJ+k+7BnGdW3vlDT+oTJsKTxtfDLcKpHHH6ZXVg6slRhu3csXZH +s/kxGzR6IccjGx6KV8mGOOtJ3yIK0pCEupQHA1dYTeZN12PzN5mz//DLa3ZriJwEEAECAAYF +AlbtOu0ACgkQtpemM5wYR6LDSwP9GfMq0MmWpL5mgx4mDaoHfZEFu7XrQCYfm0a8bq/sqmgB +fACTaalU8BGUpYmO9BbOBf8FM0qjpERicWIU2Cd09tYAd+l9svSBD8dW53+qmedXsTst8i7/ +C7xMJWG+67WlU5VVPUZu4S8lxoh6JO0zv4Balycn9TLB4i16hw7nWEyInAQQAQIABgUCVu06 +7wAKCRBRCDAKvwBx/038BAC20NddiRNg8xl0lbGwoFbJs2JeLc5StQjQRRsq0u6Y35dXi55z +lc5hOA3HEYXOMhBFTjUiln1gnKBSAnu7MrKUSDteagddIxkCKwYQxJEH5pMan8HutuWwFoxi +JA5DQAPux5vpzmeqMVyAC4i48HaIWg4TtjJduOHP7XdDw6K5PIicBBABAgAGBQJW7TryAAoJ +EA6JAW3TjrjPVj4EAJM9skDZVhCgcPSpikHsjOa4HdfwtHaQJptBWOJ95MoOP9XIMSRiM6mi +h2rPWrAbfR3enQeQRWibC7fAFBcjtKnSaN39eGXvHi0kGPfRFzKtiQHr/U3G67yMNkRU8Txw +hlHKoTOMk5RfWLiBK2hEfQrWipalr4NkBkjJqKN8KSXpiJwEEAECAAYFAlbtOvQACgkQlh9q +xuKOgzW6awP/V7Gru9FRcBOp2ART/hCuA5ZN80TDRZKNiYZ82Feoc4JVWdRVjW4pfT+QirXi +7S0Z1dsHNIyUSoYMNutPEfglGIjhBOd5pHYMgg2BlhKjNPfTwvuroGTPUIJz4KI5+IZf0/kw +T2RPCjmEnAdB2ZIs+AwVhStlTmWy2q2Ot4jZy8mInAQQAQIABgUCVu069gAKCRBykaTKpIEJ +RjKoBADMPAo6Cyo+MqIM8aLAiAmy4OQGuoCBXiG47wkNFYdfzl3C/pAqachjvFLBtdjCctFr +EjDLUhYPD5RGBjm91vJIPtzAMaNoe6Zd4If68PE9YqNwAnyXnrE5LGR9JnPgyRZaGOpogikN +7Y5jQZSBT0ZCDdjblLkdooUOi0UXmuoTyoicBBABAgAGBQJW7Tr5AAoJED4ILwvHzaS0yQ4E +AJchZ7VwH40zkwVfeiO7lSLxzLrTge/Fe9ZVRBH3HlB8q9lnWc4uzZ+QSentMHZt0kII5vph +R97Aza2fHRne9l7droffCeRCPKOFCoO/4kV+aqNgvq3+dhV7He4wy4jjJCOX4TgbdAi864qS +eaWJi+zYCWr4ga3kJQMTKi/a75gaiJwEEAECAAYFAlbtOvsACgkQ2UlHf2yZY0xNgAP/Yu+7 +MAgOP5oh8Lt3kOewsHczrXaIZrkWiknsEHIwOZZ3h4mKFV5r2dQ6YijV+QIbI1jJ8ltkS6Bz +EQNlpnb7Z1ZRzlx4YK5aWykyC1PfneJE9XsPZ/VdFjHP/Mz3fIQt/m8YZvKN7luDTs0IRqKH +pxiAoCi2BVg68pJ1nu/FfzWInAQQAQIABgUCVu06/gAKCRDRYp7zI7XV3jRPBACvCEKUfREh +fDmSlQJtJC7BgmJhb8meZemQ0iQDe2uLZshIIB2GGzBQTtiUXkhgV9NDM/8zqnwu7FNH2Fuo +NtlJ+H/cU2geTBb7pn0cfmv59zwXWyGegLCqO/w4dSq+Sr5T5szhuD6bJZr+VPk1IwgFHbJ1 +n8iJLc/1VCvu+MZar4icBBABAgAGBQJW7TsAAAoJEHGjjCr3rEHUPDEEAKYakw0kOQEo+Lsw +Ip+jxtS3F1QZNsZT2l1B1GAfCC/DHf34l5NW7aJXCEDbTy7Yxg2/5hC5sVWEDT2kxnFUwRSG +12lXf/ZhaLdH+Cg+JcqSFNBcXQU6HerHBhXgwemQjfa4ptpxU/Ai2R9dZv44d0lWpH3Wb2xU +FbuE4d5Fg5nuiJwEEAECAAYFAlbtOwMACgkQmYRQ5xdrDP9GrAP/YN4+43O6zofzfRmJ6lfG +ak8dEwTUpAjpJfOuzJH5isS02ULLNr/JfOAqcg2EAZSFrRJnPrCogLdXjd4CyClhqNlrqQkA +c8b8eh1cdW/EtjfiE+4D6vCbV6L/hoY2rFkuWgHdZ1nq9HGMtsYTBGR+yJLC9jo5sPQXvsYg +/Mt14GWInAQQAQIABgUCVu07BQAKCRCA3TAJ8OJcri5vA/9qkbIfUlpljU8VQnG6FGCjKEAq +805Ag/Z5jqeM8Ot+AvnqbIl47HmtJVf+vx8JxY2D9pzXXsqSgiB2Om+4yHzROW4U7+Vob89g +u5WO1/wuAXlNQegmPtaRPY52bLvi60WM2/qpGIu5gEHMLfxxVhjCF7ifIWtIpDOUMmB330Ws +14icBBABAgAGBQJW7TsIAAoJECUMTUlHcEMbhtkD/1Yu89aJwzSF43rYm/3BLWvRzaoVcf5c +61vq9gGHSAp2Pn8IyQ/mdCxrj3gBFbe0DcTyha9OrZwjnJB1KIknfaDV3T4E1IgSXQV4c0xD +uLw1i3d++7UjAIKRGTvW2NvRtWRARx0GQoTyKCl55v7pC/1N0lylPKmYHi9VUZFh216EiJwE +EAECAAYFAlbtOwoACgkQOFF9xuMCFm9z1gP+IfTdU4qMEMYkCki2zSHuVB7v00Yaf7nfdK2K +PA6yOQiV0ifbi+03X/3NWgrPOOTcCgNPiq1Ite5db/7oGDD1VPNLvIJQL2fresYUDKrmSm2g +if5Vej0Gyzsf632hGGao+ovxFXqZ4yQ2CEmn5/fuELWWHZUIvkD9LwEx3YTjBXGInAQQAQIA +BgUCVu07DQAKCRDuvo1Raz6nmfWKBACcaBTOeSg8brNm+YAJ9RpytRrbKsYEg6tQ/918GBFy +HACWwP3onxtmzm/sLrW7ckW/55r2SYI/YV/zyTp8y4ChxxKvdMqTLgrWbBF2aRaLsHddfkNg +cxbERZ4cauIE6Fps7HvfsATbQwAa0X8lvjWGS07O6i8rjqkq+yydUkGROIicBBABAgAGBQJW +7TsPAAoJEFErZIt4pVWPO3kD+wRXyEfWg8UMJ9JXePw4m/C+bZU8sqh1xR7IjA2XCz3dt5jl +XHB1DWV9oLxdLFlRsAGPO+deykM3WDPggAD/OmEFZsvee8Y8JUXOO1bbcRTxNvtx2Nte+OWZ +gqp7Hl7uvwGMTtckxWTqX7BriOOldk0JhECynPjCQme6UUIwtM9JiJwEEAECAAYFAlbtOxEA +CgkQPPeEb8JQmQfq0gP/Qu/XKAbz9gV6qirwV2tsJFqZXlJDdmcO8FQMxHQP6Ktep+vxg79W +E5zOYjjHsBRm5CYGHC8WgKXQsNUQgXMU6PvjzyLTsbZU1AEtqPRg9k8bXMnR+xhmm+VPUk6E +lFzgDJaPQS0N8TbPq1DaFMtnkLVre9gs3+nvMRIPLf0ogrSInAQQAQIABgUCVu07FgAKCRBm +EgqfV5cby2f9A/9nyJdLF+pIdzDirErQfGPwiCZeHDzYX5q3lztll5HGnl4NEAfDj8LZV6Ts +FudmGA+05JSArpuMVPORSYctcKR2X3pLlycmhVibTT3zr40wJP8poRt70SPBOSjxiCba8Oz4 +S+YIEGPL1hkrWTJlnwn02G19K2GYJfScktVrBSWml4icBBABAgAGBQJW7TsZAAoJENchJ51v +Afd3ohQD/2qKsvHKtCB/XYmig0O0/bdCH4H8igoiArUZdb2TGe6CcKxsHSFNOB45CXoDi8G8 +ZToD9ROdzUIJCnD4myD3dsRZ10XfeUz9bEhTf7LdIW2Mt7VC/0E7cBl+KG77kwOXeC3EQIqX +2HRZRHET4219krFItLPF6x/g3ePrkskk27DQiJwEEAECAAYFAlbtOxsACgkQutKnxWBbj/8/ +HAP/RLi6vjtthq6S/RZA+pMu/Jpx+5qIbEilR5wjFkIVvZG1cJp8eBl9227lifqacToNlkfN +iJE/dEZxqqts3IqHN7X5+qFM1IPtOffpZk67boz+SIq59EtEinfAD704OqoA87HzyJyDOXOG +QzBxCCTmx/DwXjTMJr4iIyyLJHSVfDGInAQQAQIABgUCVu07HgAKCRCyGdoWCVDOdjgiA/9i +LFdbBxQU20fmo9Gh3l2T4Fz9H8DbmXbRWn69GTgzGdom8cxi82l+VlsgWbYnRBrXny4QxcVU +M+AoUCZsFxIuC/CtbkNo/h9KRemzUnSv4IMnhVaoBconqjQy3UegES5LzGty7AMSWO4Cv9oo +Mat7mQwP71UgFkU28rmrKVcnioicBBABAgAGBQJW7TsgAAoJEAUWFxOzm68oQtEEAJlU+Rpz +KNsbZGBNuPRm3QPFla/8KYtXOQFEIOtAS5DX2Vc//e3BkXXmheZaqPvrLLkrYxV+2A5A5k9p +wV7Fn2IuLmeWurLbiQpbjyk4/mLQvIoSvXkWlS675V+574fdUXWxCG9asxpaX2wVSBTj6IsW +/TJ+uUlGF3PXs1hO6Y0wiJwEEAECAAYFAlbtOyMACgkQuJLPh3f17lPbfQQAhIlv5OsK4Qkf +93NYg2v6UkggPZ3U98jjIhhGJb13OFNB7JE5Fh7CTacMXwN2rUJL5j8GFGpRyXtZaNCiH/Jk +b1QhwVtTDerBvTHnW8Cj55XOtZasFF36ScTwTf43fzimi7V79VJDLSixyQiBrlHB7Y9JETkP +bNrhsEsqvDPHKCKInAQQAQIABgUCVu07JQAKCRDUywanT+MT4V9oBACtVcNrYPht3I+08CvT +4au+viiYzGY3CvtU6eNYg5MC+ZsufK2x1CU/akj89xqBsg1VUkCZMKdEL8I7mPxdJiBVzwg2 +r2FzWkXcizZagviQqPCULDsicac6dkZ2C2A4HewrOG5L21U2lZL4qQVoV/HMm1ao5TW/VIWh +/MLAdO2mCIicBBABAgAGBQJW7TsnAAoJEJkq+q4WuFOesPgD/15AmhcZGe99Oo29YSMyLSXp +pXfy9tjZKNCPLfQxr2c16GxVlg0kLeC7RXAYjIw9PbDxGYM7/qO4XqpEiwyEByg1bij/BJxq +19m/IS/9DmaUZEN9s40X8A6Z/q6rTM+3RW4g7mzlo4vfue7NpiW0WVXV/CCG09Ju/pKTjsex +s9apiJwEEAECAAYFAlbtOyoACgkQX5pdbPmh6xHIEwP/Y2DOxP5py9sOmJcG9F+dXHM0QNQU +2lJJDOfeQEwg2YSHC4eXOEqjxdxAqFV9tzAsRnAGkl06zX07ETHjs0D91bS2HodYYZQlXPFP +2WHrlj5nJ1I6Yh5JLK6iM/P7lfeGF+ufRaU3b/Y1u7Jy4thd89FEjOl/sz7X7P7PR1noHB6I +nAQQAQIABgUCVu07LQAKCRAGhUG/VTN/DhmQBACnLjEG0sF2au9N3ldzhyACVT2Uwc3v2HFA +pjN8bEuDlEdh8aBAKQO9C0KbR755gMWsqypGg3ders2ztvtfOcckv5z9c7pU1Q6v/Hq+m/KK +cJpwnM21DPIqDTZQiDtv9EeqUvvHUxrqwh8DWewH7FjJu+V/29FJBIR41HCU1sX4qoicBBAB +AgAGBQJW7XadAAoJEHeXvvyKdCOph5kEAIv5fZXwKEEMsVkIREhzKtziqbxHKE+uqUCaBIeM +ZNaAtQU+vsQ+iPKfSf75wPqLd9aR5ICKKsLV6h61ayK0/Kurkorn588DcqxwRGWV+CAKKNMo +AH8XIFM7yTDXVDVw33I4VOP17m1mTW2pMy4RS3ZnjhunX0rxsuGZIlxun69RiJwEEAECAAYF +Albtdp8ACgkQkBhzHa7O+pto4wP/ekyIFWcyYzRcLMnebbC5mRbDheznGKEx+osq94xWoiDh +ZR/nRVsWBOlyV0JGKruD5BUtzY7mPMCqqg5YbayR5r9KWg6s1KUVy7pEifug/dF1XRaX8Sge +4E2/Y+OaCvNOjSnBXesu+xfLYTFApB0pNqpaurOETL/awbiOMeztPaaInAQQAQIABgUCVu12 +oQAKCRDwd8KekJj67AmFA/40r3ioLu23ehtCm+e6zLdv7sKNjJNybR8kZcXyd9f/NjjuvibR +9fCQ1EsIhLJkiUjEkcQRnD8Lm59dN8Ok+tU+7ofn7+qh/uQJxrrcfLeaijJiRMWs/rkLpsyz +cDMb6ybvGG/kcbIsfrTsw7mH3U1W2MsmUKHrgCVuFXI+Q1gytoicBBABAgAGBQJW7XajAAoJ +ELjP9T4cP9AO7qYEAJdxfFAwQtsOJvcE2/KdO4keHu8Y8jVdn68qi2p8x2eZU7SF34/Co19K +9ihIxsW5cyYVPiQ9Dt0tYqSdYVovV9MA3cjV8NNy8V46vaxPP2IJD5X/AgG0eazvhKXwf5N7 +XfRI4BFXNvfjXlvEuKybuZOQH3NrcwOzZJ3hL8fcsrRLiJwEEAECAAYFAlbtdqQACgkQOZc8 +Gby1PdBtowP+L/WODFZwFDfSjF2Fw6e/9GjtCcpj9cauEzpy/4oOa4pRbH2um8LJg1MGjrFB +skXYoc41q7pj9bdZ3zzZ+bkrrgbq9ybng4bnMT0NvQNpieslrnH+vaSb7kxRH8sX67Lg47+a +Yaj54R1JauoLamGuyDo/8GD/O1zmNQPXykUcXMOInAQQAQIABgUCVu12pgAKCRCl3T6p3oA3 +gYwzBACRoIPIsFDmJq9kRxL1/4pf8kVBiXw+6NYJuevqixpZP47J8ER8nT12A3KP1itoYgk2 +gyRONxFfzaHotwbG3wqf2Uo7uISbzT0ORWm4OfBKFeQBj0gvaJiVUABXcPVYe8HcPV3GqVZD +tsZYzsT/sVLV8mHNmLQ9OYdpmrQ2RPBLKYicBBABAgAGBQJW7XaoAAoJELuoemg+1ex98+0D +/0BrI+sYq+X2Nuc7yfw++5uMWZMLNFN37ELG4IsqxarE6YKXsqP0TzH+F9UXcMPI4hMGzRTa +/qhr21k5GZ7WBNNE18UXmKB/QYQvQPwFClEeUH4sg5ENLZMd4z3H69pj8IDjVqQUsYy2kk70 +RV2keu/6Cz3o5jplWLpDvoFf+omaiJwEEAECAAYFAlbtdqoACgkQP4nzp1wgbdZ9AwP/VPZZ +Mr2GnI4w8XTru0agEnZP53FKyS4+9mL6+MZBqfpWWEhdLmgRS5oHqo5xId3ccC/EKCF8sry7 +BoOjoyRvzp1uvwFXGQwGZv5olQBh5gzCeQCPJ6Vp//OXVXt7cVO8ZbR4phD+kSi2nokcg2LQ +tzg5gkhwWNS8HeGb1LsbxUiInAQQAQIABgUCVu12rAAKCRCC+vkAOCBuDPGwBACw9MNwclSM +zkQRVbXhO2EOMaTCZ5I2GD/D3QGcEZ5UF77sJbXgohUPa4c8a9kxT5e3rXVmVDbH/zahT9hd +nVVz0Ok1lOvg5Lz2gPp6SHi+rIqb+48e9MRrkdO3PWWj9tSZQUFjfvF5W2y44odvwtddIhJ2 +tbjaE8Bz/lXGDGGfN4icBBABAgAGBQJW7XatAAoJENneCSQaG11hfIsEAJH5CpK848HAwYSD +GY8cYH3BdtGvcyxnbP4FL0tjh+g4H9zzN4OjCwacPbtlVSWlAMDviHKAdipjMtHEFS9GJmt4 +gtqKbZ8G4TgrBFVoq1DRkeXyriGh0g5c3RVo2pnuccgraWYQD6KK7rHBWrpzIAxhB38xTzBp +HM978gyzPafdiJwEEAECAAYFAlbtdq8ACgkQRyS9XxdMPbliLgP/XzRK4byj9d22th6oZvpB +ZHF7VLlL5kbcsxUF2DaEhekCWge/3jDY52IRB9mIgnpEvqqBLERqKpYkfBXVVqEFLsLVYNzf +bpwIoesNJ9w3KFIpAWMGPqWdijqzgxcomaQo5xuRab6nwHA8bh1u+pR4KeN2sXq76fP89Q6m +QEdDLgKInAQQAQIABgUCVu12sQAKCRBomZpxjNcwK6OKA/0W4YJsB0kFKVBKOzgs/AZM8pyR +VyENnLz8IxASu+9Bu0idMxqoL7+/gfSHe14tJGUY7qHZGm6cb5TKrKV6qamqenMbBk4lYq5u +P4Xu+uY7s8mjBwKZiRrlTKNrmz+JqnX58VoIe64IEIyqYRLaJl1CDAL3kO+kGUs6whg7hj2N +GoicBBABAgAGBQJW7XazAAoJEKY4530Q+Xsv9N4EAIGLU3HXHWvUleFaRoPUNBbAPSIIy7yG +LKoxNL9jtYlLZ2yOzi1/r6oEA7NYIZX7LZ7ygw7kLmsQdPD0MVO1B3oeiQ3lpe/1LuDP89rH +bfADAaZ+g51eSsesh+AbomdmQH14gJ5ufULTFW1ZO0KQlgiKsUr2IMbw3cdCfvvxWZDDiJwE +EAECAAYFAlbtdrQACgkQCh58xgAo2rhsrQP/cdsBGYMPmGWypRUAr9ShjfQgDPC1ZcGh+vwp +Rl0SoXTNvKrpLLKtcrg3/BNK6euHzOkD/nQT69GzG9a48SNe1uATEmEhYL0WntEMeVG3lOhj +xtKbVDjacaGLsE5jw5iUSH13gyuo6F6p+JX0VvXywpUWUdihZrkV8caraTSVq8eInAQQAQIA +BgUCVu12tgAKCRD3AWflqNG4ESPaBACqJZFcgg1BVdjbJ0nfpG5c7AumpcA/+5XEfXphoL/m +fxVxxyiMQssGbw/26vDAHsRM9rNOh/7kFiv0iLtI0MEUMnJNAX9ZRZBjESOJjqbmPt8laFlt +dtJjQQiMUF//cpYajzpB4IcYzqjQgmu8xjYMFmnafAf6hTBy4uPR2qj754icBBABAgAGBQJW +7Xa4AAoJEKfRol3ODEHwDbQEAJ+xf9+CxLWpxJtfaemW4F2oN8hGCCO0n8PZ6SmXcplXgYlR +xkb6eZG5fXw1JCHhzpS3y3i817AyftVmbhYzOGnONKyq+m1/6Ta5eqvX78bNuafUunrxUbUO +6uWpPb8X5bvht70rId5QwDLSyYhaW2ufBnkaeFhWNys54+LV53CqiJwEEAECAAYFAlbtdroA +CgkQylkKZ08FAUGslgP/Y212aYHnqC2VMPsLjAU4TrI6xLGzXnM/kmyla0ssgCcMQYi2m39I +fvrIjluCd/sp7M8cN3Uu8qwOM3qk3BY4kvG2gK7PKftmRYk0FZm8Aj5h1Xp9Wd/hyOpoa9jC +7RHgEoJNJ3SbWxjHJENHLHtioTgMY1m0W4JPLC+9dJ5efaSInAQQAQIABgUCVu12uwAKCRAo +gl1yi2Rn059yA/9Y0VlDTfJtKU2Q1YHHYJD8Tft3JyDgazic3XzE/UEXsvnaqqB4QVo12Q9W +0cYmXWeXEwmo38avgPxwgpbQlIJ5ZwJicVD6IvwdBA1SCMc8BVbC0zuiwBJxHrzOsizVdawJ +USL8ykcgAYJ5awHbirauvOpQp8O9oSHYRvkhSf1AvIicBBABAgAGBQJW7Xa9AAoJEJThajzi +mFZcAAsD/0u20sFoRi9q1DsA1T/qrRQ4iV3qgZaL4VBbtuwWBNBHLARaZzEAUgkFgv1U+hk/ +07ITh16WWgAgrrDVbbPvam2h0LXblyLY3E1fkOmntK6PmfItBWfO8aZTXs+jLezDQX1xptyf +lFHQGJU/FHwL2BBy+gLhKMqANuRf/1JXO7z5iJwEEAECAAYFAlbtdr8ACgkQESmuU6uYd/5C +LgP+MAqJRjc0t7WUhdqgM+8B9148UPsCS50WMrOV1bBKSlFhUpHEjpfZhC7waXnnevEJoC/x +fgWHvBGxiQ0PjWnhwvDTHt/EnZu3tXPGJUAvQnraPwJregFFGOqYCay9MG2EHdtuOZQluDj6 +pJDPgAcZ1yYXanGRlfMSfTeJNHmDhA2InAQQAQIABgUCVu12wQAKCRDRU+98BtTvVQiTA/9V +mckrY+b7YH51AFipPwxVrXlhlC5y7rnD9MOPB+BMs9qOgdFSjfApeOqj2EmRyml/5DgVXpuk +u1c4yJHalpZ5me7onUmoeFO9FLh+tbXnfNupR/T5gK2rBX1wBxnarvTYwqdYLTSDNxBJNUTZ +Im4u+bMcFUqs/prgfuHHzz/WA4icBBABAgAGBQJW7XbDAAoJEDx6Cw5N+m136jAD/ipOc8cR +o8ML+ae9gwq70MDbWaxoYvHW+nltPq4lmvQ44nIm9diXBDl/qRtnI8tDJqtvpZsMazZ9MHm9 +a9YeEN0L6McoS7/fhASroVkHdPP8P9ClHN33YtDjSReFp8a9CBCeBB8+soiwUF2nhXzb9ENA +fliETjIQGoTfUfN8rHzfiJwEEAECAAYFAlbtdsUACgkQ+QcRfIa4i+lyfwQAqUJVyHWt0aN4 +9h6lX2JYvGYOvmMl1pVD988tEbmz9K0CSQDVm1tR0LJnmTVZP3xmmbUNMYDlEwCbNg8yeFaI +X0/QexrUogrwTHdGKg5GTggzza5d0+cFGISKTwWBoXNu+AcB4GGXXCa5U38RGWuwH7JU8T7a +ZHvJ/rc8yy1+odCInAQQAQIABgUCVu12xwAKCRC5mWrYl5uy1XdvBAC3hoDBx+DMVysJDg2W +eLST0EOgcSOqZz7jUKMkGfQOe3/LPWo4pdx/BlmOhAv9PkeTVL4cnpN4aNRLNjOMe1O8/Nr6 +xzFx0v4fJeg2UHCBLBqUVpI2tOTRbBGnHqZ+XtefqI9d0pnE6B7e1uHnjYXXvsCK88XZIH+E +WQCXDSx5aYicBBABAgAGBQJW7XbJAAoJELnOXWcFiYgrcygD/07YBUVp8+ICfAMV6znZNvbF ++XwV0fiFBWd+D1kCjWfj8hl+sZFkJWCaSvayOFgfIdiU/ETKBstUUW7pI1m5bIPPLGDmInH4 +B7ksA4TrBhKiZGW5WjLQREUS1bkkzAMUs28vkHJzdhvEJmEFhPg69VunO5VuPa6Le3fzgRXk +8rlDiJwEEAECAAYFAlbtdssACgkQfOZlyuZ1Si+CkQP/QNuxPnoBocNOQmunZBsBVbXKrmse +FmFHMq23d2yT10EV5Wl4SLAvjVppw0WGeGKb0Pgnrc07+XpUZMJcz2+A6kv3clb1vXVjKf9K +owe+M4pjCf+oQeI+2WjWDhoHcL1Hchq6lyFWZKrSQcb/h8urOMmZHhqH70uPKhkqi1Y2QBeI +nAQQAQIABgUCVu12zQAKCRDmgBmKH5wU1sWDA/9oqVnu87H6P8U1bIQwLllKpC8c2qfxayt3 +i/grBx6fIVyt1xuzatO4lKR3j7H91OUqPpqhjbuYd5jNBRhETk64V9zb9TOZxUnGidiqieCF +UIani0hzBMZcY0IFcu2SuQ+9ZMSgYO+wbHoy9jo7s3d81QoJgxcOIhTZI5gLt1Gyz4icBBAB +AgAGBQJW7XbPAAoJECLHz1vz5Epvy6AEAMqLxCo5w1BST6NxRfwtr9YDWmKye1G1bzzR5dfu +IataWkl76CEWuI2bSN5Tx+7XwhihbZ4BptkO8mHbYTH+4jR7sIHEY4XnoGnr9zZtiPGfXw22 +kILBAOu0WWkgPiXC+LL6yUkSuPBbf9MSrT6C1kZsXohyHuc+DpMZUGHLTKZNiJwEEAECAAYF +AlbtdtAACgkQSObyLBKE28gKLAQAo39PbObTHLBYo2rGLsSIjFdCh26Ta6HezbsRFKiO5WTm +u9CTq05dkIg1I0eiLXjoCZdcJos5FAyHYLWw+cle9jevU7N5fotog/H2GxyfAFsLRVRLpvLI +UinL5FBmK7tlyzY1jd9kcJdaG3FGdtBNQ7NU2unPYXDQ5OnZogNZM3qInAQQAQIABgUCVu12 +0gAKCRBu2/wDuFZVkm7WA/9ayALxsrhX50r3nMD7qICRTB6DA/BiCT/9lDRd77+Tb6ZUwAOc ++LxritPzvaxQqzKgyLz1+8lVVCNeqHh776rjdN03jpM0TK3L6B1RKW338Tl0Fxvvc4tH2sfw +q+DScL3e0Pa5aHqod5x2lVuBFxjAvjj6DNfYQLD9Smibtn9uPYicBBABAgAGBQJW7XbUAAoJ +EPatBAAYPqm+pr4EAKFVwRXl9R2pidgN7nVBgzveuNixDbkabiDe4zRrSM3wQ6y70kMqSeYj +XkJjhcWOpWwwf9pHy/kybjo5JKen1vGo2HoEgcJLJCrFQFkHf/++YsF04c4i1srLmzOkRe4c +Smvvq5ZUD51ZaCu4WcMIHZRNkVsuINX/CufHZYsm1GaoiJwEEAECAAYFAlbtdtYACgkQpW2G +i1P5r5cF8gP/ScZ4j5r/Vd09Fj5E4qbcy/p/ZeHDDiPYJfL6orb4S4cuYrER35GCVdF5Kl3U +rsSHGA/xJgLeNY3/Gls0W37jqzwbPW9h3fOI5xIxAipI9pTPeNO7jxcXkzM512PHPAOEGOEa +yEn7Ee33MR9McYP940ELRdGSlddorzMNrKUgQdCInAQQAQIABgUCVu122AAKCRBiAejkGzdQ +obCDBACrJ6av23PzYUdM0ctvPCQTnbO9BQWz7Qk45T6T06CLDnMie+srMma8U8LiAPehgZ5Q +XZOv9avkWN4Z7iuum1JKuACsQWOAOwXcoxVQ0E5wp/W4jgBr+t6ndNliTs0pfb7cFSamlD/h +YyF9ipnhf7g8bSuD1x6sVdcrWp7GV1rQPYicBBABAgAGBQJW7XbaAAoJEB+ntdRjnXwYXu4E +AIIuP0j50KOybHoxAoaSbA24Dnc+EyUa8MiGvcnTHnkVf8rniFKARcPE0KBeAwBX9F/XKkg8 +xcaKhlNoF45D3Y4cmGozllRPz3DonKzVKYniUTGVvEDNyh/loM5UGDELy/aGHvQFz+jH49tb +sbBUcNIRV68rN+Su15vhvmLsCcCgiJwEEAECAAYFAlbtdtwACgkQ2UnIZLiFXPUpHAP+LfJ1 +E8EIMVLL1k0Dx9/0wUbMIRwZ89Vc8YbQjl0B0KF6Gs0VJXIGfj4ki4/f7Th1lgvrfkff/1Fx +E4Ovuwa+6WSukcKp4ATwfD4JDCU4iIkfWbmU+T9SfsOVm2tVaH5g2XHE6rHehDBwOx6eV/SU +6e2bmYpdMDve6I6CeCAjeASInAQQAQIABgUCVu123gAKCRCcaip4Q42JOCx2A/41LOmzg8d/ +VnRJCCIvD4bubhCqVZ8r8/OXCUyAVFBYw0cGgrHd8Bnk/wabUk8h/I4T5CrMwJ6mh3nLg9Qm +qr2vKmUVVXLNd+YVk227H0xu8Dnm+5fEjTrR7698fw/3horvsk2SBXRG2b4yMGHlcXjrc1j4 +zddHGBWCjGZq7gwJ0IicBBABAgAGBQJW7XbgAAoJEBt+tw29/nsrTM4D/AloZRchJyMpHOeu +jsyyVm/kKy5mBbmfu5vd5wudYBm7E5Xj+g25IBm2w5SAqrCPG4RbqHLOVlbaRTJ1YUldDEFL +SmMlTJDnpqnZo5OHoiOa6SLv2MdjNhu8zoPt/sRyM2laX68cSZBckzO+j9jhCbiUvTUKZ0Go +61OJIq6RX67FiJwEEAECAAYFAlbtduIACgkQJ/JrcYifOQJjYgP/YECIXGKlyDul0epLy7RZ +N2zEBAgE3WjATShNkaWQBu7bakdNiWoNMC9PszUVtpaKSy5YYf1holQgqElsnaVcjfINM3dz +CjnP6M5jzPsIuiUY16C2BU4kNSluDR5CuDIyhxxdj1Mu6peo3K/4XUiajXcHpIOxLyRdlLeI +LQDNLaeInAQQAQIABgUCVu124wAKCRAXG3VK/UfcdL4gA/91Lb+aCKwRm887Z6MTOX4gnj38 +gkhoBswYg87sGoDW5U31kFEV4O/Lj2gq1FQIyjCvQ9zn3o/z9N5VBDhtLKOsJUhkrkf5LiJH +sIlJ1pu14aRyl2v11wYT4FY96l2CTSwkNCpT1CAcP0u5gNLYNd1LFzJhJFNsE8P/2jiuMYla +2IicBBABAgAGBQJW7XblAAoJECY4xkf+sxdRWBUEAIipkQFnSbfd9u8ish5tbrAmqx1JQbeT +Z02cLQSZLk9c1/T0uHjXy+eLs8oq8CIymUnO5xrypQNXx36OvKz8KwqAXyoT7R9eNcGKRxeu +8YP8MVrDE2MfiZqmI5hEJrmRwNJb6omHuDhmcKbksDWe3n8FROR6bQKvPEmB4IMoZEmMiJwE +EAECAAYFAlbtducACgkQhSRDcmwC54e04wQAtnr1l0+a1AHXVaEJjNT+UoeS9yWYfyuz+tA4 +19Ef6ZdOiV6D0S0dkhq7l1NzNPQRGDzsREinsxewP4ioPTZzC5atkklk4EEFz1s33+SuPoPZ +tpUl69aauc4j16jxP09TejWTOnFcZy8dI8DKxSW7hF42EK1onFCDSLlfOyQsQIWInAQQAQIA +BgUCVu126QAKCRC3Pl14Kmm8dQCKA/9RIOMUwdWNvwUcqv9PuGDIjkZ7d37kYMEFqJ+0ksJj +ktYV59vW9fOJCrbSOl/nrQflbJ6Z7GU5P4v0uh1ZHYBytRqz+9g6lpM7b5+JiXtnf3UYSd/c +QeDD0/VPo1ltcrqEMG/rVtkqleduUqGlErFBumWXARsh87faU48gk9uploicBBABAgAGBQJW +7XbrAAoJEGusfzUN5b5M5RAEANFLghtVTuZ2BQt41odIhQjvpHmYfcH7PnjqLt4qAzICch4R +JEDQiDYuyMnR6f7tnYAag+RPk14SW0zTv4KfXR6tZ7NI3i4HJRWGdp9wta2C6TK4Sz3iTIyc +fF5pevjvIg3icI805uAK034u6MGeOS4C5t8P1itWwEX7XSCOY/cniJwEEAECAAYFAlbtdu0A +CgkQK08pefH4Os3NUAP/S3Q3lAP+Q/qEtyZ1EPYFGM+3WyWBCCigH8iKA0A/bihmfJJi3jlX +KGwhTBjDu0514Pzy0/Y1/4GywOMznZeW+LhpP+ivjvxby6sbg3L2YQMw3UmkVHD7naSzdNII +zKqOdjyNZ9bbTCy3W7ivkyVirjwVKWJ4OyHHAoheXhU9+6iInAQQAQIABgUCVu127gAKCRA3 +HeZvgseYnIecBACQ1OYE31bB5gN5RTHfd4hiOL98Y727oD2K1fX6M0XPzMm5enDu2O6rMksX +7HBwxnPya9WXU3ZpkKCTJkTMUvJIo60hBgDkx3YjKkRUOFNX7DcPd+mZj0o/7OSKGCDdRGfT +7ZgGEb8ViuSq4kKAVM5bbPbrjEpha9G3JeSe9VSn04icBBABAgAGBQJW7XbwAAoJENYGdFbN +HEgYCUoD/iep50UUSV2gM83QF6tKWnnl/s2i58RIVp3S4Y7l6RitS9AfWTbUS5CgoiE8IUCf +ahOWRDfEJHZyL99CnmB4R3TuWQxymWKi0i5jXKL9Muw+DbcoyTpySLNl+ihMcUmISJUCAm53 +Or6bftRRxtK1ZyaPMu976TuMyThN8M95Ttb6iJwEEAECAAYFAlbtdvIACgkQYrV8wBiV6JNT +TgQAqMQxt8YqKGfbPM+0kDldFWEyFTfOSoAwoD/9rhgKUjAkW0RWfhoE2XFgbNs0jCO63mm0 +cMS3+AnM4VsbpqnWS9dQa6e7lnK1pYUSOD9eml7x9JflUVH6WgnXIv1u8s4wsFANiyINCiP0 +e+dDndUC0BJkGtGzNnNBNm1MbqqzZN2InAQQAQIABgUCVu129AAKCRDzZCybVElQ+MpRA/9s +FRa4dEdofCfSH71ZU528p6YM/Er6FYpWHd9ATpJ6vMEeMaiUMmH9FbVCYmU7A8gKYdxSAWlE +FuW+vBUVVeseatac6lBapMapFDEM3ZZysydHfbDhuFSSnA/qRKByhS1886UMkGjiqnZCZq+o +zOFd6ddkYA7T1M1mU3NWFltn3oicBBABAgAGBQJW7Xb2AAoJEF/hbQucyQgla3kD/irm+5IY +TGbmoIf/XZdDZDM39cafNvUwEztpbDfjPeMPD1p51ThjNUal5PdE8fr3eYpcLL0ZP2q4PbLR +j0SHQoilfNK6cP2gUssiAuYG3ciFG0kf/qara+h0sLJuZ4PakWzsijOhmhWZbr0JvwebypXy +qeGkstCFumnrq0c2Fg4GiJwEEAECAAYFAlbtdvgACgkQxQnodnUGr7RB7AP8Cmc4Ob8qYycZ +dbYR1k1xDinJRykR3xrs6dyFvfBDAfqbZpattjMlsFk7V4d0m9DrMWROrjWB4zywJO9LYrb2 +ixJl6s+c4Tx33n7wzm3nU08ZfU16Znmwe8Q8MTmUDKVpAm7x2zMYIVpgok+ISznWO2N0z8/E +w2ESP/L/55fAHEuInAQQAQIABgUCVu12+gAKCRBgmMSMB9JZC/gnBAC0RPnyyoa9+ZN8aQDa +teclcr6lfFVjuUIXrkKz6hzWxaDzf3ZWHFScWzLLu8P3PN0EBWMZJfcvt7I6L5IZu0s082tJ +F+ZgHW+EJP1/MH0CC8cEafTi/uhMIqT1zqkyAvx1fH6mheF/E9qXc2aEdN8l0K5qKTjZDk7S +cnrd3tpBPoicBBABAgAGBQJW7Xb8AAoJEPiDwkVpn837+dAEAJxawrTEnfiC/G3guPhhmKHS +4WK7jtQKLPtzZw55xXkOVDGaiF4m5PpSn+uJ16aADF/FZGgAjbDOrJT09ZFMq2WMcrEZmBVj +3pn1QA4/Y/pUUgMWqD9EhFkIpeIzEmUSeFMdFQ96UjuSKnb0Obpf1rgfarboB1tSUmZ4uYc9 +8c6giJwEEAECAAYFAlbtdv4ACgkQuVG8xLpbDsgPIwP/fnc+iw/fVRbB2ZEkPjS8WVVorgGi +wMnjnNxDGu9yZd1o2UlsfXJ02oIFDj5opgJni91FvrIZUwh2AwuX1gTW6WxzUP2CviicX5kD +ACmRYwuAOXPN9JhnL/U3ilEiGRXZOyaNXgTpkoXjITaB2JICcbGXw6X+rYv2Yjs+UWlqR4+I +nAQQAQIABgUCVu12/wAKCRBJasRmV0cEdLmWBACQbP5CBKsy73gxKEcxVygh9AN+Sjz3Ky6J +/nXp2xH9TXOthOjDHE9kNbeh+N7wiNCcbmhFa0Bi0MCZVZNdrXxS9V/aATWudKQly7xkVz+A +giZm9A1iYSZdXHk+UiuVThRuUvn85ObWXcUdb+p2EnldZcdS3CaY26gunIXvcxCUKoicBBAB +AgAGBQJW7XcBAAoJEJizPHF0op2+HiwD/1NP+am2Uh6DWaKDzCCQaqTwP0CuoeLB0xd8jWs6 +d6EKrLIO3U3c/ZERTTwJoNLb/l7VIsHqL1BX2hoPKnv0NQZ+HQ6PtsVmodoMc5eFEmtZo15W +Gfvv4XENuXSU3VZew1P4cymunb8xQBt3BdljSFuJMUfEKZj9MAOuWA7i8Vx/iJwEEAECAAYF +AlbtdwMACgkQHNgQZB5AXGSF2AQAnBKNv7iyhSrh0fPrdxEXWhLJWS+malC9XD2X3JOnm2Yd +8nQZW6VnPaiaxpFStgdARzuyjjWOp94iL3w+ImNqwz9sdljUXVOtkWSiq1lNw8oH71ndnJz8 +zS3oHn3k4Lvz2zOcySpeeFwK1cZaI3w5zW8qKxjdggfIWMB/OcfHpbKInAQQAQIABgUCVu13 +BQAKCRDSwux9C/OXL583A/9l19F+E6rtX9NY8As1HSHociOcFHPykp8bW13HdJaIfr+W2Vdq +0jkKcKBnJi7ZgtJuib5nY4+k7EVYDFJMJEPVBPbXfyFHmyFSlcSw7c0zavy24RSLuCWw+Usf +vMDSNnLCf3XCWchTiAcixVLpxp1V+ikckxoIQs5Cv+4NKrM2mIicBBABAgAGBQJW7XcHAAoJ +EJiJoXX1nPQNRboEAMvAbrkAXKWqJXzEkSOW1toi+nyv0WvqCu9bsbrDqHDH0FFsYRPwRkqB +1uKrqVqPJN/pRm/FvmwuwaQIhoWMN/FasL/MVAtznfZWxUhVZumQSsGkz7mrVy4omDuhja0f +UYYmki7X+smThOpUl/PcVr8E1eIiRrzA9JoGXQpw6M03iJwEEAECAAYFAlbtdwkACgkQeb9M +DAFCw2AdrAP+NQtq84dnCjFwuW8+6+D9hFmpPHspIz0txY6JlpwQqVeV2qxxFE5huOpaj+bl +Ykk0q6Vb3rGlxcZABfOTJhNEFNavVVjG5ypO2ya+MawmhEkxNnyTg1KD9h/UsFRLM27Nbs45 +qRefACidN6LrNl0fgE+Kd3L5acBVg8QGV+CL1uqInAQQAQIABgUCVu13CwAKCRBkpuoDWVVq +HPBkBAChhMI/YlricaZIXR52NsbEgLuvPSm8tpbtOoLcnUNfr+GQHSVvIbH978gKeO0ePvgE +efBRMTm6671+b5K72UChmpiOuB3ISN9O2AJ+YHFfw9fD15lkypz2atqYSRIG9pXRmqlId3/h +6mD4YK+WAODtqgE7/qFdw12iSu/rIU2CfIicBBABAgAGBQJW7XcNAAoJEEbb4kdmH1S9/rMD +/R1wDvgrEsPUp6uGxDIrptocDdQW0aqP8eOFkpIv+iUvvEeGriLiJJsVgprCs57gcfLh1vKj +TI3YU13MxOzwu+GVrBcGlhlk55i/8Eypz6bYahZBxWQuYfZ/H+ZrMW6pQsj/RBOSJx6/oE2q +/HGIVj49sR8MUJAGE4I9KO2LCQ1viJwEEAECAAYFAlbtdw8ACgkQggXY86iqduD/8AQArfcO +FpyN7VLSQaMCSBpQGZbn29FF+pyIDGNHyY3ZVtcZG8zervu46LoZ98i/K1tUGOf0gIEiQ1xY +u/p5H7QNvs3GiUFAKlkbJ2AiIP7Uez8d3n4ZsItXfsgU3lwQjOAy/jMb0bUPwY0Mh5QaskGx +BUM2fG0cOhzDDV6zicdCm8OInAQQAQIABgUCVu13EQAKCRCeyxBd/iz8QplrBADVIJytrzmg +Di63sQrLBJA9tcVvkBr3QTr/B1rnz0gNFcidyPcmMljoRtFrYLaLo/IxoCq3wqQmyU3th+X1 +VwGFmwTYEXfMIxcSlV0Zk7ztYGvgd3hb6aj4KfZtnn4axRXqy4CkoXZ9PYgvJBQI29uhfCd3 +PI/Tfwv9LkiNZLO84IicBBABAgAGBQJW7XcSAAoJEKp7SA5zwAEWlKgEAJgAHK36q2w7YmiQ +Hi2nmkhxLdVnjx+KzXGtchs87r61YZI4ho0WpQPZgHV+nHo1dvq+qs7y2+6HYgGAF3oeyGsV +Mcck5HWfaOQE7Pj2FWtgWCPhLm+4siCyyCHQYE6N4dpqeZ5c/iBHPgCcXDgFkXAXGQiFyPrn +O411OaoTsOFwiJwEEAECAAYFAlbtdxQACgkQubXHZmk7BHYBiQQA2lZg7o1C5kf5cMThuCTb +aVIMvYSBjSTBj4Ti4GG6FbQPFk7LJt/6RWGOHDZx/tm1ufjTiTmk87/chAXBUR7y09j8dAj9 +rHci9iHuNk+dCvzySaUJVyAJhxAPW+D8Nyo2/yc1G4QubgsG9p2C29rlNqGAM2sdY8dRuQeX +vIhcDyWInAQQAQIABgUCVu13FgAKCRAS9JcPPEuGrEPEA/91rK1uXoJHVAAeh0TNj8ITeoF2 +TB+rUaIAxw4KMyw+sNWobCJLU0NinZN1SyUjX95EvI7kzaNdhUWFmh7CD5DIsbLOJG1jWqlr +nicSiO2XsNczyD12SxbVYUxguG1mK8Ehj0ST86NSKAoBhBsXKV6O/X9Y8MXirPLo2NS+vJfN +74icBBABAgAGBQJW7XcYAAoJEITqzsdPYuqIK1wEAJzwfDvAckHvjmx/3aAwez+NUz3e+9TC +Q8lqsRkWWyLwa2RyZGdLx/CQ3DL4DwtEBlKKwJLxFPuVJcLQKrGq2mN4y5KgPz66TR8ppC47 +tnigTA0Ug1ijZ5cCpPE576Teyz88KtpEsHWK4jQNRnikdz1TYwtiW7ekSHJmbBNSKHuViJwE +EAECAAYFAlbtdxoACgkQTdppr68+7r9lfAQA7Jj6YgW6jl6BjbE+UztchbtwvQDdxSsqXZl8 +Wvr12tI5rHcat7U5lOy/7SCeDnpNH6w7+7I1NVBNCQvVXB6TnBkBnjDVWZsTWCKPA0ZBRLs5 ++sdxCZLtzXA2qLhI97rX8opO8TdhBKnKiwRTLdnN1df0CqCrrNIZ1t7l981BItOInAQQAQIA +BgUCVu13HAAKCRBYOgW2+qUVjtE9A/42WCUOndjpBfvQzrgmY/pfK6IX5A4fKxVQxYH2PZ0C +SAYURWb1Cr4e7Ztqlk5VGa1yo0wIUq1FHU4CzUMZTfzssDuUWngHsacCHKHfM+VNUmUNWYk/ +kyNIGJZNPgBjQNIVj5sNudg2qwVELXKx6igfeNUPNc0wym9Wv510HucfiYicBBABAgAGBQJW +7XceAAoJEHxfTvnz6kPYtjMEAKv/QubcoM1s/YbwbuxR2w8EwWSJ7+ACZ/W41wXOm+zsi5Xp +SYAGU9FDS8vYOGBHcgUEwjMJqGav9f+GBtUUkz2Mz88rsZ1GmuxAY6Mb3L0ccCGXkZvae5uW +uQcEPiqqHopL6NllQ1mPtceO8cKLhQ2RSs/53MdyyD9Aczfsi3X6iJwEEAECAAYFAlbtdyAA +CgkQSOFqeBiO7xUz5wP/cCvAw/bZ3Bo/GVCwgNGjtLQClmqyuFnqohCbeQ2Ck038NmgiUqR3 ++LAtxzFC/KLcolZGzCXAH8ccN4k6PuOSwPx9Kuxof/eaWddpLe7s2Wn9+DF5b2zLRqsNxGVY +WMV38oT4UZplNKw+SDKD+GEiLpwvMYn8UWUxGA6V7f1X4GyInAQQAQIABgUCVu13IgAKCRAV +WQCpYrhl4Yv5BACS/1oOSgj3Pf/IIeozWpg0f8J8mxaBNPCJGDjgpj1wXLfvGkvU1WhnpNjv +LNSfk5cbOT0XnHAzsp7w7y6/Seuqg/3XpUu8DKOG8n+xqgfIZ3hlX2UKlDv40fABYYZOHq95 +EANPhm/MUYy+2EX8FQprci/AG44x+XTGaTr+RIYrO4icBBABAgAGBQJW7XckAAoJEOaIpO2w +emQCHp4EAMdGUbq0YNiBE311ryuoGR9k/RJvnpy+lPHqcfgc5Kko2ocOnYlsjnD/caOGPVw3 +gyivvxf5Kq4dnaUxQGUv12gTkPoNPUbsynkI152d4gPcn8YywvOJF8kyap4P2ycvzbsnkIRJ +zwbSyYsHyJpXfQV1d+fI/q8oFMVSbw327ctxiJwEEAECAAYFAlbtdyYACgkQ9uqbOcM+bKWg +tAP+Nk4VXDh0gwkBeA4531fD68c3UmpPQClxZn7zmqBhmJXzQuMmigb0FjRMpWZU3ERSazCI +aX4nRjidhi8/0NNeHDqSsuQMZb7vOH7Ma/tQKTDoMGsW905qcBu4sHxG0H52Rs8LxzYYdxm2 +aEFiVr0y7oD4HRmW5jFO0f61LiIM5+iInAQQAQIABgUCVu13KAAKCRD9LImQeB+sr5XQA/4q +PsuPurV9SM8ao985IoyM72p+ouR6vs2gXoMDHP/b/aw5qEVow1cv7kE5NrYl7M57kFPtF24A +dzHd+J77IxGGcsZkBfYDHFPEOvuZikGKp3uQFnA3R/qKCypfJD/YpDGYmzwDU0CmOFjgTEV1 +JP+0XXOcoSPn5JhST0fXzo8F64icBBABAgAGBQJW7XcqAAoJEDl54aUrwp21S/UD/3e7BNYS +IDayhH5efitYusmoGD7s2vaV2NlKmLdwasYVuPvkU8rB7v6XeaaDcVn6mcEXDfFGlricQ84z +ImG9jO3NfxzXLqmmQWK3N08I3ZHK729s4SdDhiWcraErkTrcsosqvB7fdW7gb8DvMQTFbaNI +bCLDRmYn5n395I+gWOssiJwEEAECAAYFAlbtdywACgkQvIa9BNOQtr2hwwP/RrjECAsHiYJI +Tj2HwHx7WDw9KZAAK6QonaWyMLPFE3qsOe/h3ChSef0r6bhBir7gY9vPPEJEMYEbzZtv5rMs +MXq43dtFRiHTChr6j5Wm1OJYTQrWrabB7L/SVn4rhArt3L+FwkIpBBnLs0AU8Msb+RE9UsTZ +NQgd5n6WVWQwSqiInAQQAQIABgUCVu13LgAKCRCh5LONpjVrKK/6A/wM3A0VaayJhjaFikmg +/ICVpvNbMacC15634ZuL6SUDVXZKvbpOiAXkfRr3CQ9Y1k2o8hLX6xwnJNVjE6QThTb8ntYP +USXkJjK5bQOtv5d+EkD2Enypvw/e7s2iIyeG/sFRgfm+/oqgpeTb7+s8PmBxjE2f2RMTTmRB +DmWvyHH63YicBBABAgAGBQJW7XcvAAoJEAnbKC2gyBLkw20EAJyGe56+auy6Ru8VmaO4t3XV +b0N8IUHVitOBjqxxA7f2Osz3useEEwbaGmWLkXyJCgpTuHzrV4nUaFQllbN/K02wkHf6upPl ++wdjaEGk0LmDlL3UXqzNTn+SrM02ojwoE+6SXlobQkH9HjAlmXcMRgk990kTsYX/ahdINOg0 +IzaViJwEEAECAAYFAlbtdzIACgkQuvEJJA+leUChSAQApuBhEezVqIBMNkLRJoCNkxL0rZlr +GvtHRBoS2X+MHkki82el7lXlwccR4OKKp9Fe5/wMsecaS8ZY/RoTUTryc15E9yQhU7faZady +KgecsAzDkVcGglIGNEd7c0K4p/00ADlUYmBIzmoPJ+zyMk/vFySWDcmvfR1VHsABi5HPC0OI +nAQQAQIABgUCVu13NAAKCRDLAP/zS2jwYqHhA/0XMgBkRMWet+WMEcCWh3vDZ7VixTLnZQnS +XAtS5gyVhXk23B9aLlnVcKgwpuzG2x4Ex84f9vuiNnsd2zBtMjuhikbC11Gh49/8N/tKbTbd +ihkEoCzdILMFqrFyWpXzOAYljTeN+37qN8VHo+ZmA9l3lkioUmTG8ysQQMxJkv4IXYicBBAB +AgAGBQJW7Xc2AAoJEC4zFRaWRlbbd1QEAKwkJQ007JhwO9K1lKTDLe/su0eLxqQtbannqLfx +j00krEGwfY7K4cNoui7aPoX4YTBcQotG+aLioQU2/WyZSySjzhaiEZLMbcRUr07fjU6juK/v +ojT/+VOoefOPOZp4TONsOXp+mQ05h4pjusEoo397I45C6KI1812XtJ4WfOW0iJwEEAECAAYF +AlbtdzgACgkQMkLL+S9R8DlAyAP+I2mAPhJCpYHI/fBcAsjoEuD1FrI89nr9nIYuD2Es2iaR +DxRWySqqzPKd3sU7gsh73jgQcpOklK7XjuD5BJo56Lp3DON2qlYWsbpgyWF1uql8G7v9ge4Y +/9NuC1I6OcPxYhDgNJTrTy9ymXwCm95FXrpA2yapvaocxDa/Qq8xsBaInAQQAQIABgUCVu13 +OQAKCRCuG6+trL6DMN3AA/9LYMs0I4IgbSqRdbWuJ7BLq0aJFDtgmSs4a18eq1mklfYlVxmM +1wGZ+JEpTZFSkYXQQf8xCgh+e/syuEvKWaRZpTSRk/US8+esi0OlTaOey3WCwIdNdxJkPSEK +7fer5kk51qRNH46YyrmgDwY/JhjC3OVMxa+ufUlK4BPmr7ypFoicBBABAgAGBQJW7Xc7AAoJ +EJFTrcYbkIPOw08D/iwx+DUmsyz/oNY6lV5raxsnREA5o/BTkwD0ogN/EJw3KUVdm+5sohvN +2tlnv4lRZ+DBUZboGJWijIaJFKFgYLLNLtASjtoT2o81ln+dNJ5Vu0Mxdq3owFfrbXYPrSe6 +O+6nH7yYEFUaPodcFxyIy+jFb2XWrkPHNWw+6xjwMrpUiJwEEAECAAYFAlbtdz0ACgkQ9Z7v +gKiBkrPEEgQAthp5dqUC0On9xiryaU4NVhPfU8KOouX6sIWukqQBmwjvTn/CTxqyTrahnOZS +tdo5bMIDKS7g0+4OR0+fq6JAtcxBcsAXQ/t8m+rMh715w0rsMUl+3dA5AugPTenZH+7EVt9t +Q0auTs+4ayeB5iViCozEfbbcJ40iwmYBjJjrCxCInAQQAQIABgUCVu13PwAKCRD1uU2ImJLI +MliWA/41LhcwMIV9qmmRZmUHABxHPsOqKHFH8O4nTqY+D9hlbHpnZrNIawxj5sYhdaG5s35s +3ZshSBbU7ZjU/Z/L6AOr6s62LhliHHsNcaozblccTFkcD9WZFregUklAkacuTmuF926bhAvQ +6RABmV1+tk6CmrHB53zc7wnfbC4obN47M4icBBABAgAGBQJW7XdBAAoJEIQVyUGen56nh8UE +AKkJN1VktOdRYHCLBxAwtBQDulFaa0QbLDblKM6+ig/prQaNR3EXquDp3c8KRPtpaM+6VMDc +BJy4jHbHa0lm68Zq2TNeTRsCks26bFZBzwpDTzYbb8InmeQiC8nChm+GIOa9b6+an4itFbLc +I7lob2SQfzSsJmT699XcHief11dEiJwEEAECAAYFAlbtd0MACgkQSSW3R5o23HkzkQP9GIvx +7xxmNpXV6mzKO/s1/xTKGReTHOsnbiBhPTIaz8kI/k+5Pf2vwDZALlW35IqliX1W8JxdKXNB +WDB457LI/PHZZan+Zp7dVpxRE586yodiYUGjds2Hz6VrPp8cA7b3pGt38lVFAwaiY1MdcAjH +kkJEZH/7DGakOprDgrUxji2InAQQAQIABgUCVu13RQAKCRD+UlUcX+s9KaUHA/9AGyYM1PHT +VMSR8vxI3jZYkzqvXvGhK4lzu6gt6DFt7uyqLkRSKiqu6ukg39IOX2tw3MbKxaMHLgRggOCt +2JNspqdGwnRYjwefoeS0zl6bpTM5iBPAb9QPhgHuT/N+HO8NGJMl4awPJz7K4zH1fsM6Q1Yf +lGgvTOl6k4wK5/UyvYicBBABAgAGBQJW7XdHAAoJEBRYlwk+Mxt0DN4D/3NbYiqm9myZEyT6 +p1Ub8qM6UR7VirA+HbsRre0+bKVWRSr6XDpHi2xxzTuB/ak9hcTuj4EWzBIPlGLROAMeJRQ2 +DsBfaPK5hJ2uJrO+1yLP6c24gUYowWE0uzNUwtNSAC1IAUiiQNvjQVSiyapkYPE6m9uaL9MV +rlJC2Ze0h/1niJwEEAECAAYFAlbtd0kACgkQjq1Mt+UbUU2Y5gQAn6rZRtyzjPswLp1Gp+M+ +UEUDS4LNCGIkP55C00RCjfdYY0dEK+WN29QRwVYmPbp4QH+Kg8jRhSWj0F4jFud3K1KLXbOx +CWXn93be+eqD+c+IakfStfGPZ65CJByIRkggGiargSVurykAxowHLQN5MM6C3abvmA2WWY5X +HdzX4GaInAQQAQIABgUCVu13SwAKCRDU8B76rw2MI/WEA/9IOAt9+qQdbZAPpZexcEz60ZRP +6jPJeMGRVsjKrdb9U9ffx0jNQ1haO5plBfLb2sfvmZkmUSWXp5GwbvZwV/uczILXkV+DRbP4 +pqpZL6pv5gB8T1roTTQtUsI4mYTgkbTeFzQ3AhTD5CeiMr+BhHzqMDF56MKQcB6OZ2c5nXtv +GYicBBABAgAGBQJW7XdNAAoJEKtcWrU8xhL6RYED/Rh2Hw22oGzFyvrDSAklquwOR/8LCxQg +KIjPT0k2YOC29pGSIXyiN3W+bGG9mTl30n2TE/lJi/a0zGnjSjrXsOkoQRfassis91VfiQBX +Pk4ZlQrzI9HGIHMnX/jCiOzE3YW1jH0fS0jeG5YGVTl0wU/HOthUwYBOuIy/pYMZpXt9iJwE +EAECAAYFAlbtd08ACgkQV5Efm4YhSX1JfAP/Yo/ssuPMIawI0KUyk8tBBYG3s2pZbd041CrS +tlRUxZwDp945XbzKwkFggfjT774tgOZzn+PB1Lld7FQ5tKUjFfMdNcgS/rd0y49aVTc/nz8B +Zt0gH810QfHgZ7vtanySP3c3rEDrAmfF7lDOBhy8eshP4i9eqycByqvJEutYvJKInAQQAQIA +BgUCVu13UQAKCRDEtlJ72k0WrqJUA/96YSh/3aUSleiaDCH57jsJ8tQYyMXuFg+4DdrhXJeH +nUGQtSapXqp5KxYeBBgvFUpT89nVCKyK4Jum21NnZJwRiLZs08rKCr8R3gAc3aCJTZvpgpS4 +dDuHWtfoPmRHaREpsI3Mwv0Ezv/cv7Twe6XFX5oYkp3jH6TVAxLnsvgxgIicBBABAgAGBQJW +7XdTAAoJEJSmnp/18FUqbzoD/2x+tq55D2aTEatmrp0IcF7LDwdWVyAVSHv2Dopz6AfLuVz3 +IO8RfaBG63xkwPv/GU6loRhHyy9uny/S/FXRbRFnwVcYcmWgmYvR3YXKOVG3BSWtTwv0Gl8z +s8kwl4ck6gAXnLXwNtPv36C1NUbhCq0XlEHdX5GZhWxhtQUxQPH+iJwEEAECAAYFAlbtd1UA +CgkQ43VJRrNVxQj3zAQAk5G25kemko/Wgb1O82M3FhYaqURAc/O1ns9pUGmfHVHe6ZI1lcTP +tS+h4FGkD0MxDadDrylqN4OWRMUxi7SiA4ijJFJLTzDIHJiNeKBev/5gYAs/SVShwFxprw7a +ED7tZxoW3eRRRKSnPyxJKp0Jtd32w9bPqZtiyAIow9+3U9uInAQQAQIABgUCVu13VwAKCRDD +1LtU1LiU92kFA/9G6QakrRlCbOnD4TeJD4w+uKN+wFiug/C9FRYgma6hWl/H2D+lsK9QTtdw +iD9cIphK0hge5wEpihGC7QQ02rbLT+2bw1q46Wy7PEPUH68uFWpIVp4+I8WbW1iKeUy3Iq/2 +Sv5UHApN1RPW93lohodT2gri8DM06m/UyUaZ5OB8t4icBBABAgAGBQJW7XdZAAoJEMDfLOk6 +2teXC3QD/28ydqaESAsTKrA/Qme5pGjaS3oiMMNq66legFhEwjzLhs+FHPDb6VIldYaw1Hdi +zKKLr+1HHnJ+B7MoLDMyFL3CTvDxJ5MNxJOFG+iOJml6/ynkUEZF/uLsLPf1/Fiif9ZYxYtG +jjIEmLnvI01k6yS5lVPT2sM+sR4TRtnqzH9tiJwEEAECAAYFAlbtd1sACgkQxmhrOsT5viXy +CgP/UgZ1T+rNTNAaI44Ibcc0jBpg0l7D4GE7YUBN1Q5HTFSTeAvNU9vEwFrGsAz5R90+MYCH +TznvbYWv9lKqtPCB4Ix2le9q9RgblAChV1JLvhsEqWzmF8m1NzuOnVZ7C6630NGNP/SmFZe/ +TJNs1us0goviXzAn09cjoNjEKpcJq12InAQQAQIABgUCVu13XQAKCRBtwk3a+pw/aMW/A/9j +4tbNldFjba73f7CW/X9GmunEeJMJ+5qfzmYvSKVt8N5TJJEsYyVWX435VFSzFCViPhTldRHF +lmoWRPnFHMPRbID6wZR46JNS1mz3bR/YM15QrNqxJ9pLDVFdpJqF7W5OSULBTsdSvv1lkp8X +VPvq1afjGFNohYoacGondouumIicBBABAgAGBQJW7XdfAAoJENuZv75tOBecl10D+gI/LZCs +8xtnOpynEg24olzT+4vmHa7CT2M0MWDJtx8WrEAfCLgIlBKPGeWZa2yf6l4LugVmAkrk9DEx +Fs/XrOjqqDGrIEHtL0hAAhZaXmpuNaO9MdrJYbcIXTejymILEXuw3ZxI3ZiTeJYz7pEGqgAx +YQef3kwqMDuuY5UO3vzZiJwEEAECAAYFAlbtd2EACgkQL10NVbfxPoVv5AP+PYM24vZ9PmJl +9KAkx7vuK54fZnNLqB5YLdytVKX+o5AHqmK90W2Y5aIyAR+GSiw/B0SBE3WCYyHrdh70vlR9 +XMhjxr9aYu9vdJLiJgJscjGqKt+ZRSWw9GUFjol9eGdDDevd/0ea0eVU/bqqHHNJquim5dJ3 +RhnQSBcY/dTnzvCInAQQAQIABgUCVu13YwAKCRDNpFx6EXA7SpvjA/9R8ZU+pCmO+UuSPo3v +ZvPbp/NZV4yaiNNIOvquPcM0BbM4OSVcyH8i9nI+ZV34Hawzlox5GDLGnn1ZKEwjRZdTiUu+ +cMCO90x08rFP09mdetP+JJ2DTul1KvRrKiXjn1wJOhIOa9vXqTof3KpbA2u4XeHELhCJyCcK +SFSgHx0KoYicBBABAgAGBQJW7XdlAAoJELelQVSi/PO7PggEAI2O2gXTGzBvWU/NfhGORcao +8bJ1XUnX76D50bzQzZTbo8kq8XAGcMk7cRIBDWxAcTGni5z40zbWsg9aZKU9XzrOR5hVrggd +EvROvnKMGeGJ9JPVqaU0tiqFdArlkiTy7FF4SmgMVbbjhzWOy70A3PcxPRS8Q5bxXeb8EDcR +CnGviJwEEAECAAYFAlbtd2cACgkQ6DZY5xHuPYl4cgP/Xzw+csCGtn7XmyXqyozGOFLrgQNb +TH0jYL7BTaENKsOBui4ISOXYWYt0IeLG30V+S7uFJJYt+Zfe4ZuFvtaaYI1eeN3hAbjEulks +eVSfz8KbC1LQm0hLDJ3sl6mD744zN6R1Krc5g/UQhO0Jp6wuyDrEjnvA2WfwFCtNZJSdtcaI +nAQQAQIABgUCVu13aQAKCRA78581qtlsHVfJA/0UIihBFa3RauG2MpAoxKocLpKPi5IgxOmo +HfdqqEp8lroA6scOdmoum1kYJ+tCe6Y50XC5iC1vVlV9sUmYpxxAyYgUgQI+IeyOxKfyv4Tg +DoU2isswfY5siIbggmraqC8DGAxlXDcRvAWGKocJdeU3dUgejXFyk9H0iwDV0TeBSYicBBAB +AgAGBQJW7XdrAAoJEEeP+yNOt7fbgskD/jLY+g0T6UEgUl2wk4XLBjcEHY1R1wlvhud4m+ni +xjVwbno8yJyUCGscMvaJ+siRZyXroGXeHtTNZ7Ea+ibHP4JEhcjPkuRqIDZcBvWhi7ZlW3zn +uFBG6DhQqpb4i3AftE1bv8cz/osIqIYWt5ABw18hYQU0YfSQrvBnnE/sXiceiJwEEAECAAYF +Albtd20ACgkQXNLoxTvPjTThIwP8Dljh02RpTj2d/Pl1kETrlJs4ycIo5hTc/fm3DLUvlmGi +XMKJ6BjLJX6vyj4dnytDo131dJA4Bug+S78Cye3EglSOFSK5WYaQrut3mCjWl5kToRumQ512 +NV6P9tKQxoICPep6iQhUdfZutyNtKoi0mVa1teM5u8IdXa8C318F/xyInAQQAQIABgUCVu13 +bwAKCRAazzEtMNO5iakvA/40WSgEQvpKMtKaSASckbDqgIEQwtMKmZQUUlUGpYYmZA/BkNod +2E3OhfhSCD1uzRQ1A1dcw4nZZgfuld8t9VpK4u7a0IQplsVZueeKSA122ZI1raFglSlc+tW3 +v9oa9H8JVsx6jbs3mHsEc2GB7OjkhG0i20O6bJa4wJhuXVKX0YicBBABAgAGBQJW7XdxAAoJ +EDvgSJbOT31A+0gD/jNt8m/mZEgKS5HYV4LLYN+inPQyYXc9NBCayUp0NdZLrawx/LbGbprD +ubQnLtN1A8jgGjWhHB2HpQ2m2FNhqlord3B346qT4eSB/m7EzQRA3YbJldbWjKUK/V1SylSE +d9fRnZSInKQcB7tFGPp+NeM6scOd7xN8LcXncFYS6XuliJwEEAECAAYFAlbtd3MACgkQEuMc +uky15TBB/gQAt2byXaixEiyr20hOhgxyuBKfodmcoP/3C5VkiNYBv6jT7VXVeofMaaEfvjTI +dfYMV2jqTSLvauA03FLvGk18WUXiXucbSidxGJxMdFOohhAyFz7hkR7Tlr9dz69fruqDb5rz +N+K7jitWTNCApQt3Scqg4GnVhkNV9d/fM0Kg1+GInAQQAQIABgUCVu13dQAKCRDzkk1n9NZ/ +jqjYA/9hwgSGW5M86P3CZrkcxcBHwBd7GPEmaUVA4b3KtCtBt7jZV3OwNGjEiolPeulI+wCH +MYGJlysJim59pjPrOeT4SD9B7K5PSETcwGAk7Duza3CshhnVgCYn3Y7XCVfG+nXmu3kHs6wD +cld9RUYdWLmpkAYUOtAowLoGry+j/PajGYicBBABAgAGBQJW7Xd3AAoJEEyOZdkTmaNkhnsE +ALwUl10cm1ZOY+sFhZnH7diWYgezIT5uXTVrLWLIAZV/OuvYpDd/aRHoXzjm161b6j2g5CVg +FaJESUNxtH5KuAl5lhO1Qq4pImnccABMY+YqEzLToEsoyqCU3FE4a8z6Qx1MKUSdGWhdOiqf +JVy72Zlu9zoM/2nCRF6Wv6YwQAT1iJwEEAECAAYFAlbtd3kACgkQacdY8PEn7GDL3AP+LYx+ +HPkbTYGv8bIx8HYqx2N/ILJ/6L6hkMmPKXOUBfbCfVeQ5z+UIS18QtKvs3l6/zYS+yCDWLC5 +3NynnH6F9Vs8rz8aJ61i2Rj5yuy1TSASIC5QsCr5ziPZvmhUki/d465hYVKr/R4LYeeT/E32 +Ul11ln00AFc4B2w8272f++uInAQQAQIABgUCVu13ewAKCRAU31FALXBQkOOsA/9yIjuEA4JO +58nRXntdU4vg0DQfo8kEarc1JBB8old5qv81kfeP+j4sT4budml7Pz+e8KxCDE8nvOYxGT+p +tLdWfWrhd1+EkkrZx/xRa0mtm9Pd70XLHf+gtbza4z73n+PrRFPQsbThkxPuk6QgK69lCYNh +VWbLFGJME+VV5xHWQYicBBABAgAGBQJW7Xd9AAoJECeIQXrvEW/NVdkD/j28Z9BkcUPMB8NL +J3XUJJJzQ4i6weJ7MiRRXFAX48cUEIPVjxq4ENzitUp7NVFZpv1ouOCIiVyo4h00jx7lL1wl +ie2xum+gI8dMpwVQGD20xJCU910VLDzTF15GrLOsZ+EMUHCMhFyvY9OIKIIitBD4iBRHqfFJ +23eYGnhxgUs8iJwEEAECAAYFAlbtd38ACgkQs45tcR/CoigG0wP+NWm0q+tzMJ/Jm7a6Xp9U +3WHmaRqGEyRwj737urIBYSmM6zINtMS2bHRe/rBFWWhia8RLQPZRY3mmJEM9rVTwHJXYV4Dl +xgTfPY1233ROhxhAownHK/bIG6cn3Mpc+eX3VJwdpKLNHepxDuX4dqlChZA8Bq6tgnm5lEPC +2VAXx++InAQQAQIABgUCVu13gQAKCRDlfq6FsCID3V6gBACKJFI0oGTDlcTgqCHpRQcd+KqO +U21Cy/9kcfXQNSjweCN+edZbDdr3c5rRxthrqTBB7ptcllMc8YIJFnW1fewLOJql2AxyiIdl +AAkTnp+B0TzymThU/Z8A1GiPni3+V6sGRf8vF2muVPJxTmc2iKXjNdXf922glgynqtR/er3m +k4icBBABAgAGBQJW7XeDAAoJEDDMNhXnPDpJ91YD/Rw4gGIBpYGSvYoMHkh0ty5ilI8wXji3 +4N6Us1Ne703Na9oL9a+8i9LcU4PjkQYmsSoQn5erTFTioFqD0XsdA5LNUUKSa1yyZ2+z9fKP +7LbZhki1VIyUeyMSe1ETqh7ECARjDcBv6SdCU6dia2uq7gxjKqdaGnUADGaKjN/lkDFSiJwE +EAECAAYFAlbtd4UACgkQ+rimOtOhxTkv2QP/VFaGDRW2/NTQIudF1rvEGTDFe5HSkuZ6oUqp +DRcU8odq2Z0IH8HKijbJM7eGBVziB/i9KkaJuliKhKoZx1mLBxNfTCxb2Xs0Yg0Xt47LSQcV +OLKXecO8a6MHezs6Mhmu7v2+/kgs+JPUEJpP561DY3lRK/a1XSl8SdxPed3NTdGInAQQAQIA +BgUCVu13hwAKCRDssEKIdZEsSlSNA/9aTSNJH+r6QCIvhZM2K5ICcplF74QTZZwVq1znIQwg +dvjJIiOa02VwbmL7KrB9L8XFfSKjswp1hMnhSndZwMN25uIjkomIWG07SNOiJgq4fgDuiZUF +bt0x5GCobMZXeDTNhEzXw3uiZBynCp/4A9+9nchNzGrqq5kF/ILbckorsYicBBABAgAGBQJW +7XeJAAoJECVauwOCwDZUqtYD/1LPEpjPzFwIMxEioYtGipQAeWaAYBurM1V+X4rNvjx+BR9N +BFUuvAVBsd2KOr9KOrMysIFj2HpabBK3YfWYnzeR6iK4b3+LTUZqH24iSqJysgIQLs2ZF2Yi +Gva/X2QqJbtrR9Iy4783yo9r0Ysm6DqoT+QHLiaIYPiJEPZbKPi+iJwEEAECAAYFAlbtd4sA +CgkQzrwUsNNXlpnxOQP9Eh+XTLZ6QIVvwtvCO+0bouzqWxGniQVpvm5x/JgCbeZSmgtQkzSO +Pt7VpOKS21k1UUuyWjn03TzHq6GnglzedcNkOnzepCFm8C0v2WAc4FluYOCuCcU1vxyCTftp +/OgEi38yWbocqSler1w0LqzwdYGJtAkBYCM6gE1P4WLdHsSInAQQAQIABgUCVu13jQAKCRAH +bM9LMxeRW0WZBADAYAuYh8nf2BHqMq+6iIwsOV1hNffJUMjZHJvn7A04sHp0KiW0Af2rvAni +H39lHyvFb+oCsnSNv/YQOWw9by6WCpMWM+J/WmEhjB3f2oA7QIU3yzyjq2gljzEtMk6pW/XT +Ep3NrepVdjaabTpGt3GO/vYnb9uiJG3q8AsRiMLz1IicBBABAgAGBQJW7XePAAoJECOWTmLP +TdeAysIEALGT2ZsTvul0/EzVWGxIisOqOpxaks+vMm1uED8OJ2ABY7oyATjFC6uzOQuAn5eD ++VEc3CxMJSekP8wddStJQW0VzGlu2ZDhqIws9evIgYh7l2cEsMxdNPoVOyNLQcLRl9l3KqyF +NYsxVZHWuHTh/Arxi2N49cbPwmXJET9ee+ehiJwEEAECAAYFAlbtd5EACgkQbv5qmke9FVi4 +dAQAo8e1bk2Di9tWlb+VBr/PdR+QIRvk13mPpYjZd29QstgzJxdS/v5KpIPNe5gSIu65l6ac +7LUneVvQ+UyuTnQw/uxoVTtGQNOLpQVLGV537zkAir4yyM3ucvzxuYhvH5wX5CZLtotOZUC0 +/ww3UtbO3og3CSwqhRzUlFAmNsawO5qInAQQAQIABgUCVu13kwAKCRBK5yoQ/n+BXe7nA/4x +gE1xHGG/Qr9d/QBJF3dSGzhjSkvKkw9Dv6j11EBTZ979Dnfsn0RM4trnemsE3lignIdna8/j +nhmVnID9bJZIzCIM9WjwQ99u4wT4uBBSr1Ykkr30qVIyf3g/r+oaCruVJ8Ne7t/r9JBDXFg8 +ewrovCpMyRsarqxu67D43lwBsYicBBABAgAGBQJW7XeVAAoJELSnEKctSrpB2PwEALHXut2V +YG144AN/fpaVPWedyp05S4sEJ2vPsWgPg5xetM3tyVRpN9PJj1gNmEsQhBkumCPV07QPlePG +GfZAdy+wvBZ79HII7UZHcI7mL9Ju3dL/9deyZ3FJ6N0chONEp0yox+zl6FsuitFp5Y8k6csT +mRvnuxArTVY95x8jcGwtiJwEEAECAAYFAlbtd5cACgkQPtTSp2o/u+LYRgP/SUzVAZtR/9XC +bmShCT16bzI6pPih84PnkgQRNTK2PaFBEfa0kAI44auhqhuKo/EQBFZRDN/SK4L2CFi1yCzE +bwz8I5WCqXxn4jXXmMAYLpgiomAsT1yBYXTg8TRNGSQBWkrS/HvY9m4isNXXKrICaTcY42B7 +Q11ePNRsjKpG6/OInAQQAQIABgUCVu13mQAKCRDlp/BDfl03bFyJBACc1VNAcsm6UCL6gyIQ +Xwte89m/9K1xfCA+3q1vOB09SreDmU+E6TgFg8YDu9/Rj7ZwZgEo86Pfic2B6zrpfa+aKUlz +WhMYpuvesBcKVx8McRUftC/Ekyt9Ok+A2S2VQ4w0k2+wzrmdKEBev5MgtU3QrQ6yGywE8KVg +ZR0vaUjE4IicBBABAgAGBQJW7XebAAoJENpLE8Sc6+Co090D/j2MbGiO5gVNt6sIH9jJIpf5 +0nblbyvABFSgjQc5rvsUSdV5h856k+NWrVz9ds/QIH7qjj0WcqQoJwfDkDnoYiXRQvFcSb+F +eIGeLoedi+oFu3VreW8Zrqyn8BpzO8CJUXfAuzlmYSx0J0vuDUbWqdg234f4MQsZbtTbH6Fo +c94iiJwEEAECAAYFAlbtd50ACgkQCB76RVis7RZ91QP/aEiz/8HDvfSgts/DE88O+69VuGNh +XliHhdkL3Y5dQ29M9dI8qCvjPRL5TFvLnKriFgwr+TYmUBUjnMYYG9kL0AehJKH3v/YVeNju +kIcsFNwE+b+EiA9v3f2l8IcQgn7c/DuZKdNqDeQRbGrz5NngrEjIhhKwh+3RnMiMv/Zi0puI +nAQQAQIABgUCVu13nwAKCRBe9fTowMNqUmnGBACL0TrYRthf+nPB4x9se5XMOsxlHemyhCjR +9TxL8rXXy09mrUaUHwcNvZysISIS4KUhp5X3USCy52px+hsO+Uzz3C+GxV/0WuFciWWhCVEY +XpwlZyoTn1cbVEg+7pGl1Evfqy6oHeB7xyLFQxWVn9NlwDzs6xLC5ZB6ENZudnm0vYicBBAB +AgAGBQJW7XeiAAoJEGKcH0YDjsVPpbEEAKuvFcaMQUnnB+Sn+V6gkPiOxv4d583HYvTDmWCI +wBMAcF2rizVRFa4V/kPiwrmGpRU5uRifb8pYKjN/df5AMPQRMsqluU9EXaqyJsZZ/BGWrs71 +xadctpTaaTIvrfV54bd5vryR0rbAsEbh8sOFP0/5ZQXpGuYpP6WEkHn50mmiiJwEEAECAAYF +Albtd6MACgkQcMKNtIzdBnq6mAP7Bd9rU+o4WkVhHAwcxhufF/14+xNUgILXbPcEbnPefUmK +qoAFEwcxlY9QtAyOuxrP5jZ6SqWq1idiIKm21A/jA3DNqpqGoH65qrSNMdXFXgHvMVAb2/kt +DeNouDG1/F6e1i2C2L6LMFS1rF0EhDQF17ORs9+W+FWG4eOaUKE93m2InAQQAQIABgUCVu13 +pgAKCRDZ6U+jJdbDwrjGA/4/1MYs7oQWx3StZXl/sya74pQCrqlmeMRC74eJdtP0cF/aH3MD +eLZeA6esPpr/Cu+23B23dbJevi/Eg4BSD8WPUCGz07P8xZjYYxgNs//l6nLSnRs8j4sbE9px +QWcsMLIZ26y42szDKm74WWTl95Qb0XtsFsR8c0gf/VMmHdrKYoicBBABAgAGBQJW7XeoAAoJ +EKp6OA6whXX0Fy8D/0tFaYBAG6qhVSrQAkxW7e9C0YLzfMCYaLcNeBHtyiNy5/bALoju5B+F +Mh6uOnHr7g3xX1haQdsa8Pvu3x3uNiJo+9HYbWTA3/k7a96uFGQmpMmOr0LtXFzZ0HGEPNeE +rGXca2H6GAlxPcaF/4Rf4sTcXYDG+0pjRF85daYd3Ro4iJwEEAECAAYFAlbtd6oACgkQ5pnQ +L0JdFjF/DAP+JErCj71G2D0pIPZ1dAxfXpA6E1rcJX7eZ1H5WatWVnb2cyqHds9oKKmKCLOg +9uzO52ypSpLn5eZpfk8ry0sbw1uVftWH28pNR2XqxBX+HJVF30Tyv7w1Ov93LBaIl9xIKBCu +c0OkC3t6ya26ZPhjMbE7vfqn46sU729/10riOVqInAQQAQIABgUCVu13qwAKCRBIm8yBbUWQ +dizRA/9gmIZdCDKekh/kGnkVytKm1oEpljpE3VXRfUT1OdHSGOI0ex0ZeOpdaE1rro+17Weq +ODt6VMHd4st41F1qItyrRODdEGqw7Ed+a5SXbCDLG2tfKYknx2DdfQeCnyHpLSP5Cd1qbUB1 +4STeYPknGzobjwUqba2bun1tZLr7Hpl8iYicBBABAgAGBQJW7XeuAAoJEOJXCrQ//+NLJQoD +/jJcsA5MoABLBu6W0E8pKK5N1tVwhBShRwXZLI4ZGCP7X/LI+ytIbghZXoa2aXG6GIRNngfN +M3PE1OPPJAvjnBm8ItpuSzRs+6ZYLjW2KEE65CZu02Nkhqva9H/6K0xcoMRHdu7blnP3fD3a +9Zz6NUL33YL6iZCElFwAZdEQacH3iJwEEAECAAYFAlbtd7AACgkQskhePjCx0s+qiAQAsDOS +LbKKx9LZHFbu3rD0DzjICpqn1CWu8cSXFRQ8Q3zScyxEtf/+UGwaU9s1mMLYkpL0dkmwSepg +MPL1iguMlkvykG6/HhcCGOhUPHettvM2aTUPq3WUEnbVD66+dIHLptcrc2ctUqNS/6EqVtOO +w09Uc316eqgoyeADryyKjQGInAQQAQIABgUCVu13sgAKCRASMNbvm/QhRn+CA/0U+rI9oI89 +pIw3s8GBNAENv++uM8fN3CfRmeeuwNV0KumPh8fMIdimzh1Y9xEiOFaqEwZ/jHkYSSF4XTls +Wj0x+0jdavGQ6rDiRjIYNppB/HbGYr/11+uPvN1MqkQ2WwZPe2iSRv+cNxOyAA2ypghwt7nA +bLGP2LyPM8/mexgmG4icBBABAgAGBQJW7Xe0AAoJEITKljDqjzTEiiED/iADt6jgp8XQS3bQ +7TTw5NgLOat7uZ/5MFEMTDc+LgVPCH3CVe1XRhdo6S5uUMbqW3PzSJDXe5mSsCyb342GTQw8 ++4yCznJuB+1a9w/JrR4joCfmMsNf2u9tl6iGmrn1J0O3ZnztfYo0kGpPrOGUasorePkz2eAM +4NYUx8xS/lYCiJwEEAECAAYFAlbtd7YACgkQ4grrXFhfWHxCIAQAiRnkQCKdFEFALuE5/anO +V6nbYkeNJmrOKkze+Nj+/Dj8YMAy0FxuLe033tnbRjYGTFA28zY6hJ6jkZF6AitoZ4bkp9OV +9TsRNftaHGXNIY4+aSH5cLz6kgMxJ13Gts7RBQ+YX27aFEtLPhhV2ye/sPS61xFZSyDFfumv ++LynZDGInAQQAQIABgUCVu13uAAKCRC0NstmuWihTUJxA/4hdksGx5LiDR2JHEqlIO6mcKUl +Uq9xxNNI2tnym11qeTY4p54uTtIC+a4Eo2I0jyG0OTkjjxh1RfGBhXc8eK9rnxg3euA/Uvh8 +N3Mo8KWKogOymvaYsaVsAhuKo+1C1jP0a4Way+5wuJPuH/VMxsH5YoweQf600LLOWwqmqkbr +74icBBABAgAGBQJW7Xe6AAoJEPsxFlj6W7hf1R4D/j0FNDbHLR57MeV+7mzqu3abMBJszypK +a3MN0IYYs2Akq5xM4/rlb5MeUkDAlwno39ov5962ZuXUatqHu4AKURsrtz2ENN+nH5IHDjqW +4AIJaLH2p2vDM2WxSujTQqz7W6czw/gIic8rrBy4SqNVuiwi9Jgr41jC4N0PGgScQRr+iJwE +EAECAAYFAlbtd7wACgkQAzYIcj9svzAUvAP/Ui5w/tmNPUMx1Zs+gP3MPEBKfu1LphLk2/cD +GfqkOTE4rWENoANGDFd5K+JqJj3Sdv/SI3dM2z527g/SSqG3fMpDyhf6R8XTxkMeM5pgE+HD +itjxdnjxOWOAQxQEyLxfTtC1Ns0TXtV56ar4Db1NZ05Ufu9cSosytGYaJGJsQvCInAQQAQIA +BgUCVu13vgAKCRDCP1HTBf+mxIVKBACwXCxe9WaKJWRJBmj1kxq/6h5TPvO8OUalIBejukrU +sMq1aWLi5U2waIjuk4lkrVLgv6WtjTSVuNIHuHc1MGYiO2SQjTXxWUZRdNaSPnxSTZwZ3rnU +vr+KEoG7rnwjHJnBYmCrVvlVEv0OTHihpoOaEKWL/Hj9AGk+VOwaMziJVIicBBABAgAGBQJW +7XfAAAoJELbdm1BXlSVSwngD/3EATcCNasFpdFuRuq4p2/gKLZnamH1EvHy7vumuP5kbNTUS +APE+cCsFk4rvk+uCIAl8F5eXEaJISVD9ZBfM8pn5cLVFTS7ZLo3uk8NsilLDQ2I/SE/3GTDR +SLLEIcSWzjHNuRX/9UgcqO+n0UeoOeATIyL29QkUYgCVID97bVnPiJwEEAECAAYFAlbtd8IA +CgkQi5tEvF2gEk2eNAP/R/xMFakUQvS2UM/jTBVrKOzOr6LjjKtEy4KpE3lNwel2DY+j3/fG +6zeXV7v2UYwYGsPnmDmHeTgyD26QDjiGkMuiP/fYrZUfur8NqXNOE7XZP3AtcDw+dsdolUA5 +9YaQdz6inmxsuuS0zPWYUNYCAIM8nUfPQqxRStWtC+0+Ma+InAQQAQIABgUCVu13xAAKCRDi +4nLJr6FYo8luA/0WuRpu8odGBZiIVetydHHO81VpqNv0WGatzGsn3rLkL20jiCa1xhwN2N0I +IiU6Jglp9rA3O2kFbeI8mNLo1HKk4dVIeHQ6yAuwRVZ6VihIyfSgYD0RuJQMNblcNr4viNwL +g/0B+mEz4iNZxjRw/TgfagEnE7hmHdnYFqonPANNYYicBBABAgAGBQJW7XfGAAoJEOYz6osY +j1xST+MD/0eqq7pAe3XO++sqaFaRUWySUefwR/1OgNe4r/rHeRk06fLBMKfHCw5MguSrrhdd +YNiO3ugcfiw3nNim6Yy133wsZOPMoZ3Urd4jix/knFiAITuym2KTis2r7uB7P4bYfZSKUu59 +erQ75/2yie9BDKqE3ed+FyPXrGVEO6OOecfviJwEEAECAAYFAlbtd8kACgkQ7Xn8AlHjbl/W +sAP/ePKtrYNtHDghX+yIPadDedScVye7olRSts/jkdC0mjltpWOdN4Gbd5EsF7ZFrZZnAL7M +OPOveZl2Y469Lx8ms7uIGEBr0kgjKOBnZQRGialHkKZ6Q5NT8pK6TKyC2VngAfRwh53AKwgp +muavyihzOtIEsw67keSxvcKxFBuZW92InAQQAQIABgUCVu13ywAKCRBiVRqfuGzXQz/kA/wL +EDkD/grlLJCrpQ3DS7llVHRcTtTF5+a+OkepMk4HIqrZmUXOPmKL0OP5FPuIaZb6SYD66hb7 +mHF1XCbk6l5xQ/bC5oiXR+uEbCMvrXcTDL7J4zb3bMJLP8dfuVD9DA4jKPMs396SrYvevAHO +zEHlSVOhY1a9Wkn+BIqx/dvbnYicBBABAgAGBQJW7XfNAAoJEAVBrzyYktKr4vAEAKVDH+TN +By9DKMycI4ZYTtfMvwNjNTWlqHwM+KMaZ9rPp5xBbnvn3V/nEgqj330QLGTwcJ2iwrXy4c1i +qfSIgQRSEY25wqG+Goo5yX+J0rwwNjRjG4NZDQzqYLEsXjWSrJLrwIG30j8C4nvRgQk/LgpO +lpG3UNmuWeQ8I87pbu/SiJwEEAECAAYFAlbtd88ACgkQN0qNFOeDQps1RwP+LJ76kTxzAfi6 +puIiSKR6dCrui7sQ2V//SrQR4V2laQu6jYhpJt2oCXrgJzZJcZYJBhFlOvI2Qkaq6+B6uKUA +blKdj0LgFFXrAX3knpxVbWLQ93jolcmZE/CMvINkY6kJf0POc0KdoQXdVT0c/c/6CQwz+m+e +wC+4YMNSdiSPRG6InAQQAQIABgUCVu130QAKCRDgdwNFg6tsc5WCA/wKU5RPoSiSjmzDDEU7 +AO3dbwKY+8jLrTTf+Z8QdXPgCCKPY0XrSHCipwdTbVd6rlCxIZ7mONPARwQKj7HOnRW9BfYH +KbzYKH/nUK9mQ70JMMwb97HM+wIQan0sqDfUtEK4TYaH8PnedH7AvqYcxXu/a3cGcmuO3m/F +VPUL0bFsaYicBBABAgAGBQJW7XfTAAoJEPSIR8edsPKcruUD/23mbsQC80ptn+Wm9YVKvGrN +AoVJmnxAhDD7RX/cMdvnMADlEBrsVqgwxPRfY0jWfxbcXgwgvBsvPiesL7W0Hfu4WYSJnmRt +eT1lwAm4fdosm3YkHQ3WsbxGR9Xf2Jji3yZeKsq/ZuWvf8Lw01GmCyYed+SGkg3LJSwLUJdj +1QYxiJwEEAECAAYFAlbtd9UACgkQNncBdLUClI80fQP9FoN9ujIBV8MnkDd8hI5MBvjGaN4z +X5zOegpXo0M6kN2HPdlLw6ult1hmWAntBrZIQAanv/u9Grf1AQQf6VrxLl659Ep0697QJshA +4jKdiwuiD3cjDZZuKAm0Cm8F9Fu/x+f5shvS1ci3KIwuJVmg2XO6KgaOj3Sd1s5UPO29xjCI +nAQQAQIABgUCVu131wAKCRATJYEymH9lxPp6A/0VnjrdEZw/+ObuMX+pFIH7+CSJGi9XbHYT +bojQ5FQ/sYByX/9t8QYgHXv1aH8eKe90iCjkmI03Kic0bQIUfqr25Ic1utEBEv6mXgMEMXLR +joOyOGTm0Anb2aOCXZcVe1Mko7qazYZ3MH7JBYz+E+DwvxefBh5la4HzPBtqjO8uFYicBBAB +AgAGBQJW7XfZAAoJEDmgJno13DKOyvcEALMYKYAWmG9/b2AQ81PoRAILqv9XnBU/uxel3S9W +NXfAoZ45OIij3phF9z3kjbvtSj3FzptCNjr0jdAizvCIr1Nd+IRwFLrGiF5gplyCB63wWWSV +Ti/PQYH1mgTrpSmDOTfbuDjznpGhV+hwiFycOeM3h0ox+iht6xkFHTxsLZ1yiJwEEAECAAYF +Albtd9sACgkQ7lRmm8ekTtg0sAQAmdlDNMvjqGOXsVuvAOrmSc39sr/TRh/r6MHpDy0UUhAm +JIPWWaxWsZirMkMu0FpyyrHisSc59Fcrku2fzWxRQ+PAvsXeBe8/6Qa2GNnZTI3VaTFZ4qtQ +oxp299qFi52pavpsKXNht1wMxwHt9ttzlsvi0zxZ+0bKX0sP2AXnoryInAQQAQIABgUCVu13 +3gAKCRDE/MkbZk2TuwK5A/wNjDS5KCyepRz/LAsOnhamY30dP5elCMsTDpZfjJIUvxk+DWh+ +A8Lv0YC5KFVik7Tbae+DsQDZSykrfPFm0Gw6vrqZzTvcWoG/1zyob8V2FrT4LlI6sMFISsfT +sl0zHsvPD0gKt5fQpImqssT7Ekl3XittGudyoN6K4cHa8wpWOYicBBABAgAGBQJW7XfgAAoJ +ENt7dubESsKuzxYEAKfug4fmjLMuHqbEB2tYeh1/DVZshACzgAcoYHCNN7INInKp+hqMaazn +tviNsmgdb0q2LYxdytk8hWkWpNvG8AGX36/rlOo+XbbQTwuSHALxj6Ni/uibgdwkpNbKFNq0 +/2nH3m7YDmBi9kaBs8eavWOW8FpZnIFXDC3uJu5XDW43iJwEEAECAAYFAlbtd+IACgkQwTuz +W0j1kmlgvQP+OBa7Oap8EJS88j1RJE+8mTu5Hm9waccy/4XFz91YE5koYlXW1O5lWphEpFvM +neY8rtFGZpDWBJTmOmgkwlNzjZM7u+hcDjYUSpw9V83IN+3/rcqiHKsfLBhrPaHLvDkrfaJG +dcTUlcY5+SlK7//W41IYaMgb1xP4nloyY9o6O4GInAQQAQIABgUCVu135AAKCRCC735aobca +b3/ZA/sFN2ZShbsf7Kd1rvFgS/beixEZCW3q5gqhyuvQYxbusp3I9fO7eCpj2cb9UrtYDL4W +uRp6BVP6HdnFPMG2YIEFeDSMdrZlFQmhdoXLQKLfYReBwF8tZ7GeC2xbKk//gU3WAVDbEFIb +87GX+aL56Z+rSrnYfA6bNXL1XXmQEjkHIYicBBABAgAGBQJW7XfmAAoJEEPtmRiF5osgSg8E +AJPVcfjnH57DeVi/1EVEDe5xnT3VsCwp9KNMLzEv5IVAJP773G+a5oG82TjnCTBCHMmf0ToD +IwlGPGaJHUmTgzGuWUUJe/faL+EmPEDiZFSLD2KkQ05OtwDryYsVIbQMr1RL3q17xDoMjDu4 +a4FS6zitgTgXauJypQdWRORe/RkoiJwEEAECAAYFAlbtd+gACgkQE8EeIHx0d6kErQP+MOIG +AGOAcyTqODvO3TMlEusGa79eGRCvWisXmNK29GqkkNvwZ9ngvyA0fDrMUWt2auWsRHWpRqxe +E56KibYVnfAKebIKexst1VtiC56c9tj9T0+T3dv9HLtg4XIjf8+W1JoRv0mLR4ffiqwygm6q +Irv8154qpQ77bu7ylbqEnneInAQQAQIABgUCVu136gAKCRCWcsU+yK4CObGoA/46hA81b82h +w3nK9Ddl/sdZgZiDpOXJ470opfFNnrPV+B3rqKL3J0ui+cIsOtPinPIyPJ3V4iC6R2RhUiey +aKY3nR++C9EG2A1GiLOtLQL1RKhWCk/o+OQAwoOEF5BOaZbdEc9MwiuCFB6QKYpXumaxBEyM +GmFh1dDTnChN4h1NH4icBBABAgAGBQJW7XfsAAoJEMQs15/NiYKPZ5MD/iBBBkVg8ZjLm8Bm +N34fyKROdY1HVnPA/juIQAhg7LvqbNrggEHSFRfMAqTACE/ww1g9c9V5POlhEEUa9msprHdV ++2mBIvUKerwR1IKO1tp+gBV9UKwvpVYirSIOoQx0z2SzLu7qauzbtxtTIjnQyE1lNobNvbSw +X9o1Ic7U5USciJwEEAECAAYFAlbtd+4ACgkQJG82nVCdbtnKVwQAueDC1if8GKBVR5ROKIDW +NBxqo0WkxQFKOAbcfmQY+IOjiYSyzmUQ4z3dkkDQ9MfzB1OMUnXRkpjkQVwKQp08tyaz74or +iAhRS7cRd5dmqid1WnxB/r+906IwaGcttsjtTsDqIlPzVr3lHgciPZtITIvfQMIix+Fme8A5 +ivIWIjmInAQQAQIABgUCVu138QAKCRCLDHciN2IvGB9IA/wMWYqlwtTUL/k1RMgtlF4YPrPH +A4phqhAPfHqScx8aBS7l69WVJUc23GQNAaISaX26N9CZ7CO3iix4C3UqvFDT64VyO07WLZ7M +Cny4PP0p23xtAv5x9yd8HWsOhF2D5wrtAGx2iGCVLiiTrkSus89qf5+VfbPGWorOgNwYeUeM +3YicBBABAgAGBQJW7XfzAAoJEAX2TGTCrEj89pcEAJ7kBdJkF5im8YOqBHE+/X9I1I6+ApTf +PPBhY1Df1f/So9BT7jdCwQWoPzPiaTt2iDRblz1jB34oH0ohiJzjfmQgKVdAeIXSUuBBvz3f +LtRd0tdXBWre2Gs9hmwowYGlBhQi3L06cPa8krPiGbqQiegb8y5krHikcViv1ZlDqtXViJwE +EAECAAYFAlbtd/UACgkQ3BIsoEMTU/yR3wP/U78i+eG/EaKMc76NiYq0Adaey3NjIa5R3Z3w +XKN2gegwQeq/29H8eozJjMmx1FnvQDkC6KkUzVixnKLozRCxgLbythX2A9kKM+a6Y8Hwo7EU +wts4ZGJ5ZCR6g7wobcRFlgrZwsAFqv+mxKxOZI7toAkDnyP8e+t5F2ucg7ePJoeInAQQAQIA +BgUCVu139wAKCRA8/6HyvfNRh7SIA/4tUsqMC/jHrersO0AuLFjAIvd19sp//BWozhIuhLj9 +66KZ1VqXvNX+IXgA+szLSFXpTxBhFcAClV5F7cnvK8ZSrBBvMfvPWIjHFr4frsyVzAOT5B2c +AZyZSFD8HRgP5u4z5myiVFYU2zEn0hcKPJiPolPITRzTrXzIKVbwIpAtLYicBBABAgAGBQJW +7Xf6AAoJELFcVml5jVyUje4D/R3pMfjnRyRN2VbfdxMYrrxrAa2rIpHK4yVlp7P4hovrAH1P +Crorf1AA5wl4+pRXzXtnyYi4xlrxya/X3PtoriWU9zMe89APwn4YuyYfAcfass6PMiAMEM8y +FMp2Pr2oF4cTG1xzaAH4aJOZbkaq9qejv0mBxo/9RmvQMx4EPuRhiJwEEAECAAYFAlbtd/wA +CgkQOFtpzkCNkhXcOgP+NyNXDDPthMXOM4xAFZIiDVFYSmJr1QaymmoRr4oAlnP+E/mrkpOs +A4wL0xWhWizqgma/viQ4dBZzxXfrTY2tbLFVnof4HYH0zWjuSYtrBavfnUWRHZ//01pRS5rS +qShpCFPGWhhwPfi/xxcAtHppr+uZMm5csl8U7fUerhW2VWmInAQQAQIABgUCVu13/gAKCRD4 +QzxJ2ymhKM/BA/4yvA6xhfn3T66/qFIOEmrkgw7XHjZ0OggmybBxy5TkmmYtewN7ouX4qKzl +QHrAa7wN5q17OU7bNPFEH/3U1FC9DuTE0B+ENxfFxujs4MhazPXZ8izyz1UbFYH6N5D1Ws/v +mpIQ1Ys2jMN04SI5Uc/GpaBw8CV50VMiU/Yf/jeehIicBBABAgAGBQJW7XgAAAoJEFmuM38e +pL7xn40D/jPCrwtYiup+mimJwx4NBAwYNCZNgrj8+RlOs/9uXzD2RuCCyH+w/gL5Tzi7t4ja +tb2IpK8I+F835LZjMvGxMVgwbiKX5MiM/vVkbjQjMRKzgswemaXt+64zv+xE8mc+jzNE9p6w +v85/Z/KlY4ys+jpBSXZcPJ6KQyeYGgTerchOiJwEEAECAAYFAlbteAIACgkQMENi6XLHYQpF +WQQAjk7oV1UGtHC+d5YeIgjip07yblwWmAwXAVs/GS/SIGHB72VDuFErmTFLB/Z2jM38/x/v +CJK8kVLLCH2iCan4YPhb9T81pHNOua5XSwTPqh/Uom0uQ5jgaZh/7xxZiN95ValU8zxutTrh +YUKsikKPUHUCZ0G6i8+Wmbcrfb6Pd4aInAQQAQIABgUCVu14BAAKCRCX9MuD6+AYEcf6A/4h +Wc4T/9iLz3rs0Jmxb06cPngceUWiVezx7cQ+dPNUZt503JOCzIm1lMz/jKZjIrIwBu77vXRD +Vr3VkeMzPz1m5UOT0o0LKWx8nskcE+1d5ZdWNZB+bjM/aqY9RKD6KK5Wdy8bPQp3uZ+9MyTZ +7a67/PORfmcd5baTHookoXXeN4icBBABAgAGBQJW7XgHAAoJEJkoD6jyispS+LAD/1NSuCEb +w1vIJGl5QKo49GcABTPfpSF7R4CLagbfpDi90ePxIBI5hwNW25TkNc2tQuMCUvG9Kuvc1Gtg +qfHukaXA8ebnU+aQ0kDMgDD5qT5om04YlgHZ58fcKDtuG6FuoDqCeuxaH44nRhZn/M9gRnK9 +nGbZwzmRZX47+llRXShUiJwEEAECAAYFAlbteAkACgkQekRIZjq+z2qr4gQAxvx4SJQ/wCh2 +5uab1m+habHLpJLo7Gv6zyJ13iZw+Aj2hxF1iS49SFpKy25qm5EADBQSLtmyV0CXJ0dSd8G7 +rIiLbiXb1jYWONk/Sa8Q3QMpQs9jxc6mNG3d1qbYyuJcODuV98crQ5MVNYVfTPU918u0gD7X +dP/y6eCr1kVy6pqInAQQAQIABgUCVu14CwAKCRAbpqfRKIaBXFVhBACKKnNxNJcY9zdk6gu3 +LnuRktyxWdgPau8UOCT9eQD/pTVfKnzqwaVNVY4yRYOxHHg5/NBS8y3Cvi+HyVnXZBuoTqwy +2yvy7ZTABMAQ9Rbl/eU9HqXDR0HvaKzdUMNGrAsUFg7+Dg3r1ZT/3piggm0JdaOWpTPHsFrc +cD+3qNcK5oicBBABAgAGBQJW7XgNAAoJEAhAeD0vs7aVWkQD/jsyGhXXSDXxg7RP1i1pvKyI +7f2NOsTQo0LHGVxhAnW0ypkKFNLekPpAjpwfdF5k0EYC32u0CvdODdWJAz2eQmzHJB/B7TRs +kxk5DJbbp89WUAvtLHa9vyVKIi4QgNc6xHt2E9LgwXmLAzYyBBOwptGz5qNycsxdez1bT2wo +YOMciJwEEAECAAYFAlbteA8ACgkQmD6S6zfiPQ9vGgP8Df6xeKa1myBGteRjWu+Z4ABToCIe +h4tsCstMUAQT2tbg7qUpg5HGOKgJtbexQ9YA9HaxsVZJFI5ubqntqoQLIx9LXvnzIhNG2hdA +Y//XRUIpY70FqpTGDo4nyEv9VRxcUzc7UZkSOmj0DIAG4PuKxk4/wBe+681BAfB1y5rXGFiI +nAQQAQIABgUCVu14EQAKCRBteB9kn7iBmTYOA/4hZ+eKRiFR5nNTfzn3g/3wMyX3MGNXU+VC +jnj6xd3ipbn1wr5P4PWJitD0gINWZ9cq4iaZ8GbbXA4X5JEdt168ohx0MSoZ3zsGGueH/tcO +sWfMBq90wztRjrg2a1FMASkSQ43kqSxwgtBZ089atfL9oZWKRcwBsTAyvayi0tf+XoicBBAB +AgAGBQJW7XgUAAoJEHGnAYoUkUjf2kwEAIx5Lj+C+OmqKZMvUmpBfV+s/ZVqKImws7Dy0G46 +A+LWRWXCS0pHsFbqTGg2PeN1dM/YxSs57wuVLqoOAZpZAOwdAmCgLKgUIUMZv39HDTGtHEmU +cd5ZCg6YHNpFMgP3r3VzSb0vLRksRqMqvgg+0T3j+CX1gC81dCv5i9XvACfhiJwEEAECAAYF +AlbteBYACgkQ/JT+ZJR0K8fW7wQAl6pO7TbM0sft9tGSR6ZARF4F0up/Oznup8v9sHA4tdCs +cazIGTj0JFJgunkMJ+ekVkMyZEuOx6agJ2d3arLXOPbeUKgnODU3USoAHy/67TedPVOjHtnh +nKf8dcl9l2eJD4g0Kv2VbW2KSHlmKjpiI23sYqippRcy1qet5Ho1O/qInAQQAQIABgUCVu14 +GAAKCRChFdcdHw0wESFnA/9zoiLi6GhooI+IUOaL3UlIC87Rf0NehcIPAUdG3R22zAh+gL1I +ZTkq+QA6gK6+xVpvEnOLXsqGJTly5AOuGRHrsxi15K/ekF6ZVGqKBf6AC58s2tWHKdVJWnEj +p9C89fpYpqhbIXJgGLSxY+dvUk6VKyS8M+8z7fx8h/2ziHNEqIicBBABAgAGBQJW7XgaAAoJ +EClL9jjkF0yWU9AD/iakqnJI3NTORBFO+r35Byt+ytUAwAa0nK094cAs64iTt3kXudcXkngS +iuVC61k1NhpcVYHX5OjzY+ECM1cuuud1xctAJlo8z8IzsLfd8+z/ErFRTbOP67FDXrXicRfx +srpwwtDpQjdl+xrx5pQWiGfcRBlnN6hQ642JOKA+ubhziJwEEAECAAYFAlbteBwACgkQAj0U +l/66HF5edQP/SPCgjSshy6Mw0Yp1bf+/OmdpcMXSQJNGOYNHwN8kGaTpKFr7MQ7VQ5DZ27xY +kcirCcb36Woot/QPjccokPwPLh5UKE3sYUhi+clb8zf6lnQUpglfeNsHh9jr4KmHov+Mxbom ++2THEV39Y3wZfcvJCDm0B4YxOJUPDZTePFr2JviInAQQAQIABgUCVu14HgAKCRCsDG8qgUvA +xP46A/910cb13juPGZTobtl259VW0jtWQ2dCj1i7e5p3WfHWzgw062BMC70x1ciBdAUvlLiY +04cJAGnHc1Wlv/Pu+iKBpzVumqHOyi5IctOPe+IEOjs25HEfoWkGcikLZnlOEtWcImj6FkD/ +6///gg74nmYGOVYsFC9pf+fiWNOUaYQUU4icBBABAgAGBQJW7XggAAoJEIG+J5a2UOSAp68E +ALONHRidHGsgLr1LxkFv4P7uu80cWppqDzUm/RQUy2hmbNrn8+Hp4Bbjtv1ScsPUOUIwnU31 +9BMYjh2F3q8JhQdZh5TdgPzUMKPFgYZ+9Ax2EdLN86dlxYelJhfH1ni5MUOQoL9hIOed5C+N +sliw/sBlgR99HfsYn3pttkwq5AzSiJwEEAECAAYFAlbteCUACgkQSM6bq1hpHbofWAP/TweB +JTdp3AhKawapbcSPW5zv93aWMr+m+/dBbCvy/li9BF4uQV4GKftIRppQ/NV2jA8n1ejFw2hn +xtqzAZMb17YoXAcSPYhOfuWmv6GcAPbJG8VngyboRaJNEjI7PGox2/70UUFK4yn2umtHrlm4 +zpwyFk2hyt3hcpQVINna7hyInAQQAQIABgUCVu14JwAKCRBx30pvuM8AIG8pBACHYPY9LM68 +3+74uUpBXiMkWnVb0zp5vFgJk8M1mljKPqrzn7YF8YKs836Q/KM6oXNwJxINuWlf6vjQ9jQE +NKL/hsXtUvCdwsbYmkdGF13RNfj/I0nvdhiDkVkRMx93UxV9YDJGJ2CjVLUEJtNNGBKlIhUf ++BMSXpgYm1ReFCLCXoicBBABAgAGBQJW7XgpAAoJEKC9nTAarNHEXvwD/jgKnOLxCkNIPycS +zVioAUdUY4/xa6JQuRmc5ovdIJDRJMIItKImLYBGR7pw5YWqxuClcJE72kOF/BMXE/VpeGar +pGbnqA29ocdhBCpoUMbcnZjhrujyU+eu5uJE1p5wftmtf9NUeSAIOYaLH6Ze7kjI5q9CwmGd +JhgWl2o+CKyJiJwEEAECAAYFAlbteCsACgkQboZmSip9oq3FjQP7Byc4KUj3AjK3vc1Rtiw5 +JkRKERnHN0BjMHdXEW/LLX66TzEw8bUdMeXHedP5Lk71FKjqoiuN1LhGO6tURJRFV2x22wPP +OXWrDRMScsJOUmsHmsSmaT+r7z6Lo+BoqmTKkQFTvfQfyCkRhB7GGcUac0lmZ0j/EICYQrY1 +gl3XNYeInAQQAQIABgUCVu14LgAKCRDID11fE1VjkhceA/9QoZc43/F/u2hUH8bnI2RzQC/v ++sC5FOginrX/+ogdeXvaow67bxvXdPM31Hp55vkAujnRY+HB4GEPPcg7PBokL+KsXZwe4yBW +7GJH9yK5kXlUiMZLvw2jwUCuRkTFTSLRxDFsmDS6/z7j391XUB1Oo4Y/wBxthSDRHI963vV2 +84icBBABAgAGBQJW7XgwAAoJEF48JFzfY8q7l+YEAKDC5oq832Xg0HPZntqyJ4tN1Z2iRPC+ +GCCmLoRs4hhBtEsRsr/7XmudtKQHvUB/LOKHnDQtYIokbctJoCSupL7OoTa6ZIc7rmTNMOcQ +P3L0NW5N3af2gLa6MyZdeGoCV7M7+nYtsh0SyJd6/sv6p6X//TwTGx4q27MKZCJBwdYjiJwE +EAECAAYFAlbteDIACgkQMY0JpMqxYH/bDQQAlOt4ssJck627Aa9x30hxzBYqprt2Ykgx3iJn +d4bGwWohT2mWn1i9DkJ5MssXqdWDmLKqHfhJbueOumtx59+7VYRyPkLOpNfthmoZcpYejb0s +DFfsiyJTVz4n2M+yo5AMa+bOcvUUtc/wk8tOU6bCDI6cw92Zj/fdUoT8Eoxnpi6InAQQAQIA +BgUCVu14NAAKCRA/VaUHCQQR1aLRA/wJcjfD2INxOfITU0Xp4DqSxaWuLmsltCCMtz/E+NOj +8ZGUBJLBJvVGwRICThjyLJGbsWWyUdbBCSXQANjy2pbdDCuq+t0fZblK3pH7tcVQr+1V64zj +3TrY1d1WJH5GzBP2SPtpgFxw4kjjlQcH2J8grYEZavyrnVy04W7iCHXFxoicBBABAgAGBQJW +7Xg3AAoJEPLxG0G5VZ40f2MD/31sHjF2UpAPHLWBm2H5vF8ReS+cFwPbUVU7Bvx59GnwZj0k +SfRVxJwCoM8ncAIAQqpLp87uBJcWwNdWH3LYksuahTceCPcTfG5leLu3rReNvUMV223fDiD/ +0/5A/T2yexZq5EOC8sT776F2qn/m+PrrIri+PWlt13HwDTmisMdziJwEEAECAAYFAlbteDkA +CgkQViHshykK2ePNrwP/U4YxHJMiee0Ci+YOhEa9kZv+RdtZYhzjyY84ubthx0qrV9HFAoJd +65sqUUo8MaxN53UHjg1SwAYu2CbcKfdRDcOqcuxqZG6p4qjDcr5IalgNtLC7u8KfIQl5sZYE +LBtJmUByV93fcsFzcT2MPhg9qIwcB2mIlW+NVq0lNvlXyIiInAQQAQIABgUCVu14OwAKCRAb +HEqzAlFRhDyxA/9MMhz0GDzGhwDFuUyfjrDHDOLxYXfUr23UrrVQhJPGRv/JgZC0dD5z1D4B +rjtVkjMR3ozxUpQl+Di2LtzNn9l0cA0HRqTSgBxLBainLVvGNKB2Eiu6ijdCP8pKIDJzlTIz +E5WfPD90YpLCESKZwvRg3vdc92mpp/DCSistJCKKB4icBBABAgAGBQJW7Xg+AAoJEPtxAJRd +hthi5gED/1JIW8xl8yd5ejIatGobhkHumJiBa6e/vGDlIfNc24vyYiOhNpugOk51f0FUraGV +C2jgDJb3SxyUeFDKpADZy0h4L+m7MAqtLx8S/6ThvwLWTHmne65547EPPvqpYsvzW3nHEESm +ovtA3JZPB7VnzIBXf5QuCVkEb4veFpy3gmJniJwEEAECAAYFAlbteEAACgkQoZO0FauCJwCq +GgQAufaSZfbdqjcd6+SAQGplQ7Dq/lMmCX9mspREYK7DqL1LBbszGFGZDX/GtFt9indE4qah +mfVTNuT/y0NW7IrYMbO4ywPa8sLdodgR8+DVmRy3ty+DIiffTwszzcH1bbGerOv1MOb3FJc7 +2YMqCkDObrRAje8ZwLUKRP1/oQgBw9uInAQQAQIABgUCVu14QgAKCRAPKygBPu6mTOBgA/9p +jjP9z2uHYc2LxLBc+PaR4WKeJgq/Y2HIhjuTCY1gYDqWKJHXwODL7/pvzZ66jLNxKS9v37+f +y/+C977qw4ECsD1cmRlGx5MkF/7jlXalhaULYoUYOHoCqCTZyYtvYgfH017tFh58czLE9XaO +9Ha8lFWIuFWXphP6vGKb/nljM4icBBABAgAGBQJW7XhEAAoJEN+vIC0jYlfvrCUD/ikQ4MLG +kOcO/4xr1mkVZLAVXP0RmOJ8piOL4CP56Y2agNeVLfqyB7DM0p/nZDSsYpyMKqw70RFesFnr +DkW12tJg3qPR9H0fqL+fIs3zrzHeaLxQRofG5kiJotK3bYmM2hcyl4VDXSKrqqz2yNjhWTDU +DbrB2z7enZGG/um0rUMLiJwEEAECAAYFAlbteEcACgkQiYliFH5v2q5EnAQAoLGkrzR6q/oH +xAbKjVfjRycy72Di6dqHXXR2wXDG0rv5u8MioFlamN11II2DwvmcY48G9m8iXmFl51gjC1GA +jBi9nDhjy8OblKzlCyEXhVJ7L3gaEsXDGowz9GG8lHCXrQFxU7T684Et+HggLTf/B8+HUNNT +zHcSBCosOf0A1ymInAQQAQIABgUCVu14SQAKCRCpXb1NWb2+1FIxBACzMeUsQd1VX4Refaif +LqsFnCCEoFgavBOulFZQPpoazz3G+13HOJHfdALULdQH7U4iIAijwHVBAPDspo4DH2Oix1TQ +lXFxBjGud57OR+imw+2uBNMHjCLQqgRcHdfl+x4ywjhZdYvEB49GL6cMbHXYHNcoqWTWLW2+ +JiLFFL20AYicBBABAgAGBQJW7XhLAAoJEKE/Ft0bmz7jJKwD/A/AXhWM6u0ljyqSejWeRClI +qsgW0AiEBcTW187A5B8AynYx2S5T3cnNlPwXfeLnbnkS9myxEpiX3gDjHb4Hcv1FcEbS7oxp +YVFtL6y7LPM7Cnvfor/w1pzujIZXua6B/Sh4Tt7zDN6Md//ijchTeLEzZ9mPIF32jjhx2XmQ +vmThiJwEEAECAAYFAlbteE0ACgkQmYHZB5R8JWXe4QP/RIlUzfkS1hn8ISDpubegVsICtWRM +LjUchzx7kd50wFT7Ft/5MPvamLAzfhBaXLR7NqlWMKhcgjurPvjQDEILo6hyfJfKCw+kWibt +rqSnDTTH6o+i1fVhWDcuRH+soMX4Vkjk4LmJe7rrH3P1y/C7a8EM/hsmrJYRyJZlrbDL8leI +nAQQAQIABgUCVu14TwAKCRAE4DVl4wvEfIFrA/9ZQDR14VwEyUanXL4nGNUXMOElH4x56k6l +twZ4J9O4J95X64e7b3yMGjndqGw9Or6kw/dkd9TtT6r6llBUhvixadSNmSvXR0tWkY0onwq9 +r9GLGThnIZ4VcyU7LZ4StigAnNfqJiYXWj2Dru2jFWJG45411I1Wx/0MMfC2tf24X4icBBAB +AgAGBQJW7XhSAAoJEK7vtwYu9cLgmNcD/A0cDqpbF7NtLkc4gBvwx/OMwwtMaT6g9TMg6lvm +Ihs+bWy284w4VacRODwvZpJrvn6aJHcRoSheznBroL+6c8tLd7SFjbD7PJK8hja8dXxRQRR2 +EojPgPdm/oy1zXtzzqBnnV0//JDQq16v404VThu6+gneDyNtQoDcaamnqfIqiJwEEAECAAYF +AlbteFQACgkQKR246HWbRSvhtAQAixzDR1CrugHa40xAdlmltsXQnjfgvF9RR3k78VGh3HHs +Wc39AdzDjegrVABfN+RiLinpbFp2o8pCSt4kKXsMHlJUbZoSyGGj4MK6356rXMCS5y1zUaAw +jiOXpFPBqXQHhvBJuxlLJm6NmXN53HIs2uhVTZQBUN39iYjQgk+sUhyInAQQAQIABgUCVu14 +VgAKCRAqSM59xJllg0wYA/4oTNJOv6NJ/vmO7pvmnV4iF/2XJY0edRXqj1LoAnlDy7eiEd0o +1iUnT8KQvv71by29ZMDQHTBovWbBovKZj8uB6ipEJ/WSYKfe0xm8D4WO2vnCzpiiIr/N4f6U +3FbwKfxzsOSFZcMjHlBVw1gDjoCCdbWEXRKH/ZqvZvf+3hos8IicBBABAgAGBQJW7XhYAAoJ +EKeBXwrK5Hy31DgEAMEnLL5eL2RURwuNjeyM8M64QkNoip89iS/0Y0A0SLsIh0ggkHPOg3Cf +f7IO+/0XjR+xec1dMQQD4pKrqRpNXspF9AzV/Wz21Sre7iU7mZ3XPfD6LAA4WW5cHMg2qX9k +DQbQvocRf8kqIU6fvRXx31zfCSTLHmFO4+b3FNKx4FNniJwEEAECAAYFAlbteFoACgkQGYp/ +7F5FTfZyXwP+NJcAJGaqNFkh/rbuC6lNh44VMSpkjna8aKA7gLtS6ZLGvh6dx8n35SY487e2 +fQexs1rkJ1YAtFhhWZRwsr40mevOsp985uiba0u1xNbXhL/2qeryZ4tgZM0YaCkagKOvMlFD +UiOuRg9pLgyC5P0rn30m+zCk43HiRQFyRhT7+kCInAQQAQIABgUCVu14XQAKCRBlfV3k2o1J +Era4BADEMQorl8ItauFnowHi9WB4jejfuxaDuhTlYW7CCEkhrLQesAdKNiD0/O56HvJQmzP6 +lox0/JpMmh08AP4JqQkQ8pxaGxj9lc2+VcGgGG+0eVWz02/qUpmashmz8+8ZvHvhqzLq+nAC +ybmlX6LtwwjBJCrui0HT/I1UGmlOOfunl4icBBABAgAGBQJW7XhfAAoJEMfFm9x8Ma8DWwgD +/0eJqrBejHF0yGI9Ssp/teLABbdkLwzivZNdNvAhkuwh+y5E4kUk6MgZWJMJnTZq7v5UxCE2 +G0S1f80l9QaqmDQdeypD+Ua9H//6WVdsuxX9pYHvKgyYgz3qD2Q4M0/tEhY67nkRzmPChnbg +LvPPzCZyY/dGlcqEDMOH8U0d/ECIiJwEEAECAAYFAlbteGEACgkQtJhgfFrzA2YUMQP/bV84 +wEuNp4xpXIpsctsx+HYZrSOJCpeUH5iD1mlkNN9xhifV6qQ3J3AzZi/UJ0X+3AufyAXkUTdk +XorrOJQGjPXydmfQZnApqDNXKSemC5YNILSWBI/c0ncq8BAKjwzD9KZXMDux6zvWyfNJLRFr +J2FzCf6A83sot8EYqXUVvimInAQQAQIABgUCVu14ZAAKCRDxXm//vCWIM2VHA/96tOhE8ozO +f9oP587NZbOusAK5Je6Ee61JI4+pZ/NyjHQOGhcRHuYgGR1drpXuNBpgZ9BXWDlm8ZSCS9Th +UCjF5LWlVP5OQz9lwn4Yxzjb4+P7LArld7pbV5pgu95yzMi3qgZBrLrB/+XQOu3Z7ecHeFo0 +Rcq/v5MeIZjrUUjD7YicBBABAgAGBQJW7XhmAAoJENi4+wB+bucE670D/29GyI3hOmcfwO+E +CqTi9qbOGAkHKlKFDsHh/9IbiJPBp44LR28TnLJ7GwGOXJ5PHxDVuf+ytyo3ocPPRu132Tuk +70mZ3TNr5wVo41egTtnBYoNbEr2TH4NMPVKjv8qUhbP+DwbEB47UVuPjm28SxeSDUlkaEyaZ +BxSp6Qu/0Cb1iJwEEAECAAYFAlbteGgACgkQ/txjf5gVjqstngP/Y0vH/1KHv+PpfK/7gE5m +OfXzzEwwEWk1NgUqqy5HY/uQCwQisOuLX+4FLyY32P6QeXeJptL0o4szHQfsFKYfN1fzVODz +O+pCPGL4At364Kzbp44NMp+6dWRZpG1tWdWgrkl9Sr4Cf1ZllOX+tLcdl/yvKr2kODnA9QNc +Bgpk5mWInAQQAQIABgUCVu14awAKCRBw50+3TcWE7NBZA/wNny7RP5UqRNI9ZOIMauwyAtBk +bjEhVKXOEKTNMOMXI3grJ3JPeTgL5uNurpbZLAunSLaqKrRwIIz3LIepAjlCM33qDpaUVwC8 +16LFUpqtWbryFLXLgoyhB1UOz5PvRo/Hqv0ki7OCz1GjwMpdcRoDwulvjHyrz2iHPL0ATr1Q +UoicBBABAgAGBQJW7XhtAAoJEPJwCuEH44uBdNEEAJNnkNYCrYGCF/Z8kejLUOt/T2/wzVit +71/vT0EH0zoTYxPjGYdYcRo/aCdtP5gwPsJB+RpyLOS93bu8lfTMBvPMuhE/8BDK3SMuiOca +nXhyg4xNWLlAN4VNeoNN6vOEHRl4rEUSnwtlf7jsFzMxIl/RNhAhZYYDjxAyCch1EcPyiJwE +EAECAAYFAlbteG8ACgkQmYsV50jIkA4efAP6A/RZQyy5XTL/vYxQBmumt2Ss3gH7YNLyWpVz +J/1hc2fE6sIjz7VUCgXa3YytRbkDRfh7h5bdzeEsHpMowfll3aepgU0QxEC++1F5r/2e0Luf +k2WDUGVuPoufW9X4p0K/1MpG3MzLNzkxSWPNx3DywE+65WpVZoCHBvqrgDUFgCyInAQQAQIA +BgUCVu14cQAKCRCKo06bYUAP88lVA/9QV5FOSRXBgK4wfbvjGSXlWcOzccMd+Fagh+NyieV/ +UU07BsH9dr9B1b8GvQmmivyIKPGm5T6fNeqBtEk5kw7+yLn1ctoY46hXhUmum2wEGmHPW/z7 +A5AZW6zNLdUvLoml33Oc2b7axYs375z/A/z6BtohOjoZOoPKeenyn+MQWYicBBABAgAGBQJW +7Xh0AAoJEHre6oth6cN1oTMD/jwmdqTIsuZUrA6R9lLAa4gPEZeQV1doaS1DD8+vXnAHNyAb +NmN6946kEb3kvtq3Y8jF7QiNOCB+A4MmDs2yfwHH6Gf916VL8wQWSCUP2X3YFg/6ZGMvtanO ++h8I3oZj0p0LHJKfRcm98BqWe4JKOaFAtWr1233+3vz0FP8o4w6FiJwEEAECAAYFAlbteHYA +CgkQdg7EEO5OA1YHAgP/d6i64e8KuJkH8DRHOZCeZZgSGh6A3QE1MTq9Hqf2r5Y12l32mW2a +LRrsS0biO3TXqJey0R45qkL7PhtyaTKXwqeBLNBd9JPSW1/QJI+nxw0AgrDSjjQUHxhrZbSk +bth3leQkb/P/xY8WfsY8c83ueC8OZBjMRaZro2cIuNoVPVaInAQQAQIABgUCVu14eAAKCRBo +gLyHqzSpm079A/0f8eS7SNhFBEKamj5YcxvdLBy50IXQEGxwvUlns8Rlh2Hg8+umVs6EkHlS +vYT9uF95MSJcKvs8n0GNmykiK9g8iHuBUAn8QJ65nlYVDtTMLsW57e0fItT96mpdhusCWQ44 +q04Ka5aSgv0ssp9YLZnHx2kVIoWdyGT2vtRNK1L/9IicBBABAgAGBQJW7Xh7AAoJENSjWMxc +kbypFLID/RA31Gc270w7Qb8syuESjC8ow/H9ylbXwlpp1woJ4mgfGj6HSDTyPZYZ5hiwTp0o +h1DMfz3AUWf/wMMm+irjiVpZF7/XRJU0ff/lSvv/HZGmQxl4+JIm76yx29Y/JaOx8IT9fftw +RfhCp0fmm/vxvAYnbKYdqLXeC+St5LxT9cMSiJwEEAECAAYFAlbteH0ACgkQApsZPS+fLL3P +3gQApEJIswbvEIFi4r5lrnP7yiTnZapYII3wScbFH+HQ6w4lkD+nqPKLRQgpp8cEWeVoTO/G +SQ2VKfZ3XsCzJ5C2KlsEifjbIKjH51yZ07p8PQ6F+EPi9yempYYoXHg2ByFWnLmD++qZvV/u +m+PzVKwsBnT/us1cN/5J6xRA7SDjJ2SInAQQAQIABgUCVu14fwAKCRAf+MxKX2tm2lPqBACX ++UC02YBfz8s+hTI1GeTYENvhOBIzaIoTcvtdlwLIilBLldB3tV5YMFWvPU7hFIwkbKGSw9x9 +esp2P1CHk2GWbZLpNPXLZqC8yi/y1YLg009N5K8vqJpIhiIYu7bX8hRCTn3j4DcMrct3v4Cg +l86WzmhNPVApQeXuyS0/zelwSYicBBABAgAGBQJW7XiBAAoJEAs92Dmm3xYnpJIEAIW0G55F +630ZV4Ogn2PUPAxLkghpicf4k/EQ6WnGpCW254SP2vOPJbK2NtRcv+Wyrnu37fycyzThMR3p +fA/FKiPtSEdQw6DZ0bOa3ed8RD1gs5yoTyfM3DwsnQeaDFkSMgJGxkivhfMl/2QoQ0c7GvF9 +L+VNH9PZDO/ymcehE6tHiJwEEAECAAYFAlbteIQACgkQbZVCJcbRcnFnXgP6A+qO3ymc5DR5 +UJ769Q1tIhjjlTN4lfiBiSJ0GJNSVI3AFqFW/EhzIgewGrIic0C0o/Ns6dwaZDlS7ZO5JOiJ +MgNDUBZdltTeHQWdDvNwpkbZ0nQLrhQDbs6ZEWC1IRxbm5Pjc5f+RWtJf51ykdEB0dJ3JMIC +UV3H5saFU0KLJ8SInAQQAQIABgUCVu14hgAKCRCLNuuC6dV7gtf2A/4+VE1vpdVlMbwvDeX5 +dggq045BRsESU6LxeqTp1NG7VfNvHxpDpDrtgq1M0Ggp3Fe/Gwzz61sO5SRuuSisWXAlyfRa +8pXaUodkZdpzNVkgFkLFouvFubsTdJLKMME2ftALazyG8nLxELQleUlvzX767ufNy0ejC9Eq +4mLIwE8N6IicBBABAgAGBQJW7XiIAAoJEFiFuRdGP42ErmMEAI8jJKkJGj6jQCZY5COhO7mP +2uZmK7GjRnuVDpAYRGa2wJTPWmvfMhhMzOfX3lZT+0Xt64Z8AHrt5Q8XMjC5QMr/a3W1tAeH +eI+qKy5tNRx6KXs2LnNoZv8Aj2akecxPKdmo/6Gx9JytW1PzJy60zHUvPhWAPhCn6M5u/Mv0 +xekuiJwEEAECAAYFAlbteIoACgkQ4WVe1EYIcGPi+QP/QDbX7RxKUuxqgtJdnNy13RXLyUpx +m3LEu1lbPDVV/tVMZ5vYUyaRjCisvuGvlQE9HSCxK4viI5NE94ir9pZtcUvDsY0hjEOyk84F +nM1wj/p+R96mAzDXExL/9p+e/ulV5PzTyAXkUsSV/O7aJm/5Yv/0gBuwswEkI1crIYh958iI +nAQQAQIABgUCVu14jQAKCRA+cFH3k3Sz3F4CA/9Ylxs1ccFL0J/Rwf4rWMUhs6Hjm2Y/q3+H +Eq1J+o4YrF+s5ULdCmzv1/y7xY91OjfnoZFJ35BD9VwiLO4lkb6RWMmR5Jbq2wgoDL0N2MTS +g6OD9BgggI/7v+iRAFZ3Y3u+DjLJWMbW4El8smVk+VqiCzoHEGHbHXGO3w/J0zbgWYicBBAB +AgAGBQJW7XiPAAoJEKjtvl8RhBEfJyoEALwX/951bqVe9rBPhnmo0Kmavky9cx/iAlnqfy+9 +racOizxU+66McgHk1w9my62sDooe7ET8FFS0MT8fTsXHfW6thoTzfVDFvDuXMYpS9dGd+gxJ +IlT5CZUOatIqnz/TSlZiapz9ST1bkQTHP6sy7YDw3F7ZnpzgyOk0hj87cBDAiJwEEAECAAYF +AlbteJEACgkQXyy8OeXPNawljgP/SRoRtE086czQHwRc9tnTVSHqz6/PgZcKgPlYEsBmEREb +C1lhH3K6SN9IbDeNyGiNhELyYC9LmAbZLkK6evGFq3hPNflYB8YDdZERNWsus+vgzvuZKqxJ +PF7YyMm3czvd+NyMuisJ6Vpz4E7u4NdyLCq8hVy6pkvUNKX+y84V/0eInAQQAQIABgUCVu14 +kwAKCRDJ/FtWWla4tjFGA/9uMQA9FN8AII5nXZiTj08I7DSnGUneSdgNteoKwo9hZEpxeiom +w45za/UVUqPA9M/jSFcR4nP1MvOincwAXPXzTElSPiUBBp52kjaiQYu2795g1VCmztOoRFww +Nw95IGItgfBhcUu8bDcVgyT6oVtyTNJ1k51rkWwKxKCuZnsdGIicBBABAgAGBQJW7XiWAAoJ +EP45tMViV/G36/8D/jaMmyfvbnBs6Ie1vN9SYxDCcs6r/TZJ3HKpzn1QPXA5VIcpV2z86JOk +bsXqPGxijeIpDkhEMmZKZoo9X8jyiGqLK35oHu8vwLQHH8mHjxyqgLiyQgcIk/eNPuHnisNM +8cHG0mT5bIghk3p8GiTP+jPCZ5c/HNt7vEzFdZ9pUf5oiJwEEAECAAYFAlbteJgACgkQDdTY +FwMe17BPIAQAxSW+jGxgGKQ8mFPa4xUvnehilZtmQprS3VrQQjt2CDv9d94ggthn7zq/hMZI +WaDAc7iadQAFp/YX6v5+PzxxKwfGCh7xG0y2+4xfTegpmKTuvxwqCK1GHoyy80SU4ukebIpH +e2jAc8Xiflb08e1TUONprmUb52swmRlUb2lHTOCInAQQAQIABgUCVu14mgAKCRBpH+FaVmz4 +cq4gA/9eth6LRgTZkOFdSPjOauC7ysUwwcw445VveEjSdwik2mIX6uPIQKot4p176GvgBBYK +uO3Omt0YqDu6Xd4/fjZe3t23bZlPGgUZE4uIFFKho4eBjXFqGXwF3tOQLs1yBaOx1Myd0b9p ++j/c6Yd07zpAhDGdLfzcyhAcbjdkkczvH4icBBABAgAGBQJW7XicAAoJEFvLzM3iXSI2+XkD +/3gCbXkoF88wxHRJ0cC621lyxnj0mRK1KpH9vdvO1y1h7+UCOSA5TL1+VYk7c3KSbbjjvwRE +PsbJ2jB3bZMnwZiL9tJE46dM/VR4QofWb3haiN+IwXtaWWM2OtX2WUuEgPU4XSA1naMAJlJE +XCZ2nyOGsLd31sSntZUg5LE6FRJBiJwEEAECAAYFAlbteJ8ACgkQITL00h3yA/L8qQP/f2qx ++Qow1GgZXLq/Zd8BFQ+MoJ9DGpb+l52JSdyu1p41ljBRfStxYLjbwg8VV1LqYDz64JTGSQjb +R5XuVi35IA3KaahaQyElnuIOUjc3HQ9LW1+OwR07MbLpq6GZyT9rVBuF4qOghZrSNCs2BMRc +XWPiJbGF0rUIRSdvkqd6jhGInAQQAQIABgUCVu14pAAKCRCqz6qX3xLthzh8BACq68M21GnC +XvaG6IssuGHCujbRuKR7S6PGw9mR6XZb8c1OBHQdi3Y+LlWNLE4QtPPMIx7UnVl8xHH7fsMA +d0bc2Q4zW8uQdJCQxhjGR5FLLgjE2Ga7TJOEESNMWu8iSZMioWBHKvKOtMaxBlMwdzWB9oWY +TQddNe8+fGFeDC+yToicBBABAgAGBQJW7XinAAoJEIwrt5I2LL9PYuID/2amiTLM3O6m0U5E +pMwAmbhspBpTCZBeKETnsPLqwkGAUeoUyGZOBnq5LKaSE05v7GX/WCfLsZ79jaZ9FkLHcv8d +7fTKa51+opIq2BBdduRsPrObkFD+CQScwGJpn22sSDC5ciuAE99cS5IbFePN6XIqen21Kpk2 +ZJtqAWwL6prtiJwEEAECAAYFAlbue3YACgkQmw5cbAsiDZQEyQP+OVhD1zwlGBy+oKo+KQ/b +hlmlqjafsgZ7rdswGWLoT2Y4AbCVxvtLm6roP0IGzyZDMVp2XVtd67rA2yNCpx9Ts+i8qiof +oMURBKXipJkDIu+OJMS5/NKAf7luZwgJRtOYTauhtYkKEZjHe//jmTuWC1PQMHIjc/O+MBdG +ChE4mJyInAQQAQIABgUCVu57eQAKCRB16evjmuSfYD2gA/9ymOUtOwf6f3eFS5O/nI3xiWL5 +awEKUPz6M9mMYZtyXlmzUIEBtkvkeAyxouUpL7NQae6fJ1Zft2i77WEQUnqrapa2MmIlH4F3 +r24UaJd2HVymZAvWLoxIREZwaahSaF0ilMVqb7OEE/8oi6xh1WeaHmgA3IOgn65boMArKDes +5YicBBABAgAGBQJW7nt8AAoJENxxn2iyE0x8loUD/3avbs77zu2z42bs3tLovtS5O8qSRiNT +V2NIJkbQ+HtZmvW3E8CXIKiVqasEooPzucPftnwCDHNG8lLZxu0hpFuWJbm+XGdmUij+rRQW +1uU+03NtNJsvnm6RV9OJtdXWjke7SgqNEtd8/R3rky33TDjqDfeoRqbWpeAKJPtjKp5giJwE +EAECAAYFAlbue38ACgkQDygaT+GEqx3l7AQAntHwzFo0rX9z6Wb9c0NCyT/bJr6n1uB4/Ey1 +3AaKUsOexjkMsFUuGUZ4Og0uiEZ+KWJoshKOYC0gkfPjVD4/IXgr6o8TgoNpK0+f27NL2IG1 +0X3U1pESsWdNliKY9roV0JUJ5fstXpj/jmWu9tes/jE5Ir+7VXXmh4ckR5IExt2InAQQAQIA +BgUCVu57ggAKCRDf4EJ8x7QdVj3kA/43x++f2VeJ2d6DxCoevSCkkT9db/Nf7R99BPjwzTDn +TED4NDIm5WwcVsdPRkNzVJHKXVck/RgfXlzyHnTs2nG93NX61WhqEySZDSSVKBnfwJ62Z89z +HHiGjJ0JJk20Why+V2zdnvCXRiuprVj9KWytuT5K7BydKM4O2NBfZUvPTYicBBABAgAGBQJW +7nuFAAoJECSCXnZo8PgmDlkEAJOvQaT2eeqjAJCfHb832s9ZVpy0iDv2tBIhFIMgGe2IYnaL +H5be2jiVRHuQwV1Myd7RgsLhUro543omFOSjZ4/JbsG0s286D0cWyCt+cNMhjX6kf1VN+OKN +cCk0vrhMNgw3/O9J/zQBMWvcr0R1MEb5VBbhR/97YrIG4IQpp+mRiJwEEAECAAYFAlbue4gA +CgkQkkONCR52lTqqqgP+LH0V93zsgVqRpYoD1GxCxnxpUrpSYWd20CBpHhs6Lp8WoyYuyTTY +bwQFiVuin9UeZG/qvA2yMCjwaLKDsRRc+rcDym9LBk0csk8Tga4e4+6PZO5dYqTsHyRzLcx4 +1eHm9pZ3sO3rhpnZc+jUfq4DUfh5iqek8UiElvLdEhl3rwiInAQQAQIABgUCVu57iwAKCRBf +d24KyU5YLvHOA/44wQOK8DMNGp0CdapfgUAkuwFWrnpRyi30JnNRKZKmvBezfov5xj8/KkJ6 +SbP0mm1w/qHqCSznGfROQGruisrEYCjX9NRz7QFYgPlGJono2aJ8bRJxppkeYx/yHjMy1/GY +ju3F8KrOa/UNYRsQ4JN3MMN8X9oa5x4vz62/5hpRlIicBBABAgAGBQJW7nuNAAoJEOHWmZrc +mmDwKTwD/2CTbyKEmLGtrAuhO3M5YtcH/OzQeT0ycpk/gAGvcSVlL+SsDwi7S9gQ7BU/rHqF +n6hWdKBi3fPgIA08SByu4AZh0hj2K+odBaD3jItV6ZbdSXk6D1whNikvRCTfjbP0vr2nJqTg +7zZaMyScOxXrvHJLy9vuu3ZUsqoLjR7Nzci3iJwEEAECAAYFAlbue5AACgkQnsbEojJpq619 +ZwP/Rq/M+yGws+DxH9ly/oYTWIo9rb32ni5dlq57OP5sP/wQNLJdBVkmdaqTu4ZDxjOmIy8a +QVyHlujimWt7wbkbPvhxyx3USFAI93FlUGTBswaEsEofjbP5SU8k2E5/bojCHvsiVJ1Nm2Q/ +zpiYJAm5ym/KWRBn4Cd+fMXZk+FYUX+InAQQAQIABgUCVu57kwAKCRBYZqIYEWP56/YYBACP +hZ2GVx2qQFeeIZIxSjDGeMUsz+OGGMZXciVa3oA/VMlZUoPE/Yxy7Fq0YYp5F0m1jHTMSXTk +J4tAa0xbBR3kL93SrFd4iYWf6jcGzvvOXii5ZTxC4zcbJ4KHDJTKetICkZmBohoTyDbOCSX7 +nHhXTjyqBLmBS0S2AmDQPn+yY4icBBABAgAGBQJW7nuWAAoJEN/JpsudgFpLh5YD/1byz/jM +c32MBLxz2T9J026GCDfPT85qo7b10B91B9lg+CiLjaBaOt36dUOJMoO8dRLQgy7Arp+PCh5q +ASm/0LqM0f0aYlsIExW/NWjNwTRzFDfzrxfLGIkdMr8ftzmxwK7C0yrkb8Ayim3mT/YOqPap ++1tnlZsJ/hEHKdnivRGHiJwEEAECAAYFAlbue5kACgkQZ0633+Ed8n2O5AP8ChRAIFhFYS9y +apV36GcxoLeZ78AaXWhbBWhDfUTuOjXj9wlEy06n2XbZC+HbxRh3ZzR3nQ6GDyh8lMjLP6so +9eUHsFOKxdHG8kFi2EBfTLBtQQ/nQ2b5Yub77vbCFhL43JCo14gvT8/70gMtFt56k1DbNzcw +at3sVDzgYKUr4W+InAQQAQIABgUCVu57mwAKCRD/Ez37QYC34a76BACmB0v7EGhAD+E6GlbW +DEb9/oC9iULU6A1dIPG1UcRh4allv1x+Rjec/zu528cAWJrl7S9HV6/qQ+bIdcgF88jGKGu/ +o9yLblZo+ZzbFVaCIAUjwrXEPHamUUIBAGtRtXEwhTuGYQ7KOuc0POBFmMVgJzMlclAXAkET +XP4hxrwpS4icBBABAgAGBQJW7nueAAoJEHzjTm241gfOe2kD/1+GMvpr7qv46blx7cWE5SkG +S+S155/dE5vTGFKrlOnPz8Ujf+VvQBVd2ih3dgDXccKYDjDrwXIC+/EgYIo61ebHZuYXuBMK +Tvlsly7aGnJUWHaMusBrqjLu2uQGEONiNdJg36O0ioLiO0DjJIlRJXmqu/0PFRvl7OFlz9M+ +uMvFiJwEEAECAAYFAlbue6EACgkQGF9Rf6u71YBPjAP9FmqY+XWSprs/F56d39RWlmrKtNj6 +MsyY+5A/SOAiTz3qvS4Qjl3lwzJ06qNVr3tThEyMbQScxfDPZ3p4GjezUL4zuS5yVW0kxVOE +JX0ZBTqsPnwtxW0n3dcy7Ts9ED3nNn5wPz4T+loAgNRUVYuSI17grg9Q2zXGJJE5zrFMrKaI +nAQQAQIABgUCVu57pAAKCRA1LCXDHKOhKZ7jBACLwg8MR9qzhxQ07ls4rQPyRIjfpO0mUoTI +xoAFGVlRjMxhEXTReIhY8KMzcZNqD2anE39xS3XoHpztmF2vDIFbFq5gRpdjtvsSTZA6aO5s +YUqPz4/wAJwZ1kz/rIFPyRgtf/Y2g0iUn6b0hgFs209ed7VfKiy3aau93BVSsrmMPIicBBAB +AgAGBQJW7numAAoJEEqOQfZJ4uyRR1cD/2y9VboP0zWKu/mXby9CgVbem9LIPLc2J5SdepNa +XEYz3U547XtkTtugLVGMPkCZsm9S01b/6xSGF7Zef2H32EAUB/ZbgT+iShMbODlzvGEEIgME +Poa52hYLwIWoD9uLblFZBm+Uvt5zfd+2D/9QSVUvXay8PSMO1zT2Zica8CDdiJwEEAECAAYF +Albue6kACgkQA29GbB5DEsyz7gQArKQiN6I/SGNjgTf2t1z9Um0HxRJWUY3qlKGX8y9XDf28 +myHco1LOsOgjgKqOsq3f8SU5/NuepcnRt8B3QzWZEogukA5/OHRw0DjitHolWgQNdcwPfWxb +MJE7x4cGhm7jvQDqztq7JQwNusNQl4V19Un+bGYpQaB7h8wsbBaKVlGInAQQAQIABgUCVu57 +rAAKCRBAZHgppABItcDrA/wMf06tLba0wAVYxgggnbMHL97TNZX0Pk7zgWBmJo0TOIKuGm1f +uc7PY9kfhr2CfNyF3LORlJCu7PSRYKqsGD0qvIXNq36Jct8shgJ8Aef8nXsb/KDvvpouUKWt +7DzRKadTq8xlCMMJXXKy8jt/dnKu9ZJJEH4tI5XDIEcQtX9EeoicBBABAgAGBQJW7nuvAAoJ +EHKuFlsRiVyDUcID/ipVfudTIeJVFOQtrDWAgxgR4oYzWzxFfLCaRph7i3Rn4yP+BTs3syLv +8NJ7+ZlQyyBZal2tW7og8MLMZlNTbcvGXGIGSZ42wKqkrART76QtV8O9U6xqJnBVSYTKOb46 +5DqO9l3M2rf/paIu8nfiU2J9pmdyFxXQFNIVharyvhIbiJwEEAECAAYFAlbue7IACgkQ6IKf +saBeEOEEhgQArZGOvpE6K++yBmlM18QJJjAx5absJill7aDFSZMm8d3jKrwlEX0LnIJ3dEhS +3bLR/xgBjZJorfeGIVunAXxgEkp4icXgDbDn0bgK6uWeX+BWDogGgUqgy6MtVCLQvzOuT/iU +mCIKfsHzbfAgIH/bmYdrMDwlYHZyhdY7mhRnqBqInAQQAQIABgUCVu57tQAKCRDZE17N/nBV +MjP4A/sGbmw5mAOpQejbqSrHTmn1IIYol2zEsYxfFDqExUey7z/FNAWQrNiYSMswqXE2LMbq +ZcuFZlgECIIQT9LUxnExttdYb8lGJ3aYe/bNJMx1fl5I/EpKnM//5EJWZ83VkeDqZBFJZpCe +2218pQsz6Mko8mLXzrLkuJqsmWczO+9xS4icBBABAgAGBQJW7nu4AAoJEGI37JV7pAUG1k4D +/iyPrOjv/nnhPLE2CTi/QQqivIa2JkoVldQAU8QSz4p5J2k3KuY1e8tErqCVGGSL44cKfQkq +XTYvUtpKT+UDrni4HZXqftLC/kXTZQn3BQiULEgo+mD+2jULjG7dlUvx03kIp+K9/ppOuMDQ +v7FUOCF6JhcxUs95wS7aDM2w2hb9iJwEEAECAAYFAlbue7oACgkQGuiJHHoQQv1LLAQAkPst +ixzC5it2qZpS2nXbgbfXXwn4ckhUKr44t/BguHx9SYSM/cVv+aELefmV2sdorfChqArjQYk9 +WReH28ufVaU50yvUY2OrB261rimm5x1qJDGd0rYDB/m6w8uQI13E/vE0qj4NT6zhmF7qz55c +rCkG+2AJiFSKoxXssQ3o3t2InAQQAQIABgUCVu57vQAKCRAvu2r1DRU2Cj+TA/wJE3CCEeLB +ESxjmiqLHzB4y21Ip1BZaa2ZfESM5RrI6UjBvQwtSvuWLTbCzXvGT0m9m9KO8mWaGt5W+Us1 +Di3DEJj0LURretrUMc9iPGtNLwBe+6ct6PJkk3k3Vd9nYDE3mBZUTdQT5GQKcbwpH8wZ4OOS +FF0ZFkjqms2o6hLYzYicBBABAgAGBQJW7nvAAAoJEKBYxujTZrYq8RcD/0dBW9/+0jMmLRr+ +z2XafRSWJnJ+a+/+UN/m6fN39Hjd13Ey/wl/4tFRfbQ3rBuLwOO8WvRdwMOAGHTOd/HmRPYL +f4drKiKFRMOVJmrJTsnfK5PUktong7o3WglQgpr51xlUT4QN+jygk1Te3FBrkVaODEViLejH +6MOxXNM1eTkYiJwEEAECAAYFAlbue8MACgkQJC+HFtKKlECOtQP9Grtf+y8qM4AQqnvkf+XZ +gs2cRDnBhsdIHCzERTArxbiMo9WJFE11fV+YxMSKQGhrHVRJm68iITcnG2fG1lUTdmu6VLm8 +9Ainz552DRwzWByjE7dfZH5NUVejVJHovqiLhSYWaUbR5Tyh05+cmEVjTVLD3pMVLobR28t8 +bOtoLJGInAQQAQIABgUCVu57xgAKCRCTg/SgpHemB5n1A/9zXHZ6kn2rCLGvrhCZoQf6ne7o +QY+y5JXQJNJWfKvsLx+OKCPs9bPjdN6ZFGsq05auMFA/9UHT58b0lRVYpHX1QHahGt2tLxjk +DWuKR3omtOrrdgiu9pBSrGeSAKhbSW9BeTk0yLRwDYGG7LOOfnWmw4EaAUAofDQs8gMnnbGp +SIicBBABAgAGBQJW7nvIAAoJEKR0W/zAS4KdooED/0wcbFOz6N5dAYJyL8gPc90Lt9E4nUN9 +syX3OjdmapJbxHK1fXuNpUH0OMKvsCok4khy0IrOgV9vloT/JBZcI+MoogNKkGqZ82TKYqZq +OT6elNg8jwQGdroWFt++pKOngniY1I4Ape0FtpR7ddooF1czO8DjwFW+6+r6JdQg7d8BiJwE +EAECAAYFAlbue8sACgkQoHGeLBHFhmnydAP+LoFEe/2pg0S6qbkHNIdRxaoBypvRBEmVxpUT ++sCFlmBiGgG2UMJDYekvC3/0KKRH62XXN7LzeOrhEQEqCz+NQreimt0/z8ZApKvoUTLEk43O +/CVN709/Cv6kGTz8Gs8P2+gr8kz93fYTITQ+mzrl6s8HRwpk3ok2814WU4DohvKInAQQAQIA +BgUCVu57zgAKCRBja0wx2XDQ6RClBACItIpjzNTyst0bgHiKsWTgex1VhP/lOJiaK/38ElH7 +HGiDRLHsnCuFgUNmy0phRZBTd+nXfryq8axHicQqjpTfirtx+V5rBqRrgQ9+9i/m6yYHbjCe +C4OYavSv93a3tHlOcgBp4//9DSNXiPOqYyxjxtkX1e3MClrLyp66pt02WIicBBABAgAGBQJW +7nvRAAoJEO5xa062bxMVgowEAJC3+gF5E5sKOC9Anv6X5x+1awxNjXUixCkIuKhHpnqoF6JH +t2mqRFFb8Qm3mzI7WUoTaJIZ/7UoRX9+ADIz3aHHlZDTqQxZemlqzUtm/QEc6LtDJHzq9eC9 +mwjPoKVHJI7BNkd35jLiWwcB+lCOzUPpuqf3MMz/+DMpl+CJkoGBiJwEEAECAAYFAlbue9QA +CgkQlN9Go7XnUTY0XwP/UkF/3BFJh1YzFISN8KzaBq5R5UnfGSaUTsB1ZuUBaVVi1sQWfUE9 +zV3jESlZ1epayp1T+raYU+UX3Xhrs7vz0jGKe0ZPWXnTKOkOQGjgpBcCPSc+qRcmsZ2SQOnh +6Ifk7oKp+pBovdbWT8AfPJ0N+hfykV7qSq+3or8CRIg5QOSInAQQAQIABgUCVu571gAKCRDW +dLs4Yqww5R7gA/9qGQG1kLdo2oW7ScIyortJeAluNtJFgQRREnLU6C9f8MLmFtDURCyYkmN8 +3am2/rbkveSIwJS5kkS7ThTU2lIhbURN6WNeys42F7Z3E8LjiiPnJQCM2Ni7/S4ZsysiasG1 +x2jrokOjIujNAeLN5QiZAjXv2F3U9oyNEe5HOg/zJYicBBABAgAGBQJW7nvZAAoJEC2s/GYP +O5gEPdoD/3jJV+E6/UzdDx2HF+ocwbRfm+RMwKXCdSmuOjDi/fWGe3avdVZUv5kjxQq8aGPC +3kz21LqLXGpc+65CIsxlzpbUg7O4IUeGxAUlpPTgfopRszkHMVAPlQ0E+727monXSj9AliFg +5h5KALVkYVaTRNPOF8a6HQTHmFRG2Zf7+9e/iJwEEAECAAYFAlbue9wACgkQX/uiING39hg9 +oAP+O/MHvCWt/UwplwVfk+NASwKCK8sdVZluoWz5A4tqYz/X7nsVA4bGFZ0r9Hm22yw3RFiT +39TDF3+qJiQiovqe2nDqskbFN30cG553Um+7d311AAvajSv/hvT8Uw4URbwdSugCuv5/KBBZ +zNlIJX3KKkFC02KGRp1teLA9rILNumaInAQQAQIABgUCVu573wAKCRDYo5iCofQVeaBZA/96 +qSooOEY/zwYGGjfD48JiQswkk387Q6bp1yJEdl7aCsWaN3hLqSRZ3J+p2cK8vsii+kucYfVG +Eem1N1oN0Ri0lbkvsu/199rzT7EoowhUMEGz7kAK1sYmr8gZEj7TrY/KZY84hGfXKYIShsXp +gsXFtHa95XwevXmzKAGLyBSww4icBBABAgAGBQJW7nvhAAoJECJ7pcrx9CzMwx0EAKuY+Jyz +l3OoEFlbMh6f/eL6lab6ow3ii2wzzq9ReazR8wEuuOXYfXHTWUE7icW2j+eAhoKMPHFHcksG +JJRQL51puNGW7HZvmIzysUQbpRr64dsao+2Pg+4Eb6TTAJjphlEq9Hh8JSDvoHrulepN6XN1 +4Lkrp/ElT+BL0Sc+6LtWiJwEEAECAAYFAlbue+QACgkQd7f2RN4Xt+5maAP/UjnNvGfqWeaM +Klv21z5o2k8Vs9V3Q3XiIORwwcY0f7aDrjJ7YSkDvGVux9J27EcZinPSSsdSFoLF6j3xccnp +ygCjo4dXac4wXGdVpN4eNtwP+/eshLUlJIoaXVa4YY5oxtjLNtHkjraRyOMJkN+MDV24eQ4z ++QptJzqNlvSafJmInAQQAQIABgUCVu575wAKCRBPDIOlEhEKGbpeA/9kZ6sKBCML2qlgHd3n +nm4Y5rCYIIBVK5Rf/wFxhHBjsKh98So4eCR18SKELgHvBxVGH6POXtKifyCnQ1al2eMthIbv +hGQblXJfqswJKF312x23R6Nhz0y99QQo18PCQSfLx4PnufcN/ZxXK0JDf1eo89M93TJJy0b/ +ZxvpmwmujIicBBABAgAGBQJW7nvqAAoJEJS8j99CZNqAgisD/A+EFP9rxCBZt2aFq7i9rLP1 +otKqJ0CcjvFtSg4MpthZiXBibT54QuEF/wyU5dNwg567GvZR6vqpiQ4RTDqhFpHIMxoMYXsI +f/R6rSsvOwF+Dg0tyVgbdjjY06XPGyNUP7d9L4tlgLB0a0kzk6grs9GeM7khjbjdwD5qPRtR +MawKiJwEEAECAAYFAlbue+0ACgkQpee2a/fVoAqk+AP/UKdu89bM0ubLQbkiwJaMoUh8AEmJ +B2FR9d9WlY4CmycgGogI8HPdBIMVZ1lFdSttzQWgki1bwMtOUDBGiTX882ezmt2DVzPNbQui +pbdFZCShlN3QVrPyh+XkiDH/4+JnEgGFmriIXSQXLCJcxGnnekD1G9QQYkUKzILsJM0dTLOI +nAQQAQIABgUCVu577wAKCRDCjQ5dHb08B9q3A/9cheq1aeC5yNLtPtepHS8ZgJwGFHSWflRf +WVpFA1LLTCOnWWVlNQDAXIbbiulO2c7iXidMr8EbxTLU99B6hCP56Cnax4W2rEhZpub8Bbj0 +FiSzCmWBucOwCqd+zHfUmA8eOldvDc2uI6re0p6TZl7RzyK0lWlQgVQpTZHFWoxLTIicBBAB +AgAGBQJW7nvyAAoJEPCSEkxRlFwTopAEALhZas6LqR4YyQRb5tZPu9LkHMjhR3f/Tzf08F7c +4YHtdgYWdmivzRlf4+Jok4axowOTf+pjSayXTiYaeq4VRMIPbL44UzWSZipyxtc5rr1GG6Xl +IeDdkRB0d+RvVEvYzX7FbaCWfveYPQzaHiOsYjQeR8uoX6ybTr5BfH9csPpJiJwEEAECAAYF +Albue/UACgkQgzbRtkpkkaoECQP8DZPg0fIsgfx2OhNKeB3HI/JQziBvgTUmtgPi4B4WrLnB +GtZCGJ2F2PHzhGn4NenfsfCrEuqQWqMYa1bcSarE4oY3uq6KJ9iwXw1K2q4qGbzpmVzyeaHf +Dz9L10E6iNEfChfsaGVO2vNgyUohFvBmWvlaFABlDmGNGK6Rwah/9HWInAQQAQIABgUCVu57 ++AAKCRD9oaTxFEP8fh22A/0WWZQpPfwX3Jr5JPrbY5/uPsMivkZEqxfw08r5JJpRB+NMjANQ +uxFKNjl4T5EQ1eiBhy9rk0DoP6Fti6H0qGJCpJlv6EWhcU0R8o55o+VZojKsvSqHchZy+vYC +pM1xa3Zrwt0eVBoN/9yoNC+KXb7mUvhdMeEdpCOuexMZAsU7U4icBBABAgAGBQJW7nv6AAoJ +EKw0ZeXHgR0ZJBsD+wXJRWlUBPXfqmfPnYUFuC1aBBwWhHHAp1MiGcODGOAc+KFWU73ubAC+ +XgTXRBYlrAbBfQhF/mqbjCJSIZnqNFUG/wDZ5Qx+Gi9Av3cMn6cLj9GTfQ6w8JwdjUVpJmXE +7Nhsw+ag9cBRODnXMyemuAp3dJBLYKmD2yemcYV4PSmViJwEEAECAAYFAlbue/0ACgkQX+E5 +IYJLSOh4dAP+IsXglaytF4P0fmg2i/xvFQOEP2+KRSNnpS1KVQiseb1pTL9bPGP+SW48JgiE +CU6CIjE51KGIwt1ZOamiUcGWAzFwPwZqCl2By+4rPsyKVSPx6HZ6VremwZG45l9HEEOdQQNr +bQebf7SzLxLqt1qLc4/rsXNxEa+XAL0bnVt0ekyInAQQAQIABgUCVu58AAAKCRDGBKpVs38A +3io3BACT4R308GMOfEJjDJkENYKKMYn9be37j4DqEslBcVRfIEHs11zWspeCSm0EYFlmoljL +9FNGhBU5KkA6m75yhfrLOzZbQKekw7QYdXCe1QGko5JF14wsK2OfvN0SWRmFQS0oT7y6yBrQ +2HclBwLdVPn501zQjPq6tSol4bJ2+kwcYIicBBABAgAGBQJW7nwDAAoJELJPvTkzZ4Yy8usE +AJrjFX20Hnd4fvWvcgg4DANyaZS3j86wPJcGSnBvKufF65EnlGv/VN5tvXIpxwg9vZyDfB5m +OE8CFaUb4W/hz+TYW6bpefT+b7XpXEux1JqLOwtUtrA0t6ZoV37gqykDPetHhTXQ1irKdphn +iNJKgdKmDqgQWbTI00176WOdotG3iJwEEAECAAYFAlbufAYACgkQpQaTEjU2BGYmrQP+JiDs +5/JESZl2xgshhLF40nlvwWqPIb6VH4vkB3AKCHg7oSIqMvNai2p7VGjhpJNorGkloEfk9Y8O +ezotBatNzSDEPHts/4ciw/65M/QBEMBURQjb/VtIg5y21JuBcjPQliZV4yNXwHo4umBX7O0z +PFcsGSvbuEeCJhK/4XqgH4qInAQQAQIABgUCVu58CAAKCRAGh7XTYnnYjIHQBADZIcq4Pxp4 +/7jE2fNywiGnCs04pVJNfZ8abRwwnzvcWA9vYPF+8saJITjiYV8PBKCaQJhGWkEvoyYsron1 +AKyhXj2of4nCfCKy5cojiwKT3i6H8JmNo2QP6SfCCQZa3iRqA3RTnOikYDUUbkk81Hpp49/M +SdywV0qjVRH0QjZGHoicBBABAgAGBQJW7nwLAAoJEFZBVzqaRL9peosEALWJOScOViiSFHiL +wDulirMvNeAxmLjD1Y8ofbec27FJRd+PRqbZah8x+ro7tranrqKaMFYVz4ZhWLOgAp7v1Yfh +NF0fTWRFTOzUGwBIAe1llfTSuP+q1HjRL+DfaJUYcumTg5WYS134dHYNcO1swsXZA4/vI+SF +cXxJW9mjpW+qiJwEEAECAAYFAlbufA4ACgkQ6f4kO4EGChVolgP+OJqvhLEP8y09td9xK5B8 +nc4V9I10VTOKjc3U0c6XnvQktRtOsoWhReKkkqEw8mXTO4D+YKL3/Nu6ZjbXf1u7nqLGfNua +Z+BpSg8xBtr7vBDV98DSv94zER83RLF+sByGgcopX2B5Im3slKSPeCZhqtHXIAc3SPthm/mG +7VBzOoGInAQQAQIABgUCVu58EQAKCRBG95u9EqjOTXmcBACFh5oa72rQmXpLAmNPs2sEYflu +nNwo/TQaOIjWh2Q9ixK6P973iEFe9I9TGpiBItPG62eKobxPWn+hjcCzUcGuHN7AuImza4Ea +MGJ25x1csH1PjoHV5vDyWQXJb6BSdjaGmv5qrt8lVIdlYr/H3aq2MsJ3bn3nDwAcfh7ItC1S +aYicBBABAgAGBQJW7nwUAAoJEN3lly4nsyOjAeQEAJ80XicRmmTqZJK/nNko/7vgkqJssblG +iS69bjTIJ4Rhyu/JLlgZXETP616StBqbjL4ysGC4fiedCS02O+OKrk7tOe1Tb72tQIQeYxc0 +QRdJhWJ7DglWQ54CET73iPxdOSdUP41fbL69okNIBvTGeTPKyUR+71Bdft3paINiqG9MiJwE +EAECAAYFAlbufBcACgkQeMvd0oX0HlVUpgQAjglV1zBYEZXKrIo8Fv5yPgiRfrbH+EbcZ/m7 +LX0/QzuIHAip3aBmcrZI9D6QsOdOnF+3ksyvG2x3wqTewxp0yLbJf/qDXDJ3sNcvbWEkM/V8 +eUjhPai5Qa0QhMxbPtukca07DVwOTjnNl//g0ytwImXJeX/7WKwlxyNqoZ8FC7qInAQQAQIA +BgUCVu58GQAKCRCGFwSJ25T4p/bkA/43RFvWU7UZbE3x9iJUydDFVyoDDr2/2dVHIKvR9bpt +F1RxT/Dfvb8dOBPWszD36P2gE2U34Cu7q9qEF097u4G+xlPMmlynVvmtdooKn7OS8idv2cNp +9sIfcb4d7Mt+s0N8TvTbFrl52YtFZj4U9liCNHFjR4z1jMCIX7EeiQJYKIicBBABAgAGBQJW +7nwcAAoJEMqAiUtEBAP1RFEEAKRgUaxfb2PQM9ypEB06BwAXTiH0aJxRRCbfojFK8fZBus6A +5HKQLIzYEpvbBLSp3dANi8v6mxvi3rqcTNDHcAP5LHeCLZp07Ur67nj0xt6gO347FbBybt3Y +iMBXYnbkwvtu0r8yCNtnshQoTKh7IorloYAA6B/WPOk9NFphSoIoiJwEEAECAAYFAlbufB8A +CgkQuPIX/dROZJom6gP+KAwKHh7wtXHr7SwFfjvCPDjGFkQAJD+IdVGZVL3trVj/SRKi3Be4 +xSr2bzRij8RAOW709Rpwj/AZf224ynJTAliawUQ51/V0J6F739jeyVWbMxTm/I0wDLdcj4JO ++RTsZs/P3qlrQhFrQTHIKxHwRYIZxT/zLLGmrzu1SKbNGZ2InAQQAQIABgUCVu58IgAKCRCt +tRLe3WX4qsBaA/4lLamtsFzkqfq4zCYt5rtlXQnhM5mEHRjGzzP0NTym1LJYkwCKtH+6Pkjt +Dz9ugiXed7S5jubinjEquUyvEtmPbz37K+YEYBYJv8dwfRRZmiXP0hfzhMAe9lWqiNhxwYmX +EfJ36UC5IdV5Bc/4W+dDZsBt4uXVtPi7DBqyDL0SgIicBBABAgAGBQJW7nwkAAoJEI0Lnt7t +g7QcX3ID/jUkEzdu/FdoEwxgstWrOMYWGPTlOyBVodzAWsC5SEbOLu/HHmhJAYftU85Xd4FL +S2ajqY9ewtRQtD4j2smU05cLaEbZ86PkAjn3eQoSfNURp6k491GHXlQM5LY4f6cqYh2Mw6hO +CEM/boaJnezE0b6h5QkTwsZZRxNSbHxkygxPiJwEEAECAAYFAlbufCcACgkQETpRl4Y0yobQ ++gP9GzG76KAUQSNneS66MMeVrVCEbq8RGl5uARC4Mq9+A1vB99lm1UBGjiVim3ovg97shkyW +eNV1cCfwDCCgWDz7Zb2eKDiLzl/5qPEmmGu/9DR/TPfDCho/ucRY6IP2kt8luxv6Twz6DrB/ +WnfBchNTOL+N/WBcft06ykn3DvKenjGInAQQAQIABgUCVu58KgAKCRBOTgMvHrGpZocgA/46 +aVZv3ZmAIeOP8IphevRiF3igSdFF/SYEhKyBQpJpz1CO2/5dZxMW/NOK1+0pNxz8geCHHjPQ +rohxZllUb4LYSvInNbdcWl6N3bhi96MaoLzWqsIxzV59MshWOEic7/eKZdAoJHBa166A81xk +h6AmEEBWz1n+cvCZf7lIXCtIfIicBBABAgAGBQJW7nwtAAoJEGFrpG93Zte/sTID/iOxmzOK +fll56Km6TfXd3CTfLq4SYDb10AyLbJKJmIgyzM3PzfydcYG39x/3hys7BUpjYo0PUFUS908t +iKlsIjDxcpzdluVKEVQgNABomzrmJbH7BpXzVHJaKo9o6hy0iVoj1CsBcYI8ztsGc6oL0cSZ +3MzYrRJY3CTXk6TgPXkaiJwEEAECAAYFAlbufDAACgkQksQ6ZgStt1efQwP9Gnm/VTBvur3P +k225E1wTS5I03ZMjyMocbWp6u1N2tU6jzxlUML3utHpFnz5FBhpmkBM92Pr3gJmOND5B91gx +i/MkooubukGyRTjaTPUqtuubITeAwBNH6jPKHcEl6sMSPI5An9S782mzK8TkPbCrHcnbf2Cb +jF9SRvp4ng8ARWGInAQQAQIABgUCVu58MgAKCRCq+MFkYqH7643iA/9EnrIFcOBbUgW2szdv +bzKFo+ajowm4FBB9G9CM6EZ1XxmNwr1GTlJQIwiGDhd+zWOf6XeV16O6FrRSPShaHoNMhRtw +96mWMi916HSsZcsrKxAzhgcAYcuOTQtTatHI7t6RJV8XWV1vlWpSz4zvkQLj770X8jsY1D5z +AXl6NfD/KYicBBABAgAGBQJW7nw1AAoJECMaa09Q3TN/xMsEAI0dPxCHBtdd7dPihlIlhiQA +/88bGG3FuOylry+3A3KzyCA/Gb8uN0lAForhhXYpOcZtqbm+459BLrIRfYQJ8QMoXr7lscxR +eoeg8rAfEp423sYlII+KbiA7ozJszpwxsWaArtMxWOFeeOr9SvO1W1GiIkM/Z9Uj4Q/sbJb5 +n7I4iJwEEAECAAYFAlbufDgACgkQHZ4SngNovxqeJgP/XT1lQ+gYYC+WuCJuj4LSDDFIGiXx +6iEL63JvnCjH7hQJlKYMFVHg07cwd97f3J8pDaK7HTZ58O7I7bN8NJl/QXzUXVJsFHRgV5hY +DswV1ntjdVZKHgV8uYTj5PKO2/3K5M2CQZokGTCwuQhPiei/FRp+pc/8DmIAyknt77mUG6uI +nAQQAQIABgUCVu58OwAKCRCBIa4SG88/bT7KA/wIstCMcw0dcOwkJlB26HUhG6uAoA8xDV+S +Tpvzdk3AU5sqOpRBdgZZU8GCKw1rhuGYpTfGs+uVVT1gbJ0R/GML08JiMgbpnkwylmXNhEsB +9Dd1OBrIET+BRfPgWRia2CF7LleQA0zOnb857CY2LtM2Ye4hGHLZsIr3vE1G1Ytj7YicBBAB +AgAGBQJW7nw+AAoJEHE4jY6KrBug9LED/jdp99i7KsuG3beE3rPtkXeIi59mbp9xG/T7US2x +8pCSq9cHJ2LFXT11rTCNWvN/l0Sw5YdDUoRQL270U06EWfqHOSlaOc/RfWr+81e14CS0XtZ2 +2j5TJqMk5SlKi7z4MGv8FGEWsA5I5azA4c3TFWPzEWr6IrHTwciRUXMr5c6FiJwEEAECAAYF +AlbufEAACgkQ1nsIL/JuI+/v9AP/acKjLfCgogzjVNaXdqqQQXkfZwipY7orDXe4mrU0QT4V +uV84wEn+7M51bIUDWk8MM3dQVUH7om2vNVvixEGEqdZFs3RSPoATtRVyXpmycCtuhGr5kPjz +es79sXw4lDuY4axHzTzzAqqgad0WqM4as6Nu7NZzMY2r3qQ0JS5MneiInAQQAQIABgUCVu58 +QwAKCRDfb5/YC6tTewW9A/0fkoxZWnVN40HVy91kzSP6dubWUw/Tff/qTpQDi6GpBEFcHo1c +6RHHlzex0duTrFVkcbCb60xaJbjZX3g9QMHnKPe0UIF8SRGfFIeHFXWorEjToHwGF/yi8Ca0 +Lu+n3ldhR+qNxqgiNuOeooZFQE0UYyEFr9ATG/SwFVQdVaXzEIicBBABAgAGBQJW7nxGAAoJ +ED47t22CmKB11IUEAIYxDvU4hzHSzD0sUyxNMQiUFNwgCJl+Duw1WugvTgHTmlIjshz22wyj +j0qGO+Q0sTJP9BHJCDykjt5mlkZ99gx6+Xznfcc4IYMqrs4yFf+tD8NfIFyAE2/JG2CrbjZs +ZmwbCyT/4wUCFHcEbRdfINKmqBuZqx6dY4Hk4TzeBat4iJwEEAECAAYFAlbufEkACgkQTpQB +KJEpQYt8LgQAjpTmB9UmFXrzona+jN5cwg4SBeutYezXb6IW2BTHKfwd1+p/dRy6zyjyQ12k +6OgDoc2EPQ830i0IsZegFv+RhlvrYcf8DY3KXPWcnF9meLBP+fUlP/PUlZXVMY2Uhzblg9aO +tMWQY2VNVyOgtU5R7Sv23RWIe8814OqT8yOi9mGInAQQAQIABgUCVu58TAAKCRAZS1j69jy3 ++ks3A/9woO4z/IN3OM9mkIuTaHQDHsFPHJqyGN8TSaU76UhoTu/kcYCWFUEBkbY3xml2xISO +HAGAfeXfMuAnR4OYbTUX+CI/WiY7tCxVaBrKZDFRA2tHG7R/aAv3TzVn4hg/8fIvka6grDfR +IGD8VcGh5/AXqFfkF171ts4DfO9JmCrLPIicBBABAgAGBQJW7nxOAAoJEKeMgreiRsyyP7AD +/jgL9DvN0FYMsRMDDSs1ufvTiHk4DkgP/verQv/O3HkzYw6RpaNYfusUdOUFn30+sMFpsMD5 +RRaN1UHuTPF5bwKQZ3CX4ynAHgCUY8BCYsJhON/Cb8tir3uRfKP9lSn7BikO6HhmPDN2t02K +L/lPI9GtG9bFUFt1xgJampxC0EJOiJwEEAECAAYFAlbufFEACgkQWCUKC8EXiKYTkQP9GdrW +XtllGQItXAPfXhsjh0fUd3f65RSMFxT5cLPHHk2XUlO+iMNm4HwoStGBAmnsGF0BWCLx1Z/r +1sTUsC6w230z0XuRNmNfYkA7GBwUUapsAZBbF95FN8JARD5Uupg593lDzXy7vUzoRyqsA/ig +21Wq9Hzr1rCVha6EVEwQ3xmInAQQAQIABgUCVu58VAAKCRD3xwLSnbEb00UoA/92T+8L0oQC +vhRiYtQ8vTVxy0nYouSkTzJ7SwD+x8BylB6ztLSd2Cb+DY80avSSUgB38knOGufCgpR/mu7n +E4RIhTgeK6mjeQwqPkAkJTb8XYJhwaiBU1tCH5hALmTkPC/d9EWhDixDyDC9kE6RhneTBwOE +BNfyuLFvOt+DFr0Yd4icBBABAgAGBQJW7nxXAAoJEGXfjbz+aRmpp4EEAJHBckLp50oUq9Kh +f5r9omN+RAhbIq3cbeM6JTj4Y7mr38wQW/qlxY2mLT3DeVzFjrNybYB/Uu1h8Uonx1L3qwPn +aNrJKXJ6GsqUNJr3/Z3OA24GZYckPHIHrsV2Z8igEhCeCZB+WUXiEegKwgceP7sr11r4/R50 +W7F4BkYOVGRYiJwEEAECAAYFAlbufFoACgkQDLENxLt+hu0yxwP/Tzvz9h1Pr9K6tVjJKBr/ +n0H7Aa4GmEgmtI8MtQDFtbmpdSsgSCTkPtdfy+NNTO7pdigD8bt4yDe6cvIhpXW4Uubjuzh7 +hPrUI6eLpCwKIDN5pLEO/2L1d3955QqPUncSUm6sx6T1KNFjmp+97lHbqJ5EHsRoS5yExHZJ +uI6954iInAQQAQIABgUCVu58XQAKCRDCbM+ZjFsttKPBA/0aI2nyNyIU0tuDkHWL+uN9Dg0c +h25tUsLRxF+GJi2HfKpKyXGF8gpVQEHkVVTtd6dqPwGxdyODmT1IwABj5fwbwqnTA38QYkCb +CsOCiA9hFVEKM5QdJEDM4yI2WuuA/CxHZMGvbyyZgCvXpKNkbJmwcI4qXKUrU1X/sgq3OpRy +6YicBBABAgAGBQJW7nxfAAoJEEiprQQgW41C7NYD/iU10rT9Q01P5WYtUmp+GGC3532hJ3AO +29aE7VhzRyrofpGroVqr82FL4WDZkvyDaNiIIc2+VRdRH9ZjeFy4W3V/Y+MxC9YzlJglHSjh +ZVDMjQzerb8KoBhjXlL4QAB2kd/t4/aq0p3dkAkZsv43+kOnI5+Xyh1CZ1a0z3I9bT1BiJwE +EAECAAYFAlbufGIACgkQbZeHeQZVdczPWAP/X0Xf1tOXefH+GipBNmS6HNtzrQZqd9eX9L7I +5MxhtN0BF9rjfw6hhOgqp8j8wY/2/yBpAfBgiUTdbtJ7pdovqFWaTJC9N07RLEL9/B/WB8zR +D3na8gciG8eg+BasJJ2K4Cpm8G0PJjTEfPsGsq44jwFPkp6iagkXE0yuUwMmWNmInAQQAQIA +BgUCVu58ZQAKCRD8tzIcZ7tZzakjBACIwYuaSmqrv9rIRkkL0JNlLwR+RwMhgyCOpc5Ym02y +tE8p5TtGdALQKOUS3tYi4dJeDSBKngDgpoZPpImaQk9e5fdgznBj9LTYSvUCA4kBblSWcUF3 +ALousm+wmOPnMovNLZ6jT7ehAnxxxlu1TI0ymV7gLe6hAKGFAMbCb9wUaYicBBABAgAGBQJW +7nxoAAoJEO0L/9ftFVovtRUD/RoxxkNu0+GKx1dURZWD5dFa/bqOz4mStHLoaGaBuH2fGTWB +ehNfm607YHkQi7SMFD+2LZ0THkPQXgND5Hp04RkMIyAOnxtxYwuRyr/DiPWzd9acdkxg49zv +LD2S919MrOtRXHJeRdxRGPr1fyEo931sqziR5xraxR3ydhvu3t+MiJwEEAECAAYFAlbufGoA +CgkQ7mIv0LosN4b4LQP/QjjLgw0xLCn0oV2B+jWsPvC9xaEFxGPs1m+UN3Nhe4s91kspivmh +7hYQ0U5J0UiAH5URhy+nVYnur0StxzblX8YqkuY8UigBWzTXfsaZCcKnlbdH3Qvnx2g96S8L +RVapOYk0d2d15rKqxTyoSLc8Bkh6ItrG20mOpFfbmI46m2mInAQQAQIABgUCVu58bQAKCRBz +zhzZjDhfavE7A/0bQOEWhBsQfgKxaeSJ3mM/7XFZPX4L6lqIPRaMhll0RhkYTKhuWjd5gYrp +ZVLEZDEfgas8PEAApuGWVz+NHr0dsAdAvWOvl0N0iu/Nr2xBwEbNp8fBGu+RvnXWtI4Q09Y3 +tluvCSgSb5f/U98/DzhPFPKIEJjiOBkxr+/FRARMgYicBBABAgAGBQJW7nxwAAoJEMJFuQSq +9V27HyMD/3606HCzFFU1Ihn0Dy2rc51KthOjHPoCCjXR0ljk+sYtSAgV13jcuZt2WXQxV33L +e6RXhCDtxjSSZBwbUUwf6V+zhogCIkUoOP6kbT1B06etS44DWha2lizL8JUv91mW7UqMmdpU +OAAFY5VYN/BwwyUra7du+oyZiKw9CDs5SBTSiJwEEAECAAYFAlbufHMACgkQq1MddY1y0CH1 +3QP9G8QxgbLX+iU3KanLdF+bTaUt8sNmCRrE+7qcXQU6GQq/SkpyzbwsVLQvTxg9gBaG3ry+ +I5rFGyYl1MhmvstLBchXkzWD8NEOZV7LHXP5RRVHtjvcZ7oFnD9pgyEJamX8sOcrfNtobPw5 +b9lVPwrTM3Xbsk58zQ+fyhUIyVZnk32InAQQAQIABgUCVu58dgAKCRAEcIY5Zvbiv6vlBACY +ligXFlkVWP8Owcz7tUwTLwGTApQbn1QkfWK7hgvT1MpZjPHm3G0hQ5vuVa11MDfdrA7lJ3L4 +KcgYRJ2Sxy19NwQt7g4n6DOkQCG9PxOgE8d/qsbScMn+y1c27/yWw0yKmEsiHcTnYBa9jXf2 +03upqrALQu4o3GhZFVKwzFecNYicBBABAgAGBQJW7nx4AAoJEDUz2kfXZjNE3CYD/0Vx61rX +oaRLEAk0vQUKrjQ8LeShH9SnmQs9DNlq7GTgqBv0G71HHgx+jQYcgorZBA3yzu+SdPirYVlm +GU9FY6LNL5BSLlTkdTjnIOGnmc/rGajPDeM1ez02yUeSm999LyRLxoB4X500rT1mfVIepDQq +kBjeKyoqI0EjqyQMSIcZiJwEEAECAAYFAlbufHsACgkQ3ltvfEuf+hwcZwQAhPeL8g7ZdBga +IWiguOcLEmlpEODTJdBPq1G0bxumhVBjl4eDLTSVfutmzT43qgMq6yBU+3HvuDkznbIffo3e +G+mJZI+LVOEkuQt56Oyp2UX5B/vg4kPispS9ZdpomRKlC6ligdg0MskeAm090u13fkzvAXq+ +HMqHxn6EiLZQTJ6InAQQAQIABgUCVu58fgAKCRBqiCJEw176vN0WA/0YUjGv5AO7d375HYAc +nx4pmONySXiKVHjmiMdYpe04S10b2ux1ViryOUosisnm83cYY4jPTah9P/FNOIEYSV0vPY3d +Z2mljD473PYpao/zMvmpSW8EldCFpyceeaSqXiQLTSSa7/W54Frz0d24WLIIaB1gf/KRkZar +0A7uFz7XCYicBBABAgAGBQJW7nyBAAoJEHdvGv/1eCdBI3YD/R3vO9qJPJ9F8Khap2MJ8hFk +nXqXMa9O/z2UtlDVPbIBw8/r1ZrmhzvYLa1SNGpkceGws/kHJlV4euBQgP4mw7xPKkmIZPc6 ++WI2o1OM6Q0S1XJVrs6KgJ63BUc8MA+UkGDMsS370pOcAW6ZEZ801v378pou9z++rTA3bJII +EcPiiJwEEAECAAYFAlbufIQACgkQFoioeky6xs0EyAP+IpLVY7g0OSxmcq2DUesueiCUt2P+ +MHI2axEBqmNS/lfBDbvIcbsMthNW0TWQ/FAuyEELDdPZof3ZaJ6DmSCyda1bjhXc6i2vXWGi +MRpDLJvzQyWt1BHTk9YRdp8oz+0GSKy3KlKEG7lOlLrZqwsQ9X6/6c3CBtXoFnQIsxBv0xGI +nAQQAQIABgUCVu58hgAKCRBRO2HFim/DHlzKA/0XJ+DpKDiGjFs5b58QuYgRO7AInCGkQa5H ++b6v2TL1P3HIJhW8GJjZYpt1U69H59NODlkRaURYUZfXvFMExQZGmie85oSi7wBR3c4Ux4Tl +ZIyaQK6XkBXFv7GNbjwtd1hhQ98WlEXKekiQHwRrRWmh3teBtKrxs/5+AgH6/e7FcoicBBAB +AgAGBQJW7nyJAAoJEMewLtkQIydeOckD/1ENIpckge/ls/b5g8XqspWayv5Y2vDhmDfITzqS +6ZVw+QnQMZ0Gg4X8tR3hE1XOqoELdGE3+1f4snvVBn0WI90Wq91P6gBlqCljJR5i1vhqfsf5 +2vyheYFdVRgubgX3FT+kUpw0l0AY9Jpg3BaXF6arkwxb3dVOICbF5eg3R+xGiJwEEAECAAYF +AlbufIwACgkQdkJPSF0+/mFqfAQAvcqplmL4Jl6yCK3OY/ZzQnNh2cM8uUiBl1QgP2TsTgG0 +DEphpZvGmrIQswo4x8nodXcQja4RdnQSIQ7JFG5RcK4xo2pGLeXaGzqvIl5sumuk9CksXa6P +eWrJjBja10qNXpK+8JePg2jBku1g1SFNdWfAshWO0T03drEAxwvGkUSInAQQAQIABgUCVu58 +jwAKCRA9XGmvlojSZOnYBAChhgSz1DtwfXVi4wZaDSODesHcui0COoIlEkXAu8fs7BDXlUmx +NJA84qPtT34PwOMZUS86Ge3/QUhJuRzFT4Arp9Z0T/FsExSn0+MYzAGZoe1ZNIYJKw4QkDuz +v5nOHrbAzYC7os345RP9x/BV6to/Ppj8oVonsq2fMH1C8MGaWIicBBABAgAGBQJW7nySAAoJ +EOx9wwBbqx7hOxIEAJwV+FP+cPPHSdjq+8hnPh4bNb/tmtdKpyz6XIIMwkiTXobFWPJOfM/t +RExp2ESd9nWc7rwTj+CGVEVvyixxIZFqGDxoO3NwphB5EbeBNB3hFoKJkKYDQd1auoxKNfV7 +vrpnuQ/gUFJedYSkyPCPwMR2bGBfhuWRTTowDsKhZIsxiJwEEAECAAYFAlbufJUACgkQWrHg +LmmlzyvNigQAgF7PGIxqwH81jetBaEw0WpBPdlGH0UsmuQ6YfHOo8LmokzbWNEaahbad8t5J +vrg5bxwrHADGj2j4OVHE3WgKslRmzkSSATVQkFNFhMhM4TLedOA8emn9cn1qg4wuKtVNOKkQ +ONxcs3u6LLEYdFdfjxQxvSJjmDvvhaJ+PdZSvbCInAQQAQIABgUCVu58mAAKCRAMIdIA882S +KoMGA/9+FtwZyLijCNxTr3EAKXzVGA7QJFswVRG+3wipQ1Y4xGtXlT5Grx/MB++9+rMB7kaC +m2K7o1DoNXcRuhKDJ0mUEFQYblW7WL5PiqjYp7LtRBjLJLiLTiAb1CFu/3qtKJ3b7OAl2vEk +/1eyq6nDQvtuz06PpNTm6OHNpv7I4yPF1oicBBABAgAGBQJW7nyaAAoJEOC7bINy0DjNhIoE +AIz72YSUB2kww6lpIJehl9bFR60g3OsN5HZUaVig6RkgncMPfQqHDPwCaNCD6Mwj/KRSX+Xk +UeWFBGXz9v+FlJn43QQVxArei9K0f9fAwpe/veFUbst2i9VbwliV868DpMC64njjskY74jnT +GZWnDzABFfRiknm/yLCn79DtmFlgiJwEEAECAAYFAlbufJ0ACgkQK0QsWCfA11gqEQP+P8U+ +uD7TCnaAD/BnxF479PkOfNMYV6bbVESuuY0piJIl4p16MPf69z31lsjPu/jVbvrzXaojuc5S +RTKN+lGyLEQrhuiFzFVEzZtGM+y3bHl7CiGMoUaS6duEEIyIa6hsOfldTgudMeAlvcoqOn5C +6mLssaL6N4vNVZj6r88O9QaInAQQAQIABgUCVu58oAAKCRBhAM6URbWSHdCpBACDkzKmqPvD +FzFoDWeTcfj8U2SIWJ+yXSnfxyVjo/QINUHCzKg4N97t9s87eZFsl74ukkLcpFX4cYEa3bTR +iwSSutyPMcbx+i0TmHetiB7dUGnrlW+is6w7ITdG2ttpO9+7HuoXkK2wHLIx4NrOjV0xuYdJ +IgcaPaCF/fvfgRLGRoicBBABAgAGBQJW7nyjAAoJEDziS4NSCPQsZbQEAKOg+Df8VMwQFoln +xWnGng56+9qdU2t3GGuN96SI8nXA3ilkgL2js+bnB68hh/WKfjQ5o/f4+8hDyUCU3avqnZ9J +S8H5BEzITTiWBl4yNzOaP1RbacBeZRAlREtpgxBEXc5Ezvn59LnWt2ee1a4AoEvmmRgKH5fA +jpmkLlWhH3laiJwEEAECAAYFAlbufKYACgkQRYVJRzQJ2pBSQgP/QuxQiozLw2pYzOu09qYc +UYP9TVSOEqQqtF+uENHIq6BVfEI67TE7UmgbtPSkV1laJPTJ66d3S8TCod8qKPQ9V5SWd9Ng +CCbUPPUx4D1fcT5/ZiNFW74yDhtNn0TsSEc69D7UrONl8Gb+up5iMXPnFfRyWNO2ksA+ehnh +/dBeGlqInAQQAQIABgUCVu58qQAKCRB31RRcs49KJNkkA/4/LKdQx6IlU96qRzq8NFTiOL/X +sCDGzLn5MUum3lSZ63KkJ0AxzJboEinBrdQ1sTguUbiUTyva6Fwbn7TIk5spplTcngY6iv8i +7Bl5IA/T6T2g9puzyIat0mQznaPIkFj/ppl/LVbCoSMOm1iXtc8z1p+tGanU3ffwT53whOot +CYicBBABAgAGBQJW7nysAAoJEFBM0OQU/0nMSssD/0fs24Hl9Z0lbUM7A5LvMdXt9YR3RnJW +PlOO1YBEoGCttfBeheCitv4HlFzWlBcLF+k9vsOc4zM72jIvri5HDtjZkx23F5ku2v1rtVmc +ALq/kLkGfbl7T+gp/6FeJ2N2asUasvfBYLZTwSKuSwB9QbQy4EaXaYqbLeMUei/5W7AuiJwE +EAECAAYFAlbufK4ACgkQ7z5UOZ+UjY4jjQP/anPsreWK8QIydIsetf2mhlyiXLg3NuWT2md5 +y61XMRUWXtkpIVZkoFR66oVUcC09EF+Njj8Y2jp1pK5Zj8yJ0b+FCSzeqpQY3GhAoZ8kC4uB +O6zXHP+Gak4n7eOJg7KjmKDZX+EIia2AqUy2wMGGzF8Nc/6gDS5aNScqRAGvNuSInAQQAQIA +BgUCVu58sQAKCRB1wUxUVt5nu94qA/wKGZuQfWKRyhvx+/ozl+nJYipLARfM1pRY4JAd85su +TRuMor5zrSKe7/scbbmaAL0kelIDsjfRxjRAVr0mHF/FFg9tl7AJov4Xs7fmEvvZT7fAG5m8 +OSa8mopPoGD1Ig9+CwP05qVD8tt7vGGJgVgTInTzTkfnB2Drg4GAULMJZIicBBABAgAGBQJW +7ny0AAoJECGxJYyxK6RU+tgEAJIF+a5HIgwjmZ64EqijtimIRf5kmL/xxOedw0FNfA7pt6l7 +7aDLdRi+ffOMZdhsqZ50HZJZnwOTBHCHyu3c6PM/KRKPByHJ38mITobfG31kTo/GDReCiG+m +8U2NXpt1+ERdqKibs/v1Id04P3VZGY2f+BdvAkKzQK0afnJG9kEliJwEEAECAAYFAlbufLcA +CgkQCx4jj3HfhJ44fwP8DYLA3K9Jd6NLgixxzdFr5Wq3Cwzq7OKuXDdocU5mS8DSXqIreZj7 +37AGanW298OHQ8NiALxoBshUoWBngogtxZH0eQzaRdcclnXJeb2t/l8Q3oNqmScyYnPbKhO0 +7TMlXf/AcFv0ixa5DJPmAtxnwREPACXBzkbotnu98dVZFHmInAQQAQIABgUCVu58ugAKCRAm +ZaCR2/Hs6m+rBACr/XQU/ReNLVLpWBSRJSjFPWOWy3x5We1SZQxCCvMYdtq3xoc30x7WxtCP +TV9sijzjn6Nz7/hP5J45Lb49YBqVINsAYmmh4fMtMQ6uSsggADSbolwcXvS66PVylB9KJqSR +MjowldlaLlK+K/ArdrNA61oxqbRjzm4uNi2s8IBTB4icBBABAgAGBQJW7ny9AAoJEEZ06LDP +9mJYz8ED/Ro3OW7qQKtpEx05H3MBN73O1MfwMmq4DZuqrRq0dTX+SfzdWw5pffEnve1I+gxP +2VeylCk8RV6YfUc702YkJaEzS1bUSp8EdQ5dCUmJ6u0rujtqFxDnZERLDZnGyUJvDt6S0HAY +O01mJDGhyz+MYtOC37sH1q+FOw0PjLiflllSiJwEEAECAAYFAlbufL8ACgkQz6HPmDieb46e +UAP/Q9HYNRd/Tq8DKMqP74AwSxSDUkWi7sSmvRM77Pve900YgUCZQ9wivgdgWWKNcpXmEhve +rklCmC5olaEkNLavDGY+TRLEkMa2NTM+2iuV1g7G8r1IdXqpxT17lqY6GLKuv7zqWkjWIOm7 +LyIIa85NtPM9gDQZgpgCZJaZmWaHGMmInAQQAQIABgUCVu58wgAKCRAdE9DWbOCngzA3BACf +HIp3PGo830uqv0/JLhyuKVo4fN3aPNyCnv29o3OfIwd2OFLWhUBPVZsGsyn1y5dZiSaFyGU5 +ZitClVitAoLaFdQ5+O0CIh8nDzRtIVASsyacIu0WBq9QkizC2AkaKcOyjJhx/EH2AIKcwdkw +FVxMSpwQrjzE1ldL4TbxJyevZYicBBABAgAGBQJW7nzFAAoJENVBFQv8OWb6QxcD/ieBL9/2 +Js3RIWd1te00AJtySi+p0eNcEa7jyGO0OGZJ7YNfnE1vctSipRfeAzp2itDD1KVL/wsjou3F +xiWwMtrbmEuDfn7GkOsElJTVdBhR4Inw7K1EjhYL7WgqGDJKv9mevCHzHGOcPtTcCODaAN9X +CnZK7iXDWUCI0IHTgVsJiJwEEAECAAYFAlbufMgACgkQfwphBaG7jSENEAP/ZU9N6BqzoAZ6 +DVBjSv26p3wm00I15X56acPSvq0v+nkuSe0iujSN49o+c2lIu6DoOQqEjWr6HmmX/0MUeUbQ +6llWtBC7IWw62jtXZvsap92ihK0EQKsc4f76fce+h7k5YKmzEV0hHFP3aqenSuPx7904U84q +/6msuMdWCtrA4luInAQQAQIABgUCVu58ywAKCRAlYJXbLjLEqnNoA/wP7JI6RjmuNUt//T4l +xT264ffrf57CTEO25mMwjaXuvZkNuokYfZ5wU0SYp68DRrOiiCwxEGQsaEmirTy+APvx7krq +kNhsM2csv6mthCHS+tqLnzUj5fC+HbSHeZ344DBwo/caVVMy9vkYy0pPLneuR3b/T0X+g0P0 +BeH3yNJTaYicBBABAgAGBQJW7nzOAAoJEE55It+B9Tzfy6ED/jFhAJliK0c/R6sxNNlgc/76 +gllAm5YwV1h7SgW/8t/5dN5+jye66q+JIKRvaBXeCZ509Vh1TbuUb68/9kY8mv1Aqntep2Kk +upq/nl6WL7x0lTf2tObp0BgglbcgB6kZnXBJE3yP//XnuefycCmb7Uv+a0UUD+0auy+qoGvC +vdU/iJwEEAECAAYFAlbufNEACgkQG3a1+/Pw9ZDfOwP+KhekiS4Egpsb5KMQSzQfNuewCn66 +kCth5LYxnnvAZIDt4Rot+TbRx6KliiOLRe5UIw5OWmSxAItR27tVMuJrKWx4ThvLW3pp+Nzr +DUZafCYTZFhHEFbJMZpgUsDSm/Sej5FeHxFqNRmau7fuf19jEiTnjksVyCdzwqKTDzYMA0CI +nAQQAQIABgUCVu581AAKCRCedTezvAqTvDfEA/95DEqMU89/8RDa/iaP9dnvvmXclCNbQcUt +Ruv8hOfO2+k9yaSf3MZB356Vyv5dEv8JFV6Yk1s4D4z8NzVg7jcToDBh4OhFy14ZkDpOKcsl +bo6lb+jyAreVhQA+68bztBbBW9JZossLGcvflzpEXRrUSMHz1X/KjaYTDv/FimFeD4icBBAB +AgAGBQJW7nzXAAoJENIZihnx1F4setEEALLVyEX4T5ylU9dJTR7mJ2nA2vNWwxLqeP+HEr38 +2t2sT4ejUdOHnVzQe/kiYvY6Kr+XW/4G7HA1X9RDpLoTMGjBfmxSGVcv0mOrYVvRCS9pt7rJ +EXV2cAp89uWqad62CBpqDbghcjUPNCcqGQk7Lrny79VE9uYZWAVEF0yyN8y0iJwEEAECAAYF +AlbufNkACgkQSJ3QZj3jbgyGwgQAh3FmmtqLDQclsYPowJRRbzkcDa5dOU8Yg1ASyBHA/jXE +sTDo5ZDrRAkpj5c49SLGYsph5kR8WjAhfwREeWSmp3qV1M49xrBq+UWRIwNiEhWso34adMBi ++3tmn0mIzmheA0J9AZzWiRkKMjxg25Z3boy/rc9NL8m8mWW8VTXP/QiInAQQAQIABgUCVu58 +3AAKCRB9r9OPsgJufB3rBACJRJ0SxTy6W9AV/bLCqXEqex5ZbvHEHC7nA72DaNT2U9dlrO3H +AqXgHuYV3TYUDc5AXxPxZSxNLN+Q8IrWL1fxi3qoB94uVt5RU/xLQk8IktlpkAJ90Vu0H52d ++Sz41BCanuT+o15ahpBR+LOS1coLli/wWBp2646akZJGMsLx+oicBBABAgAGBQJW7nzfAAoJ +EPjnpa/zOIs/FzMEAK5nrtK2JGthAcW8wAUOqr4qL55L0zeDDiphd4DPAEE/b1MjdbZ7J/F/ +oua7WPSrhxcKm1KRfAmzCbNIegd1yCqnF/5bsH5qXZnYvs43SqvXuI11wmR51AOst9+Sh2mp +FFoaDThKSTcN+IVH91NnYYTHo83YqN+gA4r1s/yYeWMGiJwEEAECAAYFAlbufOIACgkQDFge +h9E5LUqGywQAlSNuWanuluEnZjgvxCAPmeSPpanGF82sHfThC950THM2QeryEkauU2e88JvV +pcBSTPIAXLccd3dwlIZxrEZAzV2s/N41Qdl4EnQkttkBfK1IJITPdpJr/LUX3OXnb19LvWTt +kQBuQyeRgOYs/9JVpmZKH/1yWSVxKMyg7hg2gZmInAQQAQIABgUCVu585QAKCRB8maMk236P +83+HBACiYN82fgjNPPbGk0aqKTC9GYlxakUgX04Br6eQSaQw1f+YfvUfnWqGcGhYrCNhrhas +AA+smdS3YyJSGsvEw/SuexM34V+SnjJaw5Np+7JewGWfewYGKPMsLv3hMEO/isacEVK2qhoc +av3nUhQ2b9qAs0dZfJFQjww2kkFxxbPz8oicBBABAgAGBQJW7nzoAAoJEA4tOl9cwvhKa1AD +/1v7CtzKiZty9mdVnBYfW8WphxVJBJZfXnbff/GKe6IQfhSnzEocTFHM0eiDc1T3fm+Njv9w +C/RSkbAsmaNQd9LmPuQqNDYWq6j/HwSyqKntUrp43o6nH2iFpJhU6wrgncyh+9RewEnOHtss +GNXZEHJzkOqFYiyMNgU9DsRBz9wKiJwEEAECAAYFAlbufOsACgkQ+DR0P1yUahEbDwQAuJsY +3kU+P4m4KweOy5yBgZvOkHUTmvN4S2uWrCuUHIabIWxKVztqEue3jjncCEbRBB0N0MZ1BS2j +rIaAFF6z8PuzUU+Vb25Zpf89Dl3u6LxaOBk+XX/YYG0Ox3YwBQgesiGCuQfQhgJXv5McqQ5z +qQXoJmOBq4h4W/ywOXObP5KInAQQAQIABgUCVu587gAKCRDFxSQs7h8ELa+4A/0QNjwn/+IC +0iQC5YAHCWervN2OpfQRh+890nMTadErtyRiQDNCF8wOX87zo5qONRqSvtgU6fFPmlEVm6d1 +6W8qiEKnO3J4wJxakkNqqZidPLQDsS5Ezh1Lpwm5xdGd+JNXN1IcbpfNEHz5Xd7v+qCIJs1v +8nETtdulUH5J3u1oVoicBBABAgAGBQJW7nzxAAoJEL85OnXzHMr1wW0D/idEijkS5ikaeE4q +onwgvy1hqyd+5H/zhr5nyl0nkwikXJ+E8iOMb/3OqCEHj7wvCIFSVuoZHy272nA7pEtewOBz +1RMK174L1BurMEBaor6IhCQxtq/03GnkWZjaZuSKYO118Vpqeppotwhpqzugx19UCNjzYuCL +etjeWN3JJiXdiJwEEAECAAYFAlbufPQACgkQGo5QCm9C68hpOwP9FQqqrHaHfpJBTdiJ8jxA +LflWXYpbBvwQTjdktnT2cyxMuqTle29G5U485qrlyy7TQAz6PiKNeU+W3SHwU9TtuxBHgasX +jV8lmN7uzmurijhtCa7mbKIClfpLc1gozX0PSTeJpUM4aea3EXWx1YqgOYoL3qk1b/nrCeQJ +Y7dnFfGInAQQAQIABgUCVu589wAKCRDoFwKIvfK4b+yDA/4p0F05zvABPdDRyN/9Ry3vWRg5 +XvRDVawjkkOto6MUB5PyGk3n72OKa0JgXusdwNxj1az47Zmk9HV34xrCH3WVgjLUbQPLr4QA +FOgqZhg1Cgw/sE+mX39usGOFTZjf4dlCdegc3aIpVH5xzA9hS/IXgCnC7NLswLUHadSW7Kxx +nIicBBABAgAGBQJW7nz6AAoJEFN9sfr8jgFfXRID/12bcQcMjPhKOkdm53bZE6Ri1JC+EXFp +KrcpyK6iI/38USjZUTcz4AXWaV0kgFWKRPdA4ia4vbxw/R5zsV6VWkWqIV48Y4OwL4rUfl5C +VqIjBh/KG1+mqc/pGA3TLonay56Qh8GQoqSOgWntIIxMWcz0qNcHIbWNiQbUPDf8IOVPiJwE +EAECAAYFAlbufP0ACgkQN5pM6zEXsbDxRQP+KRYSK7WjLsDBoAuEwfPO6eGat3KxILg64+v2 +YvwGtxKMDm98V8AMxOZnSDhA7mBzPC8kCpuQ/uRwFcZTNxL++8i5we+qxWDRpPoFlA7/Mp7z +5lFeZtVlm6xeWtez2158KbgN5PsQvc7+URCO+DcTpi797uA4gTS/rak15663RoKInAQQAQIA +BgUCVu59AAAKCRD3TvFSHypBQqUBA/9WEjpz5aQtU8hQLfrMMTiIPvO0/rD/uwlMCrXtdtEZ +i4H6K2mUSaU7OSDyNgFjhQbfNn+Oihi8iBPCjFrrYYzlOgFNYnV9CpY3uPdOkf2I+HH/G2sv +BugJVbD7pP2ZlF9a3kEg93JhTnUFQh5FVQ7Zn5v1P2XoJ87MINB0lbI2Z4icBBABAgAGBQJW +7n0DAAoJEN+htfluaePqH7ID/jLHh1LuB5/11sca9u5g7KiHqulKuhogEaLOhqmPbYtbu4hf +yz9n0jWlgzOP8RQ2WPVQok2VQkNlW84vbZXpp+mqnGalkpxdBUcRQZ5hOWuCOWE1YuUYmM4Z +1ix812DBNYNfLg7eWirWyCaew7ycso7geoGfdnIrUlbIvBEwytu+iJwEEAECAAYFAlbufQYA +CgkQFeMDZv/ntqGkXgP+LA/FV4tmC3IlbCDAYXT0UighiM5EoIYEOkvDwovZu7/Z5Xsuf7aF +WNYo1ynS2CLeYPj73ulRg3fSYK+R9ydErtQrZi4Sdz2SN85em1thcQInY1Tz3NoodQVlk2cl +HnR5pdYk9rUE0ThMdlE7saYA8L+Zy64UbQBrV5jP2XeZy0GInAQQAQIABgUCVu59CQAKCRDr +iAEWZrPv5ZJ7A/94SA1wXNzNQtU03iCjDwMyF2f3JsgUSADqRuoRVP65onQWKllxdxD95+ZP +qgcGE4u/1Soziel6Ebq2eW1580sBx/Q6ttFurMS8uSedVM8gHx5zQqY8xRtWBAV1zUjZAORt +DQ8f9Frt12iwypbclkofe0rz4b9McyqpAQoAFZM5W4icBBABAgAGBQJW7n0MAAoJEIpNnPTu +JdKJtFID/ir/eHNPnL+woFSOhKyKa02kg2+AML1nwGpnNVkq7ke/yr+C+zp2cpaS0y7xgnES +AdKRdg71LgZI4TicalLO0ZuodKQb3WIqy7cGpS2Hd4Eac3Kg75VEGa0iqGHiSBqBT3WOHmZM +LH+99sRslZbV+ofD2j9Vw8JUsPRahGNApe0riJwEEAECAAYFAlbufQ8ACgkQ/uXmvOJ1m+sH +5gP9E6JC8emixdCqlaGNTR65U3nZsL53uO69CrkI1NdYvY1sZNmmGrWVEw75XsE/yhzyYIib +s40q7tviSJWg4hbuRiMlMS1k/9Lq7yeahy2YGSPCosJHo03n2NUB56WrzQUr8NN9hWCihTZT +U9LilC0RZfKlUx+NMg4C+FzOettu/t2InAQQAQIABgUCVu59EQAKCRDBgS95LmBw7tk0A/0f +EZrzPlwtPZqxlpqqJZeIpZQ1AW5XGuhqxLpm/i1nUPHl2a1PF4TlGnHTa44jnqYxzJD/ML3J +G891rhMsSQOD9nU3fQXSwZ30qsIJ91ywFwk50cEQ7xHL16llRddGeMM8h1xVC/msR9TJIBzN +acxBc1beX0+nrkXfHoWeySbqwIicBBABAgAGBQJW7n0VAAoJECMnB+b8t038+LMEALnQ8lCw +gfOamLih0TG2yA+GG3NdmYt3maUuVTCkvxAde4WXeUlyl76e5hrWeLeduRcHwrqYNvT6qdGT +a01PZ0L38tyOC1QjZOXgGETrzEj9CTkS2QfTeuzCdOYPGhJpf9zkJ6y5msO7bxHGW0c7DMwk +yjDGJ4+EHJSHN1MkGd1HiJwEEAECAAYFAlbufRcACgkQE6bB0/MoUYJiCAP9H0Zp+ns7VnDo +ZnEZ9eh46RYntn9HbTwxuqzOjNqn86ze7Xv9PeSFNkiLQDL6axl3MvaN/oyuly/S1gkOsgke +l6Mj90rqlA0dNEVVM1YQZbLf5cBQapji71JK9BiLwPyIcYFfDgz6HOkPeSKKEFrLP2hBS0mw +8ry2y/p16fkyf+CInAQQAQIABgUCVu59GgAKCRCfUqX5nYm8sID3A/9FTK+Sqygz8xlwOhlS +Ykcvisuv4ohhnG6fUJURnOx8vXHr4YQNXFMT0U52Yt94b+eo8ZaqML2XpDpZF2u3eF0amBKp +1yxTcwQ6DivaccyNrDH8RLy5E/5+t6zvcpZWxLQjq0B04Lrzxxre9EhnGY/HqMHXSgxdQ/vB +wlfb3n4chYicBBABAgAGBQJW7n0dAAoJEBQYP/61baMOYawEAIqx98Vf6QUwTjvaLhQPaEAh +tiRZzCgKEnCYntVYzmk+pHqAQrOioHIZBfrwNJy25IB78QhuwoLMHMOyj/6UbTCB1NGIvcj7 +o85Q/HUHz6av6OttBDUB5QhcX98hSVdnw9A6VEi8wMF8rppg4rEV58kb9jw3SiqTR/vb0HRD +KtaNiJwEEAECAAYFAlbufSAACgkQvH/eDieWpqme6QP/fLaqLwdK8qprGjLMCkMdB7PgslAN +sv8paBRunIhKqo11V6wVCzcyzkcNZj4jBmf0iD2FxqMLKX6GIDw2nj+f79x+T5EMYjQpvD41 +BAVgB8wm8+XHbpGI+qBBDbSEbpK/YuT86hdrwizF68gt7pjfOzfrKORSEhYlp9qe4jiRfdWI +nAQQAQIABgUCVu59IwAKCRCBFWipumnW1QZaA/4tBKE4Pyqes/m+X32Uj8B7rQF7OoctJuKr +OJLrJ0AOIcegxlYQ95UJd1IeV9R6YV/cW/Wl9yNZ0i15VHgcIDnkrHISZp2+btKEmN1ChMIl +5d/CkbcY/b3lhGnJYurVYzVVSejNQU0L0NmSgksXrZcnSRm5pYAGXQddfG5CdyYE/4icBBAB +AgAGBQJW7n0mAAoJEO5+beOIiEa0kXID/A/z6mY+ee2mM/MN4I+0yz2vfj9ipp9vC8oRYCHZ +SfMHQ/dja1RoZDN+oV4gQGunqdahF2ZEslRBtxbditf3p6vlWSEQKxrBnx9jAHwnHvfvph9C +C4QL9sGtrlQunroALodh5dbBT+2AyMhkSjDR9nCR7geMoHmwSJPw7DPrEis3iJwEEAECAAYF +AlbufSkACgkQmuee8UElp3JL3QP/buzcU4WPxhKW5sDp7jfcCO/GKXOJoPtGxYXWiR4UD7Ap +uV2dDvoUhOkTVrw5VlRDAoAwnPSRmYqyt2QscIV9y/ptoRw/ypi+PM/y5OhrMxlHrwQNOprv +A8AII7yaTWhJNvF/rG2bs1mWr2zeO5g1YiemDFk4ZwkoPoTk3qr/Wg+InAQQAQIABgUCVu59 +LAAKCRAr9h0qJANXYhsAA/4nYcLkvNR/Hqox14ge3haTa9K0/z1RAa/cbmcO6Jvbm6Xa5+eM +1GWKhJWpvhZpy3HkJiu+ITGi+xNRrUom/Wac290njNTxffxVCbJmrB2bKWzeKSiSZJdhrbj3 +YhxDK3XLMHO0HdNyrYqI5TXOLMMUvZGZ5u7fd3Eufg4O9bl4bYicBBABAgAGBQJW7n0vAAoJ +EJs9FfSLiaF6UTgEAIITuD7eQGsrEt9jZS6YL9OldTa5OLyfaElOI7t7s24WsvAV6dCPreVB +lyJiWxkaTTtlGloTuf8zVZwSsmaQlxB87DNk2bOLsS3Xyy9qJSY1dSSPPkTPbdS15862Upcd ++XnRI0sQPkhMp+CXrnQm3gDTdKtyhV29iSEfQYXYtDCFiJwEEAECAAYFAlbufTIACgkQajH/ +yzV4ieWzPwQAkmIg89WHPcYd5rb7L/WB+Bg6YmrZbmexdrboWdWdXvoz8yyVa484Pw1x3Mpx +BL7odN9gNhJcxWjW3gR9rePA+exFAwnmfUNexa4EwDqCLcRl0QJO9DLUuVjBbamZ24UKWx9O +YbBz3S0KGMrPBMU+PuA7dfxPNBKFDjLyxFcTHnGInAQQAQIABgUCVu59NQAKCRDzFox7RQ4+ +tkfwA/9ity771ptZ51zbumVfFoFxiH9daceItdn9GAFG2qZ/lXquEGoAhwsvldT/uE2eaooy +S4Jzc0dx2hCvitS1TPztT/wTNptkV/31FWh1ysY4Ejh0h4VPKAXFBRS+h4hP0FpAruumPaRF +8s0gbMDybSnsRKujMvIpgI8rIA+w+LJMzIicBBABAgAGBQJW7n04AAoJEJuNEA27HPeTsSwD ++wZux2F0BkJa3y8NtBrBvWPO5G5DMhC0lPCVzxKzSqF2YgR9D/czqyBot95l0z88Cs/KSFb+ +dyQjIFZjlSsKqmerHlcdPyZ0cLpG0blNUn7xZWIdS1pbmIXdkzSnX7b+BtGk+I+DWhzDChMK +AsLQs1PDQ/RDkQqp5noSsivT3lZWiJwEEAECAAYFAlbufTsACgkQc/ldiN0raVknQQP/WZuw +wfrFH1INYkze+Bqv2dvCh9qefkN6AKH3MhQCGoB7TWRQLF+KaWtd1Ct5qmwUBRkU1aAgIDfL +YvbFAmwn0BzTxG/pc77pYM0SLA9ZAaa4b6/gZWwGcO/bZEz17K2w3uDXvoCHHiHGC7t0o/ks +ZyC4h7KjrPubyqjFrMieVWCInAQQAQIABgUCVu59PgAKCRD+2kDFTLSJlc/aBAC/oej5YK+z +hIj9DcLAFeFzqbTSfwnjN3YPOLzWRcvTZBVh7LgYRWOiGwSyPenq0AUt6ncdSCkSmJtxS9FG +pcGs8RqYTgw9jubCXrOs6vYE2AxDlpKD9gQd3RpFKc+2B4kFxpH8Rx7dTw+QoBjg++n5eHBW +wyt5Xb20KsfCCwzx9oicBBABAgAGBQJW7n1BAAoJEG/AxR11TmeM/KAD/iI31Dcs7EQCguZf +0ctt8alSYIOKOte4l93kRLUt4tgKQ+7x523sD1o8pw+sbwZU79Aa0g0q+p8P8pQBPNzAt2G9 +hzWg0ABhVulaAU7XItF62Y/5yGd9CAoOM8cRcyMUPfkUciuNvRz/nMwQFAoNCA/QuIGPCNLO +DFcq3DMYJZW7iJwEEAECAAYFAlbufUQACgkQ0r9bQTDheYmLzgP/QdRm1lDEkDThvxKRVEaL +okEDOVuD+X4l5QicMa6rxpwVZbKo5f+JKRZd/hQwl1z3EGEyOnC6r6/DaGGtOI06Di9TBIzq +ZcgT3GdmQ8n9CClM6WcGP92beCohVjTGlPsnsWUbzT9rfCPnp25rtum5opHUuSvNp30Ji5Pu +qNPiAHyInAQQAQIABgUCVu59RwAKCRBWIGw9SrKSM5T6A/oCSzVxbnwbFc+1muGe+Qay7Vwf +nV0oAza9VceO6YgTSrJBsPLem37xNFULNoi3OBIcxGCQ+myRO+KMWmEb17OQ7+AqTLa/MMbl +N8G+3tsm3lFfvDUvxm8GL7V2PBv+2IzI58Fe2KY5gRvs4xbzIIuiMhtXLr9sHAlH1bQ3CDjh +qYicBBABAgAGBQJW7n1KAAoJEGvX6WW9TSwufOID/1utE5f/Jf1wSLO8OIlYX28XRt+HM97p +K1RKn/YGor2tI8yukudfwnyn9zM2kl3Rrhu/wdtSN7bQqC8ggDvh3TS6abnfDMWk1voi0vd6 +MVbAKUMWun2jkiIJlpz53ZCLdhfWxQiQgxwKqgdmbPfD9vcuYyj1m97YZ0DW3h8GVsnfiJwE +EAECAAYFAlbufU0ACgkQt2ksdgpr5xW3mAP+JnRTpyQAFU4lzWem1VndXNbrM5rB7hGr1YL6 +Ugtp6KzYLnlIFsGsK9eBxUh1cNgHq52Q+YRlRmtF39AXyk6nULRkO5ghxMTQNvxeCncn1Tml ++ptH89C12Aj7PfcZPtHQw+Bgea1Gg78NTl6Qd9dJfMifK97q6qk4m71c7arP162InAQQAQIA +BgUCVu59UAAKCRCrnCITT6yuYVzUA/4r+bwiRUgyxvUA3Mg633Y7tsVc7MZFjnZ2UWNhLai7 +csRzK7PLZtBTDag+Zx7CK+lPQYt/9jnGbq59Rk/9jBDDrND2LdfS39oCby64wMFLLEy0wWZ4 +doH8mWf0qalBcNG05U3xL98qvjD6VjlKa7vkRVWkWiwf/6sXmQfE81nER4icBBABAgAGBQJW +7n1TAAoJEM3lLEPAPYrgij0EALXYyx5RD4UHYCQbzj+QCKgdw4rW/jPiS1c5wSLlXEVomxWc +k7QqghjrYnJZeBZ/tp+AxXvGG1wiTAi5MLrUpMFvDbFwj3jII2fLAh8FasNHTItq9BC9mFTy +gX0vyQW/z+2tBNWqrQbDE4hsQa8Mj5e/QzM6LvChEX4Y30FxAhvPiJwEEAECAAYFAlbufVYA +CgkQpoKDQVRVwy1TxwP/TIPK/B5oObGpIeUPK5KOuDrrJ1DXfE8rBnkXkB54AisNpURPXTaR +V4NsFjLZaApMTu7BYjL+pleiVhrtvlaCcU4moCmKwA7Z6Mr+8K4ResRFN0uwjdoIc0rsXhYm +FwZ+RhkvYfnO3htwP37GtY6R+FJWSH7bda/YPZ8DF1GWrZaInAQQAQIABgUCVu59WQAKCRDe +D8xuCq1oxQpBBACMFYDQ0tV42ySmy7pR3hpHHD4SwK4/V81zDKG295jEUM0foxxmQf48Tu93 +ymqiqRCDkDjE0ZnaeMxsAI70OxVet//lq8mPbucv2+rjPSh5X3n/INElOS6M1JaGJs3XhPa7 ++r+mqybbCAsMoV5WEq0EoE/1bN+sGTNyASCnMfZAJYicBBABAgAGBQJW7n1cAAoJEGMGWdxx +Fiyz+lEEAL2kSAE2AeYRazc9YJrZqtzLmh8oqv1LHvgxiOXhyvPA1qSeOAMbhd4l654L0Fuo +CrTMb2n/yGr9jMqCuNlBedhf3nc0yNvzX3ir9S7uyHQohJ73ddtncRFqva8O9Q98viAGJric +7RZo0Y2l6JpGUzVmPV3ZKbBVliXpC/ij9uLjiJwEEAECAAYFAlbufV8ACgkQGGs7DTJ554NC +QAQAlTyOBvYbE9UvuHx933FJFqRBckEyjSdeS/xsQVcgJMN+R4GGdRMhL0evJ55lhHBPMzBY +NbcMJCftvohBhWh2zjV50AToZc5UN43LWQuyZUvzHeNMUnaWDukqPbI0SFiobttcfuIFeK7d +ev1kWPOegTEdhTyKy5X6guUjubHIgTyInAQQAQIABgUCVu59YgAKCRA7+jylQjedSwZCA/0S +mvyXTEmyGHiXs2Mv96jfbLOYaanv02/O9Mkvva6LSs5fTlTV+c6MPZGFiKJAQjZFjxvKiv3A +ILvOOdRuBDkHDez4Etb4Y3S+5HkCsQwaYyIDjHTDVlw+XcIZ2dz3P0uCFqC9VaL0uXMaIvqV +l7NE/XjlVff2wFqENGggd+z3EIicBBABAgAGBQJW7n1lAAoJEFHQFtRVLaty5zED/Ahai8ru +nmh8N35v9asD5Gc1mFp9Lpm/hB0Aax5hUmZyRxJrVTgItU0I0PwL1LxYIcPoUi9Jr2J5MjEd +XnvDTas5g0ePD0r9tsLFCLTA6pAslILaAnuC3vv5gOPT/hJsYxYfi3FJzi4nrRZDRzHyYlBv +kfpZvhT5Cm4KaccR7/xfiJwEEAECAAYFAlbufWgACgkQNInQtnVYPWQMKwQApBdNCn9/OIp+ +i1h7yaI2WpE/vV9IzexQLyF/uXomeEYTkLoGx56ciZbw1VYVbmN7C+QTxgoaHfVAestRC58D +olbdHj5uaG9tk4Ei0QAAIytfXTWSdDk/ulx9Wce1EGIb8RtEYDSl4P3uxaAdUQx/twZCO6uB +i6/xoHlbHduvC3mInAQQAQIABgUCVu59awAKCRD36wt3WlfUnB3dA/wIISve7/Yts87oSr3p +TOF3VqVN6Kslg41nmIHrP98dN/RFfA/7f3Rwvvv9HIXjP1SHZxu6InXgRaxGaQHT4N6uNYu1 +lR6DY4dIlxhGs0uWdyAXNIla15Kyh2mN/TwJ2Eg8HtJ0KNw9lViSwd3fQtQkKz4dy0YtA2FK +BOFBFWRXoYicBBABAgAGBQJW7n1uAAoJEJSU5BXnH8LlHZMEAK/OxriKDcpQkRBTaembl1c9 +66dqPN2xC4qRrrXlhTcORZ/M9c3dk7Bzu1TZagkINHUnZAcFEcQSBl0p/Vg2qQvmgkqjTKZf +jGRO373ocvPGJx9OtGOn4zA7QnLjU9r4maqQ1fI+DBKBIfKZP0JAe86kVS7TEwrM3xQgCInX +CgKAiJwEEAECAAYFAlbufXEACgkQbslngTWeXu8waQP/ZKP+5LAgQsCwP1lXUbjue85cBgPX +jYQbEWcani12uoeOjS04JhMXRw5iRGRWFFm9esZ4f3A8HWlSlihYTErKi+mpokGIHWIbdfth +X1s2cmQ9cS2l4UgpK+qIaQajWRwseHMdG1GyAfU/G1ZjG9mQYma3gyU3cUpTIr8YH4MOPzGI +nAQQAQIABgUCVu59dAAKCRATEmza/tZ9XrvuA/9o0MQsydk5jv24ISydbeDsj7y3NKHbXzI8 +bc+J4EKd0/OnR/vMkAY6M8pIErYFyrf4XxmwWMX21nKJ3652QFoHUAO84yc+xdQNH4z/W0r0 +EVNSWpj3eF05tg/aMhI0JHcRWKkfjyf0T/liPYKbBv4dMV96v0AAVCUMhBoLFHpQu4icBBAB +AgAGBQJW7n13AAoJEBKnIScmzKniq84EAKfTEWRbdjXUpQSP2UEiv9vJ47FAu2U+VskUfnZk +dejXSksFiqaV+cbjR9lUFMjlKok9HzAeO5NmmHR11zB8fPvymAeMVGddfpl/3vUr7m1wImjE +uh355tnupKpXkjfMSq1FWB05xBQ4IM1TrWlBD25EtLqKnMSDNXSlTsknhcBPiJwEEAECAAYF +AlbufXsACgkQ6jIEh6OCTbMl/QP9Fs3CXVCzAjo3NB+LkN4//KlVyK+Q+fnbrahrEMHHjBgN +ANARq45HBOZbg+AXa5G7StFN7sNIvjb/NSzjdWZIvlO2Bn0LdqlVycA/p8TBDipZEBCWU0vT +uenjs+/6L97ssAZqSiGXQ6VsBeo5SWkAYbtVCrD5Ppon0KufP+Aozo6InAQQAQIABgUCVu59 +fgAKCRC4T/nodBxk3nJwBACCiv3WIVZ2lBmFDUza/zHosFT5Wtergiq1PA5itTsLB1q4h2ub +DnmXVEappw8Ri/C/Ga9qB9oZtIkjvgwTwVDTXacCY0y/6aUVYdz4TddKbOUFSMd8OycidoNu +CnqQob4dqsH9ai6QRAuLxHx86Ox1ug3taCIZSyIFWPJI3/AFmIicBBABAgAGBQJW7n2BAAoJ +EEv5D1Gz1L8GJO4D/3zChHt3W8HPArHOglUYZ+Iw0IFITQt9b8zfNB20Fw2kJPxzvS3CHQYL +HCYLeJfJH1Rc23ihk61rfspqEzDRZkU5l/lm9LQaQd3sdnj6KX+T8wamHiKh+5HNOeLpypHt +WqxJodcHColvgSTcu1icxxpvk6NyiM6uci26T9NLoWVniJwEEAECAAYFAlbufYQACgkQNWNA +nzAHhYU7ZAQAiDDzw7J28K0uCQpAgG3ud+iyEU2Uz8cHoW2YzY5paqBI+J+yyB/UJotURb4u +IYq/QWSEbYY6+OZlVgQq8MhSXOxj7ZXm0yw8T+D1VNFsFEO8n7sIGPsAXNhcfjNkV1BotQ84 +9K5l9EZ5Lgg7ZGEvOhxQinJLApdpWujmQ4nG6aOInAQQAQIABgUCVu59hwAKCRA75dn6xECU +5KKiA/4qPmZHgp11+GvvW75EM3Ou1DKoBu5/lMVr6H3VQ8SMn56ufPAGzKvSTsGy1vXD0us2 +fa4NdTfoK5rVyzKl8ffArat+YE7RtH6zN9+dYhhd7mk/7BX5UG0c9/Hf1ci93xErO8YJRDgV +zxf7NECc+l2HnydjLbUuKUlR1qmN5s3hfoicBBABAgAGBQJW7n2KAAoJEKFhUW6NjnnS3PkE +AJi2f0H+9glq5WFG2KQ/xtTN3qdCHGpfAm0bpVa3557kqoa4DC/R5583uq2/4CoIFHtx1e7k +G/yJT5TLhnrA5hlvhrH4Bz1xkSClXzmCfM3HlEM38Yc52u7uMMlsMEujZsACutVxBf+ptan0 +SVooW5kaELct5Sd+qn3030jblHXEiJwEEAECAAYFAlbufY0ACgkQN/mDbmqk3tqlPAP7B9ix +iMhwvfc7qFfDyw2H/xV0qkNeQ61w58iD0jmvvFQ7r0lNhrxrC+mgN6ujqLLb2JK4+UBtCHP5 +4IIk4YwfrToGds9qCy56AA7FJV8IheCV9ni9tiE9zWYgcVhPq9vS6rqAJrb1bQ0tSHzhOnEx +JS8wZjSbZiUuJKoCvQUFhiaInAQQAQIABgUCVu59kAAKCRBx3F8zKhZWy1YYBACW15csfE6Q +8pTAEVVB5O52XTyX/UyGsFrwsZS+xdxK/y5kxn0TfKqwd68uePEQRaAs3xpbUizmcy5RAZ/3 +Uy6GkVrMVy85HEoxZOkbJB9oGCxBEOqWvqng135rSDEWLr7QMyoiKSfV9T6UTO1pBgvKW3ns +c1I0ESHIcdQKVyJiR4icBBABAgAGBQJW7n2TAAoJEAq8g0qiQCg/ZgsD/1xBQ58i6NLBxAUd +gN93P5x6nInyS5g5+Yh38KnmW6/iBAnpsbGXY5ZZTcpx4vAN5IYmINtaGEAxprCX2y37jYM+ +NiwRyXlxzni2nys83k1h/dy6EqTvieJLSQ5OKNLydv1/QXd6Bpzz0Gsrx8HfX3iQYMliXx4C +PCsOQSZ0b2nmiJwEEAECAAYFAlbufZYACgkQZwPCV7jlf+ei7QP9HtIYTFOpylGiy/4foXrG +97tkG6DE8UjRtq+KqOho6jVGnkSbQInC5vNysByuU/Ug2L7Ra10fyxHMzYK8MQnzVTz+nnsh +EqFN/Xg1JxbbbmHAIaTKIkpq2s56k0jsVkTWm9LVunz0wxeI5A21X0r6HglFjanHsKHSniDD +bR9226WInAQQAQIABgUCVu59mQAKCRA+EGiAo3R9HiyQA/9kk6zHW7sV199+omedAZoII1W3 ++vSvxIA1/PUGnURqw7Zwgejj4iq6Q+A2hgClcDY/LZxM1/Lu6jX6KtTAl76U+3mj1txyQWAR +INCw16okPcD8fBp9EG5Z80ebEwCM4iAC82GUrOJt526uV0Ua2Jy0AoHpQ8sY81/oz4hGnZcc +t4icBBABAgAGBQJW7n2cAAoJEHSH2m7HAC+avTsEAIBScvBIsxAXB45jW9gyOdPEGP6z/un3 +RVKCOrwcvEWlzdip5BdityKEGtSZCXwrDjij9tfAbjt9GBVaTZXzqC/C+xRgRv3pzoau7JYX +oXNT941J1aF8V6CltHRJur+lgYB2jr9XRXY6Hh20RTqQgYbZFPbFNapex5ZTkA1oJyuciJwE +EAECAAYFAlbufaAACgkQmJk9vjU2PvQbFAP9Hwq8fHaoNq2nzsWIuvhv/owlWI0Kc6rEekqo +S+MfvpyES9TScFxMy5vTglj4nujNWDvMUtxiQ+ii6oL/1iPeUkZ6ZTJsckDHQchZ2Eb5BG+I +Hw+UcUVxvLevuXqn3WqdNzADe/w3WFpu0xdmRRCfyGsocz3VPDEM0SZK4XT93y6InAQQAQIA +BgUCVu59owAKCRBLTA3z3bHG//umA/oC6xDa/IHPUHazE08OaYxj6ZqjpDLrwktxEDPloumR +xZ1sOi1bmJvIWwud4FdVcZ4PbeVo2xH7HhleNYOCt4jqD+DOX9LUnGEr44SqdICxyPuzoY9t +YtDZgU9VgJ+2XXgNMkBkUu8vImoSSigsbtL/M4aCouAv6HjpkBwZXk1t9oicBBABAgAGBQJW +7n2mAAoJEIIrxxne2ufX2QkD/15ihgO+qKRi6GvR3BXZS/KUYYSgbAxiOTM+j5inJM0Shi/s +vDHs5P0V4Cj0mWmumRCjvuyeGrRRVMNaI50L9IzsuQ5hMQMCXaLEkQVX1c0p3oa8IwOGRS7g +5aNgAdUtPBtRFPX06rUY3tmUacb50RgnbnUE/bPQ0p7eQRH7f0r2iJwEEAECAAYFAlbufakA +CgkQ+sOH/OljgtghvQP9GIcp9tNaEssiPoTqZqOsmXJKa+ZML8LZDsl7BVz1zP7jsw1zDRU4 +ftxqAJg2TMlV0+3wgmhWgK+p50bIXeS9H0xnIO//L7DHZy+z2fx14TYKpNzD5Kna2fVj1khT +V/7g47p0cpdKE2yLTDkLNHq8xGNnGPqdv6DMxpUBK2PKjiSInAQQAQIABgUCVu59rAAKCRCq +TXFl4ci7VClvA/0bc3n8J2q3K3/FmjgHfj1kFHrYGwWka4B0k10jm29zq11H1jfuOwRI7dvq +GzkAcZLV9utVOpwm8/BC9K84sIJ+8V2ClFhOr7HuwaF7lzxfegndbw+3lwoS0AA4JdNeRe42 +M8FLpMRaAo7twXxRQ2oWBNUx29/Ui7daNEEjgIac4oicBBABAgAGBQJW7n2vAAoJEANNLtG3 +sI091OgEAKcM3KLYjZVDu1fjG90fqtLcnLqmiIpPK6cR0QHvOkOsd++b0A3zZLRCmJw+XhRf +26/dxvIYWa/Ndd+cnVPrMLAzeJwTqfIXPd8wof/1TMdqOCEMNLbiOjzB6GDAdcpJCTpIDp7N +Lf8HMV3bcgkPKQfa/z8FMVyiPe4yZhpJqgzxiJwEEAECAAYFAlbufbIACgkQq7weqv108+In +DgP+P7nO9i2EaVROAHb8BxTFluo+9oSu10HmXJsz+lybmleEzqwd/f6ocrRIfHGWrPf8px93 +FEY+1OY/+2Z/gZVTTh8V2AXVIZFcrC/NcFFkrLSyUmtWGgJojq91/2GA9YbHubyyyQnzLAmv +GfIEGyC2QpCq4hEeq+zaVapKd1bCi46InAQQAQIABgUCVu59tQAKCRAz2ahnZQ71xu3bBAC1 +loMVtvoNapnc+w0+tM/iG+KCeA8dpJiUNrWrE6Ng78Qdj0DXOb8xfNvukcUp0w4xfI4q9gAa +VHCEBUszJ0y71B4ukePr3zbnXRbbHz2n/TGzeOyafz7fmPwsPtSpfKWpn91z+Ck3nBdRZFVQ +4loFGv1T1pS5EG5mamLXy3FfJoicBBABAgAGBQJW7n24AAoJEKgTrJ5Lb1YjUiAEAIv3WvAA +9OPjA2N9D1GzXsiUnF4qvuRmyS6m4Q9nbE7Gn5I6i6Vys3whDjB7wUypZrGKliSZpv057OL0 +C2Mow3IFY/9Rnr2UCMT11MKqr7lHF1XnebKCAu3X0EVnPQpWsaPSNpUuIbOUpUAccAGjyGmO +J6aJ/3s70F1bv1BiMhCFiJwEEAECAAYFAlbufbwACgkQt2ZnqXRjMlN1wgP/cTO9ym2RKCZ9 +2xucGe4HLpqio3wNyIUaE97mWf7tgAYlsUhI44vsMysilTzBF9BT++moz+RJfTvLtqFihgc+ +zVJ7ZyDPdUqDiQ1ICVtK5JOswWkwKbxdteIY8wvVYZ2Giq/y0hhYMuhqT9k6qZd8VB2vm8Ky +levrEpZkkFIJ8iKInAQQAQIABgUCVu59vwAKCRB5mNFEepEhBvW+A/4jp6URecUJzep3FF7V +/OMn5qmWH76KbcHtTv8ED0y/bjyWy0DXJC71hYDDBzK8sp8znsUM7sSYO9jc9o99pdlxJAgE +Bc1EZD6EgVdRyZFYfwx4ssuA6p400i8I64S7hLJwm26FK3dtKYdZ1iUe7Q2p+Zf3IPZ+H/xq +dFc9yI3B9oicBBABAgAGBQJW7n3DAAoJEOaVXVeFXqj+2kQD/1XhX3mVv9MQCOElWvWrDlLo +sEiDBOT6dl3b5H91w6sioa4/4PHlbNwIn6Pj5okeah5dcvyark3WLUr2FTzUQFhNJmHX2Z06 +j+PIZyIN1wvXsK9XCStrtEMuYq5gCmtYkDlX6Mfrzpubsjpnb698ctZwM99DDBXY/A28H34l +4MBziJwEEAECAAYFAlbufcYACgkQYH4adQLFBnWFagP+PrrjPATiG9OqscHDh1040frwPWbq +cLizrY0QFY5ChKJuMd1YDRZ1TCtjTCAb2/LyhrnWYLFltFzBahkuc1vDsqdo1dIC28sKEAQM +7pMNAq59sBTdwSw6gwfnqWlM6UY/nMknAH51FZuSf+IKu+N7IjrPdWTlRk1ZO1t0owDvbgaI +nAQQAQIABgUCVu59yQAKCRBcAKYT/zXj0dWtBADS4VFLlrlGGh1BTM33764E3yHKpRfAlcto +CE0WjMzbWYfzmXfGQzWeZlvGiU5trB0ZJCZXns2p0VP5D8hFGxmCU7HZyXAgdlRj2SZGap4r +vjb/XaaTf381L8Vy3I7WYIsqfblTai41Q4pIorv0xtoLr3mXbFJ8xCAltkUfg+x3xIicBBAB +AgAGBQJW7n3NAAoJEMX2Wh6CT3iTn2cD/j7ee/qa4NZT7fWiH+0/sVAYYP56RWnyXk/v08UC +ctDADFU/C1ILbxwDpmdIfnO6/JUj13/SQuJhxTVYAsfUu4V+timyo016i4CyAAtRxiGAG0ip +1NwBPIzDa+zLwqfK16liceeTAw0WhHTTwqJ6RyuzpBvDvw8N0n42CikLT8LkiJwEEAECAAYF +AlbufdAACgkQTpwQrSYaelRAEwP/QJpdIoTlyftuCeNkW7/W05Gk4BHJXgqnxPYmT1D5fZXx +4qxx34EloC4Z6r5XsHoowpKKhz8+6qLO/RNYGyDSUPC7RdJuW3MM/roqPKNJjka+Zh6/d5Yd +UB2BIPgg1/zUcUyulNew19K8b2ze9d7lk3XN3Ue6toYm8/lHes9kaqSInAQQAQIABgUCVu59 +0wAKCRD+Et5cziBrvQyGBACdp0+y/HLu23ggUaXRsWaEGn2ws/PIyRZWzxo5eFuZhVOPKhuC +jBDBRsuTQdSPn8BS4EksAO/s0dbBLWU7cv67QKoD4CHp5GymzO0coSbMzMhGW0rmSxcoKF7n +70OUKLTmZmMnQ1XXTBOX9SEhrwpMMeIfqlNwI54xzfgzChYfhIicBBABAgAGBQJW7n3WAAoJ +EBN764OeWkH349AEAJYk1MG3L+10ERSw9jpupWcDr80enE2ETHPXzg6kBN12q9/JxQ83RLfn +do4Q27bGapOgQpRQQf89yKWpbYZ8JS1O6+oX+K8UsV1y/JbawfUZ1q7uND+Md2xtfT/oHHuF +O1PTSr8N3+yJbTLl49MaALxTidzzXwIJGQcIQUrxsLFniJwEEAECAAYFAlbufdkACgkQEswK +7Kvt4dAtZwP/dGknKUKoUgJZHZqd56dPrRCzqhAP8EddIed4pO9jBopVSxooNCTkKtgBw/54 +DiU6GMJnbYLVBv/B0DhZ1Np6A0Hi6t9FcPMEAEkOCdtGF5K9kYoPXNlEk24vDhrg7GofKKC/ +qi6ZrKDPTA4UVT7uM9xK2yC/E8hqUnFYVBeQ0GqInAQQAQIABgUCVu593AAKCRD5Z1EDghyT +DNZUA/4k9QEPraJNJsm1iDciEtpxqWO+zchpatxOZK2H1sXWqanfgycAM0+yv1Rd/dupNb+g +xaEA2kADMkgh79/sEQUdD5Qm5TRj6J2qo+nzOHznjPa9iMK/uRC50jC26662UFNlUwuzDnkj +kzQfv/b2tGe9+SV1KlU4T32vWxZHELSpO4icBBABAgAGBQJW7n3fAAoJEIDcWDALvOo8LCkE +AKg8MQmYoKdBtGRYuboFoMktx1Ya2u55/3SgijUewiUoOfudKGXPKqK8weNnMdbb1RGmNJI+ +j52FGHfpif0up2L4nwfdjqYxZRhXj/vhUyQzbl+dCmOhhm5oxL1whStzrTpgg9sMDiJe5o+N +K/hgwjjleczx0IeyGPzAmfwPxR7miJwEEAECAAYFAlbufeIACgkQ/w0GhvfyGyncagP/TCVW +7nBgOxT4MTYTb1EBM5OTkWMKWS8ePYPdFSr3gGvL0hMlpeX+9CPxugVX/Qe2VKCINgynLDhk +CtKxohLuKxY4HqkoYPl9XhrNghIp+6TS8TPKRRPx5go96xST35Se1po+FOhSuVVy+Eop3+ch +VXlTfufCYHzqLum5OGC8hTyInAQQAQIABgUCVu595QAKCRB4SUYOn3G2AsaoBACxy0EiALKq +ElPrLCPFtscotZN9ZktJzcHmK86ormaz9mrws5jJydIaFkbMPxx9FTwzlAkFhqz0++XB7gDo +Ja7GDBjCLpENG87bSZkWV4H+fEDEi73WlH/iD46SwC9ZmIgKqRWfHAZZWssPAPp/4DF06HgJ +NA/ZqO0ff/CLUkqS0oicBBABAgAGBQJW7n3pAAoJEG5NLjoTF7YlK/UD/1d1UUDC8rmNPMKa +Vne8t1dPeu09RkGZuagtesqxu2H3PNG4XS4NPCpyAMNxtGPyltczRgB624IE9PMnpTsbLZG8 +I8s1+Xi9KoXU5W8CbqO425jlKINhUPb0PyPEt20bf8Dbur56AvVyrXrZwPbGzSGlc6v+XYHi +xztY6ypotvDHiJwEEAECAAYFAlbufewACgkQyLeQuOHG5Fw3gwQAmeRtcd3fsVEmNny+rbSD +DD13aGoDFK9Cb+W2fncvCAf8f0vjhIlajfLvAZoYrJwEIyNzMibdrr71BlSX9UdFp/XlmfK0 +EOTFDNAptMbK78YaT0zfFDbMhtPuUhG+5J6ZTwkM09M3Vmhqi+mNCfRHltEU2mZ9G+9nd3yi +4SGjzu+InAQQAQIABgUCVu597wAKCRAS7Bt/elHtAgaVBADBArW+D/qVTc3xDUs3EYV84ZGZ +rkr42BLETXQwLvcjThnrcBGn33xsqlHFUEXW34MDiJFWuLvVoXHbhuskeQror0sGeONuSzpp +HwdR9+qfu/0YWSspx4P5F+n05XRZGY7z1g2I+qwjcgzTQAL9HiOXpkJ96FqnqIMW/KUNa/u2 +d4icBBABAgAGBQJW7n3yAAoJEB60C1PcE+UaZX4EAKpYw7lt74L0SC2AnGncIdXohG8Y++Yw ++V4gaZLAFUJnvUUr1XqQRGtBnn1XpxEW/+DoxAARCsMIN2xVZmjzRPkyfctCGujbZ0i+RpEy +tKXRUIEq8baZ2NAXVm0yiJ6kNDszYNl4lVUQ5qjFDx5YCASPqAzsfRvJAtGRlGf5YXaciJwE +EAECAAYFAlbuffUACgkQV+fOcuBq1f9RJgP/YjJflwi8Ewo8vC/hwzmpymhEDuLh6sbVKlYV +uvqNUpVvM0ntUvKP7MJN6vQboIOVZHjeqsJiB93XwoBfSjCfP6Mtdr91rJPthwwUFK0RLk/K +4zfWFCP8QIsV5ZRAYqwop89FW49g7VOaSDGKwTQZDmTcaX9pkV8efyRNefT1n3CInAQQAQIA +BgUCVu59+AAKCRASrAC7v1JOPMWPA/40oNJ4glro42QFNN42TYy6As3qDmbmM/R89l1BHGw4 +8a+kC8nq1SGZYFXVlsFwcAtUq4E0dqXqyUgHmwvHDD2N96fKdQMQ9VDKkweLRHGkLoYs+PWB +pL4xkV7oJM9ifJPuW0pT/4KlXS1ROjtSAf7OTT3en/Pzp3CfQLmrfQUmV4icBBABAgAGBQJW +7n37AAoJEHMxdB+CNVwG494D/3x/BbNECAISgLikLS2UaLXqwa7MsmpLKmbqv7ULeTkC6vGy +tyq1qW0VWjhX0sCXF+JRYL6aQC6SejfMA8GQ4ZNWu16Cbfg8aOdRYT4Ook8xX3Glt8oulO5Y +dMrC3ax2zZSZSXmMRDuICzPoCiydN3br4fzFLxXLDOVt91wXikjKiJwEEAECAAYFAlbuff4A +CgkQQSL1F+Itg3QwpwQAscFrhjfULfVlM3y3X1OdP8MIK2yBt2NFU2Q1qwFSrRDJ1EWpyKfo +dW51/ABh03AsF8Aci0+hxgKMWjl2WWTogOaFp4lYQ4Y+Qr8Q7q7soOUUHFCRpSRGSuAnOebG +5zW3jReYDozTbhEHBWyfOoSabNltAWg9n/uSsbTBW8t3/hiInAQQAQIABgUCVu5+AgAKCRBu +CdPDZ0DwMZE2A/9vPcosG2t2PecyAwnlAAUeA5gRD/vQ7TxI2s4Wix18VK5ffphpXCfJXzOy +zsQtEKecny4fuKPbEPQUTn+jIjL/DAXpyt/IAEkJ0IuOcCXmF5NO0diTwzbXl8BJXpa/umn8 +si26gXvIX3jaLmN5OezzPn7t1v/tDCR25ICW/SUpfYicBBABAgAGBQJW7n4FAAoJEEn5/mO7 +CPr81cQD/jEvvBrC2tTLeymxrGa5NTYbIAqIHyuIiOmy9SN+mUb5qOBeoZD6Ac2gZjoLthBq +42QvZ+DwtkIG9VNDVW0tr4XMQcIMfdS8HIs1T71hjNEq/2lYd7UMbbPpnYk182LlgZWDKE5A +W5TUq2hrfpxNx1FbOSisjvdLaIyneCf1u4eOiJwEEAECAAYFAlbufggACgkQCCubw2isxqqR +QgP+KY2gB27JwkgPnKuvM1kVROtHUWu60xNVd5/p556AZvPY1wz6xVcZCCyOtx0ULc40guo3 +ocs7sAC6IY3pRPA3Wcv4xj3AC9MLPjMH/s3cRHDHsan7Gj9BOfWHZMUP3g0dsP5Wg2SsOS9O +rUue3Fy2a8ncyza6FMZUfs6VlB7bZreInAQQAQIABgUCVu5+CwAKCRAnEyUhGBktknHjA/9T +nLUmBY3Xl6iHH0UDBZI84RNPYg53rdxu2vZ83CGdUp0sxel6Eoszk5GJO33pYb+mjePzok+T +HmuxJwMGhiTLQmsChmptXIFsAelkkhdRCxQb7UG2WT/MdYpNBokR3vy7qTJmG5Nq7AGBPZWe +fbT0veHKcyZgesT5xI0R6v84NYicBBABAgAGBQJW7n4OAAoJENkUQxvFrPp4xF8EAIgKXbTa +A9+SomVUsw+VrBMCoSDAel46gNBb6E291VrMcn9ksbNzG4x5ThAZ5S5nHD2MjLYMCpKTFynx +sUUkBcuezQoxWmCR6kmi1IzFOUeUqEqNMlwhDK8bRVqSJ2a5BMo97y2eHWB/QWNc3NCTR51q +td2+Y3liqpiL7LZwepthiJwEEAECAAYFAlbufhEACgkQ3K0gqbzQ0NhzXAP8CA929YK8VWpS +TS3jzmOxr6iGyQpwukiQKUGGgdKvY+vt6C5WlOVWHTBkhP9z+n8novv0AI8TiBNyf7+m3LQM +St/60MWXp/Ib9EI/0akZc1DwGErRNF682O99LXRVGsPjz1H12mSsA0xXs6ocG3GviavLvjdU +zjo92/vr3EXlgieInAQQAQIABgUCVu5+FAAKCRCd4jCR6gRQGaX+A/9dguwfEia6kn9xP/4W +kPmYDCWEVjNS/De9gegpZOuVSvjE8VFqDOhuPNZqnP2vs+6XTqv9SAgNc6z8lQmUoLSkCXOT +R/ylsIjdaEzZ13nnQ4Or0lmW7AMg5c59KZAqTt9DkZTHClmiPkNbX7qHBdJQV7cVh0AYuMxI +hn9765OdzIicBBABAgAGBQJW7n4YAAoJEIvlccaNyjo9KiID/3FhDbX2c+CUZfSYXV2OpM/o +t9nGO06oNVQ/nkDdVL/i373sG9HAVXy33enRkny1ModjCMlhL3NdmFQxOJ4KkRpn2/vg1EGt +n3keY4peDaysRcZgLFXsfs1b2ZciaIy3R4M71tQgYbGUMwvg/vX4ngT0wZimmn4uzmWFcN8h +bUn5iJwEEAECAAYFAlbufhsACgkQfrwq5vlbGTT2pQQAnWXqrr9O9dsP8lN2UdWo1wVyQ14h +MsdYLWvnKGuLWosIv0kQh+iVBgVQkFxRCFy/8Qop6yEDc00X/21cmb3Y7HcphrH89eg8jxo9 +NiMczSWZtGkedDJQ5ZqWFt5WhbXY8fCpWXShgt0Xp8sqTqQGotvek/6E5wrNXmtXeMV7p1aI +nAQQAQIABgUCVu5+HgAKCRDD6qhR8BZcNlAQA/0RYGx5W3eyh7VGgz0Q0NpKYb8RVUvtU/8n +NOn1xufUonbNYu7ctpPAyjpt4s8SYNaNga4+5glEDSzWGkG6DNHoBxf9FZ7jrB6vW/TddJf7 +bp699mumFq9CrgieSbeyJSpsOteS4E7umgO6F6g0km+bTP5nZ0xOXcWPBDfZaYZezIicBBAB +AgAGBQJW7n4hAAoJECBcR1JnQPV0QT4EALCq4nl7NlxkerJbJSIzk81KjjCqkskcbuQHqp1F +oFAqRhAVn4LYAEClhODK/AZJuCJg3yBPuKqTqTxdr21gwPiUqwOxI1CeYZodQDmwdibGEaa/ +l5S1r2WAiq7U3ZPSzmfVZJFLHJGV2DroDv87hOM93TvRPUhURY+/AREefBPhiJwEEAECAAYF +AlbufiQACgkQLbXe8zxOD3pxygP/SNZLkrAUsiwpThvPc6FQmJZahM9GbsFBkhhdGQ979Blv +oVhSgHm8bKEUz45Gp/dpzZZqfPFpXafA4qMLE4FWugqxaWqIaP3JRD7OmT4iuOpxipUYX5VE +NSAtd+D3K0+VmiRfgTYxTMy0ugPvRNMbtzy8lAppUkEzNQi2CQ4lCM6InAQQAQIABgUCVu5+ +JwAKCRCUnKJaR6DCK6FgA/9KIZVdA4LniOTINW+/M+YspeevaV+1NqjvdxP9NJosxCX8eKPF +rsoC+9k2LERxz3uA+YOJJbIZ2QxTEnTnNlwJwQ6IhK9kp8OtVTRxmoVxEjloyZ8UKQSy7lCv +d3iYKVEITlZOlAPakaI4REvxhIsgG3eJtbuSToikucYi+S+PSoicBBABAgAGBQJW7n4qAAoJ +EPtoaut6zdilyOoEALf6eCR7WLPW6fcdl8sgMFG5XVdQM5CAHYGEVqf67Coi57EqbvVNo/Nl +vrJog42J/wchGqWh6XOv37x0InQ7R4gWRNFaEkmM2dMb9r/2CLiNE7K9u6d/QGkGddEz0ko5 +sb50GBqHIOIsXv9nO6M43nkzoSp2EcyLp3mmppZOOvv/iJwEEAECAAYFAlbufi0ACgkQc94L +r9spY4zYWQP/ZKAl7BsCVP0X9VJFD5plgvX+10eJEoilaY3JPqNuYdpZXycdjZDikOA0BLYw +5LTRCDNc8JC32OGpCZ0n1JQ3wNg+MtfMvSryieOon0wZFd7XOZFuLnY69kPYXVYjug+faqdE +KOiCbUEhKpH7xFk6dgm42zKGXBNdAKdDquuMlaaInAQQAQIABgUCVu5+MAAKCRCAiIzhD1RI +fSlBBACI2Z6Awpu02VVdEB0TMS/HrEPtruN2xxKvhg11rPBZFF0R0G8IkYghLrSXhhm+MmwJ +qexCOqSaXRKIro2TEcY9/OX3PAAVB4oyfTZvfcJzFwHvdGLXXVpEPaiYaKDW/uIRxrUJNc+4 +lueoP9DHt3oZr5LE8oNXQgG5xan2lUxigIicBBABAgAGBQJW7n40AAoJEKxxdRnTfZmW7VQE +AKS0+b8s7MgnbwlmB5TQaZtcAEfOu+fqmB2xU1K7UJqcI7REnHgoVA1KdW/5jKIenrvUQJew +nBz19XuGmG1DmJyAxRieuADRzUtxBwR/yYNk/H3l/IcMbBURowKLv2i8lJJV+fy21h/LTAdd +XqXU8Eb4bUzMS8n9feE7S7Hi4RWgiJwEEAECAAYFAlbufjcACgkQ0vezex4M7lDEJQP/ZlkA +E5Yurh1JGIqLZ6k6Xq4fnN6zNNqreCIdF8IKGyUDi5cLKA6GXQ/mpvgZhNf15USXAnnYQ5N5 +d6fBAh7lkJZhkmzXvbrWLb+Qs/CW6P0/wSAGkE7XOrgDqpWv/iiP5UVdfYNYTSa8iRz4RCld +h5xD8vjPIvs/zY9kp5kABjiInAQQAQIABgUCVu5+OgAKCRA7srXIa32Wj74fA/4ns5CG1qV8 +3baPwhGa7omX5LGoZC5QjXyLsYiXFbt8nvW5t02ZbfFEfs6+DZC6HXkvghxcF5NmEMJHdFXL +N7mjeUypvzIIgfvHL6jOp+yy4ejlZ01pjlLe82gAUZljGtkCAmxOKs/YBbG98dquPDlmn4HX +QbIbiWczUY/k8Z78b4icBBABAgAGBQJW7n49AAoJEJNIxfrLzXGmhVYEALaq76JWDIWwJZ0m +Le89AjxDDpd7JhM2nVP0B8+gK1mJXxZ0ybAwglXx5caYo5JKowDG/iRGlsiByiieTLw3oLXw +Z5LNSLLG/pT3btbJhW5SsUubLMfQRRVDiJD9dAWNfmJSx6XvrGPFZ7undL02z97kgMiQW6tt +y0y0xe25DGa9iJwEEAECAAYFAlbufkAACgkQoWpTSvYj8BFjlwQA3ERrPkPamjSkoTQAoJQh +Jb6Vu9WQpzTgt4F89T9G4Nj61Zu3M405AmmN43VyXPquiFX5VEF0ZCFe5Eq6Q4b4FVndgvlk ++WWfrQnfnNVmbBnrKgIjWvjfKPlmW6+OjZCF8ocUOnHEADM+01Q3c8n4xBGsMaAqM7trbIJl +s3J4AVWInAQQAQIABgUCVu5+QwAKCRAjijitonVmlWU8A/9y8DYhlQdFMorwMpU7a3pWbVNj +MccAxfRBbfSyWLsYlLmeHCbe+4e7UOW1toPshst6SFTXwBqlo+4AotLe9Hv9aD4WLVVgwo/6 +ok0cQEFnNU/Po9AEbuXCaZ7Y05kzLydy9WG3SIFEpZjcn41WKPjovF8nPamZLR6UtFqIF49T +EoicBBABAgAGBQJW7n5HAAoJECfRcRoMQRrOMRYD/jGI/RECTuiMoTtpnVWyy2ltMTqwYrEt +c8+vkLjMwsggA/cJ+4/GB9yJ0G04Xzqld9lXA43+M0LqcuYg54MxBiquZ7rQh1Pl511qzve1 +udV8MxVCCMv2vyxdMLv3t5rEUkGPe8NuW3PHPPFX5VAbN3FLMJTcwO1tpKP7230WIh/qiJwE +EAECAAYFAlbufkoACgkQRXZgoZJF2j7tBwQA1zYG9QMzYxj0nfSce0sX+HE/2wSSXlyAQPT+ +CNAVuL3ijF654XokIfXMjdOnewROq5FQH+EJXjmG81Q10qDVNv/kw15Pj0t7tKWHvaKZaq+b +T177e9PTQKdx6rnyE5zze9omvOUZZELfHj2x7Whoc58LFBR62ojLTUdn7kkq72KInAQQAQIA +BgUCVu5+TQAKCRA0t/DEuveQ6YDhA/wJepWDufDnNyy+UTycfYWf1BpuSEO2MExOOTlvK1cC +bzP3P5dMDyXgqSkF0Unvv3rLa0dpnHdOYgSicaayi/JHnc1rHk+DxmlBxrbdgHe6tRBgwLfS +rDR7pWXwNzLzNjA4aj1pqQg7nBHOAiXEwTzn4sjWDllWqDF4a1QjOK3AfYicBBABAgAGBQJW +7n5QAAoJEG4mpwfwIYE+BQ4D/RhvcEuHJ7k4+5WHxoXi47hNJgQLOdjKSW6Vvbl+pODz6xFk +0ch6gNI/FdefoXK04AKvK5mMpmDP27jPCnbdFPcHvneFeGlvHDtv6fW2EmPHHzuRPtrDZU4M +h7GgtUIxe0RMbqQrNMexZJqpcpvVZn4BnahFOAm1+X2TNN9Xr3zIiJwEEAECAAYFAlbuflMA +CgkQvAIvy9u1OKs1XAP/b/P07RZgh7lIFEWLobUEF5+tJQAYVzh4HaL2PZZ6e5r2arqGjyQD +MrRy6W1kYpk1pGjQtNZDAgKXHJlodD/xNodahVh7o6NpCZ59rts9a1degQm0dOCP9ubHWmpO +gTCBjCFdNjT5XBHisQfcxacS5PAR9rdPLZTigrdQt/4dYoaInAQQAQIABgUCVu5+VgAKCRBB +5j6ZNkmR1cSpA/4t1fdavRHbZtNcwCpvqLnjJikX1TplUGj4lUdi7EwABkVZZhyxCqJF0J7Q +usvSs+XZyioMchkkSo2qBf12uFcBsQClO8no3Ndk5nF7Gnr4OlTHET/MmbFGeTzE1o0u6AvL +00mAs8daVsiVJN3CczTsQiExycVTYROm34NGJSMko4icBBABAgAGBQJW7n5ZAAoJEKB0eu5b +TpeCIMsD/1pn2fw5t+WzOeKTr+LjZXOBemITDV/dBjzwweEhNBXtUzhVFc9IEGWhvq9a7KcZ +31GQhYwudzswgzDzrlSS8eKJRQiWOKhJ/BVpKbUwuGasVanwsCmuO6udYnpY88ZaId7KkHri +pPubVe8HiIKTAsvoDcahDCNskgG4FxL1t2PliJwEEAECAAYFAlbufl0ACgkQnNl6B4X9hwZn +rQP/QMVSQwm1p5CeWyIXeYlKraC2DYaJPxEay4uFlFBoLlA8AcbstsPrLfDVyduiE9HGZybP +ehAVlnZXN48JLuJJQbhV2Vr2GJWFOQ13cXExQG2VCPL87EXyaH3yLmKsVgefnAkfLitcxffC +whefgdEnL4FHE3SobDBag8EkoGGd+YmInAQQAQIABgUCVu5+YAAKCRBnacxsd6U7t8ebBACb +qXR7Q929p/XuepF2oRdb3LzKfTuxQbvi/zW5M5xJkjXoZ39WcpyFP/8Lrwmjkev0KmqJf/Eh +fz5jp5Qp5mZpDDTVQrwLemdxkFkDAhC+04u9crgo4JGD6IiESNhY4tFFkVcEBaRnoKUtsA0W +7NGsV8lYaXprVIqdy9cB3xjzI4icBBABAgAGBQJW7n5nAAoJEMNuM5sRDhaMWpIEAIkB757z +6lCDQEFjMFlP3F6+G0/LCVxxqC3YIuxkmHePsq23hMaTL/gr2lxi7uZh2iHBAuAnNvknmT55 +qMRpvlDTynpGTFdaktc0lpPMc0abMvuYttuhQuUZ3vuFevnYS+hnNIahqL2V0WjevXEB+GOB +8KemXuQ8xkszq15/RWR1iJwEEAECAAYFAlbufmoACgkQU02OPNnxahChtAP+NevL0FuuIB1B +qqJJ3py7kL8r5NQhvrhUbyeltgAFFj0HJ8QObFoGoBJFUN1IOwcYqyHmYpcHBbI5/AjevOd4 +hpR9wAmMHsUh1kE0xWACfFWBudV2sB5bOyNaE+J/Ryow0FNWmV+vIc2IVQQJ3Hz/AatZsugh +/14tS/fEactLQDKInAQQAQIABgUCVu5+bgAKCRAuLmOor2d1JJi5A/9L3dsgFeHfUbyqjzAD +FvmQEhIZou1/+ZWHQc8kDhjIbsXmJpgndgHOgtEOHa7/n2aL0u8eksNVtPNCLN8R59oXYv7T +i6mAB7btrj1VxVAcJd0w+h4JnwRTMUzvzbuiAct9HFp4srGCFveMTu7mqt/bDplASUSNX9US +c9gMlQA/HYicBBABAgAGBQJW7n5yAAoJEBZM0Saqhiph1Q8EAJpdLwglk6NmzMmgq3y+5NC9 +fJKSrSDKlZJbnLjQuQebzKzyQBnHhVNWNiaW8gfldcxvBOchIBRUbNr+JTXU6PZfALa42Ibg +ZajWDp1HOgrjf9NvHxWuV7Kc0o5WBvRwuGdNNHy4IBsYvZz12zNxggRa8waaBpDSZNWP6cAj +zjDgiJwEEAECAAYFAlbufnUACgkQsblIBPVj4F3wlwP+KILDbs4ml1OF0TyaX7KuUpxhslVE +F2HaUL8GbWR0TXPEcZbNCNkkL+davxZb2LUU+GfeWvb9yuPgUBXbSQSXGAy43zYrcM7mSBnP +TGiiVrPCPMNZUOxRZEeNhLNkYzUIzGI24VVJCPRuBmbLnMawoWR53CBpi5Do/0g0JuRoabKI +nAQQAQIABgUCVu5+eAAKCRBJKC1eyYMLVCzcBACcza1gy77HiXTxsXom4Hq4FprkGb+9ftfo +rO+d07JQQJ1gLeDXemAV2dTn44LJ1ZBX0CogFRSHtWm4v9z5zA7wbZpnMi42n766cJuSsoyq +b+FfAX+Q7qRchNor3oBqAQYEenGZm5ArB1puihDBo8U1CyApKbbw8eJcRb0hlyaodIicBBAB +AgAGBQJW7n58AAoJEMYRjzWe1DEXDcwD/1aXquVltC9Bjn7ApQ44PBbOeYbm8r7WlmQG53YL +ge5ZNrVsf0dByRyWJ43m9nWm58cDtxBYO5uS234Svb5hm0xfUEUzqG3+Hsuy1rfSgkwdsWln +2J+VShJYNLiT9qTBukkDMOEk+dic0+QV+TsCok5gl51+lowZcplYhGmbjjnliJwEEAECAAYF +Albufn8ACgkQseEqy5vE2TMcpgP8CjPOASTJ0nuvVj1TxTJwlM6l6AyKBiXKS0WvFXF+hxb+ +Fd1XORwWpW1/XSTRxMMd6fBZxET+O3DjSr4xvYa/bl2WJ1v1EGg+Ws5ng+DWevDqbFyq1Joy +3//aLlhUSFEoFJ3CVS6Q7Pf0isQ9v2AyDyXbuwSIIGQbJIBLO9gxprCInAQQAQIABgUCVu5+ +gwAKCRDddtdqHt/uPYoWA/99vuJF+gldIPRwqnFu85rmc9+DG6aoragk4FMdx2T7ALYa9kXR +ZD34gl2JpEhUgH9fIeujYAZXXcaZlC/UGXxqyuT5gb7HHhJv3/EZw0nIJN/UlMGLvR/hI2T4 +cWf4nK6GSUTzOmNsn/okDvIrJ863DM8lzPJKgrMOp4eMkHc+3YicBBABAgAGBQJW7n6GAAoJ +EJpZ317gAliPbMID/1FS3k3dCvlyCUsy9nS+VQAI3kf6u9xK5o89XXM1wXKpsyw+FYcY4GMc +9nwW5bIwPlRsH9gvvUi0VZqoHw7PQBAoOtAUHMs1kiCbKVwikr5Et/uPvfyc1SfBIDGuLF9y +t2DPXz0Ho4r4obGb1gzbhIJEZ3uQkm1YiBO56voT3DXUiJwEEAECAAYFAlbufooACgkQ3IDC +wSWYSW6BTgQApiDr4Eu72HhEwX+NC9Z9pRfQ87tcjCFDsnHwxgdyTjCRh34SNfxLD3LbuJ+0 +gJz/WsLb6bLzW2Mmo/BpZ7VYhrNCVD+Z4HRRSm0TFjT2viTAs8rjSnGYWQaH1Z+vkRorRdIq +xyjsKqfp+u8EzyEK3z1qtbRdBujQjegfjcy7GkuInAQQAQIABgUCVu5+jQAKCRAlQVZDt6MS +qHdfBACdtUZdTmJjmcsna50b78eosvFP01JLIhKDqH1f3rxfyJCrpAcNcdj479saWM2e9IKj +lWBMES0Jej/0UTLHrOrDAnAxG1GWW/zLmO7VyLIdlt/gF1zOYQYJg62r+zA/nurt9KG89KUK +lNic0R5gY71w3BhWSEwgpZbnTh45oVvFvoicBBABAgAGBQJW7n6QAAoJEIsoyQ1L6edstsMD +/iZ0mneNc1scHF1w6fZLiXRQCBogbbjrmOFan2CDg/7Np0Cl9Crhr37RyRS70399erhi7tH2 +in4tZFJNLf2fADhN/F4bUPMZeUp88By5NRRqchciQrsZQtPDWErbP/zcBSz1AfqOSWmQTS9L +Q3PD5GmuEsOZPoGTVspoEMzImStqiJwEEAECAAYFAlbufpQACgkQVrrM5T9qr1TkjAP9Hu/C +sVl4aJG7f5G1jWZaZGmjAVWbuGrISki0mZk8pPwp2YUiEWQJ/kDQxn04DYcGDzWP7qU72Ycl +o1fHhRV3g+uApsXLMbrmgwuUPZgHr8HVJb4NwsPNGieRUgIok6H8wg++eoyxSxjmo+6VkXdI +H5omMCSRhOc5Qj2zTXMnPDSInAQQAQIABgUCVu5+lwAKCRCLInuU7YqpHgGWBACbC9PgArWs ++LdEWjXXUJJHilg29dg7YRNrwJrgmUlExUDZ8Xa40lv5eBdqWjNi8lIFM+Ykt0ypjRZb/ufP +t2ebk36+/DHSf+G3yyk3K/H0eKkqoDImTGTF6CZebQTxyKpdw3u+apPGmpIspF3JXp3lDTMr +ZLFQDURJAFnNqWg1U4icBBABAgAGBQJW7n6bAAoJEOdkNRrziW59xwID/131YT/3lZzIj7xE +JszvqbfOcTaGzbTbaO58imVXdQRiVJUGj5Mr38FJhriI1dIuHy6CcavNzaGGYF8JvfbmcocO +E+SiL44ykxpBQY8leDHn6TkJ89KWudUgEEAo0JZ+3ryS9Pxz7/LCJq4KmPLJZ68pRJoKz7vE +2p7SERUpGS17iJwEEAECAAYFAlbufp4ACgkQA8lcRdRS+aqjQAP/a08soSP/nsoQgWZvZEc2 +tHnbyWIh80+prcqxz5VOSDSIpmlrD07pZQKZA9an7hPTJmGQthwt3EXACzV5lhUTx+QjLcE5 +8U+/zBhDMnAlhAtuPHEwhX47j8spcweAEy1/KJbvw+G1aH959NbhhGoWmI9z8e5wlC2LHQE9 +Sj0oEo2InAQQAQIABgUCVu5+oQAKCRAkGVzKs6EjvWA7A/9UvpEOCkhKCaieSDoZW8bH5vgi +lJt4ebRzIur6U8OzviAnef0S4AlWxUmT0o11UlJXxIUA1qANbRsyXgPetvPwKtGqMj9DXpLl +Mmy7NEvNEDdcsJ3VlU2l25bb3HW/PDCuFLK2N3ZX9M+Nceoj8RitNRhRZB96J6h14J07JPFc +SoicBBABAgAGBQJW7n6lAAoJEAONvSfcKxR8lnUEAJFzTSMHsIs2t/pPwL8TuTFIgE2jbocM +QeaM1x8JMz9fl5bWQE4+2jtpI8OjROjGz3IbcxtO2by1w8/uC0mm1kUJ3qlM1qk/2XGrI11X +qTebTRfkDvtBmXW8VQdetOFDjMWo18OQsvGPebf81GvzRIPXP1+NN2Qrq3zZx5ql0lEziJwE +EAECAAYFAlbufqgACgkQJ1j6SoaXZexh6AP+IdOnB8TMjUPVkP/xnvaiL4FrsQmj1+EH+0Qw +Vab5oCVV8xoz5osG/OlX+Pb1LTHGCfDJfiZBTm/sObDfE62JSG8NMfD/PEpqFk5E4XQOPfG0 +eXJ4afjLTZ2Cwm4mHe+9qOztGu6M4ZCJjqdvcgiHeq4KCZktrWjMFQT506OxLBaInAQQAQIA +BgUCVu5+qwAKCRADrwp1VU1+vwKkA/40KbCNudCfbfZ6yyYjl5lHdg6d8yK4bYkj4iYQWp3E +W7fqfONVDF6P1Tkc8ZkIxPzM8HGolL0E/kdaHAQLG7oR8sKbUPE/9v+izMZNGpqynA4wWu8p +xyGyYuE5vB2earvzSj1pmQ0gfGY6MDRSVPwBMjs4ciclFW9148a7AoDti4icBBABAgAGBQJW +7n6vAAoJEEvyn0RhNZ/oiGID/jHJAYY/lE6DOyx8+z7bp/Z1RXi/kbMfMnQqJ7JOn87gEytp +vbUmBePZu7R61dL3bTFh/AiwVp1ywskI4wOx3Kj6vaoR141BjPFksDYrWyLjmxBxJ+dEteCI +98uU4kQZxtrPArhEYX9g6zc7wovOhVmJYOy+88ZDZGYCnQYXoNh0iJwEEAECAAYFAlbufrIA +CgkQaYPV1bpBV9I+OgP/Wmk+rCtrax3+XqYJdutxeZ52FhDs3lp5+IV6lQxx7MArWZgHu2nL +kXY+4s82BkAvYEr6lTOFozT1LSdTlNddqxs/rx6VOMsE0/r4pTAIfcu79e2PfT37U30eSEpL +8x6fgCXdB1JMm+7OiD2DWn+nXmueaRc34MhhTc22+jzAjqWInAQQAQIABgUCVu5+tQAKCRDs +NhK3cVz1LfawA/4mxLHER+5C/GZZEhBKPLal0PFI/r5kilk2qPAXwCUHhT6HFxUlMrWaEgNS +3N0rh1VEXdZFPITw9rJPI23ppO20e4dpy7GioHC/xKJmABOXA2KKy+qQOmOOJ5JFPg9LvMgG +d7ZWWi8Jji2gLp96lyekfmrZm7VGEGo/wvbx1zfM9YicBBABAgAGBQJW7n65AAoJEKkKTVhb +QHfzKTIEAKKbYPCWmklqmkwBamaxkmv1+ZBIvdnLFcpST4c1eO5DEjpKiI8XnCBkNx4uyqTc +oF8GedExBPTVZDsRIPA1BcS4KGGm3C0k4V8IsY8WvOSfqGf5KJNLsqjcYolKQuERSzFdRevA +sDucryUaz/uqzPxpcQM8h28/RDNDAIKuN6JgiJwEEAECAAYFAlbufrwACgkQkVLD5ZYSGEF+ +3gQArEhCFioghk6d8mvTfcKvkx51IjuERT/MvmDLipzTcE3/6LxC3be/I5yMAWCp0D67roVe +E/wARGCApdLmee4E0qneddrjE57Px+okww5R9FWoZvL4ogWTs/xLmFWO3ng145l8R8eXbdC2 +/ggTa4TWi4e5ydVPd1SUsFNzOAGPOZyInAQQAQIABgUCVu5+vwAKCRA60Q6vHbr1MD+MA/9R +15UvCVs57ZFe7KgSuoNr2FXwcvgs+x/gv83SRXguKaucyTUKJtavZLfmDeXuHaDxtzFdcG2J +6m8PC0Ag8U97A3jPPPz5Ii9D17aeX/Yqpgzuhaq6CW5o7YSyCIPk12eMFcncW/VcJh9kaIqv +MeMVmKyzQQ4znOH9Avxm2RTvAYicBBABAgAGBQJW7n7CAAoJEPG7y4OEPBMxyTAD+QEXyy4M +QZBq9VbworEsD5H5gq5QloIuV6Yn6hfEAMW98N0Fa5muQiCTU49cvho6QW+yFLUQg5wrAN/6 +odcRcIgJFxzae4dl/wAxbdQnna4JGYD/ygSk7sIGqjsumZGWZlDVyFIxMOL6AEvYAGZR6Xij +GWX3+WPKjO3xY/wi6mTdiJwEEAECAAYFAlbufsYACgkQ8+FqV8ArDB7c6wP8DdamtYzI4ntp +kDbhS2d87sAY0IbnUkHL22ooC2vERC9p866zMT1Bi+eYPtEMHyrDmSVTxzYwRHQnXjNQ+mOH +PpKHkRyqtMs2QlQ8j86hdv3a8lwI7l+/QBQwra0/3Ypa8hEysqzWAMA4HgpbghOAmdTF2+Vh +7yVrZ1DOGjpy+qWInAQQAQIABgUCVu5+yQAKCRDLTYK0KxGaiVa4A/4tyX2Yjw37G/xVZtB7 +J6xCGmw3WnXdF+obwcdPklO0Tffo2RTRrjXWwBwQA/YcU88sao7R0V2Jq0khUCI7FomTyo8X +IIOHM4MTe68KhlqCNtdsmjmLiBK46bakG+dT+moOF70LMiPmTfxc1A2Ei9VTbSObGybAqPlR +RJ3g3UKBfIicBBABAgAGBQJW7n7NAAoJEApoWEAtl/8SYmwD/1ciXAnvfNeBG4QpxAkxAMrM +GWRu+MCMIuqcf+kT4kgppLiZP5RM/bq5wwmO4Fn/rM8hVohpz/ZZEC7Uh2psmUtBix+JIHlv +R08tkZ45Y7uYOxEYVFMM4q2nfCtGNtPrAMH9EjYtw4l+j79R2xdQlJCAuysZxaL2lNe+M8uU +tlaqiJwEEAECAAYFAlbuftAACgkQl9Nk3Ay/SqqmMwP/YKyxwfl98T8o8WZcSxWWF+E3DrHF ++Pr1xD2lFrB+q4d6UkrzU8CwEtuoOHP/5zkoHfwoZ+Toq8sVVZsx541nw7YalXYd3ydx+EES +5MZxkSb7WBstLSKXZloIfKtBiw6UKy9vYuK7xcZgxHVBKwdMU454us2DD+7Qsw7QzRIKneqI +nAQQAQIABgUCVu5+1AAKCRBmCp8UE0T85cAvA/0ehOss45GhNrsZ7HCEiMWwEpu/hPFKp8aN +YiZ3kdm+OqbdSsyXTjOrAJ6OLLmWpyY0aimi36P5M0eYcUeh37ViWlDhzDFlD5/hx5lss1Du +6gy40DDVgfWLXV2lLvvPAugPD/kNolia5xNczx+CPaKFH9fEyWL0sBOxuCFvclGNmoicBBAB +AgAGBQJW7n7XAAoJEMjhbt8eTaWP7TQD/AjZft/4drDknKPMIpQdwTJsRnu7zhFn2Msrt2/s +DzIHNyeWLITUQzau7CKxmjeTnh510/AWXDI7iC2PzYEwVotMPcItBEUEoY2brCsouYmGjYvw +1aipm3OhbYKOQz+iH1gVJq1/HHAn7KDoSq4mLvhFnSHygo28DujwOCv8aClmiJwEEAECAAYF +AlbuftoACgkQTnPSHSIBldJJtAP/Vj8s3Ogvs0oUea49JbaxVQUVeBtlOeOkUjjoazVoW0Zm +0iuFuZlMHfdhf/fp2AADQErhzBCTFJtDcgFQmIEJDp3NycmIWlfU9S+um8Ci/0ipiP1z89WV +QaYfuVNJ0UJ6/giSeY9VxqKIdUyN7nZjMSYuZof7z+PciuaVQtdM5xeInAQQAQIABgUCVu5+ +3gAKCRAX29E9Y4STtQ7HBAC3LXrBuVWvkFm+znac48m93wQoOcLqXRlJDYxRGocDdpgwQ5iq +d4AW6G9q3nBnjiAvwcn33Xg19qds/Puo+dt37TTJRTVvClPxun41B6XgEvGUYCPtJ8mL1Htt +pKLZLCtWCcBGGnDFjV+JOjoepmtzlTky7iJ8F/3tw+XVhx0QW4icBBABAgAGBQJW7n7hAAoJ +ED8eYTBfQVvHqrcEAJfPD3r7wN+lqgyFpzITHtU5cXQ9YoRi0h+13uKjjzB44+qzVfbR+/7X ++MYOpKSpmyZ9+VGbrZh4fwDL2++3kfDdZzCmmfioP0Q5KzcwcmsJOZpKzAcen05SQWnWI85s +WMXtxLCzV2tWoNtLHChbAp4X2ZU4AGcVpQfR31VcXR6xiJwEEAECAAYFAlbufuQACgkQuVaD +tZYpVIwyrwP+MO2sOOYJYVR7op9DT2UiZur3X2OeE/aKma4f9XVgbcuk/QOSek9UC8R4wFHL +k0KBQI6GMcFz8gw9BCP/i96NiBXjhz97rl76aXexywvwJ85H+tQO59VhLhQaVKiWw79y0DYS +v3KONi5nG54e2V6ieEObGtS8X8UiFnWWlaW4At6InAQQAQIABgUCVu5+6AAKCRBj4Bn6tbu9 +28P6BADWplvQX4MikZpWNyIZ/2r2EzSZaDvBPDZLlTRFl1B5zG6KywqIvEpDxH9hLf9MeS+n +IhqFOZ7/Gmq005WiQirV904/GAg4BkqeHQjCnmcw3Euq5Eofc91B6bC34mMzI7FrDZ2C6VVY +kX35r/fqx1OxRdMii68/3ej0BMK20Bg58IicBBABAgAGBQJW7n7rAAoJEMhYPqnCodfKu/AD +/32fH6dXkS7bVt9+ech/FJbbtkgBY8mLNckE+Hyy8EqzbwUqXUn9zQTwkHnkE586bahTe4uI +Ue/kKqQYZmm9Tfsf7SxqI9AIGCtYHX9IcxRaPBNkEWHHi9ySdPKuj/qIbFf9X2Gmz5BNUBkH +sIj+SxprgmtMA4i7juuhd6dd/sE5iJwEEAECAAYFAlbufu8ACgkQVuZ7JrSqoaX4GQP/fzYt +BjsjdcVxd6TPaQjp89bYsq4/iXnlIwCPDRroCOwbs8Tg6gunigd3ruYKHTxrhmYrUy3C7odq +aorwei6BdXwx+xGWIQcnrj9Aor5bO4glOpQ0MJJ7qKYnpJ8oZSJxnYzM+xbfIrSVCv809dvo +b74cGOcCAxwWsLn/n7R+aBSInAQQAQIABgUCVu5+8gAKCRBPy1d4GBirAUuqA/4ntormU/LX +Eg+qPqcg2XtaCOQyypwBSyC88pHYBdR6q3RRjcZQyHM+hyAVPmokUF1X+aHBlgXqY/LTh4sY +lSbffTEqE9+73DDk7pQkWLfhTN/LyV7ARRs6X6g5zMD09Ge/oNYL3RdtF30pPNnaP0ENUk3D +nSTUe8yjdIUBXRog0YicBBABAgAGBQJW7n75AAoJEL86KH9nuv7mVMQD/Rt6ceMecM4ff6Ax +Hc7bzs2JQf/LdcH9Mnpn9S8Zr+jp8MwQHI5gZFirfFvw0uZvJ1RjbVo5yh+sKPNm++vHjrMv +9+O0B/nLAgf+l4BYxUWo/k9NC9JRF7hSE9Q8gpMYONyTrywuI7Q63M/Ax9fERPJ7clTzXoLx +1lCDIj+txffkiJwEEAECAAYFAlbufvwACgkQ3kGvBmR7ZnpxYQP9HvuOkQ7i692jkEAtY99x +SPqe0lm36LoJL2HbSVcgTBwwpXRHcZl4dvebJnkA+qGEQxJ4xmg1atQS/mneXt3lW5UpqVgs +SiUBcgpc3HjjIFYZ7DpB2x+oBLQ5/SlsQIEDtK+II+FZfgB3iOwsTIKwDlIuTUOjaJtJbHmB +6EOC3OyInAQQAQIABgUCVu5/DQAKCRA08NhVAAyQC8R1A/wMzl+6kElxFMvaeu/PKeRSSEKf +CBCj7LLE7dmbjqDjPprXlMnoWL01SefXAjOXDwYkyXa/OPBkSiw/q5vvSZNmTtg+DyRrtO2D +sflvHQBzQW3kYlzajqd5wFh+p6eXF1TgQT1Bjjheom9yhXyTnTSSJVcjGU8MxMbY+TQOjDQn +eoicBBABAgAGBQJW7n8RAAoJEPDtkg3QypXAlTcD/1WAffWpsQe+br6M6uwrnsjOep3/IYpH +CE6Q302Y3Qw+q3u7zShuw9TPBwjuUFqdYTvbA9bg/0ewJ3KixyeD9QrW71vDUs4BVj/pmJb6 +lWmwqaTH0JqcKuTzXwjC2/aXrJFPL5UP/g60Tw1rCol0pr7dAyOsRppwzHRN+fw9zN4uiJwE +EAECAAYFAlbufxUACgkQ0h7KbuimxgT3YwP/e/yxJV3P0ht6AAqyIxEa2beKs2MeAmUWsQcE +DpFFGxy9KxJ0RoWPMSwICQVxlsQ6NLvVSt+PuEjpZ3dzH1K+C5dO5OlFHSy3qHKX1H36rT6T +2mG1ik01BNcJNbUWLf3ZRU4tEtD1VPFrtBzDZjFsCJErbvzBJF3JbQ/poJqxa6mInAQQAQIA +BgUCVu5/GAAKCRBTje2gLO7uc9hDBACQLEq48t9JCRjeUbQkAWOcQQ+DSONUBR+0A0VJZnOh +ncwunlTbfmmgv9V4MnqsiB5k35knMYjmWheYtl9EQdogJbpKvJ6a2Pnuaca9ymUfORFLzaYY +AaLvE7dnTO6R1K2Cx9GXYjSpCdfHg4pBI1z8ll3lJnb40qFwemUzKlM5tYicBBABAgAGBQJW +7n8cAAoJEMVcRgIICoLTgE0D/0py1NCM3Cki36tK+dtAwC+2Gfei1jJpcPLnp+UxnZe7fMOm +uvHh+mW/fUV2aRvM6/hzgyhn+rhwG2W14UaT4lafSUYM2oA49KjYvDIcprmAoTVSwGHNG8hk +0w8aA6ounQ3syBXhqr59+4YsXWLoG7nUvuVISMHFT2xWK7Yls5JbiJwEEAECAAYFAlbufx8A +CgkQ5SGiyjUTbFZpwgP/TTXCU3E9vP3LEoBaRueInMOVQe9LcCPXCln19jNGO7G0Vda8CNIa +Ppggc4YTWCPWbVOUsujjshpFnDw/Vi9t6RZiWmiaU2QEGq1GtM7odyTlH+2OP2n0U+oEe3lj +5XoXzopdN1x+n8rKh95M9mdAaq3zMITlWMHuBNDRW9aDj8qInAQQAQIABgUCVu5/IwAKCRA+ +Efo9IPZM8y6eA/93gbJ1vq1y71T6tSCW6YlcDP/PQ6N5n2ntlU46KOt6jZO2N6cA6fneFv4a +DROhypbSsfGYlWaILKDhi+dXx9l00jeielIsTSmMp9m0ZYrgAhjx2LjJJDYk/z+fPES0JbLK +D9bDFUT2OqI96q5cDGJGdsKTrLdNtuEYyiMxKVyFZ4icBBABAgAGBQJW7n8mAAoJED1dZyVb +useW0PYD/jX48PeIEohmlT1/pYm6Wcw8/Fi1q2KPOT11f95ysIkvO/e5bCZ6PPGCExTMUX12 +0s/UPiJQIAdIH9Wh033ZSi85fgPoajKWykfH9uU2mKZ31zyfDc7cjZtLa3jIoux4Vv2VU67h +DUWnVB8eLdJ+Fs2LKUNojvjPyNiPuO5pWeMQiJwEEAECAAYFAlbufyoACgkQnDE/u1/IRHOL +uQP+LkqbXxT1gyAyJDm3q4o3GxjoWbQNAWonezPSZsvnAbDPGnD7TXn1XOWa9Khr/fImQu49 +ee+IHgEVjLIALY+/Td0IlBfKIrUepKthHzscwmrBMRhjJbAJuAMk6YpwtYCjTzJFntOvvIwl +blFKNLXIYFwTZjY5GSZGifq1h8M9gAmInAQQAQIABgUCVu5/1AAKCRAuCaXFiIEoMPHkA/9J +pvaC7Cr5T97ySJJyEdABmPK/243kiUizkKOEBJ+BcyearbYioov2tmBD4obP28CpBo4PoAXR +YreB9wYeWPnyfKt6puBJmXkx9aZJJ0sTl1i7a0dHcCEg6X5d6eSp80boFQGMVIQFh9IZINDS +4jHeioRwVYuFeYrVBWR0KNU6EIicBBABAgAGBQJW7n/YAAoJELWPTLe1smPGzzUD/j9PMdej +5QPbZfJ0LkPV1MQ2kwZQ7WJ0KvX+ktZ9cPk7ctjpLNr4U/w0VMJ2NtyNxtpdp8S/+i9aRaIx +WBtJ8MKtvwwp47t2CLi+14R2bwJv6Ucyy5TEuqzO3UfXqzXXyR04yRJEU3IggGzPRgg9Xinn +3XE93evtWFpRY29J/iRFiJwEEAECAAYFAlbuf9sACgkQCDrn1g0f7cGdfQP/avm4RBYyLd6y +NHto6UsA7AFrcXfwJPPKe8PLRz4PeXq9jbHySIYsv4K20FMxJm+v+8pHYLhe0ligEEkAxK6G +p73kVQDUjmJY/IpRVe5N/Kufx76xbkaFUwLFpjJXDChh1lv759hXAqWBNA3WDpbp1hwmitBR +Kooxcw55LQdpMJ6InAQQAQIABgUCVu5/3wAKCRBBrF8+TAz9NPjTA/4tub1bWVdkRBt4ghan +my0t+h3k15WYadcA0yHqa8W5xksiqK9g1AjORel5y0XpJTKMvvbm66nLzIZW8jXyAGFjFYKA +cbOCtAOO0XR1j3KAn4OwgqbXlaDW3QJW+86K8Ngdhjcu8vuY+G0bgQsjABFLeFinDbCyhOb/ +A2+h2eyob4icBBABAgAGBQJW7n/jAAoJEJ3JyX0sqbJuKUAD/3X0Y3sUErvNllxvVI119dU4 +QwWY41+Wy884t/8x0/WjamPi0XGWE5Vjr4JNIwaawBnTc/lhjwpf4uiIiGiCsSZP9aHEVCnQ +Xy1njVQaWDSmBr7EF1+MbHccwndgsAzk5kZu2T9s3aBDCw6CFKb6vIkRY2EqJmC5ILfjRSlD +1pa9iJwEEAECAAYFAlbuf+YACgkQo44lXw6qZSVuRAP/dJObLUXJu4ogtLXhQBBuEd5gnvKh +9TneRkfpTMpBO3AT7QgD9wyYiJL7Z3yH/v1UkHqTuZn5bmunC/XLw0kOIAZkThMNChE08ckO +z77DH4BXnlwRwqm96+brOY756TRy+0KTiql2ALftMLIQHn4F45cExXq7TX0cg/N7AyCKsxaI +nAQQAQIABgUCVu5/6gAKCRCUJO/8ymBBdX3dA/0TGQC3rOMvmz+7EOkz/YAIEPelDuUuE1pn +M7rpXQnorZ7L0NRMClTQxbIfFqE9PmcQbfP3qXdJvLCBqf2uHH/o/Rt+Vt/ONq776DAmjzpl +CO5GjBmTI1jYH/6hvCP3TIsLvuGDglkt2C4e2+NpfGV/iyH0YIml9On/WfmZGWt/3oicBBAB +AgAGBQJW7n/tAAoJEIJbjJ6pi3fXV1ID/00SwQAltoYmQDlLyp9LoVvS7eb49Ij8MdrcOjCc ++u8oPiifNfOjibme6bHVONvqRgluEZ6bLOSNRwYjVTg1s6aj0rOD2SwEfnufwW8ql+UafkoR +DkPyxli1YPeWAo3H58SZdMWyVEaeLfv1tDoYZPbGc0DFmkNQxJRKRfz+Qb3CiJwEEAECAAYF +Albuf/AACgkQCD7CxhCwI6dlQQP9FxJU8hp2W5J+vZwj+xHcV8iWtVU9FO22XAdag8f4KIS+ +imAu/HXpKrNMRD2eKsLTHcUchgMtpgjpxqMPXsbK6MA56EdVIV2qwH4IuxUEmKVGR8nPDlP4 +iLgdt6Fx4DApj3ecmUOEzk+4baItOg88GY4Qs2B+t0B5EykefDUoZDWInAQQAQIABgUCVu5/ +9AAKCRDkJXlbHznh+RWXA/9vp4UhvqnlUImwk5KjjDOQFIXIW4eZ6+s8tZQ/KVt+ulShMVqV +HHcJHgsOePlpeD+2Jzi/eLUFsU7FLWLAtxEB93V4xPqH0UbiyXARlgGxoasn9GF3RViEIOdM +mV+GND1YbEwyHq4O4zPZGR909RtYb4sxf/vtqiSBr29KasbrNIicBBABAgAGBQJW7n/3AAoJ +ELn2EJWn+RCm0mgEAKOyby3KErfu3NS30LIXfapZpbHz0TNKxQ/PyOGZ14tWt3k2yEcTXac9 +u+p2/z6xRzeWgknKi8arnKKpUiUy6DGg6TtNl+3vevsyPSLDTa8rNShdDV9ixJfmHcE7mOMy +lomvGKJyr19u7M1L1FMM3SEgXXH7XFxs4KPuEYuUE3k7iJwEEAECAAYFAlbuf/sACgkQpjsO +vfvNI5oHQAP+Iwq7y3L39LFzDTlJm8o2BH2pTriWUPBdArthguSd/8DUEiQmEGq1yQVhwtoI +mHwUCXDpX03XJTOgF4pfq7ppbRi/JGEKsyzULKRihJVyJ2jFVBu9gqDh7gBOO/zS2pD4MRuF +CoZJdy58rrGLyf6dDcKJtyQSXeR2MvC2al7ztfCInAQQAQIABgUCVu5//gAKCRA/Kb84TnPb +dVXeA/4yRAcmbjEDfAudGvR4kWnbVPbCbl37lBiEniUW6QSPZsLYxvhUzdZnHJ5rKs6qKu29 +butEeyHg09YkZlSJKrHPn/ceAcGcTxSkrvlLQMU34Zw7tuJYMi95gRVEOximy9UwesCc30re +NqyDqrLbB3eaZiKJK1yRIhQvjizrywa3cIicBBABAgAGBQJW7oACAAoJEN/pXKHtkjMyVMsD +/0KME9gi+mSYYpdmq4FIS6CPb6Ah/e+rkVd2HjgkSYFXD3COmKOFQ5cF5dx79bgSY2Zfc7zh +8XcsTu3btRBYkXonT6P43XD8Z7ggMXTn/rNRU3vib5z2lGYt9iAEOAorlnE14yYOTf7yAS5f +rMmY5Ma7vMkZ2GS6f94vqStKPHeWiJwEEAECAAYFAlbugAUACgkQlHfLHN8995MwawQAjeIm +0ZeAfUU8HS1lEnAX2THSXHOiHDfkgPNJkK2NAVMXVYd615q52cI2SOmvXkRa0hXhTKI06Gmm +t66DwqgMe75kz0c5TF7abJmpunfVZ0EIAmOq1u8H9xE+Y38KhfAs/8jPh5DS5Nu076nwBc/G +PViBeqyLBuLmCA/p+x/N0YOInAQQAQIABgUCVu6ACQAKCRBbHZHGZ+Hp8zDaA/9xAuzZHK6S +TNHo8nW/SSeTFMgauitqhCHitIYDt6KjXyosjgig6r6Ca1TH4bpjwUnVpaZk4G8Jz5z6hXkm +/WGh3fmQi/NoaDq1+Sw9vKcSG/QeXJQeR3Gy0lDpJZ9TWNFk3r9owRaJ+s/W2LAWT9jk2I6k +Ws5apZc63Alw9K6+qYicBBABAgAGBQJW7oAMAAoJEBVTLrEqLYhJjQYD/3YXjdmKNMto5EmG +pw23+WMwHKoevmo/XGdA2R3XQgpSMROahuAFEm7gOCLoisoFj9nh13kAFX3F+/V6P4z4moNl +KFxgyE6SOzt9fwA/uy3cp4E+9BH7ebKoHjG7Y/Z4hvl2E9KH3pJBhlYoSFk6o2hESVAmKO7I +XZ8KoO5qnXVPiJwEEAECAAYFAlbugBAACgkQkIAQov5VeEvyzAQAqCQWRrZFspfrhzlW0pmK +LDRjQTx2k+21k6h/yLY4AvYuiO58m2jVdHsFLi5OKm+xZc6Gha/FHm3DXhIMQ/Vx507qLQxg +HUXik73QaJn5Q0j8fXdrzyNvdkNztGmIW6r2qRQ9n5vu/yrBCGwI/mfmILhU3F+x/frSd0O6 +xpV7ymmInAQQAQIABgUCVu6AEwAKCRDYJrfiHVskJKEfA/oCnA08YOMpCW1FnGHxY1etYFXV +OcvmB0AHcDdhP0dyHvS+8NzMp/ILxNyHU9canWGRVPDfJTVzyF8ZH+FcfYofknmZn5SgL7VS +OXkVbRm7qkGLZtV2opjkoA1IthNW/1PR38qnRnTIjw3xZtUvtK2cPdo3JZWAx3rpYhNOktGg +EoicBBABAgAGBQJW7oAXAAoJEB8DC+0iL6W2tRsD/2cZxqZkG26T08mRZ4aRUZDWMEUDRPAE +TUqE0eLtrxP7kabWwkS1LMymOQUQ5kZOJSiNlj5Hx2bsDFNMIKYpYJ8r59/c/EnWbenRN+Th +GDgYn807qiN034jq2OGxTiQDIbs97Iu6mgEn61g27iY7IDvYR964GAvtz4WEDRk9VuPDiJwE +EAECAAYFAlbugBoACgkQWVvpm1DESzigQgQAjiPKI7nYJSxNelXytdqTMSKMlQFaCEE7dl3l +aROvx7qvEqkFz/BMkr4Hn7+BZBBhGLqPK5qB9WTYVk0WtKcG5XocagYfGaghLd3cWuxgaM+k +0YS6Xu8/o7PlosJExy3hUQqbOMwwETcsVZpLHtof8eBCwCOkaknePCFKhYKwxTSInAQQAQIA +BgUCVu6AHQAKCRDyy5egGxf9yEBgA/wOcU/41wsyR0z0025Zh5RMlUzxWvmAksnnaX/7sr3e +ZmCLq+Muc1vPDsXTWtFH/vSDh3ASbMYYW40SskuC6l7LmYM858v0CDhr1XdUsYzDtmh1prKT +hzEt33xBfHMxF0WOEMRPRTTX1uoiTCbSZ998+7DNtCxLPQywGCID0wrW44icBBABAgAGBQJW +7oAhAAoJEMedeEHZchxotgoD/0t7Txpi553gvM8oyUimpTohBAmGtCSB/yjIr8lnNH+vfFYU +C9g61E6ZVsoGP81JhQJYszMccEXUFbZMpIQEkrA+LpzHfDEEnrxeDXW+izJHu1hsfBfnVYPl +5tsapCTBcBdNVTBkscbeqLvx/NR6QAy1DIq7TZ48yZTOz6g41bWSiJwEEAECAAYFAlbugCQA +CgkQLG4PFKJY8PxeaAP/WZgCEJrK6BciH6SZYe+46TnLzwV/7R9rTK+UwBHha1fzBIXPC85+ +Rx/bnIrRsFYyqogJU/6kgT44Ccjb1YiQrm37jeB1cF0KR6Q3CiUtkm1dVEeb2iOSJqA7040f +WKGnZJaAKQ34zRlfgIEtraETKEl8lVAbfW+aFTIdVd89Jk2InAQQAQIABgUCVu6AKAAKCRCG +VARgdOfW+FEiA/9Y0DOrBs0awMqfC/+6Kw8dHrnr0II1+XKkqvjNE5sN4bb6aYHY0EjGC9Ur +v7qTzmqL/z2l/OaAtM2CqzhGwVk5t/QLbnyhZSdcj2fO5k4V+dhfutG32ng/G2U2Gx/I6jM6 +DQzGej4Q+4yI2ifAEQrHI+RNJzn3KZ6Sr/koCZlqV4icBBABAgAGBQJW7oArAAoJENhsh4pt +foiCEuMD/RSjHYgWEbKxewy1ZJOgsFI22qCnF3jaXlOeRKT8JINGCKoACIK2ozia6fhnH0pJ +mFZIrxD6EU4799vSLHmlzb+JrjaV55dCEb2t+cjwl0tp8lrkRhRFl8H6FK5IyXIXGqBp5eyU +q9KFOSCXrQxS8j8aCLDCWuAScvMM0LwsDs6tiJwEEAECAAYFAlbugDIACgkQS9ws2Qkc/FAE +QAP/XNeidzuT3tm07wjC65Sp5MY/CGKOph4Tuh7s5RS3FuaxRpmcw1GmB8NxNBeAjq5DmBKg +HCc6ahpoJnv41COZS4q4zAkP4FIQDra2vhzT/JpRq6W74ojXADE8lJEaW++0TZX11G36FlkT +PPXWiVHD5q6vvhfvKtzyFwCAMWinonyInAQQAQIABgUCVu6ANQAKCRDhfg3T1KPQCfTJBADm +bGqym/kuAjxvsuIee6Y/ClYw4QbOYZFUWs/SQR1BzeaYzEisuKsVqu9B08GzUfLfBbsIZFOk +hw5/n3d6R1x6Ws+2b+PcllcMng5BVhA3rhf+SLaK/UV7URex+BSNs2JhdisfzAqxjnUcFg9i +VmBeZlpcVkyabXMemmFUpbnBOoicBBABAgAGBQJW7oA5AAoJED7MCFLyrBCYX0wEAJgQg2kr +MeRK36OifKzs1AwzZDyLAYoU3pRt++WHXkC+slCwVAoIK8NP3Z/3c1m0axmPowV+Y8g4JdbS +/DMIPEe8cFzOpwl3vnusIY+HTalkjKXDsgHnwxd0ESUGndZK5Hxj/k8Qw/2p0FEx+Of8bEEl +qt1EkHpjfyPl7SO/jJ1siJwEEAECAAYFAlbugDwACgkQbT4nF1zuJ+K8TgQAtNdY/GrSPirP +yCrUdOCm5hx/cwjl0dz517pIxQdW6rzyILNbDmO8fgC6x9h0HZkdtNRbNgsOIywFYN6Juu6A +BCBU3XybXAgKTpDdPfCbaYXb61f/GcAkvRyzoLRXyWdn1zXad4+RklpCuQGZMHuS4Ll6qq7A +J0YSJInf8wH2wSGInAQQAQIABgUCVu6AQAAKCRD+TeztJSHcgRG3BACB2zUSD4MXMRZlGpxP +6NWrHEwKMSHjjdzZdZ1QyS7OYppoCCJjexTLq+kZVryTZbZnHnwvxIdb6bgLGTLR0cBOFupA +SA2RDvpLEwZI1BWN4MZ3qHgiDkEjbXkAO6jVHdEDgABM5suE8yLhJEgO18Ksmdbv5cEP75QM +GSem8S2XAYicBBABAgAGBQJW7oBDAAoJEEnG7PDmU4z44XIEAOBvPpEmRJZSAw30VannuA+r +fxbuRDebs0kF8Ds0p2Nhka1cV8XMbUaRPB1yegrOXrkCRy+qQSrigX3fcV6/XQWpkQU/KDSO +GpI22gel/VpR0lrkn/IK+qjTZffYyDG2V7JNYlohza9wES2cWAcPjJqdJP4XbqeosIn8puP2 +4s7riJwEEAECAAYFAlbugEcACgkQj/MlcJAC7BgmUQQAhfNTbOgFdnpmb6YA3gfaA7Pshl7F +L+BmpdRuUQS0NYeV5xg1J1K3rEzuwUUR1O8FBGR2WQAYBcR3xrR0SJw4p6BSquWCHb6sLIHS +F5GzlzCL2fJAEW4PxDynfF5/l2NJzQ7k7GbvhlsHnUJW0McFjb6v6dkI50AOtHhkHfdLQnGI +nAQQAQIABgUCVu6ASgAKCRCn94dNWCh94U/1A/9IliCKJ9q3ofclBDFjVxDed20tuBK3rJcB +AAM4x2ln+mn/znfGOzy4zc03MjbwSEPauoGpqcC88L/Bc7q1mL94vrMSeExV+UHTaAaNWvmY +1tSN/YpvwgKO05lrge2OBh2FgtBFqyXcWXucpvxaKWHAo8oE2A2+nwSg/RH78a5OpoicBBAB +AgAGBQJW7oBOAAoJEGjTcSqMc6ywgN4EAIxk0rvkj54c2WPWe/YxxKx70EvOmzh55D3YOnaj +JKL9RDtSqsPh/An5wwOhxLbbkHz2r3DF7HE9PBqQTeGCou/J0ljqLHLb+DHCbcHIW6N/TbmK +KDRZ90mkhSSTlEOj+JUqU83U0QtzOTewr7az2uKiADrdEtQXWA0uJBycgWbHiJwEEAECAAYF +AlbugFEACgkQTjVTGpYpekjorwQAqxScScxN67eqCct1oUhxvjON9LHGFDxclNPYi7UmtIzO +KdpdAdQhF+AGZydGvhjN3zEy5pcYAHl5kup6Xp4PWvbN0qP6pETsqPDgnGxKvHt1CF2Uddm9 +4MLzIWtRVTTISYLu2eYU1JauklIAfiCmSzCNeC8UKWdDCXzeT70/n0GInAQQAQIABgUCVu6A +VQAKCRA8lHOaXBZFRUjeA/wPuZ0uVFSPL+v9SQmUdthrOLv+ZU4U2lkyxUPCVikiYJOzpRn+ +7crfSfNZTGXZmkntkzxjDQDN1T3Li0yTFTYlwlf72sVklrWAEeYXs+gjCpbbWvwPvIny+wvA +MGfLQzkjgVSIaKT5ZX67vA9GH6EMEHexqRL2wNilcMEkPdx2goicBBABAgAGBQJW7oBYAAoJ +ELuTVvWDCYO34+MD/ixdjdA7sCrmOzbKFAwyPsAEt0Si8KxbDr1geI7E6RzKsP3JX5SiKtc7 +L3h8sn9Y7BjZZugKwki/8XrcabJdpT7ijqxncTjzva3siC64tMOWuKW1NuESlPFLfcLz6rGR +nqypyKCGxU7UBtrUkF6ciyRBvVV7NnwzG5kXpEsAhP1yiJwEEAECAAYFAlbugFsACgkQXYPb +AhmOMjWpaQP+Ndmq5tROKAnVf3OrWD3O0mkoZhfsbwyedTdRjxiiAqwgDDXG53Q7vLI5Gx4W +lBX6x5OpsGt/ianyIBH11eSoqCiKK3f0KwKt7HM9zEBqiuuOvtVQ5c/0w0gowBPJsiYkdH7w +CuSFHEIHmzTAZ6fzOprBc4T+hBTkgAnDiTCFxHyInAQQAQIABgUCVu6AXwAKCRDGmr4ugkbz +F7cMA/48QVpKq4q0aljkV55HYdvSN85cRiuW9BGcvrTAVDRiKh5/gnBHRuueknH1L4gYNtAr +2ssqZSqZhFwDMayE04EcnqtlSGElnGKQ2q4UDCTTG6NZUiwbSrGnzWsn6fr3wofsK6FQDkNR +9g/eS8wmXUrH3umlnKUb/WAaFQAR6iPYdoicBBABAgAGBQJW7oBjAAoJEE3ZKafpjFgy+8ME +AMh5T28Ixn9eE09byb3kPFkfWQUFM9tDYbQ3YEn+qzeoDnWbTEq5HmZ5XgMmsvrwz1QX7rfA +HiZdmFijfE+zbszblzTBB0ys53IZjRnGv+TVNKQ99CWEUZrCc1LlLuY+dd8dFdYTKCw1uYkO +WeRqWWDYDkBIkhYSaUO+KA0k20A5iJwEEAECAAYFAlbugGYACgkQC+xDCds/iKljhgQAuKUB +dE9Wyy22emJsx+Gc4JvzwSCkfpES3e6mGep1xRoh3BzmJpL8yGMAS6pV5aORJFgizj0dKoRN +jIz0IAUuhSPvySJoxBhWMvCs3vevCNLxndX0htq3JZG73fbeeRqiFUfxnv6MEVjmDKgXbYJa +JhsrSsyqhMFCZM1VDTQ95o6InAQQAQIABgUCVu6AagAKCRA70G/Wz4aqJbYqA/95BSfnyU5A +m82l+XPzSsKPvn+D9I0tvmtLl7RCKhGuGOvkup+D5zOBJ1aEP6nq7cfMZNFt+/vMdbPRhgG7 ++Rhtu04ABxZkwElhzsNAt2vgbfHbxmNWwuDnfC65qjWLgj0O0G91xVDckwGCR3KwFXBeNfIu +VEvRYVmLdIyvKkHaeYicBBABAgAGBQJW7oBuAAoJEOVMcFbzX9UrKdYD/0FdnFRWYflKzQho +6i04uIZt1Og8/+L5CgZaCoGYBwQ4c71Xw73DfdtkJFamKjehX3ErvE9t/8XdCzBQdHD1Oawj +HJ/HNSISrOQJYmEW2Dylo9pg95N2KlTXi+N2U9bbtzpoHBnOzDdSQG3QmJ3eDO7VQnU0NwdM +T6ZgI6v9lXU1iJwEEAECAAYFAlbugHEACgkQgSvTSmHAF3f1dgP/VeqhUFlDs9z09rNDVPI2 +cxceMu2e9vf4He5fVfO5MWx4zIYv6A9wJ1TEnQU//LlGmRk6RLDtByZdbadboGU1ugMYnW1u +MejgTFvQOwMW5UanjILNTuIXQ1qZCvi+Nv5NG8+dcfwGwtX+berG4ZcX+bPkhTSxnLTGwepX +1j5PSQ+InAQQAQIABgUCVu6AdQAKCRCeNc039S+omltYBADDFeArj0wcT7xZ0sUvuQyPbZ8a +p0IqU+zmK0ZyrsPERWtPLpDlD3qtrZAc17jJmm+qwHrkCV5mW3RYcItuHnHqLVnFnNRfB7iv +JM3ks3h3amj/FKCeHQP73B0C07OjL8jMSXXF1cOgC1jCTTAsssdaq7cDh53bjaVXRZvVf8fX +sYicBBABAgAGBQJW7oB4AAoJEEl9kf1n4D8P7qQD/0UPrxkFU0BhWExcwTDdh7mctwH9dINL +fkblOlT4x7jPrfOWXVuH4Spl5xAE5MMD6v8lsFzxU5b/Oay3giSCXZG+v7t/y4OWz1JlpY9j +I2vJDnU4YHEPNRn5wtsYjefrCO021kHfORETYai8r2uR9NM8g6QaUKzr/+AidhGj3eM/iJwE +EAECAAYFAlbugHwACgkQGc6hEIWTBMi16QQAkGr/RSRu8t/72Tkdd4SApTYj8qgdhjZEthfw +nsss4v2abZZQ2uaBfIRabnfa/vwhY5V41Pzk7MdFUzaS4eDP0o02HA0NH1jw3G45s0Smm12r +oVO0wrwXUXo374mBmQjnjuEj/+Jjr/yVnhMjLJbMPPvGpTiW1qhIQiQKBGYcm5GInAQQAQIA +BgUCVu6AfwAKCRAp1euZ0FbBH7UmA/9G1SHm/xAZ8jkov9okjmLX0N/v1qIdrl/vFTXLNuoC +Wp6QNeBB0kv9U4Mv53RziCqRiTgwjFk1F+EMzubDlUEJtfr6J8XBAIcszoZfx2g8c+fNIYLe +PgGa6oj299ZYekZaj2y9ri76sRADQ1rX4CCxyB97afKRZ8QVQVMgEdwzXoicBBABAgAGBQJW +7oCDAAoJEKwja9ELNfFzDM4EAIapJ1p/4XfyXbSg5wjI9IWBxAN0Vdi/U+iSkBnuBkXUZvf+ +g7llPXUaapCvqxiQ1hYu0ox5U8sXknbdL7/ydeNVe+YPJB9bC7Jz0KXtgubbwIvgLjlntdMI +QAEnRlFJCcujeU4ESmuKmux7hlGQNbTyCGhp2ObO5tWwSGay/w5oiJwEEAECAAYFAlbugIcA +CgkQt4TYLcw5ivuYsAQAvzxvgMjlDFMiYTFH2nFHjKiZWbe48/CZOVz04A2Wq/kYTfdKPIIq +19ubLUtQMpvs6wdJPv8NQmCzt7UA484l8trhwQdsPXeopyvv1EWjMiWyyb4WrAIqywQPK7YJ +ayPC8bSJpxzdNGtsbaiI3GPv0RoFpIOIWvyOA75WU/hmhCiInAQQAQIABgUCVu6AigAKCRBI +qKDtc3o1X34SBACFJm4QyhHN5xrb4JzyMMf+uoWceomer9E0OSm+HchLN3nAnYCsRpsBzrg7 +rx/UkQhfnFou4fbVBRGgzOrSObSukvYvUL5anOTzcw9kbFW7FReBPMz5rksKcAc8zrP7Ykox +cXuePIzh3sfooDSseK0W1TXgwa14HJfUZXv99hkj+4icBBABAgAGBQJW7oCOAAoJENps2WAO +3iPiJhsD/ijn6eI7jy4jCgoTYjkXlSEdhkqre4kIrFqG5w7J/NQIhcSpRenkq0mCrTwC9dPz +czWTBa9XpJAQ00NcmgkNd6TKn/ySSnduj8Gr54HUaPjrhZDZd4Vhu0+BWxLelj8HHuRLoP2P +clxKOay58UenLGnET42mpWPls/WXgamb76O+iJwEEAECAAYFAlbugJEACgkQViGrzEMiB6mP +agP/Zpt4ZBQX3UdnhrJZbyGxhrx/Vt8N59DAuw0leyzGpubFnXafbd+gxxf5U+jcPSP6LzSL +GTPWmLyBUHKbv/6BXD1sCHdBtfgcCVWvCoRGfLeJmIUEvVeuF3x6xtC5WchDMqjkQ8sv8xuC +fOqHaIhbQoRwoEXiezxzwDYLOQI1wLOInAQQAQIABgUCVu6AlgAKCRDGTeAPyX8QXan1A/47 +eE7bMc3bjF8pkGhB48ghBLKBFYr2X8l+Da9OV851XwIuHSjwqyQr+S/nV9vcwUeOI4tbx0S/ +jmvVkmlrmafpQStcvA3Ikrfws7tweAWj+pikJd4KZaT03/CB+yuu7bU6i1UKc6icfRz6xp9c +JgZVPJUR4kzbaCQYEnD5A2MGl4icBBABAgAGBQJW7oCZAAoJEEwwXx4r6wtC83wD/i+xns16 +lpEqRpy/8GQWyg9gl+jQn2LIMqUjL/CX5NzIZRuhogMn6h/bgQg5WzKz8mH3PBbfdQ2hB6+/ +6+9WIJUgjogGhlKxndHAOo6JAKyyKRHg0JI+51gKgjU/LsGv4H10c3ltncA1wcO9CysxvH59 +tVxl9broqx+L3y3MGVfMiJwEEAECAAYFAlbugJ0ACgkQMu3YNfxcoAOT8gP/XcPHZVJZJy3C +4rbbwS59nS2ZfyvIPVPYGLI5La3OmcBIAB2tmDu0vWklXbCWL3uNJzEl++Bq1c7b1cClwZu9 +tutEQSZuSBH3B+1WJwPA2sP3kp6cr24relwzd6qcasP8dbzW26jML2aUV0uMfUy17iTj7YrS +Yd9C4QnvQSg4ae+InAQQAQIABgUCVu6AoQAKCRBSdbhyN5FHcCVkBACpIKgfr2Uf4uhLwuSH +qvFFbiXNlu609Pyd1O8PIfaVroW6IcCY1diPllZln5Fp3mcm//AkZ+tuoIj74RB/L16OnYOT +Tdan3fvxl9MtOu2ec6RtTWAKus4xu+CJGaIWbjgDyJsK68/7NDCJuEtV2ZnEP4iOrrAQdQPQ +tP4gXPdZfIicBBABAgAGBQJW7oCkAAoJEL1ObBZnn2MO4TkD/3yEr6dIVAZag0E2rvQ1EbBB +E5cwMaIMuBanpF8cQmppusWPgCJTgxJsUR30bRT14Zy8o7qy28S4HWuDlLykfqPZpZBpz+F6 +Hvow2SIKGR6PxKTjP8pNrBSD8UyEimSAMrsQdjnQhVnaMFcHAACgRvk6byONvFkPBnKD1HSI +ve37iJwEEAECAAYFAlbugKgACgkQoHpGScf0jkp2FgP/XM3SxejsUc/UaYy4qSE2jVqNmTLN +Jy/hxbTepZ09LNAs55FQoEImgaH63FNweGrcvmHlEg83z4CTcfys5SjAbRSbDUu062igPqcN +NRmnSGJILmk8ayOXk4NBk8rcvJq867poLO0JXfWb7zBtryjQs+UEYmo1vRbB68fr/4r+euaI +nAQQAQIABgUCVu6ArAAKCRAeelEl5Q+YcSPAA/wMqnxo8cM4MZwyKvZkS2rLyQQT9HN0RRf0 +KwLg0RVNdJNWp4QLciKGXRGfZK3LmUAD3LJmN2KjqUBQeqnDLIoesh7x10uErc/xe3+oPTT0 +HkH9yTqo/tGSxvk3BaRMr83+QChEdn//RMtVYnkkXHfpa3pBjkcFSmvKSpc0ooI14YicBBAB +AgAGBQJW7oCvAAoJEAS4knveZ4gxMn8EALgHp9UO6K7By8vQQ1I4MenKULsLlJ54M5V83psS +sjLjYdJTpmPD5GUK0LFUSV4YGyslpDCCmOFyp7j5dlm7Do8zbaRbFknwKyhRmN3sBvo/3PYU +PESLpp0tcUyp9fimiqLOPUoRj41g3fY2kWQEBCJRuVTXhe9rdD3wMvOhfl0KiJwEEAECAAYF +AlbugLMACgkQRVB11sCrgmp8vwQAq1Z1w3iGhDrMU7wOZ+eTHnrhBw/73xOUWcC//MljbEAN +VjhF6pFhAX541QzyFZzT37p6a6xZPqMxu8g67IYXI6GgnY7MfKLFt7758pEEPlCmwDN9vylj +qCHyBcYKSjHzfk0iqoN2r3CMjrIAWQoVuY2fw3FaHbiw3VRO2oANjFWInAQQAQIABgUCVu6A +tgAKCRAtk//x9HBKaBgqA/9r9pZIImk+vx1Dhe12Hogm/KExTNY9CO2nJXExY/KP824fvvEP +yHrifZiZumeWWj4Tlr8K7THmYDzCcFBR3SvB/D0ubXUgL0lYuHp8ldSkV6ZCvkLEsM+ooCGc +yymtpWkvP8L89HSuTwmBKLd4MYzoKzNqpyCfZGT9kVZWPnmrJYicBBABAgAGBQJW7oC6AAoJ +EBLESmGhvh23pOcD+wWC1uKfqiqpLYeTHg64yLcgbtKhGyQwuLN/koTfSMNx+DySpU4zrcG8 +zNpGjr9R0OVB3xi/XRq652UQeQLFLix9HLj72LHNJtQHhIa/UkRPZ6AGvLUhA/i/bcGb6VQL +RPX6g9qNFq5VQXZ3p7SFSIahPD7ONvblQtLOUIzoYqR0iJwEEAECAAYFAlbugL4ACgkQldR5 +7VqcPH6IXwP/XraYItWu55Lf67hcQ0JvUVhNV7LCB2nNx2bBNTdSvV5iAR4GKbsCzEgi35e2 +u0LVJH+AraDy+JM6SaT2tu9H7r3sG623KJYJzFuojWEuMTakl7VtOMLe6kYG9vGnrmB3Gt0Q +kp9u3DkHPRUxnTeat3gSbU0O8i+J5EWcmp85/LiInAQQAQIABgUCVu6AwQAKCRDY9uoHyIK4 +2Vp4A/4lczVUnMd6YMFNevO5xjLlEl3E5vGm3nG7HXRjHbhRWrps4DiH6iqNyDUPoMvpHx0S +st4aZZCED57juJdxS4OWfW2hX++lusIRanPnrJQYiHJA1Bs6lu3kfw4/gtV1dAGdOAsteWda +96wvITKDuWa0ak7rcz3hMnxYuHF0CSsmaYicBBABAgAGBQJW7oDFAAoJECqoApon1J2ssqYE +ALu09g0lvPcCtI/EOx65PH7jYMOJiSxB/jIEle6zEoINAH20iQjefJvRkC1uMANxAwy98kMi +ffF2KHzJqK6oxNJaRS7DPAJMSFjWpTFxXqHi3n9dJeVxYxiSvc4nKh4H7G8y9NAHHBRonIJ7 +LoHsjNIS+cIgBdvSZRmZctT5ttOniJwEEAECAAYFAlbugMgACgkQZoTxXlqmkaz31QP/dMhj +53OfiAcs0IjM8d3SLtQh22P9QpeNJ+l1fqkgdJnFTE1Qc2holBBsdyQpIggldba8jOxPkpuq +p/bMp/xE2lvcGyitL5v66vjzKKbUnJNBlfRcx2YvKHeX58w/O5eTW1gosZCXrpjii0Biwrqq +YhBDv19cqPke7WDYngfDIF2InAQQAQIABgUCVu6AzAAKCRA52wn3cnfw1JyoA/4kdWie5LAi +Dj+/L8KFX8bjzxZdoOjciyRkqMPcsSyZxGNPWHHL75ydseB8HblVi/54CNDGAfikwhjIOMXf +VrYWI2WQO4qijaRCvNCEM+ZG0FdZqjPB/66WI4zZ0+EvMOCBW0VqpaeOxZe/Y0dWXwNSbgIr +srTqKA1KPvwKfd43O4icBBABAgAGBQJW7oDQAAoJEGONQivm4t78BtED/R+xqdBecz9jPviU ++rN2lKEExyLNNC1rbv5Jmtw2/pi2mkqSO/rHTI/xzw1vAcHlj3r3AfRg0vlh+XQmozOCzX6l +pxdKPtd1zE9m+k5QMLiNlQOplPifgHWlatV2Zp7S4elArTz45wAtjUgxQ5rBPdSS0Yej3IDw +rSTWWuBBI8I0iJwEEAECAAYFAlbugNMACgkQ3ugkLalNN7LO4QP/Qb2fVCiofyFdPN5OuymG +305+wXrapjkqy/seEFd5UFzgvssAV/tFdT4HzbfSA2Sec+3v4yRzupRvCWO1E5aDVy2L4pti +eKGJrwdiN0koIV0p2HDrQdU/hx/A/ZFDmdvIk+RhvKcIyrZPkK++kszs97uL49fs/OnlQTpS +ucK+KCiInAQQAQIABgUCVu6A1wAKCRBbejIhqJtRzxPEBACFaToPXT1FEyZOzlx5K/fF8hn+ +EACuYnKVQGwKQiX34Y800E0r+hYigsIdyKs/BaZyqiHus1XahyhxTpgiAU7KrbCKr1crIXnN +iZy41IkW5h/SzLTElQxA4Ba5KlrAnnA2zimnx6VxtG6HFO0ITVPIrLgvlD7ymybJpU7zTUh0 +GoicBBABAgAGBQJW7oDbAAoJEMkdFf1AnypMIIsD/3BSYLblbDQ0ju/uoJD3ZG0TjwhBICUY +5qtk4m6OZaM1HdWZDZnkV4vxBuCUK9Ik8rHlmmssat2NVV9q8EmgRQzMuk0UxpWCVft1RxgP +QdImKVnMXldH23abnpWSak6cxRupeOCa5Q4XDigZeVIv4E9VbGp/dNFDw1HkqsAO+cKxiJwE +EAECAAYFAlbugN4ACgkQrStn+ybsQ0KTAAP+LZmNlj/3+KHzwkvOCzzf4YtqDnOFxcmzSXn2 +ESfQ0HJR3P/jsaij+wLEZNPwnMJ3UWj79lc3qZFL8AtLa6Q4a1yKmweK2AH8QJ4mrQMGic3E +G48mHAqa2hFSWP/Wpy9572dOsXMrbF5ue/ZoUqHJ1KqNAtcsY1g9cuzt+EmPRRCInAQQAQIA +BgUCVu6A4gAKCRBWdjYolXu+33sKA/49Krw902GJC+GT2mYCr8gVp8AqW75LOtHXqVaoZZdo +Gon4f4NaNd9Lhlywz3cAPzZUy7Www/4zNGqAUtp2lc4Q7vIF1oPHjB/EzJ6eBRyMETd+gr2R +whBewsAi8D+iBBTTCiTvXEcJygAdz6L43z7pRpC+OR0dH2DEJpeThgVcVIicBBABAgAGBQJW +7oDmAAoJEL2f/sI11GQaKOsEAL81Nv7LHMazWtHzsiNHF9LFWOazSfsUfkdvcwBIcKbXQB2r +jRwuiEfqitzD+t1n3hQfXCImp7lbm68py9+DMSpasTa+as8fHZxEEpAOjUHMng15XfoALS7B +DSWqeUQsuWWwFArot9SiCOfBPoYF1f5qgx4ari2TvzVBEjgd0OrFiJwEEAECAAYFAlbugOoA +CgkQHjcSVX6KXVp4MwP/eLo37n3K2C7pQnvz0RR2x0hr8VK6dESYPl2wy+EY69vLM4YGOQdK +ipDO2q4wfKHzTivbboE4ZxPX3myUwRcJptHhgSOFkSWdVtfAcwtPFX777yRwiTNekKx5IyO1 +POHik0BINutqm55AUC8HzH1IMNqPnNw4RRbIG5QQ0HKNPOKInAQQAQIABgUCVu6A7QAKCRBW +Xdcp2crYu/I8A/46B7oBct2+fbQedGO9l4eezEOfnW8CChOJnsAlyBVkpVhC/B6SbZsqKWIo +1BEmlXpBPJZdq1qmtXxW+XlzsgolKonMj0isPn20vUw+h/EfZkWHbfVoiY91pFkrMouk2QzQ +jd3cVrV9X5qQUjFwHGBkeQdjq86JZWiCUa8J1hhEk4icBBABAgAGBQJW7oDxAAoJED1kmyuZ +QyNDdDYD/09/zn64pfBl79v0Gh/B/pgz8he5Ot71rOwozSA0kAXJ2FZRAsSLOsWUPlELabyy +FkPZSn4ihobkm7eoiyox2vFe9BI1i+oDosHvfmq3hz4+U6XrIzRkhbDCxXdQ/FyXgNj4B0Lp +1zJNe+FeIeID7wQfBrLs5SI/fFpq2cDWHddEiJwEEAECAAYFAlbugPUACgkQcEFf43YdMhoL +HgP/eYqvzqB3oCUQ/xbS5/zB8EPtI0dWI4rWVlOszCKIf/ij4M7wr2Wo1JGT7fyV6QEkf19k +Us8DmgfZKhR9Te/Iw7wuVnnHZQ0TNUJaJxw++HSybFa59j3jkAQR0YT1XmiIinQ8tGPodu6z +Y/jbAmJZdv3YPlo7P7EGcdwoXRrhHiSInAQQAQIABgUCVu6A+AAKCRCWM1ivCIBaCotHA/9e +P2YBopN7O1GtINGMZOqtu2dL5YvZ6TxZ7aQEJsM1ZJbrMSzU7gedozwnkUULPGn+7r/96Juh +OFCijZsZ95s2KwCXPd7bE2tEQ23kBTHN6e/r6f0C46zprazPRZekErz2ZAPPu9xnp1fbapbV +iZzu9jG2GY+x+uWYbn1Np1TdR4icBBABAgAGBQJW7oD8AAoJEE0CvT6NwU8zr0UD/2EPnW1W +QCVKUWx+Fh9PR8fdO5QHTIffMX3wGwVS1RSmWj+gy5fEP+iOeb8n0Yf9eBEWZpaSjLqz0f+C +JaLDXr6eLZoWSvotv3uiT0sJFj5bmk6M1xMw9ACbtfkVSjHQRta8t73W3Z5y9ayxg2tjIkuO +YtgX2/X2BV7o4s4eDIv/iJwEEAECAAYFAlbugQAACgkQnDxU9fSp6EktNQP8C2J0nqqkUSJw +o4294MbT8aUC5/mV+UMAZ8uQ7lvdr9tshcjBVIoel2Jf9Y/mgHJUY+Ao2IxVzC4vnvSzYyzM +BcHMYVUuEgAOlQeZX+U0Sv93SymPBwPMJqW71tozDhMc2sYF2492IzIgcQJygyE/jOR04KPq +l+dmX1L5njq08wuInAQQAQIABgUCVu6BAwAKCRBDPPYqj3BMG8uSA/4wu814Hhpe8CiIds4n +uS1g2Ewjkl79dhcbqYgJqZraPPbzq1xKYezm7z55CDeOEYeM70cJBjyBYT7Rk7H/slJXnxN0 +kpQTGj2Cxu2garlvUZpvmqEBJwoDjO5blcm8T4+TTZo9WCN8EVUFsQivQD5YLvUtZntYoNi8 +OIoy8aS7qYicBBABAgAGBQJW7oEIAAoJEP7uhBIw3YwNa9IEAN0RQg0d2U4Z625cZHnku5o3 +gUGzgXMMf8Sr/PLu74joaNPWjQyAZt0B0RJ6KKNqW3ewJCZjo6Qv7Kqa4YpemEroxXVr/NMw +Tkwuo9QGsMdw41j3a3Yg4diivkHswTtH9K2jczR9ZsfiVMKmt7MADRkKdcJ8tRBpDZu4k5R/ +qSdHiJwEEAECAAYFAlbugQwACgkQ9ct6uyrXKNsUBwQAm10rRfO259usKPYaZa63yrE3nfVC +qKpoFzXJH+uyDP9tVe8vNhcf3VLJu4WK7dsqN33WNdOwerS+vW92/s/vLe/DhlNrQUGQzTEN +WfywBpYztTY/s792OQRWUuRfbksUppBKmGnc7FwQANrYQEbUVIEVWssgTfEcFxjXm5mVIbyI +nAQQAQIABgUCVu6BEgAKCRAPmFOTDBLJgttvBACocJIfkew99k1+oCkJTyoDwtawn2hQ5bvs +6GlpzJu7IIYlijny0fMGl4blLwghSc05DJuzWWKUAxk852VCuHPOvpiYo1JehJDtLJB4k0he +9J3g2i6YmG94P8j41HHjl7wUSrP/ttDRmWDcbA6g9kFd1cortvl4l2wVBjMgRWrcLIicBBAB +AgAGBQJW7oEWAAoJEN/a6/DUTo5xwJwD/1z13kpSagms5euJETGzr8aHvc5o7eHiEtzq+IQK +lB5uGUly3hQdCSQU1Cgth8jWh/88XaEw8EAlXVLNJB7GmUrvEk9JcchhNlO+8TKyvC53gNN2 ++b3a92YTjnGg48/IeEbqRVo85eNHeae99tZ5tTpFu6671Kk6KBgdBBsGKbsAiJwEEAECAAYF +AlbugRoACgkQTEzlCFTiC++uYgQAznFF6htR/Hyzk6epWHymEQy3/kTZgOiCrN3f5D9jBhpx +9fI7Y62K0K2vDEP3c+Nm2B1Wi+A/4W9jMzWcNdICJ+CrotBwvSV0jdgqC0rr1OPqlL5w3uB2 +8P+6T1R6K/usZM5G3uKdeu0QQWnPJWpCyRgioaT7oIvxiOjCFY3vIKWInAQQAQIABgUCVu6B +HQAKCRCZ0FC3xVvgHR6gA/9sYa4gFprgzGe9q6/Ml5kslN8QAKSxquCacs9TBB49bBmXY//q +hDDTyFnoMoHHPmsAmTu0tOUM5RfoX/DKuAKcNVzFfJbxK/PtY3xkywJGP3tucJFPb4rnprbH +j8Wp3kQjv7t/gL3TfItWDw7f7wnCRwK9ndlg8WJAI/nQ/7bBzYicBBABAgAGBQJW7oEhAAoJ +ENPKAtLX9CXCvCMEAN3aAK92ZYECnaaPqGjUpicZqXq/AZsoFAxhmueBv100s2QZAu0erFxc +ICHoIiPxU8OOzAGrYW5X/mGo2w0+Nh5YuQJvGmPhX6RSIfb3L+utC0iaRuKCLRkfaQSFzMRs +9txLWfjV8WOVNVOxmg4kioJc3df5Zjpkw0t3TdfSJK6ZiJwEEAECAAYFAlbugSUACgkQ69ey +b0yJFi1iVgP+LhuQgBtHuvgBoBDPhMoQcP3gHGSMHM+qTnhqR6n4WT3HvQeDCnnYhWr9Opsw +IrVYuw+ea2VxYEovGs0WA/96xRH0nNLgQaYkokvI8okd86dKxkqNzSzkEjgibnmHeFo3PpIB +9U6cnrF0yoIbJ+0eMshLUU4FVe9wdtcWm0xN3oWInAQQAQIABgUCVu6BKAAKCRCIMNc0Xpiz +3dyMA/9Thtr9DABiYqDbuS15IZfiGkdPEuhgk//Lj9fpo1FyvCfXPb61PQ2irDQXauSavsAM +CLLuG9G3ajoBu5qa4vVPdVcirDc7QsWA/OpEqiiXn/8FymUVxNUM3h4/dkiU569NuW34Cfng +UP3cAdnXbhCtzXPhfKWgvH13UEFjgtRxpYicBBABAgAGBQJW7oEsAAoJEMUK+Y1pYxlw4NAD +/2kWwQBeGJzio6frgkP5lM8aDiAZ6GybV1wbhCFy9bNBiqBHn49m789Pu2RP87eBFU0+1e+8 +f2DoZUkwTKx4eo2hhoUD4cGFozd60XLuC1H9FxlDox8jxMfS4FFe+Lod8jJhQ82XBVnE7tCt +s+KeUqNTTKeOS9U/nRt0msd2CyHviJwEEAECAAYFAlbugTAACgkQ4Osxaj0D5KomGwQAvt15 +kw3wJhKNU0F63JGqob0tap3oX2KaT738X0kH1laRMwRQxMtPVugyIpGGZwBe5IMlpEyc2rkD +9mIXZF49Hp+wHfugUbF3S2grLcM6iFfwWsjwfSJn1mDiiwEEmLe4P4tEt87ZVC9jtspk+kLL +o5QxQqan2LVOHDHs7H3dCJmInAQQAQIABgUCVu6BNAAKCRDxmvBPFD8pgJs2BAC1saw8PLqn +j2E3bHNvXTRUQfgC0HAN6C4MvmHWayKI7xYwvVjNblR3bMMh8YfGj2GGUvA/DSpl2H4bu6Xq +2J5muZcJL0iB8Kp/FoA367B5Fi6Z1T2vbFd0jmrrznmUmqS5TUDo/lBDhJH3dIg5FNtMF8bv +bXsBln+BUg18vhT3MIicBBABAgAGBQJW7oE3AAoJEJmKa6yylVVrEbwD/0mw6ZoGRGG9J7OJ +jZ+7LsfjI7dF9BF7uaN/7c5MOmZIGa7ITnb38rSQQlkacaFCZUKjE4cWCmaf5Z6qXFUXiuay +1gG3tKkWTpE4vOqJTvGzggqf4tqpaMGR9uNchEHBkF/z2zfJZMDxCLBjxoM3a5pfMtzFQQ8T +Dyv048bWy0XNiJwEEAECAAYFAlbugTsACgkQdWZ7+IrT994fDgP+K3wlF2Znw9DdD8bRRqLX +PeHVzldqXzgl/CUq5BwpTfMj9n+95O4mnLmcQzCkRllzB+3kw8GNtQ+5SW/PVjNisHokgLrc +Jwfhm/50he33Jp4K/qlcVDYaA1AGx9IgtVxwXWwqrMef5iEKsThBy2g8sVtllI91eVhPg4+M +GvnZwOCInAQQAQIABgUCVu6BPwAKCRDDmowqn9l/cLw7BADQT1gp9S9OWfey5kjT4dWlmbX0 +0+hfwOfD3CsG1Ca76W4fAuMVbSCeW9OeUkN059dPRkdmsCEBmlW6G7Np5azqIwleRzSACtST +XmaqRe3lCs78ocArvdP1omZRw92BfLBpmV+2+108rCP50bbI184qp/+zrvY+u6Vzz8Q906Fl +uIicBBABAgAGBQJW7oFDAAoJECGdY6hW4Dw78+ED/2NV7VUt52xytLLg/CiRBi2q6qaSaoEX +sSDiecxdFLLEhEmG0NeqZ7GCEXpdB5TXIxfSXEfF7g1jQaAo0MrHXmv3+Vg25PMhyjf7AlSS +d+oewz9ZBidL8LTA1j4n3Z1pIGDdohFc+Ikb6mLqY8KvqEHh8dsx9gStlbKXWVUVJ71hiJwE +EAECAAYFAlbugUYACgkQMvIngbbkUMti3AP+O8Z7M+pIMjblj74WOKEGVHq4i9aEBdt1FxTB +RsMEvhZs7OE6w4PQ61m6NPJ7g/ZVDaG6i96EZinhNTfMAEcAxcGmN7at7EQhCsEibZFa7sXh +0ZHMrHOjAs41yHXgrBHzP4OsVrIjkh6XnhCEkGj7kfFHUvSz7RqJnMsXu9Rpmh2InAQQAQIA +BgUCVu6BSgAKCRD2xNJiOCa9sQswBACwzPBOL0RJwvcapFpzrfRc0YUxGifJU5KgsaM8H+8X +LXPdUOAcZ7Sx2PlqlDrmrKpAj34aM3xoenrZq9Vpt9TkhdRWu3X4CdXH8tqMht1Ux1trO5dX +6u45jY93r/lHQhYuL536h5+EmpYlf5DlaX79pziRV3lYdtAAjRMtfdR6QYicBBABAgAGBQJW +7oFOAAoJEFeVsA/KLRKTrHIEALqVc+OCR/zjYTBZYnYCUHolRB6iQQyPye8ySe14NOqb6lmf +9YTimx0WK9/evPZaFQLxx2h/D1NNOaq8KQrHVkw/LPmKS8axrYyD0Ds8Q4Lcmn2OVS57+jXB +wpVvchWlLnenjhJvJna4kEcyPa4sjzm7kK5k37dJxJ37keCjvZqXiJwEEAECAAYFAlbugVIA +CgkQRHw1CqkZ1LDOxwQAte03sgrQUVyMGEHWMLnUwA9w8qK09UzZeIHfkdeGqWvmYdMUtRHD +dtXTt8Qgtr1VSJobPiLnsvYacZNJkDO7CheK2UvB7qpehT3VcwmpIdem1/pAwQUFmnuhODLO +E6czYB/j0JU8bzuK8UHCaoInAwmX4Hql/dOwItGjzaETLgeInAQQAQIABgUCVu6BVQAKCRBq +7863TVwUcedJBADS/UlemvDBJZ+r+pofe7qfOlAT1ue3ky25390FHzvsksjMN5L5b/m6gjMu +t1yxCXOnkgUOzOG/MS8Y783OvEVJDt6C9NrJxArQYph9x+wdxz9FH/7myLCYPNIK0vK7FBRd +6xwLmnOBgsfDM6P1U+M2tpVi4BYLQRtzZNIuELHQrIicBBABAgAGBQJW7oFZAAoJEBu5mU5I +kjRFRAMEAJbuEcE6CXvruAcOoPnZ/iphyoubiG7XxjU09NVHQhVhdbPAFcSISUUh8eqbSIOa ++xIzhH3eNmApiWX24mvY1ETLdxL9judeKT+cdhNJbAlvKVAMGKvSc6FELkAuqFrVLRaenSoT +fXW54UWmO9lzPnrulc5kSJ7PKv85RF/y0SZniJwEEAECAAYFAlbugV0ACgkQ/opX2gloGOaS +VAQAivIScFWMcXMRPEaID5XeYoO8GivkQoXEdcSaXieKcBCpn+/ZJTiUaDjKuchpyQAsvnfX +CURSkIafVzyEzEZQn2/hy5Yx+0Y/tJN7g+ZAgdREgsvKkWieW7V4uC9TQXq1pJxHxdPB2zLm +ompJKKNrnePA1K2lxKHprQ0pRLyeQR2InAQQAQIABgUCVu6BYAAKCRCXkcPdIjsl2Ie/A/4g +9OwelknMcyRqehhNM+xocg5L+mHYuLyQ/LbGrxuXRZh3hKIfCF6BCKwJ4d9vZDVVjPRUxgn3 +LbdKX3YsdaWxdCDvVs+cNmUN0BPfYEgnZAMrDF/xRmY73r00vFNA83UHkhQz+bptfJsKtNbn +4gShipuFI8ei0aKTO+2ee8v3uoicBBABAgAGBQJW7oFkAAoJEEcDvoXsU6kSp1oEAJVhLYEy +DuyEoWt446yF4o5iV3CgiN8VA0yffat2+kyKLykafCw6yNKrT2mQk7jzG1m1A9/T/RfSrHxe +75Uy04NUpOAiPSUeSaPpe+AFMC3XUGC5W2w3oEirwfn4G0L8otkd24DLQ6JlvV1HnGjpOcQn +wb7HeL/2xRgMvTdKb4VCiJwEEAECAAYFAlbugWgACgkQqUiN7IQwcKlhDAQAs5lSDx2g6AaA +DUAVaRTLxqaqdOGrF3kK+N4kTIP21zZYLod11ubVVE0B70fp3sxFjpou94ysdkFLFhAajMdW +AAPesoBQC5r/UL9Yf7jP1eeFmPPb5qtsTh6p4UuueiVpsOQXDoB3rbn9OmjiqpguvYFBVt/2 +oeB0IrIl9HwkHsiInAQQAQIABgUCVu6BbAAKCRCRwR9T8tSuwrQRA/0TZfg5R26r1yDFdAgE +5fdLrzHpR4dSej9+4pMsIEpqZSYpLKP+qzurR5KahsIgVOVy0fRp7EY+5Nt4dbVsXiylTd9Z +khFOpYW211SbuDTCwFGnbYYUn1T0HzeXSRiynKCduHwOsX/QesxpL7x5pfs8W3XQ95pUxUGZ +ZrqAYKA9OIicBBABAgAGBQJW7oFwAAoJEC5BAUj2qoGCPLkEAM9lvldJnOqUXIsr7WTlJnVp +HMdrW9mpwYKiJMSbA/bGoftdwa2J/9AXIUsIQctQRwNTlReqQl0exwR2EnLXy4XE/gMzNMAf +x55MfZHZGA8PTJ9Ouj7j2eSNNazlsAks5/txvolulyF7uWtyf+EkdOK7f5QolSVsBHwOc2wx +K9ZMiJwEEAECAAYFAlbugXMACgkQDjNpM9DKyaJElwP9FcxjiglEnZV8suwzg0b3NpErLmLD +6iN1TDjGBYsvaUAX9brTITU8tssqYYfiRN9Zo1tttQFyie7WzYZt/yvUYAlNFRJeVVD18RoJ +U0BcNiK4iuaELleqOZrHW9mEnU3cBad43E3PKqIIzVbxObogXfAswq6bDzyhXg0d0mnHHeiI +nAQQAQIABgUCVu6BdwAKCRAVdPccMTsi3DfZA/oDJTK/p2KoA73OouHPQ0ieKCysxqrfL4vG +f+LT/5sBSonh5Q92UK0Q4XwHRnh7Wlelm1Jb0h9iUPUztZl/YllLV75hSuZ7daELUXu5l7q3 +LNx5yoTteHBtIUTvKTYkHvIDDpYw4El/xY4hRFPemgi1ZJjZ3HtrwvD8MhpKca9rL4icBBAB +AgAGBQJW7oF7AAoJEDeo4+pK+v3Ir0wEAJp4gdggNhLoYutYlQOc6DxeG7TIpOHNAxOMAkpN +areKqyh0j8YJ+3bnEIsQxg8tZjBNrEAXcGTYfNXN1J1B6rH8pOnfFGtAcQc2pgmajisj+QZv +wkhI+stJT/yhf7xPmExYfXQaaPpy3w65XcpRNzaTlsZMxeMcCGcQaI/Tyw1FiJwEEAECAAYF +AlbugX8ACgkQUKMOFWK3OeF0SAQAldWj17AnjiMd45opYO8/0vMP0P8xfaKy2exvfO3TxhRK +Jhp4M5HczzrgbGlO2mjXKOf3OjbblrIbRKdCvxLVbYzawzkBs6UArwhjuhoZwfijx7ODUEfm +5bK0cAvNgCQSwH7y9M8wcVS4K0D6P/vI16h8YG0Bzd8bQDZBAQaK+NKInAQQAQIABgUCVu6B +gwAKCRCljq2DD5/x6uH8A/4zauDnNYJt+bCUgDH4REKoQtTEPCwvU6qacFbQVCPKQrKYTMgV +hr0Y9EBZFnvEWPT2H++ydOuN3OzXi7KYKltRYRJe5YpQ/fpJe8S050r7lT/cUonoOTbtUFIB +W9uivJtNKwkOSWWzLfz25dXNf2bJ4txn8rtHN2g3bA0TG9X1k4icBBABAgAGBQJW7oGHAAoJ +ECIUOU+z4ycL3KoD/1w5bTZSb+GsDeaLsproVkB1/ot8xMUiOQ0VznQV6dTyph3C65ctDNXq +hahviYQYGAV3MxA0qQbg63K/nscDYCaQru6SM8mmUSO1HUCAQrJ+KUU0fIVetuNPSzUV3Unu +xTk/L63nDbFZ0VedHYjCbpCtPQIz6sMjOHyl0MPGyT42iJwEEAECAAYFAlbugYsACgkQKgoM +6UD5w4jPewP+OwoQQxu7SRNkEnE9SN53kmmWkpXH1JwNMEjaUCDVQs/qF1g7rCE6rgbb8hJL +g6Bm10tYYd92nLvCchQdmgRyETqcKaA8Zyhn2golesXckD1mcYH65l+S8HcwIWdOMQ0QkNbq +ul+xxHXSQtP0Np2Hkaz2XJ0HQhlwSc4N779A8F6InAQQAQIABgUCVu6BjwAKCRALfyp6yB0p +W+EcA/sHgEYYCv3+TvZLJJuDEmNY2NrGU7CPPnVVD/uZlgDbmQNVOnDlltcXYvXAvAdFzw4d +Wxf9d7lcbbZdtms0aLrYj9deBBf1hbV5vQ35F+i/dENcWRd/6evwg3Mw8RbUjpnKojWx3mLT +J1txxK10LPAEPHdHgAQuZzz7nVvVUppJn4icBBABAgAGBQJW7oGTAAoJEO4U6cT50jvBVOQD +/1nJLn/yYgvoSbg5W0XrI1xQzAGtF6gwLhS3X1quJdC4+DE9BCUuJaYdI+CtlhO8SpT+dqR6 +LkSimtDLUYYzStitYYS3j1tckM4Zm7TkqB71YY5IFILuUZIRRqsYvstcz5FC9jzRoXEtyMgg +Lhr7aSH2eY4CuZZjP4SrimoJgRLiiJwEEAECAAYFAlbugZYACgkQBPTkk1W5r3jQcgP/XRWs +kCRdbhiyx+yfc6Hu7TX+fOI9iEG3wW3jQg1gZOGfclpu4kN54GNdWZYMJBHwdn2/6Blr0/eJ +GAYtpOyYTQedpXxZWjOcEsF5SmYgSbGkf67B1MXsmcA4uD8xTJW+6jewQZXTE0GSkGOvHNtQ +ZDH5ktrTr0wXPsDL3LHLJCKInAQQAQIABgUCVu6BmgAKCRCSOpxDrXvkX0nIBAC7HRBaaZdR +P4SstMtfM5YVg6ioP/AEjPba2MeFsiYNURFKKFIQpXoSOyLIi6GmpXDtOS4pH90/UtZPAXFd +17iQmGqxwmWE4HbWE4HATzCh8ZriaiHs6hJ9HNEIoelD0IotNDT79AzVMtzHQIvxQ1X/jBrD +1C1akKuoOsx6NvCwwYicBBABAgAGBQJW7oGeAAoJEH7WRZ8icH4DttwEALXcNw6p4x+8oEDl +3n1O+Ul2gwEikSKueqtWv6zqsb+7CAiyQUjTu/J9HN2ykexlrpH39eZxJ2uSfo/Bq4rP62bi +HjMhLh9PTKrtzsH9cGrNNEc6Hsa+rTcSMKWD6wHeqgTsCZgJUFj4mA1X9vTcVTLeF47JWaA3 +Dd6bEq1tggNViJwEEAECAAYFAlbugaIACgkQJrg7Y3Ec0GPK9gP6AgvTP5He8DdU3mw5LwRp +lv12v9hcQUyY5dwpdB+uYzFogGsKhoSOuBXY0nf4VdQq8ipTDsSMGxh0rpMZsvhi90yctDHh +Rdir6j3fAK5R7Mr2mH656lh1GiAhts9qRmOgDrXMSdLEXe7dmIvsFpI4jO2BwgZUQb+VGy2Z +GT9bjpWInAQQAQIABgUCVu6BpgAKCRArJbr/QarcACWEBACYfX55yv7gKBOTJe61IoYZZRv3 +PjfBBjGU2K+5eaRxSavWNG/s0avh8p3aiDZTiDgfMEQLJ+23zmHJp5GheHEnAHAvDsF2IpcR +e86GdPYMLmhgxekQZJVyKmShMvfOGmi8+KeIm7TN0wwm7SfkHhI108PT3wys7O0+33Vs+MS4 +zYicBBABAgAGBQJW7oGqAAoJEGrjx+WCor0sjysD/j+fyYnvapbyOSaH0xXuroUBBrzAblnG +IKx7EXYKW/lYxffUDc4nxh8bxZVCHww13u15f/qaK0W7D+/dz9GtngAkO+piRh9w3qdW5EmH +hP+1pz11d7UsXd4vC++qcQ2Dv3SPyagMBeB6fNPlRr4OPQNAR54A5o85plBSTVm31/bwiJwE +EAECAAYFAlbuga4ACgkQc9hiTF8U8OPoaAQAtjZKIQrMD9aSlOLfuJgj9aQ1JwywWF71L9cW +eq82/kkN+AiCGLNqyyJ5v7LThJ/TQ73TQfFpmQYy6BJCoZTKvgJ50T9RbX0qELABUKawf6Dt +LDlUdUOpx0Owk7ydDEFQEzCGMjNDuYUswiqv6JdQ3N2OY0LX4a+USwClqpp4HDiInAQQAQIA +BgUCVu6BsgAKCRDUutsDBRpuSbKCBACv8cAfOUfp2Bmb4hmUzRguadQhD/EszxOMwCFgeyJ5 +k/hvZdErX7K6wgJD2zF3T99oyypfAs9wHiwzDVYQrc+dUp+2F0gl3hJb0WrVva+QUefBteg4 +tE43FJxG1I7iDBLj5tKcgCQLCFTBZ5/N9gN8lF9zSKyS0j4dl4cvsF8KAoicBBABAgAGBQJW +7oG2AAoJEFuNkuQ/o50XSvwD/1uv1jNyZFuqHWPBETnjU0aHgVUVnxSFOKWXh1N7yopo09pC +ydciGzBTNrSDAbgRp5OMlTVz5MI5vr95vUj2WW6zvGBJEq+Vtp4Zv3aABX5RIiZmDuK2NTGD +KfavAOK0vfnSVpo9O4xFbavFaJSaic+NDVNrtpH5vLRPQMw5HM2BiJwEEAECAAYFAlbugboA +CgkQaZxvdFiOlm45QwP+LDcjbYoSWXvwJUYOe19S1gddrvbunHJwHaOtrjl/V9lnfLml/gfW +FpTzENL2bfq1ZTZP8m9oF5aixFGgBrQwSufGS30TOVPMnBl/G5ULPhiArW8AaNX+uIIsSpP8 +ZEpeZAYwkz4X4jXvPepExw9KXPDlng6mCys1x47iEFFZW/uInAQQAQIABgUCVu6BvgAKCRCw +vDXDb9eYYM2xBACBM0ZHPj+pdFGv2o2RVe5BrlGbHiK57NPrcn2/VJgECJIDq7EMNijYTKie +mnF1y7YWclZqf9L07dALF4c/J/XN86r8HKrwYrcCRfcnJc3iOmi/xMU1yphNbjFAHvgUa5ln +UmBg2DxvzlYNI0FSV3D6YLx7fV+3R4GFbCrbI/H5WYicBBABAgAGBQJW7oHCAAoJEL7bKqNx +TLHNSqQEAIxYz81FL8nCfCY1KmKP3vR+2kMwvKaQxROzC2hoRg/VDIuHvCtR9/yD12e+n06i +B8K80t13Val8u8gMzcjfxzIcRYU/NWffm288hSbsIhyQrOwbJStwIET93Lev2hlwuFsehNko +ellRZsYAGeg1/hRrSeJpS6lyHVdt9P7R58X9iJwEEAECAAYFAlbugcYACgkQd/2r3ZXi2Bu8 +CAP+NqPbcNWyvevLmu9A40j2rUPUCWNzLe9nQluBmVUkTHglXO8lVdAO89feRakQeyFHfK6Y +Sjq5Mdc+mFIfK4jyFeKYMVnd8ojg0PBxtnpohyKUEdrNoD0BYzuy0cvYQKiR3014DLfb8n30 +L3fo0knKwCJ+oH1KaE53idytGM1/CxGInAQQAQIABgUCVu6BygAKCRDeY101g5WU6BUIA/4s +ZlaKzpTs2gLULbxN1ahbyPvL0fyYKWmzlaIcph6a4yNVkQo6oawApisn5oLsRlROidz9evuQ +49rNvCbqOLXXbwG5Ly+Fo+hClHI62xo4Jc8F/V22ZoNWn72biW3DJa5Ic716Az4YiXk7x6lU +pf4DGvepRr8ttuswMfbkVkrg/4icBBABAgAGBQJW7oHNAAoJEAJR7uPcDeLlw8QEAJzpK+K7 +s2UxrZz/md8EoYkfNBExg0jaiXXxQPExp3+4t5Jq06IED+qOiZfjZvBRABfTNUIFsE6pxFXm +NvV2tGJ6xcIi/xKDWn6igMERWz7vdz2GWfILQuN2OX5CdpouRV9H7Yt1qGmypeGfXlP1SPQO +Zo2htsM5d86eiOykaN7PiJwEEAECAAYFAlbugdIACgkQwohYseXYAq5Z7AQAiRnR+bdejXZE +Y6rs7yrr4AQNS4M8qjwt3DA26RbCJf6vDA253wsH6tFXa4BU4oZLIHH5HXQWghwoxlxju4Mi +UR50NHB3oIDyy+55f60fcda9SQtFuZyXnq0r/CHpxAdtTU5FxthGxhKF1vIRcek8j2/iV1WT +ZbxfK67LoDeDfriInAQQAQIABgUCVu6B1gAKCRAQnMVjtZYOcUHOA/9z0fGDiBG8Hv9m0+P0 +AFzyM0YEWDFHQvV9Isb9Vnza7903Y7aqg808UJbZKp5M9cPcI+43lLv1GfOY603gTbW8f7oC +08/vbDX644gXyMWK/rhJENGkq/cZa/3B18h7EEcXFTNQwsEe7DQlSo6ethqxdc+fYR28yrZU +aADmlkpjqIicBBABAgAGBQJW7oHaAAoJEDA9/DfaNvMlpQAEALbQsuu4XikNZ9Cu7YVwam3i +3s7/V/VQ98k+8M8Vx+O33gsz+fDYov6Yxr5MY4DEkA/LG5NCcpyQIPbyfTDE38mv84EmhGG5 +IS4D5lD+sQ2N+dPYLfxbk5uDlcBp13DsNyKbsFbuw0dLp2tVygmtQE18IRRD0uRvpS24m+KR +IV7CiJwEEAECAAYFAlbugd4ACgkQk/4UnSv8CO8eLAQArxlO6P+yv3VMTusc5S9+JLdFmXzA +8c2RCaoGLcOvWMqGZWiLh8ftAsVZ4Uh9+DyQASJa8yia8HftFeE0nm8HSZ4LXLwCOjvwiu1F +2+/r/pKfPZ2lP4bZFw3biSfehw4XBY9ZMye2PSU0s7FSpRh/50lI8ZkBkSp0XQTeeomvzNSI +nAQQAQIABgUCVu6B4gAKCRDbsIkJoxyR9KaMA/4roWyp82sQ6ImX/2EaPdO7gv2L3zYMVKfR +4hOBPnmg1sa4u2Bq8QwiaJ+reg/iw/V3rdNer+kbW9takjs2cF8EyEEGCe+28bDxd7QO7ejZ +9julrxNHOSfMk8yxf58g1VNzfxnQam72ltahQbC8xGP+6roRq7DF5Bdswl3deica7YicBBAB +AgAGBQJW7oHmAAoJEKwbEyxLN/p1l3oD/0i3GcO5IIPPUGDrvlFkAwPQu5eH8bPeY5pJiHsP +CTaytb3EYZ8Oi6BT5n5w38gqmdenfuif4eBtuJ8vHlACzlVQzCvs7CanZ5nm1/vEUF+HwJWh +x4/oStePcg1PDNa5fAI9c15iFseM5ojGgX1Nb5ARwDNvHNWUyG7+/fFa/6RtiJwEEAECAAYF +AlbugeoACgkQojBb36RRuhlg0AQAjFIBRBP/ReFzK7NIDe5FRUZocGtXC8Ur2owrTJiXHj6l +BR47QBO96WmyMDLs4izRpaNZ3AGJAsIu4H2GlUamAusOxldGkXthV5H6XJ2Dz2Nf4sv9uIPN +NlbHS8Mm/GgNbfnnY0Ppl3lZ9p/kdb2Ru0vTbmL7WRw9oVcu2Umpy8GInAQQAQIABgUCVu6B +7QAKCRB3mVqF64BMrCQEA/93MSq//VsKCb/VFdGObAiYp2sQJLfkClZThsVL6HUwNtqdLYa8 +eGn7JywUOLaeolLnZr2RpmBeYZq6Qv84qxxbELHmNQ19Erwp09nmsyi8R0EuwGocIMhrSNMH +knm7r/KWo7vTlvpI0HhNuzwCFwCJDlrFhaOFkTmv9lqSiRpKxYicBBABAgAGBQJW7oHxAAoJ +EFe84HRIGpvy46QEAJntqTCBNJYFkcDr++LpdLF2glTmFOje9+yKfIDXV/+ZrkoXlV5SGzYs +jqFDI5BdkUwXmIt7qYf8VQlZ9J5WVHTTsM83mjN3dL4pctgDQVNlBs9yO32P9pRo8n2mwZgZ +czPM/+PCRWnzuX3W9ZNn3/u3u7cM9zAm+egyk89ZKkOJiJwEEAECAAYFAlbugfUACgkQh8fW +05PZKR2E1AP/c5uQ+zKr+D9CXGqY74FyV4qBS06P7pchuAQbet2kQBDhmHom52OYpZqFOPk6 +Gu3hollNPP80Kg7IYqsi8SiJku5RgwIfXQlCuMoRGxI5lqLNQF48YNQ8+pWegq56aF+ZnErg +GqqIvpsr29fEH+1+bYb1an1msJVpEv97L+BzlU2InAQQAQIABgUCVu6B+QAKCRB+QGYveQDX +DB6MA/9+tlbtgOZDP3Iq26W1utRteEd1E/AeNoXr/ai3oG4M9qxz+bCcFTDElHgDxwZjWSJR +W2+v7PgacV5iN+Io64ZBklqtbt3wbxVv56mt20aC5zyrCPeax6KZrJhBaMnKvlpu3/WcWG9J +o9q2MsLs0wcwQRaK/xZ8oj6c/vplAylyMoicBBABAgAGBQJW7oH9AAoJEMhssnWT3jc1PQ8D +/A98SYz1r9UubUjTxe159/q1z2qaHXTeUlA3rFy2WHqKTbO6CRuL0lNRWdkIf/8bEfWWg6hj +/t3oQXyMcnINb638MHpJ8BPrtwEgAhNDNtCmLjLElxmvRtVzRJMBQ582Na4g9TvNsWp21W1y +J0ojRDZhPMJn8FgLTqTqSiEkdio7iJwEEAECAAYFAlbuggEACgkQPd8fYGjbvfc7ZwP+KXIj +hd7EvOcYLe7Hdgbc/xn4MXjIrw7jWmIfNwoj+NXNgerTsUWMhjGjAVEEM7kYPx+/vpm62BkD +dcnVgq0voj+Q37RiKb0Mo5DMyKi3cllAZx/6TVagSwFawut5gKjyhCJYTFz3Ci1Ewxb/YvQ0 +S7jttDQqGMeF+FmYhSxpRCWInAQQAQIABgUCVu6CBQAKCRCnKFFr5/V8bJLkA/9gsd8gtrgL +jYVHwCixlFbk/fgL7r7FYW3ayIRHdPEcIVeDdG6VGhpI0I3vo2oXKGh6xF6ct7yYE5gNBGJv +WMWUj3QFKZXl4QBn9zdRAaimmkJ6zW0H9eItgp3rNu4EKpwSctTfyg6W/vgYbxEqniuSUbUE +T9klXqs9SUsLukIwSoicBBABAgAGBQJW7oIJAAoJEAurQRjjvDnhMZUEAI5Ry+KYcm9cylBa +u77zVhGZqJGI5S0EfE1i7VQpAAkoh3PN4RzOLS6D/0F4nAMAdg8aFxF3v2dVSRZHQhCJStFc +B6CfYUiPUoSOw/bBAAp/CCnRlE+7uxMjS92/pqW2s6WFLWehc1oNWCE7Qxwk4fIwTnkcJH9h +YdKHd0yMWsHOiJwEEAECAAYFAlbugg0ACgkQEwGZGcLlgC5JxgQApxQ5dJN8KqK3CAHZGzuy +lUSda+cb92r9kvwTVCrXEMTRKfktg4T/SvtqrOkneo0BJp98Ab7lvswXZ7btHyVrg4NoDKRI +6w71oDDpJHAf6dtyiVzjtMjUzpYhPMCdYfp+BDQt9AlX+S70J78M8LOUdzZvSztyIKKHpljQ +arLF1UuInAQQAQIABgUCVu6CEQAKCRDk8p3uLFXlqCJYA/4mN5Ard2CQgGrequ6lRXOtrUF5 +BQ+m0LhJzQuc0Sl/McLDIO2wWloa6jT+snFSuugxDGTu2m2WNdCkC+tOKaG1zBGluP00GU48 +GSfgmM9vg/L8vIUBm0n7zQwogpjofmLzumxmQ4Po8Ag1D3+uktbF1l+CyEgtk8w77oNTepKO +f4icBBABAgAGBQJW7oIVAAoJEJPng/I4+d8Q6wkD/iC0j985hOXq5GRFnAQPKrJ/y3FNfp7C +lZe5OJIWcucCGA9n+YMqUB/5XJH8JjavkoSA2bqniGEZnslqUAJVwtO+BkhJlbx3Aqp3r9lQ +4ukW5uFwd68rYCRFCRqKO+V1xhBtXXWM+yPZ953ZCSehsaRCKclJUz/ka9Lf7UqUXIXwiJwE +EAECAAYFAlbughoACgkQHvoRjcRe4zp6VgP/QS6THCKLWZuQ21i04XJS1ytS7wu9uYrwV+dm +Vff2/h6b4l8Ru+wcT6OR/TM6br7l7vgU5Jpqs4pUDjPbz7sZocgV1qaL3diOg5QJJCpK0etc +aNWCpkQIN9/PRFJNYL2c/itutq7ZDk130UpdZ00ruG8vuAMIVWhnn8jyKE4oboCInAQQAQIA +BgUCVu6CHgAKCRCRFEoNvMM8YUADA/0aTa9wn0VZ4DhA3yZJfINuzAM+07J9815UPwRwucs5 +sKDMQnhoyqDt+3GpIeAgoXqDFUgMsfhoUtGS19hVJId67c16fuwqR8zEoMOFduhWq5okCD6p +8roJ4wrIS1G9U+OKtrEHiL4wzDSxCSADwu0LEYhYlCqc9kO1jBke1hv9kIicBBABAgAGBQJW +7oIiAAoJELBgzVptSO0af08D/3LAWC6ovUhoXcFY2tc9qrYkFrAJnBR9c22A8spnbfY+wshJ +fYAIkImYMl5D44CK8JxwyvDvJd/t0DRTDLdVPp1O2mjc+aEi4xBGnGfgk6/pQwgiRmor93Tt +I8p5FPJjAoOomwwCVRUDczfaQeh7GWgvT7Harrx7FoWh+5Xps7xtiJwEEAECAAYFAlbugiYA +CgkQuhZL/4kijcMnCgP/U/TgfLexlPl4VxRDfmBA8IXaTLRS6bLxrU2soYevb5jLcIjGeG/l +VZEhWDoaJjoNQIwbTbdlN530InJ3wk9cb7oDVfCS3Ur35oeRI5RqsJQfhoGjyt3vN5WwxnTq +txzjUljsj5n1UNhW6vyWG9Mov+riNoxPPjh90Saj7NirNv2InAQQAQIABgUCVu6CKgAKCRDX +7JbPUDipYc/qBAC47RRtIQbyett966mATScOTFS50V+Zy5c9ZQr+O0mCuQX6ZxVku56Ni8o6 +0QFTsI4DnAqNV8XGG70/+sEY9EYTE1TZ3S2RXlimprkeSxa20bk6+Qj4STWBBh55V4egRaVa +WrNThZGHCr3oBCLxjLw2HiK7s5W8hTzQySo+Q37oUoicBBABAgAGBQJW7oIuAAoJEDgRE15f +TQOO0l8D/Rhzb6y5lBBQ7D8X/shyUlIqGwSzvYFT1ByKqlbfT0BxfMBWBo/DgqHNhP+BX7C1 +Odg86GZrbgnAg1C6X+lzJ1TwxcV8BdGO48G83yVs8+bZyRcdi0VY2qaRDb2xi+WDNj90hT6W +4tWps/G53UZUwsb/2sTYmIv+Xg/ml7BzdcZziJwEEAECAAYFAlbugjIACgkQEtS6vsndAmAU +ZAP/TSLLIiu1KqKBsK7RYFcsoSoWZC77mnjydyqCxakMYDOq3fwPx+FdgYoFcjWLyTHJlBuy ++Ezmp7MFyRz+Pd9Ktc5e6bsiATJvVfpAIvT2/7mRZRovecn+cTqcML4Oyc8x5ZrknzAsz1R2 +gvBs3uGtlAIS+s6bsjWS3pYArY3f1AaInAQQAQIABgUCVu6CNgAKCRAVLwe3krv9CES5BACR +YKjCxsBm2zahmIHx3lbog2QZty78px/e5NVprKaIcPikhFEW22EdoOUpyE1jexRAdNFrsPK1 +mTVGRdVBXF4cTmuaGbiJzg281px2FcE7OYSDcroC4UIm848E5BqRBeddsB8IREsxRaF5UMMU +3S+zJgTn10kW6GyFIyG6SnKofYicBBABAgAGBQJW7oI6AAoJEMlVdDXNRGNLyucD/jDXRaji +3BOaVXgFERc2omqLJw/H4VjivFxMF88Hza9y+lYGx+cUftq5SsqPMqlYv5F+aWaHlBRzM+UD +nNKjK4S6lWZnpFRbU1k+lkx4JU/b6x2lmFHoVYka21qs3z2gDDOrD6tMZvbH8zwqrKn6eVJr +5Wwb6Y88kqhn48fSKXEmiJwEEAECAAYFAlbugj4ACgkQPdMkOhV+wi9t5AQAgprzwR7HGrtE +uaat4cc9l0pGQDHt/L9yhJCuFPkUlsgiB4SjcoGlPqxIrTugKPv/wEhl3Ot5ZXMggwubOYS9 +Ay8lxqTQMrOPxzfjNomJgMEUmLLmT/2SEM1aDZX5Pf9WKAZNxj2rzWm9H/KtET8kDtjmwNg0 +j6SiJftu5fRDNkiInAQQAQIABgUCVu6CQgAKCRAWC+7hg3o16hpqA/9YOuElHzuxt2V4A+J4 +co5qzeRxX50VwikwkQT9U7iwiBofxQnCJXjRYgAh49WnqCY6EiSWqzwwcjgu6C/LPAo6g59K +EXWueeshZgubcnkQ4gOqf+iNAXIhJimDsyHkTfrJKnIJAK4oHggK4xWbjYs0HCQhiaHOX3bm +B8iU/97a5oicBBABAgAGBQJW7oJHAAoJEMu3YQcTH0FS33ID/1dbPEBaQ5NywTBcBnM/9FiP +3sQtyAZH6Q4eX/on1sYW9T7wXkkr/VLwkhcqlr+NYP3VxkWYYXe5DpxjzFODu0BpSLN47JBK +T3KK666K3ypJxBtlGQ5Nq2eD5VJY2mabkJna1S+LbWX92Bqyz2Hf4mVo/0zYaJ0I07G5MpxX +S6JziJwEEAECAAYFAlbugksACgkQw9004S0pFDGEyAP9EA8HeIjTTXeIjnl7uLk9dZ2ooMX4 +rxmqaiBF7HuivglBSqirRi0cevke80cbnryxbKFDlY5kIezsEMQcOL842DcRoqc3UflPbaWw +zd5AYP40lzHyx5kuFKYo0cTfsuA7aIOAI8AlhOuWuAMEk2ZRFJojPy/iTEihepcb7OZtAN2I +nAQQAQIABgUCVu6CTwAKCRDQuanRL631tw2VA/4v6IwQMuPmvKTbI4nZ/ZjW384xgV7Qdb0j +w15ZmvfbYai8Q9gJIO18YNqmkyLnSwGA56glsfZ4O8V2vYK3G63u5dXY06TmwDlr7kj+/Ybe +yF6fUVsINfqIPzMbyjXpv6SIEBUUh8BS6vgHI7wY51FO8wsgA0p1MCpVehIl46aja4icBBAB +AgAGBQJW7oJTAAoJEPvvdHVnVQY2zpQEAJVl/lk3HR+e0LxFAEeugO473vTWVc9gaDk4FeE2 +RiXJgsuwGvRpcisCf5Lv8CCYD1odNZQbSLBo06UlVT34/Q2Llh8dz2F2W2oJqzRhZ5tHeavF +WphMlSkk69yGu+nakOwzf68BAg/7R8Bhf2mZMkjetNnO5+DCXWbmeBOKDrb6iJwEEAECAAYF +AlbuglcACgkQN/qG71UskVdPiAQArQWPsd61wZh74PVNgQ+7NNl+wdXb3uWdgQ+TfGs3eqC5 +p3qDvRJec7qU/VJQtzW1ejc7c81jQjetPF9ntJ+7dijL9rUXRaRI3SDriRHpCygrhhYnx08d +PYCWkO82tiJjOmrPevANVLjVxXFgh5is633bWzaIr737I4TIH6A94USInAQQAQIABgUCVu6C +WwAKCRCukqHKry5HYJIRA/4o/s9VIrzfY15xLX3yB+RgR+goVv2LqMzERIl3g3JI83lf5KR+ +D5ZILvzM07t+nkXPkrczlCG3aQV5OQ8TfhlMeKPqMC16UIcUE1k3UoZoTmdfefkUiXJU5vnL +3D6VV1ilQpO9zgkmTW/d5dI76XfxOT5Ols7g+r/yp4bb1iN9SoicBBABAgAGBQJW7oJfAAoJ +EM2PR38qDaIIucsD/3hroew/u6HFQ1cWvvYsM0nEtonH0rwKvkpOAB1d2njZ/a3gWMYkOBg0 +YTqi2b2dmT8XSLRCN5PRZjnPjdcxJGHVtVsFClh3YUZ5kxSViA9kcbIZoAj4qAtUze/fjbVt +RYlsTSen9WezopvzMWLBeu6yN63zT0UqcDSeqd3wMeaKiJwEEAECAAYFAlbugmMACgkQ2fFp +b4CIySDsHQP/cg/o+T/6bimjcXidlgI8/6epQxKZ4YB7AiAXjn/nd0Titu4Xn7YfBDoRfkcJ +k+NrVsfaoIwoSvgNElM+jrNxOeWLkfVJf1WqbV8Lot/ptOcEto66xcG7piq2NBCPZtnXJH+4 +23maoVDJzTDQ0KaRhBG/VpyoFEAZeS3euFCcJAuInAQQAQIABgUCVu6CZwAKCRBpJNYt7WVP +/z5NA/9kBXWveIiJeK2R9HpVD9R7/1dAqAN2XhM8OZd0eIz7zG5+2M38r2wqppvsbhEWjd7q +QE1pP6/fHrCzjwF8TLYPgtE9WSXEgtmmAM/YNfe+SpAFpzieJmWgnPPa8sNZDOEerUSoSWvk +94HrWgZIHOm39NyDk7K8bDx46FvdErOG0YicBBABAgAGBQJW7oJrAAoJEPiUmxRjEJDlrP8D +/A17fxsxJCCPtt4fJvQH3Sx73yO1lK0hwTiDJMSGb03PqnvDqwLFrZvZOPxPdGY0bb33rFRq +HnjjTnVbDKajmfFq3iHRh6fqrn2cK9Ut+PvxDg7vAEN221bVme3iNrQFzgjRB5I87iXP4hZ2 +Ry3BCY8kPLXdTQ3rvvjLSIaOM4y5iJwEEAECAAYFAlbugm8ACgkQE3bezjX9FgawpQP+N67X +P1rkFKAfAG3NcWe4Z0kuBL60BzR3Rrn8gbMZPOasUhlcRvYctQRglOeLnF3KmUREXmlNvTI9 +RkRTidXynsm1WaGUlNw0wgOFhu4Q1Gl6Uo8ikFBstiiMy96ZqI1xanNTqpFcU6K3WDoE7xfJ +u+DSI4Np1MsXWN204A7OZICInAQQAQIABgUCVu6CcwAKCRAe7t+RsATnFZiaA/9MjxE3Ivi7 +I1mskg5kQQ39A7yQEJCN7jq8lG8deEyhaPzV5p7MeQNaOcUjJckojhU4CwBVCdTjhzKbh/61 +tbv3f8uwnlT9ZkKT5MeHhJ8549dfUpzeOfQaiL7pAaf9XnnWENkXHRCwshwwAkKgl7RjtnOY +VOlowiZ736/4/iSTgIicBBABAgAGBQJW7oJ4AAoJELfPR6VsPElw+5cEAMhNFarpUAhQfFyY +HO/gLuaHMyzSQa55C6wXMF2u/Hij0RWFpJVK+N92N7RFOSWyCjYKs6o83pG0w6sms89WzF2B +vHP9nCjf621Wc/UQSP3S1PrJlugVA4zYnh83ZFdZauZ5Fy0xlQ+sYovv6YirMErMennhVnL1 +EddlaFhYxnLliJwEEAECAAYFAlbugnwACgkQzKuFjbPLGxG5TgQAtFrNaTFkccQRzVywWIGr +dX3OQmK58TFdpyiwMIOM9lfFC44doDRTQgNiyrCXlX73UcaoD0ovzJ1jB5ZrSO/Gl2nWN3j/ +/t+hIcAgmv0nR7hXR/AQhV0F2zpacN55CaNhb+wqXleMA0wRtjRj6aJWyKThQvuhZc45FAuA +hGQak3qInAQQAQIABgUCVu6CgAAKCRD5NE57puHQAIsUBACUEz1O+BxjUM5pOctq7qoAEvAd +vivixTsNZUj1NnzLFGbgzWDr6Z+LPvN5XqjdVudWJbch/PlNBhhwYTBR0L8djtVQsA+wlGOe +Fd5+2oucp16iVcdy1RN4QF11H76yqbVEGUWFA5GA8B2W/0Rnsi59KCmGMFkA+P55W98Ohj5C +m4icBBABAgAGBQJW7oKEAAoJEIdkw8m7hbCcMWkD/348FkfHwPkOaFgjShBJFZToI2k6PVJP +nGN6yfb2rTepvL/XzMhvamyHHisXqwxtUdNKKLF7WfbKRos8cdyphg0xEa0L9wR1bgpTugRZ +aQFAT3psjkUTzQpR5Lmn325txsYyAW9Q8kVTwGzB19nnBF3M701D2j2RgNArCOlHeI2fiJwE +EAECAAYFAlbugogACgkQO0j0inSxpIsdcwP/SFq3j4vR/GHeB3fxLTb4q7tNXoq5kAbSJbWl +UH/ZaK9HEx0/gLegiEYlFaZy3OHi8zj1Hz5kLFptkQvvY+9ItThiGNp+Jmhed+WN16C+2j4P ++Cahq4mNmkCMTNJOUfzi60ws3RUhWOg8FRAT/je/sbC7YLMgdN0WanVJg5qZFC6InAQQAQIA +BgUCVu6CjAAKCRAK9yb1pmblZZZWBACQjhHA4OH6IMdCXv07bqGM17q00+VHpOrjT+nYii0q +m32UXOClRDTM2u7wjFzXqNPW13rmhAAuvXks+lD8GGdXsk0S1o25EmAzNqfLJ/bW/SEPl28o +mqMmQojD/fzoys/meXWwEpAhcT1iXR5ap5b08wqkgqyIn8eBN8+rhjEi3IicBBABAgAGBQJW +7oKQAAoJEEihL9XhuNVutUgEAKMQfeuUwYQ4PehaaiolAMuaCGdeFuPNvLmPcol4Ob0umNXm +IU858zwMCLov412NTT05spp+afpGU7EkIV3C5iBQnnIDrmZIuZFmFaBx3+exlgLawHI0pCum +JKJmGbTSz728lUj7Rsrv95WKdz52H9PXHroAc3t/w7RM1R5m5kBoiJwEEAECAAYFAlbugpUA +CgkQcO+eSMVgelTbjAQAg+j+s1lzp/TzHtMbXegrMpS5hytTYK6dLGyoHHa5LwgfYP3OZwnD +xq1BZT2Qnz1/2xJ35oexHTYU8MtZO1z1BlQCAnlU/xOT5wiK/kSun+HeocFVdpOMTK5PCgpK +WGoT5gXuSgSoyR8BpdvLfA+k+Gl4Pv72gtBadFJAdcCcoOOInAQQAQIABgUCVu6CmQAKCRDX +b2BTG/fV2DoXA/96H+Bg0kWb6io+AGadBdUxUsRESZeENsMuV2s1T6pUKZHOEftExPCMJ9Zo +6lszpWaxo9k8kwAU7MqW5J7xOAyVOKJULPGU3tu8a81Q3mVx7YK2QF8SiBuCQfi1sAathEBZ +t8H21UtcL2jaDlgWemNoskaz2zZjFtYV2299dsCRuIicBBABAgAGBQJW7oKeAAoJEK9dSX5A +1JN42qID/ArO4SE7GV7LyQTHnLHuKhCGYT3t7nkI2s8e2maG4UtCG8jUnWxXPS4DbHqGqlUL +icRvutQ2xXueAkmVQgG2UcAFdZlC8Cp3epSabDVAHj1pSBd6blHm0rXqWAqYx29xQGiaouAb +vJ6MAIph0bCSRbVohxl+uuCuP+gzdaSxog9eiJwEEAECAAYFAlbugqIACgkQDO8APrA3dw58 +oAP+No/HWa03x4aEtJmEUieBFUbpsvIkD9xFQ7a48Sfnwp/6JV3Nt6Day2qoYJbqhmcEBke8 +KI8N5pZl/ovF0xP+YNAEQE5Nyz7ki2TAbP7PWqNIAeXrrvxJ2FsS3LAI4KDisPG+lHD851Vj ++95A1Vl3Ca8WQwg+fdoqVS9i3+rqKdKIvAQQAQIABgUCSwTwvQAKCRDtoh6UtWVxb4j/BPwK +Gsu/DRx+Acrog1WdtjFyAhmtWkvLnU4E2FXMmA+g2byMGFcWADWXUHR+oiVGpXtR5LV9WzyA +DTBV9CTzuVi7JC5OkMaKeHKUjeTU6tUEMi8UHarC4OA4KZTLCNgy6bwmvlBtyMfdGsK+EVLe +iE+GwvSjhqZ68tB3ys8P2SxC9FwZgHG9NO3LFIcEIOsR7KUxjW3iPaUuqCttEK1wzFNJiQEc +BBABAgAGBQJH3piyAAoJEO67Mb58Bv0lF8sH/iXvH0AOwdXQAIjVWxOGSR99xnQiKzZMLL/O +eQNvnM0FqbWH4uZWoydfjUa6Fdrn4Zy9izXR7TaxjEAXfGDLkc92isvJgG3aer1yMSItGq0R +/iki23oztWtmVheRZsoSZOlHWWEEqSNDpcJOn1j2QPGWibsWal0wAYsKNmjpo5OUvP1+SPkF +zgDrCrSxs4kxzvKBhURSwgeSKMWQPeQB4cLidByDc99eOfRUh2do5dC4Oa52l9icHOKHdlti +ynd09HSDvw4Gm28rLoGmK2aeS+Y07pJSZG6NwS33O1indly1APg1hyA6g1FAu7kBKU0uISE/ +XNIM3C4ISaeOmy5M5dSJARwEEAECAAYFAkxVvGMACgkQsglaV3ge2QkCdggAjg0uYFEeHwua +PI1/wNr8diuKzx6Xdcw1RN3xZAg3vdYZIB2k0SZUUchHWAFWipTuZ6veOIeFfuMgMUWhSxaZ +6lqEU5RO/LEnKPzvZqL6MpTngm2Li2/MHuXhr/C3wzEPtSPRLPYA20J6uuG0AS526VZsyalM +skOVltV0Jobfjgk6wFcu27XwF5UGOFG95qjnVHMxJp3YGUgBZiMUZj/eOwiTqcneXotcdexy +cnUC5bVF0/3oDAhK4PIRitHBBMv5Cqu7tXoSkUrY7qFLMz7RGewzmtrWWS6itOVU9B2Dv5/e +eTjbzEUN0KLIxrxW08wDa4qNdWQGH137iCGNIo2OI4kBHAQQAQIABgUCTFmpAAAKCRDfYa/+ +c72KulCxB/9O856aQZDjzi4EGpbnT4q6RBOhT9dRoF71Wbpv0X2NTGivdDmNZd1FTQX+BAxn +ySG0JOv9LbXLsFISD9HjKAQx0V8XzQ6p+18+LCUBWnRa0903+DMOmsaWhQdeE9wheA2Xr5r5 +FaLGppWvrRR0LV4OpuJ/rPrnhtcvokkkfc3sHRvpoO0AuzbZL2gcITGJmScU8Czsv2umICBW +PD2y/wvlcfx820MEVw82h/HrCzTOrd2C4i85K1LfQ7GW08JA0HWVZIIpeD9c7AD+m4x8eHQz +2HgCyFo5cM0nCsO1KOqvVE8aYHQ5jvk5SKlYiuxTg60zhVE9r0MJst8bDcwkgi0GiQEcBBAB +AgAGBQJM8oUsAAoJEIRo+5CNRoLoo00H/jCnE/SmatqzmUSpN+KbZphmO2ZEixiUxc1AwV2Y +WjLd9T7qV79sVhkwVI6AnhfBTX9Kb+Ry+FdP6uQkQ55II6E88J4X2g/8Xrud/AgRxA30sU0c +gqocpLXPrFc7yCQg4F/sD9+NiVeOLMkIzKjfxyV6ux2d/VOmCJCcY+bAN/CEzL1dan7rvwUh +QtJWS/loD1QqKWjJXPxmx95b8sq+vswHi+TxKeLjtAUiTQK+XLkSvYiP6UxoL06CaXB9eMIn +XSj8w/+nHhk4tinmCdKh4fImd+vFBEkh6/ny8mLvehlc+qOVPVQffAIlY3QMOaZO3xf2i2G5 +1Kw2W4McS2bzu2iJARwEEAECAAYFAk8JkUgACgkQUtaZuVylthBKRggAiAgEm6IduP5a3Pi1 +JF1G5vC9+ghAlQ4304H1OPg+itvOs1/ehPUUmTKyfQJFuNbmslpFiDE9GyplDq/rJIrbDH/Q +S2VZcFfdtpJ7a3FdsoY5oQZI71Q1Hw0V7m/BSwmL2/LsTN1+0BDZotp0DH7hnXXwUKxWuXDU +YPsh8B0IOk0zNcDq7+jIYblgZvE3dQCPVVq4Bwx35LN8AsiytRCcucOjzny8uejCifTK0s6G +e5oeql3zgbc7Hq9a+iPh+twYuO4H90NSG/Z72BZLJT6loSBmpA/5DoGQsrhFehcDFdu020+3 +bh6Rea/lkEhHIWAbtq8dSEQalPiwkCmF+uRu1IkBHAQQAQIABgUCVKaEPwAKCRCsRu/m3lAL +Prh1B/4oTo9OylL2IeK+0YJflhlrfH6bDUhXuj1pp3jLroeu0jRLu2bkCy7Ebw5OZZ1XNjAE +EvyjwFMI2p4JeOXHVXKFH5NporqpgobRGzR/SuUT5PSScTjRDAl6givfSEuPL9+I/LmHsvE6 ++lu/aPnpBqC8UP6AIx2QwBOCZR2Ys7PH/NdzFMXGmBIcRnsf2T4JM8T7coZ5cM1gPZlYDOm+ +3WW7Y3Bcr8PR83MEzvRWWPzPHF6GN2BbXJLSnd5GRfkNoxbZ3HB4w5Yp1q+c+pnISTkds3i8 +/9NrcVGH/Jjx1C5B+ug0ASSilNjBV4BVDawZmY7j+XWXwlAXZYEA5XW+KMEviQEcBBABCAAG +BQJLArqwAAoJEPfuYW7gwgz/jOAIAIEaPM+hOILxD+NB16OYqMpUgt4c+SBlzoY/ibE5gzFj +H9V43TamXmnyGLX6kwNhOxnp6kzGbkCIHYhLjCpuXq0V+VEFDSP0QSv+RSV0fZarsxaSHsPJ +BRxMOzysWEhlK4V8h5cCh84tM74cHnSx1RklXCsoVGD/BtJM9/rmjFsV1SfTknFouERB+auB +Q2DOPSMXQZn/dVkoPP/2AbW8b2dGnFcBc/+Nntm+zGx3JQ2o+R5rq2iHbcrwBNgrLBnjbB0U +LewtZm8ipzRrbad+BbHWstDPXK4M9VNiPpiLf2hn109FtoZvZHOkuaab3dpRi5mWFLoCym4J +M2FolsK+WHmJARwEEAEIAAYFAla+CMcACgkQnS/NvqY/ls99xwf5AcAxjokaho5qiIus4nxL +eouVtWSaxJcGZpv1IO5uyQmPTqDJkMaYqy3C6wSVIXoU6CGzDj88GHDF9TzvormCa2mukINq +zm7HYGYCWjNcB2XHPQYkEq9vHr8XLqmSyrg2ycfSO/lAaqhotPPooc0IYT0fs7IWoaVcdTyA +gdBy6sbbipDaqc2gC/FYaDb8+M4ICwRpmb2UaUBRIsBYGmJC8dfYratEKRgI30d0vAMiSeP/ +8v+Fue+We+LM5QFUClqCZxp6ABeSJMOnrQcJmBgwV/zPszCjxFwaWKG1BOuvaX1hNiqjjHy3 +fW/wiO8MY0tUvcKuBk02XfpI1PSFs+ZXKokBHAQQAQoABgUCT1X1vwAKCRBi7MHeRXCjcXSW +B/44UWiTXEjnfaueURGVsyu+uMQ7PWP6nI1EbSdr0LRgKy9YpQgL8JHI5d6bOs5ZZL5aheox +KA0kUHIzeAzN/vsgW6c1e1AgLNp0iXebSCoXxeQ90/2dJhRRhBw/DHl0M1G48ugyZfqf5bWx +aGhgkucE4N+/hPY5/DBtZY/nVkaHNhbAxTW2zNwU9uO3KJ4RNgigzQJz3y/6gk/iaP/7NnNx +o/KcyWRcff2qt/zMiwfKd/waG0w7+18FYsM1vUScS+2943Qx5KMI2C6CLdk3wZNsWkYUlEHm +jwLPSB+9sxw4lQM5HNUk42TrpVCJgb7GrOnl7LDSgW3Eacli2lJMGlpoiQEcBBABCgAGBQJW +KjQMAAoJEHGMBwEAASKCTbsIAIblz8pn278FDSaFKSXjzK/XbaQKusjg5BAX5MHX8LJXndV5 +JzoK/v07xdaUC+c/wo32GB3svk9UaixY+PpJsWw8y8TGoIhR7l0jIr1X1PYEnxs9DCmuTSAb +1NFHK1bgPrc4WJhqohQ1TugL5gATIHb1h4t2IW4QScXwPlkQoRRwjQJxNDW+WF8yqumKeWIP +EexV2AIt3ykQ9i6JGUlcvGXOLzZR0SZIIi+41c9dan7aV8daWOmDxeYNhyPcqNC9Xh7tbNKp +tonAJwr3zwlzyagbjCD7LHYIYSX8PFYYvrbXQQXq7a3G6GFBLebfOPmIpowTd7+QaSxzkl+A +2FlrLWGJARwEEgECAAYFAk06ewMACgkQlOkt+SqqXDv2YQgAq/aV6r2dgqKKip+PW2s6e7cO +yUC89xApBqSiXf2a3UmVFfi6HGx3iNyTyeBb1eLRck9rztQVJEDyLHdtp41z8ynBlZzwGFCE +81/ChCjiONX0T/yEpqQAHHiJ5+KWhkqPbQ+Pbmlc+jLP3ysMlhriPETT4PcaZURV0A2Fao/c +ft1syD5F2bQCZVa9x75GyezibplcITUrLtRn46G+owgH0PiWd294AMnXELDVYL3Paa3eHU4k +7B4MmZsfmIQU6DreBPj0IYS9+BNMq1WxKbm8JjxqSrXTomxoa5I+hvRnHJrtUOfHGmMLn/Ww +PCfDsbiiZVAYOfPRLGfum6r8uLIu5YkBHAQTAQIABgUCS9mUoAAKCRA9oTItVpfiBLoCB/0W +eTuE2SO9Kj2AmvTMFp0YHaGh8+uYCNznBf1CNGpzP1D8GBEXR1Otrhh4QWp3GgPk5+Q09O10 +JzuZ8KGnzZPnJat1Ut8vlaP4hbyo3aoNLuV+4VXaYYHm8b7I0uccWNpljrQgcxre5vO2of5e +khbJ796+ZFgQHaNNOX8IPYcB1W6OugvYNNQ+Awn8RVAMs61DdIExSx59Y7UjrbA9T7t2q93D +ahs6ps8SbvqrKf0Bo5xnrJyai5NvBJI10j1Xm/D9U9pDiDFTRCi98YBF3kHgK2tQOOOcNwxA +LP/tbrebBeT/toneByKkazQerd1KXb8bWFO5ysk9DFuInHuxbJJJiQEcBBMBAgAGBQJQq3hS +AAoJEN1A8liqzgHpFusH/Rk/PmLyDBD8deU0/8ESO4s1CqipM2tn841BWAwjJDjqanwSsVND +FVT77RFq/tRnB3aAAI8Wx70DJ85Ohrd0n0iTZAE8DPn94a3qYxUA3Ff2zehbVP3nbCZaGj8e +K/b1UiyhcR3ObWzry4sJovUM4x3vlN2AlIPpFLKZSVwglaLhr2PU+Ayp2qqzobX+SDD6tskU +MgWZor7gGE1TkrCp+fZT8GjamImAsuZ46vcQ0KIpdkTwa74ftUW1BWk+6MMojwGW8mFL6LDE +o0XzHonBUjX3Ls/9cAWs1efT/Z6uop/lWAI5fBeFkdgl9vvDgv1Ir6mbRKnyjk4VlhNcuoIL +kEqJARwEEwECAAYFAlMzOuIACgkQA3Opy3d3Wvl+FAf+IZwNyHVZqMug6WVNs2mYAvKjZlyX +ZpUBtNKX7jeZq8inY3SRKi1O8u7qlxpqCFu4806gJROzwo9dzhM8sDIaKNNY043jSj0ZOAsK +gL3TUs8q+T0nhR1d1deOmE2GxheC1qCbr/8mbx8xegY+kXClvxfbbs+uasm6PmbMNsiYMYxE +Ggl/XYxWcouscwh3I1hHYTmQFWEFjESWptWuSjHivE/OWaQ1FybaFkIyJfVtM7ETnlPphu99 +dacIjnnXPFwsfE1V5MNXaQfTOHmF14zmOrk9DTxapL1OGMAd5t/9GJNxXbYW7o1a3+WLrLY3 +luP+16aU7G1UD1e+9fEN/rVW64kBIgQTAQgADAUCVgilPAWDB4YfgAAKCRDOAPZMwrXiqCiO +CAC2m2NwY+Wsj6uvTn4bRcRCf0jk/N0LOI8T+yWOQAR9ZjpgvUFUYKrWW7ybxbsDkWhxLO47 +ZO1xf+zm2KFmK2D6zo3dHR6KFtPJzxx1XpQsthwEeRcZYccYjPWp5Q3FIMiDZChUudaAzW4R +gw0PxGTTF4SMcIapxrffTvse0GYvDKvzvUCut3QJIlehcWn6RRBiQTUPV6nK7Zc7hBZSnulA +qlnXEFFpoHHPdAKkXft7ScIUc2EZrjj+V1cIrbJz/ZpqRn148+yQao7312ef3fkWyHJ3AP/Z +36kZQTRcMKVt1jeWbI+DGVx2uobwF52OLBHE49s8RJvYopdiyKpkfKj9iQGcBBABCAAGBQJV +9Xf7AAoJECI64FW9lOFUzWYL/29CyuETPRKRrRJL5eN/EQxu0QPV6lhcAah8mJNDL7r0nLKf +waX/LL/gW/4apxBNwE69tluzaO8+swcFFI61ss1mdkwC0jqbPPoL6SiYmMdWMzCtUgNtl7Em +5nsQE40r3quHgZl41PblFvxTXR6WhRH0vZIduDs02xbMJUPLUjXWme2z6TyTltuis3QBtBOX +56fue4mpvXs9M8Pee8gi4kn0djnB9Ivwlw3dmsX1k+j+A39pt6eOc5Er+u1h0XuA1fV5PtIc +5HTzFoBNcCKZd7FcoC6OZEp7q4OXtmSerLWyDvxRnVNf/gMs/Qf0BxsHNeoSFCKDW3kwelox +E/ZlrbkFNRV1lBciiCKsltF1OYL4/NF6NPmS9bwS/eH8NPNRDvY2XU04e/wLZgnaUSH2iOf4 +ZibbzNfEjqFvRU7XSsiYY+2yG3bY66glOXECOI1Amn+qXXNDXvUhDmLAwALqX03UJg5bF3tK +HlJeWEeFUTJ2tDCp2TR6frTOI9q1TUsJ3IkCGwQQAQIABgUCT1dgRAAKCRBtTRi4xGi9EUig +D/jV9k9LjXIO4bSvkq3H+WkioLV7YISBoXKYQwb9SEtW3hx+6tATxV+Vlf33MnrfguDKYmaQ +mo91luptx2L2TPbuZAx69xWqUHZv0EbKL47Fpu5go32zDnmyCFZb+8pKCKGfl2Lf34reHlSl +PsLn/8lkOR2kgMuJxZREINalnFoTmDaIwfIj9clk13rhuBCmZ5/UMXGXKpfPYbqX8rzg7HCy +WlwLfoQ/kpSU8JjJoskBqNSgwL40oQbuolMw0lyYfB2btnK4NozkRPj2vV5YSIVFwn6nKuNO +WpjW0HeLTX+KVDubDgieCTLb3TDSAwQScBkRGk0JSiaPipYVJkKY5bQHxzt9UYGzFRqv2J1y +aQwOpsNnKlDdLYMRWAdYQulaaU3Bw1/G7gl5tyYBZsxhy3agEHAnwJAaD7y3AJtyhvlpgOqS +S+ccK+J4plihUl6eGRGfHRg7EG7Hm0GWtKbpOJjhJbxfjyJATPiAf5fltYSV8T3Oh140AOR+ +x/DYKXQfoenG0e1Zzo4UxqOWc0nxdj5/Hi3GaoKM5KpLpmN9+fmVfPBMJE0Zdd4J1xXnxxCz +rivyeuEQ2GMKP5FEpoHPUYwSs6SW5kBrjUgFyvcp89bTk7UMpWggYvfR6EYcXeJ6g4gioI3Y +0QD4UVD076sbqeBeua+MTLgZswNDAulRM46piQIbBBABCgAGBQJV9KM2AAoJEKPA2h5bdgU9 +P74P+NE8FrJhl4bJV7Q0pVMQXFG5O3zo8Lk9odsmWIZirFFz0l5Rcddv7h8ezEavqEwUZW6m +NfPADxB3CDsul7jRVJCXjtsweqP6MxmytbUghHag7CaPrBCgkF7GgvE87PAIcw2LqSrQwm62 +IxQ1R/TiaV8xIujttqsH8QG7Ngos0QoytZUwsH3Xq0T1HURlOlAYxxOCpCH7BERXNoAeFgbr +Px2XgckJJqaXVRNYccmZPp22OFCCaU4woCt5K2kTnYpCjrfAySkT6XfE6M1jTKwLjxr8DLHh +keen+LHbkMYah0kW04E+OtkNmX45jUkNtAe4x6C/8H9yTzXkxq+uUEo1Wpc9kASllnCufazZ +OqKqHttIdNboWHrAZC2VEtY//jURr7qoRqkG2ae9MnPtUT15H2KXnZOqn1GKRV/8vrNwipzx +SMuZt6bEdmB2f4HD5x+gXNwHrzhy0/wwLA4qZnipXfcehJsKDl0cuzV0eMSyXRJsc6Rj0XEv +Zv/ZwlS89cNY7EnWnVw4HXoeEhKuQs4texFJJh/INweKMXAKV/sUYSSd55Y8P5ezu4m8dGtM +InLhXyevGFJbylPAZ8FVcvC6bFPyrR5JRFLe9EzeJ2QCNm5QJzSYDkxBjvEGbnFDwMTt6DD5 +zy8ZuJlN6anCw66moqpUEcNCjRq2FXVrf2YW9WGJAhwEEAECAAYFAkpHFDYACgkQ6ilk8dYo +pcr1WA//R31DqvYINOiMOcI+Gmkf4RleAKXFJFro8WGTAWP9CSGt3Vtz7yh+MDBGOJyNvvii +PL874oKMJ72IQ9uwfPvYGgFoXlAiAuxYpYyh6flhxE3AqbSvsQQfwZLkwteXoeXq68SWwdTT +Ea8+r/dSxCacop5sedW1k3FlH7AWB634U0bVRW+fOronpwOo8xOSNORoaJa2zWHlz/n4sOMb +DHwNGKSzDnTxGOZBlByyRWlDQvv5tM3iSgok+YmWFASFAl+/KsmSNpU8eAyHuPLmuZBi8+dv +O7+ikRD6ttGjSzi+BMdxgDkaFv6tYU9tg6hgRBb3CJJaYAn/EkwsOWSWkQykl6qMD4IFhZxR +SLVm+d0ibOgXUWTyO3Ti3eFr3NmCGS9/hQmpscDqFDjAgcgrFMvI/N9aZnj4b7Djeu5QVaeq +dupYqaYG1feAWiXqtihFyACsvxR7f/CB4eN1a7wYzOFRJWmalfPtoAHVAEEQlBPJlDyt34KT +5uRILHroF1Ys7k96f/PHZEIMSvkRHdm2ysA42KaqI/y4/95ZHRhwLUd96vVogz9LJUP/BQR4 +kxupwFnyANKCEqnXshJzwire4aaAH9WlX00gd0ZFpIzWyCepZEpa6ndnnTCYSeKfWXoP1CcM +GEC5HLVCxfrUDG6X92SYdAMC88Fedg6pxH00wBajj5mJAhwEEAECAAYFAkxLC4sACgkQteOZ +n77uZ2TN0A//dRHc78zxLl/1si4xbHh8ek7Voc/oqCv4o2hnCQYMY7yzStWSl5zfAe/5d6BI +MhvhFx/CywgFmJQBeAC6NMS3GwIOmViVymr73zviGH6AU5TsdMsuY+Nh38NrPtNoINjFkjeS +MiLUmXHss5NMINe+5bM56yTMoYt9Rr2oVvVoBEqHXXolakd2y85eNKjYgQXz62+A7OzYb3hc +451F/dIvRc94kg2469NJ2Q+IF1FmJy0G1os4FAh6XeijzmeIJ9XPqcAMZPBhm3+iXU+H8dGq +sin6FiiToyj3oo/fNTP2mUXhjXM7K+1HD5LAEuagsNrUxcgjzglM0mARKKZAib2m7fC+cNW2 +uZ+/Fh0UrkQ6DQgxYOiZZobvsY570aZVivv+ScCc0iE35Se7lWTYBGHfTpNku0TJr/DZIWSY ++K40419AF04+9v2kNdh/HZtmSPWo3eJLA37HMspIzThHiAQq5s9h5TO8ftwD08drtOVmAFZ9 +6uo43j2VrT8Rg/zsUZ5MxNPgKxf8OqYDSnmAr5L+ELpgNhJ4C+EfnQJGJdZ6GXmnNPOUmy6M +ystqU+OC8uQ0q0Hkqa3FFnDumwTcUMmjApmH/B6iatK9P7JeYJKnL7zz/81HFcVIPDNtyrpC +GnjRaahpqs8uGRxrgOnBkiac78x4Imei3117z6Jnu9nhNbmJAhwEEAECAAYFAk3RYb4ACgkQ +qUNQfXbKFgTf2BAAgn5yy9wBVRc8z1MH95QI3fRZoMySN3nGE0xcmGPudDUqvnqI4pxlpE4t +92oy/ctvLFUPt6zCUuxOTnr7W5p2GeABDo5h1HPUX6R3YysNwhrKg6I6e8CwdegwtQZcfR3N +jfzFhtgWw9OwbPJ9P13qHMnBAu8hCJlLDi7tKQomc7fkRHr6Di/l6DKN2XujO00RINrcz2Ae +cC5Ct3aVGetNQDrb/ls6XxJr6c4yzneRw/ZYMDvw2VJ3ynMRuiQEV0UHtfM5Kyc2GupDPmOC +4NZpDZ46ijv9t544Qo+4YSj1gXba9pURCthb7t/IX/QMstX7LHJ0KUrRqLGpqiWuCdILfZcb +QCkjhwtr9N9VajU9+c2HWuo3Q7AVN50i0YoxgkmQil0KLUrD3WoLHMdwfCRgzisydI2yOOtI +W0DYnH5R9zOLENe2g7tMBtJ0KPSTS3WMOzDn8r6PNyJo/3TUNVr2GAvYnqT6anwMnjNJ8VDU +gquQD6Tuj6XcfsHPCGftk/gRaXiPfq5JU8IO6UfAeqX/ks0EnXZrrp0QSnyotNB5S+v6gKv/ +rhzSlNJNu9HQ4opVW9NqP1bz9J12PsG0wzoXwkjxGxQlsnanl4ESAbnSM6QoDCD+3S2jmJjd +nzP8wsS6/arvyQAEyHwt9ouvAY1NcsgitUAfEsaUuwU0urjyzOmJAhwEEAECAAYFAlL587QA +CgkQ6y5AmvFUimeURxAAvU7d7hDcmtnCO//S193Opfs1b8GDTXzo1x0Kw9mFpLFJF+FEeaIU +Kjaqv3UX8YfeTtHCjez3aYconvUpHmA/UT9OlOmIzEnO5Yo82ikB8MRXOAZBcm695httI80K +HoOA1xyqMzhKlFjaxALXw+lfPargUe7xBNseFyvEfWjneAA5K/ocpUjOSHOOR1lL+n17RjB7 +v9pPK27tQ9gYdMn2YCAzg2lDtKHZFnr1FvrwOBt73e2yZ+qQVrP/Q6N3JL/5oODOckL0rPxY +Ir5j2Gk4WxkWaxXSyoiXeCx1p2ByYTqna5eNDUph/4k0ddeKH5RvdSGJFLiu5/nr63PW8pis +QvpiGrrgmhe0wOLHbfNHcXAZ11lg8GPvCqZPbyJJIHHYWG6NWa6yyCaBJUjdLLFrCOac5rYY +OYxiIYFZ3V2YEATfCLOzhBfJPt2SWSuucvaxaKaW3lM7U14VuhDHjxHzVuUXgLTvHHgfjQaB +UE9hvRgXnmIYlQIfuzkt3PQopzrwdkMqqa21gGz3/hGnlAxSm4ZIr4/5NiVYvKIWf0Lutr1A +4IeL9x3NUrjGi1Fy8k6PCJVu6/i/RTGrCoYXTzEyZWrzr9tmGxJVgHpVoR+uZxSyEBPNged8 +4aAEJRJZ1H5JZX5CLXkf+bkXYBn5R6kV65N9vcVqMgYnSXRMJlzvpj6JAhwEEAECAAYFAlOE +eSIACgkQLHwxRsGgASHozA//WhXU1lfohdGe/lhQofVf59FhYs4pLGQcghYnb347dAbQN12o +7KaTvu5S8ne6dgtrfNmAfwBudw6Knpp0rbaJZAwLUTCEQZcKAoatu2NzejY0Amtf/CD3s9q1 +1xz9gU7/Ru5Y2cBHiYo6PNF81B3ka1DyoKIFO9sXlA0o0jce4cG8P64cQF8FEclQnxgn/hpe +nBLrX6ydLgzv4FvsKm8WPdFW7HfQuX0/hne/7SIJVejURY7Tol2RB4yyu9bgtOsTSvfgiIBi +ewC0RYHREQowRtZ2bidhbTQGj39VcpHwU8W2gY4UWngPTurm47QaKkyycTVwxre3rPaHh+WU +6xF+yzZ2sBNS7SFWBtG+HtOxK8m2rjHfqFZJyINhZKwNKunQ0qQDthZY1ZmOeyAnlrjtqbBM +rrRAvh4A78EZzVOLLr+G/srxFxyeLJ076ij+x0ST5W9T645bAbC9cWdJQfYSd4l3KH5oP0+J +etcBPQubD8HDyeuNxxvXbhOBana5T2XzCLPXK5JdudKoaXQFQg1aWGEqXhypfbq8d4YlB80Q +AiW9871PpEIqKxuqHOEnrkY4VGrIcTwGzlJe/QMupK8oEA2N15ja02a/mjgN6OXjUHJEBsq9 +CE2NuruG6W/wExJ1U36UbCIOBVk9Xzd2FplhjxV9kTbt6gT7udG0g/NPIYOJAhwEEAECAAYF +AlOJ0nUACgkQrQkgCBGgqvRrbA//WXMXRaCRSgW0LhZEKBYO/Y+Z4J5VHdV+lOZqPrQqUd+U +u7we28Drv5ibo9GixbyVPePGpbN0QarXhKtN/iTOjwhdFfAcOMUfRGOSjuimHHi/3mSBeHde +S4JLLA20JPNwQNWUG3KJxGE7yfrRZkh6Y15w+mhHpl9ZkvLU1kmoPiggWqDVBm56dV4+E18C +Vqd53+NTe5kF29avyGEyH4W3tJAJG340TgGQpCIUWLlL2qpvj4PGkpD5FawiSD9D3wl9FMsi +WDk/exaCrFgZtBzaH6Zc35VhZNyyJ+QzmtaJNJPg0t8HR8GAxyY0arB8W5V0vnp59fxaMwVC +MpzKMS4jTvVhcad+Gb5muzyPtetY/CqEDakS0llNEZrfm6SbQzpcHSqgeKEjYO9uM5obLhom +3FtDewodLA9YQgs6dYrhWP9vPer/7aLUv/DfTBrC3gza10ZUHNB/t2zBIYkwmIfQ42zdMg7d +5Yak0qVCtsn3GqZR3LlyLI7BzkD+ZWkSDtCLQyT6GKuExDPsfrY6SF3qiI0tdrq2svDTxHDE +DsxPCJXCb5g5ol2zY4h2+7qVzKyfZF4FbqoJcA6v5aK+E2sOfzqTGKnbC8fuQXaj58YuhxNo +HnBXtXoU88ZpA48zVfYbJyg+eH196aSFgsEmp2yx5AC4la9xpcksYDzPXntBMNSJAhwEEAEC +AAYFAlTOpTYACgkQLUFonVGctAGMAw//RElFhP2LXk7AZ7xR9mQGy6fTQWQHVvxxRFHssSvL +V7zORZSuWfceaCrFM0P02qnwiENsk9irJNq1gPXawyrs7MYYSjUnf4f6jNftkB/omA9Mg+gU +Ory2OR0Jv6P4+WmETNUOxieOnQt9Nus+pCv6IemmwEulFa1hCuokEq1WZ7ODrUfwABL/i9Xq +s4bWmQx70umTozqHaorlAFlMbPEwyl9g+a4LpkJSfPHJ3e4qlzwqArffOanU5XEEaReMVn/V +8uemRdrSfUx8EtdLA1wMKQvYa2J/iqigMSmxt7CU0FmAK+z1bUNRKfPGJkSiUB6KM5NRuUPM +bdOFcF9V9tz0hxO0ow/dCFRVOk5yy4ww9UoZZuQ5NP0GUOG8cA8FM2G6W2T9rIBcZLEIea5C +3cvl973sZoAt0DxhNMFyOOLxKIL2sNxv7zWd/vcmf72+ALPqUt0PJg2FhbWStUVa6fmKiX6o +XerJM+Vc3PzkPjyvHgg7exPjVhuS+nhQuzWTbeiJPSjWEbxrjvOPKMVKi3v6gHCNp9n1FmB9 +ZSs+PJ3g6F9vQqEM1Sk7DWqljdgWpzIs504EhEoJv6BS/edJ9kJarvgVFGIFnCjqGq/au7gh +3LM+ITG4SuvJZ05lUGmOQg1Rsb8ZpLa0ntjl+94hVDVvGnirOHSMZkfS2UjfIDEIlv6JAhwE +EAECAAYFAlXRuJQACgkQl7qc52GgljsLlg//dc6fIcXzNwhl1sdYX3HrapsqzhpN7Gzl+0zL +2MdOytYZyBWuO2+1w8l0UIGaMjGefhXYXjFxjevSN6VYOgKYS3R1eqC54wTAoit0jM+0pWs9 +of9H9pUlguz9BoFjVd7ica/dgouDsDFC27ZJfTTKxmsq9Qbq0fiwvQYnyDCnuuvVupxtdGf7 +rK0g65Mi0XBlQ6NFs216dl3XUqUBRd4hMcvx4Qq8kpTSOf8jzn+rJAdgp31ekPQ5lPiDPkfi +Qa5NwsJR1kMRS2KIA9tAaGc1B6gMWMtDw1FpuZdc8zbYFC8WDWmEBEzOlrUqRW790tcsC6uM +sy7m8rthU3Mjr5+vU2IHfI95hnlD06JHGO1z8+33woYjlHBFz+quLMaDRp6Ba9H5RBExam7g +QDgp5P+HT/acmYV+3Vn5XboPd2jss15oflZ+lPL+ZDGOWFWxLLhRVyK6JYsrtqj0IV1uk6hY +/BltQF8/prb5Q5AVsg5NRB92i9Lnh0vOKwoN5SU5VM583FXFgS5ezpOF6iid9Z+2nJxTwNsP +BbgTl5YfYhWe+qPf1tSwIi8hdfkmImlkNaI/VX2Rm7Zt8NIqc5Lgcq/L0fxgym+SpHoESvcJ +mUrw9LPjgzVe4BVQSOGVKkeADja5cvgy0KubFhpBbqxvtdbH+uZoMFdfIU4+r0fZqCrvmRaJ +AhwEEAECAAYFAlXVxWQACgkQXudu4gIW0qXiFRAAj11gUaGUrsv4tQrhuuJxq1aq/WGXDUOZ +h3j00y2xoR5RsrGnZ9+QY764p4L0iP/gvUnezqbADhga0l0XBPr/ewfuPQPhtn3DqFXCciLe +sR22WqKtY7L4IkelLzeQgqepwvzuxo0oyl8+IFQkgOXuwXTze5DGGHjbDON2ulZx9Ud/a1YO +hMq/2l1If0P4q0WD3eBTFELjKoZMAPjvQKOJg77hcZ27OCq27yjrPj3EiwrPVPJ0FJOG2gpI +IMEgHR8C+08dw66OyDTskX06hVeUXFusiSnSzrHAGf7qr7p0GMr4VmQHMgLn0yY2ZSk7fw2S +h+4E3ctrKaH06VP/flnuq+CfAT6FziDqrjVF1nUPCqHwT9pSqEhuJrSZX5J0TRTVoa2fGb2q +gvsoupU9V+q7DwQN9EsM53sGuw1isDE/K/sLIe2Bx6OScWTFmWpIGD8oWg4JXDx8b/A/XS7L +mGk7BbUwZN87NJ/HJdelZ+Vyn54Vpp6Um5U8aOvCzrgFC3rcj/Z2+JyvhDHGhV/HloEj/Tmg +z2gf/3damqIFXbpCZKkVCr6vLh/PXJnYwELxi/M0axAJXopp3kzWs0u8fNo9cxh1Hg7D7eTW +mOuUwDg/v73u1iLsCGKtnRv8BfrsLVYyX7Z8JHqUNWhRROIJ1gMeO7zh0LchRuiaVVQvw7ZE +quaJAhwEEAECAAYFAlXXSSEACgkQ2a0UuVE7UeSfGg//bG2uheoX9y/20TOixfvyThnz7vjp +g2Yq8GkrToJF/8aa2ioDWXcKP6JJk/ok+SBnv+vToALv8AeE34g9U4nNm6EUyw0iiYv+fvH6 +RPTLoG9rpp53RCz2rcwfu7t+LxAZzoCIXZVgRvfBJeaYHLzSOU2EZQWVhIiJUahV4akfPSG3 +k5dSQatX2KqVBZ7lwbNxnRxKm3KRabq0LbDLqWd/59bUQ6KkiiPQFe+4QUY0WUitnW+ZDKed +YRog/G6ZcvCQyoq9OYGYjlcVC0huISeN3J1uTNLwdwTqmfUWjRqP4CCwqJiDaIX3d3Uy85Hi +8TvV2qCOyCVRKmV+tFoL0quozofWo8XkVFxXmHCI9vIrzzNPoDG5RrxvOLov78dAXsk2JutT +x2Gc4WXG1DTKUg6I4i2qvNxR4nDGByMNbpUQADHEfQj+Vq9op4beEuNlgFx4PuNFuPkCnOlH +ezgi3gyXM33uNO62H+guCePNi/LHUk2buSUOQ4eD414G54bYkU7X4QJ1YaFgv0VDS/n+WSx/ +Riul23X+1EVJ+aOgLehgED0L+nM4Kw0vAOHS6l48JYl0+NWSu1Y9ksPkVss5SEsElyhGfu7f +gCBM1HRTEZ/ACdb0McEE+cvORM2/p54VOonxo1P/KVPtUEjKmbD0bkxX9POGMpWmAn5rv8rU +xJEp6NmJAhwEEAECAAYFAlXbARMACgkQ19NALgEGYwyi0w/9EqqZWAi1R1CYTrRfxsPuO2/U +zPcK56vw+klpmCmPNB+eqGzZr5yod6i/lKpKot30XHX0rCB2M5ORn/VS/kcvXGDGK6mqj8L5 +o+lEfuyd9UO/lOx3DCTX/Ax1QrDmEuhbEG5It1al2hcEEjw9XpV9QHLz7t68z50zFW97Pby6 +BqmzYUk7hfyF46hmDVTxSzPlWXwNnZ63HOCbgsgzdjSf1lZn+aKC9mvVgm3EIT9OypeubAL8 +RNOqoNigDyRUoNxRiJ4pgPm7eUFCUFRcj3KfbitYYJIYDuIcfgwNx3tkOOUuefFR47ZFX+wA +gL4VjWAU6Oe2V2PDe9EhA9ZPHDXZS8QoPUSNbc3FCWSDV8iv+1Y6fB/eEqX1X0dUbABbQvQK +Acev28/MzCBjnI9SNP88izSJQ1rz3lNXLxwIXp0/QrRqNNtJ3KBol8SXNM1ndNe4rKmE5mNi +geVFy21Zkspxaya1H13dUDXA+flr+Gk9zzeHeGPPea5BBI0DtvQClJDdHIBP2IqE8ILtOVqT +hr1C4wohegMKR1c1ZB7V/x0HkwbYj1goPs2+p7Sxe8P2qqNDKuEzPiSPhdDcMDnKFzB1ohBT +uoU5DsD7jacMmdZWYD7t8xmHFXT+3JYplm9DI1kOWfEDntTBqz12q1atQMxQs2IlVBNslesY +l2v/zzqPk16JAhwEEAECAAYFAlXjYdMACgkQg+fqZpoZy5Th6w//TteDhmrfeNOGSwH6/xAj +ul4Ue9GHeH0+ITSjYECRa8V4hZB3ONttnPADqlJfpfqW12v9VcN4mqnMvNg0Ai5Azh8pi5tI +ne78Altvnh8HHSr/nZwN5WweKWUXG+eVl4coHT5xHNoTLPNaEyZinT4KHXoaA8HcP1Jn6Rv9 +ndTYhQVRX14LktiUjnmYygR73O9n5mxDv8Qpi2eRaNjQ952BraDUx5KcQAd0nSOSfxh1mkTl +EmmfxZGVQTP12sU8GivRpRufU9TfSoN/ZNBmZ98PPHTiVkuRfHBhPQWbAK1LPDf04KrSVqn+ +k42xsWZfVOF1KLrGEk1dN8lxS3Q0BACqr2UHfKhtGMrd+LsQdOou1V41g9VDX8M7JesomtQl +Hi1w9p/+8dyaUmH68S6iK0D16J70aJBwvf/jPO3WuWDALEkHIMPQRiWeupOkTthzIMGRyjew +XQQdF/4TDsUs2AgZagTpiKsAAnB3TEsLrWklURb6Tfq2/fIUNotGDWeYZC8suTUn/BA7NIP9 +gsfT31tcrMP1BPXLomXnvXwc5eBL5sH1ixGBV6PtKddjApTTs/Q27PXbGcPTAvGGfT0jSGT4 +j0SMmzYW/tnrYl6C+eGa90bY8JdlWq5p1OZGPGP4UrwNexkJMZS/8Lsd65bssb5t7Jff5IxL +4NJ65bY2Kdygn1WJAhwEEAECAAYFAlbEimEACgkQUuRdKao078WEmA/+JhCXJxB+Z0Wu93R/ +27upTT66qyo2pPQoInJA8KYiLz99gxGoHjfXMwbibBSGXaP1uyop7ykTTHrm8iilLoDorwxb +rFph9W1gIQMQ/f7GEkYRkyuout8AkDogr3Mbmjemvq8CDQW+F1T1M4GF8J+Y0WoLpazlveh3 +Omv3Jk0+Rz6gEVZdmR665unC2AX5AGteo9+YcIg7cXSpbVtHk7B+rkuoKHVYHa9eSGEFKNV8 +INdax+lurSq9xLZAJgxz25XLJUwh6cd6VXygqgoZb0ZwODeu6A6hecd+v3a6oALzgOF0tmWv +vE3LFFiAqIK8vhMdcFrTIXE52QYO0HypCdnq8DY+Gz38+5BDgPMcN2POV/RwFoHb9sXT5gCR +kvGQyJwunm0NNKoYMzvy4eCQxkOy4acNFjHrp3PNWFns99+Aec+QUKT5/J+WNRY195OH5SUa +giWtr0Ez+3RJETAJezKjAAbPD3Y4Fg7+bV5Ru/35sq3zIq+O6vbu6/U5dUercMh1dD2AP3yR +n8HAKLA1fPsnaHLj5zpcJC4i2aLGmUrK4ki9WKxEbBPwv7gjzZzF/pDMzofSRs2qbUDgC8Qp +KMqDeJkoUQAjWzf6ApKw2FGFm7B/b0nlu7O28tmutSKkcGIGJnmhRUs7xoU/o0Bwbs6swhVo +cF9KKuEOzoHPDHe+3j+JAhwEEAECAAYFAld4KjYACgkQtvHYPprNnruF5xAAhtem4TZhyl8X +EYkkDzveUWy6aCsJ+Y+c7vylLDeWDGLMmifDCmgVeJpxBDfZSvDRNXuAP3dYlCWjJronGCI4 +tI4VGw7Um2WX3W17n70aO0z8z/ro1iE8K/vpH+9EsIgjaSl8L81f+0AMRU/6TdZ+F9Stgg2/ +7o+7K27EgCyhCFNfWQRdggZj+9L6qWJBllbSi0AuG0DE+tCGpO2gr7eNPiFwBAAZikF9K1de +RUAg5L0Cp7f+nPNdkgfPEn1wWSXBYvNwajxA9S1rLVQ5N2MPfRPR+hs5vCIcglQTPLjNXPw3 +Z2XUnk0LSTmF82uWqh8Ks4ZpfJ2K/AyXKNSO0QppLqVrDMH/93vGkrH+Tdvt85AtU1SHZFMr +7RBeTp95891dxLD8Mkyg+Vi+JOl/oX7H/KnyNl5KnLA1bbQHojMOmclKo7GlAMWm4nAaqIA3 +oCs3YF14o+IgPU4wQaXqnVa16W7OtB3sjrcXviYUIswoTvreHmOvNr+Icr830E2XoFzY6LdG +gf0k3AQcfAdDRY351h7hBoKmci64AC3pVcqqOv3Bm8MBVIz4zGGc0Ljn//B7DV8PU5WtP2Sm +ccmi6faKqwKEpnPpshqSrTyeYoR4/oz1Khgi1R1G9C3o+oih451pIgt40tIXLfEh1M8IdRVo +Ym2KgSTQoIrit61AoVSQL9OJAhwEEAEIAAYFAlEf10AACgkQl9BQA9pzGhdUng/9GyPRfboL +QpNXK28WzcRoJk76VJiTyVvhKwc4eWWFpu2dfvxqmE9p78YqDi+pmU51wMSHLziYyboBTyOX +ASAibmfclfGPuGTMHGkvoT3ElGkE0GIC3s/cWNCO1i/IkV7TmkWEiF9ei3Dh4BDPG8hHKK8m +Vljl17a++t/CHdBSO5ylmTtz8gxAL16spNSxiBQNipfKVqTZQQdVl21+mXDCVgPRQodJpkED +Pfgti6XOnUKPm8vytfasE1/0TuAwet9Uu64/ADaVx6PkzMLmWJo8r08fCjRDwdeI9Iixt7la +iu8vrHwihdzufcrD82l0yYY5yeCfN5hqUC4DZr0hCNmB/JYz3VX8rprxQ1eefchqibiJcFMG +oUQG39/o8FhjN693/a08g4JObu5sMYoMbnsohf+1Tdp7szmM1N26Y3rz1veLV7OssZ59xbLB +tqHLlxQiSg1h8w1eZLjfaAru3oOJh2sZowCrCYOAb66q2KKilIulTSHG4VMJBG3r8dVHtSAs +kq86EowVy9gxG0lc5IWe6vWedrgPPVE6Chu/cBV3PbWUzv/3FF93zMlNHJvk88xi70utYBL6 +z1qUGoe5J3yuNjGIYNvjJuSpXgePMEbmgsMq6HbD87Zhgd4bpgtW0x9+3W+QqB90BmA/Rl0w +sHRYt0A2Tt/B55Hs6MyjD5mDbC2JAhwEEAEIAAYFAlIsKhEACgkQFigfLgB8mNGdBRAAtxZL +TOYm/a4P0f1E7xZUfNomF2vcK/byy0d4o4a5DuCHNpZWCs91ZAjxskoQS5/TFgaBhJVJtUri +COrLDy0HYNZE7zaf/kgjjYqg62xWhGDGh99xKlziMSpecsZ0tgs4gIcOS0Y2lGjaLYWbvHF2 +6K9J0KuYI2HwccOBdRo700P6OwSKGpnRt+r2QbfcotMdIyPLrMed1mHG4aL2m8yZttSHxcey +Qo8cnGiXWHkpUyXYk9+8YzTntD+B9X1kGMkndJoMQSz+/3B78rXizxb0jFPpzbjaq7YHNRyj +J1U6wa5R0lOBjsBvTUqsqEPqnV02vh2kB7Tk82JsOESzMFBsag5IlLW+CjhuCtynw0nkXnYo +L/KWJ77NB4iQPCHuX5ClZXQT22RHbBgERSHk5uMavG3WJnXXE0gf5E2eCCLrGWzSiEZXJSbS +RJ+TfQbkwPzXkL6jucSUA8uRmFDN0TVX2PaLaOC6q+NuqMqLQ3Ve1E7Ys5iHpa/FB67z1H/6 +lvae5F+x2+MKMsjyd4wx86A9zySXqvgFBO1xIGoNNvBmXvk9qi/aBX2qk7gVYiq6Fymz8i8/ +lKKmYK+esGJl3QrUE3Ca4SHwD3aKruo9Py8ltIJan41EgOq2bJUTU63O/tZHXFcxfG8yaEMG +wDGLG/bajYBpKY8HMWsF7UyEKoIAna6JAhwEEAEIAAYFAlLv37wACgkQC3+LYOPt+uMlcxAA +jpYwNiC2IjjRouaUQe89X29IXF5uRLjUypEHNBJBnxETfFalpSOcY1sgCFpJj6PmC3+zAhED +esTC1/FAgM2bSSNEDeD6ZZYuZXAXR3/Jj22UdDulJ6HXofYpUdvfjqvvbblqQqqZn9IncXhr +KhWx7xh9zo2gKeY30O/FhhvJ5YmHfrLxZOKLZ6Df0wH3A4rW9+LmGaGzDLkj7/pl5XSuxdYV +ki9M54C8Fw92vCi4tWJPYA8miW4FruAyratfDIOUA2E+mROKxHi5vLAJhwdZ9oIjWC4dKKp5 +dQNFh8jE+jMGEW/HC2BlKRG8QH+GobOWkA1Ho3xkZG4Of8fXFirVQpuzY9qnZTAail9NIyWx +JUNkxzTYaWj3O8D/9JwBLlXJkT8XLxYu68FkShz3tAYO2GE3LIPptCmmWE8IlFYAqrRFQZ4j +DWsy3gRSrHfg6204hsGSjLwc0iOn/CJeiGIx9ySigC6WeAYMSB6+3dQ2TAqeHHLuYk2IyQla +baTGV+c9d3/LS8CUkGWuDi+3F9THH1ttl8j4dNBYYCK1FLOjY0Qlkba4nykt9srY+uhldjYN +Z/CHMsj6eQxsAMQ5pueCV8DJuwKPiubpfOUXd2j+7OvzrddINrybaxy6UFXYUjd/fDcZTYvM +SN2cIxUqNjAVevyT5e+e3iRF+uLJY+8kXwqJAhwEEAEIAAYFAlMDjW0ACgkQC3+LYOPt+uPR +uQ//T5unQ7/u4UVhHPamgF5wCWwk3hbwWJSC/3TmhQyjf/Pihm37MqTJ2P+8+GA8MVKpW7y0 +UK1qbQ68WFNUqplhh+jqYt5fICnPPXwDarJT2lOt4gDWY5lFnNmtptaaX3maEgdaBLlM4kT1 +8f8hAsqTowJ1PQjYeWLuxYulgEFzzSYdddGZ30T7nZwuQfyqm5/aUPqm1R323NxQde/HYHY0 +FpYS/FioqxHPl1AVvA/7ka2aYmIHYsJvXQQJo3hgnvDj2uC8V/nEwsWqAQl6EsVU9UyhZiTP +D7sN6X6m+jF6w3j3sj6BwckPT8s166efjv6W1eVI/ZFP7J8k+d4NIa016ZwkOXP/PGmC4U77 +JlpoDZwLbphBZXHHSNkr0L9jWZQkwm7R9UuV4BqDXaGoqW+AbO6h1S+PUScRPtacAoodVwyD +QvYlQUt1LqAtJOcJI1jg3O+qd3LnCMJw4uZbOOZVEzjBvIOsiOiVwGZ61xQgd1U1M2hSTrYL +//vgh8BYTmNOP3m/oU5ZSgzvRAoy5D0yf2knoKlJo66rBBfM6/Dn7m1NM5TZLVZMVeI3TPy1 +Pzy9EZAHBp7kbdxhOJ2FQZ8yUkO9aKJMqyMyWLGl4zID2phW2SvgPKmljVHVhQ87CSyAwuMe +fRP2Hbbxs6exKOdLV8urkgxI1vZg8sB8AzORxo+JAhwEEAEIAAYFAlUQULAACgkQx+NXyzVe +6/2r1w/8CQBKRtJ1qvwK4BM3lrwu0JZAbvsvxTh/p8oZrw3tjKyf3ONZ34QZ3csT7T+xms5M +E0NfFLd+zj2JkkKKPXJJtg0hkOhudwPHoByiw6zKlGt4UYYiReSOMxtoS9OjBN+CHnDhsBHL +I+JTPAyHmhr2WOmX+NeUQRRSW6+7Uk5JtbL1r6KR+gfIvm0L/byI9RLUbhyRKKL6WPFEoydQ +wNPmRbjXq5WjDce0b/UfDxx0XneOnaJYFv13qocUUs58UK8vK62uHX3STMT0467mj30fATo9 +i3dOb/uWEfFAQnjyKADdyKG0XC199gfY06y8B80WZPldBJ23l8ypaG+/JsxV9uyq/Z9XzRNr +RJpfstpSIVWLndDxKD27mr6U2KR40olqTtbHmPZARrF1K3cnmH4eWjOclCssFTo99GVRXwyz +eVlbqa8RCwJREnzj5M4ynb+o3d+X/jHxX+LU9jGiVTr58cVoLTqlXCoowVS22CAX0ulzV8ev +ALfz2N9hVXPDOVp6Od3uHSvwZHuLkjJKDJ6u+OrbVIGWAP6DGxjGSpp+bWwi0UXOaIM9eBwg +sMmyO+UgUVcA5kNN01uw94051QuDGjasp/L8l1CuM6MSV7ma4ohR7SjjZjcQIRqZE1AN6eWf +YULVrTCjGDMlS1MW3YKe9kcSGZns2wWfjlCW4ktOCu+JAhwEEAEIAAYFAlXTNjcACgkQnDFQ +PG2GY5YqVw/+J7xSjZjnuJh7tMxX4KtyD/LF3tkAHRMNoAzSbrYx6RFb1s6cQhXJQoKOL49i +Qhii0n5Y0tWuy80ScdWiOaxSEmZTo2hIL3fgR+QBylRIEYubC79INGa2J/pYnfi2HQIkzqDU +BAdyVhGwhdExYcyzTiGxieiFcsCt6iFnBTgwCXXau5VSpJyyG2NwEsTUZPSdjh4OEQqutnCR +tNC/7nL6GBk/VJJ1U6pKUjnp2P/vLAaF5bOgEDuEaGanwSPdeTQzmnftMmgIDhB5JYAPa6YG +z48gMdcFTFTjzajsXU02Y3pz+EvUUpasLgw7X4bcE2hu1ANh+ZMxN04DCKUE0F54E5m/WBPF +7l+cWMwt66WiWEM/SW61KsehpTwQeL8oWULVaa8iS9Pv2n8i70sXvNla3Rj+RxiTIDrVdECu +UHVAldCdipmTCle8H4xzX4Km4pKM+7wVWw5lRuNSWipfUdj3fNs3KaoSv49D2hfrzrtOx66M +saHibAJTJEsCG1AjOgKgWpxjzlxbZCufHDoVSri2ZoV/1dNolywfbpxntXbLPq7FrOEa2IHC +KtKXG3l5KkEJuXSq/bivbFcaJCFi+uf0ti7AYVekIe29rqEGMHOupil2ziQIg8lbl8yHdXWl +Ipf10HHyY55BXoxeZ1YZnLyqR4uuMQ5XtqlCo0Uf+e183L2JAhwEEAEIAAYFAlXUq6EACgkQ +TFprqxLSp64XaA/8CFRlY76Bd2Dg0si0HBAI6SRsdvoNs04gcMgJ6t+KSG1lRrBuwsVgT24C +zA24Xfi/VYsRfDqBCbhSMih9nAI++qotC3kocofA7F2Qc3Z+bSuwdOvMb8wsKLpSnmOoMBJT +X35Ijpjg7iLw5sl9RrAHS1ErqAbmjDVhQlWTFgSm55z3nzXSHFdKF88cNYA8dAHDr9fEFZwq +QRnmYiBoW0SE/H5wli1RvDFLCYasqU2tT3R89Vj+mKdGZ7qk8EQ3A4vvCIUsuUscS03B1+pW +uurZ7b0/hl15eLAHhviWkqK38Ne8LKmZo6p+/0a+KfQrpL4BZjtsuws8cpMSg66E2xeyI83u +gOoXQ1jfFN1bjmyhqSe405KXym9XVXFfD9LU4lZV6k2pUhakZqo+zZrkOste5z9cP26GLspG +zIB5JrVCbKQk5YkyesvGu9B4UZ3DXv/+UwL0HrzRAu0SZMIt1c+/hKqw2cEds98oMnPPam7p +XiPuPsE6OpxNyGba/f0pGyHR+fvOUTryOQEdueCZjZBExixDDeZdJJ2IN/PvZX2JhRIyov1H +xbH6aIKRrtlgoaOvCG9pI5hTDAEcQN1IohJvcGTs1xJ2B+8cQJBTHcDBgJSoyvdTR+vzgQUf +gV+3OyKoSBf0vwOJCw0jFnkXiBXJ0N/JtsQNp8TSjlzv371FAFWJAhwEEAEIAAYFAlXeEfoA +CgkQaXQOXLNf7Dw9dw//QeUSuql8FOH7NJ3b9GMYS3kXb8WC70p5/xPdkqTcWQU4TFB6YtL/ +ITM3iSQW/oDAqvXlKM5mhIKP23VDzbjY7YSxXeanr1X5CgU70U1arhpDROHilau+h136jTyO +iwndDgK4Ujprggs9W+83oD2C0D+XLGFf9ZEPjdA+obg1qa8+10UCekWBVvWwEIm3k3w2a3PB +sh4SM1W0Lf1aaS7T95szBjwu0PVKQhi6iUXyPigE2jFuub/6ZaJPhmnpd34hB4OiB+0XbvCC +DDxyCPvAoro3dQEA+jwUO+CiiucZAypHfJ+qM/4SVoj5+7rWZB5JekxxBH6PuQnjf0l+WHK1 +5UXPlT1vXr23hAMkVWrKjMTKDSqMUGEzGVDJt46RWAkksPK9KTP//dKxYEDQDiN9tZmfc6Mk +q7xhW0VzTbpB881qvSbjBF/7aLNoWPiMQCxu5Z7deSH5ylY5zhetg4qmF+M7/OO0JvF9rXXO +0jKSrvezC5CDReza5MCnsx7ErQwqFfRKWrV+LwNFTp2vVYiNwAaVDw5aRD4Q4H3s9TP1/Y7c +5o3VCTDuhXj8L9jvP3J9aqY0/L/FzCIUWMPtOhh5UxzJz+K/m8T2RfOCO4M4TWij1inMHSWN +cGXTy+2ANh9uUWU8EUMZU81WAIugyUzDPgFMP20Ux/5RfJ0cudojNmuJAhwEEAEIAAYFAlX1 +eGQACgkQcKbdFdvarFbcdBAAwy9ypW6Hq87glcJ6ADZHmuWDPA8q8xmgM2bxxCD8dUNpEwX5 +iHIZqFob21YRZe0D97DwmpOHIuzmpddx+HEINYz3G7koofwQpc/LA3ND+1cwJwC/gVD8CEOU +33ZOEGMgonVk3tzpwe9scKtbReiwISIUhs7BklgF9LOQq8HqeCtjJnbuOlXT6uafiuOmHBXW +npZzYosreJ/wTuDaDiDzIRAg3cJXfGwxrunwEupzq6qS73QLOvGnRJH+bqLHDojF+bxFB70G +c9tfkLQwcJQVlV/sA8WlXlng585aX7lJRte9pIBgMcfqXNhIkZPPi4GNg9aY+YxOZcegPLC+ +8ESGGsVuWEMOU8v4v+hjCgU0eCLmiGWGuirYWKJEURdS1QGHQwoqIT+ebwtj1aMQMlnEAUaU +qtL4J6yr9iINo8uL7wEL6BsBYcy2nC0+Fq3i/TByqMMCV7TUpo7RO41GPyX5tcjBTgW8Xpe3 +TbGJQdCbkFn+CuNi/di6jRsPN3vcX9GaRVYZ9tmbdB4SN6TvBsjrObueAE+zN6Pj9Vr/k0yK +kxa18w9kvEqiAlQFSFEBsxaSS5sG3IiDTVvCQjFIgH3N5iatDcUR0rL9aI4guvyMYTyCsmN9 +9tioAaA0+7ETUBNwXzZQdpLVpALYBXvPYkDuGLdM2geOaVA2k0QoOlb276WJAhwEEAEIAAYF +AlZetWQACgkQB6LMPnzDbC8xxBAAzpcI5+ulvwQiZubMDQeX4X+B5R80tH76k5QPQBov7OUP +srG0OaLxf/fN/DQOtXGEPfMc1eRDTjAbDCcx06QO9SftL7IYzmtvYMhlyNupac3DFbRQm19c +9elZVKJWtrGV/s7amwHs5MyepAhPHXd5+xu1IqrnUxvRePb7hkQoK/er1F64D4/eakvOCM4M +ydUlQuhPMo5jSOsWIj43efceTowxsL7inqWkXCpuu4Pq5tsAUnzBMJuQfoXfv6d+8s1yKdVO +U/Hc1gnnqzV7dNsZqkPg76LuQA3mFOFOpXvvhI4UqkBl5ZaWQsxY6geDNMW3hcMu08aTjVkY +AH3Y4pJk3jWCr8Zni16lHe2N3D149K6tM//hiAkVTOe8cA9CRiRXEKLEoLy/ojr2OwV7FRR+ +/h02bHWRuOK1OdtzRsvXvKIBnQgo/W+e7XIknxjBfDCT7zPOv9KuRV/WMvttnKpGccGyTLxO +AIIEhbo5xtLiquao1OQlLpuIa03vhdGnxPB6VG/WJsyr3RomcR8WFyjQhQYXFs23nieQ3Pm0 +xPD5Ig8MoAIYXdqXpgKiZ/HH9GyLoSUHh94HC0wIWDZzI62jQfcg3hjq5Oa6pT+GmWgtAFTp +da7p71BIpfbkl9/IW1Xz+wRxs7ZEvSxjpZYB5FGh0COhlswsnxfCqWX0JZZhLVmJAhwEEAEI +AAYFAlZetqQACgkQ6dduP+dKCwxhJw/+OVg9xQ3lZw8tX07hV9dAeevCnD584PWwndpP3vlh +UFvfTW/yQzmMFnUM53rtFhpbbz4pusavvYO5FtVlW+V6uksig3TzYDy1E2XtSNdkuHqWJOBR ++XHuNt5cr/jMMUG4eSk5IhqsGZS/UFE7WqPYLlDSZoIzv4qL2f7haUk83kAwYcr9HJQQNKfv +mDOMjL4XIbJglbU6rE6MONovXuf+nCcAzGytE9fFcZkHhwkjFH3vDT9fYo6Uop2EWe12fLCA +14wj6tHcbdI5x97OXVQ+lYYG3BMX97fkkORP1jhHaU6kJpmBqXciC2USpp5zJd6CLhP+LWRH +JMHqq/yMPWTbWKaWlt/BppuYhHNbAq+eL810Cs5Roy5ULI++FNCeRAikfkPQvuCJnAlOB87n +ZLe8TzxQgO9BjGBm1T1iIX+Bi//9DrIbvmJw6x0euklW5iWStB/Y6SAOeD1QFrmwNRKEcTf7 +LnxMzGWmkvW/AeNR9cNq7+nCupVA1k3yvwEnT1ZMkK3PwXVrgp5Df7uKPgprgjmOqfhy4De+ +BDGsC7GfgUHnSYxuRNw8cnK5tmH/ndPqMOJyuvXOuqzbHYo+1jLwoj2W8pSZDN79MPQmZlBx +QkpGVaHeXNxOjIzi95JfC8GB5HHJSRcuh3cvdnReU5bZqXSk0nFUjM3jhxCSrYl8SUSJAhwE +EAEIAAYFAlaGtWgACgkQajoQsxwQlRfBPxAAqQ6lVGcMnn3W1bjVzA27FmKxYeQpbYt1kbqp +c0oK6NAttdQj9t2EgPV1Ew/WRlIukVXGgmFBJPBS9Ucw46ehU/IOWP/euT0AptVADbuEtUMp +LVHkReC9NYFwbEZ6+yxa21ZH7jGta1F3Z4UVU9YWMElgXMri938P881gnMtydecaGE8KU9ge +CcrEHWQeziIz4ZaBGmGSgcVEBqEph8YpvAkjTe0AQZ5HQif5Geques++KRk/hMZtyNRvQ+b8 +KZWGoW8GwpV8fAuab0LZJnE8l6a9MwDTYGwWTLosXj8DjOQL5+H5U9JD5Hi2QvVw9U8ueXbU +tr8dysYwzVtRO9nAAHWJs4+Ab/ingQJt3K0IQZefEPX+KXU6eB630DOplmWSvtT4jGo9aYHU +raMAncKYFRpWayk4qbolnGCfBEEEs696spIp3NzW158R2Uje4BSZk+fhxcn4GWH3FvuQekrr +EehzK3xDcXlujU9Ow8QY3Pm3A3mCsOHxWW2OYz1Oln7cTHLtN+q5vmI19xIPFWEw9ifqns9f +/cNp1M4D8KjwRkXZWPcF+stP4aOLixPlcl8AGEkdDj5u+ePdaeDMGk5moIVIzsnT9b3Uhyzi +OXzsYj0hn8huKhXliv6YlL3YQyj84Q/vKDnvBbi9ri+hO/JoFzPb4RO3Q/iKhLeMPwjMgBCJ +AhwEEAEIAAYFAle4eqMACgkQcAn/58OxzNNuDhAAtR8kjovZJm3aVIKjbMeoffnIaRd4KHL9 +592KbG9d+UkrXKzaIFUijHUVnmVo7fg3g3/zHJm7qdCk9LaG1LGyqAKmweX475Jw6cABRTOI +JyObaxLkwmAAV57a1rNHIplNGmsPUZK7JDv580L6sfaXcWje1r6tnA9R3uqLbSS5lXp57gLr +tjF5LvGmwfdyHahWC0g+9Xpg+CA1MKj7iPnOlQGxN3Xaoc5P4XO/BWwOe4mAQiPJ1eanEvtG +qvl0ZUOa3mBv2XV4cWbcMn/DedcXlDuqfxxgGr25fbm21DXBvHRtMpTulQyvqAPmP0B6pkT6 +4oACIftxMLbxPKRQnk4BbxZX6xO0vB+UU8v4M2DxzybkDGhEAgQJRRZvsv4t7+KEfpas8nw5 +OLXhTQjqDktrwf4YYoWJb6fmK68rxPWSH4gHdumw311vGyuK4u3NCWM7bYGgXYukb052Pxtp +TwuHjy4zNeB6lC/xgg80uPk3vjTky3kqycGOEy8xv/LI4eoO4DVuLvEBUy7G7hH4LGn6zk13 +l88WbPeOoAPO08PcmKteEWF6udzwaq2mcOCE0rJp7PHU7NPv6TkN1XSk+mbPe1bQfQ44UW0M +K/MCyf/DOxx3KcCkG/72JIECkwCMyB22+EdCW73qDERmDVkp+yNDj0ego36wQa1h/eHiOl+f +icmJAhwEEAEKAAYFAlU1PzQACgkQFT/jmIIcg5TmphAAqJ/pj5p+vXPlnJyfWbWwU+XbvTps +6DLyQzVxq0V3hAQmrNBEna0K8KA9CXhg8ASXQN8y34cC//2fS46mue5etHyoczIF8POYlh32 +GQ2UERQMf8x2zzDieM3cajvXPp7lhffSbTcJakXPrvbci9QF5l19VfPdv742ge+8sHShRBeC +p7a5C+cDWYeh2dBQ5IqNQ0a+WtqWdH5Rhr39YdTOYYyjtuR9RHo7IjiiOFtv+2g+UA1dG+Q7 +X+dlsUYxUyD30a5jyDzW7Tg5Vpa0QlK8Kr/HMg/Fam65ATVziScZZRoYGfNm2RK4rrtDAp4J +6qq+Y6PGhd2S6O9YUK8uH1nR8InbRRZSrwPvnkmSbWamCd7X2CpIiFdTFw82KfwsUW2LMQYC +nol7ip5VaexkAhM2HPT3Z0C3mLrhJ9ajmatYBNHZBZNVNjCM0Om0+kqg0VOUAWxoGL8fxbWm +N2R6GULxHWXlsfIulFhmhpbiP8j/UhZeAcZO/PToFI5sFSCKs/FoABKzdPcXGPLBWuqVIbYZ +xOCqutV3a2mnaKzzgW3/oFxK3aYHgf1VaAG+p1SRnhZHuIjQa4vQPHL0sY21IK94/zXrFQLy +gkTq+NH4QbtzpPKEzZY1ouuh+/bUz/kvofC4n3uUg42MWgNYEBmVtpAheXoPaTI3eTUidgP/ +ZyU2wMCJAhwEEAEKAAYFAlU2IDkACgkQksanixpPiDN8Bw/9GU4fdJ6vJIDE4YkWuKiWYURi +/9I16ih/QVL15udITSou0TCpj5XScfEhOpJXT68zbMLdPZXVQwWgSQUcN5CAyeO0jmHcg8jJ +xzLimVmIcJVh6HwNY7PLmEnT+xFn/6xUDOfFFi2q6EA8/HNC9jaV9bBUlylBKpOtbTsPNSoP +KU8yxqCxeksqHxaZyGbGqGgaVWiYzkqzjrIPWTBcVgR4KEgkUD6/2RlO9q/OIfCzvaETCNYg +lpmSU75HS3CosMNVzH89GOxCqpWszCO76pPB0bEtowHCPooc3MfE2J7GaU2VitEFKHhS7Uxr +PBbFeTgkQLt/3Z8sLVmGvEoyQR2rtDPJPgKomUWGjpGG3HFHaECD5//Qule4tR8WyhS4Wo/z +SbXBXtQLwavOw/mbya6+jbG/QHlGndm476f5S7/k9WcRQ9YttjkX9Wy8ol3Ybxfs/AD15GIV +uUapPBczo7/VDV2c+EHuwv5MXoXRePV07IZEq9fgpfKwTzkjDTKFgZZ2Jj+AePYrUYtECqVS +TkTaYtp87MPatbtf7hmAEmCwJrA20fZ9XVe33IvhXA9Sh/qXuyQpi2BsuIIsgz3nqLhEeSM6 +tgF+NUTlw/4ibmnCuoYgrL2ZhSsGeCO09A9G3ZL96YAejCWkYkfjdEjUJabqtnkqykmjM2bi +yI0fowKyKQeJAhwEEAEKAAYFAlXYi60ACgkQgK1zc0J1va/s9w//TmTvoK9QSVnaLRlpBOFy +3Ck+UQWu6CERXAMV96Ce2tI4L64vSMEtIo5nuVBfByUFdI/+awx9TajgJGSdmkObz8nuhu+S +AmkkBZ4nahM0lrUsTJLW/Fo9pE+sgBT/wsdfUN5gBd9G5GqcNa5GWbdJZzGvOCrPraWbOs1J +LjTpL8r0t26lcmT3TIdGpAjk0/MiwPdQSWuhS2l2q+OaLwBKBlzwyXmtmBlNL/V6llOV/hG2 +qvGxKd8UWEwa+3OHB256gnsRfoifqRgReHP1USM/sczxMwz7vlX+L6mUu7ZnJkwdOD5HzI6O +IFqZckmP2Umvacdn96edkt8wAqOZvRcGdw7ebE017STWjQNBZxTaHizdfgntPbE0cFgpRzkH +sMBJGN3RmszIaagL5o92cefg0s0R9JlRJI1WPaEnv/a4UHo5S8wLz9i884d6oq9oVYhTKhAJ +aDCXFEWY7XlhD/eHKDYeqrSGEtU5sQDRDdN68ZJuw5g0cMOQgGnKtbEdejY9UZP6exVAJusB +j34NZyy+TNkOtdsn3uiTeIgcJOOEuPC7/arnKfB4Zxxpk06BciJVYrbZGWw5YTy90fNpS3g7 +a4gL+ctZrat/NEjkW7swEiOAq5ImZlxpcyDIQg0M9/TOo8iH9CqlwakznuEoFmo4vciJLAzu +fTbBCHx0addU0MaJAhwEEAEKAAYFAlXgvR8ACgkQYK5C7Ek5c41IOA//V+iXZ/ScxjxVaaBh +7Blb4zL+ctyVuE8Yrw6vtBL46/zLooEaSwuPXxx5HhWF2iJHW0zZz7p884FruOW9IwfFKl4B +3Dx7svrV6a3jNIoG2aPc20gPa12TBUSjjHrz/iNZI9V36tTydpTOAlYjodK1ulzVVYKbAtJc +WV1GM7YQBf2oSNDN+bgc/cQHFWCcyxf1M/Ojh60p4JD8BQQgigl11K7UrB9TAz3VPeSi7hzL +Vl58OOAKD+MLPZWWcX4miUZCdHm+izVtIefPXJcTRYRyZrsDqVM8xqgBs3MOhBnS9HPHWRyB +tSIVaVn/H6VTa6e0merQv5rsoDU3sB5uE450kaHXjZoe0G/U2qSEIFB1C7sm9hdSn6rDNMWY +mXBvam2RBV81uBtP5JqcIjalN0NfzzeqLxHrsrIBKrk2I5ZankMBtQO7/Wufr3mMTTXDUnbF +PBUBQM2Z+GXNfUARuau7pzuvOIMQ2w4g98UgwVRiuaLcSzbj9aG8F5jr1DTG/0mTd/vDLJyX +RXxN9Sz//N4pTjZeXr7GwQtjNeQ02HuGqoIb1lkV5uog7Mz2DtpSEUazrkrWPnm1nWuy7Oo5 +kGTBq5kDbYeiOXkB+X0UbC3RH2yteIHQiLAuqtjd9Qp04qJW1jo8hFsFejgZvfsvP+vJbzXH +my3E7GYDXrIcJXJ0NsaJAhwEEAEKAAYFAlXrCmgACgkQfq4mQYHnc9XARRAAp8bAkzORAExz +gEneKlQBtiKgbB+EyO9j1NLwea6S74oPpegOEjHdZh3Ihkf+5GG+/ACNlnJPmntwfaYwGf0s +8l7239rcGGtr6WEJnF7LEyHTnx9xowlOvJhhtJyVm6WuAzSYBE5p/VVIv8MnFF/0hkqIInQg +AxBtWcpjSrZ+MsLOxbjkVJ7rOJEzvAF0izy1/Lk+dX6lH2LLprVQzn8p2ddqnzhhJF422Toz +cyaHCUxE28Ujjr5pTPWKRFVfFO5m71YOON9rhrGrhgH4txIRX9NaTiCPZUluyRisBu8QKy95 +/M29rJzyFi0AiMityhYtgDld3o8hJCD9dUvYMMcwJvO7dV6o1L0nmc5OeY/BNa4TVQ12o1ed +3PrajfAz9g8aplH4JWAeAdSbtVUzSxNbLT2hda51oMicNZiVmpfADmZGb68E0EsRaBsvH3d2 +CKMDgiCPALPkjCVv1HUc52lG+F6Es1QR7BELHVY0kQUKpvxzANZwJAKo+ajnxO3L+/baEjg1 +UsyZSnHJid+Pe/RsLZhkezQUil7rIeU5SUlmh62FRqFb1LzogJqC/j0Cp0QtrtJtvdhwIFQX +cAGubx1381alIMMbcLWcTfFzWxQS/PsCr4ZhKWxFQcZT+c69Cw0RoT8KLoejKNcexyXErh+k +Za4QnNzdR8bI9eYVWuBKn7WJAhwEEAEKAAYFAlX0o5cACgkQhpgcyYnFVGetKQ/+NNhj31s0 +gSr4xNwSlmc2tA2/KRr9XHKk2SbAAx+8KWswpGMQzboPazu+sXwm5heV2vM14Z3vyjNsohSF +rUcmslL9ahBVhko6BJUFWd+hAv99/Gv7oh3en9RhD+bA3QQ5zGxp/OVGzApuzbQn2oGikSo5 +0AKAwV6elvHZ7rCoBsVOQHpgzatvgdiOfpAyTeGPmqV5hu4Gbs1xLV3njmk6hF/kHSne66VT +S7K0bEyYTNNgNHfbCsP9blgfFLr1ZxR5RUWTG2/L2c6St/A7nj+jMHXWzt6sl2r22tJjQPlQ +/8QiOhdT4xOs3L7vmMaMLjKiSQwsUtu4zMNK7N/b4CXR/IZ/bkkYHBlRE905QXM42jqG13Q+ +xKfbC9zU00OM7RyNBCp6i3BIkxdxrdisPRP4zZcmH4aOAQrgbng/0uqW7wrPFuPHnt/ZU8Jn +BduYoB/Wo/G9UoLc1SNIrAos0rAd5Fu8JDAlsklEhkyszXtyYzaUPp45ZvqNxDBW3fsw6Xg1 +qxZIf6tnZ26wH2w7D1AZWZrTWUfGmcjPsmQy8u0oXdcPdvxvhrH0JwhEFlHqK1MCbBtgEQgi +O4T+zp1pVZHxXPdTh8byciGZR1VmpNOPfs/zVLfaNRP7jm27qtr7u6xkMTT/YW/AH1q/w5I3 +F+hRmX9AS+segbsvrT11z5ltG9aJAhwEEAEKAAYFAlYqCyIACgkQe9GDIN6t+hHq7hAAto9t +g2G8js3xm/a3PN8uPE2+fdM4sUCssKjOlaX+3uOlRhwdsnv1pqDGhn3/dHNbE3ZLL5VJbggN +6t+s7BWI8EfEa6FERi5rSqELvd69pZCFG695T8qLT41jeLeM6q9YcCJQ8fsJ4TI8hn2XxPQ9 +arhHkJymVfABvfyA66/26KZqzbOxP/vdDEIKS+eAWXD7CPV12uNzhRMIjU0+a1J/wQH3uWmM +0U2ELM61/k5SnAphrhKioVnp/7shibAplBvmrXOk/3X3kXkOHJMyjJDbtf32dEM1Kxd4t7z+ +LS5E/RbcEwi1+EekvNhqBJISDCPU0oTLwb43b3R5YaxwicDRzMjLvkpipqHDUZLbxipWvEKs +beClpUuBlgkkN+ftRj3Vz3TwzGLzphsc/mnYt1vgPqDBvhRr6VTCWim69bsmcHIpx5JdfQSH +ALBOJZCLcaZW7Vj3DIfHsOuL7YhSLzFeTny/42ST1KpHl47nMTOTcF7i6OvHTlsnSgL2dZeA +6aGmG31UYrQYGqiKK6j7nYcmbMIOtubZde513UoZcFhxEtOk0pazrKHFjKHoqTq90eBHHZu0 +3boExeAxuQ3dN+Okyrd2Fdw7M153+uCz5LLR2pDndg9Ts3cbhEvKh0JF0EGgqJme/BU7ZtjN +KLuRm3Huz/ooCIs8jRDq6DOsV4wzWAyJAhwEEAEKAAYFAlY3T+gACgkQ7UVnjaFPLNw0NQ/8 +DN+YEiFlsPG2Z0pXytCT7Bs6nw7+l1HJjnRx9tS9/+vS4LD0wgYUdgr1i/r3uYaDk9RqYw+6 +UnPVc6i5Wl8hmnv0ontDr+dt3g1Yzpd+30zRXnxeGTcuo0sxiCxpSaWxr2HXwSv3a5/kuC63 +Jqhj4ec0+Hb6B3H0aeusJQUbzv2XB6JqVe1oiNBDokc1IH+4OEZSrH5/IX4EDg4xC6SD5w5x +E07A8Sy8kXk426xamEy6JWGtoQfTGMLGWEiGrX8Z26Q6FpR77UXDD78kro//dthgG73fbHTE +mVfuyr/fNV+fcgJKRhwsKiVUsZrnT4b4qaskHXng8s92RvQ4q5vztLeOiEppvLbwCl6JF1OR +tQNSeTCteKAKCfEvfs4xU9pHkQKNGo1IkCkMfaIuI8tKCgh1WK8epNC3W+8pxOQisbQrZ0dm +69BkuMPd816hEtn8v5kxsNptBgNAfk7PDSLC4plmTpwgFkLHYZdIMrhYVVF2v567OmDlfI2U +yuB33rK4pgLA4k27Iqir9uhNF13+J9+84ONeLb/rJzW/9NvqWbJ3B366Pt5Fs6/8GtLjSZwY +e2xMNVMHldCfbcTON++TcOFXWKmpw5pS6ZqjKjI//n/JxsdP7fjrCtFqqHhtTX3Jo++aXtMl +Lt9fDjzTO0yrJQSwDLq7wxSQ8a9DXLr8LVmJAhwEEAEKAAYFAlajRd4ACgkQcagC0LzRvJLA +rQ//QEmuwkj5oiwGKIVrwQI9pOYCGzHcliGCvcCGRkT3eYoGEryfeCucWqQ8yH/mAUuCh427 +HleEJZiCK2olf5r7Ca0miRf32Mha51rx0tHIN9eS2LpasMh0neCNsuiKilS2MenfccsACf3M +0jAaIk3tCkyTwyh/3XBLT69UB/qRU/IhOm9APMdUQHKvvIG7tPqt6dwzPufl7DdRBIyhU+ZR +jPHrClSN1EgrbxdLCcJrGGcm7+uvGmOxrySyITWI9o2dRXzjfEhvSzv1xo1ZjIK+JD4dZdsH +20/lo5oU+LrcIT5Mt9ohH3AAFJDGPHwi+6ZkCJMVzzIZCWJBAM6TlLpjeVpn0m8FuC27aJ4S +PF3psmFXaARUncC4pB+kMxyCX0hNBRvnqxXFiwpEFakLATXpJK0+LICUQeMV1IBuCsAbCUuh +bvRV+GHkuqHteLFDOUqM5c4Z7nqcALuZ1ErEhMPCOOUGnAsUhOxCmf5EmHUR/0BQ4hah2PTJ +kPpHe8tXhNQLQDZmYSvzfEbsRTLV3EowbbkEjuCyou2STenFg1lPiE8KnPbr30Ggl+/vTOuM +OtOjTz47QYMP9RtsW+g8bzNx342yGlJwX4JqI4HeUFah6DnkKWap6d1jrikcrSnRqAuz8C3o +NSMLlPbOCLcOlZ+kxOqqXr2/LmI3Lt42+T7EuTqJAhwEEAEKAAYFAlawfdIACgkQ6eKN6gCq +VVbLtA//Y+1rQYRGC2kVhFqi1lkFbTt9A7xTXP1WQl5lGqvDy+UVzTF4yAFQqWl/u/GdNLAp +i/IciThoVT0LkwKDks+fxW0Tu1kZ7tJFjX9qACqyWa6aYxX5cAxA/IRyfunSmtbKf2xkUIK9 +cdL93xlWI3D8rG+xEFLr8xS+LhSD+7032VQDniY12bZ3Xkw2Oeee5QLatMB5hDe1/Esu/GNz +0aGiDyiQ2kbXeQ5C1z7awOaC9z3+kQP40FCku5Aqgoe3F5s0L9uMuaW+9NrOCoaaXPkOaEXU +VEaRUP/Mi8zHeerawOZknN22FNtGXbQ4Hv4rJRxjR2ByFq2DJxK32/AMwZ4xkKSDghvnBaSv +SWUZF6j4NSf69d0t071VtRiyo2ofdqRp8Jo+kRAVESojdHvJdnnLKJrr+uih+C1NDSDtSWcX +Rk/M2ZIHUlKHQYHLBPPxyKHjslfuQGe5pTmrhTNHUS6zQBL7fgXpyEw7iWgExVPyRD33hflq +YnQS7Gz8Z0T9R8bHVZ7ELomn4r2njknFuao59bmiXUw6PI5fA8pjx3322Oqha2LuWWCyECNg +5t7UBwFfrdz4ydJI1VOH44MbEPODDZ0HvrCVKMJNIVeKRIVTH5UCWLhxs5nU/3zFo9ONy6Cq +u5xK15ssQIinNjorqykooh7Zz3c9bscBE+u389ZEN4mJAhwEEAEKAAYFAlb6v1UACgkQl5nX +Cejc1pDYMg//Ub3N2+2QTkxHPozKpIw0la7aBqCAfa9pN/gABx0c+dvyTK8jt07C/LIT+cvY +QVfF+a50xK0m/Zkgd7lLP6cL6QSDK0xJioC3qT690LwUrS6EhK1UkDv0vfyOGpNTy9NDYjES +pQd0wQsgqnjMTdKj6JsaXBiBOTQ8v+jfAlz+CfQI0agkj1X1C0X3tPNjEnX5pJTGpZYSIsCQ +HoL6/+eKeyQPgL1L5jZnKKt2K8krlCPNiMAxSSPjIV6p3HuqMvok2HtBFijlcg/963FH9cK3 +Hy7a/H3eivEjLCadURtZ47+ku1MOHyuuPjmK20SrC5z3wxXH4fzxrELgeCd38dL5TWJhaf8y +uzR2D6tsu238aU/+998f47ewqw19/O70za2VZE+ZClsqmMyReDuu/g/D8gL1AfN2Z5Fwfhh+ +cuLj1yL0cf9k5L0Idk76cPYjLeD8RsoMzn9eHZ07dKrk1IcxUiJLxEgfJddQe/+DLhsN+/fd +w9dExqJWySoYuWeYkqdd6wrlIAErGsX2vP3OVy6iEmKNaaxvHDvIGqLmuB0lYX1UNtIWELYA +K40/nvLdD89nfSopofbnoSSTCd+F+10dAaGltHI62OtvxrRS8R4oJThykDznoUvR8dwTrkJt +pOwuqe8Rr86fGUFeG01FDoeh1uBme+kAFpuFNpHgpMKh9UyJAhwEEAEKAAYFAlgypHAACgkQ +LfSd1GDAGvQSsRAAkcdvPaImEcdp2ys0XAm82pCpxvr8IgsT4wZybolgU7rI53QcMQQIUxD5 +sIC5scY3SjteofSe0xNj5nwJmqpjSXL9h9qlUEEyE4ERGJBZebVOhsHBKaD719fuLzTNa5JJ +EN1sRWPEVdevZTP6KsW+N5H8tOy+O1JiGQIgrBZpwP1Fsm80iv9Bxqk7SJLTuHe1CpkNjjNv +TVpS51StmTDjQ4i4K81+1DlyNG+nVh8ckdKQ+M2FI1xhsGaV+Pjxr/mxLEKuJqqenRU8l4mW +zYkuqvyezzBHw22Vtt1RokEkKKOfnC1sEAQClXNjtdEEKtgqjk8d8j87270S+M3sv4Fg2VHG +Qv4RQIIVG9PS5ggRBZIWb0k6ArlSPjEfMBQUIt/k/NFev1rXmdp5xzzEFm68XyxNO3N+1+yJ +Qs3PnOAy9FTRF0be6OsQpgFUanOZfdwJfVc9S+k9/3PgN1nQgh0m09sxgmVUgt46f/VHtCXq +cQZprREMgpCkQKvw6hp/MhaB5I0Hlo8P/JR2+zBFHvf0tClTL6k/os7dk2EsV8Ps4Wyd7mIn +GK7IB6Rg9r/ytxggs0aYqQwpoArNsLzBUXEpx/ngnY7fcy1RpYDz72VtNDfcDsNemyRXnUWy +2wjSu7hCf+LxYhT6VDfyXgSL4SRPGHiTWEo3opWqUGgGfoLxa7WJAhwEEgEKAAYFAlc8yLgA +CgkQS4O8j3e2rmTQjA/+JsWMO8pSiyP7n3WEmIFy6DkpOAY99M39j/RJgrJNbmkqyXq47XQx +9uwv+kmqMAMiIsGTitSgCFLqYVL5LFgElWzW+HMP0uDKvV7INgf6Lxz8L7uAoxLbko82Cu+Z +Xx/1QEAabSa72k95u3n3DaHQ3eLOqbwLL6sNqi/HHm8rSQyqfutH1OFZRaXBDJBqGRaAtqRe +riUUw1AdO8fE4wv2PKSJ5lA7E4rivDARKvJw6Z0iG3+VggTz9bpZGGRLPSlua/oye0rLTWdw +Cs6q61T8Z1uvLQBQah74yVweaoZkXlxpcNUWM04o4qb4eQHI2AYrhOvlt7bRvi/Kz/6G980s +9quOHNpO7I51l2StDUo7KxU3tK/uR1RImsMk+M3gmjnEEjS04QSTsmcHB2BY7gJWPbpdzQm6 +1K3Ls8AxEh8Gtl0VZrai0ITgWvoFi8J/V5adNYW0xmffKbS4lqFLPBJDuA0EjSVisHeqvoVS +/yhPN/l44c4gJ64sPdQBHauPEgg2t+za55dlt8uLJgufldvnvSuQ/24outBGNYv1bIJtiXZj +hM06Agrk8ma1RsfcvTGzvTFKLYGzh3yTBO16wCUY4rGZ3OOZJYckFXQfDIRc7+Xm6o5sBb+p +Hh8WytOmw2kYE51K3Cao4AKW7skNuimHOYFSg+qefHb1WeKIzCOd5GiJAhwEEwECAAYFAlfb +5gkACgkQ4rGTrcszHybiKQ//Vq7R5raAtaHfaKiOylu9PUWK/aFwS/JA8IUjZVAm1E30zG9l +NgdPYeNbBAaSDxztajeNPH8WAPVgq+T0ATrdmNuDqVbdDADGuIk7vHtZA40qmqPWogER99ts +gw0Q/HdSff+20UQAdyQsrzIyO05Ms9fKu2Y1bN3xT8/+lkubXT2f9BNwDd7BQl81wyyMJ1ar +qMRN6lpwPHLOpg1mEM8XjvqiXFlziD3brOn7eTmBJamTPQG1BtwqCADBU1iolPcoEh+/KJ/r +pK320yc+z/TUVmEim3IRacZCgB0pxQkRed7YdP6wsxDvc4UIOANKgFkK6NHVjDV2vOhJlLct +Zn+vm6oWrdf8TkOyFzwdGd74ghxe7sw32PImsd8/VVTfTM9UyfhBNHKdijD2uD6E+j8cv1/W +NAMv/nftxNZLOFeBGuqz+OfTOr9vQ5QJc9pY3ICB3owQLdHi61rZxgsU6/wxFvkKchnHl0bK +OYyqnvW647filKSJOlM00gOo1UT+dBxl+9LWGOHiwDV3Df6cqcpVAzBZuXgaKdIUA7itE2PA +BIY0l8R4PgiTpDpz5i+mLoV3i6eJ2hVqQ7zgh0k3M8yEivv81O4SVsIGG1YPtwZo6hoDfbXr +4pmD4M73ad8wt2HMTKx15XxKKxgLKEGr5hwESiWZybc6k11fbdgBN9+IeWaJAhwEEwECAAYF +AlikHn8ACgkQxnTA9D77hSpVKg/9EsuyOVldtARzjAJIx3d+4x5Wms1lUWaXck1D+zV3n/QM +W6DMerSFIWra9LC0PQ7nCPNXVC9OSkGyYznpSPEHK/XK0aM6TpCfisvxeQsixPLXFmESC8aH +zitbWwzydVqkGDPP8b4MkTSAe6Epvr8A4aJdf0rTfvz+xu1WNeflu/e78hsdLbhobT7WhGHB +z9svx1ZoLe5pQ2Eia0h7J3ISWAlPP23VN0PjUIbEQjGG3KG5OY9ib1nWuAnQs8waYPI+Ta+O +v6J4lPiqVIPNC0+9CigYdfXfclGEMpoNHiKh24ubDgUY6kv5HL3dRigkVYvh9VIfPrgE3qUf +tXAjJtX95Idqi8w/4aa2RWTR3KkvHkcb4Ol2XTz/3ahUEbm1R6t56Ax6N/iendqwxNP5yD8m +8WuNjMiVbm13c6K45VFpq1VQcq6qokQXZR2+BDxmmlwydxA5+NmYK69/eeZv8l9NSIrE98RP +Im130vkCQt9XzAEw5w4Ndj5nRXwIj45+2xFOlUcc/mT0mrq8ifRswNmgvsbfBRANZ41JE7gg +3ylTdIzGxRGt9yNmTI7CAuzOrU4WmG+P+3LqLKMObneOcqdAoh4hpnU0lgV3Z0YLBk8Pe558 +YzAmqvcTWYWINQSSubViDGXI+IDPit+HQ05pUtbRR2GNigWrVfacsvQ4YwxLweKJAhwEEwEI +AAYFAkpSW/QACgkQrDCHmqtVsxJ7cQ/9FEw0sBW3Yv2hlb+1yJOckDwxONcaNNZOqpfKgdTJ +AkALH/2Hqp6HgKf3CyytAXRHX+BjGAVydRpjpRLrSC7VICQi99P6Yxg3SKyWLE+uH4jZNHyH +AZXiuIn9h4B+E1Gaj455Gk9YCLYvoeE2CSL6Gw/S9HHz/qxnDADyZoWriByDzzCSPui4O8ny +/stXQ9Vu+tOGDopZYIoW+HfjF3jD/XmGG3kcfypFrV1YbXgbdQWjMFxdTwe5+82IMwUQklGC +ToVIudo6f46SQd/9+gUema62IMWP3nfJegPv+yOdg4UFbdnFImD8sUwFEuwQq6H7iieemItP +pkMgFtOfYYkJjdNqYRuBUL81BYEPMW9kpyNO6qwY3E0nUwiuVOGmE45fDs7WhOdSNzWBcgTN +LShQKBZrUoLFTswZth1xwIW9lsqeQodik6QdQJGMs7oJXiszXpsOSPZEbZm7HSKdtmDmgszw +8YtJj9o6szNxdBh8+V3XSkSZMzLcUJQUi7DVi2zvii9oPyWlU3uhCfw35idE3AW4PIoFkxxn +fFFoMv6f7qVYlUoQtBPGSN/Py5hq3zWzg1HKNK7tIwUM4PGmHS5ZHYMmrCBs6yFA9MNpRQEx +Qb3hMd/oYe6T3v2V4C4kJucNizzwVsK9houutiMH4g/Qs6vS0lywqmThR9yK4sJxb1yJAhwE +EwEKAAYFAlaJaRUACgkQLf9Sa7F/dsaOchAAkYelyvBeu/33blOKPN2TsLnQdrs93KqPHJsx +7sl/mEpH0J770E9rPFW8WVjjdEETCUFBVjxzlvjoruGOjlA2GC76YLp4F8s6eMFOUPPaMA+T +cy9+0goIgvAMChNaQ1V6XciNYOBLqVEicfV7IYPHSOGVNQvb5tWhdz72ZrOGk/0lRMfOLGBF +S/P3t5rryTJw7drro1CwqOlVqK9zFWwvZtfS1dyzadH3gAQOUKn3KxG0SJKJq9mN1Q+TrNMH +kTfPZl/lbPaXW0zMZXAu3ROZHBTWkswr+n/EPtOAWxe5tOevYCgTwhnr+AXlFG11rJUnlIN3 +cDQi7GtzescxgJiPooKgUfnLsqy/oWN9HcG1VgrpIYYlKPqEjykvWEq14QX39LPoOu2wjnyW +XfBXTUFqk/DcOKhqBOS1zbzkCEOu4sKohOufPF+bvGugQhj3RPmE4PArXGI+J014m95n57Ja +eYIUwCjr/W44Y+hqj/B6LC/RpRVdkaW++dgGLnQvWbUQAcGSIjDMyZoEEvwZgd8rpA4Z/4a8 +UPCWfTWY0x6kBtyP0+3S1JxnarHlIqR7hbqFUdRS722YbxWEiWKwANSuKd0ZTaHO0b5/H1gB +TJ2lG7A4onWfmtJ19AMKrK36Fdi6NnHDTdpIghPfq1zZWcPfUgZZZdWcSuFQfOneVQzwQ+6J +AiIEEwECAAwFAkejaxMFgxSGNz0ACgkQu69gyCxwRjLgqw//a/tUwu7hk8TxVOabH22OF+Yl +FJ9JHUYWW3BKX2R9dsheQNBMqXMVIvNw0vU0gtdg0Upam0FRknfomj2aO1CAdMVk4vbFU+hC +opJBNsaz2coOKChYcb7mgREJRTu2svkEDq3INf12FH72b/fuTgnB9K/XzaPpf4/+Ta/W96EA +tjlq62LErTvmwiF0n3HdphiX5rIWjiBD8uFQlBnDGsQcOLgzGazzak3gvtrRM19wQpVX+Pb6 +1cU+k3xxRdHCwTUpnSo4HxeuKC3MpC/TRzJ7JciZJ6kxPpiOVO8RHw8JXeGXnlNg5xM7qCRj +UZQDxnvRNCgguu5TD8bEDg8+GA8CQd5o/egR71U5oJ7q1e8phPFtBbEKORbVXYpXGnHf9WEZ +Bzkq5NUKbTvbpsjuEPsxRQG1q3FdB7NW3BMDKd2myoR03el7rYKCXF9lwV9spFcuCkFBjsMm +dsjmoheoWyP3MrccJ39Ml8vFzpgIE/i+tWPEvfYW25YWh77hKURXDm0+t8aTR3OXnvpgUjhe +qEDsHnA8XSt4Bp3tnC1jFvOHIPkBaVdbU+w9rYLgGBXoLMBDm7PdgKKHvO4Wwx7ecsKTsEUc +Sbm6i3bgl2t3mqPCElkSVVXkTAS/ez2asO9pbifwB1Psd7s1XYB1s4IkF3m6L5RY5FLoQJyR +l2uO2g7pvdyJAiIEEwECAAwFAkeja5cFgxSGNrkACgkQjJN8VqOoVKk1eQ//aaQhz1am+we4 ++AQNiytBHweDjodxvmfbFoerhQ98oCb3SCZCc+pcwupBS8NbH5duD+7PBtwOUYpI5n7r4+UT +Fgd5yRLmnnFazt9wnQfdE+ZSuVNZQZI2j+pOjVKujhn3tnrcdY/tvNttbaQornIYzsbGb+0X +CiV2O7+XaAmHpVkZNuZuM0PRsJejQlB9ujfJNT2/zEf9DpgTxsiCTdoCTwtiOzD64BN4yGpY +VHmiRVpwoBl9WoSAu6OyMu5l2fqNeAKgZA/eWsP0uA/wBMmi3k4UOuRYzAvq/R4jUM4T1fyT +h/OMNDCILHDL3B2pwdbdJJDlFFIv2Jyz43DrkGYzUJgqIH8D9FFn9DX3F5qAILk5rZDmAEws +35hCkI5ncRlEMAukkcJvy+n6b55th6yt36y7AHl7i8DAWn1qLe+inoH7M+lCYzN86w2swNRj +B3WZMwDDLNBnlKkQqz+5dI3ZJ/qCSIpkJux6Kk79TQ8m4i5ewozz+MHnyVOWPgCY8L0Nv6FR +QfFOnRFpt4od5NGpntiGa3vh9Cqndlfo3v4IKt93NKit5wUMX1scICJg/7xutMgLKvWOZYzF +x+9aYE08tKseiTT/U5ko/t/tPnXY/OxZmFTqPuNBnbRtLDdfu1rtVVfmUi8qc+k38+mcvnpV +THii3Y0NA9byFPQC8YkjMU+JAiIEEwEKAAwFAlTXj7UFgwHhM4AACgkQ3/6N4xpyBfRVtw/+ +IWuX6sHxVecNkABHwR/h7KcXCxBacMbITwQV3zRvQJNbOPIADLmaSgM1vrAKCcCHgkxQA9WU +Fnx/MlVdp/WTsXDCuoO5OANtL4UIsjZgbW6n3Bs8V5QLg9GWleR9M18AUx4fEf71sNWnrVj0 +SV69XrGCK+5KraCubg5BKxb8LJZdmGspU57UzT842DHsVe3+9ODbGEg9le/Y3x6te6qXJj7S +HpP8jViyiqN/NGT1RD1i1Tfja3wNxrQPHkPf3RmnqTNjSu1rA6JcItTFzVpeo4IgTRZ24lfy +O8N6r4CerDZQTjnZkBIWX12yjjLkqvHWn67bAvlLSs6yhkfY+sLiO2a7Ph9FCm9yhm/lijZA +W2ZMvxsKUAjj+DuaOwmum6XHWAnHnPt69ZRH5bLAKJvxD3RQnDMiDqCff1yKQSvYK72rX6lk +U5nivInu+pepAqO1bk+mKcxl9g+m5aQAi1t3eWnzEjti+dGCyAfma63yYH7jIMxuuBKYFLcK +CCWsQGG9zeKUqPi1DPjNtcRP9gcFN8cFx3+BKHJnTx7pTa2P3ctoPFaHcL3lXxxcQ3AUWwh5 +oa4U7wUfKU903ZUc64Pt0eJiksA1gq9MaxHC3RxhsPc9P08SzOVSAhAoYemxNmf6KmBaEwV/ +QoTgEj97KUWm49iANyBn/nDTBXkNHD4tXPuJAkgEEgEKADIFAlafsYErGmh0dHA6Ly93d3cu +aGVhZHN0cm9uZy5kZS9rZXlzaWduaW5nLXBvbGljeQAKCRDs6SHahjuV96CdEACMRoaSjKpX +wOMPGzWAEABiCW/sxbVsEGOIirsphVxNP6p3KZCMw31k05tqzxk10KXZqk9qFXkbdJrrRAvG +BkzcFI+RXJU81csp+piZk4EtVzS4yKJ9Bb/aOWmrZbNxFSWwYUhHIEskTz82AKzlkB4lWOG4 +3UYY+WwcsyFD8gvVSkhTg25Jh2b4tsZoJfnhJBrtdZ8tDzfly64jfgIEDXVJZmTuvh+eQ0KO +5kfIaKjaFMOkfiR/tVy9Dok/4ADk8n6jswZGs/PIG5seMgOQo0eQfpnQQ0cmUN3d9TXfZ40T +POrN6KyALK5mmfl7PfljBflh8uHPzhS0aCRSC+4jr51Msnj7TeRlH871IxyBrVJtKBZZLKg/ +6JGt7DyR2DNOuObhIbMZ5Eso54+bYJgMtCNUgKVnZEdobr9OUU8J08Tiy1wuk5FNaOIKbdUY +6/SFJpd99bx6ml4p/WfA9wiwbT8ax9psixUGrwjXVK41OVneQvbFzH7NIngzlSNWYLVS3D9R +EClFDbLOpXzIPnnKKIdA8dXXlsitlF29R1KNTjAjpaajWkqhEUv/RqZQuUD/t5J3EoZRpCMr +kcqSyHpxKVdicNClPAI1Cnx6AyApzQyxj23W/sJajUwJQc4QmBbPsgFCii4VuGlMY61CRKmB +aJ+lgIpTxyNcyNC4v2L9xS3y0bQcV2VybmVyIEtvY2ggPHdrQGcxMGNvZGUuY29tPohGBBAR +AgAGBQJHeR3nAAoJEF3iSZZbA1iiiWgAoJ7UnehMeDxjPq1zYlTuNhSNwsbxAJ4oUP3rmSqX +s05T+/Mg0/u9WXwaj4hGBBARAgAGBQJH2roXAAoJEAeoNRFMU4b3uOwAnA12E7YOIhP5eFMd +WMw9WKwTBA9sAJ4mplgwNCyboGjGn9cS4nSsoidGCIhGBBARAgAGBQJH228QAAoJECbj3Tnr +OFAk6eAAmwellSGvVeI7n5iJFzVp7asoDCRyAJ9r1oSzqZitbvXTNFeqQNUIV276mohGBBAR +AgAGBQJH3To7AAoJECjdsP0Zyba6WfcAoJ9oJ0B+q1En3g0+MsF7zQSghLAGAKCkNojCKFwe +5tom7QHEpUUudlJeaYhGBBARAgAGBQJH3tNbAAoJEDKM1rPrwnUVKKMAoLVOpQ4bH84FR1hH +uRsocQiEWKTpAKCJPs4Rq7Px551alqEwcRcP+o+UR4hGBBARAgAGBQJH4ZS6AAoJEGpOVkX0 +ZUOAIlQAoJzqw81JfYdxvVunBYceA/1w78dNAKCMU9bT5t6j3NmRYYjZyElKOOnKoIhGBBAR +AgAGBQJH4ZdYAAoJEB29XnWDmeG7yccAnjmcDXE9ZW7LBWa52HcA/mQfKYEMAJ9GswjomPDv +oKYJrA9Bkk3TyVYDbIhGBBARAgAGBQJH+RFrAAoJEMlnNNgRt8YvO0UAn1V6PC6EIZWTRXem +yDwAlkU7neQBAKCTh/3G4fGZCMYrMNG2kc+gN3rmVIhGBBARAgAGBQJH+gWaAAoJEInhPhCW +6sXYDpMAn1YYiuBumJ7Vqf9dIJ7HAMZpf9DqAJwMpnSUXP5LT60z2D7jpLrzOrX5z4hGBBAR +AgAGBQJInYArAAoJEBJ2JBfPBQjsIB0AniRsBGJYsghX1sa+xHdt++SHD3T+AKCExheKScxh +RgOLSgrJGRvb2GdjQ4hGBBARAgAGBQJI7whTAAoJEHfWhFBrJ3pl4hkAnjtAUH0GKSmnoIxw +4jOkyCv4DCynAJ96UWI7JHRCqrxisLW3yaHgjr9oSIhGBBARAgAGBQJI+h0uAAoJEIzFQNLU +wxu0oVkAoIh6TJ5qxPX/wOWY4WmBcWXTf/2yAJ4+Bjs2xMNrEHmBU8IpWmH5nWC+uIhGBBAR +AgAGBQJJCj20AAoJENAH0xZhuVyB090AnR6aLpU7hKUdcxm4e1QTNbSHYnz3AJ9tJfL/5JMM +hYXZggHz9Sfg4SB1RohGBBARAgAGBQJJfEHCAAoJELRKND+o8jtmdX4AoI/u6zImKEmgUYzX +qz2PpJyCPKp1AJwJLHtc79MjtLSzAWp8fC3HNJSDB4hGBBARAgAGBQJJhHEhAAoJEIfWoN3a +ShEWTPQAoJYl6yAILlkqKiyiM7z6N6ooS/iaAJ4oeltKOAo4APGJkYtrSkebSq8QmIhGBBAR +AgAGBQJJh0R8AAoJENLwolOfiErIFQoAoKCWhuJbI83ybxZkJyzSohXKGAsPAKDbP2qJfOEh +YsUazpO2ET56KN/bDYhGBBARAgAGBQJJu4foAAoJEDuOpB+C9hJAhtMAoKJI5wSZLuHbiyKp +a2UKBqsy+LWoAKDWLD63sT1Ih5L68nSCglPn4J4DqohGBBARAgAGBQJKSJk7AAoJECUUKpDb +VyxwHe8AnjBzHKPVapcmk0xtnvt1tMxDnhv4AJ9PW3PafJ3Zb0SC537Hf3q7PMwWzYhGBBAR +AgAGBQJKSoGRAAoJEJzL2hYB+otKyv8AoKgydonPyYeYfaq7FAhevA0A6tHqAKCiy625ppK2 +miXq4QHHXW40kFnUr4hGBBARAgAGBQJKdt7RAAoJEDMlX+ieeD4F5OEAoLw48Jmh+qnLgLDN +f/XJYXbKgIwbAKCvGN3PxIXjNmTgOv8ySaBRLR9qZIhGBBARAgAGBQJKec55AAoJEAZOQqbv +3+tXYkoAoIOfkiEheIuDl/NY9W74A4uGeloNAKDYgjywLochrlP/UJn2hevlusJY1ohGBBAR +AgAGBQJK/AcUAAoJENG84OKPoRoV0uAAnAxhXMEd2IvtZRLOj25H+MfRw7G5AKCGaf7pGt8s +krTTBLsKwNGR7LOmvIhGBBARAgAGBQJK/BgUAAoJEHJZXrGBcEuTpwwAnRll43U7lZJKOKiJ +aTdmtECd11UuAJ9y+3t3Y3hR7x9o2H8unoMMJMACf4hGBBARAgAGBQJLAA56AAoJEPG6TB7R +yLqPvE0AoJ7E7mvBI3INcK+rfn/tazpMTBadAJ9+qDwYR5CiIfF8epN40qJ7s6DZXIhGBBAR +AgAGBQJLAStUAAoJEBgFUbrZWjw1Hs8AniO7pTuh6euOFpMT28IUiBDpumliAKCN1VdBA6kl +tDJCIJzvAiBg+zox0IhGBBARAgAGBQJLAZwFAAoJENsmMCSB3bBlmaQAoLJVFOl62c90ykOf +xWfecLZ5JRkFAJ0a0N0P9pBu2oLMxSom8tdzGRZ9iohGBBARAgAGBQJLAsbuAAoJEFB4/VGs +ulDHa6oAoNeT3w/ihzC3dC0t9gZx/yHgQPpoAKDqWPyNpMgTTUQRLlU5wgIrysTB/ohGBBAR +AgAGBQJLBn4tAAoJEHfdleLqUuz0fqcAoJ68rEl6GqkgAJOJbiE+Eyp5tIPUAJ9s3IthjxoT +PG5XOsjQVF9BxprVSYhGBBARAgAGBQJLCQJzAAoJECmflZArdNqyWioAnjbdJiwwpNccph/4 +6Tv+m/qvcDizAJ90elFwg25YXmBWEKMsVpf9Y6d/lIhGBBARAgAGBQJLDplvAAoJEG4hb+1k +Bp1cSFIAmwQZVSFKWbD9PvjhIgI/LL/JjZGHAJ0VTXVQv6nJ5dcenRnMU9BdwGJVfohGBBAR +AgAGBQJLHGdYAAoJEMcaTGXwWbHRW0QAn1ju9MgiqXqzRQX9ZkKbvXv9STwuAJ9fyAor4Ytx +jT1m7/9Jwjp/iLbO5IhGBBARAgAGBQJLMKawAAoJEMK4wKy+MmP+dl0Anj4Q3TSEhRAviPFy +/hKsFRWZZYsFAJ4/r2AVDHqY77vScVhow94xZGMTAIhGBBARAgAGBQJLepWlAAoJEIjq2qqI +Z5tJMj4AoIF07YCSZcp6QJWfL+dnouaNTvasAJ9NF8EncjrxXfY2ycbJ2mkINKzLfIhGBBAR +AgAGBQJLev+JAAoJEE6mlUJSgFLEy/cAoIUkL2YKr8Yyyv5LkllUHj/vcPcWAJ0WpuHfTESL +6C/8oR434eYwkxYAW4hGBBARAgAGBQJLe8fUAAoJEDYAaQ6qWWq06ZkAn3RZnSOcU8PrN2W1 +jwrXq84ElfZUAJ9Dqaem1fFaIV5ZffYOgmAZ/KDEu4hGBBARAgAGBQJLe+C+AAoJEHIYvL3g +mppnLo4AmQEvsv3b7f71dYzUVpc07AuvL6+JAJ4hblaSeLf4FbDexXmYWryYD9c0AohGBBAR +AgAGBQJLgU/ZAAoJEH7RMqO5O52I6IQAnR39Yu/3meLndfnU5ctCv8VGUPc9AJ0Sp3z09c2L +/cC7/fGl2xOYCdkyuYhGBBARAgAGBQJLguKeAAoJELnjbqQR58S53ZQAn2020B0OvdAphCkw +dhL4/hSuWILaAJ4gwrKpHamR1kOmw2Q5bfCh9UiJn4hGBBARAgAGBQJMSwtnAAoJEIMSIJCi +6IJeNUoAn0U6gzNla4DtCPMKobWfEYbhWmmHAKCJ/t8T+jchv/NtByRvj3JkKogjt4hGBBAR +AgAGBQJMTexjAAoJEGUd81I9I/Jd21gAoLFFLo8c8LCC/zGz2cGWPpaE+5VAAKCRFwanozR/ +jH6CiCTk+qhlVdSEa4hGBBARAgAGBQJMTffFAAoJEL9gcItIQmx+TCMAoKex8zK78f8Z0XF1 +/mvRqEPcl75xAKCX3eipJZFZnJGHeXNNJBx++Oc/rohGBBARAgAGBQJMXmyqAAoJEDJBm3hd +DNz8kG8AoI4S9osDut/x2oLUIFPZMro9OlVlAKCSVhQa+Sfe9Zbo/fabTEcBglJwu4hGBBAR +AgAGBQJMcmEbAAoJEISAc4An/PEuTxcAn1PtfhlbBdqmesSc33FQ4e8CCDJkAKDpOFHqFW6h +BQnbEQ/vRmrgZ6m+eIhGBBARAgAGBQJM43BdAAoJEI+6d0TMhxDQxgoAn26FCXmEwKcQu6pB +XjBbZZ8F5HYMAKCoEEu8C70onaLNdhwbIqddLZP5CohGBBARAgAGBQJM47/3AAoJEDACjSRI +E7X+COsAnjalDaOXXVAzSF0Za4UUQb8u186VAJwJ5sMQpt7jR7m6M38KHK54Wm1M6IhGBBAR +AgAGBQJN0/DqAAoJEAalIsEfKJat2hgAn1JY9arvq/zPVbBCI6UZZYbA/kKMAKDRBaAdHYli +mJz4lt5NoLFumdZKl4hGBBARAgAGBQJN8rDPAAoJEOVQtZ9Y38YIDTYAnRV8M1T4GJGfAB3m +U1h0839AQVgTAJ4mdAQtkcx6EBlQKnmXARi/yXXSZ4hGBBARAgAGBQJOv4xJAAoJELW0d0l5 +skq3w68AoJpdsD9AOVSaHq+YnZT4+qgbR3hWAJ9FlZqiNO3YCuICAWljh0RPn0uuN4hGBBAR +AgAGBQJPRpyxAAoJEA8mVjp2uDN6se4An1NNGfKQPKlBuUjj1hNBE43bgHgMAKC5xL4VV9RY +fKnD7ni9OENAFsjCLYhGBBARAgAGBQJPVSW/AAoJELkN18ntYZU9i4cAnidebmsJ9A7cDXPu +zCU8M4YuETaqAKCAz2bT9iTJV1OeKYkfyRKPrQXVvYhGBBARCAAGBQJLArryAAoJEDlgZk+V +6iPdeAMAnRu3p92SWKcJCKwk1bEbZV3a5AiKAKCwTwjBQ6nG90sQSynlXA7+u+YUzIhGBBAR +CAAGBQJV1KuMAAoJEMWvd0pYUQtam+AAnRyq17+2QiZz2yuoAIfhli8nWDhaAKCz7q6DBg1c +4R0OkpA4hC5/IzVMyIhGBBIRAgAGBQJLZXPPAAoJEPcpr9mBgClUX/MAoKUceykLyv/IEoLw +NTmbRyXwubZ9AJ4tP7Ohj31gaQ0AZ7L96fDg1TyOaohGBBMRAgAGBQJHqu+pAAoJEKvyrWfM +Cu8+XYkAoIhyb9cQSZ5+7ZEODty9ls8OAiX6AKCRVkoEl3hGfJz5JA6ldMKehLJTyIhGBBMR +AgAGBQJH3uK+AAoJEI2fCBHtSI5uuNEAnjOZcpxbYXUNzkTIKpp3sdZQuwuTAJ4npSRFZk4z +lqBjGArjrvUJFXQlwYhGBBMRAgAGBQJJ65YnAAoJEPXBMydnXiKiTlEAn1/2U+v/UD4PwiTZ +ZrY5+lvnaZjHAKCW/Dxmerr/x++iDINu+D+oezrz/IhGBBMRAgAGBQJKTQnNAAoJEC+VFQiq +5gIupnAAoIpW2mG1XDDXzqk6iEYlDdlGCxvTAJ0SabC1G6CagDlPmif6m52nzERTSohGBBMR +AgAGBQJKfwQCAAoJENumiZyC1vKWumMAniQuciG6AjCFSfyWqYK5wQGPncH3AJwNmWOiT0pW +u6ZfbjCmUd7WWnT7/4hGBBMRAgAGBQJKiAa2AAoJELnGX4dTs4krT9AAnjg7xjRseqlte0nE +MfMgsod2Ry8AAKCgqP7StzPaV9uPiT9ehVFNcyxecohGBBMRAgAGBQJOvwotAAoJEP6kW/2o +hoL9xNwAoJP0VfHopyfD5GS4YedkiKo43pyPAJ48/y2aRZKNQAovYyB1fFvIi8BnWYhGBBMR +AgAGBQJOy+74AAoJEAvgqvm1LMtSe1UAnj4UVgljauu+MfSy1aR3hWfPjqKXAJ488gCThbG5 +9b9aGHkJ/X2T6aMYzIhKBBARAgAKBQJTdhI5AwUBeAAKCRA7b4rxQ8IfO20PAJ0QirlSHtAZ +Q834izuwfXF/SWtwywCg2dlD4UVSvhMwclBueaTbNmaVipeIXgQQEQgABgUCU/urEAAKCRDo +l3WoMrZzBWlAAP421VIQL1nDQUuKgpm4EjUEfy9FycfpWNxhABhKJU+AdwEAv3CbsHmzOTMg +BdkyYvovn/+xjokkoAJoPO6eQShrKr6IcQQTEQsAIQIbAwUJFLCKjQIeAQIXgAULBwoJAgUV +CAIKAwUCR3kegAAKCRDyrYWsHkKzZ/pEAN98mmysmPc9bo1aMXCxe0TnNJkrF++bK0VyI8U4 +AODSsIJ1dRjdUC+myh+BuwBU4JiTEI1i8sKYLmNxiHMEExECADMFAkqJv/8sGmh0dHA6Ly93 +d3cubmF0dXJhbG5pay5kZS9ncGctcG9saWN5LnR4dC5hc2MACgkQBk5Cpu/f61c9NACgrVGV +ApJPf2vlBz5mk1BlMGGmrYYAn0O9PNCMOr3GG+I87vsT5NJwXhcUiHQEExELACQCGwMFCRSw +io0CHgECF4ACGQEFAkd5GiEFCwcKCQIFFQgCCgMACgkQ8q2FrB5Cs2cqKQDghqWJfOZp7wmq +gK5K7E1HswYzJy8s4MUPKuueswDcC5H3TUjD9bgbCt632qLXWbK6MCXpfb5IATOULIh1BBMR +CwAlBQJHeRiaAhsDBQkUsIqNBgsJCAcDAgQVAggDAxYCAQIeAQIXgAAKCRDyrYWsHkKzZ/ae +AOC+vujb2xsstBU5vtkdHarBhtMe92wdC00MlE/cAN9VnPz6klJwt6CK0fc0SUo1bl1ZtaZX +UCq169YKiHgEExELACgCGwMFCRSwio0CHgECF4AFAlLFiycGCwkIBwMCBhUIAgkKCwQWAgMB +AAoJEPKthaweQrNnbPEA4LS3vZmTvMJaUO83SHu5829dBP+0XWXkD2dXdm4A33CYm5eyM9yV +nAWp/NcnK7yhCaT9ORs6Yr9YI4KIegQTEQIAOgUCTsL5rjMaaHR0cDovL3d3dy5oZW5yaWtu +b3Jkc3Ryb20ubmV0L3NpZ24tcG9saWN5LTIwMDYtMTAACgkQ516QwDnMM9uKTACfRNEabImD +XXbr5m96Zi3lsas74RAAn02oM1n1/nUbnYSU+wwU69ZuNawSiI4EEhECAE4FAk5neHFHGmh0 +dHA6Ly93d3cubWF0aGVtYXRpay51bmktYmllbGVmZWxkLmRlL35tbXV0ei9zaWduLXBvbGlj +eS0yMDAzLTA3Lmh0bWwACgkQ3oWD+L2/6DipywCdFd/ajJE2ia9z2bNiRvdlxbbd3tQAnjdE +UbWrZYD2DlnHzBYQGAMYpI/jiJsEEAECAAYFAlbtOX8ACgkQriTSuKU5h6ewxAP4tqyk2hRk +NIxe69lLarex4CSGmYfVinSH1xAvRBLOWo9GEjv7yQV+NZNrC8n615qVO+aSs86wdUFjxkoJ +pL/sL7gKCVKD8+dnwaosX/hiURRQ+YKkONythlc0mGmTufST36cixFsy1V730HLCeDcWvD68 +5IXHfhKej7GpnyrlsYibBBABAgAGBQJW7Tr2AAoJEHKRpMqkgQlGmbcD92YLjMQI1qIdI4sS +dY7W5H/mevuUGLPDmpAFH5kMpAPGsDIRYoo8L9oPWOw0Lm32NoTh66e1EPLiOD+OM7jA2JNe +pIGA5UcXeb9vDseRMkY/WmP+oYPEo08fzHd+4rOUVsNQC4SOCpUHJHYAJi58phxKgImXFfBu +nc+xhjX1X5+ImwQQAQIABgUCVu07GQAKCRDXISedbwH3d4NsA/URs5NwNxrJ6VcZ6XvQ/M2S +a1ON7sV2ghM6/V6Pkld6xtM8FpGixhMpaCgbiG5+FiD36QcrmMd7vcL0uYPYy9XISs34ac3v +WsmbSf4a7B8MyUFRfh698Hmqrs039+x37tWxMbEljQw4qv8V3af7CRIRbcSXoc4iVF8vc9mX +UYwqiJsEEAECAAYFAlbtdxEACgkQnssQXf4s/EIn2wP4phyx9DofmaSLO11HFEJ0PEazw7GP +hHrztMptKibyrbA3bCw5W2ubu24h+3eOeKhpOCQa9rX7VVsKvVhYBJV6KFYsryYHhZjWhNrs +jaiJfxzqVv0nmJkU6o71wSptaZ4HRyhUnA53ct+Qch8GsOpm7zGNKToO0gDnAQP6pWCdLIib +BBABAgAGBQJW7n0DAAoJEN+htfluaePqlEED9RhLozG2XCtQ1zqOZBwMLphnUMPgCo3KFK5B ++3QtLocU9oUUSRrNfFjIL+mSDXhKpVa4SCKr8KSmYpHk+6w7acFzAtMiDGMMooKBBBSzV3EH +9umQYOI4VzGz1TSEEuL7MA5Ifm2sJeNE/2PIjHfSxlADK6apZFKfN/9ULnC4hmqImwQQAQIA +BgUCVu59xgAKCRBgfhp1AsUGdRkFA/j9UDAIvFwTE6oRpi3VlmeIJ0tmgAFX/4aVzdQAxyN9 +KEPcjmL3Rmcq6FOT1U3namd5j9okp/cxmWQZGDURxR0RCSXVfSUXH/eD1GoksJnhxomXp/sn +wXFpypxPSYT8z8tXXFka4/o7ks94BmcEEBlIP2prYpLkrl/FNMOadpe5iJwEEAECAAYFAkfe +yjAACgkQ5RUoJTMc2l3r+AP+P9z6zwFSn/3zs1MPw0NqDGXAtENmA9hcy143V5BDG1gdaYnN +ZaH5eVvI4oJoC/482drVF54lV4hozNqSAfCAbS5eWEnxVTBcyQKDJenMmNFmEGCI62fTPphY +rA4Gtrs8/gK0h2cqEZgv/1WQr36ITWNsSd/GEEP+uqrsJ0CRkkeInAQQAQIABgUCSw6ZTAAK +CRD1TYragIIf6lr2A/0VA2BonYZQkEsu7bBcG8dZZr8sN5vPQ1HmMW+wkm6M566hOILyxfWX +h3XacXyYiwnXj2iQGEjVzeb9FqZ+ZzpwbX3PR6j/F57iMK9Xw/Urg/iOtniAMdpBm2C8cdEW +/9S4sU+ws4NJpAqgY3Qkz4va71M4cw7QZsNTQrXKxmhXAYicBBABAgAGBQJWfCsZAAoJENt8 +nY/XHAKHD7MEAJKlPLrJv9Eb3z2fuZ0hiQK2VPIp+n/DV6m0pQ8nF0n/7p55Hqe0v6YvI+y0 +C0QLp7KSegwPINqpPaBvVx8nZMpk8Se4J2GYmUGJgbK8/hYgUSwxvtTnEN92abvU3oLBgha1 +PtW7VCZywE9qs1OsB3YmK4hmWnIbJG1lKPoyuPGmiJwEEAECAAYFAlZ8KxsACgkQ4fYF5zJN +t6ccTQQAyFSn/v/KtccQ29jdjGlVjFAKL5KpSN5a+tjdT2FngcVzUQDogfLCNuevNXgZ6Z0B +RAvTFhN07BO8c1tCqfKHDkXeReq0huOASBvVSVSNZ0WbN3c1przfMeFPYiT3rLgCBDGhBXus +StUr0P7Gzsi9kf4RDZjl3y6HmrNl678jC3+InAQQAQIABgUCVnwrHQAKCRAOly+K501Y+PyX +BADD6kk6mE3Q2wUj9VoSYiCFECLP24umCCS50HP/tQ/rbU0e4ltt1Qf+kHHPYPeu2d5HLSAB +BJhybTVNaIgUZJvtc/1l74T3NrzMURmLJSeiXLfERYxZdJE4W0SfG5ZPaQDUyzR/T8b4bnVc +A5sk+1+N+2Q4Cre/r2X57Jc/1+rKnIicBBABAgAGBQJWfCsgAAoJEPJ14U6IxyGnAtQD/0LR +UVYV6TSvmC7/FWtiz8Az57aKp5/7AYFwyKK7x601KRLRjZZt+2LxjIOXUZXKaqArRK7K1XCM +nIQTq49FJKiTl5HbX4b01lOzwbC5YhQFFxLoDLdfIOxsd37ntaJd0j/Q2xXh06l3NwINKrxv +d9CFdWp/DK/qut7MqVlZPgYHiJwEEAECAAYFAlZ8KyIACgkQTXXU1dy/Czx24gP+KWeokm8e +MOzArJ7uvOlbxxEZ/Szhq6aifzUwvq9BXYfPbXEyC76jh+/ETuuY9vRyQaOsoEx8M0eIyxAV +kEigMGsDLBGJb++WCv2Dpt6FuZrdLqpAjkeyYrwOZ3ZrZ5Ix+H5xPZDJbz8KaG2fZRjWKICD +XqkTPBUq/BkZ25eNC7aInAQQAQIABgUCVnwrJAAKCRDgwScYo+qi+aymBACWM6Q0Dm9BcWAP +yRtkbAmMEOf7jhzrJh+xsBuigOrOXtogtrJtKfxxBUDELY77gjuf20/NxYUqfstaVO3y+yFR +dynbNGOmIWwICxvWnAh+4KvfeL4cF7d8x5sTrd3Xv79KyncTt2rMRdhCeItO1COTiQ4JO+OR +0b9m/JP/CkANwoicBBABAgAGBQJWfCsmAAoJEEoZmob9Ssj+ABYD/2KjFJ+dRw18n6V6VLEM +Kh93nWoNYEl9V/U2z39iNe8Smxt4r9n4QC63EJSkojAz5KBCd58IPDmHAdbmzvQ9i4G4jHvl +R+tjBpZ1j+Fmgy0dfs7KHIuEvyX3N42P4PPcL1M6JdsV2PxWNAH6ptA8HmVxTzEGTxHBXJzU +BaSMNWawiJwEEAECAAYFAlZ8KygACgkQCxIwWd7Mfo5n/AQAifu1vKPVRtDHFEGF54Xu1ZaZ +3ob5OQiuMmwJMRy/uCoR9Y61YiVhiVyA31CO+m1BPeSctyQmIzI+r+wKNClA4aWxVDdmS+Bo +tV0r6PruXRLh5eP9+cXSgVOvmftmY45z/9nCj6cU2f24twbSJ21NE5nWZdVw6Pa0IGYG7EQt +oMyInAQQAQIABgUCVnwrKgAKCRCbAZMx6a6QOZ+dA/40L8bSSGLwkzuM+oaXa3aWP1rguEIq +9ldV18c5mLxjJRwFHNk6YFM39il1c9yrWrIf/z2jaxKSGigjDsVojZdZttj58VqqS+MtdHLn +4n7r+O3BB4ljN+hy4gEjH2Zspo4u9qIlfI2NWMwGyMZ0H8Ow7vDm/EjAOqSgI0w3xWYgY4ic +BBABAgAGBQJWfCssAAoJEKdZS3SAaEPmBMIEAIN4FI3Q/H6MnI/0iH8+al2mcimAMPW2CyY3 +qDezDGubiOinEJjrPCiWLXj8B3cOPRw9/9HP5t9sYNoR7/GfjtmobGEGGC7VX7q7T9zLZBR9 +2j2ZZPiWs2hw6/d5qAAgWU2fWUrGk/RnIWQhoGWks2CRgOrWDjM5XTra9GMTXcJ5iJwEEAEC +AAYFAlZ8Ky4ACgkQ3IDEM8fVUMndeAP+M7TYa/5hmHieugUp4Aqzg8R+qFPp3n2nP0jZC6Qn +lNAAvONsxoV72oiyHpupXJ9HrH1AssCLbSNCmRwVh2uB6itKP5FHvU+j8dJnphlQlbH5YPm3 +KB8ahCjDidacCrrKfjaLDAyrsuj9ewJwxHZvArYeOeW6Qupw1H/ZSbeyZ16InAQQAQIABgUC +VnwrMAAKCRDCeVyHTCHjQq59BACbnQANNZhJdzZAQ/m78L5MXsirEFme5QqY2Be9QzThUc/j +PjGnQWLC2dXuNbBBp7whko+GKjavRnb6reKW9gGToZfvWuMGwMVC4frLuLglHZ66bW2F0uDn +sG8Bq0l3R91PV62d9qTiwt2HgbeaHLD8UNZDUC1A0zXbxRPmAHxOj4icBBABAgAGBQJWfCsy +AAoJECLweT4jP4ZPEiAEAI1JW/UGZ5T6Wn2nvETgsMY9v6sqNZ7l9PJCu5xbrVv3ynKG39V9 +3/idxVhIuTHWfmP8b8MxX3ZxZc0svND9S3JIUUNcdZu7Y6WHe3vRuBZ1zInVkip1KeWblyMz +P5ZCRv7AYa1KjI+iOKOwYzLAouuwVfafe3Ok0MuabJ6mzqYEiJwEEAECAAYFAlZ8KzQACgkQ +6quQwPMhyrVvRwP/a+Oew1+kH8GCSHWwCnsjhFl8gVm0au4O4ONtx3NeAcyEwET+0tabNlLt +dUDZW80tJb8Ynhs768KSAFRcRsIw5AIEtQW+dZBHpI52KQXJjsPgGoGALlPdSP/xR+xCl14M +q8OxHZkjSr2CMehnh4Qh1i+gE7uWb+385AKtE1Ob9FSInAQQAQIABgUCVnwrNgAKCRDkmNCK +71zLNlwrA/0UXSbZCeWcvKg60ypVHZcgA6eATZy7R7dnApMb66t3aqqvlQZt/0whInAmbNIK +35oRkDRT3E3jtUgwAsg60AdaZWU4CczAiWmdt2iR6LkLBHX3XtwEdm19b9Y+WkNT2BDwPZ7E +kJgmuufHaDVg/V0VMQaufd4tflDltVETVgeMM4icBBABAgAGBQJWfCs4AAoJEKi7Jdg6FVKU +k18EANeYm6WEZQ9JL/lIB9sCT3WM2Rb+9hgzEGH+oOIG2vfPENlPAnxz8fhQvIAlc89AXmnj +oZO2i6dMFDIgQCCRmViYvBzIY+nFY9xTiXf1waIwpPlzhyNusHboFHVbDmF2i9Ck37g/TmUn +YqadvwAsOQUBi8XCuwbscNvgXvMYL6pFiJwEEAECAAYFAlZ8KzoACgkQUN56cCsBXkhNIgP/ +doNip+ug1ZfEDXtkjlp9GtXf4kVl+QMBjVS0BjFjYwadiUjFsTaqt8DapTpGwsR79eE9KAQY +kZnnpQQ680cjjppgaaXAan72nzQJSN6kWj2etfIQEj/juGLy6UgwK9fMoE9hAzoNN89HXdC0 +KVT84FkGcPcDpOK9VFTKfQhImVqInAQQAQIABgUCVnwrPAAKCRBMKfXqNgUThWmKBACSTRWm +diXiW8UfZHz5chiktvyZ2II6D6wEHxysigW2ruD5KzJ+eYmPfu8qaaWqtaF1zJEeNmOXxs26 +faWDkDYZxEnb6v/QN8bah2Jen2YIBcssULsDCniKbHQ2JKw0pLkMzvIe0XrByYD2RjaHa+CH +RzP94w94j4isG4kcB9fqSYicBBABAgAGBQJWfCs/AAoJECUxD6Uua+hVn7kEAJIzvzeKGIS9 +gCh510MQkcFKF13ZsrEEi3scOB6YSWijBq5VmRUo3g6desVRG4Z87xmv5cchHFdmt37BvNfp +xiQEOWZ33FGlIF9MD1e4VxIUqAkPIh0kIsHednCii33cCFP9OhM46/N3rStgpztiuiZWYOJr +WAodEBQn/+9F3CQGiJwEEAECAAYFAlZ8K0EACgkQlGWkIqEfYCjoVwP/cdKSV+BJMiex2kn4 +uhtadDS8v6EKLynxuf3aSx/8JdWMdJycmDgJHB39ZjnxG4BNIRjGIANr2GxX3b5EyJXyn49B +G0ivXI5vWPbZUM7TS1j7IqfdGSxxzEiS7W44TJYaB6UpNCnoOg1IEPgdGZvEuWK5lQbcX/iY +cH+Mho1d2n2InAQQAQIABgUCVnwrQwAKCRA39Yb1UmepXSodA/4tbzapRvnzb2YD3RYrn6IB +954/rwnuIQIwEiJY5MgDitY09xXBCRNnf/NYAbCkHt+wGu42Gb2SREAwS3yRg6TQHhTzKm4f +Hbm8gWQlZIu8SRDkKutjPXzLPWNUs2eTQR642w6Q62Nlz+0GnOngNvwxrPPrBE2jvdcs1As6 +LehoBYicBBABAgAGBQJWfCtFAAoJEGufCpE0S6i+8kYD/05wTQPYJfdBKBZOJowg06DBDsen +vxch24QMUcQG9aUAXhSlEWBlzaGZzNbYjqi0UMVjSOWI7J3l7jF2ePDbPYd8hlbxzxdhLXZY +NNjOwqdBmj/sYYUBVevgV3BfRuoxT8U4t34o4Y8zINYbLWdIUeu9ykbKWBuHowV4vVIVDtlE +iJwEEAECAAYFAlZ8K0cACgkQY/AteCEY6pVlZwP9F2yMKlN808nO3rydyC/zAcDKIvDVh1yk +5uvV/3TUZdKOocNdPbZRFXPBNmdukwt2AuRxy9+aEhOV9BHMTzKE3HS/1lZZVNJi2MxZwzsU +IgzdUiqBs/CJvk1s/0HWGbeONAktfO9V4+638sJDJXUPtnL/V8qelDmoYe3/aJADJJCInAQQ +AQIABgUCVnwrSQAKCRBnKrMV/2AucfEXA/4sQK/Vb5iur/gSQ83Aajjewzxvwn7nE8ahMQQt +l/VRGmLhHWnS48PIR41EIccGJqz1ONQE/RXGlXlkgtR2mqA1Ymbx2cI4KF0Fm6bQPkHHYuhL +9eVkPegujEiVlAm5Go7OzLHQxGpMlRc/iRr25qJgiDJhBOq3ypjUP7TCvhB8joicBBABAgAG +BQJWfCtLAAoJEHJvobQ1cqt/EF8D/1aouSYe+QZD6bfpD3FwIndmdQc7kNJIQglE6PTcysjJ +XXANtsgGdAsHdG+nDx1poXj4VYF/7FFWihlSUU01OuiqzYDfi/9sEwaCdJ+wNxc7Fz6o0Q0K +Ia2iD4v4Z/rYA92LF/so9nBzJrhfx6tdOmpP8drE8pGMisu7jxuGy34FiJwEEAECAAYFAlZ8 +K00ACgkQl4zoWZ8K7WiUUAQAj3/3B8KAZXroKLhoGq3C3/mmZT8ZhnLkrVl5by1xq6aARWKy +RGzTk8/xtrpn05hzh4q6Bl5YoOroK34dJ26jWMcAKaxGN3Ui9d/p7WZ9WDevhOBRMHZAHf2z +Mc+Hb9ukJUmW3eLh88GyjJUMc43FDq9EVNbIfFGDylnPwdxHvkSInAQQAQIABgUCVnwrTwAK +CRBuBDgY22DjHI/WA/481HyqjTTBEUoWkQ9+4SAbecWuNmwnuVsEkeIMaORe0Yl8vg4RDxj8 +lMOqUbieKB5p7qwDfmhxx/VrFVa8cWjNeT7n43AdMjI0EU1DoEerhSYHp1hldJU5qGsgYMmN +KD8nXtibH2GkPJGcE3uU5Z6njELmC/vlizSmYmGKGPp7aIicBBABAgAGBQJWfCtSAAoJELp/ +ZvW52zaynEUEAJaYiVRZtLk8IU2mWEUlv4EWHIRZX0QECnyN5dJV6yPDOQFnt+QoWBPLLwPv +JSujJdFqFWrlYiM5NNOHAHMKtbFbJ+xQ/lk884IC+pNtq/8ARP8C8LLkVKx22zH/bNwv2Msn +61iggk4bANSffQjHVYbAkqTBW4Xzs1PJwPMiCjVtiJwEEAECAAYFAlZ8K1QACgkQ5ySm4BTT +a2aSHAP/TUEzlilW9FGbZzDZ3Rz59DK3R1MpAa8vDVSoo8pr0hHBgsqMHeXXqM4UtQZODiMD +vfGUryHoXUOReuLGGr8HG4HPFzKmF8acuO3jHLCmaJj7zRNbAQ8LJPDQjsykZ92bw95d7CrU +hdLcosjYH/4wTewX0l/Klrv2bb7GhLB1GtiInAQQAQIABgUCVnwrVgAKCRCOiPUB9/O7OPsx +A/98dEXEFfV/PVJZ2UtSv8hSMuMgu4DmRg8weZKT4rUdzL4CDEp0UfCoksIFq6U8jIiqftel +MXAwQL/QczLZbrm6ILyE25xVTDv4fpjEcQgYnw18jk/7DA/dT2Jpqi13HGz00DVLbs5jrhpz +mUFKRYw5wcmsMsohwhUvCVPFctw4FoicBBABAgAGBQJWfCtYAAoJELy+K/Nfo26eOSoEAIY7 +FGcxWpyohDzWj6wEWPnEo9v/IKeJzJHq7HDy2GJiP3MOu4DvGyYacvEjPZhFZzk4TxeqsQWZ +fweZEn7SLXOj7JPgykL8SXGv5uYei6azpEfJp3iZclQRtbg3kxlC6VNpDB1G3zKaTDokvAOo +4pTDMN94FZTaJMEjtnujZWomiJwEEAECAAYFAlZ8K1oACgkQKKzuLT5w5q4vSAP/WkGV2NBC +5D8WXK4HjYV/4meKIP6x0Q3O4C2Rj2GYfYxB6uuaHwtNhefiufMLL3iraYVmNQrY00R2V2GX +q+/M9xhLGWXGCijJ/UIaPL3w/VphNFE7AmCFTB3YCHED6avGTWfyj/tdBZqP+hPej0hx6wrT +q4spYgD0HCx4QBz7xF2InAQQAQIABgUCVnwrXQAKCRALKmp+lhJik33dA/9PNGNVRzLq8IIw +neEEdbnNF92qEH/NZXqrM6QacwpiY6rgtz6L3xLA5x6Tyvp6KzdClUCQN5g7+jTX7KqymhDb +DMW2O/MrZU0BZBQCXTiOjHyeMityopcQS9Huor0oyMizh4VRZpLFDMT1ku/pUW+Q3l/HZwji +GLtFrS9utVpBMYicBBABAgAGBQJWfCtfAAoJECmYARkru0baH3UD/jbQ12QGjW5xxE32ag76 +x6HzBgco/x5KeX4IGgVxSMgLTUNqqxn2UGmDLSHP6TmJafHFwENg01UL/THp0arKHnAdGu6X +e0cBRP6uUTkfAJUEUI9+nCklOAaAWDJgGk4AoEGoZvyVod2bMfTVFd6RXG2AHIfX6Jzq9Nkj +yY/fiee5iJwEEAECAAYFAlZ8K2EACgkQXzLKNpjPWcSYswQAtf8IFbE4lDYLIzK0wDTGZ88G +vkQW8Irb25XVzNtxxrEAhz6Mse+5E0bM+RT6T3+aejnozXk0AoiNFOM35qAgPV4EsMr/FIm6 +X/dnqn2svhexVjQ0W4FLVAHyhJURMMCT9f43zPdRVZx35MG3brmKXP5Qmkrj8bWCaMTaoINI +HhGInAQQAQIABgUCVnwrYwAKCRAnE1VPBAB3TAPZA/9dJAFyo7UuUD5aumvLO1d5zV80MoDp +MntOOTK7Kt+iIcsFRtpvqgUO7VYiCqZ73nCYUsq5o4Cnm9Teh9aBbayaiZ7CSoccAZq6oVnR +nqOX3jBWBQJCeAuXUmVnL6GajAIR94k3wijj1cvc+Nx/ag5WLemonEOetpO6Rd7oKiwcWIic +BBABAgAGBQJWfCtlAAoJEGwSEN0T8zJpqLoD/2NgtVISwY0P4hI8drKCjlPf6tlNwHVjsci8 +CX56f1uz0sIcPy2PXBeVfzzW71D2rGL6sJPnSZm+gZETn9GInw3XLSZZIPYRrDdIHq+WZXTo +vUuFnRLQC2jjPLtwlY+u0b/TmyR6nnNHD+nlkLKn2ozL6THy5uaXcbWpTb1J+miFiJwEEAEC +AAYFAlZ8K2cACgkQxQjunPo22MccKgP/XzNoYUABtLe5bfbzYIJwfZOfRyyQ2cw61ZDvZoiS +Imkl1k4eNnutkwNhSLLN9d02UWoUthjtt5Loa2uW6ztaA1OD207Hwwm6MBdbNeLzMs6n3/yR +1Qx51UrYQDDVjLHFuhorkZq2LnOlcUReooMMdH63auGioPfGmWLr5vm65hCInAQQAQIABgUC +VnwraQAKCRBrZdNjJmghtKaPA/90w1f1D9gi4LXukRn2RT3iedxFiJ2NCU08XyMBY4J2Tp0w +j+2wufmoC3wRexKzLCZHYillZkmtghq9kbYgphx09qaQ26SsMvPrmgC6MP8vG4O6UZ1R5RVU +Bz7XtcnWxq74QwSqSCSaClGnhUGBF6vrR7yAlAEGltufOCyk/vn57YicBBABAgAGBQJWfCtr +AAoJEMjhwP+N6YJ8K18D/jQ4ujIBFENKrMwLpsUKEBvJ9eglkysksp9HHkysraZadyjxZ59R +ohrjOlvQD8O0thhc2p6+R7LoVSHgsyXO3G6RSbnp+Q79YZbKLAOG5+l/ybv72Zd/KS60YVZF +x7xfUl08EqrpsU/XlLy6bm2H70dHiiVpA6GlFOJPXfNmqFJsiJwEEAECAAYFAlZ8K20ACgkQ +C+xLKgrGYrehXAQAqb6FIrd/rNRaHJGUM/3lApbQY4bXbsv2N/MwHaf3fHHt1IafESAuqvwF +vaGSNI9csRYTN0VD5PfOEliIaAGorvQv8ezHOJp8t3UVP/HM0sVlxBur24MVsy54s6ZlAibI ++Far9zN8yTn4DPtDP24ZeEIdNJLhNVhqPnx864Els0eInAQQAQIABgUCVnwrbwAKCRC1SOOg +6k2IuYXBBACOoFTPBFPVsg5IrmE3PPt+IjAAgQQI9/z2TMLaYaOA6w5NJowtmXQVUbzAnzt6 +xPYrR4jDi7ncTLasBrU4h6b+xMF36rn3DoZ1rCxel+9p8p07yutBG0cSsAMftB+m8hTiX541 +Oghgwbw6WBe9JPlrhvbxoBC1oZUwR0UNHP3l8oicBBABAgAGBQJWfCtxAAoJELDmpIPyIDID +LWkEAJvhIO+dPKW1DlBdCo8SAJg37e90ivzO/UBwZssQDEUReazZ41gyC4eezz4IAXl0cZV/ +Kx4JQ7Pw75ybt0jKFCA2b91JveT6L8uXAKxjE4BIxKOoHDdf0xuP3jEJIKXGvxW5SDzlzvlp +RJSllRogW8XchHUeKs78X/rsQez54eYQiJwEEAECAAYFAlZ8K3MACgkQFBUQgu72xV5YWwP+ +JoU09W76abgqiQJmzpknS/JJ9C4M7rrRrLOKtTIfMWA+Vf/37j9gN+mk7mBFk3y668D5zZ1V +FNjSEKMb90GPWzOEn+L2fBu9d/za9iL/gv0Jj4iZBFQ1G+mgNjrc+4CSBhxj24T4O/ni+qDs +X4p1DliLVnLC7djxRVXgoZ6Yu3OInAQQAQIABgUCVnwrdQAKCRAT4KV6nPB/s/McA/0XNGVP +mnEffNXF2bLsWBvyx+sTKz8xK5OPu8ctXtXmFE2IY8gwZgE8LOAVQgMSKR5wc1Kst8LOC0Lt +vjp1tZjkaAwds329q5QTowHXZw08uO+H2GZXAcI/SOkB0GDL/TKJFvFjfqrGeJaVRtmRw45I +Fdbb70mFUNqHP4w1TJgsq4icBBABAgAGBQJWfCt3AAoJEDQrNvF2t1hcFH8D/2LaIH5br/gG +byzb+1tBK+nUDlgZuf9XZwwqjGCC3SxT0s4cxV9UB0K9w8GxfprafxdSZ/8HMR3zutxSf/TY +hucXO50Q8GV9prXy7DRtC2i8//N2tprsNaGYWVPeBVZJ1rEJZGaczlFeeDoi6HisTFaTdVFw +rIW7v1J0xcOFmnLNiJwEEAECAAYFAlZ8K3kACgkQ1OiggXC/qHq7hgP9GIzibr4+6eQ4XinI +CDQ6WOx3tvrORupGx5AAjh80EbPFbOzOtUb5FkEAZirIdcF7R5G/k45zDE4/Q4vOjfQDonf3 +2kjNjjDUgQGjQX/XxQ1YgRUll+92anZlxjPKf2iE9cN0/AM50EMZCS4HZIwEsrFltyGxIgrl +ZZ/F1QcyHCmInAQQAQIABgUCVnwrewAKCRD7cnWaGxzHhoASA/sEqgm/zc8PSuV7DS/KL6Ys +mWU42p3MOLVRb09cUzvkga0UNHTXn3Jpo20lAWuU2dcg5GWwPQ/UoImCIdKLAnhGh8r809TI +3Ejo4T7g4ssRYeZmF1c8tzStAjqNgTt+CUMGyi5yIQx+QXxlu71gC+kx8EPsNT09KCbKaB3h +916UaIicBBABAgAGBQJWfCt9AAoJEGbNKoVIUNoelXsD/1rWWvv4JlarAUaJR8PzbEaeF6E/ +q8TRMVGciQuZK18hIyfY3pQnTzcfB7zgXIUta9sGEe8+pSxz2h4BYWqq4k64uIhN4VjKOZqD +n3m9jVC6r/A7nPXAn+S5aXBnTJl1x0LCL2BQNO8ZKohNnwFYU2tq3e6Aklf8MXSzOouCCU2o +iJwEEAECAAYFAlZ8K38ACgkQ2eovo2wrbTswSAQAnpPTuM66AaKhTqGhjL1RFhF4l00iebwb +IP8pZIkLPGDLPMoNXoKv+ByaRYu6oZ3evQ1KrRWNslsLqFygnNzpyfoljbQyt+9/z8wR0/9d +Vv5F1GdECdM9bsK9faYD/fx2JhODKxSdaoptRUBhLIQIwBvposVbkZ35lBJ/GFzyFNGInAQQ +AQIABgUCVnwrgQAKCRD7rz/ABCAfHYLdA/oD9Y7ItqfdGTnNeHO48tCB6Uf94yhHpKcHdBoW +2N7OYAdgUN2oCwovix5GQwiPaewONa0BXUuJBH6IjdvN6cwOFtxs8dpOTP/Q33EwkYa97Duo +tqz+V3aOsBNBFjX65uErRcww3uwYrYRZjpeFxke8NEWpX9Ndv/JgEpWjjHBtooicBBABAgAG +BQJWfCuDAAoJEMAQNRrrwX13ZFQEAJZfNK0dFP3QYjpc/7l2P3ahyV9890NHyR4BiKaynx9d +Ps4ZQh7dWx/czxFp6legK4tDWJixqUwiN/DMR3G4C4HYa/a6O9w2zuNCzfVI3wFJT2RMPfkT +XhV2jZMo24Z9Hmpz8xA9wl0o3D/HDeoENvYNpaES2LJcpgKVFQDJCNB+iJwEEAECAAYFAlZ8 +K4UACgkQelsOuU8DVtGNGgQA5ZZvU0LBOqY4tN+8RMu2PRZCkb1O0CHD9CqG0aQuiT6hahXo +JblI0EH5MSE4qwi9cGpvT8TLXk9nUwHIGJEL7y7MD9O76HgWlT9KSaBavaJtxE0C50kM+axF +mDG4bWkhEUiV6XTyOqCx2jjrpShNoFB91oUabsbJKyeWkIxetayInAQQAQIABgUCVnwrhwAK +CRDSdOeH8TzInZZGA/969UDcS6qd8cRkhre3BLkjjz9fgHS7ODe/dGWPIaiTsyIlwiG6xSyF +ktdN0b/R8u/zCvczhqtg59UjvQsBWWF6R7VeODRkE8ocnW8uxZ9YEg8NUJyAeyTi+d88hIay +Fkb0IViJk89fLsWdhY/sBeZsUnS8wJl5tTerud8v7W9FtIicBBABAgAGBQJWfCuJAAoJEAnx +AN7TjuVwt38D/1T9rlaEjm2UwoVZRpmm2rhZqbbWUMvph6ZMT48PyShoiYq1hU/R4NdFEmrg +AoL0giS9ZKzRqZMLbD7Ldt6R9IX2QObcdZl3go076btAQ7Q/XT6KskHeDBv8zmpwnWvWLOPr +2FxCbVNH7afv/Sj/dXUBmv+DsxMOekXzcVc5ANPaiJwEEAECAAYFAlZ8K4sACgkQfPBoVUrL +AXZXegQAtIMswPkFlh/UiGpq0b7nE0T6FGETzEfRJv/sixnkaG9+iu9A99wb0gvN433XLPOx +Qjx4Zt+vnGYXVSFF+eW6m4NfkrzjcKRLsxl0eZbkDUoEvOUd3rzs/E9xlcqPLuRt9eT1Devb +7n13RvKveIg/IczkOWCAkLuhHAwr2D7uOAqInAQQAQIABgUCVnwrjQAKCRCdBHwxhsnMxle5 +BACHIoqSbv+52pAsYKV42yW1c+RkbTOnBFGoljHwQUVLRT2cCCBVqmXGSXLffHcaKgu0BTI9 +gGDDL3vmyLB/TQQJ0NMxXHlEhLQuUZtoy1eR0//wsjoxTDP+qLAsrU65OERjJD7bRFEJJZBv +iRWDjhcIvjNVpGpn7Or9Whd13/LhUIicBBABAgAGBQJWfCuPAAoJEPDRM6FbD1It7b0D/2hV +75S8w+7zG0fPkn4X8jRvv+6WWuHFVSt7z7qGpJjM3P165qIXJ6kD0EuOZMHpm0kMlxhh0ilA +4G0vnmBthcA77i+F5TrDmBpFkzPfHVsFypqq/iCu7lm0+Op9LKus29vlMon/eLu4PurOYTTn +FNMTy19jF/uN9aH+/42SQ9vviJwEEAECAAYFAlZ8K5AACgkQEQVZSA4pTF20eAQArxO0M1lo +fM9WBBW4kPaxDBx8bYsK3pdN5n6KEq+pxwtRGXQvuJiIlwM4plxRyhNCYziVWCY7uhPY3SiI +TFocFT3oRTAzvyAO3POBadENd2Y8DsfihLzcLPUehDO/39EBSGCq83qmibRoS3qH7AOlx9yi +iiRez5bRnrnRt93tDSWInAQQAQIABgUCVnwrkgAKCRD9ft/b3K97N1cnBACXQuWMRAqUr0KP +yTbBYGjuOIEvveICtPNYwy9HsuzaqQW79HhahUkde8L4g/5DlbbYgQbEVzDh9f6Smvk7lMxI +XoGP78iioGRP4I2OnAFm5Kc2sZK34gkxFt8UTvz4Qo7nfD3Uw1hoqoceUE+fuSa6gDmJ4ndu +jskw5vGABo6RioicBBABAgAGBQJWfCuUAAoJELhYMRMTc/G+YaoEAJ4olAcWn1Af+7peXKST +VI/BwBDzlE7Igk74rsgEeodSthIfo31xEKyOrnMfYnYIhBer78AjF/31XscdTof1Ze7YxBPS +d66Im685Jrhdf+Ntj0ugo5HTRlIlW4sMVLa+KXnGKUTL2JchAahCKHuBzrRm0WpD10P2VMAH +OMrWEsW5iJwEEAECAAYFAlZ8K5YACgkQrp3CxS8lGwlt+QP/Xp8nXamut6HzmQoFsBirJwMo +QinwjvGjzDOE2easvSFTCGLnHZbvDnXoSqVg4h3tzTk4kChvTHPZMU316SnUokwqXmH03P76 +Oi/rjOw3WIR434OaOG50ALraHNxlxaPJ2d0IurYDzqtcrEBXoBCYwSvlQCYtwTIVH6Ih3tcq +io2InAQQAQIABgUCVnwrmAAKCRA95vxUuPCmvF1vBACloBHHd4W4pRS+T6KcqnERlBayh2g+ +FdpnfmEYX1EGn1BzjPqZn9leZjOEAVMFFA1NwPl1IXaBX86+fc5oQgA/Vv/5TtftyTET4Dvy +9gyKDvY6iJIkB2lWfL4RDZaA9p9g+6/P00dh17JnhuOGdID7+Q4VJFiw1Icbi73TXnA3soic +BBABAgAGBQJWfCuaAAoJECnx1jZO54AMnY0EAJoElgmFk21lFpOs4fOzcf3x17+fDejVxkUP +/9W7YM6PKqJlCy/Fl0rUqUx3C+0bxXSmA4g/V9DYDOJACN/BooUy98WwtqVSgSfZh6gDPzdx +USDPYucuppAG1bIH5LPxhtq5wnhU8QHNk62FZ7kJxKkqARrrX5XnRySUypIqxdpDiJwEEAEC +AAYFAlZ8K5wACgkQVDneVZXyrRCXzAP+Jve0KSDUa1bBxjYB2S5ZZ+NEO/W/ljWtiXTYMIQS +L9laBPqDrFXJmg9ovMsOSY9FNq5tAdHeG8t4Mg4YLVRppGhwnq/u94Yytau3BmeBQ4G///vv +LUBSsa3FTfknvyK0TPAaJE/3qoxMieKP3gxf/uATDkWdti+wVWQfa8vdrNKInAQQAQIABgUC +VnwrngAKCRCwKDKaDBYRtgjHA/9bQ6Qd/SI+MWnvFGwqSYapEc7prWeUoxHyxRBZqYEztL4h +wcvM+quo5UPXx+bLMvpGVurAp02vM5k06wQraRe56K/M6WrOnpOhCq3AdzaeJRjaUGoukNSw +Nzez2SxLABShEe9xGKsdN0r3VGDniSqrGPbk966ttW2E90HVZCRikIicBBABAgAGBQJWfCug +AAoJECj/mR9Q/jvdLoUD/2/LhaJ7ldU/sTlL2d5C1TemtyD1X5psJzdqNMQeTa+Cn7LEwHXA +kwl2pRGawPbrUunq13+BQwUQRKKqXli1/jhqVzOAXYFP4loOjMFE8Ov7M3+5BRwYog3ebgoU +TeHTfe8McLaGo02iy45I+5vbMeCp3NfQ8yf4aO50+i/e+eHniJwEEAECAAYFAlZ8K6IACgkQ +NCGD3zt1YZHpYwP/YkVXEni9WSjqgf0E1k/LdVVWxQXLhmFjOvoow1lz4Z2kGvQW41tujOOt +q6Rq2A0EzQO6QWpIWO53MTRiUjzAD7DxdHCgc8a9BVL7GLTYt+on7FhNH6dKnFfCY7yEBviz ++E3SePNpqykj9+OpjxSE1thcYKc1xBsKe7FkxQjxMfOInAQQAQIABgUCVnwrpAAKCRCk/7s7 +50b5DbD9A/0Q7eGDTDvCU1JnFpHOPwgO3ZgQ7OcXFglPe1R54FqlModtG/NNPJp/3KwOJ/iS +eFpCxFP/kimcrwPN9YE3W0DdsCYPRuJbeEsJQmViPJBrPB0FwuTqEyyXpNAOBEhyKpqIYHs7 +IimUMRiH9TNVb7aUarRBOg3N+91MQctTSC2QnIicBBABAgAGBQJWfCumAAoJEFDQRRPZE7kn +1JoEAJ2p7DhMSmDAlSd7yBXvDSrTYeOZdQIKAq6MYfj6FSE6RJ8JIT1MjHT90HognpKedq++ +Lwlkk9jQA4Qw5pV5QlPvHu3DfLuNiSvFmu0V4Tk/UDCyAMEa67y56s9xeXQLoa8FfI3ZkTTF +tjS6rplhTP6OTSts9638cbnhgm9NRrrLiJwEEAECAAYFAlZ8K6gACgkQ/ywU8ybl9+2UgAP+ +KlvGkbnjhM64K7/g6b4gbkR9MNy12d1xYcoQ23IH3yCxj6tI9LIrWPpkCTlvMDdJN24bkRYm +s3oDjRIQY9LyvESHK2Jor/SEszZmq6M69bQo0DBWu2LBLtSvyGSJ4uL12ux1U4jOaQ2XU4/r +5Eo1J/+ddEgNRd9zwDvS4C/mxIWInAQQAQIABgUCVnwrqgAKCRBzdOEuu3WKuqMIA/oCh+hH +w6serFqOg20F8Pad1tex1CaICgyZN+PfPuyLg+yATiGhTUFOGpzVfkJlO8u+ApAWCmjeVHOL +Ulm941wkIeA5yZQ/6CCt+t1mDtjMeKMODZ4NVqyRujeSS9hx91M/19avDebCHhbzYYK8jarl +KamzD2PqdnZ1WZFeR0uVgIicBBABAgAGBQJWfCusAAoJEOQ40X3FKVFa6bwD/1vbAFXZgZn8 +dyVAvauSuSCCoBOki1Kj6xDX2Rpg6nhEwVIbJ7/UWR8i6/fP12IpCAPwS8Jji3C5N9lDLvrn +sLl2gJZy7cyYEUi6TmGVXjjHWOssf7seN76SIm4bbV8TAz4UqwDw7AIoXxca4w9i37rpz21M +dTGBCXYbpmLrQNi5iJwEEAECAAYFAlZ8K64ACgkQ8Z54+EUs2R2w9QP/RlbMzLY6mBpuyudz +FnSjQMJKrisVZNRZzqc/syKu88iDBJwPNfsGTJhwENUNIllykUTj68OfAV0/Pj9O/cQaNWAC +cw7JnFdISzu4FtmEO1s/26M9NWdshZEaSmWx6JPLs3abigk0vJnPjGiZm4CuDvSqzppgbwj6 ++MfgvUwxOsqInAQQAQIABgUCVnwrsAAKCRBc55h/uHeaJBKKA/4z8ZLCLrP+y0hga9GpYDV1 +jVOX/A9M8e66csyS9+yvMjerGWichPydRuTd3y5sPwOCnFOIsOphqqFdeTdoYYQ9YfmfuY6M +q1L3Uhx/0kGXI53J+7cvcMoSYPHfgP7XdmmPBVY/UIWGp0s5N7duGqo41JhXG6olvH1BrMTF +OyHmuIicBBABAgAGBQJWfCuyAAoJEO2hzwunUXzut1kEAJFOpFDo/zjSJF/xUqGpRl/zQ8I8 +RMqw/FJUSQpV0kFJLfKsKNPBSIO5yJlionw9XLHnlUv6V44f2z595/5n2f+Vo0kbFJAOpaHy +nw5ereaVlm1pGNRXRJNPBsdmVqlodG/rkYFjytspO2hwvJ6XXJnqljvdcD0EEQfgSQQhfW8c +iJwEEAECAAYFAlZ8K7QACgkQQLT/Dhm049RRIgP+KmHliaCc3jFEAi8+vIfjpqG3qEU28NEY +o1Vcgl1GLrPs2ik4tdLNQOImg7o0htsk1npXRKtXbyEqrb0gtdAQ7V3oX4AfRVHNDgU91MAn +xPPN8rjGDg7mGEwUIqv5s3M3mWePmlcEyIkdvX33IvDGKuNB0sHFRDwNrzbzJx6Tr4aInAQQ +AQIABgUCVnwrtgAKCRA5sqSqyPvDgWQNA/41E7PHX+7Kt0VYunEDIugpnruDEXeeAR6uv3qn +7feB+LP8OSBB6c6Jeh6jtS9pht2s3rJ4Q9X6pSdvXuN7WVhAsG1DrDleUHYb2jb2urS5n1SR +bkRNQJKsr9g/b/IGKjD339VEZH9YN3eaRacQNru1iyrjCgwV7TW2xKqaTvy2JIicBBABAgAG +BQJWfCu4AAoJEKhtegiBFYZgte4EAMKxxSpnHUsDpcn/CZLr+LkiDooTx22IYPoO2HJIhixS +SZt4kl2He2PaLc8PCuG3vIep0S2KXLa5EwdTY0VFlid/u2cvIP478/tJnjf3t4A3UXkpj8bs +Ihir1DSnvSnoDizqYAOMWJUGXUpGA215PuUoI8e3wG8kwK6x6WCG+f/yiJwEEAECAAYFAlZ8 +K7oACgkQLD5f1DuPMTzVswQAgvp725bjEyoX8DtyjWrI2Vn1OgkFQBC/FTeQwcQCs+kNuIKD +yiv/Zr6I9TOWOdcuhHDuT/IWVvJQhAJz2pB/hpq5Bn95uFtH20Dd9cREn+iAfFCodiVb3TJp +sH07aQrfE3/C5/ED2lVfV8eWv6qqJHQUTREI3PVW+TWpiz8BkcGInAQQAQIABgUCVnwrvAAK +CRAeXjAe1ugJFriMA/9lXZl3XBgrE1u6g+aPyjm0hM/lXYk64URH860cf2Ls0Jr0UnUr2AFb +7haX6s4uv+Os7a1iqEJ4FtaHhCdEV0aZeuIf/hCUpv5YfQoG49HPHm5/740mUnwRM2Kb4SrF +qJ57MDOlRc56w1RUhffW5Gklv3fA0bITtflnuGi7Jp7MJYicBBABAgAGBQJWfCu+AAoJEJRR +ieVWhjCtvxID/ipsz7RIlAMZxYxMFt+0I1wy365/ujrf1AzJg0dENpMk2q//fbrytHLWWb9p +fXoL/vlYA+5ZTsR8gLjTY+/INRzpbjMGQ3ukiT1Lf3E0GoADNR27/XMuDzWRwrsKs+XwdpQ3 +4EFjk72gB010h7nedpiVP9mxXgqYC3CDHTMZm7ziiJwEEAECAAYFAlZ8K8AACgkQGAlAVG/q +Y6dQHgP+IpLz3tit5W02s25NrPjj1vTbzcsKf14ZUC2IShr9mbALuyYUC+mGacen2mUP2wew +NIeUlgVbofbNP7tBp+lnTd0IJSOuPL9ejPc74eeyuxd7kfb8Hv4hsRMCIZ+HSXtV0ozSyRMu +Bbcx6MrWM/G73TFB7DPsWHol/D+AsfluKMCInAQQAQIABgUCVnwrwgAKCRAjtL/Up8bAONbe +A/40Y4DM36gtjfwcCaxs5BZDyafCw6WbepO72DfIJacgH29MYfapafFUfthFN/dhP5X0jwtL +7C78U0u1Un6WtcTGyFg07SAJyNm7t074afStjH+CZgc0lmunzfbTQvsfV3Ypy5fI3UAtpwdg +NL0ZHWNwZGizAf+SI9B19kKZgeDXwYicBBABAgAGBQJWfCvEAAoJEEI5c8qxWWmiNpoD/2QI +fs2GmFVP6DqOEPhnNrJSxbyFZ3oE74poE/28zYeH0qf+IbXDS6+k9cpGwEFIlIdtqPVURFsw +PqO5mgd7s6PrvCAmEEXQsr9sZN4OjYpGR1Qrgsd0eDixTeOi3hlD9bbn0jVJLWWfT3n9+jMg +AP5dCWHm2sbuKy84P2aQQfgqiJwEEAECAAYFAlZ8K8YACgkQjzIduacxwF+0ewQAi2z1dcMl +x+b3cGtKjfxMUEmp0dVQSrIjwhYZDm72aihzDeqEfvrUAdXmjBQcMY2Z6fhS62Ee5P0wXVwP +Bt0zMRNgf7OgJAywpAW9edDAKpNIyTAWiLvBTJVrP9KtokZgJ2x93jB/iqz2jpGECXmsccGo +WN9Jm3lRM43z65AvkvmInAQQAQIABgUCVnwryAAKCRA8xHQza1Tb5m8gA/0VVgFM1OnmHlxW +O1riIM3ZvESQfG8S5pS+FTdUEukQYpCCO3/pIx4rieHM7JH8atSLx/T4YqDgufg8BvyjvD9T +Gi7JFmSRDaa82eDMe7oHSAkmjEAwIk/Y40WS3lI4E8SZ0oVvVQQwlZgc4vhWfWtqP0/g9+uB +Jlk6sqzBB8x61YicBBABAgAGBQJWfCvKAAoJENna7RPI7ifHFacD/3ju74ikxZlGmLk4cnXY +CRMuKWE84YYWKRnsZrlTYCUBnfTbi7FNWzvnuglulXWvvR8s7lztbxPnDNCdoDqIdmfsRDRa +ZD/SjXCP+Boda6Sm6YbqGoEZmxzpZkCRbZ9cwkpOfpp+7T1qMHwFNIQaqKARmYXlDdZeSOnl +M04zurYziJwEEAECAAYFAlZ8K8wACgkQiq/2725kuM9lHAQAnmAAvpybJvVW192Jf8Q6/P8X +38g3d1jtyl2ue4njD5B808QmdHH0E+ES8J1gRUQ7t6ekyJ0WRJqWMj0recQDiJFGzrNmcMpg +wI/HwJ3djGJrpqj18gRACx7bQ3WksaADapzSGRlO7RGBDkAFYRZwZPVrz3ffK3vfJYXDqZXH +V4CInAQQAQIABgUCVnwrzgAKCRDs3VqHhe2sDSWPA/0RSQw2ZIvqj3wYo64YxjAaU8WzQk4y +k3JfqFIatNEPyHFMt4BsGmjcs0MSEeTcTLvOs8muwX8F9JU6tJxnv2yNX7pyn4A6Tyoiu2Hk +UQ1tfMUz4MHHQ2/oIHmGJas2hmR8XVqbk0khIenUJH2XAKI9KcA5Y3jVE3FM9l1FGrqVCIic +BBABAgAGBQJWfCvQAAoJEFJ/zZ74H7f7gq4D/2GJagddeKC1dNi/HjhnAFRlLEkCg/d3Bnt7 +1kubJxYYtl3jboob91podIDMyw1Zh2IYdYQJdoL/Z4rVFVhM7aHU1oT58xN81+n9P2gMmII5 +sXKyGVTbkV2GRZzwHHYUtwjAWhOT5VeKjdWXSY05yjGI/xY/2aPaSBqJH/mWz693iJwEEAEC +AAYFAlZ8K9IACgkQgN5Hp3FX12EgoQP7Biy+OGHM8pJiOL1zRHJmJ59fBfFE+M+p3efx2Lsz +9kI1SKn/NY2rQMVNcX1R4FCp9ETaIeATUyVxBKfgwP+KBLvdwOf8F6DXfb4JAH57LTZ0ysRV +w9FZlaozGqNw5LF0C8YpSWqmFh+dlX3snAantz/Urs71oIxvae6iQKuZjx6InAQQAQIABgUC +Vnwr1AAKCRCeg0/bQGgF/g+VBACXVF02A26ZRDFAA/VSF4QIQel/dqDwTdI2gyaYvtpjgog3 +9ogeuibVOHmBHdfJ8KZ1cEz7AKSVBQZtc1fDLd9o8seX5Kn1g+mondvxpJwOSCKXOxshMcKF +hx3Ff6CxyHsiEisNWgU0EloraBqe0e3RyflNI9BPWb1+UFR48AWOB4icBBABAgAGBQJWfCvW +AAoJEDXSv8xw1zhvxJ4D/2pxXygeEN8O2DNRqHOgIehuRsREjqTOLuQENhQflyVwv2sNjh2k +NuXyqj2vJp4d1bSNLyQ6dYNoAtMGzkcK4o3SuyxkLmSGmqlrGyd9+6Vr13bxVlbS6X5Mr3GD +msWxHfmYTFcYMIsbzyZUWQHUJybZcpscxYEIYow7oZpljvvaiJwEEAECAAYFAlZ8K9gACgkQ +7H9lC1HGrJeNTAP/X29ozaVoJoQpqjIkDF8vQ66ek49dhP82Gdj1YJVCNvskAly1zK3Dl+b8 +dXJB66SqwJNU+xaRKiskQMPE2qVUdZm7ZLgJAXsIGpatpzE2ouOoNmrmdlgOhyZ6C2mSPVYp +kt/f4CS51zOeFSUAg3ShtOjcIB8PYxhmT2qPT9qmtfyInAQQAQIABgUCVnwr2gAKCRDMuB6k +9nAkQPGbA/9Q+0609K0K15JfOYbIekxYDwplL9ok5WfQViTd2j5upyEMGWdgFi0MHsPvFo85 +N+R0W5eTHPRTVZk9BnLTRYsPgy/2eXnR/2gEzUjirM+LqCQJG8x19hzg503r9qV37YSwOmTO +x1UdBR8cghnBnluuQcQKj0Q7nMPt4IpexZjym4icBBABAgAGBQJWfCvbAAoJECq4RqcP9jbA +kLYD/iSNCWLurDo3t1tNFvdXsV/zDvliEvuglnBgUAMdRz0+PLy0wWqDT0e3rujM11yb9gCT +weukFHD06p0+5nV11peBFvBP/JtYHfNnoYjgT1jOsqfrFWV4N4RSpjXcSdrhfIpwSqiDvQYv +jpf+8c7v6ToEmv3HA7CkNpAMvUV0QAKXiJwEEAECAAYFAlZ8K90ACgkQRSz6/ResqoIFmAP/ +f/Vpmkanf/y2O++l2E4QUtaXFb/SkSnsREDNdTBhzdNyVmYEuzfX1ePLWlR5Z78Id6e9COV5 +4b3jXBPCyeEuOzhDte44MFaTFCHkhJztdWx7mIF4gSnHpdf48MfNYoHdIwY7Xz5nO/WGEOOZ +imm/nc+dvTj3b63lOYPqb/BbCISInAQQAQIABgUCVnwr3wAKCRCdw/dl6owutVUIA/9a/DZK +VAu8rWKdQOUohlYCaLEM7XiL3tuKeImoQScOYQjCDNveKc8ZvyRxn1fzb479T/B/D/YxxZpL ++OVeJo8NYDvA2mpT42Vmk0og5lOv2uPkOcGIaLj0AzSK6nOIuAsag7EQ2fCUDBUx0cu8kBRP +VB8IXX5o57+fdhOBpM4AaIicBBABAgAGBQJWfCvhAAoJEEjztB9KecJ+lKkD/RTpi8I8+9iS +u7i6Mkm13Gqpqj6v9T1yBxiXPCSUZneeyARlR9nf4/rIUCZMpVju8xwWClyeyyKksnuvd9Lm +C375aqVbHwx+g5aKCm4NNGIEpWXdZKJ7T5gsKdhdX2ZmQkg+izWn+kB/LoEksQRv8PMU2Q+h +MF1XuUPQJ/rNeV/DiJwEEAECAAYFAlZ8K+MACgkQEvADT77SjaJe/gP9GMQYqXRNvdeMlAIE +pDUPXb2n6Sn//skmkUl6cgGNE96y5Ty9QGg6yb9XAQ8asqE6NRzO+6Zl1panRLzq/GrYaGdu +FAnhHLMqbM1XiQI1QBHjBMBSV3c3w3nnL5dbyZHZWOGv/Rc5CSqY+ZCEutYfoNery0MJEXIp +iUJz67o+XM+InAQQAQIABgUCVnwr5QAKCRBjevY3Zz9sL60oA/0Z+Ij1JHTWx/8KIiNctSOy +NJ6SV9lVHdQd8bXgORP0+BgrXjCuNbNn3ZG+YL6ni42lk9MSi1iS2vrNOuWPW3yzdcfRz9SM +KKpWlDpl5J+Dmpjrgn9DdIZHzNlEewLGVSOt9sDpZHL5mFUcQ+K5b9i5ZLR6slDBZ3Z8PQEz +g1En8oicBBABAgAGBQJWfCvnAAoJEGQdnuOYlmTMsYED/jKN6Ys7sUYJeVDbH0EUwNhYrR0p +rbQwafyynTgmF/SU7QT2uwOulONWBA6gt+K+bGw9PVT4CsqXBbwQJhjAVk/UOntU5WxA0+rz +bEsuADf/FVYF8qBMKHtMM6TXJ9aCPV8NosYlyObEU82BESu5yIZ8JQe3dRZQIeJnhuEJACog +iJwEEAECAAYFAlZ8K+kACgkQSfSouBirTrYjFAQAkKvp1A63sWM8/0ZZcZOC7LwjjEf8RqqX +SZ+bZ/TTTzML3UT4IcTWx7VSmBpjnOvE8Knf9WKNQAaQPw9ZMcVHp63QG2v2V+F55JA/DvGc +AnVAm2vlsIFjQYfxq9zKWQzqQpnTm94fhiy2ktjbYIfjp8JB5eHeuSKBb2aZcEPd5++InAQQ +AQIABgUCVnwr6wAKCRAcza5aaKofen3+A/9dyzyiDpRpmsCnSBtFUtvm793gZkd9B7/U3bgO +bCyLgKDaimV6xk602Wg2aQxO/xfozi5OIKG37xFqChJvghNCOF0KGt3rY7EmBLq9TXeVYora +aSm3ZpOmjnw1Xph3rHadBFcsjJH4bVr2zzpYBuK+uCRQYdtpGtLBlT9uh9xXFoicBBABAgAG +BQJWfCvtAAoJEP8Zr7DxMoMa8voD/ikpLvMnAdxCsr1ee2jeWtOu71QI1bwlxDLlxdFghVmz +ZCXDQtQ6J8enkGetYKZ3QcpMzOQQRmzGljHd5Bw7Ei9wBWWpOliL+lnj6VZQWRrO82BFoLL1 +SiL3NbmBNVL273Q8pYEbCK3eL8hdH4cMePfMDFpxmIXZyiY4ygyb6UTZiJwEEAECAAYFAlZ8 +K+8ACgkQLpU8jNw07LB2gQQA2sJ9WYa3dsXMN08OooRCg7KZTLHavjq9egAdBnb5WtxWV36D +9CoTMcmsQXs5O7F+FFdSht6DGWcu3xEAmxvBmKTTMeeXCd7jZhyV/xcts6glHfcyx0RfvL4i +2EEf+ZIU/sU8dOXwRFYjyJTTX0KR6CVvBdVj997+jMt0XO5r2qeInAQQAQIABgUCVnwr8QAK +CRA1EZ+cm5JLFKieA/9TgaV/GWZQmLNV8mT2HZgcyIg3UkZXiybM6q4uNS0tXZbnm/XLGDrk +1VfzCT8DGbRBBUduu6kAuMjQHbmBP8MHerElsFDhSZCP09HzdXEZ0WmAiWTJKmJikSlhn5wB +455cSWEOV/J5p04v6KiBiNwhrJUjCSF+KbmzMYZEU54PFIicBBABAgAGBQJWfCvzAAoJEHH+ +iyo8eij/NpgEAJdpguitKv0YpoPBC+XAVhlubld0g7neFUPZWeFhXZdq6ol6hb7txhzdKtsp +0no/xJd0r0GEEMrYCZQzaVKUgzart3z6OyJKIQhLyD4JcAAOE8P/+QalytXb0U4EL/nMoFSA +qr1BCp7SjCG+D82EwFU1wJPmhtsGxFjfhoDulO1OiJwEEAECAAYFAlZ8K/YACgkQcTuXgKRQ +Jib/WgP+OfL09AbdmkSEgkkeSH+rRMe0rGcqr3NAmTZT4UhYfvAmj2VbAOVXMkoF6I7AxkXt +3yahiTghW8UqYXmahjhF3FB2hYzPXFVVVy7+6YLSxhOsjLdzqWxmY1Kmpg2+TFWNDzhkMQrB +CaWitCwIMmqw7vhpfqTT5c3b8cW8GTjC21CInAQQAQIABgUCVnwr+AAKCRALZm9bhfspunG+ +A/wMI9U0Lfzaw6Sq4IDtaGEF/CKeuXKgp9yTYh0fw5vEJYmky/LpDhJmlDB6m1UZg0BJHQHk +uPjRTEx9/yTu/vkfO4s8miBUgprYGz4WJmn4cXOsVTh/0kbfQRUGk31aQwY6gbFlb9JtEa2G +yFB/psnd4sdKnV0/3+riK/s7jOP4gIicBBABAgAGBQJWfCv6AAoJEAdNMYh5ASRYleID/2rr +BK5dJVbcMP2vCEs3Ng9IrCFPT+IH71EUYL5tJduPIVthtIl1RAGUvLXc5q9olrLZle9SvkL/ +bQ1l3TEAxqMmn7+1iqqgidPaqf3VIVxBTi8XtRsdAciiXC7xrNCrWo1cjkDEBFJIB+WyjRSO +vPeHnsYimNBaZ6OSD7tq2B5CiJwEEAECAAYFAlZ8K/wACgkQYxzfXGD9KPx7UgP/RlobixA5 +qug8r7uhe6D+WOc1pEHgj0FqWUk01uQCkoFqSUZfxO9UYPszjg5qjp9Q5qSd1FYwTwr7b37s +BIlvLcwaMYnsMy+BBUZAYexv1Rr0L8TrCbcnZkAvy7LsBeY7/TkFZeTEEWQzit0osy6vMpy7 +juwR5Qss+KypiLDCvGaInAQQAQIABgUCVnwr/gAKCRCRWy1ujGoDbcswBACiWmPsovjrbv8J +lvL8v9rUN54ZiPdFCKA4HWtWvo7keU2E+pU4aQENDL5ejEgVxreBgVKHUMDIRLRnKJ6JltbR +ijNcFZSPhqxjJISkYRUbCkUToCTwhooD3LbCTEU1OdSHRe9jk2TgTfK3WBbzTeIptIxcs9tu +DqwoEvUAL3v5S4icBBABAgAGBQJWfCwAAAoJEGRPM3zhaGT58DwD/3gVx/MkTn9dztj7XZhO +gcuD6B/rlRZfuWO6Xq4qOgBOv+Ix4AQTXXaFH1HYFqf3l87nEctHJwMEJxFK2uaKnRq8bAwk +hpPG4c54jX/w2r+EzPPK2A7eJjvCoiK+JVfZCFCgah1Fqc0kZuERJHIMhIUr+AtTHQAn5HDq +XhGJ/N+KiJwEEAECAAYFAlZ8LAIACgkQYHgonhIbLhMDXwQAuGLrraX8Z15kkD+g6GUnUSOa +aiickWMjkglZbCeozcHfM0+UtvuTYXmeGC1UFXjpZVdJE2VZe3H9NZ3WIY5f+uQNwUxyU1dX +UD8nocWsJKn8QNCNmWn/m87XUHt6Mz3y9J9mgZKchP4DXOHSyICMxuVZX0HLkw68GO57hHGD +sXKInAQQAQIABgUCVnwsBAAKCRBVgZUVvDX4b6W8BACgvMFwCUK9CLjLmfebBxAINEIcsy/Z +tPknb6Wq0YkfghclOQPiDZcUzVA2Wm9qmzH9L/kB2y6SCZDPs2P7jkOcnnDtLuJfcebwIB/L +iMzIgh9/MFmJSW5EwfO0XlW9p3uuy9VI69wMG/+D3AwQQCDVoZ7Ndjvny9TLmb0kiET6boic +BBABAgAGBQJWfCwGAAoJEI5oMLj60kVPGUQD+QFXIejH54HHntQZkzkopEYPrXN7swC/AavZ +WS6N9a+29hjxWmLKiRIZH2CE1JdqoP8HVsVXJK2i9Oks2JYxfu9e+VRNW+Yn3Ubs9E3b5/3M +MNu1wgL2anCH0ojY2EPgbr6PdLvhT/GX7AQv7BD0l8OHWovSsp8rJmFPjzLsxZVziJwEEAEC +AAYFAlZ8LAgACgkQWyDaQQSsCi5d9QQA1VjBiynYQnumrmpgB1+lf8viDototfBQ5g2G8nFA +qHfibc86sL01NqWJ9r723+uqOa/XJ/6lAb5EYEHkbB+oRD8iJD3+5jmd1frLkjHF4Ow3JV5i +axa48xKl1Mv46k1lkisUeGo6QTXmxho9Js9aORs8wz+mI8/0uMmkXw/3md+InAQQAQIABgUC +VnwsCgAKCRAOk27o2Fan/7RfA/9+mLsd80Aln1lLTpyWjBp8kb0McJ+d9Lz5XZI7vhe6r0zE +75lX5kibKtl4rLOg5BfNRzQwfBYCqvG8VUqYwgS2qC6mSygXyzPRH2z7jeBVAeh1MH6vSQdh +G/b0AfmLWYDgEYcXigvu626v1O1C8TXNZsG/0oVcsuIPSG3FZirQJYicBBABAgAGBQJWfCwM +AAoJEO3DEX7WeU5bPZID+wVsfSEWjdQeCjldLRPmK8XK9cVpqcgl+NefleLJtdbvnTyVBfKz +dWRYYmmVbL4ElbJXYgGoJ22HSjfND6Pgd5srqOSfefvFrrNUBofBkfzdFXmkS5fQm5tBj3QQ +43TJYWBCpgO8InP6W6IVkdTi1NYts7gMembat34RLT4SMjwtiJwEEAECAAYFAlZ8LA4ACgkQ +K17gmewBTETMGAQAmnOVV6AcjJ/5sh20CcPJ8KyJgAPraYaEuWV9ST//chXBrhSxzDxtb63U +pa9axQMB0G0uvrjvL/K0LWTxadcRXsKqft9aQBn1eTLuWR620H/93oe4dPfomiJUHOo5JB4C +Cn0qXIB8OCV0vgHUipOl3dx6SVN55ztYT1STCpB4N8mInAQQAQIABgUCVnwsEAAKCRDs6k4V +mq9PwNWbBACEHFi1ElwmRAV/n22IgrGXIp2s8k2gSJU+RtQZsXC+G6fQzH1P14sGXGvXIG27 +ETVRD2gW1LGeHucR2s2SZYhYn3boOL5WDBS9IUrJZ8zUR6k7kHfSfKLuczpjl4kCECV45ePA +Tc8QX7WTFj/71N4knOiCW7wfTJApTgCLGwhQkYicBBABAgAGBQJWfCwSAAoJENbsH05YPK/3 +5HsD/0CVCOoexxL5vYHsg/b6DplNwKsn35RtYqISXAviv0KhMxEMbJH58OYvD8Y7rSpgYGBB +xxBXF5pjBbOF4pataelAFpjmC6h6EOeoK9r0E7XF65zrO4wna/c/TOt8582rsrXQWPnPJ2KK +vwAnyQRCRdVhWnr4Jeea/gbFh9AlYwtDiJwEEAECAAYFAlZ8LBQACgkQNCrKmZypuOsJ8gP/ +UXSkjgeU4ULZibfnPXoQVVKJ3j6QdXK802oMe3gTWcm3x6Gkq2Mqw/Svi00r+6c4pyjaJR7V +nAHBkptYiWNJ7lhWvnhU+x5H6YKx/OPcMf895uiOt2nB/GqeN8sTNqKMzcU8JekxUV4aVUwA +XHT7PnSKqXBoQVjxZ5GhjfNT2K+InAQQAQIABgUCVnwsFgAKCRA7EkWRo8kD4CPTA/0QH55B +9wMBXQ3oq2jZnTeJ1sVBOvqzP3QFSi5l/yRzhSWoLWLS2mEEfLuYqOzOwjVcgUpCSy3ndr/u +Pt5KBxUxxT6zhKnOQW6a++l++lADyyNhPmaEmeFWPpQLf7kxlgeq4xyvZInhyvkg/JhWcHNF +H1FptsGa7SQ1WEpywmUp1YicBBABAgAGBQJWfCwYAAoJEAWtQ6X45K0KNjYD+wa0x0xTdiC4 +a8IXZ0dj77tDELdIs4RP75maV/8Ynkspyfk4l8Tc91P/4a59YBVdU/LZwa0q9F1TNuC8+r35 ++7t3lV9IDLiw+yXrvDmrLAGZ7xh2i0vnlMWk6kl02BWiwlEvO05X8jK3x9EDfOUu2/KCwxyV +Aaz4rfThdTzB8od+iJwEEAECAAYFAlZ8LBoACgkQcBEgwyxNto0k5gP+K9bFPuzZeB22yZtR +Q/KywS6EhlVanAd1Dp23Xe8mba9+NZpophVAY6vap++W0Q4RVDoo+h4wfx9KJeK9zzmHHVVw +y8HaGfkSsRtVVls0m04Cr2w6tWBAHgI4aUWh7x04o5swbDqz2/lfud38AKMhVkHfAEPUCc8c +FVo4w+WXb8mInAQQAQIABgUCVnwsHAAKCRD0o/+orMa2LFOhBACxDpgkbraXPpotP9MPAjN6 +xLSvlZmjWKhRcuNoT5CUqshC3vZzsi5U571Tv835gX+IfY36UxGmxXSFxc1dmoAU6uETFkpt +YdZ8OfkyNU1ZD/KP+nOBLzGtp+YDR4vbbvER9rTQl68thwA0wd+Ur2YpznYt2fsNlJ2TFoVq +sjsU5oicBBABAgAGBQJWfCweAAoJEE8/atraeX4MvAcD/3EQGYgX3GGHDMo2f/n2loFG+gtF +imxIzZmxvX7Dx34w8mOLyTmmnkwSpIM/H+dDDaK0EGcXP+MUbm43OLZDxtsf5NZnwH92NOoB +Yj1t45GFXWXrMpnavt515ZbYJt0Hx5gZ5RsT/LkZru2lZXWPfcgfO0QWWMUBeVrmr2Hb7hl2 +iJwEEAECAAYFAlZ8LCAACgkQuVFyDm/j6DDExQP/Vle/IBCIUmX+m5Y5Id5XyX7ifqERGESk +P3Nog4JXeKo1j4iQjUb8/MBXqOITPxhB41SzmbmAlDm98YJiZ3kkHyrjwD5lMle+3aGTwoRA +m7McYsL1DuNmzP8TxMfSnfQKTFCTn0EtdS72ExNq8ev0c3ofQaN4LYs70BlsDv7cakqInAQQ +AQIABgUCVnwsIwAKCRBr1UmfvjHgRj+3BACbbfgmBuKJQzT2TSfFC8lqZSzDHRN92xH6yQHF +bLjXs17jZ9pUVJrA9x6V8q0TXy8oE1lsE7yZM2KUOxtMLTBWpGr3zJB3GDmkMpqZ+gg6qJ2N +onK/HubxtmtZTIPxYOqOyCc63gsbY5gyVKW+orGwCaDW2hpkdpw13JzGY84PBIicBBABAgAG +BQJWfCwlAAoJEGvI1iOGjF6ZNloD/1tcfJyu2IetYhSJTRSq8VgKV0XOqGW/J6792jfGy8mj +dVhyDkf7jsFyxZ4LoZYFTg0pKzNd8XKkGyKq98U7G7dLeuN/06jrYpFuRqkf8F8Xakab9+H7 +253hJfdqdaubBRG71HpJ37TKc5tlUA1Vh6sWDEIPVkjwTcnl97D6/JvtiJwEEAECAAYFAlZ8 +LCcACgkQCqgGg7SW4utAjgP+I6MTXp5IgsaYvcOOwx2CAOs0pOFr8BlHDptefOFgJUyZoAnx +ZdNlGtWherbjBG3U5kGNYn1PKpUjylxUDXYT+ZzsLfZ7iVcm0ZWvQgveEIn4MEynriiWKUBJ +8zXUNG/gFAALSCTEQFp5Rauf8janYWV7iQrthcZZEw6lAGVdEvSInAQQAQIABgUCVnwsKQAK +CRBlf8i/eCIvcj1ABACr+0osHhsUcSo3Ky/x1sEUPaSb+T5W20URFrH8WaQwqpAJWuVRju+o +tPoDufeKy14q8MYo7GMoHrHBGV1fYpNTF/Mopq95Ixs5ALCPNFMvYeaDLlCccnuR7Fcp3iM6 +5UobqW4qH7cLSuoq28UQtO7C9kcMstcnUdHapUoT5KkXOIicBBABAgAGBQJWfCwrAAoJEB0h +tml3RZ34T+gD/1qaYBkT2Yc3wboA6ceKtLYgpSR2ISSQq78wbJSYH1DSGQ3ntCOI9xEbiBYf +SZcwCko3CB217tmDev0+AW1QH69NChOWxB6U7VfU3wVCPjcWbxniRBMP7f1TuPRrbtwuDlmd +v2YlgPp/4ZcunQS2cftfXljHZUDui2F7N8G0+Y2TiJwEEAECAAYFAlZ8LC0ACgkQAiGOw3w0 +rzYM4wP/cbxsm8PpLFly99dNyy3xXXBtB2I/uQSW+UMPnjgEBC2eK2fszraJE92LbrQPRC4y +McHNdHBOngcPVX+NGk8ld7hvRtVyg96955WOJTjHH6kgmQ1FkkVnSRvikLDS90u7wUC9MIwu +kH3I+r8V2Jhhu/dAySUOSz5ndPT0xOMZ/yiInAQQAQIABgUCVnwsLwAKCRC434oRCPTqPjmD +A/9Czwk5ZB1Xx88R51zwFo2w4Msq+w071AaaH+6AETvYxeJVqioRaEZQGmOugNFCRWxTSfSN +HmS/JelC/d+u5/lwRKesvYNLSwpgChOyyxq2WIurTyDEBnQMu2PlzBHRUh9BxX8j5cbLDOJz +2RwA/4hfOkGf2x0yjqj2f+hezHHrhYicBBABAgAGBQJWfCwwAAoJEPl+ryiwDEI9IGQD+wWu +NWGyz4yfDOHLVQRKRJehphK6ASUqAvtApmrUR1PfFDmfavVU11eObPW1z+0jZP4EdLpYyy+j +wltv/rRdMle21y+M7gCTQc4NFR5pALkbWkgJ3I/ugdcIXynWAEUY7DdkQPoatBpEvaELwa/k +hJRJC0de4zAAd8114fd/vzWhiJwEEAECAAYFAlZ8LDIACgkQu0kT3bWNBWIXJAQArij1813s +XZMWeUTWfarFZxi0Z7gfsAahy/Abp6jRbrfrWIxAbMaTb9RPyuhUbArX7hiFtWLlWK2SNU06 +bsrIrwu8OEhUlFGS/6AEsAcThwrC3YvAcL2duXNa0y2AtWmlrAHhcPJlYkjIa2XHRo9vx5wM +8R9hGxOWAJ8V8HJUlrSInAQQAQIABgUCVnwsNQAKCRAFnZaVZo4DeGEYA/0dESlRUWxKxyVJ +oW8ExRIUPK0notHgfKP4hwpebEkDWi2IXGhH6MJSJLs9YngJBYPxX7h71FbCj+ZNzUBmCY2p +1oN1Y7XHi9+sL6aul+1qGzp3URmVXA2b1y1qj/xBYXTHbuQNGQmVEd1Vla9tfkgW5bNlGvgd +9lL2YXFkdBGPCIicBBABAgAGBQJWfCw3AAoJEMMyGTNAn5TMprAD/AniCcNVcjCfXG1gefOb +ACxVviALZ6yJWDPIjYjh8mnX/IHGIsCd5tTQykC1qImD1MaEGldd20DUhoqFr1bLSgd0n3gx +NQ56paAfgV5iF3TxYExireWdNRYX+GzXZnYpLUBJN8/uztA9HdPwWeby0lR96U/EbAmlV5BL +rWFrOuMriJwEEAECAAYFAlZ8LDgACgkQRGUOssEw90xlaQP/UVCGisDkmslTOEtl8m6aeVev +68PiBjVXA/DuE5I/6Ah5nNACCm53aKI/ZN0B1NMrNylx5Yk5zqfR5kih9nBsJpiuxMEA+wOn ++0eCyS8BXRUb0CrccTD8fWMtp7WFF2DrCfWVy7mNMlMOp+wV0RbO2qkB5dlLpGc0oOiJ6ecI +lDCInAQQAQIABgUCVnwsOgAKCRAjEjgPq12h6HPvBAC5dosBAp14eVIJSZFwPocZ1LlCu8mT +yEPhtHRfB2yoGdViMrkzxWoXtnZKosiI8fjza0H5u0BfMxBc4SlOPEy/87C6Y1k+xEgJj3fB +b00TCVfRAQdXpEqN2iVg4wnhIdWuSKwX3pvbb1L297DWX+xagOlYoQaucLZF5jGTcLvEdoic +BBABAgAGBQJWfCw8AAoJEIPMt39nA6uZ404EALuE9Be8+R54aSqHamhTAy/4JvIF06Xh7kkH +LGUPXGV01Oxam6Z1VIk/7KnCclZeRds/8ItxeBovoSiP+0cJyQ3mHnKKT7dqK1K5/h4XmaGK +CS5vm30PnOCAquCpk90otsQsEn6DYQRbbVMGR3pG0dLrKZsxOGRrav3OeHJBCf7ciJwEEAEC +AAYFAlZ8LD8ACgkQAQzxv2ZJfsWpagP/R++WxpY2lgSI++ApoAd3wuD20r4FFQmY7K1b7Xr6 +c+cxStQKgTB9tGRD5gaC5QkT0ulPb22tnlib7V23hr1YCCvfJrK7pN2sg/XtRTZehsfct+6l +hR0gdjF4MaBGflDl09ClGQuM8yw8sU8a0fsWA6qZhpsqIlYzbfGBBhFN0zyInAQQAQIABgUC +VnwsQQAKCRAHy1PilBn8whVIA/0Wp65ojEDSQBGgGyMuWQPrktAO914dhqQq7zyWt5UPXmS7 +QwK06eYmN+m8D6icRgusv6ElRg/dmwI9A3l/l9FHNZ7PmWPhvTo+rv9SRVN7mrKygF9sT+1y +uffVFUPSMWUIirKqLB7Q1Jnl70uQ0NGtgZ0VYyIiwMFoCuCMu2hAtoicBBABAgAGBQJWfCxD +AAoJEL8NNp4bdBBT/fcEALHl1g0oj6tZ+Rh9WSgj7cToEEHSIIhX+qf7PPhAIapBGcta3W1t +O/hNnHaDE5Tw/t92ZeWL9PSQjQ3OlF/6XSjXdbzF4iNvQ0NptWEltBvlUKQExWZJEl+81njy +9oz5amo0Quih7wUKNUTF9vFciTKIqBGKnuhExRYIsz+vf0MJiJwEEAECAAYFAlZ8LEUACgkQ +ZISSkgcAUdtVMwQAycNOGAj5PmZNQK7DqQ9JkelsjqZkq6ofxAAlztcw0LUeMU376Z1/mb5Z +vk2OWRwTh2Ny0ZtVSQOHe56Yyt61+CJKgmQGtHA023UDKQe1KdYP8RgYpf9nVL1C8uls3ZMz +RXu2pzb2qMJDQCBEPCnJaozT5RsdYi46apliIfjPbhaInAQQAQIABgUCVnwsRwAKCRCFnFkd +MEIXmIuzBACmX2IqWyPxYWbFkhnZIjEu0HZmrjVOnmISsQd94wnydTL6+rCiKolE0gUEZ1GT +vo+HnL2SEGWZdVRSU6dx1pJXb/VGZgxuJK7goSbU8uLrWJTVn8eDRhxIGsVHBLQEHVz4Qhft +084ypIbW5iw4zR+HUD51cuKZa6/OYjo3LuCHA4icBBABAgAGBQJWfCxJAAoJEPuOMXLssEMY +MMID/09U8LqJ2uIirfdxESPkbIEIy0Z0enkqVcNIOGt8amKmNrl2zm6/Le8RwAHS4Iy3LMpr +1TvpWfB+4JHj6wgszUKYJCCls0FrEJ8uLkMfRgV/5B098VbuxbOQdaA6Z/z3fB7Ovu5KKyVH +mIrMyrekchFK0Vcv27nYIom9Y1uQphDwiJwEEAECAAYFAlZ8LEsACgkQ2MNk46dk2gj8aQP/ +bfZ7kecDRpa4odw6I4qhZhJydHmZ+kO+x2BefESyJJx0HPlDyBouUgmGsjAQ6hNPxicjZlrS +IUT7Fr+A09AI3T2mjNKY7RFglzO6ipBhsjLclm7qb3MeNfTZ2VVXxKc6mROuyJyDFWadUPZz +SakhKsDlRshxh7mLncq0oAcNSN+InAQQAQIABgUCVnwsTQAKCRA8/Vyx8GMH76jQA/sERsWO +9r2+8nK9JV/EHGuMYHYLw+Y/WLzlSFjid4M7Aj827PMcmUB/cadu6WZb9hutoGg4SfSCb1xn +VWFkbG96mbEJiKiuSze7d84eFd4BblEYZEkNcv+lCz3Ecof37GQTnp33fjU3plfKH2WgJzVl +eUv6wj4yyrdR1uelISi75YicBBABAgAGBQJWfCxPAAoJEIN3hF4LkCYQ7ZoD/3hCe40unjbT +NG9lK4kmvsY7gNaNW2lXuvK9kRiM5PV4FGd5GShEBkkvn2IDeBr3qjUNURQl9pabF6gtKsmU +Hn9EHKHvXnQUmox6iGa3kWI7bsTlqD4ZU3VQDaY3p56oL5ZFT8P0H4rm7RPqqkP4kBWjM43p +xBgQ+nJ9W26I8jUIiJwEEAECAAYFAlZ8LFEACgkQGc2NHoADlv4tSAP+MiG06/3LmkosECQ5 +wqXN3Y4CiO40Jgqg2K1V3hgrTLkv6A+Gr/avd+/KqpOzDjmWyCjseXxTK7BxEufyXTHDzKjO +qCylf76OzOCv4wUgRIjwqM65RvnQcmTI2dVOJNqdY8nQCIG2XUQXnz+xuHQe7igasOh9H7bZ +OHHgmoPWWzCInAQQAQIABgUCVnwsUwAKCRBbxK5tPEivc596A/wJU23E3B1ANjdI8nlEfSb8 +GrTQOdjwkQsHJAD7u1RrAsvPn+xQHfENH1t36pjRtDtjnjmv+kpMOeBkXWCAwx9ltPizMMr8 +tUr14o5cXOV7ZcHt8CGUMLz6iFDtZxY3XznyT9EtuyeTQFwEGzDARPQPvywejpmke0D/9iVZ +9ztHVYicBBABAgAGBQJWfCxVAAoJEGIaQAzlTqyaPisD/26mtoLChg5ShR9Mnp1PFLLHq44m +zeu0m9zeW8LUzU7ifnB/Y9lL9yVQy0AGKZUHBqAsHwV8G9XEQQNK4uUhma4hk+A64wN7E5xn +8kHrN08Kq2oLpeuQ/5RV+xRnukfNZNSHoQjgZTKkhgKSY6yKueJAQU1+b4nSbPL51BKC+4Se +iJwEEAECAAYFAlZ8LFcACgkQuBSH/mLz6gLGHwP7BLGcK6OZeLaKUzBS1Q9vYlJ8y6XAblz4 +4m//tIMmBQC1op2qwRRH0OlatRH0IMOlLiI5DyVPTZTtMbqO7B7vGdaRoQ6tu+Hgg0EEnLWd +qs5FCuZo2/PX98AiI8LN7g7fk/oHrptW1e5LJYciZxYqjOUrV6iJvSe7Hzq7Q+EjCQGInAQQ +AQIABgUCVnwsWQAKCRCgtlzztQcUaDlsA/4tYfJpicxvhpL1I3djbi1KEgob7UhvU99fFkWb +1EH0983DiJDp4dRLXh+JTWSgk5LfIOYDsbKFnVlefph0TvWlTaFI3T03o1X03Wh7Ixr3Q+ip +TW7zoOYusLWFf3u8EUYyPucHkrTU1i8ncxLjo2RoCMjzxlPCk2P5VVUZog2sSYicBBABAgAG +BQJWfCxbAAoJEEGIaYQf0a8RANYD/3l/QI3oC0LhhWi51mSXBT3BXu4KCQwV/2SS5f3B+efD +DOsECjPfpH8/joKOAK0g1xxZ0DrjVvQ71gOh6I+/2HM84/F9o8CCK6CVAvtvs47sT2+6bQ2q +l9doUG34HQJiYL7UL+zwR6F3vDSIdvO8xMXUJEzL6+qObVkeCvh1nt25iJwEEAECAAYFAlZ8 +LF0ACgkQe4dpGSm+UQegSAP/RD/C29GxcEdb6gzHx9BbYVKaCsSX+NfJVRzeTVsSGUhF58yQ +LvQQi1NncgXE4yncgt95VsFnoFFF44sN3isZjciLd0L0S+5RxK8T9A22UlkJ+gAJs/5/CIEq +2yIeolyRlW14BJBT7Bwk3al7zDOEj4AoibSL9DHtKlmyFTIqRoiInAQQAQIABgUCVnwsXwAK +CRBUlVfX4C2Nc52kA/42HNhiKo5mwKkLUNrx9nnsgNOpem3hnY74NIEQo4BKm/oN54wIYY28 +8sQrphyLJopOQCaHjVHFxSTV9BFXTP+8jfkwEVCGD6xh0l484mMLS+CiE+LDoWH14383Nubg +n4V/w9kBCqzPagGekYea8eL8mc3/4PAnaMZ56WAP4zccHoicBBABAgAGBQJWfCxhAAoJECTm +wuzLVzszl2QEALCyfa0hlOERONJTiY3HJsOm91CdKAPT0hKHJjry3npd44jyMh5SLUN20Bdz +QpvuYOSiHHywBikej6GTahgUQ4vNlkZZoOZwuVTahxpzOixzRXsk0iykdL4xtKLKOTRV62DJ +2FBJ0muYvJTL7/aAfKS6kZfx4VJZSPLC+GTUVtGYiJwEEAECAAYFAlZ8LGMACgkQsBCY+rZX +Zch/CwP/V+O3/gKxSvteZ7LA7+V2FJXTviqAaJ2BYcBo+YzPmdp4ctuYQ8lyN9/EcPvWaRmJ +YbayUbk4aQuWXZBwpuZIOpH5JAXVsv/URKuPqj/9Wnh9kNu2AjIVakHwFxj2J8tyL9HKid7X +O1JWxoqTzctcRWqzQYo2lBAIM3h/6YDbGGeInAQQAQIABgUCVnwsZgAKCRAZ7RG+DQj8gGLO +BACP+M3RWT894sLgmK2QgYsMajqpfh/b/Wi0F1aqFkhJd7XcVYHgABzDJ+waRUSeFXY6m+0D +saPST7Gzi6y++me3BHliIc4dyLjTpxsA2NFnx8C/6LWVNBuRytJ77ia/QyWpsH3U2LUf2dHX +RFowgH4sAg5xunq5wDhs20pWM9/BgYicBBABAgAGBQJWfCxoAAoJEC3Dcg6ibU+Vye8EANHT +BvFsOQxyei8JwAnCFn+lvJvK405wBf7csgqdeCtlzycel348b4/aseS2Yk464/Ua6RIQimnd +dZHRFzbfTuwxEWOnu9xZvP5aoM1Vdj2yjeftOgXYFmL8j83tby5uvxUV4QRjeYC6iST0YH8p +TcL52rfRnB3FJvmy2Ah1WdQBiJwEEAECAAYFAlZ8LGsACgkQula58natlHbX8gP+P6d63LCE +iKbNbjYyh/CnPQKwjhduT4Zqbf34i8jIhp7yavhJx/H+nZaFrhDXz+LVkdOk5GCkHQsqnby2 +oncIUgivHMgYCoTDHzduSLV0/HGIOH1L9YOjCNmLQ5gxprlgsCvC6kdroqRXiZJGhZRVvPPs +z8vrfK33t0oBs4QdKOqInAQQAQIABgUCVnwsbQAKCRA+kUNiiVQhtVPsA/9b9uJUl8vVXUG1 +R1NiCwXUBJEdnpPvYghTKM9PG/KVqKDAATRXVIy4AhYoYuMrocqh2UA+lqfLZ3gFJeTy9JI6 +QwkA1dAktM9+/HPjquQVDt09fbGHGG50junkjE3DbBu83axZ1edm+2CL21MdtoVkqTYohDoK +q+0qETcSALB6LoicBBABAgAGBQJWfCxvAAoJEFnD5KGY4owfwUkD/0mPg2A7RYRDIdILmXe0 +9G+po4SPwy1iCtlqqKOcq+VhyXe7TbuBQ7PzySHo3uGP5+p9IibKTdtHqFkFZ/cnWwQFLAHy +WbDMFUGmL3aIpLFP5ZHkCFIqKiZA9RnzRu0Kz0OUfIa2pDjJ883TIOPm1ovncnwAXPErYwYy +1+8wkAS+iJwEEAECAAYFAlZ8LHEACgkQKpq0YyuHXjBMZgQAgDygoe+hQvnyrbcJoQaqPif3 +uOfYl0UBEUcwe5rfb9PlwGszfmm4BQ3K37+VW7z51RuQf6AdwtfY7wAixjh9FSCAG8Mnjh9M +vvlvSZ9t/5l2bDGvBiCHpH0Tv+vgbBYOF0A0E0P3DHo83yMbjxf0/HMsSlnyKWFd+MY/FP/f +99iInAQQAQIABgUCVnwsdAAKCRCKa5Xn1iWCGiw4BACRsH0dF0RFHlAYSFely2B17naw3/mL +MHrIpYRJtmlkqwOowlVnpSA7Ktm5CKV9Lh4n1ehOUfNx84Lw3TR/W8hpu0CkVNRlcuQmk03b +Me4FT5YDaLEw37fRmLjPbxvUezTBtdkSQy/w6dtDY9ngLzMlH2W2tvutVwF+MNg3AuikzIic +BBABAgAGBQJWfCx2AAoJEBj10opVHxhCblID/08rjU48IydcWEkIVxZj8HN0NXsZXEMARzTn +ONmwlH8m8cMW4CcEiZ01yWkWohMhfXBFQbc1PhC3jIjvdssKdxbYIjrfIeun9+3IUq2A03YZ +hGrEQPMTz5VT6V5Nrsc++2FzsKvkSe4JkQyvxps2zRZWuZy5mv36gaYFQPYyYVUwiJwEEAEC +AAYFAlZ8LHgACgkQKrv+5MgFqZnlHwP8CZe8VjkfG/PeP15k6LUb3xq8UxcmFvqZrifRMXrp +3wQ678Pt2x9rgV9msDbPowZoZ95oJ4MILtFFMu5VRD/UPtrbS6KDahVhjxtyrYAKcFRYaeGG +/RvnHR2UaKNGjQRc7bRB187MUED79htssgALsLSU+LopaYvKB3+MQ/GxvXWInAQQAQIABgUC +VnwsegAKCRAb7w2glVdz3BciBACQCUkx0eR4NdGmOiT2XE1+6FlVBiBu3yOC6Sl6hBxtbvea +5fJYUnnyuSQhJ+TQg2C47pjVCotyW5pJ6SaLmua14Cd8S8GHLqlohHkHJdJWA55mi+wGAnVq +rjZuT6wPpr7tJE93W/tlw6W37lUrLGn43VrewFy8iM9c7xn/9rltFYicBBABAgAGBQJWfCx8 +AAoJEJYdjBpKN02a1OgD/2PlmUlZR1VPB+tJWXxIrA7XIg3qTFDgGaUf6r2VK24uIQQp55Bm +51VlJzvzl0uH1yXK8OFuS/SnoQyE90shblhzWCIe3RcAEl133Pzg0UOm2jxzbu9W+V35IQ0H +heDglmApMNlRRZ3+6jEp+5ZbJlRSPYJtNuUul6myE9CVoVMziJwEEAECAAYFAlZ8LH4ACgkQ +EhZ0NM64uRn/PQP8DDkyBXP17KXsPbWyuKhy2jAKCOHp1e31y9/81Y5In8zX0tEJD9L9T/5h +E8GZozdSfx55WJp0I9PV0VEFApr0voVwzWfHRqP4VwZvGSs6ef8ov3U+Z8fANm8sNMoK5hgb +Zc2Yi2GACmAvI64wiMdYM8VGoVvjarE310QEQMe3iIuInAQQAQIABgUCVnwsgQAKCRAPed9F +PsKdNUldA/9XqoxMuNfK1JPdRyXLjF2fAxCGPUBbFWYUEX1IG9mtx4IBd72Bly8oZjoDtEYT +YGrzAH0jcIvgaL8lb4Tz709kmgJuRQUe1saRN1fFBG84oHxpqskkCl76ThduN53pz7JrfpoP +f8+TLagSY8AiMXOMekWbcQAPqfGKrVhi9YF+LIicBBABAgAGBQJWfCyDAAoJEGtb2TNs2llK +qOEEAItnHyBJklTXa8bS2cluM+ZHcXDd49bp7BQGZ4hOViTC6CEU6AL2+sfmqNP9oliMVi/n +eD742j3bJ5HDpRptKdWzimMtbk8W7Vna28yfMwWDXQJ98r43d1o5O5gc87CUPgKCVBvEjbqO +69waguHzOrNeemnIYIxbtoJPY5qSeUaYiJwEEAECAAYFAlZ8LIUACgkQBjgCIiY/Apz56gP/ +dkMUQwNz3DG6iDuvqUD+1UIukkCPQKTAGXtVUymkqyUUer/2YN8s+8Wd9McpoogYs5WG04xH +gmcFT4Bnmxg0izisXfpXeHD8MjrPLDyX+mAjTWQEkkM/A5IX04aMMZfoU8/WO02TXVLOPxBE +TocG1BeyxKGQ1h+UQirbSOL/FfeInAQQAQIABgUCVnwshwAKCRD1AfspvrczaxqyBACYTl4C +Xqa57cuvJxijSkF9v4bnZYztc/yOxtgzp8ly4Jo8cn2cxzw8nXAW/QQWGGa7s2VP5Opnyq/R +f2pTWcHPWRwfNlFXdeQ+ZJKfGq6CqozyvZJ6PyRO1VWUqDNRNu1tUmbWJQg2Xwt5L4aZmhm6 +fBa0/w+3iH5YNeMzqHpI24icBBABAgAGBQJWfCyKAAoJEAZwy4Gzf4mIkeAD+gJ6yMJNCCYF +zppDWWCEJZ4TNdw4z32Mgc9MrIERP4RoxegOSfpjPUBBmgkngojaoXnVOPrwV04pOtSKcLmS +QRLTf8TEuNotqmQ2UHZNH9jU4Jz6EIYZeZg7t/nzGHIwO3M3FOdVA9splLJo9ksmlvHkVMIo +e7PSARTDUXc8kL+7iJwEEAECAAYFAlZ8LIwACgkQ8JeNvg55s51C4gP/V4iLNPZ5lrfGZCcR +YN/O8zmy9cQo4dIy0gGC5VIVXcH+iQZ1vrXDWtlz2q2sAqEKcWPj+8TT+FkjvaUGGMnKXH0L +HArgVuMXAslPlR6akOlj+H23eRLGsb4rYdzaj/5y5Y1GdOauhQkZrlnfDtumQBPwRucBd4pg +EYAwbDyGm4GInAQQAQIABgUCVnwsjgAKCRClT3uBi22I4EHSA/4s/qSA6if/jZGluiED191A +pobQz6AsATatJL+19N4XDjb2sHH2LWoMoa68Cs2eRj6PxhHaSIqlsFL+e4frCCDAPmVDNjS7 +BOvjjnI1R/zMO+O6tJo6r9WASUoQRsi6Y1YWgUiNfwwzQP2GoQcc4hiG3NOcv1e4zlqCXYKh +WT1GxoicBBABAgAGBQJWfCyQAAoJEJW3N9E6FwTQhdgD/jurJEQAb3r5ig9cPJrVh95g6mZo +CJ8DSzC7G6o2yLhmmnEDT2bft4eWJYXJMGCbYktTwGLSqLVPLqXPQSM3fo6zJThVG7E4jL/g +mN8OconsO3zgt9xmJo/5lr9XAYppmRWCsfopHAF0lXajNBWbjkX0M2tnr1TH3UI18pTh2tvB +iJwEEAECAAYFAlZ8LJIACgkQemE6xvT9wroRrAQAi7OTD1YH8CfbaJKafBZ75MS0mMXMU4Cd +sBkbg1C9pRsFuDmJgkVsdNkq3JQ0kjdAt2rEZQJhMYcIhAsOIkWyw8bYIXS2/smT5lrt48oJ +Teu7dhq+UTxpyYVs4qcNDNhqqpY+teSu11JymAYEgmFQJbyB2ZrEkl5sNiWtHqwXU5CInAQQ +AQIABgUCVnwslAAKCRBAF12208rV765NA/9qACX4lEogKn354ksbp0cJdWG00MHZi2sTmXMc +dfCf8yfbPKVy8u1OXBoS+lwFglvRdyZh9jDAeQKV5Hs0jzW1aBorP/6Lt6spPDkVdotjT5Qq +k4tjGiSnD8mmpu9cXJ+2diFlYUz3FkBz9pW7ku0mpicmLbkjNiXc9AQvNB5KkIicBBABAgAG +BQJWfCyXAAoJEGjfFsa8FxChkBQEAIAnqVfjgFQ2ZTjTxNC1tyKW/5qeScvsVh2K/PUgh0BA +KYPrKz2XXfpdFs0rmvrLoJSWxIjJMz9KBft+kq8L7dWiDGaO80lexpmng8bPd5riZybF6KJO +qLfP5hWuJwkaoOxlLK7IlAzq9oY9oS3OpIU+CzagCRXIS3wW9lWEDQDjiJwEEAECAAYFAlZ8 +LJkACgkQ2KBqqf+wc1Q94gP/TdIdT6ulaWCDgR8SDwf4lPsctz6GlQvuRV3qQSDo1QWolbiF +yecELiJUg2OQSYZvAGQrgroaVk/2ADuIoMsdkQLjYSrxl2PrW0s0mnu1pDbvhgJ97hVCHRgo +TPXY7KeD6dpX6aIgokrjNX1tbfW+xCvNcP+My8GOxjgzFWBrfPWInAQQAQIABgUCVnwsmwAK +CRBBCc/Hjo3g4JPQBADAQ1aBh+h1UWUSEg9mXWne4s6yLmzQvlWzAzK0xCSeNG0Xi8mGUf4P +DvInr/v/UYNxgPV9mVjrEMQoBGt7yR1IoLVxnsnpW/sEpA46Dxa8++fLkQpYC5zrKW7tahZC +TxnYFE8K1emykjJtQw//QMl03odq1wjmAkeFAM538jvLkIicBBABAgAGBQJWfCydAAoJEIW1 +rdMpNEL4Lx4EAJ0oyLyooBxQPbqjil5hUAR8c8cwYGkMSTbw2lmzHp9juu8gG9YST891lnPB +UkPeDqfpg52rqk+OLb7PiARIAsTeP+LmoVVEkGnRKZ/EK0l7BZ1cnHM3Pv7Ut81lpL4l9M+A +nTAJ5tYCc3sO1OAIXLeCrqfLNxpVyyQlO7lbGdfPiJwEEAECAAYFAlZ8LKEACgkQZ1ILuv/n +5YPiaAP8C3TUC3zpESIK8+fm/hoI2e+WO3qpDLP1S879GFOTqPV/uem6Z5EIyS5qYHRQ9UIB +ve06GnqmF9HlaTp5abrUvJpkGLXajMzQtfm/ywn75mjK1xlgIxLgPBXG6VI9GPU0IJsTyFSg +niWO4W3cyqnA9LKfMBdzcqRoT5Qg82t9arOInAQQAQIABgUCVnwspAAKCRBaSYIGHmgCDoe1 +A/wN+wHkBvCRhi7viRCAGAD0eq0ZUt5vqIXRSV/1Ii1DuRameRtBSGI8E9/EJDIZzQzkzId4 +Ok8KeivvWiIlNC/+6iVbC+VZlgbIBsTVdNKTsehfgy2le8aZvx+pSg4VHPvR+TcpjI58Se7P +WyiaMzrsooHt9BxUC9k36UfIEAF1kYicBBABAgAGBQJWfCyoAAoJEC6daK2d6w/I11MD/2eq +7aBnoNDQ3TdhD7+Ev5Qs0XYiX5rIW+yr2+CH3mepz4slim8cZ9goxYtUaE4K63cKLtxgdLJP +hzsKVsfh5Gcx7w070IXFxi6P9hlKWFZ8ZQqtn5P+NrDy5qGqwNF0kx6TQnS4qzGpMByT1wtS +9dOS45Vb9lcOq94qQ6BP8l2hiJwEEAECAAYFAlZ8LKwACgkQ/saqXN3RapqiNQQAs5KnjW79 +nXi8fvt9IXYx0sZrwgJ2a92l1lqdBvd7UW/IX32+yriISr+WtzyGSVEjN6vMJABiKAy9Ufex +V6cUfbTm+RR7GPlf/UPD9ELFxQ5LG7p/Yq9Hnur2wCHS/KNUpCi6qbunQ2wYhPP7xvwE78HY +0nSxPA6/QGyPlTYMUCOInAQQAQIABgUCVnwsrgAKCRBQT3jRgxaLXTUUBACk2SDMCCugcdaF +0EasOT8S9uFhsh0tvK79pKKLL1PUe+eSdpMIkZjPb3QjHvIP9Hac8bltqX4TIbi8sAtsw+5G +6J9HgtVGUp7mHxlKcoMYCVqJs8evWTz/cl9DElZ7QIwUrwL8pqiw1RFaYlHA5rdABGH2sK89 +CJzeTytM6A75WoicBBABAgAGBQJWfCyxAAoJEK6lQfWqnhyFrBUD+waMM2UVJUIknPtEVYlt +QvpU5OxCKRuSJo8qLhVaJM0uMt6PGEoqueJRc6q7QudugSOhdxXdDuW97jZp49Uy0Nnbnrca +LSAWH+yqJRwKXf0WQsC99lha/XEnXNE3eZilDTBnasjKTMGw9aKpXUNlBZcxryPJf4csbwUv +MA7PfnehiJwEEAECAAYFAlZ8LLQACgkQmVmZtrUya6Vd3wP8Cu9+4uuKmAbqncY0eeJrkRZl +aa49X6q6Ap2AvU/csfAybp+KpSso1vacnE+6/pSTTGCq6QJc49h2O6dl4tVPEZOSrycXJip+ +Lrk5QgcyxV0kTPGbFYlIjah3qPEVfmIfTk635bZdfGgcoaIt8JTt+yjm0s4sWxxV5uufwp6m +ojuInAQQAQIABgUCVnwstwAKCRAFJijn0VQHUdrpA/9TjiyJ1UHHmOy0igmUo10FDq2jj6z6 +tKfFbpErPXXVmmsClvrwsdtI8n1XC2RBDZndJBPTKa6zriOT1uOCVTVFfYBcx2rMKhybre+x +DN3lAjt/+ifIF2E837Xw7/OPdTDoEw10zlx8Yyu8Uet4y/5P3PU+4gzpo1md21KAwIlrBoic +BBABAgAGBQJWfCy5AAoJEO1iJ3MZ+T9KOPsD/0zadX1WUledbK+6jCisVdJKtqD5OS3HePw4 +aTG1fh/xCiBTYUi121mE/xtg5ruvEZwGvLEP/6f7u4xGLZaZIa8UDxK5HrHs5oyVBnbZtX31 +XXv+By91bD9MrPfmowLJY2lRXRdcC+2k0OGbkt9C5Z+gtAOQFhT2GuWcvrzm9QgViJwEEAEC +AAYFAlZ8LLwACgkQesNavPoM4S7j0wQAizPMGWOutXsaGzOccflRODnzOqydPs7TeCwd594k +Um+1bTpk/rsSXISaOyZ6Dnov84JTWLYf4HEZv+Xf8LoNFTjVwYnCACF5jTW70vJI7tvrWF4r +fBtJe37d62f3qYCvvH7Ixi8KP8P2Xe8pLzZXBg7sHQr/OozeknkVseHK1yiInAQQAQIABgUC +VnwsvwAKCRDcyM3QCdGy0NHYBACYI456/lQKRQISQpkS+bUr7asqLU8As/TGH9mnoWqsPCWD +Byig+uy5A3UJ3Jq/VtA0lqX3D2h451ENfrKYd6cI+0msJZVjfR68a31ITHpFgXUXeL+SiaCo +9Am4o5yN5poyOik2il/rlmCEoNWJ5pjXWp62nos9cdVQhtbwJYbEiYicBBABAgAGBQJWfCzB +AAoJEMkN5Gul4/As1MwEALg/Zs5UK2a+bHrCVpk3Xwocer1heBPmSyt7/ABECIAhYCH63IXJ +KCsFevZEtFpS2U4BEOEt0fAMONQQqO5x+bMWYjpenIZdwsbjdvj7tsIt5Ef2AbypzugKjRkV +9eS4xJY12CkJKZK+8W8g3ouaKTOQqWfVpy0sTdSwM9etkhy/iJwEEAECAAYFAlZ8LMQACgkQ +AziRgP1rj60CXAP/cww336pXW5WaeZNmwa2ejesrzb5KzjX5GdMTYQCg7NlA9SW4gWXoA9ZL +wVsorkDxATPIuQoPNBcT3IqgMjsQDBT479Nu1Cv+IxbXgTheS+oKjh15Wtr4y8dsbLBkCGWP +nmGDqkig+CaosP1DiJUhjDSElneuExHfC7OZryrtQ+uInAQQAQIABgUCVnwsxgAKCRB8UvoB +WTuhA2gCA/43UhW4/ThsSbI4zZmG/Ek4eYLqIPbjsY9jKugs7eycE/Kwz2I5nrcwQGBSxJwd +52VTeHrAaqHC8UtlO91eFRNF3lCcEQUkabXavZJm9+TLxRqQj67aYWc8RknN8uAJPI5y24PQ +iTe2Shz8LfEjREUbjwht0fV2cruWT5db5gMHSYicBBABAgAGBQJWfCzJAAoJEM5tWJOg/+oP +zj8D/jyRsJx/Wzx6Z6cfC9NV3CqrFRIAsRPXTN6bRUKxjaYH+d9NYsvtE4GlwBL4Pr2SQgzk +9xP8StjN5QdonDKQhpH25zrt6m6IHgeNQXMqH5pNn4lf+LZ4J263xpP80HRf6sacGq6kn7co +87uEBYx3YmmzoCWIyE7CErYaBQyIfOQwiJwEEAECAAYFAlZ8LMwACgkQfhUKIwgdJEr8fwQA +ioNw/tTUIjIc6nERfDgV38EH6CaBXXCBqNbkNuKu+AXkDGc/Nn8XE+0eUU3PH8OBLg3sOhiR +wSaIWNHDHMLOsYQHiCMICtaoxjFKA53+v225reDdg8C7qhfMzbWoxUovHTd4vsbTgD0fE717 +KXN8X04Rz1lursNUCGAtG8AAhiiInAQQAQIABgUCVnwszwAKCRCjukIF01/EiIVpA/42HFbT +Q/LvHyYv+rRJ4MxjpuNPMpVU8Jua2WEVeLAt3ofO151KFS8cNDGAZMge0pCkYHrxmIpdOwt6 +kcCPgDQkVeYp5LIHR5J9xsbAcyR4SP4bZ+C2VytbTwS+50OWvLO9D4poMVPpM0U0z4oIsou7 +ub+rM8tzMi5B52Iba7hUrYicBBABAgAGBQJWfCzSAAoJECKqQPxVghK3eCAEAIhZj+68J82E +oG9UTgP/alnscCUGXHmAcUy6xk/tsPbaVoZnR5dvJxnKRijECKWehHqN8curpXVpkBCn7vG+ +6ZkDY20WVT5n87wr3Nz3YpJZ16lRHrFzOUkAneWZm+NGCa1HEDnzYVXHg9xqRm4BGrihIlJW +l0bo3+HA5Ed8KOkEiJwEEAECAAYFAlZ8LNQACgkQ3NTk/jMhL5eqIQP+OkXtWAeLm+FU4jqb +GIg9CAG42P1EeBQyYFlwpWQVMd+i55tkny5CtEaAf7j0yfwikGdcLKSBo5bADF0U4gx8Jil6 +aw1ApeQNHdc1dK1PcZ4ty+OvJI2w2kP/DQML6F3vWlK0oaDaJL6BfF6w8vH23DiaVrawYJ+c +GLNo13Ue9ZCInAQQAQIABgUCVnws1gAKCRB1u8Ta7hOkRM+/BACrZcgsdDAwWgZJM/c+TlhQ +rfz/itAMvzcWdryl+DNojVgVTzzeUAPsf/IE2YltcqRUrHT15pcwj4Wr3T01D1WPd5Yv5P37 +r3tTzchrMPmZDRtQoNZpIvuNaMZlGTScXaeNNAEW0y1RQg5z9ciY/I1vL+u/cKRTsEHDmQo8 +mItUX4icBBABAgAGBQJWfCzYAAoJEH7tYgfxsFftBOMEAK6+HNeyxel+F+NAo2wGGA8SsR2s +TkIxoE1En0zVzpVU0Q0+lSKv/t/QCYS0JK2qmRJutgBQzaBM/N5oDMWSFn2fQS0O5HH51tUJ +gkJHYqpY/A7uXFu666Gb2w3bvvqqMAUBJUKh4CSehOEwFfMHvg8mhJf4VTzo1azJIcIQfofL +iJwEEAECAAYFAlZ8LNsACgkQw/aw5LvwbILlLAQAgzMuOiovtar9575UztXBPX7m3jlJtH/H +o2/EzwdlaKaF1PRCmhegNuvNecfIoxh4pnvK1guml/YSmE+WAgYV1AhC4fb9MlRlpp9CJApo +RMq5V5j6SI8tEH5Bx+B8dM89EAsxSbYVltTzgeCg4mQMtaC5QnzBLqS2vr/7uYKcENCInAQQ +AQIABgUCVnws3QAKCRCi+amS4MXYYoKiA/9ySY/YIQ/iWaQniHOJm84KwerEH+S7KdKt3Phf +3/I5SVGN3AKFR1LQQ4lv/8WzxWxEgLdhoIKN2I2ojiU0zi6PW0PYzDKDQ6ofMQdGFy98ilCb +a/ixKaPK5izQMCBKFJQECGYr3RyIls1zHa+mgPuf3ugiJ9BKv2YGEHqFvGhm8IicBBABAgAG +BQJWfCzfAAoJENyA8mCCCaocDb8D/i3buQ21JuTWz02DfIb5ESjAn95YtlHXp986l7vl+6AG +U2Jso1mu56vSNIzmOVakQMWG138r9bl0OZh4pHEyqdB+st01ZL2x7j5v/fS93T+hQ5M4wdyT +5KnZC8w4vrq4ru5iTzKBEI+fqBbQakkVAoS6mtiOA0OmFR4jhpGDjyb3iJwEEAECAAYFAlZ8 +LOEACgkQ9xW+iaYUziKLPwP8CSskXqwJwh0NXhHFbpIYyqEhTGcmqXUjEC2fFGz5I521IHzm +87BLcXZYgwGUbbsLYj9gvKmV1tK4fIPYvP+NhhGQXGYz4Oem8j+Z+YR+xDBT3hlmF9dlLXH0 +0HHV2wyuoyAZP8YoEniH62vXMtYjc7/6kgo1TZFWmCLCFwRNFZaInAQQAQIABgUCVnws4wAK +CRDs+aXiKQwvq8MoBADEu6ZANByaMWwg5tiEdQYjgDHwE8es5za9t3UNEJJWWsDBmvs3oqme +sBKTGXbcWLdZHC3R8RfUc6CaBXBY9bc6QPWCQ5LHaTqkCFvNpYIOWPcnqafbKwR9zhdwOmGv +lLijJRL94ta8Be4EMCSDj8IHaMSeVyKophK6ICAlNbR2xoicBBABAgAGBQJWfCzmAAoJELwH +XmeLyTVlOFcD/ij5rDgInjq34nq9magHMwskOlmHU78W/vSctLinkiqo4b9nevPgzzXR8sWb +J7pYKghXc9yZslZbIpY+N+aIWoX6kTCTIJtKEpyk7aAxWRMZKd6HRm/CVqWwg67xCo4wJWwH +JFG+JdUEFXPWCGGFcHQX/qdjTnpPSG0OgTK7jWYuiJwEEAECAAYFAlZ8LOkACgkQrFluQoJJ +ufLsXgP/Z4jVK8w/87EBFYwyZd8j9lWBAIkK6BPxsq8ePV+z/a0aJBJn38mvV+ti8uLoJHxY +9IBOVKwM2EPfX9xb7IA8WSt1AWR8diUsm/1bYlFzGHbWpp5NoRyX1VoaH7b62y6XegtuOPFq +5vAVN01i5JNxu19lya3+BMSoSvPLXxxlZZ+InAQQAQIABgUCVnws6wAKCRCXvJFyCF9UWX6e +A/0ZvGnb0lwvmKkbSiWM4MEisL5xAAT/3parJiYvSIeTRhrGpVkFdWbcqv6LAdN+sMVmm7n6 +BG+v6FcemFjgkIlKGHHBZ78peW7C13E9DeEt1HIQZatnVlZr3NbqDfbkdmQY8qckZBsDgvPb +MQMIGVLJ2Zo2+xgnfWKcjjm3mYmqB4icBBABAgAGBQJWfCztAAoJELfDOsEZsB5b37kEALxo +bRCngXvesbE0lo6jzZSmL5NQFK6gIqNUiNiXGJe49ZHFxzbsVdYWMCSjQPblT8tnTLj1G87Q +Mu6ZSUsR6+OWHZ4XfVIrsU60W6k7w7ZhmeOjmDuPkgDS70tWUtG6I1cHkpOATW84vdCbkREA +enfvuDHuah9tRguz84kD1aAziJwEEAECAAYFAlZ8LPAACgkQKNbYQgVeR50D+wQA5Zfk6KLe +sRqoH0eUd7NNF49cB0lTa4Id37rsddIeHqF1SXjj3WUmi4C9YnmGW/lehwHr5DPqrUIaRu1m +qKCVynoxyqxXm5Z6EW7RBfFVykrU9gWT2xL6BSbO83knqYWTbL9VZ2gSIB55hZAF465H3M7y +6kjSXuVjYrluQADsJyeInAQQAQIABgUCVnws8wAKCRDxsGeZjMmyRpPrBACx03R3b3A4je+7 +xzKH10wQXbRFYMDASxG8+UHJJo7G0Od65tNUenjHzdbfwSHRKTYqzv9jor+iJz5LUf1oPH3P +9qExE/MWRos/MAn1CdQYit260TyMRePYKRYCSwqLecUBj4ippuFWewyOZKclat9YIUamzY03 +JVO9jCj9MB/zdYicBBABAgAGBQJWfCz2AAoJEBIX6Am+dWcHLpYEAIdNHyGzmOIbAsqvyHoh +wAx1QRLBIi8PRrYFOE4UKEZF8NIb9PtTvN8mR/Vl72acPD7TrM1f6DPtlq2Xz7iilPvY0Drc +hj3/REYhb0W2ey5xLqbNbayRv59jGwWIknJvUikIYM3XxtGF09qyo0mXLrFIO8Y1reB4a7CJ ++f+3U4rCiJwEEAECAAYFAlZ8LPkACgkQU3NLXkd5S7yUTwQAsKQYgzYiG7fERq8+hV8f7feT +3HLlsnv4aLEVJiclviBdCZGpO13yuOZ+UFtSQYVuwI2XOiujvUouAQmIzQtXNkF27j3Pfam/ +Baqh4g1rUggRSHaKKAyug+5vZlv3vl8VL7LuRkmHiBe73X23Z89GXMrL1QUeGBbbjmWLR/6e +B2yInAQQAQIABgUCVnws/AAKCRCjgdVnwpt0J2lCBACcHWqzmYpJFKFwCCLgNha2stfEa+82 +B8IsJh9qJ04o/+gMWQA4Uwm7LsHGtdcnFEhMMvg7losx/c5V4AV8K5ypRx4d4hs8mU/ZsiuT +vp8SroKD/uCPQp0VPMljQdQ6NtxvNBQXSD+h6f2y4/zmb9KmZSN+4deabRwrLq3k5xT7Xoic +BBABAgAGBQJWfCz+AAoJEMO/C9/SNq9hrasD/3Z3dF99aW/LfeVohHQjX1PSzlJ2hVnV5Aur +fXXXVY9ampZaeuItuirDoBBEWjwd0ssnjHDO2xI1jbSHO7WxF3FNMxydxOYqWnCKrNlBvGQp +MhnKuTNBlHNRE1Fq01gaEL3D/1FJUnSrt1/2O+zi3HOAsmQ7axkFEtJTb1hZdTQpiJwEEAEC +AAYFAlZ8LQAACgkQ66xJ4tuM93gm/gP8DAJVv3HI6CMTKu9q2sH1Aj0LyAA92SfKYLaA0W0Z +9FDn8QWemN4s3aQ5Z6Xlgq7JxKOG6vy4o/JBcf/2gmcXsZvsbECUlldJ7CIrsLHRV2wrBF5B +PlLSIKV38qX1X93dEXL5uSPlrKGAAlRvi8we8TCjjvqxMCBuy4pnbtzLcN2InAQQAQIABgUC +VnwtAgAKCRCDbaABCO3QyYlmBADDANjkpnd7mHAGWTtGcEnEkVBzVhtk3iYS5UT+BKnAttaU +tmzpclUFuo5keTxZ+N5NBKwcqpYEXgKYDq9Eyh+CXuwlJkVlEOSCFx2Xu4B1SCoIGee8SR7H +3YUnZglOIM8SSRh9gStddl8x+yO8toTVakC7AYiFvU/WYS80/vLMB4icBBABAgAGBQJWfC0F +AAoJEJVqr3xWlPNi9GwD/AnoY3MfpHFkOrIcVDiUl2/Lvzr5epBr0viqflUGzpRpkm2k6b2X +6MtTVNWtS5meao9Eisb+azOx5svkkpS4cj2KEyGfi0kS/HcLp87VwidIo8TsmQm5TOixoR6y +88i27Ct0o2Zom1NCDBbSDT5KHA7a3klmXJpvIXWkH37KGBNYiJwEEAECAAYFAlZ8LQcACgkQ +WyxDt6+bepnn/QQApahVEIwkQVI5LDZWVwLf68Mm9X8RA7UXkDkD3F++nDQn5SEix+ibdxT3 +BmOTF8vMmNKMKZ/RL1MADA4IG5z+50lEAcCEA7Cge5EicUvu//wfLuhfIRBYl9OfuljKv5cH +WAsEo/C5FMycjZgx5hQAPFz/vt7+skm5KnQNJvfRJYeInAQQAQIABgUCVnwtCQAKCRBITINB +n0M5JU7MA/4tE7Qa7Bzr6dn9otLwnE39UHoWNQCtT0pzxQbIcxLdV9D1q1bqzucH0LIP1T5I +REvdWAKtCnlQMgrYKHlsdQkWjEs1BRcZDZ34fUQoFVevhgk8MGnqe42EBvkTVSt+7WkGjIW3 +Jq2rGvPfyYRRZ/YLx7b6IAy3IEz7QA2AEOu3L4icBBABAgAGBQJWfC0MAAoJEB3eO9zh1y9R +kYMD/1nt5H6rt7hX5G/159COw6UswYYCYMa+s23X6VDyJx0+iWX12b2o8HfaIRZ3OokxQDJd +D93G7JzOoHK+bv4VjqGTrrjN5FzTkKhOPKDVH6WLI/0lIQWQJK4FdVnNcbR+++gtvLsiwzoE +84Tyo7yqt6xOiU2xTyAtCdMhBnq6EQcjiJwEEAECAAYFAlZ8LQ4ACgkQ0bbne4im26vY4gP6 +ApoxDC0o5BLzlJ2gqQs4Ho1cg3hxFts2BO7aXHJfSGsxg9/thwVW6VIfm5QzgmmDsIxiXxnI +VhGNs/H4vltfoye3HEuu/OkYbkHfNcjCP1FK88Jv9kaYMOLCqliTVG8vr7EfltOCefgdKIku +buwgtKuEbZcgN+Mg0K67u9KYj/qInAQQAQIABgUCVnwtEAAKCRDtMsh7yQ+fV5nSBADGYUhV +l7s6n6fHMpezgRyFi8fqMH6WA3mN/aZyLC55eISz/lLXMJBe/tMb1wjSAe7RM1Ft7viA7eY+ +PQGseGO5xNR0FTWf1xmDTIIazrdM1tOOjjnJ0qIndFOuLmYFUJZhAyfkscDsHAS3D38Oh0Bp +4KYH4QKiCK2lVUrTPKedvoicBBABAgAGBQJWfC0SAAoJEM/TiJLI9E4jrRsEAKMlG7jY+SFG +FW12jQwn6QCPTdZz7XQTwhqDZrHKufSqHp+ZLCwSfl8k6L6vcbkzj37kSGLH+hJ+OtVS/Kzv +7huDTsW9+0jjeTVQNFYu5FoFiigD4ON+SpPxYwlp8AVK09IzC+xR4BGXNxyYL0gU8HgwDbDR +lGSF6mqM7I9bc4pqiJwEEAECAAYFAlZ8LRUACgkQJ4DdIqfIYbnI8wP/XEiLM1/bUSgAGpBn +NN/TpffWOW4RocbDfqnVmFZL5Dfl9Zqjjb6hSoH0wqBM7B1QTKqrgPij0TY7cH+j9VA1imCZ +g3estup9h8XbJCg/KROVlJXe1lSnwrp1TNHd5MW5/tYTGVveDYIvGgoUMIMZ229yXVRTryv0 +fTznF+QUytCInAQQAQIABgUCVnwtFwAKCRB6/cimxBNyZCEQA/9q6ID84R7Zm1nSaEuVeQk2 +1/oddfzFzSLYi2cifhmR6WLfjGRngq6ZIdL4mDPhLE4f+gJ/pS70A4kGEgSTZOI6hvEogufk +d+6UzG7J4s4uLlMt+hMy0bUlm5yCeRxOBaB5G5SjZ9t3Ms5stJuCBkNc1ygcsQVXaxyixMKV +dnp3l4icBBABAgAGBQJWfC0ZAAoJEMfPO8C1USXcvGMEAIZwzGggAAHrVnHOJlpaQV2OuTUp +2jlDJnu39ota8IcXXvFeDYso0ju402DaPNKeu34/ygRHcV76D8z55fXTwbYNAbqvGWK/onMV +z+YA405ogQ9upnd6bbd6pJsZO1/n7T/QH1pKZqsrHJNHCLfTw3TmTAI81l+s4YeD+f6WvffJ +iJwEEAECAAYFAlZ8LRsACgkQ6V8ai6oWjxeoqAP/UIa1YJh+2E0ElfGya65xV6Q5TRlRklve +sFuzJ2Ut9uk23RBfFBdGHjlKvkHv9i+wmM4dNK31jsa0gcdHiWEPcHpsSIV9YORgY2tOXy4K +JYqf0+LqQGDfc4earHrhv6ujtc7eiaUIQCVvSRKqUqduMIZzEw2XM9WuLjH6z7jZiiCInAQQ +AQIABgUCVnwtHgAKCRDk2zPNe5mHCBiLBACVjJbdBXnb9HfhVVjwzYdSyUX/mjElqxn5n+tl +IJ9sFFOMgyBIDirUKsmUHjGFAf2H9QuQn6pz+kweai38TzNh0dqYMbRFPfFztITLEY4drwQb +vf8xTM3s1FKWskclQdDPvJicVwytSesVAJqkdN8dnLwfSd5XiOp0VT/MqVNueYicBBABAgAG +BQJWfC0gAAoJEE29sXvSFQBVSzgD/1kK+XIsnzQ5k7ewQisq5QZa4IZVBEIZ7QBfBM/k0JX7 +XHfZJZEZcNDNhqX5d19XpKX5MLNSOBcFjY7WCnQpsC1BnKpWrHw9A12ppTLtbTCkj7uDqToO +CqvLcsd3fWPpW6kscdWwz23Gi22qK3TLNCEw8PCqU1MpzS5GgCCTxBECiJwEEAECAAYFAlZ8 +LSMACgkQjemrjE1rY/1iogQApI8DszOi39ly0lPak5ykEH+ATY7q7grkOdKlnKgGhlAKt72Q +h4oQ/gcplAfXWFsztPUWpopzU/ku9zSEd1fX0W5hFUTLgnC3c9WoPzSov72QMMiaXYUJvK2t +uNI+CY5x8KLGSdlAt5vWw42lDandrNYdXo63E2wHkhfbIUFl4LeInAQQAQIABgUCVnwtJQAK +CRDoXOjVwdqB3e6aBACZc6O+F7Z6kDi/X8Qd/tJ2GxXnKiVHKvCDUYqNoHToCTxjNDqQhDoz +Wjvg2jxQCyQa+ehk0jig8MSjRzcCIHh//5kDefqjn4js0mqu21qwjHM2TdChhUNhlCfKKUdm +DQnYYcy/GPehZbz1PS9WgrGk5Uw12aim6CeiOaVdfJfVGIicBBABAgAGBQJWfC0oAAoJELZD +Jk8XSEK9kWkD/0oMPky4tv371uP8xiAI8XwYgnno+kKN1YmFnEwJ1qAGj/Awd8BTD37APOlM +4LguhcwddWe0YQozjh5P0Vz2g50Zk94a4QLH6KvvTX0cJPprmYuKuVZCRq34KbS4Sd+7zlSs +QRK6GZDsOEFU8lOVyt85hWed1dDi/+54n4ZjTiYqiJwEEAECAAYFAlZ8LSsACgkQLPd9/cmi +n0j0wwP8CXQwzUww+s8JqMH3UWtpDwHe8KYlCT2bWjMJKfXxb38+A+/vyH7uQHQJgGvpXWqI +T0OlObjFfHAqejE7u+8Ijj9Ai8usX7dHcgWtocXFUNca83JGB9DfQn6kFStuYBGzldlQVt5W +kqtKNhLzAHLx1GyfYELVV4mknQm1RVyeudeInAQQAQIABgUCVnwtLQAKCRCDaEfJack/LzDD +BACwrBqXYFy2XOnVSWnnUZjfVvzGhgs4FRdjapxLpednQHK8qmss4apiJdrA+xQwXw9f635O +qRLoSVf086gPIbG/FhimBbo8Nl1iDcV33+257ebCO4eexLDSpKazWZU1MxT57crOaDcZ3uVJ +/l/J/bKgtPZJSCABoT3BjJTBC/2uyIicBBABAgAGBQJWfC0wAAoJED4aGDiNWHIw4zoD/35E +ApSeVC9ZyX7hq8fEm/5IUuYU/6BjaeeDTGM8Uuz4QUiU5Q5UhKhn7bNNTL+Zx88Bcs6ox29E +Bilr/UIEXW400Ujudh3bjz2SGlFep8o4WZ96KcEFZ2EKKNKtYnsVSkUKMxk00D9JnI3qrlft +um4BgovEBcmjskKaTXfYVhsliJwEEAECAAYFAlZ8LTIACgkQEj+LBAVM5S+vFAP/fIOrn4Yf +eu5OwB6PXyYWpKIUSBqaXRQA+/uqvhkj0qb6KJYHzqfVTlr9irayDYLIKOuZ9bSSOWnqHQTF +7GS8GSlsZTtwXsbzHk/HQHMyFZeLMs8WjGvtqQ6unoKYGLRAPJaq0uBRHviYCNfcy2w0QuT6 +0eDR+mHUEqZtNTduJ7eInAQQAQIABgUCVnwtNAAKCRAXQRpytIgf2+Q1A/9JLTK+UORUVo0w +m7m39lFQeAcA/jFgHU+H4OFIzUydO/7M1Uzsa7gePQs2ITvrgxnLlUcSX/IGrZgbwyUaTsg7 +h/v7VZVRJqXUC20RzPi/6P/3I5Aig5dP/OuvppQJJ2UhLH8XC4ZsTie4k1jq3pJ62KLybomd +1m6u2PGf7wweq4icBBABAgAGBQJWfC03AAoJEMpv3xSzwaVpwqIEAIWM7YsVq1k+HLjpfdkr +E5VAE1aei32JwTez+A7pQseYbsdhmW0+v1Veq+e2S3OBpF6qVXyH7qidVETsp7IBXptqUPA5 +XwRUkRtOoIhuaNOAMD2tskj8hJ5aj1qIJmSmJ59CswjOcG7zGhe/mvc7aP4OwdEZS73VJq5D +gN+KiUKYiJwEEAECAAYFAlZ8LTkACgkQNnGw6DSbR3GpSAP+K7SidrBcFRLqmeNi+0VMexuF +iwxBSQzPIob078FWTr72/t3riIPFg5lkYIQFFQ5kkQTa2J5O9hlM7IsHYu1pYatyf4kKiWRU +ZPJq1lH61I8BBdYMOkG/BxEV9U/kNYDXST/nlQ4nFaw23SdXZgRM1yY7LzdzQ05sIM5HpPx+ +EcqInAQQAQIABgUCVnwtPAAKCRCm07Rnfym4pROcA/425TKtknRYpUGnKtZzpSpnxM/4XKzR +rdRIttClMlxtneB59ut1A9v9sLa2K21awoY5uiNWIzL551ubO44mvmFNR8FWT54THbydFSir ++JkJEifiYNGWVXBwyNK/SLW+S0/37ItPi4nrul9WTwHfU9yn72wAuu3M68FBAK+os+EFQoic +BBABAgAGBQJWfC0+AAoJEBsauxZInFd3fqAD/RGLD1DuDVrW9u5Ycvru70868/9rDpsAGB4A +18GlygFXb10AunEX53MUEQbNG1c4JOIZEJmizB+XnHxM+I5h5ODX5UQTAgBiTOQTOB7ZacJB +w1qMtB2uZxC3UeRrFHoe5m8L5ltoiR4VQ5FF3YTqMwmQGwcD7ARQ5l+IORaNzy+liJwEEAEC +AAYFAlZ8LUAACgkQXGw4/HCYLZnJDAP/bY48Gpo9HMf5YJKNbLGj6Dsj55O4yMf9TspCjYAb +87XjtBmD/zWxhAJWCGebyTXK9Wi5Aag6uaShUWkDVsrmvgpjM2ea2vhlw6/phcIq6gZOKmzL +ZM/1Kl2Ohi037AxiWs+ffdjwHM7ld5uWmJxUIlIFt9iwE73KBZsARx6rF++InAQQAQIABgUC +VnwtQgAKCRCV8BV++u9VMpACBACmiMwk3QrF1kcZyd5RefmqkRHfydwKDQklLevuwbkbvea2 +3Ccffn07vCE1aVjMJZ6i1Nn/pHwXxcfNZH1ncJBSvrFpkhFZcaao3Gy/UVTs5oFotOvFxdVV +eP7gqVVQh9wbpD0wnS0IOyqA3DUA5kCZVmKNjWh45mLNuORsC9Tsa4icBBABAgAGBQJWfC1E +AAoJEC6PVflVoMYv0KAEAOXJG1bxl1r2p5FH+d0qGRfabDovZ6bs/a/G5q7gCM8QLiec3DC0 +qxUaeMvi16sZZJWj3KMbr/8KHKJQXCpuY1lwbU7suJO6eC6RPoru2nTdwGqO6Rc5EGtA2n+4 +bU53EO83de9KWqqbvDsmld95XDXNkl5rNEbyFAl/KFVlweC5iJwEEAECAAYFAlZ8LUYACgkQ +xp05gJwOBJmgiwP/fOiAHerxYfRbk4+ryOB/DwGaXfYwv1U5X+2kpJDxakFoUx8ZdpDD7ooV +xYqEX+InUZMDIETXHCze1kM1QFUX3Rz4PEgrTWRtsxCqlDSV95t7wXSfQjUtPTNcRGPrX9aD +LtuFfG2fsov9LlOqrVZjve1d13PFCsz3BuuPphXGiiaInAQQAQIABgUCVnxCSQAKCRAp1gmH +CXhpsCoFA/9VtTLVkOvjImczvKeTH2cgvtgPeUOqGK4smlNAvUaVr2NlMLgfM3l9OYE4S3bq +UINI+XD76m+ll9v2XkuNQJAVNBo9tWaRQAVl2cCjEn18uVumVDrfQQ0G+MCt9iPkgQbuqNIk +0f/a1m5EXzxKLmWOzmCthBxFE8iDfqM6pwvhVoicBBABAgAGBQJWfEJLAAoJEF/djRUd+19E +9TkD/A4B0pqZ3QT9rdUrJ2CQvXXpJ+LxkV9/sCtZy7xhXJ8evXH60BwOZhGXQk/IKKwE3ZO7 +mi0UZQIWb5zAD0e7Tpd4C2/blEhtRKPNw8sitb7xBAukOwbmNIRWwvj9PPWT7VLxsSEZFGw/ +YKPvsr5x4b5Wbr5rSaZJShy/xhn2sQcKiJwEEAECAAYFAlZ8Qk0ACgkQxMP/whvVk7WqOwQA +ucS5UZjnPQ/YmnpZprQSBAMm5gGiuKFGWZNlw11BOOj00Ou+jkYsxoZ7gkW4HfkQQM1sKSTn +maO+b3S9eZdFEADVuS9kxEe1HZIZmYlz2gaqBtLrJD0UNEsCnc1UCw3KESRj1wAFUvJ8hWXO +9YRVGQwAtUZA1ZiEbADfpNGSOhGInAQQAQIABgUCVnxCTwAKCRCTTWRpjIpqKZajBACmxUCv +mM4XTMvFoOkw9cxaZ2uk7nV6evQ6/3E2vAvxs0oQU2TmKuaF0eHDdgXy2A37YpDHZeXiAi3W +wtp7j0CDfwyWCVPJ/t98XIB+bAZ3LVQ7PJymuauM2h4SUV/ezI25imJ0oMFZp8zjor4rASRj +0c0XEQ2R85VwOesM2tMYW4icBBABAgAGBQJWfEJQAAoJEARZCoxrm1Qy1MsD/310m6i6WKCl +1dzWvL3aahXoTSlEIVT0v0aYLV+Ffkye24XzejYkdMt7szVhdvtGiqjFR4u76zYSpRkqurJS +fadd9PeRqITVUfUxWP2EFCLsB9C/g0pasnVOQNGQt5O0RvjDMPa5W5m8EqLry4ZyjsK+aTpO +GhmcwFNyDogFKmPAiJwEEAECAAYFAlZ8QlIACgkQb5obj5xcdzwQWAP/QblMKnn9/X237Hq0 +2u1eCcZCIBB08WC3nsHAjIFTBJuYtWzfY0eRVlvgVxkvOVSyhPwZ8XB8FFyk56GJI8MWmV47 +Om65qk6yPOI/2uI0ARxMLqfG2d5ysfAy4Sr0Juqltx5yiojZfM+VcFyn0ASSPDDITKyT0yG8 +itKzrhVGf1SInAQQAQIABgUCVnxCUwAKCRD4AZWQioZuDZh0A/9j1uTbtGMtC1C5bYkxQgCj +hYhAUwWBxEK4QBqk7dgi/lLHy9g+VNWMXMjvOx7QBQiyKdmWOy8ZRwVbHo6c82LE5fUEatzt +1IH6PwFAXFho/BTvXjy9GNsGVmlGWZHmFABbzVAS9Q+h78Ftcmvo2v50KbgOhkDIc3O9iG1b +8bQtqIicBBABAgAGBQJWfEJVAAoJEE8+zqN0FOQgT/QD/3XCApYW9rX3NALneZfd5VwKzmK4 +6cMIOOc6biBivxKbidwQuN+b3XumWz1ciL3NZghA1cHEDUAwpyo6l0vHhl9LKalMAUt0u15M +dGK5b1X0GTYAw4opxrMGmKE2koYen1wgD+1rE1RLSjLw5P1MpHUawz30e4KrSkWyTLSxQoFO +iJwEEAECAAYFAlZ8QlcACgkQaG9V91lmkKMscgP+OGS9hKaEtoej81H7twR39OBryMrNXv7T +T+86g0m3JX3zkukiPUJraXlt/rKa+QeHqucwYjnQWpnWDHN8dhZY8cc7aL5AMXPGf8LCSTN5 +u6d5nuLPOH3cnOjgHZd2fdm+q4ccIgK5IhFdB0ZryPkdKJ1yVB5P/rfVlSsDgpTTmP+InAQQ +AQIABgUCVnxCWAAKCRDGJjMUnX05TpHSA/9HntTqj9CMBUweS5ufbnhPIG3aNLdVyqY1E8Wf +Q/LE+05SG3rrvU7OvgDog97OFz2DSrGQnlor5kDCDaSVC3pXrepL9TzflO+KRv3dROlA1Edv +KTe+LYJ3GwTAecHh902Vb4lfZOZYfLW4JkXYIu+BMUuO/mAlOPPI34AwAklwkYicBBABAgAG +BQJWfEJaAAoJENnhW343PA2yzmUD/31KTwndBYYfzBeeh9RbLUF5pTSMXeo/tfGdKfZN/joh +p75B7ADiaDUKq7FZKBo1WSPlyhHwr2gyhduoA2G++eq+E0b/Ub4Xa0HAw0Wzpxrl1IYHyZGj +h6XkaL999M2Am7s00PZrjgme1nWoJ23eQPoGTHFjzkxzKzJ081Ju2E2miJwEEAECAAYFAlZ8 +Ql0ACgkQDo6RJsBLWNOyggP8D80kAuHt+89pD13x6FTw8Sn9cx/aenjkF2aGIbhN969j4u0o +u9C/SMprlQD2/yGT1NJC3tELnRTKVjkGNjFw3GK8pOjeEF567I7SfydpMSyd0ZW5RnU1zSdN +iqziOL0nfpjZkOgaJHhHzIMsUxrag8uXQHAGr+Ye6GKNRJO7+Z+InAQQAQIABgUCVnxCXwAK +CRCWNj7Q4NB9ANWqA/92uwIT1vXHQNEZYT2s3uGwUjW8rkbLe4F+3C0j4ZzSgA9+8URnjS1V +LcCk+u8uDwjV9nn4oN+5OuINs02NSq2QXdQk+ZSd5+ohaSm6v2MZ/X5MFX+Hw1V6k1K0u2fW +33DeDZRUY+NKrOYYNJJG17aLo1kF+HOIuapp7YRkcvKSe4icBBABAgAGBQJWfEJhAAoJEFVa +iejkoNY1f5wD/jne/ReyI2sNiRYOsCZBitwXOZEkfLreLIx8UAL/NVEVE68ua1gNRhUXUYMr +VEC2ACt+eDstrByZtEm8UZsWS/hsxsT766T/aKkdT3gcA4ZnqdlzYg3rrR3osZ94ZHYhTGS1 +QFZPr+LscZYcqxqPm0V0Y0PBtpGCvmRe/LaKsQLRiJwEEAECAAYFAlbphXQACgkQG8nv7XJu +Y4vzoAP/RxmsxE7t/OUmVWHH3JEjrgkzueTQy5kLrjoo823AMXnWm1WAKUfKxngx24gVsRtr +mkTmOGQpZ3/mo23bTqwY0zTHq7IVmfYoi/6/mWDsjKnG6bP4u6cxKCxnMHNbOQzf5/WCE2Lx +7Q+rzVPwwBM2s2oVgSfeTeQznWmJfMW/BqmInAQQAQIABgUCVumFfgAKCRBT+Gu0v0l+JUJx +BACIhSA9Ty+j/nShtxDtbt7mbHKC857p5lZ1VH4WUc5RJJw7DPRWPLtmwVug6NhqndiuPf3R +afhcSwEBhGm5sexCMjA4qDg4U2FHL9EYoS9FUbqoxBWeBaTfCskC6FMhgKxlvZ0j7b7L99/g +66V+f2YkzdYq3q/+vFg4/NRmDnAx2YicBBABAgAGBQJW6YWHAAoJEOBo+HF5GE4CFX0EAKiB +iTlVtcKeRM7l85rI+vVypKpt0zF1kW+4wL76MV/qkuTYicbQBV8NdHAGH6VAD7cyjj6T39ph +AUaxdZjOS0jazDTjNza8+fB7nGuJEeYBb5avUir/ovSgi6ZPdMicEsoU+q0v9DNRK7f2Z4MI +0qAuOfof5vQH8gUuZML919kUiJwEEAECAAYFAlbphZEACgkQoRl2k6c9snQ88gP/WpF0WsL4 +XsBrKfhqLkAWSt+45vK1j6+QKOm/yKbj92WV/vR6x4KADJFbZjGfftnxNsk2xNhObW2REHPj +XPh2T5Q2fejlpzhIjB722JKq+jZh/YothvGhDnX9BL7MsjNuyUnbxJD9bAVsLi8hRe8ACDUX +g6rL/RetMwZYHdvLnhyInAQQAQIABgUCVumFmgAKCRAbWyG3rBBGNuP/A/9HLJSMeDS8Biwg +aSyg97226c0xq/L18NGkYhLjvBY0E4dDcY8gottukA9F7xGjg43KFVqh3GSav/V40aT02Rt/ +3CA84E0bbXjRHK4u24KgVWZukXslTxp41qbVL/0pPNAmHj90uqtOG5wOY6em5xtnX6HLrqbj +2ErMjZc8ezYgBoicBBABAgAGBQJW6YWjAAoJEKNwEILmGvS9xXwD/2BfrnHRLBn5T00DibLu +9LdXIQjzYi8IDPmSXp96okXSJ+pUAm4MRmQuMA6ousQA0OZ+ANWo5uedsPJaAQiHEBYNX1JI +TxFCLRXuMLXg7YkQx6PrgDxzUs/6ePpwelybEw/yCpr1s+wlxfDQ8MLo8fXc1dWxy96/VbPN +ZHGDbELliJwEEAECAAYFAlbphasACgkQgW+gR4QjR8opXQP/WZpEP/HH1nJf+Y2+Ay+zwHgd +Eb7ez42sAQJQsWoN0duw3AIqX4V2wQQUQVi641wxvBVsrtqFCiejyJdxwK2pI9yyjG6+OWUT +iPdwexBid3goOV/6BTeDNnsl7BpgBSNmCZ2X/hiVPafip5pB0ZpeSQuP27OvqExf+lCR3EWZ +iiaInAQQAQIABgUCVumFtAAKCRDt03J6j078FzCCA/9rcRLaC+JEXEk17TbAlhMcesjt2uk3 +cshN9Gntog1aez7LRLmB0OejWmpv+3tCl2aXMspHvzT44aGZEDJiWrdsI523w0HZuhdY9nok +uEtF8CPqt7eQDlxgMuWyWB1YQidk/HKDPqaRl+aaNAkQ3L0kLJXAL6jPDK3jhR1DO2VPZYic +BBABAgAGBQJW6YW8AAoJEATfLpzcs8qzLBUD/0LIj1+46ZKRTgy65zeljGPnlvdgEdPiG4J4 +wCAfWP5nw541LnWoXUCStAvHeKI3U9vUmYjljDdaQfFlIHGiT3jPaQqUyORG+ZEb9TVCrrls +dKosxm0sFAQCw6YmtbbrW/dE8qE+oBvDbW/4aMfb8D/5P95YnFgR4utKmDT7qu2DiJwEEAEC +AAYFAlbphcUACgkQVInMlqluqM3hwQQAx/JhEh216BCynBqTVuwJFsEvmzKdM+nYHoyxMeP4 +JkRQ1P4IPpmLqDNmLzk5bm47vA2CICdMboN7kkmy4NxuHut4+bvkIqC/PuxPZk5J/zWPjOas +NdJVERbqtSR9tgjL9WSKkuEVEkQBWkuKA6VGHspg+5Ryx5gtgHLImw+FS2aInAQQAQIABgUC +VumFzgAKCRBJ9pseUBL3E8r0A/wM9Re9F5SZ7LlKWyllCU05OP+hQUZgq4X6uQNfaBFCpbbi +vug/aPqD1v9el7dVQ8jN0/My5Qzn/mofBtXKjqlFm2hyhXckxiwlftivMrt00OEgySZ7ZF1V +vOItZvuLTGHosPKvZFunY2Y4Avr2mBWa3B4YTFpi6beGZD+kgeIhVoicBBABAgAGBQJW6YXW +AAoJEPY7MwpPtHy6pJYD/j/AGO4JKkQea8mmPjPzHGp+kd7OaD82hGCGA916mA50wlxulQ1x +2zH3+JdxVpUmro2CByKJe31nfCsvaD3Cm9lxlUNZEQiIxWcir29RLiswSgznZfU68ExBhGkR +GqyQJJ2jhg2oqpzVJ3uINV54c52VCZVwxA16etEyppwFGvIwiJwEEAECAAYFAlbphd8ACgkQ +aKS0byRiMMaNvgP+IsKVjK5A6lxMTzRYS3Eu4+Mlww9ixkxpwfciO5GW+/4+CfbU01TGmgeK ++IXxshJ4Si3/lBpoYUbrvJx6xiQGRVXicYKvX+61w3wzkCj38rNUwlS+RziMcSm3Y3QYPD0N +Nfr5BHtmoRaAM9gFE8Tx/uyEkfVm9cUhlTp+GuDL5eGInAQQAQIABgUCVumF5wAKCRA8emUf +I/fRiqn8A/9bFt+UM9fLpLM+MAlWToXji+Jx9wgRgzeskvemsTShHi0KpLrIKSSBnL8r5Z+e +vYXxH32SyBBVzTQWTj1170Yz5e6YpoOEvWEYa4Y1e06Lyfj09wnhUJYjcwJjRlTZSVRq53fi +ox4aN7KBa6KSaGHHZWHQo6XFAZsjnMJKmjNSAYicBBABAgAGBQJW6YXwAAoJEFEsZet49/my +MTAD/0n1ahIIs6TkBhljOV+TVQ/gY/GcnCyyGFS2dEJWAGJIAGMLmci86ObkmCrK8ovfDjHh +F5DFg89rKURBqL+9fA6H6RcTa8tLlWVabQFDII74wRuGv7uS9MPp/aQxCaTJywMxufWvhSyA +J3C3tRNwqS7QcRZ5sJ0NfVmf8BBC+7qYiJwEEAECAAYFAlbphfgACgkQhcEEciSMMU+XzQP/ +d3p2ss+mykMeuvVXlUYQpIAa0rvjGO7i6xp2M1p76/MP3etSt6Xoq+8dqh6D2oppXtHPtoya +K9EMbQrvI52NsTBvdBA0Aqs8JxONM35/uArcJjlryphN3hLXde+U2SuIJYTKrRO/pAxSfZr1 +vqvLHy4y9NDG4l4p0ya5NiGOjS+InAQQAQIABgUCVumGAQAKCRAU1TAtjvJFHZJjBACVuUJm +YIrIDoN5MM3b2jeJo1JElW1YXFmsohCe7N3kATpJZ6b7RC68uVqQISZJCQcREObW9rWBLo3j +bBEfRgGsSfz2TxSKh17QMyMQa5TU5KMM5/cs1niAgli5TUt9Kz02Dt6D+4uaY0XGH9Gzftu+ +hRd+uH2fGoBzPWFHIWAHy4icBBABAgAGBQJW6YYKAAoJEDZawL5S+KmFc0YD/jLs8Mm8PtW/ +KzWfRqIs56YH4K5+Pl+0rZJQvbN4/wX2I0qg2g7KHk500SANx9HIqP7wEJiqGmabeH/Lzgah +Mn5x5lJtRRCFJtaWhh5EWtvjg+AXUMBnVydmPpqLMzqSF7NYzYbwLPbtAG5hhAV853oljGS0 +cTMu6PsUF52QNxnKiJwEEAECAAYFAlbphhIACgkQyFxFytmCeUTz6QQAnEwgH8s742DmRN9S +qtyEwdjSeFsE9Lyog1ZVUWBCCS/cOqMBC3TE//7nJS38iCAyPTfDPIQRpXwHTAEdof8ZAajM +E72rA3xZqnFEkT5uZ3NHjrnvQzgkNS1/SmFQ1GhBIIt/BQ1j9g/rOO25sLgzjIEMP9f4Ek10 +BTPxtuIuo9qInAQQAQIABgUCVumGGwAKCRCQHUZCpitE1ukNA/0dF+jgG6m4bVEnZO2krMQb +XYodrZIjEGJE01lEiIHQH23c7LOjgpRPoq4BpDwn7sPgd9ZnhifeTl2ENAMk16is6W8UtKQ3 +4zaubIU0WFEjr8KKcpoelDQLFMf5X3H9pj6yhQQ2VHyPzCJOrMDKHiSGjWPEIzxVlTNJbGkm +6Kc6doicBBABAgAGBQJW6YYjAAoJEP7mFLw4K403GiMD/A2HFlGY/0X6XsKK1s+3D3BxeAKT +62/eTSxwTJg7Tvgbr+rWCM6ZWGr2DU5slg7tmanxU3mQ+Rtb178/Bxu7svPmVOCIif8/gzit +IZT84yWBo1cURJwY6foWlGrJpnZz+gJYpY/bH0gXJptOFIp7c+M3+V4zZsN+FInVFc//cRKd +iJwEEAECAAYFAlbphiwACgkQfeHHXqcHZUN4yQP/Z1QXOBCVzxcEOESkeQq/Bb8oTkH/X1GH +VDllq3R3FJoi3tkZvcxWBw0hVD1kgHmdwhUujYla2Y6WTkmkoSEBaX5quO+4zThP8N/5uY9m +HyM+GdYthIjXhSFLgSbHtjEuusRL4h0eRUvL7GvH3p0U+9JUNzXnrguOynGzxMxps4yInAQQ +AQIABgUCVumGNAAKCRDbUpsXASGCJolvBACbGugitl5EjpV7sHblDn0ROKos8BC5xECOVTIT +G0K0oqRzE6RfX6ykYHVa8+M35OeZmnJWcrSkd89NrQBf2cWRRGkllws5Ccp1upQRNGWJqVmI +Pl++uMuFivcSIrT+tBwVa2ZrXOBn6lgoteRtxOU+jr3VqSKBGDlkboDJCGlRK4icBBABAgAG +BQJW6YY9AAoJEG75nLUFUbRYER8D/17q/mFy8wZ0Hd+eR7/EJcVBc7DgFB4Ga8MccoCZbsjJ +rQHgsczwL0p3QUEOpSXVvh4OC1Wwspm1xJ/9jxCoznKLED3tsoThe6mc91iQqLfGxYfdc9Bj +ANes1m5eA8VtPOQ8uS6cPYPiVPybjUp1/dd39Im2kfpVZko6FQFFigiXiJwEEAECAAYFAlbp +hkUACgkQeAm2/FWcMKS+ywP8DPmwfB6hHe6sfhOoEB7qFlYJb2bjTwVTdnfNW0jR8nrCR3zC +ZlXlct484l/d4wRDpz8nOlr+ruQzD32dgKY+UY9MMBrkSg1AoDeLkKbT9Bp18HXL1p9MO1j+ +RR38TUMSHazn93UyDHoHN1XtBAFnipLptA+hulKbE7f4C7zMo7qInAQQAQIABgUCVumGTgAK +CRDNfM+BY7kboMdmBACXeW7Y3Z46iW1P+ly1VLbZW395tnOdwBw9thA7tMTlGDpY8nBCNxve +3I2OvkcSmnoYE3DZjfhDW2SGBsynhNEullZidr2tYLGh+i7BUVVfnC167fwdj1F4pH9BbfNY +frTeCqdnQCiO2vxnKfiw5UAqO7CSqDAZbfPhdu117Ia8J4icBBABAgAGBQJW6YZWAAoJEFgc +TV0pvlBsbIoD/0VFjRfKqMyA+SCI1KOR0aeVlT91bn1DlvMXxTIvGQm46IvhrbvXQ2WDSOzw +1DdIc+uaGxp6Hu3BEvyiuPIoGn/deOBFlyTjCCvzQnbWHPcaEDExLeuXrs3Tf+aDQcrmb8TZ +yGgj+fYGfDqdUCk4+nl8vjKgWjr5vDPKJg1go3mqiJwEEAECAAYFAlbphl8ACgkQvP5le60J +2MBLKAP+Jm2kofUpKvV7VXlx1J7QbM5z9eVXQTrjZEEwdgWBtGUF/MJEINipWNwOzl3UwCxa +ZB5Cbvtn6iThwPuroQVuw+t27MiuNTQnf/HuFFkOTP82vquRrL6iGDABOMqIceRZEUjmM57B +t0uVwQ4i3QZTJiINwGyFcuRtOhxKNdr9lEuInAQQAQIABgUCVumGZwAKCRCOV+I3bClQnHqe +BACV0ADZNXSsvtxAppSJE8ljxu/paNWCRyeVTBWvVnvel2DnTqr/eBJjcI79JXk6l0eUFSg/ +fjoJ62/yTa16HIQ0aJRxjj1ENiipBO30PVsKSHfbiloP+Ia23bG3l/YSrmpPCEV4CMwbglvB +8TwjcDMsUUfNH1XTXeM6lvSE5hrYUoicBBABAgAGBQJW6YZwAAoJEIExGSggZ7qmFV8D/i+Z +SQXcnKNt96zvmTqb5org6GLS+2tnN5WXmlHB9UadYXr3j9LmxoJptBDV9HFpBshDzjQutEb3 +Gcx7fkMjR02YVMlGMQ7KY1O7hZjQLUTqY2XXgsgivsMkZR9BcrRdWqux5p771jFf9IIaSDv8 +f5OPQWBjNRoguTBqCsMg2EroiJwEEAECAAYFAlbphngACgkQohCEENdle+pVcwP/fBgaWR+u +LE6EF6RFcBv3sZkjhAMDnExTJqh+icLrft0/qEHwozeOnPpDbKLUdUBX1DenzkQMHkqfnDyJ +omL4hJ9lqO773MG0sZpfML1p4Tk0EcNIgb9pyJkKtyxBjVT5C/mhDKYPyEBYkUfpKxZSRg+z +WVluhhQikz0ppQQc2s+InAQQAQIABgUCVumGgAAKCRBZHtmCxkKMqZabBACEKxmSdempMSaE +Ju88bD7mDF+MdT+qaL7+Ety5fhtRWGCjPLjvuh/H1+jm4VUl/sye+lXv91NJv8r0bsw3+Dob +dpNeuY5lJCxSllNaKb/osqhf52ANgyOeltp090eVgbGQ64ahHNM1TASvgom42Cdhd/Z/sWid +LCM3lfY/MigvmIicBBABAgAGBQJW6YaJAAoJECy6FzQI/mBxgIQEALoaH7A2ItMXzct2M6JF +AZNYP2I5D6qaYE+TJvW7lZZCHwS8j/Oth9VXZMc1RG6AlPmn01HGGTQhfVSsc81SyXOedRue +9+dwM3QgwRAEu35nQoOImkso3DqwGSM/w0EuuZhSHesf0hJlRPPFC5OBNH7aDDQLJu7EPxfl +RS6oUWGXiJwEEAECAAYFAlbphpEACgkQBdufcT0tf61f1wP/a9+ajEq+rwqyX14NnptWUsV9 +CgPn7y2L/cuAMvl8nfBkucRzHWmRPvSHl+p55IFULaYHNdu0MhCVoekqDfUxz4cXVRaopvep +QmxPrFJTVpmi3W/IPHpcsWLgjcb9dmtY5DCAtpxskOZNFxTrGSkzFmqPSWAJlEUnyvEM4Reo +AyWInAQQAQIABgUCVumGmgAKCRD4IQd4/zh5LrCsA/0cBxGbzo77yF9XHrsyGmaaA8l6TRpl +zBB/zH10HvBJuRUz2XmPyb8YVbfORvusNn0YdGo2lW2xLwnXL4+D1pmu4NTs3wr6TKNZMuNA +5rVx/46lF7tjMG3RUqz2NbIehMcUIOt9nVsrB6dPwGLieXq1TW4lXPU7N12nUnL3nZdyt4ic +BBABAgAGBQJW6YajAAoJEEUrrfauzXZG7k8D/A+S3oepZLUP8OS5FC90Cuhj1KcMH/2OS684 +P+vKYiIKJCsNokbdA00UaOi1vvPhTdiHm0WV0yGeeZ4UJbBfqWXzRpRlvV4ezzpAi3yULqjj +M5I6JNr95no1tobpOf3rtmWQumge06eswrH8BIJ1ERLEuItCAuDE8P7UW9BfEk0ziJwEEAEC +AAYFAlbphqsACgkQrz04ml1BOwaocwQAsJszWZa8KKGaFZJ/W9uuKSew4DAOEafxcQ+P5uaA +nWlR26zM19Holg6e2kladP1uxGs6GBHnoYua688EwEq8J70Lfv2iHv3httkezhb3ZFK+Lv0U +9Uq7zXIjEH032gZvqsviexUbyPt83DdF4BbOt0XdOYXnQBSB1uOIPl7ijzmInAQQAQIABgUC +VumGtAAKCRAzU0viHeaZyCskA/4/bR+mt3+ShKqtfMWwSuou8GrolZlHx0J0Zf6vVmWczbv1 +x7DFkrGSVJG5GRvNE83rLH53Dg9MRoTAo9efpwXYUk/NmRXCs2sDWrCezG8/rJEcS22npZ7k +91EIq9sxQe3bNHoZHkwEdSvvXCTocpILhzDlY+GQGPTaTq7amIiVW4icBBABAgAGBQJW6Ya8 +AAoJEEqnIl/+Jzs0QnYEAIkAduS3ychQBPiuDK3WFLFtUe6QicYiN1psm8K6Axpz4Y2QcXKk +dbqdhN64JsluwMe4sde/9moF36apb9dMAiAzn7ESegxm8asJd8TbaR3QSBbAdLIBoWFk63vr +XUtrPSDSsobM3Vx1EPMDfd/8+AQtiN1aNfCwpY1CicI0OtgZiJwEEAECAAYFAlbphsUACgkQ +mVengt8kbUgNlwP+JMIa/Mhj4nBzHqLeQWS8htJxMrlsC7ycXEohXTo2VMQsltJxboQ1Dger +UQXiFx05u0Qa6bni8Fg8LX4LbPP91aE5GCph4TL2epLUF2n944V6q5TjOJ9eywLVG2Wr1XtW +4I32Z1T2If13oDwDlnVQnHVkfgMNfXdrm8XvsdalNGuInAQQAQIABgUCVumGzQAKCRBW0Pez +LzhDFIowA/9HMcJnl9rIP2aEJLibSzfaFlPtsyvT1Lw5frJxdmbHyBb6l8McziyAMzuAPNyI +Y9qLrINdFogS6fYbHgRSaTyPk8/jvB9BpsVfTcepOL1BpxNzFH65j00FZ1/ODGqF1asdZQQF +lb/RFPmpDAUEThWRWv0fJkUU+v9p3Qvel0oR5YicBBABAgAGBQJW6YbWAAoJEFGkDp75uZuJ +H5kEAI5zwur6ATW5MS8Z7X4NqXOyregRENkgr82Znn0tRKI7skO/6y8cYHU+Edvla35jaEiv +GL6riQwCZy2qSrX82h4wf7R3SmR9zcss6LZiUrGPyIaAcVl1ZWJjxVQldiePin+HZhh5Dzui +rkCScU3ABkBXCsvJv6zPmNWUc2xBNX4wiJwEEAECAAYFAlbpht8ACgkQrXwV/gEuJdBh3gQA +owR/PeIRIulEILJtQvD4ORs0UmG4svdWNSKKlQOpXkvjOL11Q7zvUPBJYn2oKXMwzgN2m9Up +IR4lDZLXI5XucOUbdAKkQSnHOY/slaxy7IIzgfoRNj5WU4RkciT16yTMyosp17toxvxiNVv3 +Oe1Hv99O16KWwjExu8a98dpY9pGInAQQAQIABgUCVumG5wAKCRALMajtN01LB5pHA/0Rbhkq +MqepgZQtMcZxCzRhgrZLEN8Bg2Q1mAyJjehAA0cDytn7p51rGEX3jz7baaKWqFcR2SaNqxwl +25DDqmDEgqtpGQ9DSZEbW08RlE0ObccJuuJUurcJsxEbPBGoQEvtidFGp/35FbOZ9ajgwNc/ +vGnkKUMwXMdS9Dz2ZgFBkIicBBABAgAGBQJW6YbwAAoJEK1L7HttcIU7vfgD/0eMe57OUbhj +4a5vZZhlioNBqgVp+7We56ISycyLDwblZhT35XYab3fD+lNeMLQu8FnHUMY+9nLUydx1SusH +aYHevVjn6Kz+TYp5H/bk6JcpDTgRjWf2SfEcU5UcYTpUQBL8sERt/g3qQGp+7whcknsXlanK +H51YjYJLWEz/flpJiJwEEAECAAYFAlbphvgACgkQsxKSdVLvXlzlpQQAxbdBfQoIn5A7JABF +ZKFjjXrQnuNpdzRcpN5B6UOrVIxAUxEwl0myuYlb7QgYQ2LVI3g41kIwOQnhw+bdMyjP7tIP +Rd7ENpHMjal+aFt+sORLPg9ia8KzB+RjdT3ICjlJ/4SkQJEOKRKt7Y4aZwIM/aJlAZYR5e7G +vKaVBwtiv5eInAQQAQIABgUCVumHAgAKCRAh1ZtJrfwP1d/MA/9cGBxi8z0uud8mGlVdCSu0 ++oFBmQACAVU/vhJtNgmIjyojMm18sbNYr9dKwT+ScMIAICNEJJYyE2GDQJ3XyTnI/zJkg5xd +kwgxrVX0ZxGd/YEsF5jDrWyVWb+/6fN3hEEWuCkxi2zx6Kp00CgB6keX1WEgLOZYGx2VvSjC +V36ng4icBBABAgAGBQJW6YcKAAoJEHn7YMIxMS21K1wD/j2kSoWWeHveXokrBzxdBxaCI1uW +9y8rZCi4QBhHbZ4dkV8gplDXaGKXZUYF0kFfxB4Cod2FFuLbt7nqFRbCnm9NyJ4Agve9JiFl +0wuwR0xcQ/JMPKvaN+NFCx55lLkD2w+4lTrpZ3vzy/2aM/QgCzO3yK3UV/osAev1b4hZhrh5 +iJwEEAECAAYFAlbphxMACgkQ5LbSYyXnsARAkwP9FG9SGUbg7XHPjTjI6cLSFYe7kc0DQ75n +xiC0Sy5LeFkrGtZ3RcZdZ+rdWHdHkuvoQC+WoYWhNvcG/FuYypRCiNcBYBrs0jloxN6f6ieJ +XPIECFYceVevOMg5yUcN7SE8x86Wa0w67mmibxlRRxm+bBjWLAw8mz7xY7hbC7sMZg+InAQQ +AQIABgUCVumHHAAKCRDVwrh7eLTjH49SBACpoIz8lkTo8k0qz5wHc9JaE9Cwrgzh1m55r0OL +beRCFHjUJw3jscuGrojG9aHLkVzwu3z3i/BT2qH+TgzWUNtkYbgfh12FY8vuVszYiS94JQG9 +BnDIQ7N/tPlv5O+oumnl9T8G9Bvk8V7YpyLwH2Rb1FIEdFcoGEUNGllRcUDYIYicBBABAgAG +BQJW6YckAAoJEBd0n0vyh5bPIuED/jHvBaj+HGqq0xXJ8MKxRGtKMEaUIZgVbRAQmEkuFew0 +JdwffXQOEAOam+ZRCSLBqb4/FIeHpBVDIM6yUmHK3U7DJNucHRO6AUJkhl4q8LLfFD5UXnhv +kf3/i4y1I5pcbe/Ob6wPMc9xvWCcBsLwjWjyFd2CcyB25UuvIUDMU5iRiJwEEAECAAYFAlbp +hy0ACgkQ4FLJ7ytm7J78mQQAjGR5YElFgexv+SoNcU11gFPSEihl8v/1FFc3XrI1qTpL35gb +lkmQOPdufumF+F85zotbdaA6cL+3DwkdoqaLM0fyHHqaOQ6/J0kQ/lWQAmRtbj5XHCcFmToI +kQDrtwlmixNdMKdtlRnZyVQCNyD8TOFYQ2HXEUApT/MTJX6ZP8iInAQQAQIABgUCVumHNQAK +CRArioeeRhIIN8vMA/9R0W4AHz70EgQ/fjDJQm2unQ9mMQpDIbrqGZbpg3Sxvrbd4vypT87G +DN/SeTAemZ0LkElVNAiJ0BHRGGOwkHCGKnM8ifkRCPQ+mGQ8KpFMUJ5C5fKMwwamypqsTPjr +5OKkFJHyZHxZVWFOSRZA9NVybqWRr1fSCwAI3LLtnCBWK4icBBABAgAGBQJW6Yc+AAoJEHGt +mfV0nrdUAGgD/32H/+Gikug+pQhEcAnTpoAlkqGnW43laefqq2hFLhMB6T6otLO2OOK5oOgy +uzY5g7wmZRYK9RJYAX3OxSno2AxN5RMCZBhY6mgJXPAuhbcTnPefTMzID3UW8xl4cs9q9KcQ +tB1/LiVQ2oIrJMhhLdu4zkreB5krBr7km2KjmJRIiJwEEAECAAYFAlbph0YACgkQLyrUoViu +SEzO+QQAwlufkj/wtHl0iYBRtLt8qHleaoYK4DZ5sfgQnt9aRXVN0E6ZG7GBMr7P07JmC6gG +6gDdtruQMyMpw59UfZnPoIZksDxmH2s29u+A2Qd+n3Fz9gc0GDeZSL/N1jZPo04dfq7UaHqZ +MFcd9YgvDdtCaB6cJZzud08jHLd2WGjuPE2InAQQAQIABgUCVumHTwAKCRCfbqh0ERZKgIA/ +BAC3+avNRSZWcdYK39msjTdqrCaotaIDYdPR7XRoykQFUbA0XPuUynWVZokNaGg3NK9k865J +WsLaiiJAoDLdzg0+3g7M1OA/MfTH7EFiHkEOIl++xVJYpOTeG9gLeUW3cOCV9JwgN1ngz1Mm +HNT+uUipmM6i9hxPW11FGeaIWxl0+IicBBABAgAGBQJW6YdYAAoJELmo2Jvsf0hK4jgD/0bk +FQEm4Y9f36BW0yoEKny1q3si9mdWCCVRg+/BWSeV9JWnQbB+w6J6X9VT20VoblVHgdW9ijHD +fypue5EkccIUq4vLHXvw6EUQ55dTtjSY8XLzJN+fn/nx4TwtcdOTO7js1bZZrhlebNJj06Qz +baGmJy22mKC39gTf8jURhldjiJwEEAECAAYFAlbph2EACgkQ5pf+oeD5v1UZ+wP/VtmhXNU8 +JrXs9xIbpR+NOaJsfF9WHYuYmfXZi0QWjgdWXIa+SFNvhKPM6eDs2d6lyyz3wCgCQ2V6DvAi +pqZwRIUomOEMzgCm8CTBIQC7A7gd9M60tMuATYDTIOEMuLC10U7QuuaZWUZdOtOhvlwnbl+y +SM7pds5tlMLfIhRB3Z+InAQQAQIABgUCVumHaQAKCRAf4bLu6cUcz6iHBADMXMZMNtAdshsl +YMET6SgBLpl89jXr6Z/KuvMM1BpnW2Yo7lUJQb6D8DkbG05AASz1cjKLjtoLAgCw9WJY9Oyu +38+s9Ym1o9uXXEbZV+2kup255l9lm9GNfD91hM7bDO5werYKTcj9wci4N4IUIvdJDde5QUpv +DTum55jsFMEzFYicBBABAgAGBQJW6YdyAAoJENv00VoRE65R00YD/jZc/L7jCIP/0R71/bS1 +rZiHW9uLcDLdJ4TKM7c2iW0D8+pARgQHYFkL6ncy/SagQqP4i2Aw4h8HzAJHyvTXdr4HlM7r +r51gGK6Y6Ho5Ui0WIbWgvFxSKSRY69xe27YZhmhGRUgHkOH0ZADok1WYcLgCnEPFjvzKKKXY +T5KoaWIwiJwEEAECAAYFAlbph3sACgkQI5+HoCyrBOaRMgP+PMjY/9JhP2Web++YtybBR/eO +m+jGpJQbG7QLgrC2g9tWDP+K1QOGejkK2MBbd60czyL5ozKalijpBOufui8IoAPEGJX2xkQK +R9PIaTxW1Y15q2BCouNgdU9EuKxXQFF8KKX0u8E1epw7wJbBlgdWpk4CeRYqHQHwUOP8wh3x +V4yInAQQAQIABgUCVumHhAAKCRAfLidktS3Y75XRA/9taC22793RQdznx9zPlLDwpr09JzSj +jQQUwfHtLpY1Bny/MDLpwgiLF7FZOd32UjcuIS03mR19J/b8hREdrIGf+6v1YHBeoPA6uvAl +3XpephnCd5eJDximeDrZa8OXkHUG3bnvygGqHJ1E7vKHXI6vaHYMukKxvmKoaV8qXG1wN4ic +BBABAgAGBQJW6YeNAAoJEC0RBf+kirBd4FEEAMCtoq43o4NywYxjmqicHyIxyWnYqdXiou9m +yXC1pjH6j/oYjz+R50aMB3YYE7gGzQc5RqRN6xYil2G/IKbqL/yaquc6sIydtDEV9GsBH3SL +4GYM74amth7oEm25rz53NVs37W0vgkMIiEkDaAyvW+gdagLEG/Qt1nHH8bpgiD2PiJwEEAEC +AAYFAlbph5UACgkQpDWobpPa9Rs8egP/YMw6KZMcUm9ONxJs+0HEHDdn7NQpmfJtng7kkbar +85947S1bFq9AqROHiUFkl0dIklicESbtS/DxNwqfv3AZaYAVcUPte96jP0UgfTqw9LCXM56t +6FavYkbainCAiiQueqMjBi2UTeFo04VrYpzs6Tq6wfZX66jZBxYtoUsbVPWInAQQAQIABgUC +VumHngAKCRBFqfvNBUTx5Em2BACtCWUmWaQvAuqqQg/lQtptiA8bQai1ochbeGYGSq292UU2 +/WHZx7w+4jkdRxzUuoibHMyyk+eB21ulZx8Lt2o65a0hm8YCU6h/drGVaoJXvOh4xbKdeKkU +gy5hsygqxnSFm/PeeykSTITCJ+41DnYE4yAG9zZC9A7XjSmNempR64icBBABAgAGBQJW6Yen +AAoJEEg8xBwpONPE1U0EAO3qKtq4TYK3MGBiy0a83aWL74XdEyqW34dQaCXb/8h2cQ3sJdnA +HVOa2W07Th+Lg0ncjrDNUFuI6LBuo3Kw/Oc1S2G/flnpwSFjq4DLAUMdJaytcSpUHeWOPmJp +RDdUkDds9lDQWctWPh8D8VPT2ctx7f4pphl4P7PaVxiJ+2TUiJwEEAECAAYFAlbph68ACgkQ +Fn+YPclpPnjqqwP/Z2pVjTbdvZFN8imKIKE+dMeuV5i8k0PM1r0W6QNOtF5NQO5x9kOD4bYJ +L8xhdbcCewxpUjg8fN7FtVu+kYxAvsYYUuPgyoxTc2T62Kq6IBTjTZgktukuv2V/Ot3t95L5 +r3fi/5ejq1x+DsjIv7neUoEmaGVA9I+t5sQrvtfTixuInAQQAQIABgUCVumHuAAKCRAZFqZP +ec4R5zHjA/4lm03+DRsOZEB2/PTxtvbOF5vR1powHF4aJlkRneufLYirdVMPyujLdJ8dPtkD +cpAuQEoRSAzsJ0FUSXQqhH9iAfJxA4IOXKdkwbxFaRUe4vXdaqPyk1POh8QAfBHSIY/Viql6 +1R4HN4DzqrkJ0dRRH6zSRiYWXhWNKntVFInxeIicBBABAgAGBQJW6YfBAAoJEJ+nvuvafOUE +AcgEAOPjIdny6XyON1kpWp8n9cjgsEBL/s3ngTjvw6Q/fmdx7aMuMTCS5q6kMpObh/DlbXlo +PesNwQb9u6NFcXwyXTz2bzX3bgPi/ysuPYVbWilfuvrSSGmvRvuh/1u1ZjBHCHIcjUv3lmKU +WLmSTthNV89+Et2sXMjKvOlElKDric1ziJwEEAECAAYFAlbph8kACgkQWW1qWdaZuUqlugQA +k1u5/gd2KFgr/gAB4sIIl4EZUCKAkEXnd4EIXL0jtejOIkEQorsOxVqNCGXTN/XnsoVOzUIi +v5uXe+degr5+9zmasFAMrkVNR0QUV1Aa7XYcodVqx/ILS273jDaCl7j0NodFakLPtjpeRFbt ++sBiIQRaAEai+74J8A0jqZAaG5+InAQQAQIABgUCVumH0gAKCRDqqJGImKZsosIxA/9xBwju +UZBWAl66JJnN3R6uR6X1zJz3keFT0JCnIkObUc21yiN/aZ2spR18R3ScphuV8wzlEQWv4S6i +Rd3g7Y3lcGM2641MKEV4Fgz6G+ZQGHKI69v5wFuPMGiKXLMvbjBzauNgnk2XukFPlXvyZ/e8 +3fXcDRHUEwbH0PgwTcF2rIicBBABAgAGBQJW6YfbAAoJEIDl15axnl8eHs4D/1ysP+GfRpAd +3teVGwXEbUiXSraGhhB67xRkSfLAEZcvrIPQehEzxvsa8C3Tadxcc6u4PUO7TUH4kUk9FZ6L +VC0Blx/i7+Ix9J9qqMPEhkzXYe1IstucjU1lPig4fqgSseYakvc6UL1qd9jDtsz6UJRbl2Wy +wU+vDP10JPo4KWEOiJwEEAECAAYFAlbph+QACgkQ96AfO9tFF7TJSgP/QnRurwqibVT+QLFX +ejPPSbm6s0r1aHxFcv2FnU0rgQ/6lj8Y0TAjrs5D3rII5kKl5x0I6Wr3rgPuQZBdVMrLnGmO +eEcmnThEZwG1wAIoN6hH8xrDJjK1UqNqOMDatys89lEXlrkguqbpKIvX6jcYBx9fe1cEvOZd +1k+em02X1QSInAQQAQIABgUCVumH7AAKCRAIamgQ2aRSOolxBACrngGDHXYjZL6pok/iHC7Y +k1GlGJGtwLrV4/xTYUBUZ0rADqiRDOwOlErqKJkdK6UHVv9SajBhFzah/q3de49hjHgEMxiO +/ImVRjDuRtoAqDaP+bCnySJC+KWpItOn06EHGe/DcthiMsuRIUOQtDnE2Kb79yYvxjTgH/r7 +pImrE4icBBABAgAGBQJW6Yf1AAoJEMO7zGxJhS0t6E4EAMPg6I37vQWViNKxJ0zDHhgPYArH +zQXESl1+AlijxuVnuWO85or/oJvbxz9UztFo4AQa9d6M/2YvjAfaIboaAAAG6jUf3XNoVxpS +dj2WuCV6qevkvjuGlrEwrueGokf9EgQCrQzTpkT4bgEHt5KhiRnL2kM5qkQuZtM0G5sb2CvW +iJwEEAECAAYFAlbph/4ACgkQiyIbt7XNaKqKQAQAk9iYS6YEsaNhuoy+7/zCtRy6gvoYtSGT +rM008A7rZ4Ys7a5WMFmXheDuetAQ+2D0zPccLFZWJ711yjVMl+0IgD8cvvOUAV/vf4HnlzW5 +e1WnBcvaUruoHzr2jYJzi2cUo+7cmKHyTDwExDjvtW+46zQxTAr8mnta83Ly42JSju6InAQQ +AQIABgUCVumIBwAKCRCiL0Hsfnhk+OXnA/9SHpOEs+RsPkbZfBdm63MDRM5NDcMX13davPBu ++VbWwHx57Kg1N6qf0lCLSmXzckdLUWu6/iOPRc2viPzX3bFAl5meyZuGCOEsw2JcDoT4nKMo +7pOOKYHtPYenzOA0xdUJyViy16qtSbToKlubRNBLA+A5pIYmkJNJ8W9RuEU1moicBBABAgAG +BQJW6YgRAAoJEJ3yO3ba/LrYm/oD/j7cfEIN1tSQUILKJtJhpfrZfVJiSxj60JizkFduUnoC +ZK/rN23f3oHBsjQnMLY+3wQTSuzuwWFzUeZhsZktxUIgJIedBY0g1XvWJF/6GF5YUGvimrfw +5sPZA8st00j9M04QiWAFvxX/Hm/eHLrICwyOmtk8TB49N5UojAo0sGUoiJwEEAECAAYFAlbp +iBoACgkQf3Atw/QEIn/AtAP7BQPaC32XAFEwRGE8yNF3QE3l+sasehtlaXJ7emqCpn/0QME1 +jxfulSwzlVqSnpgB6IRsyg6Ny2CWfWA4JomVra1KXLLGyTm5NzoAR5jjss134aXEujZv/3Pr +xCNtcf+A+aKhQXirMLdGwAYN33OHrbfRrvv9pgZEeDygs+NS7n2InAQQAQIABgUCVumIIwAK +CRBEinZGLq/Y0N8CA/9d9ILs/uo/ilvKaNAlPFdr8OscnoUHajXu4zSxT8qEsda+iJUDlXgs +W3E0W1HLYBjk+v7UqnpwrSVVFMIOQ1o086XCyTgLtZXYFhiyv6dlj5JH3pbplYbt0IkDio+W +9S0Tqte1O8La3YppUnUpRNwPWEuvg59d8KnHup7XhIhdtoicBBABAgAGBQJW6YgsAAoJEOds +sTKRIhAkzr8D/3skZqwTsHUl5ZB2yqBfw2BSmRuCUgCWLDN7wLpbDj1ej02d9l/Au9RBVTNp +Q8eFZK4bwt7dzfVdlBx1J7NPnmEDkRJpC4vooAdhHw1WXFBOec5N8BU3/T7pB5XcTiGJ0yU+ +NSEaYIugndJwW29zasVvS9Vydt4wW2A+fYbIiAPsiJwEEAECAAYFAlbpiDUACgkQQTI8fqFr +Ae2cPwP+JtjEChfNTIexkXAJsf0+U6yGoLXiAEfFTv+tVc2kLvL/DWDQBhkklRgIVTMdATIZ +2XI7fdvp6ppmmVxPHtI9eH+BdbEpjp0vVcWzH2a9WjGOhplnvq2K/tQL115L5eR5BoyiTdkW +Jt8+dnns4jPCPf4lwm25lxwU5G0UdbIBGw6InAQQAQIABgUCVumIPgAKCRBfsQUkU0uxsHR4 +A/4+bZitS35zZku/jix6UYQ+hTYwPtNEFoO5Mw2OBf14MBtsgvlQO0IKv4QjaLU1kxzloeiX +cVAdkwTXViaoAP+i8/wXnPkSmWrdlAUMukydatg8r7s6bWMJQsT1tOa9pJY/6xu5ADc5Mrte +ASgqbVrjWJGGaychC22p/TYTNul1noicBBABAgAGBQJW6YhHAAoJEOSElRu+sHOObl8D/igQ +HDjWw7vuLX0BxmJ6t8JaxxPhbpzfzPle1EtHMqJHZD8pYMQ4t4MdYRtoT8G0HPfyOJv9HX+l +Lrv+zR+8sd6+Xnp2dw6YBAYtJ1kn57GcjhFuV6vW9P0auv3fv+3vdQOUlbi+/S4L2dR5pj1D +dDSfpCmvfRFJ5nye7XS/i/eMiJwEEAECAAYFAlbpiFAACgkQdpxpBZR0QD33NgP+NIBJR2Ip +5znjjiKcJBEzuhHDG1EttSnH8PbapnBZj856yGNu07VlZDZFxsQlhox1AzwHm2KJSEkMiIFc +Q65tlCEeIW9FB492AHn4Nz+bnKKklwMGAasoPMXwmhrzWD42M62xhWUCcBO5SjnyBRy+59QF +gmPh8k43/Fg3+Me5Or6InAQQAQIABgUCVumIWQAKCRDaO6yObNOhTR2VA/9NHQc/CLk0mXuI +Lz4V/5b9njmmidM+joQfpB8f27niKzxU5m3HhFiPGbIFL/9ySxLzAOVVuUywoB6Sy8T4Lot9 +wSIcJIf4tWFXMIYSOz5YWo2AUBMmlzyBoE+aHfx44okW5c6hBzyfl+JmAOVNVDjRoa3B37Dm +MjkWEeYmlEXHkYicBBABAgAGBQJW6YhiAAoJEA5TzeSpZYdtTAMD/1w7NjeY4tcQus1IzUpI +0udYAN+oIw7id1LczZYPwjw0USxBAuYyESvN4nkvtlOCZk6Sbm/TRM1RuMYDftCr+cOF/Bwb +TExb6U+5jkXy0i19fkPhOKcIHH+rCffhbFyfDttUu9DbZ6kW7GNoW5YXjbSqCfjKrWg/pcii +DduCst9siJwEEAECAAYFAlbpiGsACgkQObIsFWcq+skh/wP9Evo3fXrWP6mIGMF1TKtw2MZE +1lKArCv/eAcnw1WgXjBlG9cwlAuBMv1Bv/qoNZK/x/Gt84DUIcW27lnz9JqWNVanWRQlBsQG +I3baBNQUEiigcyQriW9Icw+nLZa1PWcf//RKtdsTqNIBbKdtAoHLXpfG1rcoWeFVw6cytDGK +qQ2InAQQAQIABgUCVumIdAAKCRC0EoRfFYFDPWhhBADG/EtfnMRzm0vTyTpSnJp9lFBSu/iA +Qju25I8B7VAfb2B7Tqd7BbJp2WFgfB3wevCE4nQpfy0xoPYPONIfzVEn0Sv9ON7IqErePVxD +6tqKvYag0dzPCK2P+rKVmfdJC59VHmeVsPpHvJLG7BlmwZxtWNZtG8ZY69qPi+sXWpB3kIic +BBABAgAGBQJW6Yh9AAoJEIeEt4D/hj2eJm4EAK+K/GXJiup8lG8F1FpvJWod+ff2ak5aBosL +p8ovsjqBQmnV7ZuuWREhLfJqHg7nKY9n+D1eVnlN8FlOZ4lzhXSG9IZzhiTm7m8QMahm9DDM +zxtieVDWZBSP5rUvX7g6P4AAlOawp8suczm/yRQlq0mAVotFtRZcdViBPWgpSL+ViJwEEAEC +AAYFAlbpiIYACgkQqmaC/tBpX6/iYAP/WqixpS1FKI9m0nBMQui7KHY/1YDOTmswkElygE8w +t0Qeab1c5dD0CSI7idX+WK09ZuxdHqFLl0diW9ZB44sJmrbjkaRTwSUbltx+nBjrtNVoH9BO +Z4sSYwBnuU1rURsEfb4jbNB/nDTjogpFpiPtMBqvqTJ50ANne7552nyNxgSInAQQAQIABgUC +VumIjwAKCRBEMygf1P/LnCF6A/9a42D24ezNDJEG/G23UsUCyXZWm+kv5734yU6sYY2D0iWO +wXmDp63Z2L1xy1pmAztzDIvbSgRRcDpVHFtRUk+TWI2r4/9kVIaDdcQ+uBe6KmN/HvAyFXrM +7DRrEq145vxGZUL+odrRZtQazHQs14ShV8pWtMYCgNt/EfD5Wynv7IicBBABAgAGBQJW6YiZ +AAoJEOFHUrvyKraj7ewD/0ftYD5k3T9E21aSCPk0ZOYKzD5qUOIPJqkkpIo8NSWbbydcMc10 +7g5dDK5CEsg4DGxCeR8HuuoeaPeP3pAZQd38v8WxOHaOhJaATDlEUMDWsdnpvF+FtWKtEG4t +iuLf/VWH+UCZUdbgeZU3FIwKgFbE8goiKZaIRN+ib8JX6RtfiJwEEAECAAYFAlbpiKIACgkQ +NC542LFRws90oAP+JRLJgC4iCKYqF00y8gMOb1RrDvFLSq1lRImtJErS+6WZA1valSIdi1LF +hphcHePWXAUvnE6DF3q9j9dbKHtD3ZLRbvlbXZrezb5tuYnZeNrVFNTz+SlaHMr8+/8XHhsB +KGkDrzzpbt/Baplt51b6nD8Zaqww31Oqc0rIGleupR2InAQQAQIABgUCVumIqwAKCRAW/ksq +E3RxGs6EA/9xW2TAVrm9tPoiWgCvK/pi05JlOFbRlkhlSvQglkt7RtzAerYa1MOqAONdQd6Y +yhUgX8VNSSslx/aHTSQmzUJwRXad7HLi0PyPZsR7Uox6GnFar4uVWg7VHaQxCpHVpNjN9Z4z +OdG/ddLGicyIMbAG6DPZMNX8cvbDzZ1FXX+Gq4icBBABAgAGBQJW6Yi0AAoJENLrNj2wsCSk +sAwD/jW0lLc/WS19LDy9BHLebsA+cLLAezh3TzoEgSmTGv8lt6sz94OAkxudiS+BzKmP9C4i +mFm9QgDXDLigxRuRQ6p+0Xr6r2Iiwh8I7DMibmJyJvQum9PCmE7x2226iTgQwrdRKPRuF45f +aXKbGA3i9c1h9frULesJ4aVrXtOierxLiJwEEAECAAYFAlbpiaMACgkQMNPLjy6kbG1BbgQA +zfAoAS5h9mv7ZWKAv35KKzVTv0ajwyIXwbgZe/x4a81j+lIvGwlFoQUQ4krRBcfLB1iW2b5d +Rvm4p31M2Uu0fMnqtM/UugE0802cOeDgoQVk9+Z18Mmn9nHk3jjuO9YAWWz5TLOlLuG5DGKd +SqZQNHWdUw8SinJqnmoM0VUM+32InAQQAQIABgUCVumJrAAKCRDRmvjJzsqSGFPhBADLmbGA +tP8DEXiw5masyfPspq5FzObBUf54DC9ZScmCbg2+505bjXARTgk/y5XRBNG1EfHVn8R2gbXD +bJwZBE55lqu0TKe/BNWVVAZm/ZRubQLpYmwOvzvwrN1NFD3hYH4kMSl+9zzSA81/jmnZZZ3a +ym5G55CxcyOdOofW3LEhcoicBBABAgAGBQJW6Ym1AAoJELkTLRYOeU+d0kYEANPHLCp5mK9E +9mBrBzQAGjxbJTP7+X0SDPKJS33hzNGA+vK80Qedd4NvO6dkTZL4gyRgrNZlYxRyzzJrVzdp +FsGGO9LVRmBKbuUNaeo7r3IcrE15YbOSxWSMGcnlewVNiRt2dtR3rBfd2xKSA+OVyaopWL+4 +9GnazPCSXTFawNwliJwEEAECAAYFAlbpib8ACgkQKm/qsCD77PbnywP+P/EsfgX9UPAwc3W2 +TFgEPrAc+Gs3XZY6FofLhiCIYhgFqdY8ZwBDHe4SeiPmkGa7WeFN8VpcVIgXiVR2i/Mx6Db9 +IHlrW760R2tUGrYllZsAWBYFyGY6gy4L42bG8CLzB8aEpF/3P2tiksyl9BrvCo07Z6/WFCON +wnFNsU2ie4SInAQQAQIABgUCVumJ0wAKCRB0FfMpLVLQN0qmBACyesr8ks09b5hixX6OpOWs +ymUodJApkINvbziu83j8R0lZ/A7htf7J2/qGbCEEv0q5mfjRF01DfpO8+QHLBZc3SbAaXjju +fn3uvgyPYrh/YBJqv6aAyRxl1Rxmw9W0Mkl9XULq1hCk+sTay2th3gEiY79WCT0KTe21ck4b +Tnc4YoicBBABAgAGBQJW6YncAAoJEKQsPViF/GOd5XsD/idwXMzEJ+FUcSszgkAvzVWAu+NB +oNh0lZT8pT+INOUTa7I7r6SUkgjh4ikAE+deKF7324GAbkvVSmjiygiACIO5qfbMcBwtyz42 +lVz0J2ei8vh+P3b8D7Bafgrn8lgFGmeSljf7qI6eHVvftC875Ycvsv0p0XXVNHyPSpK3MpkD +iJwEEAECAAYFAlbpieYACgkQaZLqEtoHXWKUFwP/U9HFRE56h+cER978ldJJcPlNBMB//ijH +n5FYxfaBtJ47BXf0HRr+gAfV6st54Chm0w/i+fb4Xxk8wA8n/UdDHVy+IKZTiBGKinE4U5dU +LN0zg1yMFOHegwmUIk7uS3o5F2jJekBHaNUaTY8iNynfnAZSOx9XSPA0s8tvgzuiLNKInAQQ +AQIABgUCVumJ8AAKCRCqAgkebJJW1foKBAC78AbPTVbQGp/m1M2fCDqjR9tBn3EFHuacqD2g +PjU+p1tfRt0cjnYJSnoSlfGrpaXTBS9G/xc/UW0ckbWjWv/jdg/4UEIYpJCJ0zGVuq1O1SEM +oEPDsCRLmRvy0Ui2uomIKvvih9WL7lPSCZfj8INU72Byv9oTrU/BbiOep7dPQ4icBBABAgAG +BQJW6Yn7AAoJEJmte3LckaOnlB0D/3LMagnxPOSjVgKbq/1IT4Yl/LQ4JfotVjBlws0C3u12 +ArTPXgR844A+MxLh7SIfkiq2J0RQOIUQXJKepQL+Q7e3t2+QVQGo1eBGUeA/J71KpbNEDYfi +e45h8FpK12vBN50wZesPpC7lc1sYvGoaneDNnTqqGS39YG+6DF5EMOgeiJwEEAECAAYFAlbp +igUACgkQ2QXR+IKR2joF5QP/XUf9B6sVZGb+aPCShBBPQyKYAg4WXPKUGg+SwKgdL8ybPHHH +9JKqlhCE0VznYhG/B5gTT5ZM+JaaGXE2CU4jO1kCAYFhQWkUBZKB2Mdx87eLc9IJrWNDcbS8 +wqMGIGMHQn8ot+A0r6Q7UmQ92H0q9jznjFHl1tOprLJDQcH/+fCInAQQAQIABgUCVumKDgAK +CRCFrPQQDz4mK/jLA/43w1JpHs5970hOhIi9ZUHHTbKOVXvgZjUjmJ7fwWefqP42CQCOmM+E +VzvAngYFAoUVniNzN737vUE4CfLHOZJhpbbgOoyZg9iQ6H/waJwdRFzwhYQKtc98is/kvo4a +pe7tgRJuaQ6F7oSgCZgG7raRrGuBeYp/tpnv4/2vBX+ilIicBBABAgAGBQJW6YoXAAoJEO/h +NLQOuYec8BID/1dgBDQb/5e4ijXf3oSjyxvFf0DWlKj/GOtyshfcY+9DNK97GEY2hVALKzSm +tV1ufj98830qBfYlH6FWZGjje2wlEVj+/TT2GZZ4CG1RZ/24SUYWTbvogh4S4UGgklwXym+K +PeAGRZv+7hcB8tan/Dh65I9/UR2cE1WBL7nr288kiJwEEAECAAYFAlbpiiAACgkQRPisieWW +zRJ4SAQAqTq2RCP/VzYLoJ+VL2jwKDeKAGKxHKBQrYbl7pxpkuTcKZ4KCb5+0tqm25fe68Fu +lqVqDhbDEN5j3QFLq0XlZ887P6/E2E4n0YOd+k7BkfH5AjmSNAxgCaDeZlMyUoNjHNIc1Z66 +t70jsSlwj295gdHfBFO1PsgtgEqpLeR/4keInAQQAQIABgUCVumKKQAKCRBQAnHtT6GePKPj +A/4vM+ubIgJ8FYRvqTUIP/hpjp7L0GEJOQzkmXbbjmXpVz2Qt2PsDxN4wW275zhAeO1rjQvJ +7cxmI8vxFhAklBOmAFg9w351NTY3DSEFI8VHNoMxoN3Tv504RVIIfAxlAx/GFL19uUEExck4 +Z1EoBtuOoKUwonE3EEMkMpt13Kv8QoicBBABAgAGBQJW6YoyAAoJEFZ2WQT9ZcwxQbYD/0V/ +AMM7JxnSGlg4Uq4uoFbvc9CKUhq19xS8jhvgNgTqWeNEE5S2vcWJWenxbVHhlXO2DkU4Mejv ++bANmyGzSqC2Lb7MoETGzDX3c8uTbEcTjG3uoLVARWnAurHYDgsb8M5NREaO/vTDrcuFZ81A +RATS7rPbG/zjFH0zBHZGrNjeiJwEEAECAAYFAlbpijwACgkQIEeChfXHwsZhOAP7BOE1L0ak +LEN0NMYRNeMqx446JhFS/honfRshGfA6eN0f5B/pgLt7aRK6PsiIp/VqPZNnoEPB2Gjgfpkx +MiZG61YD5xkPK9Ot89HEZ9WhT846zlfHYGlnI7KkCCS2oX0SwtjDH2ZAnKJLrb+RxIzzbYGO +Rog1u5o4ETHg2xIBwweInAQQAQIABgUCVumKRQAKCRAZ3WLtWlqzKulrA/4xChDL4zdV+6Bj +rxMhLn5X1iibJUQTpCaQR2PlZbIJmi3DukCTKPO24AJyyeXgbcx83JGNGHwt5rBzZe+6ZcOS +T4ohWdwPm/Izl6hjWLViRUu/zB0J5boAY0wR/PcQeNSoRcq34kFpUlcLLtTq6+1rTBpZywWf +Nas/2N7/8mbveYicBBABAgAGBQJW6YpOAAoJEGDwWfWNnK2rSaUD/jmc8iiV0QyXriYIbZE7 +IjVOPky9U7jqtthwrdAZUU2YPrUWcUDkD1yRIHtDJkWgw4RnMtifteC5pAXjXPtuceIFTVPa +rBa+X0SomQssG8mhwzyuvVajzGbNyaBCYv3W1nQz25nWbsYWcx8otIYXDFzjUgtc/FNgQZup +i4bbLQWziJwEEAECAAYFAlbpilwACgkQlcQqk2qXpqt9LQP+KEzA0EbsGlmzEPcQ6n+M/jJs +xjEblNbQqbfCpp+13BmWnJap9pBD2JzRgsYyqzbzMxHJ5yEBiVH5V5loZ9mqk+0arEu7txuZ +47MrxjGD0+T3LaZV5qDmJdI7dsdYyPL7On6MW4vOATeboBe85F9pPbDImn0QqajidnpXZh+q +NByInAQQAQIABgUCVumKZgAKCRDI4+JN8rgmMX0oA/4vzx4lURrzb5eIHnCxSMP/2syvBQK+ +EjxFUWG9RenjJ2aBRX7pXP/jC6sFigDrFqbi7qlY/Qu4QYatOsZ/OteONmVaCMhSjUz4DJWN +tWs1lA/qsFbNLSBapWbASJLso3ZnL8bcTD+q+eqfrrU9JPpCiOnWoABBBJZ6ifer8/LSKoic +BBABAgAGBQJW6YpvAAoJEHDdKljL6Mh8VpAEALLRAJKejNzRaZGR4ycyMKEBwOa1KzwZmE1h +1Dlih/itLgN4DUTH/J/7dXDRJpb9VhLXFYMCf/RfwAd8gry+x9m3pKvVFCFVC2gkM1JmR1vF +Fyk2cBXqSALlI9ACUR8V1FFJD2aW4jR8Bxg7Ng55ZSf0OI+vxAJCE7xvfMByWpxKiJwEEAEC +AAYFAlbpingACgkQU9dZNxEfLvefaAP/QZY16hkxFdbGfw8VNzPrmYaGAm1+UaFM07Yfuch/ +HLHe/WVqduEJzr2ZeKttsqVDMxsOJn/9Za9TU5iDZxwne10hKQSrPf8wP/1F3XRYJVdh59kX +0qgrCTho/1zcpzZq70d2Eg40p265Bivotg5T1wq1Y6ry0Q3mXvwraCqR8CiInAQQAQIABgUC +VumKggAKCRB+HgDc5M+8OOSFA/4lJgdZBnMAvfnBtb25GwSsdu5u+/jUi3Eo2xR2F8kbHdkN +E/HgVwAwHDpL7aURLeSi1PB6oRr6HNtdhUcceRRN8HUsebQxUG0dW272MMhSCVOR45kGtQip +2dkKb+akZaatCEl0inJyxkVIWhDwE41Xsm33NXbB4SHYv/SikOTtiIicBBABAgAGBQJW6YqL +AAoJELh8bx7zTaKyQyAD/10y0dlHZ5tix2dGwCcRy2Hw26ECQo+x2+Nm9ZQsadYi6nNCGMU6 +Sluw9GC43UpJx7tADMfdZoyc+L5rOYqnSfhNWgqjsQuQq1erjInbjWP1JQzsnIfWZZvqk01f +HwgRJHG6kdbMf+L70Yx0x5CpmbR6+fj9hwhjgg+hV/H5Qe45iJwEEAECAAYFAlbpipUACgkQ +d3EnWNcjkmkhOgP/TcaAA7YrhbtYJphNi2Om14PLFrOAmT8+nxoC4dqs2JBSCzGTDHV9mZR3 +vzqKt9GHR5C+O7V2XoBBxDWrp3ZayUoDxRNbt3jsU7gFma5IzK3Iad8iWWykHp7gogqt5kpZ +89TatbEOHtmPVmdnJlT4798RKRPdSgR5qLGsjS2zy6+InAQQAQIABgUCVumKngAKCRBYAdr+ +95LLdY26A/9wKkQdgZNsdO5WKVZgwvsxohdh4HUSfBGqCzIuAAVMgdSTeDaLzA4UpXiCxxtr +rxJpTKm5jabHi/p9Pa3dta1hoAqpzLY+Jek0OaRezxu59g50fTcgviCMD0pyJRjUOmy4wYnF +XgbRHleDgVjC4P56M7IYfNuKUbAPht4tHNQWzoicBBABAgAGBQJW6YqoAAoJEAnAL2746tSl +E+oEAIQopJcziMYvgxRwVTA/EZ9C0aSSNOcO2l2Hc8ClbdzpCxJqn3HU9cvFh6vbgxPrL+cY +GuhoCtU4JzzsEYTPqncmlnvlufC6HGnr/uje2S7FEzfbYHwLHXuODz5AHEnAriToyhyA3NK+ +7fytNGYLuT2loWHfcPTNPgGHp28LpsW2iJwEEAECAAYFAlbpirEACgkQTTOAcQAmKT6bTgP/ +XuP5DQBtaJBmH5icOqPLTdbRKQceJh+0t5Zb+fW0+6DGmiMEzGmLosGzNvDzA4QELgp7ARU+ +M8EL4KbewrOL+2LOmDG87iZ8X8z9bA2eVCL3JC2yc8kx0quboAQTI5AhS7P6MhsHCELfsrae +R1Rv6hpFjOgr4WHwEWKyVHqq7jiInAQQAQIABgUCVumKugAKCRDtl7IU2xTFZVE4A/4q0adi +R22chcRjlCcCXZ0UMENgCaelhXhfbSUfyRT6c9MHtD4dCgLwB4t4tUsbGuM8BXpxA/9zV561 +N9AUUfFNwOdLzYDYAdpQM3EiKd5wileQ77NaXTnxRKga8j43/GdYukmaVPXaN+ktGlGQzcA0 +Tf/8eSVsljAXpP0GnTKjAIicBBABAgAGBQJW6YrEAAoJED/Sn6b/9qwx3FIEAJKrXveUHOIo +pE398Xkh/8DpcU0QJ3HDc3IHFpeQXQnxlga395ile0dPEKubNkcqsNzWRu3GpWKSvuiXcIVx +g407Lzwto2xmTM5+uaeBnQMScNbhbx66dayYFoIym1qPKEGx/hYGikXa2ilYRSANCpsd8TrC +QuWyIzPLCvX37mUdiJwEEAECAAYFAlbpis0ACgkQvcPDrYZms+9K/AP/faWVcIT8W8FArjk2 +mn/pwk8lBx3n3H3JSUl+AUZbuoF1+NSHLVRAo0xtXiU2kPSCavlWZ/yBdVJ2KtjJigqWplgS +3bkXImeYIVuuvII0FuqK+7ZgTmPqBlyfRRhwZoO7ciuU1IX8APBul4QtXD31C+0st0udik82 +AwlabNSLiVmInAQQAQIABgUCVumK1wAKCRAkdxeLUUQLPqJkA/0TQmFvEDzRvKVAlM++PbK3 +pTJzA6Hh8TkZf7MnzLkjl0ejk4zvmX31GgG+o7Yln94RhBXUMURwn0V4bTIbdFVzDC3NW+ES +rLPzYwTy8j2ULt5ZiozocUPgRZVSnUSneszlPpK0bL4CSjzCVZRhVi+v1QTvX+xdpsuqJF8D +h/NT7IicBBABAgAGBQJW6YrgAAoJENWnVOmfWFoww3kD/1Aaboq1BNbQMTFw+dUcYTRWqho+ +A0HLBYRyqdmoB+VmzR8kS1v36k+vTeHAHvLsQjawE0SeC2TCaYa2JSR+aEYXTWaR6bKk4+gb +g/oWtOfDrb7Y0Ob5HHVRKKQP0Pzl+u2ibqotXKo+KT7TQFHwJRMafB79VdMaSpVc5TJYKKxG +iJwEEAECAAYFAlbpiukACgkQCB+sDV01G8g46QP/c6D3vUTl7I1uXvk4HcLRNmY+G/t6CqjU +dm5UpxzxivEq+Trd49/1kBQGW3WQVO9U+Gn+/BmaUw83EWD4kmMLLllzfQPE4LJb2oTvjZVC +VoSef9hzmZfvDTP5QjzFQEzO0kojChYiJn1bAEhLWLsgB7EKVWaJJqxB0B18M7jLrk6InAQQ +AQIABgUCVumK8wAKCRBODSaDK1z274Z/A/9LNRJD/z8S/L+pWndsxLdwCLo0Y8sfAdo7X4xc +PMFeBhbfQ6sd8LLz9TdklHMCwaW8qBmW1l/8RfL/h2oR9eRX6FIO1v5LaCKd2L8T+9xiZKpq +WaQtISL/oullKG45ipKapnSDqGgCHmt4yFYLAXXfPxHRvqHKrdM+g5MK9NFNk4icBBABAgAG +BQJW6Yr8AAoJELA+/COgOxvjLAUD/itZGOAHgso0+gO/J09vJ5p2YvLEH64J2Goh9Rw9P05A +MYprMyoHdvQj75CK7IPyB283B6zi50U3yaJT0FLtwc/wlT+6DCls0zTuyj6PpmXgEsmv/tSv +TCrL3GpH6+W5MYXKFK0KEy/xUqOblKkJEEoNY1mKoby/48cIKYtw97JIiJwEEAECAAYFAlbp +iwUACgkQZt3N2w6bwC8cSAP/dZvyBMQ1SB5vmKeOjpe3L7xUQ1nsS2+FWpee0vvsYec3LaqS +qvXYWiw2O4jvV3cU54J+bR9hwLQvVs+NWU0vsOscWjLQy7PSoR2+oca7SyMm3DmU2e4qBHSw +BhZMYsRRfqPMSnYlnEdUBLkXyKUrgaes1pf7f5IPAcjS4fwcwh2InAQQAQIABgUCVumLDgAK +CRAKZcu+3GB3KNKbBACqhO47AKUh+jtSBaNnXy7TrxaepfqgxqQjpur4WpsJkM20h+ODWfDw +D8EtqExrV2AbMYUjjPpdZpr4jsYPyEVXuXo0cwKFKSazX7i0WZcxPlv4XJ3nP5/l8FY9gu7w +fkuUP5Xb1Kxh6R98xeDZZNDtEGVt1RxaZLWV9D7XIhMjH4icBBABAgAGBQJW6YsXAAoJEND/ +Rgq51LBXg7cD/2KL6o2qzR/rqZ8tsTZJ0x+mdjwECtfupGG7lfEogRPc/Sy8qzP2DtuwTQaB +ZSe0ONMItlZ5TK9zb3h58zyjDvPdyCiFTYfd8teTTp1D7FEmAV+B4pEZKDsWjQNqPnWpCpnH +CycKBdPqj3e0akkW9pO1DJaQkMnGgeCS6x7ZOZttiJwEEAECAAYFAlbpiyAACgkQ8TCPKajG +0DE6uwP/TbC7XbuSEVmq5w1X9PO+lx7kSIvGkP3DithG5amvPV8I06tOW/gHcSUxim4X/gC7 +JioCImuUPAYeqwWj3I3XwHweVPDys7r70a+LoL4+8/dTVS8JWcRvVqY4aHLZT14dN7kHwY5D +k+D6V+KdJhH7+E2qVB/zJmz+jezr8rFFGqWInAQQAQIABgUCVumLKgAKCRBy420OLTpRa1kH +A/4g8jtQQ+nsnrKFU+twf4jkC2+VuA/wTCVEKIEaatbngy2IFqaFnJL+Odisj87pcz13s5fe +0FnSMjNg8QRlsIXT7OM5G59mK8KN9fVyHpERooZ8+eV76Vdw1cYk58qZSbluOlmskkHrpjlY +YAkzVdlvEDeF7ijAl9WXZ1NC1qC8YIicBBABAgAGBQJW6YszAAoJEKklEZ6xWy0d7+0EALP/ +DgnAgmUlex7lSYN/CfCAJJzQmRgmSNODK35oSWUezpZEFGXcMQLtZiatAtwEX3uhh0BqE1hZ ++h/Zzbpn3lnCdhZYSWr/DVtL/HVu/KaQ/Vl48+P/kKnbMUr90VR+O5MxZvkx11wVGmy+BR1v +LiKB4/tI2HWRLLkQ+ZHvjK7FiJwEEAECAAYFAlbpizwACgkQ2gcMejGFqUKzcQP/UDVMJSzY +y0QcFBS+1IS1xsageL3OJynjGAkrc9yYSsfaSa6FRvx8HWNK64tbrqGu6JeQTY/dP4UgwDeM +TO4TGWu35rsT29PsEqKckBqyq8r4AuBu7OuT0TJ248KdDzC425YIjru2TJTsL6D9xCNun7Bn +1keul/uzpmnrvQRfPHWInAQQAQIABgUCVumLRgAKCRAjgV5ImRwOTlPfA/4wPbzrqHCoETmo +NGcZTVltdt9ghshLcQEcw+Bp8Fk3sxMKxsVqPXJK/cG4i8ykq78Z38CzGesDaeDtxasMjdDh +SZyiFq51i/gxL+80Qgr81aFEEsJNHNp9N2RobK384l/KZGQaZz7Nq82KNlOpWfyksLDJhP/c +kEbmzRntludluoicBBABAgAGBQJW6YtPAAoJEIBtT9uN7egSmrYEALI7Ac/ZPnDqVZMMJG/6 +V4VSOo2xpC2PVuL+ZNRHWqB4Fs+B+HoRgSpXaz3zGqv8lCQQ7cXewmd36gaFEl9eyyL/rLPU +ng+L7GLv+anmlStSua334GMMpGJ+G67OvVW9tax0ENcEp5AosFrV7xBdSREUtD88QueqDQvJ +Gjm5xchaiJwEEAECAAYFAlbpi1gACgkQ660xnOWxSna7twQAq5n8hA4XNdUT14jtJuog2h/J +azcKd0I3N/dgvPWtcGRh5FGA9W49zA/tfp/zy4dY13IuJNXy82zX/YeLdJtNOkQxyj7AdBCS ++VrNUmLOeSwJL6s9O0rDDpvF1WmTYZQ7jhKOqZLVYgD9eM9CeMIoE3P2popf3FLiHoWA5sPA +RxuInAQQAQIABgUCVumLYgAKCRC2dfqIMgRcNF1SA/9UWkx5IrrkrSLyrZLffyqbUA4VoWhR +QMSAb0nvedmt+m+ka98DM8TeSrLRBQpNnZovkGGDpOT2PNoDoGva3lttwGJiz6+QrP9wi1Sq +syIPQLUd+76N3ZVULp9K6X/A0Lk6zn9VrKEgdbIMCr7+Dnk/o24SyZMDKBt04c3SQvup74ic +BBABAgAGBQJW6YtrAAoJEIWzHW6i+I3/I1kD/16Fv8rK4m3C55ciU4F8Zr4gdmCI2GEz6Rm0 +hvtx/qSh95LJ8v2L/PjS87C5p/xGx93dOw/Oawrri/M1ci+ln23bOAMpNIn34kTd8TUdSOI2 +xiDG0kvZNpElr3BFX50L0wxAWEqjCCJ43Rux27zxQlENF0NVagWQyMJ1veMkqiVJiJwEEAEC +AAYFAlbpi3QACgkQy+uWGbWIATNPVgQApyOues+rZrEUyLTsaOeDRnJ9eNDnn7yxHJo98Gsc +k2SmMDekD8P+ylAm8L9CdJI53TaXdC4DjFVyJfv6HfmADH02+mYCJj5iU+X6hVnVkykA3s98 +s5FLS8lQKlFJ7JeAGqTVzfo8w8U4+1L0PsMzV21nETVq/FS9JQ+9ph8Qam+InAQQAQIABgUC +VumLfgAKCRAvwWTeNqoCuVHdA/0ZZQpk1GF4mpUr/80QjBvQWZq++kxW3UTZBsJ6CxaH5lOY +/595WjN2a8HLfawt3QCrUje0vhl/Poa5f+2vRLHX8SH8U3EyXAVAwkVDxfO6H1BDzPiRsrDN +egUY1Hv/th0miaGf6AbusX7h5eFbWZBXa45QhmgUm7nc/wF1hgLyEYicBBABAgAGBQJW6YuH +AAoJEMUF/ox317bHRL8D/0MjNRK0EILcK4B9mGewE9Z2DpmlUBpQs6/XaW0fzof+MFUCMYsL +ZYsWfGAuUTgQvs5Sz9dr0fUBGOpI/uLVBiTBTjgEZNHy1k8VAXAs0OhJyyPI6DGavYC5pWhG +rLb7D5R9MYwPRW++KbYbNDDziQvvJ7qSSUGw12dClEUmUbWEiJwEEAECAAYFAlbpi5EACgkQ +6/hqKp1Zh+nc6wP/bJ13D0MpBZ1jpLbgA/VBhnliK2Y1vtCzzG7YtPzP1BlTyUBuOxfqWqUe +5QsJSQ8keLWdwJeyr1seTTMXmHizLg0NHrIP8eOiaMXCQQb7YnEM7WPsnheHEGSkgPU4QXDt +hx/HwO5aWRkUZWykqr8kOLFMCpNpVYtWS5e7dAeaHEaInAQQAQIABgUCVumLmgAKCRA9KQgS +Za52OePSA/9m2GgThctXfDLxUO0wLuaGeifvlgULCpcsO2kbzEnj8qgDnp5ElQnp/adUxmAG +Il1Cu7DEU9E6ioOnpRhLrFpd8QKFuK/nRvl5+qOIkQDshEKQ1pjRKf1udhXwS0quR6JQ+RPH +rbmJjVs6U4VjbBwE8A8Kx2c4vF/W6ole2XnaMoicBBABAgAGBQJW6YukAAoJELL80I0PrLei +9ykD/0gFPPGveIDhFhilx7FgRqNTk41SQfPvBMzPeraXSHdSVFc28SwW2ik7t0FWQwOY7Lly +k0pVHrQL5RN1N1bnszo80ww+bEo6KCE+7c8SZdGz5Qe8/MVkD8GJX4FCqkCrjUCF0AHcO3+a +DzAkhAMhpBD1ML3RpgiusuAb3z2FidPniJwEEAECAAYFAlbpi60ACgkQH2ml3/jMp4f89AP/ +epBfdDVZ2tAqmxCMB/zl8Wp3Q7UOUQyd151EadQ4QfP72Wx2Yludv9EljVAPhGtUTA6476Ad +M3aErpCGBGy5D3r2vWVuX7nqUVcE2ClMQ+30e+aijiWXVLSaJKKOBQK+C6RdxVNvpDCnvX8W +ZVuHSP7jME6og5JGdL8Ku4XJkomInAQQAQIABgUCVumLtgAKCRDL73y5qG6DOpyxBADjYOET +qnzBSNHvrGZUCUEQuF5RTdJxKKSZaIT7VCFYWUXZ6o13iC0t2Ehlz6KsCa69EDVrS9h1BDbI +LzWT+GHcgWvAVsc261fO+owXQSs4YnPig5GZ6sMNXvQOeawYtPgKmq34AzXA4XaOl6ekkFhN +WLNMUPX21S1NFo7nW47ZUIicBBABAgAGBQJW6YvAAAoJEMkkITuwp+gy29ED/1VZyiYVmCw5 +7WXoElFD8w6Haj3l7h/F9PGn0Zd0rq3wnkQavadcpnof8ErU5Gn0xuW4s0ldVICzjYj3IFq7 +8GUOHMxwdTJDTljC/SzYPiSuoJWdkDvEbbd48DARWPqAN9wXVKPJNrOCVIJ35AAgk11uNaKG +wBJYujiWEoJGGXmHiJwEEAECAAYFAlbpi8oACgkQt9aMQckT1pKRLQQAxqLmgWRSApT3KPk4 +K8CtPnoKBl4gzJOz1ktjjMMDUbKmqrK3b0V6dIVX+tOpRBX5NQBsjOxCLaWdRNuir4UyvAyW +/MZZSwhK6NnUZxqkOPEpLTqFJEDzU7XfHhA8SmJlgDdj3nzjLwYZ51nzGg9j0eeNrGP2+wHj +TL8YEl6mjPOInAQQAQIABgUCVumL0wAKCRCUM0On086R8XW9A/0RbV8hHeBHv+zaJXZpctku +axr6C8RxeO1vxBV6rf1uvpGUVIFYdbIfuFviId2tHDByWIUrKggciXdH/JVO+UZVYpG2eXFa +rU2fzLOyRILGRHZlY4VcTNUNJP37SLlZ/vU+aEzVz4r9Y1tOx0dYll0g5glSNZgIgiRfstaL +KmwgDYicBBABAgAGBQJW6YvdAAoJEEZzjToFF4BohuAD/jZ3t0l7A5HkEtAzr/q3n2ZV2U3T +qNgTVo6Ew+CEaCSl8YS0fazU+ewrU7iqjRfyhiYsvN6L5dRLFAQFU2+6B9ei3kn19KqGskrb +f+3x4Sx10xasSyzannq6IkicXz/v785Tbd+n8E5sSE+UI+AfRJbdRpeJ297kvNatCRl5/SOm +iJwEEAECAAYFAlbpi+YACgkQoDi0juqL4+KPZgP/RW3TnVKnyzQ7uogYp8upmjb3KggcMSU8 +4mZy7DIyEhrEU8rBOleUC8Kx1gcg//KKgJ4BI/pSjbZsb77tQeU6wumR7FWP3Ti87M5LqGfa +KQIu4v4nxGgvIH9c/VYQHPTRt8Q0R1/S2n8f0UTxtz0kFUtU03tfM62d2xCA98PBg16InAQQ +AQIABgUCVumL8AAKCRBsB3RJlQehwwEfBAC59Jn8V4YZFA2Lus0Uqr0Wk6CN8fKKMY3gnZtP +mv2ixK7mgFJfVfLIZTMrb1Z8L+JmEiiewQK9YTqifdPzeC2tqjtftqLtORmx3x0IPbJ5JnQB +TVM7We5opSJz8KuPIJ4Jukf7FD/zbgi6nSHIOpEA472L2CPlVWH0OwR/dKEWRIicBBABAgAG +BQJW6Yv5AAoJEFhtFFWi0sjFZ6gD/i6Z9IRyomfUB6JuYCqNwGWlArmsD2Bupo3+idOIZGak +vo9s3rsK+h1x41GUSPo1xR9MTWniazmQs0PIto2yp9wV2uLenpF8TQHf47Y1I3NO5cwsiebI +ttJ6zMNtelDckMcxOtsisybiysott5LE0JDGCPedaJ2a6Dm/uM6kZ/Y/iJwEEAECAAYFAlbp +jAMACgkQgWyjEx9VKivrnAP/SRdjsIQ384MGzuRS+pYf3Is3A8FoMFCpnX89H+aIxy9Rzco2 +blHcUNydmNMCHl+GThziKv/gPlX/NntOVGYVuTUUj9jLz3X2fPYU16aU3QGPlax0ZB9OMree +zPG8BIbF0Eku8J2Nt1ZpaaszsIvC9/Doa4TNWboAyuMFQK9aUXOInAQQAQIABgUCVumMDQAK +CRD5JUoslK6JAY7gA/9muGfu+1sfL+avaGHeCXj6/qsfdOUQ1otgClYvn2oqXbgIJJv8a0LP +S3Tu7DAx758O3CcrCcyVoMyO4827NrlQRVf0IH6Rq3q72qxOSwjXQNUIkMRNTcuTWJcXuXQu +xs00Cxri57J2yse3YH40ByI3fKe+LLqmT5GIww4Wl1Oy3IicBBABAgAGBQJW6YwWAAoJEGPN +4gOLlOfjjesEAIIb7mRBE6FxZgrue5luHPKVcBDhdiD1DxrGUldfnTVj1v1tzL2kOgbwhiCC +zqo6tBBKKvdMVZa5Rfsl5m9pT4xnOVW0qqZlRjm7hZim+zQEgaBSc543RdBS39KxdpyAiOaI +AaA3eisFYcWivv6HevQbNFvm1UFfs7nutp/qmSdKiJwEEAECAAYFAlbpjCAACgkQQuafi/4G +OuZthAP/TMtzEYBslo+re4nuOkI1GqpPjw1arcgadz2lRvFtejyx+PWwr+fxZSLcxEkodOFb +/xmOYQiRY4GHk1uN+QF8a/8wIzkgr/hovw013X8B9hEU1/7wQmWxO3qCIezn59EOobKwdMOM +KdbP3jzreuzvJaOp1PE9IAPjdYxBoO4zUoaInAQQAQIABgUCVumMKQAKCRCh0CsbKvpi5Q5O +A/97mVQJCMceqG7t8LlixhxvQVxWaQFHmpNqCS2bvCfdAPG8F1XEK2DERd8uKAEAC0+Sks8I +balQ06lRYA/NF2aEFLCc6ztKEaKkiedw6kwH2q91PbLYT+g+S7QRp+2Q1+T4F/Qyj33M190k +WNH2x+5C7+h/SKTq1oOd5x5VoNNCmIicBBABAgAGBQJW6YxTAAoJEJy7SPeklZL1RcgD/j5O +1Jdh+ifVIoP0TZPjXgAqtookzj7v1iVtGrXzEhnlGF1ekUDvnu1+jOhJQbTiTpkONqdluTd1 +e98c8nSfRXZ9BiwurfmgZNDE3Nx51RYE+fJCIDQJw0BxTx+sTfwd1jnob1lrsE5au4zOr8Y6 +6TMdueQZFNqNJEJDYoLBiftQiJwEEAECAAYFAlbpjFwACgkQIhluML+63pxvfAP+JsIX6Ufj +ppD9Q3CnltQl8CJ0bWKKMoE4IIkeQMVgBqjj2PYiV+QIsHVTJaZpCSGN/TFilKmazwD3sYyB +jPD6fJ3wwGjPhDmfTBMKQsr+aDzzf0Rff7BT6fJPxGi9wNrLpJC/NJBAT3rOQT8Egzp4lWh9 +bupbufxnv/KWCVwPi9KInAQQAQIABgUCVumMZgAKCRBXowuE2u9GHjpcA/4nO3Cmo3ZF98ty +Jl/seS+AxAjHZOpgcnYNh+3vXjtyKt9wFHOJ/xaJxL8obzb+9hzJXVBYkryoFnfmzBRDuTRB +s2VV4trEmEdGsgIRKl+dbDY1VCvf//+WavKwF867e4VpWQ51ZtvwCOAzYBKkqY7DU1TT8RCi +UNi7OmYFJ7MqHIicBBABAgAGBQJW6YxwAAoJEGJd9Vgbl/LkX2wD+wSiB0BybYlOKdQCYC7U +UqbVyCeFZtij2pD4ZlPnoazsyqxWkSW5SGbttd/2Ro25BRq9SmRynTYSyuupQFsbv4Ra533n +ZguBStA1E8wicsK/QWUGFTWDWh/IToprhLsyJF2B60eaCDICOrkZhvVm04h9PZ0SQfC3VANo +1z6lSycRiJwEEAECAAYFAlbpjHoACgkQZmFDYapMABMXeQQAhEqaPldbEhsOg4+CeIzWX38v +5iGd9LaKKaIQ4LG43YYsXeLD5ILVDI1EJvJElLL4yH1sDhvuAD1ZoNbWqKlC+T3RVJ8bSGMQ +l2bTU8pjVapYcicNa7FK4VqyTCkYpgXxN1riGd0F4LvYz2LBETXpQK+vzifQAkvJb99zmX63 +C9SInAQQAQIABgUCVumMhAAKCRCWycVj6vtdsJsIBACE5UDa/lA2nYzdYPDzEpb6Ob4NWohi +xt+fuJpjLWS/eiTLjRID2iQtxGrObeJdgDDzCQmT5CW0KzHad9aKAPKBRfw3tJdobiU4e7+U ++gfXQTW4U4PG2LPO9ZDixiGLTn+gzFKf83qTrYwzcgeSLyu8pwJp4LJlytvS7fBtHgfbbIic +BBABAgAGBQJW6YyOAAoJEIQ5BUA+9I2I3VMD/RvP503mSljBHIaiOFiEXdNJHbSJM47moRk/ +AZJ8R9KJBCAItnpEIpsIe9DqCMEXtuTV8sKyv9NRtOLlUCOI/szY8dt9dY+WUlLImrwnM3qD +9PuunlAgJb2pklOdBd/kXe9/OEj6TXvKTy+QJiOqBWJWRPEENeKdfZB585N6HMlFiJwEEAEC +AAYFAlbpjJgACgkQA+7cs79RWLpYUAP/a8qaHDItLZsahFzTFyU+dqvq3nQ79CpLn14zDt2l +XmGYkzYo4/GcbWCUFqerTRH09tNjSQD4dDd8mx8sUV2Hr2eYjK2wsEhTHvzDLN5Gb7Efg2WA +2DCykDYa0YP0WVW7dGe+T8XYffHCKFcc3E6aRZtApq/3coDWCYit7JG4mWqInAQQAQIABgUC +VumMogAKCRDCg5jbpF0CbN7rA/4ijvOgZS1Ega0v1s4vk+M40jV2kp8vj8SE4AbaJhnBqPXE +bf/FB3UsKC7sIYhE0VEjTtiEhq6hFGaWUkl3uc8FaaWkN2p8mgYlF31VZ0vFrJLnrzGnTnw4 +daQoatYxAC5NdW5BOrPgLQz5/K2564Ky9AhpZtCxNmy28jaC72IutoicBBABAgAGBQJW6Yyr +AAoJEHLu5r8rtHhRddkEAKoRiGQwm9D8hOvV6NIDOtsGw32ukxyTt+DxFeveVex8qu72Fe9B +3G7OurQxHRZMM9yn0VTaXt9XGOqTv6Sc4Yr8toN1q/qn7lqyshySbpA+2s2DS+JYe/BA/aqi +Qljoo0SR3JtLXJlKdUJ2v/WTo65944yR4a0L35GgEK2NaWg5iJwEEAECAAYFAlbpjLUACgkQ +IY3JyM3xhxalQQP/QqgVVBtPDRc9d8yMiNUZNRhNcUmBljDugVG4xjKF6FjMQFOxaeptlkKk +wJNFo4FOcHjDa2YDUPzZn5Tn+XV/GHU3Aicv19PSlXrCZgshP5OyXNogeQjpuR0Elp7e3oMl +upcMvRHDik1EO7l9Mva4W75gaBemZ4is8lV3GVocE1KInAQQAQIABgUCVumMvwAKCRCZTzCr +rWOh1HZ2A/9J7ty0vElnXE6M7u1RxmATNTYRWBorCe+pbGh/pq8fB9zvTZqK+3XTgEpG2UEx +l86JRYRDIBNkXNjdo0sJIFc9UrJ/Y1aWa4dlcgEp+uyJaSzC8/mfaErwxTUYQBMewREP2VYd +vvEhhKFoOdHxUjr8xfOggGgdDFgWBwTnk6+lHIicBBABAgAGBQJW6YzIAAoJELW/yv72ngI2 +hh0D/0/UMh0TCi1H33dJtPeyOCFwJs82abxjPQwm1sU+IxrZyXshkwgEALo/YndDnL0mpQCM +Kajmd0tkO46Y+bKkapWKd4naZNEdpnGjwmxXZghEzgoNRiujyhcPQpD0enZ8ysaaCpVC4xWx +tA4LMqlccOGaBWLba8UL0U+OlKFEabDEiJwEEAECAAYFAlbpjNIACgkQ7fzaqWVs5Xr7BwP9 +GH5hgeOG6A8VwoQj8oJyxRXeBVsEjuCsLMB5/SdDJLfb96CLc5g0wO5mtoPlyYKQG3d+mGF3 +oTp9aoCckFFboGmNc6bBbS6cMokmAjmCLe5XD72rTiWQVb76h053IhajPs2GuwnHR2npmqze +TLwSdWj8XRnotPHT+KbX3LnlmzaInAQQAQIABgUCVumM3AAKCRBYQubvbqWpsKqXBACtxT41 +55lU+hLl0uDcYrK+dTYafCvMxfEfaN3dXsckVgrH7JNj/ZJHue3qe7aXlyDf/uXNQZjV04PR +vpY554DX6o6+uE9eZPOLjJOaq4cSW5g0cxUDXhsWZHNUNkVf1z0HDfpUc2l5Z2t+O0FL0fxk +3Egyi5JbyOrjlPre1aIQA4icBBABAgAGBQJW6YzmAAoJEIZd3JaJCC0wE+MD/j8AmSAit4N8 +UiDNnNOFP9ia/GQ2KyjAzNjEWw9Jd8R5fhgVNaQEhJvHZX79gn2AugPLDu5HAdjFRblQ0zzb +W3wHjZWgQgng7bds/73ymQE6yQ4NsOVrmofAyKoyWfG5EHrWh7pW53TAcvshWSct9bicRGZH +uMReKlAIfcpGAqc7iJwEEAECAAYFAlbpjPAACgkQ+E8T4Hsj75gqFgQAjA+DZlD1atLu1hHZ +C2OZIihJp05wFfplv8ioxmeR9UnFdwlU51wfT3NwDxAv9M76wk+ybHO15cDZ/rS/tfFqkUSf +0iVrltPhCqMX/aRIkXXKlDdt9SMOYDGTM5XvXyO5x+HtzNKHh03bcvRqhJ1fhgVkxtn46eft +BU0Wou+p+eOInAQQAQIABgUCVumM+gAKCRAzsrV4JE7Czl5IA/9SjAjSrCgOfc/VWG1ooVUx +EUYvsRzCW0qmc9xhkb2Z8Vt4XGjddgY6c+4d1BB+PDeEpyZ3hWnwi+2OkVHe/QNtRqbXbcy8 +iQfnho3o192SZC4g1u6aJKFp2rAdoN1dDrvfXUQov20N8LlU9H+3dXAqu0EFsYT6rPYI7CVW +9GX4LYicBBABAgAGBQJW6Y0EAAoJEMviTEbMTOvkoucD/162Q0ef5jU4VP2OH0QJQi8NDPLH +hmvmlEeOMFgB9jzXYTXBVrwrioKa05/55aRYZtS/Xx64GEFnyJOkvwcM6q2116JicbsQPbcq ++wlWwOGSJhgmot+vZliCWpMw9z+YO1Nrd9rtBc21jfTb06ppsuPmvS/WrMh4c6+IpIc2y3CD +iJwEEAECAAYFAlbpjQ4ACgkQ6TLOS673fj9WsgQAubkZ7elJOF4zzIvBbVnqfHYmxWT8JsBA +Nz9mxOJrsbSYrVwG4HcNf9RAZHBGCQm00YVXiq4D/kO+7boxmA01NPzZnXaAyAJ9qLTsulp6 +wrsZCOk+2EDxrQ9h1+jG5ILkftsxoSCZOYEZGoRXbWzioSvt7c2kqS7+N95gmdK58ZaInAQQ +AQIABgUCVumNGAAKCRAYVoVOCTuJjaMSA/4x0Szdkjc+muhqjGh3RlogTH/4XxriGGS3DIBN +tz/scnMlxjrrvfVOROP2kmGkc0La5dzphaXspRoCmoCTcoeRVBpkxH6fM0JFBBlfXi1H3Mxg +GgpPN+JVDzKm9OCWEZh1X+1Jw/LaOGSI5XiswBIIkbyXvkBnEhpdaIJnn/JBIIicBBABAgAG +BQJW6Y0hAAoJEAVjdRYfgGZxDkwEALAR4Q0MdhKrYESqxLammbCsLulsI5/GPVpk1MTSyi8D +bLL8ZG7vKdGtZpaY6mjW3ESPoE5Bc+ZSTtRFWxMvI7mBXXIITE2u5O5XplbQfplVXniaPzBw +jMKnlBhfRjZ3wVkjQnwFoyg+mIpBy11BhEsGH3fe0SRjvaGeCD9XQfHRiJwEEAECAAYFAlbp +jS0ACgkQNVnNDXL86TZZHgP/dqGOf7kll7W4rHbvnjFieQrBRNHbDcVDYqQkuZ0nIOH/zyrY +57GAB5VJd7h2j/8iStjk2aW/aPQmcCij/AfWEwUw2uto8PjH98imlosjWKsXM5/P7ICznkjb +P0Awbe8NL3dAau9ua2u9uoL6xye02p23FKggbmrMB68YnIsbGCSInAQQAQIABgUCVu045AAK +CRDRsatsidQNtt3jA/4y+2SQOUymJIsERV7h2tyUa/qJMoZdGKs9piOFFAlPTq0mSsUZDNL5 +q9xfO0dqXr9gu/tD4g5fGOvTaJbBLFFb7zQex+GKN7Q5xvmzyv2rWCE04GXlm2CouPEWPOpi +zWj592MJlEP0jryHRYhh7RCBpf2hNl5WmLGYXKyAzZUJxIicBBABAgAGBQJW7TjnAAoJECM/ +RoaLr147hroD/310Lhav48qZegCxW8pZscFoTjmOoGqgnZInPcw0okCtlksoDyTjg4/1Zb49 +gNZ8vPcs84wNHYZGPD9te0vGOCE0gMgMi6yl1gTBIlKrAiULIfo44cPqo/zkI/OxBrnf250g +FrAXVsU8NezB4yMotaUdEdw8g2XsSbOv2/+QvrEpiJwEEAECAAYFAlbtOOkACgkQ0HLtS5q2 +L9ZFSgP7BvV0tI9CYqILLZGqaJWchmtq8mrjgeBzdFW3SJ0WJ3chYjb42tRHmHwz8LwXpWd1 +SHU+K59ZPXfmbW2qz1ivjLybJ39cKjrXfTzhgKixufPNBVWthzcsbFuw0P75JtoMKdsOE1/X +xGjjfOpDzLVwcVrLX4zHUoI6vhyTbDeWirmInAQQAQIABgUCVu047AAKCRDf5Mx3mNIwovPP +A/0eMpiNnb3TYOx1MKpujN8q/T6ukDbSyUMsgNWmav2JXIcpUQrqx5ZcdvCvZeAEwHrXtv3+ +ReJxoUObDphDDlHrYUSONLYePwsVKrdj4PgxZzO2w+svhSGTA2YCBBa5Qh7aeYZMkGcgoX9s +4GRiv54f2VAbq1YRIOXs5eMMADJs54icBBABAgAGBQJW7TjuAAoJEPGln1pjh8la8O4D/Ruo +ha98CSYrqSXbSy0ADK6sHPmWDYEdx2ePzMHjCxZdFjQkQRDlbJG5hp0OiZATCQ0zVArfJHN+ +j3I97m1YWK1I1OuvNqC9S99i9ie73UjAi/RCpsTeCXVtn5mDnbazrDxOzDN0o+w32aILZClP +5BJqQRwepmT6iCfhzOD0XcQ/iJwEEAECAAYFAlbtOPEACgkQn9zyiU3RWA3aDwP/QkhIm88U +LGjwd3f8y7HO51rErDRRBxb/zXV/f5yFh9CIazrLIIGY1AMiFJ+NijbJjBThkI16ACp9SnGM +iVU3yUNf2Vw4ypJiOpaWkhMR6ij/C8QRfm2CmwkDpQv6gI+qgEbTHU1AQVZIeEMhHP3g/97g +cXNqcLVVtilCAPeHwmCInAQQAQIABgUCVu048wAKCRAL2d7nOZguNr+SA/9FIXOE6PGHay89 +QR2TNHJTIxiCpSluo0kXbstdZjWXQQE+3dhHtDPKHKeo7YZ8prpPj8L3KBLd1EewsxtBqnXv +EdZnC77btTyavVcu0RJK1eVZ+WA5LWhBSGU3fWeeQH75qLVSI4ZYSd+blE6gwySJJWEjhWOU +JQbWvhfdC5yBuoicBBABAgAGBQJW7Tj1AAoJEK2SnS8MF6lAEnYD/jKPQMR9YnST/Bp/I0rm +elOokDUiEEIjJHH2P01/opQAk5Vc57QSbNqjiPUWkSxQNHvWqsoK01qSWCd7CBCtNUqXpzg3 +AerZtZSlWJPKGhVXaVX1GhLJSx5B5h2LUYV99mlvErHKryrKHaLL+d2HAppYe275BD49Y1Hh +Kv2xlHAciJwEEAECAAYFAlbtOPgACgkQO7BBy7UVgbVSjwP/UAOafMkvgiE3cW5/Y1wPGbUP +GpCgcYgID0ZWSFpJPmuTkz8SRCV9p7vLbG36JdyWdFh0zjfjUbuFdqDA8LuRQAS8K3kYOcmi +dS+tD0CMfFMvCot66fWseA9PQIWz4ZdLQ3kG80mROTkn/0xAU1qIO0WryjAzeRhelHE1hlVs +STOInAQQAQIABgUCVu04+gAKCRB66kxscssBpiBNA/949zcCVbzLs0MPupZfTriVy15DstLN +m2P0DYEmhxqO02Fs+V/tobYuy8YrgrGlm+y6rrocXefdZzydx6kflnmenw+CNtkTKDybQ7W0 +LtIolysF5VcMyjs+/PlxgP8EvoUiStAFnCKVDVIXGEnkJd1pd2sPyAgc2a2O/b10MtQGpYic +BBABAgAGBQJW7Tj8AAoJEKFHiUYv4ffoSBQEALDnCFuAppQ4eKMwionwQTirlzCE7o+CtR/r +6G5152ZZ0VLFGJTWTZtKJ1eAnVoZyDurEFXA/pIqKgrXtUC8r9dHzRLmfojlPhcx5HhpomW1 +mYIyWK12p2vKXqQ5FkedLJCYxQRqcErC4i/wNaimUScrEZDELRKi1/LKdc4Qt4HoiJwEEAEC +AAYFAlbtOP4ACgkQy4mUrNK523B9AgQAy18Po9ZbX8gJW76E/HMlLjAtjcUF5RXmlHQxdtjD +uWGpgFaxDevdMvx+f4eBqgzeqzqBswqSXMzZo6QKd9oEAgW3NFllmQUQyEGUsDUWgPQin7Mm +9F6euj90mmgAOpwui5tjfyJP62CKjDpsBaC5ejtGqft/XRU8zyEPaiuOkr6InAQQAQIABgUC +Vu05AAAKCRB6GwN0J84q3zJGA/41simGMprzUour2MynRGpfpBpCOV6Q130rHRH2Bbjt4iWi +kxT98K+UACISnPlznuvUBtq3sVgeYejjSpwWxfcfickorY0L/c60BxTnyLXGfDCDILIf+XZs +Zfs/ItI6C2fLHazfczm9CmZ31K9u26J3qroPuWGBOuD8gxM2S48/ZYicBBABAgAGBQJW7TkC +AAoJEHblG2seocKhmYMD/3/gRn2FlpcMoi+aYupJmonxoJSCENjLCEMNPF/Z6Cg6ijw00+BM +Rbe84ZWay8DqHglRsUXx4CBlZpm7Viq83JQIdP6TMlfFL71xQ/c5HlP6un8JInmkj8Y731Iq +Q2v6FQv70STl/bwTT1keTFoEd2gQmJpXkET6R2G6QqJeClbeiJwEEAECAAYFAlbtOQQACgkQ +MZucJFWS3gTklAQAoG946bWtvAftkccC/4xZgU36hbzyjznqelJRvieyFf1GRo7T2Gdoidnb +mSK1+I8WHlMx+jFCSOXnGEkMN7H1a81cS/dj3w+ZK9FBr+vprP25vyi7A4U0I8bA+ACCc4M2 +b+/9ZKxfdyc/dAGD0rvQDOmXcS5tQBb4xZ0zaO4GWeqInAQQAQIABgUCVu05BwAKCRAStw8H +jtxPcvstA/9Vzq9VwY6Z2QlBAEsZs38WFq5gA2HteNl97Upl7fwre5lYLeWPe0OF6dBqfXC0 +fwzoa+tM8mwUqCiLfBofB14S4m3HCfGaHuxh2l00aMb8USoMs7yauV2jHoG+6/1gDwOveLzy +0mj4LttM6HbcWOSubL95GW6Deip+72Dr6KhqyIicBBABAgAGBQJW7TkKAAoJEHkusHwLAXeF +D7gEAKsSYr7hE7AqVGzExx5nT/zj8pn3zD0ayHHiXfnIdCNTQxgUVNom6npuCVIFg1gU2Tx8 +SBFT9BjLBzIj11VBeCXYbEH6OHWMbm4hkMUuvV0CttfD5uw3zgq+/gJFq9/xhbUTrxO6hmcq +6MUBLWTf7HkmgKIeeTwnngb05/0+KIgDiJwEEAECAAYFAlbtOQwACgkQWi/9MgShxHxNggQA +pC8NRgIjseFkuMyTdcK/O7K98WBVfdRbEkhrr31n1J6jBRfEVp9lvHkCYwYXl4L2+TQic+hh +yQqu2x5//a2KFZq8ynpn9BItx4gsvhsklCmQ3iOAewc9pUn7Hzvsa+C1A0Kx6ifB0YrsY5gV ++0SciTl7mzD+vJQNIovcNBy6nSiInAQQAQIABgUCVu05DwAKCRC4PkYXinwNJ/WmBAC+c51+ +kEB7/LK8QdrNESXXxd7aVvi8sUM3Z4iKPgI0OHPE1+NQY8hijtFHW3C2LtOtMY6yyXmz2IVg +M15dttD4YQnWsJsYH2NxHUuIPoQEen8Gi/E1Ns72lA8RWs+H/EZT3647+//cUmkw5h6l1aQk +wZcmF/n8Sujta/WhrpKbr4icBBABAgAGBQJW7TkRAAoJEJB33aPoDbGVYogEAKhab7iemfNt +akGegav7es8qsxwWc0bBqvDQ7tTOKS1tQb4n4626RHcRyL2Cg8+F3dEZ5BUMpXNnnFHZRPQf +m6Xn9pK3GnR4hQeOgi3HxLP04LJZMzW0WrsFJatZiXFec+W0Q6fHk0/9xwVoRt9/3M0gaIiP +XMra/Kdu94QVc2BfiJwEEAECAAYFAlbtORMACgkQ07dm/9Yq13nBwgP/erfUA9AUB6tGyl+G +NyRiN10ERIEfi/p2mQarKGqIcgA9ekdeHgvye/M1kk2wQra4NE19Sc29ZMfgC0hH0Xl4ULYA +uApJGf5L65m7RnTolBy+p483ysiC+F3CYKCoYP/nqYOyLz52ZmEyISUfBP4DCRUoLg4K3oqp +bFIg6kdQGKaInAQQAQIABgUCVu05FQAKCRCmrKtfuZ8MGs9mBACFkjXEJIOS5ReTBYgJLF0Q +zI11sTzSFGqZ9th9keJh9DM/14AOFoc2zifx2MCXjWOecBGCWB6dQoJiDPICC/h5WcsdGseZ +uULceOYnJlypY4MAOcyP2NCN6Kba90/thL5CLg6BrWkBh8BfD0yPhQ7cRtjHk+mSVhdGLTzA +EJZpBIicBBABAgAGBQJW7TkXAAoJEOJol9ObEeE6ScAEAIXAExxkzf67NF5NfsuEaDseGUVB +HuCpukfP3pWszVK/035mEr/6YZxlLAgOc5k70OTh7cEV8KVCdJFaKMSZq0bLTE1pBag4ew0s +AmLEKuoANv09oxoeL39smgH6nQ0QKHLpS/Fx/tCnKPVqMPA52ATBz6/ZU7VBaG3kAKUEqWT+ +iJwEEAECAAYFAlbtORkACgkQNxCIt+OpBjIZsgQAt37l5y0fAz8Bfex4qAfqFq48s8mzJwBA +AmPUDZ/sMwogVRyG4kYOZekv4+JrH/vymB1mM6DPm+ruORofuDFXpa2rPxV5THjmFN0rKFOB +/BN9laHUDNZq0A+VChMlauj5QdSp6HPNqfnfcSJLFwKKbOTXSfqnkIrNOT1i/fp7x72InAQQ +AQIABgUCVu05GwAKCRDJLlQgahjQH9WeA/9fgMo8IEi+RLcNXw4KcnqCrCg2IoA3BuooHM0/ +o/fnGD/t0IO91Jg/9OLTire1qtG6hiFnA7NHE2p0tuVyAX2nIUKuoSYhubcyoSWQoANYLkvA +OLVAvJK4y8G7bqkdzNc6fkb1I+NfHXvXg5pNW4Q37amkll8YbJNxVef+0Afja4icBBABAgAG +BQJW7TkdAAoJEECOx3LXCuGGu0oD/1Eg9dSknUN57gBqltfyqrl6kOsx3Pnz8FyGs7ijzVCI +qFXwY0kfWNNmBx/FnyQWW3pC4+EXz1Ck16KVJ3raOtwXtyvvA9Gy/MPXkgNo4d2ojwrn8BRP +G8UchNLCH7fDu0pYU2HOvJCY1pnvBw5HNwzZxnOQiW27lDSm6awRNP6ciJwEEAECAAYFAlbt +OSAACgkQ/5Nv3bqjT29+WgP/c025RrTcKDZEwOeix7xLDNzE9v7ZZvH7ukUWm1uhb72Yblqu +iMDMURxUDxSUctYyHF2gKzFEty4+VSJ+BMaY0XF3UMeqf6fawdny22KtLAML/R8v8NL7TTDS +//stHgV+I+7MvyLdRPfwLlC/1TkMwBysi+Gt5xR2w2Wx956J9D2InAQQAQIABgUCVu05IgAK +CRCQG1nczlwGmWjQA/9d27oj/4wwggH37KMX0vKsawr+ijTgUPKxK3opCDWnrgomNBOf1dDJ +BEmrE4ec/5+aYLzdzUZ5EE9uNDBKobhSOVT1OW/AYcYOAWFlVK6AWedxrn22+EdFMsqHkAel +3wTWyHA2rzppgEWjt23sY5chqOjbZAtTL6iCrSpLXANoj4icBBABAgAGBQJW7TkkAAoJEOMq +488pqFRYCEED/3+xaWVpwsr25YJYwRkswOuypycrpveArKTyGbtOobN1pEIHqBGjoi7w79SU +8J1WiLJ6h9NxhJV+l5KIH13PUjw9AdUevc24ZrmSq+Fhazb2+xRmWQt2H107WlQ4+QnXyZWx +8NoSnOn54hJZz9h9q+H09N5wLu/1jqF9mHmdQgLfiJwEEAECAAYFAlbtOSUACgkQEJeyupLM +RozYwwP/ThpoXjLjaj3+FyDdNHeWqcJZBhQntPZ6+Gws2ZaCQXEaGIWiyC+r/d1MjL2nl3g3 +U2jKuhlCGp4d9QbmeeAgkhqUUei4DHj44ngfgtSB0EtFwPAbRDte0F1dU36i5MKV9KIvfk81 +td20cNUXn54axDQoKMiXbQSBYB3DkBV1NziInAQQAQIABgUCVu05JwAKCRCJEOiD+aiKtBWG +A/95TepDdhY25+CH5mQquIZKH1XXuJ8SV+2rq0NvWKJ6XR+aGl2+hZIdBE4+Ny7UJTEnwB7d +G8S8jKvWDzGAWRNHHFSRDIxlKiqwlokEPc9QR2Y/tLSH4apFdg9bnv0Gjd3AbmpW1SQX5+BN +PxD6sHDWz+LDIsQ0gHNTLP3Q08KU44icBBABAgAGBQJW7TkpAAoJEH385h1QpuqTI+wEAIDe +b/QdjvQ7+8S/SBCfU9Z0DMSUZIjUDaHGo+qA3p+LAItodWyjVNExUSHUA5HmDMWpa0bqnyNu +d/Rg278Jvhdi908v7Ul3pf5j5kSzkFLfpT8tBRDHSpyXcJG1kutn1fZm+zUlgikVoKvkKjIE +WzEb+U9TyAdlIM4Q/IZikilOiJwEEAECAAYFAlbtOSsACgkQ9euCiY+E39JWLwP/Tcu1ByIl +cqPNkoaGb+R+MLJuveXF9uI4OF+sQp3+j2XdLcVoUWABGQo1iaBvvm/cOa4Rvl4fXkzAVVyl +6R9+D6zfv6T+46w0K6zdVLb+9EUUH5bhPsEwWortgiOJ+R4Cz7tX4byGI0XoKQcdf0DOZXin +KDGotJTDCi/P74tPxLuInAQQAQIABgUCVu05LQAKCRALgiOEGDdS0fRzA/9NpvUM9hd/w3fZ +Zyp5sqsrJ7DtiyEfnD/G02NLGu+hjvYk7Uoj2AlYF6SKKSiZY/pYQwv81F+Ol3ZS1w/PL+aF +bYoykEFB1otvBABU8FgShuIU5DIyT7H/1nkTIem4/M3v7yRwSilG9WmFyL/mjI+9/0wS6iuv +/qS3zNId4ZLGDoicBBABAgAGBQJW7TkvAAoJEKM8snDHvBRU8tQEALvYWCRR9/iXHyVp9PG0 +TnwWVY9RixQcPumiculUz6BlkvF4eWVJNT0y5oiGV2CWsQRfhYMjqsAgHCbwPBsaK40URWfM +S+4/rvIzu7FGSbsZaMe5uI7ua+aKFfw3kt4Cr8kF9P1NRqpy8gQ9PVnjVRYEzuMYhaTdOxGM +SBorn3BHiJwEEAECAAYFAlbtOTEACgkQlgXZiEIYlQA/uwQAjWknUS1cenza8DD202hPBS0k +HGtUOgD0enHG97USpcLM3lzKF/RDzcJN05iHX0vhsTqkjPRmmFm3pmm5XxZmZ3mI+BH59O3d +l15yMrbMzYJ7ZYlg5X0FqZ1t8OWkdyv7MFhCU8sumwW7yXxffAx5RBFEhQ+17uTYn5QP8gDo +QAuInAQQAQIABgUCVu05MwAKCRA3vQqtOZVKkK9nA/4yC1qofKD2xADZXy8ev5aHQtNuf0Dg +otT0r+dtbRf2MZUa+vZUJ66xlnXK2QwelFo6yReMwNXGBGJ+fi+ALpkEHKiyuNomflT6zESq +dVSZrujasSXIMQmHKPFIUqWsXlP4t13DGm3JIad5CzjLgp3C8ImebPyYQhQh+uUNkw8u1Iic +BBABAgAGBQJW7Tk1AAoJEFxycdcLngXnlVEEAIZECLzQ+BFRTwpAJavKfqyB+XausH4hvM5s +7VRFzeDlsClIkBhJWf+6bI6O9z0Q5pA5t778XI36HlkfGTIpYceGIzCeUeGU/Qt7M6Y7F3aD +ddpYiaEmkqM5D2Bup5DC2TmFpfdly78WjqYz4WJ3LaYf0/4ugRyKNVCPmkqO8LzwiJwEEAEC +AAYFAlbtOTcACgkQompNyRd+KBO1zwP/WT13Y6BHmIZGFQz9I+20ag/BX66yefbBJwaSRuav +1YrSO8GwtMfjeHzXNS19pk7z/iJSkPM1YcVmy6xwbJyiMpNGQCOzD0j/n9HwiWrOroHuovht +IODIjrDBgORMP/al8ehicwO6Xxj+PGVoJqJOMGdJ0joX1OmQ0T7jN20f/pGInAQQAQIABgUC +Vu05OQAKCRDV4uoXzn+zfwiGBACxPnf1pVVlSX3yWT0TP75FLycJ/kNkTsL9zFVyuuFE/TMW +UdCbJiYBCDzF0wVbuOToN9huNxphZNxBLepfRsvZCBqtANPry8vtu7bsvv+ES4ePYdu7hCaJ +d7Jv7WKzTcr7T28PiSQhoZGuLQLBP0ycDzQVCXV66QThT+Wg6tVxioicBBABAgAGBQJW7Tk7 +AAoJEMF+YU2f+edsUUID/2sBN1nGvk0l1CeTqfs2ESkARHp+vb+DH3fhURdO0JPqRpQW22sF +1yGUilmgqZ/rJwWe6MWxgZUYjiRR5IKfOohKdYnW5ijG8wkHCEqZZGdMoXTfQ7dUMNLpQI9U +8wRcI0JqR4BoUJ6RWovxJLIz5MTBqF5BqYRK/hCGj0Monr0niJwEEAECAAYFAlbtOT0ACgkQ +JJnV92IHwzjjwwP/Y0v48VwVHZdJC5EF9M2mayTvF2JzpHx7vjW7WSd1RIaMurVmleOeD6LJ +HeBtyS6ge9uo+iFJWVzsncANX3v6poC1uPEBCC+aSlnKNTqGGO5DZPZWCBBm7l7tnp6e8dVc +Ke9CWuZdt7EO9NWbPzH1EAcvKZ1+Ja56dYZr8okjy/uInAQQAQIABgUCVu05PwAKCRBR+pSt +b4ywtwz3BAC4JpRoosFSxVrO0fRDhOUkU8ujSqPPPl+4XRlkdp/U8FEB05bfneZKiskuWAwL +DsHA3y/viTAqdgIM/zjk+m8Q6FLEZeEtZGOIEEHvq+z15FiYYHo8uO6mN8P5+UyYoEy+/jb5 +zri3Nqr9Sn/SUpeTu5Sp//x9hzEImR0/M0KDeYicBBABAgAGBQJW7TlBAAoJEK6a+YGaJ6rp +lFwD/0tFpeO6XCzqGsPsl2bdcdqzErQx2gZ7IYHe0BmnTXJJm1uS7jQnL6B1JkzO0R22OQ0b +Sth10+37tzsBQdlEY7ybNyo6QuPCx8QJxL/6JcPR5GkMLzvLx20bVJfCc1yOLxiqlAc0f+xw +x+KwoqaEmnL4FBvYxB16RWCHEsPvKhT/iJwEEAECAAYFAlbtOUMACgkQ4E0Obx/mNZK2NQP/ +Z0j6E4wkqTyJAFb6+5hAi1PJVqk5mLjNRJ1sOnE7aDVYlxv6mOY/138lp+WJWOurRGJI8fDa +sV1OvLvhCl4d8/JE2DAqsA0L9RVnMDlPsyiLs+CnxJ9Lyd7USdqGyXl8uVasY2HM8/+RXjST +yFjJuSzZoiSvV3r/bhG2ghH18gyInAQQAQIABgUCVu05RQAKCRBlP/LnqZU56Jb9A/kBIsoH +Ak+WkCuNwawlNPCz9qaqV6bNU8MmjauCoLKgCZFaJlx6YrhLOeM8RRUQPw93txBVvc3Ex2P1 +OpDwzerrXATljuLo3hLk3KCm5Nir4cBh7efJOrh0GQ5JmuaCeqU0vfP73rQprcIn2eOF4G/+ +IILVYT0UU+zx48nnB+UBQYicBBABAgAGBQJW7TlHAAoJEBOKF5HbI8kmnQAD/A59ZocqDa30 +BLOO4Ax53kzFCrMfOaY8Q6KxTcYlPBLaLaFVWqBBA2IqLLEwMED81PNXZqoqOUdiS+wJ0qNa +hnJZ9ioMKpwHWvbh8Z8Mp2r1YhgEoSBxtXUir/n7IrX9OxlzNnTKJ/V41W6spdM0ou0SPsKh +RNbDcPERbbDWw6JgiJwEEAECAAYFAlbtOUkACgkQbEZD5ElUQqvbCAQAyLL2vLeKBpkg8gvx +ZuaS3dSg7gedq494Z7iBUPT3quaRLoLiOcmjNdP0XSZletDPeM+AdgCxIAq9tacgQRBre64F +RjHfIZdZ/VzMGq+SMNAhjjf6DyIN03rgQTYUb2WSciVkps1mp6pkLYICTX6Hq9JH/GmCXrvM +VllmM+glLY+InAQQAQIABgUCVu05SwAKCRBRcYRYzI2du4fYA/4siAJu02AHhgqMh37quV1U ++Hw6/lyYJGKw5mEkaWzdHGSO3/5EWNHPOp/vWU3ANeSgSVupl282JTBOKC9lqhx4CjB3dYwJ +JGqqWIB377LfmSVD1LoqA8G5ZZjSKXnEYxlCdWgmw226qOoFfjwXqQvB8Lu8arViTe5/jZu7 +JTu/p4icBBABAgAGBQJW7TlMAAoJEC1hkkVXp6iRi8gEAInWCIeFchXp+mDHMd9/DPe2EY0r +g2PfEY6hZtMQErfxuwI1xOoOf9RjolH2GBlyhh4LhZP3JqfZOIiQ/jg7G4RyS7Su0ynoO0AD +kSd4VuA3qoN5ip9l18eDE5BHHn8JZt+dUj/M/A1EdFVROfxSCNBIUexZt9CiKEThW0CTJuSX +iJwEEAECAAYFAlbtOU4ACgkQ+V9t/+U3t/4XjAP+OLlRq0PSBTtV0s0Y8PfR5uGasAeRBg5l +k3czcqpuzWEUwPlCHXh8pTzY69ucvFrs+Ru7H6aH+Ho+FXWZV8NfZ7cd40P0zI+SB6qnbsQ9 +j0G8uiBrLxThcfvm5BL2yiFfct9H1LX0Uw/ikm8jDhhTqhhmVG0lJEPywbTFdSBx/d+InAQQ +AQIABgUCVu05UAAKCRDyxs4WhCcxcFz5A/wJHCqPdGaOIbWf/f+1FRQ/WHuaotQyEYJ2cI0m ++8awD+esc32Yo4DaMd3ottO3JHfNlqGNOfo6blhshPGn23lgong8mINtDf9lXPKGgOONK7rN +3Hi0gQYGnq3pR3ZWT1Bb9QBMGEeOcNUEg3UkTUb+mu6Azoo1jepciE+LBDOLyYicBBABAgAG +BQJW7TlSAAoJENquKMe2sjS0zwsD/17SzZFZt6WRUDnzz/7lBh4H+RcJ0/HdlNzBlOlaOIuL +O3r/bfCGM96S9oSx/QD5q7V7yhJF2C4bpkZ7HNlUHQeoG4KEqnxGNB9sDkSKzzS90LQHkR5A +ASnxqN6XuLWOUl4GLUip6SmNlT43mQ/X9gDTWj3p/XgMTdem/voU/lYUiJwEEAECAAYFAlbt +OVQACgkQ68JosEcZ16OjWgP/e98RfMySu3/nfxmc5LNnFLGpvXKPy4SM1koI2Ahtlh+yQ58O +6FUJhxDY/Tz9wtqrW6IWzUhvcva1WqISIJHRGo2glZmJKpfuFfxwoSZAENjiYR06zrFLqSoW +qMROxa8MguvVd/mAeXEIAdkXkSldJfkW1DQImO7Fc1vC/O7dxE6InAQQAQIABgUCVu05VgAK +CRAMMT9ylJNIFaboBACliAp6RGrm9BTVgZ2XCy66aeYpucAx+jX9u6QLkmlxnJhxQYfeYiaT +5NgFGlAIhtUN9qWZQskbD/S9Ja1Itfyk7jLsYAyox80bX5dPUi5nbVfJJX/T8g1VxerftXaZ +Qbz8Nvs6ePctJ8gMFmkiWs1tifXTfdEd9Y6SJaUd+eVt2IicBBABAgAGBQJW7TlYAAoJEJUX +L101tTomiOgD/j4y5MgRWtJ9ble1lTn9C7xwlWYzerl3Qasg05lugt5gttUHhYoYqLwLJbjV +z8yh7KlXetiBDSXUUGaXhTNrWUFTWg35S5HG+DbSjV7JqaesNppCfMe/oGBGZLmhtb/Ra+X1 +/st7Uhn97lIHSgt24gm69a6AJ+ooYJIpsJ9GTi0NiJwEEAECAAYFAlbtOVoACgkQ3qyHDVuR +xW3UIwP/YmiQQHQeGuqCwbSW+8HagoHTIvvvRTeHqSw7l3IBkiksO1H5hsOHjK6bjIPeZ3Wc +RKqkVMUGcDIwN2nDtl77Yp0UCeD4xPJqrzxmwV/u3ecBUQGA/KG5U3gjzxMaNN8c42Ia3dIG +RH4KMRlOYfIBGU3GS0xOFjEbMzzb47LYy5aInAQQAQIABgUCVu05XAAKCRDHQeTcy1K8ovPt +BADPaAmEzOaYEDKQzhyMiELljh1dYqeVZxHOQlxVm5DnrJ7uDIe+h5QjHr0gSYJmzjSVElGU +Xg2C/OjbayYYjHM0qnWFteX2HZ4NSS/YwCP4PcebRJ5IecKqoMkqExJ0Z4PYR30KzyjC1Fvt +ANoSflkJWnVlz8yLmzxUhP4POteChYicBBABAgAGBQJW7TleAAoJEKaGBiZzgXtzhbcD/20y +tO0H/3VJ7KQIn0tCczEecyZYMyMhG0S96FvOO4C1QX/adfNXsSa1LmUjjfWD+w5E6nevk6m6 +1XXOhPo/9KkodGe9XXGfxMdgMX3ShWQVCDYFJOqBpFAg9qEzcaS4D6fslPpG2bdlKeRjbQq5 +PLhz75V0Mx7+VO715wW59q4hiJwEEAECAAYFAlbtOWAACgkQ6EvpheIek/OSTAQAg+n9ggta +1ezvpOKZVp9D9Wv7k57pRHQIEzzn8cmTI3S0RL8YJk3QGnxmLbBT1xYDgwDDgVdpcIK6Vt59 +ERUpXT92YGUeTjBe3fIFQ/2G/H9EsSAazBSr+oxohaRZPzWBOwlAGkCIKXUwH5LOluunJla6 +cJq+wbDONbCqtnkiF+eInAQQAQIABgUCVu05YgAKCRBInfgUUsJaIDiNA/489wTez9fRDUer +OmPhxmSPvvaSkI4XEviuDunuthCMQXfhUvsUnhidwansECM9LmzzIKl05ONy53gfMIkrVKqO +BdCDSpM/vRWYtCe2XHJOBbmRFEziV1sbW3Whun4uKkZUj7BEPi9oN8kM4Bom/3iOHpQMGsUo +Y1IMJk8QM9iBFIicBBABAgAGBQJW7TlkAAoJEOyGKAb+kG68qYAD/RLAahS3T8rU/SUS5E3r +K+tgCJVfOu0ySM9LU+e1M1/Ljme/lm/ptKwwAe7NF3/pYYXUdL02kZNBu74JaMbuUBGhNSYy +itujgM1bUL18oge2TdDQm2CWkGZrBTVQ/UbAkwPCN21sQx1Jy6saYqhBXqrPHf7QDU5xtuex +5Jg8qB7MiJwEEAECAAYFAlbtOWYACgkQc776DEt/EDv6wgP/YTVDsgFoI/8cvuQMyyAAY13G +5NrGN2XG55f61qlPl9uglgxWpq8nldpf205GGCNLRa9w2jCwaFWQ1bJli7lWI8Ut7uMNEQ6u +PtY75UxD1oUA1zgbMXqmJeZPomwxVKGwp5Y76TjGgnLakuOjqLr3z43YkeK1UwsYJaZSHdCZ +YMmInAQQAQIABgUCVu05aAAKCRCEI8+lKXvXXNTPBACjXqsyX9YmvJUqbYkHFRzu0cQ+Fpfq +aNtFiIxXQzqxpxYK/5YLmSRXYT1MVrOwbpRLVXcmcsqQHoJAK2aOtU99eAdcgH8rn6RnxtJj +LAhQpFSnIAr2iKaC+FQ2Jj7i7SWduXv92HbjL+WjD6EjilcHVueIorSDI8BLEU9C0Xu1nYic +BBABAgAGBQJW7TlqAAoJENsfpp9rAN4jYIcD/RH/x1JqSN1+uwhPpqHdGZqByEdF3FD9Qz1V +iMflyAl/qFpVFGzplbezu6Xle5x9Qmax/GHI9bJXxzZrcAVDP+TZh11/62VRgqV2jF+dzYGx +5qUe3ODxt/lb8/IscsncblG0mhShymLzP6+h2i0k+uVE/bZP3MqRdEgaSbYKMfYMiJwEEAEC +AAYFAlbtOW0ACgkQ4Uxnt6DSSrBN8wP/b9D9FzFl3lcjJhedDrhFpVOg+Eiz7pj9hlSIPNZH +a9C9bigENiliRxtE5PnboFG5aqNcf6FH63/I40q5H1QJsvyj718xwyzn0/wRrZnfxtNOIZa3 +KTxLpP6HV79laxTrcLUzLG+JNNR+6/jB6xocsKxBfwFtpjBXlTSRH22i/kuInAQQAQIABgUC +Vu05bwAKCRCUHcAZOMnYDvLfBACbUnKnycFh1UBpg8DEBH1U0J/02mZfJEi3S3K48d3KIZhW +Nc4/m/2oToZyX284+1bLbFOlh3Do519WSZlyX38k/ov5uY6Rlr5D93iV+pupYnGTgGK5NA3D +WBK5WGy2ZplaXaF8roF3BpZtvi7TgyFJVON53e6qscGGx2ZBdHe4/4icBBABAgAGBQJW7Tlx +AAoJEAOiW3DkQrz99m0EAKhVuxxMoRaAD7h98GYkvW+OQQ8V7drb6IRtWF5/duB17fOYjATM +KkQS2BJUkD4554HR6woW73+h2kroQTz5cByEyNx+KUBQwB/xX7n3p2s+mBTRzQKgdXgvdEzc +d2zU4vPJlQg2ZAPc2Y3MR4F5MUQmweo0m14OFN6Gwr15sGv9iJwEEAECAAYFAlbtOXMACgkQ +EOj87h38wjRLeQP/YXN32NFLkmGnXc4QCVtukkKcMKhyf/9czxB4zcureXLoZdUEiAr3pE9A +jUsWwacItJbisLQKJm5pQG0c299/apuM8fdkmRyrt5JULJbIEdl6kSHm1om9ghnvVVvedJmk +un05Vu5PJK6wWP7CHyATX0wD1uiE8PgnQL3GN99lZMeInAQQAQIABgUCVu05dQAKCRB+oiEj +9GnjNDK1BAC5JKe1Pp/Jlfim/c6lvdb/UrXqwFimtmhb6RksFEk1YxbF53akUKIoRB9ruTM6 +axmW/OJ8z+WlIdbY21izFCG6M9rScw/uulWv01WA60kD+RTFRthViFZzUinlJYoDoz/0qDid +pOA4A8smxTl5ozXJNNc5v8w8xBZgvCDE8iJPyIicBBABAgAGBQJW7Tl3AAoJEIj70hiwj+Sy +4oEEAJ0ecEj86PLcUj9QLdDBYy9XZRVSIX6WDGufYgBgrfGfti6KNFVYi6sO4XnguInFNdQ5 +jNIZ49sYYqUZBfD1dDiJzYZ2899OBCRxDe8/Fo7nvVyce6nQs7XXBslvHBZCUS3J3wMI6GuF +/YwquDZgrM3zpYR+BWEg6+jqRZppB7ckiJwEEAECAAYFAlbtOXkACgkQu7tGQ7Zy+4NFjQQA +lycxAbSsIc7fpFyfRFheUKpJ5ibtOEbjmZZLGl00lDbqSqQi4Df/aMIsBGizpuyRKzHG3ihX +tLNF3R0eZl0C9uY1hoyGZ/xzENaoB1EclA1/WArvoHs9+l5RviR5GkVLTAgMkuqe6RX48Cw5 +ipUWv10FOe1pkyBMw2vIT5/C93uInAQQAQIABgUCVu05ewAKCRCVFgyA2QOQcVsaA/wM1Ay0 +6LwuHzlY2WOpqyOOw4fJzuIY52tciKHuAbogcoKt7/iv6lrbvW5yPvQauOCylzutkK6uxECt +lZdoohZYVG+/omuJj4OzGdv5ETzkUK/O17pUJAniwN9NM8QYU7YtMkaE+d//761c5Hdyf6Fr +dYUzxiLbhmPj8GTTW72OYIicBBABAgAGBQJW7Tl9AAoJEHnGvdfvHCzZdRkD/RHDiZDFQRZd +5EbGlZBPglUVGmIaz+RF+qsOTyaFzL5gHImbC4lHYIEKRlxZlWiAqsh/e2VGrMrUaXTOAtcv +I8NT0y2JQVgupporBxH2hX1wlocSSaVb4P6efvOaNO1gODgXsOOxv30bTS+UGZsnjh8ErzuO +h+YjJ+CRrRbC97RliJwEEAECAAYFAlbtOYEACgkQLl3fsDhIwn4AcwQAnRvjCLYeXnlvixvh +JBZz/YlBnh6n7pFT5+QJwsl+gFKVdJDgD418YAewBra9OowmlLRLszKGsjrzc5wj+CWoYOsI +5dN1bnA5c9H60dBdzSd5JbsyN8GpLOvKlx+a25G10CAFFcB0b2H3Aw0ieCdUY9fYHA17knZA +qhNUne2zcOyInAQQAQIABgUCVu05gwAKCRDtJ7zrseoRXU/XBACT6NiLhz6Fi16syp8CkoQQ +gajsRiPDyb1VpOGPimyMfClf4fio4zyJNq7aXmwUvxAg8FQNvgq4CznmOaGepSdV06A9xeQT +44gKhOBEzZC/NFCCbovumIe8+7FhrrRjS57r/eDHZxxKGzT913ysMuocZ+kaEKVqkbVoCkJ/ +TkPu4oicBBABAgAGBQJW7TmFAAoJEGeXyhyJCj0voz0EAJeCAJKDYvo0CVkOPYu45o/O780D +HfcuZghNbtP8Y9Rl7vQIXSxZVALfeFgQK4ubrXjpnBu/PWrUZ4spgtrAzOyRfEaXUGXb3zL6 +W698RKSdsLnQG+7VStUzg5xH9bq052qCFYSYepTO5U51WCsQOb+WWE2+yKYeny/PvHj/nJ5Y +iJwEEAECAAYFAlbtOYcACgkQ5WOKuaiKe4ieiAP/U6FBkIyg/se7lWvux4keh707wuepIwDN +ykeT5av9UIejJslrQEAG9orxL5w8e21Q+tPlMXt+GkwNarH6PgLWkHM0g2i6OKFK7aj+EaRb +fgJKzDXwHgWsjwxG2aBUVCnQH4+ULVDrno8Rr2NKawGCuN0xLUIehkbucpmK9rEGC5mInAQQ +AQIABgUCVu05iQAKCRB3IeHZcPS6QdBAA/9VJ1PsSLrp6bBZ/fsT4Vg6uu0Yz9pRrWc5cFQ+ +DCO8/vALFkvHUuN5CMh7we9Tp5H7BbGAkRePIBFZo1TJU+UD4BCMjc6yma2nnfcrvMPNoTfi +DSHVoMyug+Y3Nay5BhLN32pKa0OipTHx17ymzu8yAasfs2nR15dGNCYSvj1MKYicBBABAgAG +BQJW7TmLAAoJECV+TuAuepA2G8kEAKvo0ajznBlCOngQiSKT/3i0ykTa9sUly5dvfcI2PXTF +U77K+7MzoItp7ytjS9hc+/O2iT6ZmjDhAv1w+PRGzL5WuSMbVLdV6uQWIcpJhtEE3BRfWzHW +xcCY7vBzMQZ4QbHtG506pHASNXOPmmty0EWmRxSMPNo0/sdDJ4VkPRhdiJwEEAECAAYFAlbt +OY4ACgkQJWmW6rsLJf7opQP8D59iDB+Bw3hiRiZM/pAzuBOoskvmy33/lnBJjlsn4w8zVwc1 +dhjDvti0GMQDZtwDmBRRxr2aj2n4aw+KReoqykHlTfhr41FuUOcrrzeKFxzlYn5rpzaPrg6+ +3gi+v3T8OqimLnBSyjj9Lcb8xTpLzJFMZXqqmbJAG6Isva4SpCiInAQQAQIABgUCVu05kAAK +CRCMNw8HdxgD4BWkA/wJVrK2lMUvwFDU3g+HfAkYhD+NLLfA3NG3hPXoE5ZxERSowcRpA2WJ +HiU+GjOz1TsQ4K/yPSo6cNNHBoLBFr8RTCg37G2qoVhPecmapFAGDkP1CHDtC4VKBjT/eXub +zrRZDNQ1skeJR5UkvvkeXwXGFJ3zJifodZ9gBvWLwZv844icBBABAgAGBQJW7TmSAAoJEJQz +D0lvdJstqAAD/3QAZNCJ0qnVV33XIoaiDrrTynLAwfBCZHB8Od3r6hxeXt9NMX5mv40QbsxN +xVm3B7ud1Fc322Xx4R9mi0r/RCNILaYMNLEEX5CO346nSln+Y8ePWasCUwr5UKo0ojB2SFO+ +wy4sLklSMu01sChgn9yBogunEvg/G2BrYEjmo7i5iJwEEAECAAYFAlbtOZQACgkQIh56x2VC +nYX+RwP9G4EO6Hm6ZsXin4zRcjLLBUjgvs3GyAs5KRs8cJDiGIPq7AWXyHgY3gzY4s1zs+We +nmfsReul1NJRPuo8YdNm1Vlr63S5nusTavyylSH8H4BWS84ta+kM4jZW2dMK/Z6yojbk0D5Z +DoNNr505Q2Z3Vl7nKDVFm0kRqIuWR7h2nrGInAQQAQIABgUCVu05lgAKCRDBwH9vSTUqJi09 +BACd408timX3yiPTEJD4ZaN4aOuORyqX/Ar+rGf4vO/XEBE98yHOT6m/O6eWJ9YrzZ0NRhDN +lVJ7T86fUw7weCXmHWmej3K+g6Q0rq5hq41rhN2C7T7ooi/7evyboy42Reb/P6X5lOEjkoJ2 +CO99iAeaKfir36yzSfflrqqst8gASIicBBABAgAGBQJW7TmYAAoJEKz6ZZYq5HjfEuoEAJy2 +FIpi31ctrcpNx6xv1JzNK0sZHevr4BdPel3+hqKHDE4kIOLlgKx1CO/UWqT5WuvvIhuCMwCe +G9mNfPPNxKXuHojFP9KoVNXtwkybSPcAKxP2KCO4CUQR84TJEesonVDXFWKhpNHeBZGxsYGW +cAtUAfsQ1LszCoUwcuprJVUqiJwEEAECAAYFAlbtOZoACgkQTCF/TpKOET52nwP/fFKxtBQr +insGuOf7/BmcyD03cRniVV4b0KMiUqXqF21rBKINXFtfb4q6roTTfYdDJ1MH5jv6E9X6B5HQ +xba1CO80SF23rd+gPOR3pdZKhNzD8GMNuCF2kccFM9X2HKFZbJ+iH5GWmU9567VI2IDSEGCy +fsWBWz1nlPwZSZ81F36InAQQAQIABgUCVu05nAAKCRAneBSsG+/5NTWhA/0Tk6csINMVLtK9 +rcGH1jfbSIErX0z2Qyem37/Wd8goo4DuYLMZS2IT4hdN2ugr+WIy5y0YkeoCS/bJwUgX5j22 +NtSHKDc/4MbuSePmH43OBJn3Ec78uRCQEOZAOv1rsPCxeszTWl7GIVnXEcBGKJK4284iH5zK +of6CxgQceZ80SYicBBABAgAGBQJW7TmeAAoJEPvbP/s6n2/r+1ID/iRQSltJJJpVfDXZrh+S +7kIeUoy+YEvmUG3JEJfxe9LhV+PJ6rfCRyiNQJbu402SfWhFGPPEfoaoGqNVTqP3fxQAxhTl +C3ylaolsJaDB3wmP59aeXvj3R6XSTWRUO0yJGy3rIdnZsjjFBPCFz9knuvWQM0V8QoPrmqwM +eIxfIy2viJwEEAECAAYFAlbtOaAACgkQF7B93kkmZIzjRwP6A7L6ORUQC2JVXqOR76YYDWoo +Wg1zOtk9UNERQ6jJ63PvcbvKKXD+kaI8TSWZbpP8OGPDe8ht7zi2nEqpFDEr6UoCod+wRtx7 +75bsbtYWuKqlOzOMCGrRqsWJyeDvQsWuhRZZ5EUWx2q9DE5Kao3HHU9z9dd/SDcDRZc0oXk6 +0CeInAQQAQIABgUCVu05ogAKCRCL3DoPfJHs7UYTA/9D68KCQDPMHflb00YwQnezpOdi4P2X +Iy48pnXICF/8VFc6Sw4fDK7N6qMcvMVhn22lpVCWUdG3P6Nx+YozCRegaiLXEnBvPJTjOTgh +7ECS69g4gSD7b16wS0LgyllNPMdRVopJucaVVYnYh9IT+8roJ0sXSoCQkYktddb9HE6A3Yic +BBABAgAGBQJW7TmkAAoJEJUs4P8sVCtLl/QD/i6G7nWnI853uJleXrtHhP1bCBrcs1x+wPdY +ciLbSC65gL7y6SvcQKLIPwrtV2m5FkjEVizZmQDBVySv0cZ99Ws6/dmE1f0Z0CKY+ebepw/a +95+CFivKUkrN3buVIwvvDUzIX4A6ZlhdClCVrkOL71gI0EXeB/7H24AgPno9MAnmiJwEEAEC +AAYFAlbtOacACgkQv08hXYl/UUjgwwP+PzIL1mP6PEeZE2cQ2+nYXXXnapv36JPRHQ241Nf3 +UUZ1AMGQjwOrV/4QRlgnRVh9JFeGPp5cySdYyr6AIrn8H19cOA6fW3i8Yb+gaL2tzkWI8ZAz +qw4qhq2BQoy+MR7X5t5y94jCx8DLiOPmnhqyeWLyEKOWscwicmpLCZXc9x2InAQQAQIABgUC +Vu05qQAKCRBTuTr0qNsmFhtWA/4ppuJ7UyOOYMz5XalxJl6uwZ/O+xs2UpIdKBajq25xZBx9 +JAMUrdal4Tr14izhAnb+khjaeH4sfvFw+17DitNuADYaXzRi/tX271iynXejjXspiOPSMSCt +vUZ/c6Yy8JuLBggFf6vLvo43sLATyuNvGcvxOEsFl6artKT7s96Z7IicBBABAgAGBQJW7Tmr +AAoJEOFPsc2lEy1Pfa0EAK+tH6gx3N9jD8t0XDTPd0vFF+zcqSM9G55yueyEi9uYDC0K5vA2 +hZjYcAsgkNw59/JKGjRguWOtyHJDwpbUt0v96MVGrmviiH6ok5xok5G0rEv6INPwQRnyNCau +z0me2590Qn393rCU9bmdcnWYPEUdRfBU6HU2DWNuxZa124L9iJwEEAECAAYFAlbtOa0ACgkQ +Wj2XOR52jFdqSQP/f2wNbyQqjf/f3NqgZ1RATxUCO9rDsAomcsJCAppAx+8ZWtuBNaZ4UN+2 +WLg1eYt9sSr6ZU/PQ+4rfTh0XZN0sokYkdKl+91rGHBx/SjERN+FjIqig+2rr1rd5E9uJ1s5 +Ad2Qt4+GgJ+PJRI1QMNjW/dSYWPca58NfaGsdhjzKDWInAQQAQIABgUCVu05sAAKCRBSER4t +Do5jjw0AA/43adsVIESuBLIgJAnweskSzSPpUNYN6yKmSwihuc3PAGTbyo+n90BA/uUfx3iO +qHMxUDefzv/9KLUAK7lOaLZy9e3o7+aQbeVPnmmPa3wP6EfLhW2Q7+ZPqVxxd3TH9r55kD7X +F681boCNbS4ysD73KXXvMf6TwuynE79KCeh7RoicBBABAgAGBQJW7TmyAAoJEEwM3zGb+b9y +JWMD/1k9dOddl9xU9g5r1kCu/wK7ZIn4+AJ0BLq1agP+lOjzxY4I9ppGahIZVO991KY8pq0Y +Pk4Rz2edwVZL2f8OiN48exui/AQ1kxKyzoo/QarMankuAkolE83NuVreLMbLi2vBikb4fcEM +cnH+1onnuNAbCiMD1Bi0lxvsXao5AmOqiJwEEAECAAYFAlbtObQACgkQtBQFR1U02gr8xAP+ +LnCMtO0YJWXEfjP6Jjs1mJdBvCtMj14wBNnGhNte4DFk3Q7y6b1Wy10Qdwn3U8RrF8LctlGZ +Jtpu8cVbrDauyltMhpwQrT89+WFINlOJb+XQEjID+MbXLIBvRJSvD17j2nW9ukxQjem5y/GC +gjorxBU2gUM5j4CRe3YLV4to8OSInAQQAQIABgUCVu05tgAKCRDf6OAx7Fw995kGA/9uKHh5 +Ah6Ry+DXnQgG21PGZ9dREE3/gNJKJxAYPbjmAPaEn2ovZ6unIPcrOPsUYFwZApgw4VRiiF3G +OqxYohDDE/sXVbBKxRPUriO2Doom35Pssy90WO8o3T4/JB7nS+yw6IG0aRfWy+MglK2j1U92 +zgPuxBhd4zLb2l0nlumSsIicBBABAgAGBQJW7Tm4AAoJEDeAJOuujFPopMAD/iJTylAlfHKU +IuS6LZ16T5nPWqC63SPYBEsuQ3sU4vuK88Skw+X2jxcd4le/L+xzDBDd6OyqxEUAyfSc9fQg +NPO4I6XpB1EsvXdyJR/mTpSQ4YP1b+ryHU8ExzR40o++hNlrxR2POYnmFqFANbCEAKHbWPSM +B/Se2uo8kmGTuyc4iJwEEAECAAYFAlbtOboACgkQz3uQaX8QzXKMvwQAi1wbnlrNf8uWavMg +kEd2igMXz0MlId06htWqm+n6z0tWAeaZSd300tnibeLdzf71p85QDNtVbAlzBpHKX1NSPvzH +qE2v4Yx8QAZB2qbKZ1yqbFw0Xulbe/vwiHraPL8EIxNsmMkjScMsyt7L2h8J4gmSDqevleJa +mxI7vTuDL/WInAQQAQIABgUCVu05vAAKCRCxeANHWDn6xKngBACFkkiJODcYM9UeCPLR6mtF +682+4ZX7kWUQyzICLuJ/dbSTBUrV5aNOwrDmjw1Jamgl7pgXusYWEhUWbZV9QV11AhJggebe +JxiIFeREaMX9c38tDTRE0DeDirO36cHaVGKmA6U+vVetcCv26D/VoXrx9yXYo1/IXdZHKvt3 +4TWNjoicBBABAgAGBQJW7Tm+AAoJEGSDF2VeZXVKezID/ioWECoGCB4BzR/WtJaR6NpI5RNL +xwQWQie6ACRvQKK+Z6AfkbSGRm2dTaRRagVuY2EYRtNOOSh9Greh1S9gDD6/edj9MWFVUxzN +MSGroHe7aI+MOxCqOvSHfEilJBRJlk+0JJcQ4aJJEZ/SkM7pWxuhkPiU2CJWQjrk5g91+62C +iJwEEAECAAYFAlbtOcAACgkQX3YauAM8sJUIEgQAlgsh+2d8HWxFwlH5btUdfH/UKn3xj626 +l9g/zwp35eJH+SBSZnFl6xwZk1t2R7MEza5KtvNyYmKA+g6RwXgKEanBThKQuRgkQ8WN/Dac +4VeghhU8ehqqVYqN3G1O7qpBx/se0C/NIoI87xJ9AxNh9SVUHyoso1FlArf6T32VNtOInAQQ +AQIABgUCVu05wgAKCRA4c7u/OdAxlUuiBAC5S08DlXZd7efdeAB41EPDMjEA0JC05A+yV0Af +70L2bchieut+Bb/B0hjMJbYI+GYc+dzQaFOMfxkD9b1ByB0QvBCEAz9duyXM90FjHY/SLBcz +M81YZ0093tRCQlUhS1emZWaf6gMjmPk13zvQuyjClHghOdY/oxIHl0+cvnV/+IicBBABAgAG +BQJW7TnEAAoJEHPip8mpd1KQiOQEALXNsuBX4aESdWP7KLn24Q4KVgDWbqYgejD+9ob5a/2a +/02jNbIiMYy43Tpy3m9q+UtJQxCGipyifyRZfGmDzIO3dZbT3ggsp+Ap3GDGrxxY3CnHNa40 +sMlIejSqMejY5V81In2uTXv7nEiZshhF1kUNtl2ay0FVXrGnkdrQW1naiJwEEAECAAYFAlbt +OcYACgkQjTKvVizOvYaM8AP/Uh6Cm+x8aSwsgj4HhE4X5VwqTFjrWLXfQATTCB5ySwcaHnUI +qfwdt75Wee/h8y0OqEcUj04/672WIWS7cffRC270xSy7StWxKJPw4gosP9d3as78bOugTT10 +L3bQmMcHpDMEP6QemEvfjk48kltH6+tLU8m36chS8ApAIsKskeqInAQQAQIABgUCVu05yQAK +CRD1+X5GPOgTalUGA/4y1mcbMCP/sU4x4rN5xn8+R/uxbOFqgH5hZ+DiG9TTjiPyU2kYpz2L +AnqO8tqh6V4M6a+OV5+qVgzgzUtGSlPKUk7a5xdsK6NA7MbNhYninsSt+PkGyv6cUSRXwBZx +nZ+atUo8oD2W2S+yWpqJ5TWFUcSofTLygvy7kb8a37lmjYicBBABAgAGBQJW7TnLAAoJENjg +pV07baMMiKkD+wcyvQQB1cNxADCWIBwspk3A5XGO7sOn9/XxN/BiDwsGYP+t0uyZO51WWzfx +NHjFpqvHoSlQZ9lVgzuJXz8msL8Dw8y0Swtl2Q30LCQKvRMqxHQm+lnrNOJjXHDo3Y3ZQyEb +Wx+eFn68HLTxDFr7h3o2+5Yf1t9dHE/dLctym4ppiJwEEAECAAYFAlbtOc0ACgkQuGeKvRqq +X5XIRgP+NLVXdFRduTo3KOrb0FM6MNHiKwA0d3mwnbnkLwWdsugPMuT7E2a/58xuaW0Sih5f +y5zVMJJfFy80bPAARc0itIMv7UKQaEVMXiwXK3lA/qc04EC/GqQCjZAnUS28KiG6yKyeD7+M +kcBiVUQryz2JVff2JfctIok274gWlOgi5jqInAQQAQIABgUCVu05zwAKCRDkpiieVggJ/77n +A/oCTcdk74vAKZd8ENTHVHZI3plyxp2sUUZUZxuAGM2iTwAJ+DpuL97jx3hY+j3rz+fWCPgE +HAXnbZ022MRrhXZCHx0VjbsvM2jyAAxQRQknMw8EOjN7CsZ/Qpkzoq3dE5aGRzFK97l23wHW +/Ys9pkQsYa1qnnxMM6VOPzDhHvec1YicBBABAgAGBQJW7TnRAAoJEB2u6so73+AI2PIEAIkS +6INdY1zhpYB4PRUUyyDum95h6+/Igb3JkD1q/UyTV6myElkAN7Weq+c3+rwqncuoTKnBVBF1 +UbBrsGDJGTy1tTXfimBFy9lMG0Knd50Xl1lI6AZ1bKX6VtZN1j6/rfHdi17+Fc+UDcF++JW9 +XWpo1ZJQK1WGXIr6FIDHwSo1iJwEEAECAAYFAlbtOdMACgkQqdEZMetZMVo5agP9GaK6bSi7 +oTjB2ISBFHmYo2fqyqFH+WCrSbizNSv68l2rLKSg05zwfTRju17FqUZuSnAoUeSHWeCQwVd2 +bDMqpAkxCCMVv2mUMW6vq/DWZ1aNC7g9y7RyNK+VK4Z3xE6bSS0lKoAaQF44urHpX1BTkRyL +cOl2YOVlxRpPHmcQCk6InAQQAQIABgUCVu051QAKCRAoNHPoBV/HdO29A/wL7CwquA2UC3l2 +9QKW6dIRudsXou0tCdxEgjvXO7ShZSh7FH7okpdy5ypWGqpoJbStkQ6h2fM+aGY9fHFMGWIG +r/aHZptlUVxEf17zgIbqNaE9xEwxB99uoFr6EZRtUothwIVINHMz53CQX/U52GvgpiVevTW8 +BhcLLm9Vwdz50IicBBABAgAGBQJW7TnXAAoJEN0xTRMBJ1Z9j34EAJg3U4203g9NwyB8xKVC +Ft7g9q7Aef3Fm4h+RUaWI1LZXcMs9HHxWWwZBhJnOQpkpLQs/pTNUZ3Lm9xgbvZQY4fXlwSu +IVCMYN7taR65yCgB+JJhBVVGQHvSnzufdXfaK3nowke3I3/eCIIlKufzwbVzpUQUD/YAaO6h +v1qQBYzIiJwEEAECAAYFAlbtOdkACgkQSI2JAIlImd6pDAQA6NW8drau6bia+3iE0K/rGXkw +G8L3e+wh4YHFafsKZBuX8aXFa4m7Sv5PI5jsUHubwpOKCUnQURk0h8q24xvk/y47WmI7XKiB +MGU6Qicf60qs55ofsElpcnZS408k64lC0X0BrfhZUWAwCznOLvVorE+EUdAiIhY6WRDoHDsm +eEaInAQQAQIABgUCVu053AAKCRCJpq/+QCiPylhaA/9uBoHyB8kYj1mils5mhl4JafqBDmaJ +5Fnc/QRQHfJIRKyb6FeEUXQ3wsCNRd4louymHch1GkUavqBeAXtrC2ujquCrmqBmcbTLfFyr +I9zGRUPXFk1FjiMwqIslaLJ2ZzV/UOuIvegc1YWPpp66DclGMlcA10+GL5mHZRXEBaGPSIic +BBABAgAGBQJW7TneAAoJEPIsbW1sTpzSn18D+wfL/h3bvXT2T89ApECZ/mLOmZC7cZP/TScC +URMfvCOIPuJb//IlF4fbKNdb55MmPFpyka9OIrMfjUjj6xJHIVXjgWy2uzSHTMbk8Q7X4dCj +PvyT/FWH2Lu11B2XrU4GdEu7wOjCEPYp8p+ySKSXWLQhffkbbFG2OCQhKFs8k1w4iJwEEAEC +AAYFAlbtOeAACgkQd3EYq6IdVKqCCwP/QK46Y/kJFZvg/YzTHrPk6URjWJFV1/dfss2Hyr69 +lut2MsTuDdI1LUcdw1FWDzGRTbRTRBh2bHOhb2UEXoYilbvTFLQGlbV/+USqY2ksC6fF97sq +P3oXhS5bmmOI8/msz8oQrxp7ByZqwYt8yD72n329N20C5gafNYWCip/stSeInAQQAQIABgUC +Vu054gAKCRDbYa9Wl4zaSiUYA/0QqyiHYY51nffxQv0ca/hulVl7wLxH/XWGZOSkojfOac4u +vcl3BEFacefNzBfGejwLCqXU2qfUv13WURgrxg0SkDuV8xlLn73LFy6BZ+H2dFwhuotwPUq+ +2kJn3mGKHYI79KkjZpYRvJwO0oGkMEw6ZqOsC6vs6bVAl5N6Zxwk2oicBBABAgAGBQJW7Tnk +AAoJEOuQj8+mhV+luiUD+wSvxD34T/kotXYnc7qegG+9TIKpb4fG9ViQYPgYL+VzEqh3M59N +EON5FQDBNVx9biLjo8O87PXZ+g5wapvogC8l2TUA+7dy9ow53O4Y8s/rfMfNwuUvhbKol+oU +6JslDOcryvL7ongwodP39fkFuCa0W0pwvkvF0vt97tLgUlLuiJwEEAECAAYFAlbtOeYACgkQ +ea6RCSaUkyG0cwP/d5g1MIP3F5hHDf2UYyvKQCSlJyiX2ExctNSA3cGCu8d/2KYBg3zQC1fy +aQIzbMblqIq4M4NgecXuF6HPvhLqINi7aUG0W00uj5Jb3vJGVSCMZROQXMLZny9DiohvtWed +eu+Xt0jfjTCT0ZxH1rIQR7IowUcnKglIINttjpuzbACInAQQAQIABgUCVu056AAKCRCk+lU9 +p6jSg8XGA/4o/orOEvl/MVsZdzQ9dObADrbS5l6DDQZvG0GWadMGxyJTleJYbFNMQRml9u2b +/GK+vyxtadr3FqQLNnYN6xqAF85ZE/uoNSrFQ2sC9Gi9OcqE2gHyuq06Orxs2T614AZvGdVC +16TwEnJCB4+8tHajEGNjxXRcKmMw82VExQnbooicBBABAgAGBQJW7TnqAAoJEGv6CUnqe3Nm +TUAEAKIpJ3hsE8cDngEFJ7gjKb6NE6UspfSk3fOKWWrN3mGVZx8cyNK4eLTtKdygvXb9bcXX +gMEVnhoNhJ9S1CI78eqGgbtT7x4uVdx7t7pt+JcLX9zCLnBAYvfpxHj/1n0wfiuGoXkIrsS8 +YgYy8i9eCZmc4MOLms6yCDbYh2TR4qP7iJwEEAECAAYFAlbtOewACgkQteyorYxEyjW21wP+ +IYx5RyRaxb3Yxcx3nhH4YhvcoXipVcir5vYUMCtU7eeVl5EYNP/u46cg3nb8qIPcW6lpeX00 ++8O7EBpipW4mB2gZw7wq97TpfdZ10iTb7Bwa8NrvJyNJHKm/hErle1xuUPh0vdP1Lx6EPfpq +kgFnvGqVV+FLAozD4SPOI/SXAe2InAQQAQIABgUCVu057gAKCRDA2JjcqBn9SkedA/90v7mL +ds2MQjYZ8ZASQq0sFmQztQhkhnMCv6i+nsh+gay5CnQYoHZ0nWi+/3kCdcFmEb99e4tgwHp1 +rozfkEvbkaxmEhglZ4ivIWWdLtrIClTF44mCZFAmQKAqn7atRrHUMbVSAOyUzSlFLQKdrPXT +OREKPHOCZe+0shqdfBE5D4icBBABAgAGBQJW7TnxAAoJEK0tMtA6L1rHgbgEAJrNHuG1/rKX +STTf4Ol4nWMsbX6cykLu3XxQjqQ7PsYte/e2vneJ077R+i10mXv3DTjC3HoS1LQZIHgTUFjk +DsjjkqrBM1Vcwu4zUsHKsMmxk4x8svj09GKLVWakwgecTB6CwpFd3VNM0KanKvSEx7UOniyS +LoDAbv2urWyWRQ8liJwEEAECAAYFAlbtOfMACgkQFjD/7KP/Vi8KDgP+PErHv5NYWJdyGQen +foFbvZhyFcX9EDse1MS71EcpKBFTDZYx7b3tKPfa/iqAvLLlDRtb/wzD8AYJdnBSkE+QSBW4 +bMR3/Hn8eeYGJtLoMUmEI3fsApNzuqvRAgJSUzrTxckXe85yD4UJ1ghqw/p4e/MXHeFJXC+v +DGMDvBrw8GSInAQQAQIABgUCVu059QAKCRCuUSQM7rvK7jB+A/44uxCtWRWXGJxXyxuuJVXO +c4E3kenTUsGbhNUDZ82e2xN16U16zNpwUnetAK/0OPsDdnoSnY7damCl5DRnE7kQvWOxFQvG +IBrMZTMgVvC1FUIes6GKRrIEkzApaK7HwTqPBsGl78gWSCTqQ05biSaA2lXIOaSRs8h74UrS +LLTSq4icBBABAgAGBQJW7Tn3AAoJEFhZ+iWYslJQRFMD+wZSiK4jKs0TPIz1/tIZ89WilOzm +U6xFLwRx7THs9KqqmQo1AQCvhEn4/M1bis3yrBq//yyD3BoJDFfrzNMU+HFtitJ2uC/JjvGL +YHvr0dz8Sj7c0MLzHgrHmBoXESIqurlARA/+Zw/E5tQ56nQHFvZlrhWApV/iIDqvigvZgUIh +iJwEEAECAAYFAlbtOfkACgkQTj6laYdGcYRGQwP+OQRsVEaB2GZ6Fmknf+m16JoxG48O5WQr +9gtb4/nX6x5IT5neLPoizrO3aVm3quHrdpbm++ajXqd16u4QLxe5Ra9nPgDztJE9USOaCkJG +DwUusw0euZ8VHK1ya/9wnZij8+e2kDIfq+Z0bJzPzLXQJIIwX9zb2IeT7RW8u1ty6YCInAQQ +AQIABgUCVu05/AAKCRDcIA8JW7jP5UT/A/9XDks1yT1x/tZjDS5Y6EJ3X70z3Mj74xXBqI9K +de9koyuhOBMC2xb5VwUWOzM41i1k1y0X1L1fwJJzQDtfoI7zcRQ6ORJXNSNPiRqtL10c4kW1 +DHl6sfzxkMmiNrprPfkJjWBkvV8W+qQQasLO2Vk/7mS6DU8FqBsE2FiR9nYlgIicBBABAgAG +BQJW7Tn+AAoJEKfzLzsDOtA96qMD/2RsnIvKp1VZuHU89hJfNSDrqbdfux172ZO+yk8Rlqjt +zmqqE4PavvrAJFnxB6gAXdYOvR36cMftL1L70bnVIWgWVyvQCUc7y4h+l90lOMPTYDr4pitL +qFngpKdI50o/c9LFrtvfQddghrUGyqIbCr/xv1xjzKcOONMo16kE3lC6iJwEEAECAAYFAlbt +OgAACgkQeL77IXzCpN/VlAQA1V/GyHXjDeWV0d3G8Z0nhrnJgNAKQt5rTBDzBfENj5Ndt3gq +uaSlrBTbGYar70bg1Jkh4kPrZ97XJY1whqIhkflshbYL52jqhh77BQ6l2I8cYgB0kTIXIzn8 +OOyUdtD5OvFwuU5Q/H9FQ8o3ISIERR15xsFgbFNDjL2HE1mvr5GInAQQAQIABgUCVu06AgAK +CRDNcflMSS75Xjy0A/91g2TmTQRv21Zgr8bBNswk2h9TEZvhreqwuEmXkgKbV8vtbxQj/oJP +M/yePn8fW5rv97BooB1sCAr2bqALKmxFxW3B6k0wV/X+Wr2ERFBWPTJpE3bwUvcTMphg93Ra +0MdVb7qQ+Y2qn/LGfkdaTZLAOFgzc1vteZzfCkxAoj3JRYicBBABAgAGBQJW7ToFAAoJEPJU +wFgfojx9wD4EAKKxF7e2iqmklg1uPkd/dkr4RFUXf380A5YmLg45eip99JqBhsm04Wl/KffJ +9ZWY0rLxIJ0wNs9xzb5ugdjhwpQM63ICSRkxLofDEJAVgRXYvsofk5+sGsr20xfwdfwHSgmH +Ba3r8Iv3QqPDaIwjBxVZirTvDQtRk0sqmp+Yv3IJiJwEEAECAAYFAlbtOgcACgkQTE7obTD2 +pB6exAP+IYrOGCetbI5YVSMgTRTZL7kicItIel2rFDE+mNxyRpz1AeSP8MetLph3kW1fxD9I +z3FFbzVS4UGbpfmYZ0HC6dMGuuZBE5w8ZsAwV/tu0pPJdPSHALw6ayJ8694rwy5bkhgFOtVZ +EvlwX5yohRFe2h5ySxIt+0Ht9+z0V5Roi92InAQQAQIABgUCVu06CQAKCRA8k1vS45wfIfGD +A/4+kIs5bgmypnrVrkAHmUKdNq6VUZfNrD6DTLSLddDjyIbvZoV2AX3KYdowXqn4SRm5j4Jn +LSt8+4sXUkwf+qRhXI4nQWKgNdqDuKA9B4olyXKCaM3QIQxuLCop9LE4OLpdV7AnBqSqk3J6 ++N9HetSJqAd8ZENtrNGecxPlZHsF4IicBBABAgAGBQJW7ToLAAoJEMYkhj+wEUvxq4oEALdO +qmJfIGbgEucAKPlBEuoK0Z2AJmpALNs1u1akOOxhfdoHzvnyR2VwFmLbC1P5M1nLPCOMnSC2 +Nbxk47l/moZnNgOBG/TDmPJHIcAUNd05I8YV70664zhB8M2/l2DJEerfMtdNQgyETGVBki97 +5KSO9LuI7q1M2jIAaRjdZgQGiJwEEAECAAYFAlbtOg0ACgkQL/AJopB/fQQWQQP/ZOf7yVdC +as9xCuLVUcNfTJZzOnyE0TehQktsA+x7QnMIpb0BTi2T2yyQDjiDmmAZBsSQfk1ebcSOpGcL +Fs0qbE5XgfWWITp1ZCbTITBx4eKnjdhGqE6s+01ZW97UtTLeHYBpmFY3GeVjoGqCrDXkYtta +SI2Di6hgdtZO9wa8kFmInAQQAQIABgUCVu06DwAKCRADJbD9e2pm9gRyBADUFRltyBup89KJ +FIqn9UUxTJzin6vNySPn0ljwYQ5wYrABOM/6HAuz6TJ1NUm9xia95pC/ipojRabQk7xpAzJJ +p97MP1QxKyvGVKpf/tRYz0+yNLLe3cNk+ksR9wnsMONDcRMNI6LNyvaXbIgBcKfRMtBLu6IY +i5+mEbscc/5amoicBBABAgAGBQJW7ToRAAoJEB3SeZLfKxlB+KAEAKZShTGd0KBVR8RvJ7ql +y98/9M4AIK5wlgvOAsv1DlcDe74Grd0HaagY2i/oPR2/jcrTrd3308/PHVzZ3Y0wzRSfQyYc +0HNam7eFdojGzMFSxaQv7AFPJWKAhAwFmwSxUrxCh8RQkTh+apSdoB7+VKlf0Aa7s294u2oR +q3c7kJWliJwEEAECAAYFAlbtOhQACgkQjmRO5bxQabhnvAQAnzpXwjvun9VuYYP0ADO3uM7c +NAo16+HcjXPMszs4xkNPVdMCdvEQ4jbfI5lMjhjK0K72Dt28hDIAvPB4dLP6h0ypfxNAnB+R +RpGwVrBFq2kOVtpG1/iuHIFNce/c20LzSURbOQbe2DHrbkwgDH/KF4HbLallr6bHLSpRiO0e +QRyInAQQAQIABgUCVu06FgAKCRDZ8HDsbnBnzav+A/9bOrIRK0MFlneHA/L7VzloC+q2mRlQ +Y98MRZxArEdY7tmHl3K58ozLovmVORZI2PN5eA+Zt46gu2+5ZErBtdjT1yvTtlIuzzgOKEo9 +DQxj5Fh5IL8TYQdftQGe9Hhi3kBu+aTxdpG2fYkZ1DJV+BrtYgQl9C5QamrGW4ON7iSQO4ic +BBABAgAGBQJW7ToYAAoJELr2xrvrfyuIh4YEAJQ1LhDd5uDBtSCffrztQKkrZP/MYRKBL1Eu +JoRZZbvTeefXVVh6KKfDxxybGcwd76Jr6WVpFyQIhuBQ9BKpZEeGA6yY08J9S5tG8CeTEaCF +O+dbGuVgHjkmHI9Btz+JVh19niAjm38H7ZB92Tala/LVuV/9PZOqXrIjQJkUcSnIiJwEEAEC +AAYFAlbtOhsACgkQlN22LC6IiHjcMgP+PeW61pB0+5LrrHaOoBlEBJJ10cl2KBW3O9PUc/aA +TX0IUAzITZMkPlkXudBNQcymhns8mpSoVEk9E7VVGO6h0cUh77y+XAe1y/UDEEb832zzAVyM +98fqRgdeAn672Nk0MqyGL99NMV+5O8HZBatXMoMmzBobzBMDSBLQjsqBdiyInAQQAQIABgUC +Vu06HQAKCRA9vOXt/lFMAx1SBACFUN9D3qcasQjKTava3IAYxcmnt5nL71S0UtadagSpJ1kR +JY0ZBy4EJ5omFnVy15A90gqFnzzN3PogUWmvlX+fFzspxWyKc2LI8OfA4g97EYYyr6ykQ7wq +pHFjiLuK0KrHq7pDDvlgNJk5rxM1wWn3c5DJu4j7KONuhlBJdXiFFYicBBABAgAGBQJW7Tog +AAoJEFRGp5VUgN/ozZED/i86NrtzYEkF3mizhHUYqH6i5uaTkx7c2hFN2NJ/rkMSN9d+bFL0 +OEl3fv2YORPcgReUN6rNCymVN5CqK5MXV+PXiqo5wPGR5Vo8RmsJwp1k6FJ+s/M9oL++K3ZM +D5rao9wOeBRnFh44tLIqDjOldYHsk/8B4SuZxYPL3ITwf9wYiJwEEAECAAYFAlbtOiMACgkQ +E2R2YRcvNKt+xgP+Pq4Jed4aTcK4bb8ox3SmZPqHoqMKL3pVMqTYAQzuu1XVJ/+R5DMWg1sL +ntiOmUn2vUr4SMh8anvfwZe9JEi//wCTnR1Wdq2M4iJ2tqKkPuzKyaO3usVCVTZGK1rWh04Q +FjiCiTdxcTXu9ImmXaKs2U9jDbtxXC/UF2dGd8hVwdOInAQQAQIABgUCVu06KAAKCRAJhPqm +nee9uYuHBACRD6GFu74bVvR6N6tGdBIGOzrh88DLTx3dYb8jf8koCjf4uqOXryNtPfTjUDnY +6aqbJV+yfNGpLHg3Qm8L+tXrSVl5bnnSRM6FnUumiwYjPjQymaVRUbxXdOh7aAPV2oXDhWam +tmK6SGtIO3Moh4mxqvoTHSUQzaKPcf2ag7wKTYicBBABAgAGBQJW7TosAAoJEEcuKrAxOOen +040D/RvkrOpO6kpHrlQkDOcXdDJRWsbUk6aGCyWmKknXKzfq+qzy75B+Wv0hasK+lP9sjHVZ +n5kzW1NKRis+sPeHbFXkXblt8SVnml5Ikcm6yfMjHFsGawxCOprAsCrV1MM7M8Qg9xrmHWHx +b5GepgcQp9rqkanfRQwtRyE8jMdzu8o7iJwEEAECAAYFAlbtOi8ACgkQvjDTxL0eplaYagQA +svOUUFpAn1WgdQ9jjPVXBI9GmdZih/Hitkw/j05hsPaWvlZubdmCkQ7H7OLlsKEZQ+YLpN3/ +iW96x+A/rwlhBXTEjtSkJ1DqPFx69+8URD5JQxcd9fvGHBxEoFdDlkGLY090/3dn/jMiszpD +nL6lI0oChW9VrRmO3iIt0VdKEC2InAQQAQIABgUCVu06MQAKCRCQ14v/WfDpNuWwA/4ruzgT +ucCm6mtlOlJO2zrip+aTyfc3LGp4KUAO2rmvyNZ3ZMzExKZdUzFubbcpyIMkMfv+0rE3DoPE ++5EIH12MAS58o+sV2Ln8qZZc5CS6qrfzP3nRv8KCl/b7jM8UNijfSuW3RyMkwjbWNVtmLI3P +j0LVglZ+Lwf0P+CmDmmcS4icBBABAgAGBQJW7TozAAoJEALrLzCsuhu7hiMD/RwMUZl3R8Ft +5/aGQ01L7zl15B6DlyJ1ukOWmh78qT6u+bpZFG4lHMvxpdCcuVhWiINxeXL7FEsppJCQv+Ev +h0lCkB/zWhHU+zxbkOSPzCrBz1tW2C49ti5PhwQPT7cm8+/FNA9+5FCwlLP7xNZJ+FBS6j5M +TLX1mk4Gmd12hTuTiJwEEAECAAYFAlbtOjYACgkQRgH0Ug0n4bDReAP/Q0J6WwWirjG2xK9F +utw6qQfWSokpogt9FZZrIpTTlHnxRMkuBAMRU4QPtbtyafSWw97ltFqVoXju6u+nK6+5Qxvb +9NluGEc8K6ALdI2wImjAK/UdW5fhsb2rqQixeyryRNo5Dk3ouWnGRj6zc8cX5V1guJk/435L +HEentbqKD+SInAQQAQIABgUCVu06OQAKCRDc7ONDPqT7KTP2BACU2bweUH0ucGNwHNwpdvAO +6wkbEagTCffXzZNUEguKs+E3cYAd6EeH4P8TeiBQ+UB/zYxK6VIOVYx5XiohDJhsIGpklKcE +GkN7OUXx445+oF6l1Ek4NNE7L1zoOGKEbZrgUuTwri5JlMIYZCn5461yq1P93ZVejHsuFWas +0VRQ/YicBBABAgAGBQJW7To9AAoJEN62ZJq5kSgEj1wD/2YOnZTjtyYQXHvLRukPwCpW9OP0 +rzfkHyqLGgG1e5Z6D9EK/Ld10+LOWo1Dg7cC4p77c0DWltJpzBUSOY1Ujm6I8TyL1mKboNUI +hv6vbRqYljtVtJDlqOCQqDR0zrkon/z7CtFC7RllDuTaBypn30IndOmG36FRghJ8qmejmmsF +iJwEEAECAAYFAlbtOj8ACgkQ7FG1C5vrJPWNpQP/U10X6KTM1TMrP1bYM8iuwXfaYgo/wJty +MVZdcktWdIRo3b9XrPZp/WDDMw9/KcgZSsmLNKwiV6kCFo8mExxtfdPLoxA7hGvjEtVilwgl +joQtCjJc3IhQyzXMO195p4VWJU8d2pMCezxxB+bS2y0n16Oj7UzJ1ZqPkFmpYDJPWViInAQQ +AQIABgUCVu06RAAKCRDygo1mWM5heviTA/sFWPToIr59NrnVaC/gcmFDs6yG3diTypP53K7y +6ZG3khmMk8JBP+JBZwAXFD4+hwRN8ikUSQsz6ue6XYCG2/a7OLdEZV3JFqGZY14WgwZUkdP+ +eorC5O0p3qILvgGZLIqF7YJ/P4gVerLHHXdEzfPDjDi8UieI7sM9ng+yAiLhxoicBBABAgAG +BQJW7TpHAAoJELbRJqDJXJaZqBcD/2wdG/ZBsPVYT4jY+UMfEQmx3z/Hi7DudynjJXWe30Jj +6GufP7aBXfzPUabQ+UPV2wPVQavt9ZBB/bDowWx98fUHlsx7xTRuqeZsCkF6f1avgs5ge5sQ +qTwvWeRncCZVEKZVVRmetq/VKnTZOX/hyAa9IWSXyFpMRESUhEXt9eKOiJwEEAECAAYFAlbt +OkkACgkQStCxqzyitTh+xgP/bnNE/LSrx/JiQus0MWizNnlb6K35PdinERO/LVB48iA+BDxp +1gJ9tHAAIpagsR0put/qN0Y7fk6hGH2thiVhZSpntFaVZNT6wO2fMn4dRql/jJVBCkBNP7mF +futGTTJA5HAVxvJLaEUXlPIfechoifIVeDGmevcE1pAILaT6aUSInAQQAQIABgUCVu06SwAK +CRBrLBHdHrtGt0/LBACVaVGbGR0utXUfSRFcqrxKo/preXV89MM6FdqAt4wUGKr/6bgJ/Icx +JxtzHD9fbolxXhf3rJ65wrVESAgVgsc6SaVZF8Y2n+L+xLeKLnwrY13TLvKYq6OL+hH317ue +k1bbp67tAhP7WaFO8a29DIAUjz6Qope/kIqFAF4VL8Ud3YicBBABAgAGBQJW7TpPAAoJEJsw +JIIvg2eRYRcEALY26gYmhB5lbQGkm397DgubGJ2CIMRz48NuAIzgMbh5xCER1Cf4oKqgSSaK +EQKsKsQougKa1HzMAgS251DxMd1YYm2KZY1J9PXQUjM4zE7506+j3T0vUDoX16vZ+hzfVj6w +5o5wBFppUWDX5+YBXqxa+hw/b71NI787itdbXljRiJwEEAECAAYFAlbtOlEACgkQCJksnO8Q +uepetwP+MTrLMvwLzsu9k9wyOa3UV10QRL2xB4PB2IqLrdFlE4jefJJI+bVd36zw6V+qGrY1 +wXyn2vcSpRzPJu+EAxhAvOtiHMOG/8eG4Yq2yyl5rRiLkJNCfzew44gcq2NP3GHKsJPFFY3t +LTNFkAUcdtSGg31a9gZ/UGMs2nSgivM0T1WInAQQAQIABgUCVu06UwAKCRBDAFgefjlZeG83 +A/9oydEobcjtwBuzm5LtrL4fTSKxwa+8kt7TiH2zW9t7rM5RZpfIaGYzf23G/2POuUyAchgt +aBP/zrXazdy8myCPFYA8gdViweve0Qsp8ZMTcivFrhRLma2tOuLj+EE/OyFKwyKa6vx1Rz5u +gGvrNAwe3m5pYeBWTYqZuvDZ5tb2UIicBBABAgAGBQJW7TpWAAoJEJtvHcGXL4u2CoQD/0R0 +FQqewEZ51ZkWj34rYIIwIgDW5P08FORX9RI5oiQHYxvWmcSUxY0CPWXRGctS0FCm7pGKR351 +pdxGqIN2OogZaH5014wCPK1xhFieO89T2dqSVwDSLhu8QdgVZemxuhE1r82IRLWT+R1o6vyq +pOHnDm0pQWFxNrFhIyh4U7ggiJwEEAECAAYFAlbtOlgACgkQvQdm/jzqurA6UAP/eXYw+mLc +D1gKoVyUkMMxDTCjC2HU4IcxxmS2FV1N7WLNM7FHTTy+InXTUtowU0z1UlOavVikaP4bZ20F +tEuQq8+c4oZL+96J5rv5JwY/Cq3emSY0IEr26bCYh3a8yqX/wsFlxr/W3xXVQbL24jo8hX1Y +nr9exjGid8LoblzJpgeInAQQAQIABgUCVu06WgAKCRC/kJ9D9+xOWOUIBADRDseyxMgsozjI +/StRGzY/jeUfcMyqTHre+GycG+R67uI55a1q+5rx5742/TtDL3HKF9XBpBI4EOHyoY433rSM +Lif16YPR/efLF5Q3HAgIe3dR39DdmqeRZRKoPdFGgRKDZHuIgIaBM3Ik+7ZzNAGLuACsV99V +kueoEvqIU0YkJIicBBABAgAGBQJW7TpdAAoJEEv2f6/rdW8fNuMEAMHkw+N4h4xMx5kBKxsN +ejGsTi2Lr9db9sNOBB2O+tReXoiZne5ku0PGjQ3RSIr+0Z+w5sK9lp7Llkcuaxd8DX1DIeht +ZaLXUIrgmzg8Uo1ccJ5Ctzoc5gQKHAImkn18PrNAXrJ6pdVCZDXfhkVvsAlo5cyfu+dVV5EU +WX1dF6guiJwEEAECAAYFAlbtOl8ACgkQahHcetp/UFT5vQQAjMITxXz0CbVmjjswLvRMXDcF +kaVri9OuyXGTELqJycz6mJ7zdx5x3Nt0E4Uk0F2/GFzjrh4bLXbVA1T6887Fa5eprwSA7poi +FiDUimS973hOsnRUXXr05xTh0mbg3PjwSE+8GKFKPe60oFT8aBCm0m67lv5Na+7YueEY1h5P +jb+InAQQAQIABgUCVu06YgAKCRCuyeShnW9hRDbxA/wNO6L3D8lVS54zRVuK9ZMpVvOc0blS +JdHddX9k06nPaLut+5VJz9E6JM1luFYIXnfbYSM5EL8Z4Ow24sZuKuMaawWMJT+k6Zbh38oY +UYkB76NECDx3aXcHZkAfgC4c8K40vFtRXJU18wf4jAaqXz1IR03+NuAA8VC2uEJ7ni9GWYic +BBABAgAGBQJW7TpkAAoJELyDTyR7/1SmaC4D/AovmZEuLBozEhS0WuxlB1QmW6ezeld8BEMI +idKqL2qGKbmmecXXqqgwYihFu1ywZLDUzDf2OEy2tl9F+6QFnXE03jeBzgtD8iPCKHDXu68B +DRQd5Ht5FBcbCQ6zeqWPze/4AtorHg4PCvtXliij1tybPKaYk9PJxDSAG1UQNX2UiJwEEAEC +AAYFAlbtOmcACgkQ8UK8d5+Qdyf2fwP8CeYePQ1jVAiCEdX9iZ0yCUQR6Na8kisUJjGMmBoW +2gyRhTEFAMGXpyxQsNJmCbmdBvBb+xqCvcMvKmPla6lJznzWQo/A8V07wwTrDYbr5Xbgk8Dm +nHQeSJ13Vpq4COvNgt4RgDnMA/SD2zNxKXVbtmGaqjejG4t7ozFzdJbL6+KInAQQAQIABgUC +Vu06aQAKCRDI7tu0EBYQFOOWA/9hlccFRhx52o5MFUc+j3aGHIA8YIMcOR5liw0FZguhhLv0 +MpAQQgnc2GOYvvVOlDTKuyCR/i2QJ/6joKGWgeNq/yXsBfLGJfG8OfP/wG8gdifTM6Zv69H0 +B1Z6bdadZ0pzDaWfwjI8MaSZt3q2E9W1D1QCBhAUMrLUQAEt0g5ROYicBBABAgAGBQJW7Tpr +AAoJEJEo5kA92s1m4usD/29QPs0ZxpvpdF8tT3WBMvlQ9IG143xP1FCnc7SejjrHYMJPjHiY +DegH58iosjkXf9D7qswv3kAf+EvnQvnYsfXHZisqwuTJixQhTVroPVB6BTmsOwscpj/FyYac +5c+UXUAh2XcAmHXg4o6swVTpNdrVZD8EE8l+xTGRL10D5+XaiJwEEAECAAYFAlbtOm4ACgkQ +Ay1U3HwDN4hByAP/ZkAq2vb9tpwQ0uabGuqUBMv9URZInd9NiF5yKHnwYjkn//QpN+Ov0OEW +iyZG4/4R4QXYfWaBD6N1tyZi1jzfCjT43FD7bAHZyhQAwOl+5BznQxVOpwZOPjRxuvL4tShy +lsNNjX5bCvGaTOGafxoCfe/kMYiN9s9rS5bUeIpNvKSInAQQAQIABgUCVu06cAAKCRBMoYam +xm1ho0smA/9rgAjyNT6ZotOkWaeibPqaOcVDecGQTi5PtQPWzvPvfomFZQEBp6LInzU0yrV5 +6zM+pKSYI4lOC5NwL9u3it1FtRjSGGZ4jSaJZAyMLNtv0JpLhr9UAixRtJuumTr3OmYS1TeZ +BPMxk981oAPq202eZRadk+RFg5vZey7BNIC7B4icBBABAgAGBQJW7TpyAAoJELZmWkoHfUB/ +uQYEAK8mb/hw2B5zo8pAkiiwyeU3e8P2wie2ThK3SPj7X9Ya4TiZpNhI4fdx+EoIrwhk6Gd2 +sWmi2wdAzU3RrvG2x/Sz5ubuF0LIFTZm46MbFPLU7M9IJxQFbqK9DTkE6Jch5I17j5Q26wse +2iarFrJBqijFDvFjtGklfwImeS0KZfy2iJwEEAECAAYFAlbtOnQACgkQS7KTQsnTkIidLAQA +rLK8KKjZnqMPaSkc44HWtrOHCp9UhEPNBKjuwmom6NtAVtt0FoCXaeCypE2baIj5wLqnvJWy +p3IBLGEHE4qFcc9DO55KoTAwYDFWrQcxKqldld2+h5D4vqZ1AjHF1TIUD0bLXhqYKuj8vg49 +zOV4gIHA3lw7GXfrNzS47kbQbR2InAQQAQIABgUCVu06dwAKCRC7/byNnz/VVZ4dA/sHFe9Y +TZ6VXNmfFjMAjcthiqxQFibmcWgmzjusuXvvZr9EFYDPaKE4FVKrMjELmc7odfUVHkcBxRTm +1yt/i+w3+8cDXtJe1uK1VTuI0SC+3iwF5rQ14rTrGyFAIjwqn02xTUy8Nh6vgGIgzr1tnv1q +C/2SZnf6Cx/En7e/81yG7IicBBABAgAGBQJW7Tp5AAoJEGBaFPxwao7x4VcD/ApNr41Wu8VT +ZN3W7nq9YuTrvWT+QxMErT+MjTADY9pVtt6IrzF2EdcoRZJGEAxfqtZVs5Pm7rRuvL0cAban +EmkWpf3KScox9vZ/FF4qDrytrTv+/B5//UhfzPDIVovQoswbdgN/F+s5jSRp0uzgEZRm4NgS +9scgUSUaJDq50aX5iJwEEAECAAYFAlbtOnsACgkQVRyntPWUGqja4gP/RGnN+TPajhQDmbZO +B2S+8wEicYrHKZEi4QAOhUljX2NrAtm9f8Z0mOyIxB9yHvnqvpBXrCpTcO/49RgiQV4w9SBj +WXDcYEBKiPqj3QAOeYoop72ePmWVHexqU1ucZX7y+S57WHWRRni7gkwK/Vb1gW9dLGVq1Ax9 +g+zWQbtyF0qInAQQAQIABgUCVu06fgAKCRDRjxYrS5kxAuVCA/9nC2A8ZLZBjWkHwET/S0gQ +IeZvmsxCunk6qf43yleQdB0vTCA1TEPiglCdIlIcavI9de0sTN9Fh8Sfb/VlQaIC0s75oCUB +dc7SwurTLVHftbW4z4EMPiFNuhT2/uRp0cwhe2qrRQ2da/RuqTj7D62gN8Oa1jOuccoawYm+ +ETnc/oicBBABAgAGBQJW7TqAAAoJEExyswoS76FJRM0D/0bEuyk6dkQ2DeY+sbu64+YsIHSI +v/2UaQpHXnWOPD3572LMCLtFZUNAP6jt1dvfMecSUjGxPz6uXnV2XKU1LvwXes3uyHgk4M+L +FafKTmZ1nos/xSN/3vyiQflBh/t99LscllsKl7IZueInfNvRAamkAvUHpjs42ilEQr1/TlSU +iJwEEAECAAYFAlbtOoMACgkQcxFq0TgGIp7a1QP/bKmG7K292GvKKTajHTgGOKXvaMjTV98Y +HdN2Qdp//c+9WefNZCI8UCqNpyNsxppXvnhrseWTelbZThJhVw6Y7bmIAx5eTpy+MdpIR5p7 +JRPpd1mgk25Ah6+KXUiSpHjvYzdvrVrqBVxzXIcMjoINj8m8MPM/BjmPQeY15lZFF86InAQQ +AQIABgUCVu06hgAKCRBIAWm5oY6wd+Q8A/48QfQblkB5Xv1HtzOtV4TzgYE1+nO236OBpzWm +AqkQqnEX5WQdAbF8XWBLuqNf8Zh8/5Yk0qJ8Y6STn/hJce41QoW39njlNzBtf84szx2k9gvp +FnNxeLcmBxrK/8FweesPnqVIVkhITL/9asJHbX9uW1llykyh4uvgWIay6Qtp3oicBBABAgAG +BQJW7TqJAAoJENlTH2kzxXRxRMgD/1r9AMlt5BBW4+gaYmLSAl/3Q5EhHkWLd/0JFlJ6Gik0 +yjqg7qQYOlv+HIbtn5cUIqYtxnBmsAgsLGrSOStFvwEY9US78u4HLMEqEEgJDgQU5eWE6EVv +bkK9r+VabmLOm8WSYp3WlwhHCSo/hOYCWB3yEVimWDNw96mqxW0rCblhiJwEEAECAAYFAlbt +OosACgkQ8cFHSfXZ2Ubh+wQA8PYljQKqF1W2DuwzVsjZTcKk93UWD0+3GrgRHFkm9CdSri5k +/L91OKAlI1RB3bLiQTiicA8NGHbeZBiI3qqWK3I2ea/UCGa2RXrwrrDk6jcvZIsAFXBejo7V +ADul4iDBVXG1KkyphjL4qTKn9HOEH6Xl89E51TGumdN+jh4XxbyInAQQAQIABgUCVu06jgAK +CRA4GNCL4xh3Tls0A/9Xxmz4TZJTAMivM7EHVrlZDmSaE6/TPeSA960jGNzMkTm8JHX5sOPp +9QYNEtSXX/b4LdngGY1JvALm5WQj/itdkyyfM8YJpJaM829FNi0FRYajhupgqvNPxxwgXzCk +WSQOtTH2Ju1GWklGSs2lzGoXikrwjrBrmQPzXDooBuP4+IicBBABAgAGBQJW7TqRAAoJEJwh +V7gJC2AVn+gEAIceVMpAtc0LELD8bEW+q++4m3atAxfJgRYjILYm7jh1WLfGZCq0Rz+03Bw8 +EHsbRK/WjFqEW7bQvpHt53A5LgtmFajjTOk7J2QX26Jl0ssOfGgU7w0JfUn5H5v/sLsZ+TdA +PKg6gDFgRekSkonMqcz5CbRn6Q/FDzTnkoe0xuPoiJwEEAECAAYFAlbtOpQACgkQpX6185Iz +c7xSvgQAn4qrd22/9Rfk3OLzXcED4ySHy0NcO85NHIzaxT4tYsZlQhmHnyt4AGRtn+A/mrrp +gPx4BELeQ3VjVwQ9jYJAkQ0r7blBkbodnFEiNfLRbunXYBFeI7mew80hw9gp/0XB/YsFsxEd +I2AV1V+Nr+vxVcsC7cM9iuW4GdriQRl6I4CInAQQAQIABgUCVu06lgAKCRAtXO+S1/NL2coC +A/0Zr6r0K1Ghj96Krphsu6h7jeaLXZmjWbfw4S78K/rKcmId4kFjKEv1VxHZJi6upLxeQGa7 +1Rt82kaoC5UijGqNwlEzvRTeup1DOImFkD1TVpYlAg7ENtcNG0BUm5nm/k3SkxqNEyvMFYwI +tRd/Az7muZdXHzvhn96zFYBs4mws0YicBBABAgAGBQJW7TqYAAoJEJyIBI8lee2+6kYD/1ac +qF5iW4LD4R9bv0tQYuNNiZ9GxU8k/j/LnBmAzfH3XkPlMwLnlvcN3Mft6eIgATjZwTf54CbB +fV3PXssr010i5gBa7/ZywM9FpcRM1w5mS2AXFETDR4pBxrwx8H11ogMEJIX7qOwqvvVdi3UQ +NgE5ZFBEPSqdxbuYH/+fyUw1iJwEEAECAAYFAlbtOpsACgkQ/LV4QtZQFL3nkQQAsNjgAsb0 +s8GnMb8VrbCRTFCS3PqrQzIQ4SobGa1xtpbibNDCjnmB+RxFQp1EOVLuzAlI7yu9DYDv7G92 +q2/PJ9ETdN9RSjuNlCgeW7X2BGhKXMVvLlGuVGYVWVqhKEX87uvE9X0ll2cDUq26+DkFb89k +rtT4d8AEjp6OkSLHL8mInAQQAQIABgUCVu06ngAKCRDCsxSn+iO+694eBACFVqmZtMb5VCS6 +VcQ1V047xjzvO3WLntAWoeLDfgNeNAfo64hSoIdgEXBBjlk/aH+w2aNpG2dQE4ynl+8rKSRX +0T0g7M9CgeXSRT9Bm0LGFKlxz3FqFoNpzDBsCzoIFNogATW9BnAflwJ4/TI4fpNH7l+ZGkA0 +7hlDxzpoqjsUIYicBBABAgAGBQJW7TqjAAoJEEnHXVxXMlnMoogD/iFVcS0o6BT01BILGvnJ +GQmJijPhO2RdWAJKwTDt+94E/Gm4Qz2AVbOkIhBLr4R7pQ+AdM+ddPmohZTlu8b4k9MIabRL +Qrvaef/jZQby80pg31cION8Kt5W6HhDLqXiiaEBFeCGONtZUfYcHnS8ikkEIMw+m9fWWKbh3 +IRfo7psRiJwEEAECAAYFAlbtOqUACgkQwN8p3sc9KvHQigQAhfi4goY0HvtpVOA0ppnmfGym +sWRf+v+oGKnN1nSGuOnbxg8mZik8ERF2CIL2B/gwvY2TR+InnrInCWbW+owfSDt+U1r49YiG +WwFteLg4viEAEZ1IEPwgtqJriR4ExqTrqldHIbF8RtybddLzfaQ9MVu3002/szRWTd8u7s8V +rUSInAQQAQIABgUCVu06pwAKCRBIrp1Wgmk9TK9rA/9n6tUFn5pNj7L+Ztvgm5o5hG4lo8SE +FHDxIi7tUxdTb3sUV7cvJccTRxjIIT/yZ/LIG9dUOez3IIqIRRt1EGdKht+2bNjbNrbtW4F8 +nXFLRQYSMtC2uDBEnKE9H2aZ7Jmzz6vddVyh+bpFvQ4U9T4VUUznpi3nvzfss9wwzd+2M4ic +BBABAgAGBQJW7TqqAAoJEDgjgetOhi8/p10D/1XW/Yb4HtPhHW10VvFPAUEJQYyCTe1y+4Ea +DdZSoUdCXQjKVWLjEz/aKVdZrkCyh8z3Aqmg6uwy2A0DeBd66aH3I/wGoYzd/50XmUOnOYYC +svzMXndGYMSj3t4Y3n9Q9vyMhM0GuydOnrtloZK/HHyOCxI59PpdZOpNDMgfgoXqiJwEEAEC +AAYFAlbtOqwACgkQgrlg6kLZvlgRvwQAtlhvJ2DirUrco0/zkNDL87nIlutQpV+A+GlULVlL +jFQOj1u/pW9atTbOOmym4Vb+Kn5Fs4UWW7oQkNFItRregBFreZrIhALUPXyTeY9DmkETAkAP +wibD11O9xVFZhJkxEMz3wyegdcXiREcyac1KkepkB0HmvhYSThSaiBDqG22InAQQAQIABgUC +Vu06rgAKCRDm1DjgTCXOWx+3A/4z5MZ294YlhxTO/1wJHTlQAv+lDclebuxxHOvcNl76n4Ul +e3ItP+JmUqvVigosFQmvCpKfMoA8Gxvzrbrqk/x8fOfmqv4eeqVop35cl40yEb4tFGRkfiB7 +e+dC1UliDJn0xwt5DHaVejTs8UDDprZPGispCWI8Wf1nqiRH6ibxWoicBBABAgAGBQJW7Tqw +AAoJEND/jC/BMGPAvrAD/jzWVBWjp7zoa+EXUhRIvJAaI1DOty25FaL0S7DrnRGY6Gzx0IkH +j01NGx0GPlDkvnIbJfaU/wP+Xr2rjRsFq94/aJZ51Jd7oqox1UFvNCg8cJfk2TQbXYTFWQGP +g2r+xMRJoxOCAkyaeJJGqpqjo3ashlIZYmc4WCbNURuUiUzGiJwEEAECAAYFAlbtOrMACgkQ +1s7L2CYosKFXVQP/SHeYnVwOXPVt4Yz2fu5Y90M18ob4mV11Zq4ozk7TOFv0UF/Zk2tLvSUY +4CFFrp4cnOln589H2Mrx6/MR2jMFyDeQfpis3p9ix2KRbt4uzLq3jspPl6yPi66DDZN1dlKx +dvtvPWIniTXcI+zP+xImnK+Jed5X4EgA1vdd3fH3XG6InAQQAQIABgUCVu06tQAKCRDAwBEI +VnacbKfABACgDnNAm7LOFJagCFhGfub6bZMBkqbuJloLPGEZRjopEmI1Vr2KEUs/xrvpXLW5 +s3c1VF1Kj2LADvgBHtk1ccDsQU2kRYiP3rvvpbMZTikuc0viSBXLKb6JP/ktwec++15K0QaG +SA+a+3z0QT+J3u0yk+OfyngAS0PSO1t5sE68JoicBBABAgAGBQJW7Tq3AAoJEGXcTBDkjohy +KIEEALGP55f5/7rnq+loK3f7sqMU5FzwlRFrtMJc+kcotLs5XwiyapjVd9XMhW4t59RtE98g +KmFoUrqdpuANlgqsRUovJo4pzs/0QjPb57gaZ1l55CZaThT148Mc+rR3/25YTcuKKfBfNNnG +tUbMwkQ7amYvSfBsZl0eumESs5t3eVLDiJwEEAECAAYFAlbtOroACgkQfZDir2q5e6mPTQP+ +P/oS5byLPSXNRqI2JxYnOF9dVt6UWOIN+GvirMoJp9IO15LobKOxYsZFhw6oJgogmq4SB3V2 +Bsb+R8nUzEnEZ/2vU+DS1THhv3xW3xF/r7LN5ZrN99bA9BiR69im6vpB3ERZM0S+6XCBSFhR +HTqM1YfdjHuu+rWpuJk2IaaXIjuInAQQAQIABgUCVu06vAAKCRCXjvvLptYtj8/bBACH/z3P +FBkeajIMcSVtC8dEtRDnjILiwjmyx9xUTZi2svaxukNWryGqOsPimDFdCezm5s8luKubRbRG +A8NUz7BDiAIvF/32EKYszy3SojDlHvsFz9JxzTW0IAn5c+/Lj8r/04vUxAsNlJD6VixASPky +kYsNRrkD3o0xOTcnhZ0jLYicBBABAgAGBQJW7Tq+AAoJEEL843cqBlIUD0sD/jf35AdyCD2b +deJpSQj2pNZSWZu0qHEYRHRdzgDIdJhlSa6wPwSk+RJAA8dsjcrJe2j4Ev3eRQrnzUdNm/kC +kLaDPt7aEOom/4ExKefPd4YFaAxfc0bQePgjZRMUSJY+diK/AXXCRyXQ5zEKl2QiJYALH7MS +cTaXcyH7yAoElip3iJwEEAECAAYFAlbtOsAACgkQ+MoUFmuLxYTbhAP9HFhmMlGt5tOxCY8w +ZiymbslF85zEmkxvhOPAE5vtFJ+2zsgTsEoUAEWDo1rWZYrrutUGCfNJU/7Ni+4bBLrvfY5b +6/d8z3r/qEethKPHP4mX7SYvXrqnpK/esqRyaiuL8bYfjqFR7kJGyoaWWXJM8UxMimdy8MgS +l5+hI/Ad3bqInAQQAQIABgUCVu06wwAKCRCfol+g+Ad+yuItBACkH5rM6PMEBiNqWs4kCX+d +z4SP3VKehc/E8eiO//fvYYrodEDffFj5UdbqXTXwB3U1DNB+Q+5UBXk8+IW+X4iOVAvTLuu4 +nhovsQWkZM6q4+vH/CmuoUkR1eqdnRFHvNrXnnoC0k6vi1X2HOt5PfIkMFgf3PVnhWRLfalb +JZ9gx4icBBABAgAGBQJW7TrFAAoJEGAzy3cgQR/4ouwEANEy4KXfJcMzu+Nc4kbGEReOA7C7 +SLev4N6e3WfgO7Ry9s/lut2Kik7urdFtif4hj9LPFZXFmw7vmPoNfsrJzg+NiuAFqXUPj8Jp +iqNLClv22tbFtgU8TOOq2kuPNgLjMX8nPjM68icmNT9BgbSfa+7ugUQtPBzrIXOYhfvZ8uK1 +iJwEEAECAAYFAlbtOscACgkQweWlldwl966SdQP/RW9rye5ChwKQG8eZdTV3mhuooDLcUhnx +9OVpnwZjBHkQkHvGui+adyMJ0bEWumzdFAO8tIWjG5xWzYtLrKhBDan+VEDN72zA7Od7xQWf +sHivsC1j+xvN1kL1gYwtqRL2ZrGip6OTEfYHjUS1axZvJomc4pLl7GgY+NB9l9qyn06InAQQ +AQIABgUCVu06ygAKCRDwhs++UwIYSiVSBACAQ2LR0wJ8CHUndxFCQq6c3E62Y7SdNgsj7R0w +vNraqU/2PUvZdVlvzX+pga2fAdDswxeDQBkNkZgd04IcQnUQnfo+MOUL6ndH2FMt5g85ocuQ +0xE1JVqPVqnsKCWn0XOXEEIFy1QP+uZeVw6vJA9rjyNMSJRYgqjs3d62WlPJhoicBBABAgAG +BQJW7TrMAAoJECN+153RMIkN3bcD/3fFyrq2UCx9SJ39vEtBAIAlrl76Av+KiIU4eIjQw3kG +pK2qc2rwE8i3JAfake/UNCTNlsak9FJ+ejYSXmvlEptdApKnNT1WOAfevjWwyqBNASqmK5cZ +tFfHn0xxfc1yk+IrY+uT6Q5jMFSILMyETJCIRKyvVIMWahmF5eIw4/R7iJwEEAECAAYFAlbt +Os4ACgkQXJ2Wr+GmvoyPtgP+O3hNJEDylqQJj/Ul3EB4aTJipapycY7ZLeMHbGEXxeOVlBqV +Kiniu8VMlYNJD8qn1EFlJ4Kv8YsAks9v5skt6J/URVb0vzifBnycxv+LMGBMrD2Hb4uAaF6O +MehXJ6cfNrQfolkW3yYqIzyFl+lSZR7pXXeOLWDB/O/GuDhSg+KInAQQAQIABgUCVu060QAK +CRCvaSUK0M4+teoLBACN+TXk3mplqwjSBY3G4OqIC6ZkhI4ci7KDb/Uhbq4LX+Ls6tIdczvd +EddMNJ6Y9QK6GemRmCVY6xIYEB99PXIqvt1SkO6g2pEILKfaceAufGawnEWAlf7MZFk0G1jf +0/N0J88pu1fyoo2Doyyl+lKPJawJIHnDUL8LAslzhUvf+YicBBABAgAGBQJW7TrTAAoJED7z +v5ds05YgXIMEAJchgpom0GneML55Ehg38+kYgi60fxY7hCUAnQtTgWQsmIJbHGwJ8dDQ683H +9VyGChvYNyq+ERYr8NPpwrYNxzJKjmi71r7Ex+RU3YcQWcPc3U0+Hr38XnXoOGL1nFJ/SbDr +Ox9N6Md09UgfO5Gh/uwM//mEboTjVrliQNHZxKRviJwEEAECAAYFAlbtOtYACgkQp+Zhov5i +XPOIjAQAt0x58SfChcsq43cfjr+baLf8kv9lDD+dcXpc7pY7j0hMfPcyZM3DWaFL3eg1MlK6 +voWs4OQBXaX5E9JawB51CiDtFq7VgpVtxM7P4RgbN4iMqLfQejnDlLffHIC00cDAmWYb7W+q +xcdsfYDavXbacrm+hgNmVWVN9DaJiSDRHBOInAQQAQIABgUCVu062AAKCRAWR0nu4xzLG3oe +A/4yuE8OT/9Udw8xjsZSbOliY8KHDBaKfULO9Ho/nbk1CsxmfMcSJAAsTJVDNzzFfiG44FWv +3oNi46k5EJ5xRYea1+SIWoBOsDLyMO8sKWVMWeHGZFdjS8wHmD6TzcwDg/67KE9PjZa6oWVw +GwwCHjuQ1yPPihdqHlMvwQMdR5ISuYicBBABAgAGBQJW7TraAAoJEC39o/7IS9BdPoQD/12t +Eo905ibNFh0hZhgdjvbq/CU06la6YOgtN3w81OoxgKNyNOZLhWjWHAEw876tEltMRtTNASYk +PhNTK/1IS9wQRNZCY8YPbEbgEMZwf6u247zGfwa0dhSxFK24lnjzVFd5iUQT29kdsTFx9gNH +XGa45qzcriYn467qwjTJK9griJwEEAECAAYFAlbtOtwACgkQys/TbcXgYwRdjwQAst++GruU +pBNmQ8hcktyZM2BS1Ur3zsciamaziCPS2G/xw13j30Kfl5gcV+485tGLNNK+qPO/a2M3Kkmm +Y4R8nqJU+b+a3ma8iD7DCol+WxJEOXxBt/c5EGpHKY/BIUXFbF6GES8sEorD6pGq/hJxCq2w +mWFTG+BPnwdzXvsHBCGInAQQAQIABgUCVu063wAKCRBiL2ixV4p7+EuJBADVlFy9tcZeY8Qz +tOS5Bf8F+ShikN7a3fySiOJl98FPBcPU6A5//GgSY+FoMD1zE1Xmh1PT/jBXM+2ZksX4rQ/k +UHfdk0AlhGJzfSZBAssUpQZwMdjQ4s6O/7ApS+A6hpMmHRMJpEKATb1hByKOy37Zp69Uiyf2 +xcsGckPXx+U9MoicBBABAgAGBQJW7TrhAAoJEJxycxAubktv9PIEAJWpO7+GBBS1/KKSyWGS +5upwi9UQPuETocqNL2IpH6R2uE8xp/imI6IXy56xKVc0cUuwiopdzI3DLoCTXK0Gb2gdYQtY +RkqPkasAMXEDWMauw97w12uC2H45GgaYy+cMasfv7ypakhJoR9G1WqrekyaLpwugW+5eSQvk +ejyNmEu2iJwEEAECAAYFAlbtOuQACgkQINZM4DnbZ922SgP/dqhMAhq6yJEUduTylxcDQesq +Zh4A7QHPtcZjqzieoSNtSJim0pF4uGHOp7vjRRkzxkx4z+rYctaeffqx6my97peW1t7rgDhw +DjpmkcdAwgGqjJWfnXc78NnxMPwlc0fLghuz0jjeuT/2wZG0PNmjm4WeuM0jkw21EBp2Axme +FliInAQQAQIABgUCVu065gAKCRBe1BL9OxH933yXBACFDN4W/CoBWxVuq12AE5tgAgl1yoqy +Hl6kXvvP4ey/BIHrkybux6mdwfbikVHylSECxOAUxxE66u5qQBXImi8nlunEgxy38wsTlzJt +kSsXJJWWINv6pO8F9R71MtFpLh6AUqaPUQ9mFpE+ahoRDKkm07Qw8GRWuHNJ8DQYk76haIic +BBABAgAGBQJW7TroAAoJEAScoLtFaLo4vqgD/2QOdfdMrzJ2MczEDJteuk+AdVrkDdkFZK5P +aU2HcB4WNmm7xkcSm9ZOq2Tl0AkgTzvZYkUn9P+fzZN/8rfBHih2BqmOB3MOkHl/dUW2NJOU +aoWi0NWbBxKL+KXiqaRxq46p+2ofm3Vhwoezz0mrHfzL5gwpX3BlPWDMqspY2RIOiJwEEAEC +AAYFAlbtOusACgkQ/+TKvhlfauPm4wP/UasrAU6uOpa/EN9z20ATQWGGttk6mvPlE7FZoyXX +Xg1GBQmfheSw0NWhyj34xI92FYAddvgO7gIBQ2CXvtd1FmUlCrtEolCFF06UVkNgPzZMDeBB +25weXLDs8Ph6pdOcpmx0Pd7HlqMEHDoIvE8rCU1Ai5YXiGXWH/8wPShyNt+InAQQAQIABgUC +Vu067QAKCRC2l6YznBhHoqbuA/4wnBn4EdCIUzbMrsMYoTBZhWm6C/8E3EwZQgykUm1oSJhs +0pzz88lBeOewaoy+WPOR3k3h4s78WFGmQtSBp8pRQ+H0J1+i1KclMcEdWgsKxC+bI1L6dVOG +UxOgb+6d9WZyzNMg97wKW11ehwDkRZWGaVJZMz4lB8TpbuWrVMU/YIicBBABAgAGBQJW7Trv +AAoJEFEIMAq/AHH/DsEEAMkraKHKx0qLwMQs4IrqdKp8uSxBR6y1Dt4t8G9n2wQQU2CwNqGr +wYHhn3BTvkhsTzBxsibQHzC4RF5TvsFbTlgTYtaAjZVZqdkry1vBTuJfh/0OKKwj9NsRzzor +DSeFgc67ymFvUIuyByrRR6B5TpN/1uVCClGVN/NU0p2YAh0tiJwEEAECAAYFAlbtOvIACgkQ +DokBbdOOuM+pFgP+K99o7iLHQx+JqaDsWEv5U0WM3STYDvTYZR+ZHIgxG9h6ZkmQ3pjn3EmI +/feRX5EDI5ewKERxx6Gho+1/9J74g2eCZG4ud82C31AYvA4abk1/ELFAG0tEFSAGfeoy/ncK +7n2irGvVniLr+7TAmtIqJXwdQIJ+sIJgNkPzA9c3/vmInAQQAQIABgUCVu069AAKCRCWH2rG +4o6DNVFFA/wPA2ChZNEZO2LsN4nP0j/pmtowDU4cE39JHFFQ+ZRmAyYaL5u++g9yH0TsJXnO +GmhI+2UPEc0iWSukFpC0KmzlPeVJCK4tXplgPu7JQH/SlYofHrloSTjQiP8qv1tOjvs4hr3A +8zIJllbLsv2LmUXHUQ8OtyFMRCvKAoO9Z/OlPoicBBABAgAGBQJW7Tr5AAoJED4ILwvHzaS0 ++zwD/2CFKah16UZEt4n6xTBoJjre/0z4KSM3QfV41UzcDs/PPjSCPpmfi1l81P6YeXLJSNYO +d6E8G3gOJo5KYc7m/EMsUb999Eq2PrDxWdg8FsQlLgsUF6cT2gEyfWkM6b9u6ZTe9lgsxbGf +RyHSIAeGwoSshnn0TncL9DYQ7cuHjpHziJwEEAECAAYFAlbtOvsACgkQ2UlHf2yZY0yvTgQA +iN/4EU1qOJl3/Y7MotOlKdVkYjXnMR/tUms4x0WY2/N/qy2sfhw1hEb3P2fqNx0gSZT8burl +29I6taSZwk2nJd7RehncesxmYwzRZWTehgdeMyuVwST9ntBJk2e76RdpkszpV1LQajuuDYpi +GwI4ZPKHESq12bQRvNPxJe+wh9iInAQQAQIABgUCVu06/gAKCRDRYp7zI7XV3smaBACtPFf8 +GqMvPh4ymHmEMmZZLzC5aoJiAcIGbLPv+sKXig9jkd6q7p13rpIGFrcxLVeHPU8xNhAI3MVU +Rkj8mvf1uooiVJoMCxmDaPN82hjIiaiboKQtiSG2c3ExmUA1poLU8omhHLXc8t6sw0fyNc/E +gKdJixP1KFJtLP2cSn5UzIicBBABAgAGBQJW7TsAAAoJEHGjjCr3rEHUelMEAJ7K36dP8LM8 +NwI/wk3HTarEiOJGO5oaaQ222jiP/bO5882QIkWfgRsS53F2u7T+Q+1O+t2WbEKzdtD+0iYH +SpCEZUhjs/U+z7w/pF9+Wzv9LfgKFqfhX3I1IiYuQt8WtPJHRU9aiz9fIiLjTIm9E+J2FBsU +2lKtghA8LbGcqXCviJwEEAECAAYFAlbtOwMACgkQmYRQ5xdrDP9DAAQAjPM4RxsNVv8pE+Gw +67IQgq2hwiyGvrI6SXw73OquYEY4TsOFOue5ECwtfEnq34P4Jn2Oqtc1J5OOBSrjz8hY242i +yb98GdfUxmn/L1++RXmejImgbykl5SXAbE+lcghIHfAj6KnVyMg0OzKGy6Jaz4Hvc7UCvqL4 +gT/QgkEG7IKInAQQAQIABgUCVu07BQAKCRCA3TAJ8OJcrupGBACRDVxM2HYeFPZFFJGlDo6H +FJOZbT5ei7TlS76qOpLtkfQvq40N5p1OWOCvVj5TvDqTax80DnaQhFw1qgXXzXU7JPmBPcF0 +pH5HGL5N9oSReYiAMOSYQIbo0CGelkL3EI8feUDoOQiygYujbxg7hLCp0mfJpD5MJAiK8cdP +z08w7YicBBABAgAGBQJW7TsIAAoJECUMTUlHcEMbZtkEAJuyABUHK8d+/7CHzyfhlDaHxM60 +bshG+PjYPiGQimdmOtMKTIDgMUZQysZu8l7EyYkW4OxYS3TwxQDaysFLWCnmdGO9enJfS9uF ++nG+Nq1oDzINYscIlMA+RwAye03DinjHl6/iI9woaROUiFKmPB1jma13WY5oY6/w0X6Sx9vS +iJwEEAECAAYFAlbtOwoACgkQOFF9xuMCFm9IEgP/XJyvB6nDqyrtwXMODVkQHjkw4fkRJ7qs +EnphvusS+/wbM8vFGn8TLaRbW3hBl7aG6YI23OJoIsnV81NnW4Pn6qhzOyDalWWDrlB4Ub7I +DQCDiqyVLe/UtCh16fwKp7Wk8qNWC3y436qxgbDAlLfyazhLxW3q9qXpGhqrTobmN4CInAQQ +AQIABgUCVu07DQAKCRDuvo1Raz6nmbHSBADR1tgBYTuqopcrB2qA2IfyGb6m/LAOosO8KVil +mpZMMeSBbR1ekj1d4QKZypsPhRYbPKy4vGkwqbo/HgZ9iQIco26yDtuoeABMJ4k3ZO+zUTxY +PWYg/bCm9eAfw1zJhEFLBSmyGKUp62vnVWsqIzPRho+BBoQPA0R4jPeTYHxw3IicBBABAgAG +BQJW7TsPAAoJEFErZIt4pVWPiFID/iYBA8U4Rhthp1H+ZlLcfcy5QeAkLIbXEvngirn1TY71 +dHuqGjdabwpZYTjGnAF7cmDOBKQPQy8PAi2SkXhx00ojYtT64jRKupYRNm3qM8xF+OW1KtbQ +22ykS3LFFMus5JOGuD4IednxRPrv23KoJbzt+AeUgad0XTAwrL2vEqMTiJwEEAECAAYFAlbt +OxEACgkQPPeEb8JQmQcphQQAp5nVGz0ESHRQuh0JNR8LLMLjZt2Y22QWKQS9pxR6CmcVe/z2 +39uDAjMIo1khMmHrRJzvqWd//NqfFG0OHBmSFP2gH0DOE2VzaLsC98APfhg8bpPJSM8x/AHr +M2JoKzWC8YHtsqn69KIioJ+G8V8NA9N3lVHkmERdTAPakPwLK5qInAQQAQIABgUCVu07FgAK +CRBmEgqfV5cby8LiBADbrDazjMnFPIyqoYnyBLhPGBJEPKuxcG0vVnezny3mqjubmXyuzAhT +nJtn6shxVcQZPMXShKZlUSgEC+0xOaKVhW03724MNa9phHpBZo85EKSMLlBUaHoMcdr383u4 +SB1KU0P7VAIOT8vhkHhtioXU/L8j8LdXvLPelw/h9Ngl/IicBBABAgAGBQJW7TsbAAoJELrS +p8VgW4//DbED/0lxqlZ6BYHUQfJnSBl306xDMBwM/i9lzRk3PwdNpkpkbOLbRfRXiLQoZjrc ++bZyjjiIXVY9bnvBGYtACpDxtb8b+7UaW2snv1DAltM/ay5Y9XYbIE9HC/wdnB9dQSLd7qb5 +QANTWt8yg1uXwMJhQ1/2q5hxJzvZjiiFN2NHLeAtiJwEEAECAAYFAlbtOx4ACgkQshnaFglQ +znYkvgP+M8EBi/FQxiJ+REyy4FM6UrMhPReNIIgDLdES4PDike7HaOUT5wmSJPYHIHi+xN3C +GyaHTWS0LqUXi6RCpvzWl5i85MenAyab3D2MqP70+p9maAc/jFnpIVGUAfzlX5pT14RLNxgx +yBG9Wuh1uV6qpH+5jN//RA9zYbLpq8Vtw8yInAQQAQIABgUCVu07IAAKCRAFFhcTs5uvKDoq +A/41R0PaLwpt1tkPe9RS5j1+BOu2ayvAjzaHJkaQEqHDdMekOXbq1bTdWyRUegrg7m0g4JLH +ANBvx6vJW3GAYHzIdmYk89A2PIkJ+rtrHDJutRd1qj/EVS9MFa904VVdJ6xHGo5ChK69Lvmf +un2vVNQvDhcuzeESkvXN7fDHbITXvoicBBABAgAGBQJW7TsjAAoJELiSz4d39e5Tl5cD+gLf +uGfKjd6+icZkG+nJt8uNuSP4KEiPomhEy7RglPtjV285vLmmml3K+Rk5NH+W3F5n7cfAzhhH +IQY24FF+dlqfHQvEv/pDbBQeTTrMsRTBmPS4q/ttodEGoFRyFOsJbZ3Iba0H+JlDokUPAE+G +xLw7tf34TRpz2EykeJCbI5QZiJwEEAECAAYFAlbtOyUACgkQ1MsGp0/jE+EEkwP/QFMYNb57 +Oyj+AneMYUwp2U6bnCHqS5upIICdnWE5TDJExe6ksfv9hC/I79j0avI23fCkSflgFEXYILLu +iuKj9rjFWRFmqUMfMDhkqbUoAe+CAIQI8ZS5EuGTeklYSzEeSsP8tIIPzc2JtgxAL8iIUYHs +CgC3wKNe0TTgblE5QR6InAQQAQIABgUCVu07JwAKCRCZKvquFrhTnrGvBADeBBIwjIPF7yHe +BodMMgJAo6CuShzWlRhuCEspjUdY15pBu42oK5299LlkCTVO8pPLf4/T8A0in7K8MNUvXBlt +DPBqhtxc/Sqd2njQTIk3ZkKdyjWqF8d7laIDwvKqJkxkHFHxoIhVeoQ6mTW0EOgZJG9RwBiq +9fhsxZ4ATp1vPoicBBABAgAGBQJW7TsqAAoJEF+aXWz5oesRFE4EAKErQaQTodRp//pBLlKy +y2PNjnD8Sv7l6M5CDQvMd74n4zR/QKhKfai51C4jU6pyfoLROg3LJETRF9V+HR5DN4BkNFY1 +2uZCUsYgQLT2Bg4xvAt18uqDTNGXURprWFLs9XiBUMNcVGQaR41IB1fTwf7gYyG3e6jqm2aY +WwAmMYYMiJwEEAECAAYFAlbtOy0ACgkQBoVBv1Uzfw6q+wP6A1VPeBAy6klSsf6tX+qNwojC +5wslzBTfA82lIKcdjdvvLqoCrHXrJkLGYf/wttTKJzUh407Ld1rSJbiIf5KJmG57YIQojzn0 +/H4rmsbIGhIvXYZsM0gaqHzUX8NoAV9WqzN86T4lFM1pzA9uQoMhelKzGS7sKpefNFTts9id +rr+InAQQAQIABgUCVu12nQAKCRB3l778inQjqWtAA/9inz6C4PeYPF5tx07uL1OE5PSUxa8r +ZIOYyjWfawFw7TMVrvxsFeADGd46cNvCQHsNNWVEpx0+Oht2fX4EeJp8FcwaAPwr1h8EKLqp +t3CdbdUXtH4EkKV1tP/WkOG2eI15Q/zuIjU478kLU8VDbicv/4OKSmDr2QnEA4I93IiiHIic +BBABAgAGBQJW7XafAAoJEJAYcx2uzvqbAlwD/jVYvV9ZHkcNIkjs5DirLKL1ywDAjM4TOs2m +om3dvByyQBMyoh/3w7t26zn/RN5UxPgaCNsrRIFs+EekMHEY8sEPzj8MHpGtB9QR8IKjqsYQ +OfIqsnmdFgmh0DE0vKUS5ZSJ7d2AI4hui1EccApDJpT0mv9z8NTBnvtC61rHaLIyiJwEEAEC +AAYFAlbtdqEACgkQ8HfCnpCY+uz38gP+K6mqEjTZZytn/uA2B3QjYogvrwtvFE8U6+vaYR0p +DkYDfs27FoKbyVIJiUSvwpCOgE6wCxmgpmIJoD6BciiJ5z6VpDVH640TnG9USUSFzJ+elbtb +ColCUBnsAPSSdPeruXrlQOTArSqv6GQbqzbkR03sMQTpOKPonddB4wp0fOSInAQQAQIABgUC +Vu12owAKCRC4z/U+HD/QDsNXA/sEBAXOkaj0/et6qqzzudAd9rSD2lPJTpGYgs2c7vMsQXL/ +xi0WDS3eQAL3k2zbhYY3d2WL+0iW0ZnEvA67lyyvPzupvN97gvqAsJz0MWWOdB/m0Ki0yxps +ikPPDAF0SO+bssU2MjHj642TgplfxmEOQET2DmrwFwrkcFxgDZKa7IicBBABAgAGBQJW7Xak +AAoJEDmXPBm8tT3QFK4EAM4tSiOTdonu2oRENUgclN/54wEQzJvlml0udVz8X8RBTZgvV5sT +j+oolz+IYsHreWO5Y/kseMrTp+whOBKk+ccPwFxrRRJxHf+RKY0H7fNWDNyX/k5YCV1kWz5u +QXv8guj+qGvYiX2WOsaWHZixiY1PYr/ecU2T2OWTBJ6COFzeiJwEEAECAAYFAlbtdqYACgkQ +pd0+qd6AN4Fm7AQArFStwOzqjxlwV7hRVZoNsy9/nC1h1I3c0dfEdBnqDCJKNa18YBY6S3ve +w3KhZdNiZbeVtTof+8qF48QQg1Zxqd4nzAZgIV95w6gqjlLs2w3Mrx8FgM84SBoCVB3fkOM0 +GffdLCq0YfXkmHcxEGAtmDKG5k6/8vgDFActYGGMo+mInAQQAQIABgUCVu12qAAKCRC7qHpo +PtXsfTwxBACOHLh0FtzJM9ZBXov1AvO3gu7YGHJ9wmLndFeCBj6wQy7IbE1jhDqOMKxU1KKO +qfPb+miyjGiX5eDPGLyZzd0b1IBD2jeQH9CByx0SY40pVGHs8spLUBD0KHG70nQZdWK7ite6 +Wai/WfQ78XrU6STRHYVBymnX5069kwTWR5i71oicBBABAgAGBQJW7XaqAAoJED+J86dcIG3W +eMQEAKmfchsX9yS9tF4+ZwihiZ5+iLE+eFICRsV5FrWrHOI960QROVUwCo7z1CHmpiJ1v8t9 +0dnnWfWbc25QHyf/fpUjUIMae+i3JpBq8UeAJt8dPPNdYBTt3Tf4o9nioqxj8MoPsSDYSTDH +Q9FqE6wbXx9zJxdZ2JZ3q8QX4ha4onvliJwEEAECAAYFAlbtdqwACgkQgvr5ADggbgywkgP/ +UusYv+3xQ7hfFzktCL6zH29ngKTohxbd8pRLy8Dy6FMa8M2xDpM/jP2QQ1a3bYTWx3DSQ3eo +GPJV/6AXIF7uvP4khRcYrLbGMJwkPP4SkzgoCNMhTf47RKLjbJ8E499GaZZ4Kq4RxfpkLTMM +mzIWf2QQvIzHsOrck4aWf0nNtBKInAQQAQIABgUCVu12rQAKCRDZ3gkkGhtdYW51A/4jK5LH +5m1tneDQ29kGVM5TR1VJful3J6hoapBDr2uY16sBv9Jz9kX8hbqlowJL03Wr/K8ydU1VqD/q +miSeSoOH+aTer3TtJPwQSkTKEgWqdXq9FY1vin9rQ+kBHhdDHicbMqVdOUJwMRs2A7dZzGwb +Ty4V8BTbizR11ynjeLwQA4icBBABAgAGBQJW7XavAAoJEEckvV8XTD25+bAEAKTEIEVn/iyA +8eZGZjJlFWEXi5aY2QTmJz7gDr/FllWJspnHPDqnCB/2elhp9LAvxlOABl3XkMkZAu+JHmgg +GnhaCht3oCO9MQsTBBY8lrM2TQV6ctKa2smxnKK6iKQdkrc3wrGf72VpywjvRbVXBKVEEbFD +XlR+4kjuFgBzF25ciJwEEAECAAYFAlbtdrEACgkQaJmacYzXMCtcogP9HyiE5YE6Z6ABxu3y +xuEwu3FApYhyZDpVMTAP9/0hvuc0Jvy3EXUWibyPTaCDE/cEEPjQy7c8mwJDi98ONxfJvgdo +4l2RuC+YVA3UlLkW2KlGqn9vCEj4bZ7NDIc4D2Tm3bEFD0bAWhg5Jkhs2YuK1SfSbUlAWWcB +R5mlYBltLLeInAQQAQIABgUCVu12swAKCRCmOOd9EPl7Lz66BACek9ZfYFhwBK9su+aL3Ftg +cvn1etxTFmKsiUvlF01l4qsbIvH0RieRrwNOOAdH6VGl1Txa+7LQYc6ouhfLeZRRgFYxdVqg +FF+hduZG4hG7a7QAS7aLwrdYZ+tJPSKpD2qRFHyKOv4L7czGH721SLY+EkxgR0EuPv/n/C39 +Z24mQYicBBABAgAGBQJW7Xa0AAoJEAoefMYAKNq4gAMD/3DtH9arNb6h880VUuxgtstUkses +4xDWFa/68NCmG1+GYfADqLJIlx/Hsrx89d3DyapqfOKmCT7PoNVab7c7LfrdmBaSVcsedPwU +7r9MNTqcIWKMrRzHi/RYbMlzz7FT/IDrfwy0aDYa+IhTSFEHFwKjeknRfSgWGs+eYqx2PTXa +iJwEEAECAAYFAlbtdrYACgkQ9wFn5ajRuBGAZwP+NzkGicSGTHg9zD+115nfI5jP/eNmlMMz +HooIMDbBoTJUaKF1+WV+1oVtz2Fgy8TUIYeGSOXtKqguLkzP3nL9lYBssi2nVXGQtkLcQd1U +4QV/9zvRWqyZ35tzSKN7q9p7zgx+138V2xWHeHyZhe52DJBMOV2E+3x4bJsFScB9HaiInAQQ +AQIABgUCVu12uAAKCRCn0aJdzgxB8AroA/46Ll3rmMQtliL8fKpebQCjYt04euxpeUmQY2za +Jp8kmzRAF9ZSigF1SRq1Gc2eTSxFtTH/T9w4ojhSCcK8Lou3PT5pW67xP8IzBkxDX4nFaNSn +LrA6Dlza8+h1l7svq4P5awLzYrv1sK1Dj659TAY+LGXC6q2+bfNOscEKfGeQToicBBABAgAG +BQJW7Xa6AAoJEMpZCmdPBQFBf7oD/3l8ujiBuK4gdrThNw5rrye/MnOeiF1SLy5q7VjsVHMm +CI3l0chof4LUcCasI1F47rCZwg85ixJVi11HR6DaeB8oJrhmW5hXJhnkA0Rog6fg25XRExL1 +WJkv9MRf4nzI2lniqZ9t3tvZEf9plSxVBixSMzYvQs19uPCXve46h7SViJwEEAECAAYFAlbt +drsACgkQKIJdcotkZ9PkVAP/W9iL4FVQeurvdY51ECdfISW8ZtiCt8Ru2c8eemjLHRf5z9qN +1Z7Fid5eWXm4fAyVjhW7maLXmEsiYSN8r2WI4R4YuWnoAEOz0fUTMkmfatH97q7rckSTPkoa +/GlO1tHnPa3TOeAsHDoAfYwzOKQpHeepFv+6AMn/MKvTFxt4zTyInAQQAQIABgUCVu12vQAK +CRCU4Wo84phWXEslBAClruLwboONHUf1PNs9KcIbflUSjJZLD4Ob2bWT0pUNRoYtx7ZMVcCV +VVMn5l6WHzSqSS5PGSoiwhH+5y3tIql/Pej2eLjgKuu/bfBo0SyhFDs7sHf9Ttr9MCUAicqd +UmVmsgtuBNinPSjdC5o3JDws0d/KkmgOMzrhjzAn9UlBDoicBBABAgAGBQJW7Xa/AAoJEBEp +rlOrmHf+pikD/ig/lImEImySQ+QRvzL56/wZiBstcRL4xA+FKIfksvH3HobNx5uB+007Umma +Mpek/ahxzoa/KQj7pm64gp5YClQV6WmQuWe3mHmfDOwDctgOhCckb2kVMKtYJyuanWsouxQG +f2HzvNLg3mymWNws65goF5xtPMmOdtRR4B8lwTaFiJwEEAECAAYFAlbtdsEACgkQ0VPvfAbU +71UjAAQAnWF2k5LrsQ7zZ1uB8D5lk0CTGo8zwJapConxerIRwdDEUiAsdUn/e3UZDzsrIyjz +JOVGdkG/SZ4Hdgqv86D4lsUhP1c7lhOsZ2/PnvNllgPkgaTLYuqt4QOAGEq+Q94hfcREroFn +6kXa+lEU7MQIpQJ+noB2jUNtoFCwsUmoLpqInAQQAQIABgUCVu12wwAKCRA8egsOTfptd/mr +A/9IZbckgrMP/RJsEgNN8C8YSpe+/sk867/On9u+9j6cCOZqv1aQRAC0Rqdtqb5v0toyDBOT +LZiMFdi47MLPK/FtGUfRMfsBOQk9sfHTbbQ6QQviGQhjlcPyLoVdjZ/jaUw8Hj+0QxIvCY8q +4i+P0Yg6Lrqp3CiSsQqYjxUmEaKyD4icBBABAgAGBQJW7XbFAAoJEPkHEXyGuIvpeQoD/1r+ +laBRpnqCT36hYHwUZb6f8u4cxHJhbF1Epid7jsYX7w6ElaEGFS8XqZ7N8aWQ3HkPlY7k91Ay +1upX0TqqrAyZ1+bgKuu2yrlWDhbyGsU9FmPGPCC3sdux12YMpolAOJyaZGJP5p0qnItATizu +Eqj+6oMmr04007x3PQEmJdFsiJwEEAECAAYFAlbtdscACgkQuZlq2JebstUHMQP9Gaqz/bvx +Yo6fPIyEW/ti9hEph+qMs5ANWmkQg/Y53i8s3N2FCv3rmv1gEgeMkPIDKEbd//nIjBhIuR/+ +TNRJ69wwvfuBkTrVqamYkhSbd7V677k8mjNDFkOBeZ+4cD/waAcOkrj4I2cJJ7jXjF7o7fJw +Y/UUaQUSlhqrDsNKrgCInAQQAQIABgUCVu12yQAKCRC5zl1nBYmIK+huA/9RZJ+lke5UJjgy +5XSBcxXh5aEdvIoe7M1iSWg+6qJmyGKrWGNH8yt8RZTesPw1lJKAckUDIjDZ1m8b3NXo0LWD +ukHJH3IWKM6k7XY+ZwhCb1vRFtP+C48xEV+WL+WwE1ljzoIQJYNnb2FJwOt+0p5khpIctrKo +btDim8dFFgFoEIicBBABAgAGBQJW7XbLAAoJEHzmZcrmdUovDIsD/1cuZCunZMaFW9OMXNZn +nDM6/a20imSZz7c8ezdLsSKTVKwJPM5Gs8ppKrElAUFuHNXHgAdpJxk+wsnRFOLpVbaDVlKF +pABWuuH1Ej+gzpZJcNsDd7w/9Jw+X+GURv3Sx/E2o+c57RW5p1FSS6VkwYceiJm8XlSlz3IO +G2yTWl4ziJwEEAECAAYFAlbtds0ACgkQ5oAZih+cFNZzwAP+MndYS/M8fH48pr4TVUOnLadE +7J4xGRJp0OUppV6JvLMT+LJNRvgWKIpS1loXi6ZhU1NP+QJY2skpKKHrY3bSYuQ12VG1BOt/ +yiUm6f1PaXIwjBswXmQN1mQyFobKIZ7SUEoMrfen8A4coHm0+hBUC43Q9HPo/lIRghZAC962 +0/CInAQQAQIABgUCVu12zwAKCRAix89b8+RKb+cMBACmxqTvr/Yyp/espe+FTtk7ul69LP2m +oRFjiJiB2bF8Y7tk9XhZ9gFfJ6CQiobaYX2YcEdd3UDTe9I3M5YOLZ0CKET42wHazebF7Jxx +xynt0JQcH4hvrCxVxyGX1IfM6fq/XNfQ8BIvx2W61ubqGrg/Zvit5HCtiBz8gFgv/YppF4ic +BBABAgAGBQJW7XbQAAoJEEjm8iwShNvIuxQEALWi/05Nq/si2Akm2xUA19GqhQFN5i81zvVq +qYik6o6ski1CuKmohugX/cozeqnWUo/U/n03r0AIf9g02KbhC9lri+AgxieTVzv0J56A4fjm +zJc73JBd2xeJXfjzTV+Gj/jEmVYaaMIStbSATC/EYGC4OreZyMueRVk7pL44oLZgiJwEEAEC +AAYFAlbtdtIACgkQbtv8A7hWVZJKPQP6A9Iwl5GGqb6lKLd2vmTvd48HigPilM+TnHGVMiIz +FVmLjTZEfsZre88n+O2uudnPkUNYrv5kGhLp+Z12hiazhdbdc8cvADqIyS55bNwwvur0DeJX +bOgLDXT2As3+kOP78zHFMyZDoH0eo/9rzS9szIdXDl+DUedIraoKvqZtYUiInAQQAQIABgUC +Vu121AAKCRD2rQQAGD6pvhfDBACY9pVZfrip87vVAW6PAkt0OtF+Qx5cAcuLzwwT/xTNL6FM +h7YYqTw8pJurq2hrbPJal8B1ynZuyT2RdtOOJcEZET90K9Cypn3y3q8tFTnjoP+lvvJF2uU7 +Jqovy8Q2MDsphJYb79KGC/pXxCN3UzYKU0xiBq4ZqUQHuEGeA38xLoicBBABAgAGBQJW7XbW +AAoJEKVthotT+a+X+cgEAIos/tN/RpomXEbhXZqI7E2SAg9scvnHvyjFvQOoPjyhRkgHIvhS +nITz0UX47s6SfjQ7trkbtvf1vio4L14a9vrb7Cv6fwaSZJYWQXQxezIlUR7WQVVl9vfLwHh5 +lR+5NnQtXQofB75uwYKAVcu7BcJVovn4bICUwEwm4fJ+Nk/CiJwEEAECAAYFAlbtdtgACgkQ +YgHo5Bs3UKGgqwQAze8VeolDJA4QmDBqRP5idzxJ2hj+Xk6emmJM0B9D6xK8jk+FRR1yG4n2 +DwlqhvleOgKxZoYKGSEIPv8uCMbXcdJ6GuxLCw4x6KwdIB2g6bI0/7b0TS4UsmmNaNFOLuTy +J27/xtFbJX5oiK3y+vyQN2MTT848qPlGvmuzIo15+rWInAQQAQIABgUCVu122gAKCRAfp7XU +Y518GDtdA/9BbkWu1E/sObh5bLyD3og5HBQd8DZR1qLJy8XFfhZqZmMrFBfPOXoEieLw1T2I +0H3o2MhDd6701U/CUPnepop9EVKZkBoRz3ozErxe4ZgJqcZHirn5+TMPbcA0AdALNfOZaRsa +yLBtuSLvabBixCYvHG6IlKqA2bY9Xiai19S2D4icBBABAgAGBQJW7XbcAAoJENlJyGS4hVz1 +a+sD/0VzH5f9oKWQoAUvZqn61pDTUxXSOO2jb6UrBgkRxd95JPfneU8y0g+FtZeJkmCB5209 +RqRGzIUu7k7Jqvf7iW50P7yJADCqlrMYLwUlfOMYlzNXlKDw/qV0tvXGPVZ+x3nUIxsQp1gc +IhAyOW9C20oamaOdDkQmQsVJ1J9OJv4ciJwEEAECAAYFAlbtdt4ACgkQnGoqeEONiThn0wP9 +HaVr6CBdjlhB8kXdlz5dpngG/gG+sWdWxyUT4CeUU4gydLFl+3oY7Pm0MMtRl2jGDkoOHkGM +Wk7JzzWdwoVoj7q86/XRDc9OyDpUG7g+5jqYcCibCn24iy5U9NuVDQ08z/0mOhBqdu3T8UYW +/g2MYVacm9hqzzbM7eYM+1zKHV+InAQQAQIABgUCVu124AAKCRAbfrcNvf57K740A/9haGHz +OyQG/mebYRqK81vHk+eoWgSVcKQlAOt/F5Tv+G/WPJ3ujFuGjhUcpNSSFMWbDkz4ES786TY3 +8On2k8xwPaNdx05JeAUQr1KxXy+SPg4GQ2dsZrpU0oy0Ur/y6fAevq/6mvY36BTa8DrIfjgY +5vYOQ3CYr1IYEV4q0FVC7YicBBABAgAGBQJW7XbiAAoJECfya3GInzkCwlMD/0Y1MEKjWTRI +5AcE9k0lEDFQug4PkmjPQwGY2tf8vi/OLpbrnRelb1+v/Ho7jAJeGgOFXRuvs9JdGT6V2Bho +rPxo9Vr7Zt0DyCoY3y/pKM2YVAVqN/Q1+ARfHmfkaHK3lh6qXwReFnjD6gpxedOdzvF2JHQx +Di867vuHTvYZKbKiiJwEEAECAAYFAlbtduMACgkQFxt1Sv1H3HR7lAP/fKHTs+u+Qxmxq8Ih +qs7a8UGWf2Ton6zeauDvTcQr0Ev1FPIVHNJOAq0/v71f5jQnqGNE2TWQUT/tneS+mB2VnyTk +OkPytUmnkHTEeHgcvJ7vymextPvBISVRCLbruQem29HerFY1t0t3bAj+KiaspPdw3qJUJ2+v +2WLKltBSgBOInAQQAQIABgUCVu125QAKCRAmOMZH/rMXUU30A/9KRQCCR53LxwLDhfX+LUdC +xMDTg8qbT3NNSJBcoEscCgM3xcJ7VdzqBx27B2EOl53LN9LMRIIB0Ru5m1E73CvtDsWuUz3C +0G3u+gMJ5YTU5Gtd/OyPqGLLHY9XJ10qBXWmQpAH2chsvF1pk1NkoHiiavhZlxugDRW2IbbI +wUWzZoicBBABAgAGBQJW7XbnAAoJEIUkQ3JsAueHSrUD/0XfDraA2lWWImsuoML2HozOI4jr +oLh9eBSH52poyEEuRp/jcGea4ukL6OYjeqSFA12ZRqroItffsg4hLHhL6jEI8pOxM5tsHFD4 +Jp9bHmwQbxWyjfyPvYQbdav3fefIaqlWA8DluwoRW4Uht1nphSE0Z7/aShdANxH1VUf/vTvL +iJwEEAECAAYFAlbtdukACgkQtz5deCppvHXoqQP+KgeASyCGIWxrDM/aK2M9hr19Rsvf17FB +A4J942muBuec6FHWTx9+oobt65f0pbbAidC6QSYID9Ii2CVgHpLXh3x2B+bU2tDqCGyY7k49 +bsXn+y3qQIBvsE80dxHgO2uSzaE8tfP7vdoDPg8r8Nqrtv5dpseL5OYTZYNUAmwzL3eInAQQ +AQIABgUCVu126wAKCRBrrH81DeW+TFqkBACTLY/5P0arMco4CDDok5T+odk/Ybd2Upfmq/0K +YaHvxwKQWfA8TapYt5IidAvKMDkCA5fCy6ql9aCFVc7NdbldtHBp5lGJ6KqnJncFlx1UQUUN +ItlFS8X7gAzoif9tfqjW4v+KRy2lwWLMRS73cdBuifY8//y869LPpgAtl1UOv4icBBABAgAG +BQJW7XbtAAoJECtPKXnx+DrNCpwD/3Lrpuk2pTRn0bwgH7fa9hP9+OiD9YK/dzVMNP6crls8 +NDY2sWHu+dnDrCuQEXBVAwgyk3t59Dz89JJgMlu1mQCVLcRJb0w+oq8hYZYB/SCmNdm+5gRd +XEDt4AjKwNgBJGKGaEljbg6N0fiuN+NgP3PSBM2OgVdF6CCF8ypYJUvXiJwEEAECAAYFAlbt +du4ACgkQNx3mb4LHmJyCLwP+NA3iqXrkeAg4tImXmieBQCsqWpJXU8AC7b/RCGoITSbq6SVq +Ilv0T9pCMX/O03SMvutamNmhDqAkKpp2LQRNjmTAKVCLUMwE8y4SCRZXROp61Z9Wl9jxkNln +CxBr6oQ68gorxyTmUs5Q4Roia4vln0RxbBPpoInu2XBvk090ZdCInAQQAQIABgUCVu128AAK +CRDWBnRWzRxIGO6LA/0SotG4o2Eds5qnEVB4Jp57C/ScF6qesx3TNjAf4gpEwup+Itkmqt97 +gNcrP5xgKha9ul0DzOgxywmTIBN47WzFRBVHm/7i5and14wTbg+12tmPVTQGpRZv1cjfjCgJ +Ye8b8oEdeUKmEpRG7WYbQsJVCbL5iasf9792MBgzgUU3jYicBBABAgAGBQJW7XbyAAoJEGK1 +fMAYleiTOB8D/A3L85Khp0jmYpK70wx1zOgcJpGlC05SE2sFzgwueW1TAw0U86ktY+q7oUBf +eShEkjqG0dnSpqXIivuWkx5ZdZ8/roMjb2vQvGNf9rXVmDBtVfGF54LuqG8ib2uNgQbAQw7n +ngobNFM+2hVT5Apd5tdRquvH/+HKxc87ik2UMT0ciJwEEAECAAYFAlbtdvQACgkQ82Qsm1RJ +UPiN5wP9EgVtvsvD+Q7a3GE0vNrV1CVL9PfSgHEun80c3RBxx/UD6+ruQgY5YCzKO1880Bbs +hytSIwgqR1UcDd8xhBeFcNOtnYIJaKJbm/OWMebvxAFm7QV9LioeBEXjcCuO0vBq2HRs1ed0 +39qMbG5xwx/fKfw0XfLX0plt07C+eB7vRyKInAQQAQIABgUCVu129gAKCRBf4W0LnMkIJXe/ +A/90CrLCRmMNfJlSkOf/FLsph4JFr0I2Y5MgYmPkg2/SS4hSSAIufVgPGIac0o90S0Ld0hIg +jOlQMe9DY/bYWB2/aj8DvUM/zTZaJrpHgCpYjdl9mGY7SlLztbJ2Fh8Z4zF2d0ic7/1JiW6a +I5EStkE0gLuKfFMCK4fEzLwA50NnYYicBBABAgAGBQJW7Xb4AAoJEMUJ6HZ1Bq+0NwQD/RBy +JQ2UgCLjKcc9ZNjHJMkCf4sQSUiUOIK/HXlpmrGkob4NMX3/YygS+UgTsIlRoQqaXPwnOmmh +zsmnI1f8iQScVKPzF9420lxJKZWfzO1yDhW765/vg19LDhKgmEk0GscabCSsezChigDoAbIS +IzVEZhWW9sAI8Wqz/Tzr5S4siJwEEAECAAYFAlbtdvoACgkQYJjEjAfSWQty0gP+JyvUY0o9 +4wF0Z5iHn8tVVlxBLORArH1t/UWCquhuFqfJpSHoOYgwAwie/NeHBsbV5hmgPkKqrTn6+wx/ +48iWnrEvFR+O/ZK/WI2703Oq264PdLs/e/azJNZb8UUQ+clucxsJUM9V2g6ookFYR7iTjfXj +Jj2TVrywzJ+X/HDxW5KInAQQAQIABgUCVu12/AAKCRD4g8JFaZ/N+xZyA/94isnzA374JEFd +TIJwreCavGsknvopKiBTLYU663FQoDDJK6fkfwDHxhGckCbu38Paa8fVi2B/H91saCvXXMGp +JcGMl+IwkY9CYEFCDX/434Vn/k2rZ0wWwNgXGPmsPIOKHKuNmEXrqw2mkuRTE155CDGxFP+r +IdkWPDnIirbyeoicBBABAgAGBQJW7Xb+AAoJELlRvMS6Ww7I3bUD/RgosxIzkZ3SAbK9+Tvs +ySc7UVWtuKKlZ5eHGEiOz3u6KWE2GceIDZ881YdojEWeSDnhDBdXch76NLIqgejiv7g65GLH +5FnPygzXpwpx8WtKD/cfO7X3g3iwvEYPGx0p9LDvs5bphYlWHI1kG8AtSfgedHMEJFujmk2V +KlOGuCQOiJwEEAECAAYFAlbtdv8ACgkQSWrEZldHBHQoGwP/QO3Zx+gHTg7xMLBgnOq9W9+r +sRiSBiVfRJGhdvJSnM4RfNLVk1aXD8fZEqnuzmAPceVgLOALqK1KVdtndfJvLcyMFwDW+0yi +u9xxBg0NW2u/FW5+aoGNNFG1ES17eeOb+mX3yd8SFlttTOypGWapdCfXSMw+agCD9K4z02T0 +IUKInAQQAQIABgUCVu13AQAKCRCYszxxdKKdviWYBACSX3OTQgc3fUtK1jw+qVSY6k82CwX4 +E25+KEiQ3guGL4l4WpderBmyu9H4e+5K8VdTbxJkOoMhO0NiheJCzBSTzZZnr+jth2SuGqdO +XRXUocrRFCYVGMmsGaemXDbXDnUI1u0H4d0EpPRteNs+6Ptr0ARCSazTZT8hMNseWVaXoYic +BBABAgAGBQJW7XcDAAoJEBzYEGQeQFxkv8ED/A1UtQU+1cYMNBB3zQzxCfm6fSE4F3nYAbMk +GM9pyZfonve98gfFancJJInEq0QX3CV1reunyYu7WaHL65zRK8+iIq+KjuH9Grp93xfUhv0u +dmRGjhZtcI9WGxueNUZqE/gPUyuBDeNr2o++boWgK5OtObXPnruJDiQMvSttCr9eiJwEEAEC +AAYFAlbtdwUACgkQ0sLsfQvzly9/IAQAn7ODrDxFkUWkdpZrVLxDKkCUNNOHOuOgUld67F5c +7/C2fs0td5CK6l474qy5G7Y00LZMMDXM14QdjDjwXHmg74xbJg6b0lUfL1PH6+ELbLWDZQqM +IptRQ9ofrseFamv2P2kDXPUmrhaofs25mGzkW+v/hHSHUN1m8TCmsy+YicmInAQQAQIABgUC +Vu13BwAKCRCYiaF19Zz0DSQtBACEYtoZqjzXwcIUaRqv3xlo1HvfOeGIuj8tTaE92VVvPs4q +/FiZ1su4kl+N5mgXsQItACcjGesETSC+nbJjDAM4U6uT9m9zzLdjlLs9UoNsQQcNZBi8O56/ +cFOcC7Cc89hCDzbu8BnGoZxVUseo1cOh8B2CGr3Shd+CyC2SOiBdNoicBBABAgAGBQJW7XcJ +AAoJEHm/TAwBQsNgqmQD/iaGjv2Zq6wdxz+W2rUG4f0oHpdG3QpVFQp4IfM3yKMW28MBMdZl +K2E9DdcUO0NnJJuOf+AmQsfUs0oPk/BUD7H2gt1p5tZF+S9pby4DlYsXrjFEaIGgpUgAe2+f +p9Os77It7NyPYhjWsqFBg73gR9Qdj9EekVQEylX5HmNyTdaRiJwEEAECAAYFAlbtdwsACgkQ +ZKbqA1lVahxXZQP+J6T3G/T1aoFq/o9Op0Y81krCSR/bdULfett74nZiAMaLm0d2DYg0Oz/w +a4dKN+G6oc5wu5iT3a8ViNlWoLRsjlLtaGQGs+JrqbgK53P0/Um1jMcODjAvd87fcSMV1CF4 +XMYB5iRG5GZ6YYbS1BWm6C8Ck0zpUhD9edP2eYjty1OInAQQAQIABgUCVu13DQAKCRBG2+JH +Zh9UvUabA/kB3HcL4leB8peOo4G9DxJa3ppzBcoL2DYR63FY7sB3/zpby7TUSXil5OUCrPY4 +msRXJQNzV7r4Y+z4v8SsRGJxmKn9J9fLznxW/xPfrT91kH2w5GFqRZat1XCCufK7fKyjvmjq +SKYVKFrO2btPs1S74gFhv+ieL++44lv3QIRUYIicBBABAgAGBQJW7XcPAAoJEIIF2POoqnbg +0FkD/2DzhnNIOhBF1pRI/+n4CpeBrMS4emsHe+2xfo0JKMqqGMApn+sQFtObmk9VV7EMelA6 +0/BxjXa+x6+MpsYdG08kZcOdsWq068XotVtoHA7PbmyyMqOgjYsKjenDhdO5AnnAJL6Pt1Jt +DnlkBoy1Ki8NAAHZuaXQGd6+kFam4ACMiJwEEAECAAYFAlbtdxIACgkQqntIDnPAARZn8AP9 +G23ubGYKPkaervTeL/z49WvvBA1j/PdiYNjmLOdZGZK5Gd3ciBP7ZK0P/7DLiwi+FFP4VwxW +eTzzy+d7WjPxhoQb0QKMh8A3X2KUF59sze/cot8xXEnNnaCFZlq5lmOhnho9uYoULJRyrvaW +P1wGHREk9bxALTyTB8sawiKJCCqInAQQAQIABgUCVu13FAAKCRC5tcdmaTsEdlbuA/9Doqg6 +wXCfPyJijih9h8HdJulHGiJbLWrRyu/UytgsoqoYDtyyFcXS6pNelIbw2Ewb67s5Bd0Z1AXr +AsAVXkZg8AZ3gID0nslsPQ+zjffKJlqsijyK+Lcbt8PJWDMDw8GeKgMPR6EOIP/t+qb+mbUk +5/2FDuevfp0p6DFvIt7o5YicBBABAgAGBQJW7XcWAAoJEBL0lw88S4asUAkEAJVTvmKQkmxI +9vHzj5Yzn/6fxRd4kHf27Cyftxg6iOXtiVzeU3FVrsCHhlDSFj7vX9pAHQtmtXzOBc04Y/o+ +Am3j+THJDsbL0jswQMVo/bFh2KooYZPIbXGd5qxFBY93LHK4FMV/So0yxYP4yJGRTVthQW6C +BsV1X59W/Q6OwipfiJwEEAECAAYFAlbtdxgACgkQhOrOx09i6oiPxgQAiqMzX3yvW5oLZUvf +yes1taVSEe9BY2TSW9kVuOXVbGkMTF9YHefG4EqgzUTPEeiKqujFBtLkObnxGfW7NjT8oO7y +CG8fs3WT9N5RdRqlcInxbGO4LFm0EwvAJ9HzGnIzaZd+5orLYaAoTXqCz5PIj1WW1hOwwIxl +GpbvBmfvFSiInAQQAQIABgUCVu13GgAKCRBN2mmvrz7uv6qIBADNR4WoyJ63k5A3sMX9p+pC +cnUeaU3ZzXYDrU0q/i0SjeL2oH7Ztl9vbWw2DOjbRU4QYOGSUaWV040Y7LR3d+phmEH67ZJf +dMuD/M4XAeqiI8f68arTGaFKukQCMBfzuyxz9r82CpZlEPQooLQfwT5LfXYuyhH7pL5YGLML +hzBaRoicBBABAgAGBQJW7XccAAoJEFg6Bbb6pRWOgYsEAOEjVTkhgc8iU8AqFYNA9qibYpVD +qypqVli04KGaowo6gs6GhPV/Lv0it2qewcM7C4x7eKinspzajjON6s1oOgCDA9ZH9Q/NcT57 +0jxr32cLDC1YND3wV4dR1NSIi9NFLU5bMW91ME1oavcdqzMxeJ1tCANAuysNIcHGyiG5I9kC +iJwEEAECAAYFAlbtdx4ACgkQfF9O+fPqQ9jdggQAs/OF73+/ZGpT7Wal62frO27rZWPq7eW4 +F9l0m9lZMGJsrHnS3g5y9SQro6Bn2B2Plgy6KJ6qhRmPt0y8RkVrZpjxiGKeMgW2W3y/rKp1 +hQOC5PEYmJkA67yX6SY0Iv6FyBsLsv0fZnysZzbzyy/cPAFN/TqTyyajrGRzJGPmp4mInAQQ +AQIABgUCVu13IAAKCRBI4Wp4GI7vFfa2A/9i11RB3veOdqDYrMc02PiMWuiCV9k+a6k2IfAH +dJ0gwoetHh1Hh9+i7G2+nkqbziwyAOOnNBGQrs7VySsBY8GccJ+YCk7YVTvVacy/CVMNKEIC +a6s0BKLkDca0OXwaP9u31XI9rhbdAPEKpzXw0i7cgASX7rINbIMs8gJVcCwzmIicBBABAgAG +BQJW7XciAAoJEBVZAKliuGXhADkD/14B8IP5M+Ab9oALLE0qQMS9+qdSDGuA0WzqRQ744XWM ++uaN7W8rzeZZd07av+IPbxqwuQMqJqjrkLXo6Q/Mnr5TiIz9RvsI2Z23QBEuTiEQ24XXEKD/ +yVlRI+9oq4vhV7ly69YUoYX3YqXga6lqZd26CA+wSPKmKN57UFD1FFyZiJwEEAECAAYFAlbt +dyQACgkQ5oik7bB6ZAKdowP+P7SB27lSzPNYubdzG4MSIbTuEgJdDUsTVogF2x9+VbZ0itG0 +uSMxkcdRcUulfFwn8XlRxWU9c/xMEX3zvJ/IaSjjSthf1h026lOowFY9iAwcC4O0mjR2gfM9 +FReLikjCUvNIXsfjnDmGF1esuoS20y4P70wlUdBOXfgaIDA9LpaInAQQAQIABgUCVu13JgAK +CRD26ps5wz5spWd4A/9mUBe/lD338I0Xc+OJRMwz/e/pxXqoGnKdKDfmFGBXuqD3rb6JNIo7 +h3IDBqVAi5vOjL+oVGxXTS2ZEyUGLoqDXBx31LVNx8+JHdGDqBUr773M1SOPWnvaT850tXnH +D59haUav9IGe1WsDuF4i1gt1SLnsznhy/noXFV9RXdwhF4icBBABAgAGBQJW7XcoAAoJEP0s +iZB4H6yvLlID/3VMLXh1JLLyYTahooJy4m5Uy7YAihKZW83+5d1Loy8JatpOfFjAOxB2ZARp +HCXhK3Olm6h/L8cOgbsMO8OrUDx9JP42oxUwMIMbBDHL3vNG9myqwNiVbpedO/r3EymomgH3 +JVPfQ5ho5V7Zn9aiXytNVYl2VFATfI6NW6h5HfDNiJwEEAECAAYFAlbtdyoACgkQOXnhpSvC +nbXE8QP/efMa8ANek6ztOuRrhTMhdtMCGk2TTSJe0MOQzikyFTR24tI81KWyYAU8lpwdF0jz +a8asesO4pfRUmVe/MvSh8OERTXVU4c17LzoRvMuEC5dB/LEpn/wiW/xq1e0Td4xbRuA0QByt +MWfNfmgbD2vZZiIny3CCL8UOsIgni/mdnq+InAQQAQIABgUCVu13LAAKCRC8hr0E05C2vfWR +BACJaSZ3zgN7zPt8+yx8u9ncc4WmMxXvZf/PMC0S2GjZcxJdxQjZ/8C3533EinBvyvyYyOze +/EGa85ecRE6bUFXJSVzZrEUkU5hxnIRn7o/66TmBDxjhiLSmr+DLba3CVeQvzOIHiVzMamDd +PVehCVzHHiM7aCVrF/5SBYwWMB02/4icBBABAgAGBQJW7XcuAAoJEKHks42mNWsoET4D/Atr +Lhjos6ANdOG3X53oQpjb5gDPMx5GWWjACWQzE6T2tf6Kfrc/51pVL4BnaX/ozFs0b+5QsxkM +Rp4y7wtWq/zYcFS6bIMzWXGmSFr6zYshiicnJwuuU0tPbIsrU1fOtyK3vt/8Gv1u0tvFg7X6 +AyIJ1XV6+vO98xHobFC3dNALiJwEEAECAAYFAlbtdy8ACgkQCdsoLaDIEuR1VgQAyDytclGK +mOLZurGNDXGvT0ODhhH+d2jQVAFO7CNvZBD9KiN+Rq8O7bQjyR5LLVvbUI3ocxTkQITdnRxf +fJ0gUhm3kP7h1kU6/ach/JH43ItwUIX4IhzPn2sHUk8gkDT/fL/r+v8/lQRCGXQgK21ZcFOK +So5ZZour4/lcmoXAcKqInAQQAQIABgUCVu13MgAKCRC68QkkD6V5QNeUBACouNHPYB+Wt+8D +8UH9Vx5+3Lpp9+DfHQtmtQkSvdew+m8AzOL96XvkbxZgQVZU3+i2/CgoDzP4EM9LxEdZDUZo +Yuvt5nbvXpH5fRH1vUiRWQnUSHjmDupDOb6tGBrGFrCHTr5MN96NUylT4s9ekuUy6W+IIMyH +JuyEwUI0g0o4I4icBBABAgAGBQJW7Xc0AAoJEMsA//NLaPBiGCIEAINyT1mo8QhOBYyB49xI +V4b5eqPgGx9jCQe/AG6S9KRPJ2B5yVFmcRXu7vuP4be9yZvX51+qSRNXWeB1Eu0DoBCGO5X9 +/g75egNOVBotUVlJoUsJcO+49jY9wRYQgqKnWS5utgIVUVO6SV7WaONv9hHrZPg9/l+7znRW +9/UTMoVGiJwEEAECAAYFAlbtdzYACgkQLjMVFpZGVttcSQP/eCUDUaeSA0TkNDKLcIAaM7K2 +yNifNL3RWq4accOKasUDcEyj99AQmSLTzR8W3MGXhin78d4+40f62phK1tt5bRK9ptLXP7Ql +lYaD8O+XW+tKyTYjMRnQnFy7WoBHnTC8roA3VDi5hYAwuo/+tnP4aSiNNyCXa/XwYlXlOInK +HRWInAQQAQIABgUCVu13OAAKCRAyQsv5L1HwOSzzA/9BwjqjdUF0JClE4EvS70Q7vaXGI7Rx +wEV5CzMtfu5wWMtE//Pu0QqpXf/2YTsuWWDgX9A1/8iFCc05K8Vt+ubVZjcCTGD+AtGh7QPX +oCnujsCEujinDJmjtuOkSg+TpK9dKapplS9fzzZyYMmXRTHMZxbXdpF6Khjh3P8E159SC4ic +BBABAgAGBQJW7Xc5AAoJEK4br62svoMw3lkD/R1aDV/iUJwpYSng+0fD26b2Yr8l0Yrhfen5 +4YYCU4AXig/HZZo4vpBxeCG7zyLUnPiAKOutfMwopfcstR6BSbOK7nQTajqfGmOqZiq8lFjE +jG11FsQOzFg1Fj3FClx+o52fjJnbVOjCpzHYCVOLYWSJ6eh9zV3sKdsMi9/bT8wZiJwEEAEC +AAYFAlbtdzsACgkQkVOtxhuQg85BWgP9GzlZlNTPnDBeoZQWVaUC8E6f3QyX+ww/bna0F1Tm +aD021KMrZmFNL3ifPTwv/v/XP4lP6ywXodt7Yhneu3YWDNyRambG7qVeFKyouVOww7qEtl9R +G4k31LUvKJnuR9iWGc2iZ2E/XoR9swK0y7t5LKdF1F3X6p4xcqBKKMQhmV6InAQQAQIABgUC +Vu13PQAKCRD1nu+AqIGSsxjGA/wOkSM1/QObfQcA9S7kaa/19xuX4DPu6HJNlOpWyXG0PZNN +XfSydKvnMVyHlRk8ee9UOkGcQLsYQrT0/f6mJb/QzE2LYC4DpzY5cOsvfISFFoFiL04IwlBY +XV6yurKGPtB2jP9TXfqlVv+UcZXa4BuzzZ+klNuGO7m56Yiq4Th1dIicBBABAgAGBQJW7Xc/ +AAoJEPW5TYiYksgycXED+gO5OjT5qF4K01IuYv889v+yU789SqZemMUu++9KjKj78L7tEl8/ +ukuXqFGle/SRklD8KSPwrVNpQHxyQk9eQ6B2vpcy58tQ3z8ZBQDPVI/PcJxtFVKs1S6KSpHh +OTxNlLjtjuR47Bx/WFYsnF3I9jXlBqrb79kbaslUc4NTwVmFiJwEEAECAAYFAlbtd0EACgkQ +hBXJQZ6fnqfgXwP/VESGmmHddHLzxSFr3yrR7lxLRtTR2OQ1YFxMawidbROiZfmhRS63BS1a +jaip9vARu8aYw1mJUQOWRT/mAUsOOD+x9tjcJg+3ddj3+RZmeQhtZfJzbwXTkqGYTcHVnQoN +y/6fT2vM9RrjO7nYkda1OCTcu6KgjJEhGKJw64kqNpiInAQQAQIABgUCVu13QwAKCRBJJbdH +mjbceRShA/49PvzaJzn7eRfazrdASvVJOcH8UxHKrir6uLRgbjBmXHy8oHMWQ6Sf65cL3sT1 +y2hD0Aro3CPB8ucUEY/8mnXP7BNaRYDnS54K2+j/6Xj1ggTCMPUXrcCibXQov418bSUPWzaV +oZQz0qmv+FH+psvOU2/HdiGQDDode7n6le7Q/YicBBABAgAGBQJW7XdFAAoJEP5SVRxf6z0p +D7MD/3JC1Dj7fV6HlAjB1OjBt1bNyLdRLxaZQKJVZVsyQqJ8rrdkir/qKmaQ/wj6xbhWguOg +CMfFB/YP6x09iGVGb1MDS49vm/2nTQRLbp4Ojj6X5eXeXhveBrkqJbe8fjW4ebJdEh+3WMsM +m9znXR0VcUsNBA40v0flMkeCiDttEbQQiJwEEAECAAYFAlbtd0cACgkQFFiXCT4zG3TDmgP8 +C6Dtm1J6ofpbJT29sw0c6u6iRbxCVjKkzZ2fiMwpYPi/FUqhojt+QUM+OIuH3xRR9SuhOUbN +E7hhPWBsr8MPvM/cx7wLJzoBVDdKOosjA1zmR/hZW2Npqg9cVHL4ZmVnZiXiB6zBVGK7yxep +yl8h07bf95cvRrS3Ch96zsN5a0qInAQQAQIABgUCVu13SQAKCRCOrUy35RtRTfPeBADpcy5S +oKN9lVQbIqTxKv3YTvrR3FoaUg3aUtltPRDEiylROsHr1p5vFSTAf22PkcAttZytRFa5+TtJ +eZprBdbnbhq9yYX12re/ZsU1QMmXlI8Y1dR9sGC65B+iQS0UuNU1QN2aovj4mdKT9+A9n4ma +E6qtyx3UHUpanly4zz1UGYicBBABAgAGBQJW7XdLAAoJENTwHvqvDYwjOF8D/RI3DGFxx6+b +cBQj527Ti/JeMQlRXGNkXUCcHq/m2ASE4tCPb5MBfUw57y7C8Cm0oT38qsL0NlzqSf8TtQ1F +fbYUaVzUKpXOWY2nioZnYq3fpC7YkH3HB+hYZgycz9CrPkxV9mNbdfZUQLzNSJKkmOhpQiX2 +hmhzaboJPGVMUM5PiJwEEAECAAYFAlbtd00ACgkQq1xatTzGEvo/GAP/f8RaISDp8v0e5Xcl +k+5M50usU1u1eUQ70gvvesyKz8w9XeS5lJfL0lTtVv/pEsGBWQ/0auKVFkUnxCCLsvrANSdQ +NW8r9wT+HOMYKuJy506RfhccxyUoPQy1mlzIz754N3QHHcTwEYdjMvDZyblbeaAqebfFQaWz +XAd54n6Pp/iInAQQAQIABgUCVu13TwAKCRBXkR+bhiFJfeoUA/4xJpEF0WcZGQ9ifD/RXrwf +qoFLg2Q1j5xQBr2Ws9mUiOFqBTqaefZOfwJX1ZYfLLrIcPoBRHDm4mz6EF0jAiDNIRJ7fziE +bpYk7Javf9i/RvcJW0InY6kOYuuIMzxbA/h3xfoLKS06QZZTF4OXrB0tUPfi1wabB195I7mK +vN4At4icBBABAgAGBQJW7XdRAAoJEMS2UnvaTRautyUD/2ewhXVz3Bhnqz1l29kzxhYMGZ2H +q4C+eZq+reyMMwz+ykuHGviPzXKnmeop2+LDfY3oD/8OlniAAmb/n9IcsUzSqkakPcXhtiJr +98UZi1ZDSiKAW3/K/pbnq8BKHz7ZaT6VODebtIr83RYV+teW5xCkDmMYD/DJfiR9eIo4RJdP +iJwEEAECAAYFAlbtd1MACgkQlKaen/XwVSrkhgP/ZyjSq5GJshsXtKPwLJPG2mgAljmwwP1E +g6oV9WiSB+eOHDHJ1sV9/HRe1xUB/SceQEquIjGM0/qXezivgBtbkRPB727HL0Pa21ki4gJj +HbHybBSWvBTM0lIPyFzzvYM21GrkxvDEf6baAweA3MPtkawUQtVtXnnvbhGryL6O0iGInAQQ +AQIABgUCVu13VQAKCRDjdUlGs1XFCGwWA/4i1AsUHSfMHfkxLCd5yCQmHGR3IKP6VyJTPAo/ +d60HvvXvtrc3ybT+vr02GvEaEChp4CqhNOubCZB7P/Fce+cI4XQGY2NH3qRCa0AAc3DRknB7 +otFQwrLp9WuJPKYhl27lSQbZ4Yh9VEcdK9uwcNvxS312ya1aSioixpV6f5ob3YicBBABAgAG +BQJW7XdXAAoJEMPUu1TUuJT32/cEAI6QbhGoyY8ZtGaS4Aw980vSruqEsRWGSAn+86Y+H+zX +AiIzXmcWUkkuWYY0k56Hf4yopZ/igpQ+LwjGCTi8Umctzk9DEmNqdn6VJWNv3XSpaPfR+a4g +1mzsZJxQ6UeQQ9jmNWcVcavry7GU7C9IdWEWRo/S3KYtfOo9LwkA00FKiJwEEAECAAYFAlbt +d1kACgkQwN8s6Tra15cnhwQArs8nUIFJ35L5xnaVKIvnP89a17zl0KrzcFSu/fpQZoOc2g/A +SkEcDEm9+mWia3mtrUD+l8owq2blA4vRbGVJ4SpxOxk4gj8jUa8036tymyW/rIFcKeXjS+XN +M1mFFoqVCuzViXQzl7XLvipkSqQwW3TAfmOArP0ColCupdPsdVWInAQQAQIABgUCVu13WwAK +CRDGaGs6xPm+JTGOA/9fOTybdWZbY16Ls0JsyZkD2vzDiGz6jovLp8/gtfRZe8g9F1SPvup0 +psIm/6jm5Kmdw7Nly0qp2K05IXP4FhhbVEo1TXdDlNPYm9l8/EXG2wo146Ss7WfdsAWvko/T +8d+QUSKJZXvcjDP7+JR5stCzEVTez/IJ/czM3KB3s9Jia4icBBABAgAGBQJW7XddAAoJEG3C +Tdr6nD9odc8D/1vzWLHr98wwwobevnGWEQP9xqnep5/jyB610CicPexI4ezV5o3bWG9xXIdZ +DI+D1HEaQP284strIVPAkiBuMdQPvoi3HsYgDEYYOJMuAGxWx2hlk8uvpvzjXJz1ETryr4g/ +d92YsfjDc9Mn8p6Y2okGj2vKQ1mUnmLhxfIO9WHkiJwEEAECAAYFAlbtd18ACgkQ25m/vm04 +F5zM2wP/UfrJIWaQVk2XokHTsKDd0PExll5AEEDIHSB2uiTsl7bSU3zzM7th7ORCTLlBjcWx +Z8xXmcOFBjFcPKNltIltrvglJU9idIWrOdi4OHoJItoqLAnboM8b/VZziLVUaoHAJJ5z3psv +OHBR7/L6vNil1irZD8LJngBNxoDQEnZPz36InAQQAQIABgUCVu13YQAKCRAvXQ1Vt/E+hXj1 +BACr2FPlfEM7SPNPdVzQUnaAZmUQVSkzbufqCAS+Ssgw6i+LTTwc00gVOqtqx1D2gLuEUxcj +NBUC0ve+L3x8lDWV1GZydk62INnBGQgc/9XpP8/rvOyIJv/BBTzIr1ylaFD/eFnk38S6u8/6 +boaUm7Qz8HonoNBAlw2X3j/JLkmOSoicBBABAgAGBQJW7XdjAAoJEM2kXHoRcDtKZd8EAJCU +yhtEGAIaSmNZYnRn233APD7oDu8wWpdlg/jgcr75w9do3mgE0r9+JCj2WVJ8+/42UsCISJPI +qqA6nIu+nu9B4Lk4PTtcchdt/vin/TKpfUEcU3gPqItjvXiYG55z0z5Gysoywfrk1kBS8b32 +bJc5JoxGnSaX4CUu6aufIry5iJwEEAECAAYFAlbtd2UACgkQt6VBVKL887sCIwP9EndrJJrs +ylNOXz/TtJ8E8z8d892TPXYn9vc1Tr/U9iVqwpvssvktMQowZSzkJr4Hn3pKyEN25kQ9L0o3 +9/C30+gZXvg9N/fdEMpUU08qmYdpSwp0gt78+I8QD120lsIUo97/m5BK9JDt64aTLKJr9FAV +c3Zt9Yutf1Wv+ZVhmjuInAQQAQIABgUCVu13ZwAKCRDoNljnEe49ieXFA/9ENXv+DeOHKHGw +KtoxqyNJlEk80+H9WSFkEfHaoN58VpkJ84xAE2MmdW4nNIdoxp/fqQEvzGfsyh8g7BdAHUU+ +J/UpvvVF7S9ONMIDUjW3bZPEWBxISVPXMYXQBzDNbMhQX85hfKKZE3eegcsfCk/u/rlTRnjp +WunjuqoiS2PNkoicBBABAgAGBQJW7XdpAAoJEDvznzWq2WwdA20D/RMKT09vJldL4nGDYLj7 +r4nMkFeRfFApzJrqezQ3fV9QToVxx/xtRjerH/Dn8n8L6msGQNeEdBh70fnXU+6R2aoPfyKH ++hYc5nUX4Yc/zUpsmWem1nMCpg1D7n/dAUXRyrzklJvCDxe3Os6geL//xmrLJfLXNjfuNydO +vWTiLO0AiJwEEAECAAYFAlbtd2sACgkQR4/7I063t9tpUwP/ZCzMOajoBHVGiuaep6gZwcRD +smCaPsAaL9ykmY07OxMIK7prriKqVa5QxDsJ+JF39P5moKeU64CvoORDls/SP0OgtoaDLo3C +iMsVMmDADnmmo5EHwpldB6fDKIlkLw0BZ+DMbT1PwvP+S5OVayv6nCfSkkA0PgGqGmoGWXnL +tVmInAQQAQIABgUCVu13bQAKCRBc0ujFO8+NNOAABACARcS2/2eB+IrhlFW4ooZFZYRHT+Em +Ms2sms95+8oJE7Ea3tEukuXRCxrwnG1cx1GOfmfFFmXVCdmSUWgZVRip1nCpUQi1aHi+VaOh +SSscZ5PZHCALRxpPCr046SF+aeNWQT8nu6hmUIK7y6wdwAQDCZj4w0Jfnz2QGtCtx0y/XIic +BBABAgAGBQJW7XdvAAoJEBrPMS0w07mJMvoEAIqjPzmdoLkCjMTEcijaurRGgXsvS8KeQj/T +YGAKt53I2bk7jUILuF5/0ttHCWnL8s4Xe3sy+zAMef4qreHYfYF9/JdsV4u6l2H9HF3Mk4YB +Ykhb6AZlpZJFA5RJvIWNvBbXXvCmS6D1zX8mNiwfl5eWEnsALrlgTqmNBWfe+94UiJwEEAEC +AAYFAlbtd3EACgkQO+BIls5PfUAiJwP+KRimg9pHCwycaZVX/LCIJSiZuq3FMulJLoUOn00F +SLZ3AgebYOxeKrgCMSSktEX1ZQKWvYpaZefIzcVCWua6ohDx+bKU5Z5xe2Ossx8pz0IR96Jk +jqPiyJo5GV0FhcINLIt9YgrpthNpqKi1G+kPoYE8j9IonsXtASXD9pHMub+InAQQAQIABgUC +Vu13cwAKCRAS4xy6TLXlMIlGA/43jtyhjLC+Byi1OXysvhIhRbAfpIFlXbAKgwHkR+QMIOLC +loTp0fkvkG0BwoRMivTzJJ6VGr5DcDZdSpkhfoIXeT99q1zXV+s1pLujxDCoNgHDjeMUurKG +5gX+yvqGY+6N9MhUptriL+JXdQtgQd0IFbKK+8YmkqFmdE5LV93HooicBBABAgAGBQJW7Xd1 +AAoJEPOSTWf01n+OQSAD/ReFif86/xewQit1ntB9dEZ/89/AStMbqKUd/MVX3rbGkfRYpi6T +fKTbkp03l3pVOB4NlJlnnZd7k9yiBrIgJb6nnZcWpwDaaYZRApSjcZYCcBt8zietthlpz55r +G8WMKnlZvwT/UThFOSLLCjpdO1Ls/CWWuhzCOg3a8rUc+G7qiJwEEAECAAYFAlbtd3cACgkQ +TI5l2ROZo2SsDAP/Y4ltW1UhZtpRYAy70Ut94+mRo7ClW9h+f7yo4WiSez+H2RSqI+/Nw4zw +BUryqmYkDqIWcS+u1NpLK9wwUJOStL+7zpraM6noMWbFwTzeN77p57++eHxmhTzzwjZv8uep +pQSis1Xy7yF4kYMfd8apsGACBHT0M05/IoaDtS1jhXiInAQQAQIABgUCVu13eQAKCRBpx1jw +8SfsYLa2BACx6TaRN1ypF4gMgaVRg8B+Vj9K8i2st0ftSoSRrGzHxuWTAjedXXxKqv7yVtYk +PEjsLVCHOZWSCKqYXW9+kwjAbx7lBn+E65h7ipexXQf3Qga/0Z3v212BMqQjPGfavclWUZWf +1PDZ51HWyIDlIofvspV2cncA8m8/YnSDORPbF4icBBABAgAGBQJW7Xd7AAoJEBTfUUAtcFCQ +Q4gD/RIW2si2aqHlsfzAvF0qXhlaB9XHtvgfGYV7Ezr3Ga52eedAuzgYH3wfWqETNM007tdT +VMlLDQzhAVa0WyUeEzsD1ZCkw/l9S6+s7WlVsyyy42ewIpiuUsviLcVHjGfjMHWNBep3WL// +h/iWSYsEoOFjgrmWwdcjTZpIhQ7rKkafiJwEEAECAAYFAlbtd30ACgkQJ4hBeu8Rb819jAP/ +ebCBC8Him3hs73+Fwc7xHXVd9N+f+LdjiUqJQ6pn0/oMSFxDD/Py/5YPdkZlCSu2BxBV1PAv +41+gXnfjSbxEMemDcrxrfXJL74illqtHmDQJBtt3b2XmYG6akA9PjG0Nru8T+0bjcdtzRLek +EZI4S6aF+hrKOlwz+nR4fKw7Io+InAQQAQIABgUCVu13fwAKCRCzjm1xH8KiKNxrA/40W6+9 +bdgMiV8LSmbZSFJ9LA5nCJhK4IbN6FLos8WEUp556XcBLJNgGFnXHJb04O2jXVFRoi9LVZI6 +h+WuRyXQnvn6FVTynngJvl6OodiEJSzYzEOGTml/RqWCNWDspFKGQtVlORVSQlkFz0+AqU7t +dR+ce4Uj6zmJJvPSWUUohIicBBABAgAGBQJW7XeBAAoJEOV+roWwIgPdslMEAJJmkwyh73SL +VC2R9uMMr8ev78HY19derwfRsP9UoVU7YX7E0cJuvlE0DBVwdnyEtCGyZuD5qLu4lYgx9ndc +gF9m+3pGpQf/O0t1q7ub/3G1ns/lWplbK6IjNlMBHVgALNdaWQGQRJ7qtFMdVCRVn9tleVkG +Yo0c6NHYtb9abOPsiJwEEAECAAYFAlbtd4MACgkQMMw2Fec8OkkO1gP9EFLTYiSx5LMdNvSj +TA4TdHt3RR9MIoR7TOezLJkXTG6dTBgrKQ7POGv3V4MXkZ9ZBdbxAzLYt5UiYLuat197hg9l +p5pvnL3CtXHhGF34SwuMw1ExPOPYmGtRvpuktR7J0024JSfvvuCAnuCwrWhficS3jDymrFIj +qPwd8B9BtWqInAQQAQIABgUCVu13hQAKCRD6uKY606HFOZxqBAClKcfk6qrkyHxnXeLVOolK +I9YkQtBF/za1fZu3hHFmFLqxBRn2IFsrAy1TwUc/8Wh3WNqSp1D0Eqn744xRDpXOWqN3pSH0 +7lADzKbHwIy2VNpTdxJ1fbvp8N//DEeXVOR9u8LJNwSk85+p9UZXufOfRM2YyoJKvpr2aK/0 +D9wecYicBBABAgAGBQJW7XeHAAoJEOywQoh1kSxKGxoD/iwAO3W3TFdjDAbqVprltiDQZVH4 +3rviKWH9lgGeljFgTZolXWX4UfvLuMF2kKk97oojZmoecR+rEeEGZQmujXT6yVe+f0S3tido +Rjt9DoFKCc2+vYpr76YXQ6OCODOk4zKkz7nLxCGeU1cbtcEu0Pt4tz+l63Jub7IRs8zqDN42 +iJwEEAECAAYFAlbtd4kACgkQJVq7A4LANlS/pwQAs5LBZrUGV/oPd7srnpzQ01MJHXqDQ0qf +XUO/ajMC4QfDf23VaTniTgpuBM6rQr82GWF0HG1DM4xwzoWhK0uGX9xELz5W50yjxhhgeqzh +JhAfeRl+JmAgyur31Z5xkwjduAvv2GynpxJH5xX9vmi3JJpSdVp9Igf1IFEmPsPhES6InAQQ +AQIABgUCVu13iwAKCRDOvBSw01eWmWs3BACOX0HbCqLmcLoYSKbCEzMdO+HaFCh5lyizCKH+ +X43Drcu1sl5dQwJAufxedi0USRQ6AEAlHf06/ggTslSfn9Er9MV7Gv5WlqW2JPHHTI3wfSaQ +1nNRdVYG5IU93CMYO+mIxICukZxokZcw5dPzC8LURHsarYp8PwlTMgyzDbR8lYicBBABAgAG +BQJW7XeNAAoJEAdsz0szF5FbWXQD/3M45M/z7lKNqcNgBstCu3oHMig/VfTPwL6vEynzaRKD +Xxk8+xjFfFBrNqjVKjJvOGjPhVTfi29SbYwgxVzHOdpVjzQMOJT3g0uOykdQ2taK62EmyMuc +NBR/X2BB4ndnqF4vtcBXQZRG7NHj9IioWJAOopwTNcb4sMlLy1+2yWGAiJwEEAECAAYFAlbt +d48ACgkQI5ZOYs9N14A3IQQA9VgURDtgmF28/4HrGSrEj0BVbPUQwMdwJ/CDgLg3OcCsjlsy +v4pVWOqEZlFCKZ8D1ys/rx1GdP0hQhIFdkTqa0TF4pQasAVI7rJGKxccDfdyQX/OCR7HxIEM +rnNsJmfNABaVFPkh9hoZ/qKxSLQPaXcZDlZ9kbcJmynk0DE+CQGInAQQAQIABgUCVu13kQAK +CRBu/mqaR70VWCx9A/9mv5NBYDpWOs5Kxluh6t18opfFWkwN7scaN5laoFcKPVbnVz75JCrP +ZWTZY/xJJlHmk9qIBG/FgvJpDMc64gcsQKrm/t0fwo4M22WOur531rIRp93pMO282OJ1iVaj +bt8Cwvj4JZRi7MMEKUJgau5m5XCOZCABWeqg+hpRek6b6oicBBABAgAGBQJW7XeTAAoJEErn +KhD+f4FdwwwD/jEO8jJtig6Yl4G/g+ynW5MlonEW5oPOFheIcuWBztx2GcYrfnwNHeNqP1cp +klqbqicQNfM7nkQtBPmqt0eAd6LzkF0XEJXVafSAX8FfuJ0RtQwbnRyWjGGzQi5moE0JPSfZ +B+kuFyeOrMQ4fDUtzt5im1zPdDX3o/YDpZXNYWNOiJwEEAECAAYFAlbtd5UACgkQtKcQpy1K +ukFxrQP/R/jYW8aK+kIufxlUVfaO1Xn1QUgHf6MxDcdw6J781yObsyP7YEa8N/VM4Ymke0l0 +Ju4yBdUYe6FeKCORqikWNtACxAoXx1QMo+OlbE8QjjRtebv8V6MKvk7A6L05p2RN5GNBQCbc +X+KvCQB64lk8ptinSnf7tCYAoTcjKpHgnWiInAQQAQIABgUCVu13lwAKCRA+1NKnaj+74qyB +A/9CiAAx3Ts1ijaK8McKeelwT+gXul702SZYMgfrgVS4hZDjFE8+EnIX7Prl1CzbO/kxj+i5 +snkNioFaEs0GCwmoXI/Zu45lWph1EScAtL+jHY4I99E+zq3ltOmNNHqQf2FsviTpoclEQVjC +Qjzqv2Ck1hr/2FSruhlEA5y07xkvloicBBABAgAGBQJW7XeZAAoJEOWn8EN+XTdsvt4D/iL3 +alXFjOZusNi/W9CjOnuI2VsFPRDzK2yG7nyccInGwfXRNxRs01bsSPKK8R4n++L76pnFoOOl +qMdYdjmcpG7doYiqyGWdBoqWTiVEExmnvbEPMaVbWTeNoZcskUeFAO+86fLckAzOUi0lVJlt +HU9ebFfmbylKIZvCJPKPCqvsiJwEEAECAAYFAlbtd5sACgkQ2ksTxJzr4KidngQAqIpm/s0G +G4/Gob3iIJ2gQtrjtuigMU0za18Gu84PFZmoJ5OZFSqoY+bGKeFwr/5M/c8N/WnkWKXhz7xs +ggxEJ+OxbvjsU+dcuUxeDFcggDOty6N1LNGwlhl8jIcl2eVyPKUCo7xRGq8GsmeYmkJkFTLG +s9nbqSE4IN4sn8vnaneInAQQAQIABgUCVu13nQAKCRAIHvpFWKztFh7ABAC4RreXvV3BQ2Ob +/ihh2ZQP1c4ADKhbGbqNMX1C4gsE7W5HDSIjc4lGYB4Ye2ip+8bnQQtbmoJ5mTNF4hSiS8t9 +TEpmIvx8f7IYtjB3LhTeZvR8YmnyU1li3MBoiQhxCwj2+lbhzudTGNP47od/f7Pv519h7yke +BGsFjid4g850woicBBABAgAGBQJW7XefAAoJEF719OjAw2pStSQEAKEj3uOhCy6f6WUUS9Qm +qGR30Ft/rQBpHL565kNm22Ka61FRDmZXh7RveL/PugIf0T6Z1UWegwS0o2QVZg0M9APrNmd4 +KEh5z1FuTPRu41Vy734IDzqbWDzokk+WYV9xqYahSLCQaQPlQEV22KX/OvrTP30/ypwvDyGP +3HRCLU8OiJwEEAECAAYFAlbtd6IACgkQYpwfRgOOxU8FtgQAoC5LojAUfRgOhSdIy0NgtHD3 +52Ij1+nTm1pE5NkOHkjGuxppDYX7ti2xekSz5kkc9TJekcHS/tySEvZtwk6eVC6Egp06xOWA +uM/KWjZBVowuKR+SoAMLq2DgB6M4O41GSPnIL3jNTgpDc5jzGvEb3kGOszZ0FU5/2IRhY+Bz +Uw2InAQQAQIABgUCVu13owAKCRBwwo20jN0Gei3/BACL7CAQ+vBdRtm8cKeayMqN7yuqeJ5U +mqXUJeDz/hbDdU77RIvU8l78a+rHrMIFsnYeoK0u/N0iGGRv0a5Sy4+2dG35n2pr7135Dame +qR09+VkbfAajqY9SjNNbYaR/mgK9HLs3zrU28SHUb8jRvJjvbsbPIwnkI46rKuCOBPvcIIic +BBABAgAGBQJW7XemAAoJENnpT6Ml1sPCV2wEAJSD/ev7VxgqF7nrtRlI9wFN21ArHmQ/nQ9D +/0DeJZUfhSHzY+uTZcIe+cyWUY3Ax93NyTFUmnXcoevRQrlGIe9dHRyzX4Bjpt1jIiyDo+0M +1nbtXpmp1aWML3J1su8QfPBSAFTK6wJjWJb1iRcUzzkK4zP/vIgfK4J12NusR2zqiJwEEAEC +AAYFAlbtd6gACgkQqno4DrCFdfTirAQAkk+U6O4/uyDFCKHzpKrDAIplj1uTbTgTK+YsDesf +qpn59FXBCeIqHstWOJG0ho/aJ6meNoSv9nJCcyE5CKsyxb1CmdpQyWFg/xk2HYwQNCTt7olT +zXmt3SYghEdEEfCjkZ+2iBQMNNUXCk6rh8NcjYQguiFWeQt1RQAb+ddqNoGInAQQAQIABgUC +Vu13qgAKCRDmmdAvQl0WMcCGA/wMQL1JZ9LGYKG9PT3+tGXiqa8VXCvKZqY9qV+CR1IMy25I +PHb5gRZzsXDe6xU/cWwA8mExja3rzsZHK3n3Ubx6bEFoWusGJHWLSruTC1MwYVT+hvJwxxaO +sWzUHF8RJ8+4T4lBO0YxmFSmyDvFv8ITTx6gMqFa/wQp39UtlP1avYicBBABAgAGBQJW7Xer +AAoJEEibzIFtRZB2gAgD/Rj9jC5XTVH9POdJaO/Q1ArRm/2ai4PK2OQiy3uhx9yhRwweL0Vc +WqcojyVp0aoGNjh8VqL3PpLqKIbGEVy0y+o/C3hWKYhoLoETNXPmKh/csqRldgvRLTW4vMDk +gnmEV+4+P2mQcVpbemgrFaAUEPsi0ssFI2EZo9XahcNYH+vEiJwEEAECAAYFAlbtd64ACgkQ +4lcKtD//40tyoQQAk0NdEFEsBiB94+yD9OBlwZ+2LUtEv6TXTMyHNEBkbPrKUPp76Fj0hENy +5RHEqHeQ01DF0oaeFrGD+bmsb39hlS2YytyRdjfoZaawMwtBjArE4fRp55SHBENHS1mdfD+Z +88gPZkM+OXbBUCNiHyzGjH3WU2XGy8QA+JAgrJK9OJWInAQQAQIABgUCVu13sAAKCRCySF4+ +MLHSz97ZA/4u5XLXP1Oot1RcsNpcnsxw27XBXFOZHprGYHXb9kXXudeeqpMaYtR4EbQAvOgE +LfNXQYABilmB04lmOZ9fTQFowRpfPVCySGhdqGlZLxnc314UGu4UY36r4BaggLNk+1bUbXas +Ph2adTaeUM7vYOF6n09D1PVX7qInXrAouAJQBIicBBABAgAGBQJW7XeyAAoJEBIw1u+b9CFG +AA8EAKGf08+ydY0xNpkpkDuT7PLEmBjMZqjBAX8cFYB5mYwM+pX3nHlfEAk1/luuhzhYyrqn +d6xa9G7W8x5EUxu8BohPZwCgSgwCKStczXO/dpydQY+bKQC9JjQgeRozUqY3sm7Yjpg9IJ8t +aZ8qtPbqZMlCrRVkwZAQm523GL40c5iBiJwEEAECAAYFAlbtd7QACgkQhMqWMOqPNMTHQQQA +iFtXz6BiJAVtG4BR9p8Ve/Rx7bfwYuFp/PB0vKlloqeyZq9wLIPdnMVBPMSbao4FHPD3xRo6 +wS+II84bFQRGOMKj6qGh5hUik/ZhhxEijDphIhkeC+IboB6ycntzRL7zW+IWbBgBjCB+gYHt +yDYRcnGIYQfIzB+wu68X3dD01L6InAQQAQIABgUCVu13tgAKCRDiCutcWF9YfA3FBACkintm +MGvGR7Ku8mQVbaYf5UZKUez8EePCq+flx5bJzAab7u5p2UImVq5NfvVzzbh75ULGioQuLtLO +jvZ+lSfn5Lil4zTxsFMZqCCzn3FEv/BPkQ6lZJe2I4f0zVRwhilp9AWgP5HscvVDT9vqg5gM +PXNBAePXWkzj/SCoPmd6OoicBBABAgAGBQJW7Xe4AAoJELQ2y2a5aKFNgc8EAKzTWBD0emQt +SK57iO62V4vqCfKaBI9AkV1gNZioHwvKGkmfhz0xr2bEUgqrQ4JG2+WziaenN5uyRyK7+5IX +EfR5FnthFGEFDG+plpbNF4bbZBk6fH0LMcJtOawNlv42DFswwXMKCugiPXQc/Wmmo8G+SPqE +U2rF67FsHaz3+1rIiJwEEAECAAYFAlbtd7oACgkQ+zEWWPpbuF//UwQAxGuIjMSNfVvw6yk/ +Z8vN+xkEf2yG8R0BeNMisYnsTe5h8MsqgkYP4hRssEPV/bCMMBlOh5CjG9HDvQf0DQlQMDq8 +lWxw82+DUH1ZDgP9HTuWyKVl/MvHPOtiVxp9pex5W+NH2f2CzAVPeKia6Q1cyogBHn/EN2IC +5PNgMlL/2vKInAQQAQIABgUCVu13vAAKCRADNghyP2y/MCcKA/9dxy8RKroUHHBzxpeGbHQQ +pmouwmdBeZYYTflv3yOXjXYyhA9yaMuOiDgLrXsWwvw+mvmSFdQudE7vlHtCGSZWgAF/o9P9 +12sbfFw+lOVL5ycreWriGLSGA2oT4tCMHWtHJw+v00ZpKV+UxBXzdnEMjNEa3wbsoSHiZ8JU +cyMeZ4icBBABAgAGBQJW7Xe+AAoJEMI/UdMF/6bElUQEAKQ1Ua+AUOb5bdWTV+Pt651nhdXK +r8AV57wbvdR2Ypr1sSxHd/ElsU88US5WJVmtSBpBrk0CW4zzwsjJzA5XS3DWdL9d0zt9bCeO +14tCNE48vagtpTe3/37OT+iy0um2ISMsoFoESu+oDF+ok00RslV0R39eOwsVX5xJZgHi3ces +iJwEEAECAAYFAlbtd8AACgkQtt2bUFeVJVJfpgP/Rp7nks1Gg+evZ1d0mpavt0dZ85tUZto3 +2hNnaWBGLodxII2I1MrEOSk09RbzekvxhERHTXUzrsxQpCw7VwzV43YgoeUI4b++C7ncAQYo +6HV3+QZRXvFIVy7Ie2dBEDRaYCyC0zlAeP62emBBtLZU6sr+8PE/4zPVjCn/muwM5ieInAQQ +AQIABgUCVu13wgAKCRCLm0S8XaASTUSWBACMWRIwECnjpPNEE/dG18OfxZGnojcBL/qKyx4h +28wotjpUQDRT27JJFJfm+1povJDrnHomOdGSYtORTt4Md5mlL6lLasXBmrbJv5I3ymve4X7K +NpkfnucKWIOAsAb+xYRlXEvRUysaNrkWUIAHG5WX71Md8LAdpWuA0wxL/5jCEoicBBABAgAG +BQJW7XfEAAoJEOLicsmvoVij9yQEALdWPhldG+Qk8VxlFEec2wvewAIWftaDe61P0l3kNDjb +MFkyDXkk8sTRJTEfE9jUPswv50lh8N2c3+vj2+e+lvwIMqACwSenoZKu2HSwB4j/j/ylghNg +i9tvbK/1ABsk3KlAvG20H+im1Gc6cdkC4EEnXeTavbVoZy/D1wJcoF+ciJwEEAECAAYFAlbt +d8YACgkQ5jPqixiPXFLcJAP+Lr1s/ldax2a/N+Rq8IeGikmXSKv1uLKmjcBbleF4e/SHw6fq +MgboG3QE23H8kiNuYObT4nwcaAwFdyp0jUdsiQkWoPvfHiN3H2FcPeYW4gx3BolvkWi9nyRL +nVIui00JgLZlgFF0Zudtcu7xY/+t8miXBicnzIkbhDdIrhAMjqCInAQQAQIABgUCVu13yQAK +CRDtefwCUeNuX7wHA/0Zc2IpjTVxqPN7PXCFh3iJPQwVDQvsReb5qalHy5BADUNrkOLC/wKW +IxddgTBvJopdCbNxY3G3chnhsPnvVIDssBdeVImFVdtyhelq76HC5z0q65nvjxBVRNKf8ciB +SDjnWbU1Rwcg6yRzqgPEV/W1ZAKQ7lC0FXWdtJaFmB4ZDYicBBABAgAGBQJW7XfLAAoJEGJV +Gp+4bNdDkTsEAKUN5/FDpMxutdsA5/5RGEaDxjHuCUK9w+xJBxFOI6GFUO5vQEHLQLuyfP6r +YvAHJ1fV8FqxUVG4fAcRT8IrnsyTiqSXgHoKE4kbs3S7A/gpqD2fUYdHAY1f/SPXMmuqURJC +csqDMon+IcxgO4S+DXmds8NoPJq7+J5ygrQOkf08iJwEEAECAAYFAlbtd80ACgkQBUGvPJiS +0qtoigP/SHWKnOxdV8QZ5ER2hlEuiHoPB7TPwK03ZWnmtHbh1FHRGjAFr+QGEmsOuoemrxg+ ++Ze/fqeIqy0GeKx9LuSzs9eX/jG9KBJzhZEHXwfRrSRqp5quWNQEZJG8cfqfdTlG25FOMApO +LX4N80slXGJj9074p9e8T368E6VvCCtogwKInAQQAQIABgUCVu13zwAKCRA3So0U54NCm7EZ +A/9LIHOW2fXkKvsmN1HzfOs4TRmxzttkWBnVueSt9GfXchDGXTZkoOveb30PC1Rbevha7L5r +828AGTDZhoSImaC8HlLisZqKMR5eL+4vMsH3KaPzsN1LAyz9sB2n2J++nTCAiulTLWGqpA3T +NMPvflhVgZwnoRSx3CamvOV26r4I/YicBBABAgAGBQJW7XfRAAoJEOB3A0WDq2xzXeAD/1bo +BOi2MCy/ftti25UpFUqIY6mFIDviR+CREgA9dtrd2aqR/atCtg1ZNkhG0fVQ/QBUODwSHdJ4 +DzS75KucgAJ4tKH7gTe47M/Vp5AGGk1THQbCv0RrsxMXBaPMl8cJ8R9CUlgrvq84o9Lo86Oi +H1hOG5nobrv9/cBC8jqlx/8IiJwEEAECAAYFAlbtd9MACgkQ9IhHx52w8pw2+gP/UIKtSHtI +qeZyLFuK0o8TAfJWN55s/3O5R79kt4oT7mD+kbzFou5a/f3JzMZZFoHQzMHwkk4ivMjLcNBt +NHvQHH6M2eD3mbqAXNUIEXf5LNtes1vJEksnStpfuEZ1BM+govPtI4v69ip3kahR8mmFwX2F +rj/PkMExjUKNqW3TybuInAQQAQIABgUCVu131QAKCRA2dwF0tQKUj2LhBAClj/fG6LLPanpe +sb0tNYkrSMWfZCzF+AzkKs7FD7Z7TgDdlI+vWmZmMzNnR+kimCD89bwEtOmQdtBjY5qXazgX +cb02zKUM+jxRs8jmRp3k27fnvBo+4uOOhhoWvbMPI2h69TeTfXtQCRoy2Pc68l80Pmev2jIS +oloP0tiaOVwgjYicBBABAgAGBQJW7XfXAAoJEBMlgTKYf2XEx04D/0OH/CdzcWMvlKLQfsiC +b+Zy4VNJT+cK2iQkpVSjssfZIAC3W6lQappVWS8ywaemitwzfbJ/bvNdAf8YFZacdjY8f+aT +TKcGlKyzPnoVVyphJbk7GuptNrVQ3yTtq4B/sk8b2RIKkFWRMAelAIEj3UNXjz3tYNNJWeSZ +NWk+vEoDiJwEEAECAAYFAlbtd9kACgkQOaAmejXcMo4rHgP9FrEQxuNo6IKWIfKUX6Y+CFRU +9I12cbSk8p9xDLDajxRMYu5p+MQ04nl0/j896p5u7vgbuKLil8YpO/vOZj32yCzoLkau3nIL +M7AVwBkVtsP3JQoxH3kHwu33yuqpq0qW+5rzvpSJiWS1D2kk1vGiLC1NZLwY9mtZdWNo9dt5 +OLGInAQQAQIABgUCVu132wAKCRDuVGabx6RO2NpwA/4xUvMuL48S9rJYCrFTQ2K4X6PCetMJ +p6GL1k9zQKXdTObRdMdHh+oKPK88coA7YIJajRGPBB3l3Cjw/ijrV896m9CFslpEkpsaqwn6 +uNoQDDg0tuY7zkxkMc+FUaTlQTBaLgNKbkMVVglazKGcToWS2klvbVAGe2lnKORBrajGHoic +BBABAgAGBQJW7XfeAAoJEMT8yRtmTZO7y1oD/joehjDKsXVuJT1gShhi1Fpg8a2wbzvbReP5 +BiBoItz1nUXrAW0u9fzlVolev64+SBbVkCgYLFqArOowgu8bgpg4VGfuW5NdWi7z39bbIV1/ ++xbCDOTjuPtfPi8WtGXd6cgzm8AVvGqb5rm6BRVsiTqD58PUw1ZqVB5UGvt0LLPriJwEEAEC +AAYFAlbtd+AACgkQ23t25sRKwq55jwQAlelhM1vc1z+ZtCGp9bzQL0I9t+Y4PyD0uSZxljpP ++2icOgayYLylZebEyMo6Oww9pPQsJcOJRTYINLr85fqO6vEb6xFDtjKP6d5NsvgHTa4ZMGvk +trZR/BybQ9xLWsxsiJ6oCpTapThCxzH0Kod1Iv+j5/yXt2wk3RaninHfJ1iInAQQAQIABgUC +Vu134gAKCRDBO7NbSPWSaYpuA/0QxEupbs/eFmoABdN8p2Zm21fGJIi8ngMwGXhLhT66WKDi +F42i3qtW0V4YbMNs0pVarp6l7QyJT7nfSHIlPxdHbQVgbwg0r/Q9SujhfYZQxGPVPHSV2wgd +l3vIM/2Obpp/vZPmfJhPCBA7Wh+TzD9/fJ++s2yWZEI1En0NLQH4YIicBBABAgAGBQJW7Xfk +AAoJEILvflqhtxpv9Z8D/1895j9eGivRwOemPczk7fOd38+/x/bkkw/QEP74akcUTqp2GuL1 +g9yO2KIMz/RGpSlgUoWdeiMVU96yGJX8U3f47TYaBHsE9ueDmXgR8D7Z7lkIYWX0c3+at06t +oo4+QWOsK82zBlnhYFTQQvn+LhJjt0rUYuJTM5CfMsHM1KvyiJwEEAECAAYFAlbtd+YACgkQ +Q+2ZGIXmiyAyowQAk+sCu8bGEL6vmnUPqjoSiTLhlllNtucYPMaSWi+tuQoykSv1bXeypMaw +Le3e6wrASN21i4lPYQa1a6KIpxdsi1oamQVptDcpEPOvt352/ZtinNnj5f50l2EwCT13nHLO +OvNoUFybJM6YDiwQgqaTMtWFRIpmU8Og5N7EwML24XaInAQQAQIABgUCVu136AAKCRATwR4g +fHR3qSmsA/9Cl8xbDQIv9zVBj5QznjzsKNRuCQp+Dh/LbirSPa/4z6BV86OTfO1T0/l9W5UQ +zwKtT1Gmdfj5JZNjONJTmA+iw9o2HyT9za1utUtAo3FEpCPjgvfDa/R7Yj7ns+qzC/ne0VWw +bODkubxCHQqPLZL1GGO2Ke9Awrzuil/AyUbXgYicBBABAgAGBQJW7XfqAAoJEJZyxT7IrgI5 +A7sD/RbF2ExRXg79RJUaREneqJyY96d2n0bVA1lenT0s7Tjw5vUHHZpTW1eFcWvbu9oVH+23 +fzWKbMw9CmdaTqN2wiBKEohTXAK4YBiyyglKZi/KBhHlX8NUcpDjiEE+2G/JP4oj//i1AFIB +qRh23V+FbEDXNf8Pahi1gaQ19ESQaIEOiJwEEAECAAYFAlbtd+wACgkQxCzXn82Jgo9c5wP+ +Pjq/oyzPDdsq8JeaHjBg8XiSDzPnHb6o0q6KJWdeV3pidnjF+CL2MwxvYIm91ODFCT1jyets +eAE5JdT+eBukB+eOAYZ3m0BRHW5n9rcLw2kHBf2xgvqm7uXPLOCC2QNKtsHMK5WlAajOm0vV +9yJ0/B7paoSCGyhOJu7jEtetxaaInAQQAQIABgUCVu137gAKCRAkbzadUJ1u2Xk9A/0SDK6E +/sjscg+gCyBoWPWvxjSMq0zA8tzJAZFUtOjiDdy/vmVaZPqXCK/YjlnFly62JI5bQqkDsJpo +F6k0uZ92LON6fvNjf8G5Uie6+IFhhcHbzI+AnkSylscT+S68Ab059KErtHTXyRqaL3lGr0Lw +bppBlNq076IzpKRf+nyow4icBBABAgAGBQJW7XfxAAoJEIsMdyI3Yi8YjGAD/AliANVTTYG9 +EMumf772+gFKT05Y6aGAPQbunCUV4hjY75t/jMQXbKnCTyZ1GAK5uFgGZDTicYufHRkDSBiw +X2JNMpDyQV9E9O03Z7KCQzW/DmOMr8yHUD9+fA5oerm3/stRf/1Z+2FZgMqeBHHryL9HOChY +aTuwu+/UEvBkjQoLiJwEEAECAAYFAlbtd/MACgkQBfZMZMKsSPwvWgQAmsj36UqY6U75BgSv +t23Wndbpli8wNgLWBBa8WCdB8rZoPbGhwENfHJxfwjD40QjVf7UK4lFEVo2yWTebPJcswBMM ++dAWFANMZGku7dqoWbZd5eXKJiEA9Zt+s9HLIy3oSFuYYPbkf/g9zLyK/iBziZuwnFMpD2bb +E0uhemLN7hqInAQQAQIABgUCVu139QAKCRDcEiygQxNT/L+5A/9C700P2A1jmU2HEH+1O6CN +0pMbCEiF1/PFY7OU4wMLQ8QBB/pB7MBn7euA2SpeEv92QPBFwKHz8DnriBbTm85DNwxBA0EL +Kiv3q2Bjsrfj8YpMhlAN5dI9QdhshgJT/PLqVtyOhw3ATt3JiFPNPfJAatXt2A7Vcc04jRP7 +ZQCYTYicBBABAgAGBQJW7Xf3AAoJEDz/ofK981GHv40D/RKpewMitZ6vuuItJejduBm3Ei+4 +zu/woa6HMDiQ060r27jYfLFJ+iyQ1wNaVREKi6xDxBZ2tHDWKObQ84hZglpsyrneR0iRJDdR +9AkDyHnhPgL0X1qCtoIrYIGUC8X8CQz2wxTd9fMfdTrPfkGmPxweSFmdhN+vyIT8KrLgavIx +iJwEEAECAAYFAlbtd/oACgkQsVxWaXmNXJRcMAP/WU7Sd5Ku0PHM2swx8aeWKewmy38zG1+r +k9esBAyh31UKrHCk8+a7pySrmmy/UTe1pNwTiqql0Q5PHtWVc5Q4Iladw5mn2RDfLwzj7rmF +ptUyhGNra4BcHA80RTqIixCghmaGCMEdTc9hWDUuAGtx25QUtHuHste9P6DSKpvx74CInAQQ +AQIABgUCVu13/AAKCRA4W2nOQI2SFSMQA/44QY41CCKh5goXE24kiCCEI8qW/fy3baK5wpCI +ApAubui9emo7ytWu3edzsuJ7s3QmyKKI9JggRTSm91IJFmkmVj2X3uwp2GpKUSmrzyqHnbtJ +HSOO14GkoIGdI0vU4L/seYRbFSveD1MOIn1tw50Bx7Vxi/lpGVXPEfx/DfwSWoicBBABAgAG +BQJW7Xf+AAoJEPhDPEnbKaEogeED/0loOn0QU7S3Ih2xDo1smzE1AZcLn+R3LS56ZU86pbfD +TAt018gDrQxvkSZWz9Nyibo7W412tukyCWPhiJD0XtNtOxnwqstmiEkZlXBfSgMtRzf2kkJR +lMkk02e6GVwUDHi0mtY+1YT1ZPRuAteza49QPBiXZeHNO1QnngpJOQDGiJwEEAECAAYFAlbt +eAAACgkQWa4zfx6kvvF9VAP8CRsL9vVqNjNmglG1Dut8wlZKRksIsoGkH+Qchb1hyhcAbvAu +2Yy/7tvnzwvTKF3kcG4FwJTRTyIQI4MWsyDrMXVrsJRZR6o8Im9mr3EmAE+Hgb9z0aIZxZ+s +Px+/uHfGfWWKC7h+PXl+DkRpRPfmKs1OusMPILt8TW1D9AIOD0eInAQQAQIABgUCVu14AgAK +CRAwQ2LpcsdhCleIA/0VwxAhMIfBAnACB7bXnfTngE5gz0yYu40Ijsg//QUb13BQ6xa+WWI1 +ztLEJ4rACapt2rxNOI5Jghe3qZNvKbmq1xDd21ckGGAlps/WfSMgCEW+kbs99HRfRM2zi5PL +qZVXycd/4U5GeD7dX+EIbc12jpsRBAKOR0e6SP3SuOGc54icBBABAgAGBQJW7XgEAAoJEJf0 +y4Pr4BgRQRUEALD72I+9RththXlrYlYBpPY83ASpxR15lfkcoSQxRBQLWmBiOeIMq692fy2E +VXcSdM46ydsRW7LeFkQzX122pd8kxAV5T2b8IMwOdhXbbwLmQMNyvBAx+gKnyb+A1k3NevWE +S5ULC7X+4eI7rxpAMGwU8uN515JWGt0YXHyfsCeViJwEEAECAAYFAlbteAcACgkQmSgPqPKK +ylLKTwQApXCivZLfQ/2SX3BtR+o1tdsG+rGNb+KNl6H+beEFc/H6T7AGcJXBdCCTlYw19sNC +8C4ojhUW/OWgjKBxGf9DmSURmM0RH5B1Q5L21Bnqdq4oAqV4ZRQdsnbS/SKUCRuNIFU4kIG2 +aymgDs1QFSL5SXZbnsDYQzxjkxWX6EbC6G6InAQQAQIABgUCVu14CQAKCRB6REhmOr7PakKU +A/4tp98ykTTAho+xP8YDFnyz4Yrj0fThTYtWnp/XsDL7XO2rxeXy/TsYYrckFt9pN6xftXIx +Q9cPtWg01ojKQphQ5m405aOyLhyOv9uU2wsMR2mun0SlQDVdjzSyCElAw+sh+gEtuetCE9yQ +ZD3y3e9wYN7HuiDVW0fsq2sco3PLTIicBBABAgAGBQJW7XgLAAoJEBump9EohoFcaL0D/iEa +zOq7Q2DZ5PiuGY36o29FBFpKnW1vxSzWqm3DVHtDl/tS6LjbbcHx1Gfh/uUsFqDyIb2iWIIH +/9AL57lEROPIXcAph8iice5nJuF22LPYB1SCueA50BPvo3rknKwpASZi2DtgAtCcQe1kvoJi +fAGiC99v+0xcVD0sDM/Jn1ZRiJwEEAECAAYFAlbteA0ACgkQCEB4PS+ztpUkBwP9F+vdloF8 +33y/k05SoK/yOZ9uGMNZ4B7+TZ9SSlzoxwMJG1Yf4Mu9MQ6Ls5Jdn/SYjgaOWCTJxaVhE/PD +iPLilR1HpXDVFMWEdP4Xj3TUVUwFVJTSDKVlMVCW49ygGQuNU4nN2R7ls4B9uCFiPGY9ge5Q +P33jupQPhxvbSFMrequInAQQAQIABgUCVu14DwAKCRCYPpLrN+I9D9XcBAC/FhTQW9TiczDR +LN10OIqIxEbvkdmqXcG595Cm4cYbbm6u/lfA8CJcuug+B+8h0ZZcgDBig18xwbQQf+lA5P3+ +6ymR1ickdCzBvkG0CqOpGV3FbKDGPFtumsXZoDkqcfFdIr9dOuK+6vxOEFvClgKRcq1WPJKA +RJQFvjOAaLni0IicBBABAgAGBQJW7XgRAAoJEG14H2SfuIGZfekEAILxV2iLLlSnydilej7k +NMUh4GOe1JilCFoitOsCULQ5Os+VQIkHO3kQJN1qGHP7dpZQ80agY0PYSYbRloGELCLxoo8W +OXZGEvZRjHX5qiE/b/+kJ25Mx7P4qOaWO9E/b2iQZjM0kOKcAlHzQ6Dz+j7At6dtTMbpV7fN +AC2/eXeLiJwEEAECAAYFAlbteBQACgkQcacBihSRSN8+kQP9E8K9V3U8z54yM2weehnQBx4k ++tQEget60S0iRvE7Z7rduzrJxuBYHOXwNznh14KF95W2z8j+MYT89UrGjUuiRP8NAmIfyK58 +2hE+NPnV/0RJdyuc0Uh1KqoXmlyT/JWkPSBtreqFW/7fztnnPWsXUxejpYKx8SR4n0VJwdZc +3IWInAQQAQIABgUCVu14FgAKCRD8lP5klHQrx/JaA/97DT3PX2MgaYezIL3bWNG4HMfwIFR3 +N/Hp1cE0X4sX5ekd9o3r66RHXlhdSIOcYUXrogmRaSsyhhHb5jYSPW1/CM89hc0cx8iP8FAO +Xa4/pZ6evhfGJqpg9Pr3Gr8qy3DOLLGPxymtunXsHHH11NiCAjYGZZYVcjHjUPIniD30y4ic +BBABAgAGBQJW7XgYAAoJEKEV1x0fDTARnbYD/3dsvEOrZg4jkTgKlns0Rq74mGDXQZ1J4qsf +FTxrA7UpmQh1ItQxvvFe+79VDPT52GywRv0hrN3lsjd1sk9csp9JmrAp9PG0kJ/xCnYDQ3W0 +9mYqPjCYCkA5YnVCUYXEH2NmWbUePyvl7LYVc5czCHEZ65PHIHq7TiDhm7iwNnx1iJwEEAEC +AAYFAlbteBoACgkQKUv2OOQXTJbEpgQAkb4qtcSrLBw5O4HgbSk4sQGcqul81e8cWK79BaJI +iXtWiR+VnpuZrs+rtVqARGqZ+tpl8zm78wZj+ui/J6gFz5LciBdyqgPkm/hB8fsf8p2i8ZeC ++9hGBhtRG2LeiDvzEyDJIYYUuu/Qe4s5mRt2H1p9rruhk3iatbYE30uYW02InAQQAQIABgUC +Vu14HAAKCRACPRSX/rocXjsBA/4mcyI5dVDP//xdXw8zoqBzVGEKJzfzTHtWfuxOZseK0pla +aSvvDGB2hYwvUK9bx7EgHMeg4GaLSlqbS4BhGluGOeBrCqZNeuNMuPzc3nOtPQatPOWapaqN +MUwpbB6p/vAJEcTR81jXasDt44HCwhtIYdVywcB9us/AT7qtzlrLrIicBBABAgAGBQJW7Xge +AAoJEKwMbyqBS8DEJdkD/3C9JwjyyOcz1HXXsn4UzT9v5ZBXG+D5awAysq5rquiqESYigmld ++a5HgDT3mRiXrV3eftAjlCCrzax10CD7RiYrYRC/MDBWV51wXFl8p1q1Vbk91zuVxqK93Omb +tXQrZFr9PHU9ivYkKOd6yh/3LLoO3qSMxYxoP28DWw8UCyQYiJwEEAECAAYFAlbteCAACgkQ +gb4nlrZQ5IAe6gQAkTR1dVeQ1Kno0KlShRZUlQZrOqDvCDVWexcIH+R+DIY8ETwF7OwptkKW +i3+vG/pe+beC5aniZMVBy6yhgDhzbeG2DwM/p6bWCYSFhx1cVu2goTyFV7AZ6CGTgkumKYO0 +F4oKVDcqAgydqBUfT5sZIuUHK5Lfmn0K20pyWXYpt4SInAQQAQIABgUCVu14IgAKCRAQf6QB +3EXGRQM7A/4l1Mwmi9j7Pr4ZN9OxKHgSlG1+fefBkIyXvKwYC/tqEu6CMmmjyiUAgYsrbWsl +SexOmEGshpBybulHB4E/Q5kTRVh+Qpv2kcEECK9c+rYV8QedNnjDzZdkcJ0i1bPEYIQC6Vun +oqXQJdv6qXNss6TMhCn27dD2GYh0siDKwi11loicBBABAgAGBQJW7XglAAoJEEjOm6tYaR26 +lN8D/Rh1+p0X/UFjVIvmuq1LICKZAG2YppONIv55V/vhiKyFKlVOicq3nqUhy/jURW5GX/Uc +mA9FvfxYg76iiAKtZJ1BQVJ1XeW4o8k+geLfnIvPLt3qGs8zqP0IJM0DgDSCjM2WNKd0fN22 +Uewwoo0ylq14xMKTyLSbQbt6IATMOEWliJwEEAECAAYFAlbteCcACgkQcd9Kb7jPACAwogP9 +EDZTcHwWqCNMfIVqHmFdAF0HO/cmMlvYFRX4GWuAqySa5gs3ZMjCDTO0eGtt2P9gZQbSh77I +Z3BbDEY1Ciy2WR+vofDeMRIGQVliGPBfb3AfY5UadzveQDbyHeaLKnG7qCQlrTeWlnBz9XwJ +i6lG8FIMtlvcqvaAwrJB6/WSdtyInAQQAQIABgUCVu14KQAKCRCgvZ0wGqzRxIvnBACfWZoN +ExW1GLKqYV+IvT9j8LhNJ/uE1/wajBU+hVF7psyEFd2PCx9R/q5FayWHtpjgvVBICIExAR+X +6H6XrvDqnJxVe5ToHhlbRjrLhshkfKgOm20/jnKuVrG9z9aLrweTQiA0txv3Qt0Q+3KlKNQU +wdu6dtvZWfJ9/lFdOqSHz4icBBABAgAGBQJW7XgrAAoJEG6GZkoqfaKt9zEEAIvb4r1JVhbQ +NjUeEovPh/o80ELpePYJ+PLAzw8dU3iU9JS+04BMTNDINn5LT3xyyjvYxKwNNX8VNBsdjfWK +UXEe7lh6Tjmp3P1YUk2EMyYqDHWycfJhda4NypqioGbNVcjCXlSn0d8OgqUenX+D/X2WJR/9 +kl+gb2VveYgO5ydIiJwEEAECAAYFAlbteC4ACgkQyA9dXxNVY5Lj/wP+Nb+QyeQiDoNcpgi2 +d9iJtuhWl3wFqeEZPorL8oCX6ONUhvO5MppsxxWEJp1YrB2O994vSsNSgQUzxecX1/hOVq6n +wN/accXMy36EvVi96Xdxgo8KcLlAwhz7IijcqYT1MkSYe1aw5Ry/CTMgCsmJb8jrqg41oBKG +sWBwryUja6mInAQQAQIABgUCVu14MAAKCRBePCRc32PKuxykA/9ZgbNw8bzhAG1rFCLltx/b +MzLr3h/qm7abjORb4TSrsI9HWMaE/MsJYmCRyZ6oH9WGPBeFs0KjDNOsmzY07z+BVEv7CVmS +8rhgGDQM/CTMWtO2Tv1xWToCHBhyfXjGWoK9KtII2LzvJXJVNTczEcgAJObhEvbxL28S5Wu3 +Q6v2voicBBABAgAGBQJW7XgyAAoJEDGNCaTKsWB/ZpED/iHbY1ygeuepyBLNG/gbPs/dc0bY +RBsOHPN+pkpRGB9fU2+QPjwcQj2GR32Cf+3G0hwaDkTR1FaR/KxnwmeM6FMaJcFgTYjZLWO7 +5Y2YHQbai0PbzIcrkbFkXqGik0arAVZp3RzPDIgzIdcgSbZu+obK8b1eA97vdRyFn7Qkk3xi +iJwEEAECAAYFAlbteDQACgkQP1WlBwkEEdUgQQP+I94YPG7Bvb+/1XSYYZ9tp8zOFvd2T5LD +rqGx8nG7zE/zQgJUnkj2DIe50Yjd6AjZIlt8QunNGZI0fWAhvyZaFOuSwFg26l0tJ76CV1IL +5xZdH7oiTyu7y+ubXtrhCMObY0coYQmadWr3l4l03nAyAY2ibZxnoLlT/2RzjfUTrtGInAQQ +AQIABgUCVu14NwAKCRDy8RtBuVWeNLgvA/9QAKau9tFhku+BC8h7XFljTFveeGYCSxW2JK50 +tHLlTClLNhA9N9tKi2Eu2l3TLKDDgcYoIMuxVguEVRRHKd+csIawQlbAni1jrt0/+l+VjSxb +M97lwJypVoo1k3UONggxFR7MhiGTXr8WVtwul1dRtvN4VvBTPYtaRi5ydHvZEIicBBABAgAG +BQJW7Xg5AAoJEFYh7IcpCtnjz6UEAIuDcCb57hKDxPRytfVhg5l0GWDMWCwqyjU05ZeV7/dJ +69pnYPaVWdhBQOb08V3Sw4evSQjVIXcUmBQyA9oLJQoOB6adjbA0VAy5+2YsZ1mXw3UDgvvJ +J+8safcIQmY2aDIpUwIpVXltBemEKRq/4lbzrIPalXJGrttH+EjM4g5PiJwEEAECAAYFAlbt +eDsACgkQGxxKswJRUYSPdgP+LgG0uqrZ0XvHb7Uae4RVYal00VkYCCIkkPY1lonKHZYtc58b +zw07AU0uVcFqTT8CLPp8SCt/sg9yNGRbt9zYwlxc8hWOQrF764sgE7zyd+3Kqvp58hvrE98t +Nd/duv9/wq2oh2D+M+nhcPKMwMM1DonRxikW0fI4eliRK417oweInAQQAQIABgUCVu14PgAK +CRD7cQCUXYbYYpfoA/47hOgosmJZsomt+Zsp4paaohFR2kUxnSWcj9uhLZVGRZBc+2TzJPYh +cErQYirhTOYTw2uTUcIwjS8UUYpYBQgtSLGMgyWYecmdvSuYT+jpEmUa3kUXO8kuXXHJ+KbK +TQT5QGRYKRlKatFrABWRxM5ouNiwUcOSKUl8H8SbgrXvwIicBBABAgAGBQJW7XhAAAoJEKGT +tBWrgicAY9AD/3ri522ANHWAHd6OlEfSP2593emF6airSGw9sDHg6RLvV6jFhppJWcnrKURH +QGuvUn7RS6XzqNA4uClmiDKZnlDDO7ao/y2JxysjyESpALXAXs8cDueVWIzSwyubJ+B1c9uE +FFnGJVE9RO8HLo7b5RRQBrf3SZawwVBoDqW7IotziJwEEAECAAYFAlbteEIACgkQDysoAT7u +pkyXMwP9GM2uLk9R4+kMwHktDuSGrInJWN2HExiQKnBwPNcZEcI9Wob9r8N+RPVjQ59Dqhej +enpzZqabL+YbDTHI8V5Lknxs2f6GRRaNMubeQAG/IR3TZpg1d3yvWolvbOyJOWDfMtETT6gO +f0pY5xGa5okQyU+L7h4OYZ63RIPO9yy8Lo2InAQQAQIABgUCVu14RAAKCRDfryAtI2JX7yw1 +A/40oEGVU2uFkK/As5/KasRMN0kq9ILJLJdUJD9PLKMiI91cj/+0mrHP0bA9qoTLX1rlfw7r +qdY7+fkyfTtPKjKpc+dlqrp0N/7XOLazl8yzQ0UiVVOVJi7M9pqpSe7FY1f3Uxct48uJndUX +3Zfmhd8G1PDZSAOllAs3Ah7aiYh0qoicBBABAgAGBQJW7XhHAAoJEImJYhR+b9quhYAD/1hN +7lfoOf0Sn4Z/YR1AyTyagxg8dF/erJekiWgxvkt3WwX3dI3mq4tKFjRsyCqLHBhZzbVjPk4C +jdZrchkuzOOtE6cMfxASvSJF6tW3onh6HEV2CQ+marrqvtKO6rRaKIRNanff2JokJjAEh+Ap +b6CG20XUAKtBQRcDHQM3bbxPiJwEEAECAAYFAlbteEkACgkQqV29TVm9vtQK8gP+I6nwbXGA +dxg8m+i1Hh7b+6dfyJ7PRWyFZq3xerrRIcfk0r5U6swxkeUxj8XSbD9EIZMLUzzpNTkrJAPj +fsyBX8eiwurMh5ZKvLgLOTmnbSLvtCiSAaZ1XHEAa9/XfqFwKx3O8o32GwPKR26SVFYeLm8y +PR0v3LD0OrHzdRMQwrKInAQQAQIABgUCVu14SwAKCRChPxbdG5s+48P7BADHv6iiTwJYIIBr +m+ir/xcbfSFFt4GiyCHknHBomqAMes4KX9TkXGyr4a125pwKaiLkjtmUCf/RiUbjPGdVpVAv +Opp1O+WIcGSkDI5PlHo3U1kRpzjVmwGrfz0C4L8RAezSDMY7ncnd1f/kzHM3+FKzYoiMCfvT +Hr5DKmU4OtQLpoicBBABAgAGBQJW7XhNAAoJEJmB2QeUfCVlhjoD/16AkQLsAJZwrkgLO3Wc +MKnkM9Ur1TYm+uX552KPKPN+OYg/9pY/ero1U16TOS6VH31YcyWFCZtZjnmPwIcr29AKjYpn +CsV2izEFGImdxu9EYkb0wW0g5IrehtBN5YyTHz+Aa4APg/a1hkgzJCv1V77qNWpVwYjM9uUv +/kEsuHCliJwEEAECAAYFAlbteE8ACgkQBOA1ZeMLxHwvMwQAkQMz1be8x/9VQOEW4zlkabzM +EQaxKjdRlwpki9za/T2zb8M0VytkJwRai3cDlYmCkbkDfGkBEgiFoO2YD6KlnyzpO+1ScS7F +hwyG4ob9DPwev/iXjhvsrCSxUyknRnpseFNA0836lhPLX+nzanoY9xP/berJzzjj00xt7iK4 +u8uInAQQAQIABgUCVu14UgAKCRCu77cGLvXC4HAbA/0Ynsq5ScV9YPfRFmO2rNP266jLQWnl +knkmSxsatgKzbJHYH+9AMbdFV+bXqAaoVG4MnagEDjgNiQsYF7djU+oz8Kty1o5CPm+jn0Qy +o3hytxC+GVQ12ki+RaSpIr07ns/FDOvVkeSHROJtBb23v/huzFDRBFoFxxpxZA9SsEhJ+oic +BBABAgAGBQJW7XhUAAoJECkduOh1m0UrDx0D/AnozJnPw14P1tNKtjttNoH6wCcTBh3f3iFy +uQQiCny7F54XqA9N50nPX7ISUyykPYOMcwapPP/zyKxWb8j5piPiJCHa5UJIWSgWbrUZ7egV +hd3alSbqN4WwWXQcV7RNzLCawkb1j+rsNsQYP/8KQukMHjACLqq7FqiiplJEuj4xiJwEEAEC +AAYFAlbteFYACgkQKkjOfcSZZYNL8AP/bk8kZ6Wkl7OY68in/Bjkd3WPR5nBdh10Z9Dfsu1H +wJvk3Hgar68ZNwlsNo2kmBxCg209co+sgGpSM/01E6fnPp7/cbnSuGAKDkgXTpH8Bh9Krw0P +eLf1rSVfSbf862NzZq+mkg/U0zaJq4Sk7QQHKHjue6Dp+IUbgFsJG0PVSUmInAQQAQIABgUC +Vu14WAAKCRCngV8KyuR8t/NKBACV3/ZPvVJ6A5JDpss3ICS0/+EcnMSagkPzTj5XOvifsbvL +PMq6vYWOBEFK2JfIVU1ilYHwShouoPe3eb8CMyspJzFZ3AEwNL8hGLWEi/P+w7f2o2HLtvbM +qv+MvFd5raAtXeGnttkwV1amo9bQ2yYBF9gstNGi9P6Nq8B7tcihloicBBABAgAGBQJW7Xha +AAoJEBmKf+xeRU325lID/iix3qpj8g3zMo0AAetW7pajMaw3XPJGh6ttdn5L3kAXTlZqr46i +L5UTSEhjdpkM8yxuKdRn8WVm97yHfD6kMqRUnyR+GIVuIjymqWf6SleuU1ci9235vl4OE2gQ +umGtrYF3e8N1d8vb5xx0H+mq6c3Punyaelys33D3X1wYjMOIiJwEEAECAAYFAlbteF0ACgkQ +ZX1d5NqNSRIKDgQAunPqDHXyqNQay3cHKQpIolG0fJtSw0ldu97QnFsEQSnlZc8JkaIed8BR +YUlFxXDDA5M+Pyalm7EcrgDSV6gMhgvSi36634+OAJyx1xi985pzdCUQZC5zfnAWiysRklBx +oflGHRTkRCTuRHb5vNsLzloKQvv1Zwc/6jWZezBBaF2InAQQAQIABgUCVu14XwAKCRDHxZvc +fDGvAwpjBACt0+9gOwipnnPjt+Psj9mMVG9wXAsz4/L+UeXEBnC4tRsy/E3oZHEyH2kgqx2i +QdpaimcK7xOHW5foZtUJ23rBu9FoTiT7JX/sSpTZ0TTCsXBCVN5atZouoms21kNy4Opinqaf +WPQ7qtIMSkzTXckX0xAKSC6AQhSrczKQzP34BoicBBABAgAGBQJW7XhhAAoJELSYYHxa8wNm +AoAD/R/YLBzwsAZ3yCiN0Zg/+QIkWHHqI9EcmvCO6YHhix1uGAwnmyLUgZ7Syqg396p7LFJB +leNDSTK6KTTHs3ppRs9vMQZot/LnzM/jbHUq06lsF5pv633b6VyjBqajseLzGw3qaE/ghnHM +mujaF43VqOEynYJVL9EIAUkf51TkDKDMiJwEEAECAAYFAlbteGQACgkQ8V5v/7wliDNjHwP9 +Fq0HyfdDnqnmbKhugWeBqKD0a+Mnph74iz5q8qkmYVNHIFLBYhc8XHd+dgQKDKYx4revxjUP +pQRVadzQ0hbkp4yM66zIjye02zxUToouwQSq5VMIXZj+uB61e0AMkW1hXGHIqlXviYVaYalh ++v31tlaFwcfgcGy4j2EO0Vw+bjmInAQQAQIABgUCVu14ZgAKCRDYuPsAfm7nBO3BA/wM7RgQ +TJDSNpjWxDEum7Asz4ITtqCxkZkmZRbNFnyMyWIRc+fb71K3xcEXWWaBvgoh11btgYP+WxDX +fEr4q6gN544G1ORO7IoG283i5Oi98psmOf7i8YyKq7CwfgFvEL5ippu/FGc4LCl/aKOXw5Js +T/DtdmErCW/ChNe2KFqP2oicBBABAgAGBQJW7XhoAAoJEP7cY3+YFY6rk7sD/RBYAIhmHFGx +I/bqFB1rFdY0nyzFgdOGJ9eB8zeFShenslQZ+ZHaoo+VyNaxPbib2+HBgQBAMioF9vLECW8Q +UoYiQi/qFPOORYdIylrzy4YGdTx2b7DcSbbDK8MJEtzk8crHKTeQggGVpAlxg6tRl1EJqHlF +MLP46LfQD3IZcT+jiJwEEAECAAYFAlbteGsACgkQcOdPt03FhOzaCgP/W0gL2oGnhby1TM0q +cfGiBw+8RdnKCCYSXYFSkSGqsYM/pMQLjyFVh9+ONfrA3aqg6xZzlGpz/5ukAS3fxKcR/OpT ++D0n/Jd1aSbx0XZ9IOl3G+cmrg7qm/GDaoHq8R59CvKNP/nf3O9WDQiJWqGkox3/dlTSbyc9 +aS6t5+o42zeInAQQAQIABgUCVu14bQAKCRDycArhB+OLgaM9A/9tNiPd7f1Py3zG+lPqE3zm ++aHsw3tH+hUD2h+bRXsJ44Dvfv5Xr6VyTv5TbDHTNDxsy5o7ZRIfQpOmawvTU9UzjB/z3D2v +VWcDCqQGSchSuGO10zgbB+6kqsQah3fyqOxLw2Zt3maPUbjsRxi/IBPHfBikglzbruxSXxF+ +aS7Xp4icBBABAgAGBQJW7XhvAAoJEJmLFedIyJAOAWsEAJBbJT+7B9jJRVt2aFmwdhF6WMdK +I7j4QVN6ivU+BlKk9El9Rbcd82LZpH7VF+9QYrXSPSRZL4tWuFa+X5W/JH0yRAUUNII6OGNt +U0eWYkKZ8xw03Z21F8DBzSN/fmS14gHF2+2LS8Ka45TemcKj4tlBQKWklSGg44gXZZTEmGJw +iJwEEAECAAYFAlbteHEACgkQiqNOm2FAD/MM/AQAgx/180maIZtsetHBHDW9dGfQXpHArchB +MujuxiJkFDJ03vnn0+IjX82UwHXEtbHiY2NZos5LHO2GmlEmd7PglMAGSud3ojC+6od8nlEb +PtlpRWkfsgOTlZN2KcvzqztzsOmVoWkdeyF3amFrSpEpU81l3mZZIbdef/TQvjhvuTmInAQQ +AQIABgUCVu14dAAKCRB63uqLYenDdbAZA/9QsuSSZyBXB2GpFtuhuVDPK1U01qx5UvkX0zrh +xqwnYbLBEYSSkc+o1YdnFTDOwKHl7fzmohvT56pLHEv7iHO5HwdoE4hqaY4DkYwYYS+0BV+f +MAmZFjji0t78mrhU8an5mW5tLtqR48Y/5/7hOXDlryHRkhq6jo+PbzWU4zAqbIicBBABAgAG +BQJW7Xh2AAoJEHYOxBDuTgNWB+gEAIOtohGPJEIlllv1qW0dfX8rijFyUA2i6eLgEeF0XuoK +09Bi3Cp68xxqlvfa2Z79LwF4HIHPe3YroWTp8CFrzlPy1LJbHcj3WizSQwgtYNVCsIYLG5kt +PKaj1zJUH2nGRIdaqiKHQ5MF7jHQxslR+ZB1OMTsWqdl7vF7TEUiYQRIiJwEEAECAAYFAlbt +eHgACgkQaIC8h6s0qZsnBgP/XM/Vekuq65kecV+s2mfFoIjHNa1EbWHq9zU+s5cav8edzBau +pAok9F7pQe6I9z+QxCDk3L/sdWHvy0eZsx4elJ4tmMcqvTEm+GupgU/wuwGN7zeWdRtyPLXC +Vt2RxikH6FN0gjLIJrjnIZu3n2XH00++BzOmRDi4EXMaZdkQepqInAQQAQIABgUCVu14ewAK +CRDUo1jMXJG8qW+7BACrlQiniE1mlLElRoioWC4XLwEWcdvKAr6P/b60hgNEaUqG403W1PRS +uMqoCTAaszho2qlJuDLArlMJ82On67zfPMPV3A7qCwr9yb7GUfV4RWBM0v74AcdpYccctiId +sK+icOdQl2Hho0tvzxrA2ct8kaXKDKxfJzcHUipfubJi34icBBABAgAGBQJW7Xh9AAoJEAKb +GT0vnyy95F0EAKlZ31jQBC8WM+SkzqvpEG8GBydEFJbdECsabgTStlFCtwgdJrtxqsQ9NlQk +j1TSSAaL/JklfPCHHX5W+z488fdgTq8Ritty6FPfqlP87aTRyP6MnjeY4kjdR71pH8Fpy41K +XF5QSyl//or8EwjOOIdDQicagdxIEDkg6198eP9jiJwEEAECAAYFAlbteH8ACgkQH/jMSl9r +Zto0KAP/WYK8jtkdo6L1K3Jl9VyhPs8hU4ia0yF+NmsQC7RVn2/LDZ30a4CGVBw6qP6GDCQR +v4vn/jYNe5od4LhJp45mIqb/eZJWhefrS6MTT6426KiQNfgP8w0wG78WMGY/fp4JhDx6oJSW +H5CItNlTfxQFkPFR6KTeE5lLbihi32a2/0qInAQQAQIABgUCVu14gQAKCRALPdg5pt8WJ/6B +A/0f9vk79nznod++gdnBB9Yv1eeLDXk99xhD1OqIp+85YobSYVAlqwCXICtYdc8cdqWT0JBS +fUE/pUikg4JnADghEqX2Qcrc5ENPvhvmoEgoD2wzmacy5IVjiMtm11aMKqEfdlmXbTTbQPcl +uT+ichj28ZeIdEZiVirkLDMPWkJGr4icBBABAgAGBQJW7XiEAAoJEG2VQiXG0XJxUx0D/17T +NpSFfuIX63Yj2ffsOqxH65plAQPm6RbcPn5VB/zAt9glxkzC+AbAhaaZBGk69IjPj/Q1k2iZ +5Sz91hZbYR5Msw9BrcXd52NSSe7bszk1x5tH0W/4p59mLrPFpwXA72nQVG38/J3GOAVWVftw +OmrFnGHa1YAyF/Fj21chGq5diJwEEAECAAYFAlbteIYACgkQizbrgunVe4JQYwQAzh3YzF65 +gdApZv+xi90Dpbu8lBUYR1geuYyddOYKR84+/rthYooNu/7E5rSiqcbBy+dmz3ucFnbUmYoO +xKbZjLrSHKnrrCxEB1VcVAkUnMAl0nF5luepXDwfsVP1tpdZOILmsEU7/rnSRn717jwtNCqb +p3Xwor+UkYiUoMg1E4SInAQQAQIABgUCVu14iAAKCRBYhbkXRj+NhEZaA/989TgQxFRPe4L7 +Erycdenq1SAb4Q5DpJad2kkJ+IbVvtEl9eo0PDMDv+0aG3ZG4hctlTiyIsrvQPor5XaszAZU +0kG0mBVYylYE2Rq3qInfYNFKRkzuHtE1STt+gbqnGTHAc5E67dfYVWY1VoS6gk/i7gz9yYXy +JIPzS58zUn4Yg4icBBABAgAGBQJW7XiKAAoJEOFlXtRGCHBjtzAEAKmQ3v63OotnOlz4Gf0q +lYxR4PtMLOcPGzXE3LCizKuw1bb+G5IBocr3xzDTEqJTcUOZ/20aaCzk1Yf8kYc5K/6RtPls +K9st8VILQ6dytj4NG9J/L2fGNMDvDRwTfJfmYJncaELynFhXWsSpJ54g9A9KKa9ZGPk6nU7J +m4B41tFciJwEEAECAAYFAlbteI0ACgkQPnBR95N0s9yaawP/Xv9JoHGMWR13o2/MAumn4ZRm +dN4Sv1dBrA3tjonyqnUclOMCs4ySTJ6f/OSnvOLsRC3ldst/LwJlp5yn8t/nWTw6kGu1cTtP +hTQCw4wWOoyZO8rSizQ5E2DCbZZ3pcBdqlcbPaA+tf4Ma5fvN1nnaA9pH2E+moNIJLdXw0OP +cJiInAQQAQIABgUCVu14jwAKCRCo7b5fEYQRHxyHA/9bFc6TGHaNhFpf0yiy87BuI+Pp7feM +N5mZmf65KjhM9kh6K1C1XAyhYaULyQSnR1hYzaj6b8W+glXzz4aWqWH7WhJFIubJKHKS6/a2 +MRf3XSA3xQem9jgcYqpJXQKQsNjZeaJhbhaEw1xlfz56ZSGew4vNkoo6pEK+r7zg2wCcpIic +BBABAgAGBQJW7XiRAAoJEF8svDnlzzWsdKIEAMv6d2ra3q0hEVYD+h5mnHvJUYpVNTQA175d +HzAvS5F6rgKwTxLfJW+p/DQc2N4duRt7p2Izb9bK0wlv5uIUjt+qHrdC2vmJAH0cNLB6H9hA +5RUUVk4W5/NJ89V7RHKLgg1zckopOYqdFGakkC4pHPhiUHuQ+neyuhOOxFMp5jYPiJwEEAEC +AAYFAlbteJMACgkQyfxbVlpWuLbfSgP+PiurNmFCrBR4JMbaxZujspRwmSbXn7tecrIXLwuf +wYylWViBd8vBw/LYHqSz4kIcqWNfKANuEnGsKygZDPu1ad243aiJCOmn84Xlv0HfIXEfCeVO +8cZvxj3A85cnaaBrkxThbjJdyCF6Nhh+xUYgvu0AGdbk8pxNm2yoVqGvdNKInAQQAQIABgUC +Vu14lgAKCRD+ObTFYlfxt9v4BACB9jujFslcNdOV6ss4M9NfEzyRLUbnQSvq1+Oyfpav4g91 +VemSpVeeVblWVBbaxrwf1uOBjIIWuAMi9zND8qbqvlzCbuX/kDET2mkO+b1VierYfALXHYhp +/C7Vf4vH8do6Psnm5OD4qaHSSBegYaA1wBlaEvwLGRZImvjdbnRZaoicBBABAgAGBQJW7XiY +AAoJEA3U2BcDHtewifsD/jWkj01AHDN8BtuqCsNmv4qDIu7ZhEgy4mwPS/ETls0qBwC3wc7J +PoxFbYx51EtzGbf734+QF9doczklXM5Ppsgr/LKbxhuce3/0aS25dYZ3rS7e/+VtafVZ6xZQ +nusczoNNU97KA4XkrD7n9ARQm70pTNHsfQaF6qHe9KquPzLUiJwEEAECAAYFAlbteJoACgkQ +aR/hWlZs+HJFSgP/TFAkxcIQNx2hAMIcbspqopfYzJ52NOV7/XbypeR0i2blWTAwR2IT2U2j +VsgdIt0tZNtpGjYkFMu5FZsprrschEiFia94Rqw3A0FKYiYRuX9Vd1MqGmf5xCmvbKQ9hb1S +owQh13kIhYQgwUy6odeztLtR4NXQXED9n5pjWF3RvjaInAQQAQIABgUCVu14nAAKCRBby8zN +4l0iNhlEBACfwaREEMqs1cM2VSnvVj014eaJeEoYMi4MT5DYLFLngLiY5Y358MFKVKsmpHQ4 +YYllFVT2RDlsvjWmDANYLp3VwDaAJBWJKvW6bHUQJoxQv8JI9rTEBQtkWFTNYh1LL6axAZqm +gSpGHFmtb10+f5LdKrwAn/N3cDXq1mZvpLiGhoicBBABAgAGBQJW7XifAAoJECEy9NId8gPy +z6sEALgvjv0akp6XUxFwYcAU2BnQayD/YT10W3LlwMSOp/3Jc5LfCzqgrqvYc81c7Wougrbi +NzbGEi+Th7Sl043+yZn+LmMy788wwKRzI/KvriCjZ+xLRpne9qGDvnzizW2NmJXhhUiNzDa1 +o7RICBevCSL5ohvf2Cjt46x1iJNwM2YviJwEEAECAAYFAlbteKEACgkQeeiEkMVfIgjKKwP/ +RRuzN6rqnEw6US5EWEXfPC8O9Rt9LLgiwEXS/ndJtpCMz+xFkb7xQgtEOwVkw1qCy1OxzVut +aAoJR2NpnnFVQAD0wobfTxq0hStsfP107anTen/27I7WaY6lNNCFev25s/Q4WY8kZA5hR9d9 +jA4Xq5TxmqAik1n9ObAd1wp6IriInAQQAQIABgUCVu14pAAKCRCqz6qX3xLth82VBACkB6Ky +emyav8GT5MnNjQy7eltm9RH8qx84Rb8mYP6YOL0f01pVlibeyq4isU/6AQrAA7ym0+m7Yc27 +p7aUfkRokfv55yLAAA/Zsu5/azpr7TxOma49IcM6TqGZ1+aW6EDrklmoFHnd2AJd9aKfbcyz +kfOw4wKu3P0pBL8l6h+O84icBBABAgAGBQJW7XinAAoJEIwrt5I2LL9PwM0D/0jrwCJnaE2a ++fv8Hl8itLt03XNOEWCOmASd+988f0nHcuNzlLWsvF6qVqgq65lxQdmh3O6RhML9trvoD2ao +7FRKsqcQkSSw50whXyh1upK9wTAVFfGI4oyFYCcv5CsVZnuaaqZZH8N2ZWUpltEnGnbLtVa5 +mfpkbKZQyt+ZtEtgiJwEEAECAAYFAlbue3YACgkQmw5cbAsiDZQZ5QP/V/68VL1Bw9mApjtd +AuGaqFUKChPQubon092DtOz8Prw+3pWVyt1PgtYpIbFAqFNKDqpEWwz4jEZ5OV/WTygZdCo8 +bRp/DjYNale7MmiFcZR5rCpp0Ipa1+7qaZjmkw0hKnlMofiqvwfH2RFaCTTUjmhEsqmR8Snq +GWyRQWOdTcKInAQQAQIABgUCVu57eQAKCRB16evjmuSfYDsOBAC8WBMncR7pO09UuPpCAdnn +W6yKGzDMzWiTMVMmrRtwY6AFuLnE9iI46R1q7Wjhz+LsWJq1Kgs3omt/9C33rcOT7ctwj3hs +i/Hd+DUQaa2tByqPlp8lVyJnuEaT5c1gGxlwhjvhBpbhRLRV8GJmQBKCn4qRzwwnxMllBeo6 +TALYt4icBBABAgAGBQJW7nt8AAoJENxxn2iyE0x8MrcEAJBNLS9L+Zw//UHWwpnnZ1j1bGt/ +xltKehIQMDxieXVJCEH9+28NStchVTvRALfCC4Kz4Vgv2SeoZ2hx2QqbUqOS711Y60q3fWjU +a5If+fa5mP/T479DuiDs9UC7mEC7CmMT7i4KYw9HdtZbSqGLb+bB4AnKQ+Xee5pcbBIYTO/y +iJwEEAECAAYFAlbue38ACgkQDygaT+GEqx2tzQP/V8RX48ozlhN+GYIj9zG9Ta/zSzldH6I2 +87RTLDSmVj2bQy6E4lgfuOny6CC8pklGYLqnNqQQIggAjHcBUosaOxBSVROh6FuyTXRCfPhu +vgEXuyh+ctgb3b42emVp9KDB41iiUiA2s0CKMTbRGNLPh9+kgKt68+bCwOxWi73JSBiInAQQ +AQIABgUCVu57ggAKCRDf4EJ8x7QdVkB9A/9P2kCGC6wcidEXUGS6t2YQhOZbuLk23pitzUUp +I75jI9fCt5QDPZ+9w7coOgRpPrVwb8aYYsGcBFS10ku1qxXZAebAcAa/dZRDHEXWDKZGdovL +BNLuV0rXYsv381pRVMGV4Q6RXC5FHLPAvcu3ClKFgi8+RsHKGP8qKu763wrIFYicBBABAgAG +BQJW7nuFAAoJECSCXnZo8Pgm2gAEAKFenXs9kzXqPWgP+lpl7qVhp+Y/x6RjEuqKh9Dg6xz/ +jg2Y4Y309P9FoPhhi3B1E/RUUX9FcPxVcbhv4NYXxNHZ8NcnnzwNDMxSquaT/QEYnhrvWhZe +WfWwnKGPVg0FYa6U0ZlyumHA4ZiaX4lDR6g5CqgqtgpChk7iGql6RbsfiJwEEAECAAYFAlbu +e4gACgkQkkONCR52lTqNdwP6AnPCHKgEWRu2u4kAh+7KNq4PigIlVMALEyNMw/tInDLQAOUa +auMHlaBbnwooaoYtpadTjRAA1aJx/TUvjDoIHMITofhIQE447FNuvzadVtrP+HLckQ78hKfE +19NzYQfLy4F1e0+sfeIRmQO/f0SUQyFzcvUe8gDRp6NwDwLxtcyInAQQAQIABgUCVu57iwAK +CRBfd24KyU5YLkgIA/9sImkxOytZJ3AjsrqlpjWPEW7zs5UCAP9YCABv+VRJ1Kjk7RAV2hS9 +NeCzph2IA1b6CkAfwG4oTDSlRUZUYBoo2S2BALT7q0Cfy5odmONRAyZ6GxOUykSb28T2Grya +URuDQZ7/RTowjMn+cD6UjLQhMNWeRuLFTTdIU1JQfURj24icBBABAgAGBQJW7nuNAAoJEOHW +mZrcmmDwd4wEAIUQtp9cAlelCK92qJood2CeU39cZyne+ixSBtUruHbO7KgzzkDQVSKhmS5k +1tGwIoza4RBQ6Ong4PIRGq9+vegkPm5DYaOT4MG2mfxcvgdXwX6DxTgOIWFOD3fIkXc4t6/5 +jAL+OiUPRUI5Iu7fU5OCZsUjc+XDBqWKUlux4yT3iJwEEAECAAYFAlbue5AACgkQnsbEojJp +q61rawP/QGmOicbiSv7vsqJVFm7wJyevv1XrsQnkykPyfzRfj7Iab75KxbxQhrjuIss1qSam +cbRAnXSL+pyonn74+N+EeU2yuiAYNIxjrCe3tgDeqzg6rFDPz+25zfT83Q6h62DAvEKta+XM +Ffc5j+GBWFSTGsEcE7t4grEVKELMeEy1qyWInAQQAQIABgUCVu57kwAKCRBYZqIYEWP560+/ +A/9Znj8xKCJJjdNfC5HDF8zIbCzencgt8y9IEEH3tM7bNmBNz3Qd2d+NI5KrO2FBSmDOrGr4 +yXSZgohhoSOc85myKIK9/DXFGmlVzaPjcCwlHh1sc/1F/b5DL2AjtAb6smVtVKVvZlDx673k +9KN8pKEXluthAl5dHih3KpOTELdHOYicBBABAgAGBQJW7nuWAAoJEN/JpsudgFpLEFUD/2jA +DvUib4R9rD+W4G7PZfuweX9zB9rBam+Q8awCcHpFHskjrRNtdF1WF4+fqlKzXbJRXKQupDLJ +QAqzW/SDOhQxQX30UQDDSF7PvbVLGlvj6I16hQN6hjgHjiAryc9LVSRtAlhqJzUn0EJsiTl8 +h0SxnQs4nQcnON0Ne/9leDv8iJwEEAECAAYFAlbue5kACgkQZ0633+Ed8n2sQQQAnLcctotr ++5Mcg2vbpXGoDG9AGR3oCD0E/2STDDfDkhkdOnSHB23Ra3XLQOjPyClqDEb1DadjZ3F02vPh +537u7HTrKHKjz7+cbXOu4ACAqlwpgz8ea6vUGxUCKQJHFjXhRFnNNDDO03EB4jtq904vyy7k +nLV6h3SK1C8uRygBgKeInAQQAQIABgUCVu57mwAKCRD/Ez37QYC34WW5BACW+lA5Ti09rRYi ++j25z8FzMarJGIHVmfdj+Mr+ak9t9Yefn4LmH0Iixdasf9+DYHfvxSOsp57nTaxZ9XOzPJUY +fWGxR+PkSv9N/vXJBlHFpv8FxD+YHd31/28f8bJbK+e0pC/31Yt2M/zm8/5sMKewZP8SpieC +r/U+g6a7o0+ONIicBBABAgAGBQJW7nueAAoJEHzjTm241gfOCXYD/39j4n+CIJi/RORIIFch +F8IELwE/e574I+g32EgClHjiGyGwqQKvs512p9ZH2whgty4kRKpBj+8oa28iBcXySlk4lK42 ++zSNDcYZSOvaEBUB/5eye8qQHXCqB1iSqXCQ94AitV/u9syLbikqtNvMfVkD2j/lLYHHTyUV +dkybNRy2iJwEEAECAAYFAlbue6EACgkQGF9Rf6u71YBMHgP+MLNXcp0fNKijP1sxg4lwSwd0 +fOUDwgD7NNGLUFbU1jVOLajDYuXvh7FKKUdLHojHDOPmAR+GEWDzQ3VWrm37D+DbXnl2Y4mM +ju8F6UuMb3JtkwwZe3uI26k/y7yEiKbWmuIu9fZJ5aLbWpHjUzR7+F7LWhg8DTEQhAPT1Ucs +VVKInAQQAQIABgUCVu57pAAKCRA1LCXDHKOhKS0UA/4hGn1pE0xpmT7RqSQR5bnfLfZfqWN4 +ErTyF37RpSe47ucOq8GDmb4cs5A9T/m5Xe3n2GJUhVYOAV8cDBKz7IYooGncTu1fcec5HekA +1cebz7Uk/fXn54sxfkxREIDcVXQr3+GFPpvu052OpinTcqmYm1x4e5bR42EaIUo5EtLGjoic +BBABAgAGBQJW7numAAoJEEqOQfZJ4uyRiBYD/3UMpfC7mF2zmLhqX2TnqOY09asKldoRTFlL +QelBNQHPy9kDItQfphHuco4cE00pvXhkRTZa63GxngkKpNq9ve0CMZcB1u5zmI0btOWontRr +NCH76k38Aq6X9moWPmfcw8Nbf9b8Jzi1r8uG5hBisz9SwNMjwFaOPAU87gjVAmkEiJwEEAEC +AAYFAlbue6kACgkQA29GbB5DEszs+AQAknoEu2UFvzDQhJVSmwe74jNGqITYa9RLuCFlM48v +l6/YcfB9ZrHx5vDdX0amLm6KFfL3wwgsfdPARBAne/iJ8LC2V5RfZ/yYbgHggoLlUeb0rqoM +IH2pU/7g4guSXUUuZEcEew78JH8NqfbnhALL6RdnFQa3GZv3vvzbAcMkQzOInAQQAQIABgUC +Vu57rAAKCRBAZHgppABIteEYBACo5QdD7a71vAdtNOv0RAnrI6xnlfATsgDeVF8EHlP95B8P +JjKhi9gZlEelR6VQ9qUgw5a2GGodXQeyYhuQtxO+EnCJ/N23q2Ly9dCiZDcqA9m5/l0SiA6L +Je+FUYtkZUzKdfCT3ZtHH/MHWSa0KSdKoy4onnP4AiM9HvONVLIX5IicBBABAgAGBQJW7nuv +AAoJEHKuFlsRiVyDmAgEAMpkcFTSRi6hp98/n19GKGPf5T+pL9eFST6z32zmNRaKn/yVjTRY +P2EHG1E5WKL9jvbDplj2z8DFiicBlKto2YL2Kia4KmkACeuqH6B7eclno4b/sOT8DVKviw43 +IZk0waETyY71uPbHuOkmJslAmlJJ+91Yk80ZVoPnhd8UhqKMiJwEEAECAAYFAlbue7IACgkQ +6IKfsaBeEOGPTgP+PGgf842tGli4q2ZLaZCoUI/lBTuBTyKbYy7KM0KbcalpTigrI+OFarW4 +sxQgp9DAlEz7w9qGpDdytrtGDfvVJB9Hq2qJfeM+hMNGeE7fwFMo6I3OLFdCCO9sPjwczgvm +23LxzWtdukqNQ4LTt3ungjo9eLLuCdbxwc+SvNsIhumInAQQAQIABgUCVu57tQAKCRDZE17N +/nBVMliqA/9PCT+yp4utQuyS+Gp27XfXnjT1kxaKNEcfHaXar9mEz/jrvuaelCe35SJsNH01 +nY91Ty/lCysAGnaFjGahWGeZ2HHScStmNRB2TgFu0MzIRkQs/SJWhFWVTQLyn364zXQ/K96m +gn8JeG37BasGyl2iz9sMHAICCfj1knERUl9HdoicBBABAgAGBQJW7nu4AAoJEGI37JV7pAUG +vY8EAJC7xa1OOaokaCMcaOEo3sbZTNUTSExy0bs7hq6vDM8OBTtqtI1dZeE5ProuqpR0cxMo +ZFXL7g/a2A11Mk6SeuCHWGxRTK4+GwDHtkw1mfsct1crAMpIrdNviAcC4H9bgGqqdW2RD13l +Ql6fveHAazP5H4X2vmVWwlqRqPGIBN9iiJwEEAECAAYFAlbue7oACgkQGuiJHHoQQv2I2AQA +rZXVnIMarrztyS5gEMHrZJQyvR8+aHUAL3Gkk3Juqraq0bq55mFzGE+qIiSBM+ZGcnHgSGMX +mmUqJf85Cy6C+8GQbwN4d0GZSeXkyp8EOpwK8G1r2R4R6shShhCw6d/KZ7BPMx3snawi1QTH +zCCoGUjKb9yH1g3Q5TkDyRmkhYiInAQQAQIABgUCVu57vQAKCRAvu2r1DRU2ChKxBACWARw1 +zh/Hke4PziQMo5gv19MKp+9QqKlqYIFhqsrn07voAUiQdk+r7PRirvrUVl7f8gCWBQKMtxEN +4HmnE8A7slXOERDbrDojPcUSD1ZTIKDcUWyv3iYTwhzENEKJBKJYaew2JMlXHBH5sHzXypqG +NG0HiDoaSlRPt773sJ0ZoYicBBABAgAGBQJW7nvAAAoJEKBYxujTZrYqRRoEAKChuPIJUzTW +WP/0JixV+eq+Av+Gju3zxc0PTacE1U1x7n+qRX3GhY8JMjWmm0AIj1Wzi7XCLNOVhMGN2VNh +wHrVaaDE9yDOtU+sybJockhnqoBQlhw/nd2emtlaeUoTfztFQPCUDUykFK5pFopcB1S5O6Ii +odl47+TJddZyF6qliJwEEAECAAYFAlbue8MACgkQJC+HFtKKlEBcRwP8D1soD4mSOvM5D6Kw +uS2QvU5dbn6iKg3sV2xAjdcoJrPjd98T/GT7SCWuzChoT8YFk+Dz+dLvXpaEPnRlwU2Ry96P +COem2/rVlIsc5DTzVG0DTdxu8oQd6hOlWxC+jFHUWmcefJC7J9UvWUPKbA/KFPvln4nqOMjF +eCkilAOV43mInAQQAQIABgUCVu57xgAKCRCTg/SgpHemB84MBADD5HH9LFL3QvsGO/3qEROt +8CEnj20NKZwea74jyD3HP+eiiZ9muG0JiJx9kfJJyZxAN2xhefeIIY9lk0xMT+eodNYg3YQ1 +oOtx9O4/QV4sRZV9yQd4iz4c3t1zPlEN4B9MzKLRNl9V42u6J0A+IkG1tY8cPwvZUPBXCS6j +C76m7IicBBABAgAGBQJW7nvIAAoJEKR0W/zAS4KdDxUD/imSlbL3BY9bxDOtplfpB26UzGd8 +XgvRAR8F9YmN6rV9w1OmEjLwqySHwxKqZfxklEpCsa+YDcfKXYpBKtt6RO/rMXAK5nQRqHlI +01ZS85gPqDb22nYHf7rJYSbCbmZNKnuh1IwfzqM0PFOGV0i+mSdwGOvk91rMlHm4XNp0Q+Fa +iJwEEAECAAYFAlbue8sACgkQoHGeLBHFhmmyPQQAkAbqeSILloToLdsxrz7jRDj3dTgGlP/F +0RirxFrwm/giTBZYP2259xKZK0AMJydwQp9fm2jw002Jcgk0yKu5AL3bukkMXU7EDFBByvAm +rZPn+yTrIerCa8XWQ+4+SJYYoHPol87mrK/9vL6S4ObwNp33O27+NfEOev0N4Jd5t52InAQQ +AQIABgUCVu57zgAKCRBja0wx2XDQ6fUDA/sGuf3+YwpyQkcSAZf04fvbbTG9IynuxeYh9dyq +sQ5zJzcYjkwh584Ol2+vtWa2CzDFPWxfxcq9gF+dLNRPsgGU6fYhDt/BG4xh9nqxqTusJbuP +VqW8yDLcuGOX9nnSUDRkWL9OKNSkEFrP5ffekZQbsIoXXLNZGPSWg+viPncvuYicBBABAgAG +BQJW7nvRAAoJEO5xa062bxMVIHwEALbj11SELWXVJRbcbuaK+fn/6TlzAnvcNYJwBAWx0miv +m7rRsXJejRSvgagzlLmVYNnQA2arL4NBdcWbfuThRnMKVUOBWA/P1c4JW0djVV3oZBX//equ +lp0vXcUcQRGy0pfnFOmEdQ5/MJ++KkMQSpMr4E4QefAzZ5k4tcttEO6+iJwEEAECAAYFAlbu +e9QACgkQlN9Go7XnUTa9mAP/Wo7lRELeQrVJZdniahzgJLjH43yBj9hHbJkFWQRtigzgcXb2 +wm/4tYf8OUA1mkAKHW5KIzx4sg7LqI678IL5oZPW2wSG+rW6f48JK2ansY8/X0bVTeRWUfW1 +oWFoqoNiJpATErmXKZXntOmayEtA0Gi7jPbqA2V5bOMMAiuCMGGInAQQAQIABgUCVu571gAK +CRDWdLs4Yqww5fueA/9iozzdOktu96iJ1Lt8eYQl1IrIm0kMuWSsHWQCTMGAEpN3/441fR0D +52qfjDeecPtyCGSp17umthM3ttT2qFu2YAUXQJ9cUe3WJcJhC0jW1o+hQti1OVePUExF183P +3v2MpnHgoHRZBfUYVTDu+J+mq+SNpAExWe4dHpSq/pfQ54icBBABAgAGBQJW7nvZAAoJEC2s +/GYPO5gEQUgEAI+gIT30LuKPwhKif/65voNmFiQHzRvlgKil6+1S4x1xDe8tUk7bcLwbvRgZ +o7CxWkQuyfz+0uH877Ul/dDFO1gHI4TjYkGrmQFyxSdjjTehPRmBAxZ56MS4g/TZUgCETH6K +MqOUggkAqo0E0+d/4yxC6zJp5p0K+IZTwBgL+nKiiJwEEAECAAYFAlbue9wACgkQX/uiING3 +9hildgP/aSLO/FNDNQ+v8dqRVpne/jsHbokY3cECjvUBpC7OYdlMsFkvyiOtbe6D4A6Oz2N8 +Wr+9kWRFeoi/D0DEoEiu+0Ku6uKegTq2Ecjr8/FrkJl8yboI5a+NIfEq11i79gc0SxUHkriA +yv3wqIFyYPLQiEFwufpdXd8djuqw/ZAMEQWInAQQAQIABgUCVu573wAKCRDYo5iCofQVeT4k +A/9bsxmhHcd0y6HQrT2MyNrmOsABeEkAcg2knaqKWUxKWIQLFTslB2/Ub54NiZkVtaFPK2/t +m0QgUbZEuxNn6b2Pvz63xJD98pIeeP/5Hs5D+7Eq5c4kYeJdTB47oRtjtScPlfWDA5272wc+ +hGnZUqel9uVvb2GaD4CY/IGM48iegYicBBABAgAGBQJW7nvhAAoJECJ7pcrx9CzMOkAD/jwJ +XD26jyBkRBrOhp08tyllPm3LOn+LWhQd/sAGelEAWRsL67SeGmmQn4o5BGypDaIbm7YpsVVw +XMKczPJ4V4UDQPb3VcrTP9kY09e/OTBpWvYsv52afrZBw10DprQjwkjq66AHh8OBtzOE4G7B +xFGfRWFYw4s1im9j4PaD5RoxiJwEEAECAAYFAlbue+QACgkQd7f2RN4Xt+464AP/cKr4zViY +JJjuzYXsqwm2ihjSZkGLqKigELx1eVe4xJvWS2vdTBhyKEvoO88RAwUxvYcD/6EOW1bfDb5A +qg2SFV4oqVP1Q9EcP/YYMexvz+c8vofRRJrQhuf65f7mJZXbQSUH/fGa+/Q14glzKBPVACo6 +GGe/y6TJ4xK7tJ50EG2InAQQAQIABgUCVu575wAKCRBPDIOlEhEKGXE2BACc+++XKESCQpoq +GpPRZR/vCKXo7cccPYUHh5surGSbFNYaPMlSXp/Tj9Zq/IR1G5oxqZCg3VeRV9RJGHAaY8I7 +dNhK1eLOBt+Ze2u94TwnFPnWq5E7dvkmlXci5fTalVUXdZjexhwz1hSAdQMK4Pz0Z0TXQqKY +ysymkWBmEJM1dIicBBABAgAGBQJW7nvqAAoJEJS8j99CZNqAQZEEAMFzJoUzNONm+VdG9sBe +OlE18rtc7ZWJtAnJCGMrZ3dz6ldo4VktJk/hld6LMsclMcqP7sL99pfQYr0fCdw3yxv0nuW6 +SnFGZdlI0H7/+FG82CwmhWLv9ZuS97r2BLSY7m42kbrNbIJDo24k264YrVRQ/XwlofNnT0eW +ndWuhpWtiJwEEAECAAYFAlbue+0ACgkQpee2a/fVoArMzAP/VlONrWtW2ycz6mpJPv9hSxmK +SvKZ421zrfAcnxcHOtKx6dE8BRzFGWJYKW6kk1Q3RFgB/y28Bs02QK2vSymF1mJ6xh/kV8gH +XiY77JJfbcMaVYfubSXw3jzE4UvlwGQVe0EV7VLR+ewWfnCAq76jmxMD+ppfHzmQBBJV4rSw +OdSInAQQAQIABgUCVu577wAKCRDCjQ5dHb08BySIA/92FpVjuSW3PEuYfmCKlCYSnVDbLAFh +5q2WPzBr/GGWe+WegYbDxci5egd2+6kONonpjawnffnpAEZpLwwidsfPFLwb+faR3r1WiFlX +XMiJEQHw1++NnbDPeSGVl+EsVHbSqCZ6q8pzRrdIh47xGjvXKUiuCS8wgpnhZMiQ5oXpxIic +BBABAgAGBQJW7nvyAAoJEPCSEkxRlFwTQAEEAJP+2HrFWAtX0IkGcMgcIki8m0V9YKOHZnPe +AvAsMwwW4nLorxPy/8EUVaoJuNGP9LmFGFsw0PkEwKQx9hWw5dSgWWyRfx4PWp0RYdvFXH4c +41iEJGS1pggUJGlWfAlaZ5OHiHOMytjW3AD+8CxUIQv5X/hZhwqeSeuyeOwuuJPtiJwEEAEC +AAYFAlbue/UACgkQgzbRtkpkkaoC1wQAoodLqPf6u3yHn6kehdo1X13y6+nQvR8f+2n05qGO +r6FvxB/O00gQFgBU3pDLsIV+2QPRF/Ua2o4G5d7zl4UBzjfjw89URzdj/TraokH3hwR9o1Af +Zhte6nEW4QibbQ9aPn2ygY3dFs9aurAOeMxyavol18HcY0SqWD5nd34TVq2InAQQAQIABgUC +Vu57+AAKCRD9oaTxFEP8fsk2A/0VA9LQ0Uc4/RbPbluiM1cfQNRQqkpi8PTovmzp1Cesjs4W +H8lbr4FiJUFl+Jj0N92NyLByk1fJUaLoUIG0WZj+WJyQuPu3tPTFlTL/cSX91A8UrqLU+v5C +jKjxJTNf4h/7NNx/OqQYjYsApUmW2ibDWW4fYIR+53sxDklmYANazYicBBABAgAGBQJW7nv6 +AAoJEKw0ZeXHgR0ZiDcEAIKqkGgvCgVF/SBdTLHj+E6Es2ri3x5tD8TEcs160n1rwZf+qmff +QCrJBGeu7trMJDgckn+ysnqd2lmNVrbosNvy52gSQvuCxtUXNs+RM9G9yFXy+u8Y8jy+Xkp3 +WfG47R/CFOUOS58kUL86vbA5intJnV3bPgl6qQQxHKwulNL9iJwEEAECAAYFAlbue/0ACgkQ +X+E5IYJLSOgoAwP/Shj4ZEvGsDTQSQ8e1tOyOKc7NWNcrPIDazFRMeInGT6NX0/ZBcjBYYA0 +d9ur/sPDkdRKmpSpNuL7G1XUTVzaixcuKvHwsronZraAzVl0D7vWaGYq0N7a6oR8/+3Lbcye +YuCmT2hPCdUbFN6VBQDJIEE7Na9YrLocUFuAw6aZ6WSInAQQAQIABgUCVu58AAAKCRDGBKpV +s38A3kt0A/93SpSmEKsIshGZjADnUkxHpUqhriIc4AGVVaAGzpSHApDZ2fizn7MUxO1r/R2/ +EX26CLUy8d1DjXBcESuVgw4c0JgU5i1WaLcPUzj4wp3MjctJDszC7UaTZAzX8bQP/UWWjFaQ +YC9rVahfharZw6ZFKoeGf8u1FTzbNazLCAlWa4icBBABAgAGBQJW7nwDAAoJELJPvTkzZ4Yy +yLkEAJ8KSIhUDW3Mn++Njj+kjGeLVpdjO96ihqtMW6TKEYENb3QEZgR41kesHBL0d7YBxiqi +g8f9P28k1pctT4/5vI1FUMu27fig7h9IrRNGJKSHZITBgaM6sJQ0KbRTaiMjC8eaZezmW586 +GR/kYOYkhvAX0ySoP3vS/tL+jBHG0vRyiJwEEAECAAYFAlbufAYACgkQpQaTEjU2BGaTAgP9 +GJCsJVQiHQZerGxZjQUir+3iJy9CURtxbv3B6uL8vCR6FCVSS0jHuzrAvGZTpVdYesLxo7MX +CThS4YW9D5YC7HM87vqq0iW/kY+1Su08lZtcul6QiQ1nJF5VQickozsuWTwUCprJSZjtj+iA +BYe+waoVKNOfsBU17CsDIuzBLlWInAQQAQIABgUCVu58CAAKCRAGh7XTYnnYjIC9A/4qFnao +GZiUV9ApcSTy9wgPW4TCo2aGzleKK/Aio/8az+ivVd12L2JZGFaXJOpKYYPUBmZzKCvpmgdQ +/ilUn9xE/DTBDoQr4B6pdQ00tk3XA82mfg42PhYGZvPqS27DraCGFttgCfY/Jl5Ui3XAdjXW +p8fXR/SdUok8g9e4krl6E4icBBABAgAGBQJW7nwLAAoJEFZBVzqaRL9piHgEALHCNA4ceixd +TBjZnxNmvtgNbryutUq+Wgj5NHImO2MqaZLFQFOazdE8IiUCaG1jJVIA66DY5tcktodgb2QE +ssTSM8U0z0ijZ3mJT/7olsDBCFYsDf/v7kNyaFlwhS7FbZmm6OyUGrH7qt5cNS+iff5kmOgc +sla2ei/hm7JOJA0YiJwEEAECAAYFAlbufA4ACgkQ6f4kO4EGChWfbgQAjZnhxoTGvD0CDNwo +UIacUAbJwRsMQhaGNhdwR/4vzAW657AQpiQbg8IVGgx6cW+5Xmb6slEZ0wnp5LUCNZfsM70i +ESGJ7nItNvKsk06YuXdiQdYJbYJW9TTzcBGPMCRNZyFhnojyu+fHmAcDVMx6KYoYNXELkIKS ++35Lf0XnvS6InAQQAQIABgUCVu58EQAKCRBG95u9EqjOTQK2A/9w4ic8XvvSHZysanA0UMoY +l0p+euJ6LvpYjQHBk5ZhIU6qkfHt22CgnuEgryro2t/Yxr/X1Fs8d/2DdsxelrHfxuT/xUZV +pf00q+yCk/wMxdCLuZHiM8ncyTluEi7a1sNpZKNgAJBHFHjSDJSzKtMoql+tk9ctqKEZHpYH +q+ppNYicBBABAgAGBQJW7nwUAAoJEN3lly4nsyOjC2YEANAhTnMVmA2D7UGPpiKLUlLn5wSU +0gnsPoNnB24BCvCVfjI99GF/v1G/bKDxgapawmFjrreumvs98kv4JDfKl9nODiK0437cYN5O +7mn+8H2AweF8JLR9mijPgxd7StTIzcSmd0MCY9qpBvaRpTsqjCvu+Wtgwws7RirZ+QN4WP0q +iJwEEAECAAYFAlbufBcACgkQeMvd0oX0HlUS5AP/YkO5r+vxrhuxbUYILbONM1tyBX+SvgMP +QNYWoN9bWK1x5VPU8GNJXPqL+G9SFTrq+PAHU/BMEkI8N78ViG50PZ4ghMjdNiSk2fr05DPk +1757mR88yMY/ErD0VNk48T36DOTI4G9DrAZuqNKxHH6WzncEAJUFxmC9tdqSMDiDVu2InAQQ +AQIABgUCVu58GQAKCRCGFwSJ25T4pwg0A/9c49HSXXTf/DWH694b6mdYOKvUviBCt9PxR5W1 +uSwu7+Gi8Qja2dW5u9Wk60/QCYQZrqNknnjr4R1cEUTScSYn0zR+u57qBz96ngibIjcnZ3gU +6IhjERQLqLALW2jJhy6PGPNuELc3KIUT9f9ZWQZTazrYTqhwAyPgnVNvtdLDLYicBBABAgAG +BQJW7nwcAAoJEMqAiUtEBAP1wtMD/i2Zw+Mbu4R/fsvjfwp2H4jDS4EEIpKl8P6InYozapsr +htu2SuKlm1Q7J0jmSV0k721QitK+WwnoBx+VpKfYyA1d+WLvuzF3sGxl2NLnGVNC7OCRuCOy +RoKJQ88FPXMSvn//kfM0flw06dSCt1lwi0Ovl+0mmY8m8JW2e26b/ZD9iJwEEAECAAYFAlbu +fB8ACgkQuPIX/dROZJpD8QP/aQQmMea785skryiWXsjLemV42qzdhBR2V1PLxpbyJC14Cs+n +tbXcT90gID4MR3RQtwOq+eUEI738rPla71JyroHbUg67zn/xD8tf6tIWfAtdrSZPzKaotLDj +LL1dVuY0GJdQ1d94CrhMyTuE2fvHTTc9WDQZBdhETGDOJaYh8nGInAQQAQIABgUCVu58IgAK +CRCttRLe3WX4quhCA/98KwX83VJbtHxEZYZ9a5n4s+prQEaROD6UHJ2FCyyTPJRpZ4Qw65g5 +ytGuAu9CrO1ZuCb4yBvL0p5ZjcGfcgHdKI9ZjHx4xUq8Lvz2iHjnGNUvJMMDihZgcD5BYNYZ +66JtsRv37MGjMN5LJqYyyMUTGP+dJoO5ScSN9O5p8ZDxKYicBBABAgAGBQJW7nwkAAoJEI0L +nt7tg7Qc6K8EAMIYkYVp5eWPM6wb6bemoyRnUAhAIUDNVRmLYWQT47srF35wnhjMBmV9yTPi +Z5T0/txf6AoUs1dBm312Bjf3fEI9eM9b6ZHIMx+0uTCMMEuifHwtGa/MfbfOzKMJrbE1Uvaw +2xEL4rcJtzlt962OPEa0XkRVC8JAOX7RIbSUSZZpiJwEEAECAAYFAlbufCcACgkQETpRl4Y0 +yobgywQAiWwUQtUbtIARWX+6sznYJlmUc/Qtg2OFQ7wG0qUlqtcYruwxLKO8BXRwZD0Z1ClB +yVeDaJ3zCSnMh/yqIOg7O+8ccrmAfEoUChAErd+ibtkBoEKL0ALaegYIytIyRhLA73xaFmI0 +zuK/aG5D6KrNl7EiOakuoMiSmovNi9xJZGqInAQQAQIABgUCVu58KgAKCRBOTgMvHrGpZuYn +BACmVhEnXNI2FaGNT7Qh4JiWC2n2ihxPeDZ2ptdDkxDvUUCX0TK+qBPoec+Mq8mJhGzdSmwZ +JrQYlKsegvrQY8JC6MGtyUqRZ0wf1F/7Q8Iq8o+D2g4Meoez9eNL+L/qVd1anZHgLApyvqo0 +8HVMmGR/Izyaw9sIfW12h129iS8Ej4icBBABAgAGBQJW7nwtAAoJEGFrpG93Zte/KlYD/Rfw +HopOt65PokF1fjyXFPdBJKtQw1tEZV16CAtTK8Gnde1lQWLCXud4nztC1fvUw+r/2sDVQXTp +O/pVXXOZXvbXGHisr8aW7x0/7LcShl9/uojksdNbyLrk92agzXjO+xioP1iLh4fEEbrQqtAU +X/uM271rEHcJzdJmUAktHD4hiJwEEAECAAYFAlbufDAACgkQksQ6ZgStt1cdCwP9GzxeDP0a +81GPJepT0I/iJJMjKoyZBGGWb4kOAsNVctBwziiUJW0nO0w25TsgUukrFlCBQou9N7OX8OcO +Z3XEoq+Qe1oYsL8gMHXY2IqTB+yedJdSVTk0Md+NcU3Y57M3kmsC1adn27V0Bs2BjqJaVNZt +PcUV63062DhSL+j+Fz2InAQQAQIABgUCVu58MgAKCRCq+MFkYqH768LIBADDXXZ5UaLkiH7u +mzC7FGldg5grRB0LNdG8yJePFeiAgBMclBFYCO8WZZo5Q0Ypa/qTmVc0Pn1AGZ9sKkeqwCVz +A3wVTeSjm3FLDJ881NtiJpSqfpbfrUM6gcpm9nptGDLiBDLAkTPy0IiVf64IANddVQihG6Xe +DAtubSzM+4jddIicBBABAgAGBQJW7nw1AAoJECMaa09Q3TN/gsYD/1IuRzY4otu/5akx1Dlp +Q1VMjApmTyvEemKbLXdsnucLBTMzyWVsj2IkcoIE4Ecac+dqIAuTMsg1LLcWacY+hoBlpQGE +06yoav5P6LrAAr2jchGBW9TnVmKGwAUFzRsOLNzQA5kkGB4VeszhxNOj2UyGx9vuOwQuprl4 +cNUEVepFiJwEEAECAAYFAlbufDgACgkQHZ4SngNovxqI+QQArCI5kKrohOuUgwpajbysp4Vs +b/HpQW5aTy1yGMKKs4gO9UtgRSKzs6ZgqLlR9Ruc6Vf/W0LhoXh7UE2ZzFZvRMAAlO8Jesan +7qixvH/EuBKq3N/I4zDXi99RxkRjn2JVz8WQXvvXVAMNwHrYxCSvpGfFfEnhGp13MHjwTv7X +NVmInAQQAQIABgUCVu58OwAKCRCBIa4SG88/bVxJA/98+UNdnnJwifyuGFMIoJ+pvRCA3vVy +BVumNRgzSY/N0lpQSi+/ErE5Kcyb/hlZXEHsa0VYzCST7CnrT1FEkZS/Ya1n8g8Jk6uodvN2 +durvowbn0CcVTPwiQeonBOENoGteU44eRgki/S6e/oH6qynKF5JDSozP9BCMudfAnO62xYic +BBABAgAGBQJW7nw+AAoJEHE4jY6KrBugf9kD/2UmnHw5+B9gSktKGnPs3hPgIjck/8k3G4xM +DOXm30SyOtklFRpXRCYY+BpLHTSon9HfE1pi+2eMsC680ahoCmeowyqHL6hcyUIJyHQ/CPVV +g3o4sph2bWeQ5t9rTUaEx5y/QBu8z2QiL/YLHLCPl7RFzRw+Naedg0Aq4oVYjEAeiJwEEAEC +AAYFAlbufEAACgkQ1nsIL/JuI+/6YwQAjGoBtA4WLT93YbumLfOoKSWccn+XsiMID3FfI3CP +nM8nVokQ6rAyHfMUDDGDkaSJ2TUFfSsiW1AckTfCA8Nin5ZmxT7xTfWkz62IvmbBbmRWh83K +fRIVrs1/NMhoD5SfYBsZjKUgAmq8/BUnknvAHJsdV2fOxJ3fkOMR9R9Ro5qInAQQAQIABgUC +Vu58QwAKCRDfb5/YC6tTewfVA/47iJn6eIy/SYAvRMLAfzsu95cef7sacU227eQeYLDJ/jKl +xr7SE/0XouuCWFhwUzAClSfhr4QNDeX/yv7ziLjynClqwNvwTZOoAuR9nRC5YyAtGUrMY0s1 ++a+Q4DkuKuMUKYF6LKBpbysyUTiB0T8J6qPCra7gTOTMOPRTpZF/soicBBABAgAGBQJW7nxG +AAoJED47t22CmKB1sVkD/jv9943ywV58PXhFn5XpOPlH5MLgQvh/lwhJ3FQD/V848TE7JejJ +mBlyTVZiRQWa89sK+8EgYgQbAC3A596mVs4KFleELuYCptUZ75JbVXqk1BSCUl9abVm99opY ++FcQSdP49N0kZCxV7WQk0GdhPZX3lcWXtUsF1OpS3/CiW3xniJwEEAECAAYFAlbufEkACgkQ +TpQBKJEpQYsO9AP/QlxZMvbS9iRv+hlJV8iCCSgRqAnwDw58g8RLcEgdKXevnXBcmAWhmShN +4iMqvaV2f+4D+XCRTUzseqTjLncdJGUUfc9mf68SYafUnVQWSD7ls8420q6RyZF4SVL4ZFP7 +q7mTR1SHNhALiPMfIeqzm5Aq4E7Ilsu7H+AGdVQMaLSInAQQAQIABgUCVu58TAAKCRAZS1j6 +9jy3+kpgBACgSacVWSJTo0MiN+VsRVp3mdzvMh5PmsYY7Ze/j6G/I/Vwo8YqWipYIOjZlqyE +BvEH/5x+uoimC8JWgixd4r3pghex7d3PGnRDH7D9LV3i16TN3yGBwk6B6XzP3IX6GSZz5kn0 +feHeZaD9eZ6wbykniYamJy2dyxY3zn6I09cTtoicBBABAgAGBQJW7nxOAAoJEKeMgreiRsyy +PKwD/jVb++GrSZMS37Y/C4pPjifQ9R9m92PfohJtvoIwh/weSPkIdMbcVpATsau0mWJKi23w +e8uootcJjbvW30R87cEUIKUB1lWa7OnKu+N1h31MK69aCamACRSB2Y6aoklunVr6wWCUOLLP +FUC2kNkpdamVLtxvoimfoIv0qH1lhA7BiJwEEAECAAYFAlbufFEACgkQWCUKC8EXiKYRxAP/ +bH5KN6wgsMMMMhfjsCoIdyDk8f5heWS7kbGObbpK/K+tnLUHKI5xtmu2gBjEa7p/E1x6LIge +oXcL6BU7GsvAFojiYQgPZnRxRBNEb1A7bC4G0zu6Q0DBTVgy1DRRzaqJpOHwMaXB9O/9DN2O +LUUqaFJNZwM0N9cZ20cg75LcLKaInAQQAQIABgUCVu58VAAKCRD3xwLSnbEb09TGA/9KHX2u +zaIpsP8pEjf+asayK6XzlI9vsn6wzinPE3PYoJ0XOnynIMlSM3t38MjK/lOaxXg43/BEWdXd +G/ixlmzwhgNW0IzYNW/eAOpHXNXc4HDmiRWNcUw6hld5cHPwmXwV9vmHog0Q2X0r298FAjG0 +/Kqykhu/qm7SWG2dZN9jwIicBBABAgAGBQJW7nxXAAoJEGXfjbz+aRmpLw8EAIhkZneL3hpC +n1alUM1Hm+B7UONOrmnN0sNtYxhIimeZNk9D+7jZDmU4MR5OjXEnc1O7wlHHYPJeC4HPFkDg +6wEP91j5kg9f/kawirZNAgiebT+YRc3GKVRYpfZjSnz6ztLt5CqWvXYwqAoQ4SAyU52KZ71k +V+Dljm3jtFBUcZJMiJwEEAECAAYFAlbufFoACgkQDLENxLt+hu27NQQAn4CkKbo/BKm+ZGal +0zVDGhTEALhVbHgsfk9UIn1di1Xs3RCQGBOWiCTN3UN54MbdbRuoWpBpVhSpUhqqS8h9MSZZ +6+YE+59Zu6UGoEQpxz1zqpy8PF/+P8+SZCK6i2NAnP7rd9EWNDw1zq1giCwLSH8+1sq9+qzn +U2H8/Gbql2WInAQQAQIABgUCVu58XQAKCRDCbM+ZjFsttLbsA/4tzetvV2plvq4djaBh05g/ +WVbtFSINCFuUV5DYDesJu+o8LyKEqMS+iuawD4rcNDj3P+ms1oesvLsn/xj2JUXF4FtE6CPx +fyr5gPinlAIvMoh2ohf/uRG+soDkf9PyH11zRID00P2rQa5wB1MwRqnlC+B8lzAdCqkjrDl4 +c09A2oicBBABAgAGBQJW7nxfAAoJEEiprQQgW41CY6wEALho3WMyy+6kBVE9IC0UCtiI6CYG +0etHoWv6tvDmUhBIRwtU3444gD8ufCeqNob+EN2ye3bndP/fcl0VhpP7IlmqLnT2aztjHXno +53HMoWHY4WDm1qCr65utsNucOfjkEwUef4vpV/3EKmTrsKqkK0fb51rigynYVvnSIMspw+EK +iJwEEAECAAYFAlbufGIACgkQbZeHeQZVdczv7wQAu70fRfkHq2JTx3+YnR6cb53SHaMqxV0V +3nF7Ysy2qs+D9liPMoJrZBHkknlssrqylbB/9m0cWm9OsVggUWjHHA//NJepKosgiorbBwmP +Mz8ffzXqEvCjbSd0GCih/l9uWJMf5t0M9ZR+/KrcWxH7s0AcugM6Gg+PQCBp/tYSRsGInAQQ +AQIABgUCVu58ZQAKCRD8tzIcZ7tZzcXjA/4mPLzWTO/CkUPL42F2P/M2hmso/MqojRY7xu36 +qfblNCEbmirOyNLq1BRWn3rbUdIzmz9oiaApOmM1PU7FT73UN7WXoqo2PJNWSFnb3l43oTPe +gc4VJOiw3gVgo7NcA5lwWQ96OD1sfpf/H0JkzQFvBmp89oohkdJEbrKoXDM48YicBBABAgAG +BQJW7nxoAAoJEO0L/9ftFVovrpYEALHVSdnqSQlBzeTVcjbJ8q1GC8tDHXv9GF/rbuO2pBne +6aWQCd2HBKS+zD/EOGISZAYsxnJgEdPxy65J6QvTykqwIF4Ic32llVuVOOQ9gW3BhP2LmAix +EHg1mnGticFkJIbs1QY564AHvA2oc8lx200JVyBYIwNkGDKQu+otB2yFiJwEEAECAAYFAlbu +fGoACgkQ7mIv0LosN4YZnAQAlV+5AYWWijqqKT+fPNGsErpjoBWhPTdg9xCGIhylf+2a6OKP +TqYPxAojOw8f4tpE3j8LWaxWgd5fFFafrPiudfhWZ1L2E0T0vXKFAO6teyjbP+VEULE2iBNy +pDtQtmNnozF4YATivEXFey/AdBHEhMWI7OPEIxK/5KtgIKNweSiInAQQAQIABgUCVu58bQAK +CRBzzhzZjDhfakIbA/9KHwGl667FeytzkrbnLECVF6Ra4EGlfFlIBxg9F4BwA/A5iB80zfXo +QCZUVMGNtAaz6XYOerQgsv2IVJC1/tbQdebJAx3oKAvQIyW5jYYpiE9LHeG50RlX2asOoXQi +yAV8d4A7XwLEvp6hQLabbs0Dw+vdOhHRu4QSjEFpyKuJmIicBBABAgAGBQJW7nxwAAoJEMJF +uQSq9V27VMwEAKg0D7Z6l4+mejfucS1VgQtKKkozpT9wB6Vwu8IcyjDmgdzopAX+TJWQznOA +5xigfKjFIr2DOS41i3X1no07BQD+3z78ftjSLhYlPrmaEo46CgWPNSKaQcWB4QN0IQeCogYm +GkRtBt7lLZefEWntqYwMAnoztJe995Fr7t0SmIFIiJwEEAECAAYFAlbufHMACgkQq1MddY1y +0CGsoAP/QjJrnCFaCwIBUiuG0F3ex3WpWcN+Yr2vE3w8mHB6eBkN3RPd4oGI4dy9o1cAXIUR +g7kbnGyraNo70xRl0xKQd75LUHDSHdR41TmYxZSatJXxU9NWcJzGqIE9+Pwk+Y8SgrxtRmXK +HhsR4KVzBmO/l7hEvJEVPK3EWUxkm+0PJJiInAQQAQIABgUCVu58dgAKCRAEcIY5Zvbiv5SV +A/9IK+0HOfXcPSomv6uZ5Cgs4Jz5pgUwfiUGoYXKj6L/lQ4CPkSX7I5RSE90nJ62sDEm+Q+M +MCy8+gvz7Ytdp1LMmOKxMgW3tE6bplHdEqlJhRRUWxm0HdsHS+FBLjisOt+VIVB+yaTuWVva +2WzAvAaqNmM8/OaWNwqhTY7sNl7CdIicBBABAgAGBQJW7nx4AAoJEDUz2kfXZjNElfwD/29A +stKIV3iHzbGj8ly25wsx1lJo811UBYWmyVvmEec+TAV1mO1sWnCOA5CD/ehJbr9r1RlGwBxS +NpbeqkBl5+TJQNU1KKLJ/26c2q2A0w4LPFtwogjZczKyC9iCmXrjnE+DyheaeVaYWqt2JnDa +Aho+hflvKOJCww3XBVFBOzGSiJwEEAECAAYFAlbufHsACgkQ3ltvfEuf+hwDugP+OETl7jdc +arwfBj74VcTlMUj0RILTuRY3DX/gSzKCMImEolwe18sky4D4JQJT+LOpNTJDNewq6qjkLxEA +0GGHIB+hOvDyVxwbA3L47rZYk9I3QbxURpXBYEVJWC4oAdLDL8RS84v36aPO0AlRlE4AQBEx +4b474Ky0ET3rwG/0vp2InAQQAQIABgUCVu58fgAKCRBqiCJEw176vOVEA/9ZpM+6ekaWNzdF +BXo7fSPBnB+bNHfO9zYR1jLz6heAjDn+mBtAaeElbr+bLASpuIgC6B1TwnGoXumZa9nUi6IT +vibfxzu3ToocF4R3bXHBvReg7/I651FM6YKXnHEn2hyOaes2gkE1Ec8lsXK9pIn5TRuGm2bz +eGwQqKJeURVIQIicBBABAgAGBQJW7nyBAAoJEHdvGv/1eCdBpGEEAI9gdliWs79mKMeTZKT5 +/2QmbZNFdKqw393AYDwQ52km+VJ4IgDac3qgW8vHx3Jd59DStelMSlCoWgqs5udvKB9DCT0P +aw5YxLFju/tBGMg+RTaPvtwal3w5L00n4DlH+DyGnM7PsCx+4n0i4V+V2PmwRfvYZJ6w5ei8 +UOhuynTmiJwEEAECAAYFAlbufIQACgkQFoioeky6xs0+eAP/dY61/2MXbLtZ5kr3+ys3sxq/ +g8oWXC0cFuZjR9R/at58ReNoLIsNI/ltFJhkob8Ej74y0IDnHKzFgbeGtlpl0KfQau8u5bKc +zQkZMAcNcohdHn/q0CHlcZ7WtZknTDvrJPDKIRHt+viwAwfzgVq6M2YM46X5e3js3extNxfz +n7OInAQQAQIABgUCVu58hgAKCRBRO2HFim/DHiXMBACQ+CE96Vx8OV44ImMEZInet7ZrYkPB +jyfpnb+qijZLil734Z+smwkQTGLM6oKMvcbkDktOFw81RhZDb4q03dWt5TUG71vaTsDnFY89 ++uHrOb7f+Kw4KUV18CMrY/TrldoKoHwUlgjWpg6l7fUyZKjCzoLF84WRlcEwOZe3+vxRgYic +BBABAgAGBQJW7nyJAAoJEMewLtkQIydeIcoD/RQOKc9JmgwUR61Zr1p41vCplr6DfSSYTpcs +T4Qi3udV9bHpoTbVUfFrrPGpAfZZ+lpx31JpwBW1PkVNU3pZlDluZtF2lhjyDxMwl0UhHYr0 +PHzv7GNCplDKjHL0b5wOaKh0uzn09kmacNDkTO3HUcewpXUqLCgpDUjgJqqxQ5vuiJwEEAEC +AAYFAlbufIwACgkQdkJPSF0+/mGmrQP/SnRPQ1mV/HPG7kPlrZ8L8B0EOaweuCPlvAw8Ie/y +ns6OQzRxSMT++ToHITTDAUFkQTq/zEtKz0cTLlbnCqXrDTUAb34qbg8FvMDgEZ5giSLbxRol +bU0ZSDKth70L/XrrzP1f+eh7Jjvrj4vpGS1r3J9/9LrKBL1Dthr978VJf8uInAQQAQIABgUC +Vu58jwAKCRA9XGmvlojSZLFWBACD4CD7F5bm3zbgQzeKJvo2TNGUaK4PvuyDIrsuBo2TQeH9 +UJJRPzwj202d9SjlSY0rUmaD21y4Si78rqUZm+5AHSyRyJ/5rBVNwdy3xMcLzY6LgiZaf36w +DfGEW8xAtfm6VqKY8Orr/wVXtvnVXp3wbW6C8qh0gEJIiOLQ3loMboicBBABAgAGBQJW7nyS +AAoJEOx9wwBbqx7hFl4EAJmhWKHdu4aGXc5vFX2GbCW4mldgjWAAiUI3uvs3z/GS0Udidc9v +lS1nnN7N77U0t702/y3sZOz57pSGkXGi86hZeiDW+4SJ+ICImavIfMQiKiHr3/ekKHzsqcJa +mV4HTTS78UFXfFNqzLRaRB3YQF5Cha5EKI0OXZKCmEORhMBBiJwEEAECAAYFAlbufJUACgkQ +WrHgLmmlzyuIJwP9FoV7JoSwChyuncHidE+204L/Pkdq2PA2lyD2B8o687j7WN2w+SMY+/s3 +MxhracDYUilUqUZXj6LCDk9nYag1+etp3No/1qtq/dn0sxbZ9IvSdwRE94td4pxTxA0rwCBp +9BVWPOKk1NmTHkQQUNR4b39hsRgA5PI8DSJ0xabmO9aInAQQAQIABgUCVu58mAAKCRAMIdIA +882SKj86A/90NMsXt8m/br/M7nW9ynT8PVMIeBTYowQ/WRVtfcOgj8bO6cvtYsFKtX2LIWQ4 +lG2n7HXUflalePIHtnkkgUhfvut/yb0a7OXnwmi/9b9OEUO7bM1trjCdvhXkd21VGguM8gYT +AWRFjXS+yTrAtEtL4/skACZaVNsDIcV9eUnhfIicBBABAgAGBQJW7nyaAAoJEOC7bINy0DjN +3ywD/RI0dmIBDAjBeGctBRxtCSrjpjxcG79/6f2ix8IzPbSfO+oCkSwHteJLLLVag9wTFyGh +nzVnjaAEjfL8+NfcKKEAPceg//16g3iRGdgrDmUzppIcDplM2vCxlVbk/nIxDXPzkxdCk35z +OxpSDoCdG4WwXiFJ+urJ3oslGs3ScBO8iJwEEAECAAYFAlbufJ0ACgkQK0QsWCfA11hX+gP+ +PNp6wpSOvjAWL8wUVW1iApcKOr5C6wAnICNYVclQ5wncTOrFHiOBby8VwgpYgTygJ5EZ8Us5 +X8+2EENqD+ixttPkWMFWgRO5rq0UqVR92mCDD5P3fZeOcdiRZvmCQbxeqbDIcQoBld8o5tO4 +/o7/lQ2Qfs7YvkXYPX4LowgSVSyInAQQAQIABgUCVu58oAAKCRBhAM6URbWSHZTYA/4k+Pru +N0XZso0EkW0Zzd9jM12bsQsJB8PgTi04NFne8AnSDdrMCCxv+QGyXf71YZHcC+cdVNCeNn2A +8ShiObZ6ea8uMlSGeGBcl+2aCrtOLzNQ/klv5DrjrRlJwIss/lFSUEEpcHhURnGg5ngvHS2w +mvolA/RDEitSMniX+9iMi4icBBABAgAGBQJW7nyjAAoJEDziS4NSCPQsyeAD/3imnusYxjaD +KBPu8pRzUsY7Y/Mqud6natog5PvpFn72HvdufBIqPu+V9WRXy0O0DJ1mTLHqns3ry+PpaFJM +S+u8xwExormga4UG6Th/0Jv3ZZ4oiK/QG+euBQsMQNL3aQdg/9Z+xC4tO3dUJ06qoRkQaGu5 +MBAqNrkHJkwn9z3jiJwEEAECAAYFAlbufKYACgkQRYVJRzQJ2pCZoQP+OjnkvZGCYsACKzL6 +bMcr1ql8db+wv/syXWKs7BOjm8Y5phxgP7GyRwrPXyl9lrEHf9bS8QBCidkDvoQf9QGHnuSg +2GsDCwRueeBv9v+KlWDd/wEMDcWrEMreC9VL4H1xNos2NjnB6EjFNjeZortKrL7CebPXBUrC +fPryZOzJ1TGInAQQAQIABgUCVu58qQAKCRB31RRcs49KJNX6A/4p5LA4JrA4Y68sJBh+2T7b +2awhpj8FrmM/dCd6xnVfPSftXxOvq3c26OIldEbrnLBSu+3eevBct/ke+7mgGmNP92uKL5iS +JSG/XTdROyvQ+OStLb5GjtckNUlwUAENn3IAAcZK7kRUjVXaQrLH/wr8IxcQL+rNTRqwn8FC +waBHJYicBBABAgAGBQJW7nysAAoJEFBM0OQU/0nM1nUD/izYWsVIU0jUQUz9aOykaTwa7geK +LufvLKCstKOmbsSqpca4f5sKhgtLa2YIa8ZIR128bPlsAtOZ0pGnNa8K8kFZS8zXAL+NWzcC +1w0BXlvUKDnolvnxeShxYRwcYKbjqxwMa/j+rSqtb82IrfvSpe3hsuPpzHGekhFLXnKIoEvb +iJwEEAECAAYFAlbufK4ACgkQ7z5UOZ+UjY7mZgQAs55nx1M9kGPFGm0TvGhiE4uoT92H3wfK ++Rg9AvQtXQUuqQ7qxwTJWl40rDFIOuV4XMYn2PiMrogzjqsEIyQ5LO98gpLItAop2xKmOwcQ +hIqzctbNe0wMubFDYRzrch/a/Pfrnr8nNx7T2RZxvJhmcVhOa0lzxNYuKFl3USjyAwyInAQQ +AQIABgUCVu58sQAKCRB1wUxUVt5nuw94A/9XqqFgJ0khNaRysq1z8wqu9lT0KBqVE3IJFKrT +je92I//PHoEQ20/EVyM1Dz/oPmnaqRrxNQvnyIBDC9sLwmbGSwq6rFtChG+p0sCNt+yJ2gX5 +vBHedc4zDxxhIKAutDm0NOnoDO91Ick03iXBbGo6M2haaUU+ZwnY8aH7p03SVoicBBABAgAG +BQJW7ny0AAoJECGxJYyxK6RUBcIEAK8QqzXfx7+T+T/WmS3g7A71Q92eeIc1/xn2pUfFOt6h +Rb2CPgGiw4Z2BgWhkvEP+u/Potlat5z5Qk0yy6e0cRN3IabPcXIjjjMSrO97Qk5FNEsox4BE +aM9VEd7G04bTQX3WjZ6GiBT254LARkdUrQCiEZbu/x0idhdxS00RwRSOiJwEEAECAAYFAlbu +fLcACgkQCx4jj3HfhJ4nsQQAoKlBFL3AOU0FxXwB6/LhfC9YmdDYtgBptHqX/3Ahz+zrEH+9 +zOXIk1wGZ5o/ByvaJv7wuzCb2HQC6NcSqdNt6ZsgyiUgC7D896padb8PUpzCFrC8dvXPiMqD +LMrRR5LQoUCi+FZj6P1y1YiCQLTAbq6ii1YcDiH0/b6IV6IFl0GInAQQAQIABgUCVu58ugAK +CRAmZaCR2/Hs6uU7BACeesLBSlwFveirA9peJO1k+UoTG9SghJsDkSw8kMEl9yW9xxQl3I3/ +4XjH/TVj6QO4ksz1DVEFfUGMcyKxUbM8K4P61iCQBUAuKYu1ALbxNNGGQX3K1zXhwfQ/PJ3J +6gxZqCG1gJX9HXMpqVNrRCBRSF3KUuRJ7ncr/e+W0wzRNIicBBABAgAGBQJW7ny9AAoJEEZ0 +6LDP9mJYn8MEAIcClvTtC6xw2ez0kpXMWadsEOXYDAvV7ZKHeg7YSQvpkZEZi6VVFwwAUhxA +gIm1HF7V/xg6x6BK/gfdVR8gQonys6K6Km+/+t7bvkiviG/JFbVbr0/XfcsMUe0PnhZoTibo +joRX1+bOC4viRH96gbJtqWBjjjr0KgxPWT0PMjGgiJwEEAECAAYFAlbufL8ACgkQz6HPmDie +b451zAP/ZBrPJYdvXL3aNzaSi2FuOXJHH5n/ZDojGJeKdr/kgFNLP5Gv+Q6ZXupQoaVP+fXZ +H3zorTvm57q37xkO9IDhKS2CWcOV28BktxVcY6zh7oYIXSW7mhW/PAErw/FpAd8ODruMBkHP +YDMvJpEpmm4ghNwmQjPo0HqLO60pW3i11z+InAQQAQIABgUCVu58wgAKCRAdE9DWbOCng94q +A/0QV//rvbQ2GsRiGfeBKYnZreSeDJr3ED8AOhoI0AShraZvVFtJ9U7zp+nAp7V7+ocAkpjd +KGbmlpQoUa2jUJG0gBLUrcrIC0kwZDR7fJjc3OwrBJzGOj5HZNjxnF6W9ZuC+HZk/2M6Z7GB +Wxg5GOb4gn1lalqCY+UK1e8KG1tIooicBBABAgAGBQJW7nzFAAoJENVBFQv8OWb6H6wD/A/I ++xOuyNMJStwl87rDMM475UCUCJfBLOKTSltXApIfcY1ayKNJdUQxwtnVbJR/i2cqTnQkKbon +HQOqQsrGmHtKsz/fDWuBCez4B/v78QCjwpxrEJq2xRpmmU201u5/UoaEh+d3Hj8fuTMnSJLl +bbXnV7NIQZx3pYQqUcHKN/sCiJwEEAECAAYFAlbufMgACgkQfwphBaG7jSHKBAQAgDSExgUB +N1TCSZWiqjGuGxNXGrsgP6ywwojmC3Y8pcB9n5acDjLZBrxqcNcJj9RcW/uCzi0TSgt2rLiS +ivEqMVTVqFkEUvczs+RxpMi07Sq6zvHWTtkaPCKAhFs7y8pPYLALRQgJrKoZ0zQzbnaJePSA +XtNx7WxHCBOO6AkAVpmInAQQAQIABgUCVu58ywAKCRAlYJXbLjLEql8pA/wKVX3JHB+I2RO1 +fL5NFL26/NHy5f34yK710KImI4kOZzExM39/eHnniJ2nXGZzZmhYUiWXo/I8Mdz35jIW2N1Z +0+MSId718+wlEw/nEH/Qv2uUDV7tqs0WJHT5Do/RfKdoqWcdjt8XygsxhKw4WFsIL00J2yz7 +d7Bp737L1bB0N4icBBABAgAGBQJW7nzOAAoJEE55It+B9TzfwGkEAKF2grQ7EJKMQ57qixRy +L/cJmlD4sxYprRJlW0cb9nbtzmsop0v21j25QkwVn2b3Tp7quIPVdLj44rxaW5nUp/6+ziY5 +48UjAvU8HIEvCLXbwyAWgHepyV/0nl6Jm+/qRWhArKdSekyYd/Jry6o0dc2NMutt5uQEpueZ +HK8wK4pziJwEEAECAAYFAlbufNEACgkQG3a1+/Pw9ZD4kwP/U9aZBsH62S3vzZcUk3tMCZ8T +xVsXZOTMziLobkYlwGNAvF7k5XfHIqpuuLNIGC44KopVZpdd0aXYLWXptBPyALvb2ETHHG35 +ROwZPnNnbFpwMupRtpZkp4GINzpbeZepP9dZwWlUJDq+dDI7TdYqRJjm8ytVQ3o+bP7/SCXt +YiiInAQQAQIABgUCVu581AAKCRCedTezvAqTvOVoBADKnvrfHrJmW4QkjP5uXZdkYNlPT07Y +yA6LIcXuQvPc+a2V9VTG2/7KNG0JttVg0LTeCUCKAuaKii9OHfNEHqgTmoXUlOEEtzgWfyOp +zxPLYgCv/ILdjBdbWqzSj2JBClrDYzZQOevVfVX4Aka5XzLJnrs+jSqts2bpFHHvfHdTvoic +BBABAgAGBQJW7nzXAAoJENIZihnx1F4sR+oD+gIx3Ds0LiySSxYUBVzFBjysK6nLwsZVjVYB +k7BrUOr0gdAv5qFvpptVOtGJxaS8zxm7nOHFzTcz3zWrihAQ4Kz4WJyd+26Ud596D7a18NsU +wSN8AH+M8yVzLENUKTmW3o17e04jGWVDVoJtsEfEqVG0wm1yM5sFu7eslx6AaK4siJwEEAEC +AAYFAlbufNkACgkQSJ3QZj3jbgwXfAP9H91agOpt4jfgX+GSJVd4SNuecRqZsI0LhiMZ+wSW +9CPXILRDOEpn4KjJFknejOfywODmrCPw1mTc1nd+GC/JgFg9fHleE7X9ZSyDIb2CQB/yR4NT +89KcbsrBG0844/gMEqqNmUCAmnrM0VNtiH6+QkIyMaTL6povmzUWSns78HKInAQQAQIABgUC +Vu583AAKCRB9r9OPsgJufD55BACwQtGTrUSgY3wAFgVeMU6SSvpRgFSWualV8VMuH/f9Gp51 +eLsY1tD92g5nWIU4pHVDThC9gQDeQVg4sBOSSTp04w/wWsqG6cgP3VmnSYf82yldMNXuyCkh +PgmGLSv4+6sRIav0aR/0/YMor1BtBzZLk8hQ6ZjktQgvvzssEbcLrIicBBABAgAGBQJW7nzf +AAoJEPjnpa/zOIs/M10D/AptZXTShTXmN+457URv5l0GqMvPUzqJTa6rL4eWWp0pjiWLBGK5 +YHE+LhlIosJnQjUXWfSPk9QsYjftEBtH3VnJbBNKCRduHGKa+vBzIkz0xiUxXTHG7zGGtG5s +qtrwA3sr5CDMyb+k61Z1rhzn9rVGUVLrnKTQW43wDTFIKTXkiJwEEAECAAYFAlbufOIACgkQ +DFgeh9E5LUoZ7QP/Yxd1CEUCNQN4/IJLnZTXeWQDz9HCegeacO7tmJy9Ft97OT5yvBTCZXFb +/y6xcjX+MmJuR78Tt+tJu0oVClWV8kFi9XHj7rDclRytnRiVyYwk7pC5CB4/kBTDmjiyMlI5 +N/hU1/hO5Zh4K4r+Xv6WFtL51ivxQbgz/WIZR/XMjtGInAQQAQIABgUCVu585QAKCRB8maMk +236P8zRdA/4nkrCl0ZnnDJyVs5L3c5e43Juz2PcXdxQkma780s9KifA226lvD4fjNGMOSSL3 +4vHRELAkuoM8IclBr+oOee8wwB/DusYfsvKsyaHx/B1iOwepNRO9oH88lyr4Qqi6nCgNpkRQ +DB/O/8bbqaAscNEdFEv3EuIUuqRPWwQGS7JvJoicBBABAgAGBQJW7nzoAAoJEA4tOl9cwvhK +UNsD/RHdwJo4ZdBvytr8RS9Vh3+B6du4qwtSzm7qxncEfzaQobCzcepQLTbqkAR6dN/kX9xl +6dZqCOIiASJXFJtpHIrBjOgggYcNyJc+pp9lbzml2TXclIGINDb0GOs5uFxMOSvNPjCEBukS +nLQ44gcA1u9sp74JgF5hXKx7YXZeeYRfiJwEEAECAAYFAlbufOsACgkQ+DR0P1yUahGVRAP/ +dMU2D0Al03aozvhpCrTEgEwOmjWQE0ATjPKhh4EBp7+2ozAB/JOk5vrpBEbfsr0n0i/N2+Gs +neEX2jrC978aosE05hrCkSc3VZQONXEM92n1VdCBRxcaN9XknHmBlHsqZu/RNaGNXGpxqOBG +SmzY86H+1DXB1ChnAjC+dQM0t5yInAQQAQIABgUCVu587gAKCRDFxSQs7h8ELbAtA/93JB41 +6lDYwgG5DFJiCDA7KsFN1emKAyQDIydpFLSmoxv0Q9qgZiZI+5yzZk4m2l9kuRWE//iuHJOr +QoRf3HNqQVqf9ylFqYvrWxesQMGKwxnyeO7ZqGX2iEX/7uEi5fvjxxl42JeWJXtjA3932F/A +xwnbcomOK0JU8ALmOWv1RIicBBABAgAGBQJW7nzxAAoJEL85OnXzHMr1kHwEAJJvW0N9/Jyp +NvDBGPhsL3kx7F/pKFml7fxD7YQzSk4mfoL3qHTbkg5mZ4eF2824jDnvqDOMcxcuqvxQaISd +yQ+U+V10abnaDjBH8EnBBpBJ7EN1mVgOOeCQi/oa7eeqQwYVMTLQgfebUr6ZXD0L28Cxs2mK +/lVDgrNQefP9S7bfiJwEEAECAAYFAlbufPQACgkQGo5QCm9C68jy+gP+PMFDjTdE2iEnLieQ +3GGZNwuFQFzwwEZli2l0B3+K6cdFo7lHZ68L6MEEMupwsoMNXJZoewfwWg9pdw7LJJvwLrJw +qLPL63qffhNCFOwd6v7sYHaP8Duc83QQ4U5eJ0Uk3tojLW6ga7WXm+oSSzv3fnznC7LH5k8q +pwOAkz9+CWWInAQQAQIABgUCVu589wAKCRDoFwKIvfK4b6T+BACYd2riPDstZdK8WM7NI9Qr +5H/eprzdJcWPlwG3x0i+l2NwzPIxzrQkSy+zcDYJqjBboYCBTyefgXM2Yxzv3sR0PUhqqynf +RoHjELHNeLlholIX2OTmZWfHqyOSoDkZagQDtTh09/TYc200Hh/xpffY0WFc+18j2P1UyjMp +hupfL4icBBABAgAGBQJW7nz6AAoJEFN9sfr8jgFfvhYD/jK/nFh1OldqKvscfQA6uZEcON1s +gRLI+dFeOUXXx/qH40PVJiTjWQDl8v+Oog7nRgHxmD8bE8fY5YsLlmT7VWH3gQ5o0scossi6 ++2oZwMH3mYIaa1dcbZChktgfYzLqFA/FcZXx4VqHWsMOmabUz7FMCoBnj5wxp7TXOk67Grhg +iJwEEAECAAYFAlbufP0ACgkQN5pM6zEXsbCLrAP+I62xCxxKpChUPu2xWeJvvAlSfwEsULw+ +lwC8cGTxIiG/3JOhGlC8bvsJs4tOHIcQRPBH8g61HHMq6oBWESDsPB5urMFEwL+L6JzaQf/6 +Ms5Luv9MJpyfv009Lk+yjQb6ie97nBR3/MuKUvoeN94QKPS5Be7TPHrjl4ZSf/TodWOInAQQ +AQIABgUCVu59AAAKCRD3TvFSHypBQnvuA/90s57NkzAUmSTm77V6gxHLb4H4VaijnoBOJYv5 +WXT4A7YY4n90SlKlfmMNKaLSFXJE/5avREDa3hE2xOa6uWfJq5cxhBgQeSkBETF61esGQCtF +nKDJKcxxbtSw1eSsInLHHjwI6Ffyq6mmrLJ9/6d6IUnBB1TjW3Bj/dWypyY1FoicBBABAgAG +BQJW7n0GAAoJEBXjA2b/57ahwU8D/iysGAybzIvcLLaTj5SelAavO/zaFrpaOIpQ5Bgy8aiP +Zqll32IJ6TE//iki6q8mcyqrxJohMchnlnDS5bCkyRkhG4VzjMAoVErSgt51BDUf0/xPR1Ki +YSQALMXdjzkOO/ZlSn7vqhEszC0uGiaHP5jBL9KZBo86yJ2You1GTNjRiJwEEAECAAYFAlbu +fQkACgkQ64gBFmaz7+UM3wP+NexAAcuOnGHMjkZMIKHtb1anb7sPo1hEinnVvfy4DdR4sv6j +/GnjJMcj5lM4RChDa3shHa5orhu2DzMbuxyrqylSdmlJmk83Z7t43oYgNLsiMIH2h/vcXsb8 +DjtxpdlnfknF44d4c4I0/L8nLqkkUqx0FVZTeRBbsKs9XFwczTeInAQQAQIABgUCVu59DAAK +CRCKTZz07iXSiSigBACPFybS4+G/IBFD5S2muqbISsXg/67+cABun4ixuSfSBJjbdzkW+NDk +6Kmk39QBaJxOaf3EqEWOXQmeVQyG/2iPiXCC5cQiuYtdDyfnNJ6f6mWtETZkXtKfy53Y6Cz3 +ClmxsD6D/UrZIG/2UUeAVD2cJWHAR0t3kwXbj7i8c886BYicBBABAgAGBQJW7n0PAAoJEP7l +5rzidZvroXwEAKsv9G3zBlU7DzR1ShpLTMkvPySkHzMyIqXjF8JmXr/uLAoFnIE+xMMdotML +dVB2c1vULAXzauPNs5NFKNNZh//sfb9GTvmD0hCmwXKIy8E3ZBSH2nZmawKawzBWpO1ra3kQ +546c7Sth0d2zaUUOi4cJKjDO5aWvX5hPe/cmeOgeiJwEEAECAAYFAlbufREACgkQwYEveS5g +cO4jBQP9GWt92UprTI3NwMtlQXg2oO2zB9D4h/rnq/eYHGZLhYvHxYlkcSOYW2+Mwl2xjWWA +IcTZBhBxDstb9fNuut0oUgHLLajdmcX+htRpeiuQYjTCF6rP214j2hy2s5xFfzXf4hLxFkRc +v+XG8m59+/wQEmMRx24P1vM/84wz0IR9XveInAQQAQIABgUCVu59FQAKCRAjJwfm/LdN/E+f +A/4yq6gMcdGEqOzjE4DX1V6AIB+MEkiRatToXfd/xd7cQXOV7UjGjN+fRrA6Y1/wfLfympEo +BsORV6VeErITW46jKRXhhixRzk0+jOXjS2PY1+UtJqLM62I7CoD6IfyL3JFjyvSmZRumL5RI +T7sG3WiwOtbJ2HmaeuIwxgSw722GsIicBBABAgAGBQJW7n0XAAoJEBOmwdPzKFGCoQID/0y8 +Lj17oRkdtMfgYOWGnf2EU+d8xMfqBqZGBVoHohbToRBa4DuXBYChqngcg3Rw1etJuUx5Cac0 +CYg0BafRr7Oq5T5I/kF8CLcVl5xeuK2Qp6zTBS7pdrjz9a5brh6ILnBP7iRVQE44L1E2YGUf +Gh3hpy0xngyLLXcSVkO07zB0iJwEEAECAAYFAlbufRoACgkQn1Kl+Z2JvLBDLwP7BP6tcNEJ +ry/YQFWS5ecCaeEZgJJXdgoLz3fECBuKb/FcUqLselUDBses9VQyyzawkZ0WLTvPheU33zxf +nUuJc4jxXqUfGV1D7EcQB+DMZ/TBlGJ0zeI7jv2gtAUaGeZV+W6JoWsLKqel/7JzwcB8VRaA +uBkkpctFhRMOtSdFnXuInAQQAQIABgUCVu59HQAKCRAUGD/+tW2jDrhuBACGMBLcsj/DcJ7d +d8pvKlsyHJeVbu5fOExtJkdn2VD7h9CohwoUtcj4xcBJnGXvwMLJPUbSD5Z8YNorFoTDrDlY +HyGIWvt61JPqDRsNsXqgvOJ3IXzp9fitJ4W1Sob+xbfLYU8/yGfMDNelA1q+jo/B+tmYAtmi +Urlu7fAH8uy3J4icBBABAgAGBQJW7n0gAAoJELx/3g4nlqapNn4D+wZls7yfNspNR4me7Pez +gAw+UYydPfqxJdE4Kx7qPasIA5LRv9djrRXOCUaufifDDByvMGFAm1/c7ABtlNuoBdqAHyg2 +5xrzgfvCZW8vRlEvYSOejTJwK/zECG3oVnoKdnS+Tubvfge4QyMlF2yAwZxzVJD44V1nzXSC +MuM0/v8viJwEEAECAAYFAlbufSMACgkQgRVoqbpp1tVQ2wP/UIx34FgaQw+9Semro7I4HePt +3O/TdtDB4wq2h05arBuZmCmFjd2s577QVNeQNja3cmZpkll5Pyc7wxu680/eyYeKG9i3mClL +Zdhe9T7BgMcxBvRE4NZYEX+3ai8eGJKRBn9FpXB5PrMoQIhrJr0oZiRNXVx3s3A5DgdfYWif +bfmInAQQAQIABgUCVu59JgAKCRDufm3jiIhGtFE2A/9f+jC2kmffRFj61sKmWyQ3eKwjbH9S +xlSwvxnYvBajEBnUD1DuxSZUVF6+VT7WEnp7zhe/UGc3KC76LOE+Y/EO4OGBVZhkHHWVD2HF +VwTAqHXEIrN27IkrTJOaQc9hg7yxQCF8wENza2IeguW6r+MJxQ2SfD7lOENb13vTbvYDCoic +BBABAgAGBQJW7n0pAAoJEJrnnvFBJady/FsD/1oMjRu6wyZ3UYiPXare9GXCC8itIxh8NyjT +zVCdmU7Ij684z0SEHBpy9q3B1rJf65JEYl/Z0OpboIsoliC67Zap59OBffUsrZX+ZJmXJUBT +8Tb8ybrrUYR72mTn1YVwcuHZKVzXw0ePABdcx27OT0jOCfPYszZ45Vg1Za8bIKHSiJwEEAEC +AAYFAlbufSwACgkQK/YdKiQDV2I3kwP6AoT5mwdTTpKFJh/J9QmShCwfiNucWNR9PNleXMDG +PDiBSJDcj0YLpFO3hWhbQbUCNTW6My2xj+lkwXGVmlfoO0ieFREGoAqDQXYY1RBLO5hf1miL +u1gpOOfquSWbxexmCE0FT8RIE/nu8kCaKxX1B1f+8z9sO0OLHAM0KTHoJXqInAQQAQIABgUC +Vu59LwAKCRCbPRX0i4mhelP7A/9aEiy8Z4Xo3323FMiUi7LQujd2/frhDE9acguSQtn3fj33 +4XinCML2I+sy4Ici4KTWQl/GTCCo904QIn1XwkD/dJO+hEpkKNFx1YrRB0J/anIdph1atANO +kJeEVliBo7iv1zhVKuWlbuuPWRAep3pNzJCDgrsl45Vjw/siIS/96YicBBABAgAGBQJW7n0y +AAoJEGox/8s1eInlBacD/3ANdfhI41jmwoQjZIk9cP/lEGJzoPfD1Aemu48mz1dVteE1roja +LWMZ+fbf/Sy/rb3XOICFT215AIzioPzV/0nanlf6dJuEf4srKsm2isgan9353DHR3UbwzQuI +2CLlKm9txR7PVqp2byA/7vuHzAkCBssmtEY/V5Ierqno+xJoiJwEEAECAAYFAlbufTUACgkQ +8xaMe0UOPraptwP/ZmmvPMhVHo7w9d9UL31ufrAZFfJF4YSvYeyjdeCGhtmnUgK7g8KMA3WG +nPlhUpTgQSNcW3Mh6g97AdH+rHASw2xxFUYRmYligkcNZLbGsbvOeb0WuHpGFyOJZnV01GzZ +d+dsc80go+SPr76DaX0sgaS/Q59SlS6CmPUT/Q1M5IqInAQQAQIABgUCVu59OAAKCRCbjRAN +uxz3kyS2A/9FmF3V+8lZxkpE2rPtqK0sQdqMyVHVh+lFLLofBUC0b/Oivf5c5/SYeX8GctH7 +wmmQG4H0FL5FPF91t3OEZgOzCVcZdTocd9Bab1kowmvdNfqCwr43z9OkFoybdg3vRWNq1X3q +rOInobRHNz2jzscd+05e7VDef+lseOzbg8q474icBBABAgAGBQJW7n07AAoJEHP5XYjdK2lZ +vq8D/21Af+PrX9DX26kzqzyn2IxxvTICBn/DDBZfrzXvfFlDyov/p/sO3LzhXWVI2qBTtqBz +b+pQW72V4hlnJCp050UQS2xq5IXoFhdO46Z5jal8JuK8EVDUluk6W7yogo8abUH7/NdmrOoJ +wS2izEzA6R3Brn2KsyZeS1m5Td3gum2/iJwEEAECAAYFAlbufT4ACgkQ/tpAxUy0iZVJ8wQA +0ybdg/3ObifBZVl3i+/280jMJoSd0rajDQAgrsBjnPHNc2XZfQoqV4BstxEDOl7bTLpcveTu +BAPGQu/X7sa733CaNsBMYM6h7YZqJ2CtwCL7l1eWUvYvAxOlwGKFqCegUOr/nPk0UEqkhzBR +1NqFsWUKPdd+14RArFqEnFji7nWInAQQAQIABgUCVu59QQAKCRBvwMUddU5njF5/BACtVW8M +Uh1t3jb9eVi/U9lFnf/NizWn3NdyN+6kDkp0eMkeyG6VqwR40ie74wgbbQILmXaswHycLf1f +njjjR5PHexjamNWlxaqbg52msZ8hxw+sU6Kg0LXqOmRC1qPcd3OF0b5vNKlITe95Z7DtOuRE +rzZEcoifTLn58KSmSknNl4icBBABAgAGBQJW7n1EAAoJENK/W0Ew4XmJGI8EAKBxel+4LALG +VAfumWn9GQ55Yf1mG0d2q313KODFUPCSo2xw0ZQ0rgLq2BwfP+h262SGYI7p7DTvpLC6yTxA +z0Pqgxer38rBq+pYTMT0aVWjrBb2Mh1FgzPgYD5WCjTEb53lLQbDycxk+dsKK7RyzysPgQX6 +vmeYM4xBlR4W28HqiJwEEAECAAYFAlbufUcACgkQViBsPUqykjN/3AP+Ia/FiLEkBfvW8hwI +POwQ98pSwy+2yfUIf58AuObPOW+wA6+7km62WB423ezQ3EKuAuWWTrB+3/V0faUv67+OcFvx +kdjkHc8UdAYHmFpVbfKAVNg8FsBbEQbxtkWtaojbu/547fEpkZ6X9+i+qKSSejpRje/PUdUq +k24fp3U1SquInAQQAQIABgUCVu59SgAKCRBr1+llvU0sLvpPBACtMzdT3o6Kyiyo7FDUzC+X +x6j38B7nkZQOBQ1tfxIIpsXyH/ndAPhfKcVda01Abft4sf+QlZzrHbQ6SuflhK+j4VFKup4C +V7ZNVnhscXnXdR86MotkHGSHWUmcbUQpnap3xhak+YrcDGZK4B6Jc5e7Cl0kvLr3KGWNiyyD +W6pvGIicBBABAgAGBQJW7n1NAAoJELdpLHYKa+cVQU4D/1GKxakIRTcmWHqQz4F1GfL6FzqU +62EoJTtbOpDQmw1THmhicHWFgu6hynaCAFS1DE5OHrEIU1Xw64oSPbwQNpHqgqvQHkaGnZ+V +Ar0/XckqxRiEwO1Q6uY9ISZSd3gbl2Wq6QOq3b2c8VBBwJdB3n7uwodTfmcm7dkoTnPdnTEv +iJwEEAECAAYFAlbufVAACgkQq5wiE0+srmG02AQAlsS6z+Yayv0MXHAnuswmroDH7cpT5j0L +ZBgv5Fj2cXn32aIDcGoI7lNOrH9prh8iaaHqhBG0ECGstf75ZgXD1OqEvYaDh+MxDh6oAZAA +nWyCtko4IcGRxFDmvq9Hvy5TYfFKLgzTG3YB3khSf6stfyAaEGADr66u8D10cfkuUkCInAQQ +AQIABgUCVu59UwAKCRDN5SxDwD2K4EdDA/wMTNOqAB+Sz0lhkfURBx1gvNOIptqoy+R8aKLq +1Et4dnvNQi8BIyhQdv35MqeApFDLzSdetKCmLWGyf1Qux7dZE8/j5DtcVhhw27wfK5Dyns8k +308uoDIu+HlqWNbKjYF4msGGWDfQ8ZXm0TGt48njUDNFVRr5pdubSD7ULz+tW4icBBABAgAG +BQJW7n1WAAoJEKaCg0FUVcMtrPED/iBm3dF5fVcQML+049rmBNKNrcdKtTOmc9aHbEbL9Epn +BE/fZHwag5FtAKinPDI+LXNVoUapMiMmWCN7j1241AfTipMtsk+kTGAG2LUYpfIGKYEp5kj5 +1BiALpHFVHtEuo3cu3qjmoet9qZ1ICMD4fmJRCfLe86/5Vt0RRdz82ROiJwEEAECAAYFAlbu +fVkACgkQ3g/MbgqtaMXe3QP+JYLwJJRptf0w/gOTRgwGwTAicrUiCav7GGFdBviIH02EZqYF +F3rsm9tdh77A7exb4mqxaBYu+n3gvjETR1KPkEiOUflec6g9nGGHS7UbH+e5TYYLM/p+1rpi +52ZAK62QAQOQMjv5n/EK0200mGukolChD7lfvXumq+XYyFp3Yw2InAQQAQIABgUCVu59XAAK +CRBjBlnccRYss/SOA/wIfGKHS5nO886pp5soZx3ZPJkzpTLFUAB+O3aziNPFaychKgSbEjIe +zqiPsaswUcMsn715ZqrmkOLutiT9mAnNWwuR4swCreh6SYFd6sdjZ9GnyxfsBPdxHTi8Hhpe +AUpc0/D5ZT7/teeEPw3U+gkQ5xT1M6K7AnOpTxSXLuDuLoicBBABAgAGBQJW7n1fAAoJEBhr +Ow0yeeeDpcID/RjPPEchwMh2jK2apGkNzkl9yevLylCQk0+1Le8bpeVe7l9A24kSCMPdS64x +4F6KNyR3dAngj0hUbbZsE/WydMPekkUrzk/8IOFNi9WlV//TsZqgRodTEuyxViH9DKpcqvxT +SZ6CZ3h5iZLxSos/75C2LXpj6l1iuubjNSyyyzqriJwEEAECAAYFAlbufWIACgkQO/o8pUI3 +nUvugwP8CTz6xK+TZ5sg5kOCiTweNHpEqppIX7kLvXrWkBG6zsSD3wZ3Yrp9SUdwLylY82pQ +oTxupJ/M9WxGqm6P36exmjVLfXVb1m0XMXc/db2B9qmhD23LHiJLTN92wYqfAYtGxoL5pj2y +HFMhOsNIgnj2+NNQDQWlFHPjg5BmsGsQimaInAQQAQIABgUCVu59ZQAKCRBR0BbUVS2rcmcp +A/0S+yrljOyO5p2mHIWg2SpF6l0OYbsrM95pnoWxy4t9RjjXfCaBgXpRoFh8ACPBZDVSgP/b +YKVYjCgrjDyaxtP4pTD5E6YLuKTyiRzVP1oL2T47WYAB1BrxtDWLEnUhLzGZjcEjQ3331qsF +DO2P683gHZzF3fCKgBU80xur03ME9oicBBABAgAGBQJW7n1oAAoJEDSJ0LZ1WD1k0BAD/0Ae +guzSllic0etGvJ/9eFV03C8SKnF+XJBw8r+go8UFs01ZEhdaPmaD2vjDfFgWO3wSyLk3iVH4 +T4bRJyPJgXARLbAzXqd8uvz3X+Lsas9guCGQPVPr6gar2Uz0ezKo4b89PaWbicHRD1YffCHu +0HaurrjWcwuDA/GSfXPQQFtUiJwEEAECAAYFAlbufWsACgkQ9+sLd1pX1JwrswP7B+hdtXPW +jL5spBgKSLsO7KSAD6bkhERFf+b0VOhaJVQ0xas2xucrEv6e5oOY8exjL89pSzokDx6Yi1TI +SeKvvQZhd/zq6otDHaMuqG3VtjWLJj2wvhuJH6IXRJ2yf9AiC4N4mpqeVuF5XUhkMDVsS5DX +UX0TsehxbvqGUaHSB/+InAQQAQIABgUCVu59bgAKCRCUlOQV5x/C5TCsBACyN1uVwDsfN2Bl +qeKICHnAT9yN4I5ougvskR+v0hLAGjV8RRQjC+kfCpytu34znEAfs1hViUGo736gkDFEgP9o +TFpDjMXBZLujkYX3buWb04oBUDTw68CBoSH8rZxTHa7Nga6/++7PM6hlfmJ46BuJZo2lA3+/ +pJSdestNxJUNM4icBBABAgAGBQJW7n1xAAoJEG7JZ4E1nl7vBNMD/2Qy1Lg/CaX4ygaenTyI +kV59c0+Ofdt6v81VTX5oq5rGLJgxxU28a4QaxPW3JW5uM2A6nAtLCAY2Y3WInFE1CzejJbPg +9UyPMLbRZFkvqDs/lI7Y7EkZ6L22pm72Gs4xGrit802/P5CwsKR0yCC6dnnLs3lu+Z8wa0E9 +D2JqbQ74iJwEEAECAAYFAlbufXQACgkQExJs2v7WfV5jgQP+Kq6B2QMDfyXw4s3tP5lTp+IT +7i44M1XdPEya2/7KhygZNoLYULS8f90ZQY/cmnZwkCc1GwD2fWOYxU/G7VBpqUevF6CZtQph +grppMWfa7oomg2zNHh3vaT57CKByWS1W3YNraEEeK5v7vjKqkHEOGKvuRhl4YJqlxz5Q8iU8 +Pl+InAQQAQIABgUCVu59dwAKCRASpyEnJsyp4hOnA/oCqD+NPKrYESrUxyIQsVX36R9uSshZ +cBnrcKOyt3+4Ps8+TDgoaajs+3OPqINUooc2ux7Kw/DYq3hfvA51eYLZihtqjv8dQUavYYB5 ++eeOVmnnwYOO3E0UES87UIIGjjLesHQDMeRXLT04zIjCGKy2xxinhcJhIj/iD+fZd/qYQ4ic +BBABAgAGBQJW7n17AAoJEOoyBIejgk2ziSkD/A0HkXyyUJivemW09EoFtlE8hGukvU6/chJQ +PUd6nmapuq1v0iaETLLRVOHOTqICGPyvNX0n5S7oR8ojSJCr62XTRe8BUdJjS+GYW09I5Fd2 +oDvKKK3d1/pVwTx+DRS2eZH5wl9Jr3wpIcFBWFGuRad1SVxRTMmQT4Zrs3AKaz+8iJwEEAEC +AAYFAlbufX4ACgkQuE/56HQcZN4PjwQAkMPfwu6aazYYdezEqfzG/PUxem1rZn4VUqh1eU/9 +xjiKysaU8ipEJjnai6W2tzMxUD1JzJz9zy/o33Q5zzUwQ6f8VCjlob7lf0f++Kts1k90BnG3 +Cua0IkTndP450KNkMu1Xuv68nsXdfcwzKtdBF7d5iVJ/g8zj4zfMZquIn4CInAQQAQIABgUC +Vu59gQAKCRBL+Q9Rs9S/BruABADGFXKvs4fxKs3RFiNLZ2mgo/Y2rXOotIrV8uLDOIm8YME7 +U2S0GF5T6i0uKHeHDHAGNXX1rCYjNhC57drbT1FPCNJeqfwIDL6y6JrMXs5cNZOfs5zwav6I +cygyszUlsYfo5qNOtedFN7DQIRoj98fQ/uGQvVSH0flUHOHQq/VVsoicBBABAgAGBQJW7n2E +AAoJEDVjQJ8wB4WFgUkEAKwErcLIdpYiDqK6U1MOQ3z+kwLV6SnUqiexZN7YiKNC8qKFXEVD +D1psOwhhRTXXwKeCmKrPs5+zGXkMKfqc5IPMUzuB8sq8KQQO/dUOoVfB677SK854/gCMjDSS +fzQJ2VY0VEctQoemBoQGQBH7++1wgzxv5DrCiaEJDnBgbdEniJwEEAECAAYFAlbufYcACgkQ +O+XZ+sRAlOS+RgP7BAseXeo44lL76xrtTcLdsDHAWq/Q44vDjJzkKEhGGy/f+HhAbnKNE073 +lpXmMzuOStxAj9khPtrkUWNYjRetaq82i6v5oNhcWLBnaI24tcVUG6BxD6Ye/qYOuNeg576w +UVpgxAb2EueeoS8yvWcv+1Tv04Q0PiXywJJatxzNauCInAQQAQIABgUCVu59igAKCRChYVFu +jY550j3OA/4u2KbL3mZIODKajec6qrkzXwLpMTwxsyAiQ0EaCb/gRsucMpKkSUrbhSL1Aerv +QodLBRuPs2h75sgX4Cw9hu9N+wJRr0SmUx1l64YDE7yeh6gXHL74VosykYLpnamAHl8M/7K1 +0bPrUOV6VXeC6bXINqMzpN+ZQ+7wSltPyPp4QIicBBABAgAGBQJW7n2NAAoJEDf5g25qpN7a +ld8EAJwLO0z0vE9phrRVfQbjZttYzmvIwkIXc91l02Y/ooAy6RLycq3DAti7uuInC5qWxW8W +L6k14By6HaEoZ2HBl9jbAa4Zy+gPd7LbvrNoL1iV1/SsDGr4mxOo/ZO3O1YeZ44qM7u0CC9f +J33VaL152V9aZHRbNiu502opGxsDlQ6HiJwEEAECAAYFAlbufZAACgkQcdxfMyoWVsskMAQA +nTjoK2uEgj64CgzNRh6MaphXpTViPBYwdlh+1xeZC6pWJxRgktzEfosGHy7aSE/3+GAwZEvh +b1Eo6BA8G5Zlf7XQPNnsmz2ReQuQHTAn5bXyszUrKOU6Ig3ZjJWZqWlW5bp086J9aqWUGiCT +VMPJ6XbQ8rnJmS1smtPCEcTjh62InAQQAQIABgUCVu59kwAKCRAKvINKokAoP4jGBACwTtqE +C2kFrrBnlWHpPcC8mHa3jK+Nf+bUfV0v9MLQcdl9a61ix/T1cTyGj3GauWHDici+b7wbVDF7 +OI2Doa1JZ40xdAz5cWcc5NZiXswPrNpO5OSqHYy4exA9xBEQ6EsjuqbuK7ofQAyan/q7jkwS +id6slvKr/wSU83lRFczb5IicBBABAgAGBQJW7n2WAAoJEGcDwle45X/nx9kEAIJKL448PNt9 +dXPrCCUZwER29NnLyFeVSJyDQzLfAPxdpbTT0DTJyGWlq79OD4IZsi3pURZ3BlAM6pkx2Lud +CXBCpDV/vJVzDdrLBtErUAH98GkQBFvJUWRpWrh5CCbcuKYHuSCnrNw/jGK0VoQtYauU+amJ +YZHb6b24OJY2elSxiJwEEAECAAYFAlbufZkACgkQPhBogKN0fR6IvwP+LiUnSTIDc+p0j0Q2 +3t30poJJZvJYGQUX2/KlNs4/8hYFDYTahYLPAUy7Ah3mfFw2tG3jLoi9LwicRjRP0e22iAcl +t0jCHE/hzLznUfccyBhiOg9wgbSrGWGk2dlY/61MGD3vIpe9neC/6tpIhfh418mzoBmR6soh +vW9dB+KZBmeInAQQAQIABgUCVu59nAAKCRB0h9puxwAvmiyLBACHwwQ5i6zp2pJtnWdDS70s +eO2JpLu0fSZrDRPsxVCuu8LnZBzCc4D5NqWrNbh+aSPi7ur7FGfLXXnfA+Fx0m1Y44l1aVXu +P119ZkHW2mLt4b8WD8Yi1WfsJjh6tmdHLNX61vuRuA8p6OMJN4ALhKZN8kh0l2ajX61J909b +ZOr/LIicBBABAgAGBQJW7n2gAAoJEJiZPb41Nj70uNoD/2AoLVBynyT2kJ+d9ch/8Pj6VsbI +Gmqq4y9H0yr00RzWAX4sI8z64988DRxIugzBkgc2OlmtiHnsU7TWCwBYO/mlZsGi9Hmt7ooZ +tpN1kMMztHLqLpK9zGwikLPi5znVE3PGzX/n1ltRMJPDTMPG2EQvUKgvFa8oKKBEvd3945nG +iJwEEAECAAYFAlbufaMACgkQS0wN892xxv/KzgQAvXZPHibjaELlJYELEGG8nZhyc6v3AkGx +wHutpUTVI1aHKYF7WCZ/ZQFrjU5U5cyslaX00KRy38i7LFG8QYpT5aJZIIXfOuQaKRj3yTGz +SkmtaeHFrKfwiFaD2AFx+5jOp0QgPWxFODI8lYAtYP5ZwrObbZWV+ugXmwijuJGvqqeInAQQ +AQIABgUCVu59pgAKCRCCK8cZ3trn14DOA/9GJvyasQ33lE4aErZVfaoXOnAOnJNzNIs8CWrT +P1/CwarMaXZI2lpkOjjck1NSm3iBYaOBPLpp6cwXnLKhx8ngzWRVqeDhNSFupAa0HYIlbkJf +V9A90j5HJpDhO1GOBeJ+jBi3f+BrqxRfhrb+X1RgcO1Rv//KBxi+15nN2kTvAYicBBABAgAG +BQJW7n2pAAoJEPrDh/zpY4LY9OcD/2VxxgoeDxG6WIlrhpoKeMWgBpy9YxGnyuHerT1XVS7p +5SrvAFB/lRbXXU21lVuNlOEZwAe5g1AVdmRl2qSKCfweKUT/RD2n3yrW5YicIGgNQ2Ui+MQp +4VR8fqhV35mQFSrtIU4O+IQDvstdPIsm42KdclCMdOTtNPSNxa2czivliJwEEAECAAYFAlbu +fawACgkQqk1xZeHIu1QjzAP/Z5YAJglA+U12aTXVk4nwSXx+O28Qy5y4g3H5QZy72v5KEBKv +ZU5OnLe/AmQyYFup3OKkn/O5fuKVqnaQegsUZvUK0RAM7nOCd1+7lkffE2wwlJD4dAJXL+0b +Ot27JtmdOaVWCDtW9dHuSJEPtdlBIRtbnokOIeadXQLki9u2pY2InAQQAQIABgUCVu59rwAK +CRADTS7Rt7CNPehpA/0UA47oVtPEsBBzT/ibVSasme+EEGtj2iZ7c0uqPuHJrbmarMHOGcZe +MDcmr/KTc7sty1fTja4+Z5vjlERYXSgqCmrvqFPIYUwnTMg2kNwFlNbq6plOCYRlFtkayCM1 +419jysdUFiL1RovG7VZbuRUZcdO/tAs8YJT3rWCw0Q68UIicBBABAgAGBQJW7n2yAAoJEKu8 +Hqr9dPPiDFoEAIRNrcUpr2Q+l9PEnzdt4n+TjFFrk78skZV2tNczjVaMjY0j2r3FfvNkUs41 +nYpbJoiELbQvGYVOCU+mMpow+p7HKtapYrWQV54DgoqehNSNtp0K1QdDUIwJZrOmL1hGP0VF +5ZIeGV0kln11axx8nwbuK5i1JADxuFCpttiCsZiBiJwEEAECAAYFAlbufbUACgkQM9moZ2UO +9cazYQQAgSlFB9j/QbnT3p57zN992rHdYB+7ttHDSvVADMWubDTbR6SWs9kpqf0L1tJUCgcA +sFwh677sb7YaEIt7A4JXaxfyfdYD1oqxN+kDrg/keh3dQcAAGEEfSRndckZ8WeZ0uI8h7T3L +XsdrHmyRVYMzeQUpyNTsFysF5t/uxUYqZR6InAQQAQIABgUCVu59uAAKCRCoE6yeS29WI3lt +A/oDmUrkXddrlLOC2IbePNEfWmBl3i8YhUdCLi1QegMYPA+NqSTInUhBppcY0rzr0VpJt52R +BdTzPGzZsB8jruS4ZC6wXXgFuMDsaapiulevAHRP8yG46Peg8PPImmK4MCxlDuDxxX7taqwI +S5BaZtruZcTjbODJ2e39gbYOTj9/zIicBBABAgAGBQJW7n28AAoJELdmZ6l0YzJTn5oD/2nL +8rzWOSp6XK/UN8zmdBLaciNiSUD2SvSb2iyS4DzFOU9IwxVu6arJycPFOLm+oXcq+bCEKlxE +m2qmQkMLJt9vgo5VtFK8T7SKsDHqlsAXYFToL9hO3QZZHVOQk4s0cscrd85YQgJftR+rS5so +Eqe+AOPoawthDcyr/xdTTVeFiJwEEAECAAYFAlbufb8ACgkQeZjRRHqRIQZUWQQAkxg6qhl+ +GE64AVwUBvIuqDM8b3UO49rF6T1kiRBqwd/8vR8zHd3AcEbdYuzLhhYYkRoVlhuvzliIaenz +zDEZAODBikb7paKYmkVZrO9l3NycRwePVSRn5fR78JasO//95smbaMp4CWAj+S2a1sdQ7CVK +fEfq/z3qpLmP4lZQCJKInAQQAQIABgUCVu59wwAKCRDmlV1XhV6o/rbCA/901/mFm4NSRelR +7WuHyDsVDlXOTsqf/JM/evF3UQvJwqcZpM1fSgJyonLw08dpY7EcgWI0BZg0hvSP8LLhFc66 +ypfEORyYnK+BvtXSq65nLbRBQpX71U//KGXxjX2UG70JmUelwrexG6g8f7fp/+kV4s7rhJYg +k4jlWtnHqHOkw4icBBABAgAGBQJW7n3JAAoJEFwAphP/NePRSBID/36YkHW4DVnU1Zx5zZlt +MBWY80Qi7LuKFwrF/5qiK0M+K6ub8ebyf2dtT6fY81blcH7Up5jALfOP5GfgNQkxJqufPlmc +DJZf6o2uwFyhVdzsSYIN0hNRVwBQF/mSUoG6xrpm5PiJRWvaCB3e3Zwos2sY/iBrEOCJz3wb +yJDiRKTBiJwEEAECAAYFAlbufc0ACgkQxfZaHoJPeJO+PAQAvOkTsMrJAc1CQ5gmNv5ig4iN +t3y0tB+p1P3XOI/y5p0nUWUM8A7tbCoyX40AFN8DpWn0GAyF0usRvW91sgb3BR0h+E9/d/ui +hWq3UXagXSAcEC2QulqhN9eO8eROCgboxZIczxcfoCvW8Kfh9tVm5NFoAw4b5ARLSGq5TJ5P +TSOInAQQAQIABgUCVu590AAKCRBOnBCtJhp6VN9+BACGkfb4KwyKWsdLZnWCq+wswqF5a+i4 +CbZxUuOf5hnziBehzXKCSBZgQsXBEO1YGdY7plT1VgxBt09BtHBwpJLTcgh5wS/b5ohg8JXm +9Ra+VwW0V9x5KUyE0dXWfWnxIsxUxWtduj+f3EaFoVbmfVvT/tVB+h3t8fSzsrLoPF+HNYic +BBABAgAGBQJW7n3TAAoJEP4S3lzOIGu9qdID/iO5OMGxGqAX9zMBVUuqUdgdSetP/8Q9lRWu +v/BcFgOYQVCoVh+lgqPid9zGDzILT1Cah85IfU4FfUbMpeVdTQEROWrV2goAZbWNU6mk+KXg +HRzAQQoyQ4FEyxGa/JPunbmq+PYRML9WW/BM4KJr8MnviyyDRiosoJAc1iXFGWiMiJwEEAEC +AAYFAlbufdYACgkQE3vrg55aQff78AQAsZiEBlXE3jOLPd4SMvqC9Tuzs6Jp9eIOxox8vAyG +14LCW+EkBfX1rYiSAFNbg3FxuHe0Nu53h3yuFuU2OggoYNMihnWmCqqR4J9usLZBDbl2/qmt +fSTKYyfuq0PL7zSwnPp+IvYW1tA6f4EfuFpLyrAnvTA7rcqZtzUZBjORmV+InAQQAQIABgUC +Vu592QAKCRASzArsq+3h0GzLA/0bJXU3A35E9T+q3M0/W+OCu8MANwPRyoZqH96/W5udHzCm +BeDySlli6MmrrSVLsy2OB6CGXIY9ceXfaWx/ThSNBaPDbe24rzJDmom10FaWKH2nC9KF2wQx +FPGJJ+9SwLSydIaqpBIgR22hz6a4OoemeVt3vKGx6vrVxlYLNMgaQ4icBBABAgAGBQJW7n3c +AAoJEPlnUQOCHJMMioED/1AclLci5g8ouw3rHZTyfNkjAjEUkcxvbZB0Mr7v6fBCI37iO26W +Rd4gQ0MezRD3am8WHDMqP7blWWuwNFwROmbWvFvo5YT1F+QrBOsZGbNZQP+4bApFynEhu2rG +7Vm5KNBIjp/Xo0js5WRpTsHU96DpKjRGZL5e1Q56h3Hv7Sd2iJwEEAECAAYFAlbufd8ACgkQ +gNxYMAu86jzJ0wQAhFbb17F6nVIZsqIA/Q2EfLAKtxT0+jcobBdIJXz3DnXPisALn2CS8C7i +9B9uy+Wa9vr/LmzT8x1r325KGIjQrnoFibJHeMbktKBzQv+QHj/UXH02I2izENTNWYIO/5SZ +0zPnW/NKtIBoWRVUqVhZLljkluoLeTvyO44/o3iuH4+InAQQAQIABgUCVu594gAKCRD/DQaG +9/IbKZvuA/0YLqta8ldwwTKPRpnYV8cgK7vNIdC0Sy+ItyNjCqG7RT8zLPgOYU//GUcsW5se +VqLyepmcDcMFBPyWSG2FCa1Frn/oK5wExF3W5Mda5hF7auIiWpTPdG27La3GqaihJQnc/ndw +Vjz4xqbpe6nd8zv0uFqQfAd43VleAHWedbFks4icBBABAgAGBQJW7n3lAAoJEHhJRg6fcbYC +v/ED/RyWe1Jc3kJqWqUvcd4cCZha0jZILyOC6uXwVSPjsYDYeFRpWwQ9JlHediNvDwmMtBSB ++5OqJraWyM2DVh7zfl1ybWLO10YCprlWB10OJ2IA1FJAazQQsP++QdXA47qCw7mQ5Ep/Eppd +xiTew1GhyoymVfhT3O37A5kMB66lrgJ+iJwEEAECAAYFAlbufekACgkQbk0uOhMXtiWuCgP/ +YOXsw8bs7aOqCp7jbnobvZjkpP95neLEwv2+VHhTgDUHmid3a7GXbpPKK7Gray7r3Uejs8vg +ofczdx641oebRaHJYYeg4xXRUoDDhOuEObVls4tSQ9LAUY4ce92j6nxQn4cVuQWHXyYP6iY5 +cvbLEbj7oXeUgx52pv4itauCOtOInAQQAQIABgUCVu597AAKCRDIt5C44cbkXNwbA/9eoGXq +w316GbRO8mQ8kqs8cqftbKb5vqmp2A6xao49m5+DUOtA6+6EGNjQEKFxVYYJMLzBCcF0H5ED +jqfho5wO1wXFlRNm6FFXcZHg+Xic5llaP/0gSvy6gRuslAwrtF+41gWDKXpCRO56/dZTmdFk +SoWwEc+lmNqYcuKjCN2OPYicBBABAgAGBQJW7n3vAAoJEBLsG396Ue0CZAUD/01iceWOJMXV +lRTl7/qt1vtRXFRSYvBAeC+LH41tpMGLHub+WQMPsULBdon2FTmRvr1uXHEk79WjbwQx/KqP +ChpbyuRPZi7TUw/mKDKJ2PU2LeRlY/p0rl5X24hm6sri/ffO7YFQk+ljEXhXo/5/vpRf5szo +eWRUPeIZHaRDwapgiJwEEAECAAYFAlbuffIACgkQHrQLU9wT5Rpn6QP+PGbgKxXlpA/r71hK +rtNp2AUwJ4bTSXiCWh3gQf2mzNoP/FD3uYdgdh1ghc0gi/uOfpSr0p85p/BQNu8Dt+5IrYyD +8TSPRracMYiVpAAINVasrOfEbfauBxRepXV2q9FhBUdB3POEO2FiJYFUb1hJqnCExJu0Avs9 +poQz8fXvq0OInAQQAQIABgUCVu599QAKCRBX585y4GrV/6x8A/sHG5d9eyG00QiLNv4h/yPp +TEKJMZfr3CTpD7MzgiAixcrCqdm0MBGP4ygSQ4t+ZLlnCDjNEi8oQT0dTHGkgaHELfEfNeMy +8o6GcXtP4kkEaaAiJReiWRDQRV14c0rijSNGE/GCt8XqRWK5UNh1Ot1CCsF6j9MbjcsckbXn +VRBnyYicBBABAgAGBQJW7n34AAoJEBKsALu/Uk48yxED/is315PzTcUuNu4WRbJ2Fz4pFE/+ +FRHik1UqfG2sFnbjJi7n61tWWMqAW4on7PREPHGjfF/ED1xcYrjVFVmoYNpPoAHPvfO9Nsnt +z2lDivnl8CTEU3K4oS38zPLVaUJY/1W2K3xZEVkIf3VxWrKjBG1htUGPNLlYd2oxoDI98oRT +iJwEEAECAAYFAlbuffsACgkQczF0H4I1XAbOfwP/Y7CE3TubPAK6RSGTx28oR1uXozFbPyQ4 +zmmMy3GYCA9V1PK/7SoCV3/l937V+gUSndQeNeJwzXMZqPS6WmBgsicyUDdWD0lU9GqN75Mz +8BTvzceK2iJbepxAns9Pnx4gDhC1IaEXIRzs3P6Z9vdQ6iBQBHIcKkON79gy686XG7WInAQQ +AQIABgUCVu59/gAKCRBBIvUX4i2DdHCiA/9r1y0VxFp7HeJoo89DZEqCO+3/uKaqLTYywuJL +L2L1LcAjgaH9SJJvbwXI//apsKC2ouQtqsKBbCgA/JW6sT/22oP/rXNtPCIrRJsMBjeWIGAY +Gs3u+ddg5199sLCTWh+1RwgGDZjxRxFz/61NfigydBu3h7j4t+J2ffwfN2GJj4icBBABAgAG +BQJW7n4CAAoJEG4J08NnQPAxbtcD+QGmHZwWQQlgKeSSRKH6uhvvmO/EqMCd0wGAcvKLOBS9 +RejcNZud4KFjOIggl/aodsxYGHc/rTqXe41F7FzqHOxSdgPh4/XUFs2821luxIa4YclzBrpY +BcHcvVaerTAIkbCh3NG4iPpm/XtX0K4ClFUDTSg4hbyjSSc4/m9Uap+fiJwEEAECAAYFAlbu +fgUACgkQSfn+Y7sI+vyUxQP9F4CqZPvFHRU9oG4mC4kgJTGPIQfQ7/9aXTE1X3yc6kuAkkFR +6rJrQwgjybrGTBrEHNjIc++zFes7GF5R094KKodSALDnQXr6AvLFqt9kdHFC+yxsRoWncsSJ +9ZQ0oH6FXyxoVvAScL1uSbS+WB757Y7rNa+YpWWaSzDfMnrS9FuInAQQAQIABgUCVu5+CAAK +CRAIK5vDaKzGqlZOBACWz+pIM16P9/GWygt9EVc6NgJzjHiao/+aFJ2i+0Uy9Q2RT0H1PTIM +EuYzSFQC28i7UGqYtZlmdjEvcqqSmMNwnOqoPVSzSeDYCLYOHF54jHGgeugl1jh33+aw/Ax3 +3FCm+RQ4v6JoHOcGHMg1m0TnX9jCK5va9stFC4p0VgTnjoicBBABAgAGBQJW7n4LAAoJECcT +JSEYGS2Sjv0D/0wsWiM9SNJ4DryO1X/DYOQPhUfhxErvUpWpKjZ3W4f4friztXl7gotVGmBX +KASjrEqX8pXXvgjK0AuM8EvD8pxX79Nwu52DDgXPbR8q1niZ4Du/KIntc9/wJxDHuBtZpKi8 +Ub95jDetQiMkG46rK0wa3XyOS2O23hxPtCjsIzPViJwEEAECAAYFAlbufg4ACgkQ2RRDG8Ws ++njnWgP+I7qDLxPDPYdSwJo9sFDH5arvQV09GSztSU+8BZ1tEOkcjQTN2rJEmWmBHTBV9hay +xHTTQsH27tePMg8r7hZ4U636MCmao12navT7aShHjl5BW7oXRsPFzZYNUE/sP/rUibOTtPz/ +4ppmwOliVp/FX82x6xAn1Uq9PQGTRHNNsnaInAQQAQIABgUCVu5+EQAKCRDcrSCpvNDQ2HAe +A/9HS3tK7aJEUxwE/mi4rwDWTmUk6KA0fnMveeFS7lnk7WF7IhSlb8VVmcs3QiS395PX0xzl +6YrZ4iE6qjrEi29r6mtv1234AVp3HUJi7/A4UGWpcSBuZZgYBF5I55gN/xYJ3NvPa6deLPGp +l9V47hAHoh7fhP7rsRmKtvSte5eiP4icBBABAgAGBQJW7n4UAAoJEJ3iMJHqBFAZ5KkD/1jq +q2sJ8Uq1iJQfMiznPjdhA+3PIpTc9MhjOiH67WnxUKKqcPa8noo9it9Zt7f8Gk7ig6csQFwV +t0qsCWqUVOf2vPOvks99ug0RZeu/+ndWIOX6DcWkFfcXwPT2i1xwirkIRtr5Nrf5XpfHT3Hs +tlApegt1WtxMfp9S6kpBsMTWiJwEEAECAAYFAlbufhgACgkQi+Vxxo3KOj1mnAP/Uik7wHsY +EkZnXscxj2TvibJyD1q/FvreO6kfiXgFtA6NXrtfrCxXA4BGACc+xLkKwrI+S4JD0p4b4Ayr +YeAFQ8UPNVHCaPFLLH50C7MfgA4s7IC/+zdyV7ovwk9Y//N9ErTdEQQwmiUydsKrsFkFXy0K +alEm7gAm+DKhJdf8nVuInAQQAQIABgUCVu5+GwAKCRB+vCrm+VsZNI3wA/4gYFFPVK10JojD +nOSTrwFsbCXgLwpy3sTBM5ffNeQfsLUGo9eF/7DXHs4O2ARdNZ00QZg4itw+/vywxMtkX6y6 +tVs0kR5YEawWT7sY2CGIwUKjGt8R42IbwHP+DS1cFdhUucGZk/Ca6kQANtAniDcydEgX1ohe +eAgsTfbOyOUPAIicBBABAgAGBQJW7n4eAAoJEMPqqFHwFlw2h5cD/iPlO4Z+CAyLwgaYFD84 +ZT/htFXJRnpsemMOgUgPCZN85P2aAZ8RO/Xds5TSsD0l3FKzdw3LQvR6XnxZBfR/mleotviD +jSIG3xAFvwZ5MMTAFTwAbwQcnYM8WNzBM/i6QOsCmCq+H7pzvjhpCdm46BVeSsM4+8ri/tL2 +8bYYCeeAiJwEEAECAAYFAlbufiEACgkQIFxHUmdA9XT0YgP+JvDdf81pmSdDIhclsGbK+MS/ +JUNPF9nDEnr6iagLlgOF8ZM0d3cV1jXgi9vPxGp3K+niVD4msy1FGwZ9ZV+s/Mdt9+e1SnTN +eSTPeAnqeC38OsgoncwFzMDXNfaVr/4CV6m1mljCCX9RXQKFBEiXDhlxY2/2AmLxUmpU2JYd +JHyInAQQAQIABgUCVu5+JAAKCRAttd7zPE4Pelu8A/sGLjnT7+TFDWtxSXRKFiniiecRNObE +q66jck5jm5Got2PFgOgTh8/szTMTBT2o2Qzrr9CVlcBFurHO5iSNT95I9dwzasQ8gLcuAqYz +WJJYDyzwkkAJszSPUAn/wfiE2ry4HiZ1VMa1yTM4LJ3S+CIRhuFSNt9b+rr4jjuXVuaUSIic +BBABAgAGBQJW7n4nAAoJEJScolpHoMIr9OYD/jboOFrR7XuXDvdGcjd59zm1mzTU/A2QwRPq +z4jZ0usEZd01VB4PN05uXd6HNT4s91Vfhc9ep5KkGsFJBKR+Q/9n/VTixGjUxYps9IVJU/kJ +9iFNvmiCA36xieruhYmYql2AfYS9dAV++XTXWRrZx+L5Gd80pXzsiV+m6u7Fuo2IiJwEEAEC +AAYFAlbufioACgkQ+2hq63rN2KUVCAP/dPiEchro02FWmmuv9xUqK3NEYHfF/XuJX+kf0Zw4 +U73se8Y9psPSw7nrAH6iQ+n1e7IkFKXAERQspmGZzN5nsdd6wK/CU91d2cr7bqy5GGHHx96t +nGHx+v6McWXUYbK635N+yNORsU3mWjhAARLKoGPbx6tPPlEad+68Ym8Wy22InAQQAQIABgUC +Vu5+LQAKCRBz3guv2yljjPVwA/9wPZ32jqqOS5Gae2gnzUDZQ70XvtCUmmSLzTaw5Lc33Llt +0vrYwScBnTxRBlXnovcGrlkIgYnjgxFXmSreybYmnK9wZyxmIKAx2xZA9NlanVkRN+hCzedO +1tZq5mDQFXrrJn3Fmy9ypLan8KSui8+3oyDtfWAblg5NUTUDpjRSnoicBBABAgAGBQJW7n4w +AAoJEICIjOEPVEh9tD0EAIvwGa38w4+6Vo+Gm2AA3XWvpjbNYe/LNJnZoTgtUMEXC9vJmBs/ +irKZo8L6pzyPfnVw9X7irymsekUNlY1EN0JuFscykTHRhFCbHixM/v3HC36wXg4I0hTz7qZK +jRvvJ73XGX2hc1aO1SE7FKBhNw9k84cMRMdZtYI4Kabbgv40iJwEEAECAAYFAlbufjQACgkQ +rHF1GdN9mZbQ7gP9HjnySvy99BhQy4xsQRGYHATFfDOvyEAZPJtHtOA/OhOZN4JVrQDfSt3C +I28jMUFdPYcdva64sos41VCqiNm6yJhq10Q56u5whW9i+IokgnsI3X8o4KEwKlV3/zHfMMab +lD1cBakIcMPVUeMzp0+Q63Ftxdp7tLEGLRAb5SGRwUSInAQQAQIABgUCVu5+NwAKCRDS97N7 +HgzuUDmwA/0aQIRVNHUVDv2yXIqyBruuXwAtcnByGoRYRcrZGGxkcGuMs60DeP/9ozjZj5f+ +PKcoLIO31e6CqCPyBxMKzJhuQtqYJFtAbP5TwIAZ8Kp3i2TLw16BDiuUStb2q9p3IJmmCKxa +aKuyv4PTAds+HzY5YbzsLWw9dWZC54E6i+IhMIicBBABAgAGBQJW7n46AAoJEDuytchrfZaP +EZ0D/Ra7Teicpy+1wyHyA9JRWSr9aAW9clFajM/Euv2bKc2YZ1/SzojlvLeIhbqR1tAf/EWl +6MeKCpVKqD8T4+0AF+h5Xqe3YJ+RDCk6fAk2p0TDEgkjigsCb1gNaf1gG0Ux55uhdnHhy0XK +lHOEq/HlK1yiOW8AdlpogjiL1luo+KlziJwEEAECAAYFAlbufj0ACgkQk0jF+svNcaYNIwP9 +Fy4qbWY6Z/9A+k4jeHsXPU5PieGufxpjS2NewVsLj+r4zfFP4Mtu4DOilXN7SYYEQKmk4Tmh +JHZS/SS3iH7tmB5weVRUNJR1MjiRjEx2clor20TVtGEN51iDO5PKXxPkJsKB5Bo/GTR0EIUs +n8Oa23fEof10SHk+Al4tRgkJaW2InAQQAQIABgUCVu5+QAAKCRChalNK9iPwEZEEBACVEm2Z +aju8bHkjyIwjwwl5BS+W+qUlVw0uYasqe/bTuHGlb/0qTTyDJUxVOBi4tChowVn6a/bMlP4Q +gBqABbvy+DeekFmg067xOV2il00S4VD0bFMsfQm+8Kww3cfIEIkBVh8kvJedD73TPsauXxhJ +hMdw3o4SY4N67LhNsF2SZ4icBBABAgAGBQJW7n5DAAoJECOKOK2idWaVT/sD/iLa6NIPrX/N +GdUF1pr+GA5nXK2P5T9XMkXlDHyWebX95Y7CrUJOW2ABr9w573O+StfDTjrTUwfhKgAzSQGw +IY5u9f927AFsPeW61VJv9RbEO4Kh+y/k9yrdKd0N2GTtI/22gUE9u/rp0svHZeUC4mjt+lDJ +Go9iwHTI1P7hTrkriJwEEAECAAYFAlbufkcACgkQJ9FxGgxBGs4L0wP+MjCO69QnU2ePPcio +X3BiwpopygfaJvWp9w/dgiefGNbhPVZdshMo4Yvcrkr/YTRt5BVmXu05uZYtiCGxEKz06xQW +QN5FeKQqpeKGsnSa0wDtad3N7ERFTRsm9RmCraQPyvGTfzhFe1JYTIBFLtGwVhKNpwDVXV90 +u6/zJVbxJz+InAQQAQIABgUCVu5+SgAKCRBFdmChkkXaPlGpA/4yy4sXb05ZkverwlJFxa0V +vQVXfHlqNiFRuZVHTFiV1QtVSuLk9o8tZw2+C+WnVUrlcg3HTekeETV3cV5TVlRU1MlAp++V +Z5oxDhLFPdu46s6Hy2wgt8wqjqNqaZg7i/DKFj+7NErZtXvMfCExyTiyL3LopDPZzxCP/sjr +/E5u1IicBBABAgAGBQJW7n5NAAoJEDS38MS695DpYSkD/Rz6nkoHwPiVWyJvV9dkdnwILnnu +Xv3frqJHh8E74u70oJOumXySnhUSTEkVjmMeOCIGf526+pt4u6JDkk+kcsRKZSlB1wiJoJfQ +el80Xir6gZe63ONV1a2rPv/USy1nicmDQTwPswXmPf0lVXPXlRwhrth4eXS5ld7mX8QNchLz +iJwEEAECAAYFAlbuflAACgkQbianB/AhgT5ncQP/Z56ZRfbwPGZPYfnk/l1pSTh29MzgX3Z7 +TGtZlEzQcsOXtLg+O3HE6U0L5XdrkVXCSggSYAIpMFVWRByO+BerpIB3sJPgfa7BC0WAcMcE +ndZR8xEkZtszNAU4xK3j3xCg5VQlHPQvj/YMbwJ7Hx+Beu9oLBhSFlFlr4oMac/lGsyInAQQ +AQIABgUCVu5+UwAKCRC8Ai/L27U4q0BoA/9pBUc8+2Mn3TzHBaAWhpbW017X0QeeOr5NgWtf +tnuJIZCdkYf3g/ngaBAagadW2kGxHYhk2B3tdOUIYUcZDJfEd11VdLyIz+A0LYiQpIqDfw5L +RcZKNB7qse/S6NCOhQCSgtJ6kcyh9Mfq1ZIPRrgojljhrN5buwQiV25RlCUYqIicBBABAgAG +BQJW7n5WAAoJEEHmPpk2SZHVp3gEAI0/pL67hhq8lUHo+VtvjeFOiuGWxCm4VvW6pqS3jEKE +EjVSI6Lg8qVgknvJbHQCKVAgneBQxMuQ5Ym0nD9jrk3sEG6jWg+DVGTPqZRsW6stvZwUWFLN +PB2uoX5gizMnnMjkjOYuBasbnzqCQMecwYR9JhJ6vkqo3Qb1SwkAqY6RiJwEEAECAAYFAlbu +flkACgkQoHR67ltOl4Li5wQAoSDeNiH16wbh+0w74TWLrBfz8FCHrNhv86QbrcYd0VM9Ociv +QReEqSWGkR3ZsOnYdE4ju0qI4NikXkPoOHKDL/wF8lKwpv0mv3Q/+ZRmTByOqg1V8HmV3rns +qt/SJBwSingcEtaT8Y90IEpR2PR0vUB44m4oqjjy1Iinf7peb2OInAQQAQIABgUCVu5+XQAK +CRCc2XoHhf2HBshIA/9Isq4TdT1eSe5KlQP6N4j7fZXLwWCs1QitKEZGTglyIOGZPIHCfnPh ++a97278Wtto0SgbbuaqFtip+YLCuYlmojge2spasllNV6nc/Z0W8kbAdJNO0cuERaRBo6Jqm +QXSXpqAlrzH7N16ZHcARy/Feg/8bn2pnnqtTO9IHLOYrH4icBBABAgAGBQJW7n5gAAoJEGdp +zGx3pTu3NU0EALoGY5U6UAYc4uWrnunx/o6Os4gs1sFn34EOiWeDLOJqydPBC2wDiiqZ5M6p +qOfCnxzXqC2V+vq1sN/nBKMb5mzos1JrGcOzuV799YnjSMideGX0bJqXWQttJdxTMffL9JRV +7j/aJdEIeUhaIBk8ocZMu5E//tlEp5HfCILlInQniJwEEAECAAYFAlbufmQACgkQyY4kE6Vr +bzZ7IwQAtEYLfFEjdiqnqfZOQvjmanR5AzjsKrg+HMr5GgGaOrJ8zZu8vBYI2RJJIfaclPRV +Eto3fd1esrw2knVXNyBAdDhskZ1ztNR8rAyxXRra93QR/wpRD/dPrPQYSz2nNvy5k4N8ZmsF +ZgGILjjVWjH4S/6r/BPqJxe0pXJggnM0RdiInAQQAQIABgUCVu5+ZwAKCRDDbjObEQ4WjE5f +A/49BfCDclrCtUtEsbrzHEgQcC/y1eL1wFVPksTZDypXKDtwt3ryK5OT4O/V+vAvSw6AHYel +EgI+/NqCO3c7y0+TVXg1bDfO9e/+5yMPNfLwU5TOzKeQ23dWpc7kjU69cpaAO1rhHBXErSZw +PVlS+leU75jZ6DqkUcUv50bozZWFUYicBBABAgAGBQJW7n5qAAoJEFNNjjzZ8WoQYh0EAKXa +ORQtP8OXt2GxtPWzO8toZw8JjUUVEF9JbJczK0DRM/1eRKm9ismemeK3tMBgkumPi/PEKV1m +KpfQc/2YYwoUk2Vrvt1X2/Ys0AUYBn52wQrT/Iuvx0WM1pMxez5XCNw2KnBfxD35j6ceFIBm +osRKqxyq1G8/Ryuc+OnJWiAhiJwEEAECAAYFAlbufm4ACgkQLi5jqK9ndSRCrAP/acRT9IPy +NvvieeNK1wB+Eb7TU/k836Ut1roeKsNNyuZuGegVX9PVftReSwsFKKE1LgEv1TKIbFOtxIQi +vxQdiYDHUMSR7yXwIgRJpFhTJbeGU40QgQu4S2qyA9g138xBNj72UHRMJzr9QIT30+eYbBwc +d5dpZ2HGJdGSQh0A04eInAQQAQIABgUCVu5+cgAKCRAWTNEmqoYqYcrsA/wNGS1GPu+1c8Ye +SApa7deVmylNEaUkwM9bxxDE6AzINuQ8DohPIOwhXOyiA8psk4ZD+dUhDGAsa8f10apbQrJC +LX0+FFfg9a5aB7VIRYV14e7p+z/oBamU+D9iRjbPYtx7CheR9hMsRMbaN59rvHamDLgW/zCa +mZduSqYCO2YMnYicBBABAgAGBQJW7n51AAoJELG5SAT1Y+BdPAkD/RsANzcGjB7fGQyi5uzQ +RQxgTxg1APewHvV6T8CDem5bB8LDB/37ojyLzcpOBK++KdqTR463Y9egPUM8ObunTDJdkl5T +CEp1FqKDHX14iz4tuRd5RIp+jGGAGX9C12mLgYvyoezMw1UjP2RRCBTcE0YMil0VCPwIP0AM +0UOmST2PiJwEEAECAAYFAlbufngACgkQSSgtXsmDC1SGmAP+Lx/KNZ1Sl/H42SzNpMXyFuO4 +MkX/G3Qnsa3E5c3vG8RAwurj4AZzueq5xkjgEowHGcOcGj1cM7G914fF9opBwxZi2/B7NDw/ +BusdLmzToLyT3furM30PDPR4TCee3k96Vz4j3D13TbZtuR8/xNervAIrMeMCsFWvAXFxeP2h +sTWInAQQAQIABgUCVu5+fAAKCRDGEY81ntQxF3BRA/0Zvz1wjp1AnJZxM5DWyYB585PhLHD/ +3LYOAIf2Zx62j5Li9IM0myiE5K6lMK3NPIQrO0FbRYONjYJ/rQ6aEfl5nXyf6S/odSiOSB1X +8wrh+W5W84yXeYmSgL7udIHWZU50Gf1HCd7qEjzTrqwUPoPFYFHaG5KdfNlsgq9QFzGJyYic +BBABAgAGBQJW7n5/AAoJELHhKsubxNkzlWwEANeDaU8a3JHh12WGeuqj6NYe95Zr5uTjwUdN +YbyiLAJd3WslMkCq05WFqEYOWCF+g56/7OTIpzDqpiqX8YR9eSsb7Q7Ecgg2jc61KnZ3GTkR +YxCNnOriVutTDipOisBE6WuOt7aXsultAC+tugi2zz+R9j/4zwE6+CYwarLHPk2PiJwEEAEC +AAYFAlbufoMACgkQ3XbXah7f7j0LJAP+POucib0TAQuLolHCzs/YRzz5uRzdySZXFaTMK+0w +U9BxNkQyvmNHp1T2y687ufC9ISOB62j31IfMx0nf/qj5mvy3lhbdJCMvhxDTngtRDaHwue1d +0H4x99nGk6KUvtTTdhm5/AeVWoed9EBrogYUtdjA4a68SBu0lrRjmh8zVaWInAQQAQIABgUC +Vu5+hgAKCRCaWd9e4AJYj+D+A/0aqvZY44E3+UWpxvz7j1GxTJdDf10FBuVXmHSym3VoR+q2 +2PCK++nX+Aunmd0JiRAyAHy+dWoDppKe3Mm62S1fCeewC3xLFq1cPwtVDufOxUKfwHzjHkH+ +LZCllMzQifF8rO645B9kURRFlMhXFWv4+j3NvaycGkUValv8kEM3HIicBBABAgAGBQJW7n6K +AAoJENyAwsElmEluKMkEAJCkZwLakM+zUrKy3UHr2C93xZmbkRv4TXC6LNtS2fOJxG1Sak71 +cu1Shv3fv7fmywm1BYmTwf1XJdmtTGDTA0verc70XAM/U3KGhlhsVmhOnob6wjuvyLWv0RjE +KZw5QvmXCs4sZpd8fiXWJ3ttVs6ph1i1/j6boLyeAmkdCSfwiJwEEAECAAYFAlbufo0ACgkQ +JUFWQ7ejEqgcPAP/f12QjQUTwXlwtQQkxLf8RF/6rTgHv2TOBRWqgY3+Ees4ZkeQNFTdMOUP +uiDQwKKSXw5Ab14aIJvjsCJGdoHUfFR0Qe2XHYr6XGSM7tRN4+plccgmCFZue2Y8rU+ZDYFo +OMrsrJ5haqj1afRAwahdylXCkknhLPWC8RzqptyQw6CInAQQAQIABgUCVu5+kAAKCRCLKMkN +S+nnbO+eA/93JiXPjC0c8k/A8nk8reLaC5J4JTwKxu0vWxPtMeFkSRaEqGrLzZooI2Zlp1YF +1/uLcEA4YHduRNTAUw44zqLACJ3EiD6bwdslt8fThf5XzfhYwb8v/FzaJMn8lHkJjmvIan8S +BIOpyVDL5HHw/E4pdSVVJ/lJ5JNWlge5GHECCYicBBABAgAGBQJW7n6UAAoJEFa6zOU/aq9U +UXkD/j0XXj6EDgMEVUpTM4OGY1M1wJk3dXmKxDWiEvnxz9iKIQVZNHk+oVGJesDGOZ79092j +K/BA8FghBrheWMR8XK+M08CP17d6RRoXW5/nE2hY50aOqJmq5eC5B+ZoWyRGvbNa+JpHUUuV +sYw3QRU7g+BCGjuyc7uahgWmBCr2yF+iiJwEEAECAAYFAlbufpcACgkQiyJ7lO2KqR4f3QP/ +TOkHCh/nxWSmFvwBKpHhIbAq6dlJ/sBmpA09dVd3JkLhNy702xueGqKXxkSQCCs731dWA+Yo +X5QXBp2nMs96LCTU6VcW3skc1qUmUQIdvRpxcMOn1jn485dqs2i+iQ9tXUHz/RiGCcqW8IV3 +ty/R9c+OYgcFFK/d8eSkoNY13fqInAQQAQIABgUCVu5+mwAKCRDnZDUa84lufejrBACjEt3c +Hs7RjejpklSvP0WA0ZRgDi0BcxuP4dLua1nAUnHLrIXqkeDw+P5+RCJ7amouKICxLa42cnaC +Vw4oSBfSo9wL1tCxpvUzVFGYuZkzH/Gl8hWx3W8pr+mw958YIASoscdQbiWlDIAg3jBTU8XH +KzsmZIxPbgje7NXV1D3+Z4icBBABAgAGBQJW7n6eAAoJEAPJXEXUUvmqbtQD/iZ+2/BUiBm9 +fGtRUMjnaio0oV7djkgV72n9Osygh8c3DltSXHKwpCIid3ZlU6QNuWlcSdAgY79DWmuDw2fg +G8lvjPvUQMdrr3Ix8d6XyW8v/UDoWhN2Wu4IggF5z/VY0jYP8OoCQ2P+Ah4kZdb3CrDOTXJJ +D7E6RZ5cYloh4PtmiJwEEAECAAYFAlbufqEACgkQJBlcyrOhI70cNAP/ZOJthjugmLGIHHYf +DKky+tZbbhh6SRlrcTpwf+Pme8l74vAwcOdHj3IhytfeMu74XM8ZPcPM5iauKuCXEpFia4fD +5wOhTLvTVL+oQyKX5yPspTveFr2ZM1SxVmqV/Oo25UW6P23PjhJqqSBhayrU+gwBPmFEJ99m +IiMsvWGm6GmInAQQAQIABgUCVu5+pQAKCRADjb0n3CsUfHwrA/4vuftt3UfECbrEBpNPfVin +QWtnn2T0TCmDecVAgUrKteK1rpeeVU3mBi7NCdDARNyj25iL2ymVbPKhEU/KmRjCl4QGDYyc +3PQ9AauiONjas0KkXB/GHwPG+oROMz37TB+xDkrjjbjR4aXYnk7aqUohLqvzwsgXHhsf0ipp +ep/BVYicBBABAgAGBQJW7n6oAAoJECdY+kqGl2XsRsQD/05fdz4B4+PRx7wNBsy2bladMrCf +1dhejfgq4BlocC02O4DkvDRTkrQj4GhARbIvcsoJMVGK+gD+CzGtqDbtdGUdT/q0kT9Kv2vP +j72Tv5JvjQHEpoPyppAF/12JKn7wBiBVIwnTbO73cAGDhjKdRe3CqmtuiB8eAr0lu9ClRyVd +iJwEEAECAAYFAlbufqsACgkQA68KdVVNfr+DRgQAj8yICL4/1jMH1r1OvPpxbbsXE+NLH+hH +vbkhs4SsF09YAMS/c1bvSrYnppM30rWG5GpUwGkuVFWqbaJrxAvS2V/mQpMBMX79MRGRi8qT +jppKpv/fO5P9WCuW409Kb9RRxk1tPqQEoZU/HWqsFC+6pNTy452O/SWb8pgGWdK9AdGInAQQ +AQIABgUCVu5+rwAKCRBL8p9EYTWf6KMiA/4uskizYucwSP83eklsgvC32Tw6uU9gRWB7fNqb +iV3z9HW7NwTb1V8Gc1Fm9MwkRntX23Nvsp0sXZtv7UUTLsoz2gdXWOI1Puy2V7COytQ1oKrp +oN4px9ffCDAzy5CsDb4xRrBNWX95msRUIU5repRLD9oKXZiJEzoyWvmYPQw5S4icBBABAgAG +BQJW7n6yAAoJEGmD1dW6QVfSrLYEAMKjOzACcxyVpOa/z0yAOEYurtcGsDhUHiXIkejTRmpO +GXsyzBRfFCc9mKHf7tYlMGQKnK/pyG8dceTriypyS30dM3NuPtjcJy3CgKagHDpXM5V6i1ul +45ixZAw+CySB+PVWISbJwE5ZZtvav9x1NpWeJmCKHXEVVbxc0wBe0bikiJwEEAECAAYFAlbu +frUACgkQ7DYSt3Fc9S2D3gP/XSmLfRiB9VQQSBKbU5ilHNoquiH32glz1nu0T5mC/T5qMhEj +K6geYjEyhNs4+bkbIGzBI1of9NpybI+5iygK0hQVBwChzeFYNnbsHGDyvq4L0ervkMxQpCZd +qMSsPJ0ZcbqQpRL4zbv9t/oTUQZV7d7UqlE8xzY09FEXiYDbdCKInAQQAQIABgUCVu5+uQAK +CRCpCk1YW0B385/zA/40jGyyckCnCQOnBUxmdDJqiFozONpCPFCS63rL4Oywm6vzHhIrOU+J +IcOb3k60JgSd2lADAiWNYzc9RglBrz/2a6vKAXEWv4JZA2ZwLa+k1Uag5gbxslM3H67hT7uC +/BZYGqCCMnw5TrYypKsSGK0r+steNNzzpQRwDYoZKd3yTYicBBABAgAGBQJW7n68AAoJEJFS +w+WWEhhBjMMEAI5U+K71HDSwpgejCJWtvKTDceaixWiAU7hMZWM7E32HIePtAwP4LGEn0eey +c1iRhPXOFxaL6gss3mX3kdEHhRO+sOh3sk2JvR7M4fa8UdN/BlpLK9A3CY8c5AMjAvIHx4hA +K2OJX+XoqxHdC1V0Ql8Mx1gzW+YxHHk4VEfofxRmiJwEEAECAAYFAlbufr8ACgkQOtEOrx26 +9TCYSAQAx60xGqXdBXdVNBe5W3XPz3hcdvCg+/nBnhIraOy+EI+p09tAAHulzIq46UiVDcxe +Zx/HT/XZzSeTWKkFRno0I/wTidoMc+QI8N2B2QKgbeemvlQP/5DOlDWVpq0Q7BViufupE9up +SmaWFznwCRtdF6IxRGPEL1Jpmi0GSe/fsPKInAQQAQIABgUCVu5+wgAKCRDxu8uDhDwTMSaR +A/979xquxC0rk5dG1BvEC9EjgBAIh8IHy8FPluQk5IpRbnpl3TqxuQSAIqfBQdHVhYspesh2 +w2VVzGM90k60V4UHdRKPwUs9d+fR1zZ7YlM211oTjfub9pR3d3kTr1pL8adJXtNjQhEizxCu +LUMhIl8ht2/IWBh7BsB2HcVx01v/KIicBBABAgAGBQJW7n7GAAoJEPPhalfAKwwec3ID/0AV +4aT36vanpy6z5yscZaCF0RVN2NjoJLE8MOEiCjSUu0WWIz0kBco4hRIjpZGFRKEUdHk3Cg8T +h8sdS4XHCww4lP+1vQanlnED58fUpe5DRGYXVtQmj0eeyuTrdiuaPOQzSRPX3uxwNSJvQGNW +D7078QMCETm52y1aDpoih90ViJwEEAECAAYFAlbufskACgkQy02CtCsRmokLbAQA4c9on30v +c6hOXtWdYlVZZSOmFyHwAbGjQeKcFrjmtQGwQsBmrUiVaV5gYX9QyBVjKVQO/3geiQivfg3m +WGvazDuiVBiW9R4sbqXMnhc9VljMStTtJywNGCb3kuPB6Bv40o3709HX8nAYp1q5pdMOHoiW +VJ/hoppbbC7hd8o2NGeInAQQAQIABgUCVu5+zQAKCRAKaFhALZf/EuW+A/908mIaeRF43A+o +ojmJcW4weS/1qn33aHKElPlRhH/5K3lDP6zDZqON56bH4tGtmbt1/TuTrwI5pbZ8VsGd9NH9 +wteSuv8/wIPkYHYZGJxjI0eraPgS8PMffuv7/cS+f0QxgkucksmxSxHZZ1xZ/xKDu3noU9pV +zIvmkg5+9Y/sCYicBBABAgAGBQJW7n7QAAoJEJfTZNwMv0qq+3wEAJOJT10X2BVk2+dRtGh2 +rZeSmApjuG6nZtPFHgMexbrG4YHY/E46eQDdZ+8WLstA1ud4FsK287Rsjmt7MSwBwzhhmnSm +CBnhRDrlbiOgNZ08YgA1G5RlkjTIFVnTdQGcUensjbGELX8neyOmG6VggjLrkRksNkyjAzuN +D4xBZ0NjiJwEEAECAAYFAlbuftQACgkQZgqfFBNE/OXJTAP/WrqSEuu24CL/Y+rg8qo8DErm +475Zj9bWhkR5RuNl78hik7x/c++ZAQxKwPBJ8ila8WEtSUynvvLLFOQOTvz7zsWZlahvgt8g ++9kE0ZGN/3ZceI4iSI0q9QgpQy9cdpMy1QnZWd3BMpuyZmeBP/sT8DtsoCYDN6EqRBJ7nVBe +ww2InAQQAQIABgUCVu5+1wAKCRDI4W7fHk2lj33GA/sGZ9Z1QmsJxxFgHSknbZyO68hyYTY0 +thj4hf1SZg4B6Invzk2/HnIR78DJTA3Nm9olE7HhmZ9YOdKelBwZAqEqgTmjy2HsMyHFEOop +yKXZPJ9fghCmCukQG+aXEXixD8Tx5rFXDnIzcAxbvp+wA7RDMOeHgYLERuipWu6EA+sohYic +BBABAgAGBQJW7n7aAAoJEE5z0h0iAZXSJqoEAJntHc9euiD/yn3gPFMmbFC3hy0JLSY9qeZm +W/HC2OqiwUuW3odg08jiyB3VPrM3ArCt30Ootd7sExW2Q2+ODVtZGBGraFo2xzuFpx5qbuen +sWTnX0K/gO37R2EZjSmBanF1O2EfCFw6pf641S6FnICqvE+J75O0LAF4ttFNCLzRiJwEEAEC +AAYFAlbuft4ACgkQF9vRPWOEk7XbKgQAiRNTOUIb2kXJKMy++UTHbLL/xP+i50NQxwcWYiIv +IoKh3Oy+frLNAmKB06f52NBYYKQWZmUZqx2y7axgOo1k0vDQQj+MBYyogwjL8BdIK1R7vpFb +RLOTMDJ+lTOz4qbZo/b/A6TutXwmkn/y532b6vy3st+UF0m3nvkW7FIgr42InAQQAQIABgUC +Vu5+4QAKCRA/HmEwX0FbxyO4BACax9EyQjU6k3VREmU7GwmqZIOmZhq0aO4ywyPaknf/nGf1 +eBiTQmsYg5hOGWNS+hRSzX5l8HNMz/S5cFvnNsiipvR8owHj+oKVN7cwauByOX3rRr3+lXgC +1lnBW95L/bRbceBqWiP7WWX4ce1Kd5v4pjuv5FKt5sImBDLypI3KMoicBBABAgAGBQJW7n7k +AAoJELlWg7WWKVSMmCED/1CKj1BhOk8/9VPPNZSY9t+jRldYm0OFZPrtz8kXbe2+Hg9ckPLi +hfHr6CeRFNquEu+eI1PXuStsrTx534JK+XRwz+pAqDqu8ckft0BcklVAiCI3dWvzDqrb2kiw +mYytCcPa5sU48kW2noQP1+wx3MjNkTqlja1qhXx9kXFBR2yEiJwEEAECAAYFAlbufugACgkQ +Y+AZ+rW7vduIzwP/Q6l98/i46OTDkQjphGZ39Vbe2atpMJYDHJYcMXmr8WgbPapSE6cXf9Kz +WMZNsD7AcWCCLjwQpWW6QVYjtRQ05LDq1bKM9vLEIeyWE13/PM/2mmqTykueI2vbsD5BSd8B +DzzbAjFXy2hyoI5Pqkau2PEgNigGKB05u6pdGCcOJFeInAQQAQIABgUCVu5+6wAKCRDIWD6p +wqHXyqrVA/47Iv9AFzivEVMNOKKmScxevemxC31xQ9pFqRlDGON/NCcL9UozBpWWZYtsJwZB +hVlzKOADuqBTi9sKqQCg0DtDh/K1j7agmGGPcQ1YbFws1Ott05EaVh2/BKWbwf4d1//fhWut +JImmp30gC3KzpA0ALXBhRmyU3kColCQeRueL5IicBBABAgAGBQJW7n7vAAoJEFbmeya0qqGl +HKcD/jsOmwNYzKC9IEnvbhqZWjW7MV+QJB5tk+iGCXhk0XYGBPkXtQebZYTL6QO1fYWLA3on +nc302kB0I+G9cnJ2QKd37fSeUa7Tl9T7PGZ1Mnr/4sce8k4P69OwxwUqyG6wPXuXuXnLQey3 +7MWHAonny26XCF7Ey6UIGIZ9VDrQQjn7iJwEEAECAAYFAlbufvIACgkQT8tXeBgYqwE3bQQA +nakz15gz8DHtVo66zODKyXfJGUmZsH4o9MLP4Nus5E6tYxwqKxg2bVnGSx6G9HGQBCNcV7H+ +QX3P4GGzyIFQXNVy9Fi+KW5ggrnFlDvjODM7Ld4F4namAx+POTvimV3mPzF1zc1Fl8wBC7+u +9H0wwbfkasfn2PGdT5GUE2M5IsyInAQQAQIABgUCVu5+9QAKCRAP72MTWmEvNQm4BACCr/13 +IDuxNGKh4GEXZW7dMPGR2cFWlo+jKIlkTl7OHwalwH7FXntxF2ZKM345ktY0p4npobHdJoK+ +a2kZdMg8dhMraJ5s1WSQibR+NttphL9O6kPgRF6rfbEiBW/sM3fmOwWFueWGkfMVrjywyChX +G/DFMTS4YVQUwRQsOCHu1oicBBABAgAGBQJW7n75AAoJEL86KH9nuv7mbXMEALhH2unkqggs +WP6N66QSnNrm2fwS1bX8dRCJN/Lc5mNxXLL6wB+17Rq7xLsSEFrGDsr4zUx4v2oy02QxN+6L +QU+4dJDOlT7fwq+fCRpCp0U6Ti1DBVxpb+rawUL7lK699z+KLcbbuezKuN5pFy5azFFIiCL5 +OFvPVwS8+p9LWKJPiJwEEAECAAYFAlbufvwACgkQ3kGvBmR7Znp10QQAtRTZ7rkg/73npPPy +SEo6uU7Z6QprA27K+LjHPKLNk8clIqo+8Sp1YJOhGNadoqS5Bh3j/5aYG11KvdVLndHcLghn +4VT4qVR5y/wSAMb+55rv0RyRtoLln09cMML9wrcWtkngs6p9fCu33Q+/ztGzc+Cy3UOJKWuY +d/OBMAp7JACInAQQAQIABgUCVu5/DQAKCRA08NhVAAyQC46qA/0fv/Tm3YkejcPxCHu7NaQJ +igbMpEo71DiDMQDDbjbC6EjIXXqX8tCAIf2Y26zjSIBg0BOI4RQhBZDBLFalnFg1Ud2q5ofj +tqBKgP6JYcW9G1N7lG4ZjiOMnGwQvSo27mg8VuS1rpMGrgBjn1W/1U2UnvtkkoFCNKux6TNQ +sMxax4icBBABAgAGBQJW7n8RAAoJEPDtkg3QypXA4IgD/AxUhJsfbDU+Avz0mlEVlTqybrz9 +lss3FawphDR0C2PyeKxRzN1pRVHi6ESevfcPoSZ0M2fcXhOoPVVL0Kb17L9j7qbk1NRJrwKZ +MF7fA932toEbLEUFERqobeUlx6F5jITl7zUev4sIRg1rSfYsS+MNGf0L1FSGLfwyu8f/Fq91 +iJwEEAECAAYFAlbufxUACgkQ0h7KbuimxgQJ9AQApIdsDlVRzdocV6UgZdioAP00GgGpOmK2 +06INRJLQYFDcb8iOAiYYysK5m7iX/p0rCdmypunCiB2en+I+kvfLTzd/jWGwPHuvE5TrN2MI +eulhKcQp/l4IUYQ4KvGhmNfgIOU5JNG09AqBXMHIigQJPQwANhTX5+unmuDslCFPDx6InAQQ +AQIABgUCVu5/GAAKCRBTje2gLO7ucy1HBACXZZdDDqr7vyDM5Vsq6JaxKHCi1VPUz91LZtCz +lIq5zWT8a+0lnNqNmMeROJuP4SZUMo/KeLDn2AYFjg+RKMN9bAkg03YNib+Moy3BsP7Uvn32 +9mecBL0MYCPZ9fPUnTVtX+FAFhktu0lhrYxnEK5WcCyY0QnfgqEpBFb9AkPGm4icBBABAgAG +BQJW7n8cAAoJEMVcRgIICoLTa+4D/2FS5JQJ13P5QJASrSmLVvzmgSmoN7HH1DdiYErKcvED +pO9y3jBVkyCumE1Pw1kFFe8B/qFc3NT9azhh86lBhtGi7yjfa0egIaWqe4OoS4A27kS7RDDy +cO9V7iIcV97j1VjTlKlh8QIFJXmdI6sXCqkf1AOoTby3vICV67n9AdysiJwEEAECAAYFAlbu +fx8ACgkQ5SGiyjUTbFZBtwQApQN/3ZADw5F5+PqLy9OaM5sQS3WnfF0wwqrRpklCcP1cmRA8 +JwKnOTn9tyASFUvwuay6Ze5SV9tRBnEPHMxdUkswreaCwD/lgEIb2RAbmsdw4aCG3bJwYmib +VcZqMYLvC976Pel/3NSXRKBrgVVWvoiEvH/Zaxxy1RjpRBWomzGInAQQAQIABgUCVu5/IwAK +CRA+Efo9IPZM80EQA/9xJ2QKliIrKvAnWejhEEGmJvph+XWbBkwEHHTEnhMqpeZx1OJYwqpp +CmWVVaXxY4ch8nNOvs3F0qPCZ3FkM1Zr4ghxfL2ir+or+4N8j1MyX0lkEtsbyG0AumTjXz+4 +NKO9Sw+KsjBDhOlJsokKLQ3gpEMPPeieTBpjfEfaxVlVhIicBBABAgAGBQJW7n8mAAoJED1d +ZyVbuseW4LwD/RkbUpWW0asH3qAkqfvv12Urdc2IsfBPBHyvcrmzI82kcNeQRf/AU9JO4koC +oA8Dbajd8mnBhvKhZDnXAVoI8GH7aQYJubDpCWlRNBJNdwUf43DUNo/rhYaCNfCBeWzmITat +DCC7JgSzZEueZ+vAzvtXNlZ2cPVg2U/W8H07rDgmiJwEEAECAAYFAlbufyoACgkQnDE/u1/I +RHP3TAQApT1NXb0v6MUdHGbQHjCc+eGJd1EqGUdH5MVUQ9K+FGgXkUqUwEvb5jESRkCReGLs +Sam8q43gG7aMFwRgbD+/EoW2buUrVIcf6q98aKFDx1JVWwen+7eoBEDpGcFoj8sF7T/1m6Ch +f2A9/YAJnnVCmlNAziUUBoDuTfztdswRhCeInAQQAQIABgUCVu5/1AAKCRAuCaXFiIEoMPPw +BAC4dbVNceH+DwYDJSWTeyyI3mwDkFUz6MiTNvKy5VXHrh/83soR8xxLcBLlovSUkR17OxKp +gPLmv0yviJXyuxXXO+Hc28QkVRiAavbCOr2fnibIaHVpLzT95jyLqr3H3j2cyhHwy2v5UN8U +1QV3noQl1OabotZz1cec5196KFytWIicBBABAgAGBQJW7n/YAAoJELWPTLe1smPGepYD/Ag9 +atMqW+jTakiq9mdVk+ZzIM3zrtmKrZOYgrHVPwJ9EN0WenhN/ZOugGxi0FNN32gAqJbcGAWH +mlXaCod9NLpQJcSTzamAruT0N4qSj605Rqiz2iCCHfUaHXPsCmmN5Q6HUI4/mR1J54rj0aOW +BdxgdFt+nHqi2nIEpYnfEtV1iJwEEAECAAYFAlbuf9sACgkQCDrn1g0f7cHTvgP/dDdSwJ7j +CyGaT+0WWJ4/2Bu/INjntqKN6HjKzVe9tPIsNoXn8KWmZGTcNz/SbwmEvegiCCFFq6ScK0eb +jVLrc42JQVi/aAWrM8pff+8CiW3TKhBhtlbjrCDQx/AM4DMnk29KZ9cRCj1+Jhf0f08/sMeY +/O0gST8Ad1qVUFDiCHKInAQQAQIABgUCVu5/3wAKCRBBrF8+TAz9NO0EA/0Wu4JjN+6TVzYa +fO1BheZfQe9r3Q0BljHs/bhbVXQkAjmnwDbPMesAqgrBf4bRXTkScq4AOmnx/2PNKIHoDCCw +3TJxEqRD3Bz2nyV/nOIkkjBAHZBHch4Vj1H5CvnvtbjoSezSLjJb9wpAWwyWUGwAoE6aQaMU +fv2XaJUXBPfJfIicBBABAgAGBQJW7n/jAAoJEJ3JyX0sqbJuxN8EALRAOeyaan5ntEwU8qXB +PYbYzNe8uWb0TBT6CpH6dje6r9WZnCaNc6aAWdEV+mxmPIxeSGUZHH2BXwkSqrfnuCGxcZNh +8k8rrmBNfxyIXbfiljw4VspbbCdhmCHPkmA78kr90CWUV9C+BozUk8juAkGQf8EvJNHLQRzi +aAcxtFiEiJwEEAECAAYFAlbuf+YACgkQo44lXw6qZSXIkQQAgXgqQp4N4W1xqI3Uu9ZnDkGP +ZLXsrLk4fg+YIlGSYWxboi36arVHashNsDHmV/a48Vp4qeLJyy7PfeZpkV6qQaCigOVxLmBN +iqe6HNf9uOTzkYPMmn4XTuZ3U9sd3YNH52CdSI2VnimaDfkzyx6mSfCw5Y+QOznFaFCCvpdb +bhuInAQQAQIABgUCVu5/6gAKCRCUJO/8ymBBdfVLA/4hVbS/1tWkedsqQLli8dRYhME8lkoV +CKPXJyg/VMBTb7pPxDCjZIqM+3vZ8FE7iYsl/rc6rugMXaJR6pXTwIvm9fMdMdf7GvbWW5c1 +ry3WuHkB+0F3bQfolTUhvfxGcSiWTxo/ahQELprQQNWX0132esGxn5bJ0EFJ1eGqt0OGP4ic +BBABAgAGBQJW7n/tAAoJEIJbjJ6pi3fXfwoD/j48fnjNM665JYotDNY6u7XR3eic0ISLvOqf +Ro/4S2zMZjVncndgCTrBSHfb1jhTYhwSDvktUPdbXRJD1Mohm2DHZTKk33atXRspB1NB5Hj1 +oSZhaDVGpIA4loKG8zk522wzVudXJroXSsfqQMn7iNu/pqbthB4F0EGt69v0BMP7iJwEEAEC +AAYFAlbuf/AACgkQCD7CxhCwI6dZmgP/SMonevby7B3CbM2gl6HrHuNbRB8IA6RuJO7HWIII +PiuCe3CbgfVAnGKr8Lqq5EHpnRyq02vec8UfUMWQ6AwrbtN0lQ1B+cXrGWZ4EMe3bAuRev2E +XJaHZJF3Lh+tGPnLnaMZLQpEFoolYD+A524mUrwUkV/RHg6SW7G0UJq8e+6InAQQAQIABgUC +Vu5/9AAKCRDkJXlbHznh+eEXA/98JeNELUZPIbCJkE9Fp8BrrN925G8m0KnueRZyIUPEtrwZ +XM8KE17X+k0y39RDFQfvCf6jyCUK+Frz15ii/QKrMkLaPZQbMWx4IRPoyJ8uFoZIuEzE16qX +TiGYiNYuBOetpjcCpfoJB1vvd7cTfclqTxhbS685kkggKlHObe92G4icBBABAgAGBQJW7n/3 +AAoJELn2EJWn+RCmFZUD+gMqIyhw1YoK53nLXLv4GRfXlfEZK/OdSDJI3OKxRvWeKY+KzSXR +WJjzuzYsDLQYbj6eF7Svw3W/gCWkHl1+P2EPzLA71QSAox2UN1+1evqN6D/RIdN7uwceijNt +CMpZpICUWXUaFPPyqPyjsQo/QZmA47Wsw1uw/u6wMGvEAY0oiJwEEAECAAYFAlbuf/sACgkQ +pjsOvfvNI5oMWwQAo1cb0rbUcrYQz3pnBsU6YmVSeEfGA66rcnaHqxuiIarOAkPnI+gHHb8I +FXQMuHBidErDejiclJyiKaGY82IYlTPRtoVP7KSmiW83mbKbQ6ijn4A0lKE5xn4DqElqTAl7 +lRT7PUHeyUuwZ78L9RcH+n6GpdsRz//GXVhTmiaE+n6InAQQAQIABgUCVu5//gAKCRA/Kb84 +TnPbdX7AA/9WFnEO3h+XGjx+Kc225+gBGN/jtsyzijqYwbMNhv86k6VNG4gRvTygTDfOaAGR +rn3JlLIwmMYTFzIr1yGtOOexVNAgph9wRQUSmU+DPW6U5Bgb4PMd9bNvKfcFoVjo7lVRok4e +6l7U2ZvE9RGTbgueP4MBF2dJF+QV9FZIda+wL4icBBABAgAGBQJW7oACAAoJEN/pXKHtkjMy +BrMD/j0j/Fxm9+EVi9LZ5PGqWo+GJklk5u3BFsA6sgrirVKE77RcLHblPfeR92pWzbGIiVJp +dIfFui7eCy4wpww6fJeePp3jW1WSUBwHoqfxEa19e8kozPFz8K68bR/lu4OP/Dxt98ZAOUFF +U0btp6xoT51KU2sCEIhOfafnlM7OXffyiJwEEAECAAYFAlbugAUACgkQlHfLHN8995OfewP/ +YtbSY1G43WLZkaGBDk1IBI3LGuKET7ynKT43F3MMORrRpMFx9eFGfV5iEboS6cthSAeM1fxp +wxuWfEjF31SmCrT0KXe88LjPPO1PoR8JXnxJdR0uA3kZ9qS9Mk9oOZ07uyfFuG9Bx4jT0RfR +rHfMgzMpiIKDlr9PfdDIJS8kfL6InAQQAQIABgUCVu6ACQAKCRBbHZHGZ+Hp87UNA/9fJ6SN +tZEHjRPhN52i27ME31WIDn0gMq7Pcn9voO+3QUBHtmiQLyn6VE2/bV14HfCE8BlJFwpMEcbK +meu9qYqifQd8BJp1s1D91Q+XB/wGQvzvXzAlflOXB06gpKtfY/8TItx5K60xIhFeDZBzqMyA +0G578f2E2uLw0gK9NJCf14icBBABAgAGBQJW7oAMAAoJEBVTLrEqLYhJKYYD/3xsJGZZtWyl +zfNnm9K48wq7KZur2BApXMqcfsvj3ppOM/JCoRyirXV+dSrx/gswP/10AnCFR+kQKePOGo0c +nWH6bNr+DvrVSJR3JIGACmJBhrd/h1qegb0PYkzQpeQLFBOccHfbaz3GeDyKCZEGTQFKWMRU +NI2xN08lehAkFEakiJwEEAECAAYFAlbugBAACgkQkIAQov5VeEsmcgP/a025bY3xIEdXIeR0 +tD421ARLQ1KZPKrixkqlXzfM6VwE72gyf5KH5uTHlqKvFaNK1WSJy0g0a7udWyFh7GLK84M2 +ghtD8P1IRZlTgc5b8Whe41Iha8H+FqedPmjoOHpzlj14rfRxKXF3Cb+43pyisMUiGxMhAOM3 +9U6HG1W2rCSInAQQAQIABgUCVu6AEwAKCRDYJrfiHVskJNKFA/90dlYBFXHAjv+FDRwlA6pG +iOmiMKNCUal2tpS6Q6KMKD9L1kQZPqOlcNOx+j/f6V7TH0d3QW+acugpu1HlILt6wsSmVFDe +kuRhh34yHh8asceeO3ehleTM0lyU1LwWsUjWWO6STDmIGigTwAIhcZCi8Nd8OEZqUEJGxrcO +618n/YicBBABAgAGBQJW7oAXAAoJEB8DC+0iL6W2hKoD/iGaivNOVjh7OFwLh0J95s2iScUk +xHMlNiAqo6Zu32Bfssh+QJSP0y6dUkxVdS6ngfr2+Wh/UMpoxDiYrHKHNpgI4jpg/bfBz/HO +NBQFJgP/t91ggAQr4snJF678PMOG7vXz3mWu/YdAexdgSjoUALCXLCZP/s5pf1PJjRZnbEhP +iJwEEAECAAYFAlbugBoACgkQWVvpm1DESzhn1QP+OUt1TnqEE2ZutGkKz8ym22l5ztia5bl7 +3qyH+5NDVHoIeSHQLXZKwLNNQReL+YWK8LuCfg5LkZjUsoXlhlHUjHXn3VYDbKAY7cdi96zN +rKl8RHLo3722cy4AapVZD+9j6U5XYayN1JsRLV+wKZo4uzXJDdNdh9s72IdYIfZwD5aInAQQ +AQIABgUCVu6AHQAKCRDyy5egGxf9yLVXBACso90QJ7GZyEsRdWv/O9a6SKt19C0Rmmn5XyBe +j6lxdKocY+31yVIpvBSl7uGdLD43PiP8lnlEh6b/obDwKuc42RVymypH7i0BxCMYk6G9BYMO +aD/bzyHWXmDJxX0TlAszRJ26Ucvc1KX8o2+LGCtaPhvXxbUPorkQP8ZlP4GBz4icBBABAgAG +BQJW7oAhAAoJEMedeEHZchxoNUcEAINoGXfptkyuZ2U8Mc4FHLrLZyQzi5t+d8Fi9/PiEO1O +GvH/4/uysn3QpkN9jg4B4HIvop4kjohFPrJIj1QJZ0WanXFFg3MVqLamQpvhsTtOBxqhdD/0 +drCIin+FX9S1ZlBvGHE3Yw8OqCPNgjaAvyXlGnyLhoip5gSn5/lb0Ti0iJwEEAECAAYFAlbu +gCQACgkQLG4PFKJY8PzjrAQAgqzt99lTAFeDKrIIMz1H/GyVBU8Tn8bLS2SG+ve0F+O+6qb9 +xK/AUGZHqHUjKVVyhlnbW8J7ChjYND2BbCQdvRAR6kT78ITv4DJGvmC1FNWe+btwTslxJzwC +U+bEeN9yj3MkqtNATdNd3zMcLd4Q4aSBZISPh/p46+2LXcDql2aInAQQAQIABgUCVu6AKAAK +CRCGVARgdOfW+ASLA/491+bXaUPwzFMDkSwc+af3ICmgVeCg7RWADeq0S9kHtR2kdheL2j/b +/a1TZPyNFB660zYGT7L2vca78B0Tnw0wIawMMtyPKcc0ajoL20YBefbnXYuAedA7zA95Hr+y +AwjWHDqY+lSi3siev7Vw8bv6snB9Io1Xxiyj3/qh6A4KNYicBBABAgAGBQJW7oArAAoJENhs +h4ptfoiCb5MEAJMnRg1aJt1BJjFh9JvYrxBkIcaX1yHOYoz57KVnEOtp0BtcST3aXSLt6w9V +1CjSW82JL/aOMxmCSr8y6AF0fZ59bTKPe2aRnZZYNLUpsFlvlCfBuaCHUIfuVLc9gpDU+VsD +OCtJfvJL4E0dLVLFiHpJZKAgjCf9dm+Z6oR4xsX6iJwEEAECAAYFAlbugC4ACgkQuakkoTg/ +7haBSAP+JuNXUWDQDLwoJRVCqAAfVvrmiht4ZRgP+f4fl/rHm4alqVAe9ENtpneomAjcR3wk +h/KbXa2TiEoJQUE9X065N7ThkDBTbGMHD6QEh9XjwaQTqSERhuTWaX3XlxvggEPkvu1t6E6J +7jbmdpHemEKXX/cQWVnKuGqnyKEq4hhFVvmInAQQAQIABgUCVu6AMgAKCRBL3CzZCRz8UFw4 +A/0W++G2J8/jwDnxg9bl3lRcIb4A65Q7VLGcbqNSopgWldW+p66TfDQKTsrB6WybacQLiuXs +nYtmj1sgOnabLJBznn79lGkmMyXbtQfuPJyV0miqb3SNabwxdLlN6VEl90ZXISn1T+of4pIB +KTC5K4Ad1SyetcBmkw0AusxItgs2poicBBABAgAGBQJW7oA1AAoJEOF+DdPUo9AJfx4D/R2a +DeuFcpmDOAZVPYez99s+689t6l9oD2Z/IF/ozTEMgkASQb4ZsLVtt7gAS5oHEhSqb/GJk7st +i0IohqhGVcy1OdZG3fR3UfDHbM4kQPWuWfdMBh/fExiP4NHZXdbySLNcRJYRpeIRtycVMdyS +7h3hfXu4KhdGxdyT/ZvlHBCMiJwEEAECAAYFAlbugDkACgkQPswIUvKsEJiGLgP+LAsuWHIf +RsMqCWvts/SmsKnMrQRUOJgtStDgNSR3TM62T6zFJHNc5a47+CUWKXNO7W30iN5UVwMKiY3B +yC2yEtZDMbJXMFkir/bwWOrk3XQS7Sc4L/7OIJd7OoH2mKaYaTyOF4ww6MmKlfT6iJzWELm2 +wt/duYqPh6HEBKWfbKuInAQQAQIABgUCVu6APAAKCRBtPicXXO4n4nY2BAC78xw8CPHJwF+x +BcdQC4G3wqCt24Cdxt3XnPsGUPPPo+Qg+yQ/X0l+lkwPquGtFYIu+Y9oIccnjLnqeXAZL5ac +How3Wg3qKjZalxDSe2mKNddrqMpCzMtY/PA5hKyv/GGu6HVXBsXhtWnyD0vDgeto4dp4zaJs +yFw23wdnURM3vYicBBABAgAGBQJW7oBAAAoJEP5N7O0lIdyBe5QEAIjHDfyKYLMZUBpbIpIW +oJY8z8fDOUXGEy9UxF9fKZqifxqnxL5BEpfcM5i1JBLyshll7SF8c4ijvjWpWmlj1ftnBOag +/3cVxj7sQTt2AajpdsBiuMLpHTiWT8sr/P5WGMkWwu/plkqbuw9nD2d/LI3hejt8Uy3WUG2O +HsHlR0diiJwEEAECAAYFAlbugEMACgkQScbs8OZTjPiGewP/bDzlAbiGH4v4Urr5VIpi8uAi +y6LzNaLVdUph+bq6Vap0NtblG1Ml5daQ4q4USJB/VibShLDxedUp03y54DZ8halsshEbBbnT +IcdObLJ/v5rxsw3oDos6tTig2zYS0mr3gntOU6LAsQg6V/z9dSQjIhvY//vB1p2Npqdm+Oyo +KsuInAQQAQIABgUCVu6ARwAKCRCP8yVwkALsGF9VA/wNQihEkbLEI30ut6ptGaUFfugYRGcH +p+eCOFx5NQowzTLcyL6n2QgegXqkPrNrlcAV6gFTUIiZ+QEyNS0VvlPe+rHzKCSs0JKAIsI3 +bY3SEhTThFAAAQHXlaNaiW9VtelApgJ3Lq5LIyvYafXxO3nmhUjhqWQzKOEfsgJvDl5OU4ic +BBABAgAGBQJW7oBKAAoJEKf3h01YKH3hQ1wD/RuOsT6EbTCXxLyl7CLG0Pmn5gFT9k75pWuq +ZRCtLXcFVF35FSiq2vC6T3UxE3jvysjyNRUDlFsm2RAdPB1ToD2jSlc50ArkfC4XLkNSWgiC +ocqa4fE0MHXrTL4Z8xIKraBbOtln2SDm+rLaJkR9aCFINPi3jq7tbQvwJnM1BjYWiJwEEAEC +AAYFAlbugE4ACgkQaNNxKoxzrLCNQQP+OrdyfLMBjqn9vC+JDmLoFF+ajWUpgg0zNp2YOSrZ ++iB2rzITfm9ev8pRqIYFPgy0WGa/MVxu8fGaQ679fVnCvvYTWAeyiYNQRSAIg4UqBGLUPkCc +Gxgnmja2gooViGc2uJUaXMg/VGwEr+6bj+23D/3VD7QVW6lgESb0pEw7/JSInAQQAQIABgUC +Vu6AUQAKCRBONVMalil6SEWdA/9bF0VPOD7BW1FcyghSGILr9Awet/wWNEhGVOVMWse3t0oo +pvxKKIaM5UyKIWT4T35jaVedKEyCLYVSossSPpvWorkg/SvBpA6UUdLagiPW22b4rW5yEMl1 +gVNnuCh8f9+HjIeouWYEl2ztFFbwsKU1VC2Sl2lBEUbI2/iTRL1YXoicBBABAgAGBQJW7oBV +AAoJEDyUc5pcFkVFnysD/2gAILTn+cWodjztyDJolYh5knwB6578yqGZGlS19LFFEWQ279sV +OL1gqxKh+mWzPxqyDD9plyP8ByLroSH3ZSHj9czuHDE5j/0CwLka+SsVsG7pPGtBmVbvu3Iy +ZqXfhfKAt9GSEuQo+zEkYvoEDN5xdS0WksV+BcxDnRRiHv36iJwEEAECAAYFAlbugFgACgkQ +u5NW9YMJg7dNrAQAlq3XJs0elEGXUzX/BbDpwpZrbakTRdh3x2y4HxktW72YQhj8SNO1+1/G +lYCboWJghrBK+ZKxyUSxcH9s0eQMuiIlHsV5hO+m0aoMmORWlMzJf8plbblqRNo41RkB2BtD +fwyn8iyX4TAXkj6qeNnoxpaEafuMMVWHucrPjRZc2jiInAQQAQIABgUCVu6AWwAKCRBdg9sC +GY4yNWvGA/42pN5PwOGAP6x0rUhlP6RfrH97vJDC9qEWZclsUPQH05vkSAiWw2PdqF5VUmg4 +7gbYNdZBBIY5gcUWX+lRgtGSkEeqMpzBlVgR22ik7PtMTpKtLttmckJE5KLl6HbWXFbQTGNd +bGwsfkh140jnlmMYhu6e1dDCe9Bt9mPVicL524icBBABAgAGBQJW7oBfAAoJEMaavi6CRvMX +J1YD/jwNCyB8ikZWtMHqHs5dKgDi3YefZBl495GH3j1/H+AiYkHK2c0Ewsv2bMk1i9FYd1Cf +zHUJBW5r3iZfUx1RItD3tcCpw8/Le1Oi8SYMssx+Px+GNabkINrzTqmJFJCbgSjDMKI5orPp +7GkiBvsuSQA4SYP7U9/3zuhF/feb4qsmiJwEEAECAAYFAlbugGMACgkQTdkpp+mMWDJNdwQA +mZwdW98APmmQCj/+aNAwV/IRsfPNhbEaYvhBNJsrNsP+cCWa5GfmKj6mC7u4j5hYSxGryztB +bBOcLRZNW8SGwe6QFWt/qsy7iOP4mlMIyxQBU1/iLeYh+130BFgJkUV/aZQXsqXshVGZDpt9 +QL9gL7bxDV+8y5IWJXsjldZtkVqInAQQAQIABgUCVu6AZgAKCRAL7EMJ2z+IqSJ/A/4u8rc8 +ABc+3gfpNH1+JfF2H0BncG9NPXSA6N4da0Tms1VwosqL3X8JptUCwR64cbu08Rl0JP0OWHa8 +anppRdy0ikR0+1XAekS0su5foWJtlS3hROYW4x+Tey6buWK35jmajxwkS7+uf7YSSdTq6h5g +U9uabxv0+rJqQlxL1IKKGYicBBABAgAGBQJW7oBqAAoJEDvQb9bPhqolo8ED/35ij1od/pF5 +8Q5LruaOurytVY7oFIft3qtSPdN5buD14jKzqiQGfui40fshRBRRFYR44Ru9GtEBpdrEyMr9 +VT6VcUaERMRJEpcuRUShfBbF2vqri4VROGcy+FmwuUN3VGmzJORb2IsuRAvPuAuwQnARXucM +7LgbyuANHufclSSwiJwEEAECAAYFAlbugG4ACgkQ5UxwVvNf1SuggAP/dsLWKFTZgpqBy7hz +uYLltP/oPb1IVD099yieKj8fUikP73+uJYIDU6+Z79n841dROrh/1UjFf8YDEdTg6EkBXW1a +eVBE0wdGUDCRdQXVI7bmltpXcbiOlWAKzshFVpkov7Zsx4DfEDe7Qa3/0uQ0RiYmEWW//c/J +ISA1GvffLbKInAQQAQIABgUCVu6AcQAKCRCBK9NKYcAXd8i8A/9n6GACpzvqwoZnrqhutOSe +HqxpA7LUjXydEOd95ub2UJ9f0ivt8BgyZdXL2VKnAIbGd9wCKBzyEhSJW0fn6NbDLvPKeZjE +Y/8MZ1xh4zGwK/Fq+iMdS4SBCT9PtOyORoG+XsDRzGoi9PoYRLkPAXOMEKoDK4lUZ/Ap4oMO +tKfeh4icBBABAgAGBQJW7oB1AAoJEJ41zTf1L6iadEMD/j7ix7G6p4bqlqUEi6uorM2C//7H +IdIquw4+4/EjLv8gIWnWXjQDs0YV5wVFWeg0ojjPLACttuH8UZNLMPVuiijNM5/K5qmCz0KI +LFsbA8dXZQsk/lQMKVa9wTx5KcshR9jTNjvcOi2mYILJsJWLWe0vo2qjVsqCScELaLr/vR4U +iJwEEAECAAYFAlbugHgACgkQSX2R/WfgPw/hewP+NcTvjLvkEI0ofQj729F90R/aZc2eZcsD +AP2LAls7cbl3fi9ifvTrgCEPVeGW0pegGisyTOMWu+HAjjPDay4q7ocAVwiOPSXw7o1LMHMB +dhVT2InPRl7bP0S7BtSwmXTLIjZ80AAmn57WQqOclzy5fFgHH2Nw8f+VLTT3RihNXuaInAQQ +AQIABgUCVu6AfAAKCRAZzqEQhZMEyOvkA/9SBmyauPA04b80YiOT5HNduClilxzPEbTMyIUb +tLtMqpwjHuFCcM/owLQVFsSm1qwp3CbniLCKIYZeDZ3Oa8mg2qhjfq3OC35WIiz5w6Xotdfm +k/CGkEp79Zv33XaIK9eC2SpMNkDEpSyOdNisKloCXqm+Ma3xMEV6e1PGYpuIO4icBBABAgAG +BQJW7oB/AAoJECnV65nQVsEffLED/A5613nbsf2oHddxeT6+QbMYIGURWLEf+EIboe9upghp +ZEWeYb7X80p0mHxBI1RGQjfoylittMv6AJLwvY8jOYgUaF7o1LY0ILAapmEkcBwEyT89ulk5 +BBD575Q5Du5sNcZw0gIe3/PUCf0FTkVITJX5o5gFJKoiNZEarxYEqLtuiJwEEAECAAYFAlbu +gIMACgkQrCNr0Qs18XOZqQP/QMLd5G9eQ2CDmZtZP6UQj/ehd4frXMFAdk04sgM+g+CCawhc +073s+gQr26BJDMSxG9Ok/YTnSZGoM4D0gklvRVhOxCy2gGlWFGpvCzIoutmDu2msmw0w/I23 +txorXBjnyxSsPnFsvMHDHKoagjDBnr2P7M1qAOp9seNi0iOUUQKInAQQAQIABgUCVu6AhwAK +CRC3hNgtzDmK+/NUBACz6Aq3Dvoh83DwOBis7P8DrnXh0wRYStk1HqO9QSk9CamaYJVdVgpj +ICdv+cmngRkTgPtFieXNoHPtouoKnLclnvwLDxvhYaJ4H9TOPN7crrHS9WvN/2VhgnGj0DdH +hxPpTdXTNgu/WJFXrMbLCf3cRwKruObUr22zTPVJuqOP1oicBBABAgAGBQJW7oCKAAoJEEio +oO1zejVfEBID/iXeiXgYpyYW5UsO2YBcF1fBojyTAyP7TtBPBLXQwrHW88chr+vwpweX/n4c +Qa4pGZpnKj6iHBX+hJGvW5VNUvHBFDZHCM7vgBM9tMb6bIEdDE/nCfMq0S1m0Y2Ed3xGr/a/ +zLhIoK5a0G73VhRK+k9lkpkT1QIuNlpmJ2I+6u2aiJwEEAECAAYFAlbugI4ACgkQ2mzZYA7e +I+JpMwQApEtXnQ/fcd2w03mm24nzZurLdf/KF98P2Dv4JA0mJ0siSsE5CSONb8W6oSEkGTX6 +546W7+fWLVjmwDCSqSEn1TsYJiwwnLr4UtHQnJovJrTEv970Cz0Z5lCUrpvTwjrAXuPKZAPk +BAdKaMG3ia9N/k8iKru/v9XX3sIyGqty3cqInAQQAQIABgUCVu6AkQAKCRBWIavMQyIHqRB9 +BACe/KLKm2v7ZkD0IPTg3qF53giuKam9EBorqF4ZJ2b1d2Lu64dKy+1Qt3rmMo+539frNXaT +ERze1MjaZ885Z/ySxEcakLk33hNbJsHutOTvfJdHYSqOXa3ArROa7BHZEZkJUa+hP0VzTf5e +OsCA1ij1pRaUe0mN0AgMAWdnuLL7GIicBBABAgAGBQJW7oCWAAoJEMZN4A/JfxBdBbMD/ip4 +RjuJ9v9khxLp6ofyMklv7or0pBwcjxsad3IrW8KOr/JMl+i5hLVWS61MzvX3z8EwvM+Zrtt7 +LnQVEkFKRucuwkPlBTmMi9VMW5rzNT1iSLstZ7KWTGUcizp0o3p+Llhg1sNtmUIst1ViqMs1 +PazUhtDZ/6jWxrni2UZUg2dxiJwEEAECAAYFAlbugJkACgkQTDBfHivrC0KliwP+PPdk+qkZ +XuSnGUW5vfWttzcQ1pLTqlrUzP8LTkIcjdM/e4pvSAOi9HaHRIK51rkUgJ/jL4DB5V7xOtSq ++KXec2FT5nN+YuBYIt5P6dDp4DG5uChIYeQ47OZ6MkdRfDo39/jF+5YJQLjNflIvDvsYvu/e +Uj+01MRuqNNjcOMY6cOInAQQAQIABgUCVu6AnQAKCRAy7dg1/FygA8arA/oC26IAOC+40LrZ +6C+M/9wu/MDXq038n7HnebZZhB1YVkp1FT8cuIeN0N01MhVECXGU6eDzmKhn/LbAKY4Hgokj +4UFvV4p7Xa61rbgg89AFVCeowUDRc0ASE4ijv0AAtz/PW3n8/mf2XyIzpXnRKMHZiFyNkV8X +nyBKk3wmsNY2KYicBBABAgAGBQJW7oChAAoJEFJ1uHI3kUdwvX8D/3LJ8AKkloFQZS6SRgSx +5hFmIOmNqy0tEmfDlbogaIaHKE8C7xR4cd82+2W5O4kLVwTXvq0qFHvEMuJrPUgoqtbVY0ZV +YRC+TT1olrTrJ2pqYxAg9b9myGMpWxmOutt6c27M8JkEKWzPDgo5SNEAmuLirZcXlPoeV476 +ERi0rt31iJwEEAECAAYFAlbugKQACgkQvU5sFmefYw7VCgP/YfSIdQZWZCevfX+89veqyCG/ +hyZg/hq+TS0fy6/XYzqr7MXAWtNAzJtPtql2og/qLEOmyAGm/Eeo9RArZYy4aQHWbDCTaJUx +fBA/ca5bamQPbDLGxzbrMwxR8Mmje+ms6o8Nepcewj36Wasa37WdimnMMui+x/CQFKF6D2i3 +kouInAQQAQIABgUCVu6AqAAKCRCgekZJx/SOStMXBACmBoNa42PjKZVrzIiF90KCu19NlCNG +SrhLudBDNLldE/0wKGuw0EqgXH6eEU4yDppK3hA7BDEH7tG0vqzn7M41vRpO/AbdbvUA9EHj +VQ2Qug4BJ71nD1MIe7D+vPBr2okLr/VdcN8n7PeH8bw3gcUG9uO/4xe3vCDy3T0UhL3euYic +BBABAgAGBQJW7oCsAAoJEB56USXlD5hxbiED/A0/3LkgX77FmC1VTB2oivW2P21hGubXGudX +ytkwD8OwQ5Vn7yBsXpFvaQaboMMAOdMfa69DjMT8cAUL2kxl0/bw8Mc0pwhDDsB7XW8iKr9u +F4X6xInGWPM9zKm40F5MseXKnU6OsEcnyS0z4By+P2IA7G2aUknQZcPcjiQi+QzXiJwEEAEC +AAYFAlbugK8ACgkQBLiSe95niDFqfQQAu0AJJIBckxtXaRvZjXTcaJNnB1rSiAyVKwvRoBrS +1GUSs73RC9u+uFdmZAN9UztwTuYLvWPVT0NB12uMrbN4OW5v2SQikitrxnIh6d0nUkD0xekt +gHIVbjdrijS4AUHEtxbSvvg32qC7lm6AyJflCXqij78VP1mqw5CWxoPE5rGInAQQAQIABgUC +Vu6AswAKCRBFUHXWwKuCas8kBACk6drbrKIEfxA0yrCHzKwUgWg4Ff+qwFiif05S4u7OHkwt +yb/GUS1ZuCw4/O5yUK1c36D0Fb4doyR5v7QAj2n4s/RQg5M8lIeiBFleFOLvR9yC4WZnX9Tg +gTdeXtLKdf3gjdjFHxW9KnJ5r3WA+9keLdx+e5tHW28xBnMluj2SQ4icBBABAgAGBQJW7oC2 +AAoJEC2T//H0cEpoQzAD/0KyPh6ezSQ2y3QxETXZOTnyXu9OTLR83rKJLzmShW/UApYIjehQ +KkQ7v0tM0IiZMihXEhkkiDTBROzc7CQZPkVUqyk3vl5aIHROGTPq4q/AbyVqpLUQ5N4qngLf +jLZaPl9RGgVrFtMTeKoLrYNZ4NnMgM5ndsdV+cKDQLaJ7FKpiJwEEAECAAYFAlbugLoACgkQ +EsRKYaG+HbdfUgQAoEZm1OUch0C9H586vjhpYWwDeilaGb36NVMqssvltz2cOXfVqkGtYQbJ +IvCgWWzpNVTRf5cz3u8OSyG//t2xRoOtzrFx1cBr66vqVQR8KDCYEQJJdSpe1Q6y2DQQtmrO +/5DXin4Ew3W+ypasbEpAnQLjrNuazX/zw50lEY6zRomInAQQAQIABgUCVu6AvgAKCRCV1Hnt +Wpw8fi9UA/9tAyMvchbUdlNnh9glhsv+XdtzdjLC0WqYhr/R4e5D138vFRwnmmdSPi+Y1mTV +V/CBU7zBdER/CHhuG5DB8EAZwC8wBl1QedrTfq+Ut1bFXOHcEv6clqhGMyKreQ6P9r9QksgU +5vOjNDLx7VkY133ZY/lXaUWYl23Mino7T0AymYicBBABAgAGBQJW7oDBAAoJENj26gfIgrjZ +EjoD/iVLj5KUSRQXLcZEL5wtNzql4LpBU7tSFREiwhN6A74ZD5Gq7tcZi21bkUk8InQxMwCp +i8+8JOGDhpg2lHQI4T5DW7sl8lMhG63HKDhHAB7koRRGF74573Ji5doxajyekLUAz5r3YNTx +n5nvJf81xkgODodE8XhyIAp0n0WjJC2BiJwEEAECAAYFAlbugMUACgkQKqgCmifUnaw/PAP/ +bjbplIcDxvKE5ZgsIdoqQOLHuYV1IeuQ3W8TSzjy4MX7Xwhgcp6OQJ7PfEKg/S0xDMeBZv5j +S6X+m2Fol2tFpfi0mgRftrVMtOezeo5Gv4tEzl61tw8otIfdgTyi7QIKK1E/SBSu2btFZMaP +gDukCcXVyxxqf7zxysI2yuwpt/GInAQQAQIABgUCVu6AyAAKCRBmhPFeWqaRrBF1A/4m2Fy/ +gHAWpQasbgVzAnfsclpKZait3Pn2b6pscQJ37weu+0cWNJ8mkKgL3hQimozYVtRYeoeInjlh +Y28A1Nhn8LCBwMoluBGFGmXqNIEhgxTMXHLPL3Rap2jacVKAYDul7PmuWFegqpvA56pV/OyX +YeowcAIjcOkTu3aHaDsBH4icBBABAgAGBQJW7oDMAAoJEDnbCfdyd/DUm2gD+gMvCNT4Ccoy +tnHeHmL3w32t0HY4yhjISUWAZLlH3kZHR/0HdIwonwzSueY9L2hWB81kSUp06SCTrB5iXA4E +guIyuZhvYUlfMZfxLkyV4s2MS/3KDhcqVNPFrdTeNXPtvF3NiGWXqyQ52ZTW+dCKJEWSeBi1 +ogKP8ULrl/hQD+upiJwEEAECAAYFAlbugNAACgkQY41CK+bi3vwfogP/Tj1rs+nSxc7I8n24 +gkEZ5YuZRtZ0G4VzgqL9JxhZId/NN3LUELanquo0GpJkAcRNhuG7bDdazMlI5nxDEYxpzKy4 +kI+AGMohTDcArmkEJUW5ny81YzpkTGOWOJc3b0LszKjNyQCyEIyyBG6NobwlqsOy8cEid1Od +dLA7XdFLisSInAQQAQIABgUCVu6A0wAKCRDe6CQtqU03srmwBACY/9akz2YzphYZcaPSWztG +fo6folixgHj7UtBhg+bM4MZQXD+OhsOVy8zB7nGNq4wmX1ceBNEQikvPkn4eKvoIHMnh5Fn6 +rjrFF9MnjODkg1rglilQlN2XljG+qtRi5YSVqgWcyvPrvMqXi3E4YI3mcvXwgq6EN2wAsVrp +pliMqIicBBABAgAGBQJW7oDXAAoJEFt6MiGom1HPvmkD/RpDJH01JIGQYTdENnlqJgbF63XN +M6pnAhFDPegvR10dZImhXebBWYFlg9qWXqImV7SgPjH1Aa7dkPu1EfLcrQYE4EQHXaiey6WJ +lCExL/5S29usaYUfqSn6RODY23YS0s+6VM9XC7pMKBV+1xThYRA/1uKF1muxOU5Kd2ea5mTF +iJwEEAECAAYFAlbugNsACgkQyR0V/UCfKkxgDgQAg2DMkXm3vvhfhmPBpkucVilcWUDskQko +noXy2c+mMTRBWRUYzCOQ62TBJ2nykOK5NF7K5rH7Vm7qnkqa++4pPx/5E4nz+XGT6zSpCLJ4 +uD+bhujm2lgZ9AZ7ZqX8ph58O4EkrfMesQZmxgXJZdl2ZyRBCjjegyJMpw0CQhn8xuqInAQQ +AQIABgUCVu6A3gAKCRCtK2f7JuxDQiHJA/4lAiF0rT4DZGyBtY7HKOl5kk79fwMW9xoQeKk7 +sibi7s61geT1WTrkypbinoZn+j02sDeIOB4llT9osvW3v3HK4aTia+lCspHX3wo0f/rV/PhR +zyd7us5k10kXUe8lSvZaRhiECxD8eRdjY3FBJ89Pm0f5tGoEnQr2EsOIh5AOcoicBBABAgAG +BQJW7oDiAAoJEFZ2NiiVe77fElMD/0m3QHgLU/AcHI6LZk3zNp50656+X5ueknTbRc8SiMv2 +4Tlse5YbySHKkcuUPv9Oack8+TeCntdxKGDhdshUfBDN+tJi4FOLYQafOGF4g0Jgob9WOYMa +xGYJzo5R3wPT0rsyegLy0Affub0UN4XRwtLzWkWQAxoENkxfljlZMEnYiJwEEAECAAYFAlbu +gOYACgkQvZ/+wjXUZBqMnQP/VYc+gXY/5fi6uJEV/WaQqycGe/8C4RT3shebJIf+Wm+V2LND +3pwKczHoxK/2LI/sgi8KfclRhLKMoIOSbomef0M2Ubm6XYFo6btYvHdEtd9ugfgHZdSSC9dt +ZIALFIN6QueMA8d8qsDZqsGyQrcrQKQsZv7jKalLWdpRFejCqzqInAQQAQIABgUCVu6A6gAK +CRAeNxJVfopdWpDxA/9/Kynss+AVh0ts/1kRVtmACak83Ls6E1YSS4wIXazZHiQGzZbYDLKd +NESJ41prxS4JcAfwN3rWiQdY8E4FE5ttdbtAtPzgIlzIZ1ungd65++5Syjs487ilTeUqgIlQ +3pmztl3d7lHAPZbkVXy+fBDvUedQeDajEnAhmC7dBcYNDIicBBABAgAGBQJW7oDtAAoJEFZd +1ynZyti7OrEEAK4qdy0Sk1xXklZNCzr51pLwzcDFmYeNdUiNfD4oXtMHThBZuhbXSAXHHiZo +r/i6MAejAUEF/HPzqt+6jFISD73yanJI3oFlVpsD5iXRXvidXXlFCLDFs1bou+AxG66fD5Yl +evuiTPhirTO2l5GApmt1rlEjKYL7nBaOgFoqmgmoiJwEEAECAAYFAlbugPEACgkQPWSbK5lD +I0M4bQP+Id1+NPXxu9KBh2EtRi7+XOcGemJi4CDHYbdigVmOsM7/Bw8tULKeHwfTcV+jZtXh +djW24trntNEPZh8YJL/yzrPOrm1R8iuPIrp3I9XZF7+xES4kSyo3KpHjjnNxKoWZdmsQyVKZ +ZIj021DUxGGdZg2DhfwSaflRs1rf83qReDOInAQQAQIABgUCVu6A9QAKCRBwQV/jdh0yGgm0 +A/4/HZZsOQF/QMKYPS2Yok39V+ejhwW2Qh5Xnv1qBzjTEJQlgEqwzwsbz1ZYw8hl2Si2sloX +6k7jRuX7BeDJ6Exk2H3v/8dw0iLr39d3SlcTsChhvlbb6ohgzfKzMvCnzSgGyPDWhQhutLeh +EXNAvKOaC7Rex0nAIRJXvOjMsBm8pYicBBABAgAGBQJW7oD4AAoJEJYzWK8IgFoKETgEAK9U +P6dAPm0ANWVtRmelL9J9g47MDy4aI9XOBZwocc+9UG+nxfle0275kmlOwj9zGYAyEEtQQBW+ +ei8dskaS2h6ZiHsKob3wyW0gW7z8Aeqka9UZhQpkgWZ6DldULISXWG1fbCczB3u2hvEwQuUL +PBG1TL2twz9P4MQ4xvrit5qCiJwEEAECAAYFAlbugPwACgkQTQK9Po3BTzPGVQQAm1wxxoOq +epOHFnfLuo6BFpjq14meuM1+qQWIddhTGjYMd+oilqwlqyWi7vPhW4NUlCN4BzCLvmzN14CC +EjN13NBuk/mNhOdbBMU1+q2bscbXI6A4O49p0ZKolDUxMpRBv4aKo+bu+2IINCUKNz41uHSE +Ac3ax7uJalw5rKcQsg+InAQQAQIABgUCVu6BAAAKCRCcPFT19KnoSd9VA/9ehS65iz+xW/S5 +gts5rrZZYoXc8L0oEi8OwK9wzvW1nuZSkGPyxCWxUrbeTPWgrgQXFfoAjL1M9bv9IxDj5vmw +FwS7p2piwi3xkIEGxJ0B1+zpk/DOFRYFO6we8E6Sn0tVjSwXbvLENcaAH/PUDi4h/SAS6iEE +cnIZ47HZX2tbk4icBBABAgAGBQJW7oEDAAoJEEM89iqPcEwbUp0D/jQUjI0q/XdwFgnhpiL+ +CfbUvOScr8ZoA1Hsjt0V47hS7FcP+URd/gUY2tlk2FoazQ72C7ZiAD6R2QBAnXI2ofrHwxoy +qZ/qjammLjQyGG2VtZc4VTdl83HP3XXLEI+PTP66CCzxSmAdvLBhho8Im1yl6xKoo8Oy46om +iOkQkrjwiJwEEAECAAYFAlbugQgACgkQ/u6EEjDdjA2hzAP+IzevqVVbVnrLJuucZJ1vt3/1 +GmhpZBc1LPq3pv2vtMzGBP6jBbtOpKPjUwpfbzl4avFJHVZQkw9TrH5zoewn/NqGuOjQyeqb +ed2U4iECxcjdkd9fYzcFRobZ5yFhfJxv5glk3VF8Vzw/UfUMCFViSb4/VHvOBBfgezEP4uXE +QGiInAQQAQIABgUCVu6BDAAKCRD1y3q7Ktco22frBAClIIYSpE703chi2Ozurp5GpaCJ6tFV +ynkqpXZPszaB5SiMOheJCc/dnChSHM0L1Ihlfz8tqxiidnqJUc8BhQTIhx9/AmzBr73dnXbR +v6ivFQD3JMWWpWb4m2gWHaismIfsWsOggLlJHvCyhVLwNemBjzwHTlhuitNDQ/+IMFGKZ4ic +BBABAgAGBQJW7oESAAoJEA+YU5MMEsmCXf8EAIsf2bZgdFlvtrPs8wCItG7xhrawyqvLbl// +O9TsprJ+ofPGyy2HiTFMSqvPmfj6NsWhBH6Z7LtqJHrXG8gh++D7Yd5xbGTj+KczeOtgye4b +z5Ddp5Nm1SZxV++0e4Jghf52yeiDJiaU/eWeGi1nONZ81INGBCK7coJqYz7IAXnEiJwEEAEC +AAYFAlbugRYACgkQ39rr8NROjnGJ/gP7BfZ1QkusbDep4+2z6KW6eZCDbjXWM4VVQEtU1xYD +m9mPagzM4XqjjYERqoHHkGcCWRjwFJ5EL0qPbsdOaLatIPowVMa2mj7PQlBBQYOFZHLRiqWa +Y7oMNZmHVJkLqF2P06SBdupFuPonow1orHHb1BxwOPcmcAFJysVTTm+jY+mInAQQAQIABgUC +Vu6BGgAKCRBMTOUIVOIL75Q1BACO21NUscljkXreRJs6JnjA3uLIFTVuzCz+qamQUARMGQw1 +soE6eKErgOWlYBasmajEqNdF/TQPWuavOFt4yssdOmJpsKRfolRoXZ5IV/dcnezqZMHk1T0D +JIcDk9uqKTFi47fnfofcHkwl7M1gMdjU+kihDVD2AZ76i6SUJTrstoicBBABAgAGBQJW7oEd +AAoJEJnQULfFW+AduuQEANJV1O5KBRN6672IzKue+58KupCIIG0OQXnChrHFz7B6cxnTC3iA +P8WcYDz6AWGIgdmtwPKt2tMo/JWYrQWAyoE1pJjmvL7EqGAyBBlapcZdYCFc3r4WojMsM1f2 +azMk9eOQaPs5Kb78WVqd+ICjkpl0nXe8k8cIwQ6uw/ugmBb7iJwEEAECAAYFAlbugSEACgkQ +08oC0tf0JcLK/QP/cLpejZiLqgNVKMSboUS31pZHEkGaQrYh8CM5OW+L8luXX1p3uHBG+JAZ +Zzd/88QBFZ7WRZZTOldjKs/2mtztCwuw44t+Qo2X2dvd2gPZ3gMgKxM7wgkBPtA3anIEGcA8 +sSatx9reeRZ1iG11DJHRVxVMwBdock6rP0zLV5h+R8yInAQQAQIABgUCVu6BJQAKCRDr17Jv +TIkWLedwBACDXqVWTDJFjHostIuEsNxtGPfs15uU4hueIkxyoNZghWH8BkvftET0upPyDK9A +rsecwdAJz+G/n7wVBK+uU7mAAspm/1Nar0x6B+vAoUQevtm7v7ZMXxotc8h6UOpT3u0dKfoI +GzYNAguhUcUSlb1ho73WW7ROLB1MhQNqOj8YcoicBBABAgAGBQJW7oEoAAoJEIgw1zRemLPd +9xAEAIif4hhhKVzj1IPXE9paB2kqKadOTfHt1okvrkEfruCquF9RkZ/TUE92yweIhJZbKeLX +MMRhcx/AUpvSCi3WJQ4ihO6sVyKupn5DsjhyANCIs4O+xAQ/AQk4AUsSSHvS4Ozgi7iRrHZR +B5RxP2FML3FQdfi7v2ysigJ2crzjpURgiJwEEAECAAYFAlbugSwACgkQxQr5jWljGXArQwQA +oOhE7RZcz976JO1n4sazn5oQch0bfdXL/lYl4US4ntouzjXw8aDSa51MW77yLbGbOw2oUdTF +0E8bW+C8hePHlMDsMe6hyytnlR0WdbHqLLcGJK9kAJ4PkDQGbbNXuWSW1yW74bZVheryTK7x +mU8RlNXnRD99lySrKAvvkV34T/uInAQQAQIABgUCVu6BMAAKCRDg6zFqPQPkqvrvA/9jQkoZ +xxzmx1HfbWox35Jf+gu+FAMAIBFXfbVprzvFy+4LmGNU4d86CHv9yMs3upvGK4NhCcj7TfBo +1pfNLbbZjDXHZms0xw3ZqGgzWo2EGhqcHlh1Gs4LPw8gGd8votjvzPdBd1uK55efzWRTgpy8 +87r3unSC6mVloBszeJq2LIicBBABAgAGBQJW7oE0AAoJEPGa8E8UPymAX6UD/RUssjWeXTxa +HMa9L0Qtvi+FIAy4gh4dATzt3ScUivuCEjnhlm9ONXaQyVrkfidd+p4JMuBGT/RRWiqMaP1S +iJ0OlI7sGS82ekBhgYt42NubvawlTxEkUgQ4JCDMd0xZHg+OENie7M2K3M/ijdik5KBlu7QA +Av6qt7lRIksR20+YiJwEEAECAAYFAlbugTcACgkQmYprrLKVVWtE6QQAsf18rn7mHq4t8xl5 +SCGRVLuCiUhfIBrg5TGnMt0sPplNGh0V6lI3PZqDid5CozoSu1rFZJnUj1pBN/jFDBt52dHH +SOAHfSYE9x1nTfCuua3fz90wBE6YSbGCAwywi/XHAWV6Iw3d3MtGFTdDdxACIDokHqUqsFm7 +5ApKat2TF3+InAQQAQIABgUCVu6BOwAKCRB1Znv4itP33sAUA/9q9f8ki4wQR9O8tTEMNXJO +yBuUlekgTbxetpht/XG7hv2CwWJGS7SH9k8A1CFf75Y5aONT+u74/rE5CvNMMd2OAbALDXau +rtI+0blwJuxAeOanzPGEWghqsmwmwsv9YOusfBOHTM9ahwczPUsFj9in/TrvnvbkDTUFuCbt +ewn6uIicBBABAgAGBQJW7oE/AAoJEMOajCqf2X9wrhoEAIFj1/p5XBz02/i+YguCZwz6RS4H +fMz1ep+xy74/TsffKsl8Q/ZTqz34x3gGKqxCMxipXSPjTR5vY2pkXkmFnfvVguCfOE4Ar3Rn +wZ2CWEGrEAWWULmKMRfkcBEQ1z9d971JmFx/8b8G3JS1RBpCTPvdp1b0UJHR7z3e/PEIGJKc +iJwEEAECAAYFAlbugUMACgkQIZ1jqFbgPDvdfAQAly7t4oZfdiTiitYSvYnC4Ne9hwTN6uwE +rounFSIh+oIWtwvDRoqGFkGglXDzESff+2LF6k97rxvqJ+3k17n2Y8wtu8aTnGREVZAdTXQp +g/ZwLecObptqu8Mxj7jgO8OJqekGoU06H3BsrL7tGGViiNtf2Wtbnxtb3UGUC7YrD96InAQQ +AQIABgUCVu6BRgAKCRAy8ieBtuRQy4PXA/0e3k2W70zKsMNW22xUrAvklmXf4L6rZnmW2pPO +DwVnUPFNpcL5xkuiIZsLcd5FDBL03EdOmG0awgfTqBTIaKBicwTQY+w3BG38fdl/NusgqizB +zPc6R2ETkMyURI+cjwMbLGr39aHy0l9shV/2Izem8YsW4nCFQFlFgojYPmHZlYicBBABAgAG +BQJW7oFKAAoJEPbE0mI4Jr2xUeYD/R2FydXje/ARVoqMEVKUs0TxYhigm4wjUhoBxKseLIJ2 +D7Jpmc5NAK/KCbtoxb0hrzTVDc+tbiByc9tKWlP2o8RH/u7Q90r0mSG2si6QdJMtYLl/AMFW +fWoChdRWqy9JPbmcsbEJZLN9PQSRRjH/3oFE5JwYozPGy4bpqnFoV01viJwEEAECAAYFAlbu +gU4ACgkQV5WwD8otEpP5QAP/VzDFqy/eMxuxTt0mll+K2VeA0HKGDekqmndebf/suaInKffd +GYHw4MuQR3HwHS8xeIRsgXzJQRoZJa/HNhg30icXgop3NqTpKP2nA9XYQh5K2zAS9kXtme6d +GUy3gju2YcSx6CCtfrozQa0+h0SzdaesB8uLpFncszph6bN9PKOInAQQAQIABgUCVu6BUgAK +CRBEfDUKqRnUsG89BADPG5kLOWMeRoo3OS3f4I3cscrWi4VIHe2fNDVhcIfabLD8fIny/FEk +bOcAAzSJErykEBDBm1tCdH1hi1JLpIJTRlRv2CiidGOAV0/qa55K2KEC+mpDGSymUhrr+JVg +sU8q7UaKoKkDvfPY5deXax0iNveySmXT2LgdACEVqp3yaIicBBABAgAGBQJW7oFVAAoJEGrv +zrdNXBRxEWUD/ix2rRD0yDOyS7ryJmbl2cqjOkPcUbYDE7gJYig/SVWN1jbetlQaNRVrVyYf +SSELYir+IuIesqg5JGDiMOm1HgPZyX3RYNIMTjdBmL4IadJUJHWszmB8ZcqmSBopiOyfLms6 +1/6+Zlreou6U0dQWqK3ysO5tn4DKU+i9+n4AqMEPiJwEEAECAAYFAlbugVkACgkQG7mZTkiS +NEX4UQP/R3oBg8bsas2MQBk+yNwe+NNiPl3QV3MLXtTo0hXB16IuKDjBZDQ+nQ6/ta2xnEwb +ryyUwaGM8Gde+TGT1MGrFlyY3NTwMIGBIe6rAUjt+H9WMY0jt3yFaiDab4JU4/1Oa8Cu8Gbl +Tz3ELQXu9jO9xMhnlthbKoZlzcqx8BO4NdWInAQQAQIABgUCVu6BXQAKCRD+ilfaCWgY5i+X +BADFdnJiHDk0gXusLzn1EUK/GMG/aQ4TBAp4ZeiYksDGuwFiYUeKZCvAAPiUBfWn/8X7VBbN +vpiUm0qONLD6iPvqxoWt911jkcYuDEJJTo+Ya9lzcEYfGAIK0NlLFpHLBgErX09sSuVMFYwI +pmi5RbbvdMVqrxx+4ZQtmKP9TsE/O4icBBABAgAGBQJW7oFgAAoJEJeRw90iOyXY7lkD/jGK +Q08M9OEHdHqZW1HKXtXmZETnRetAVt6oc/B0mRedgfgZ5jiNZ9G1mxoZJQB8p/yLqM8SeadD +sO9zdEZq69y6UwiPq5DsUMp8CX5PoVyaWZBk9M1dRZ3bhh7K0KdFfM0l5JrXVfKo767J40+D +kzo+26Ahl6ss5Slriwnkvq7NiJwEEAECAAYFAlbugWQACgkQRwO+hexTqRL4zAP/RzpvXnyx +uCfHnR3pcoEE9KPAAyLnrnoE00EHV7OYWVmaP467SgLRxwX4PxrLEuibokp44jESpeahQ23c +xz/Bvr1NYsmi7WSqapFvlANkSl/gq1+e+MAfiGz1ZM4jbWqdBMUqYIy/D+SBgHfjVTMqmHbz +nSaTfw8cQUjKTZwjZNyInAQQAQIABgUCVu6BaAAKCRCpSI3shDBwqUPtA/9IQLqTvQhM35BL +GSgSqqCQluHUSCCfamUEy89qwK86+GvnPAn7UhOIqprOxxv+yKDZuokb2X0VOvZzDncDBkyB +6/mChU8YX5uu7WYpFck87tOG9z4h8YdFp0g4xYBgmIyVobCFe1o82mH30S2UOHtRT8BRHKVb +7dpfbl7GFUfqDYicBBABAgAGBQJW7oFsAAoJEJHBH1Py1K7Cbn4D/2vG2f9YUXFNepcP1eJM +6Vlth1vqmvnRNy5C2mQ3IwbPweb8wI8vUszXc2KecKV4z3YD8k227cr950EwXjcLpHjzRwIv +eUej3eI7QiNmfJwDkx++MMaqeAn4vxqDPIDJhFIqastBZegpbHntJjqQSpaMRD/nmEV4ufNm +FSmNgJqwiJwEEAECAAYFAlbugXAACgkQLkEBSPaqgYJcIgQAka4eqoF2wO6juTRASt8zzZ43 +cN6dnr3y1OXNK3u5pERH9RGuLVO0pVzAA/MTV+aPMZoFLS7XCt0yrGpg/Pi7UqkUqFCyN3j9 +LpwIwPpxumpUmhOYi/dUGCnh09GqzE3PmFmC1XUukWegJMJzV4vQJo94qANFXK5r+oWcq+JO +2YmInAQQAQIABgUCVu6BcwAKCRAOM2kz0MrJolPNA/4uRWjRRjtoJddg2LhdGWnr04/V9FAt +czrNWvmrhqXzylnZMLVMJO20kPZSr3ECd8DT04bfY0wJFyAhQ+8u3fmhcOBRoxPTqriBv70d +k7v198RGdGeF17VnbpGBo+B+f0B5J68zY/RlOczt59u5TltAegb57cD4i9qzY+bSsosjb4ic +BBABAgAGBQJW7oF3AAoJEBV09xwxOyLcFooEAIBivI/5iw7X+ywkTQ1qGJyHSJwYn0fSo+Sj +F7uTMalj7mlp0VZTlYRHj1Y5/F9croZ88LWk1i10U+dN2nqiORD9bOxnPH8d4a07DyEodAPp +mhp7N34wY9ac1Sajjee8WETExYhL50xv8+zIZnAID2wgUuZ4haFhr1R6X4uXDi7wiJwEEAEC +AAYFAlbugXsACgkQN6jj6kr6/cjOcgQAwxmHNAzaDWqwkMl/zXU1I/7cHH15lHfIpiKttDiX +KX7Lmb3gTTshl0c9429st9aTdnTmQhvuj7M7xsgNFRUqETbUGyH028AUlRjaykh//2dl5RME +t2gV1pJD1cantI9XdPII3u/mSwPUKLO845co+Fnrck0TEJWOSAjHgwVmIDuInAQQAQIABgUC +Vu6BfwAKCRBQow4VYrc54di0A/9cN+rkNOF452B5agifC4oqciNeDOBB+VvQxPcqI64U/U+A +8CMtrwE/fHAz4EBN+HJJRYh7Lpozuk+KB1WL+im6n3YGhoRwZZfBmurSj/XopkNZNzUdTNmY +GR1AhQdi4k0crJ2h9zikbrJkUEdfg+Yz4VEKEQW5z2L6auMkCxHym4icBBABAgAGBQJW7oGD +AAoJEKWOrYMPn/HqUsQEAMyQnF+Lo0ISpCTugw1t0Np2DuzAzftHVHZ5i4INRcAQE7N/vtL1 +CU5+PsPs8t/Xs78QuY3WrJEi2+r2K0B4Ji8N/Ag7ywGYhdQ8Ace9j1E6ZZCrXGK5JFmoZtJg ++ggKEOWLVXZebVM/iPs0QoqDCe7mY6/obag6g0Qbsj3/Of5/iJwEEAECAAYFAlbugYcACgkQ +IhQ5T7PjJwtk8AQAzvXsOqK1v89MelUmgVdRNH5D70MlmNl2rNN4E/FChNBbQd+eSPtUD2OC +2aoAorM/vhv1PKQlGEIWCIhwWQf6J+lYwQ1SR4maLrNPtuFhaTHWax7a3G2tV79XpU+S5clF +Sci8F3z6GqLmyFkVMszjha6C9h39kMJ65R0mK6qRl2qInAQQAQIABgUCVu6BiwAKCRAqCgzp +QPnDiFJZA/9HrdWWosHePF0ftO3GzduNqWjumvUJwka/gHJHMxVeAUiS74gOVfjXBMV1c0qJ +muyN/+jIGVqSPHinMnV4S+T0mn7YRwDTFmTztF00JMwsAAmDVB8it8Ednt5XjpemabFljVUl +f2fBcbchkgmjhZYg6kVWoGSGQDdaLJzalGb/EoicBBABAgAGBQJW7oGPAAoJEAt/KnrIHSlb +9jID/Ro83zRx6dDXjTBHF9ksU8ZV+jqjq8dDcKNq/r+y5elqMzMqEqRf9siut/7Moso2RPZ3 +VZ9SssqIECgjm6onyQFRAx+GvrxZ4e7OptN8MdSksBOprsdBoYAXWU65gKAeLV1hyO8vqjGb +R6Ve2UfYjGq2ImGsWSTYDcFDaiISCATPiJwEEAECAAYFAlbugZMACgkQ7hTpxPnSO8EPAQP/ +S5ce13OiNa8R5RNY+JntzbFdFjb4w04xevtZrD91cx1LWYOIOfWHhcSRw7EfXx7kgxsmVgcd +nebWLjAG59Ls0PIJpIn/OvxJgEAn9UiudM2uEljCSK6W4ftcABf2Khlmeu2zGWtuCo5u2c0W +DNKUHx6xt+nebWA7hbXWb4n/MUiInAQQAQIABgUCVu6BlgAKCRAE9OSTVbmveE70A/sHvx8y +rOmbgcEADHrFjb6sD0HKzQb+srnPIs7PxSMT9K7RCQvACDNWW3cpjUjrwAy+2t/pMin9TjX6 +i0OVm+qp9NiJ8DB/beHD8atYfck+BojgmXNif6doNGcG3YQGFBw+etwHErSWM+ZM16EPknWz +rbp/bI3igSZjhalAVI19S4icBBABAgAGBQJW7oGaAAoJEJI6nEOte+RfZcgD/A4iH2gHM6Ua +/tupOEhTb9ngGpEwfFzuI9Xh4nO0Bubd/1mifJrKfKWIYNhIn5nckBBUtFosctBP5SiuTpwD +ERUkLFDbgl4lruXOKobUkytlm3jAzp4m8lwLVJIPvSAQ9l6tVBRcgiBXZ/oloqahLtcfWCj4 +k/R72jmHp0jHTCCniJwEEAECAAYFAlbugZ4ACgkQftZFnyJwfgMqSQP/ZcfMpy92uKehy5Jf +UMc5iUO0or2Raz4JtQVVCYGYE3HDn+QQPmlXwsTj3rUyX3QhAdDuPCPeG+sLybs++1dFb6ZA +Hz+RjKsZBa/Nf6hVhJZUiUD1P2QVNmeFJ40T3mZJeES5A0fL4lvXaXXGErTgY1tkfGK8ZqgA +lgo8pVMnJC6InAQQAQIABgUCVu6BogAKCRAmuDtjcRzQY+CxBAChcsmhFUtZZo8IKyD+MZGp +gVqRxi1phwGd2m7QQqJRx++dypAh9fBfKgZg/C+iREsiJdCd2hdztYC9DAFmAaNwjxcJThxH +V1LnuM+Le8pDXOp2n0mEqIzEfAVoqsC1rgve0wAuPJEafvhIAhJd6qG3S7BTvq110parYRRe +cky7rIicBBABAgAGBQJW7oGmAAoJECsluv9BqtwAcaID/jUXigtoTjXJMH2HRRUvRolbpmAN +WTnxuoDJcF8UOdrp2nLrlDx+HVnpkUwh70xV5fmE271zssKOkMbteCf8JJbeDrRW4IQdhlII +S+SDVgkPw68QqzcREzRAchCu0/ykl8j+Bw14BaQFmlf8FkTDaG60tx5G41x4/iErQCk6CvVl +iJwEEAECAAYFAlbugaoACgkQauPH5YKivSxC9gP/c+NrSthLZYK4G0etHaQr1rdwBGAH3kWC +CEtFfsqwBrKcTmVkVV+h8UaR5qq29LiE3xxYDu+OtDiEozQ4CazK02OytXHEhRf+LBLL/GD6 +tdKLpG6d8sFuzt/yjim0MCA9IPkRCSLpILKI9O+M/6Ex+kx2CK7sZF0H+pqUJbBAdieInAQQ +AQIABgUCVu6BrgAKCRBz2GJMXxTw4wedA/0Vh7y/h7PJFXVaHbYbiotsIej2fssAv3er7oE3 +wT+yIlRBHtX2IGVZie/le9Omy8K6ReyV2eqGjlJYAyix0nW/kT+GXKXOsJ7HpfNElLvGpik/ +kkjOTOrhY7UVk/yMj+zT5KknPaVUBlHu03Iz3AwX6BsjlbZ2WJIotzRDiGZbpIicBBABAgAG +BQJW7oGyAAoJENS62wMFGm5JCSID/iTxG7bP6ko9pYxYjAHHY/B5cp4u4rlrLOCgi/Uj5SNC +k6otfDWQ8PL497hSrPaS2qdU1D9WSDfyqDfIN1ZTP+H/qvhETzXOvo5tsi+xA9s3u5GZGB0H +I/8aYn/4Sc1SGzg6sjlbUJnKNz0rtMH1OclRniCWsIn1HCnUD3+vNmhiiJwEEAECAAYFAlbu +gbYACgkQW42S5D+jnRdHOQP9F0xbD3cK+aIqPX6YmcxrWYN2y9sN37/ye7h25VmdUi5WVEii +/HBRXXTfoku++dNF9pgc7yd5bq2q4QZMFd5p2pqtak7FfuR9q863ebR2hca2TXNR2H4eN/eW +Fzi0wcDJoW+KiXO+pdmayot8e3X5PtBU3TuKqCkHNS5JLDTw9B6InAQQAQIABgUCVu6BugAK +CRBpnG90WI6WbmRTA/9TqJUduJRWRxN98wGUP+faWXWACMUCwAa+0alT46tJ9ocQGrQhqH4D +Whpd3CitJgUwtc+rnKLOuoaG0fJjpy7rchYve0sGDoPbTnfqR57LKjQqcUdcEuCUz5qhxnA9 +dYUrrRZhgQyz1V00CGKxkf7K6htxvab/CeIpjp4kyWI+JYicBBABAgAGBQJW7oG+AAoJELC8 +NcNv15hgQO8D/289S+3EF0WgLsp6h7gnhkeujx0iTJxA0iHqT4FY7qgxQJHvQsQ4Wl75NWmD +Ftguxca99qEDPVbnz1f/52NCIeWhiKxGaesFmiwboR4CZrgiP+s1nf3gFvaO3H80BCbnzJzt +6ZnhMjY2TDW3vv667a+TLDmW6J8J7JyZUMWbKJ5XiJwEEAECAAYFAlbugcIACgkQvtsqo3FM +sc39JwQAhl413Q1665Z2eDDXUWyZx5FpK8CldlwSeZqHOb7eAFHZ00viQmYZPlJBnUcJb3vU +jXlC5qxnmQ9s6kLOQmEgmUuiH9h8BFRTrYdBZ9kNb1rJ+FfMY8yDseHM3gaapNtIDKzXme+q +kllUv4UUpJ4cy5y4iYu83dlmZlR15OqgCyqInAQQAQIABgUCVu6BxgAKCRB3/avdleLYG4mL +BACn+SiS9a0ysk2S8LoEJY/8+J3wvyTZT6S+lurIWr7X7Yq0fgvunaV53xBnojovJi6omFFq +9BEln96ljSV3f+AgEMyGb6Dxa74l6Wz1oVvw70ik6aTHda2gD/S2fYaPbwqpcJFCc5/C5u+5 +3jYwcY4eg3EF0j+RC+8Mo/5ISXyKq4icBBABAgAGBQJW7oHKAAoJEN5jXTWDlZTo1ZgD/iOO +g27CmWB9a9SLwd9OiPTbCVhHZ+OisRsOHoorH1LMRgtH0YMQ1QMlurjFyByi7DvcXBQqjtR6 +CIHbi0pc1EOXbA5oVG88EWOG7v2iWc584nFkNx5qfiI1U7yEO7niTygsvD9Ju9H3UOZH2uIT +W1FeAnhPblBuhC1JkFDJyhcdiJwEEAECAAYFAlbugc0ACgkQAlHu49wN4uXm3gQAjj6Jf5oX +NrtkVaEr2ySLGTIWJJp5hASjkgWR8U8A4YKgblecchCpgWgBGW1+14i+QY6bGXWAD/Q8veM+ +Fx9O+sVSsohpIUtFUWjjK+GyusdQGlRLUKcFLvC1CEZHVHYABwDdXCNZwTLXBz4gLWC8uuPG +dE1ui3EXJKQoWQ7KD+GInAQQAQIABgUCVu6B0gAKCRDCiFix5dgCrvq1BACDNuNJARsvyAOG +Aya/a18Lpy9S21gZp9EqPAKA5Nq4sU6wg0l2E789QgKbN02NBWl2yCOLltVJvjn6UdL/Vr4F +I0DXL5UnHevPEyiwWY+zr4XqGbjGLi6lBXKpjaxu3ewYIBkHWE5Osz0Tgn5inuXVrlAvSbmq +W42i4U+XZ+zBEoicBBABAgAGBQJW7oHWAAoJEBCcxWO1lg5xFiQD/1zDPKyx2jMUIJJ9ej1c +iKxIvht9k9Xerx54/5OXs99JbA9b6XgeovgRietYJBM7/17D87Tj1LkpbcPl/6VqNZ9hpWcU +noxH6DKqcS0SZs8H9tfnA4rJDuYqZQvPTGek1y/p9YQaclAsYvLiSrOmdfZzLEP81fm9azzh +OFFcg0BFiJwEEAECAAYFAlbugdoACgkQMD38N9o28yWY8wQAgJ7zir3mMEr8FONyJ6+SiYjf +D4AkTHUzTgnLCv0DFvQ3vJCG8wVgsWVAunOd8epfZDGmkvuVa5a14v1756CnmO6Y/jr6SwUp +ykZQDffe/8n5ufI2/+OQOz/kJczYE/7IIifikqIRN6N6a7x3IYTTtMzVX7vJ4bWr2GIOkc4X +a5iInAQQAQIABgUCVu6B3gAKCRCT/hSdK/wI701rA/9a/rWW7rNJS6qFso425qda8t1xlt4Q +9s1vZaQM5tlf30kdB6uxte0YFKAee8Nb3zA9qA/149dnBp7bSVpMmnQmIA0RpIRbCtOWkZK+ +8fp0tbhbYdWTMbDEVxSV2vpsgwrZ0PRkmVxJzeL/h9f/gxJ0AY0QLoa/eBfQnKUzq99JEoic +BBABAgAGBQJW7oHiAAoJENuwiQmjHJH083AEAJC0sl1yZ4tOYRVDmFSv5yGoVQGqPHU+Mi9y +eK9LpR77pA+dgguFfdD9IbORJMzC6NBz1KvPfhJtw38yMLC5OZimuOhKNfnqXOWscLA0itSn +jJzZ/4o9/82J8DoIS5pM88wZtEi22bDh6gIp10A3NaqGZR24H3y/7d3cnxMuqraaiJwEEAEC +AAYFAlbugeYACgkQrBsTLEs3+nU2eAP/ZhNg4YjANzWdj8OednDIsKHhtQMY0ntrJ80iSnA0 +LPhKELYojTqnten+nHXu1qOA7WSAk/npCNqOLKZQhPSJMIfwvDrzOii5sHRYG/hRKgwruxSZ +sw7SBF3U6A+3HAA3Ib9ZGdXXFuVl+tVjcDk+jIsP6oer0UpQvUW3MxygYqeInAQQAQIABgUC +Vu6B6gAKCRCiMFvfpFG6GeTBA/9gvK+zByj8WlC4xNU/JtjWnYdgqHWZDJDrflFHRwwvPpYj +J5m61XstK6i8vru+3Fjvlp4wLlCEdZTLo3XuTN0oQQHxBnXrPRKYOv/jLdMwmpBTZJSr2uLO ++OZBiqlqyGXFTGMVWbZNYU95hYivY7X8Uilc0jxQLl3Hy88mSuzQmoicBBABAgAGBQJW7oHt +AAoJEHeZWoXrgEysNRYD/2fvapwq+a5CP/5p9KaI5P8WnHJ4RJbTkSW4aMuliJ0EoZGScNsw +A2rxF5f/DgGtp3Aqp2Sf39CWndrn0rO8bQTF9p/3nC5qaqc/Hhf0Fh2U4wXYgsZ5lz4bBWFz +XLbsRVzWIuXVkwa47FbvqG0mnrjh7dEwQwRi1ckDVwcpCw8hiJwEEAECAAYFAlbugfEACgkQ +V7zgdEgam/JKdQQAgRyMrPPEwljvSvnnRxf3SAOQ3hynm+IW3FG1jiG6Jm5GOVhiaSFS+UXG +QYUDa9P8YNCVUQWOEnmHNKIVeQppFvGDzNxYqOFSxHSYmjNKTZ4sd92i+rkzTSc1g/DLNVtn +kbL6ia1S4xLAa/fB26A9MPnGhR6/amvwcgxRKisvqjCInAQQAQIABgUCVu6B9QAKCRCHx9bT +k9kpHeBmA/oD/lwvKVf898XW7YwrlYMHr191pl3aLBVzfai6+xsR0F8gOJ8Q1EZVlUKYl77K +9iDQ3Xh02dI2onzjRfAczdwN2Vqdorbz/EVLFnJw7mBUPQ7/5YMP9prqYLMYAQeux3ugyznX +aghoueBj+OSWFsNy6Ir33tSBVqLIBNTOwnzxD4icBBABAgAGBQJW7oH5AAoJEH5AZi95ANcM +CvcD/2N80C2nohDBV8oFH0txwDfBNjs7mPRBYyMtVg9+9Zmf0r3jrlbv57xlGWkVncNCxjKA +/S2pLTRD6GXeYpLs+Zfbn0VYueI1Rl53g/VjJRbWlHCgxcp5as7IqENYBHasfTZAFONYEAYJ +yzKgNGrrt42zBgrNbvL+6dfVRnkkjSnRiJwEEAECAAYFAlbugf0ACgkQyGyydZPeNzWS+AQA +lhObq3/vu6d0CHLRwFbtdan60vGa9owHET+P7+z0N+qrBnIan+sgYmM4tFab372Xi6VVNRtU +Fs8ErwuOBm53ECaWu0FlaPLpAZCVx2sQzoLqTwvh8TWI0UCr9W+E3qWehcu55QLs1HsrQbYc +KM9gX57ykX0SsRHY6AydFrCv1r2InAQQAQIABgUCVu6CAQAKCRA93x9gaNu994xwA/4iPkXe +nnrPK0v3cbeLiKy+PXFL8fjFtVRISJFVmJH0rU8hSdmvxe7BzPxbpK/Sozekd3hgYhLY45dW +yVvrEZOpdJYySYRT7zVW9szfEoHMr3cq8EUpaZAuJW12PiLV25M/13smEBL3InDR4f3RpC24 +dKRwfpKE8K2xx1/WdodtjIicBBABAgAGBQJW7oIFAAoJEKcoUWvn9XxsIu4D/iavY3uLr3wy +7B01bb4Tmlzv1JDqVvCl1twD8RusBs2bwyjccvNt+6QO4G9SOd0ocGj6buVj6UT7L2MmMuzT +U/GjaE0KqX63gEDnKNJ+Lby00fOijSMw3Jl8Mj9fkdP8Y83ibRM0tSyFQwwvH+svCpt4fFC4 +SumiL1dTGTFSJhSZiJwEEAECAAYFAlbuggkACgkQC6tBGOO8OeHYBAQAgH2kF9yHL4TTocq6 +eN/uXl3uBG6+WaDgR6c0gBm69GvOi6+vOBtPT751CDIlmgOf1QbLaNjE6Yk2BXTaMn1fL123 +B9xgJH9j1sGUtGqZ7pZpUPJbQwO9RNtyqfjhXjct2sIwRXP7aKIiZTQ4XEYcRB54LJEu+Fva +krGWeu8C/4OInAQQAQIABgUCVu6CDQAKCRATAZkZwuWALkf6A/9LhPpwyrM8LZluufASFzR3 +zZQQl8LZ6Cv6214Jvagz/URuAzG0N4P1400zGVefkkSyyLGHtnmzYRirWNdsJmvUwZwZmLAV +9JSdGQt4UCwyTBEgenylamJAFUzwfa/+W0wZgUbHXErGpkY7DKrhPyoQhRWA3umczW6Wn5Ku +dap7tYicBBABAgAGBQJW7oIRAAoJEOTyne4sVeWocP0EAJd7KWjj1fegy3OpH+YcwmOFqBkQ +mLua+4iEYhsPi18+cF2K/YNhp+yRJAzR3E71XXgtCHYEdHQSrr8Nu+o3VZI1IT/ngtiUowm0 ++5C0/HmWlt7VoOAKipjIkgp8Esk5Oatz6kVX8XIao1z5IvifTRzXFHo6EqcJL/q6OczSbd/o +iJwEEAECAAYFAlbughUACgkQk+eD8jj53xCflwP9FOizQRIZQdrPjYBPN30lYtCzE+AXRAi4 +zRL0ZJek4qbVi/InkBf4LNbjLRPD0dL919m2whx73cwkpBp+Nu+y9ogZxPwKKDVC+ofaxlqU +pUnCh+30CHwVN9OFbh6e+TfTa6kIhMtZ8hXMIkHQrTgM4hhvM/zVGrw1SR46oAWUU6OInAQQ +AQIABgUCVu6CGgAKCRAe+hGNxF7jOhAaA/4g+4ATCW+yJXUpcCxDmgMCWDusN8DEp3IF+0HP +Vr6Hxb1n0hvmfzQZuALfYBlOhDv7zE1XB66tXdKFeVHhjXFERS8nkljDDUOCXUS6yPncfbjE +vflN4SlNKMs7N7TzcOqxvwMx4NBTSoaDR2T6yFYOIrjiJuc4yLssc7Ve1t5p8oicBBABAgAG +BQJW7oIeAAoJEJEUSg28wzxhHosD/A3wcSgjaiTXPR0+Etp2fP1a+3nCB9kVtnZSbWzvhZW3 +qX2fL40PpgTUnfDsCf2mDO1AFCa64ejWxOmIq9BwufbXa0eCdDh2aWn4/AGMOF66kf0xJm5X +CzheJ+YldjEH5eLb05qa9uNUEbKgOYI/yp2pfWrkY1kCWs01ri9BDVcAiJwEEAECAAYFAlbu +giIACgkQsGDNWm1I7RoqkwQAv3wFMtj7el5/7AtnGTz2zAioIjNCFBkEc85/oM5ts8zq9InJ +wlQon+2l4bincdtvzfSjKdm1QKH8K0NQ+V5qkOfGyK4EV+RJELZYABBh/GMApa96/VxkNeGb +y16oLwpaqkWUSyheYMtL63kBx/6CYaqytS/cZtvsOx3ibaTSm9KInAQQAQIABgUCVu6CJgAK +CRC6Fkv/iSKNw81KA/9+8vf865L57uTYX9imrf0VIYaqCmSm9K4YSZByzioDAFog15fiaG9M +lpr0ohSpvhpau3bTk9l+EaiebVyvKkwdWICM26j4uWllyCnmaVkhP71Ca2Y+D0yIehqPgtuY +R8gYMiRX6SIRWYXlkL0ChQtsHob/ZfzPU1bV93bpp4nk3YicBBABAgAGBQJW7oIqAAoJENfs +ls9QOKlhlkcEAL6M2yP9i+K/QnE5yjppz36b557j9d9Z4vNhxYqErSzAAiaLAuMTupk0EZz8 +Ty/9+TwAcmwgy4El9CgA5C3RZhzhzPzKOfSDhRdYrH3Enx3m94+lkEk7oqfLMFxQoIFsaUti +zgYq0PGv63EjdS7bxR7ZIT5J/MW8Kwgx9g4VImeaiJwEEAECAAYFAlbugi4ACgkQOBETXl9N +A44FagQAqBz65HxgMUiCheNWhJtMDrT2rrvJiQ+kwvCUY2R8YjDOwFSCR8jLFZGAZfC5cR4K +JbPVy4qDYdq2hkl9FHLaAm8U6r1xq2gm1I6/5spXk2RQ+pe91ROFhORGutjiuF4RfA4FZE9h +36IAogVkG+z154A+ZgCpWr1xy1rEYPbDzhKInAQQAQIABgUCVu6CMgAKCRAS1Lq+yd0CYO4J +A/9HEDwq3QeQ9VoR4EhWDqzAG7JyQyh/BaYjVh6sVivstd1zHZMjFdaY3EGzb/oZr/pwyDXO +j841qC8MGSyvqe4q6F4JzVpN3djdQZngyalW/pXBTP9XdQo/keKgD605TGkxUdROlHmrZbkh +wi/mOqJCvY3HLwiAR74iE6on+8h3rIicBBABAgAGBQJW7oI2AAoJEBUvB7eSu/0IK6cEAIaJ +KR9v3kpdEG0LZmFVadiO09DDQ54EjLw4srFrHJxAXi0RpDHqGrEM2lMW92Jgcnugs0/aI7Hm ++SYXnigPGowEisYi2a1IDvNEDQNfRvltdNPmgxqZ3ZLFZXuA+W9IJRr5EW0zctQV7qGlVAuJ +NnAI89IbZ/nvXrp78NY3UvS5iJwEEAECAAYFAlbugjoACgkQyVV0Nc1EY0vaoQQAlFd2/L+c +x9qCBe2z2LkkGC2B6mJpLMXCqwN60q+tqHHkhKvtAVhRPBg2jCL/C5S0JpKA++lN4WCkJwPo +F8HWbdmy4I8PqROcCR3BFGBIePPBiMrwpTmiwG2UAhi5yu9du470vwHNH6+CQ9YzpFFN7naR +JOwb1cgptANJyt5LDICInAQQAQIABgUCVu6CPgAKCRA90yQ6FX7CL/e5A/9sgLhXx0vBCZNm +AApouOMlnP12JMHmBE9CfBeXcJT8HgQMXVABMiyyGy2FCyLcZvnFG76yNABt/OfUgyNI33hn +twwMao0S70CEYiTEc8Ht3DWu3QYz3umwwTRBWtEPYbpf2mrqhnPu92EawlcapU3VYDISqRw5 +00rXECJy/cWQnoicBBABAgAGBQJW7oJCAAoJEBYL7uGDejXqJ9oEAJEjZq3uPMa7IiL612QQ +XRaavne/rytjCtZ8L0z2vG1mUE6YmHuob0g2W/z1AY0MM+pRDayXB+LBJ0i1kW93JdbYg1Ui +SRhTPdm+Geo1CUpxpX5yzDrDstxU97qA9GvA9GfgsXZPqNSOUCQMtolBIr/Dsc9DpFURedxx +ai0lx/geiJwEEAECAAYFAlbugkcACgkQy7dhBxMfQVKaBwQAhwMmSQdZFXNKoYc07XTyxFvV +LiOI1gZLebOytPjOmHeVCELqXaxhjyd6hbiKw1xgjtNXd3thHI7pfoCUeJmUPeDo9wouD44T +UjK1y2XyGiF/XbQfmtgve2KR5G4hSbsfAjJQ228MzphT5mtpUh/yDy9/FqCc/GlhqaEmCh8F +IleInAQQAQIABgUCVu6CSwAKCRDD3TThLSkUMVcNA/0cikVdQAZEzBIW3mTKAYM1SqUySMv0 +j4SPhhYPmnl8zZe9uKl8IiVQSf3bUAIUDuJpzbdP+GivPE4Ibf7XkF0hk0nd3UR0G8drW7/D +esySbyAVEpwlIfEk61wCUEt2O/2ozVf1Picd0tYxI00alNajMdJXg1GxIRKGqjIP8908soic +BBABAgAGBQJW7oJPAAoJENC5qdEvrfW3CQMD/1ZvEl9OB8Ra2+8Kk/UB215Pt4Y37cR3rEJU +O7vDziRSjMS81K53o4aFMOFoMKcG8pPF3IzgVwPXYJXOC4+FF/ozupCMT6BSegJlEHyq1jy6 +epwK57iPqouTUdIRwR1rECkITlWBK0Q4UY70DdF+zKUUdwwXUP0kBxcJj1J85835iJwEEAEC +AAYFAlbuglMACgkQ++90dWdVBjbnuwP6AzkcUG3f7goDmF1sc3eVAjq+LR3yMJL4DxBG0QMO +0xx0ViM9UOko+7Ktm4kwI+I3Xayeg0RIU/Sz2jQIalS0TdIq7pn9Q5KIsOSBnArszb5Eij0g +eKDXZON3oV/3EQm3fh6fdl9gXaST0xn5dwqtd3ElOaSjPgvJgZStZcNjDjCInAQQAQIABgUC +Vu6CVwAKCRA3+obvVSyRV4SaA/975bJ/8tcjTEepjQAHuXd6NBM050U9DhUqATfNAa74Ef+P +3w6glOXi1HCVCtGfpDYUykY8Hb9gNQyqiZLuc1SOIL1hbz4nbiUfG3IYi4tMjhkj2Glsq1q/ +VbTU70UeiJ2igVszrgs80Niw+TtUdqVJbXak9fh6WiLRnlToRxkDtYicBBABAgAGBQJW7oJb +AAoJEK6SocqvLkdgQG8D/RiI+wxIA3oNTS+P9C8wqgOLS0d1S48d0SyTN4OvlNfFXR2JePok +cLXJ1/S8xei7Ha1B6LkhqQjwzGQfpYwOQqmHdKKf+ZQdz6TWSL7LCJ1NHAxKxPTyAr3Fnbvn +bST7LJ6bygxz/Vuc8bTLZSUNR0CUt4rKSKyWK4/4z++KNKbWiJwEEAECAAYFAlbugl8ACgkQ +zY9HfyoNogjrWwQAq8UuyG5Rnp6UTxiidJ/Y5XXdnR+CtfQ4iHNFQls9Wz2CieesaQLRGoK1 +0UN+5oPORnAtC83bk7aLX3Ga4mgqxFV5Aye8V1UT+suVuRCtnQIHJkptS3f3HQ4Fadm9fyQi +gbCbAT01x8LvWlLvVN1keVGzEKGv9ssJZ52c1xCy7omInAQQAQIABgUCVu6CYwAKCRDZ8Wlv +gIjJIODBBACh2QmxiOTgx5enzUdNx3zxIyOUaVItwQk/NwwlHb8wBjhRRE8wWxpr9BMZeq3w +DGT7mgGRN2GX1MLvdiPcb1GnOUtmScnbxk+koMwVcMvv776XnD5UCQd/EG19HZgH4cCkhAof +voQWm78mfw//i6g4MoUaqe3xNKXyNVdi8cbVw4icBBABAgAGBQJW7oJnAAoJEGkk1i3tZU// +VwgEAL6jRhxfrYPCwt9G/yACqtaOAr/kPdlnLE4LJmSd3auOu9ZB6EvMM+pWIAf77ZR3I3BX ++/5sP8Cw9FfVJd78A4uDENYvLx7UVB4wSiSoJtadUk7fVjpFCkaAzudhi0Dwih3KRDh1S0qm +O6AcERxo9h3rzWEm//8GEo0SiumDwMbhiJwEEAECAAYFAlbugmsACgkQ+JSbFGMQkOW5kgP/ +Z36kVW/MDeIPGQBySK9ybqAaFH45zpVQM1PNOnnBmTUlm87UJnv1Y6VfWREWd5fZZDemLkkd +grDRsV8pUPnwYal6LBUQEwG2s4ubg3ne8VPCZiUvdv4sRagMjpILyWha0llblsxTwjK4ZNM0 +wdTVBe6XcoVKAXCAhJJApqFh8sOInAQQAQIABgUCVu6CbwAKCRATdt7ONf0WBsCqA/wOqCI5 +/A/tH/7Bk8KYZ2kNoh0c0m/3mVi3wlxCJj5EQPxd53+AbOoe8HUyizloMh3HFv16NxWJ6bBA +5lW1RAEgy9iqctrdBTdLWoFlH7518Gek7TlQRXgQSb0RdrXd2bGjsgzXy2ZD3xbekWN9+Ef5 +XUjLD3yvLm5vF2SJSoEQEoicBBABAgAGBQJW7oJzAAoJEB7u35GwBOcVFj4EAIglL79zFNXu +L2l8IKOuiqXjZ6/yA9UTXZTYVJPt2V468jjeTj4AhftHsYTmDqrDabAedT7tq3RHS0Cy7vCc +QRbKYIcP7UOLLRInuImEa9//V2/q5/lEK0QmWLm7A0fq42tSVUsC/bRQbLMm5HhL313htJP2 +cu43jy8c9aTkBJlEiJwEEAECAAYFAlbugngACgkQt89HpWw8SXABHAP/bDFZXbdLjrlwAFV6 +Kh87O6PhqjI+YuElc0kwRi56vZeIUl2juvRGjuXxg+zseQMopb6icw11P8nwODNuUYtlyxd3 +kYF2jG4wSNqrmNeJ32WvZFys56kfufDOhIdxL5LP7gyvB2VeUyDkzx9NpvyVAMJ6oWlyd53a +HIQHLycROkWInAQQAQIABgUCVu6CfAAKCRDMq4WNs8sbES62A/9XbeDyJfEl46BOhjhe0KQ7 +ULpD6d7uvfCGUgS+VYILMmS9hzL/2Ck6DLi6JlGU/ZK2rNDRHu/V9zLgUJAFb7Cs0TzDFYVJ +qpx4HKkDh59REjLvbjEMhUaa1TsAikd7zn4ILsej0PbYnM38uKNXCvEuoY5mDiyahfS5bNB0 +3UTV1YicBBABAgAGBQJW7oKAAAoJEPk0Tnum4dAAgVsD/RjPaKtQlXA4HCwC0z2AJJwF5YBh +/gRGP9lj8R4gdgE7wcvVxL4Gb0Ns3ghIoLa5rgh4tfzGX5Ffa7vExT/0rGpkaFgo0MLHdrq4 +IknT7Qf984dQH4YmBGaUDPtBJQfkMt4gBM2LcqCSGHofuoYrqxZ3XF86IKq6DkwePq4EoDQK +iJwEEAECAAYFAlbugoQACgkQh2TDybuFsJx4JwQAkhk56w8GY8aPSVmy4F2uyMAJJabmvYfv +QnDrfaHcwVnbnzR46z7Q1086PGDbmZoWErrLIMhPvOpkK7MUOpkOu27A2ZtcJDO9d/5HYfTJ +A829uU9gk5pjCasnJ/JcEXiziH4CprOLLaEPvqPRPF4v5Mz9GLsy7+ThnA5QcL3pereInAQQ +AQIABgUCVu6CiAAKCRA7SPSKdLGki9JkBACq+XjlmTDlXMYJOHgzuj2UYY39Mvh2ky5X4+g5 +1jUTYu5L0Rj+MlFL3slqJCEBjZOoX7NCWjisrXUppUKNee4isHePQT3dL/Sd8Dy32Xci+qBZ +fxXtS0KDnXyMcfte3DZnpM+UcO2dyZTe1pbWFsrMbuTC5iN0xHnrigT7r4ji7YicBBABAgAG +BQJW7oKMAAoJEAr3JvWmZuVlYcUD/29nxK4LMadAJdrLNAI6IcZ7GUe3Kr2MxbnGm9JO0zx5 +Oalj4CR1WOp3syQYcIY7Y+TFb8snk3ANFmp1OpuujrszQkAzBjBmhA73brrUWaO5GCfPMk7L +krkiLn2J41Tb1PNdMXxNmXhfgj0G4JGnicYKxPvdQ1uKfrPEZGnKwwkUiJwEEAECAAYFAlbu +gpAACgkQSKEv1eG41W7ZMQQAu6/lHHtdRXulIj5y1Zbvur3chG/bGE5dfhp+bDLwSDYHkFxr +3i+za5tD58Oz7ZhVhCCWuJew0TbWnw+voW/clsME6cf3uXotAg0YDfk8u6Awkjqqj1vf5JO2 +tOJxQ8j9msZy4e+BynwAWB7S4UtwRuSgjeGKiJ+UZvEu4KO2NtKInAQQAQIABgUCVu6ClQAK +CRBw755IxWB6VCz1A/4pL5eXPys+4pKoW01LMP6RJUz0tX1RIOsdUT5dJ/CGycu1luZPGkPU +h5wCpGchDSxHZhA1P0/8ZjD9qBv9/UFSClrOvOyUqnntuWsz7bQdBcCFEmUS0rOnl6POrdjA +rMdgCDXp/qwLKJA52wiakLIYgReOjUX1tIzyOb8ELOGNM4icBBABAgAGBQJW7oKZAAoJENdv +YFMb99XYSYQEANeL+8zpvgUyjaFAedSczILECWOOl1Pc9ygY1mnqq9auA0qV/nAfN66lx99g +I6nekNOS3h4hG9HKPBLLMCr51/RFIOSu5PxTvPXZd2cHEtdoP2GIPUpzFWhNk3rql+/8Tegv +T0yxX2fxZI8/hjxgNAUk6dnKIVXu81bmJG3hJGwFiJwEEAECAAYFAlbugp4ACgkQr11JfkDU +k3jPjwP9GXl168ubUI5a6qG8+1Ue2KQEyHtuFrTideLr+p33KMahhiZzYtEdclf2D7msOyEX +WfItbmmmrmf1+W/Tc/RCxH7rs3quBgUecPCq57Jrhp45zHzSLG58vzuxjONyv9tpcmfLxp5P +YctNPMeuNvZ0Ijy4qZXoRB5HZje4VQU/yl2InAQQAQIABgUCVu6CogAKCRAM7wA+sDd3DtC0 +A/4oJJVgrTgSFXZkrO/EBiLlj6T+yyyy5U7xRfHMz48JHUiosCvhzYhfyO+XLLLYBCQRBiG6 +/nDWnW2EM+WpRtEnJ8ucR0kmw31YcH4CKaKiF0kqmKYbqMKpOvrigdkiQ+6l5IQYdbx5QETQ +yiZdev8XzZR2gd9i47K4EoG4BraeM4i8BBABAgAGBQJLBPC9AAoJEO2iHpS1ZXFvMiME/3j9 +EsY4bNaLLTCJX81e4f0suWJbLvQ5hf0IkUHq7RJMuNz94USq3boGDUj92gksL13WgKgYdO7i +HILzWruayk117TETV/MHf5YX75GPU0+sAC7QRDhxyX2CGCoX9rbMJTTc66vbbNpPXSsbuM+J +aIXVSGFyUOzvroy+XgT9l7GLvLn9jG5l4iAkvzp9s/iiN9UEwQIyIws4JHJ3j5c4XESJARwE +EAECAAYFAkxVvGMACgkQsglaV3ge2QmqkAgAjZkfRp6A62xgOjRU0KJIuRPI5XYXyvcxRcWk +If8SeiJHOWn4Ot4Gsoyy9QT1WM3lFx2ohBM2ZF7Plxefb5TccBvP8Oq68wVPgLGQ1lV3PtVj +lgd9hGfdkyYEF8zVPWGhiMdig15JzTesh3SC5bZsnb6ss1Z43nBRiA9m7UdtX6b+wlkz/uyT +TQqAxF/hUPacQ5IV/qgmt3XMvG6ZNp/cxUi+WSslN3SRquo6pnYPAVTC4WRmrnRPfQ5GMTpO +9veHUD+mixScC/RKnJIDHQMp2TH2V7ftzTxUp3RoYXWlSXbLYHD65bARWwES3wMDDmw7f7ya +X+XEvjY+sfsAZhiZPYkBHAQQAQIABgUCTFmpUAAKCRDfYa/+c72KukgIB/9d3uNzNrLVMfm5 +3tOX4nwIZT7EPE9V68+GBNdbk+0BWmJvhVDkzSjo85WcEYpCTNYAGvi/kiRrN1X2Df4b2G92 +XMqHfGk+XM6oev2McX3bdNvRPsehKMw+JtKPQtuPHh0Zb4+ZsOBJiuBh+KqwDmVuUfltIbnC +5lRz+hZu3S9aKP7prK9eQkNy6Wd25EesI5//Vnk8xLQuzHVq4X/CIOTlH1sKzDmJ1RyMjb2a +eQeYM5ErU5dUloUhmLCLkGKq0Y86Rx0FZp0/JiMR65ye857FKEDw8htLPNkFCTEkgz40krqC +q3k84dliVgQwVM/fWbAsyYqPMxqDIKqj/bz84GNBiQEcBBABAgAGBQJM8oUsAAoJEIRo+5CN +RoLoKqQH/iUWdpSxJRtYBr48B/1ZaB125lVI+4JCtYHVu+IiwLelmMd4BZI+UO7TIBbc/8pU +BoTsFwp+y3aLaewGVu8OwO6i3BlRoLvVTuRENllwwBpbMhblDohAP8M0WgExmBxgtfwR04i2 +ynt3CQQg5h1VT2aqKqv6Psb+i1LvNNOJAxz5YzHHqDULrYfEaoDKpPwTeo9vhljQrGe0aPZy +65CAOqLpm+FU0THPc9NgPZu1XIrdSPCs4DpFOebUlz4kJHE9NgzvwGYZXNaWYrR0tHfHbHTO +wS+G1LOVwLKUUuLS+ZtGk4AmsdizxM88DUGX163L08Q7v8seacdJbFDK7/bnHJqJARwEEAEC +AAYFAk8JkUgACgkQUtaZuVylthDnLQf+K286wgm1s87soSyMeF99ZPeGpuzNlvA57chwcsLL +YFeR9+f/eafs+dkaDk/Yvcoi0yYzEeXP5fU8NhANFuQExzOSWz7uSz69D2tUB6HTsQtcyUC7 +YkqlAwNmls/FvPKxPnZUYu0xYi/KTTi0xSbfxhpyuPoOhbDNrcUbkP+V68Tb90OvXTHQp2dQ +lMrkw2RkJubE8zuRVGUYcTOVc9ZqDOOaBP/1iyI2k5/d5kLit+ZAG1z3nHr/NG0euUitFlPd +wgTRRzUpy6H7Ue2OaJ/2QIcZeb5kp5GZtRf8bWuNpu83+LZC27qJN6/UZ647En2Eqg8YVN8F +IsfafEcbtOEn94kBHAQQAQIABgUCVKaEPwAKCRCsRu/m3lALPnskCACeJ9JTtG2ee9H1S9Ao +fHRH+BuPxqYV7BvNGsNcA+UXptsXCmDggVIvMYO9p7TodhLf5b52uD4hDmbCR0/NsSmWIbVl +xADyK/3z4ew+NbvxFzbTBKpbPa8MmThrrlc2VXeegDzObRvLyNRNridjBRMbx8MoVxKOZmaK +ZrC4PYsKXjT3Y85Q/s7fPqjLFQmEQO51ZI4aToMYeAHPjYnplxr5DCdmChexX5V9YtI7SzcP +LM6yy41JUzoEfYtCDgW+c9G+MJ9ewIrTIQdvuBuK8umtuc50vweW1MTnelqjkaMIMeLAwxw0 +1KFIXrESwGpvojd+ZlVf8azelZ/vfIIxPlOTiQEcBBABCAAGBQJLArqwAAoJEPfuYW7gwgz/ +uRgIAKP27QxMDf7xFtSLb8AhHlkTBlhaRmxoXUSYcwQ9yEiYhPPQN10CR3pVHmojcwCXjYHp +yF4O/3Hfy53XJG0VgRX1k5Z9IFB/HCIlCbS7PFU54o4YlcQjlLGB704sU5dcbnIihx2dYxx0 +/l3c8pesuZZHXrlsEUBcDOGGa0QoW8RfRAbTDdcLg8PiQvknkIvsGC8N5qwjerO/HlJjuM7q +CZpwncIVb+gOsES/j39IbJ8OtiFxV0gaa9afc05SNMWoxBEeqvBcYuz+Q+gtwiVfR+YcBhpH +CPVgV5FM+MFOcUeOKNzojvVxq3bqqqk3zJTeaRza7YHi4dPx9+giQEuFhqSJARwEEAEIAAYF +Ala+CMcACgkQnS/NvqY/ls+5eQf8CV1uf8iY5FfDb+c5RtTDGK03XbxqARBfgP4fVQweJ6lY +o6t+d3/adF1oJlHkedF/tapjHCZo3qRYjlmPkspjtxGZBCi7IaxtjHmm5rPWPgybid1Sihdu +Z+BSpLGQZRWVfP56o2Qt8Ws1HHK4t1nXXJpfjdSviw5pduycONcQZVisqKhGWy5rmfo3fLjS +gA369KudQTqCLpu/Uh5oUMsEmz+AgxKgTiKs8IQUs05wJNCE+CvGZdWv4iIaGdgQGGCnjUFX +5v+5IWnyWTNUFdwuzVrK0k7o/n0JB8AUCK463ABllFDplV8fJbiRQJg5R8RbMrUAUUQomrnF +Prk4Q4Q3/IkBHAQQAQoABgUCT1X1wwAKCRBi7MHeRXCjcRrZB/4z13WHedPn0SXjJLHmNCKP +AWgci/dRRwAP6DhiCbkxKM1l6ekDDcxyNCJqxzwKVOkawBlQE5f6+46NwWgDERY20iMAdwys +ZRNwI65oWU2yt1BksZcZGv6Ms767yrIV/88ecqOH68O4Dii6C2/Ru1QSuAU8so0dtEIxMa+d +W4BCS4sHnvDehonWzBDO+N15seuImmcbvXMuyIH/RlsSlYvcRorJKhwpWHcm8+DMHlcLFOWQ +KhNUarZudj+TVLFlJnBXzecpTM5da88G7gozJWl/SVmLNu8WFBCay2Y+miHd/PaFseoPesL0 +tnafHRHpMKc3I6smnkzkE4WXqkJwgcCoiQEcBBABCgAGBQJWKjQMAAoJEHGMBwEAASKCgHIH +/2SpP4K7T2Xxhfp4sItu6KwIQN1yezBIOwNhXthq90CM5Mg4zvCAAeCcYuUo59b4PxjRaW9/ +YP5WmGRiWLwSx/l5Ht5c5vhuGZdbugSTshaCWsh34jiZICTb+Z47juriaheh+vUIippUS57k +GoDvsAdutG6YT40EStD7UfCzVGyRRZWj1dFNH9FeaF19JN97PERyNMwLkmeT3HddZN888Hj1 +K9ZiFGmHPlezTIhNllyPcB0d3taaOXc69SXnBKHW14G0lz7URQ9tKnYVyKgFguHH6jp2H3dM +O5w/2bB9s+Ml9uxHuR3oVl9jRiMH/czfGw6DTax6gRcSRI1TBPBzLZWJARwEEgECAAYFAk06 +ewMACgkQlOkt+SqqXDvCCwf+KlkYKkdOdXNFj0InrZq58ieB13W6y/rA9jLOUcwA7+AbBdHz +nhqgAwLs9IHDaeSQHTiRTD52ZBoqRpGfWuNE9zT2MP7uFwiSOaMp3wSkJ49uobH3NebZcxzk +uO1BGUFH457gBcizEC6Vv4rlv5TutfdlY71e/JNlu3ho2jpGzV9vvn4DsGuALyynmWUZ+KS6 +1JUwozaK7Zkeblj5Jq3DBCf474NREuDAkXgdjkNwxIPFpXJdEv9JkcV8a9TUThC4+boqbN+G +S0oDhSpo/btqv1C85n9cXtS6dMrWczhnEQ2eOszm/9Ih7TLO1tYL9Gy5cySgSdp4LH4ejt6c +BQhLWYkBHAQTAQIABgUCS9mUpwAKCRA9oTItVpfiBCx+CADKJHKHXwSfF3WkghI7PDJvQZJf +SHbVgvmMASnt++Nzw/WvGTak64VcZ89dzBujDy/ohbEydgQdA4gtI0nTTRpows2xMznWVB8j +IzLqw7s+s2wDjzV7J68rju5sasVl+QvPRcUCvcFXMwyqXZPLxRCDLslxpREXdZIIxi1/Rq8q +TlOb4NcKWdyAzV5zRkg/F5r71ioxdV4h6cssJzoFgFsEUEHa+7aMahFE6uh3U0hLd+Gz8cmv +XcGuPQaRS5efd4W7LhNR/2hQBCE9i0/jWe8AnYCFa6u0DIvvRlrCvMVzqGpAJRb4zKXtSkqD +W0U/2UuZ96YQbnYuQJL0fAby/XGsiQEcBBMBAgAGBQJQq3hSAAoJEN1A8liqzgHpEOwH/0Zb +UReXLRFIsSe7Q6wEdK6FZ+FV5gt44+YhiVPUMjX7xoWoj10GKJSURmj1h8WGWiOMwvmDh+gn +ZRkEEIl6aSPRGZ5blCZDMdj6wbvBLPRNII+Ca4bQRLvZxiuSnJ25okoTiafwroRtOJj5pHas +kNyXjJ9yLsHwvA7DIHaYqasUiJJ+DN6Vj7ppNYAzd5nPQaFY0sLJyVq9tV5BorbdZ2lu3lSv +2FP76lugQDTCFKfrcT9mb9w4MlHj78XKPMfniE0cc+pmBK1OfcjrL0Bl80PFS4ekvjsBf6+8 +PMmO3l9yO2kh/4hfaX0oxb8f7teiFKB0wyRaUPQuJ7lGH6dfheGJARwEEwECAAYFAlMzOuIA +CgkQA3Opy3d3Wvny1gf/Z39v1Low6JGD1T1T6AGA0UjufFJ+4zjpCUwbvgPoH9KMOhe5W6Jj +8+GohMUM7FX8pDorSRv/wRIAEbBN/MfbH6vEQuvzhVN1qcE0PXhQS9Y8vOifJp+uDXY8633U +zKfwAxzRIzcnstRGGuv5MdyELFFh7TAlV/sXGOjdrvaNwmzBTESXKn7apZl6Xaqmt08flRXI +MCChLHw0FsBIqb35UJjKNYrI9j/m9GMS20kfdJ/dnEp8ccxG4mmkPS9er3foiwF9n3rhVyQF +GnTRnwBvSECwqEOAtO+A7xKpseWRuTegrf0EH0qwcJ5YIN34KdSRAdv9zlTzhagv7RNLkv2u +XYkBIgQTAQgADAUCVgilPAWDB4YfgAAKCRDOAPZMwrXiqKXkB/sEXsQQ9+cEXg0a8b/6bwPE +EjNu66EBolM7xtutRaLkKyhMUG9KU519s14qoKBuE14xB+OOqka61whANFr5Kx3AFvjOq+cB +tmKzqpU5lM5kSuhftcQDxRj6cZRxneFbmONfINn6N8etKTLSrByoDzjTbBbTLKxPXrnszjaW +1ZxrXgNEAXzxqoz1WozCvj/aLopQXSz3Li3/gKLlTGnvDRJmwdvC9zWB1Pc9LpanHQn4yulm +WV89evRHoqshdbVPNSA3e7PNhsrqrMsakKh+x3gNPNZCI8MLXMPmd/cSIFi1STYzgQn2w+of +BYo/sdwtPCA/9s5TBXTFcn7foYhltjfuiQGcBBABCAAGBQJV9Xf7AAoJECI64FW9lOFUrvEM +AJs2ZLcvEHzcNRTXckbhMLUywh9FR4/LPvKMwleuyOUPnSWf/zlpPPAD0f5e6wXNNhpY3fSA +jLRdV8mkgzACyFDDz3gge43MU6tkoJWNl0bMp1UHRAdTUMLunkPMMzFkzEs4h/hJS09pWExf +FQKM8g+oUsDIVXtsqpEGHeLLC0gSiD2BupBHQil1/J3wK8EfAURiqoMOzvvi0iMWVYVoWmwh +tUbXpeIY+do88v5OY5XnRBAcKV3bczNI0CJc3FwNLixGUuIGH4KXNnQBcqELOvzEotGQ0USU +6uf+o4URyabnN1AX7tWPewFWX69Z+QWhZ4i8GdZP+mBQJTqBnDar88YeKJFGiVLIeW+I/fay +9tetaNzQzx2+epLOxnMsa4dK/qFRi9ByOqQIUJb3SPvLqSuy243beF8GoDCFI4LPC4rrpj/1 +OU7YiJY8EPNdO/kVjRVwhDGddaGsjb239pkJ30pDKZmDTvG4PEB3/rPnPLlzBAaGNGQekPyg +w2LfFV4ac4kCHAQQAQIABgUCSkcUNgAKCRDqKWTx1iilytITD/9RekWH7eSRDTp+8JkaqUhX +W6ZTnPoRUIa1tFx+/XRzEcRI295nB4/qIWLzC1eD0TgDE6a2ArAG2+PiuvoaI1PxYAhK+sgT +7o4eR/FQ8PxtyJX2LYhWih5QNCT2nR8E4aHL+oBFgpIQHmHUxwj4yZ6VyUbci6t4ENXFEVOk +tGwf05k3dW1eyRVwS6sP/6Ruva2Vb7y2XJMyzlYEydnpkXx/j7m6OfoVJhhCTx3S9eYpDrFs +JlJ//TueMMk3CTYU20WZk6xOy+nz0X29CzZV8blvcvQxbxUYDbRStOyUF65Gshs9kKnRml5g +7uWyn7qE7/r0YUtpq3s1ZMagOj/r+TdPBDJDaDICNIdhP8tXWEJuiu4a9Oi+grYM2tw6FdcS +VKW5izThMlCWBU5m5B8+MfpGz+meUgTk1BZb9V60zQtWJRCWc/1TEwd+a4DNyfcoaF2Xn6zk +ZugNAuDyqr4azHwnIXpJMmgbVts0p+86Z6lMh4v2mNpgRXMQWloY9EU8rstfS5hY5UWu5lt2 +QZl5vKCBqfhH/86j8r8SbdE/HfSE3KviPLtNLXxh8s3AuSqxaODkOACQ0f2rWK/1uaciUa0h +85+f7CBfDjNdIPshO5TLxsvXq6kjJ3ZZV5WGnlc42g6/aIQ6wyirHFfI3SX6whFteiV2BLkJ +NSxViEZeBd732IkCHAQQAQIABgUCSkcUNgAKCRDqKWTx1iilytITD/9RekWH7eSRDTp+8Jka +qUhXW6ZTnPoRUIa1tFx+/XRzEcRI295nB4/qIWLzC1eD0TgDE6a2ArAG2+PiuvoaI1PxYAhK ++sgT7o4eR/FQ8PxtyJX2LYhWih5QNCT2nR8E4aHL+oBFgpIQHmHUxwj4yZ6VyUbci6t4ENXF +EVOktGwf05k3dW1eyRVwS6sP/6Ruva2Vb7y2XJMyzlYEydnpkXx/j7m6OfoVJhhCTx3S9eYp +DrFsJlJ//TueMMk3CTYU20WZk6xOy+nz0X29CzZV8blvcvQxbxUYDbRStOyUF65Gshs9kKnR +ml5g7uWyn7qE7/r0YUtpq3s1ZMagOj/r+TdPBDJDaDICNIdhP8tXWEJuiu4a9Oi+grYM2tw6 +FdcSVKW5izThMlCWBU5m5B8+MfpGz+meUgTk1BZb9V60zQtWJRCWc/1TEwd+a4DNyfcoaF2X +n6zkZugNAuDyqr4azHwnIXpJMmgbVts0p+86Z6lMh4v2mNpgRXMQWloY9EU8rstfS5hY5UWu +5lt2QZl5vKCBqfhH/86j8r8SbdE/HfSE3KviPLtNLXxh8s3AuSqxaODkOACQ0f2rWK/1uaci +Ua0h85+f7CBfDjNdIPshO5TLxsvXq6kjJ3ZZV5WGnlc42g6/aIQ6wyirHFfI3SX6//////// +/////////////////4kCHAQQAQIABgUCTEsLiwAKCRC145mfvu5nZLhrD/0efsVP+ZJDuW7j +rhhHcSOIrwPmPAexeqsGtgTm0nJptPbzuK16zMD+kCd5OmM3dcYKvSrC4TB3PJIZCHxqqcsY +9Ju7FePyAo3oMEZhCQXgiNqU/ZHyf7C6RGWIuheg0jFnalvsQ0dqF8ATX31SwpIci5bKqQ1U +kJJQlPEM9jaqDS0yOAab80F0R/6Qb7RcLcFPSHJHK7bFCk45uo+SKemAIlHMQU4QJOY+rX7/ +Sb7yGhBck6yZDDeJur0PT0fxlhBiRnEnzx2f1Jbf05dWJsZn0acPdIkRD0deDGmWVhd0u68W +6BcPiJNzPGPlqAIhogyDGXJV38Mz6p56yNbwPsTq1gbsn3YBRS1NVqbjIDy5M9Da7zWnwP67 +/y9Ldxl+lqCKI/SkEi1XHwXPVl5nwfCHrnJjirXOiK9NkUEv2vDsR9087/F5Vw8sct2IjPnN +Me8bC2SBVSziK5d1GAMAQ5WB8wQHmUZwt78IV7ix20e2AiD3TI+RnoylmaGpv3IbqqKiUD+w +OXDFQJ9NmQlZfhl3bMKtCxwBrZeqshwvTx+Xwae5vxiomAoSV9Od3M3m3Tjh5u9vpAStPnCV +JBmRA5bEGps7r9skct1EhAOaF4LGgZRUwnPW69AeQgPcTZ7Tilg3qDxRUQ8QUb2FA62z27Bg +5YIFR4YZlDodGdpq+u/xy4kCHAQQAQIABgUCTdFhvgAKCRCpQ1B9dsoWBN08D/4iO8SCbKkg +O6+ERECRSAgpaML8NwpIrfHNDL+nByW07pYpoJdj+n/j1joQQRvmYUfRMXzeCeQL/DGVilKN +r8CPk38CjVS77qLliP+0M8nHSc2x9W1uwbKapNoRKaDyK+ZB379cbwyofAntcTp8SBYUf/cb +R6wxpc2JWy1jZ5y+vLwmIF9XBEd+Von0rCQMbyak2Z4SrsGG4DBWHzD3GhOMt39AGBceldG8 +W+Dw7AD7b44JNfSe9jL0Wfi/dBxCDU4c3n/ng25X4vkvA4S9GBrsXRvXuj/nGc8YYXgY6T5R +3l3vArZXiX0etU4pjT5cx4ChSwonWdKbLTzcILG4hDQF5gAgVX2eMvE1qQ8AQOmDkBTXEjQU +QD2DDS2aCQUmD4FGsokCU1F7j1SewDkyWIllbtBgF9gOmn1BB3CBLEJJUNsXuhVBwdEoqbfZ +sByxvd/sejxxV7VI4LcVBkJaGx7DzcF3BtwmznKsuxXFKtOFfI3grh5b47CvN9MvrXqh0Re2 +1nbVQYcjJsZGFBSJKUjfgBljRJL8q33AoaMgCkwux1iJUBR8WjeceWEQQGqM2dnOB7/cDhJt +96+zB5/cYOCvTiloFfG7b97HnMH3HOAkXlyTKntima+mFzRQmZVUMp2RFRXViPO53l4Qa0tW +dLzOaZEI6i/zWFyThvFOQgLiM4kCHAQQAQIABgUCT1dg0gAKCRBtTRi4xGi9EfP4D/wM92Du +eZ51ROMp8hR7jm2eKK6ifNXUvGGaPRq8zkuxfdS9fiFdaISkLRP4ivtxbmtyItTsjsol+C2l +aDzffwBy0vjPjWQtYOHw+bm0togAOF3/IClFm6XvM2TpX/nCyiHnP8ggzMGaa4h8ty1wpHiW ++Z6gchAmcwGvTCsZeGkEaI//cizADMMkFM/j6G1KDw0NlmDcWyHcOAlzkD1aVOeIMdPIouGN +VhYrd2+kZDy057gGD+K1lNaXZaTrbJ1cwZwB1z8u2FHN5US3oquYHS20+FVpyd+1iS47LLX7 +egxw1WJBn3iBHRDwtfjy88TLo10pwg4+D6QYsHf1ipZLzQsn/WrYOGvdZYS4SujZEM5QY/xU +4CfHL8jms0k5qq6MRLP7jZTV+q1GPbk1QvkH3tSK8vaSa9A8Y7srvhTkDuigmFR/oEV1QnJp +NeQWNGwozXKZyPZLoH1GjX2brR28VfOmpiweSLP70G3c0lrPPIzi5N1F2E45Y/FmnpBYgMNT +BqIJGxaCkFCZY7t5ISoFoNWsBCg1q/moP8OsM4x/RCZMm5uDDKmKhutt+T6oN2y2kaeK9wum +gZhLixYsjETX6mDlbNLHBh4lSJXxtRggmexVcE3Fc9Dm2lWxJ6ZyYbEfc337zH6TgibA9PsE +gec30j2c6Dy7B5zUmSVo4v0u+gJIkokCHAQQAQIABgUCUvnztAAKCRDrLkCa8VSKZztrD/9V +SuetNU+2FEvomhnhjR+TfgXBgrP6IYf7cKHKnmy1BmJ3aWHRN1n+oMkUqesxYSJQi3jV9mBp +iR2CncUsk6cQr9/ZgcfCkgd99xK7/Oab1K2tuPj90ypF5WrVdjUqDq3smhu8lK78v3zewWEO +uQpg4M2DS33kh5wv3IFzPcEZxnwX1GGkc/WGz5eSV51TsA+f3xP1k5YJFKxrU4NdU7n+rSzR +tVGKo27pvbUhPniaOBvEtEGoZjbog/dRNc5SPvpFi/jTsVZ0TXxd812BvhFmQ+Ef3ufrsioK +3JbKita+PuEjKsJq94VIP2O25C3W/eWjZpL1CpyfF5KafONjrlYtl5XTGwt6b5sWt0S+vmHt +PIYMYSOxtMkKN2/Kutp04vyYm9S/4Gf5DwohzgkqgEMbSfFhDiViiW2RLfwbzFaol57QXie/ +ezwVu8DOIdKWSKk64PYxG9j8TlkbOFJbM9AA0NmqKDn+g/9wEOFXxG8iYyBvRKPNjQ3xEz/v +0xl4J+8dfAxJM+COpBRf4bs6cXh9Z4jCvTH6uCnauR1Sj+q5F77w4qtI+mK8laMKNyyIdC/d +woKj/jm7IEmwqgLF365Ad7+JzltzsDE09HsfzyE6Qg4yKNxGe2yKtHnu3TRk0J9gBqUn0q3M +eT22g1KT2iXc3UNnjv3LNvgCqrBv/bPmZYkCHAQQAQIABgUCU4R5IgAKCRAsfDFGwaABIZV4 +D/4hrmvPALrnRE9yCP42ey5yiWwl5O7oE8CxvLi69EL8zknWx+9JDdnh07UN7YG9wnP35X1T +5AdgcmdA3hKfc446dT7hdAflTgnXGSrNg+jVKoWKrQPxD94EqnVul1Q9wIiRPSJKfpdVPq54 +NEcwNNQNMdEtQFb8plj+6P7J0mB4IBpoccTAHNCiKc1ksg9JR1d665JRU6sawEoSBoWfpaGl +/G09bSsxt5gz78s2TMmp7R6hPhvzW+/YTttlVhVIMeHKpRF4u9ekKBhNWAFq+OVYEWqWweyB +BPFM+HX4WwC2vqG11R2nNynBXZM4Sgsle0V5PLHGMIscBO+XyHUbiLIqIbrcm4ZUf3yLVqdK +Mt/gAKOHtLQObnUkSmvYTkdeoAqb2mvijn/zuKk+w/fJVJxFTTpYxxIjmZwaBtOsgeE1XkkM +t8o5CDOlVX+P5csLK3LdGb5nAYXlTI0gRLbNRWLxzj+Go/ZS8/Yjvb+r+4RE2VQ83az4DQ7Z +U7v/4sQ7bdtFbIuLMNyLa8KQXivuhThuyz158xko67H6f61HtIBpXITSYn6/HFVDGjQ6w2FL +dJsEi2bsBxuZYjKHums2II2gWQoKJWXEWQiULuEgeJg82Ygqs7oHjwnlH4v0JW8zoDzaZlGz +taFWuJPE+eY9pNDz8yLSy4SbNLoaJ0SbrIBZeokCHAQQAQIABgUCU4nSdQAKCRCtCSAIEaCq +9HzHEAChFm26i965EjvDeKHGTpgOP1uCC/CXEEJBSVafj2DbP03wmHEn9Mg9ONR5n7LR2oLT +Bl9qbeJZLZdVEzXexxsglgo6I3cV41lLV9jhGJFe2y8vEw7uJ9UM43YPouhgecUsnx9eSqJI +CNwaNmu+fIx3ra+q4Z9IXNhazU513wRexzLYRE02SsTl9pjHM4MU2NqNXL3S5EDBWpBOvScz +U9ek+Pi6I9R2hTuAKdzi8Sjx6CtQ6RuGPl7PWb0zybB3Toin07IzQ6QBFnrS8GRB4E0Q1kiw +wnlqgXXuGmDjX/iy9lGEMQrL16XNOvWbtExJl51g9+5WdrDvtpt72f6nsGzpXBOrwz3hWaGS +1SL7sinynLdgGxtgk4RgYJPWbrSegqu5uXddT09N7WcduG56hrbGq4IRAv91rsqPP8PzFIHW +yeiV1vJdwW7vi+gAuIC6fDCoY9KEEPSCTIqUaJgeZvR+JfvMTlmcZ2lBKsJ5Y9T1OuBU8XDd +x1r2rlyO0fXqHVqv+sXOn67CX1gy72gLqUm4FRizi76vyC8zPtgK1x/Z7ToOitnkuUUcroU9 ++n51q2VMhhjnniRQA3yE+QJ/R2pMasA+mJa+Z8E/liNGXnEeKoermxSAxLGzt7I5mwvf+2PK +eCk5C2FOty7YzEDG0Gdv70Pl9krIg8D4ChGjURYhVIkCHAQQAQIABgUCVM6lPAAKCRAtQWid +UZy0ATOuD/9L4OMDGqYLcuAbeVVoGbUZruqMs58p/gPTatT4lzQkbD2fCcgKYs++aR8RP4KV +KBAPMHe5OBZExRsBTDXSfYrIe4ts8NXoemvdohU/5V6ojza8gRbYGUWD0bKV7DUpJAoiDiux +sU7HCM7JKqfnA95ZrSUqdJ17QvqQVoG/HYJAZL/LgoC7n4nwSFS2zPWm45O9kDcLJmBNTQ4n +E0sjZYRDC6JucB7uMd024iaGYCG4cqiBJfIjvXm8f0WeF49Epn351/Ys+vXbaoVvr7G+/QEk +ESqDkh9NA01p/uwWuBnOxNxzNu/Qcs+8Ehq5cwJ9zO4dIOQVFVlKg1qP7LM/Y2ZF8PWEgv46 +i9W9mT1UkaO2NFIPRUHYcHw0RKuLBrT9Kh6JqJ/NQtKeYAKRZllseXAgcaJoh5Qz/fCwF6Zy +pysR6vZgZwBW921cZC4SJU3odaw9/nGI0T2k4vxV10XdzZsmB9hahvd//J1tN5TaCI0LpYsL +hT/Wy2WwbnGFoOL2XFnbMC/apS3n3yQ6Ei4ehMQpFk4O2K1/WB0Fpjt6iYOhjRAKrcP/VpcR +BhWHTwNPyw4imdIzQZTjwQb5P1YI7zGLSrScLiaUbFDj/G/5woorSxQDEJKa9GzfkNIxfq0V +RmK+21adL78QpygjXpwMZkD3tJV3ESaXKEAlJvopGrqfAokCHAQQAQIABgUCVdG4lAAKCRCX +upznYaCWO7AuD/sEoHyMDI1RD1wA0+GWQ1t2sX65XEj8IAtzivc9CTbZkoYJL756LeHWOSnG +fOLQAqs/BYzMHfqcihzEKi7AmrZjt1jPFVD6T7AaeOz3MQ+gPUFPZ6H4b5sfO8utyFPV3dkG +R9VTxwWp5SQdUqeRAS+rgQG5L5KVEprb49OvIH456ngk1D4Aj5utmgthC0CHPhTTdRl7/bJR +6MNlrO1+zp9gxHZ6k29wNG0AuA0ct+NY0e5AgjsD6k0oKKCZoianRO4590rLJDC/TkvUgVKv +FzkUBVZ7P8c9vKL+l90MHzJP2U/lGZ4j+DfpULZ3RQ4pVD2k04kxpDz8VdQP/Vm4tIzxIQGC +9U6Mml+iw3BX6LqgnRMZonKFqVjwjPQODKrp14rju4SzImR/21oyf57sLqgY2H+WGhMbU49A +1akIQU6f0d5ynDL9/7k8KV19fkDnXQSWTxT9guLJ4rJ2IuStkgY2OKxvLGId0fhMy7LaTm6X +JdFhAz7beSkZYNNbqcA2IR8gT0XfSbawqf1Xhmga+hBply6UX1roFm+q34HEk7UYLMrHtH0G +JflCCd/TnkNmSSpIkb1lG5wFEEuS05ViEHK12BrBb3Kt6WmaF/Y7lfHhOVOXgw6SFnH87Leb +71d0uDV2ObngOiKXQRJcgja7ohMg74r+bG7zQVA3KgNUim3kNokCHAQQAQIABgUCVdXFZAAK +CRBe527iAhbSpdzsD/9U2NjhHmMUIEQgQDfQ4lpg9jv/VqOYbHYhIUB9yi0xh7Y9GiF+kQvA +Gl2b92Y73883wH7yPxPam5UgKhPt1bJznj5TsWp406GLXPEEjIiuDa/seKB6eVoKb1owLYFW +5KYnEVoD84fNPBgOEIcRUd342c0lHdFkUrd5prGaVvXWAOqYKVNT0ltilsJAvW43K7P5O+wY +PVAGhOvXYDT6mfA8waKDg+JmhrwH1lKHYDFMCkOrt2Sdvq5AlCVUE690uH4MXVO8tY/DPsur +YbqDZRZ82kbllFdrajVK/D2CEfMFAJu2uBaPVlWBlZ0s9RlIRxJpmUo9Gjmj09EzZBp6OX6o +4GoEdFsi4uUpvQ7aOvgHURIg+qH6zUrULnY8wAKNI+6Jc9foAEg6Dc++kdyW9a3yHbWczMHv +y6wagaiWXfo+k1W1pBuVONaUYBoczu6+/zV3O4+UphSwp/nN4fHBth2roB6DCXdxChTRxgSE +HQIIuvjgb8qO2rurohd5J/xvSFiQmFV8BMAoeMUQSolnkcjgmtD1sc2jIF1gZo6C0zTJXgjg +AoulQz/Q5m8ozlwgwDqf66FvzJQM+X04VcuJxplGvpN/sYp1+Emin9MuJGMCYduNAH1hj4gJ +3S+Po2Sq8BQpxUbIbOu7mCrQ6akAWS0atwF5+KPmCs8Ux1XguJeCUIkCHAQQAQIABgUCVddJ +IQAKCRDZrRS5UTtR5CI1EACzlx1UuoDQZJS+NElb2ELBbey2UjyDS6n/eKXTufADKerViEum +3M0gU34dQYylvOhbPXogaiH2QK1B18cgSMGKbqVk91tqakABQST5LvZp0HsIApXhiWHydjkI +O5xbm7FpaaSWHcXp5SkbsJMAFxf/RMg5963xTIsXFOLKBknuTnxFtkLonmFrcrQseDXcaShC +uk+tDMLBiTRWPZ/4O71AXgZVS5+loKQK6M/owUM6uo++Xo9mRkiRD25SYVNMQc7pMdP0LQIj +anlgnMKU3V/tLw3mnxgzMdlZw3tnET66Scll83acGp5PHO6nMozsCl+O3L6sDt8vTWg3j7RX +NIr9ffCELviSW5AyN16+UnmdnAkyYu/OimUfDzAKseuoL4/rnUi1XZ5cv5nN+DlBGAcPUpmj +OkhIgNnTdK+unCQae33vapa541zUTrVcDcBszlKEj7EpcwcG5zLQrLT60qlyGzYeO0qPzjU3 +N6U3KRY7NOsm/LFIMy60tuKPqb8bOmqMYeH2R223cL6uOFJLANzocfl5lmoHcrT77cSEF6/G +Qs3UXy0W0m2GgA5EIfAkpdn/NvsIghDXwrc/Ldh95UlTdYcuhKnwXRw+Ix+PokFVim6zYY3W +3xFn7lEjVVmWsMQ+0dSVsC0pLH4RVdeXed13GGVQW36Gyfp99CzI1bSPq4kCHAQQAQIABgUC +VdsBEwAKCRDX00AuAQZjDKxzEAC1lE/LgUxNpEEMJa3xgmiPjfTxuK/aQPa0HkGXmIqVPYhS +ZqjhrL/fJGdhKl/gUWCUOPvpAiWki9TyltDnG5CJDSEFnpAlsngFQlEu+Bc0ttf/VMDx/GQe +HyZcLBJrIYuSSvb8toDN+9GkHllA1ud4KN4Oov1m7GBDeJou9X29DC2JuH1vYCkODv89F1tu +c1AlLqZQHhc34PXf8yuhjDhkDHHSVisOj9AjNYbVITw7OsQL8Ao3mu2TdzFcLLKVMDlqt5Hi +9/cWfanu9kdWB88mtLVFIwflBa7OI+0ve86w4vhGfLM4HcErFpE+f9hN706+RWYdoRv2pg7w +s0KyJAUyAtjfz3XftXwBVrXfwyV46thBrFxQJdMJCQXSOPzULyWDyXqULBnqjCYlohx+/yEA +2k3RocWJmGMj2KcbfOLP/WEL0EsNRERhGWzUyeGcAakOriv1pVNzgFG3XJ9biQFHhH+yfjn+ +20jmDjRAdTadV4A4My0+OAFkCy3R7iuEFGH/GUXm5NT2+TFLkuV8Q/O+fQqsZtn9FXYczX+C +YScQkBMsQo7Hm+pChh6sdmLHugRxPgCP2Vo0ISaPRnbZ6U+PHJL3Qa4ZaSrQ60sv/1XJxG/S +FbU2XcIobAbhNgXLM2ysY2BMtingQPRp/IK1IRBQT9Q2M7huRJZPV5UsPNY204kCHAQQAQIA +BgUCVeNh0wAKCRCD5+pmmhnLlJrcD/9NcfvTRSdSnsMciwucS/vg1qjXJu5fPd6dgBqYQu7X +HBkGsF30dmo5xYdZ/BTmhkzV4sepXnzUX88GFxtkXH5q8f3vMd+98Yb5Tw3KpynjrdnzCaAf +n4pZcsorN5ry3xWUiV7zDRuBV9gB/pJCVJUihz6zYjsU/5Wbug3q88doSQp6nVYs/FwG3GHH +oIzXGHRptNAtZK+ydQsD3bd+7mcp+4nElMnKBLRIBw8dnVpHQ8akTVsDL6NDXAFxDnxonggL +CX73GL15skBwn/uONpmdvUnyAywVZjcklzqEWAT5jH5364QThZNXfJFIZHFBuQi+13yLyEKR +6CdnppCsTTrcD9IvfZpCzfmbDsFlXpcEKDPxFXX14M4aHuIJMrBhjou0G2UMsRIjAnNR94Wn +KCdws2x1hifEmcdHmwFf8vEewCJR1m5Xnb4wbBFVgphHHfycWjpHm9+HsYVk+DwWxIkCD0s2 +lbuqpxjbmv0cfeQVWE1jvP84LnhJ5IenY73m2JisZtjWUrZJ8n2bZVE3KTx/MfQq+x93Fgui +PMvuRqPbDFmjQ4Pvz/ckQi6vIZr30lOsK/voJXAheS8BcFOikI9noFIbrodJQbKMRjePEx2g +bpE37wc5kLwZcGTcgwld7lyLmMy5lXIjfjfZ8Ky72AmyaEpW6CND6HHa9Z2CMEVCGYkCHAQQ +AQgABgUCUR/XRgAKCRCX0FAD2nMaFy1nEACGA/0DW5Cnxbj6XVbIk0JveiPbAb4Q0PQ0W/kC +/CscffZARHO1U5I3tZ/Y/tvAuDE1XiwleJk/QF8EeB2TmsdZXgMadm9e24xpn8otuQxos25n +2nHJh+QvH/K6/oNZMBQc3C/xc2vwDB/DJ5dDHUA6ehvwFwhHmXlYrig40KBCqpG0gInBihDh +sUHeciaaq3ynW9/xl/XcpH0FEke+rgrdxSJasoPxHT/JzT+VgmOuoLiXUEEeOmafxgpkA3Lx +bYgO6td4zxK8gM8fcOh6PtqCuw3dS/ZLTbOjS8CWu2GiOqGhHyvL9C/iWhn2h7dGJFGrBcVr +clNU5U6a0/C7T+0/J6c0RNo4U2gWyfc5l0st1lyZx/qkGemL2d07AXHaWSCP32lPK4AQ83KO +UjKSNc6zAUNqbCErg63gGyjtIPPifPI1wq7w7s4fvaZuuDLmWsr+vp3VJJsRy3yHcWfc42Ch +H4+4A4mSjc+dGkrjO2Gp+RojnaRh/3sNrD3v0uxN2Tjgka3P6fX+z8jCKGXQMfL91R2GmB1F +yGNT4O0/B/oo1KSaLH6zrOqYzrJj0saxthKgHyIGb0KBWf/N3h6hHZAyK05G6FfNYQuSC6jj +5+PrtlAk6L26mH+FLI0F822Zx/hRD0n1kaHR7ozH1GV21OMNAG2KTPIOuk7OilVQPAFFGokC +HAQQAQgABgUCUiwqEQAKCRAWKB8uAHyY0UTnD/4paGvYIRJ9B3w6tZl+MFwVi6xVVpmmKJde +GySqpCr1ZLGVYexRlLiCCtAxNpJjThSItZTXmNuPNgU1iZxddAR/qdtZwarMpR0vtBuBjr/H +81bBntiwn9qoDTj4OtjKXqZr+4nFsWkXfBv1Yq8nime6e+oElriQgPC1ZA/1K9LZ2X3ATEkh +rahyR17JzGWDscSwX5sWuwZ7S4LzMouBwOMDB/w/ciM/ZXr1G00U49/ohjxbClKMmsY2TsKA +0MNy3jpIaF1b76R8hVJ6PKTgtdShJKJ88rFgp2bX95V8BVKmIngdFkomC5vOeJ3ngzAZspk+ +vkvV19bCTaYR550rVVSvv8O3TuCeP4k6qyPs45nwECU8mHQRBiBArLucrNOAgiFdsmC4w79p +ibSbgnC9M6pSxY/23kb2vb4IAT+vGaBhvA7m2lZDoGezz5Bx2BT4ELDq5pv87Glw1+Mn9Dpx +pB7vU/yA8gkr+/B5IXP4l4JdPZ0oTPKsAX+cYQ245ChLTO6ts+TngYmnatn0P3D1v1c2WzZt +f4TxL6H+ui3M6qY2InT63zQCuv/16/kt8hmfiEvPu6LJr8lp8ZvuVfjYhAefvZOfLK8Z2KmT +gtjQOY+uVOB1O6nhUbgk+nemcKu+MqJCB7PNMsOqpdRqzcOsmUPOlov02vfG8PfAcIZnxI4N +24kCHAQQAQgABgUCUu/fvAAKCRALf4tg4+36431hD/9W2OF1WUmWtKb5lQhEuQq2X1h4p/6J +0PxP1nusvcpKlSk6j/n+yrcjM/jAb4ESxRbWa2Gb2jka0geR4IcZ2Gxw0Lo55qU6T5PhCaM4 +R/xpZSXtOITD2KZ3IB3l/mNeA9t/gLZiprWtGY4wNBK8rI2A7NAxwVJP0wB7KCG8MmMi3Gy9 +QQ9oFmyUQ4/hgFWWGILucEjH82yfVlFukIuxtGqS3K04XMoPMjsOJeNBJaKjguG/dFeZ6Jp0 +OS3sojj1wUxc3e8ssPKEy9/UIc9XYm6wC8+yZjyBy/AzXVnHtoReCvgwcke3p1ZgtgSb/zpu +IxbMadM6ZME2du6802HUJUDS3KdCsq/FlbJPCjt/GIdJ5MHWPg9iV4nxVh5/KWhvSzokJWAt +Q1ecBL2iFh2CqplGGzIkhLZ6RmPLbbgJM+tJDSNg6SSy36lnML4ZUxQPtbe0jDikP6FI6zRG +PReA4fy5E45DnygqZFFjJQeTtLUP55doe3n+iI6+ixzFrmGoM+3m1M8yobU7toQungUKngyo +bT3DCy1SYdVvsQF0jSUpXnEBmdeFcjk64gO7bFyC7De6l8xk6kMMs/++tglR3y/9A699WqUx +WxTJbIIhSK6T8TsyPkfn7ffyIVO0k37gtEJoZfRiJS3RwjYIVQagm+5DTtqbuKLMYcKZ2CXj +d5ayPIkCHAQQAQgABgUCUwONcQAKCRALf4tg4+3646KjEAChWyxRFoXf3M6B+AvHaYSVluHv +AnMKwYxumTx6OtkCExGVc2HgRs7+29uGV9uJbfQI1AuBQ1ves4ZGRgqrHeH12NAK1zkjaG/4 +WYLdJJ1dSflgxvz4BTFRTg8/+pcEQIH796IKP0z5jyeY3TicF1MHKvuy2nCO8iTuW1cNa4/q +GSYheAcYVDbGRvosehmu6v8EcWK89eVk0MHGAkkrDfIcYYWZoNKYDKxgXSFXL8hBxJJ5H81r +ay+itWl3RZExXH1SSR1klKQiPlkJISYZsBFkraoyQiwKu2rl/BT+rvOcGMtFoA5C5jkhNDx4 +sBu4nemJy5UkNoG68+Z//cpc0q/gYsWRjkQFAb+wgbjJQl3Mc6JRb0S4ohCze+ryRSR02k2B +hJQg9xi7+cKXC8r+UGlvNVVkDpvH2EkHzLXg4LCmohcvGVYF9dzaQK2StbmBUmisZ4hVTqXb +B7N9ONA/rwHVLtYTMIPRq/O1ldTyX2GD2cAdn336/F0ILyJdZLKWM/VRrWtwOoZn1Go/IGtU +lSMSqE3+H4hGxoxW5zh913RO9VWtpq+1Jr0f8yE9nCeQteJhFZprLP+sG54vsV6iHqVEvW5m +C3UEIukyn/xg/+SuWwBp98NcnP2Zt9bZoIsgIyjuqlLY7t/P1OQubzTv6wNH9RibXJlWH0Zc +q1gQjKxbdYkCHAQQAQgABgUCVRBQwAAKCRDH41fLNV7r/ZkQEACoLM1D31VwOCXzRWR8kgYR +3SvaHtL7BCKTY1d7i9ObuguF+fKqk/gM5CQw0jflDEW+ablVarC4da0CTZot/pDHsAkTTnaI +KuwI/SkH8EuqcPnQttx7MwddMlW9lIgRVnirGGLoRfL69twWyFkH/aw6wjTL1ZEdAszqhTnJ +2jlcxJJczXYQhosahKR4o1tF3LjxnD2CrzTQSAaUu/2FswiH5J63Wsq0b1Eo02J2bPAUbq4j +p1OcH7BH9Y2U7YIVeT/kHnDA3CB1lnyUg1o+j8lDXelNKtlGVIQrxjzIHg8XA/Bknw1JQ5aA +wdr7PFbUgdIdA7CznH6NfXDW/QapA8X0abDgN0XfSOQjzM4i5YXPanh+BYUZHwDxqE2NQ7o4 +n9jcRz3MvnOXLv3ULIJJpE97Y9O/iNv5Nl13HoeaHrTyo3kZKI83AIvndHkT0OWlSyppBiR0 +IY5UwmvRLy4nkarnxO1x49BVrnOnwHu7ytDUKCS+s1QxMp9AlqiIqhMcEYWINy5gbQJcYm/s +Kp3mmN72y0alZRaNq1Wy93pIClj29v9kx8/T9WpFIYwbQejVAr9qyUvO0jBmSdeTZfqCqBqy +Y7qQX7ZGj2eHJ4XAsXn43/NMBqbLerWePCXPaOKjHXyZH0utErN81v0ekk01f/JDlE3I68LH +SSDhGZQIKzh2G4kCHAQQAQgABgUCVdM2NwAKCRCcMVA8bYZjlibmEACOQZ7L9SdJ3BOennt8 +mTxCG5UiijEcmS1fMKrTQdHPAUULq4WzP2ga4VOvkoy+LwTLqyP2Cdv3+dFcrNA2MhI8ZaCn +GfVMOoqQlmELiOyA+l5sE4elbx7ShYUt9ayLQPXCJweox/7x+7gM++/vKJs3qe9P8Nk2kGy+ +bH1zo5/4gK6YSmASlZGu51eZCQO+aY+XqSmA2ourbsSVzdRtI9BH5uQvf1lGMbUyEY+W/qmy +k07HNvbn8geJYQ26TJwi6O03PPsGu18UkGCYEZODT9QUqbj7/QwDLAezKqmowfMWq2qMfhNe +M8qJQi2f2y7OqGOmcBTNuNYxH/UmBfC+TIvNi5TQIEn9IP+x/EPGROqDXIros1/KDbOyYqVx +QzuAc3UONUeqisMuAOSFkatYXcf1w20Nkss3gHdaTG8OkTxPIzfJlVl+JlS3gqyl5DybjSS5 +eWbMIO9Cbbn4slooQ4X+d9k3GfAy9/T5C6ZsykK5JB6VClZYhcaM3WdSbGJEfisvLsj4WjFE +j/4vZNTx67YtxNx11xyA4K5rxELPSJQy3VweBjI2PhAsHHfI8pyauuWetQQ+wbs3l1UPar++ +rkYZmAeh/qtyaQfqashYAK6Q0th5i7qVl8FG1Y0pIrEsQ+qtKd0pyDiJNe6x5wBBUp446T07 +pJMwlYH408uaJrgLQ4kCHAQQAQgABgUCVdSroQAKCRBMWmurEtKnrru6EAC3Y0NPNOcjW9PG +ebjoDUftNEFFxtbB8rsL20nLFpbEEDfUJbwQDwc2ghyKfeE1Jjr2dOzYJ2s36DT6I/MtZYPJ +Mb/y+tsw2WpVLBAMxrQbuX8RU7U1ZEoZqlYqCSSHbAYMw03lTa9LL2zs9l/sO0qfs2L23P0h +WqIkbGUeEcJoBqxlsiFNBHQk5UihwpJ+9R4rNhtFPsj4IkVtZZJrL6mD3rqI2joYJcRfGGg5 +99ZKLsmCjtEZNz2cAkzPfO+FT7MXSqAZ7eeewsKIk557KjMVB6E4MpY559SoXOXbWIkEU3jE +IN7yPgweLFHfGYdUFIisiTuC+91piHVi8yb08ImvWuvOFsFKQ5hpnYhioUYju78+2XuS9JUl +fydbRGEV+Hg7RUXGoqT1OTzrMfu4WjBPYNM1NqpNR01Ow3yhvUDfUD/QFru7KS54OAIVNPN7 +VwlVUHs3qUMJFXv6lRxVJ6KMFQnPma896EVX4rNTdlTuByhcCMQRuTzzF/Zvng0PvB1zNOV9 +s7G/jsk7/uZ9M5eSKC6xgciyZr62MCa342E3G1Io1jvSXPl1//yb48iIyKWszRVvGVCafBiI +mMFaWepSetw5RXhACOLXDuVWxUJj2nKrQBpa5dMCtR9S0nP5PSSEwARkOpdBgPhMug8STgWP +VPi6dEjfXbdj/1WCGcPRzokCHAQQAQgABgUCVd4VIAAKCRBpdA5cs1/sPBzbEACMOi9GUACe +Tg+8Gm1lp040Hfdw9nD7AyNl0Wj/TGt12UZfDyW38D85uzj7HT4ieAFmK05XJS31LAY7HEEx +iGNrNEd1q2izvjHCTkkNIFrjnyXOOwQ0oih2K/bKW+qALqLUXxpNWEFWVc/SIJoG2VcVLl7i +ub+p8AG9jfDsALHJe8wO6S2aUFRcQn52HIZ6GIhKQ/VlDlKHpqLfAli0k2g9kpkbuEdw2Bxl +lGcGPfxUpnvLYSLqsAlsDBG4iGgr50LaBozRb47fVvJDZrPgAfMEh0Ga0PS+ddiITyHoLOTF +PZLsutGOZOyQJp2Z9oGpmNsoJQAl4KKIJea4gZng2K6Xq/bYbXIZjHUOtxXkHr8AlzASFnuT +o6PwLjhLfs/X0d+AoL0n9U5W7RL/zn/eGJeB7v1GcXnmXQT5RhUfqSfOv2+RvH2k8lLDnfLV +jrTL2RSKFaNhp+9ZbfdPiLBmLIgWV66hlXOp70wK5jGXpYwZQ9f8hkf8pljjx1UK+oFGrnVa +D0VwgTMkBfaM7Ah1iqtyQsqr/2MICSZ4Jgcr8G6LBRL2j5eTSP8JNMlSDFlFceN0xbz7Uxab +y1XCACswbcgy+OKyiH2RVO2UsiHr3mRNUyPVdhi2iq1rHhPGEGVIpAYC8xzBLDzUS8z4H6wA +KiPLeJHkN+Ctuf8N4PYzwGzCF4kCHAQQAQgABgUCVfV4ZAAKCRBwpt0V29qsViH6EACgT5+A +F5MXsKx5hVFxoGLb/UJ7u08KIKfbbQvr8lcWDhw3uxk91RxFjaZ/fSiVX2xIo9Vwc0BCD25p +GtFZKcs1rHadiWSMoNYXc5E0JLF7pVrQmlzxR5v11a+I6JWXc1MwgAJtpj44c7Ws9MPkMFnw +jdr5aL/kLxbdpDTG1vRpqfmo098RcpbXaPZRQMOccPP/GdC7mdjJjLVZf5DZVkfyZQqaBu8j +PRceNa/omXJnIqawo/rW1NnSCms11211Mpny21Wd4dG29oJ5u26xUZD3WRSO4S+iocFjLxw4 +2IBMzVCIrDvGb2P3WVzYYdzopkdr68VaqK5kq2W78XidFzHb/FnFc2AridAn1j6AA/UP6OvS +pCnypj406gq52WGjqw1ofSmbZuqMG2jEGoJOuSFJufFhOPgjkxKhKbMOqxKi8aqNFMuzjz/a +CiYEkSnInEN0ySFuSsku7+nfJJB2CXEySrkyXXRv3EstARkz6Htb6srAdb2mWTp+VGuk4F6q +VTVwn7MF7XB2jWQakxiJphdaSP9B510KVPR1c9RkEe05iZsxlDoEeuGVNZfZrcdpc1PxrjUv +Hd1U47YcW44o6+xuzQPoKsG00xZLpOLnmzjz5g2KVI2RqWOjiictVrMxvZuVEinnT0se4hA3 +flB/wSQOI3AXCoY80Nj205/a/JNab4kCHAQQAQgABgUCVl61awAKCRAHosw+fMNsLx75D/wJ +L4ZBDbioyMsrbcNq0eRnj+rNT7C+eTXUuc1qr+wcHUZk0t3IANJ1acwkBAg9IrL6dfvBSA/X +lgK0GqsCIZqCgva3cO1UfZT04m1g+B1Gl0xhmOSnQDJCC+QBkMuctykxeclNhD7lAYapY9wZ +9x4sccgpIm9hPo1MSprWYgfwEZrEqdDFSu7EaUTTIP0nqqG4cFFDlXA2iTsHBMf4Bj6rGvJV +pXH4zl28g/YQ9cJy9+x1RXmOA4vNWU5Fq6DmoB+UOdynDY8KLuSzGWkW6ygStJUHtswGmvCq +75I2syAG0Jdl3Js9jjpu/pR4TU/cksiZcjp2xWwgcnhvlaRt+UDJoz/g/6f3INksemf/SRXT +qC+Y5GVvzZbTP64V44m1kkOK0UuXdqBwvO3AeMlUMle90YHxSHfeMSrSbv89aqO7GgJQF3Lv +DLGIG2Im8/8gqoTpkH5285jWuaJHPibn745EAu1m/9P97MIq7XY/uChsJsx4vWCrsYTjuJ/p +1sChSDgd29UhyNhPUIu8GKFCsYAvBVeVRGqzC17FF6SLXBW4NM92JmRa6ZxOS971xyPDTDSu +0R6XTVDPG4KI4cw3z85r4AogsnDqR9N7HF/ykOgKh7g8rlbhS7J+AEqBakymUt59jsVQJZnR +ugvqLuFd6EcHMH12mjw2X5KP0AAGCDw7+IkCHAQQAQgABgUCVl62rQAKCRDp124/50oLDG7C +EACHYhjurLP9GDYmnWHe2qbG6M2iWYyQ4oQtG6WHmSiJP7oKa4atX2CQ/yp/CnNOsfdMX+0U +tfiTBSQ5rwp5z/oh4CtmazLvIQaqUxhNc3JrnQfFi57rPHYsm4VGhgNeKubWj96vaZW0ELQg +up99vYe0PiTRnD8BxomHAO7WR47avtqO7f8BcM2dNZeTqF+WYnnsEWvq9MSn8n0rqtNBLIt4 +5Fnseu6yq3l5lhl840J4YtzYp1sIzjq3VBXOuA5PJfuQ6052psFBYRk3Ahbb0KZJ6mN6Ylip +CNksadJAVhTZzhjn90dOmgHLJKtKEoBuWVUsx1zXqGnXphzF86Vj6iJXIkEVJin1ZLrm4y0c +BaGSLdmp9x7C7W820ZeI5WW1j/gdGWlJxZrh63Zziz35DxMYVYzAEb3bQZjVHORg+CABijh8 +XydCv2X0iBgI8ty4uVqb0WnXLCl+cKNbYhBUkRpbtHLkWKtbARDa0A4l8vvif+BseyROmkrc ++Idnh1Tf+MRZeH33WDRpPhBBl0BhNUUJNNa3dyPWmtMFitf/P2asVxHjyE0A3HcUZAkCEpgn +X5C9Xdl+hrpd8fx7tKEHw4FhcRcYCs3fT5hbDlWcvMLx2X5MfEM2+RLMwQerQTfsY2gFPNzZ +nlzWd7aAyj/qSjgWvC+poo6OQ13bgsJeqjDL6YkCHAQQAQgABgUCVoa1aAAKCRBqOhCzHBCV +F/ODD/0Zo4C4xg8O6V0+NyGmpSsBHOqByOQ2eJgIQhBBt0zIyGIT/deSSFN4qPQukb7tmUow +z2z/qygkex/Z/10rOiUVvrdjJhgTT9K6JbfhoqPKYOtAYdkN7/BqFt1knCu5Za+8KNX6IIjm +MBLLFoNyy4/wFy/XWEGgT4ZuS9eqC3RBl9ZOghWbDZR8sKX1fVk7nUDz6zZCN1U7023p7Pnq +5ZgvD9Vd2vkL4It1MTfo4f65C0X9nsupr6/FML5gQzFhh7oIQ8pg/NFsBOb8TNtX3I2+hqqJ +3Rzo1vQn+wnr7Iuc0W0EwYnBdAEpwwFnNnerghYd1o8Ylj6+nVoBj6vQMrF+XIxtyYrwF27w +xscrVac4wcEAUGnxsqWYF6vqecWq99v4IH00Ok8HyUv0UcyHAYOxA6JxPEVzSzNZBclxsLdT +QXoN6daWtan/FZrGSz7wI4C2iEyDRA54NdaxwHG2B1zeo2Ag8CAOYTfD+I02waDxkfWO+F7A ++3EUW5tbnlA3Z8TW1Bry6MBJHsCBfgIQOttXwS9KFddyD+fnCVo2L0vqOPb+VBE19nHEoswO +KkXHXI6jOKczZkPY+5+/y1WhdhiMZ1tm95OhzOOr8D6jdnn73Vi33kEiEZKlAjXAI6kFkdG2 +XG5B4m5KGO9voNkLuXy9nwSh2SxMPJCfwaaoxbTYBIkCHAQQAQgABgUCV7h6sAAKCRBwCf/n +w7HM0zEZEACZ6iwMHyEJdvZY/OX4X5W+aADJokiB3VKHl081/5Ws4H4s3dKLi31pc3G9I0DR +l+ae70wRm8FHj3tJ44e2iW4CdCbO7PHVLkWfqFvQGCE4mbFHnB53PC4zQt0cwuMuKvHBEwbb +DwitormCTwSgoKm9x5wHkWfBIUOydlKYD9MKNcQmEYtUVhP7qwkPmSfjwdLIz38KHwz63NS8 +ctsgY+wdGGW1MEK8pg2piflMnsX9xGIk2ggp94hMDhLQp9Rk4yNMMFyIvlljP4HqWShNCajB +xSZ0fmKemhXfdHf2i2VV6LOJs59Nj2jy0yzyMOEChXkZSOtgfyRP65Gzhv40m3yo6vfn4sqk +c9UfHXJlSizy8DFXl2u/l0qP4ZimIftSo/2tgEh4LfOaPaLywHeqJmOCkd8y2rClEwb/VZ73 +EmU4Dzg9hrCdH5/e6iSoNLnFaV1Sah/bSyX7iCIEKdslUNGwHpnIAhue6Y8lMUDh9cNmp3yQ +gXW4vc4jDod2WriBhEOI36nPn3Mr58BjM+wRIHRvMQuhdi+Vd52Sav2xf/D8yZf0kJhbKAav +WBN/rE9DbZwcZL2CrHARb+lGptzikS/MzsiI2APBlYhp/vWJa8S4Y9DeWPZiXXvXA+kdoBRx +vw6wvPIq2T5VCnQNZBKvsQZkj+bhh5EzYdbm5JQxJ+JWcIkCHAQQAQoABgUCVTU/NAAKCRAV +P+OYghyDlOVJD/0Re5YXxeJfSq2BA8cApy7bZtn751t9lgEFktZWL0+FxrDIwAdabs59T9ia +QDvG90Oj77peINq2T4ISysmN6AITLmeBRSjtyQ9SbhruyccYs5mJBL8dQnjGYokOw4XWRrDZ +x8EssiXOJdWKvTCC7Ru7lbS3Y2Smt4eSI0zgwYax7GthKiXWmTsqWVCcMZ7Y4H0oQA+jCPVQ +rB76w+qh81xExm/S/7Sw5dOr2HsQMZ5ra+5idMoKuBPFL+RbCD1hWXu07cyfh1NQcHorGwhL +UsoDzkQK/6AC3rblQ/HAwFAPBlDXKob7L10y4uoQwOkWZcXKYKfogFjyLmy9htKLmAqVxyQU +fRR9ccbxD/+DmCI+k53DbstL5qOT1/rvspnSrvA26+e2J+x21DDWoHGh+jsB4YTSRdNkYEnS +5T4PjzmaEHj2e84PhbORnZ654uKZS3/OoKwJsIYIZayfLD7RJsibskmSnEKrCif1u5lVjwv3 +KtW9E2BBW8X/5yW2sfaiznTTEBeORKWsPbRWGeLFRkAWwCAwknxDcrUkLKreg5heI9JBF5zH +lxgjj0k9kyfW1Znl8PKNLjO1EaND7SZvy79uYyb1Fo5nQGGcLv8wZqzM30So2IDz+UCF2aP1 +HbKwyMFFoaZ+CYr5qKpL5YFj7GM2cixGhIyx2Kg24t6FLUUvuYkCHAQQAQoABgUCVTYgOgAK +CRCSxqeLGk+IMxI/D/45LnUPSu9coo0/i4WseWfoQ+jgsJpsA4ekIvn0nrpjRTNYohuIyaVT +gJx2TczI1Pfm7hLOYn8Zf9Ri2KjQAyCSP3dGNIn88heOZzIeUDKMh/F0td96DlsfOpp/hW9+ +6y7+wEl7iL+/5ksW6i4Fyzhl+q/mTa0OQHY9MBgddogfwvuRSLHcqc/m1jee4Sm81FKOBMfU +3BajtGVOwfVlPtgpkT/bpxRm4EVenKNJU5Vy9j/R0whMAf5YQQceUkv6o9fb2lb04o5A/VEZ +ZlgeSHeNh50BaIpUSF1yUcunXwrWE11CFszfBWBFWQoOYOkntv9sP/SJtdF3qCyLRRYBouSw +K81IoPt/w1jqpKToeG7tyxnyi27tA0uhjU/J5a/CEENk19TgnTRAnJm2l1eBQ9m3imFNVcWw +voMsHI3eFvHi/YPoomAIgDkCKX/5cLy/kXkHDlXdNsVltLMEYx7Nx05X2y2C08sGCUkXU637 +dqF6HxU5hSEGNNn1vFFzNmW4rTD7Oo7oFGpMhP66aUsnKzit3xFYA5MkGV17ZZd0gVTA/gZ/ +TpuTR5jyEK7yFUekBgQVr5YFBMYfv4CoXNvED/4+0k5CFzbJdH9vB31NCqFOqkIMalWfPzR/ +WC/SfJJS2UDgyJmeL3w8T653z0Z5a8J3JEsjchGpOlWlFt7J3ndL4IkCHAQQAQoABgUCVdiL +rQAKCRCArXNzQnW9r7nnD/9JG+K1CKkCMtLHgwkVl0n76LrmA8OtI+IrOPCqC4TueHi9tArH +V2bRHDmwqFQvolMNJVELTJG1iREAuVOeXZ/0P0g0+Y4HVkghdBKl0bXkreLpjsH9TLJVg6ag +Us9FZP3l/bw+vyrwFGS/MIzmIkgz0BJ9iguy1qIhBkxc8ZnxUlp4BN5J6LWxHr0gq9d8C9aB +3nueJh1vOeMcPUHks6toRBM6WcNlefKa8kKTzSkss76vEXVBec5IGzB5Y8xKZzA1EmQM8LAT +9iS4MQ+5xjP7+VcLbRX0qfD9hfyMR4XLaf1zGEvD2Bopu1ddbV4lt5D8c2jFiWw2Z5Fk400E +uuYHzH1xLunAwfYki7RNareFXScc09ar//1eFRngCQlUMe3ZCINWuHRYSDBOSlx9+ybcWgUL +/0BjcnMcn/9fK+Sk9l7Bh4IGw4PXqRA4Cxmakjz9RoS/9Xf9QSPmhs3thac/MwPcmMjz2CIV +YO54U8upZyI77wSjEGlkJIRga8uIuHHNWc3kN33dAxZ8RhPhiGSR+oKvSbjeVijQh/35WCAw +p2dz5zvHNAFUHhWAI+tXWvwMgVcx2yh9I8MdgpuQdbMXyErb9AYhB99rOtLq7/O1LVzkrVwF +WP/6KrtSY92/GjVuLNLUoFTGeSUJUvjm1WPsfuFISDKeKMCzVaoriqgg9YkCHAQQAQoABgUC +VeC9HwAKCRBgrkLsSTlzjXyjEACHaPOUXV5QBG7l9vxNOo9aSNKSok8w6c0Vzar5qboJTkCB +K5ID7806ulAONIvBb7PUWqCF3q9n6rFCgOTSwI16ZYmN4oRnIurcVz4eYtFHgtanpP06bNWN +JkqGpTEzaIigN7bw9dHs//+owbmTJjKrF7dAtmJmMl3IpydMVSMY7Iu7jfH+hlb5qyRVtFTO +dU5PPhB0fnj6MwAymU7lzaq9pywWL/BUB67lKmJqZUYAZg60ulB2PFcYZDOboJWXiBMCltWC +3bRTyXIBaaDjim7mhj2HvPK6ymHLXsv8eRF1SnJ0aa32jwpaszmfLatFEKkQzhea+4OpvSQ2 +8CPIZRcKHHamBVcOK6N5sd7b8A+cZfaT84XEe2F4isk1MO5jdsfJLdqFfq6wDDyb1EyzR3aV +GbTeV+hwWU62vsr9pB7R0zzGtTeGyDxht8dKOtrT26PwtjgMsPXE6K1BxJBMSuqBGPKo+C7m +NDdVxGh5xHYwiZsrQuXpgL8exNmFou9cZ+tovPZhFlR5s/ZleTKB86DCoRx+DtwPbZxDz9rG +RUNcLo2+Pba9jbS9QNWx9tAXcP28OgGdpyNAn4GamdOj21mr5FNtYkP06OWaumeryjVRanU7 +6Fx5W51ObA0323hcCQ4K9CsXljXTasVVPy8NdCi1ti1k/EZjaaCmBpCWrBkO+YkCHAQQAQoA +BgUCVesKaAAKCRB+riZBgedz1d/sEACQDkHzkNIRoFOCibFZwp3UyQ0nMkJZDYriKQ6PktKu +1YELrFsuochUMh02Y/8qyDWJBHeRNvi8om4Ym0F3rZJHpQRiV8xnSE6fU8h8YsOb18v+P710 +4/4DJAy473wvMN9Fp3c/pPY3TPBGYjAr/iXMLR4XH4Ga58g8csBJnh6NBSlRbkPmGvtq/+wb +g/hejoW8hk97B6CmzW1iThzZc7i7+UmXBNm77jctbXJQQ7039aX872TGtEjEZmHvRtZNm4kK +jY2y+xh2Bw8LoS1ALiUHpgwFnDLT0DM5lCKO1ztzzPUR0D8NYFn9LLTbBIDCK1oQhwrj9QFg +e95xQfQ8ch+Ub/pDC1wZ80S2ouBYQusjWtYJV29z/mshvAXo8S0EzEdaN0JAp69IA9wAHhU5 +N/DhT6sLPDI669VUeeFD3M+OqJrxGn26rwVcHs455SxdlwMHm3mPORwasylJDcX3DSRqwGtM +Zj/Vv/y0GkIEi+lMGBxth2Uk1wsxBGh/jyRQzoql1QyrTJ8Gq2ZqJdz/jeu1AbbkzdoetNZm +OQroT1VtF+gs/TDUYdIgNDrJNnQiBxffo2J1pfHYsr+/gMK9oZ1WjBAieoFt3CPaIWKp3Hgf +nQFQcqyovbbnPwQj1VroYb4NnVQbkJm+pApGkht8655QOzNJslq8lpK6w+eb67lyqIkCHAQQ +AQoABgUCVioLIgAKCRB70YMg3q36EWayD/4hNJHNywkjMkVXAhyTuiE+Q8+WKg5REgu3jmke +w3qGZIf/YspAvF/lmUYYWcuyGrjCJIGPMYHMHSfrlsgJ54Ryuxdi8jpLh9jZna0IxYUNBAHC +vCk1ZgNN+Xo3hMii8Zrec6kBnyi39IvsK1fGiWhFZbfFYNbZucnTZkL3OXeKTNlDVoFgKtlJ +sB84Pz1Y/jglAP+/0tDQOGxBrBjwjhi90B3YhnYemFmYF4d4gc7yPQxNeQPbirZyMtOvcCwh +eJ45BbbTBpjvbz2AqyOZhDKyqDZR+H5XJXpJwUqbgLxaYKGSRboLTD+nU83mYMstazYbWSWg +7NQBwFZjmbxmTKZ/4oxlE0ASFQ1WeSCZHOWrZTdXkksTsYDRVlS2yzb4jI22EXtyrJf8wEao +u1FqGnF9Re05wyIa2vgyGPuN+EE99K2jtgCQ1VNYIxw+blHLO2dbtBLkYo3ZBK85tv28w1c5 +2xgYLmLkQBAh9ZtMREvpbrHmZaWpY7MM9pWef6ZyGaaJSU63Cx/8hyuEdIlsNJ4590/jk5IV +YhdvXXwZfZWdgXecM370pXMj0e5isaw0uFJAJybjQcY2B4Q/uLzkvCctjiMdksrHswfBhB/u +7vQ9KGP7pBBEg/JxMIRUeIGkXBhB4R7tLe3tSb2/DGHLJf7e+QJX5WrimdQ37ztF1Y5NwokC +HAQQAQoABgUCVjdP6AAKCRDtRWeNoU8s3JUuD/9jyYl4S28eE10aW8fURUVfjEYcn570Ry7f +Nxea7KO7C2JnAJeR7EPawL7uU8hh9MOWkF9xRda8msvITMLBLyyKzODJvpTsnXF59Wxc6WAX +PVCCk5UbF9b0e7eTRiuSUfsX+6QOQteGhRkwl7PgNqVoFW6uKoZbTusfkmddDrtqg+u5U6PD +4jCzxipGvDYSL0RuV59ICCwMPWl3O6SZIJSEWKScEm+tdoCy1WLTtohgFHvY1T2Lg35oYchu +OXztyjSCg8IJa6DwmVBMCKtQCDEliny+7JSlAOucdIyELfXXXuAjJvimDd3ICHvCHD6hDRRN +HUx5miLoSDjPPoNnul7mwqtSMfOIS1lbF4QrKnRTWV/shGYyhzjUHuroGsA0RCa4OuT65Jzh +diUhKQYkykbXTqBY3kiSRu3vVfd3Eb7/6wthWsnYLSaZa8waxuURxpbIFlC1IMb9qeIrIGd/ +X+qviKN4rLOItlf+x3lJdmfpUas7IMH1bJcHucOTOE2vFXj+9whdxjnkdKTZCsqynBiN4Oh2 +yL51HaaCETRUS47e/WVU9GHxprib80JH+cIYFNbtUz3wXgIPfbkRj/oHdqmNzBphDXwPjjvy +6H+MkNWFcEu3Sn0IlNXODhg0RQTvqDuBjym9vUvsJDInxIbs6Ef5feJBj1fVH1lf25shSUAU +SIkCHAQQAQoABgUCVkEwjQAKCRA5J42oEJ5iRLdjD/4qOxf/30/Be9JJ2z4N6cWZIzig8llm +nNileuflgDR7xvawH6qVNR3WP3khWJr1BB7LqNKKep6SsaxQA3PwCgEv31EFmQIPegkhL/sy +i0V5I1tqxXmxFaGDGax8niDG2QyD+ZfrCk+fFI8b07LJT5fEoJFYn9Dx1q7yOyqESmK7NVWt +/5syHwGrOdtPDASnvHWr9dtJd9kZkK7W7n7ZIcVzr99szlj5Qas2f1lLafPj4dNdeJ2dKrxS +I6399b1IsucpCkx8e2ZkcjQkoWMNEoOxYVK77m2wYed7hMifhZZKzPtr0hNaWv6wC60iFfMz +EA77ASqy94gjEkLq+c+9bbmVNQFYqbesl2UD/f6Q7igHL49YSrXIHBq9kEXOOwa0Qqb2AfME +42v52xKFlQ0GZTnDBRG2tAqz+JScNJXrtAS/sIDFwszquzUUXFeqrnA8CSyESKlwlzRVExj1 +IRSPenf2bD2R5nSOET2fVFZg3n8DaImEsPSit9xziym84dM4h6hIC+G4+mkWqsF1dMWLP4en +aX70igB/wSF5Biu+ir5a8lRMbPQxqvaSYZTlcqi4QBo8NsGEyNrO+qIbH3VEk4x/KNDpmknH +Vg0Dt6ZrcprIcvz/Ayzp3fpUzehrCwMvOn3/cwygi0We7eIZayHx2TCNbA157FD7e3cuCFmk +HwVtiYkCHAQQAQoABgUCVrB90gAKCRDp4o3qAKpVVrycD/9gQeIuJQPsSWeG8+Nk964wo28A +H/Kz6bpR73fvvE8UiWgX2OZSkpItVo6L4e8YGsiyp4UfG7QadMsAefe7fwSpP914Msl9mphT +35pgj8KbnOiOQIYMdkVnCRqr4HuB3qRHVpqQ6fEW5tvuB+G4/gexF9y4bg4WbcdLdL8Gm7ip +OrKqPGq9Fwc+f6J2YPZsx9qSTpN31DQ1+p9jCS+mYapQkzledojGxetaAHrbNVpLc+W8wRuF +mo1JlU/39v4GTdWvVqYUFtQ60LRzDY1+c3sQvB7i4YKvcIG3mKV/rSXHjtJkRh0R0RlKdvTb +nnxCoSkOgGDg/QCXWVfHT1YUk5ILco4dr2gbBzb3vlNrvhWbRDVmtZwyN4zTMEl+MneuKLQz +sq8kLNLFVjBrsD2kRz5YEMJy+83AWQev+ed7C5hZPwNw1/yFhQL/w61JNhZKasn6Floc3mNt +IgJlUsj1tVqZZVqVu4dGlLxFXr9SWfm8AucvhgsGdIbAqOx60yWpOJV7YGUlYn+oI2EXvgGP +vKDfnUN22fBuFY4yeD/EE7YHrNzk6oqzR3G6GrvBBSFsmq2/dp6HZXsJde86AX8yskzD8hYg +P2DN5zZeeWAN2vQE4vyriHm9VVm3ZVRldvCUskfza5AjQjilDNsTdRNxiEgFHCO8evWwSv6t +ylWdZx1zLIkCHAQQAQoABgUCVvq/VQAKCRCXmdcJ6NzWkAi2D/0asjsJ0ii6VpJgjzsxjDsZ +FOkWwcJ7dFcwGsbhW/xtpwcqgpEzkTWRSoGe//qZTbhLS7MnyRy+VZmbJWRO/mA8ndjA24TT +gkfmOIUsTIl3iSb8TUAAkLbFyN5bWeYeWDBUrElhZNJCPfRpU5ANdsrzMcx3KkatnJePK4lP +I2jG+Z4OeNEvE86ODgl9wPvyyuJZFN2bDL0A4O0XkohkYVIle5p2tHnqHrrN4GV+s1V+1GbV +xhjAHdpSjyk61QUeGqw/ul79cq2iiPPSeAB7FFmIyK4CzZ0+ImjnaUVJijKPvl9rgk6EPGw4 +tnmc3bboKfKVzxE24/L0dAZNZvSKnM+iY4PIjBLEva7p3FADYSR7yvCgl34q+WNqGGZ3ZlwG +8DuKx2rhyhm+YGli07hgtvXvpzeapCWON0UPoHEVqvIq4Ha3j40JL8bicu2Y6R5HM5tZJMSO +mhMxP3XMyAuZRW5RL5AnbC8IK0gYuD2/nJHx4wwJs2WeltUGRj0JCznialSKODNX7ydq0kQy +NJfOpqWuLUNRZkXigOgT/jBh/pox2N2zvQcBJGnDfqGPrcByeSEjQAqFRD6idraE0LLFfKJu +Fd12MD4I+pFB7kF4dfNZXeDeLe8Kqcbv7Hsy4iGj0gF4dE4l/YnsAgRxqVCvcpEpfHPUw8HS +oSNIY9eFi8IFtYkCHAQQAQoABgUCWDKkcAAKCRAt9J3UYMAa9MVID/9x0Lji8FaSVcCwAqm2 +Tz0ubvWuTH2THdxpyw4jK1X5+VhT10Gtxs80VAHzc5tS6CVVvIxMKJZJZKL7fBFc20Tbudna +ReP46axvrm39TGK3Vb4DH3X18JlLMfnZDupEyx7C4j2VGrJfC/T51OLFsV4Ag0HQHZXODCFa +g0ypjQ3CDICgh+3J43UU1B7rC0m6MKuZu1ppQWQg1ojrMqq20WaQHu/3RAv0n0WFzOH6AVhv +vxuNRTwEqleO0XqGcjnBVTXed1/5LQqS6cnDpziHpsAatgEdynS7f5vDHA7a0CuB48TkAI9B +u11HkwKkQFx9LKUq/ndVpu0qixAiWX79S19i2LeB7sVQtBC6q6W530HWb6+EocTPxdL2jcde +WiKUleTWj5htuib0i4ucKk8OlOhEFhCoTVlHzRSQrREK5WsK/46lqSARK2ms6eHT98gfQLjv +mKZHrEZTo4rUX1QSax4RzZYXT0GHXo/gLAZOVM3OFLmXSO3zc5joHDhqMeuMpEGSGL2qHozq +DbV+ugBRymM1hdpUNOYy1f4NoWEtxllSQWWwtbhBCdubGLs2JBSG1RqeLfB1dlAGLH7ijyzm +wCSuo3RV9mKmxTfZjAY1vntSSFXFnNkd17BnREeAGUANmiCVwNVCald65tNjYutRs2CIYK7E +g8tWX0iIkilzDeTuFokCHAQTAQIABgUCV9vmCQAKCRDisZOtyzMfJoWxD/0XP9F4LDDBnwjX +HWT8arBDENAiRvVMIpZynLDpXaqVINFFVfGV/ihHv9Tsm30coC1hRQiXTmFAzUX4wYBy6192 +4rvRICqfGHflR7l/F+BpXtO/m/uerarWGz8B3FIpcaudtU5Tg95coPhVgkMXh/RHA67dtoMr +KCGzBVjkVZp9cd45HW9tOfIFT6st9FXqwO3bhIw1+r6Eajl60q0zNpW2M6uU92XHzqo3F+xf +SJTlzbzsm0iHIv98joJZcFh0VQSToaAUCnMxmbfqCqBq/3tCm96L+uk3ZMQEkRp2DLbPuoGr +MuTCdyyu2KavEdpkFI3cZ+Vx7Maf7Sv/kcrQVn0rD77j2j/OnDZkVm98r4SJm1w2L42cjQOa +TjWynVKdyqZXoZ4Fu4Bo8vpv05VE+UtvzBbHknImeistt6IUlkSGffO5wOydBTuy5QnmBduz +PVpQA2LTmLskaEx6njQnUBKYeA8wsO+dZxFCOGk/ex/Hy92wC008l/jdd704qLTfaT0ks6Em +eR9xnTRqYBfIzrq0Bwmb+GeGaSZwwDx9rzuYEcqNzzlcP8ctgo0dQK45G3Dh/GXgH/4SD/Uv +bmx0YhMJUtjtVr83Eq3lIe5FVP6TJTU0E91z0bQ3BMddLUKco24YqL6QDhgSHOOV5N4ueeh4 +cblYLXl8xDfWU4oAJaIZl4kCHAQTAQIABgUCWKQefwAKCRDGdMD0PvuFKjnFD/9n4+iylwZg +cahqBH3OQwFJ6mNQSVbKSjQ1oX3zmuAYXzOuqTY4l9WMr7jABt3TXC9Wma7qPrUUjn6wA3+N +pVek0qVCEtJOimOwx6Q4jLRnV75Z7vHwbBjLgnOP45ysPf9sQPlU7LlZtVJaBWadwI+YlbOq +zh9GIX1L4NfjjoJNMLzD9FfNqJx8Ph9bBmoTUovPnvZ0ggeGfg3ctQp/M1v5edC0bkmxIKFY +f4+KKJCVdOzMrJfBI5bqpML77xOev7XhxJeJM0B/lunVUojRBdERBT8jf+jggR3x/KRomkB3 +fkLCJXokx4ujnPYe9RS45rvYhcSosa+hAXInobOO/1uzs9+Vzev9isWzB2nJOQ7Uj1Ia5Pow +V4ZQmwNkX9Q5GV5yvl/GEd54++UcbLlQhyPSFNwKjme/4644xAIM/2N7bunsjIA10hyHowbr +gbX1NTNfVCqvJYfpskulntpRXV9fTaAKvvjpvyeWfAjtAbDgVv0K/TVPdbzHSWmkWS/eYGLy ++0i4COPm/fnqCo1tU75ASoyFsYddRsrPyuL52op6/t48RCz6gXNLz7J/d1seoPKMyu/D6R1x +1oGkfPPC2zEqST9bRLRQlAQJ2C3u6SjeN/E55Ox64Vpq5pwQulQcDiJUCexhGrLQpPmaA2vp +y+CgbkXh+LkLX7JRqOSUsNe4IYkCHAQTAQgABgUCSlJb9AAKCRCsMIeaq1WzErQZEACaqfaf +bp5DC7aFwBHReP5mFb0fCspa8Jp8LFLIYIPJ9rmxVmHWrNSknIsVBeRsFxpFDE3Xkhp2dv9G +gP6rUUGqioQiZfxexIx6sMaXRDFlEk5VkSHMDh/9bAUWqFsvwREtsQFqnZYXMFakxjDi0Cnw +U6Khz7xLitUwMlNPIoPgyHTro1fwskbesFJE9Wr7P7l7aqYhG6KUsRJMn8hhvjqslYkMQ0vP +wi0Ykja2yO4hRjKKUgtbujCNLFev+Jooopv5o7OBCOES7G8j6WZxVr7BNwt7uo0FaMmgBZRq +twdgUapXl3cfSOK2tSYMRE6WjL6T5ZmFH8rvYvYpnmbdxA//cjnr5+GpQYoDa1PBfMBZ2Nzq +U6AsGbQD2P+qZ6GpS4AKVRy4awzskdr8UWIWO8Zi8THIFBejcIlgKOLrFoyTsotcE+4GXRT+ +zcQuZO6wzmV2w6uvNsQrxlBJma0y+Va+I/5uL1mSZ/19OdvA2fa9o1ybas42ttTSm/PhVCsz +g+da8TYdDxwLp9UcGQjx3red/mg8xAFklJm9jd7b2cQhmfcCtNEioqd9j9gkZrz766xJy3hM +b6WNAxiGBGULFMI5Db/stjZ591k8nmSUO6kPvbzaEdIKDnaKVG66T9Kk7D1yFard5rwvdOn1 +tz29+EAvExJfBymG04kBmBOSeyccO4kCHAQTAQoABgUCVolpFgAKCRAt/1JrsX92xobNEACX +edW3iGGmeBRDzMgEvykIz0pbl86Ft/lEMDxPogV+EhpY9k4Yw0AYWXHhrI/2G5ooCv3SXnw0 +NHR+wMIKyhNojJO0t0yVirW1olo6+W3AP8HUwuHjwIzjueQP7+rYQvCbvySvejnMv5k+sttC +1/ANOMZGuq2W/rHPJCELRDUt12ab03cWqxPkcOzphl0Rm2wH+CsKTIe/VsCXSS1kg+QgeD9V +sHKxQBrP69M/oY8AznRqu5UhTmdyvip2bLLrNg9T8v2OU5nanEkS2KLsY9DG5S1/Ne8qzaBw +YSEWv+aRasQJh9g+DOcVjNCzCEo8jCYf7G8qcSqBbjatNd7WbLYsMQxTp/DcYZH6Kwv8DPur +tb1h30pMGpEEopijw/NTgLL7Syk8SzBS6kSX8UCmiTkMmOFFfNgE9HnPLqU7N4kyBLvw1aQf +rLU3u7LnpzGiAjKcJVTgYXvlHQF4z00SD3JNtl0CaPS3t8DJDKlXdNuMGMZtIRKmg3PnmGFW +G1ceSVPjxasU4KGGM3EzoSiDvTt6JfVMT0BIzW3VXghPDkitjT/vNZnnsx/awTp33B/d2myJ +csdn7xQUvN+kws5lwHSRTUbKtOtLVfX+71HOX+lh7w628rfP16FhdpUGKdyBGfYbveRdi96g +cK3c+VVqEgpYkgak7Sl8Fn167qmwNAxFq4kCIgQTAQIADAUCR6NrEwWDFIY3PQAKCRC7r2DI +LHBGMt9WD/9NQv2lG/OFyRqPRp/fUdhd2M/AL3j1vTn8njxTQl4L7u3JwmxALF7JUeERGk/c +ikq1X3rqn59tNAd9C3MUqNnfoDKbVAtfr/F4vJygHJ3IyOsqc1NM2hW6xk2gtgAWg0Vg+QDI +IpaGjZm1n1ikljyikt7IgRE6Ba22EeyQbCAHUN0ftkRwIp4rVsg7gRNza2rl3ATgMAirNL16 +zmR0DAgoHjiiTMamqPLcG3PVvsAYW1DpHDXSkXG8awnmCm/M7Z3v4fidfkeL1XxQcE3CaLO9 +GozwSIe27m2QiYf8Co3k8ZeoTDHhy8eLbbPsZMQQGN0oElNraNP0qKgk9PhwwgXRAEPp0vuy +3J8sCXLPunkU8R96aWm/3KhWLHYMuHSRuPO4Ns1/9sZoqA45Ul6c723W6QGUxIBMrYNoLAm0 +clv7aQlStHVY/qpSJ2v2CKUG/JJHbJeDoO0+3ZpWL3MGprd7lsGH9owYpbpmqGMhvkKzqrgy +CR4O78h3AL8tH8pxkbHzjh44JekaeemmHUtm2mdbm8UkbS5YPt14NttDRh31Xe1/masRwAdx +HV9VHa9A8gze+czDtdnc/folBoy42LXa6MU1twpkA4j+cYwgKyuHWtK47WzZK9iNgMHA0uHI +Way09m6YWGkLcOll57QZPPZCspS5y5uLJoNlrgH9p1HtLokCIgQTAQIADAUCR6NrlwWDFIY2 +uQAKCRCMk3xWo6hUqbh8EACToAKAFy4Er8bnuHCzAEdiQ42KylUd9uCnoy2hp5NYzpUrxLJw +LJtpMlQx18BGkmAFlWc7W/xH0LZmRTYKDT6a0HWOsQrhtCHhbDxnYqh17yYb8Gj/OslARGBQ +aIZLH21isXrfaA3BsfWetMPl4OaSkoVThcM6a7Me3hxdO/jvho8zLG2ePKgu4/bCwCAU/JRQ +0gqVXYFGLGLyJrFY9pbJ47X2Csmqz6o32P8q08Hnqj7/YEwTCKiJfxKXDIdQjpFJI/g7C89t +hc3FNcGpuCQUc0VhZR1lE9qyzqVUJa3j8cU+kvv3nicwpCmot+FX1Lvg+bQ8+zZQgGv0kOv6 +r5LGaWdJLUpWSKIw/f8qDqWhfwIpe96Bjf30U6/CCynnBY8FQA2szWDQ8R92s+blM3s97rze +//mtOKPqaPO3VZWFhRrri8kbCKRgvuIAGP4L1n1tLoKhxg3wGVKMwyZhdEH6cWZTSxmj0spc +ywJSAbuC7RtIGY3uwSUi6veMNSXloRFH3QZsC1yHbCKgHMui/EHNldg6hvMnP20vByxc83QG +s6kDpQyORloNOKiLoRIcNa5HCQ1FEC2cC5jNvNkX56i13XoHoh86Ud08h/+zztaqlWyDIJya +ojoIG/IuPAqNnjvj8YQ3d/y7pEW7f3VwMr8mdInHmwEd6xQYlI/P94rmyokCIgQTAQoADAUC +VNePtgWDAeEzgAAKCRDf/o3jGnIF9P0HD/9Hz4opDb1T0wknbs/2rYZeYhpJ8Pmr+WtdVOwz +nEmu8fffXSCzvZqd1SoG4qCCl4j0W7Z0X4D2nzB3gNEFOHYIMoa8MK6uIHZS3fefsxWYLFuk +k6sn6j2Xsdf2S7HYH2tJrpT2DA0JrMMBGY1BXJh2WIITiXUsWxxmCdFTr9Xl7P/JqbYOivhH +KL7lJgPi55932KrjURHoWtz+JN1M50Us5fZ59P3PEP+Uc7sIbcTINCi1CRFKKX6HsrHcFNTv +A46pGdTnYBZBIQW8vdxXFP8nudPpttNOaIlis+6yriVZGcQu8mpA7i8GMxtQcj97sbVzl940 +KYsXDbZws1/0q2Al3TctoLA1K+wlJ9A1I5z+u4iHIuZurLOFfwGoeH63meCvyp5th+EoXbw5 +pGA4eH0J32shuSAeg5HWN2UrYNb8I4cor++fwCDbbUEms46XfbqOgiJ0iuWM+g1qpAQQkbV5 +oujO66WakjQAzxUZ3MjbuCA56OAwwbbohmslg8Dxhp5yM8TFLnXO14rIMGQZr5DNh55DwgOV ++6OSS8Uz7bYiNcCn3fGKQ7ea+/wg8TG8yeQpxwZP+CDls89AWVh9zggKgcJO7rOMjBRh0vHc +zw41KZlFMWZ2wbiDUyPNkZo0gnsUBr5CpDeajiiy/bn3auG6T0n/tOqu+M92OzR/dkDezokC +SAQSAQoAMgUCVp+xgSsaaHR0cDovL3d3dy5oZWFkc3Ryb25nLmRlL2tleXNpZ25pbmctcG9s +aWN5AAoJEOzpIdqGO5X3ndQQAJTiYZBBVUp3+lilIBZjslqVpd5PuZicCQj6e1EtNNCtkpwg +aO50X8pkxWyDxhl1nzqHRYMP+tbTXNmhvfqgqcgn8DsMCP7BZhjXYZgvAjU13AGtRmEav7nU +JHoT2aYDVcUAfys6ulbf62SbAA26FYnn0FNEYXiRiclLDhClLZE0G2b5IJwJsaeKeDNP/YY6 +YB2/1DkIV2auBpXqqGWsdxi8zesaUISo48e77HgoTYuSgL1Fbp94H7orlg+28BWzUCUN/jcz +fd3Xh4z9YuW4NO5jdxb9XUlv9Bh4f3nJT5R+f810tRJexGrLxodbs1WCqQ43oHoU+vwPdiX7 +fxmZlOLGjo7vPaJzr1iF5TcoHoy/IcflEqFymsoJiL+QWR4oLdNH09F0C4EePOKHtBHbRw4m +sNQEf7xioQj9ag6dnUvzVYFvx9hDWApuApt75fpWk/nWDuVfxTNYdSWovcpGbZP9OBQ0Y+7V +9aSOqqlx+Pr/JRlOOrJ49u3gdbWWuCcTdPmr13FPqXvzc3n+gsvFFqdjaj3aiLydVYDLdcjC +ovsPHWv3L8ULwzwTea0WW7efFmXPou74F7+Ca1OFbmJZWNOYxVFoFz4DThTXFYaouoF0SEgF +eQ3M+O37v+vPle2OFxItypBEqBFhlRXo73VgBLRl/+nejwd94sKWmbK3nixItCBXZXJuZXIg +S29jaCA8d2VybmVyQGVpZnppbGxhLmRlPohGBBARCAAGBQJV1KuMAAoJEMWvd0pYUQtap20A +n1djpp9kGdklaZrPJ7XRx2R5zyPZAKCtrBRHdiKT59cbtNIszENkRQZ2l4heBBARCAAGBQJT ++6sQAAoJEOiXdagytnMFO9sBAK2n/bjurimoyoWyx4OlkRUocATkK6TohG1mrBMseuj/AP9x +7NF2zDOKDNValSBdF2yEcexz5ySAJxPDlqNgOueIHYh4BBMRCAAoAhsDBQkUsIqNAh4BAheA +BQJSxYsoBgsJCAcDAgYVCAIJCgsEFgIDAQAKCRDyrYWsHkKzZ6/aAN9RhDJgdm0RH2PokSAH +nOUNjSy0NsYoDmolnwr7AOCBCtIJr0mG7HNk8NWaoiq5xz3HfA2+dKxVjh67iHgEExEIACgF +AlLFhvICGwMFCRSwio0GCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEPKthaweQrNna2AA +2gMKAklaHltUySifAcYlpY0gFwb6fpX7nIat++0A33Ip2wp/5FZrYylno8NARbW1wWP87pGP +72DQtuyImwQQAQIABgUCVumHHAAKCRDVwrh7eLTjH/HbA/jNmKobRVdn+ax1fcRBDWlUfhhX ++ZjH8uWUpu4GJFwySI0GnOLMxvWoDS/FYEBZ94VF5nXgetZGIEF+TagV9ihuQNZS3Bl7jjVa +h5brUNqEhITePX4XLXaas9qZhcE8+l/dnCwrpd47HXBmKyesfZdyxBJsst+k7F85yJM0Vgyh +iJsEEAECAAYFAlbpib8ACgkQKm/qsCD77PauywP49j6FEtYNLQD0fQg2hG3RKShju13Lkc8M +t8IxbxLmcVGnZsDO3W2aL6PhDmn32UPHS2QYXVoms99AELWv1O7TkKpQ56ZRWL0F3rsUcbnN +FoDi+SlCAfPa7G+TTzN7xILHYe9PQduI4HzXuvfj0tuQQJLmPVrQ8n0uAjdZAsbm7IibBBAB +AgAGBQJW6YtYAAoJEOutMZzlsUp2ySQD9jvAF53E9Zf407YSZCNp8NpBkl2lH/qiUZ3r1ODp +4YKUx5slOSML2YFyvO+0s41jw6VCewiReXht70kMiwzmkO+fxoW44T9HqQaw3aKJKp8IhF2d +ltei9qnZL1n+2D9p/U9lswxR/jumD1fIBb5brBU82pE3TG3sW/oh/Vi0ZGWImwQQAQIABgUC +VumNLQAKCRA1Wc0NcvzpNs3iA/jtrs/RCGFynn+jYGkqwTeMENWW8wcGSF7HecZ9yFiTRi70 +Dbs+BX+F4ZPe6ja/ewruToPPPiB7RJ6I30Oq3cAnhDKMjv+a6oayZISDrCiOMq+XJ4fSStn7 +mQJ3eipyu/txfWZ1/f9zYv+vn2sUPXHRxOuYsptnkjCrwpigotAliJsEEAECAAYFAlbtOR0A +CgkQQI7HctcK4YbifwP4m919FAiEnOD5OK6rAMO6hOIbf0MfkfiNYGjKI4JGFMLhX0oV1KoM +weqrLuzyfRpOcGg1XGRkhYI45OK2O5IpWy+F1+qUunXifU8pjigoKJgZ0L8yeGP7sVGyPFI5 +Ast3Bt2sC2CTLeM17VLYKYbcGWe3zp0WYdBfv152mvUB+IibBBABAgAGBQJW7Tk/AAoJEFH6 +lK1vjLC3K0ID9jQffemx89R7xk1B35pjIKroCtnqUDytdrCcBRcSGA5ywWBOONrDr7BWkIXa +ERLC1XmC8OJMzrwImg4x/KpkDulVhEzRXG+6snBnbSLK2oa986F4IhSG7iMo7tNAZIPI1eap +CAChOeV7KL5bykvMZfOExcv+WX44SDdV4AZk2dWImwQQAQIABgUCVu12swAKCRCmOOd9EPl7 +L3rIA/dEn/cTB4VAbGMpfH/QZucIn3pZiStSpvrCpPl/juz33ipXM9miUbxB5kWbFVat2P68 +hJ0cRzW/YGNqMhQ8dC0b6MGEkJmAqQkesesZ9VHahe/xVfhXWKUiEB3v4w9bhAcJYviiaYF+ +15VUvBn2XTQZehrsV/Ni7mtOdZi6boT2iJsEEAECAAYFAlbteA8ACgkQmD6S6zfiPQ8tWwP3 +VZVfYhdJer1RqEWs3pDLP3PkFxfTk2+2xcZr3hbJgPDF/Z4WoNMFkwMzifMZ7V5YaT3lxywT ++PLWPdFv/mpyAZOdlj2GWiUCBqzYH55Hi1Ij3Q7U7sU1SXF4fQ1z4pCKwIApMLVEZ5ZPVIhu +sBle0g7eDVSGD+iU+B0b0LzOkYibBBABAgAGBQJW7oD4AAoJEJYzWK8IgFoKb5AD9iYlF5W3 +HoS0u8VkXeoQGzLLY0yIO4pnBzrx+7vdn90Uc1zyz4LRy6cSfIb2bq4Y+3M0OiEQ8OatDAhU ++TTWgI5857Z89o2ZBsXE0SJpqV9vXCkyTspadLjmRCOsn1ReqmK2WMOXwvG8sX9LDnrfI2o1 +jhi8KF7mhjvSb4hT/HCInAQQAQIABgUCVnwrGQAKCRDbfJ2P1xwCh+3yA/0YT6uccL2jii2S +8GVsJHPz+nYxOLb1pMNrH8vHjeokIb9E6Jnij497+ty/mpDpZyjaVrpeXhOzsXkuWiPFgmh7 +zLL4FBgidGmQJ+sFHBF94zB6jWKBENakQmSSE995PmT10gdUF62/GWCf9Cj+MFy48QeroZVs +1KaARKlr5z6my4icBBABAgAGBQJWfCsbAAoJEOH2BecyTbenE7kD/i55h0U/S4+xiFeyiDYj +PuXvrPrwJCJz7iRX9nTLrjwOdEK031T9gip1wSSMIuEAYN+YHdlQsmBotQPDn18vROqOeu0A +IRg5yGGZy9XLO9xyeyRvMqIj30RL6Rk0q6oDO9EjSWbX7Nxu4+tJaDHuWedsJ+6U8mxwZQV7 +UBGkoiXeiJwEEAECAAYFAlZ8Kx0ACgkQDpcviudNWPjhRgP/V0y6pzZwKj7Fix3ynRJjS+tt +xcXmdMUM4jZXY1jvFhvklLwiFe4b7zQEjkNaILqM4C7c11FJkCsaJu/qjNmaT+4CiJIEB3R6 +DyNOT98447oI5su+E08pJWXZ7caFIg6/bT3QRZyCHBKbDBsI4VPyeuG/zMaLgDW6D4tuJjOZ +FYeInAQQAQIABgUCVnwrIAAKCRDydeFOiMchpxDiBADFgnbSwBFONovjX9pomGOzrYwUCFjZ +dtEoBhmVZs5tDxDYHlq6K8QYlZ1uZZht/mIW4Jyq8EAKzNsbdVeSbz3dCVnP5zVeUr5FGnlO +IkgpY34f97K5eMMtOJTjCanXHSRIU56B0Ic0ij/EMbSplZAj7cJcPcjTT9CCR9ObMtCtHoic +BBABAgAGBQJWfCsiAAoJEE111NXcvws8/RwD/311xKnPLKKbS8Tg+lxLanneHKIrfAnCSFzW +LCIwsKb8DtIFzkmhQ4IqqnjABFnZp1fn0R8Yfb3LKicPtztQHSpxxswChe+UXRIXsJJdEkty +Oml7Zp56rDfuX4CB/1oeMbDhdUAFGmCDEkKq40NeHeJusxg3+bfVcptEunU/w2G8iJwEEAEC +AAYFAlZ8KyQACgkQ4MEnGKPqovmLhwP/VtPepoTPL7O0dBxCGoiloKyQB/919y1ulGAJ4Iiz +l8GFzwuquc4/RQ2TExLa0z3pjRYw+GmFhvZy7YTHVeJV3aEZgHh4kn6Mk6hwa63gWlWfy01/ +C4QFTQpekT0jkhzmAacmdAwHM3Ylq4ackwkL+FLCHm9OyB0mLGdPN0a+GZqInAQQAQIABgUC +VnwrJgAKCRBKGZqG/UrI/iZsBACLcsIDVNjidZhPgmbiTWafFXp3KJUwowKcte23Ed8Ws6D4 +6myrLe3Uf/L7TXafOLAaqi0fnAjLmZ1LXHHvDugM+hsMI72M1lE1Ssm5NCjujlVfJ0FhfZ4+ +JauFikE/jgBzeh2xxBfC3m91d31lGI7OQXUdZ7cqNlwBebIHjJBK9IicBBABAgAGBQJWfCso +AAoJEAsSMFnezH6OlXMEAIgSp4O6FVl+hAo7E1Zs1fzAHh3tzBZakrHj0nGt0X4Vg4Ah/dte +bFO3nZ2nAN0JweQPiQcH0Rdk7ra3jrWLrUrvgRsM0MNJSJiRzbf45Vy1AKlXiWq5V5muW1J8 +HN/sZYzhL4h2UfyYMiFqBSCFaOZvPGOUIjDqPljqZrgKo42qiJwEEAECAAYFAlZ8KyoACgkQ +mwGTMemukDm5eQP/XsYuPFHhGd3gDrm+Rjuf2rO/988PdRIJlvcRGQVeNwD+eoByNlJu6LBL +Qw8QXMazhMWXijMe3Z6SHy+xx3yKsf7IsCyLQu0gClfyHwpJ0LSGgGOnTH0z4/01PMBhdonq +c33E8ItP7Z14UjLm8KiP0nOnL/UFu+Ppa0fAnIhoISiInAQQAQIABgUCVnwrLAAKCRCnWUt0 +gGhD5k3QBACtMT2U4uf/4sed/7gyQ3+NVa3Aa2maMOaEtuSc5XR2uwNgtHj+ufcWR8TXShnS +wjhStixtc81OZgdlpPLfdxWmPfyaMRtR+SaEOAuOV5XIEEWR/YXjfKXJPfyk6lU3ORzlELOB +9mG/6EWQMVcYWRMdcLshKg+5TpoVyRyUpwHsHoicBBABAgAGBQJWfCsuAAoJENyAxDPH1VDJ +70YD/RagLyu0bCfqNbPX0x+3s1MI/aXpXw4JEGNNcMPJyRTRQhSf0dPidenQIj7ui3NpF320 +5YhMtw4E1QV99KZoWcxbm9LpermSTQpedwEIRaq6ryQJ69br6o5x//4hQoQJqXTGxJCxFbnu +HijkJRX7LjlcxJY0igF+F8dWoK0PXiBxiJwEEAECAAYFAlZ8KzAACgkQwnlch0wh40LtjQP/ +SuKYjZ6dh7T7lmu5oK0QHc8crDaYKdQaOqzvSFQPKtCP0ARZEvsTKJYcP09bPyPeynaF7Sb/ +I/Qyazjqr0stbGFmfBeuwoEZirx7Gf0yBpS88+d7rE5zSmhttMcGgSGfQTjuZsxaW/Ir0J9p +1Jd6c9pV01vh/TbotpVyxN7kvFKInAQQAQIABgUCVnwrMgAKCRAi8Hk+Iz+GT892A/9yBKtp +dnurKaqsod3bsl100j3wgup0BIZJRvZjVG9Nv6eSdNl6M3xzqmIO3/87AawdvQ4B6ZUNyyHR +QUVtOc2yytppfkNIc7Z4z5frxGybHMgzSsbqQ7IWIG/gqNaWIaF6Ry06x1EKywnQvX9zebrz +OWgxyaC9UZKaHnV6oDedEoicBBABAgAGBQJWfCs0AAoJEOqrkMDzIcq1kEAEAI5oNDlY/Mwm +G0GlnJ0mddqEUPrqo8nGuMI2/xH12/UIvU03qNLS82ZU0t5BJEVaugR+wJmVyqW9dtZQ1EjK +AYUt8QGP68YLmQ6jDFIioUUoj9t6yY/Hi8kvfWhX3y5WH9UcKy0rVB4s2U+LxMjTRbVLMADg +3rG+wKlFbN7486B0iJwEEAECAAYFAlZ8KzYACgkQ5JjQiu9cyzYQ9wP/Yn4XETePkLQxicxJ +8qQ0YBIhuxmM7WF8kbyW8f6/GRdUG7VeDgDUCE6cxAPzfRnWFirCmKk9s/9twfzSjEVUo2YS +4EzYExu2ncYtrFUNmkepOD7S25TvoqKJ2/Sgl+0ND11As6Kip3eDNHqSmLi2qLa7xBJpw4OZ +wnTtc/UUj3mInAQQAQIABgUCVnwrOAAKCRCouyXYOhVSlBWcA/9pab2h7qWZQVq3Zi16A78c +6MqaOY56hi0k8uyUAaaHhQBUmI0hdhm3R9OZqvKS+tNVidHg4gR7cZHjNqaSxjpfQWEO9IM4 +v+etDi6Dl8XjrwpAS7mhYvteEGiGbjsVQbgkBv/gwQe7/4VlRcvr+ASQdp9C/yPMj9TiXYem +us7A0oicBBABAgAGBQJWfCs6AAoJEFDeenArAV5IWXkEAI6AzxMnpbkfomW+PnLLQPE+92/i +Xa76zveEGOUsUvr0hfU6TCs3eGr5s/IdUYQ/YIVE/dUcoK0xWOPfRtJG+PG0czEBkBAtHmCx +taIoI0nVb1BDfYNY5+ifp19I3/vNhzPz4LNDyOdjvD61MEslDbEnZihm9uBcle0uyvzoyIHu +iJwEEAECAAYFAlZ8KzwACgkQTCn16jYFE4VsewQAmfnTCBrKox6KA1Xkp2vSgoiuEZynY9cQ +kVlZ+9191u3CZSqHP+NVxIPhb8i0I3xlCbP5eXFzSNvt8mKWl+Ghj6ptJpgfTHBCwsR+PL9m +nIxUuvr4jHot4fP/rRXzj/iVzq+QuEcRQtEOM3DH5QLhHw2fQ2gCcztQonWZwmHrylGInAQQ +AQIABgUCVnwrPwAKCRAlMQ+lLmvoVSXGA/9fHuStNyttD2a8bfqXS7YinQU5D2/66BUNDaBv +xAMD9hC/zoKA2Alth1pQlthesAIleIaRv+wDgt8OPka6Lo9QG21NIdLFOBi6otYNH6Oxj920 +lOOpyM66YaEMns3HYzeUORWyuZBMOkRri3A18eYaXHiqI0auyBuBw9z1DTPPAYicBBABAgAG +BQJWfCtBAAoJEJRlpCKhH2AoSIkD/0z4yleiXp91zx9LGBfnqYIYanvkBeGXODctPDjnu3kP +EmUn/V09dJEWU94900VXs1kQookezOKkK1zDAIAJqhZEwZisSgc69l6CVwkeSOszFogWI/A5 +iHCzcZQ4XeMY7Dzc7bFVDD+fpKqJstvq3/YDItvt8o3DsYbwqlvb+3PDiJwEEAECAAYFAlZ8 +K0MACgkQN/WG9VJnqV1TwgQAjCxcA2ITwf5Xd5BL8CAGpgm5UOJgrMphAzXqOUaM37SLCiNS +C6kzkMz+kU1ko971oCqKFPU93rJOROnVZaEySGFor9ou37YnDSLjR/gED1WVmBL7Dv12YdgH +o9DqQcwt+qlcZ46f+krDjKaskYAmIlvoIXbDAXQtK+LFW08vHj2InAQQAQIABgUCVnwrRQAK +CRBrnwqRNEuovrclA/4twdOm8YEre6kDUFWHvYSWCYGbwj8n1y/vKXQNS8tT7xx9ZzDGLrQL +Yqa8TiBtctzlwhnGTC1n8JrZa/NFM8Vgn7ixLcRSHPEfbacMgodT5lHkwDKat15CZeBXofKo +OtMVu0o46FtIWxN2rpi11VpMtVGFOk8YfW1gtidAU1EQiYicBBABAgAGBQJWfCtHAAoJEGPw +LXghGOqVA/gD/0evF7ZIDu7muJyNv3nigzTeGAKPBjtjc+mfcAnKVSRA1aO6AIgCaXXEMvim +VNinp4Mi0CsZTzTYGtroi2AoeAj83mBjtgyRsMxWeB3WQD+pBV4EfSk04OQB9Rip6IZpxCFK +deLM++dtTW0M9KDW2OLJ0hbKWD8Xyrxl45MvbwZ/iJwEEAECAAYFAlZ8K0kACgkQZyqzFf9g +LnHVAwP/cUgHFTGtXXgUJGk/pGnB+ETIVy3Frigx+R+dwsL4Yv0yzFsbn0EsOihy07yAiUqF +khSIw3+ay4oSPW1kQ4gtEfa333dharPYNjE2At2UOGPbZmb07K67Yj6yh7ZKCwyyFophKsq2 +1a1XdEybmrhjI4hvbr2Ri0LQteH/v9L8uuqInAQQAQIABgUCVnwrSwAKCRByb6G0NXKrf48p +A/0eEEm/RTe05r4BLmI/IoH7zdJlmLRT6DJvbS/tMS+AB5bEgXOCHtPgnEOShT8vN5ft8Ocm +mmAZo3S0jbRhtS7RZBkJst6G7Nm1R4lykxX9FdwUsE6ndnGOqCKCWDqIk8Z0TYuXiDxOubzT +5ZFDiUM5eQVwBN1jBjPR9itbUCTbnYicBBABAgAGBQJWfCtNAAoJEJeM6FmfCu1ofY0D/id5 +z0YYOGsraOuFBIz5CQF04AQwcnNfjcJ9rdIMTBnchG3wR7EVJ9oVIFGR2xc2M0whAzTXYgzH +uCYOn9+FKiAoiqb04Jq9+AmAt5P9nKdEw+zD+3XctbHbWuCW60FPOb2V9AypbFtVR0AHOXBI +WbMsg8a7B9cBdyR+YOMI8BpZiJwEEAECAAYFAlZ8K08ACgkQbgQ4GNtg4xxsKgP8CRlJdpZD +OSlu8rMREkWfTNcv6VAEqeNbdZvMlkIehVWcfe105QL2mBmuVX7pdcxXB/7JPnNnRbtu8Caz +Iu4ukNqxxq5oOiU40Talpx/F9AzsVIOo0c+xNRMs7RwSr89F3W9+QmTYXjbCOZzR/I9UKJS0 +R/3N0EPASlPnoWHkr8KInAQQAQIABgUCVnwrUgAKCRC6f2b1uds2srz1BACCCtLHUzsskq9q +UXAUmnvnytKGgN1C4dCx+9vDzWr/1VTFWLfETe/77AD0ELzjBMmxwQMLnTS0LxlGPKWTxkId +lbR6ce0d/tSeK5+YCAZEvzbatpA3hgmo7bQbrbsOKWCXibC2kiwgyxnPoGNnvdnPdEX/hHiO +Sx09GKJ1FNvHxoicBBABAgAGBQJWfCtUAAoJEOckpuAU02tmxJkEAJsdEPfK54t2eUc42mMP +ZlBcQh32nNjf8E3Mz3+hiPNzh5GXEgCk2rGL6gKZ19gXB+4ahyQvO9er+B9UkLdty3gqJDdz +ZHwjZdnIvJSM+4V8FO/FeP9NhUblq2RxlZc2cwJwEt7L8PFogd8pxt4gZk/eRttX/69OTXyL +ljuV9OEviJwEEAECAAYFAlZ8K1YACgkQjoj1Affzuzg3BQQAqhwiwZX5C/wp1MLvp6fRPcJG +9Ehk93YzXezJ7UvNgKmoce72ApM1L9aSRi5aXmmPvUk0r+Rl6XLbWoheLi37UFFPZa+xkK3A +KYIpFGviyGqhw2j9kz8q2FVgPlq4Wm9y3Sx3gJXrZAJYSnFE5K/PrrYU2u9pnuXeas04S8Qi +CyiInAQQAQIABgUCVnwrWAAKCRC8vivzX6NunuoZA/sHPvyc9Z667XCaRBNaz/ED/lXiNbVU +Av6l+7QbJnKMXbGrBvJBb1kdaO+7gScQ2iHk0CWlw2cI5gmTCyFI2BBBEeaE7h8aFLIcg5/a +taJFqPpk9b9zMhzbv5fDgF5I4Doio7dFtIBJh87wYFXLkR2fobFHGq3wrPKXDwdXFKa0Ioic +BBABAgAGBQJWfCtaAAoJECis7i0+cOaut2UD/2VHpyEFqCMVfvxud3iCLqd875TCuWFLchgS +qvBzecp8Ci78Jzxrtivl0VVnrhZ8XilkoVQMml9Rqb8D1A0Ypy0xnwcVjRCunvl1u3SXyzkZ +AK6FZ7H6ilf/LD31XTDVdUoBQCYXiIgXK9Oq9/SWt2cKcQdIW0/MRQ4NQFXGhnQtiJwEEAEC +AAYFAlZ8K10ACgkQCypqfpYSYpPLFwP/RHBRpTx9/meXXvUubtnaKVJwjxSvAOEoHYq0b/om +KfdQqbMHjJrN+tzDeVTEDdbidHhNvkIZqByR+gfz3VoE1jiVdD4chookJ362348VpQ3pGP4B +t1YOcKZwwOGutd7JXWWa0wDNtdKhFsjzSgqIbOrmwCJ9XJTV+A4WuoOD+d2InAQQAQIABgUC +VnwrXwAKCRApmAEZK7tG2rRuBACY+z6QuCiVgom2BtRlglmeggJUITglFPLZw2RJqkXSzn9K +yYQKLD4EQsynnqtc4DzMm/NdSUCq2fG2XkgMeVTJyTu6ObQ66DWvHzv3M+fyo898x/tjPNiA +w3VjfDwKuGYBvqCsxgwoCAhgiPyKxnuC2Uvge949lM4yzvMGuo2+74icBBABAgAGBQJWfCth +AAoJEF8yyjaYz1nEzVAD/3VkPOavNtlPLcuMijy/t97z/pTkwhA9ErG8A1ZHS78aXS407zKm +KgRM4PNALpwQssuhrCXDhMX4/3J8Clh6qlYEQ53u/eONOpGguH8hvCUXI4G3raKADirOj4MB +9nn3dI6V2BwzdQGZVsDY8kajJyFlFGMihHPk3NotjImjzQD9iJwEEAECAAYFAlZ8K2MACgkQ +JxNVTwQAd0y5tAQAs83IMlVmkRQjxsMr0Ju1di5X2ZTjLIq0x/K0XPA9a1TLe9dtj0d+SP/w +5gXWrZxy6yiF6ER3K/OOesYm5kIburZur1RueiHMZ+NM5IFzRpGStScuFueav6MQkkA6dj++ +czKC8X9+bOYc6eBRfoufM7rqLlbb8Me1vB/vksoFD0OInAQQAQIABgUCVnwrZQAKCRBsEhDd +E/MyaXj6A/9fqy/EEFbUf/iKkQIGVGMxgQYbH+qauKl2miYdfnUgUloScUcciQkdcEWHoZA7 +C0FCcdS2wFNkqJgb46dZOjwgT2sUbOY6VPo5G/ijpstzxfgjeXrj9JEVx46K+hfehm9MQdGl +8s+uCFofEFHCUjntDq8Wd8OHjGouiAFRwXxTqoicBBABAgAGBQJWfCtnAAoJEMUI7pz6NtjH +CHMEAIaY2t3LBcqnzt5MKTCmcNBz9Rl11mw2SqkFMVx1xiC7TW/w67k02UWR0GBr+YeeQ/Z/ +YJtCo5jMprXFyQYIhSakh428tpKqi0AE7BchoKHCzpeg/DyXc/j7Tv8GZmZR0HtMEft0okLz +eKBlX3rDxcvnbARe1n0+A7RL5JEMjopFiJwEEAECAAYFAlZ8K2kACgkQa2XTYyZoIbRIoQP9 +GG7smH2BchZEV+U33aNeA6qxxVfEwJw9aSCvxkqb+bNsl9owwxbOCCThdg0jLMlaZBRdALGe +KVkcazrMEu/8PyWNXXe9J0sxkYeGn2yJQSdA2RDTsc2YALIcTb9sy0MCDGYl2P72gbwpPFkx +bwBcxRRPgGAVJEJjteeZiprIP16InAQQAQIABgUCVnwrawAKCRDI4cD/jemCfOkMA/4lP/Tc +3ZnBpCnGsGVWjL290y8MVTpIk3zX1DrNBJyEguPYHwt6hPqrcU6Bo9+H2959E90JbfHsyL0R +8zQXGUIk4TDWcYwU6mS7Es7PRP90FqdDqMNypXkbMB8nG1mlU4w8r64wgxYRdg19R0Ga84R8 +40hC005fM4LkV85leG/nF4icBBABAgAGBQJWfCttAAoJEAvsSyoKxmK3zvoEAKb646PXUcS0 +iVJLleFnQY0KfPITnxmJ4zWo+UaU3McY+BKM20UlIsFMXnATMU7ryFoflAEOjdTX/1InJmhX +iqDeyU6KmlO++PBOMfgDULN5MX/1zYzV+++nSEZX3sDTr5etd7GUQWyX3qIrQwOuCOoFmXin +p1R904XsRRxQ527XiJwEEAECAAYFAlZ8K28ACgkQtUjjoOpNiLmheAQAri2VP17lY3rZGSAv +0nbLbpdQLgsuXP1xC14euM4pW5w7qB7xD537aFxOTjEf5TX8ykjknJtogtq+pwUb/6UjZL4w +mXuOKICdhHv8ZFmbE3RwJRjElD0/hh0mU+JdMcpPtO1LiLZI0K65Jt5v+fCSoHcVxsQpdqKy +M4GvhKU4+b2InAQQAQIABgUCVnwrcQAKCRCw5qSD8iAyA3V+A/9CZvv5ieP3Jn1Obg4PUGz1 +HTkfNXf/3j2HYv/3HuszgwzS2xyEsIxeQRfItBaGm3L6DscCRwmg64J02lt2PeylgKdoLRwH +lvK8SdOLIi08jILgQP9hIV9HQPhqynLrGq9BFFg6xuR2VBge9SFnlwRbJg/N9+FiD54cK1sk +NGoy4oicBBABAgAGBQJWfCtzAAoJEBQVEILu9sVeD4YEAM3dqd/R5DdV9xclaLwfIOBRgeW0 +Jwhv201GHE9GssjDPSW/eFojgFxw/RS1NuIMfV92QuD9X+BxY+AGOmIBZncR+ToizJShJ1u7 +XkC5ZJrqnI/7pxYtsoHrYdSowby/VoWhcGV2pZdWXh+VhIRuLVT7RCDy2OjG97nOFG0z9Fy8 +iJwEEAECAAYFAlZ8K3UACgkQE+Clepzwf7NPkwP+Jeimg+JgGUIPoRUqvxUo2ujv2DQs6IAt +XvfM8+XnZnbf3Ty51qUsd3lypaELHYes7BWJ+p332G1RWwqpCa/UYhfvxuKgmtT4Ub6sBAoO +ONdaDlEiPlygR6ZH7Src/XphtlexUfMOdiXbN0goxiO3lrLuskm1ztQBttlIqFpu+CCInAQQ +AQIABgUCVnwrdwAKCRA0KzbxdrdYXE1+BAC+2gC1V6hVK0LFSoaFhzLUK81wcTodlj/S2zQs +YwwNM8PiYVQkepfLXoJedsP04LYgEMcF4EKIcyau24nlVrxQtZGcfQ5dPvwxNlawjq6zzTSi +iHR0yw5GhDDLyMUlQnFY6ypAc/oz7C/gb588KFPuHqkRyb1m4Lh6ob5Uxe8xnoicBBABAgAG +BQJWfCt5AAoJENTooIFwv6h6RegEAJmmSYUF9CNbnfrFCbj97g8cExI6plffXMKLZJu4QOn2 +mMDvydBWWp3/nZhcG7zmdU/I2zGfr6hn1SMijU+L531oUUR9cusN5g1mvsQwsW2xi+Vdxt9U +XdBmVM5B1PxbeqUIR1qbFhR1nYmTRjmlUlQcJ6SkD7bgelM1nrsfCgPXiJwEEAECAAYFAlZ8 +K3sACgkQ+3J1mhscx4bxywQA351/ExFo5+1ltd3N6eH5zAgIh1Zht/1tT0oniJDObIAlTN0N +fi3SxZ2H9opzro3v8gORz5HEA9RGyII9z4m7tCyIT/ISBo7C60ocbXHHKO9ElYPlJVJHzMM3 +0t1IuixjfEOnWXq9d6T2pkn9q3gBnh2Ijw8d5sHsg9csGHQGJBCInAQQAQIABgUCVnwrfQAK +CRBmzSqFSFDaHkAXA/4ra0EU1cMCjxamicv2UddtYrq3LDU+AFxK1jopo4x7L/FV6iplpxea +DGZ0elws2TTm5vsagJXsN1I38h5sHsiw2DZzug78Nki3zlxm7VV8S+ZywWcZeQlgJaXKZ8Z6 +pe+peX7vVP+vVj6/35gRD0JN+sSqLSZO30lHqY0h8xpG/oicBBABAgAGBQJWfCt/AAoJENnq +L6NsK207GfUEAJWnFqLdUTNwpgsi+vTVUHYJQ4NGAajWeZM+i99ah6W7e47Bb7g6oJY6kVh6 +UHMNFHEBdUEK3Ps5mI61cIxNnHekQIKYU5X3C9c/8ORzuKsnvp0iRnFk4CRbZ5w1rZx4raN2 +vwk9OecIGS9QJHaAVBJJrXswoZL09NS3bjJvjpRSiJwEEAECAAYFAlZ8K4EACgkQ+68/wAQg +Hx2JRQP+MhbZNtSIiYGKQqiJYZchFxolQm6ZK4t9DKKt3xC3i6uAULRIHxKMFuTNiCFPSHdO +DbUpLkIlzk+Z5hLAcc++TC+mKWBQO7FSMBuS1R1ttius7QnXWTZ5hxnROO002cJdt9FSNZQO +Gk/3oeZ6PU/p1sBBed3ozEQB/R0OJGaED7aInAQQAQIABgUCVnwrgwAKCRDAEDUa68F9d8ae +BAC9TOnakugNBzXThEyCHhTdBFb78Xf8ZM0QmPmJZjT9TMsNdp9Ml+F06Qes20B+WKHq2XwO +gBvOWYvlPV5tRD5OreRrLIkxhY7NBTFM6D2wtBlAy3WAVTKKXeNq7/yAlF0+sh1uF7/F2SHS +62CUzDawJEGULBmL0BVMuU5htRNZnYicBBABAgAGBQJWfCuFAAoJEHpbDrlPA1bRrpQEAKPP +7d+Sg9rH40tqNFEr6cIBjhC3vdHKF5UywBDauUgft8C7dO3xCIP0iuni/RYkO3kFCI5O+XEU +Ptp1uL16avoMksAFPEEAV9pmZiD8NBlJ6sAptIodJYyFIyZG6t5Z5rYyPmA+rR5wNrmyVzlV +3i4nxFSVGf/W7Ggs1k9doenfiJwEEAECAAYFAlZ8K4cACgkQ0nTnh/E8yJ2UxwP7B+D76rrl +sd9vnCejCmuUy4kWGqx2jA08KVu3J2ua9kyHbtRyJ4/dBAjpMpmL8Q79Un2x+1O/AoIX1MzT +9Cv9ACj9bwKu+a954/PjRxdPn5Ppxhf5ZCaTFiMGHtHUb9Us27J5kOHJafy2P5RA3m+eP+oL +3Yy6bBaqJG+UDLVIXaWInAQQAQIABgUCVnwriQAKCRAJ8QDe047lcIYyA/9Nh90qY1BPG6qW +9frIVjCwxBqJd5HpAJONDHlva1/qqN2BjOPugob3uMSdgYACdloYZrrc2vcbDdtgDLalG97x +i4HC4JsGAx2I+rmD3Gmo46bYhibZYmQBGi7y/m+n09cX6WsNlFjFyq3POfbJF9HyC6VIdSsY +3DKuJ9qi2HzKDoicBBABAgAGBQJWfCuLAAoJEHzwaFVKywF2NgID/Rr1I2NfXdMQB2C3k0tA +fBrJc/YQOgLFLQ62k3PONmgBieunnrNaMeXfaLIYduwM/8avQDdszoceUW/ANGYaZpIsOupo +AmvX/qGQtT8ljwQzDkpRUbXUR8XtLTVfxNeY+Br35lQUtobakaUKXyDF6Iykkg2LTcQZoofv +SWf7/N0siJwEEAECAAYFAlZ8K40ACgkQnQR8MYbJzMZKoQP/X47N6gECWJocExyZ3wD40Lra +tgJ913xMzOZ9sHefKHfDi2qx/9am3S/awwMYaQt2s6MqzTTkXFfaollJLQvGIjFwvxkk7E6o +K4V5snvz8Qj/OmtlfViswNcytr5RRO6zR7Pyn51A2T3MQtV/N55f0sSqK3fH4T3rb48bRT8i +yrCInAQQAQIABgUCVnwrjwAKCRDw0TOhWw9SLeBWA/9NTfhkf1F9H79Lb/sfXCEnLHnenCOY +oZPdN4erNnjpQOHSXPSiYl9BHxwW8r3jYDClLM4O5taZhRDEzH7/xZOKUJsw9YxdlhKlciir +vw2Y7lzhkRJzJBWnsqAiWd9F1MpID+Cp27PzlhLAuQKu+B/aRg/8oBln1kOr7FY0MN5wLYic +BBABAgAGBQJWfCuQAAoJEBEFWUgOKUxd8nwD/2nBjdmJwfDlF0I7dnPx11irnbyL2ciDheQh +NW4wcF4rc1xt/oybfwwxzrGwKc6bfKYTHT4Qw4TlvZ3PkbUhpFw4ueH5IdulcV/fLD+7HZhq +qua/vWfl63Nf4zBujnmCcGCw3O1f7YTPAubeXuDtT9GXw6u4v3yyvjxG8J9bouvEiJwEEAEC +AAYFAlZ8K5IACgkQ/X7f29yvezd+mAP/UJjQarK2ICHBOEd9oX4M0Fwhf1e8qKd0RThNdMHm +0Osm1SB3Uq7joY6AbSGX+YNB0QKMFy5wzA5+KGvlBuYe7mWaGIsv+Ojnb/g7hlhjUxf4eIAK +mjpbNjpqdtTXUGzSdhLqNnBNTJybtiNVYp1EEPIU+Q03zKg3Go7Ce6oQdwyInAQQAQIABgUC +VnwrlAAKCRC4WDETE3Pxvm90BACwdnOkYPfPdlDmrP7zYX1bBWpDiUZ6HCZ2zlqmrryQ+S0X +CrAAd+0T31cAfO9Q+iEtH1qx19+d/5w8KlXdW5bipjO2WMhq+eqy0B6XQSnx4LOCY7spklvZ +Im9Iyo6119Q46ij7uDTegX5hnc9mVmHJWZ1EpaDTK97/EOPuuFoP/oicBBABAgAGBQJWfCuW +AAoJEK6dwsUvJRsJPgwD/0OjXMHqvIO2VZFMTLSszmlBmjHpOkUBChrve5oe90Y7tzxP2vbM +qLQtUHgE5DCp9htbEXZlMXKcNOdtY2algf9aTSjJmX8Dit7dHjrUE4IKlH9G7EMbU6iRq5Iu +dkOgPgpMsxgJSC7hwkKq5+lZMA9l8NEc1Tb+lyj3WRKU6RRAiJwEEAECAAYFAlZ8K5gACgkQ +Peb8VLjwprwcaAP/dtVq4mo5VVQGJTfLbZS9duhMJFLkzP05OX+riQm4V4luhm6Oggd/yY81 +4G1Mt4pvsrqXNybczOY8VkfNrjIrUnwC+nRGkxGya9KKPEPw+BMrdoVCbdlecBbCHfvLmJvT +sWUoqW4tGuRegs3gh7GoLvhM+hz5kPoe7UHgVjED30GInAQQAQIABgUCVnwrmgAKCRAp8dY2 +TueADPbXA/9FOZ97w6ueUHZ0KWxqV7SYhGLAUnqR2c2MsHGjogI/ndNR+28epldorNMATRKv +JEiHZVqO41dpKP9CWOqClE7W5PW2KSFwVBKAkzoSDiw0VJxPeajPMDIizunBudpGaJ0XmRMf +289DizJPYO1mtjVtjNzkHBLUYaYlTzxIqr9I44icBBABAgAGBQJWfCucAAoJEFQ53lWV8q0Q +bR4D+wRlfp0ripec6CisVO6vi4vH2uBaY/P9KVmASbLT1WkjEGaHncl1lN9WLN8yXmSJdryG +Ss/G7OpJbqWrljAYJdCSlsZJn/J3/ny6PqWkFgnAD/ci7Pcepd6xl4T/AXBLCl1KzG9N1cn9 +smuXsRjJZvkSOrHFu0BKg3xzfoj3BtjoiJwEEAECAAYFAlZ8K54ACgkQsCgymgwWEbaTyAP+ +IAWMCTjBizMljOki4owyQYQo8cbNtHdiW4ZxNUUZT85PisRgi5jbuYhweKW+7OzPwgMRJT4m +hf/GSUf6gAgVoaZQ1Xi99m2cfnXeYRFrTG1LmBgEuTYEdCcncEMQVdrVsgDdjfvZeTy8F/4k +pTZ6cpHLElksWzaVbqDPHtF8fwSInAQQAQIABgUCVnwroAAKCRAo/5kfUP473bHYBACq7pjz +5xAhgZLy4jSLFI+eU7CrObX/OHRqIrBpvU4CD4lJj1bi4xnZNU/TlwxW204aomy3Aqn08hOR +193vBe3DW66BDc/2b2fDrMno69Ms58aPmCz/4GVQHAPZIIM15kyb2n2+ZSY5cKy5+L77B4Sm +wOLNDOGAtcgP/11xceYq1oicBBABAgAGBQJWfCuiAAoJEDQhg987dWGRzxcD/jU3PsrL392a +TMFFN+SAHc8uEn8K5v+6eP5uBIbfckxzpnaQbdVfjgXNmFTj5G/z3l5rXMjCHaHWxeaIYgpO +Vv+957y67uTB03+poqWAK4F0e+pYXRofiVdLeVfmBOyhwNDbczBZThb3eII23H/02Tkkg0rc +CfhEJ5KAd42vQcHbiJwEEAECAAYFAlZ8K6QACgkQpP+7O+dG+Q23BAP/cPf6lTJSpcHoKEdJ +a8BuZ16pLZ4MBputMCtwXSHyWKK6BfWUgzIL5eBKP47r6ig1Nn2dPbBQugwC59Dzy6utyQaM +F4gwrZyaJmJSmJdAYb/BA+P9NRJjz2WlPXLmhx1w78QPRKhvD8LHRVqTdTUJW3/Ppk7XAci6 +pmBbBfJed3yInAQQAQIABgUCVnwrpgAKCRBQ0EUT2RO5J6xxBADUv6bTCSF1P4PdAtRo1MuH +6Rccjh/z8i8+ql0UkrsGKOzKue/BX4sHHgQBWVYVg8vdHCEU3/JJsXpz54LhFtQU1a4WXdCx +BjTEHkfhQhP7jRN9Eyiuco3Sp46mqjGmvMMOFDy7LDer9/1zBTRThaWHQ1UzewoQnxrQhKHK +sxiOC4icBBABAgAGBQJWfCuoAAoJEP8sFPMm5fft6J8EALQhU324ClPbe74NlkJqP0Muahly +luFiyWbAU3VTNmZRN7ID52H8bqCnf3YNN59yjdHjzn9QSKBdp4M0voqZphnIgxOjr3BQqbRl +LNXJf53ZpFZ99MfZRGPisD2TB8gjNhZrDZT4ASGa1RUrZXoMn8MQt58v0K7g8OxBjQZNpZ8V +iJwEEAECAAYFAlZ8K6oACgkQc3ThLrt1irok5AP7BRZXm5BroKQvOrbSMpR9QqFrQUb65VOe +mDrxeB4qkoFKEudg6NLtaDZv6loPX8yiTIYd5xFQrOMEk8KUowdq5ZpD03hj5H/7FVP/rl6G +oVZhgPdTzPWGLSeqQGa6IB7JRhp7kH5DAXl+DqL8yh6dqlL9QMqnC7/ws3eitJV7NgiInAQQ +AQIABgUCVnwrrAAKCRDkONF9xSlRWt1fA/4w9RwBMHwu7B/GSG96O8hSsPfe6MHzCHpHqOlT +dh8lX+qYg8SzZGd2TSQtWePb3MdyHIuHM3y4vw8JVCyw7rNw7Kf9rjfhdQx8QzFbhu6wrxjL +hosWJJF0ylnuokLHAH5t0nETn7OcaXmJplCKKvA9uMuvzUsra050prhrcKTwLoicBBABAgAG +BQJWfCuuAAoJEPGeePhFLNkdKr4D/0jE1KI0DjI8+jXfY5enRwfDBDWSjWWht9TQkIHmEfAz +icbo1Ho79c3l4hrAbQnGmdcz3VymOvQTg2OnBRp4b3612D59dMNt9Ww+b3ux2nklrd19RYj9 +rempb2C3gMiBQpoWb/8tZ3+mwuLXuHeXa8WivGP9wuFxrZq8xKnLhldciJwEEAECAAYFAlZ8 +K7AACgkQXOeYf7h3miSfMgQAh4C8cZNYZTVucsXkBsPssQDdqnIkjApQTr8z8JxdxI0WXoSq +HmXZcCPytJxRldOcy24VJ+43Oxkc5t/2UppBrHPUZqYpjWOLvY+fYjzSqjxP1UteICc8GFgv +7rnrICf2wwly/M1mbyrH23mG7FJzlAE4gzrW7yYCJfmkfc7SkLiInAQQAQIABgUCVnwrsgAK +CRDtoc8Lp1F87tyrA/0fUBxA8nMCNqXnwvsTvOtnfxdj3Chhw3DSd9XASCJmP0/5UrQtnDhy +0b3/mIGThPZAerQfTX6WCZpQg42KmWtsPvAI8N57NkFcnsmSecVLOPKID3MW4xlNWiG5hbM0 +JWC/ru1pnNtJaH1X+6sWLlHhcZukLw7gi2r0B+faNG2s6oicBBABAgAGBQJWfCu0AAoJEEC0 +/w4ZtOPU6B8D/0z9zYX8D9bz2Ju+ZIUy3ZSlkboLrusX3qp3sJDkuHRRZINv0vp0L1wfsufD +Mtefd8CD5qmEmoMC7A0KYfcW1s0cPAa6qWfBmfwH+cNTVql+ZEaejgW2O8qXn8df7prdbiI5 +HRfWL3BDy/GyrXRWwLoyJAddSs9wlmZQQZ5J+HmjiJwEEAECAAYFAlZ8K7YACgkQObKkqsj7 +w4Hn3AP/Rf7nfq0BTgrNa/iwh4OHbIEi9uyJPS7ujr50RQXeZ1LCm4QbmE6Einzon6DpWOLe +4ZTgV90Z9x/yxp4rHXzaFOIIRw2P4HmYFQlU52y+WNmIQFylLCHF0HZM9PzYFyzzXw3UJRWU +B/+5cQupL2gTCsvV6+BDCz/5HcJL8nLBn86InAQQAQIABgUCVnwruAAKCRCobXoIgRWGYP2L +A/9mPdklpv1QxHf9t52RCvRR0zFunQul/nJLj7P49dPLlX/fXuYcc5nJp5aIV+z9yBhlG4Xa +NuMXrFmY8z6HNwRems6tCccmVggjhDwG6vwVq3o5fGdVIc1XpIfD7W8J/CvqdkJOHOn+k7dl +Pl9e3yaAoDpPc4lr2zGCSTXBROJYnoicBBABAgAGBQJWfCu6AAoJECw+X9Q7jzE88/0D/2C1 +OymcQsNDIsBvr2BY3F8HOJ5Xd3sGNtsmAia3stbnzzFMqFVoRDljEkpZM807PrjvGG67Hc+R +QuXf0/wZQXK55ggHWqYgj/8JqxOqvb7pjrWzvVYYG5Qs6tpf3thIE6WZATuEcRYcvayq/ApG +JjhxJCbkr/dQFrH0ax5tCzl3iJwEEAECAAYFAlZ8K7wACgkQHl4wHtboCRaCpgP+LLqSGYu8 +xgUBysiq5ElCVnEtIV6j3c/GhC1YctdkNhyGoTVOE9+tjenn0ZLMR2ixPc1qiV19bpcj2hDh +NzYgpKBGlTKxvJG3fY9Dg2nT3G6QFcBFLJpqmCFCixSTroRPJ3ZZaFusostl2+PPGV7TxaYq +L+qT9Ox4xfuV0qThw72InAQQAQIABgUCVnwrvgAKCRCUUYnlVoYwreKjBACzx0WcZf6UhJ1K +FRNTqMCUJ0gtW5CE6b7cOBnVpPcEzdczpJuW/Ti/ZtEJUetaJj4oOt9ht2MleIf4V24sEAyV +GIbeS5PTmgWesNhpwvET5vIp8whg8aw+DLvmj8JQM1yyeb3ybQHjNhMkhaFyB6KdfAEZ2RdN +IMXNmVExCGnEQ4icBBABAgAGBQJWfCvAAAoJEBgJQFRv6mOn8pEEALgZFeKQYNfTwNPZPls1 +WihQh252+R5t4EPLR1eOXwnBFNE9+ismPT8ju3GO6pDgBj4YsVhWWznLSAgavWgGwmLxUBlc +Nr8pw7CFz1V8F2aaEJ2cfVbTaCTPHkIsMM9ulTLZrWhZqVpAy5PzNTb0yFtplAXyLXQgki9W +sviVxS8iiJwEEAECAAYFAlZ8K8IACgkQI7S/1KfGwDiK1QP+M6OXt37vvmBn0rNhbV5k6Rba +Nv2PzDcN10FUcc6nsYPJm6kRwLMWvR5cBkWkHEVPnAKBo2faSV/Q/Z8AXXjPTP15AnPPBdP/ +0aHEsVozVSRV3aGbuYC67XG/jGrjoZ6azbGGigzWSZ/4UJHDRDUqMctvnSG1UQpLdTpbWR3L +CAGInAQQAQIABgUCVnwrxAAKCRBCOXPKsVlponodA/kBjVOY3z4kjZ4m4r9V3RITq3muqSVN +0FCulr3Bq3wSWlwkNXHJ9C3/1HY2zLfOL3t0SUgBr+htx/XNOy7fEV9qolZGvHj9ETvNn0di +1TAPbXZKYlk3HigUs7ZR2yWMIIY8rZ4JoNdHHOZ1G5xK4paV+fKpIUC6hwPHiyNvECvitIic +BBABAgAGBQJWfCvGAAoJEI8yHbmnMcBfQYQD/jNfegnHnnoXCRuhEaYL5T7DWQSz/jd/I2qX +YkH2WXRQVA9DWTu0eMoBRmhuILqq2i1oigmj7cjzvy4PgWGgy+V4k9OY/9QK3wf8vp38uxji +zc69ra0Frx0pJLfbUo9V3Sp8Yfn1G+jV1nOtH8xmAIZMlKDOt8LYNVhp2ACu8jGCiJwEEAEC +AAYFAlZ8K8gACgkQPMR0M2tU2+Y/jwP9Ghz7LaOPHeOozCuzGKzu2Ig3fsKJKi9m75lBVo6V +GVsPOcb2M0Jl06uDNqGNud0n9aiVd85jKB3CZvicLRPWgxOSY2OIQhbyxbLmgnNwZjubPGO2 +q4vvRgDOtgTOIiVOwZyjojdId/jclkHTk1Xkk06tHfe5PpoEQxpVxtGBFDCInAQQAQIABgUC +VnwrygAKCRDZ2u0TyO4nx1yjA/wLyjTotq44z+y8ZWjiDklU9kbs8hoKdWJUF9BOKPELjWBH +9NRrObGsYYT7igRpbLKr4qUurr2CNKVFTInuzomJmwdxA+HCWBtsDCnbN4kzH61ched/4j5o +TIdeckhTyo4wiIgBCFtjM9xnG2nNXlYZ077BXSPHdN0wgUIcTLejmYicBBABAgAGBQJWfCvM +AAoJEIqv9u9uZLjPQDsD/3JOk+ce+A35UOMCxR4CwKOIo/cUnIiD8qdZ/pAFt/R+aqHqJtsW +saVG14F/JuQAISeLrOJFyNfr7+Qb6lRDtg0BGqtvs6bpCydxnOKz+oSvaRfrIivmMuMO0SYT +0R99fV/jW+9nE0eZeiEZ5lcdgFJnVH1yKZNfjELk6XwaA/c8iJwEEAECAAYFAlZ8K84ACgkQ +7N1ah4XtrA0QCgP/SGqDcIxME/FUW07mLD4m0XOzrAjnQL5yq42l8yJPhOVqBjiiBSoOKcVp +K3D4D2rnlYvm9KPS87J5WI5tDNWJp4IF7iNkZfnFHynf/NfabRi7AlIHPWfNgYy6WDPYx5AN +N9+vjwzlttkYHtv2ZeSdT5TK8HfVpjvCmpQD2UVsm6qInAQQAQIABgUCVnwr0AAKCRBSf82e ++B+3+wgrBACQCpMsrWgrJapnLnq9pxseK5kFTg8agd1vJ2us2rF7wJ9JtdYOKN2CCWDjQrbC +lyk0soREFUIGn97jO1r/jFonPWwurU5y6XtgRV/u7ZymYJAYV5E5zmWpZMLS5O0qJx/PoIfU +GFKHpQ+0T9gc+CyGurjMWcgumke2lFpVSGQv3oicBBABAgAGBQJWfCvSAAoJEIDeR6dxV9dh +VUQEAMbzCIsv+LYNvHIBm70W6K2fgYZK7JsEAXfcBLZ1HxzwBSDcPMAyo81Y59cBrkFoejn5 +1rob9MBIfz8cRhug9KwkHsJfJf+vQ6I/VNSrkt68yOxJXW9YOw8+C7Dpujv77RIXFprwZMsI +rEUZSdMYigl/sQxUVI30erBoQ9vhlPkEiJwEEAECAAYFAlZ8K9QACgkQnoNP20BoBf7LHgQA +lSolMT+GC+lcqm1plpGDNYzxoeNNITguyYikp0EcVA+Kp8NE7i/L+T/G8+8vv5oY+FNAiidi +tO4lSYLJHh7oEqkIf5fUVhLb/FfA99+46RGefZnRHH99djGv3zKIT2WuTYe7i7wN3F8++Ka1 +D2STEUxzxJR+9/n+HtAkOP9GGM6InAQQAQIABgUCVnwr1gAKCRA10r/McNc4b77dA/9wZqwk +fz09CpB0WX7yB93ndChiGjB9HvXXH/COjZ/v2kTCdDHANTjkmCH+VGzdRct0lkyXQdGQvuZ+ +3u61diYaBqPZ5Mi9txz+KMrDnGrVY7h2tR/ZMjalvGjGf9sNechquae8GNyNAZC1qa4HJ9rI +uHtb3cESdoVSMQHJxer+4oicBBABAgAGBQJWfCvYAAoJEOx/ZQtRxqyX1sYD/0sUjW1+84YS +rYsfROPnNqal/Veq9fmHMiEU/i2q1onvel7wjk69vznemKBgPQ/vfr9lqLPMGPVW8LXUOow5 +u7aO7FTQlQKKSqUqAmShu3ZeTDQGang8E3EHJ8aQgT/X/04W/FpQywHblk0x52eAnfqefZLV +JUenxqT2V5Ol3TNYiJwEEAECAAYFAlZ8K9oACgkQzLgepPZwJED6NgP9G1HgJOWeBLtyR/4U +BgY+fcgvE/kXNwqxJZLZwM1Z+bmhAKc1YGUiAuEXQUObe/MdfSb75mhfXUehUIpbHUsQT4Mv +4oAmJ6HwKqbZJjylHuNNhSqPlu8PDnKySlsKoASjAGKh005mn6KAOSaUnbZEq/Fizj+BOKA1 +9KKnCzkkKsOInAQQAQIABgUCVnwr2wAKCRAquEanD/Y2wOqCBACuwOheDNnDJNA7TP2j3egR +X6GcUpOjwS/jR0LkizxJq9dGna+AgVS2QhjprS3MGp6cXjVWkOJgnlz8mUqbuhtIUZTL7KZq +Od4BLzIUCLaSGUOX6PTSpqSWO2cDNaE/j9TVEgon9eUMaimkHtoUp3/ZcUOTkpIZclCnU1PL ++5NHsIicBBABAgAGBQJWfCvdAAoJEEUs+v0XrKqCasgD/30o+EKDzDPfpfwHBBgs2uNXTbH0 +jsH0i7onVDBCaxv7JwEdIERnOSAj7YI4XeHVyharLqwlwa3egPzKA24S7DyS/TZPoZsB+2lF +4z+veJQUKgVzauK4xVkfzp2KEV/otARAk6pzOh7Pnd1pmjwEh31Q6Ek8Rly0Jq2KFI24a+Wf +iJwEEAECAAYFAlZ8K98ACgkQncP3ZeqMLrU/ZwP+MMs3JvcGEVcocr7+cKbzeR2/4O3nDEr/ +ZOnifm4Sru9fD36vCfYd1I13CVz4Z0oM6hav5bgsyNb1omZ5AO8iHK2TY2mj0V/R6m/wZEaJ +JPO79dRGR6e8BQQ0TUXnhKoTwr2dNjoR9HLjKs7QoMvzILbECVdmU1f0Lzgo8LUl6/WInAQQ +AQIABgUCVnwr4QAKCRBI87QfSnnCfhneA/9v9cbhGWbEd2aM9JgV54qshxwaJayTrPhdlb8v +JDu8K4p/k7tPO/ISLhesnQH9yK0hmc0+OuxeJORqPHhCHByQXTmBcGMus9lAmCxctNTWsA3L +qGNzdkb6wumcRsB51oWW/h4OJGld3xhy6O1nKYBdqFIS0pKJG11/qiMkdGxNQoicBBABAgAG +BQJWfCvjAAoJEBLwA0++0o2i93AEAMGCgXE0xWzEk30P881Asogr5GIpV0OEBjHgUeNlc86H +/fRrkj638APOMq6k78SIrd8g7QWiMpWfgfaF9u7wPMfRP4UG2oVRclNJD0L3Fi9YnoI99lqH +F+3WDqlrhgPEgoN1QM7udl8PbJJ7ZebIDiKU4gYjbzUarmN6oyTLnThPiJwEEAECAAYFAlZ8 +K+UACgkQY3r2N2c/bC+oZgP8CWb6G6E8Uuy2ByYqDUJ3iQ2AcGvDRquS4zYAW+RP2z4/Q6dC +rhBaYRqYXN2//0ZxlpjcHHf6ASiMF1UCBgex3jU372L05ZfdSaqdBL8HmT83PTaxAz3xyWzr +9aI3xamFGQB1VnDhUy24llOJFE+IKydGwj6ieWtv92Kw0lqHZimInAQQAQIABgUCVnwr5wAK +CRBkHZ7jmJZkzAPGBACnnmxK6nAn7qj3dtQmrh/OdJxgfFSfwN2kNzPJqpV/c8H3FOervu5T +n1aR8LHaQtS/OIg12uwLg/8N1kIy/sUOeT8N229eicdwiaV1OBrnaLYxI1iNwdS1Majo0r5R +Bi7YiBApF8tTrFd+DWOCdTC0VK0QmA7K62AA27aPkUzLb4icBBABAgAGBQJWfCvpAAoJEEn0 +qLgYq062NF4EAKfy17uLdfBX0RTl16zvNK10nZWOuvsznF9q5w8Qjr7oyYoo33aE7Ux1jOjx +Cww8KrgJM/aS1SWPuPefI2W/mKmr4Eneg4qD2eZKkf21/1Y8r8kdPpZWY3vgDdHfmqwjKc8B +vWvrrIwY9wmk877wh4pZQwsre2/D5Yuao8mFLcJSiJwEEAECAAYFAlZ8K+sACgkQHM2uWmiq +H3o0YQQAz7xzSRNCTMjimT2r+igoghy6SZxUbAKdWLTZ4qzdaxoRdaycFpJQez3g/DOB0DZb +lnJadt5PhRXm0WGZNW0MSGo4OKFhkBHc+13p5FgFoSKErQ+7TsW97SJku8zsRNYL/0CPUY4U +PFoBJjX/GoZS1rMzJjexobwQSdVCLfpSFl2InAQQAQIABgUCVnwr7QAKCRD/Ga+w8TKDGtXF +BACR7IamzkyIHBFti2Q4fD7J5aBg0tI0yECf5zTnvOv+I108NBIuhY+cUcybzkwhhDrYIaa9 +3pJYAk7dcr5Uvr/XoK4pRKRgVoCSFe4YqCeQjfdSk1JMJSBUNOHaJGkEgXrm1errAT3VOXrV +yaFAPLBSVNTBhCc/kizBtGrBlvEzWoicBBABAgAGBQJWfCvvAAoJEC6VPIzcNOywwv0EAMaE +qG7qFqrOv8j2/9RGDUeEB2n8plBVV2Nw+9BnutpxDJ1pQX5Wk/GSBs57OsCWvQK4YgAO1pZr +6M9ZNcidgAQqCh05+SaXMxQivVx7iXsDc2hfbr8QrBoPgzSrtnfnEqAaKS97ZUnIYO3ge3/P +6ggXQ9dPQHkqn1hQZGymdqbqiJwEEAECAAYFAlZ8K/EACgkQNRGfnJuSSxQTQQP+IRTYqIoB +gqHuItMfWOPueDvKZzIT8RekuY1ROZqy4yWFgKBq73D5a+bnvoxYf09jmckl9qVf9QJmNz9r +IUIUzOSuANThosCAESsqUatgzW1XWPoGw7ppvomIQwcwXlyYEWYnxnevyN+WU0l1MyCrUWsr +bWXooM8SLqIBCrrtqUKInAQQAQIABgUCVnwr8wAKCRBx/osqPHoo/wMIBACIj4T88OroAJfu +6zLaUOr7glaq1WInFvSnhJkMATSQWJRj5dzQ/7e/Owil6mltFusN+IzD2rf9BVu7JkC2HkQR +vEUULPbPqMZpygRkkwvLUSLiZl/Hg059bumdliFHd1uPLknFPhtctWNH09vKqKWperIDlyEt +cEQGCbKaT/HROIicBBABAgAGBQJWfCv2AAoJEHE7l4CkUCYmXBUD/2xybloXdB6iUR4bGQbX +LIP1gUxSgxNRE/Wejbwe/BnLhk9hTgnSm9PcAGSAnl2f3qS2urwOlKdsxeZO7X3GNH8HbXds +WKT4Jwexl6jf/+bLcmztRd5vb/KRWW544lGw697mrMLr7G81K6mlb7IjMKRzmy5ywr7IBmr5 +CLO/iZ8xiJwEEAECAAYFAlZ8K/gACgkQC2ZvW4X7KbqRKgQAh+APX7Sn592HHKkQyEox8z25 +YsgnAIDBw9a2eZws1E0Ki9gHdX4UdANK5KFzd5sVBGOCyCJGySzxeSRnV2CBYsH3yF9VGpxy +LFw8TSdtBaHLpyjqFiGkt4npSPJHL92Y7AixiVQ7aZUyMqSHTctzJEG9qxg8m4dNX4TQsZzz +H82InAQQAQIABgUCVnwr+gAKCRAHTTGIeQEkWG89A/9HQwj38j91Ur1X6Dtj+Okl+qIE7Xo5 +EBfR4PU/SFZMCKxnE18X/2LEMLBMXLpB9Wtal+Jb4bQH1+c0J2e+93odU25ehGEOTO4JktVM +H2CxPH0WnzqMWmLZfizLOni15T7cFRxtIfgrSaL04m58f0IEH7g2v8tiY+9n0z4Xve8lO4ic +BBABAgAGBQJWfCv8AAoJEGMc31xg/Sj8gLED/391VPK/cPDXPciXfapNyQeogauB8PnwLLQ+ +h4/j1syB6shdOMHcOHaZX+YvqMZlNG9j0wRqYjMC5GXFNkiKfu43Ixyo3nMsyrTV0QHplAa3 +4wdVX8udW4tBfTwdilDPUO4a+EHvarw57XyKOBpYEKW6yv00khY6Mhd/9B2f3KTsiJwEEAEC +AAYFAlZ8K/4ACgkQkVstboxqA20slQP7BLSOcY8iEIkdP0+5n+RORj4QErw1F/06wz4DXJkL +E/X4eEztD3eZ2PP9YMAIjke2e4yDndlnOq7qP6bDiZNFiXp8WJw35TFwHHRx/MHyuUCDCNcL +JmaUb5JLbu48ZsBp1nd5d7RQjydITp5vYeDNxHXscxq7IeFfjFTt9ety+G+InAQQAQIABgUC +VnwsAAAKCRBkTzN84Whk+bHhA/oDGz5e+0tZgi3Eodm0ZDwdlsI9F2+B/XQaJpcwThkUUwV1 +EPlgRXzYjpYKcsLlGiUAKQDPjg6ohZwzEf2gqnGYczPiJwkiijPPxYL8LewkRmS4skRlDKG3 +whjgG183EW/td5N+29dT8MzOlu93X+2EhRqZjcm+0hEPY4qp1fjEPIicBBABAgAGBQJWfCwC +AAoJEGB4KJ4SGy4TCbMD/3a4ojFJa3ksfhHFu9wt5I2DRACiq7eijvr+BisGjBNxC/HgjPmL +8LhWgVFaOrzOpMUMiSuRLJHvS+7oyO4NlYJec3Rd43ZA7LEgyA6rezV6OvkW8o7TcZB4O6Q5 +u3/yYZqRqdFi+QT/aAZO+L9kKLDigxn9MJBjiHEKA59in/9biJwEEAECAAYFAlZ8LAQACgkQ +VYGVFbw1+G/2dwP/ZoghcmMz4rea54D7NcSGB9S5+6BUvkFQCfJDkYhv4z8eezjHFkm9K7SY +Pxiyh2/vP9KwUGEqkStVxGo2TFAluBamjmEn5t+05GHv3z+1sQoKTVKzWcGwKj9pDS9U+EeA +/0d6hn+XFoWnb1TCDRLuPa279Lk22TkPR2KCZXmeLcuInAQQAQIABgUCVnwsBgAKCRCOaDC4 ++tJFT6bkA/4+aZAmkWypD6crKoo+sWVNikyt+12f78KJzC896tab/EnnICHlP7GddvPAl0HI +KWDztYtAihZ4AWnRrcIjO279siWqGQXFTgfdwNyIF8dx5Ae7xZkIQFUQ5/oClnLm9lqvtHJM +nefVLCZ9Q9YLCHox2DgxEzJOW7giPE4Pp+GiHIicBBABAgAGBQJWfCwIAAoJEFsg2kEErAou +A6QEAIbl/7dUNO0zdn/7J35Jd5jSuHHBbot2JZRA9ic0tALi/j6bZog4o3PxMxq+jJLCnWtq +cGDpAsrfIlCKcpOqmgqT+OvbOMXPVHPcie8RPlsbwxg8Vjy4XmpQODrTLcsK+3CWxMzPX+lX +6+DLmNm7Re4Lde2RCfChJ4PawfESI96ZiJwEEAECAAYFAlZ8LAoACgkQDpNu6NhWp/8hsgQA +nkdjx7DzkODKkIgnhCmdEnDilU0hiTtaJeHIETwoXBUIWucbap8FhXfGzL2f59ItDjUB7FiL +ja2n9zYNex+z9LY+pdQoafrc7Go3jtUxLHwGNqgWtIuFtNlK9tgM/phOjae9B/XKxfitD8yM +K/80JROtwP69/f87340Sd63zKb+InAQQAQIABgUCVnwsDAAKCRDtwxF+1nlOW9vzA/wJBJfS +a0GniExIYuIQUv4vsu4Ul7sjqPr+5v3Y8YCnQiHfcUOrv6EeI4xxevvuLCEjVsSbR4ld4kQT +5dHWhdNU0/FHJiaa6gBEjnOCLtNgtzs3dpQ16/8khtN4aOVGZ/R+DL4DPsq4KIWhUMMykCUU +HFaWyzcrdc3NrMPLTl5SUoicBBABAgAGBQJWfCwOAAoJECte4JnsAUxEq3IEAIAG9+oEhywR +TQf2OtWyaYxz1NGoty5iFDji9UfX08yYMBuwcpu9oHruZXJcvW1qXj9Apz2qKsKizEPKnCvp +WYm5UOdxTyCQyeA9r0nxSLZ5+fv9XuGqL1eVY/4ZQNuZfFVc3K7mgcHwQ9JffrQmRL+oGyjf +IAY6J+xIroUHiI+niJwEEAECAAYFAlZ8LBAACgkQ7OpOFZqvT8CmogP+MT28xAbCp4WAhvtW +EAaLNIFu2C22cUjcUQ1OiKqXcXkZtrTpllu1k1GovvZ1ryQR0hFRgU4tuFs4oI8LFEhtAM3Z +kJnee0BPrdUryMMVZt6iZG7yyVVSp8gGDJm0IAHGwkx+yWajdUDkAFThH6IWxAGJym5oh7vb +ps0DdF0w2IiInAQQAQIABgUCVnwsEgAKCRDW7B9OWDyv9+6AA/0WsfprPd+3NDOIq+8MFQAx +T0uDkLRFY6rMPqhEov3mc2dfdrWOl1IQX314hjXZ8hw/zp7M5JEe85G67osFk6ToKATKlICA +0AVbHAROufEwNcKSTusQPBSRvOGP/VFqHx4IsBeKJsjyqqPWYxsJpvTx02Z/GqG8Kwce5/ZQ +bVojk4icBBABAgAGBQJWfCwUAAoJEDQqypmcqbjrZNoEAIsDRCXBlrgMdwtpbZ1qNCvPV8aU +GcL8+UX2y1BZwJ1W/GdYlhPuQjAYuTeNab1S4aQM71z5WdpS2CMdC/eZ7k2jNvCnKTT1Gsgr +xPfyHzxSH0t/HhzWjl5MzBg987ScKIgo/bLaYS/gk2c0o+4UGIP8NKZUWyH0X5Hk7vwtaFju +iJwEEAECAAYFAlZ8LBYACgkQOxJFkaPJA+AnfAP+PANuKbaGA5B57FiDNNvqvOFr/xtF9Qxj +EZT8drguBiSIwtKE+emiWh5m3syYNORfbhuAmTbggpTmWYLZYWGkHz9ZEtOzU2gLXAicDMq1 +WDrpddAu/rv1VLXXwCaLC5QtHRkzf1jo35YQw4odgap4G5C6Ft3GBInFdterF4MjdneInAQQ +AQIABgUCVnwsGAAKCRAFrUOl+OStCiJHA/4pwtxpvJy+PwkUQQi24Qu3CtoCZc2/yrQQlCe4 +ZXI30uEoo9K2h+5WhSL56Ksf6Qti0pntnk5AjNr/D/iKwVRCPhfWcB24kd3FNrWACSfpZQUd +oXqj6KLry8DGg+8v8TSKMtEMl5ggBf5iMwjO+RL6fvD90lKTdWutbt29AH2YL4icBBABAgAG +BQJWfCwaAAoJEHARIMMsTbaNUzkD/jTOClAgxufv+CuLGwmP5Bgrh/0xhKnLnSgM0EZ6uFTQ +e86FUuutwjdHUaDfqR9ma/ud549cSjans1BGBNDXkHhzFXQ2IC9MxQ86z9sDUg1O8PyWJF6P +hw7EAhNeMDOpVnK5cF6jMQSZxeCQTJmW2XNOJpRQzK6k5mAzW62Z49uUiJwEEAECAAYFAlZ8 +LBwACgkQ9KP/qKzGtizhiwP+PQLhttaHRjoZhro5B/xxQx4r9AQlbfUaxnn5+H5AyoAC2vhd +siKIvDRXucGU2+8R8y+byEjVeZdG4x/WwygfN+8aM5wxulQbp/ayBAD+6OJIaKzn0OqFGhRR +yRCZ3acD66rDElbW9ElaMMXUom9vkdQm4fAmPFAq4ihdrl0U3XuInAQQAQIABgUCVnwsHgAK +CRBPP2ra2nl+DDMfBACYoku+ScPXxqX2XnL8K5siTvykuSWQKlRpNK3nLiekwPB9+pjOvtEy +zNtY/xWG2mp7RBwyD5CYz4/yfu3/tErmO9GkIm3KWYKM2LtOiTUGdToNbPCd1y1s0iB8BAIq +CbtJ6sZnSiyZeq7hgPKFTMJQ/0xWeiVDJM0CRaaWi8oDQYicBBABAgAGBQJWfCwgAAoJELlR +cg5v4+gw8moD/iA664RHj27PhnlcTkrbW/HQy7mCTGh2oNJ1vkyT6Zy5ilT7SdabBX/TLAnG +MDp782sVzP2iltp2BbZUQ6QkJUtYGADecXms+ZSSRYMrMLUKk0+MxQw3q6at+4V9TFKEaiHK +xOT5sb5sAutpwnT6/tFmvJ4F7BOMghgCVjyT1YtfiJwEEAECAAYFAlZ8LCMACgkQa9VJn74x +4EYyzAP9FTDBYq8620iaU03YyKNN3T3BFJ+2coRtGj0GjbV2m2anXKlgCaFFc0DssQmgxoXa +Y+nPUxOXMwDF8Q2CKdeJ/m8g2HngRV7OxJST+kKC1JydvplLTQsyoqmlr7XY3y8HitkqtGWY +Wy2uHDocu7f4S4w+nAq5YMKXIG0edV2jPDeInAQQAQIABgUCVnwsJQAKCRBryNYjhoxemX8z +A/949FBwNCKleBrcPjl6tkNHCddQ9JcBE/ZwRoedT8LtcbMl4GPBqnoLFSmW686arpUNFiwM +0h+LQt/kZ8R4ko5Y1Vll9AHgdr1P1zYxU7dAeZ0Jfjn+pe90ODdlba1vKQVS7cRWPd1PTGkg +/hxjd9y01r+/81f5q8zg52t8wogLHoicBBABAgAGBQJWfCwnAAoJEAqoBoO0luLrCjYD/Aoz +vWwcbaG3gzrf1/uek4negv9tQHet5gP9Oq87XyLFTs79HBw0K+8ZzajI4xFWw0vzVs5xXTOe +c5nQtSXy9lRXky3o3AS/oS2bqDVeLUvwE+qptuK/c0MvffDRxXAlUn7EE+2iTK9oOOOpMJ2y +A80Xo0uLnhWXWdOpj/FpK2GLiJwEEAECAAYFAlZ8LCkACgkQZX/Iv3giL3KipwP6Aj/8UkHl +jvctedRX7pGrjrGzjvwdpo2EHyfBrkvzCXo2/6s5YfQF3KJsE955bMwELBSfjhEtHvSoXnsh +10HHIz6921L6VXty/o1/m0Inehjn3v1MwcZZkIF3624Ce+B5IDKmsjnZVwWNKgfzAiAIoKEo +1woHnAmHzqaFbrzJ1/qInAQQAQIABgUCVnwsKwAKCRAdIbZpd0Wd+P72BACtvBaK0WXYTXp0 +9GArJ3qEutinIlx8Lkb2fiplX7xihHYZjeYU8V7zOY2545ESbCTJPYsF6FDxxRxha6C9ZJin +Sx9nIlh9f1rclS4bWf/P4rehw0DwSKagmmQKM4JsCkJIKBWxlcPTSjPgkhpoRH4WwJuxn1Hu +nTdj1f5zhsKPXYicBBABAgAGBQJWfCwtAAoJEAIhjsN8NK822ZgD/itbhgH6Nh7wkHZb7sZM +vEhps7xqShQvozOq9D+QheSEb2QeHkdOWJUfaA7ACzFNOgRatau8wyOk8XiSZ+SS4qbZaKqT +J+0mn4exrPk+LonGY5twhb9J4TP2rl2kJXoQ9dLEAZLLUdhoOMh3dB157sO4n7CZPdRENHQn +aKUMA82ciJwEEAECAAYFAlZ8LC8ACgkQuN+KEQj06j6tOwP/YAAD6FABsoM/DrTKxSEm3Aor +rxYMInMwFHVFDaYB3798mULy3xWcDnwgERcPzoC4YBpl4zE95SGwUD4ZAjKdFwGF6/PBvJtZ +b8ZQdbo3NJMPrvw2sDRNNxedn5O/RaL9QYuXwamT85wKcv1EkDfSkyEgIliNsj33jxJ8/A+H +UJ+InAQQAQIABgUCVnwsMAAKCRD5fq8osAxCPZQTBACzSy42YCT7W5+9Otnlmo5Y8WCAPrFm +cmdqvl/U717UkNu1u1tGzT87jZ4QMHpPfI76BgZNrE4GT+UsKbJxOySEFSo2QtSRQM06U9jH +ObBETWKRbRqHHkXW/9Sx03aQTFisrn+hZfXo7k62xOkQ3InU9VkOzy8dyqDqRs9BkrAmW4ic +BBABAgAGBQJWfCwyAAoJELtJE921jQViai8D/3WPF49Kz4HQOIYdC0Y6DbV0/NH6uoFGgU4s +wMVudm8+7ntJXd/BZrzHpHOmysE5ErdIZbq61XjkPqfdW6XkIsbEuxwIgDWxMyGXfWrTHObU +3DIXOH+R+Ow4WyeNDTW6WyrYNwFFA9pb2hpyu1IPBdUsw4Zetchv/zunZ0pwqjLmiJwEEAEC +AAYFAlZ8LDUACgkQBZ2WlWaOA3gh2AQAj3XQK35kfzyJTehc+ilqeLkBIwYAsG6kIa0y8zzF +SpN/2YpqJnjyBPNeHXmfrRv2uKuegFlTV5MB8e1Yq6K5X1A0IzCbbEM8T6mZRLPG+06k84fD +pKUn6ZmXOePLUA7yIqwZJITNvpfCfFme7nkYG3Y8KrSxyE4TXN9iRqsd8+SInAQQAQIABgUC +VnwsNwAKCRDDMhkzQJ+UzBzvA/0QUiD4WZoB/2S8+y91Wmz8Jjkj8H07sBXkoBvv/zfoxmKe +5pvKOQIU/hQWvAY0xpcROsEzcCsN/mCEC/1muK96+llIB85umAzLBirW9qPMK/k2IWXUzSVG +t5BBtl0vBp/SSpbCDHMeTocXuBYYDCi+FSYg1i7DAP0c97rBwb56lIicBBABAgAGBQJWfCw4 +AAoJEERlDrLBMPdMWo4D/3+a5PCD+bkuyGa+sh3pqmZZ+yBeDqFlmC5nLmfY9y0bz/ElLZqN +FLkl/pO3w0BC6E6QFuB9w3fKLXKmVV2PYYosJgo7Hc0dlWXUqyMal79WDtg4d2HJiIhYoR0I +F1SVhTiz58w6630wnsc4cnFVci6eeytqdXueCaaSMNDRhdWfiJwEEAECAAYFAlZ8LDoACgkQ +IxI4D6tdoehygAQAx+mheSqCOnbh7wSkaax4/JCqe4XLdgHYwS3BAaTCF9D3zIWbvD5B5HwS +QU67K8eoKsnhL2drC0JYyXrh9T9BeDquDijdDLHmRvMruh48ewhMzSk0ulhahKCu2wfOyvXq +qpiMgis4DXpLGbflZsQWe019q4iila8/qr71Wo5lBuGInAQQAQIABgUCVnwsPAAKCRCDzLd/ +ZwOrmWroBACCOaF3SP1isueTqTjzxL521BSUXJnxkznAT7jLj71v+dFWUp8rxzseHNUx7FMA +NVN9R02znAY1I1RZbsoDRHp1+1FNWrZIVMll4SI42dtjGWXFPfHDnAC2Tr53q0NCWixicGwo +lDhPDOmisQ142GcCBkN0RJ6/qmUwELFVmXn3LoicBBABAgAGBQJWfCw/AAoJEAEM8b9mSX7F +jX0D/R3wNsxPb6TihSNDMcFzCmIptlfCnI71+Gn6WRH70hcjyrsBSe5XXfYcXeHYaL1ZmYh2 +IEsqgUH3I0PJPTx5kOhSbf3YNQzmCqlwuTL/ttLNFidCyjwJVTZoLe6KmR+kTOPR+4MarUjQ +reTaB5tzlklu/Ej2V0sR/Kij2tJretGMiJwEEAECAAYFAlZ8LEEACgkQB8tT4pQZ/MJstwP9 +GTckysJQBPUIn0by6xu80xbUXeoDG6AezEalYYFsTm+Rc22dc1Bq+g3ZoYsih6++CjH1Z161 +SLvyuNaw1GqZPZ/x/9etFwRIV+zl/QO+8NgkHcmhFjUY2XuTf03C0wU78/LU7biNRfNyDXXb +VzO7m0pTTH/mQQ2HbAfCCoZyIaGInAQQAQIABgUCVnwsQwAKCRC/DTaeG3QQU+ZyA/4+ukTd +bKXTrFSruAO+VXgK8+b5riXqPwfNgmrbMA48Dc6/qQiHgFZ5rZPbXlJZ9UiL07JlRuABOxgT +XyAioq5o+1WJ1JaAa5LMMrD69rrz7FeWvx1IpbdrYlq+EBlZh4kwz/29ncxlGuiBcapi12MX +16dyW0kTd62OBjSIlqHFT4icBBABAgAGBQJWfCxFAAoJEGSEkpIHAFHbguAD/11eBhOlxXaD +kQgb48p6hVrm6VZaU03EuhKdphcQfZrcD3KsD0xIYda+VD89r2MNyMh8OXEjLs7K6bm1UqhR +TbYouv9GeGY/2gwA0lVYL8dzT5r76yqVLiJ846swFZ1rv+u3ZdkjEvlwokmdd1FExi+Q4Sgb +CgVycD9nYSw7Lur5iJwEEAECAAYFAlZ8LEcACgkQhZxZHTBCF5izrwQAuVlWihTWuuPde3OU +ZOD212Rf/5l2kpyu2xNfxV57BVrzvGjeC75Y+jvemT9xNVAHthIGAU6xrIEeRcyzH/zvezl8 +6SMWUEI6qoK7eCq4Q5k7NT8DpWMHZA2U7H3q56Y7pPz3vhFsFjghjH/tR55wjkYXlCx0JNmJ +vIyfcs7YmaCInAQQAQIABgUCVnwsSQAKCRD7jjFy7LBDGE20BACPReh9wcdxKoO0Hn4DVD/m +9rUnZrZjWg4u3qW/8XTU7RBMaPX/eT0WMRX3Uz5FjJZHxahh4bcapyafi5TgJc3ZauM/kznn +E5kl5EjacSBUdz7ozCVo+viyScGsfR24FVCjEBJ4lO2kbZYZEKxsGOzkuBajaDP4jKDsT1NR +IjoFdoicBBABAgAGBQJWfCxLAAoJENjDZOOnZNoIUgwEAKR9TsvUEialVkGEU9QECy04ZVp+ +Bvfg+F9Loa8bXVFtuLyKh+C2xzJ/QIEoOly70H3hjlNCBpbyVOcDPiHij23sVyYaPsofB0V9 +0K9k7FtgtFY9ZmqhfpPO7DcYt5Hit60PtOS8We9gAQjUREmxW6QjW7zKqWgl3/V/eTWFPypj +iJwEEAECAAYFAlZ8LE0ACgkQPP1csfBjB+/fSgP/dnNo1pikarDqtRPj49dF/iMQGGAoUtCg +bBUFYlF9tfC3roulGiujsDIPMPSvk2IoTmJu/Co+s+xnLzvFqI1Bh6+whgbCC4dLJuAnRrd+ +8mtTfqYYCh+uQga2i96Ie5lzChIcyHs5SXZvj6bGNna1iVRrCbDVYa+pMuN04p0Vw/aInAQQ +AQIABgUCVnwsTwAKCRCDd4ReC5AmEJiTA/wI9l0++9vcyIO3YGWUgtX3y8+t1pcaG/YLw+TA +KvkmKGkRcwxOZHM/5OoxCEK5G+/ZaXUrg4skgZBjQ5p8CwSfq/RLFZf/5aHHiDMQFfKvRHnr +F96kBEWVlYy+jjWt7gimzZDJme4OIFxbDwlIT7qoEW1vVGlG15Jci0XJbskauYicBBABAgAG +BQJWfCxRAAoJEBnNjR6AA5b+DTAEALtHrg71p7GNRFSCOZlUuLB4/6SrZ5edCBBfRuiaKYA0 +5yehNHlQE6Ufy2IX1WhHvZRcAEDpAflOaLx9ybQzlh3+S8kSSxRcoq0s0mh21sLi+rjDlpTm +X2eCfaxB0U7jTaYS5KedngEZ1xBSPzUjXO9NyqL7i3k1q8BcE0IOVGD0iJwEEAECAAYFAlZ8 +LFMACgkQW8SubTxIr3N6ygP9FHw8AYfiJ1m32921PkQ48PvO1YCWZ8DOdWRWjP6ranexZZ0F +SaoTGVPgWijIvrshlcBjLeUohapHWGb3qqBYrgh0Kyf9nRXjcrVE6PlPLCZ989aoz3H0mu8p +MScYLDvx2lUbSpUztB6uU8sVo63dartRf05sFV2xa0ERIPoZd9uInAQQAQIABgUCVnwsVQAK +CRBiGkAM5U6sms82BACC0wGfbZjpQTPkAmn2fecgTE9q5EWXc6O28j8Jw7OMScIG9a6XzT4a +Ep1opbhvqGcKofG3bGJpu0spAFaubHI/B13d8/448Uxd64DerFdT7c3314kcJs66GrrRJvuk +cSBXh0uJRhMoOp4qxbdv06w1XQfjkL8j/J6HCwcdnKdiSoicBBABAgAGBQJWfCxXAAoJELgU +h/5i8+oCUFsD/R3jidefsr0ATEmIq9LB89dal8FwWGQApYOmf+y+GRgu+eOBl8v36Hblzo32 +zBX/ER1nAW8OttE1IYQUHlYG4rP6MSSV53JmM1FSgUKa5FZ6MsWRhbaQDdUjETKcczMphGj3 +y+LsY03KZyVAiw+42f8MqwGTqIpXeJbHkEou4ubGiJwEEAECAAYFAlZ8LFkACgkQoLZc87UH +FGgtqgQAj6+ozUfWbEht4h9BY4O/KWvbvmsaQ8A93HhP30wi57IpwTBL2yEdjWRyuOkntZ8Y +qrfyc3DTKq7BIuxw32/IH8oWwEiO9r+yggkk+n9mtaV6VFiizR3DWPW72KJt2v/AMCNVzhCn +fVE26yWr6t6JRlKVQ/l/u+00czAqtZbZFSSInAQQAQIABgUCVnwsWwAKCRBBiGmEH9GvEc+D +BADWr223Rq9UZUOLRjXBIq07IvAERwDzhPxaWJ1Y5MrUWsmRVI2BZ/co1h44hm+Xyb2VTIzs +m38SSKYIL9fUSvvQOXKPIVwxpe7WdbD3d1DZSIOnU3w6m1JeudjUhsVFbWUuyODHRnwtRUXj +354EOpIVac9iIdrXvtcrfy3GbdgUZIicBBABAgAGBQJWfCxdAAoJEHuHaRkpvlEHWlcD/3mU +LzMZ7zMeAGN+3mDBfZ8fJ8PNvwOTq379Yu8SN+1SWPKdgkHtOpvzZq/J0m/JktA/thVWi1Dv +fNPoeUBrJoHDABUdZ+t7OlrdWxeVVK0tmTOnA7KIjQQ7U6zQzq6Ohu/xXHcKGj+54DAJCzA6 +iEPmNXayoDMJEMR3GMMByVYiiJwEEAECAAYFAlZ8LF8ACgkQVJVX1+AtjXPoAgQAvI6vyiJ6 +iHfzB5sUiFwI9xLE37ceLRS1X5xJeJAR8Dv2GXUSEhovZE8eikkVkh9Bn8Mb0DhGcoGlSbio +ttB9fAnhFhcjTP8fLsr/M20BLAS0RhH9CDem6cHOuFCxVoiydcOV7TspT/WqXRsIzg30X375 +tunTT+FAVmArXYBVEvyInAQQAQIABgUCVnwsYQAKCRAk5sLsy1c7M4LSA/9Rg5bO+KlER6t3 +PYJn9jn3fx+y5JsUcEp+4twh8fogf9SwViVR3HprOqQr/m7DXsmJrYkCfzQFE4SQiZn8oVFA +HjwPK3mSNnypxfKWwKdVCd3mTBN4IoGOZ28UoeC3u5yL+LkYkSRR20/Vfs3V8xg+n3z/wYGb ++RWhNlc5VCa9D4icBBABAgAGBQJWfCxjAAoJELAQmPq2V2XIKdoEAIpLnrf3BHOO/rIwNWk7 +npndRzx+zCd8YJ+QEwydLv0CaIl7XbzjkI+guSyG+YMMjt4D4aSwIaW4JVPFf8wdmrAm8kRL +pCddQm916lj+u5yTYa/F+WyzbI0F09C+RysF3K0sFvrVrLZOyIi7CRc3wd3aDxynB5vFqiEY +IclNqTnJiJwEEAECAAYFAlZ8LGYACgkQGe0Rvg0I/ID4EgP7BnNTtsLFfa0JgzRLVkhLo48R +bqXFEBS5NZIpC+kxFDZX+aPxtmxFQw2gkkD5ItzUxdtYgjnQfaPL6ubilQq5GY1o/OG/WzPY +ZVxlyOjveWSOJ/VhQ77Gr4iG4esZNzu6k8mwNYb6RwPgBPb5QdJrV3Juh2pGaTrGj+eNU/au +ql2InAQQAQIABgUCVnwsaAAKCRAtw3IOom1Plf4HBACxS7YjukkYU74ALM0mXwluvLW4G1Wm +M78uC3l9ppJKzErAOOBDDjbF2FsFpeFJiI9tzpJEDKa9UKccv5UQVjxNqk+VHDglNQo/1+s1 +Y1cenQzw+Vpa3JW9XSgE22olio7Sln33JOtHeD7xpZnzQ8OYC/1Hgj+9hwsk11QT3oYa3Yic +BBABAgAGBQJWfCxrAAoJELpWufJ2rZR20bID+gPuolEHqgoGbrZsLN0O5ewclni6iZgDXSaF +/B0sowlmKfh0wqncOQzSlPKw3jyi05IgVNbBKMtppKf8Abd+vjNYrGrH+vFW7ApLBm/+P9M6 +DOWjubLNFjk8ql9BUoel8FU69CdCLSsyJFjovIjjWTldHvEPS6lVY9af/cwjrc2BiJwEEAEC +AAYFAlZ8LG0ACgkQPpFDYolUIbVAsgQAihji2J9M/syPew3OSua3DqbqXDo4WL6WU2VsJXuy +RI7l1gH9iNN4RwStFXCYtgSZ4E+6kJdEwVmjgyzxaRDAcOAQ4MzRVWwoy2WdLWYF6+1g7hzO +zocWhLanHM76m17IJoOAK3N0UC3nrlVff2B9jPvI4kmr5cor1z3HkpjiQ7mInAQQAQIABgUC +VnwsbwAKCRBZw+ShmOKMHzdEA/9NEdrOgZJcM5DO7BzggURiDhXqio7bkDUrBps9XDJASGDl +XXq4gd0l5L+yF64jw1SLTWiHOFXgc0g+GC10rDNedhl35dCSjngT2rORcH4qX2e8OucoMGWO +gYPguWUc1Ujr6VoMJVZLBQx1+01z/rMljxakvHevMOD5rmNOWU+hgYicBBABAgAGBQJWfCxx +AAoJECqatGMrh14wLM8EAJFIynFHgY4sj0O1X+WJgsk9UfbACxJo+UXGds/WOTkcmqSuTWpY +KWU95v8LyStmZscQCCsNKtxpOtYmiTaQisjQHSW+J7a3gpXNHbtVtGFuOUG85yuaQFWyJVeh +DipkCSg3DZbj5FDj0MYHUJWEVYeU3CKX+V/n4ia07mkyx7LpiJwEEAECAAYFAlZ8LHQACgkQ +imuV59YlghrZ/AP8DQwdnTfg2hJnr8/udrYlOyieeWke+1KS7QScXZnFLiHXvn+G7OAaubFt +N+wImU/xI1H1YbNfvITMxY4One9qF4HRSOmerPCO1wnFEFKojr7zsVCI7a9hWM1iUyZQNEPw +0r7WrD410+TuoEgizXs3V8WIKn4oesyag4DXcS2Lhl6InAQQAQIABgUCVnwsdgAKCRAY9dKK +VR8YQgZYA/0acEKhscTZ+X4c2iqj9RzNt5UvP7cAVICAfeMZjD1IqqnBpCmN29KpS8CC7ej/ +o2IzQtkAbOHoUVK9GWqmD+HQ5S83yRnaeFn5y+FyLTc9XAb0MsWS8aRsghjksLvcxLHhuBFk +fWqA/NVI9WzLKZmuzt4gvpvqZNPqGqfN3sA1z4icBBABAgAGBQJWfCx4AAoJECq7/uTIBamZ +Eu4EAJxDo/yXpu0H62qQeDcBh3VApfEz5tTjv6IOW9VXL+kCAIz/eohACtLArEQyOaYoIW4c +791qasONX5RKaBoKT6Hyh99pdZR1cmEHVEF/iEfdHbLFvIBlhlXmxKP416eEVTZ6feA0ZvP0 +3tz34zmElrgwp/99ATLxfTMHd5yruk0xiJwEEAECAAYFAlZ8LHoACgkQG+8NoJVXc9yOJgP/ +WjeRnpVfTkk36zFK4xeNEILmhIQFao7v+3DMYYJ/cRg215t0y+LX5xfr2fzxkWVXvzJuzbuM +ZmjRdXt3W3AXWDUT7gdP3ukwQPxB1qJY8W2039dQMcCLFhueVjGFUxBunEcDm4TBPdaAamxL +auWr4noViCD5/i1TEgCxQ0XyIVWInAQQAQIABgUCVnwsfAAKCRCWHYwaSjdNmskMA/9zevSk +G30AkxLlCfrsu72vca4THUBFcTLPK7mOloJbU2uX2hxogedWye75XsgXsBoIkSS073g616qk +NUXTvHUuxje0zc+Hpui9cVUZ1prvZn0JovMRw7YD4v0pz7OujoY/+fcT6zD3O43zGJ4vh77B +f7EssC4/L6hWB29ILz4lhoicBBABAgAGBQJWfCx+AAoJEBIWdDTOuLkZDIEEAJpnKEjjiiLV +9MlbssSCr6CM2DcQt/Ifpqk1vdpadQyHgm/41AY1SQZW4947gLNrkNiQu+MN68kgPpKximgx +6rXYw69GjKyESshwPXHB27ZIp1L0OShradGCQ8Fhdi68ExSE63mSlTPEXCnTG8WGKMlWuBvV +4ePoCQM9pu6tqULdiJwEEAECAAYFAlZ8LIEACgkQD3nfRT7CnTVOIAP/TSdEr+CAMB/07r6/ +FEzn7zbc8aP3S+bINfwBMMVTsRurjhC4Lrujv3kHi7fQ3nP6PeLNjN+OPNv63gLwfAFrNdCa +uJgqeKZ2PH4/WfGIhzrgPxbPG/EXpYaCZ/1CBa4UBhhKnWwkowHF8pczmjVqZ78iRfviC1PR +ee6hZl4p5yaInAQQAQIABgUCVnwsgwAKCRBrW9kzbNpZSm6MA/96o+yGNuqGcM7KjJ1K9pwI +LbOrKXV6bQf18Yo/aUiHrtXo9WCa82YcWO/zGM1gSAhDjDVyrIXVHWIJOsMxn/t3pov0Nqj6 +eZDxab8hpUPuk+2gbTu913DgPpJiEoAebcW3AEobwkoU7U7oT/FbKWqT7FoG4VA01QQp9Ddi +FFeC6IicBBABAgAGBQJWfCyFAAoJEAY4AiImPwKcIOUD/i4Gxrwkmf4ZKsihXAgx2wcX8rZ1 +mvsc1tGg3QjedtqB7gkYQPwPqb8gY9X5AgNbUfxdcDDWmgDY3n5ZoO7buSBvVzmhyKa9k9oF +ZwvGpEf/fHTd+1gnRWXqV+wL0wda2czT5AfehxKG5RTxAkrKYvE7XNt4Ax3h6O6SyvSXHri6 +iJwEEAECAAYFAlZ8LIcACgkQ9QH7Kb63M2vLtQP+MxAuJ9OXsRcy73QrlztmlLMdCEgFQxFx +OEMMDwJvLxpcnZseXOcIOT5PP3Z3Kf1GK5Wnd3Tm6FpOUuyDoCWKiMG4+CT2VjWCGeZNzFqP +bQhUsfUcLI+aJMafUqfDhT+N15QIosmUDSiC7tRji3hwKfVg0FC3S/jvuLsveZ2buGGInAQQ +AQIABgUCVnwsigAKCRAGcMuBs3+JiNgNA/4+62/Dy2EO4SAO5psPqAAzBxDfmwtEkj6c51vr +s2yCNfmnE27N+eeEuBBRdPduHVabgsF9bREPld9SE/gHjmGX8tbwJ0lBIFZXqdHz3B9dQKhu +PfYCIxV6Uu8wGIKeMrukz00yxNLKVSp/cqxPP039T0BweBZUS40F7reHOpvI24icBBABAgAG +BQJWfCyMAAoJEPCXjb4OebOd64AD/2OLPumKqtUfGUq9gzxohbVpv4UKq7xI8Wlb0NwHpVk/ +89t0BLNytzF+yv9pyfYPks4naQ/Llm4xJ7u1/10ZgrAe/K1rNAtytskLosfbF/IHSyWOkKxN +9k1aDDHEuZ8vqmxk++qLAYLkTvKbiwTwoRt/EOUf832nCpXQrTNvGCVBiJwEEAECAAYFAlZ8 +LI4ACgkQpU97gYttiODCGgP+I4+G2H3V5pmFAj4pU7pt9pieh2tyykud5bvuW3LJErFs/Itu +CSxOdT7NnnaF65e0jhEmUdrgblA+xJQ7T8sNNKhtTfJdlTP0h+BHSjDCn0chyoqHNM/QxCUK +yVHGG4sdmmsilTbY6VbGe0RK1y7wW2lmV8XO2SevAgXWbY88E/6InAQQAQIABgUCVnwskAAK +CRCVtzfROhcE0G+HA/44lDmHCoaSHH9SngvAfP7WToQca9QhUl7MwgNdslTT6NR9eahRFygU +cslfraEgJng3+Qmr6yUx8vzybE6JzSZb4gRPhW+RTPvz8CXireDeo+lFEPCuohaKr5J68bLF +sJU5LCHzuSFmeEuM9bbWuPRCq2mRW3xr2UACm+tTlCEJEIicBBABAgAGBQJWfCySAAoJEHph +Osb0/cK6yOoEAIz8o1bix9tEUMqjjgVWOydluNB9gWDcOuRUxXlKRriAgqymL7VPukcHZAzE +NMJ0H7tyHIO7PJLacf4uliYTsLw3OQ62fqLAQw7ESAcwwG5EtJWku3V4dCYJ6rAW9zwa9v1P +cy/znaLPp9x4B3OfSAFHc28SMHyOns1ytf7Nt4vciJwEEAECAAYFAlZ8LJQACgkQQBddttPK +1e8w/wP+JPSkYiivWEive3FKqdkbPFamC8oYF3FJc0UOVF39EtNmMAuP/7pqzCUSZV/+fpC/ +hHFe/5bab571HmY6AAdr5iUvFsY62/QH8ZU05Y1VtYbtHBiUiPQSZR09klAMkE/bm+SOiUl9 +7nAF0siZ4f9j4OIeOtwdHvj9JGMTCI718cyInAQQAQIABgUCVnwslwAKCRBo3xbGvBcQoURD +BACThD+6XXGCFiQ6DpbU8uS2Tg+dx2gg9dZDkiz1GyRSb4vKyg5zGybJm11hTKeA3e8RdB0o +BC8T1iZa6DJKEM7d/D5vHI9c+79gimHb8uXSKmi1YHsUYeWCKRCQN+kJe4GXEovzm0EvWlEe +mdOAlBeEKaWsQJJ/nQGal0RU7Ly01oicBBABAgAGBQJWfCyZAAoJENigaqn/sHNUqlsEAKqn +fwKjJ6GGc2CuHueP/gK7zsXZK9b+EnGG+Sv5MhKM9a1wFU3+bLem6Rh0T1l0RCaJAtDJi7Mt +WtVLZ0Tpyd4MpsbxZeH/hsAnVAGKQhzlwVw9C+M7AzGiL7H08iwLhpgo0JIx0p+RZClxTvf/ +SmpKwNUyFXCkc7fwPKoMD6tjiJwEEAECAAYFAlZ8LJsACgkQQQnPx46N4ODa4gQAu/lbSAlC +PoVmuhKPFXRgipD4ZzWzejsgssuVWZYdkdSKBVUyq/jxKsWMQG2PBp+Z58COeSs/X74IYhSQ +8g05xdB3uEG8+UYDnXW7cCfvx7JxB2T71WUDLUUeUYeJppS0QtzLUM/8by+KNQjdxUk2qM6F +aCMa4c0EnsVLd6XZOU2InAQQAQIABgUCVnwsnQAKCRCFta3TKTRC+CipA/9xxlflx1uRZDz2 +5ehm275vTa0BI0TbK2h6wCeXWMQWaooIvqFoVgDPLAIGyesLVL06C7qhVZvnxpC0Iyb23Kfh +TZ6gFaG5UNTu5LHp1vXjK2pa9TEDMPD4w67gHU97zI2lHeMRZ/RquXmgndOwITDoz/Hy51EJ +M+t41iw8mexnaoicBBABAgAGBQJWfCyhAAoJEGdSC7r/5+WDSb8D/A708nodd1L5ZfCwcxry +2G3m/wH1s5i0g1/xLLsGrNO8dtf8XzC5CU7c8g2sFgS/nrQ0LOYHSD3YNTMIJJct5b+F86XT +C0u2Bjs7juTjxpAP4YeBJWps5yMj83sc9S166r8bjEqNFu8nORYQ+KXbAtJEHJw6nVbR9tgF +ABo/nmMbiJwEEAECAAYFAlZ8LKQACgkQWkmCBh5oAg7KyQQAwSu4bcgJhejvKKXEwkgRWfRL +nYPzGLBVXY+lk+sIH3M9XtUpMlDKYrocb0dHQKZsIVyoZi5BGhxDaIXc/3AYolFRYWGLYFm2 +bRjtpfWCv/qby62oW4RqdWvq/ata+SSrhUVZSt/LLx4hfgLlugWZVPp86Ec4Psov+3ruceug +sv6InAQQAQIABgUCVnwsqAAKCRAunWitnesPyHiWA/4kbeBxiiDk1SMeus3R3oZPFf7LXl9a +myWem4I6hGuOPerqJB/xwaukVkYP9T7Hw6mS07tyJ/s79n1d7KJCkdXmqw42dc6KKOQBMjGb +3k3+ALFSaitvL+yL957oo8ZQC+YlbA1mFk8zkQmDt/vX+TVFB9sWPw96cs3NzyFeiRqxE4ic +BBABAgAGBQJWfCysAAoJEP7Gqlzd0WqaCHsEAMIfRExHUPn0kVSsuE8ktvFFUAHfMFWJitDm +hKfgBLVfCMliERfFJlTRfxOrjbijmKFpp1xNOmHYEZZ4bW4zlY+r2rLT13MIwzOtF890XHBP +H9ly8JkKprLPwSocS6XE0fpGKyJ03q6tN7qf1jPo/0y8/hs7yapcVE8/zyIexXTriJwEEAEC +AAYFAlZ8LK4ACgkQUE940YMWi112PwP9EpC2YxsqRlyuAuC8m+ETy8wI31S2J9DZDWmxPgXy ++bPFr6LkL4yE7XHH7upKchP61EaKez4WUrKoQGHFslSwpndn8D0obGjUWLRkOBxI8Zcz3aM0 +M7bifQ843z+lW0cTFr+epepT/RBGur45HkYpl983s90sPh+w01Y8Ux/fpeKInAQQAQIABgUC +VnwssQAKCRCupUH1qp4chRYSA/kBLrg1VwCsK3b8etdeOrmxJ3CSZBJ9kS3+dMxVoacJbXm7 +2vUbiXdr63654gt33b9FPxk7wU0RVOUE9m8Umdno0qV1e84yfP71hjmP0eh2Fg0x6lliUiQj ++cyWUHwhk0d3NpYRGC34gGKDlZzzmpFLksUPZrgKbHrRAHvRKaDSQYicBBABAgAGBQJWfCy0 +AAoJEJlZmba1MmuldjgD/22FQSgWg1Cg08yF1HyWNIZhjSitaQhBNW071G7QvcAmNORX8RaD +Vj4PT4zOLoclLmD7Oi9sZdBcGvPPcJz69w81lo4EpDw2UOp7Owp6lMRVrP0dEbnW+yWjh9vr +wySlDzD8gNGQcX6pZAMqT/tgk1pTq/4v8l33t56X1OYxmZ6AiJwEEAECAAYFAlZ8LLcACgkQ +BSYo59FUB1FCJwP/RyFS/m4C6tWWqxxTc+EI755WAB14oWff5m4N/RN3DpQJGBnRaby+K1mV +Ai3uR/si22pVvUSjHrhBu8ULz60d2g+VIVxtR1Qc3Y0moV9Wv0Sa9YCTle6TRd5hI+9Dk4Pc +FWgqRm7SVm7g+JgD2QbnRD6iqre0RC4ATRRGpLQHuZOInAQQAQIABgUCVnwsuQAKCRDtYidz +Gfk/SlvoA/9WdtGOLNL5rmHAY8kexXPQjHpu8hea1pLuM8TBjoioFaa0RlrkUepEStlOTHZP +jgwjZ5aDJcP1UryJId+9Frlw+Bbh29aHYyik7NVGzCEK84Zuk1DRH94T1uqUvxtPwH6QncYB +sQ7f0ZVwcaEIHiQLlw5yNPqtYGN4UnH+3Cl6doicBBABAgAGBQJWfCy8AAoJEHrDWrz6DOEu +T6YD/21R//jfaQwALbPST5Wb74niTc6ODVIXcl01e0V99Tr5oKpySgwuNkz9vQlydIhtqBag +L35F7JGnZIkcf4PUM6XUfiRxGiwu/iel+Is9JIym82aj1/9d4Wi2W7B1lXIZMBaJlhZt265u +G3hQywbxB97W6hYowLLQBGgUZXC/rbRMiJwEEAECAAYFAlZ8LL8ACgkQ3MjN0AnRstCnzwQA +lFpENfKFPPK8qlHHynW6juAhpuz/JeXU6TWpznLtu02ONyRnQ1624YcG/bKYdiHsKN9aaSYj +HF00X8lJ4cqBNn+BKMopReOudt08lEXbbVfrWPM3UEoBh5GE/t86QH7PkngKrMi71NbwFxfa +0co3MdYGnmGrGimncjMloyG0OV6InAQQAQIABgUCVnwswQAKCRDJDeRrpePwLD4UA/9LgJxu +RoPsWMhA4NX2XsoLCx2BUB/7G61yYbSh9shKq8rFLB18pp+YiBf8yaOp8rQWtQIQ5YzdkHz0 +X3btqc6ye2XTISUjmWnf2Szefobk7E/UdbSJ63JcsPmwsEdD7QlLBcjEV8/fcBUlBfYIxtf3 +dFAGoq/+baEObcbB3yZ994icBBABAgAGBQJWfCzEAAoJEAM4kYD9a4+t+nUEAIfyKUoKvN4g +OSUIcjjAvxkxajyt84bRcFgQSbXl+kDXhIgHOJ044Z5p+oS37rs5sAIQ7LKwvcFFd5o0Omoq +v/Nd7YQkhSN8yr9EWOIgetzrA73RXoqqP8VpA24PWXpbF3PWvBRUzQPUXNAOSDa3b7LmEf4f +xwcwcDs6Psuhoc/xiJwEEAECAAYFAlZ8LMYACgkQfFL6AVk7oQMCtAP/aIUIGpAPl2Gmae/s +6bxymOi4F44SVKxgjbcFSmwcSmtCRvi+WsZzqSK1CTXB3GSMzO7lXnep/kZeEp17PIgnerhz +xi4yTd8hEFud/p2uUkeL5Rlfk+9u7Oh0Yoo8FFwdljA05pOd8BvMmBvQ+VSQw5q41skaEtXj +QqZW/s2lreGInAQQAQIABgUCVnwsyQAKCRDObViToP/qD7UpA/4xaNS+OFcjQIYpgIpbJUB0 +J7PV94gNW6U6MpUSnWR30sUvuZQQsFc1mI202KfG5O7mVvVW+P8pJnBnXS/mD93h+TghHnDR +fjSyqqIPeivo3fG6KtOzcgwr7ne+3caEITnvGyF0gMGhMRt71EQNj9/ni0HXfNZ07ijqdUo9 +zBRstIicBBABAgAGBQJWfCzMAAoJEH4VCiMIHSRKt+gD/Aiv5eaQESFXiWmI/k1WVta2R27i +zZd87csO6HiYcb5ezMxRIsXDc6+yf3ic/LKevuJDCb3GiSooojclGw8MZ0KMFBRnTyHVwQDd +UZ/pqoVrVTgcp0eMQiJ2gQDHAocviYpyEhiIYQ1M4+C1bi2GxQdk4Ly+jaEXWfdhasYKEGOj +iJwEEAECAAYFAlZ8LM8ACgkQo7pCBdNfxIjqCAQApJLmq8JGdJxxTZmFmNGl+aUPerEt2EAN +qKZo1Mjh831iWKSUMahYKKsfifP4F/exRWGeJn8OLterKFStzLiMQdq0EAJUbipbLqyFqox2 +JThGrQT08ahuFdyDynne+ymIZMhjiYSN5eZOkIb1pdXplBcUfOl3s3DZhqaZQ3OaPDqInAQQ +AQIABgUCVnws0gAKCRAiqkD8VYIStwGHA/9/gS2aDqPu87CEwmSuS/m85MtR6H4tCuk/sxPw +wPmyRsqi25FmbNs39OwJMlh96cPR4ziJfieAYsJm2nD6woYqC4BAL80Ac6jwSgxOH0nQSkPe +dhllpak0d7a0Wc+z8ipPLggDQLn+oGXswfpn1gObqUzgB+iIs/DGMZO/rf+8Y4icBBABAgAG +BQJWfCzUAAoJENzU5P4zIS+Xp7oD/3zU5OnU1kS0qRKZc7G7quUgs4b88+maSV4zk+a6QQSB +mT8Q0aujtU7Lo3eTMsD+JiALWorLORHr4P8COMu3yNgfVwUCpO9+ua5BWJ+QY5xM0JbeESZj +8smeEiSbRcZZ9qbBwWWy6Kb/FTIpeAskKuaumthqKXckMDp3t91RNWAtiJwEEAECAAYFAlZ8 +LNYACgkQdbvE2u4TpER7/gP/f4e80fZKe9KeaK2LU+kolF4X4EDlqwMFSHRBmNnCConY7dbQ +u1gQf+sIlqvKZ7Xl/5wAy9Kqwitp1ZXBUHwXW+MypWZgjcRnshEsj+uH512i+U32CVsGZAGD +RNm9SYyiG3x/iwbtLIkvaLl7vSX+gPOa0QNEBQJXknj4AdI5aeaInAQQAQIABgUCVnws2AAK +CRB+7WIH8bBX7T62A/9jYS+f7MV+AhH06Z8ZcgkEKhI+q3ImJ2kQi/qLOTHmL5DuUOmcCcZD +jr9Nvtlqv6qxkaYg/vO04D+/pRyzxrPdzz2ktxKxg5HJEJ3FYE37q8/O9hDomX1gHDHL7sA4 +LiitB+au6a9zaJWwo8qbvbyF5RXxD9s/H4d8py8pUwS8hYicBBABAgAGBQJWfCzbAAoJEMP2 +sOS78GyCQeAEAINjVfc3nTnW759+fNDTI2H309Hy/EtSwE0fuiGK3ZVUfPGnVGHfqsqAJiZO +N2mqtGrWw+/tTcKjzNj8l8GOYrsStyo+JW+zhEa8dxz7V4FUFe2bYp+hjge0Yn8T/4e3iAqM +rUQ6tC+Q077kyD9VbhjNKCFauRUWS3XaEE+rW/0ZiJwEEAECAAYFAlZ8LN0ACgkQovmpkuDF +2GJ42gP/ZJH4zBxZsX1xIez0oknjh1BJ2DuW3WICJGKaqvqHqI92bWWzid+6H6MO2Y0Nya51 +M2SDRQ6TBqYolHMo035Q5VToeO3PITS6kcZ8R8X8qZI2jTB72dz5Bw74i7ZT33YGqyehz/mG +LH0cazGro7sW6dDH8WZdgBAJcmIwpdcyjF+InAQQAQIABgUCVnws3wAKCRDcgPJgggmqHMtY +A/98mGqo91WIgQPJ0WgEHEcJue7XMIWYNRx/DOC7kpko7zrchoEhuF8TUM2Cxdxz5kWJvq2q +gIa7zuJCWrKDxMfOF8jGO+8L6gqTafRj5ka3VMpp2VpEfUY8ahHxFZc3L3iLvYR5qDowIM/u +0vxyTqBqrZKAmlnKItCzyGOYWQSJQ4icBBABAgAGBQJWfCzhAAoJEPcVvommFM4iU4kD/iwD +f0wJ2jQgbiXus+H19ezreBSmpkA8UmUOl1DuY+sO8FxBdm7G7kFrd8sR13nbknt2yTtWXmGp +Pn6pO6qrZk/zFxKw1Mi4ZBedT5sKiu5R6X5t0F/p6L9tut8QJpeibxCSB3mNap7Upuhcuukr ++HKoy9a4eOIPnjFD70r84f0riJwEEAECAAYFAlZ8LOMACgkQ7Pml4ikML6sLRgP/Zua97jer +hmHGN+t8v0tY2tkRag06Keo82+NtKnNr3fSV9p48q/8lWmZcjHFKCvPBtblJiY+e5mgHMVEk +IbkBUAAX7dIvrKkEL7R7hdCiVheahEZwiYMhtvogUGJdqHEVp+ehT4M0LLlPKrrRbcUSrzsn +Ovt5bpq4Rk73gVnVbZ2InAQQAQIABgUCVnws5gAKCRC8B15ni8k1ZQNHBACANqRwWmBg4Q6/ +ZugQR0CzvAnh+Bs9+IIaCFdau3C64zzVZEZL2Kei4NOyZTFHw659fCeR/Yvhc6MDGJHfSf1T +oj5Ne/eMqTkDMgZZbsv4P/z0QHgV+o1di7yCLlSrpUl+1BYcbsYgnvQ2JpCTA9Yw5M5SZV23 +wqXvCJtYx6dfzoicBBABAgAGBQJWfCzpAAoJEKxZbkKCSbnyrhYD/jovG4tqq0h/md/IuEPp +dDz88ziqyopwtcF+iFjT/V6ng7I0xoqYE+loorpNO3A7oP+lhJD09UUUHpqzktNNMcCER4Eu +f9HrWXSc6xRjRlyk1BDDaALLqQ6DIbvVty0NawEUGAtTZjqp7Tk7OShh70wH+sZTxFVL2JkT +514pXzOoiJwEEAECAAYFAlZ8LOsACgkQl7yRcghfVFlyqgP/RI+hsRJUVzmqayE55e+NyI0Y +KOQhKpEM+lZSpJw0yv5a1tnDYrwFPubzvq60RKYNMtORj2dPTtXGHivm6i9hcpwiDYVwkwaf +XAfxyf3hPKILGGHSg/tAnjfo07dGxgtERnHO2n48aVDogjQznF7H8gGMt0aOQLD6HFwo/jO9 +5faInAQQAQIABgUCVnws7QAKCRC3wzrBGbAeWyIfA/45nHcHd5pEJNqNk5fHdxaydMUaRFMe +KqDNluGvMjJr3BkeUHlbgaiqGYM6ucSeKUMl3wcU5nxA4AH14gqUmdrUl02snZZygdfQjESY +V+FqGS/OZF2dL+BhaDM6ESbljAn3DwAIu0UfQc7bdSL4x/FPrL4VVqJh7gp2cAM+fiOX6Iic +BBABAgAGBQJWfCzwAAoJECjW2EIFXked7UED/i8eVdCjNMiv0cDS8f7LV7RnVTepEDEoMCnf +d6wTLY5Yzmleefbs6TXk9qfUOYuIHz3IS0VYK3D7qYclOq7OSIi4paJQwq5/IhjjzY1C3XR/ +BFlex3sbiM5kpaJV7a/TAmSDwVNTiN0O38KJfLkXrvEv2gae1a7net1/3XXuM0ypiJwEEAEC +AAYFAlZ8LPMACgkQ8bBnmYzJskZ/wwP8CLuYn2og3mZDUCqbkWATE9+fJhqD8+65ZpAO8tCt +dbWRnUovM7mFtAUp+g/gDVNq1P9W+ROw3yyYLL2bolBzLdaDE7bp49gBtL8kwM0qC+5ppQfa +eM0Cb6WYLGZ2I/9fA7w5ImbcwKmSPVc8bQxV6YooyM2vzjuQi+9V1ofTQsiInAQQAQIABgUC +Vnws9gAKCRASF+gJvnVnByMEA/wJO2OReswbEnjZyfILmH9QQXxO8G5d866MD68gmpJt7wjH +XUbdc/LIT35foPSbPzdEMlkOlkToPf8qctBh+d5ONChkPLr2vGtdZUhQIKNCdbi/sUg2DQEn +7UMDaAj3UJjGYFjOYVUEENlvAz1D8GRRT6CcrrAGj9JFlHzAj6qNzYicBBABAgAGBQJWfCz5 +AAoJEFNzS15HeUu85XUD/ieSr4VW5QmjbubdOJXw9x3HR7/cjZ/GmICTSDBSZGua/+BVnOO4 +wkxPHjKb7MwW4WmqyKh2xK7LPtL65adjk63ROw/rqUnH1KJC32ZvsoOBrBXUlBJp2vgZmI4G +pzFpB79DHkM2f+xKl+QAIOYJtNIOrgtBOX5Cngl6od57357AiJwEEAECAAYFAlZ8LPwACgkQ +o4HVZ8KbdCegqwQAr5Bmb2cWeYzE5WgKr0SnBGsH219JQirzDTpA+tIw0wIohlyr5aZqYqiE +kLdyzbiwB1b8aToPWgfnlbdwH8HMbtmn1KaKq/HpLX8xLcE0yhroKA+L+z9XN3NqrL0TsuT4 +mjUD/2NB67KVaQPeJTq9Bd/VlHs6o2YvznxSRX7oygyInAQQAQIABgUCVnws/gAKCRDDvwvf +0javYRfuBACRmeDRlUZLaHZtKjEdhREIOaqtMtlAy0wUNU/sNOIUy5keb/d30x5Q7paacfxL +KCFbKqnJtPw/pZHq1JI9CIvTBDHNjFu+RAx3Kv97c0JqBkvi4y/K99/+SXY2U88vw61vOGkc +/7H/nvlt26eCXCKptYYefCns6Zbrt24JG04YLYicBBABAgAGBQJWfC0AAAoJEOusSeLbjPd4 +KWwD/3A4syX0M4JA1IzP+UsdmplhBR5koXgKSHFE81xu3VOSuznpsu5GzEoW4tiaXxICHCOc +hYD9i7JWNVpWewJn38jvnBEa09O5KzlUk9iHYmPwVDuKL/uSbeaxsjnAQXbAfNPKoWUcCyTU +oLsTsDCHfJ3yhLUqqyN7HwH10nUaXMEJiJwEEAECAAYFAlZ8LQIACgkQg22gAQjt0MnBBAP/ +drGovYjQ8qPLXowhjT6T9WoLulAhnYqeb9OlpKPSM2MTGq2Yhg+vj9VOErO0HhbfhJkQMTTY +jX+Flp3rWvsKBVAr/kO1t+ra9AAn95sO5V0oIjSWWUYZNPTpbbKhsnuKNwdYROhvCGzyN5+G +D9Nko+3Mbpqu8Hj0eAXofDAkcriInAQQAQIABgUCVnwtBQAKCRCVaq98VpTzYgiuA/9/v9t2 +8TK95Mv2wXh0z3vm3Lv94zmIAUflxaGIy5jBjMaEJSKnP6DkLmdvlgfS2qWT7zLTND7QzCLr +k+cfSjzbzHxRd7n1c5VVOmLA6C6u8owulzxOcCfDIofT/HlzUR7XB58PSx7OTZTK20ocMwnh +LwDGaz6bIFL1bBvBNbmo1oicBBABAgAGBQJWfC0HAAoJEFssQ7evm3qZ+9MD/2MHUC6eZOd4 +oB7XIA4M1DuCjAIpsNZ5A+abvX0OngTtZ7FFpuaI/wPa7GOeISYqQakkZKF3S2uoKf5/EiGl +ggE7SNKGdDluGz7QeKijt7gz0alp+17tk4yNHbdSEVjmMq5jPSj8vIaflSc2pn3HhFXfalFL +xlux+sO0Da/UasRyiJwEEAECAAYFAlZ8LQkACgkQSEyDQZ9DOSV/ewQArcKrFUuGk65LuGcb +R8oCo5zj6pN5mUcpvwtra+0WQDRox8McYosNdKbSfLA5DTZbXKh7TkpfssMH0bJKnQsazf4I +/y4TcflvpoYL80WuqyhgGP0my8hYEK0cXNChUCApN7Jl0Kqv70vDCxrQ0Ey8wDc329Z7xDS0 +atvNl+vOfPaInAQQAQIABgUCVnwtDAAKCRAd3jvc4dcvUXImA/456Uhzt2eaFRkuzLKwErOL +seT43mpFQZeddWTkNviUGCCIr4663ML4sF32FDNNlTRmnOS278LTmHliYDQpYuJSiqK3ABkW +wv6xqJt56iMewpTLs+lziSKByAwNr7GChGSIve7fX3z8soxjBEi2rB1r22DAVkbKT4GPNDgW ++7K4hoicBBABAgAGBQJWfC0OAAoJENG253uIpturLWoD/0DQQAuV/LwOZrxoFG+lczdJgzxY +iICXlfFrJ4wzl3V9QDH6hWDe3Xx4Tq0/Lb5v/Du3K3UwwLw6Y42IKd6a+bULZ6X8a9NI6fz/ +B+92TC+cjrB5mTPW7xUz0ziVeC7PwUtbYE3WVOYjsgtLaeA0PeOBfY/1YrMwcS9+tnYD9H/r +iJwEEAECAAYFAlZ8LRAACgkQ7TLIe8kPn1e4KAP/WARsLLG7kheBoJIpGbmqxMDDXm/JSQsJ +H6cuAs+QlO+FVbl8fGj5j4bSNXiaILJQt/z5ELqqTmQQJbxSKgrPTIML2q9xPSoagK6Eb2Sh +bOi00b2BaK9Zl1bpVjLaN/Aws+UzPQv4iISqb60+2TxKeYf5WPvK4v/d757E5EguJDOInAQQ +AQIABgUCVnwtEgAKCRDP04iSyPROI9NYBACRboMEGhqDn4oTEg1rKZn+8LVVNKlzqbNvX3fg +4lZWGzZy8HT82XBvVxTDj48gfV8j9nS6jlz/XbxZ9/A312QuolRHR6pzWSgDVf67HOKq1W5Z ++c0ez9xREqGwMGmyb+qb5s/PqRW0qH2xUxUssKhPT5OFh85i6OYQNmGGvKUQn4icBBABAgAG +BQJWfC0VAAoJECeA3SKnyGG5TsED/3zv572V88pLAJ1rLEBUeQdt4abRenxd0tLOCfLVCOSb +mdzvHOaznEUd48FxQeyc0QYvxP2RXg8glfL0QpaEsSCyP1mzZ4c78Ub2yBX9UzNMHSL8Qifc +ujPe0cl6oMQd2AoMtFmIrbtiJx+1wNiVdB7HEv+WO/lZN3r/0pRypIe5iJwEEAECAAYFAlZ8 +LRcACgkQev3IpsQTcmQurQP/Yk2mlCxN0v/wx9Z6S47bi11NHABxMvx88EQHBiBC7IIipnU/ +EtR0d8ZV/W99F+Jlk5xMaOFfkg5YwVhAWKrJr7GKaY857KPCo3SOFeqKdBQTpAUs7w+XWIBa +4ql8IvHsgce0FHhMIdN/fQGa3ZkWA9sXBaHdPruFNRdy+sm+KrSInAQQAQIABgUCVnwtGQAK +CRDHzzvAtVEl3GB9A/9uw9UtNM/k5FiXaB+wd82z0AeBWfz98r3jMlZ/3Rim04y2rY2i3wco +iNQjLJeZMdyor0J0ioXpiO/AOwFytFHuFIZaCMYnlGI89eImPgispfu/X8pU5kb6Zu47Gg4O +e0CCuKSio4XpwMSAnUP6X5kkH1HlKwjP7uBw5F08XIRRSoicBBABAgAGBQJWfC0bAAoJEOlf +GouqFo8XdZYD/ils4wm9tK4tvyxcCbHO2IFxh69EsA/ZNX4751LdQftpqRTiSMxxMzOg6Rjp +jRGeoUPJA3o0ch5ViKJDXD//2H5W4nWB3ljyui3t4H6bOmbkXcp7fRWWqHR+4zWCTpEDQjYH +Pzbv/auGTFuHTWxxGXXPUHL7pralIb970wrQV14jiJwEEAECAAYFAlZ8LR4ACgkQ5NszzXuZ +hwho2AP+PYcQQsFljzuZNx4leSJTLz1RtITkWLHXtvk3i4t/n8Y9vGEMUec5KN7shYW+uIe0 ++kOWZ17l2MOMJNIO1IPgmS900inW2t9cKZgzZEyJCIFgcZuWc9BMVaSHIk/fqRQLyWWvPB+l +iHPq6K+KkSrQvunGLJedS4YMwTH6a5ykA2eInAQQAQIABgUCVnwtIAAKCRBNvbF70hUAVf+l +BACXQwl4qlRhbPxoa5XPP2aVmn8wky8xHYJYJc1DfMVkq1lg+PbORqqsh/wWBUa1/XKjOM4P +f28tjm3d0jiuXjzmIFCfiSpBK+3AptaY++TbbmNG07KqmI9OjUlRy5a2a1k024CouOUt9a0N +B/3etbjSy3K0PK0S+21PoL5EKJ99VYicBBABAgAGBQJWfC0jAAoJEI3pq4xNa2P9S6ED/0al +q+IDuElhGYVZj0wCazBhok7DB0aN4MSFboiaqTXvEfWeC7/e6pKJq6RT1O6StohupserwmRk +q/fX29uuUS3gNhmmX5ibPHpqRvextRx/jLvUQ5ETnU6S8rqSAluL7F1muISZWZIdQAsBBfkV +biQau14+djvJhE19cI+ZmwmoiJwEEAECAAYFAlZ8LSUACgkQ6Fzo1cHagd3aPQP9HIhOptMS +sRR6EDyo+zpQ4Pz7ihFr/7woHfdJ4wDW8cL0SkwCQA9wp+soQge72hJcoRHDEQ6gjiZZOKMs +RaiL/GyzhDbVt7Jk7cgcpZnmtS4zLgMLgl3o7KnAj9J3UdU25peqoVCs9hF1cCxvhtPwg4np +XRwtkXBdJMf9eC3TGpOInAQQAQIABgUCVnwtKAAKCRC2QyZPF0hCvUgWBACQaBxYsNE1xKnK +P0TvNjaxP33Bv+A2WSFLwmFDjiPW8UPZqkoViwDCwktQdndv/jWKPUwRFXn8yHg8ir6yeSbP +V73pMLYep9IEnRcVnLsAd9oF6vvGijElJ74NXM0qGfvtsVWRXBKM8ggJVu73Ls88/I4Wtqpb +mfZ0pMTe8f5wdIicBBABAgAGBQJWfC0rAAoJECz3ff3Jop9I5CYD/2CsfMXBD8S56B/IXzUg +eN9nBiLu3FR6RY7Nw2IL4JMJX8NVArJCC4R2vxZMBRrOrdvsDGJ6dQ60N4XHd98ir6qSQWJw +t1ZlR0Jykw+pOhOx2kCXasCtSuewm4utwp5p5BIwnm0S609SSflBk5qUg426soIuZEXjOmhK +UW+axIT4iJwEEAECAAYFAlZ8LS0ACgkQg2hHyWnJPy+iTQP/QHppj/PFmUG9nZM0nrP7TIP8 +TnE3RsPBbxtF/ZLYwI2DFlKEnpa/hkjigNRfyc45pERTifdh16mWgy5Onz75Yu6im3XKgBNf +BER9twLZQbpe63kCkAgfm5UYUN9Z2N+80F8ZjJKoAfwu1PMkQp3sUtlqkP+gU8EpmS+Ucgvc +2IKInAQQAQIABgUCVnwtMAAKCRA+Ghg4jVhyMP8cA/9jJX2duaIHdYTl42LLYD55uSqjioaG +foQvnB3KTvP7sLPkUCWItRzwggQVGB8JcRx/plvphmhfyn+NV+5NMSaZ6JucG4kORocBCkez +MGyFUHa1AJN8baHNP9CBUsx1D5tqWBSea/Bq4X2UM5OqBUWdgD2ofqsORtHa/QhiKnlXNYic +BBABAgAGBQJWfC0yAAoJEBI/iwQFTOUv54oD/1QL+dV19XAOpQeiNPi5eDZqEaW67hk1TLHQ ++YCrgLmUxiKZRy88/rzvIJ1R/HP49E+nTS5/qGV8Qy/WP28y69Gc/prWRk9NcDov3mpNKa1M +IfIP39Pko+zeFoT+x+Kg54x3uIiEJrSYJ8O/ZICIkluxAZB8Zz1TXibXdjOxpcYkiJwEEAEC +AAYFAlZ8LTQACgkQF0EacrSIH9vS0AP+M9r/Kui701BtTr+Z206je7fyXjeYrw2a7/lZF3U6 +stbO4R9cpJLe6DkH0jBr/U6Ldx4tHB7j03s2Q3uNFpZR8DEVYJG4nacidin622dq55HIigWC +DTZKb7fSO9ZfDAUHjvJtV5vNjqpZrkOXoaiyetuPBV2xQo1dxyC099APKwKInAQQAQIABgUC +VnwtNwAKCRDKb98Us8GladJbA/9yH3+2WfY/zXJoIBNikrx+PD/xqJPYwR1Tk3gq32c745om +V4KdAi1Ue/3BhxZe4eBjJAflS9GhovP8HmIFhFsq0FgXgjHNrCiiT8Qvy3l9d3m16MGEMqK2 +PEk3768RSNUGueHyoUumLCTGEEOG2J58cayEIgNAtnRk4zP4T7W2D4icBBABAgAGBQJWfC05 +AAoJEDZxsOg0m0dx31oD/i/7dF4w1SP7YA3NfC5wwy8PtSSTMQgiFXsHS5OdASck/Yb2BQXS +xp7I5BTYPYkBlxN748vqPdPMJO1KY/kqWJRueA/d+KFMC/us0Mk3ce5bIX9+AjRIlcNIChrL +Vh5i5GZGYJP+EVfx87oMBpGns7f2ja7A7zTFVuPay+UPYytkiJwEEAECAAYFAlZ8LTwACgkQ +ptO0Z38puKVD9gQAxkWF3z69mg2f8GrZd9Hn7cKnafDgzRShIWcORHE6QK9PBUJhBYMNgZLZ +RnJq8eGuklDja/a9m2b4F5MPwaNJ2DxEWZ3JYyctCrObWW24xt+1fuk79anzDZk63HSEtSP1 +31InNvMhDX1TMjDFej37nI7LazG6BFrVVcWkXWUqcAKInAQQAQIABgUCVnwtPgAKCRAbGrsW +SJxXdxoHBADAJdAbyj3NPfJxy68THbMHp1iSH1kf4E5lVoBs7y3wOL/mRMmKxXyko5O0Nml6 +K6W8OoNeixNJbppGSKKonhDVqEKH7mI51owq31M8wmXe5XLD2Y1n984MhJjoubT/756JxP+B +crgiF+HO1jTRtkmzxXBWHmdE3M8LSL2Rem5g5IicBBABAgAGBQJWfC1AAAoJEFxsOPxwmC2Z +DxED/0zlnwkGeIZLQ4W+G3pu5S+3sZfg1uMKljyiuSTGMxiRCEFDu5aKHLaau0i/JJ7LOyay +LOqPi0bbhAqmDB0hd3LdUScSkkJFK36AdWQFHNHXKhu+22IRT2dZAtmVV9UGPEc/syHz3Q7R +40Zsb9ld3R1eDbJiZ6xTi3GuuP4UJi/YiJwEEAECAAYFAlZ8LUIACgkQlfAVfvrvVTIqGQP8 +CuM6aNLuPuvC/8eW63+BgQOqxmNCHfGnNK28ckMcn+kEhBYy/6hCoiNVdSr9nHJwdmnPAtVU +WXNIT1x8eb8VQMyF3t+S42LDc37KN0L1dnWKHHinMfRLI8EdEK2dZfTq6UQeFkkV2anXeX2N +S9cUZ/mirYlLr0mKzDUkpvdiD7aInAQQAQIABgUCVnwtRAAKCRAuj1X5VaDGL203BADpbVEv +9AI/MZkdU9/aZb2PLZ6sXZVjS54i0YQ22qubNPgzsr+lz6GZrfuvtgzrPSuqplpNaTokQv94 +sX01zw3R3GKbx9+dML9C3P2jRkkmRA2VPtl5QhOPviZmT1nzaPRMSqrEaNS8BRb/TpEro2d5 +bcjGXW1L23spVJjIwfOY1YicBBABAgAGBQJWfC1GAAoJEMadOYCcDgSZBiYEAJ8KileJ4sbR +lSYg0AMISS2i29lvzg3VKWiFIhLVhtH854Ij07f/7TG00V1Byf70sckC4o9EPMH/1SUgCm1f +DbJ5512Q3BZ9guuIU9mCaXbFh7fRFvHxkf+cT7SWoZ3e3M+eaioq7YOgS09rR4j3gH7hnAJi +mbzG6/MT6zeKqgvsiJwEEAECAAYFAlZ8QkkACgkQKdYJhwl4abB6OQP/Y0NVv656UtAkcgT5 +tcim6NyZnS0ewV/bRDCl4X3x2zUIk9K9TE3687qB2P8u1+D3hISxsVIsGyiCIWuHJ58Lcbhd +whKUgOLtIHQExyDj7F26DP8yKwiUUvbwHnz6KdnHgWUfLztqEHUONpM7G67AyNNmyJkvUyVl +wtmxZ1Lop1GInAQQAQIABgUCVnxCSwAKCRBf3Y0VHftfRNBOA/4hNDa6oo2JYsqO2TEMF+S+ +ZavwSWs0Us7MKLBO8HWJjx5ZHcyTMWi81FmUBHVmrcLYFFFCFsuggCPPZU2HF4TIppUbqvEL +AQR9DM+iWlizNemjkd+N79ZUfa0Tm8TKZvn/0rPRDvUPe1EQRLjoW+yICZndvdtbSthwQFnP +mi7WdoicBBABAgAGBQJWfEJNAAoJEMTD/8Ib1ZO1nPMD/28QYPO/8Q8vjIYiKXETRd9MUwck +R9I6j9CsJWiLbbm3Jaib5j3ASLur6oRXsMFewDK18W+Sile15gjPTYrRS8UaZ8UbTUtXDmFR +xXvUcv9hnHS8aUgg7WRMTf5jDfJr2vq07Aj9xHEef8zfpT13AT0Im5yZENLvHG0zUL+hGtIU +iJwEEAECAAYFAlZ8Qk8ACgkQk01kaYyKainiBgP/SjdDB1eEtzskzt5Y6qPosISmlpcBkaWj +fP8BXvvMyBfmCEjyJuR65skFeJw1W0EgnAyM5svl5uwvx8EdrRbHGcBseyvYEaBXKNrO5Pq3 +XiEPO5rsZPaFggKaGlKGKW0PQSR960yFleKMHfwY569MEkiaYnld72DhzrQsE2xMuIiInAQQ +AQIABgUCVnxCUAAKCRAEWQqMa5tUMsuzA/sFMHRLAVcPNmAPktWINZ8KI7mWcnearqv92Hsy +M3TIvtlUeJ583MpmxQNByxGEwtRema99LVitfe/7xwT3Xco1RLKzja9Gh6XfVbTgkGQecwrX +mP/cznxmJkAxRGkFoGqvPy3OiL8rRHJV1wx9UDEbiQj52WvGDF8PYGTc1XYWNoicBBABAgAG +BQJWfEJSAAoJEG+aG4+cXHc8pLMEAM3Te6RqZmU1P/J2bKsxIhWlrhj+ljFyYWvjUsvsnFRm +KStINdmUOCG11XjPLwKPoXL32CCnVQvHix1ceplvH+GHjAwYVeuEFJNidNEqzkQFgGsRGVop +eA4y9Xwfyls++iFYy9pEHpGuEV0p7fv5hnh+rAzNoF3LyL8/Qk1YWJH+iJwEEAECAAYFAlZ8 +QlMACgkQ+AGVkIqGbg3NvgP/ZDG0OUH60fUmjPUesbi+JvBoJ4sJjEbCqet5C4SPmh+fnWzi +olrT5Lago2JYwdjDVrLuvhrCV6IDIlpFMayT6tsm5qrCopjEwczc2mmu67QFx8onGJuDVsW6 +GmS+uIhKY7Q7XMbRploveMjc3FBNlTnBL4SW08ALUdvjWOFe94+InAQQAQIABgUCVnxCVQAK +CRBPPs6jdBTkINweA/922SUIaoZIa+1AFlHABpn6n3JzVm4azAt7Ikr/1aII1LSV3j4Uc43u +lHjH3VTDUlw/kARHaS08k0H1/SHvl75YSNAMTKeG9JJongYn8OUjznPSl9wV6LsTllPLsnA3 +5FQ+k/MAm4JiGlUatN0nfje4rkPMPfH5s27/vR+x9Ma7zYicBBABAgAGBQJWfEJXAAoJEGhv +VfdZZpCjGqcEAJ1wP6/CggcqCvokbjQh45aOKEtaaomh3nA3ANfl3iIRsG1h+Atq096tV4AV +PqVLLXGHuE4M59/D1Dlb1TqfTLI/mvWNZayGXpJN8R2ZMUNo2KpVa/JH+3lO4HwQe8WyHE0w +Em7MHhBDY5e4sxLrvXTMLNfdyS4EYNUpFDN6n2LXiJwEEAECAAYFAlZ8QlgACgkQxiYzFJ19 +OU5CwQP9GNVhNT0P6NaX6c9+Hom/JuP//yu+Nt88psZ7DKML7xUVHTJs8smuXQUnbtrjWRkq +nxJYmk4TMBQgbjQpepmg1RVGJxNHxknbYcOls98gte0hTOrPNJHgStNaE0D9RvKB94UGBdYY +yeF2tBgRgJAV11E5s7WVJ/r0LDwQfmeey6yInAQQAQIABgUCVnxCWgAKCRDZ4Vt+NzwNsov1 +BACUFcysJOqQQcSpB7z3NMwEeFC5BJyMY0odNMSQeFFkKum7zhEWTeN93s0FWV0L6U7dq/TU +wfU7hlVeyvaBeYfRAyVCDTir3drJJUyGapWiJ/Sg/us3P3RTnPNfqeWa8UdWKSJqWyrhRGXm +v3keg3OxE+d9V2yReQUcpW/fX00+ooicBBABAgAGBQJWfEJdAAoJEA6OkSbAS1jTZwIEAML6 +zF9tWzpKahZF1Xz1S27oqVJqwgGwTvO9jnk4CD1ZBZ73bPvbhSkLkUBh3clpjlBehnOIcDD1 +9prA93LbK4oVZH0G/jdOuyyC9MdnblkF8dv1NCcjLDsHuNVY4PXXSH1fsR02QM5OhTV/4+2Q +2vG9Iv5M91E04fpktH0P2C6FiJwEEAECAAYFAlZ8Ql8ACgkQljY+0ODQfQCijgQAhE06apmz +H6vSx+FgCUjdKNJ90CpTdW8GGbdh0x43Mx8nS23nbF5vog/GybRy+FpENlNyF6zim93P/QHf +SyWL8AIwF+pBqboa+RWLne/1HWkTFTKU0WGMFfyPVteLFIV1mmOGHfPQxLzdpsqdIKuWpIvv +eSd8lJNs4yk+QEbo7+mInAQQAQIABgUCVnxCYQAKCRBVWono5KDWNZ88A/0WXKByLzN8jBiQ +ESUqShr5wxi6i9/SRMLb7Bc8Nb/j+fdWC60TgQD/kbKjUoFrcuZNn3/oeovgfHfwdw1312ZD +bVRYrHn/jh6ZkXAPRnuJ84JXCASUHs8ZfX2T9H/xrA9R8ZnQRQG2YioomFDmak+Cx8MkKQYF +2cW3qF7LcnwJu4icBBABAgAGBQJW6YV0AAoJEBvJ7+1ybmOLdp8EAIIqgFNDCc0qtQAVBANm +3TlkgILQ0Q85zg99/ZZQUPr0/CViWf/QtjtIweFan13bxU5jTXm3ChU8pGAbRduEY6W2b+Qn +bz2s1MlUoQoPmjEIe9uWF+cVO4+6CDXva/frboXAD3t8maQnyK1Iv9WziBik9mNyFhAFgwN/ +zbsvIHz+iJwEEAECAAYFAlbphX4ACgkQU/hrtL9JfiW17wQAnLQAYLoFxOtIglYxLnZ2aGiF +GF7/2JNNhijiicCJYLSQ+tmfvGNo1DSoFEkSsiIrORlTxsjWeSgnZDCZCYEBmYlMe/H8U8CC ++nRxhNi7rLcJRkzu7tpJmw2Pxelvxk896MaMbJuUvaL0tmGTsyIkoohLySKpt7W3zEL6sDKy +ZqqInAQQAQIABgUCVumFhwAKCRDgaPhxeRhOAo9yA/9tNQ9hHGoC6qsjpnIN0fHGsZemUlJA +K4O5L8Y1szc2UWigDI4CECHYPZTuOBMv0L8i0TDhxkKysNuVa73bteuAvwM/oncfyIjE0J+q +1BhWP5FGz2zYYx+XyaEie9UKAG5ArwG7wLjGXbljk1+yl2diM9mtcfaooPsM1MZCh+jlGIic +BBABAgAGBQJW6YWRAAoJEKEZdpOnPbJ0kbwD/iKtYkpRgOxMqPyxP9jz9g+Sb1icsq6ZhhCW +RrMSsUpfIP3+lhw+fee1mq8+pmoghlm2C1o5MdKBDpbZzXo/Xyj0OaFsT2/jpI8BBS3UJ9ij +WB31oogsbWN11YgI/nsA8ujRBzFAgugiSA1gBy/M+K2f2DrVf14myJWVq+VUkweliJwEEAEC +AAYFAlbphZoACgkQG1sht6wQRjZw0gP/QJZxodEUGmK2xKb6bua8jnNIXgLkpMObqSgEdJwP +qlr7BGy3cBw/zHgCq1lCbQy93E9sdU+RhGOLnxPOulv5nKrvOMoPQGgIrxncg86tmhToj2Dn +CjNmnG1QoyM46IPKvoag8jmkzcSuFul9bzvZgmFs3qYPBg1wWMVP+rF2DOeInAQQAQIABgUC +VumFowAKCRCjcBCC5hr0vUsdBACZaGNryFCkVI4F1lXosvsYUSWCfMXEBwgiajV/zgJlSM3n +QB1mBxPDjdnZz4M/t7ws5a+ABjlpBdHrheGkteCOhC0Zl/M4MCY7Ru8WvMbdWlB/qn9qMx/A +RlacKkO1V59EYJUMgtmC1wR9SvV70OHQIGPbYxh8pex3obCldP9ZsoicBBABAgAGBQJW6YWr +AAoJEIFvoEeEI0fK/HsEAKPFPeO/wAcG0lLtyAQzGN6f/28AiDBA5o/CzlAO0s7l3ci9MBt7 +v8+V/ptf0vC8rtn6WW2yz3tM/tXwfoIMy51zsJmCwoB3kxER46ZXRqn049g5UyrAnL655aDo +iIxWMRd8gbRHFcZ8kO2yYMcGSabuAZyC40yKunlyKA/n+lBAiJwEEAECAAYFAlbphbQACgkQ +7dNyeo9O/BfwEgQAtbVAk3CPVoor6LLk1T8BF/Dpyx7gtZeUtTo14fzDX027cds8nnQV1i36 +Z8R4yXTfKM3kSzQACDfhd/QiAudBwhhChcfOg/wF/7vHQWVPt5Kb5F09L5lOO1coT3JdftSD +pFhlJhs+knCWyYM0D6awExd9lDvDhftlSnXBvvEE4yqInAQQAQIABgUCVumFvAAKCRAE3y6c +3LPKsynaBACyRKAq2uH1OFDgv+g4UMxM01iO/sCyPeE/iQIVGihEqrygSHE5+5+KQoIQoHjf +HOUdvQZvmnwwKJyJKEJGBmEXiH6lAokwuViDvLhALjf0xHHwcCzZg2IUF7lad/Nn+Q4VeAXr +6z/CT4lvVgVjbexGspfyY/7w371yLEEcQ3b9AYicBBABAgAGBQJW6YXFAAoJEFSJzJapbqjN +pMQEAIW828dSGr/ZH0DnTQM8FQ2XzHMNyTqY0tFvQfe+oIkbyq7BtpLjRQ4b+WnAx1BwYogP +MLB/LakUMSU/iRH8ZBtKR/F6OhG/DlvJoZvCctDgC6gfT82n7AuoWWb5WfHXTASRCcnLtRtY +Nt24uYxDc6dTuVM3fS1dxCD514Z8w7VKiJwEEAECAAYFAlbphc4ACgkQSfabHlAS9xN6mQP/ +TvuG1Bkbb2bq2kQ6fa5splspQx9tWkGUmDRm7gCzntksr8g4Bk9EJLJ1m4j47GbhInzVW51u +RNfL2E+Y/hWoWj+GhnShkCo3i6oe2E7uk0F2vL/S0b9o46Y5+iwzvyBImHs6tnkU578CB+qf +o0HJXIIrEVOcboHJxDcHc/b7sgaInAQQAQIABgUCVumF1gAKCRD2OzMKT7R8unxtA/9UVtbc +30atu/0Bmvp7VteWdmzuv5RwTp0dFOnrdSo1QNeYxnIzvmH0TvtT0/N5+congz38LxSS68lF +mCMIouxxDMV5LvLO36qNMlQZAvoLdF50c3hmxp79LhCJtsy9nUBW9s5KCZEtmLDIKnRpDi6/ +s5jlKS3vahup4V/dLLuMDYicBBABAgAGBQJW6YXfAAoJEGiktG8kYjDGCl0D/3WVtlktHyE4 +876O2HCwIB+7sFXcellY8Gg8SQP90W9g/l1oM+ADJp+bwvBq48rKgqfXF3VF0JLBSv+fSECJ +8emsSpThc59YI/A8NXiRTQrhPYx4iWagBe1E0h8RxJ4tWpohhO62Ol7O8M+GnJ3c3TiT//Eg +A1erZ3+g5ewT17A6iJwEEAECAAYFAlbphecACgkQPHplHyP30YrDkgP/eJmKbZT4aGZXHUUJ +kML7zJo/+XE3WCGAOZBCw2Z6eWXAUzB5MxC9nbgJHY3ZEq/hJ9f+0+/kjre3hI6y2KCikKRd +XECpXK80oya3vNOHF/sSKAIBj70367Otx5c8gMgGWcTvYsvRGSrax1LGOChoxLOtkNVrXd4k +PzTZrnRZlgiInAQQAQIABgUCVumF8AAKCRBRLGXrePf5sjDSA/oDzg5BUgTz5E29rrwPOon9 +VRLDToARJjiz2GpNSAlhzInIeGdHgjOG5G06IstEBfe7ceA+XJnawnXdljPKmYfCF4XU9SVg +ia6LUAueA79eGSYRVuS8fPWd8pZsoYySoV6fltiEP8egF1+s+Ap9NfssFce3whZZcxbWV6uC +alWxzoicBBABAgAGBQJW6YX4AAoJEIXBBHIkjDFP5vQEAJ2bsApujIJ24EF36bcANcYKJnNw +8xxvQfn/M8Tiz1KmpuMnZdyTjxcoGwIBPd3WI5fnopHpO4/yjK84xgCEAFYyBsOGE5/ljH9E +eOOpEv/28lz/QhjVbsGgbNArlmirn95nK2m/Fu/4b5gEjec4AFLtstrjeH9+E/pQD4U5A7i6 +iJwEEAECAAYFAlbphgEACgkQFNUwLY7yRR2wfAP/Rc8q4I5tJXNHAPZNcUKppsM8bzOjJBQ9 +XNMAhBoq86fpi/X1EZO3yfOPJYNYdQW29QfXyrSLvmdS1tZlG/BURNkXXH5qEOiSRpBbwTAo +pse7dqzBKiV/JEIl+8fJeWcgptvvJynXh5Ik7chE5U6RO1Yu4e2seFGpuk4HoWl+sGaInAQQ +AQIABgUCVumGCgAKCRA2WsC+UviphambBACNjKSc89fZtkkBOpZoQ9Ijd90ylBOzqGE1Iekr +ifKq0rpM8SbSOtUZXfKAEFuZbUEHIpONpYK5RiEAEQunaKHOGlVMw7CMB+bXPjmv6WyRTIrd +tf4X75dRxsBBGuuQLf78Ay/nHxAkWtGcj+D194KhgzZwSKPQmArD6PWmUiXkGIicBBABAgAG +BQJW6YYSAAoJEMhcRcrZgnlE5bwD/iBImreWP5b6lnDrO+b2SyiW5f88na2BGxB7eKQfIA8a +KAycCzrYHsWvbF0UAOpAFKruUgakMjBsRiXdJXiQ/+YayWffgYU3Sp6yjXKVxr221zyLvMw5 +/llRoJDdy1FfgfxAV4GtswxiPW9le52KiZeDGtg7VfqV5lO8QjaADeMCiJwEEAECAAYFAlbp +hhsACgkQkB1GQqYrRNavuwP/WdccmFkpfcY4MnC1fvR0nk7lGt+qTBKwMcTrZHDo7TwmFHPv +pgjyCQ/ZvraG6a3Wg94ZylvnDBhbcXRfD5SLMsrkdaMGIwNphhTsGGkfNNTWN0iggnAoSmbm +E9gL95eBvCGypMVk3rbc13tTRwA6tcR/wDndOvs6ca/CdDSGh6GInAQQAQIABgUCVumGIwAK +CRD+5hS8OCuNN+NIA/4wq4N+DeiFTt24TVvJ7Ia3am9FzOKAU+74poqhJoiFC7y8HEdKBht8 +gD0uYtoYouTn9kOsDCz0LoTWVEDCm8sSzal3ZrQc3vmdCoGWoYi2VXNy/RXY2CwDUXricSup +3lqar50Zm66JlM81LPUmadI8XKmL8C66H3AeRbMT9OVGyIicBBABAgAGBQJW6YYsAAoJEH3h +x16nB2VDGqAD/i3acxFZ3LUurrCdO5BPqQ4AOQ1+996xyO4Jy1peYXA2Mh7IluoXtqkizXbC +I63isXcudx4kVynzGJhqWHEFIlvYJdpCVxp4Zmn1z64b+CqN2sfgB1rbIrkLvZL0CI/KxAfJ +7q4td72GDb3+Y8/Htdk47Jx/e4HqAoi8hoyLMoMQiJwEEAECAAYFAlbphjQACgkQ21KbFwEh +giYbRwP/ft2h6rDEFQ3QhhYs65zN1aQN7vk21ItsFL3z4oA4kUu9FbHVlo15C4uSSa0XwgcF +NbCk9nbYdWH6TL6axF84sT4HCA+3B8S6hElsUzNQu3XS7AxQ8Ne7Jx6r1oKSkB2VL4W/oMzb +xFis8eybf1rtPLp86Quh4bq7ISwlZE1aufyInAQQAQIABgUCVumGPQAKCRBu+Zy1BVG0WM40 +A/9HkzoukHoIb0hL8qsjpfl8QkLNkQNYNl1bhPCeFqwuOwomAsM5cH0dVqDhK3HMfG8pVjPp +t851sFilqQIirFq4/rGh4FjqfB6F9U8QXKbRXkb/vgAXC6u8dF3Y2IVurCYiVcmX580Nx0kg +RYZ4TNJAkdAdEqh5fThN5CMHi1Zcd4icBBABAgAGBQJW6YZFAAoJEHgJtvxVnDCkySMD/3OG +6TxwpezWAnoTkO1hwAmGimYmRGPeccCcN3BBOTMvGNrz//TVxQEJZ6ZXokWPN+aiShAvjmT8 +TxM6fWYNqiO+wWr6f5rH6dsKBFgjqdHZKDqYW9jQtyIuucAJB6raXAhC21QOoBcQGsCusRb6 +GjX0x7nf4/hjI830of4AOfnUiJwEEAECAAYFAlbphk4ACgkQzXzPgWO5G6BqtgQApPC4jMRm +i3KX0f3bm45YtzryasClfOKRkTZzAyXCO2TKrt4gRq2n8ARABy9wcKff4DjXbg5rJ34qVDTZ +lvrgABuycxH5SDnI9mfSU3KTvr3hr0CmdQxmkI77XH2Wi/X5xtw9hc6yQThnY2Ewuhtrf/t+ +vJIPR3taIZHnlWybhWWInAQQAQIABgUCVumGVgAKCRBYHE1dKb5QbHPQA/9cK/6d49en0J9s +99ZIc7Ri4KuvFXfiD+cy1sP8VAl5DBindXzVgqFEJTn+7zmd8Czijl2VvW6V7d4C9OSramD/ +kE8yMDWtDT6kDNP9xfUR7O+HI4ocQdSv+VTDNC/0eZfVFIwsbFcl6whAzisZvWOrRmvf0pSP +BUOY71i6/7o7KIicBBABAgAGBQJW6YZfAAoJELz+ZXutCdjANWgD/A0VGLtvtKUzKW5/r61Q +s3INQ7AQLHEaPj6Nm3uJBrwpfBFo25PIRkhtTpMRBaZsPk2YoSdtfIPkcFOrS1B9Ygag5Fjc +WIoHX3HFYBAWvOm4ZBSkKeEemrh96jIkhSSZpvkD0y9PcAW7Lgb4J9zj60d81yoWcXRfQ9ui +BM9Od5ljiJwEEAECAAYFAlbphmcACgkQjlfiN2wpUJzi4QP/W7qYjTSn6Mly3d/rQm60M4YW +wrkYuubT8eQ9jfghVD0a/1W4BOEXZKFRQiH7U8KvW9Qo+rhODJWvehV9R7LJJX7/sFed9Km6 +RiNM/C4LW+rKP0n+nBBoWlLNMpvUMKlasn9c2msXxacMVKG2nkOBvV5/1X5SichC74Q+ekqb +RdeInAQQAQIABgUCVumGcAAKCRCBMRkoIGe6po7QA/9HZvJ9/3rlaKDycyjE6+2UZAE/wZi5 +SVNV5qkMiYhrIELVvvRX1KArYV0VlY1+MuDVRiLhIsilob4mrLdZyjWLrQvLOd7Tk09lvMFs +xI0oer7bq2fWHkPe2YKhhCaD5KkZ2izh9T97Wz4WyDecoNwxUvmZ+m9GXc7lH134PBrOfIic +BBABAgAGBQJW6YZ4AAoJEKIQhBDXZXvqaHID/iXH9yMcYQ1EYLFeOQqD5Rh1KNIEocZZ2O/b +8B7JSs7nUnFtKRySz+tlZauWyn2odFlvowUQpdI/y8Jx0BTLgZfvuHMz16nexnD1meifIyLI +Q6hmNvCRiwHrskXxca3vl3cgCsQ/2/xmmuzCJDHwGIc1h80Lx8jTySX/qvYvIkGQiJwEEAEC +AAYFAlbphoAACgkQWR7ZgsZCjKk+EgQAiFrvgTdt5LGwSAXt4fMSXX/QqrnNv7s7AJ1x94RH +O/binKOBJTUgetS6br5aypbjX32xbkFadn17YqKCu/DjuRD68yCj/bRr5L54gERmzUXyDGO3 +FnSgep7RNgzabxnbhqVFqHVXyhIM55aa6AMXjpHtkVBccp/T37cgialjzFeInAQQAQIABgUC +VumGiQAKCRAsuhc0CP5gcWkwBACBXBs9vA9sT2Rf+5zjmdDnUHiA6B8zygaFyjD6xmzpMeKt +MJQiKhcIse/o0JFhMaoQmcaM0oxAcgssUzeIxMNkA5JSEb18aaKGzg/Fq9fL+8Kk53j/yK4L +ssHGYlp0aqygbQzkifCa2TyQDYnnPznmwlV8H8JfFjk8vWm1sVsp4YicBBABAgAGBQJW6YaR +AAoJEAXbn3E9LX+togoD/RwV2gIs9LojepT4YNoLmtuhnAc0wEKHXRrJP0Op1E0uqxuGY+F5 +l4sgwGr6qAKR0buWUFVq6pXq7ZGm2/S496sWJjYzFMJX6i0W99wOvuQCzVTrMoJxUgc5GebO +ooQuvgIoY0PuE1yS4mO0nsz+Oz9xqs5ztjZBcwSEafGNSIFSiJwEEAECAAYFAlbphpoACgkQ ++CEHeP84eS4u3gP/YdLEhrJe4WP1ofONV5p0qsUKW4YsHd6RjOMMBsrqT4QjrgZa/jP3jl71 +QTnLqym8WcXb0vUrnZpm7ErvnG9rX4r+C0/OzIOkUNsoSFvknM8KYw6X5dyZUOPBThuDcG01 +kg9eLHx2f0v5hxMPQLehqy7ls62dY1aquJcj7pmez+KInAQQAQIABgUCVumGowAKCRBFK632 +rs12Ri2dA/96K19yHJPCPljuMxfekEhhcumOmDjOPtBYZjQpIo1Urp0WXwkFmlye/tzWHK8D +/wP+JVCb3tyrj0YetcGKNRxVZdjdTfP2BhPbu0LEQ+hsCApzRZEmlb6Xd/PbFrArEmhozZZe +3bR0iBIcWC7s9uoppKgSX+5ihT0q3/HdbSUHS4icBBABAgAGBQJW6YarAAoJEK89OJpdQTsG +uHgD/ipSVjto1F5jR83DttSV0m8F1LdeKwm8AaGcwlDxfpvozDUxNTb/Uxz4GeUhjX2O4KAx +FJ52v0F5ndRkIeiOBUpCtXvzy4MXcHlOQQuTYrxtwo6WUL7GJKmzhkt9q0jj2zLZTszXbA4L +33U0SFQ7We5tXdgylUij0p9N3pgIzzz7iJwEEAECAAYFAlbphrQACgkQM1NL4h3mmcgnowP+ +LrNr+/yOVdGgp2E+VUW5AU8Iqk0hUXfBc8h66xFoALJCZBOXRvebt9vgmk//fRiQ02QDR4E9 +ME1QAhSOAmcJuJhmdhp4to9zLKdbiwP7Lz5UkiAJ+vG7gk1iabdAWNlAP+nWxfA5/ZuAOnXb +DtDNQ1JEMx0hXyMGxGHuQVdRyk2InAQQAQIABgUCVumGvAAKCRBKpyJf/ic7NIx0BACg3FI6 +WjqicCfOWa0nphsFJBb4xhct6FzEG2S0DzsyfDyI9kVANPIrnoJeYPvkxgaWEso4Aukr0yJf +c31vX8CkqwL2JjFONmloJP1vyLTdjNtJdT9KovohME4t64Dd28Jq6tPWZzQYaWo9VUEWBh9x +HXjNv0mFMpxXO6bjhPAO8IicBBABAgAGBQJW6YbFAAoJEJlXp4LfJG1IwvIEAJHdF4lRyqSC +977IC6fkeo2m+CXF0soxoOBD8ZtvAn9ZEo6PbWbMn5NeWWx546Lh/YvY5QMV6SxxXhajZspn +Srdt3UIUj6Yhh3ipHhKYj3FwEmYgWtXvbGH2mO9ty3bdiZeD5ds8Ggg9w5dg5/tHKjsuxXCC +cRWcjNXYubfDx0qsiJwEEAECAAYFAlbphs0ACgkQVtD3sy84QxQQWQQAj16c2IT3Q/WNhHHV +dhgb54uwGewpUr2CTkhDaJi99xsEjlgxz4L/7UWEi8J6jhpLrl7wkSL8rgYqXwJtKzJME/KZ +ZqWdjWtoaVEBuYQId2M0J2kyh2oMw8pprzd8Q8bVLSPDZkCtEXARRGwNqW7uA26RUnc3OEhb +Rtn6QgmHFHCInAQQAQIABgUCVumG1gAKCRBRpA6e+bmbiTmdBACOXhafCeOO1F3gCFlcpYcE +vEOZymHp/5RtgxLAYESdOfIIl/Nbu75tBOQSBO7vp967esLsbTVfhLZUGzIuBV0lt0MDiR8g +Zq56tNU/i9gkFnK6iruQQ75V7tENVAdcU/YSgCqxSm1SzMpsZuUBlsap5P/fDEExIZHDK0CG +R2RJHYicBBABAgAGBQJW6YbfAAoJEK18Ff4BLiXQ6kQD/iSuGp5PwbJGC9ihZPgf5z5UXokX +nGuwfsTyQVPD/oafJrBqSwkaVhdFUIS659wpxgt5LkMAAbLyAlxWk5Us2qkiwNURJQ+tfVnV ++dKVHpDA27YxPz5vLdLtq6vgJAajjU+22YzfsEfTT17UtB7l77TkkLpgLP8Z1eyvfi8woefm +iJwEEAECAAYFAlbphucACgkQCzGo7TdNSweqwgP8D+t2HKquCloGtjtDJeo5nvY+NpxTPwKe +c30tiaMVhzy7P7YEdE4XQ0b1wrFOdAqLbByulCldDe+aLEhZtRJ1r0uy7MLAMfchguzs7fhW +z83hha4cHyzosbgLQGbO0TflE5KlsKmJ1HpNrQSivoJAmy5Tbz0Tp3dephJg79O02SOInAQQ +AQIABgUCVumG8AAKCRCtS+x7bXCFO0+SBACQb2mzw1MmIXen5RORhHrcnmPoDH4phHqyyflH +XnqiApzPJzWjWBizXRzAU4T33K2LVlN+TqIwHzgQ+32ZlpDB0XAnTFMffzcSIwJzkwVrwvpD +lc5J5+ElZVeU5nnLoBg+J5wyySINmDW7fiEJPsj8E5QGTk3PjXAaIqVpTvlKmoicBBABAgAG +BQJW6Yb4AAoJELMSknVS715cqi0D/30IV4LQEKosjwven37it01LtabX9suA9U4i6F3UvJ0u +aYM2g3w10CBaqbjucBc8j8mwJzTj3EIZQJKupzlqBk0KqVsV3CwsiDtAHR9e+txks9NHaqUr +R6xlB9qqPO09kjpfRxz9qqafSrKQJcFKFiZNENkPNk2bI9ZbDc6kRejGiJwEEAECAAYFAlbp +hwIACgkQIdWbSa38D9U5EQP8Cv/+oOGRmZQaP0D5m6sfsCl4nzGizvwdL0kKlOBRMIMSKbnA +T5nvDVh88nTL9IuZwmCNC4xY3iIggn1G9hr2M+hlrnQj2AUgxn4hcVsV808B1IlvtPHKk4R0 +7sWonUmZOcZIyU+nDGAEAincPB0boE6SYblliGWp0pbqBfZ9UEqInAQQAQIABgUCVumHCgAK +CRB5+2DCMTEttTsRA/9iagKjrrKTGmXBHQoMhHWFtPUAhC1KDeCXSaJ4wzprUsC//kDgss+5 +S4fHLW5G3NfMd7GD2xJnO3eszLZTEkjXhqE+GM26HdpJ7wo2yqLcV068HCFi7Z9AmJTCmsl/ +laAF+EBwOaBQe24VWv6prBsXxKlOYJ6SBNuTSFK3onkVcoicBBABAgAGBQJW6YcTAAoJEOS2 +0mMl57AEhIMD/jZIfPr/7P+CkATQBKYVyDSfGz1ds19Tayun8D/LhSzwtuM0281T6dug6NAL +M7f4u8cP0iMqdm1WXML3j87A9WueaeYjuFhcVULHnqwmTZfb+O0EkQgsm5Nxta9cIwHMxIdL +taoqneK6GNgAQKq3Ur6w06z5JDMeOkR+ytppuy7niJwEEAECAAYFAlbphyQACgkQF3SfS/KH +ls/q5gQAuBLXZF/LlW+6NFqRJMuALy8esWl4+gGkgDyuFga7lf3/haZh95PIwP6EkJxx90Bu +Qe5LwcFrSGLuBmgbU7Z6djPyqSxGsq9sNf7QUIWVUtG3XeaQsJhftK5KgTOWGY0+yaHWIRGu +MVh47A/R3dZjLS/T5P9KwDdZhueKC+Se1c+InAQQAQIABgUCVumHLQAKCRDgUsnvK2bsnhRH +A/0U2anOcsB/Kcyqdrn1B6/qGT1ZBlkujN7sfmcO4yj7TinBc3uBUibDAe9nMdlTIpwaL8jY +LjMlGQsY3QGz0tdSJJSwfHxskd9PSQ5r9+orP8x1B8AdaeQkJtUZrC8WqzMj2qxd8N9i7eU5 +RLRVvjat39S7TtW9kDmlJtq4gvTDbYicBBABAgAGBQJW6Yc1AAoJECuKh55GEgg3C6kD/Rmy +EHV+BIPuHh5BgEa40hNmPN2zTpezLuWIh9HpiYSOFlTKIiH5MnBCG+qe47uaOBFPkGCTH9M0 +4FkrxZIkyTiH5y9BddLHLJW398I+GSayHyL15I8gM6lIr+h+85d1s4INi7Pjg80SFV44IsW6 +ONQZDaYpmDv6VaAIeASH3bKmiJwEEAECAAYFAlbphz4ACgkQca2Z9XSet1QXjgP/XUZOK7zh +pU0ie7FpSuI0YrhvUyyK836speJ9prQuZK/jLqVluz3PYBDhhUV47ZmHa7gUT0x4Xdz6qup3 +XLsiqAkFfrIjYWrkRTJAKfdEY02R56RsTyKuuDsC53VnvBp9nLJHmF1DHene2FAfUqbA8bly +WOxSNpCPquFieOn3qACInAQQAQIABgUCVumHRgAKCRAvKtShWK5ITOQEA/0WOAlwkV2kpyEk +FD/yXaLCUxv681WfOLUSPF+JPvJA9DrBIdGuvAwileRmnKGlARjOOtO/clyzUt07VFrvfBv7 +Zg2m0FxLqvRlmvOKJY1AemXaxo5q0sdCxc1y6H1qi14e3O0xCjBXBaWOBTvbgbdnfz2sQc5C +bUrHehNe9AkFsIicBBABAgAGBQJW6YdPAAoJEJ9uqHQRFkqAUxwD/ji1GvS3UQh10yE9jkP5 +auCHpEIyIxOoON2dZxaNqAKSmxCzwiOXY2WpqbvrXwc83lhmTvaBXvlZzRQdiq/K3wExC+P7 +51OZY+1v9+/pQWkNc86mUAonEqA5L/lEK35DWJMyoeKpfl4817HV8SjawY7saX2GqGWj19DE +tOHTmjRziJwEEAECAAYFAlbph1gACgkQuajYm+x/SEoPygP9GViRoKHp/9dxOsNRN2z43ko7 +AXXApFHI48Z8KHH4Wgpm1MGk+pakrzipp54KIWQG/6eMP4s5JJJlsuyo1Nq0oVfd7sm2EIi/ +Vl/U7oOYK4aqnSELwyhcXZ9U2TjagShBVY5Pelw11Zgb7iWekzJ3w7RRA8HbF6ptWSWSfjxK +yrWInAQQAQIABgUCVumHYQAKCRDml/6h4Pm/VeRhBACvSvfijZldpThLpyxrJGruAhjznztr +378G8anYg923irxpeZ260cfMFn8kt3tL+MNRAewTfsBRxn1dttew5tVU5brPRFqgT28gKgxU +mDI0zN5Yd8mt8OeeViswGEbxuBZrk/628enw1JwYmftZgLQcKgQVrbCk63cMYF+EiwqmeIic +BBABAgAGBQJW6YdpAAoJEB/hsu7pxRzP2Q0D/12w/TxxJn8Mol4z4cwltu8eH6GCz6neQbRu +mf3bhL0XvDLq5Do/mSs0B9mIlPHQaZYLstWlr5cEMpQ6NzAUNTcYCQnc1SM3pOQ8AmELdVQb +IzMdypzEmSVaEiuOQm/H+p3yAjlFFSuJsfu/4v7QsmOW1uxhYnsU2VRpByf6A0C1iJwEEAEC +AAYFAlbph3IACgkQ2/TRWhETrlF/kQQAxBeAzO4WpIfKlpPbht9ELcins+E/eYy9O12ivRSr +2e5G+5gmC5fe3n7fnCR49Ca9+a4KJAoaEE5AIo2YspF/zpEO8zXvnIWMcZ21y3kWj4sIokAV +YkXpktAWVFoQYrLbnLt3RpqGP0tJWXBhzpDuE6BjUTtgVQcphfQC+tpVYNOInAQQAQIABgUC +VumHewAKCRAjn4egLKsE5qNPBACA/Y/SuV+ZGhYA6e5Ese1m9oPUOADgvALqXz4AtS4CNNpI +bn5Gqy3DmdHwkwaKPMJMCHjOUxwXM6SONUNpTDXy/GkalpgJ/BgVPvgLk/i8CSUtlJQrQ8Ul +JcHkjZYzPrqs8dOy+dj0WY7XbbnQLbjrI3bKZqQhf2oyi30S/hhbg4icBBABAgAGBQJW6YeE +AAoJEB8uJ2S1Ldjv4OwEAMRzf9l9z1ejU2OGlowjNL1fWyhj761rdqpzFaY0+5iyZhLOFLM0 +veQFucDVkrwroGQKzMn+zerqbvrtGpqaakmzpuGcTaaZ9UvMJkKbRqXrlLEdDgP6XzcVpvKt +BmW6tnjhD99ZHX3AXIuhCtHyzMX4WEvbrjlUPJnAAPDQnRhyiJwEEAECAAYFAlbph40ACgkQ +LREF/6SKsF3wwgP/YZluqHAZnxteno70hw5RgLwLhnhAKhb1zpyoBOYNLNShYAtZ2FjBShNq +kuiY01CuaPEgplXTZ7AX6Qby+gZMwXrU4CnSB6kG9wicuMDirFyVKUQkjPXvJadH2oooDLS6 +CEyGn/MAzPxN1Vu8aLDnyZnEA9+KN8Gt6QwXV1vl/pOInAQQAQIABgUCVumHlQAKCRCkNahu +k9r1GxgQA/9BNPfptlhucY7EfelZVcIq9BBkLEQUIAg8rdMFNS4I2dhmt0nPdztpv9mZhzLc +nb5KHQJ6jLFqF1SPPUgq8vWR9PTC/HBZzJ7yo2SV+p+mFeZQvbDJ6pVlBfACVPl7HQLj0QsQ +gaonKY/IeS9vQQzPWcFpnyI1Tkkp2178dzwq8oicBBABAgAGBQJW6YeeAAoJEEWp+80FRPHk +rBoEAL2m7s6WDoxCsl6G1WAaHtuJY1DmI7/fMBDQt9Himr+mslR5RcaPjyM7GAQ4w4cWr0sl +aaa+SV7wD1aryWGiu31vU5HuYO3QqqO1aNCOt9C3HUSzx091ThEgPoQ7bOGAqmedvc6JcfBP +GIJ5kYH8nMe/6NOyjK1NhHTE5PKbq31liJwEEAECAAYFAlbph6cACgkQSDzEHCk408QHyAQA +qVtgCAiFMsPjMbgHk7Ye0tRXkXtsCKzMBrBa6BDDaH5c/hPcZk9KQTDcPLpUg38zFld954f4 +wPMMGXbTbDSutjLKIl7EWONzLH5qdJ9GRMUV4NGhEpSuZo0a6AoJkcqtoOnb5X9m0asd5DjK +EECCrpZfyAtIDdlr7LgMdV/QAYeInAQQAQIABgUCVumHrwAKCRAWf5g9yWk+eH31A/9PCqgt +M+pxz2Gskgyqr3zWsfcwORm93Nr7DWxtx9b4w7vWVKp6h4VBI+ambK8Kd5aKijGtFWCay8+4 +UWVPMHtZxKd4w2l+xBAaVv49EceMZ+ilIe/PlBKfVvYn3ciysYaS3f5x8AFN8lhM9jz0p2cX +bnZdSptw3qqlN+lGv4E7z4icBBABAgAGBQJW6Ye4AAoJEBkWpk95zhHnyOoD/0t60/KhXdSN +2uL2IvYiONwdFGCEqbVoBJr3Rgje2BM42LqtZcOmMDTVcw8xj8wYLTdGkX2z9gv3G/qpxuuw +SAUK2ViPEgyUDWFAnDrTAAD9b74kXSYHbBEwh0DfcpA/0cYxTNILvl0+0tBN4Mi4KbX1OfHo +ab3WLMxF6vw5FrOciJwEEAECAAYFAlbph8EACgkQn6e+69p85QQTDAQAuruLNNP2Cmc/p1oM +w57CZVO6OsSPNBBgeGs3yC2oVmYgO/ltZcwQyti/cHRMVcKu8XeYHzluabx17Nw47FMoTXJd +MVH78HA74pQ1Z8uKUkTV9J/xRy48BQk/7wfHhsO8S7h5s06FBwuPt/LQzVsrWfO6UYz7CHyn +pj1n+Tr7avyInAQQAQIABgUCVumHyQAKCRBZbWpZ1pm5SlnQA/4x3GKG+j2Q3xsQp4Vgqzlu +ocGVnzERAPTVtkJ3kTg4mgbi2FuS0tMx0hkpikEsmJ+cDk7uGGdfcg/dyx12pxRmMRpt5K6v +lSYlHbfPUmK1B/gGJ4ZiQx7+QT9lStyIFsSYFOw2gZHgbPWqCTP5bB+GkZNWULkLTV+iOkgA +0ntJ2YicBBABAgAGBQJW6YfSAAoJEOqokYiYpmyi1D0D/io0xpvZgjmllojNTMug3sOVXo3R +N+T/JcTT6y0RORNAd85E4BYKlfMuTvxypZtyoIq/h95h7XwnFErAs1Yaf5xnzE1qnvjgI62c +h1OkNwIr1kT+IRhXJZ+cGTOb0LdNz5OGP9DFuUZkMDu1PHA4WhSzb/zSPbnLqkg+FYf3AB7g +iJwEEAECAAYFAlbph9sACgkQgOXXlrGeXx4NhQP/V6Qx48KlrulRUDt0OJUubkKyZKcidrRd +ee/76S9bzXX6pvwYDfTFa7pHegMp+1jgMyRhJPeuw0o2MIv+8I4XDoH4zple9FCXUp/2qrxo +oItj4MMFUKqK4y70eowrwgoDBeLAbQBQS4Y6PjZ1okOmB27F53H4kasTHVquLu3yOISInAQQ +AQIABgUCVumH5AAKCRD3oB8720UXtN6bA/wKuyrqeIsG4yJNRpExTZ5ouzxpwNpIsqKR4a16 +PfabHau6TXp9hrb3+47m7uU+5ZsGjnCHkjRB62/t0FR5NKAyM3HR45EJixVt9cPnig3KLhQQ ++Bz0rNTu6HxGky8ol/hO/pDZVrWHvO7VRb3ls2U60sqN5C7k58iV22+q+JxK8YicBBABAgAG +BQJW6YfsAAoJEAhqaBDZpFI6Dk0D/j/jMk7KVhl288h2hrLXrAE+Y6qJYt+kg7KuEPuqRmbt +N1SOLuMwi2PaV0MqYnpCXArWhSwpD0jujm+6wnqesZXdx2m0NUTHQXL+fetBzdvowu3lsXnF +ZpkMyHWKuWHk3ciuNzB6RDZK3GFV2Iuop0B2e1CuwbNmMVlkUkGts+wJiJwEEAECAAYFAlbp +h/UACgkQw7vMbEmFLS2tJAQA31CUEsyFhEyEsr9BqoA+KTTwVPP/WnS7yAUKyl9vr0oTAdrv +inV/XlCP1RGyhTzUtgmk5JQV83wgmt4WKq5y6PbWke/Ubn5EOa0QuZX+3kmw5CyTwEnThM27 +Y38crx4XG7IopJjS7L3l78zcv8qEU3AWsBybud2Ov7PkKngBrEKInAQQAQIABgUCVumH/gAK +CRCLIhu3tc1oqhlDA/9n8592L19ZMJJ0cD61aTcalo78lo7EH2nwOcrXs476rr01OvsVxC7W +ccBZPH9eEu6fKEdo7OKDa3TAHW2giFFIiMWX7wEcdh/90p63NVcoNLUQFV9gFANYwf9JrxWZ +tODjfIchmntORiQYQ/HFplz/8TS+6xC/MpASQuRnraPuYoicBBABAgAGBQJW6YgHAAoJEKIv +Qex+eGT4CakD/RJBZqjT6/vnZDyl/Wq+TqtnRQ66tYCkNpgrLx2JDrMv33Bs7US3kzAHgn3E +SjbSGBxuNmGZVzMKX61kgYfb9IDMnmQMg1D0cSAQtbhemSWuAWuLRVWvD4BFGzt/6KaYEqMx +dNtRWRXI1RxCyKelqUbcC/HBAfJCR7jDcWwe2jc0iJwEEAECAAYFAlbpiBEACgkQnfI7dtr8 +uthqMwP8Cr0K7x8/fbNE9WwKEOrkO+9Cr5IcpOScHmSyMgEXpkKSypgGHOc4b3yChCCm+Pku +TeGmw7X2/9GjPwdeMoxlUPN8SMwzUs1u5qDHjgWqML+EwdP/JsAX30SYk/uQDHlP0hOdcrDa +9S4tslPddTy2SVhJlj9smjZGlOa/m8HvOjaInAQQAQIABgUCVumIGgAKCRB/cC3D9AQif3oS +A/9KkDr2IfmQDNLG/AJOxOAca3/CF8RfqGdcx8LsYsqY4G7fkxkaqXIqAz9nv3HDTFPNHAtI +iabUjrmIOV5U9V8qoOox2/n3tw0+yAt3YF3jjcnCIF1b259jSeIB0mSX3Cix9orectsE4x5H +RNOW/a+X1MBR8JvqOohEqXn/UoLje4icBBABAgAGBQJW6YgjAAoJEESKdkYur9jQ6VUD+gOo +0U4rGICDCPr0jgzUegRD+tC/WZ0p7RyGid3yhBBXNKazqEYVWtYzJe8cx96RfqdPqVAiG5P2 +HAkHiNkJDd5g9hfEnOAgM1SM5wvGKCrBBVTM9s0RIbYFI9fxybIY57WjIZeORkjPFpMF8zxO +OfzyOZ2SrqRqRv7Bi4TgQihgiJwEEAECAAYFAlbpiCwACgkQ52yxMpEiECSngwP+IeWuk/1J +Cg37Lfv2EdnlUAJqqPyxSbH/y9gQM3YHjuP91mqP4wlXn4vX0Y227nhnOGSBakSV4Ev5Iefc +DydkWC+SHdG5ZXtsiElR5Ne044A8jZxFJeWGMOnYzfSIrkHMyAODe+aIM37eNCZfFVIQeThp +6IabfJljOKUCiEVytDeInAQQAQIABgUCVumINQAKCRBBMjx+oWsB7Ut7BACB6O2/i2XHU7bE +e7t+MiCyYTdnDtWFLpaUNoIvWeVuC/03jTSudYBfyG1FQT4u4b4Leykz83yyGRsohR/I83m6 +rYOO1Xjg7efUvo5Xk8DGpsc06r2MT3mpyqnPDMcA8c/Y5q6UGyFIq5hD40WzfQ0t0AEcDcZ1 +UX2NWHyBh56v9oicBBABAgAGBQJW6Yg+AAoJEF+xBSRTS7Gwu/8D/REFzO1D5HMylr10IHsa +HlcOU+KHnZm9LRKqJrVhBQMCGwKVLzG53x+JwkSp4mTLb6intUUtgZaFV9uWASyoUU3gHOb2 +NMCvEDmMRP8hFjsWWIfLf8NYNbcYNg4AgoXdAG7gKPCMyXDmgsEfzC5aG6JiMc36Mnr5moiG +YHPvGoReiJwEEAECAAYFAlbpiEcACgkQ5ISVG76wc45WiwP/aLDrC8fblwBzbzOcgbcgQFp6 +CeNlwR5mU3rhGT/RcDaloh+OPRQ1apaYrVkcSv+69zRauSXc0qVk/V0bp0hNlZeZ2a79Yl0Q +NEfqnRkoBmD1WugSV/sh8u3s5JzBRtua/BSdEfb8Jmk+KGao9XoG2O5jYqzZeMJuNEw+bwEm +ew2InAQQAQIABgUCVumIUAAKCRB2nGkFlHRAPQOoA/4pPQowRYiPIaVXotRt4oLpy9Skk9Mv +jWiWbxKw6DTmUq6pU960FYDeg+cvSgcMpjM3aa+efkCK0GrF5H/zF8ZbhPHmW9PcvxzebM3X +8jfx7+xo4A8WBiX9J74yl8Apw92qsz8LGjIy1qkWBtwJDmgAidOf1kIBWJnjOLWUrQgvx4ic +BBABAgAGBQJW6YhZAAoJENo7rI5s06FN3BsD/jVqaoNrnthX7Cl/UsG1PHzF0Js11spuYHlS +/EOOBMO003m0uk3j+G7riatrE7vT2rMtD5zKVmbbbigYEFkTVAszqf1NRIvdk20N9zoNzst8 +YJmdLEphBwx6IzxglqRQNVJSuKh8zNtRR8Wcd9aJuLOEbSADopDOYGucBdPhFJVwiJwEEAEC +AAYFAlbpiGIACgkQDlPN5Kllh20mKwP8Cw1yR11xmFCZctv1GI3EqSH3eEL6yCVTU4l9uTOd +NYXGbvcOGMAJKSiBJ+JuNI3JhdlayLjQXHAw8XwAiTrlKzdYT7b0yyd/f4mlQz3dH9AXAO+9 +eTCyR+C+HJlce3y4MZX26dArwcvdB0H59XT2vItSd4O1IaWziEfwR5kzk1qInAQQAQIABgUC +VumIawAKCRA5siwVZyr6yRFdA/0f4h6NNZhgjhJo24CrB4dAODl3AQQZ2GRyu8180AQCF00Q +K6PKELIjPf0S8pTUA2MnHKAVXvXY8K95zs+RgmutbA/aC92h7rieeqisx6AHqyw5SL4sMdnV ++VW+jPNOJahuspFAB5d78qv9FLLOaIsLqykNDVIAf0fd1DAVj2QtqYicBBABAgAGBQJW6Yh0 +AAoJELQShF8VgUM9yyQEAMvGTCoDZqFOe1Rh3gGnueBGZq+4tSKr//YQq9h2iENw1bu7PSBH +ORIUXaLfwAeymAJHgU30/AnXzUfh1BhYlHfyRQt0bbMPNPKM0nM39Tk0f6VdHMb4wyykB1md +IGRJPyuPNn0Szr8O0iOU2iHksZlTPGCwZZxvcwqhYfKL9iB+iJwEEAECAAYFAlbpiH0ACgkQ +h4S3gP+GPZ5gTAP+IvL5lmicTskE5g8/lVS5DFzjjG9BNvo9Ij/lukK5vWwUawFRbAecI4+x +IWnKp+6qMIBB5eMOK7MbbHsnx0gDDrfMbXxUrGcj+WSxPc6Lgsfm5pmI0SWTkycDH861Y9TI +V4G74KYO2oGyBQpd1IY5kg71qf/ufrqqPFIKVvX4pPKInAQQAQIABgUCVumIhgAKCRCqZoL+ +0Glfrw/RBACkuG0p1ZAq7pEvXaP4PRqOwWcLhvMomo+JLqgs+VQjJrlF+ZDurCCN1Priv/c9 +Nl0/blAyaZp/Jm7pR4mCY5uKsreBr9tdw4Zj3Kr/hrokwMnIdSHO39hgK6PeVt/UWzocH0pm +rnq+5ey46djLh4pc3ToCStdFnUuCVOsaxkZXIoicBBABAgAGBQJW6YiPAAoJEEQzKB/U/8uc +gaEEAJYIhkzIB3shs5H4EmYlkRm7gfHTefkqqWZcYmvUSQWp94zvsYFc/Xyq0Fj19Y5JzKqV +PdyHLPnqRAprPwfciixGz/IYewMqHkn7rKjMwhF+wjyAeeTzdcV2w0N68xjaHk2gUTjL2rdf +BwSS60chhdykNDwvi9cgBr1GGcXsngMkiJwEEAECAAYFAlbpiJkACgkQ4UdSu/IqtqNiwwP/ +YPN2u5IdOvv7hWMZVzBlIt9meP36oNaSMst8LPH8tnpxWEJpXfhmiOfVSw5cT3t542FlG0zk +SMhjp7WrpipqjXq1u/159Zih78CRuQhFSTTni+lGQj2fqeDwRpxPk3L1V9GCvGTpyYu6RPUq +ebWjC1gbiHmGO9l6Gph1UPajmyCInAQQAQIABgUCVumIogAKCRA0LnjYsVHCz/WaBADiWinQ +DMkVUwwGjdalUye12NJ9GZ55dDdoeVtrb3/g2mzqY1acl0vPG+2SJW4popzHqXynfEXiBN3/ +H4t6VmRxZGFJGMsnJV+A4/ss755ndW4CnGCPRMHtdRm5sv0yAS/w4ZfqJuv47ZsVUEeMCuVZ +A0OJM66843pJL9igR1TkuYicBBABAgAGBQJW6YirAAoJEBb+SyoTdHEaxvED/jTWwGJFrbqG +KfFLFfopj2HCseerHKfERHUUYPZGA3SOIFELI1VK9CN2GiB8UykEk2Zgy+mRVCBwRE98O/CP +L7wwhBqXCJAv1kQ8qL0hiKCiHOeZ8v0EC+A8xrBAQOj31PPp2nQ7fhxDEhCFW2RluAuKCTdF +FQ+QxinXsR2g4zD2iJwEEAECAAYFAlbpiLQACgkQ0us2PbCwJKRApAQAi42j7R8S9eJ/d7ST +VpBchUuifkKHjFmRn3JaXWRROcQKd3W9TLmRmk9Ge9sMzOrEZMXAOThqN3/1iGi8/77ct8Z3 +FQH2Q0hs2MgL2KyqSHaHZpYm32HOUaFrinjAGm5sD+spBWnpLTmwXnPNzo8mrsbrxYUsLIH7 +rws9EM7SlCqInAQQAQIABgUCVumJowAKCRAw08uPLqRsbf87A/oC8sPz5IGSIc968FeTVfZ9 +rV8UajSHn9Vt6VEpluZ31bzRaHLhaNEg1S8Qo7L+iPfLXVRNNB561fgHmIaj6W7rpeML5l9y +Dqjcu4OSDwKpRdTuZr0L8rgx++/BU9tVYu2JACLXMjfmp2U+akPk5o5TNzkZQU4V/Ccos/DI +sDbFKIicBBABAgAGBQJW6YmsAAoJENGa+MnOypIYyHEEAJzEiFqUpPUQryPV1erLfVO14Mm/ +pFClQBA/QNf2oxmTUo+XBJjUh/sDZeycfD5v/FIoWQKTofaC9wYJ2iHZdiGntgm8P+UROur6 +uTGRIyzZgDymHvkq1IjWYq/N4snOk2h31fmTuNk5m6Vl5uF0w8fMyPwLQ0+lKG3JXN6V6pKu +iJwEEAECAAYFAlbpibUACgkQuRMtFg55T500oAQAgTDiiW50k2JpSsnTPzCBFZotTLg3myHR ++bKukpQ505ZsPbRzfha5mmPdQxbIZz5I7s2zkMvG0bJ2L/uSUOyUbCx5TVaEoso7/PewiWtF +4uDAJYq5J7lnotJESIOMXTCcqsw8uA9s2bo3YsVWXRaoMpYGaS153kavMomR/ZCIeYiInAQQ +AQIABgUCVumJ0wAKCRB0FfMpLVLQN4HqA/40Ra9p4pBQyHQw4oPLtKIFG2dPE2e+zJ8ismqC +nqIyjQsLgKnDpP26QPpb5+B/Kgle/nOc6jF9KReyHLNkxDW3oZVRhMuPfjikJ294jA+cGMnA +ES6db/vtCjFc8XC+xdqA0hDW8sv6kLiGNdra56OS5j8oqjgQ8mz/wS8CBW2RAYicBBABAgAG +BQJW6YncAAoJEKQsPViF/GOdTLAEAIdWQr7S5sI+ijFTzGFS3pz9/ZSCWSneAcq5HOx/4w9X +NR2mIhWErBcjfJ3K4boKuY4OreQSv2ESxcTzfVW/dVa0Qe+yLGBy3qdna5jyMWHVSaArkDuX +skDl5Ey6oWfg3FSratXaapocrgZmwa00MYs82L3wwE3vzocr8bBbF+Z5iJwEEAECAAYFAlbp +ieYACgkQaZLqEtoHXWLl9wP/WA93+8N4fvcJMLTK2cS+ksEOmZlT4ghY8kctWQ89F26TqK7K +RsQaR5v0sQgrKrKyeRT8lePKE/d/lBqmdlrKJsP5x4zfJIuzlD5Le8C2BzFIXRA60HXvK7J2 +5H5cvsJ4CyBKrO1vDh89OLxqXg/GsHszIOR49wcsOCAge4X02KaInAQQAQIABgUCVumJ8AAK +CRCqAgkebJJW1acqBAC4ma18RX5CVdXGCrxUJI/fJqZvVbm0SZEec8YBqXhhKX7eGa2TM+oH +k/+m6k0BU+jnAySjUa5BKKbcrumUqIjfXNN83ph5KTwHa5DIsNuQ4W6waZTKuUIt/XhuP7YU +i4F1Ae4bePEuJkIxnK55Wml5+CaOCJfmtwNJiVuqiuYbXIicBBABAgAGBQJW6Yn7AAoJEJmt +e3LckaOnDlYD/jKji+gCU3SnGlqiBEgFHCO8fedvOFOPTIhz9E7GPY7wWwgfHu4gMsA3fCaL +P4w7WR+Ob7Zxs8GAwSM49kq4+F6m9zlVt2M5Whn13ef2q2Cm8nq1MtcqNUxUIPER4AR8NfUZ +R30Hhf3pEGcwamdHn9mcY16DPF3hho2f/8apAGraiJwEEAECAAYFAlbpigUACgkQ2QXR+IKR +2jpazwP7BOP/sAhY4Myes7/t8N7PmiMYMHN/6CXrPcfrBrDvVlP6YhlGEd7e1Xue9aAoGjEM +A9oB3VMlMYLMA3EP63IicE9FTf1DeEQHCDWagT7PoEvsuEwfB2pLC9+2S+UiFej7Ddy5f/Eo +3E6tEsFlk6+uKlrWIT6DCmJndlB+1b1VUCOInAQQAQIABgUCVumKDgAKCRCFrPQQDz4mK1OA +BACrG7hThvlVBVxA+IaZWCD5shtJhM0kdtw/LyY1gVDZrxctKHlUuCw5F6JmcCuXSsUoezRu +DXagUgIBVtt6hCN1Jf5bVEZc6Z9/D0hqJzlip6xaQISfRuXvq3KUan0GPOzQlqlRDb8h17vk +NKG61XJ8fSV97SEpwCI7Iv3URGH5k4icBBABAgAGBQJW6YoXAAoJEO/hNLQOuYecf/gD/jQl +HneEDqmJRn29fOCyPAb9bv7NWBVXZST5Fx5fWE2eVvkRsMELHaNWqr9nH7G1zf0kQsGq91qk +7Ed4fFhZVRwB3sVxOBZAFFqSwZ27hDswtJ+Q3sr6vE1pf/tw4g3+8pG4QMIZC2gA6MtEsBey +r5GtHOxiToaRMrdTJl3r+a38iJwEEAECAAYFAlbpiiAACgkQRPisieWWzRJsJAP9FDloJNRf +KSZWaCd9gn8lnma/ie/S7KHUESR5Mapo7M8dZkPd/KXXy5l9R/3ffiAIPYsaIwAene5jZU5u +7FM8PkEEtBbDQhEM40FlRYzKKwI01M6VVirstYqeT9O+RXXOvYd2pFE/yOILIGRXiWaQT0tT +lrbd89UI9LDXo9jGG5aInAQQAQIABgUCVumKKQAKCRBQAnHtT6GePLvnBACRrVcTqWfio4el +8yvhdCPt1YJpOk1vgb1luFTLvEEab125/YhRmZiHhPgF8K+xIAYzwsVnyq7wRZe1fO8Rhyl1 ++R92k3r42fKIVOVBorzSgAAKFUVxjhpg2HtMYRQs1AqLkKGQHTIPqA3hM8seb7TkzWhxf8Tn +DwHvGGXCTCzpgoicBBABAgAGBQJW6YoyAAoJEFZ2WQT9ZcwxSCAEAISLgtUun+0kw475jmSj +XeoQfr/CV7CGTAQS6rI+jM1wwEhB2WAcn+eq9JKLsuoABlbXFS62CrLbef7Mf6xxndB8lZA2 +7awhf731HZ4ouxop5YukbWCUuk0i36tH/RcZV/qmcyiLqW2CxbFgX9uk1yMExykSuj7wtZUn +ZqFVLR2EiJwEEAECAAYFAlbpijwACgkQIEeChfXHwsahWgQAiIFK9qesQiaf6sjTdyE6Luq9 +RjIj/kdkuNgHTJDFJu/g0l0Ongm7qV0HoipNz4PU78TFAHWOcqGjticC8z+vQqWXnSc3C/dy +KiNMSzOCIIv6uPIcfiPEG+lq5oYGNZ2IRYAGSP3h6K2wU0lp96djPD7BGYeuWkPVXVaoJy9/ +ogiInAQQAQIABgUCVumKRQAKCRAZ3WLtWlqzKqekA/9W5qRVwN8RCIIsDxzg8NKdCr0TuT/P +Yq4VHcv4GiZhQMSWcAbowmqDYMyu/KA5LSOGiEuAlhgycieKtW1g2nZv4ahyC+EuIZZrDavu +VHf9Xy+viiwpKLvtTSxDeJ+xP+4g8g/Da6RRkmqAB3XiGYwdg8uAzXMM0XENdC15SeKWe4ic +BBABAgAGBQJW6YpOAAoJEGDwWfWNnK2r4CsD/3sp2p2x7jJMSlBqzMYet2PqUYOoE54Tg2MG +3Wgk5ALPaS8L9VEmE+ogRDIv6HK2/AUITsus8NU8kOTP7TEKYlQwQQiPA1ccx/vAGJc8go6c +RdzJrHiyyyQN4jAPhlUFxtkM1PlUljkU8KYHOjVDO1bAl9/e5ccXj7NNa9wnuo6UiJwEEAEC +AAYFAlbpilwACgkQlcQqk2qXpqswiwP9GRYv/2JsNviLSNZ73jb/xjSCnL++i3KzyzEqWGUm +Cis3aFFq4BVA16ziePpSVha4o8/b6lln+h8lWiQPgoNX9KHHBUN0YfLkp3OCYhgvaRf2WVAC +yMM7J7NReeu7sfjxnIVccD7HuFda+QQloKx/B07g2Xcs1K6/HYIoJCNk0PKInAQQAQIABgUC +VumKZgAKCRDI4+JN8rgmMXLIBADLR8B3foI6SVm/jr4uj2DAs3x0qEvx4NAS1k8RocxWr1EG +Ya4n9/FS14KwXkFHxI9f2HOrwWefb8HFCGbYWcIUr37TrX1yYq9hrAu9JFKS1dr+KQlVsVFD +QdHphpxOCcI82SwSDlvlnyAt1s3Fi4o471ALVbbJcCCFdX0ShUbsyoicBBABAgAGBQJW6Ypv +AAoJEHDdKljL6Mh8mzMEAKoVlGP6wzlZw5dcZ5osf70EHSnYzyKGeU+mZA1TVfOdKGfSwhOW +OLXx7gNEf1AoBcoXwtpCK0l6sfukbiB3+MRxvCqjPuykW2iylRvUSN6bxNstiJ3DqUWncBMH +cGv5hTJ3FqehF/9YSrpCfyXtgubNk8EyLM4NRfgyaCB8RhN2iJwEEAECAAYFAlbpingACgkQ +U9dZNxEfLvf4ogQAk3pujRlv0Ts8tSpS1JnWoZLUJt4t44V1kKZ6g4nwRASfFsXcE6vZbM0T +Pg9sdatePdNsTPdNzWA6o9OsSJPAcqEi5R5WUlTnKdYA9bcpuhlNjm2guQ0wrY+onsnJnleX +k5S3b5r99PYNVASnAye94H+UfQ6gFATcb6PNbCSjdBmInAQQAQIABgUCVumKggAKCRB+HgDc +5M+8OCabBAClyvyZ8TKJ3XMdObBybedis2paKTwg7IRKU6EpXi7ov3UpOogXZbRkwAvlmOai +7+cq6OuofFUJMbQ2gDkJdKi0MHSopGwIXSqzzNoqJQjgv32bU5gXGbHY0qw3vzK6zE6qwmFH +gUdoNGacGvjdkv/UXa77SkHejf7Y4d463YHOS4icBBABAgAGBQJW6YqLAAoJELh8bx7zTaKy +kisD+wWC/wxCxuObDNxdeqjSga960yTVVHjB8EkrG93dDe8PjHFTQNza8IQ8LuL+QleuyLo+ +jZFIo+uJTq0htLxVb6zbPWzNTA8HWiC0YxWIf2P3MUSV9NIzDcEo4bk4kGn3M7OkWi25qQoq +clzsDuFy4wsUEcfuvPICrYi4ZYeo/hkKiJwEEAECAAYFAlbpipUACgkQd3EnWNcjkmlO/AQA +r/NO0EsZSqQBsFm0Piu5BNnhBKSoWvdm7vPqQIk9JSbLX+GgbrpZ9MmsGn7qKMGT6S49EbXK +qaeFbsawYRjvuq8uVFHyrsELOj7lJ8MCxMhlk+nCiU+iJ4bt1BgVsMb5aPotd64SlX+h+e6S +5JOc2ekCnXOHtCQjJW8jhDTcVUGInAQQAQIABgUCVumKngAKCRBYAdr+95LLdVpWBADGiw/k +9sWC3Oacrp5H0oyhGFr5CRKC4xzmLZEg0tu7S6DD0Qro67EkU2dEhx2JBBuMX7Jzcn+K7FKO +l0Gk+9B6uGhYDgDf2fRx9pv7pqD1wmjCyLD+nImFLqtJQ/pbo2/GWjKPCdyVBozZZlaFduV+ +xwuOdnyYZKGCH6NLzWVme4icBBABAgAGBQJW6YqoAAoJEAnAL2746tSlNDsEAJk43j2BIqjr +zOxI4+kfHZuKDsWR7dp+LUvUqwoJPCQNCJfbbOXAQAmdZxbcwgTofu4BNzvall5KkEoMgwgI +CYRqcwvgLBHJHWkzfNpzmnLOOY1VC7OBrrMACchludAMHZ8kn10MP9hVM8yJYGrG9hsT94ls +ciJwEom6wWSyoMGriJwEEAECAAYFAlbpirEACgkQTTOAcQAmKT6FqgP/U+Mnn6Z62JOX2DfJ +hw0tjegsP4YgOdKR//LncqALuvnDW0ZSMNuFk+S21k812qT1NQNhSFomgIu6iWYRGPOqFKpA +nXMz+N3L5patHD/DpR3JnyGOg6TIufgU84MsJ9l35uNx8d/B/ivQHP3Ksu4TdZdlczAdRkR7 +Nz1mho31CZOInAQQAQIABgUCVumKugAKCRDtl7IU2xTFZen7BACXYSKV+AARb6MRj7q1zGHI +d6DKUWIzjjDqY0WwP1rUAM+FCL99SizUTcwkwZR+o7NtBhcWUeR6kuSM78b0MIQUgy5X1wfQ +FgkYTkvo/WtiDJobkjvZgnrwAVgbEygHBGrDRWpjyn23bUu4cciYPWI9z9+VUP0K2Xx0qzt+ +bW2jq4icBBABAgAGBQJW6YrEAAoJED/Sn6b/9qwxrdkD/iDdCEr/yCz83UAF9QMYKUX5rBZM +rqX0OO9VUuk5+AuUnVy6RbV192IOUIidTUx+L66/2HJYDZudgs/PA+qyiqHvxp+GE8E1audt +q4qb3cyGPhDCoXEhHL4ryRBUiE/Fm3RrwF8/9LDf7h1L4AAn8fA++1xE6CZO7VZJxjO20NRX +iJwEEAECAAYFAlbpis0ACgkQvcPDrYZms+9URwQA5t+yOI+CTAc/qqSzJ3293HYKfk5qBure +/I6pUI+9zBErrS7z1Ba/PhFEE5aSuoq2OD+WwP4ttZmqKlprmaoGEP1f5/u7DYS9V3oxpxgA +ExE/D447ZN2LKB6WWxKZIX02yMhyqijY7TEtf5i3Jslk7XedYv1KFPO2b/DR5pbd6VKInAQQ +AQIABgUCVumK1wAKCRAkdxeLUUQLPlIFA/0ZLbibVHavkcIzILbAKXPlRax8UQpYf6C5rWSx +Tx/Zlx6+mtj4G8UxFV99YwvfZe8MHLUPdPkdyMPENsvLvG6qadIiEubBu7eGcU5NQkdlIEsG +9nsbPevmXbsBVU0aMafJvLcNPQQu/JGlU3H5aB8JhqlwBD4oo0AwHoacxO2IPYicBBABAgAG +BQJW6YrgAAoJENWnVOmfWFowiQsEAKWgcaOqcUJd+UsVjSqKByo+sh2i9570a3E/6p+Kz/rh +pq7vn3BcRfeTdHOkTN7xjMXVEe/1VSj+D3NXH0RNG/M8PiGJBmovQo+bjUFYP95YyVmVUFrK +h+2xKUmJWigVa4a2HRG5MYnyJCV3Q0VgGOuQHEKvrsno6YH55l1KD5SIiJwEEAECAAYFAlbp +iukACgkQCB+sDV01G8hriQQAuZJZhgrWD1vXbX4aXLB+Ww2sNN8YhgBz/pMh1Yk9NzDE0lwD +X5IHVM/tHL837xAfw2iYdxqtQDph6Z2ykMmDUJG/qi5Znn0vxyvKq23Mnb009K3NfvKUk5lh +HdQkeenlB5BaMDJz9dGdX6ShHGkXf50ofdogvvr0E+ICX3KRV1CInAQQAQIABgUCVumK8wAK +CRBODSaDK1z277+mBAC2G0Y34+cxHyE1XnXfX0sR7T4fdsECuaMcIuND+nfmDwQkPBxN/65M +7tkyveU3v7/q0yUXeYND168DZknACS32p8n2y/N9We9V5xHeupPLY28cuxGE6+b3wT2GVXk9 +6c3yZDLyhwwAGZ0oztjLhBQIRWEamn2+BvY86EG/8IBl2IicBBABAgAGBQJW6Yr8AAoJELA+ +/COgOxvjY08D/jLQDVknOyV/NBWPrf6j6wE5R2LgtXRceGEDrJ+w8NrcYnShxrZhUv1UmbcM +F6iB1W58BQUsF231Zm4sx3g/oF6DiFHzL3AEs3D/hN4/dvVzjOjkGCOmtU7WQqOQ5wurqwfy +LZvF1TabkVcsd/mm8n+QMJFzUuR37XSHcaA6DTKFiJwEEAECAAYFAlbpiwUACgkQZt3N2w6b +wC+KlwP/Ur/87zFn1mmMTyF+L48tmkjsHsBVpTsiaNY/u6wcTh05lxNB1wuwjE7PaIKkF78z +S43L66tK+Rc6HIWkOIx5dxbaLfAA5PvaXxUb0BClLyFL9lnYAhzCTVFrmsIMVbMS4U+4unwb +QL1DtXMDuoghUWrabdEXSz9zRov/AgH+LVKInAQQAQIABgUCVumLDgAKCRAKZcu+3GB3KFw9 +A/9giudizqAsOfEnKUxarFKeTQkrpfinkg9AOp44F6hj0+rYsYjTYRCgK/IM/m91t81Rp/d1 +gm21Qi8FIPH7rpFbqw5OqBAjPDKMhXReYsxF58QSsVS1GTo7DM3tFdPV3tpsBefKO0TvWr8o +qGaQR1WZee1Ob2RJ27nX2cf47yWBaoicBBABAgAGBQJW6YsXAAoJEND/Rgq51LBXwgoD/0VI +gaK1s2HEFrzwG7wWEnCZ1XLO2R4f80UDkZ1rfKBJzBxpQ6nki+4wUbMdkJJySr7/YpCotQF9 +CBoFJrC+renS5HbJZN568pDm0nQUfq7ADMM4nf5ctKNJ9JW2xmI48XdpOLUXsMiHcMiUoSjM +H01HEANrwrrSdJZVj/6Zy1ExiJwEEAECAAYFAlbpiyAACgkQ8TCPKajG0DEi7gP+LIBP3VLb +HWPrwgBT5x3z+NHajZIWz8WCwp5vOIEWfoDQFYTng3pYaZepF3t0BctWphNLCfY9AcTEjaGI +3klLXlnhwLgEnj8/iQNnbwa4Uv7qD8UpBivJlgGl1ISUGyTp6SUU74fzLL27FIPOLAxsO24l +FlFhJiXP6GGYqb0FILKInAQQAQIABgUCVumLKgAKCRBy420OLTpRa+EfA/0SstSicjyCISy1 +fkBNRCF4c0N00hfDnHcBo75lJsgal6hTHf9AvuLlXvv5tjU7x+JYJcP8j5cq7DBUVljwiVwA +K2jSXUy2qNMsB1QywrckGMWsjP1PjCOVF3M/b2D4paglpUkFUupWNc+L/TzDzLSYpbHPliOa +1kpPI8U+26x3PYicBBABAgAGBQJW6YszAAoJEKklEZ6xWy0dWi4D/0owe9+2p9KzfAZY55wR +wc3RUKKMEf8jnlcvo0RFUwqYWdPOtMrba4s5iHCYel9qLiareobZxd59+lXjmLMDc9+xW1LX +JYo6pee8j6OwNuh4b4M0SH7f3I5yNso6hxB1qc+mPsGXLzww/NusxrUWdnvUxXkbGkytbFZC +vun7vmFciJwEEAECAAYFAlbpizwACgkQ2gcMejGFqUIcpQQAuyB6IvC3xekLNqqSHkak/UpX +Wih5/LwswDy8s4naqocmkzHQlh4NlTSpxtiCalaYjadzVPLgokjRoKUHVhZkWxWtSpPDn4Xy +zCX9jzyy25mob+ofycM0rEhtClgY7YDYFrJRbk0nBZckw8WNMUbbBTNapPjTLJ0Z9tsqoAwZ +K1OInAQQAQIABgUCVumLRgAKCRAjgV5ImRwOTplbA/9stFCmx8XVefMJyAxl3IRvW6yfUnB5 +kvUZn+KJgMnmnU4PsvRtCtiBfLrMdZD4BfTFuV784zw/CAjtvOs9+U/jWx7DpxBTHdSL9j5z +sAdJUlsS8OFEQ+d83fh495qCxZvWBe94AL9rnvO3B072dOIbvd6JPDtZE3d7NWL8fdX0p4ic +BBABAgAGBQJW6YtPAAoJEIBtT9uN7egSM9QD/2SctEyvEH3e87Dt3i/QoDT/fCx4yTjiasH6 +rHDLxk1LhbxWf8bxVuGBlB8bPDTm+Os/x6kLoPckzRubRLxS76AeXG+gIuvnfm+5v8xn3AGs +llmE/lguK6TNaUIfFFtlpnVYlr81VTpbVIP0QtK4mmKsUSvAURJ4v4avBNvjMlhTiJwEEAEC +AAYFAlbpi2IACgkQtnX6iDIEXDRQQgP8C4OaI92tWg0DIaT0R1C6GsWsE3PP8yXlcXK7qVFk +rgyi+A1mUEahk5ifclXd1TmE9fvSkGBtvew13fkZTh2ngEy9ORkhetUkZ623OtdwqiWQQTbG +YTg72muagMeGAGM6XazrI9rWgxq2Wmr0fNJVOB22PyOUtqz0ejbp/MlXu9CInAQQAQIABgUC +VumLawAKCRCFsx1uoviN/5N2BACLMbkQz7/nSeHSSPQZTG9lym48u2S/xt14NXCTR077Ruco +FNQXZLRSjuzfRdrhr+ew5n+N/tZbeATfePDinUjofTm/y1ELmw3lZmeCiR7d+IjZKZYeZtav +MiBnAn1HDx3Cx6gFaB5pdJme2Ao35W9C3Lev4/raMjwQGYInBZHPQoicBBABAgAGBQJW6Yt0 +AAoJEMvrlhm1iAEzPFoD/jaLBpEN9c1sHbaTPuSiQGSuO86rdTMUoF2werjfjl+b7O+kSkU1 +1PXRjQCv/7XmPWllj4tQXXO5DYnbrtogtjFMH8s6deLYhc08fCD7WSukpJTHZ4MfW8RySFDc +TyxxJ4Qv+ZL2mpDVFAQVF1/nSmPMw+2FtiPdj6yoc3SUxtQpiJwEEAECAAYFAlbpi34ACgkQ +L8Fk3jaqArlf4AQAjfClwLqxD9kW0t7FeQOGDhzkDufwbI4osYHq4/iiQqzfQk4aSNiJ5p9c +//zQzckXXH5NPhksXo3lmUcWipUbJRhuRZeMpUc7XfIsxhJn6jDZoCRfVm8wcSuB0cBS+p/j +VAvNNpA0wVMwcmvw7oy5huw8x3XIt+6pBptN+DNdgzqInAQQAQIABgUCVumLhwAKCRDFBf6M +d9e2x3Z5A/9qPMpkxcIzl4tCJ+1nWwEhnooEzEOVJ3Rq+ROGZV2fZX+DkfIAcZ08jhpYDNg7 +5YOrkdGfhOkzRyh4wcFSDbV6AU25xz5MWf6Zf47XbW7sutaZzdOTd855ZVKmVBb+6wO3C7Fy +YkcAi44Vj7gg2csu3gcafbIY60W6Qf2EUVcwC4icBBABAgAGBQJW6YuRAAoJEOv4aiqdWYfp +A5EEALz12BBTI+ZNTCgpACNNepYIKRy9ktz9MMP5mnXZDJVvvKEz5HQwDDyQ2BReRX0S+P2R +nqkRv5rytfUwKMeDCCouDduCH5RiMLJk9Pb8aCWUU/5+/BvIJXp9fZetLrK+TdBFS2OPKLHH +v9QhbvP+rQlo8m0Zoc4rj64wXFmjfHsAiJwEEAECAAYFAlbpi5oACgkQPSkIEmWudjno3wP+ +OmbVqUPVctmaXIgN7fTAPItlT/+1n4KnHLG6VChLrzNeeeGE03E7PWGu/0xf1tf2rDGcy5yP +RXo/xue8txMCz8w6R6yfaRZTV0W0EPZn3xT0EkqMlflxphmpzRLtABXD5IVDE724KIApPiHv +S4BCdS+rcg4KrAGKT2wJgQw3MgOInAQQAQIABgUCVumLpAAKCRCy/NCND6y3onJ9BADHNh6l +UvcNuPxjz0LQ3Hm1+3T+o34+LsZ7VDw7gCT1J36nc4HpBVVxtAB0xRPkGC5TBSh/Ko1kJhyY +3ypaY1uo4yIkgG6wz+rO7KqaTC0NPrC7K/kyZFXwVEQzaWpwjHQrqeonA9xHRdGUQhLafuf9 +5GeTX7Oi3ZRxYyNOVsF8DIicBBABAgAGBQJW6YutAAoJEB9ppd/4zKeHgycD/jH0Lwx/vsBt +jQp8UfQAUkPClwhk5pIM08Vk0XX42pZCZC/Fz51ad9y5iybmQNbDpome5oS85WbH2/JOCUdF +PbTVVML/rhG6g8+uqEYuNIdq0judA9zNmDQTIc3L+gu4/YYSbnfU/7dF5Q3afubYafMf9ipg +J7gmKqIdNcuJyxm1iJwEEAECAAYFAlbpi7YACgkQy+98uahugzrNRQQAxUpIRqJIdnLfT5pP +ezH1aleO3E2OOJvdsO31VC96gg0uBmrUrq6rCiqpV6QP1IFJBfZcJo1310bKkQYJVhrhObIy +z90m3b7tNSJcEMUWl4+aQfT8pA51wJ5En7dzvKC1PjN3BtJGPMs1UATAIir2qdXuY7cAAVAI +/KPXGXmtwouInAQQAQIABgUCVumLwAAKCRDJJCE7sKfoMlADA/9eiFbLMg5VkJK0+TBB4PIU +tYxz5YdMCWibZmOTbSio3bp2adbb3J4+Ei6v7OnXlZkgTkvt138fZmPm9pLVMnxX5/9jwr9y +LavSTvnFzSMB/fS/pWtVJGJP9jIW0kLxmtWPTkYbwEIJjMSzkCx+DnfiNYJDH5zIqKC90Zb1 +Dx3eoIicBBABAgAGBQJW6YvKAAoJELfWjEHJE9aS99QD/jfoMEw+iLx8KakywDppOEYurCGH +najhFE2pSAQYKurahShMis6YGXTERiiG6JUAM+CJ5ON+uSPugvaM/DpAvAFWYCXeYWxutJIA +QGjPOWOUdcFZGajOjXr9DzNROo6MmYBvSv4RoeE5n12YutixaDgHeE2ef2UwH1PPx8n+WM/G +iJwEEAECAAYFAlbpi9MACgkQlDNDp9POkfGayAP/VuGFEPswDJ48OxrIJbVRPZHeCi4TK3Av +IgFR0ew7XCqG0QgEMX7U9cNhHViwI2JDbUgEx2iiaGOYX3VIifOaEdrbL7z3rl+GLb9ZxThj +dl6P5Qu0gpf2gbCHvQPTWmVnJwcB+Qvq+f7Nb3nWKBHBk25uCqMjiM0452feCDSjnVKInAQQ +AQIABgUCVumL3QAKCRBGc406BReAaKV9A/40FoeAA5926Aw+cIQhRxXvaEep/l+lzrdJVsny +lWU9bRORcnyJaewGi+uLYEdC0LEXeMd8yjoIP7BG1U5xt+3Ybz9AB2gnQcTAD82XSQDLGXP4 +/ZJoSvQGN51PvzAXGv2gp9ulP6NKipNlkhhWfFoyc8w1zDW1CAv9xBUFxx5O2IicBBABAgAG +BQJW6YvmAAoJEKA4tI7qi+Pi27sEAJhvcKBf2xZtrgfq8fOd8Nq8l6eFQfhEBCQqexpLwxHX +du+4l6jCD6lSkUb79vfieFITLIP7WqHy28hw5bN0TFLVmcmcm2Hn8D4CbZualJF8/oHnhiB1 +51QllNwfoi/1Zs3xTWeN+zkjXQ9LU1E5JpRViOHqo0QM1h6/flSmilveiJwEEAECAAYFAlbp +i/AACgkQbAd0SZUHocNY5gP8CyDmMwMRPkgP/1tUutWFlBVMSXiogRINAngHOViqvN0FMEiS +Ey87J1cDaLIvQ7enzbxFOfgZlekhDmanmewgNZqWVSloPUNrI04cec6d108pdXqCwc2foksR +zFxQH8YUlRuc013PhWPDy6/B1HbRSnFHIICZhFw0egHK+ZyLVTuInAQQAQIABgUCVumL+QAK +CRBYbRRVotLIxa/bA/9Jy7sWodDK2j+O4/OXl97FPNWvEt93XBFHIbamcKy41tYvTAwseRuX +gAybljAOu9TytF2+q3EaSwlv9c0OUfXv9XzaWwvcTlprQsCZO5flbPRzWX7G6LsMALU1ByS9 +vjPBXe5d570Ce9d1LSHBksX1WYsPSarm4qMpert/iLwIgIicBBABAgAGBQJW6YwDAAoJEIFs +oxMfVSormBID/Rvc6BQiJK841zER71MQ6DhvnGuoL1w57ghjm9bqjH0PzydtL/LKhM4deJE4 +rXlDzlnFFiZpc9GhiVb9RwoofAQybiZHbf4A7wvHiDjFmINWLRFr6pRyz6npqGv2fGGXhZLd +pCEMn76r7rM+udCaie8+waoGfJ6cSCXJEjFSWWgPiJwEEAECAAYFAlbpjA0ACgkQ+SVKLJSu +iQFWoAQAgSoAQrWuvwmNJ0ZKcEDKKJWwytUMSAp9fyVmndD0Tw/N9QKVw5esfTeo+5obDCBX +POjfqIKF+jF7dDu32xiL0RnWvdScM0aPcIkjdE2Fbp1THnKvbCGwOD8UMcffAoYxjIBWlR/Z +10QhCil3kE2aSJq75+oyqMmStHrpFsaBxieInAQQAQIABgUCVumMFgAKCRBjzeIDi5Tn49me +BACqjUZFRrYS17QvdiPNag/+6Eb+iI7oAoLj+82Q/xwZZHW2Wh8g1pULBFeqqV9XH/F2spJg +CZnF2qf0Vm3JBIOSfct39GcNyVA0wHxJlAbvMxj1pDSZVQ/EoOZz1q+FduoqqX7BZsSRoGep +NM4wkNBeAwYsWiV6JhWkyZqNxwaaRYicBBABAgAGBQJW6YwgAAoJEELmn4v+BjrmdfkD/Aqn +Lsb/vfPUaaA8OvVL6wNED9/H8RKGhCed0FObJIyhAN+QCvMWsjoTIhf4gvn5c00IQAkpy8Z+ +1mknCele1Npn5H9yHb9wCC6wtAnwKfoTmGwGsSy/vpYI5Vu8ipc0ZNqYo3NTVQme2cZEqSsZ +LA+b3YEhYfjGEduG4ZWOK2r/iJwEEAECAAYFAlbpjCkACgkQodArGyr6YuXe7AP/RjQe+u6s +0pg8nqHpD4cQ6FpxZmgHfpNn01zzOIiGT4vRbYrBI+jL4kymUDTjQufgldLY2Wlb3ietFdLs +CyKfwemVqw/VJENADtIpkcaHowpG9Qzp00t8B4F5qyk+3SAO9uJX/glZUyGjXbhyQlsqY96U +hX79ghPcTdUAhO573UmInAQQAQIABgUCVumMUwAKCRCcu0j3pJWS9c+tA/4xszfeBl0KgAIE +uXbANIL8T+L7Nhu97qAdm2Qi8fUQvriIdudWsB3shoLX200ij4Znsjh2AkC+2IZGQHxsy9wm +upTP8bp2xLQPrh9+cIlkrizwlsxWwT0DsUVJkjxLhEHyDKW1Uee3hJMNkH56bFxWBTp58PBT +e4n0uzuF86X7UoicBBABAgAGBQJW6YxcAAoJECIZbjC/ut6cVGMEAM8+kfhkJwq0SNZlvbu6 +s8NXSlN3EbOmF3lWfSOnLdOe9QwElFu2GVBwzZkCYdosRjYs9XE8b8rkX89BGmtKWKLyLyIf +OPN2s9SoCM+xgxC66WBXzztuJaS6TQGOt1tQRgyc8vcSxPfue/I4Ie11MxszDe/iWZ6T46sM +dQSkTNmMiJwEEAECAAYFAlbpjGYACgkQV6MLhNrvRh68zgP8CRELohFGMQ6wqB5fzdEiiMkI +TMJPRiUNZl9XX6iW88cWJa27HP74XRtMv5Rkmr9LxApMMw55EBqQkq9MD2IbpQqBjc1sWQ7o +dcl84ncBec2v8+oy8D9ninuYifCUKsVqVFoe9xwxoHfg7uD0s9vA2q3U3nxR+bqjkVNQAs75 +samInAQQAQIABgUCVumMcAAKCRBiXfVYG5fy5PVHA/9IupatxrDh/7ymPWm1QehiWeOmKs/S +lIFa3ev2HibU8Oz7NTDfLh1m8npSCqhfkaOlVd+2lN5y85wlCRzBLHkvRhORVp/YCmjAnate +/3AKsh9FOg5Xuh/A5+n4MFRCabHi283qqdZAbQJVItBTZ824bqZUDZY7psnq7yTVOC5oqIic +BBABAgAGBQJW6Yx6AAoJEGZhQ2GqTAATjA4D/RQgLxkVRhLty4dt6LOkhb+5PRn828UruG8p +ALEG38DDjR2IBgE3fgrcmSt3f9x7P7p22wdSTUhegwy/5bmTYZY/+zwgUXpf82ZcHjwqg8lO +0LoXCaN1zSCq8tQcQCOowzO/rboJKm5WZfx9/n6qiFSyB4EWDkqXRj5coA+JeHHoiJwEEAEC +AAYFAlbpjIQACgkQlsnFY+r7XbBC4QP+JJ0M14KJOnwdg2FEEVEx42FL4N+Gb2ae4zmbTw9z +dAtIuYW7ZAAVgIZ6MDkbQbGFU0QXXNYlM3myY5qkT2vTJbq6Cdctl7zIBuhR5ZHslSEnebW0 +/ZafyUDyOlaC+sbJ5+aONwtWt4lZZVMFyV5sFdlzej5Y6AZ9MYoAOEW5FZGInAQQAQIABgUC +VumMjgAKCRCEOQVAPvSNiCRdA/0S1O2CYsNpI9onKeTUE1RgCiLTRweE1BOao1sFI/SkDZO7 +fMuQZxElMOKRHtE0rjGP7Qq+8kWCpEUwevATn0Sds0/kD/yDWSsG1rueZE127gCWZYfPBX4K +rA9AePgmlexE7DlDM9mqb9kcA3Atp0kyQKlgX1EAwulC00/K3AbG6YicBBABAgAGBQJW6YyY +AAoJEAPu3LO/UVi6q+8D/1x2C3wDbyQvgAvrZ7eSQcoQ/dARfkIbopulJLXh2yoYPbsU/soO +MIABUeCzGzF3445aJP2iglvR4EYPMhgG0n8g54XwZTLnmZ6t5/PIUF90tKoUSIkIwC6auKxQ +qqe4pKaZNEvF7JOf4APRgOiDIFzn3mYR3Ya82+udl0OoasrCiJwEEAECAAYFAlbpjKIACgkQ +woOY26RdAmwLhgQAmO7s1/MYV1/CwTL9ZNDgNhlzqLnWPfotdaDkUGaGDAr2vEjcvWCJG/zw +mM5ZXqr8YskRpC15DahLRWBe4uF4fTVJKXYSJG1Hd7n/R+/ggqvr0M8fZIlKqtp6I8ZEzjFM +GYzWHJWTXLS7oXGZ4jtJntqjYqHPExDmI0HvzAu4WVKInAQQAQIABgUCVumMqwAKCRBy7ua/ +K7R4USc6A/0dTlw1ZimnNuvt0gBiO4nw+q99eeQ9mqL0b/taNtJYWr46Y8xFpM8OAXpBuU0s +7wbbZpBeQ58ixrNthd4xem9nszaWVOPmRx8Y2LzXoy2mKSbq3F4GfEJjgiFLso1si6tCjRAl +hAgyRjA+Pflkh3W0TJ4uu13aumEuAFA76W86TIicBBABAgAGBQJW6Yy1AAoJECGNycjN8YcW +oAYD/ivsO5Tg3pSanAjoidFyl2QhVo8oB3u2WbSpxWK8Shy0h/v/5VYnwKzn0Nzgj8MmuwCM +gnxfrGNcvhVD4rJE2oVnabg6i05RGvBWaITvQwMtIQc/yT8DY3Qr82afGthCfQkSIMxeE3Ch +PQ46kkgZpfvj1BwR+HQSwukfUtO/PAxGiJwEEAECAAYFAlbpjL8ACgkQmU8wq61jodSfRwP7 +BdU3NvIHqyp62hPdNCFZdMtXYWxV339LWtGsKU0Sq+Da310Zy5dtwT9prI18OsO+1aA6CPf0 +WmzFa+ORdbd+IVIHxrHd7nNQG667+Ns8wUCgueBm6LkPRrLQaGmAcy+2Os5gJdN3TL54UjeG +OUwzifuxouCqkvIC9Aq2j0qlVFyInAQQAQIABgUCVumMyAAKCRC1v8r+9p4CNlZRA/4g27wR +3qlprqaaHz9P/sR5+nF4wob6VEmtekXEQ9veKg7PzZVUXGtLJStfVVGuJUUpgsOqo9HPR8IW +owhpdVOHsXi2Wn+WIlttchFuRBp1kL9QKnuKZJItF+LWoaMXB8s1KCYphAIId7YzgglxX8/a +ia/v+I/3WSe6rOq79Ysg+4icBBABAgAGBQJW6YzSAAoJEO382qllbOV6HkID/3NdcKkz2wqj +bdLAec9kQlNPYVH4Kz2iKPkiQ8nmx+CJ7eXiwJd7gPWyiZuS6PaODxdHSMBcrvCSOqI4ZyG8 +uAVU6ODbmIh+MPrdMv/cX9FDZIJcuyuiA1GmqdK0MkEkBZbisHWbWwknqFjgBC/GyWp8IJoa +dZx6BqhDYtZ4h+42iJwEEAECAAYFAlbpjNwACgkQWELm726lqbBSFwQAm3W1OdQ6/zHEungr +xm9DYZ5Sm2ZFSuPwEpw24dOKNTC0mIQCi3xIOvqjvgIhxtUxKo/YE/kpZ0cg+vhgQ1erH1fT +FhW2KjrsI/61k/chKRyiRLEI9jdOjRdqY8VrilOvmpd6h06o4jr2eUWe9weSctI+89552fiI +dmFAD6h/p6iInAQQAQIABgUCVumM5gAKCRCGXdyWiQgtMJuUBACbhhmtvKEzLZNkaF1rFjut +sQ7E1RxFJVYyCluELaxAUa+7HiMh4srSwewTmnxbg34y+dc1sHeRorECo6/y+oSp39usgWUW +zk+u0WJqST3UaUb/TUU1Smpq2XskxmjHDqI0lI3YWbmTq6+B0YwId3mZHhh24DESjrtDj7Do +VelSqYicBBABAgAGBQJW6YzwAAoJEPhPE+B7I++Yu9UD+wZwE9YfHtLbeLXzIAd2Df/hJ4Ij +sd+QL144LssnIoQIy+jIPKOogwo2d9XMTxBxx9qIwMHsRcKBJUs79pgxd9t2IEhYOnS+NYir +sVYKTV4JIk+lEBycilt3aUQQS7siQYBbI9SuSCfRtgKsYmBxztDhbV8C+U4pdKikXM9JD0aG +iJwEEAECAAYFAlbpjPoACgkQM7K1eCROws5+FgP/dZgbad+w3VdBoaUv8C1Gh8QCbixo0p15 +5Eb2ZWwxdWrZKhtU1urCoriT3hSpsQpaCqdZ5FR7D+nn+B/NTl5HrU2npkUP9L8hcI04S40c +XBGi4cjw59IzRejArybx7akn3fXb3IXo8z7OqagplmJvt3YgAAgT5N2jLBtEMy5P05KInAQQ +AQIABgUCVumNBAAKCRDL4kxGzEzr5PwrA/9SiMNQLz7ZXbUTEFvRHTQx1svgGl2yiZKplTHo +VfIY74ny/rDD6n4hEZIFjHlowwoGrGud8dWudWzEt/ACs6pX6vs+Y51yhD5iy9eRF26lrV/q +ixC9TpfE5cd16IN/IECHVwWhnUlJOmxVYJz27QaizDfFR7w5sw9kICUFEcxECIicBBABAgAG +BQJW6Y0OAAoJEOkyzkuu934/sYsD/RmYrDpjXbjKc+mRcNDgTbdv1truvg/PE/GY2OB2PfEU +5HQeq9+yN34wqPHrO1QEFlIoRGY/v0A82bzVOgsf5DKFe4NPHuYIpPbM+Mw80PdrRRa1zv/w +OIp8/ao6IGMJopbWSffIi/sC9MQ37Ta3h/876LrhwcXJDUXHfTSoX37ciJwEEAECAAYFAlbp +jRgACgkQGFaFTgk7iY0hMQP/a1TLHDMxFnKY4GALI1IqfUU54+wcMRAeV4Nz68+i6ZlOpTD3 +E/W5yJt6RxRNNFfQp2N9fmFCppEalQToVf0GArzZNx5xVRMH3vVOiX1w1KNSMj6+hPDANbTQ +oZgVTIN8h2FXDW1mQlu94/+Qh7O12bc4Eee6iWsj6HqNVoH5gpGInAQQAQIABgUCVumNIQAK +CRAFY3UWH4BmcdmqA/9rLAuBXc0ral1D/u20fxp6dOHwgiOk+c2x8f8xP760JlviQ8Vd68+g +KE1ir1gg2oYwEw/OzNxbZ/YobdHcQNpzgrNAV7Fm0C9zOa6eN4S0O7JqsD0HRBIBXhFNMirL +i9T5Ohl0zPbuIhZVxuD9ettaKHIo8cKpkd6HRviekBN49YicBBABAgAGBQJW7TjkAAoJENGx +q2yJ1A22o6gD/jYq1WuN9rYdjWeRd4aqmbI4wIcBiw7Cpc1TPqYAAPZMaNA6Bc93OFdlZsfq +CjnziL3gRV53xdBgkTySPT8uxbKnW1FFaGVNWA0JBiaoUy2PG96jy4PtwdGKV2eIxcrNcErJ +NUQ41HqUF3y9fS620knLubj3o2PjPlHQYYNNRNZciJwEEAECAAYFAlbtOOcACgkQIz9Ghouv +XjtlMAP/e6qT6qo1F2Rbpb0+99pHnb/D8kpYk7ZpALT6LVfZ+D8tQETCB+MkqeDl/EG+SXx5 +SZsrbGbzv1sNPORSdDFlUWzzFsOJ+AB9CYTplyxN0ZLTK7p86A4diyA7stcDTZ9HyXvUJoQN +Ounj7tGMt679htichWP4yuORXcH87+3rPc2InAQQAQIABgUCVu046QAKCRDQcu1LmrYv1g1g +A/wPo5HWY1zBiQm8RzjsQnoh1RBa+GjAWusxdsGWpCHm9djXTQ4oSr4hZecRiE+v8ClvqnYQ +ma2rbkZSEs3eYdF/Y8RFLMZRFjyWkmKslPmshCeoggzu7TXdKxvNmYrcuCTPedBDKFosOHZF +rNN0FIPEK8EWtBInTL354p2ifHkRDYicBBABAgAGBQJW7TjsAAoJEN/kzHeY0jCiWT0EAL1/ +g5cTtgRpYeCnMOZJA1HV+fmWp2LIWmxeqvSwKIxLy+8X/QsiOqgc9tW/O3Ag32W5pyqsqNUp +G6TgozD7r5Zt09E518BQHcr86dnhyhPL6dC97PfV4pT2gF1NbwNUBCe+Jk0fY0JTDeMZnqyy +LVscGrbi3VovpXflioCglN7ciJwEEAECAAYFAlbtOO4ACgkQ8aWfWmOHyVpnWAQA5tsVG10H +Syap4lRKJuvQ0NjOMHRzGs19qJ/TJ2sLZPL/wcB2qA9OHcaib+gYpxOebqnfaAUBs9YxEROu +SPzJehcb4jZ4jQujP+4CetIuwXvy3191INWTEVoyf0i0WRYS8yy1d7GtK86c86NWoc/I8XWo +JGGC+E6G/waNLydQHrqInAQQAQIABgUCVu048QAKCRCf3PKJTdFYDbJtA/9gHs9kzK1eXXDo +xqObNbDdr1DJszSxFMRfgO6ab6sCw9cDj4tl73+t1JDgLXp5S1h44KoUGsnIAB6IMVshVd1h +wlC2yzksu5/LKesjANn+BbBRjm3BOpIJ7mBNZ25I1vyUUf5WDDFkDwbx1bg7CjcGO/FS4TU7 +FcMTbMu43CoMcoicBBABAgAGBQJW7TjzAAoJEAvZ3uc5mC42PQED/RfmTtj8B8cxy5fXAMWH +Q68Kus4rZf4kdg/2tdwkPiNIeZAoEOvm0yrqQCW2IZ1lAgeirFr2bhMcHVDL8rRRDPD/F3n3 +exsay/aeb4rlkrwwD0q0Gnd87B28HF071R5g4cmR3Iral1qQW1IFYLM+gzLtmn4iCjXdq7r9 +eUNFB3GbiJwEEAECAAYFAlbtOPUACgkQrZKdLwwXqUABcQP/frBa0KcqThjxpvNoe4d/e3/B ++zdC1Qyx0S3wPdIQUxKrv4O6Rw/QARjfMScVFNU2TGoXX9JO+uI1rWHnOwCpwCZLDPZKKYVw +twnVyxEtz/IJSbYYu7YlsikLVwsY4dxlW3CuT/Qf9yjYRy2XPm8UntgwfceULlwKGZ8/VO7s +/kGInAQQAQIABgUCVu04+AAKCRA7sEHLtRWBtZI7A/9GS96l1UlEj1f2WhhHAPQw8NJ8JOIH +vwQmtOo2PuWDD2Zv2h1V/6MwOQgvtSAAnc4ZxnL0CgysQSfrsmcVKX8iCzrQW/Xy+bC0+gFp +eHNouOGUyFzYibKJ2te2SZmJ1kxymsuJTJ1lx7nhuchWzhHKn3pNZcV5W7bCAB3CrWazjIic +BBABAgAGBQJW7Tj6AAoJEHrqTGxyywGmbRAD/1N3P9uPkKqtdiGrFqgEQah6rBhGbxaVOxYR +TsjDj/5AfhJuE3qsDTao0rQ3lLJWGDPQ+kPXTwUZmo33f7AtsZ+SW8nxp75eMZgSgq0F/qlY +xiz/p/rhQOcoWsvUFAoCRkQ3webo0SeT8HTYTILNnRERzXg31G3513M3zvdA0fKSiJwEEAEC +AAYFAlbtOPwACgkQoUeJRi/h9+j0tQP+NEav2ZSQkR+WlTLwjgEDaM7ixoUlfNpnsS0YYpCJ +lftc9J9IW+Yvh+JKxdBpe4bo83WBnJzzNawQsCiJVjQ32g80U31Er3SEKxUYnbnyeV2dbYLW +4lOiTJyY5bFoNv7JmqZX+CjYjIJbBEhIQFncvaMUPpsK7s4AEevN+PLhhJiInAQQAQIABgUC +Vu04/gAKCRDLiZSs0rnbcLCPBACo2nj6srNTKWIaw58VFzaKbY4UzHwPp2dIoPMu9CRbJiww +neGjHA4WSBLdBQmlgdfCNmq0B3aVzWtQBBIEBMixojNDhD0IrpyPlqCptekDI4zttFLXSTJa +oY52lR+G5PQuyecsMipvC3znyWaUxqwZO9I/ub5NOKOUzTLmNwf5wYicBBABAgAGBQJW7TkA +AAoJEHobA3QnzirfYXMD/3fV8EJpCSNt44pxrJgnCRounPndZYgObULiLWd5FeSdB+4svnoJ +ftjBdmKVKvpGFnxuiGJRlF5MXswaRRZO0+YDtwLCDE9hQKlX6hGS0SxeLUk+lWtHoRjC+7af +kyphdS157tuqz5KUAwm+6FK4i/v73YNeTJO0sDGfyG+hqp3diJwEEAECAAYFAlbtOQIACgkQ +duUbax6hwqG1vAP/Xv8VErDvBgva4qbi+Zg/W1wW3pKJQ9X3Xgv1hMp+HvFIPAdURf7lvESJ +MbwTcScuXgq8nXI68IfzmXDoTTtVlF2vU9VoPhBquLGd/ohLhGTcx+yM0DO8fYRfyN0AAlae +Nx7d5ciKjT4q/K80J1/NK+ddHvu6/wMCXmAO9w4HbTmInAQQAQIABgUCVu05BAAKCRAxm5wk +VZLeBDDSA/9tJigtvJMIxoMW98ZNC+/qRMltsEyy/LL0l4ZRWvmXoq+xd/QZ27kbAj8BrKA0 +/CrdFDlxWlPQoRSPRhI+8XwqsoRx3TvrPyULDcdJoeff/VtVTrEw2UvjiOI7elfhOQFomp/p +25EIOuNotEcHcko9y0JJ8Fi2EUZrYzr1go3GU4icBBABAgAGBQJW7TkHAAoJEBK3DweO3E9y +lHkEAJTc9x7jK1MwDAqtPLXtwXsJGIXyOnyyt3vOPwAmZJOgfmPJCpkFU7k4qIlX6RiNALII +FiUrb4cSfA3gxxVB5CgHlhg4ahnquG7o636CFZ02KwDC94CoQywGkQMQVEr4FXK+ElclAiWi +4raCRmpiZOIkrpjPy5/3VTgcEQEFiVG0iJwEEAECAAYFAlbtOQoACgkQeS6wfAsBd4V+ogP/ +XPfQimxYNQy4MPn4U+ILWvLKmsYQdsYJMwvLiRRldbo3Q2I6BmM182ZwMWZkyoVQj+Ir5Qg/ +BuWs3U8KROmNHYAPTZ4hLIkUXY1lkwFQ+KA99sIv5Z/QFvLfvyWIoh0Rc9+psuTziYUmcw+q +ef2Y+2J98gYUEl+thkNtttcCd6SInAQQAQIABgUCVu05DAAKCRBaL/0yBKHEfLpYA/9xdz2Y +a2rNNvrIpydqCaeqN2ox7uuV4NXcRoyTnTwK8rd8Str+EHqcxRT3YIN1ReB4aYa8dKgBmZPL +gYtD8kBLPRa3enTsZx72h/z3WxyuL1ZwCD2DLN2zpbqgxgApvuEzotd8tU8PP9t3+9FaR3eo +bs+YA6h3z18RD8kkAUatiIicBBABAgAGBQJW7TkPAAoJELg+RheKfA0n8QgEAM9EQkqIP5N0 +8bLZEmVEp6aJErdT/NQPDPYz0EfquijQRKcUutP3rG78pwf/rdCIVlmbK/TabWr77VMFMRwG +4HMUm/OeOt5PuBuqVpuGwr2H+fsmJY2ALxGMMKgwbozkuKl7dm3QTiRjqSpMC9xZi/pMxGIc +ZRZZaEoUT/I9VfD5iJwEEAECAAYFAlbtOREACgkQkHfdo+gNsZXeBQP/dM7H/ZGci3UuFJ+i ++IElpOTozvpOmtijHj30CUyrYYH3LwFCcxHNALWPFMVwZ71Zhqvn10dxl/ruISXejV6uRLGA +ovIrVYYvGRfSkAtQspgEQL6Lm81FHFqRr+vG3uINWm5/BFbvzq0MLerlJn98qnVrl8KsCg+X +hFrTiy6vg/mInAQQAQIABgUCVu05EwAKCRDTt2b/1irXeTb9BAC+ws+RF0eQzllLslSpVFK/ +cpaEHrf8RbbM8V3BeqiCnDf/W3hMkjcUwsS+b0CjTWiPXX7OtCeGK5OWD2q6YG15g+8YhdPi +NbOwCouG41kJvNIYda/se05otFYrcEboh0s9AceLyB1Icjw99ek/Nc/vJp/ZHMXMPPSb5mJE +Z8ZeDoicBBABAgAGBQJW7TkVAAoJEKasq1+5nwwaaNQD/jKYQvPC3IloCuOuAp9D8XEL6aAH +xz6mWDbRqKy5ip3a+J94dUMOIK8ywmZkioHCVuRej2/L3zB6Od8HPvjx7HrrxyAl0gX51lFv +oUqM9tMKFNpAgpcP033XovuB1znrUCFeoJmRW1MNr8vjIlP6EAiJdF4dgHWIXMrqucQA5/1I +iJwEEAECAAYFAlbtORcACgkQ4miX05sR4TrMnwP/a/KBmqR44tob1g7AHeZx9GuNb/akymRW +//8K3BU2JdZdW5Yo7Wq9FG8IGPu3jDvtgZWu+VU007Smm0w97ghFJdy0MGyrdSU/RwkNTZKO +muBrYAU5lbwne5NQb7RepoU8Cef1s+B1A3giIPxqoi7M/bNQOsP2Pm9W8uOY3sMUyumInAQQ +AQIABgUCVu05GQAKCRA3EIi346kGMlHgBACk5H9ELiXE2U+Xh6PBFTV5tbJhSCqelYfgHIDZ +15QaOL/YfTeH0JcALTN0dzTkKYQm70ssiNm5eiMWKkHjgc882kh2g+KHZopD6wfrcD9sQbbP +z8ui30+g9WwhfvNji+6k0MESsYaFoL21wwH8mofO8PdC1aBztf1MS9vNFmlRnIicBBABAgAG +BQJW7TkbAAoJEMkuVCBqGNAfPN8EALdqST91VsI1Lm3NNjGFQ4mQDvXmImZqGWDX6LphV7Fq +CtaTe83Jm5Vgn10yPDSBI/4qi/PuSAmjog54E9OWH3Cm0b7xqEAQHUx/kf6L3Eu9GcPwwjp7 +iK048y7v8rbI24fgdCwD00aNlWfe2Ieq/Rq2LvBWk0ic1yA2pc8244pyiJwEEAECAAYFAlbt +OSAACgkQ/5Nv3bqjT2+lHAQA0TZdpUSkOzpJ7FEHTAVT/pcHbnc6xrsn0K3Uwrzd1ba1nB+Q +Ks6qQ7ZSniu1Hx8xuLyGt/n9e/XAqSEtQu9GyzRWF3UPx/mUGT+x+kOtU+t/9hM3MV2Xr6E4 +ZJLODP7CHlOU9bA9a/lWz8SScgD2UZyU08mli50blmjw8HXhxx2InAQQAQIABgUCVu05IgAK +CRCQG1nczlwGmQuaA/4tWToclRVx/DBAEhvlZF5Lap5znheMrGDnLCF2Yn4HV/7n/fVCVlKX +IxP+sfjCtLE296HwJpgvPLoFu05fBxxspDlIit/o4IP9pOvTimc6VnbIkLhHS+ABwNmhL5Dx +p/A4okcTfBB0p5TNxPaMmC06lQIUApVgC9T+MZubk1/8B4icBBABAgAGBQJW7TkkAAoJEOMq +488pqFRYFQYEAK/peXliADJxVRPFSKQc8HqJwg/IMs8ggU/L16e39rsExJHyqdL/pOZ9A0TC +yy28K86PdaG2XMRbeNQoqsAOM+/g9XpuaFnR4GgUuPM4nie7x4sxbt6DY90ibs5kjr+amL/d +7b0BVuPQw8LOkSamQQX9S5igxq+PeMrPrXptvpqJiJwEEAECAAYFAlbtOSUACgkQEJeyupLM +RozUuQP/awq4Efv09sluwuI8UMfxSsNo2lAo2aKC9ov3zlw5iVyq7dRlJmJt8jCEZvoLSsxt +gZJIx31R8dHWVLaC1paggpi1oCdqhmpR2cyocXzIza1mn5+MlI0CVLBHM0Jd3VJOtbiQhQjm +WE5WR42pV4lQb9ObHWWlWwE2LqzyO29zGsWInAQQAQIABgUCVu05JwAKCRCJEOiD+aiKtDY4 +A/453R2KZN1xlhX8O4csLM4AEQ5Trykp9r9liptjWX0Uebxa9s7wov4BHL3P6VvPShrksNDT +q5ApTn/lToGzfC+FqzRNHHmkSQlVvxGQyK0RGDiKEhm3EYmFJKPcVzW0Cvj08seA30AG0T6j +yu5rZl7M0DUOblkubl7rCRct8X/s34icBBABAgAGBQJW7TkpAAoJEH385h1QpuqTC9kD/3Pe +tvo4tEo06MhhFN/H7rsN66jYCeGVsGWNihs7mvfpgNgWmH9u91LsXkVYKFAfumnkLxR9WwL7 +6iIKSu/MxjOYWLuFLB47wYMSbLTVPXAZl5FdPqq35or4Wfzpetsglb7z4Ec7bkyCrtEjCSsT +0PI+o0elAZCtFFphlPMRzsCWiJwEEAECAAYFAlbtOSsACgkQ9euCiY+E39LD4wP/Z8O8Ewo6 +JxGTd7TPDsmKnxQ+0fTURgRIm0yJdnhubLQSCt0AnigbiYbf0JnH54yrCtNxMYbMhFZKNRqN +L6Wxo4rmI58ZSS5CW4PsLcUvtOA+R69DrvhlLY5jt+mZlUbE9MQCQ4/14nJn1G0JQapC+E9Z +4mP79hYxYtfrepX4oZ2InAQQAQIABgUCVu05LQAKCRALgiOEGDdS0TF8A/0eiRUkfcs+wz8x +CerLgUfbsqODlBZc9rG5MY6ZoPMe4lzs3Osel2VpUHBGb9a5nuzoUJFzAqcfs4SIarUKaRCu +J+l8iU3Pxzh054Vsb3y0Y6jtNhsSemUf91I8KOC7RsxJovpvEDpUpf0CPkq9EIMet6wNTdKF +oVa3NT3PXjf8L4icBBABAgAGBQJW7TkvAAoJEKM8snDHvBRU2LID/iSPGU56VHx+mYWEX4gu +QYdsitkmUjcQZdRJ8AtXF252+WmSTolJfzZ7C1PxjrrYopSpcalmtsy9PRmVNu74xYTzTbgC +TDdMl361rKM8LdVYDBd5BUCNC9qs+/DHxAyL99MdScrSXxxclc9QylCCeWdYBdex9Qxuv8tR +Cpyd8OQ9iJwEEAECAAYFAlbtOTEACgkQlgXZiEIYlQCtZwP/ckdfWFbLjp5fX719UsWGusne +DLTdSNCmw0nS8jWAg2qSxNF1Z+oTuj7x5oGVyq620f1+e4XjBZU6ptngnRwxFJj5YSI/4H/9 +OJp6GZSEZsovpKmsl3aqi5z+I3Ga5CT5dbI7l/XbbmzUAb/7iwLr6hFaOJDu9XlmTRpmRXBg +i82InAQQAQIABgUCVu05MwAKCRA3vQqtOZVKkJIxA/9UNVEdLiiXIketht4GSWlsI2NyxZ60 +KkRPnf4K66N2vBcOdmXSk2/XafiyGS/tmqUwEJeIqtp2/Gt6x4TEVFhnxVLD/uOE2oiqmsWU +XqzNfwfSxaom+66ZvyWdAXXaTUu7yl9fkUfj/pwvIrOsnIFg2FDw3hTW8Ui3kVVUngoyg4ic +BBABAgAGBQJW7Tk1AAoJEFxycdcLngXnNAcEAKdRrY9/HDYGm3fkaj6yzi0H2SFS0MuMSJA0 +/wdYkPtCmW1XcH4PPEsw0owmshpQfK24C/qP/woZ7/fJfd5q8ExXPySuMukjIzpdnM/O6USU +JuW6erYf6AqBWUhRxZrq7xtscwD1kVNoiX8yefqogt2cDgM3Ir+0fgL1DFn9k+LaiJwEEAEC +AAYFAlbtOTcACgkQompNyRd+KBPogAP9EVUTshsO4DzqkewTP0pStb1UQLs5qyleDzECpAo6 +VkZGMwlCpktR9duQx6+Hf78wN7IPMYRaZCaed/CTgxl7x1WN2n+S8M9gY66rlvCE8rqONdIo +UeI6hzp2Sa4cMUo0gZihbEKT6PwOiDdf9iuNaeGakm/AGmPT5OvP3zDtz42InAQQAQIABgUC +Vu05OQAKCRDV4uoXzn+zfz/CBACyCT74RgehfIflEk4xll0in/L6sI3TZCfJyhbBSAo28ZCs +7dFFFxwO/2BE5bgcYt4FLVu+AYevvNjEOUqGPhewOEmo/RsVPty9qdhcGjgARy+uHAyeXl9P +nz/9tzAB5reVkgcIlfeJ7Zp9hEqi3YcRC874WA16+zR1O+HHCdUoqIicBBABAgAGBQJW7Tk7 +AAoJEMF+YU2f+edsAe0D/R1Rv3r0CYqCsoO9kO0dck15pEpdyznwg+ZD0bxWIDPH7QUbs/r+ +cWlcP6g5STtAMqNrtILxwwF51pHYM3drb/hFumcmXEnB0IpcRB7ImrlJn+4dvt1RsX+s0Rjk +NF4mRe4bd8kEpnHSCRF51TEp5ZpjkxkwCLjwokinYD1rrzjxiJwEEAECAAYFAlbtOT0ACgkQ +JJnV92IHwzgv3QQAsS7wlGFhpvcFAxJ7fX8hjuN68zablZuaeOnrG4F5pKBZj1lefVAVRN0u +IFOfIxBrVoKxt1m442qdC317Y2IHo5nMHzLq5EXnou9waWGZA4DRwFlB0ljmOW1mJ3boRBZf +JgDDkkjif7ygqgGxo/OgOMhtgiWRC+VDZWj5W4ovP/SInAQQAQIABgUCVu05QQAKCRCumvmB +mieq6RBwA/9CC+k4caoliHfPN5CYymLfl0NThu/SNpd6aOLwXfXQbJt3JRlCB0BEYggIEGj7 +CilPVFCcL5F/uNIhvy1p+8P4jFqujsqZQgCSkT4AVKuHafoaqcCfOZMH0PGTGtNlUmAMTmHp +euPq5LsJe5bPaJgXoDjzIwZiDNhmREelYmqjlIicBBABAgAGBQJW7TlDAAoJEOBNDm8f5jWS +J6kD/0d/6NauBSRpSVBlLYN0IAqh1ixPxxr1EjjmyWcvKv1tX5KT5u0urrkctQR1wo4vkG92 +ovjg7/3zyxE7gTw0WBFAdU22rOJ8CdjkWkC0RaFqxKA2b636qPtNS6BJBsw2IL8Ym0IgA9TS +emfO7YcljhXyLBQ0uAAfR9iI4MLR/fdRiJwEEAECAAYFAlbtOUUACgkQZT/y56mVOejg+QP+ +PzLB8nRZBK+eCbSxpNRLki7CL/u9JQnoKjrroJdfHQhIuH3Aw7weKKDCErOCeFq3vF0sSyf8 +ati7TyygPWyTayEHS6oT0E0zP+NN5vMa3P8Td7B1YVf5st8wSyRULB4n3lYWljLvES13zz/P +H7u/pjfn+kKt6b8YTVsOrw4xC/GInAQQAQIABgUCVu05RwAKCRATiheR2yPJJjWUA/45NS6u +ix2oZmvkc+55Yjlt4RDM0FPkeQazcWDzvuzjpCcoM8G+p6eWmMy2BHJ/Zn69hBAo3nf/kFEt +enlnya2tRRXAJTT5W7w1pP9a2jpFUbOFNbjP5Y14ye34MYIw6ZmSt0YnQAT+wolAGtp06ReA +qiOiii613cdayHIX2iYucoicBBABAgAGBQJW7TlJAAoJEGxGQ+RJVEKr3Y0D/RgTCemd3DvM +XSNdYwtaku7mHBfwgOQl8glxYqY33HL1zkUrp7n9oC+JB5MQDEXCNL4mzh0ROfH37frMdrPC +PgCCd1SrsAsMB15sALi5GTQJ2g74Y3JZExCRlcJVvUjX7ssZBAUK7lW/5mgqYh1/CHOsp+Ce +ZugOAa9czH6atm4MiJwEEAECAAYFAlbtOUsACgkQUXGEWMyNnbsymAP/U1gb933fz2hMexni +VDprT6lDL8nHiNm2rDVQPXrw5LjzED3eTe1YU3ghQ3jxKbTqZy542arfgnpZ6WIPNZQbZ9Wm +XfWKOvFW3xTDaBm/RQpO8MsQknxugvyqJ71QkrUGFV/6u7oIGz6Ba5w11ax0CVxfO7Y6ERZU +j64dDlHTxLyInAQQAQIABgUCVu05TAAKCRAtYZJFV6eokTPcA/46UBLxJtLb1m5pTOZDtrRZ +xScUpLsJwzGvq0lTD6M1fPDwdsaK8/S/ZYuOw6JDd2Pn3rPzYq5pvkwVPm0RVEc0iHgQOxg7 +qHPSuC+yFTz14u2cV/uQ+NAtwGjMVdps8h/fW2pFzxf75VQ/hIqhkNZeFw1JotRtzDLh93s/ +hnpn0YicBBABAgAGBQJW7TlOAAoJEPlfbf/lN7f+MbAD/1RaN2OeuSE/wVjPGCfiltDP8sg8 +UKEmyGH+JxK9Qilf//slMCYgZepuo4wI3nKio3fNvh77FwR5wwqfXUB3NSBTNPD4zWdh9C7O +MGnu4EGTWOJK561faeunEv1kr1ggK21v9r7L2r1Ue5P3NY/88ST4IowsNqhvOkv2BRHjCXPO +iJwEEAECAAYFAlbtOVAACgkQ8sbOFoQnMXASygQAiP1ShHV7zrkzPs2ZKy3tbJWfz+GZtLMb +Pu2KzrAuZH4U6w5ulsbx5na6+c+rc4xMd9IKsuJ3PuE/xcPSOulZtTJP5WUJT3BDxlPG16Nn +E6ftR6oKiAAa8mkbLbSl1f8/D0c4yQ9HIFaMt/cxqLt7Ej6nKSYs9P3e1eV4gnMrlz+InAQQ +AQIABgUCVu05UgAKCRDarijHtrI0tPS7BACTvGBZWuVHzaRClilNaWpZb2FZA6njvALacLq1 +fZwpjTn0EBxsRFj/uM+sqSN71KcAOqn9zkOQufLchQvZ8seHSoHa+5wuKnLlXe3apxkwrWnO +fBXoBFTbbNQXO0IXtNmgRd0rdxLsb7Wykv0gvE/MQJm5Ch5ydhyHn48Vb1qrdIicBBABAgAG +BQJW7TlUAAoJEOvCaLBHGdejltgEAI9xHl3VICO+2B0rbqKH7LTKJGJhMbvFpjBDNUAfH1nY +OkfGDRdQ14gRkti3Qa5rs+mRntRbFpNBDjqyxr2AthazANuZZg2m7tTr/Fa/hQITwOLvUORW +8/Dosg1tGOUV+Gl9R138rQA/X9HjIfwGhdmZAM6TKOLLmBlTbJmbCj7iiJwEEAECAAYFAlbt +OVYACgkQDDE/cpSTSBWuEAP/XcVkmEOYj3kugPiDA7DL0yD6s9BsrlvxFx6ebHNQjTGas8EM +k0S2xb01PS68tKe+nX+D8aT4IJx06bc7HQU9k21TRUARCFPCjreK3Rf0poweOlcgBqkYqY+a +0TA8sCbnl49jUnBR/Nm45XkS5+vYTpGn25NKietZF3Xwe5D+6bmInAQQAQIABgUCVu05WAAK +CRCVFy9dNbU6JuFMA/9U89qO5adwbeZjDEvakDaiB69Ef6I4oJhr6SFxPfQ9mhZNoDZzpILu +3N6lbObUz2jfV+X8Xf2vPDBImuUYdenKiT0N56jwe6EqxUwdaoBoldN+r5jP2g9Bq/dndquh +mDiosN1DGZXlR0J2TXGQ5GsWc8Lw/7szuU5o42fssj6Kr4icBBABAgAGBQJW7TlaAAoJEN6s +hw1bkcVtt18EAIE7wF1S0d9lB9WpFo0eOyXn621MA89eaYe6hhUk4J9AVwLJhBhakIsM4uIE +2QdqRsMdn4P8DU4yjT8LJhVqqGkrY4cmCorBzblsnsb4EgRvxjNunvoP79lXzL5jFlxTLO5E +HxmnJTiTsUFLvp4FKoT1CbYbJqlBy5F/dig9NOBbiJwEEAECAAYFAlbtOVwACgkQx0Hk3MtS +vKI+DwP+OWZPnmwK3HrHsifDymTZ04mWg7/GYg4B4+l/B9SYEFjnUnihfDgiewRg6aG33Ax2 +dgClwfl9eyX8LJMGL4pg1wyqycHlNEAV6mfmP2CRwdgmQFAw4+TkU2s8Obupddx1m4zRlKRO +TOhUUI/BqwTvVh2oBrZ/4zDGgQdRB2BPbRSInAQQAQIABgUCVu05XgAKCRCmhgYmc4F7c/lx +A/458r8DP3dW4dqlqpGamcyWuPE0ySyYYxnQT7ecMd1ltQRSAgU8VBrIWjNpDbc7+obC7m6y +8rBXXjmRM9z/tAEWnCAaFXRmesypyHRUna9ECi/JcEMo4uydidWNK/nuNqTbHpNnsY77C6La +Mv9MQm0KW+uqGyIC+P1CpG4bVekjL4icBBABAgAGBQJW7TlgAAoJEOhL6YXiHpPzEZcD/Rzm +mVFQF8zOxcCxHU8bLFK8KBOZiXLpdx8aZD1o3g97Knjp+vfcwRPE3N/HFovGZciMeSy+8Xsp +LYeLjZN2HadBgAPuKyzNeO8ShKXYGH0AZIm563pk9MM+QSjSyTr1LQrg9BafFJdrrp/obkbK +jXTQYt9PJpMq4SgcLwoCk+DFiJwEEAECAAYFAlbtOWIACgkQSJ34FFLCWiBhigP/YFFcJaKp +9lzI9hqFdn106jhHMdTxXRYDxDRP4gZ7oVG8Gekd422FQXRpiDRSMjzpsZ7C4Iv2cQQ1ZV4y ++qmcI6LA2ro8bYqt7MbcfYn2XZay2QXKFIXw5qQexL4C7einnvtNp3XQxcNevJwecD1Pjvpl +GgkDSSZ2unNSLvz58fyInAQQAQIABgUCVu05ZAAKCRDshigG/pBuvBzSA/4u2uPD4hGeIcDz +NGN9LfiQejQAaGESNnfHR+3t0+/VNTjlr7T804ANGhz2oVxhZ0FftuAIyL3RcBQvMeU4/GNj +gLFv4aNAxB8/bCgQiCGDSn/8NpH/FFuBmnvZ7qjwzNpSNWoec3gR2jngy+EhIfsGt9zbkh2f +famgE9iG+wHal4icBBABAgAGBQJW7TlmAAoJEHO++gxLfxA7tWMEANc450xtHlp1nPCZwda3 ++H863YB6uVAikYvJwIAbXcQiIxXnTPHWXC4ksQmvk1cFZ2PDa03DVu09QxglLTW97MM24YzD +AhuGIjZ5CZw2ZcKez/gCjqvCPy7MgOFsTK1mhxccdDTlsvaWxqIuv8IZxAzVumtiD+7rBRYC +NPrZatNGiJwEEAECAAYFAlbtOWgACgkQhCPPpSl711yxagP9Gx/clhAjAewQgJu1xaCyvbSM +2oIWwVvI9AMDFY1vhq9U7MVZpfArX3H7JbrvQdtebXHnYNOk3HSe3Z8uZWdsnmLAJz+aXWds +BMfohLHG/za8fahucfjY7LgOKEkbjDgpvzvCG9/5Thh7YzzEDiBPrQCMbJX/GE7nG7SLy0c3 +vBuInAQQAQIABgUCVu05agAKCRDbH6afawDeI5tiA/9DiPby8mU8DsJfsSxvCSetUF0OS7u7 +SpgE+UEPY+L8RIDl+Sx7sq/mXjH25bXpmWH6ygkOusNLNQ++QPxVEdbVujbQMikh6rM14YFV ++8w/qHPxVbpVSqXUDgpoS7cWznONmRciUFW1ZXVJtGaQcv/J8kLCIfzihUoPtGMi9ZQx1oic +BBABAgAGBQJW7TltAAoJEOFMZ7eg0kqw4LAD/RT+Ck40ULOKISzk/TFGnWujy/e3ZckdtvUM +7lsykZNFyXHJwj/gLS7hwkBxHkF30I98LpE54WtouEIwwCs86PVW8J6/+7Fk3yqPgqyhlNv4 +TO11kisq4N+5ZROXEvKPPy6gEtm3Hqr1620kh5/26RAxSJDqkwpkts0J8czl8lLviJwEEAEC +AAYFAlbtOW8ACgkQlB3AGTjJ2A4g8gP+JoeQBrS23dbM54yfMaeIgBjHJI04QRs70LOyktKe +c3RhQVt9rzu4Poka2TEuv3n6g701YQMWsyG4oUMWv6vIYhOKycpKjrWX4HZvw5zE+R9v7QI3 +iCNrQkCUOe2m/4rrW5CFMXFqfpWFR7MjvK+Q4gVcaffii2SBUifkbJYE/XeInAQQAQIABgUC +Vu05cQAKCRADoltw5EK8/UffBAC3LpPoJkPqLLMYJ0dbN9n6hyyrfNBqfBrfSO8GSWzsdMbl +g/I00rfWQ1tAWq+cOVNuvBv7MflcoQO6fRjm9jO45/DKO1hBTPrT5Vhujpeu4Ab3rOtjARHN +te3PRXOwVsAtPKcoiqu8G1ujLbZwQ45lrxl3J5VTCMG34v6ZqKCEmYicBBABAgAGBQJW7Tlz +AAoJEBDo/O4d/MI0gH8D/1v/TsG8d5GZbMxFJpgdGNxHMeIBjj8pkymSvKb93xCdrMUPc9fu +ZSF0y+XT0zkJxDaOrEt21qulIpXQ8Lh5uyEAfCNPIzr3701cypu+NNFvb4OwL1l1E/QFcEqm +LhdWgRCvg1wh3g1El/vl0caIv2nAc6FUiRLCxTOyxXi5he6WiJwEEAECAAYFAlbtOXUACgkQ +fqIhI/Rp4zR3uQP/R2Eh1m7C9LKG1698WrgzcW4QOKklzShncPiZr4YR2GneiKMeceKga0Mn +nj29u6XTeTo1MLCMz1WB351rHWLcO/BiGOzbQ2X7UEVPGgZtdh7ybWzYhTE0BR/p2JSV6VQX +u8QyxPLPyKoYCRyNvsXVkMDn2AEdSL0XkitY3s7/Nu2InAQQAQIABgUCVu05dwAKCRCI+9IY +sI/kstD0A/98E3Jh2Qhpvua++VFpyz8zmTWztSU2sOAwVV49HwIiBBoNGPAoONPYYh8tDz7P +mDenK2N7ZJiVi0au3FBgeQ7iPET6Rjz0IMLiTJbhnqq2Ip47Kk15J8NBbR70S6hQ0HgBvwUw +Yt6iV8bzPpGim/rMjOg4zXEwf2YNs/8TymJn4IicBBABAgAGBQJW7Tl5AAoJELu7RkO2cvuD +njkD/0utD76WPShTL/Ts6E6RqqJ45mxY0jRxzTrvpT/wA1ilMPiJDC22UaitbM3maiAULoKj +CIN5FNyBjRmFWFv1QHssV1LO4K1wL+0qWj7c6n0t4Ve2uwUyvmvYQHdduSZb+7oA4Vdr56te +4sm7mX/hXLVzhBswLwrgN7ddovmvI+2liJwEEAECAAYFAlbtOXsACgkQlRYMgNkDkHFTRwP/ +fyejWm6Vn21GMMw/DaXXEmsHa1mQxjlQV4DyYw27Iz506Fq+Gex+Qd3UKn6KjF1sHqm88lAC +kZt1E1bJJpn4d4uhC1GOuMk+P80im7ivk0VUyLck/qxd74OeHI7/KhLgLY+4yVjxk8cq7iYU +EsnRfdXnZTZ13NPgnI3cplwhMlGInAQQAQIABgUCVu05fQAKCRB5xr3X7xws2SjbA/9IqMtg +ixZvbpb1u8uBkqckB1dLYXKG0s8jPWOnT4N0zv8GL5xn27qdVx63hk4PSgOY9txncSm7Jatf +nywDdBrwK2V3o+KNCDJJfoey9wKMJ6lGxHwPyS1/euzzQM5P6eOPoau3yOh1oIU54ftSuMDo +fG78qSBXLmHP/b5PEh108oicBBABAgAGBQJW7Tl/AAoJEK4k0rilOYen6jED/ikFLabUrI1p +PSTUFhd52k+qJEq+5EOETWsnfcHdE4JAFNRTlg25KebWj7+A7ohhW9Do116iYiwqmgzjFCKl +ZFc5IMkklzYswba7r56cgsrHPo1MKSGH2IVrUbW/kUKw7wNnzBxlDIzTHnNNdI+aie9GvJR4 +plkvcK+gzSQ+CEaGiJwEEAECAAYFAlbtOYEACgkQLl3fsDhIwn4UGwQA7iJ19DSjaNFiHj/n +j1yBtVMwaPWKd3nJg8Vc+7o2mIMrjSBaepDfZuVWl0JwnOMqVjuJ0nWLUA0wscGhZPV1R8ak +ZU02G4SA2OGAVpRWTncLKLxMQyB2qYiU+gc8ki/KsB/dJkq0mwtuuB+cVRLD65mEq8MJ8mM6 +SQLz5/L8pk+InAQQAQIABgUCVu05gwAKCRDtJ7zrseoRXSoyBADCek1qXepIJNRh7R+c61lR +Ot+hPe/PCzQQBVz/Ic/FdpDwafYvPAanTWhpOWHDILbrQB0uPQ8SFQ3Co5Rc8EcdGze99bAe +7GN3i2/9+4lMAziHi4u3POFg/2MGd+i+QDRT0RGMz675mcTy+itwoLFtDqlKUiQfOSJCnzPg +rxvOm4icBBABAgAGBQJW7TmFAAoJEGeXyhyJCj0vWgAEAMa79KSH4Ki2Vc5eBcKQRb21attj +2mTKjncgVrmrWATfoFm5PSvmZWKKXkrlAUBkbiW5UImXZeAQ1dXhoJJ7HG3rc4Qn9eGm8/gT +NX2hs6utuPfxPcbHaCd+hReg9yN/bwuH0Js9Bz5kslecj22IlmXJ5kGRzhRLfj1BatzB/ldn +iJwEEAECAAYFAlbtOYcACgkQ5WOKuaiKe4halQP+IOfIHIRGqrL9AEUH+Uzv/pJ7I0MOXp3v +/jvtj7ln9bxbNHeqPhBHtTRMYubULg0q8sBgAJee3MS+NEw7+lSfFa42wMYwEsa01XMSe0Ai +IrWXD5n5LNG4nXh0FH0nGxk3fvFTqwzchkZNo+o6KYwq2zNYE0VLjJKU1APPvpk1so6InAQQ +AQIABgUCVu05iQAKCRB3IeHZcPS6QQ8nA/4tt9fK3XnYuBiQsziFezQbFsOlyefD+Ylgf76F +XEss4VV2IfDxBEyt9AUhiuPEvnuz1JQIZOjApHdJKRSL3BFzpuNLZsuLOT65i+y7USZ6QlNp +LpaxWYOva0lofIW/JbXh65tgQYQPqvUpNWE4LzpCFJXYXtuo2dP7q2INF6Qd9YicBBABAgAG +BQJW7TmLAAoJECV+TuAuepA243wEAMd+jTZe3TOzjWoXqbrUnY9WMQxpwAAxiUfbborHm5tk +ngAauc/ZUKygTVcLqJg/eGUHKsuZJcniMSflTK/EEdoqHtscHynRn+tD+6g64Wc02XJ+bHY/ +oVt3v4fNOHMMFbyNanrH/1Ldg5C8AFj+z4jHW3r1npIp8eUNFayTyBwriJwEEAECAAYFAlbt +OY4ACgkQJWmW6rsLJf4u0AP/ch2wQpn9rMy3mPHnkiBqdeP3aquTAyzp71s1RPhvekys6x4K +5QbX2GyyoGrpDOB1QIUdSMsLwspvzBMceNJ7TBhpvpN51NXKGpighzmmlRoXv16Mw29jg4ko +ZMP9kxyfF8CfkpFrRxOg0bIvpSzws0ua7p+fKR+cUPLCw9gE8vmInAQQAQIABgUCVu05kAAK +CRCMNw8HdxgD4COqA/46PQn3UiVjOFavyAjSBTxwX6fnal48VxrSQpOjHwVU1ihPyypL4mng +or6nR6lrz4J4HjPj5ewu0w7VPt8y6vQUhPKkEfB4WBl/OoNvbfvRIICjOb4ElN+CDeuqul/I +T2dn/804/GsuvRFrpg2UEBB4sKLYQf83Dm5lWWbO0hs/iYicBBABAgAGBQJW7TmSAAoJEJQz +D0lvdJstayoEAJJOrYTwv1E89PoK5MzEnJwdqcrjHjKgkDuUqd1OEp9Z9axuH2FgRFmGRFkH +jmE5yzqVMnVdse3KJsZwpWi7Rin68nMpTR7ur8+dxdBlOTNRz8pnkBnGrlaIwRvJy4JF/6VB +jmYA9o496KrUoAUHCD5WAgH5RwcucbQ0AuSiYso1iJwEEAECAAYFAlbtOZQACgkQIh56x2VC +nYVPaQP/eL+xhZYWEh5Y6orvHYrnNukNWgGTfOGBHQy9/YzkUWVnNyySQIoPEm9yrYSHpnQc +XCG4Tg9ozHDA4zC+9Gbr60iHLt7DjOwgXiPtz7QjM73xSn74AzRNBti/OIi4gXjnp98gRAUs +8updMA3I+cOlIDU6Svxit67NG8da4Xr65AaInAQQAQIABgUCVu05lgAKCRDBwH9vSTUqJpPJ +A/9wYZBoETx+tg9u3GTPmDmi69cddwoMdIBMpRkfYG5ljVQzW64cvhfeljabpEFyiY+CALxD +1+HIpb+Au1sBzUBa7vzQcxOORgGVzB+jNO71vYiO7/8Aeo3h7wJfWupXNt1ldHozS17zUDUn +nPe2RhKvm6Gc6+j935Y/Zlx6DvNcLoicBBABAgAGBQJW7TmYAAoJEKz6ZZYq5HjfTf4D/RfN +szKYveGlC073na2RqQFgghbscDhFCFxrj5WbA+VqOKh0Db1UA1WfxOnHcgkVZf/g0jqp3bnh +VDvdcJPGStF+yD51Z1bg5/aICZpWMc6w+JO6eSjbNGFUXEqhK8jkIumtV25wi2SfPK4YFMRH +2DkOapZ5Fp7CgiSIA0cw4A5wiJwEEAECAAYFAlbtOZoACgkQTCF/TpKOET70qwP+MTeEi+nW +SDXoxdIdlPl1r2vUApwuez5JXwFKU/1R+EpZxweSHXDCYRuQUud4VCF2Tnvz0UE5Oxd0gktk +KlkMeMjVXGr+AdJdG0lwCt8DqN/aUFzOXZRObwdTQwlq7j2JwWlYRb1WW+54BtEETz4d/iXp +oUH5nBRo1sqtCa/ET8uInAQQAQIABgUCVu05nAAKCRAneBSsG+/5NWgHA/9jW0lIJCwCeuF4 +4VL5ifydCkg3Cos9CaZ8ckV+6BFREJ+9CfFPkIaBOPw37NAurumOu4k+pXJVvw6ngfpLzuCi +cROy2KTNXgNZA6FSaLhBUIckFtqRleAVlNjIEzzd3XsinhZn+UG7sdUPvo46obfEUuST9PEN +OygILRkYa7PtuIicBBABAgAGBQJW7TmeAAoJEPvbP/s6n2/rkvAD/0Ku+cVpdVhlly6aXCPA +EOUil/YHArHinEhBAGeGGPI5PndZc8ICJRAfn+Qtf/J1CKb9bREZxaNi/PUIxTzeK07IfpH/ +vnOp9ENBAuR1Xbv+cH/pIyEXfxZ8WxR1OgM3TgJBdDEShQTfUmnCucfIRYxwL1vSLuuoADIW +CCF+CbowiJwEEAECAAYFAlbtOaAACgkQF7B93kkmZIzQOQP/fZyqHNUjYyE+LHTikqkadGqV +6Ewq46HJJQKgmWLCbQG9AQBs0zI4CAkYPdfb3JNGj6sSCiZEmlTmaLn+2EfevfeVrz0jhOr7 +BGA5+J5GYxXcU+gaa3HO6S4vsb568tgWGpPt9Zykbg1McTbGPMqs8017JcCTyp0b3xdbScMu +DbSInAQQAQIABgUCVu05ogAKCRCL3DoPfJHs7ZH9BADPG2k5cOEMV7LcJh4jgLROYbIYMWf5 +dWqHaRcjGK7vR5SyP9c6qgPAGZfFS2jm944wRE0Dr1JEdGPa6UAOa7VMzSidul0PEyYiY1pa +ZKhgUQ74wHQyYs9067qmaTL6Gq9EfxM9DGRSPm2lLbvwKwelVSwwG+oMIx/7dBWGvFEyAoic +BBABAgAGBQJW7TmkAAoJEJUs4P8sVCtLdUEEAMWDPtgh7e+FOmn7PPDUSZb+gSDIV5h0wGEb +gRCPMaGU8Gj5uJJsA0yjygX9SACqjsTO0/yRyCR6J4CH/hPjadWh97HwGYbSEjsY3otseBb3 +1vfMokL5txS9iyLS+pcMLlGn5hGxNwHi9+1ChEWYdr0686GcluAhiV1dOfvaWb/YiJwEEAEC +AAYFAlbtOacACgkQv08hXYl/UUiFEQP5ATuJQ6u5JqRutTToU7nQevuXoT93VH52BHUXSKxS +0OLjHQG5z9bpvz279ckllRTb16wWuRTrPNi/yzgWtSdNAeC589SlO6DAjjWe+aGvQQD1sfyn +azIsGeC9lAsr9Hbej4Jfrn8C8EYIO+BDZ7i/DAQOJjWH+sv+2XUH2dcMkb6InAQQAQIABgUC +Vu05qQAKCRBTuTr0qNsmFnQMBACDUD3Vn+ew6WE1bWRGDToJjRtSjJAXaWJj3tGOhpEpEo3T +HCg9+5eTJelAhecppWX4zfmy7Kgx3fIKDayn+X8CMKZ7u1GYDFTkJl0V1l4IefDgSNTEYFWM +Asd30uCrD5CHZ/ykueSJxpPZ6NLrSU3wqTri+eB3e5dmoiyCTSxwToicBBABAgAGBQJW7Tmr +AAoJEOFPsc2lEy1Py3MEAILVwN2bcT1bWwOy+qL+zhIG4dEZVY5cLEX0WnFnZUXw7ykt866H +OSGQVMVfC1O0hYWWtilIA9gYFoKR8PRX993EB3ULxPy5X26BjMoAiawuW3gOVEhicN8Gt39l +fLEFScQHFY3F1aoZvn8Y1OBkknzaAI+oXV75oG7ocb2BTJV6iJwEEAECAAYFAlbtOa0ACgkQ +Wj2XOR52jFejjAP/Tl/1lBImuAvLf97ygKf0H8FUt5Ba2OPoYDGoOtmgn+LMrc3psqDNRKWR +2xovt+mcWb8G5bCTwAp7Ud0994Jb+32sB4e8FZIU9My/A7Wwl7035HKmZytdNazYECGVwWM6 +Xol2XhKjXPuYYaVJy2vNca5vDvLF1DY50FU67EAO9XGInAQQAQIABgUCVu05sAAKCRBSER4t +Do5jjwMyA/0ShDm55M1J5fUEUBxAO+l9zNUCcQFjV+45kZEu/I8YLnqapvDzMlICwoKOLNdN +/AOge0Y314jDQTZp5jE3Vm/Pjly/NMG+X/evLhu9sK8LyBWnZyb2g8WIcajlzd6PJWaWwIJr +00xcQ400D//1MnyxXqBuEsAOYFe867FpQZYJ14icBBABAgAGBQJW7TmyAAoJEEwM3zGb+b9y +jt0D/i/p9m72evzPHGydg78tzU3V/ERyrVX5tQgOC4q8ZBVvXSHnO/QBHCg7XfLprLCFsvWY +bGhfi464MznaIXICYbP8A9ZGNs0fqQCcNmnI444HFgTH8/cmJkuGu7eF7L0L1WQbhWCgWEiR +rJP1TD3vhY1IQBYfAZJeaTl+pT6w4UVpiJwEEAECAAYFAlbtObQACgkQtBQFR1U02gpkBQQA +s8sA5ZKqghfE6qLURbqeJO3pg6QbnboPEsJY9ZLLuUwWp7tgr/alzIzWdVY1dD62n6yDamRg +KiXXE4bv9yOrE6/zvO4KupqgALjI1lBEXZLpEfQy6/8Ics81H8VtEHhCnCstYx+Dpj92sIN8 +JCrWvXgZ/q8L0HtVR0vI6UWjDWaInAQQAQIABgUCVu05tgAKCRDf6OAx7Fw999HiA/9Ms5Lp +rVQklsJAFB96JELSPBgswf8T1PueE6ElU+bz7kAWtx4m0WfOOb4hcz14VeR3paG47jbRXX4q +0k+iM/jwezZFIqgZHDdAk63A0qBWM8OGDy7aplxn+PWEmvS3l5pN+71NesrnOJmV4gKGH25+ +lIpknd/d8TSeOdPCHtn6v4icBBABAgAGBQJW7Tm4AAoJEDeAJOuujFPozHAD/2BLVAgF2FTK ++STXfCwOPr6cftkuhVY+acKAaFpvWmW5SEOwnUIJXqEY4Ndc/eNfVfJkC5QzBkb5HSaF2QOc +MVSq3lFjbWb1a8bJaUAXVLlHQ13oD+RUwY0Mw11Q0wkvC48SOjHATGnklv3wLyoTXc8Ezgse +b0P4wVfQ2FFiQe60iJwEEAECAAYFAlbtOboACgkQz3uQaX8QzXKtkgP/WdETE6SaGRk9yZ+d +2JkjAUFslU0aDl6X5gDXib512snW1GS2vYdA8nBNKjFMaclw/P18C8WtWyJFHkrx8w3ukPsa +A+r3HzneRciqk/yRlxlo+o0XptpSu0mTmNdzyD3T/cEDQ13czSncXIBY2Mzg6TAfgjYbpE05 +FoVgPeq5PduInAQQAQIABgUCVu05vAAKCRCxeANHWDn6xFOlA/9As564iIGBRlCmcPeFKkdR +klAWx8FON58gmnbLWkZs6H4OFYXu0vBpMoi1snMaXR7R1LZJcqzOmutFp8D6aZSyEtl2w1NM +aJH9+Xkrhl8LXlsKlnzgdwhbF1v/3+L36R/g0NeLClUpZZveJ4+FO4FSNhmh3D/G/YvfBdqr +4FrAb4icBBABAgAGBQJW7Tm+AAoJEGSDF2VeZXVKqFoD/1BhUkoVOv6jUyY0ZV3xcW7JWgZ/ +ykzyUJTQ9JFCn6TeFsTlDtjI0CEjpQb7voK4Vhlc9UmXINwFqK50zROp+DGoSStDuQSMxvgp +bTO/6Xt5O6faaV+hi/D2+LuwKCOawjpsfLSLP5potwRvWobtOddCGYBqHptTbx0S2MpvnoXG +iJwEEAECAAYFAlbtOcAACgkQX3YauAM8sJWxXwQA1hvla7d8Lk4ikzaIP5wAsvmYZ6cgW8TP +ALlzn0hmu7w67TZjAmQ61ygyR+CMX/iZAIsFw0U0g8CnwTH41soRS+Ku80L0UO+4B4NEmIgL +xhP+64MoALXO7xQA6iPQKyQNp71E2PdO0Z3ZhKPdKS/S6xdF4becsJOB67kpLjCgWW+InAQQ +AQIABgUCVu05wgAKCRA4c7u/OdAxlZ+HBACfgsK7Kl2TkHVK2Dcj1Ec8SqExT1KFp+Pdu6QA +6we0DvXzdW9LQ8byG2gW9s/imDmylfr6zBbaw6AJxiEsRQj6Yi72wT2Lz2ahGfB2ABJRd7Jx +WAgR3J68kLR9zQhM7LoRAKZGrKxxn8gfMphbzis3tJ/7dPg4ERh5AF/TI7ZcRIicBBABAgAG +BQJW7TnEAAoJEHPip8mpd1KQziYD/0hFLrlBiXB9SPmvQ+1d8F5/WLEN/+jUDNysTxCd/q/E +zuGaLNwR3Tv8WRwoam56WVbQDI31tB+EZ2/kmxtc4oRDxjgdsnYNu0filjjSmsxhqg6hbVJD +SObzLiVg1/WDx6QtHzFdzSlX4l6HMv/2pZfT9VwoP5ekrpNRw3UDtrQoiJwEEAECAAYFAlbt +OcYACgkQjTKvVizOvYbbUgP/WBuYTRWNpjjauZrQ5do2rBgpJnWMTXUEH4A8GuA3NRYlDrOD +PZ4uqq4v86YdjFGlN2ZAVdBKUTEg2NduFcIigCP5y5O49H0UFvxxe6jco329et/4fPnXLLDK +tO/ExS3zv/Z4zY3Cjffw3eYn8vBrUEguM1bMm3/f51JPl/1IPdyInAQQAQIABgUCVu05yQAK +CRD1+X5GPOgTapxDA/9DJLxGIAoU+D+L6anQptXOsuSFsN5ju90s0xY1DJ5Ov32FGK+8r/gF +WF6htLgoo8JyZ3JCPAROQdATWIUZlwMb1uOdubAYXlHEUp06BSdEse/qCWJqIH/Nrx8wYklY +5r5W7XTjnPwc9BcU3gr2aOoed8T4sY13Bs6nlPKG9b3nr4icBBABAgAGBQJW7TnLAAoJENjg +pV07baMMOb0EAKpMlOCJZ/g1tPgx083NMNv31td0vQmZCV3KpdlP0Cyz4kRnrIR2qoIBuGqy +5HAt9wEevDCGI2rRI6cdgilC7nCsbfCVi6N/vCT/ArjwkGdgUZasZDXXuyJ0aXkftRmbnqrW +iJ61Ar+6cGv1i2t2rx8kilbB4XZKlMvt/W1WBfkxiJwEEAECAAYFAlbtOc0ACgkQuGeKvRqq +X5U6jgQAwN+qXEzd8Zr4ljTTMVpFVCuC6PgOEADTEbG/8fVd+0ISYLmFIzOSKTTyRVUkbbbJ +tvn7xowEmpbO2p8YoFAaAnZFLulEb6rr7E2NuVfhLwD35lkFJZlakxp+zEckY6RRMT1ny3vN +rCBrVi6J1q8Gep5+daTNqFSmx2mtN4wDK5eInAQQAQIABgUCVu05zwAKCRDkpiieVggJ/2+Q +A/sEdWzmIyl0MlxjIy/x2Uis9Ihi23tmWY1SEWXBvaAveo8zvqpCUKS9ODMHNrT7uPPQb0Yf +r3xmjWLP86kG3Nx0aWmL4UaFGctWV2erW4oEWFEizIrI1+7ZuW97eXAtEkBGBrQ2AdzHa5Kr +6O3ai08QGgVLQHZ9XR10c6NSLVLh64icBBABAgAGBQJW7TnRAAoJEB2u6so73+AIml4D/1GZ +tCKFstYC05c/PoQK6Yb2eFLqVmd5Jf27WDXXmTVJUk4nC4LJPVgLT2r/yEHN88Apj5GXj3Mc +VuD7Az29iBSVdOeDRr1OjdofFW+PjPscozz0Tixkqq5GINW5mrZINSEF8cXcxzFXJOhn3Wun +yiaU35uZtsuaVdAvuvMzsY+jiJwEEAECAAYFAlbtOdMACgkQqdEZMetZMVocXAP+LQf939hl +Xo4TZ0lhkd6kmZ04b8mPXvbhxVQre652SSPNJyiSHkCEsJN49k+Gv3KzXMz8M1oo2hde3rhc +mK5+LNaGPn59aB5fWa+89ykt1hMxYtjYDn1a9UnEvoQ6NNrO5dQNM+SCrjSz+C7ZNsyFGqR0 +K9aKwv+DqmZ0mnbW+fmInAQQAQIABgUCVu051QAKCRAoNHPoBV/HdMkkA/wIK/JtOi8Dg4B6 +b4XF1TPnpZig3U85ZYdCaZOkJMz92IODbKmSSnh+D+iZ3uwj60aWBWA7mF7lCIZ+WgDzc7ft +skfp1AH4i15DLnxssoULCr+kizBL0zMqjnoraemaSHIND5hAneP9m2Hn+IfYmuRcvkE+rrPR +ah0a6nXBKRgAd4icBBABAgAGBQJW7TnXAAoJEN0xTRMBJ1Z9LW0EAMDysdzt3C+LiWk8TLZk +ntPZnHRHFQUM41kK/OWP98/vLwyUhHkCMXDg4OEt9gssEdEYpjDcGHc9SIFqkQSJ23UKpCV/ +paY4tWdBO41p7or54cVlzUUQXa/BI6J8bpDnLRzuGy5HepRwYzX7WHSl9hj2pdwCcBBl/9nJ +QxkHlzSNiJwEEAECAAYFAlbtOdkACgkQSI2JAIlImd4w5QQA2+FjZ6eL61UHEFUzCp9vlEjb +cwG+hcrdxsi6jie54htVqzVRz2AyGDU3s2bBp8AMJI0w20edThzIdjlUdWUBRFdXea56FIKy +t9e3yDD+Gu5un9aEinlN06+eVkW6XAz7FcnflulPbKuyUkCBzQaUs4VK34FevA5cOYIqXSnT +CyaInAQQAQIABgUCVu053AAKCRCJpq/+QCiPyklpA/9dAEmWUHL6SXL0JoPjTY4RtRQcO1M5 +uPzlNQDXo+pUOY1CN+dx1u9CuskGCTecYN0ReuovwOHWp9RAt34Mz1e90UBuLjzsSE55nW9d +/KmfSt3ckM077CxFYUSp32JpPMJkzfd//IWkcXQj2ENjr9VPTDmFdQ0ncnJCdaZq0Z7/noic +BBABAgAGBQJW7TneAAoJEPIsbW1sTpzSU/kD/RMQMsmtzGjVvoBkoEQlwqHldCYWT6sdijx2 +51ZB3jByEcjTvvo4Y4srRSiBwtpKn/50MyNstT/zETOwjgskzO6mrfUTGAAlUtJp7nmoD7JZ +/uaV5WmUE/XDiKmRvuSVACjGXY4gg3R8f9k5pgELXxMXTBybc5+DvtMquo9ytE88iJwEEAEC +AAYFAlbtOeAACgkQd3EYq6IdVKr27QQAhYt0kBkj9bulh+3RXi1hZdwi5Nq/Qm/8vOO0xrk3 +Rk4CnWnETmU75kR/VAgypKlI45+EuZLlfFQ5GIn45e4xiNPH5fMWkpUvjBOnB5FjengHf1Jz +D82IENRGA+NgASNis7c8Mo/qQKkZ3ky2liI3MISsb5msjuG9Tpet0IXwmauInAQQAQIABgUC +Vu054gAKCRDbYa9Wl4zaSouOA/9sK2JpdDIrGEMVskf3o2U+YPBLrfZfNc+LfL2hed73BdQ/ +Kk8dsLAGj0r97ztXniogfbWo3iTcas+OuhqHeMucVKedAUfctMW8FOJh3hMARajoqDLy3wnE +9QldVLErWSLKXyNDOXnrwEKdIyFJz9rHCpRSuIIfqQ/HQ6kTaQlMeoicBBABAgAGBQJW7Tnk +AAoJEOuQj8+mhV+lGXQD/22JFlhLQwU2KJSHoZMZoqGkfnZ9RyD9MRXBKVqNiLNFP6S8V/DJ +L3JdOLNk/nGDRiGCFSlGGA54fxBuKAt9/Dwi/xlg+egmHdY/5ar0AhIOQRD5ZZ8F0wzmPIoP +MMWhfL+WlI5pvyV9ZURPI7GiLBr30UzffC7FgyRlDBrx9ogAiJwEEAECAAYFAlbtOeYACgkQ +ea6RCSaUkyE+NwP+OF7Na00wL4D7x9kmBKQdTwhlw9cRuUeTGulqxszorwXb/l5V0sop0RxY +cKgv9SACQVMAq4o7wh5ZP/LqLWdrgxlitr8c+1TOhe5t36BS2NbmU2dwLCwuqyqzFr8vAk7g +Nhr6yrdj8YODvjSASItEjanSXnWZsm27TF5ESFin6y+InAQQAQIABgUCVu056AAKCRCk+lU9 +p6jSgxJBA/sHEDeC30i7EHGbn99NwuvkUWPBqyC5BDm0lVZ/33hIUMmIloPTGONhFykCx6HF +EG41bkRXE/uCJIeGXev28a4/t0KxP9XhO9VqTa9qXMrWqzXqqVmnzY0olvDBsuI7YwcNHlrD +xXEsnhIlJGTOA0pxYaiQD6Nhlg9RL25VTVuIaIicBBABAgAGBQJW7TnqAAoJEGv6CUnqe3Nm +8asD/0Fvx4VaWX43YXTkfP9rHF+JrKyFcF1AzuMECkfXHzzIYHSwR3TWkVPYRk2OQhF16Pic +V4SbQSrKGedkVYB/BX7+0NPyKZ3KsVOBZCntKqFnEERyeyfxY0ZVya5/j/kL8jFIepXCkOjO +1g9X/6erGIBPHaGrKoD5iWfYf7UJiiFmiJwEEAECAAYFAlbtOewACgkQteyorYxEyjXlaAQA +mLMeFGS4FaTbW0BbUSzywMZ9+k9SG1xO+E/a4180SfCmiMIDnADI4paZIoyDncZwX4zmgQLI +ekwySCNYXlWsFn9DBP6FXvqkSNHzlr/DTxXZlHG+53RDwfI0+FPl7d+9sjDYGCnh+idNvIlA +hglKDg2BzB4B2KTAtHNJ+sS//k6InAQQAQIABgUCVu057gAKCRDA2JjcqBn9SspYA/9KYHxO +LNtPY4mmvjxSibrpxGxjdDF97CiAFZA+vgDN2Nn52byUlGaMHs/0/27j//+4iba9AFQc6+OD +MH42UpBmp+I5tjN+1+gnukv2CZZAYVrKMPGzEz6mh2uHUGH8yh6dBt7JeHFIABIxRjvNl3Sl +L4p+TEARB+AwOGa0RuiprIicBBABAgAGBQJW7TnxAAoJEK0tMtA6L1rHJu8D/3ts2QUcZaIW +X7Z4+ZxmSz6mZOA5VabCXpJ49pRFBPSHBthVGgxFj+pdJMe0JpBbo+HaAANDFe9d9NA1QGDl +N8vzMusDJrP6tMXdPFID85Uz3Ot+D12V+1KMP2L/InOB0ZHLgnNiRAaBNBUuZgH5N3LZxm0F +RcfYSuGhCeyXfz1IiJwEEAECAAYFAlbtOfMACgkQFjD/7KP/Vi+PaAP+PC86UuDQOD+PMSdm +8OCG4gCxkVH0wRSx00XLXTe7LBWnkLw1r97JQRg0dOBSG9z3ZUoJyXKzTWy2HULAN4fvxjUw +Y+1nFTSK6mYL7dud6X6TFe1sV3v7AjxyV6iNVBfquRpHKHn1eAMyWZMhQr54Rl8sH/HwwnNn +IAac7s5tUvmInAQQAQIABgUCVu059QAKCRCuUSQM7rvK7v+BA/4kVk6YsQnD3Cu9YAnIxFgD +NdwcRIvKb/6C/R6K1x6KKiT40WsRqs91x7upwzw1O730/PqBD70du+a+YBZ9s9vAGUb/1gNn +ZQaE8lU5xy0UtsRFymUZScXfqqyT93nV1OaWWmVG7vccWugtDoydEiPhrhvdEATam0aeQFU9 ++Ot19IicBBABAgAGBQJW7Tn3AAoJEFhZ+iWYslJQBpYD/05Xto5dCuYqN02iozrC+NkQNaUO +V/EMTVqPexct6L2GgfWpfp6Ft+Ty+opYYtDaoamdjmF3/VDHZ9AzHM3FywN8gozzSuS+QKdK +SYncd3TPy6rbGYx18K8yjYtg5xanXJUwvayipP6pSKSNmzPBE49pwh+5yRxU801jzFuF9nFa +iJwEEAECAAYFAlbtOfkACgkQTj6laYdGcYTPcAP6A+12Lo/CWqePv+Lc5ZIwOVNhFerSneyK +TFzYoY0unFY6jy08rgfXwU+Wv92CCvfpTqgaK3K0pt0bjqYdx7ZLeUhdd1Q+HNqam9lVOYOd +OyLwvLDtkGYkcSz4ZNOChzc+r+uLfhPh1z4wQLF9mUUL/mF2snYRBXIRgRDuNhe0cdOInAQQ +AQIABgUCVu05/AAKCRDcIA8JW7jP5TNtBADgF1djfzW4eiWssaXujdJ3haGVyWISW1vBSnl7 +4UF4tXnlzDt+qa2Ouj/NHKFSRd8CWuvLwHZ/5yxwJ642jk2QLfRFsXmygrZTYwMl3xfKUrKe +wcDdvyivRLiYDGQzi/Jc+CYrGxdYsY0CbxRA/P1YO1zGB1WjUOF1Pul6SJ8TbYicBBABAgAG +BQJW7Tn+AAoJEKfzLzsDOtA96zQD/RoRZFFy0EBy7kGBal2o1j8ZJfRcASV7PuuhpJoLcPGA +Nhf0TS0frP8O9e18px1IE7/O9V5Ew62MO4yE/uiozm+yn+xBk0pB+BnjNPwUfxp6FoWtlgo8 +zr3k00nP8Ju3AotYx5layYXocRUaTOrYjgxazrQhUWEJ5OhCglnzKd9riJwEEAECAAYFAlbt +OgAACgkQeL77IXzCpN90QAQAkFfRP2Di30xkHiQigVXU/MQAagLmcHO5skySEPABqrdFaj/z +nwaH9+BCrcE0ZHGQ4O5prlYu4+SkbyOaOm6HHwOYAi2OfOq66dQZUwC5zsofKPrMur3F6mUU +9xaX6ojJ53H6tqqSx9xAZESByjZ+grEQyeFvdEg8X+ME4YaJyZWInAQQAQIABgUCVu06AgAK +CRDNcflMSS75XtbnA/905s48aeiYHfwdW4FyVwq0YDb3UGdyGK9ksgi1+cQczSCuIZq2cBT6 +r/kJ5YpC0TUJB6IXSGTHwATGjBYAagX8W5cjekdSj30mrMOdWqNtQbqAyEs2BB12wVfPh5Ld +EyZfJ4shwC6lOSiUtW6Ard+RESGNeWZzZjVorycRV/OXdoicBBABAgAGBQJW7ToFAAoJEPJU +wFgfojx9QjsEAJvfX+fSrskhQ7YwIfCvt5CMrcR9ZXXRMC+4cdh8l6s8i/AY5P6YQ30oEL/r +UZUiQh4C0BryfL/qJw8NVCkGsLwH6SNWkMLBBT+9VMHUaVejUHzizWOvOjzQL75B8rIIVOs7 +wfSPKtdrEIMLIKhwSmYEILn398xAuFdG5XXWoPFAiJwEEAECAAYFAlbtOgcACgkQTE7obTD2 +pB6VawP+KFD68wGwxBdXP1aGMOi9vQKR977SCr3em2Vf6nbhEZtFsvF5EXigADNobGiAlNyT +F3YG9JNqmZ8SS8Y5eD3C8C2ep5oqRY0lhIPAAK/pCJjOInWZTJzh3vLAI1wGK6Hw3ByeR/lq +1P3xy8Zwr0Jxp/DPHce4kkbubWhxryEL4yiInAQQAQIABgUCVu06CQAKCRA8k1vS45wfIYRI +A/44uSDB6YiSNOS6wQxW8dhyf+xu8H16hRy9tQJbeitGCzJdw9PL8CKeNgZPwVebH0lcIW/Y +Ym2ETEmWLY90mLNXQjlkvMwRbcMwy0BHQ+wrF9jVkND2EfR1tRpETOoKKFyH5X7/poqMo5Zy +FbzgwTjjtuMEAYripsNPTphlGYHHrYicBBABAgAGBQJW7ToLAAoJEMYkhj+wEUvx1CcD/jHC +WwR2A8R1WaJbyBweQh9YH6n8J6RBuMU8/iiovnMZtupSEJpSCjZn3qMhSoWPkwh6T+mf1QDE +A5MZEpFdulfaPpQPU2fvJwAN6rl0VA0X8jLM1RLl1GZomvD+QuQXvezdOmzFBcAzJgpRvKlD +LVpfS+6KGvcluJZUggidjb7WiJwEEAECAAYFAlbtOg0ACgkQL/AJopB/fQRuggP/S0949XQB +agL0yG8c3Tqt584ivFb2UVjc5DZwoKOOVQUummJ0W0VBHDLpZR8XzfloIvvSSKdxAgtq3LTj +qhNIQnIlncPGI5q+JusF5Pbzd/lFe+v/WY3u3fGCQdc2VV/hTq3KucLOAOOv5aa1io+AcB6c +CVho8iNiGHjFiyfFQI6InAQQAQIABgUCVu06DwAKCRADJbD9e2pm9pHnBADNoPh4LB1ZQpNg +58vcVjq1gwGMEztZDSLju+TlzSi1baFM3ArAO2/vbA15NZbMkDALS5k5QDQJH0wFyYLUZd02 +8wiGGAihZ+WGQA/uE5OmXHXRQxUcfvnFBgCoRU1Qqw6aJbicCJr/V5USWuR9YUjm9ohXt+Bs +1jLSmD2bWO9nBoicBBABAgAGBQJW7ToRAAoJEB3SeZLfKxlBiSEEAIadf9xQcp0PFpEpMmny +hRR+WRpLdzyniaboRKB7IcOIRJ+NVJF5vJJH+cVDxz+N84Dh20ISIh/Xr3lt88UIW60DHn8C +mNoTv9THi+GfM4B3K60fZ4qBke7Oh1GmfYJXnXpttdXxWuhj3LslV00CE4FLQhqNoyiGrLOA +Rgt+qVhuiJwEEAECAAYFAlbtOhQACgkQjmRO5bxQabiXngP/Qgl84nCt2XgpGsQ8uhVYkuXS +aqj+/KKc3kHSiICL16eOVV6Z8h5HnJltdqh+/M9UjdDvaJJx+ISgkbzSj273y6Uadm+VnYHa +wuGA1hxs9PVizH+8145XWShfydfT0tsqglh4y6KtrpKOVbslNnU6KxGZuBm5wy7/LwaVkPeN +2g6InAQQAQIABgUCVu06FgAKCRDZ8HDsbnBnzVJgA/4xYLRdylUQRDHk6dG8Ql3CN9JDjwAs +gfsEQV/vN+sNsF9JeP+sRoR7ZuiLHp69e6CIXJU0Hw9Bprv2NR4kT36NXHgvSz8zLg+w2ZFF +/K48pZ569Haqx+zEuGOS8zg+UW5T7D1zEbQ8s1OxQcoYfFFMvlP35/2qUSx2JMwVuxkpx4ic +BBABAgAGBQJW7ToYAAoJELr2xrvrfyuIuo4D/1GCW/73MNlC7NqXKDmnURUskBZc3VrH1rvz +LqGsa1OWCusTAVkTTyZDlsEgTDFft0Ti+ZIzB7CcS+kOHJOz0Aiyinc52I1s2GuFRsiuNmui +Otz8HPTF8uTbd4d6IZcU+wJo3+YPT47EGY2kAt77dnGMyufEkl1kXgcHOLKyRX8UiJwEEAEC +AAYFAlbtOhsACgkQlN22LC6IiHj1NgP/SApbcFwpIlwnsEvCSbMkHmCY18sPfut3lnRciZr1 +C8HK8pyz05/HNUZgVjrCX+3nNuF8SRGtDBTugp+SGAwZrGjJQsvEbS8hqKXZiM6acUqVm+MC +m0EIdJLnTUtLRZZCH205xjnkisd35KBcvgTnh7hCdhcWFHfLbI+zcaA6ADyInAQQAQIABgUC +Vu06HQAKCRA9vOXt/lFMA082A/0XPc2oVP34EBHHmBsahs5DHZc7N886lqbbLGpQlTpLElMu +nK3/6CVOfbbHo2OuBgv4YpLBvb2SPDSl53cFxWVziGFVOivyvQzJZF2IvG2UHrwxYQNKU+kx +j4UAd6gLqalSasFQ/TBMmczMEMaP0udcMI6e7sCbIL5TfWhi+hKoT4icBBABAgAGBQJW7Tog +AAoJEFRGp5VUgN/oMh0EALQUrjxRO+Qx5B51kj4VaCrob8bF+b9CJHzjhu8JJRCdsFGSKNnv +emZ88hrlTkc+q2NP9AviuoTbr15Fgc4S/q29OezX7HS+TyEyFSM+v4KXKNNaRnfIY2gWg6tk +EvoumuRN+sJY0UpOPFoOUPpFIlqRobfVNHsh3z85qaYqB7qPiJwEEAECAAYFAlbtOiMACgkQ +E2R2YRcvNKvP3QP8CsdDJGjt0AV6BG1QtIE+n0Qjlp4wlY/d6cl1hy5AJgX9VeZkwJF/V0BM +tscRy+rgLBX6nJLE1A3+GjY3M63w3DHAQg0dlHxC4H3AMbycWbyq7CDsUZNrNoYBBmM2MFx3 +QVBebG7QDtC3Mk8r+6XTJkk+iLn7EyeLclexgHT9EeiInAQQAQIABgUCVu06KAAKCRAJhPqm +nee9ufJxA/4ngQp0b743/ijR4vWnpJn/Bpy1M8Kht1Rn7NKRCgE6P+OAJdUremcBsWSBHg+g +NGxbAYMhLTkw1cIjLbbBSMKX61FJrQfDdkXyViaIGdHnJXsqxh0blCVYk5CW/7pK4ESGISoI +cEJwDGiQ4ON8cqgdrhL5JiE7Q9Grf3na8sjShIicBBABAgAGBQJW7TosAAoJEEcuKrAxOOen +VcoD/A8tPYCwK06DC2mrpgSyGhmXoHex7ZXjjtGpxNp5+vCJaV4lpwyj/zG1eHOjqIyg0Anz +VZFc5HA3+blz80tKVnF8ktq+3vFMa8/hY+v0hAxhfuAhxoCTfTP2sutlHugL3gI4+kKtY3nK +hHPcpEtbCp+N+t6C1DZPtFfQDYQ3M+2UiJwEEAECAAYFAlbtOi8ACgkQvjDTxL0eplaO/QP/ +YeYAzJr1gP8C9yd20EUXqY/Vp+3b31oXdrlWEn9+FvjZR4eSe4MFdN1dwX/6voJx3r8OQcjo +P4J/kP9KtZbbVTfVpHXbMIbTiLipfjMEjT3K2/r2ZaYcfNmYXOc2cUFUoZW95d4+z4fSoCy9 +QL8nrxwUmnBnmCHLr0Ljfi5a/5OInAQQAQIABgUCVu06MQAKCRCQ14v/WfDpNi0vBACFuFSF +bvOcUmaGUf4Mog4EFgtJtRWNDGkBy9HdUe0sKgyAtcDVVNCL9nOvTzjLACK+2gAH1GcX+iue +t6tXXqiPX3rag50z4jYJpESp0Huwk4YCNorHUmQvMyCHfpM2Qa+Uh4fsDxf6zLnKKG+Sr3Vu +A8Blbc7Vmowq/5+mqsn5WYicBBABAgAGBQJW7TozAAoJEALrLzCsuhu7hyoD/3WgWxFlRxTs +k67u4OFHBEybRFwsZL4Jenb9JIm0PdKqooFcZHbdHW3WLxD0fLmIbJAcfop9RPH6uVQmpKrT +hTz/mTzmSplI/bcPON4OlWLEzMVlDcYJEHX0lDW0qd82WQZjvZdGKggQLbSC77Fv606jK/zq +bcj3vLi4mPkoa1SdiJwEEAECAAYFAlbtOjYACgkQRgH0Ug0n4bDJHgQAz25xeN81Pz7zIpvy +GFGJ0c9KZeevaMIaoUSGSwR7S/M73Ga2CWkw7aSA2f8eAPT+jR2lgJcxVxc555XiGCCcbwHE +PyA/UUDyQWib+zMHjE+HY6DfdlFQk7CglxYsgodvtFW/Qj4SVsa3NigkclRLMEN9J2s6+MaG +nsqkvC6h1AiInAQQAQIABgUCVu06OQAKCRDc7ONDPqT7KaiNA/9Ua1xsEsTMSTfKEENUK0KW +1nU+XpIeHNrl0lTH0+8ndOFnJYujHKwR5/GW+r9Ymq+iZvzVTjOEwQdw4MSGCobnxsfkL3Fh +puU31YLt0S/1kBkkn6xBD84+rkw+iKIGkQR2pMdKgIQKf2qiB+VlKl1OGbTfzYVjlhdMDq5J +TqUAhoicBBABAgAGBQJW7To9AAoJEN62ZJq5kSgE5I4EAKVngOfRo41iAMt8g2rYXcb/Xto3 +NywwD5Oek4seg7Y7whV+Lf5ZH+MCWA/YBE0M5q6g7vBpS335nem2sK4mSZsPWH6u2SKJxfQ8 +LNhDL64uWoavTRn5AHWdf411yHc3JNVK+pyZj/XbfWplDemFZ9I4OG5al+E0zvWLV4wzp8fK +iJwEEAECAAYFAlbtOj8ACgkQ7FG1C5vrJPVloAP+On/atl/awKgUvrRCabv7OzVvPTke/HuK +kshCAQTohRW1u89yA833gxKBAhjvoRBbYV1QdkvxSL6NI0F1qzfbyJf8lLR4NsNwIWXBUJrG +j+7ILgi/JhEnP5vvKgPTl5ZS+ENGgat/oFTgNmZT0wkrSadqF1DubfNtTLZFRRlQn+6InAQQ +AQIABgUCVu06RAAKCRDygo1mWM5hevO3BACbItbU43xm4h8v+2S2VdPU5wR7yMG5Tz0ezF5D +dWtr1b89efB+r7f7Kfp4OxLT6rnftTmOo0K6/KE7F3vIbnmejFxBmim4bemFlE1u273eRDmp +Je73Y/Rz074pd4lvYPaOGTj8lvX3syO1EfsVvBO8VlbvU+b6dmbGch/COLPkgIicBBABAgAG +BQJW7TpHAAoJELbRJqDJXJaZs3kD/1BWIR7i4XseeKu+Ksy+w4zHjNVHjBN57Qzzove12vcf +mwjkA1OBt7+2PJqgnrcthqZskn9kjiZr9ytg3Q7QUl41zyLPYYCcYcSCKJ9EZrLuWb9He/mC +TPRlluO2WxpLd5aAfv8JjY6mniOGcIi8pxABoLh1krd6AWtNxHLmFN7/iJwEEAECAAYFAlbt +OkkACgkQStCxqzyitTgEgAP/dP1uexp7lZr0qfDESCOj5e0LDw6qCDo6oE7CcC9QUrKhV0pi +cBx7jiYOLtCrix4XxBodlpFGmhjsp7smrbu08pokk8nBzx6SLuLpWiynn/6lBETA3hJldOiN +uzPPa2vm4SHcbi+Mq3YZVk5LL57Lq59xuaYXrBftRPE9lc3gH9WInAQQAQIABgUCVu06SwAK +CRBrLBHdHrtGt5VLA/9RFUA0G4MTvetZyCI6UbhLEd3nohGjB+yS+GZGqYelM2FNo+uy8ggv +10V0nGNl6JtFURGrtaF7jZxKw+FoCfQloJ3LSbU8mRoT4FAYorCJrVNfMviI+FjRcbrXR6C3 +88hEFaJ3E9elJMUBasaT1h2KO6koyPgOIPoMXeS49Pxg4YicBBABAgAGBQJW7TpPAAoJEJsw +JIIvg2eRWDMD/jAyKsZDDFklZ9PZAPtmG2u8P9eR29uEsEKrqlb2o5mBQReCHnjOIh6MGxGm +azEhG+/0AW6+3sme35/SMhZ43TovxPPPV0QVwU3xX/HHXmmbsN6OHgUVg8cfP97VmxPPJRHN +vSromtBZNO1LyAoILXJerKqoiSWbRoewOQdC/l2ZiJwEEAECAAYFAlbtOlEACgkQCJksnO8Q +ueoVawP/SmjsF7I7Leq8oLDeEP0Oq9rcz1De8u2DPUzuCzgv7EtGaXsluBNU7IZ0i5GIvpHN ++aRPfs+pl2idfmKLzC0aUwYamZCskEwQwI2T+dcPWvw1eb/NZoXl9ljL0sR2jRWpfCOp/qTq +Be7YeihjK93HWHgzHn1p+1pcJJXB6ESWQYmInAQQAQIABgUCVu06UwAKCRBDAFgefjlZeOwa +A/9RmvEUZmg2YZtfd8GJlQp5TSZgMmAN0x4/4o9Tv8It6QWRQYMDhDGZPenjqf5WW5Offm2o +ADXWntBgPsk3v8nYG5VRGX399uP0BCAXw01N/ygKDxi48SrejRUY7MPnDXHWGbUdoxi6JJdN +sTq39wuIpU4RFeQ2rflQIp6a8Z5694icBBABAgAGBQJW7TpWAAoJEJtvHcGXL4u2auED/3Pq +AW1PCD3GrEhTGan8tZmYVumvIN12d7JqrddpaOwH0ddUYW7o9hucd/jO/kQG0j1GieCHw/Q/ +960sx1EHEg+eTYxqH8BH0KpnBQh4iBHKu6TKh3IcV3kNSuV/IdJrG29mC1/oSB/m0i20EbPv +1ro6ko+cjTUXLoITomPSLcE9iJwEEAECAAYFAlbtOlgACgkQvQdm/jzqurDtYgP7BM1GRkpT +wq6+JbSUSqvwIG5+rhB2KXDdxhvskQfMm1Sbyvpj+5oB8SB3FwAmniWR6ID6NyK2defJATjp +OfdytPmju/A9OZppCf40ys+wkku/ZyZMy5iYCM5Ai5DHKdBIYEEKxHWcf9VoarvlReYH0b9G ++QZV2ZxgipQZ2+ooXgWInAQQAQIABgUCVu06WgAKCRC/kJ9D9+xOWKgQA/9XIM1IOd4uaicY +8KOak/ujbDZ+EYxC/AoXe5vNFLe1foEbfRdZGSSbyzBFyx2iOAFUPkDnRTa04IcZJq1UlX11 +eBZBx94mn3w5UFj4OIuYHskQQ0NHY/lwLqLmklrrXWHWVN3Sb09OQ0N+AfR1VQo4d/AJi/SI +7v28LXYLTc66/4icBBABAgAGBQJW7TpdAAoJEEv2f6/rdW8fgAYEAJhSa7H7iF1+3N2pBXUt +lWYP8JFxG2GzaX6tCvEeLrv8gpKHxyxFp0s2/RggB7V5RyhlwAPy1Qn/JM2DBCn3YxO/31PE +iuGMiLuHJuByyTbq8OM75+hoMxXjY8w9kzj2dkOljeLzIv9bvRTClaRfCk65hHX34sOIhmT1 +90n4evAXiJwEEAECAAYFAlbtOl8ACgkQahHcetp/UFQK9gP/WsIjbgsQ2WiZXLF8a7GLDo5X +JC68scR4zl4ZrPj2laLsLNuwmAw09MnAbgDMPbfuo2o6pKRHi3lMY17s8BLdsgHuZLAqKyEB +IdF2uDU0B++8H/Trt9kkaojL5oVUlvWwHwaSo9q6NYYS7sJv31o+NdVmlO5IzeGOIdOVXMGd +ZbuInAQQAQIABgUCVu06YgAKCRCuyeShnW9hRE7dA/9vGzfWzoOZ3HvlLaAprtQfd3hl8MHG +Bx2WUQsVX8yUCypcYvwwsiqugrDlaexLNEe0Qxe3T8R6gG0+blSP1ecEwbtd7u05xa7OLLuT +1h9rksd1zXv9gr4Vnhp1H7z30mF0vqVsgGzWKV3OfGxsUxHR26ZT8oECFw/0n9iLVGaV44ic +BBABAgAGBQJW7TpkAAoJELyDTyR7/1Smd4QD/2qjZOTmxLSr4+OqIyey2vKymUNrQJ8vzPyg +qpM4WI3eK6WSciZCbSDi4p5gVtQuiByjBlDw5MppCUs38dFmbROeSeOwczPgNLx+A8GD82d2 +vo+pPF3EodIdcE0RB4bt1dI8v/k+0ljhYH+7mw//KfVfqJ3XsukeWOq3htaF4+PMiJwEEAEC +AAYFAlbtOmcACgkQ8UK8d5+QdycCZAP+OEgGTZY/FhvDbbgPn9owGzZ7rSmy+mu6ZzIo/hHw +opa66hvQVvIvwUfD19P8YsKXksmLcgu7fcLcB27/uxCt/NNAcw+Mlp/n9Rp2rUKrW3rts50y +TdyZCiJOuhlA6g1H+z+XFMxpFoDAeK9RHnbv2ehPBmgb16BEaOPQDgkho3iInAQQAQIABgUC +Vu06aQAKCRDI7tu0EBYQFHBNBADCehF4rwui3Wx8bWvm+76UhGkg46DqsdGfdNT0IFcDoF7O +qwVOTGMMdFWCkfI40AlF39/Dzo4NLHi/sIcpL2JblehK4FS8WUI5/3bwdow+F/h/5kIS5ZMm +liU8uxznuiBsQwHVnV1BF96bsECIQel6/rOsRXYW/dKG1rpWhdb+6oicBBABAgAGBQJW7Tpr +AAoJEJEo5kA92s1mCowD/ApY6ao005JGHnUxxCCN/0GjMPwNDQrSaBgGG89zDvjesdbEZ2sf +SCIIHKH1DItJOTF9RUjpr/UcmFrLugfwnJV2vmrH+NQFH0BzeC26X2DYIt6z2Mlv+yoBlkKU +kwUBLu1wm19TmSpFjNHr8Rabz8BCjczEmAkp8kdULM2MprDOiJwEEAECAAYFAlbtOm4ACgkQ +Ay1U3HwDN4iCTgP/fhFJVCnvHO0TMi4Jb7KyEX+eibxj0ZZuGBpX0CRXbOK5X4aHwzXFpD4t +jc0KS3tumZKcWU7DxNGOGchjrrjDcj1nY4rOZEQ7JfaJ61tVA2Wra6iMe7mMDZtELaF/SsAL +gXZiUww3qZQ24UU9COmuSTJqvWfzptGaT/9xUOgNLdGInAQQAQIABgUCVu06cAAKCRBMoYam +xm1ho75GA/0TTApPeMoCGXEQjj/r6+ePMDjx5qvcNgqgj8aI5tl7AJzLFc0Txm6dPX+X0Esr +jF+DG/mOjiCNVChTzL4tYtCHP8FOR2PisBl/+ym9C/YWayklziBkVlDMeJObQfCH9ddKpm4/ +Gg7SKsTAZJlttI+GOXXGndOjN5q1HAP3tpLxrIicBBABAgAGBQJW7TpyAAoJELZmWkoHfUB/ +Ds8D/1wcDq8OpONNeqDPNjEEG5gbVgbsbkwz7qrhWqoNa4vXtLLEjBc1bxR1K2TNaKFB6f5A +gUye+Ic40StyBL8e/u3F/XOaLF5+f6SJOhW/qly9LdHDTbWn0K4BgapCsEP8tEqZd8M+lvMi +xivHcQN08A4/8wy1Kmp0+tHj9ap5TSAwiJwEEAECAAYFAlbtOnQACgkQS7KTQsnTkIhtpgQA +hL6ynEeMDPBsyFhvXCE1dw+yxGobSIca5fpkSXO6T3c00aU3SqzB1pCorDh1xnygct3EOi3A +0FxutcCdCkosoPwdHs36kVU1bWe6VCQbpN/5l77wHHLpuUYTri5Eq4tqiPq8FvL0afudDpcg +8VDtdck0FijRFOIKEnIU7evPwdeInAQQAQIABgUCVu06dwAKCRC7/byNnz/VVQYDA/48yb7V +3EXQIqT5bbzqKUjf5E+saVuZyQNkJ+Ex1yhO/SYKVdrT72tgDmd3EVkkwc2cpT/KF6IhshqX +niKGer1RFhGqsB2Br85q9TlQuaZZs/5CIzqdd3+3onnMYNXtvWj/bcovBXkv0VtWVK3S5qSs +LwKGr/t3HMlz9GvAwlMW4IicBBABAgAGBQJW7Tp5AAoJEGBaFPxwao7xF2UD+gJZQis4jUKR +ObpXNb6pR4Hd8xIXUEsUfYahH+pnh/+w/TMLDwtcQ71EA/akkxmrI4jht537a24bZ33g5YiV +d5uTqi2y1CpFrw2TdlsPEOIWwRCoRL6FYAvh+cGYoqH72kylEGIipweJGklYw+9+LBQ9tP6L +YUsjmMNGq8CkMElwiJwEEAECAAYFAlbtOnsACgkQVRyntPWUGqiBPAQAi3dn3bhyD8EePbOx +NVYSgQvx7ahB0Te7zrP8BZgFnUWilI9f+42jl/Dg0gJSI5bjVjj4kv7rUAOuVzH8mmGeGv5w +o4aWeLYVayuKrKgf8T8M5AJD+D+JwISTN/DxBdWUuO0Rt6Vno/9QUC7CWIfM+yWqSLOjmpCT +Hekt7RjYdvCInAQQAQIABgUCVu06fgAKCRDRjxYrS5kxAnYiA/4m8KHnzs/dJLz+QNOJYBz3 +8fuHZ2XSa21n1FT/+wAmypB2VpaU++9dYN9orEe3LGVTh09Paeb3eTaw/lhCWvQc8jhJtw3o +jCEvTW5TvO+wo3gV7rWaVchOr3OIUFiXp7QHPIZzXmhxK/3MhmyybWjyZTZ/pk1y6V6G6QaX +ioYYBIicBBABAgAGBQJW7TqAAAoJEExyswoS76FJ+vED/iFAgisEJ4h+OklvPXujVeOS9qJ+ +NVoshUsprfa+dPnxDHxZh5FSfwQtNtC/fxNkwS0g2CPynM0rWv2VkC/6YrQT6ZlToQwg1yDU +xKXqpbY2+g0Bk0VKj3qFGpbXRA3cxquXK+O0llrl+qLY9WP/m/bQExWdrTIpXne7dXVXAVi3 +iJwEEAECAAYFAlbtOoMACgkQcxFq0TgGIp5KPAP/WN+ft/T0V9vTYWbK2RaHXkV/JQcpVVWm +7ZTxOF0qMJ341pAp2dh02QNdBWisPal/5L7o/OlFApqoQL8gpZCCIc+Dqqb1E2sjGphF/KYO +1IppR4lQcPqxwMqLJorAdMXQXRHOdjxSfaYoNO8IzLyoSoOILL32GPM53PQsvi6uRseInAQQ +AQIABgUCVu06hgAKCRBIAWm5oY6wdwFuA/9P7AQfmtPAbmR5jZu3vO6xoht53rT6IYjlLUyV +GyKDNPs4yebu5ssiVoSvqkMesCL3Zj0lbucOBBqBpy8Sdgph/Y2R8txqUa1wqLiU4zrItvmR +anN/6kTIaMx+SBbZ4uBgsp9wu5gfnQJfw36EF+MSYUMAM6um61UY8hrtD+GvwYicBBABAgAG +BQJW7TqJAAoJENlTH2kzxXRxLGsD/2wtQCZ833YXoIHRvUPfuQNaVI7Ui6ZJSENFuMYCIE9e +ZUy79k4Wsi6GiyZodzWxsKHuQmazzoaR5WlcAvuzcyW+OV9HAB7+wGROg2M/6puZh58ILQLb +zn55Ylsr1mKsK8Nl5vRpjfGDzuRlQG4e7BdS8lPqyyjJ/GFHYY45VA2XiJwEEAECAAYFAlbt +OosACgkQ8cFHSfXZ2UZsfgP/bTjeM5f6sKgzthQsUIPS8TmmjiuQCSIL+Bff9BnmiolSNOzt +rcgp1EDbM5T/ak0fi79jBypEJXeDfYBjsUUOMDQ2RWfOmcL62gzMxc8mFeYNTgvjfaBPw8WF +lKd9Oh8adRpBwg9wt9+jrC8tgWcoNwJgLxYR7lvcpHB7B5lhaCqInAQQAQIABgUCVu06jgAK +CRA4GNCL4xh3Tk1HA/9Us90Ef8CGMRP0hLAQS9MkXL4ytACZ4qJ9mH0vuzbmtAAMbleEE15e +DJXqWimrcrW96k3LpDHBkYIokNd0Q9M+jWbf+jw3ng5p8BCt6wmOlQaKHTkqcXKUhYzWvxzl +i17HzfPXxl1eKF3K7naniQ6c0M8OWo4pgO1bM0q0Y/2NPIicBBABAgAGBQJW7TqRAAoJEJwh +V7gJC2AV5kwD+wbIVYItxRFPGHJTNvup+BkkBZ+XYwq6opfQEJNpUbwfIZGYWggG2y/H2lfr +h5vRPAldeIDRrxanPR01le3zQvbcCMGt65X32p6UNxoS2O41KpzMdFWT+2Y883i6PSQf0+QM +r54D+i2/Xez2dxz9n///8suebNBS4sZexSizgU/ZiJwEEAECAAYFAlbtOpQACgkQpX6185Iz +c7yMqQP/eZU45x8PQL1K6mythiUVYB6EQtwe0daF3BSbBiQJB6qZOmq5bYXyuEIDwohoZDrV +9+hfo61bC6TGL8JiKU2dgokvRYr/bur6kwYGcUbJWSNNbEV3vm2zncWKJ0t8IhSbr/FSPXAs +B9HLxB80eS/WS+I9udozQk6+6ZANZ59+pKaInAQQAQIABgUCVu06lgAKCRAtXO+S1/NL2Zin +BACt9h9you80RS041rwPPFFiRgNow0Rkoj+mFsKn3n4KFR1T2veowL0/d3Sxjbm74/H+enkU +jRM8EXyAvU3RS5JzlhwWHOrMmSr5HsAKFiJxVcBm3RrBVfMlbvjKYSkJgBSUH13nceROwoVJ +AQhVOVcpzbP9xpg/XTFjwQTeZaeHZoicBBABAgAGBQJW7TqYAAoJEJyIBI8lee2+L0wEAJEj +I8kkhWJu53wnfiABJ6Ng/W4CS/cLxvg/OLHd4+VpvLgNg8KDETtQ2v0jrPyNXo+NAt3u1VsS +OYILi6fyEfkIxrU0i7eb0XgLw9+2rpZh+5Kk7Yv55PAKaqP0MMtcLykUuiVNdzZMHGrUxU0a +d3KnvhRkd5MM3W16fkEQR2DyiJwEEAECAAYFAlbtOpsACgkQ/LV4QtZQFL1hBwP/RlfgL9lS +J/oEEl8HFh22t1N/tMwHzTbXZSVOcy/wbLmDugnZkRtinH2HXN/AHPalT/Z3QzfAVGJ7mVRc +HQO+r+/F7Ew964wiEW7j/wIVUJZdfMiZrQ2BW9wnj8tA6EfZHjzZto5sUk4c7njYymdqERsM +fnL5UKpvCWQaFARSwCWInAQQAQIABgUCVu06ngAKCRDCsxSn+iO+633ZA/9i+JwItTowX14d +tHmfxQNlsscOeYQT+6QvFqCe33eYS2MLCYbMT0DI9B/cuVsH+xB4gl+HvPwDBTM930vqoGZ2 +RAtIZfRfqS6obhwHDno9ySeYaenMEBeG2qsIH0vSncBoE2ugWBT8eH/aac8IU7xmaltOQRHQ +/l+Yqd5KtPyXS4icBBABAgAGBQJW7TqjAAoJEEnHXVxXMlnMxqgD/jgZ5EoV6R1eSXIn43lT +97XWKDdhKJ8gqlR+VeW6kya7Otxn0ZCHZvUoQM5rj+fUPtD/Ud0ZKMsmsb/ekOvphwxYaIpm +evvPWLS+onsoZSgXoDOtIE7HdNSOaD3Q5iRjsaPhPtIQsVOPsmtbTX1sTQbwfRwzdjFUCZfP +bzIqKCy3iJwEEAECAAYFAlbtOqUACgkQwN8p3sc9KvG3+QP/U3EtWWlsQQ6p9Iv1pG9upmYm +dbKwrbVsT2rA9AcuYix+spRXss13JH3+h7uOm7TpmNpD1XI/Onwbr84HCrcODeVekSkW8tU6 +8O/yAWsoic9yHQB9Dyam1BiAKBi4kujsf6vWkjC9iqDryIOYMU1l+VUygCYWYJvjqUx4t/L/ +DzKInAQQAQIABgUCVu06pwAKCRBIrp1Wgmk9THHMA/wL05HS8Xz/Ht4UYfOSPGyiqBWG3jPP +PbhsDGhuzBJv8ODgRQnKaySszdgBCLxH79cU/3spBCBLkBvinsa3a3OEATcPJCdH4bGGpr0a +V7kmN7BlI6UNBg+ICFxAtzg+XflUWwdlmdtRbegzr7x1c0yFto2U1iWBpgJt3LWXwcLvCYic +BBABAgAGBQJW7TqqAAoJEDgjgetOhi8/l8YEAKUr/UMIOeNYzch99IIcmyND6te/ZxNAU2uB +jVWXHe8iodp0szX8KSmjtcIVRpTmbWB/gbYd4SuY1fqUZ8vnKUdBF42Rota8hgAWC7xE+4mP +i65GaAVVodHMfZpJEd3Ro4lzDwFHNKsQdPNFJYWXVpRamnKilRxTBymg2Xc1KhEbiJwEEAEC +AAYFAlbtOqwACgkQgrlg6kLZvliVCAQA2eANg2vYL0ZMcya1wyCDAmiaKtM4B9vX29HqNnPi +wKxH+v854ZU/jIe6glifePSLN1hXJKq/jpsaqVWCaUXJcVPAZ2r/oJwlZiHFsEs3LX9Zt1ON +ah9db9jJb75AsQFv9b+n9Q3uwTduwh3oihQaVKL8+HFaS6nofSn/PNun1hiInAQQAQIABgUC +Vu06rgAKCRDm1DjgTCXOW8ulA/42bMtw6gag+9LwS73KtIZePCCBSSE6HKCdqgp6IpeMuZKO +8efDu+TdcJdrIBC/btxTvZSeb2fBZU0vIzBbWrr5VR6P8YPIuVyWzol4FC+20S4OfVZNJZDp +TetyKv9wCSVfsyvI4SU7r82V8KTIuCDCA+GA/sANKKjEuGRz7P7eEIicBBABAgAGBQJW7Tqw +AAoJEND/jC/BMGPAYyoD+wRPKscxOCi/2SAhYD/tclwUfDbgvA7VDgwSp6wxCYLLwm827Z2z +mwpNuhj+YjXipaxi8kdXnq/4GP/6BV5E4fdOFXnrGLbdMd4CPg4RH4OxqnPOSD7bJFf2cFDt +lZNBQB80upKT0MqUnGmqYRme0n68mF99yox1uk63rB3mhZzziJwEEAECAAYFAlbtOrMACgkQ +1s7L2CYosKHLEgP/XMQYCLHtmHweGaFXTjiwUlLrtMITSql90xjDcof8706MFu3t6IKHAcrk +W9XyQSOU+Iw65UTeV1Pk728lyCxrT9oxmttdttYrnA0ZCA2qLpO0aFyikh79ZGC1xTzZcImm +vIshOUFuqU9Q1x0f+3uElR1NsQQkm7VGh/z4rf9rxyCInAQQAQIABgUCVu06tQAKCRDAwBEI +VnacbFtVA/9q6TjfKvw8fRPgjaBTD1KUXXDkPiTqF8CEpjHBWg5a5l2GUc08dEaBmk5Mbz6Q +6mXlU20jUJQSWHql01wUAcjoK70seedhLZ89NQ5HxFi4gnffPymGg+EsYFzuVSpeQqYlOHFr +1KQa14ZQhNRXYdtHpls+zAfwnQRnJwY66mZCF4icBBABAgAGBQJW7Tq3AAoJEGXcTBDkjohy +2bAD/RlDxlj7pxZ2yjXpl/8/yYoK4b8qPROkHXRLNZVIrROKhIk9frGlVQQIfxn8QfdM7wZg +A9y55sdsK6jBfd/ge2DB+DOJQtu8p2Wi6Ui4T2XC0AZNrTCEpfNweHWM3akcp+8pEEPPrwYm +KMoLEF7mDb4Wt3VwPLqJ8iW6JPDkFFAfiJwEEAECAAYFAlbtOroACgkQfZDir2q5e6mtegP/ +X4zD0ofS4qqVqq31aDFFS2Nr1POMWg7cxCcGFXCWGly3nmuJr0j2pNmvG5w59yjOpnBB6WJb +uuJPyC+Xm0i+zd7USh9R/h223SJ+qpsavxcEs8mY7VHrjYMeEWeqPDkEM0AJKA6ezs2bAZUZ +rSbGzs65V2WVf7tZ3JLw2WMy6ZyInAQQAQIABgUCVu06vAAKCRCXjvvLptYtj31IA/936y4n +FQbL6aPCdEg0MCb0dRo2j0GVh7E3OFURqs1dUYihUhUZ+eHR8SANvKu8woGxBSvHa6hE9a8n +amdYu+qEuAgZphESheDgBDwwZ2WuK3NXhHhzUt6Li47ZtahxdlgSsUdzgoFKpBIQ6iguqDqU +IcTJC44VXQM7C3/OFzd2xoicBBABAgAGBQJW7Tq+AAoJEEL843cqBlIU0V4EAJJUY36kAf3+ +D9sjRHrv266TliqfY9+iCLrvxdwv3zcgH3e7lWzveG3YMHhxDOI4NNHvKUhZF/bH4erI0/tK +b1/qGgbzEPiqwFnmFcfwfJH/CPSPc83Ece3ltNzzWug27FYP8iJ4aX2tcye6otMjzBR6GmDa +Q7C63hdA297tUm+ziJwEEAECAAYFAlbtOsAACgkQ+MoUFmuLxYTusQP9FyCljh4kD8FLBVvi +gnoCaBLtpMbPLSNMhypceQ16vB611eV9DoeEKWGype1lQPVY1M++q06xxplYsEsbs0PYDnbx +5qTj5zDR+FruS+xZUZD6/zykJW5NIfXLsH4r7oCCQ42DxVXlqUeJ09djHaUmoPOp7N8+CYR1 +fb3QG5X6VyqInAQQAQIABgUCVu06wwAKCRCfol+g+Ad+yrKVBACNTRqUwNul4lQn7JRPG2WP +Xmxr/4faf3OhHxgtoN3dnSOPkIPfiPD/etgT1rJk+2kTYD9bBXuD2+4Mib3N+xkt4OitE1yt +9HTY1+OsFkrPAqZN1OYJUhxhQ3n8Mxsy8BH6WdhqmMm19nRt0VPD1ZBvKYhnGzsO6PuzI2BB +rY2EP4icBBABAgAGBQJW7TrFAAoJEGAzy3cgQR/4FwUEAMbbF1aY6JPYXYmjcyj5grqf0Ggg +3XVUexb3fHUJe/t3e60Hrgt9JwqetS0uWGk7MxmeS73a+kVDVToPPreSof+WBHrbcWXQ+TC0 +/BRjK9SyyyNcQ2ihQby+tdzQUrC/nmLErueZXbXfktgEBeADOxprfZ/5p4J/sPML1cNI49Jq +iJwEEAECAAYFAlbtOscACgkQweWlldwl966OfQP/eecEg0TpEUM/EhZuQKZZqgm7HWA+w41W +usszm0ODcfZxyrQasNlEBgE5QJjVqiS4n56Xjdpwj89LaVl7rzA6G9cDnHWDOYUQ+20nrkwQ +4b6Pepwg5v4lkrJx/Y2ej0pdLAixBkZcqzZLjQA+FsF+vzCcyvcTuUZ9g0tyFOLo4luInAQQ +AQIABgUCVu06ygAKCRDwhs++UwIYSv0bBACktScJ7egLymWa4Sx/IphESEXLv4aJOC2Onc4V +L1bLZEHrNkh9jyboq4BiECmyz3G6mSyt+SNTJOmBCUR4u68WSL9yPB4zS5mOiooWJNBy8Z5F +OWGr+Bbhx4n/lP8jp2RrFK7uOeEBylWKrZXIm+Ph2frvaO7L+0xjCFMzaXpxZoicBBABAgAG +BQJW7TrMAAoJECN+153RMIkNC+QD/0g/vNfnEUapIUMpo09pw/LxkIPBn9cEe7ivySP1KYQR +B6i2tY0SJyq754SA3KMulgmm/ZeEIFmHIfn+eJDi5UcJ8Koq5HA+hdPXohMOg809pMeWe91c +6M0+0qnU0TA2b4V0sYjX3IfI6ASifMrwW4BX5OadhuG2DwiSL9t/TrNMiJwEEAECAAYFAlbt +Os4ACgkQXJ2Wr+GmvoytCgP/cTqr+EdoeccmYPpet9GVwQb4BEaVmoLAgNhy/RUtx6P5Avqe +rx7ojR2JnO3Jx5iyVvXxofhc/DVFCYq5fArDwvZzcvi/Wm2SbxwgFaztucxpOXYxBuafBnwe +Xv3x1YFLtvfujx4NtXCMcNqQdfXR8KEelSPyTNn4SujnkvSQhG6InAQQAQIABgUCVu060QAK +CRCvaSUK0M4+tbvHA/9oorvlT58UJo0r+dNYPx83xetKOwoTNdgLr87uncgwkDsxR58mzP4g +We641qGSQA/RE5AnhFtbVWE4tsKXaSHN45wRV+aphoGtRl08IgZp/4epxUD6PjfCNkhYbKVK +5h8uy2Gp9vNH9xowPtg6+Mwvh/uPKdWB7bd/9oUOtX8M9YicBBABAgAGBQJW7TrTAAoJED7z +v5ds05YgGgwD/AujfO24Rr2xRj+/D1ykyafoELEozmJZ7EuU9UwUG1hQjCAh1TKfDnihmO7K +95ObCO+55Dt9yKjRZDp++zhUEl5TvEOBnUWhEYcLJwlGsF+zsyBQFC9XV5Y7ypGdRB4r5aLQ ++GgOuSI9x5X+Fngrxhoe8KqxazcOuLHH0q5OpNSWiJwEEAECAAYFAlbtOtYACgkQp+Zhov5i +XPP2BgP9ERd4PctrRRbZsxrssPYFWXVM5+7zx1Ceue3busd7Tto3X19nuXdetxwpBFmgNeTi +wpkOX1vb8nrTOrRqdH1pH4yw783q8Gp/foeKu51RfV+Y/or6dC3RQ2doGdP9KEvRLvBtMbnm +SPGFON1GF9jAWG7xZkzjpP4CoGCa1s9AtZSInAQQAQIABgUCVu062AAKCRAWR0nu4xzLGyW5 +A/4gmsylTr9SmQNoars9aL9qGTZ4FRnTC4HmL6/Psz9CXm7f6j0KDnXSbQOLHHf67i3gE/dC +f8GTAqt0xl7eUON8FtU+ehinGYJBKHQh9xzcq9FDi3rohuyysq4jvo84QE4fc6rBz4Y0i7ss +q4lHuO6cIHPYbayv39XupOF1R3DMYoicBBABAgAGBQJW7TraAAoJEC39o/7IS9BdVLAD/2Ky +7BTAXoBwtz3fYvnONkOXSN2QXPeMT08UTR9rXW5AuanIzcOG9jpzyLHBVJdIXp3eaAgA0y8H +MHAEO7Rbtn9UIQ0C4BVQ99CAFbur4Tr+kWmGsRqwwI9yoAQlLOEK0KGqtMLpkK4ZKfV9Hy8Z +xPyWdU0FDdtZ/D/Vx5Eax3pfiJwEEAECAAYFAlbtOtwACgkQys/TbcXgYwSjtgQAhst76w9f +aOZxqpgoyVLs85BaK/kteyjg5ZekQLZntOqYfVEiBVubuMF2a5BMcy2IoGQCmQgy7o9YUKMc +a7Qwtpd6/h4TOn9ppxQSIpVFVjG9iFhlAVlFmjMhaEluU7Usswpk0hj+qZnEX82ChnOFK7l+ +BD/VkW6p+r+J25mMBQ2InAQQAQIABgUCVu063wAKCRBiL2ixV4p7+KvvBACrFz99nkl8vk9R +Nv4LFO85VP2b+GpXRcr9bGDk8lBYYuVQ3txion34wr3BU75O1MObCHB4osYjOWatoA20p8ns +8LIRBpwNbRecVE+m1dzV25Ytq5XYv2oWjghTr2m54GmZBnZP/9NyntrE4oYax39fmI6n4C6U +PwGES0fSMA56sIicBBABAgAGBQJW7TrhAAoJEJxycxAubktvEk4D/2N7kEWdRXZgZyawwppP +RmSOu6+F7pn78GuzAdEdyzzHURP02Zj//LhFXBjzI2ddtx6MLrMPPe2sLT2QBZzkktfMtkEG +WlSas5vXgP1qoTInEDUYG4bJCqMK9jiTXvfPiCZudjT+5Hcg8hbtpJCg7Z5iGjQVhynt/KWQ +m2pnsF/TiJwEEAECAAYFAlbtOuQACgkQINZM4DnbZ92etQP/f8nLVkhJRu259PbwhYoZav3p +aLLOmPs/sVBlC1iLaOefWRHlrjOREJuJ/cE9iQS0wPIiVrqmEm2J8HKgQqCW0+xDUgz0SCWT +VTwPTj3gzSJtXjw29eE8dj1Lubg1GufPtsOt7bk6sg6ZRv3/vPYLDmpk3K/s5gKW/cg+Syd/ +sKeInAQQAQIABgUCVu065gAKCRBe1BL9OxH9340KA/47ma0F8nnK2YbkDh4GRHBvdzfE9wtC +7FKNZ3b+PelEXl/LyT5qYtctlaUtTtrmlzaBeeSiQsbglIi97qMmvmmzF5ffTqJAX1Au1jZg +3JwmL4quBG6OQ3GRBuLILf2atvp7atHabDXmj/n9yjUGtCyzxEHculFI9ucypOR7OdiCNYic +BBABAgAGBQJW7TroAAoJEAScoLtFaLo425ID/04/lS/lbFPiwMso2kLtGJPQkUjKWpUWszjg +NzM1c/d+yU6Cbi2KMwaqLZQCnn+ZkzOjrsuV1Jkmdoo+Xme/xwL5crBcVY5CbbIpkvetqGsB +E9ACT/fL+q3G5JK10CA7IAYSfbCP7SikN9oQWw0a+m/Zo1IPLNXVc+8Vv3Rn4/c5iJwEEAEC +AAYFAlbtOusACgkQ/+TKvhlfauMUwgQAgP3HH7YmysbC7irDYhwGaAwopwiKelnE55iYTZ5e +74nKXFagejlQcyeiwh2+Ds8bVZULq0w3qvlUh7ss/6MaAVpZ4XzOvLyOMicxj1p6te8C9Uv7 +cI3RytvN1u+DAool8bVtzTGxc7/6mK1cqYEYEvV5kLTFKL3iSzbTMu6h50GInAQQAQIABgUC +Vu067QAKCRC2l6YznBhHomq1A/9nA0H1J1YqF+1OJ+ArEQTgayTz7r2+o4ZJK3rVSa9ObArr +K3ZjfJ16yfL6YVMiN1cZ8yS+KxS63G2l6EO9SLn6cRgKqB9vX1Lzq7zYj7DAT1oo4/YzBRJN ++k4TNestHHzLsx3wyKoZSTQzFiLgnXdKNVRj2PEnbZmW0A7KDrb2qYicBBABAgAGBQJW7Trv +AAoJEFEIMAq/AHH/gxMEAIYrQ89O3x8eJ75jX6bHFyYPN2/6CDvQQZGlqdZxG9ECsFQnS5Zv +XmINCnNxIx7GzSGgWkpNZ+yskJy7dX0Ito9pNFRZs2N/cqF0hxWMqaz4+KjeSEQNRF94c/k+ +LDJz2kEWjxNVtylvtDUPnfht3ZFt7qvd57eMlU97TozmvG5DiJwEEAECAAYFAlbtOvIACgkQ +DokBbdOOuM8swgP/at127V5qQp025ryaB54AnXDAyTr1tY+APWrEeMCEMfN9Otd068CzmkNe +/WzTpurlnXDOx259EZKoOBhLR+1GGgdKGfRHB1ptJjncMOwze8Gg5H4LzxsImt+TD5cXbVRJ +m6FkYiPozTNJdRYyKwTVMDYyk+iuQlRQlylgdz5W9DyInAQQAQIABgUCVu069AAKCRCWH2rG +4o6DNVE6BACM7f5VsLnUIu13zyVFkNLUzenALeASszZN/bXrdPTdkybmHM5ukoZSMDgT+vy7 +2OZOb+yfM3vpVBd415UJf2vYfSLCyVdEKZYCNItFLdNJSE6JUiMQ4hg0gSzP0FYtct/8dnL5 +zNQ7mk9AT/H6ZGAgXb/GrRjgy9MRHYIqe7WOVIicBBABAgAGBQJW7Tr2AAoJEHKRpMqkgQlG +ZVoEAKq3EMKFW2+GCFMHsbYFGsHcGQw6bI5FS4AHjN4n3mb+5h9WQL73rp4Is/BTfxgWcgUG +Fh0yHlSqs2t7RlfOGU2cNwfgx+OiGgBddfGBFOyceWtq+uDeYkeZtXnjG9bG5oIVXFJ1oEjc +T1Juw3VfOZcbduf5QuJOFEY5ok8SJm1eiJwEEAECAAYFAlbtOvkACgkQPggvC8fNpLTGPAQA +lhlQ7xkUGQM453s3Jcc5lVCAFzNMfQCtzlhZWqs7U1spj8inFzIuGOdCiZUZAxjI/fI7LhiH +sEm6744qmgMmAl6q/nlulGpBKAqnRueI9Cf9AWNJSHLimpmhxsdvOwPOadLFdDEJKeFKGCeG +RAQqwljwQCo8iYDsCF3cHk720lqInAQQAQIABgUCVu06+wAKCRDZSUd/bJljTHqMA/9d2FIL +niAfEYlBGNWQcV93A1+ov1D+88naIrUCJTevJEHV6IfRtb6V42Cw4t4TIabWYpVNYjZS31Zc +gIZzgj9u1SBxx2xlxZVqmR3H2w33j6Q+U5O0ZQFH5H/Iti8wm9WONw4JIP2dTh99qN5Qg4vd +O1BMDEob1nOkLPV+67kCOoicBBABAgAGBQJW7Tr+AAoJENFinvMjtdXeZDMEAKAqUWlLjRya +KprpVptSms7G6twQ5MM7HLdf33/afSzsvi8eSnHvCWAjNP9qNqPoTipjqBkM9IQjpeZ6zkTU +pHGk0ETYb/o9EIn7ZtsggCFWHMQUU9Xo77tUabm4jOVAwdqzAfx8OPdesYNcU4imI4mp+HwY +EOEIgJm/RUnIku0piJwEEAECAAYFAlbtOwAACgkQcaOMKvesQdQvZQP8Cyb4l4Ap5WGg4jOo +SSrwL77oaOKlcB4rnxMJ1NTQDkchFWGqLhkr6+F0CdBZqQDHc5J/EcwDVYZw5HNbAiJQnLzc +1OXqp0j2oPf4QIAVeVbr9ep6t5Hb6ClrRYYjpkRSBStn0Tdx0XXzzdCd+bIBnkavFrSehvsk +1NyuXhHZeo2InAQQAQIABgUCVu07AwAKCRCZhFDnF2sM/9FVA/sGwwJQ9kpXtWMBTKA9EJag +tkesEeTwlEslKRAjnxqoPRQkvlTRsHgCLfn07lQ5X11y1vcZ085jEqERP8TOeg571B37W9tA +yRhfrnvnl6PUDz+/PVotyf7uj7Bbv9cAIwrbyKX0UsFNITNLXCWVV/lON3MvfiHmvNSVZ7Ao +pWeRXIicBBABAgAGBQJW7TsFAAoJEIDdMAnw4lyu5tUD/iOxvkHJSFt8T+/8DeM3TgWwjEHY +KtXDkmUTPu5YaDUKOrisnna8g0S9S2CxlGBOvzqYAZFBEtV7R3xKgickhAKWYMjX0g8u1eY7 +73KaB+CnhEEZ6xpWwkQxVwG+roDaLktlSFtyUEYjLv8b/4+QI1Kb+KXZP9i2iNa/HxqUnJkO +iJwEEAECAAYFAlbtOwgACgkQJQxNSUdwQxugQQP8Dw9Dh7OARGcgCYIK78dv4SqM5N11eFat +BxDj6JUXi8HCINvH+ryOG37PIeQYWXfeU7QnckMKbrjGLxXcMeWbhiY/1ev1pqX1KKVngdA1 +s6dmDO1Dl/iLD1LpmxtTaYTparQimkOTEBIJQF/osKhbGekZqvd0w7xHwBt5pTRwkAGInAQQ +AQIABgUCVu07CgAKCRA4UX3G4wIWb5VmBACVs5dt9vQi557d+LssnP6qI7XvZvDJyvChCp2f +wwCtJoMd4eQ+1lQo24GXPkFQzJwig4RkdDyUxYuuto6I/LVgbMJFdj7SFd4kcWD3Zy4wnw0r +Hvl2XnWsM+3Ow2kU6BR5aQ2RE8g5wMLmIjxgr0kZK2mRsKu3cNBlMn3eX5S3moicBBABAgAG +BQJW7TsNAAoJEO6+jVFrPqeZyLkEAMOpzJjr1wHHQkEzDPuB4HIBqQrbyTQhpuuL+lWPp70z +6OwQjXGyR+iCf/jcwo0qkqAGuae8NiSdU5Dee9dWW6IfFhbelN0zH2SoDwxQDpTd3Q2nEOdo +wvFq7Ewu0l9nQxsoU7AyB01gMQKDMyv+GdjS3r65AwgIXHnDAznEw03XiJwEEAECAAYFAlbt +Ow8ACgkQUStki3ilVY/MWAQAjp9QiLTx0cGAsV7qjNap5yj8GUS56xICapzNwoUm/7ShgX7p +SwWnP/VwzCSxoE32hsqP3NY8+srci7fwVnU1rRlNTdQTHpFHSUmkZWidInNzxYEdDfrNEgPC +lpS0k46bupawjCD72Y9131OZ6mojWOOReM5HiT70vLQxWK5uubuInAQQAQIABgUCVu07EQAK +CRA894RvwlCZB6mHA/sGwJGUjjjioLkU5HYNHxWL3l8z6MMW4om0xwuQzD/e5EQPXPk0a5dt +ExMF2KxOhbnZEZgNfn1R+Otc94v4snUGCBmLnR3i00WYv76U9HFr9Pe3gTOFipYiuTyWTBAy +RMpFZYR/F5fMVyw8HTLod3Y+Ci26DY3jRp/wxBxKePX/ToicBBABAgAGBQJW7TsWAAoJEGYS +Cp9XlxvL3BgEAMZlpDJd1GbdP6szcrdufJAkcuGdcDZ1FfT8npsdM62xUM90BnkHDhaN/jpM +OtavA4OmjwLgTHxI5S5qaQp8w7Q7Z68eAYYBjbtsEnsZSMwPpjIzgDNBYuJtls5dbtIEtquG +/JADYSTO3TGOxyZ1L+8CQUPKj+TGWTo0iZyik6LFiJwEEAECAAYFAlbtOxkACgkQ1yEnnW8B +93do2AQAop6AiIsl52uuAetCFjbZfO4YAMMWFsW0l/VrJrQEWjSJFIlIEfemrf/silQn+AkK +X8KW4DUq10a2Ax5azRUl33mXJDoOz9oDBuQ9MYH3xN8RJRj8Odu7QMBsm5U5X3PqesiXS3sI +98B0l/E4JSlqBH2/ETWcAeol5qp+rNlL8jaInAQQAQIABgUCVu07GwAKCRC60qfFYFuP/+6d +A/4uzXXy+OLbYv7q2uymW+mkiRcO6QpEhwtH885q2Msjoje379DND/AW+CuKaxqSI+25noNQ +6or2x7WeRX5lOp+Y9W879NFs33qTKq0euoZ9MorLIduToZXW9NiSLUwKz3aWJXiQXNEgfVVN +RBJuxqB/hHbDg/mSZf4yWFdlYM72mIicBBABAgAGBQJW7TseAAoJELIZ2hYJUM52EhUD/2oq +JIJOfaHtoC+r7gChAlnSVsawC756s9Ye5BSrlaR/nYVphQ/o4tBIlQ0ptGWthRPGUpKDVW1L +UuenioiMeflRSHOavn28z2Q16o631SuGmgAFPfL8BLRiVtD98kHxh6EqbhvgyoucQlAAvMu5 +I8eqeVgBBHj0OzIDEXh0wxHBiJwEEAECAAYFAlbtOyAACgkQBRYXE7ObryhILAP8Cyq6UqOM +Tr7ttFcjRPPlnmwNWk2IVkH0PE9RsBVzx4bpplZH/AG/TkvKYJJLPUsFPbtelDFQMjfqOR6d +2En62wx5dyBo74rljlDCrLt25KDKyGJWcs5H+n9W85kQ/usV7wrbU+ufffmLwtH1jOQw7+U7 +yy9vOAxi3uj0bnYNaFeInAQQAQIABgUCVu07IwAKCRC4ks+Hd/XuU10hBACJg6PyzSUeUP2D +A8LqLW6OIJ1s6RX5lh7w50sxLbhMn7uZnFln9AUK4pqCURhkffqBWxdXtyTaDlJ8ymSNxNku +SAnj2bmJtrsEaIJ6skCrlluVbvBCrjCEmDZ11CTqL0NVW4kOlQvyK8xg2AltMF/DnJz7/13W +cTjfZn1GltEBWoicBBABAgAGBQJW7TslAAoJENTLBqdP4xPhEWQD/RwFI4ng9oTSU1xRg6Fh +cSXoXKw8e+KQSP9dMZ0cbQBoPWlvUF648GJqGZ4Ljx9UQuYrYtml2xRwxfGPiLgmeBPVvYic +aAOFbi8usd37KUmR/aExKIyjQL9Bwuzfg8SEW4KFFwS20HqW6HrWc7CCmZtMG6ish9sBN/bf +3NZmazCqiJwEEAECAAYFAlbtOycACgkQmSr6rha4U555owP+PDPK4Gp5AEALtVfFW449R2EX +foLUEJ7ns5FKdZi9FZ3ivXNBtm4cBfPSCAY1i388rrISXHHqTYKFLYMfCTY4wwjMVtfFnen9 +XqYjFfRsmUDg3uJnFaZdwmTzrZ9gakve7YdUEC21crXk/YiBHfSWgsTSQAUlcSRuB57pQYAq +7CeInAQQAQIABgUCVu07KgAKCRBfml1s+aHrEXfnA/9QoyQUSjaI78Y6lJIV2cg7IeTvK0Dh +VTGBDkgxFAbKVj9iIW8o/E4G4FeajWWDC6BnnhUu1pEQas+TEkppuE9tyre950/NR3POJ58I +PH1HDHdIx8lnoOLm62mxrvVZ9xPFZiSngmPyPrBiCcQ5SuaaaTc8LCim4dwmZIWAl/zHDYic +BBABAgAGBQJW7TstAAoJEAaFQb9VM38OPY8D/1NazmI8iOhqbN/GPsOK5WXTWKWm2Vx7Eel7 +6+wK9tanRGtOZgIz0ms3oGrBTeFJDCspiHiw6t3HW1lKJj43QD3vrgUp/gYkORWgO1bQN5mP +Mll0KYKzd5YrMbg7oY+lZ0lAXvYcOzg66pBdDCD5zy1ekBP5K3CIiSb4Gh9h+Lq8iJwEEAEC +AAYFAlbtdp0ACgkQd5e+/Ip0I6ljvQP+LnDdVjvY1aVw7v3dccsZTiiwmFAD8Ay0AIOa/4fy +iFNbPNEi/fewSjuo9NPDz8Ehs1+3irJOL8oEGZN1p4eYnIXtM6zUenxzOkVJQ1tZO0oPurOS +6Siz4hNnMMiNa8HTjOfUbYH7Vo/xmw2nG/GJRUiIEh2nVojDb5JrCazSHeOInAQQAQIABgUC +Vu12nwAKCRCQGHMdrs76mzVCA/0e3bqk0rkW+S3gFs2XcncmS0YOXAzCcq7b+E9Xn404Ht7i +fngNw+q90g/mH8/osYA3AKXSwfVqfIfeASfGHNlhbldN/x7/4EJEjOcWmkWV8gJkJenel6Vi +I9bhbdNwqok4vw760nDVl4Q7xOlkfI1aSMsVMyGp6k+7SyZsHRsVYoicBBABAgAGBQJW7Xah +AAoJEPB3wp6QmPrsFFoD/1GPvmWdw+O7yrwbh1q6am+sdsOv+FqpDPPc7U3LEfVVjgBIuJKe +ECdJ78lOr8bIoNsSuE5PogGAddvzkfGDy/c0jR4wNQdKiJRu/oYSlQmbnL/W8DLXHN2D/SrW +T5hvXxgxTuPz8zRQJes9ho4kLFBH46CsRRgGRY+bbumrX64DiJwEEAECAAYFAlbtdqMACgkQ +uM/1Phw/0A6y/QP/ZkILl3fkuXy6CDFuRi1gvwcxbXMuv8Nr4Jvsr+xbtZ3mV33u8REAtjIq +BclgyXNiKmq36l/C5aoOMIaqNPKeIWlAASVqrYGYXGEVzsQoU2TGJixioJxNPkEvQuRHvip/ +DJ9ofYBkL2E1chhvWxBU9TPbGNUY6luhPJz9ejU3WkWInAQQAQIABgUCVu12pAAKCRA5lzwZ +vLU90F4lA/wPHYHy89kZQr48EThdRdnKaMvfZ6hzeJNLFKf+GKXgOnr+1OW6o/wmkNSuo2A5 +KLOZo3KRrJKSN5iyX+0OucLOFXgz4V+xdsmtAu6E/ZmKzavTQnFCL2MC2ApeJ1g46HcaqoYn +yEG2qBrppzH4VaEsUA1PJpMe8zlWDsR9Lb1XhYicBBABAgAGBQJW7XamAAoJEKXdPqnegDeB +2VkD/jmTJoccvmM6wCd2AX36T79VcAC9Ba8G9aPM/wDWU35Jy3XUMU+r5F8+CgIxuQ9TE9rK +rV214fXn8eEXMWXp5D2Zg4/QeOWtIUYMntFM1ZOW3q2doXWdp5M/53KPrd0YvkRn05RhOx6o +gGddUHbzl2QhqwwrMU5SLydY1Vx7Ym1EiJwEEAECAAYFAlbtdqgACgkQu6h6aD7V7H2lWwP+ +J8ip35KCnNCcj2xIL8h16Y8sHIa4OtqJq0MyJZMFsHJ0aMdCAPk6c7xXHSB2MtMw7ehJKyjd +xPtUd2F3LWitEAoBBoEySbSgWI86Ln9ejO3PMhyolHoDHK7PWUQVZigVnNwm2gy/F55UrnWZ +hUxfYvlxbJbpU/JMKcbLxqig9NWInAQQAQIABgUCVu12qgAKCRA/ifOnXCBt1oyTA/4zDQfN +vakjHMNGUx0tRXyJa4NsjvrqjcDZteRjEiIKkXMa6rE3whJLQZ4WOWKyRaOkbcX+Z6rl8SPu ++BVIuLq9C0QAE1DMWB+UYK4eAp/4ebiZxVUUbaC0eLm4FCxMblGC1BZ/Jt62SyzKJCIvo8AP +oQzaknfG2WB40yOAvZksIYicBBABAgAGBQJW7XasAAoJEIL6+QA4IG4MafAEAJmE87HU3Lh6 +909iVabNg9XjvaE6HNoag/Q9CbLmkS9OeMTlixG79Y3gEaesefufFO2hKs+TcN7d+8YXU6aH +eA/oZFuIx1gtCh/bHJn0SLRy5ScNPl/Kt/b++AOYSPaqO5mE6EC3ms6CFEWy5V4hGjVtOJSd +6dNcYrqsBcqzxKoNiJwEEAECAAYFAlbtdq0ACgkQ2d4JJBobXWGUbQQAgNcAe54dNpPso/By +9gfw5mCaJjxq5WUjuOzizf+ylSvPun2CGk18TtU/5HGDp8TGefDkfxwId1ynHvm/kvN+AmM4 +bInVtBJWJS9yzbpjYeK1xXcWT195WgH8K4m9L6txxejqSV65E2bwWCnIRtDzYG2iwb+RyV/h +z4q+AFy8ohWInAQQAQIABgUCVu12rwAKCRBHJL1fF0w9uUo9A/9c+5arhHHbYefc1zRAS+YZ +n+YRntfTdF25BX92h0UFJ/9rRwvmuXemt9twDldHWX2tJlo4/Iol2a75BQmj5OCCEJ//pkJr +1mnbydYgLhwud5XNdfYD1dwKaOjVQDGIlv9PUx7LVA7p6wE3r7HxXERhKHcE7cAEWbH2CYAS +jQfPb4icBBABAgAGBQJW7XaxAAoJEGiZmnGM1zArXw0D/iixm7lJ6CL72JQulSo9ZdsoYI+x +6HajxwWI48ikQANogVZ/+ODD2hwHPIwhKG/e51YRTAt9D3VVZ3BhXJTY+/zRO8V4wKHpWAdT +l0/+h9+HoNW1oV2xa6VuL6Q1DRbwpOIA9P2EivweaqYJmOR564AFkQEiUwwdn2q0rmp2dD3b +iJwEEAECAAYFAlbtdrQACgkQCh58xgAo2rgUrwQAz9C4D7efno3qLlPGN0UGA7pdJCs+ahZ0 +0N9mRCiJIZ3s5/9acafYEmWC4lZDITWhnnMQnc+jhzHzAKCPVuVLr0lcaPvlsrJJYU7oXrAT ++U+HwenzzAndj/0vjbwyIojFUg+KBitcfT4v8t0gBNYm9Ydm5GMQCnjDXTY/BZWyVuiInAQQ +AQIABgUCVu12tgAKCRD3AWflqNG4EYM2A/sHo4Ou9zlwPeY+yvqXYnvqlpz+OfYWebFBWeE2 +SsbjmIt/CO8/WCygbnV+I4jM9xcIcHrt0bPebvEaT+eydRTd10EXPEF3xUy9PNc4ICE2LGm8 +WxZECTH5fwLuvtaxBCzCxDz0f1BbeN3nQT2h6oQMvNopdEIGkaeTvhWAyxyU2oicBBABAgAG +BQJW7Xa4AAoJEKfRol3ODEHwIDAD/iKmmSA/YSrXHIXvglyT7WMLibQWlUKOC+x2v5RYwiIT +Y7jVE2xnflb1bVb03ZHeZoubPsNKCatX49+YLCnyS/n4LLA5T2lK+uNLJnzHoznOFQV3cqdZ +nOlx7urCQjSp4rWyldTbpWdXp/SqJz5NpkG1rf5IEYnqJTpbQON7pU5ViJwEEAECAAYFAlbt +droACgkQylkKZ08FAUFg8AP9HpYzz1B5QLYvW1gIQhlGxv7bI/eJE8mhqQo1lxDPOHhQPy9E +v02jiZphOfh0LWrEESi7Z4U8L0AAuiiByHZFGIkjSjg/z9TRBnECQVACGM4rxAMWSk+Gp+mW +p73upfPna/mCV52+KdOMU1qqQBqEw/XHAzaY0WQ+kmKNYU+JUf6InAQQAQIABgUCVu12uwAK +CRAogl1yi2Rn0+IUA/9CKnmjs523W1TSKENxrsrdT7yteLlAwrmBSMxXJsjZkGDjInKCvb95 +VDY6bUDj+R6P9Yr7aPl1z8JF43BA6N13sJ4WVPAq4dQb6wPHCf04c2EQwXeIwkCKPNGWVfER +EmTbf5Z9Ar4C1tFuVTHSG9WSK8L0d5hd54D0Nra8Xw1nYYicBBABAgAGBQJW7Xa9AAoJEJTh +ajzimFZcje8D/319t+vro4eFNqLXb2JmxSn46UorkLiYGMBrUS5BloauNfFzkKFVyPdE540L +NL1i1YBN/RfPK4dHxDzgMRoW4lG+t8ZqwYhLuhI8Hb+GxGeTnZjrcOaRWaOJTN9e9tx5Abdg +ja06n0DPlMJeO7REtFONtDjPcOBdEK+BqhiPym+7iJwEEAECAAYFAlbtdr8ACgkQESmuU6uY +d/7ZFAP/Xi/BeGJny829YIykvhrP4aX98aiur9IosVutD3to9BUJaawfpS4tJRdetMFKYTO1 +3Crj+kzgtAfEoAVkr/GNhUv3k4Ku3LMJ1jYmL+kmGGuwaK5rjbjuVfbgJg5X4XGENn6OrucW +Q7lvmjURn3KyDMt97mbkttJwRvkWrHTi9ROInAQQAQIABgUCVu12wQAKCRDRU+98BtTvVbP9 +BACXFtKVdUC7/RD2zSr0Z5cJBOSXtDdzWpiyAMAiunmAHXsgRoeI5inSNiLf1+rseM0ZBnEk +Po7vUNoQfFNCxLC0YILEbwvitHa2K67aocUKMEKenr1JoNf+acArfxRsZ/oU2ccNw+bO0N7j +T181gA1796q7YUA6CwoTINADupQAcIicBBABAgAGBQJW7XbDAAoJEDx6Cw5N+m13B3AEAIDk +beG6S0mShFKTfPoiDnz4j3BF0590oe2jQcuGm8Y8/IYEQbqpUhrb8bqFtt+wPuKCYQb4SDYR +s13Mn24LApSeNs8/6GTsn0Pk64OCyoZtygjYLe+ZXawS45lSRuOAtKNm4a4FXYov74WqH/u7 +JTOS9MCwSkxfW23VgDZNSmz0iJwEEAECAAYFAlbtdsUACgkQ+QcRfIa4i+leawQApY5NQNia +4Ho7fag+l0GTlbynFXnw7sv0yyrD4PfeDyu12iAuh6c1hErp4zs7mLDCwJoinHmkdpjWVh9E +oqRomYf96gY6cG0WccL2B9myazHTDQyxL7Uh/8CkHb/iM9xvpAPdE9mVWrmmnAcDCcxnei2s +tN6ZQLNagvkFVBjJBB6InAQQAQIABgUCVu12xwAKCRC5mWrYl5uy1TQgA/4w6Xyak8J/rl/k +4Z2hsOysTrDptcRSoJCCEKU/AWz94IZyNy9oId++8zsUPyEE+CtRP9mG1Dh9u0V0e8wlyjTD +DhmGaS+HqE85iFr2YsqlrYyV/qxrHhmGIf2+MoO4t0WEzzEenxaeddwrjMlnbVZw7TLHssaf +mrACoXmX4vmQq4icBBABAgAGBQJW7XbJAAoJELnOXWcFiYgrJWgD/05i/hT2oa4RFq7+E9mg +W1Ld3oupWvuVSjlXhHgGw1+WCnq91nRPQcej7Vc61FoSTN2npiuTwFEASwuVkcb+31lVQdf9 +rAyoffTTbttdLCiEDL8JvAE+V3lDQ7P/sflkv3AOxz4QSlhOAh8vRiV6xNr9yHJpqmHWzDU5 +rIYiio7viJwEEAECAAYFAlbtdssACgkQfOZlyuZ1Si+/0QP/aC2PybGm9s5GFPpTylZwDw4z +rkXmepmuK/vE4gODCtShdERrFHa8ns29Ku0/iqunXQC2bmnv8eLucl1xL+ex/brloF9adaBY +cxm9tBZVZ/1FMsTcvHyiAw9tq557/VxaE/zBGAhLaeUb9z2n/zniHmvmX2iJWUB3dPWJ/86H +UT+InAQQAQIABgUCVu12zQAKCRDmgBmKH5wU1utXA/98YJcEod8DBwqPDvYkZrbOnMcXQunB ++KOm/lSalUf6UBfOnYEwlza44km9bwzR7fxVPM6ocuSYKGYbidRHlb9CkFwMZOmS0B8o36pZ +XlM86curclQBJUCk+B6JvuuTJINIQ7pAZquNn3aG3mOkhSdQTJO2ydqg7JaDZdaOm55Otoic +BBABAgAGBQJW7XbPAAoJECLHz1vz5EpvdWYEAJklyGzd/oR6T4f36/DUZoBY2aZq+g6Ircvp +D7YftRUDj1RrKpf/tjp+VcU06Ok1DVOknZ08OQlmC748eEvMRl1GQxdZweUoGVZ+puM86Ibq +THfsf7GfCX1nymKZ36RN3JQ/OAThDP8CZ8BIO3HzwUISECr3X/NJxJnOeo0Eop2yiJwEEAEC +AAYFAlbtdtAACgkQSObyLBKE28h/sAQAheU9GEuDoxpmpB880fJEzjC04Qu5PN3/Xld39Jc2 +i5dS8kCCXVUkd2z9wX6gU3nnOjGyqgl924co/o3Y67gOZrJDaZuSmPMyukGpFr8Q5gw2DoM3 +I2Ri6VHj8DOBhckaOXCS1XGnDCMeW4ml+KkcDuhHCOcXBpgCyaoAztB5kxKInAQQAQIABgUC +Vu120gAKCRBu2/wDuFZVkminA/wPrlhAgMcKw08RPhnayWogJM2pDTMdeEQOiMCfWx6eKaze +f68bazfbARxgS2hgGxQC91MtBHER+JX3mw2ZQZeGpDGUOjNc8paza1DoOxbOYeC7DY2zIKvZ +rgud6SFKHJPxzSRL3U5sLx7Qs6polK6zP74DCPFeXevVcTVsXgSvv4icBBABAgAGBQJW7XbU +AAoJEPatBAAYPqm+M4wD/1RcQDbeBVA5Irl82Y1cZF0SuX50E77yfdpkCr80nzaY8uIktFWB +6esukemzuVej4JveUBSXC5dW3JF4ZwE3rv+Ws69qtOGyThSdmYYMzJ8XayCf/0sF2lKZ0uzS +GG+i3u5tT5jtgDRBN9qkSqiYXjAOesEIt6KuK7BfBjjkcweciJwEEAECAAYFAlbtdtYACgkQ +pW2Gi1P5r5dERwP9E3N3lpSwORzHOvCGaOMfFtshtmO/WCPV4oaQiGq45ZnOsfiEekhyc2sI +oynVU488yLee6k5XgeHYPhE0kulfnFmqvND1o0Sb1cv6bdt0R0MvMXmLBgFYRdYfRjv+4frl +La9U/4h75wJw3VtEqv1iaA0j0b6vRhNIjV83gBVDI9CInAQQAQIABgUCVu122AAKCRBiAejk +GzdQoS2XBAC9oS9nL8VUl+1jeY9/kgDCIvzJjVxD1rYFmmfzX9Yb+0hB0FqO0uOHM5eo8FLA +WB3xay3fnhZwXQ1TCcYzw4JUcqTcpwuXTI+U6lz/smjDPlrlV0jOFKa2GA6ArO2qeXhVeTNV +LYMdpktpqC03U7zwQIrD+UgKB0Bl4QO1HlYA6YicBBABAgAGBQJW7XbaAAoJEB+ntdRjnXwY +MWED/R8n09ynmcKE49Gb0Xcjoy+jYxwY/tx6U8rOK+UvFfC/zbx03L9i1E3c+pELOMNQ6Ur7 +IA4BHhfTLopUDN92Q8TbLt4Df/YG4s6of+ifZBZQVbNmr6cHktRtQbWQnObgPdbAVQAUP1CY +JP9hr/pMI7xKKaMdd/LWXCIGqEC8mm6LiJwEEAECAAYFAlbtdtwACgkQ2UnIZLiFXPVKVgP/ +YmRUAN7FzW/Sd9mPv+G7vGY+hLHeQW8Uhs/YdX0i7LY+vsEQKBfIvP9s2KGd1dDrhOaxN/l5 +mJyMC23Q3VkUJ0II1yISAL6AU5QfqldUeHnC/gtR4w/Z+RJAtFcSw2pIeSCawSoet98ZNahu +lE7v3jf6Z50C/U5R57a/zTYTvmyInAQQAQIABgUCVu123gAKCRCcaip4Q42JODzIA/9g/h1W +2/+9a1PGNsh9W25Z/xyGwrSQvIrRUvMHr8/MbzyfypWU+ytb7L+9fV+B5Dt+WLfqsNyI1/CN +zvmrmIMdSSp42wCf7nY4w3HSiABAyWTph41ALb9TDHcelXqfwuFSx+PV9jDs6thGB5ojKf5c +D864kse39DxE+zvhhu24JoicBBABAgAGBQJW7XbgAAoJEBt+tw29/nsr4xsD/iCvVSWo4cD2 +nWik6ruiJ901ETf6h+oCnk96FSf+MN7GEmA3EuHUxqS7Dewesg7RxB252efBTiB5QcA1QYML +qOuln4MzTFXG2GvjwmXSFYERkuTPvyQmghLOn9Cf6526EyCTnOzD9rEQwkHc8iNC2K5BON5y +l0IdxnERNGFZ1hBJiJwEEAECAAYFAlbtduIACgkQJ/JrcYifOQL4gQP+OJA9DKMcmmZmrnDA +I3G2a3Qhx938CTdGxQQVdcM2ED8xKcExbIpO20qQX9xdP2TlNygDOWbElB5N2xL19m/HG8XV +8PunAJM+Stc7Ebi3LIhYB8MZhORWXbz4BtUCXfXIPAJBXKIdY8wL4H2afSAxhNzjyevHsCpA +uBo1VrFvfx+InAQQAQIABgUCVu124wAKCRAXG3VK/UfcdPX4A/wI9U8eQzVsUt6gxCTZpnFT +1K9TOvEIgSWziI+dFkQFxyrfueQl0EGsVS2BoLrOCR929PsLx6lI4NfQegAs9t34mNFvn+a8 +sfOSGFAh92akxY4nqdDlyjPWsZVbbRCfgZ2PXajOS1tLPGawyumqjvvjZhpyVYdRg4C2fR7L +Y82CSYicBBABAgAGBQJW7XblAAoJECY4xkf+sxdR75oD/1btaBm+piiHraKoiZxzEx+dFSX5 +WXhC+Ijy6vQmb5ACQELlj6A2fAQqPhI6g+Lj9e8X5qHVfvN72B6Hhwx8naa4NpJYJTzypGmG +t1CNMrglnMb+G90Bs9Hfvv8LKbmsXjvw6IyiNd+XxKw+EEyOsagqA1wYqGz2wFf9zNrOuamU +iJwEEAECAAYFAlbtducACgkQhSRDcmwC54dN5QQAriYbQustUyUtFjC62W1cKTCBGp3NZC5r +0NKzXGH5e4UBjzHgVnVER2s3AJtFyBbBTT0ww4ZHZltPLlPzwX1M8lolAuaXHsk1WxmKMQQp +6z5aosPO/auIaaO+RMPXVuGBjHBUJ/tfI93Zw3FqgXWRZpgUfSP/mBq+mawJQCYmETqInAQQ +AQIABgUCVu126QAKCRC3Pl14Kmm8dTDKA/9tZq4n5gXRRYyyBxLsJ4XJ/FEHmRMR5gy/wCjR +KdXAeg1CHt1W3LbZCWOPh3xUrO3gsWiJUcWDCQSRIfe8gB8O9kMPmYcQ5uLkPdr5nrPeNFhF +E60H4efyrbb/HTL1dJ3X/U79+njqG7gc2Z38585EbH181VIO08R+B5H/RiSowoicBBABAgAG +BQJW7XbrAAoJEGusfzUN5b5M0ycD/0ij7aMqcCnFRYwAWp1NKO/ZObeXvzvS/L83P9+wbjj4 +Lj0oWOq6+YjJ6JK8/ZzoPa2lhRCqySubtmEpw5Sc5AoNO5IkHidZRphSzt6qWZQKQQzee59X +U4DDnXd2/5phdMxEkHB0uVCpNfzEqN+iwqXOgjSX5/tFwdcg269y/LLniJwEEAECAAYFAlbt +du0ACgkQK08pefH4Os1/zwQAlsfKoEwWwKKqZna00vs+RV5VqHjm52j40ShrLOFXmj//La6E +dW6tl/fd4SsT5rVd5sBpQYSdUVgU3wdHuCLBXhW1zk6Aa/+K5RMlUBCMqa24h3nMEYK3QQOn +RNBRV+R12Psz+OUEM5oV14LpHYQQ8BEkWql2MFywz3E5FL1FsImInAQQAQIABgUCVu127gAK +CRA3HeZvgseYnJbuA/9pKv3gQ5xhCoo78W9JeVeX6mZ/BKzv9GVGpEEgJkPGz/40fbIb2NX+ +Pn1vwGSBkciYi4CHEq3mkdFyH77ERQ6hVETzuASDH2ukZBZcbAKyOZMRyBfbuvnGyqmk3G9S +qlgfcP29NXNUFKGilnr6nkPwaIU8SHF7Haid5J/mKWd25YicBBABAgAGBQJW7XbwAAoJENYG +dFbNHEgYJncD/3RMirDytesUWeT9Z7H4FschbnuyOwReA/RDmsNOwwajZ6FMCieZLdnu0tnP +vGOjZ7Htvu4Eifa3868yuTI7n51fXwsOuhSeERp9vovfS1HoDCz5O2VdYtES7LK7PQ2dLK3F +/CujXWERxi5UYm+rZF+w5d1NS5TOK8w0Q/BIVT4biJwEEAECAAYFAlbtdvIACgkQYrV8wBiV +6JNTkwP/YsBvu48HqniCUi+f/fqDxLAg6efuvXrQpn/inq19TgCUX1vTDnGZktf56UctdX+O +QVcd9Ze8tFScwBrKuDJ4uV9POWKwtd9DiQkLYjk4/tAouvG0YlWaChP7gmRXElsHuW3hUnKY +p/QtW3CZ3nOIwF/PUQVHy4jzifdP7x/IucCInAQQAQIABgUCVu129AAKCRDzZCybVElQ+El1 +BACdAVNwUEOUXjG9VvDL8vajDl0Z5wvYbY/ZqEFlM9CTD5pLUYyAd1uDoJjaPRCQf8hFbqHD +3oEUsstT1w8NjEYfAm6Pvz87mWFkTutJfK1T7uUFc+9G5liebiBBMVFlovN5+T95UloLMU5q +MYF6V4t5h3ptGt0rwzrrpaoYzlkY44icBBABAgAGBQJW7Xb2AAoJEF/hbQucyQglceYD/R0Y +vqxONObIdTKDPAYSxT7k00ltQkAoM1iXvRorD7VvGFm9nP2+sD9iOvr3w5XUqeDUq4WoFuek +s6i2bJONML6vf57VSD6VPJpN0VcZ2h+d50rodrgroP+Zp9oMggCcTwOOQ9kQ6wl+93dyIsIs +lbJf/0YxsUfmxiN+MPzP2qvWiJwEEAECAAYFAlbtdvgACgkQxQnodnUGr7THeQQApK0ZlqO4 +mIU/FhB/3nh6ffMSNlluivAbX811wwI338rKqo7i+Ml+6Dvr8Rg1r6T002WorBrjT8sCFuJS +JQR97psRVw/kMGDuG42NRveQUG+Mamg6fzrWlYHgwkCfQoyJSyEye/COxifHUrC+rEZWjvZ6 +zclKJAHEl8sK771MHUqInAQQAQIABgUCVu12+gAKCRBgmMSMB9JZC03SBACb89j+mU1Ug/SD +s+Jrwm2lBtb90xTFj7Mh4z3oK1BAw2nmwkFZitAOBguqIAUoHXiu3UWVriQKsnY5rZKj2Wy7 +nK7/jW25UHCkoK98GvXnjUCJpggBeY7tJ2Tfjn5yNFAsdKONXNSAfjG/a1HahWHMjv3DVINT +9uqdOF1GTymkW4icBBABAgAGBQJW7Xb8AAoJEPiDwkVpn837uXsEAJMppI9GUDJSpFzG5xRk +w3Et7A2ARbDJv1BWv0G6o2tL9Hq2JC2nVwT7tmdco/MfGu9/b9CqbPxWYTcSgY3V+9xcroJD +NYUL8y/SDL+5i5CfMsQOiYDdl6CwLNFzqOboV3CAGDcHoR2+nNhkHLBNfO6lK7E/W3t4K0tN +8gpG71KGiJwEEAECAAYFAlbtdv4ACgkQuVG8xLpbDshJtwQAmjlKovSPBrNzHxGL8C/50utI +P3njWeglChg/X8cc3vx8W8Cf2Zq8rWdrGWMU2NbZ8qn/jZhWbk0AT1et9WKjrdCHnRrsRtv9 +s7E4E8mNYGEd4mcLUHI771UtjcYr5Pk+BMYNsOpUZ9Go2y0rTA/Xg74Bn/Y3lO42hTgopF8C +cxOInAQQAQIABgUCVu12/wAKCRBJasRmV0cEdIp/A/4qCM5uKsUx53NSHWt0n6jdCtS+7v8j +3lfvNYGhfmGztxvA+zQGxuelqwizOAB1UD7mtHrnjOw/hSsPMEODQSph6jp+AEzS5ZWskOsw +19huGn57us7t86pNwXDCHGYGBTtokj9/2CQAvG0qtWEca0izQzbAP+Sk+IQNSF4ap84Nioic +BBABAgAGBQJW7XcBAAoJEJizPHF0op2+SJIEAJrmlGzL0mxafwQQxtrwUYlNs8VjZAaNr/qf +UWgyp0BGETUg8rRGUNg1TGQJnRrdSfWlYfTfaKdw9GnzAAPl1VYYy/79ReeLD35O6mpoqh2l +pSp9sugtF+Vm+RSipXc+rNLRSvr6KK9oyeIuYiEygBekXlptN1fhsWBMD8990EhziJwEEAEC +AAYFAlbtdwMACgkQHNgQZB5AXGS98wP/T4M4pY7DZ4c2cy0kRMDACqEuKIBhpMUxpo6s0MPG +hyZ6kaP5TGnhITYf7aYiMXFkYHEd4OqlKqmpNRxlHC8Ewkio+8Rf4IlgYkGcGZD1o+GZZcGo +DQKvW5pwVConpveTjhHHYCzRJetFjngWvXuIo4Gpu1WVbex54XzddQM0/E+InAQQAQIABgUC +Vu13BQAKCRDSwux9C/OXL/4lBAChWB8BHFFbDzhmEAdpbuggg6IsdcF6tIXDsqNfxW47ivo5 +Ln1n1SiNgVWEH8kBdZoLlER/DZOWN4HKLfUbmug48tu71fHF7rrHFTh+m0quMVEkRMyopb9X +IqPffFyS+C8M/3oi+qYci1R2hzSbccpHhMoCmHQBw6zsH/uDHyjTu4icBBABAgAGBQJW7XcH +AAoJEJiJoXX1nPQNXMED/02hpqtGHmDMWh8aYSPa2VrSD6ceimUi/ez2h7GXT5DYlUA0lt1r +e8DjMSuEn0fZ0CEAJR3KoaS7f6BMCWTtnDM6wJ9sNnzsAbfkFSQCmpwgjEKwrSE1jtVhY4e/ +QKSNbPpy2ntd6EM4+bTUcbXonYaTbpG012mJmDdI63rKHzubiJwEEAECAAYFAlbtdwkACgkQ +eb9MDAFCw2BU9AP+O9QUem9G9GgJMdBCPc1YL/sNcBJlH8zetMYwrDZbEuDQ7Hr4+LH7QA3Q +m2fM+drHEcpWBeLsQRUr47H0IVAjunK0r+qgh2/BQq6MUTs1tJcnLpI2Jkf+0sUQCsRFBzim +3YHfVHscXslI99PIU+8sURjDVmsvPwnvTKUXKLdloxCInAQQAQIABgUCVu13CwAKCRBkpuoD +WVVqHNvcBADQvS/fEpd8JJ/jeOS2imLjRa2HD3SxSi6RcZu7B9XUgLPieaF6dmWvZVuSWOYr +kCqEHl6jSLKlk6/lvlTWEW3JeTRMTYOCHQD97zo1Si4BOGsDSCuoBniXOirT3N1dlXKkioLi +NpYxiMExqAbAeR9I9vBc+nN3NJxk0u1RFr6BdYicBBABAgAGBQJW7XcNAAoJEEbb4kdmH1S9 +Of4D/0PhEnjMaOLq4rUm9EYWZUiXs/WQKlEjnuzWQU1G1Z0J3A66DnmKv9gtn5u/0dw9t+1m +XVHjeup9ZT8JHJoNOwaRk+wXvbUmsFmi1fOkDvSMEJ23CO41F8UsrQZRZd4W2dV8ymeTvhkp +koyHgjHGlF8Oy6v/NwUW25DR+lcRAJjViJwEEAECAAYFAlbtdw8ACgkQggXY86iqduCoYAP/ +bt7DZcXfz63a/IoBolXssPrO6aDNi/sDE/k8hYF3mU2w1xb5NSsQ7BHMiaeGzc8bXaZODZ+d +rjohC7m/LbX3zDcDTds7T1eaTt371H9FdFLiVv1RcGmAInbiG9dNsqXMdA8IA42umzY3sTHZ +DXxu+uj04JHDOq7yB08QMNXuOiuInAQQAQIABgUCVu13EQAKCRCeyxBd/iz8Qk5pBACWcMie +ViFdG+GxFDfhI9MqEQoQN+ZD8APZ07ioNplvaCP1WF0eQlit3a7G50ar9tepMtavDE4sSZr2 +ClxJ/7oFbn5VULgPXckt41B2u+udylNB7IlIHYQIyMjXoGK0ZwHFf1k8PVgMo/p5p9x6IKhB +NFcYCIRthlA1M7xx/mBTEIicBBABAgAGBQJW7XcSAAoJEKp7SA5zwAEWpIQD/jqdT4YXDwsG +jamnFhaMpvl7DaiY7KlikMgCg8f3WNXfZgN4BVs40KhVAVS141uvExsXbnp5WQkQHSvck9jm ++PyB+AAYaG4D/G8nxxsRydnVlU9w22dG+8dyox5rsAMYCCnNKuUt17dQYIVlR9VzR/cvfzHW +VVXN0/BcD+wnJkG2iJwEEAECAAYFAlbtdxQACgkQubXHZmk7BHbVUwP/Ss+V0c6h8oViMl5L +DcvTpLBARiyEPgz7cxRVPH9DGA2AoFzTzD7OXQGcNTEFBfRyGp94M9Lu8yCmHd51PEO9evYF +HxQ7qIysK1kLygnHRqnGvj801eM1TK3OJUSURnJ1I3sebXkleEIyQ3p0/ph7eDXEKndb3nHi +7KZPA9v3yjKInAQQAQIABgUCVu13FgAKCRAS9JcPPEuGrHz+A/0bBlKFebWzuYD4X1ZdRAvu +gZBhwMJmGCMFjUGhJCJY9eTzDL7F+YsEZJENX2L6LDhR5+Fq7x9pWYhybMlVCmqhr7GpFSIx +pNdCC7yTCTvSi1yHlm4QqD/Pe93qzObVGaegYfxwUIJAyATqbxqf4v4D76xZcZppasnCx2r6 +79fKF4icBBABAgAGBQJW7XcYAAoJEITqzsdPYuqIdWcEANLwg96C5XcDC6TbsgNvi2C2u8sW +MGmbA8kTHTU5L/ymtYPS0Gr7DXccr8dLWpyY72qKz8WedrTnk1IsvH+sjX9ON52aAKQJxG+V +bmXMHsY/RXkGWXBptVfDWz6Vyt+4chyIarIJWAPQQPL7/G9dtiBQLTFrYHKPr3oaQtGYZia6 +iJwEEAECAAYFAlbtdxoACgkQTdppr68+7r9mawP9FCxKTDvJZG7uvTbjQRWUUtcvSTHlwLaA +IybNQuD0jzT50gO2rBjx14z2roLpNa40OicE1s8a9dd8G89q4Gk25hGlVKhGvvH0+QFw+FNx +cVo09LKBM9Hcy3N4y7Yd02Vea/P+/1JoDVr6S2JcSktQ6qS6QK/W2Kjuh2BpNZjCgOuInAQQ +AQIABgUCVu13HAAKCRBYOgW2+qUVjpSwA/sFsXYzhH2OGtf3tfZ+JeB1/nvlZh7CaUrM/YIl +PAj+EWJaU7NRVpheNOSldfFT2kIt2XTjvnckOcrIr/Tj2OO/0eH1bfywqCaCpIXF9RL2Y71Z +TqyS/14R+2HCCpD42g9JU3lndXD+IKx4Amj2lkQfsm5HZ1gq1rxYkoHK/+ryKoicBBABAgAG +BQJW7XceAAoJEHxfTvnz6kPYxDMD/R34emOKCOCOknRkXHYKjovVKa6V5PPjbEZEjF8Uw8FB +YFO8cQOCXqcJGNOGa2J+K+1shDC7lxiNr+1jinjRvexYi3u1h8Pzr1a+cALXiIIXqD/mEU6b +Kik2QO+qRTKdYvdwUOKx30dKrdfxeON4VzW5YOAeLlve3TRNdiIXmk7RiJwEEAECAAYFAlbt +dyAACgkQSOFqeBiO7xUsjAP+NotOAcwN6+y5128J6EnmfEeue2yvcyrGprLbQSfPMcDrmlr3 +4sYT04a3omDy0uezKAOi/A2OiMP2jIw65eUqGspTWW182yV/kavieptzq2662agLs9cjwaPf +6K8d8gUTsNesx+kMr6RydB+BkklYxzZ6smT6Uh8uEFJhWQJODoaInAQQAQIABgUCVu13IgAK +CRAVWQCpYrhl4d8GA/9iK048CZap0BeGugXlbrqaDgbrzx2JYT65fHitlsO75Mi9Zlkwgfuu +a758KNbpAfMGHmmvZMbYmK/0mRzTQrWGVJ5rlYGwo1DfmYmU04VYT1iWum+5mQLD595PIe3L +jwvSs7y4ns5TyIdkvDps4OC94/jwoJ+i+kJ/VnSWefzJPoicBBABAgAGBQJW7XckAAoJEOaI +pO2wemQCA54EALpte4W9KPJ4zzGuVXf5D49VUhYProAkKjS3BURe8H0NGFS7YuKJRcfC2EAR +9RJ7zfKsR9tpxVTtSg0huEyse+YlIo5I1x/cHgRaH2cLcRdU6RRLK1336JszFvqfCL/XkJTJ +/EGuI9sXmuWLju10GJKs6AFwh7pLhnbODNRlV589iJwEEAECAAYFAlbtdyYACgkQ9uqbOcM+ +bKUWGwP/aIiJEw+R0LlO9C1ie0uXnyuZqSYXOpjTn7kMr6e3q2XrzQraioJAHoXZYtVKpBam +wUOEH62HXPXio5czVIQ5xc35h8rZU5WB5FDTExuEUv3znvBjE4CF/CfN7ov7+KRC0iK7S2cy +55zcxUhGP2qtH+NrR1piYQUZJCaHML/riiuInAQQAQIABgUCVu13KAAKCRD9LImQeB+srxzt +BACTK2w/7zc0uFBeSphJ5PbIerP4GOuzStSJe20IBtda2lFNrYIGFfs6DyCp1i3vkdyB5Khc +LwjK0/Lmy26LTJR2/bENTz82N4tlQsVfUIDz0nUa5szkZxXIDOLxQ4OLB3arQEubmGGX5Fls +S8Cu3M1g/z/jto6cOjcQxYelzeMxMIicBBABAgAGBQJW7XcqAAoJEDl54aUrwp21ob4EAJ0Y +Bc0rnzRsyKnUcg0Y6FgPJr/mp4agaAAQcAOivfC9LAaoUQySqhHVZx+9ocbuTyBbpQns86+P +2ACV7ph/7D3+Rwg8BxvTihU2FpQJBN/fX+UpxkXL6kr2mggeCfDNhSnlF9hkw7F/QG7w8GYv +/0UQjkqA2VMbDXsuWLkTZjU+iJwEEAECAAYFAlbtdywACgkQvIa9BNOQtr0ReQQAk6VSG8B6 +FbXigTGw3lekmUrviWrhtFXeYTyg1idH7z+pb3/8hYfgwkS886wRGea48pCW6KFBR7dGPKfy +nir0bz8HlGvxmAL8YyRfwXBMbaawtuQUnqNuAYtsJvrfpPRpcJhiu9v7l9TW44X3XW0yL18A +8U9SVNSZalW7zzKgFgiInAQQAQIABgUCVu13LgAKCRCh5LONpjVrKOWmA/9+BW6PVs4BA6aU +5V5g/7zBiyt38fgAgeb3Gj/ZxwhgZJK8ICQBGeT3RwBeA64qRYiAuJ6virRx5L0aiCKpJOUL +ZcrCNro+OJaN5rf38IYBnjCafC4Sustks6d/ZAwUsCD0NU7Wro5+vG5p0W/S1FlcBgVJhqLF +UzOSV4QPFNNxmYicBBABAgAGBQJW7XcvAAoJEAnbKC2gyBLkWLgD/RN+BNZTNnK1yEO+N1w0 +nGOZJ/BFl4489kJkaU5OvcTzMZYDECxqFfCXUvjkP86pnHCTeqjh4SzPAqIzGxL7VWTsBAwe +Dudsg1PoXw5v6tJx+bNsD4MI6WHPmuSs+DlHpXhPaDioKjvEhRQWswIScUF3Al8BqJ19sxIK +hD+SkmU0iJwEEAECAAYFAlbtdzIACgkQuvEJJA+leUCAawQApjTCzuUNX8BtydgzFZS4G0nD +6YpnPPhR9agyn4Pwd1PaDt3QgrgKMMUeAnengAqBqZJFa/IK4AQ9tVh6KzPObOKIutfYFfHS +CNdEtTz6AwaN0S8peJ6r8dYABoUPCDa0M1jkBwJPRCC83+eEvcLoRdiCOoL9h9t83MbRAYCS +LIKInAQQAQIABgUCVu13NAAKCRDLAP/zS2jwYrL/A/9gJ857b81sk88pmC67J5cPPywBGdi9 +X1saqhwvxK6yLPU7krCbf0aARMgmtd4Jwm5UqQ+V8oVIWBFf9YTDK4KGre6cJr0zEKZiINsy +XBQB9FyWLzCD34Sb2VvcyUkYpzMqFTgs0896Lc7iioLQQ2CQklPFhHvF/HhlL0caoc4Uy4ic +BBABAgAGBQJW7Xc2AAoJEC4zFRaWRlbbTvwEALtSpOWooGPQJz8665PjupA9r3c63eUYDbPf +IcfvnDYBJBBWPCJE6aqJtNwPqpo14o0OApFALjuHmwhN+ui4uYINDIdNuYvnk+j/C5U64DWL +UzBt9eySBz0kdxmip+oxJajLlxXUkIB2svBMG3xmb9uFy8lTcFrqZaWGQnrVKd53iJwEEAEC +AAYFAlbtdzgACgkQMkLL+S9R8DmofgQAi7/s/FO+A5qODxKHnWJVY3yBYVkCdc4S3reLct7T +ewMkustgCD7PLDs5QUERTKATuhnYGagnhWUc7iWmFpztFMijE34d1/muxDJ+9tvBwWDyNE1y +5t2yCwsU7DJSPxpW2OyzFzWYMPZ8E+tQh6a0llCfmoMTjwsQaD76yWcl2HiInAQQAQIABgUC +Vu13OQAKCRCuG6+trL6DMHXsA/96WyULYZ24cWZRjTcvwIfFsO0CRcBczmcFtSx0hkP5JGqz +Z0g9E6tGTT26wJidMnFlO5EMAL/IlmoltXplNczpjT+mZP3Gf3dicGl+R46tw5E7ey78nKq6 +nr2K7N1HEokq6vIHqeLD8+Yl/94YRIFLQZKbG0rD9hVjI86cYMpO+YicBBABAgAGBQJW7Xc7 +AAoJEJFTrcYbkIPO09EEAI+Mlr+SVhlRLgzareH/fJ0aexR27cU5LGLf4nX4RFlioGzGk5XW +ZgRuSeNiVPRBGwihsWWy+RuhatckVc9lfXxfCbWp2KTBo6JPRcbQKsDg23twUy5+V3FCmBLi +h/M6oE6ppoCnpP15jtzpi5guH1nBHc69iPr82lKUsE49iyH8iJwEEAECAAYFAlbtdz0ACgkQ +9Z7vgKiBkrOTDQP/Z35dpuqKQviuZHIGARtis/n0/gLmFEY4ITygRcguzCgVGRNAl8cHxj6V +q+EPLBDwGQgzaFkR5CmcNbfFutpRX/+4nKdiogpUIvP90ITnrl4vy9ssTwIRJx5u1mm/k9+z +U3eWK4WVKPEuc5w5fpeBCRllWN9Iz8PTR9nhCnI2Li6InAQQAQIABgUCVu13PwAKCRD1uU2I +mJLIMuKdA/4wNUA8iETllcuPo2RBao1LuLq6NphETyUhFtYIuDqOIgIHeQ5txV7G20WKFpB0 +dxcFnmPqd6VTXyNCX39SlBjZ2l55ZN94SH/7E+RYRGqn8lOepJR262m2Mm05s5LpO7vP/31g +rxDrhlMJ9K+JCdIZodw04pzPgYw7/8NZ3bvc14icBBABAgAGBQJW7XdBAAoJEIQVyUGen56n +Kg0EAIHy6xF9f8nWsxr+IzpbnmMaECHDqOfizfA+vJm2grNCLH+qs167SfJ2vPJiFLF1Ruij +5DCS7vdh7tP+HhS4cbw0zlSM3rOlyc5f6qmqTsp+lW5m6zuMAbpZVeiiqrvNLNIWvZkj80jM +ra+XzmJG09as5jzlprOA2EuP5NXGDPjriJwEEAECAAYFAlbtd0MACgkQSSW3R5o23Hm0nwP/ +Z9bowZ3S3VY5HP8kNw4sNOYEuKftCeBmkblvj+EaEi3TDwlt3EfK41sEvPB0X5D/OCMpcgzw +IFRo1MuzkFDCQaj9vPJzmxu/rnUtQlZfyzNdnFsKeuXFwuq47deHiwlcHCY2HpSACCvTDTXH +nnhNTcZJOSWhAtZCpNoIErb8auCInAQQAQIABgUCVu13RQAKCRD+UlUcX+s9KbrfA/98EUeI +DoSjk3DJFkQrOqJDr3gOZvHRtunvfVJTJusmDjDmHeK4RXtCA0QAx7y6j+7gY85sS97dlrEJ +t0Vn8w7m39Y6rPq143DrOR0hEcplckVcWnWstSBIIhZuCopkMY+Objd23Ar30c+MvMiYzhK4 +7crcdZt5TRADZFteFYyKDYicBBABAgAGBQJW7XdHAAoJEBRYlwk+Mxt0EFYD/3Nv5E8pnrUh +Rl/zYtrF52rFUnuypgTebRbmxRBb5c1hnN5JD69uQ9XYmSnFflOcdeTdtocDuix3IvnMinoW +FpwdMYrbqA0+Qu734GecyWP8LTe6OaQTttq95JYorIj9nIPHbtAN3YJ9Zo9zSfeOp/7r9aT/ +hyjWqDXipXBAB+QyiJwEEAECAAYFAlbtd0kACgkQjq1Mt+UbUU2ZnQQA3u7VbEifeeTjTCuO +L9Gr+23Vm3O9YY8unn/Es0Dcnlalj6MNrfma8C3MAb9di61v3CFrJTXCzZTwjOduXY+om9jq +oumKfESK2Sd58q6vFk2na3ZKU6/NXzkdn86kJI5HOy78+/WIcxUaX+/qf4dipXqi4HVVA3B9 +cSmPcB0DBe2InAQQAQIABgUCVu13SwAKCRDU8B76rw2MI+oVA/4ukbqOvRmZemcQoEgmTEsu +t8nx9nUn8w0SPZFl3mwy+jaY/XEzDdkhI7BowL0rA6jPuZqWFNkqdsyFYdaX1RxMg/b30i2J +SJ3y/tdxT7ybqmUFaWQ0YdwXj9IOOOeGuCpLAmgo69sZV7vq0KHfVKPOC2MN75m+dYmnmSl0 ++Y+HZYicBBABAgAGBQJW7XdNAAoJEKtcWrU8xhL6rf0EAIp3ahf8VLfl1Xn2N/EJJb8q20uy +qHLx6PfUsf1+hy8xV+EPkeFGASqWA2Gmy9EHhJ4EXRu7MoqXgvnI1bT8fuRQWtdvX6fUqAE+ +QCjyyfMHxX0z8Wh6GqV8d15qleUoJ8qiqva/Bu5jnF3eEowwdZDHARsXFw0qJ0Ca/mIvNXMd +iJwEEAECAAYFAlbtd08ACgkQV5Efm4YhSX3asgQAuuAnFmL7Bzbd+9UFqhr6YhGocNFc8Y/U +XrhPggdawSkUKSw756WjNX8L6+6VJIpgAnqg7PV6lLq6g/BPJ5Muie82EE70ZjfGf6x+eT51 +YvcK1olLQLsqArRfOA8YfpnZT3Se+dvIImsU9zFpfkVGHlDvIhWNqFFS9nnpUhQer5GInAQQ +AQIABgUCVu13UQAKCRDEtlJ72k0WrlRoA/oCY9KcrqyTwuiMVoTwvBimv50qbXw54vZ18byZ +3o78g1WUGX8+D+aIBxNV9U1t0ArWY6GJ+8JzTRwaqhW6pZyVvds3cc3HnwYsrioNWVh6Sqqe +Kid6FxLNXvkugRFGZ/Qii2I9woSsY+iZUYvmwMO6c1lRh/o9StGZiMnM5EDA+4icBBABAgAG +BQJW7XdTAAoJEJSmnp/18FUqD+UD/j01JIRYijA7D3L0TbpKKGLWB2m1VIrB5T6G2RV0N+Tz +z/Yv6YSi1AC3QmCR2Oloms3qBBrnDke8gH9MniETUXQWLVOyDsHNR+vcQzYGM/60f/4iI/CX +hX8wisV4yWmJxbaQo5JxBu29kk7xsF46052OU6CClIzgqneTAfHbcwq8iJwEEAECAAYFAlbt +d1UACgkQ43VJRrNVxQjmOAQAoVzXAK8BxXtQNxpR7tlLke/Kyb0urKCDmUFSnPOmLqlfrrKN +1zQ/24OOh5yhsDEsB7wbHIBTKumn/fZjuMx38sfipcWuODAXvcn9X6hm5QyLP562qoGCU86m +Gzh/v4Q/YSQFX43krH9n1GwgjbdJzSUeClSPef0pVRJkv1626GyInAQQAQIABgUCVu13VwAK +CRDD1LtU1LiU94j+A/4ue7DXauQWrGJIffofg+U1A2MlpJnrvS6OvlBZrCxp3xiFpQjQj0Ak +sF1MQTEenTQa+z6KtO1H1KYP+JQchJJSaDzEfINjT88IZ9FjlKHD41F3d3cmxFuIUBCrb68C +USFd3p7Wl8LFxqBpP99F4/6wmKioHlb6LIT9WwTHV0nj4YicBBABAgAGBQJW7XdZAAoJEMDf +LOk62teX65QD/1Qq+7TcTlyFFmPn6tqa0xzAg3mks13LRwsFABLDHBig8nwvi/tLodHgb7Dv +mqb9rHI5lFapS1/QDr4OiyHfdPBUL4lzapK7lu31gAawGkCIMCiFfc9TndI4yqEwH+weAbgC +SA7xz6qSFkMHPysOyM+2wRYjPahGKVfbiNN5ItoNiJwEEAECAAYFAlbtd1sACgkQxmhrOsT5 +viXdUAP8D/oGw/0h2YnVKObKRD1ZyzWYlISnH4oBYsadjmndCpkjS48cl+90grSuthdHNO0U +2VDStZktqWt/6cR7AjtSZaE5DjyZNUNRjd4tsTmL+zRkhXinfj0B+EVxN7WeP0kj3RGgQ93A +a6r3ASv4ypD9My69HZlz2FJh5BcH63abwXCInAQQAQIABgUCVu13XQAKCRBtwk3a+pw/aLki +A/9GrHRKKmcsCT31b5bCu+Gdj8QSGc70Q2ZifLAy1AonKBZL9FqR6SnTZpDMaSLkv5wt4cHE +Mzsyaz/aKLds2sQjlYaBs7+K/UdXgg5O7806b4V6cgGkPLYHyyex/RD8+we5XrPvbbTz/FBc +noREJL2Ch7emBu5Swc0AYqju+a7NtoicBBABAgAGBQJW7XdfAAoJENuZv75tOBecc00D/jX4 +NAbptY7zDlU4w2uT7Ds6PeFxF96B8gDeMpRFaeXQpwz/uTtyuyS4t6hUke7mp4rLloMgfmcD +255mXP88R9TO3RLeHnCP6s48mJ3p014ZGaH413qzBwLcB6EUgKgziviA1pV9v5r0cKeFdj+E +ZfEVjtnU3Up/PGXnDuRS/IUniJwEEAECAAYFAlbtd2EACgkQL10NVbfxPoXENQQAtw75fjeX +iIgQiGzD6k/AYvYQbOnH31anqmkf8JvMrc5CnLNcRb9MvRreRCnnSLO+cOMGhL/SUaBoy9Ma +VhIxd3aS8fZo6HvbmTftbKZfaW25EE0z+I/77kxCNkbKl6G7fzA7LfxqA5iV4c3yUc8uDDTQ +e34M9FCToDRbByOxXdaInAQQAQIABgUCVu13YwAKCRDNpFx6EXA7ShGjA/4zBKsFN+fG9mmG +Ts9kJx1nAN/p51On78DJUa9L/pCE4RGnkQrYxOlRZYY4qonFAK8gQLxQ9nDsJ1Fx/QDEP8wz +LPdtCu7YXOwiaaF7PUB5k4BvLk5qCDQGmuwYtXUdR7kro9Cez/qentW82wt/qZ5t9E4Me8WI +Owr3BkDNMkz2OoicBBABAgAGBQJW7XdlAAoJELelQVSi/PO7i4gD/3qRk894CFFHmi9o+Toi +LAXinLaL3AMnzwgXtnKRe3MqxiQgKacOZQhOXZvuHOpDWQQGFjfMCbNKehauckaAK3gIbkLa +ISFdZBQCARIulKc/9nki7Aa0Fkg5l+93xYI1rA6O6oS41kPt/OT48Uz5+ENQFTJ1WcKtVdwg +ZwNH3r4IiJwEEAECAAYFAlbtd2cACgkQ6DZY5xHuPYnPmQP7B3abwRdD5F7B4aMYyqC+dWzN +zRUab0bM6gPCzwbHnXTjmxto3gWHyvEQimweRsoPOimivbnqyak00TjAeKsnd2QzrUruCfGJ +fFeggx7RPaeub7RGFWMH6+H4rL60wzS2ovvAi3Qb8f7cKmmWw/o+4NyA4jIfwW73DaIcmDEr +6k+InAQQAQIABgUCVu13aQAKCRA78581qtlsHX9bBACHYcBTNu5w0FPCALYEcQqmfTyitjXW +5TdNGfzBlEFa7LajX7xsFW+EKyInf2QYO9VAjdloNWpd49YnqB7MHnuZoeZb4XEhgaafmCWS +skmS8KUoDKvm2jbxrdIKhlv7Mtg1tj5+aK5fgO71S7QRlmzQ8PgwY98ar1oq78emW5nLuYic +BBABAgAGBQJW7XdrAAoJEEeP+yNOt7fb5g4D/3l1fvZ5f9QkPXfytNluKL7P+gUmrqCZVZL/ +V1Z9MdEKUhfIebdixAv/AZsaqUkt3sACCzBuus69rbs3Bf8/THZZhYxfCUYgaT1oM4M4if4U +iLTHJv2b+wTQEa2JVy2RiKMJKHH5CtocMcdIUwQx4uNA24zYc34ij/XNq3Woc+UgiJwEEAEC +AAYFAlbtd20ACgkQXNLoxTvPjTS3DgQAsh8N7EJexVIFY/T2yeBtWa+acRpdS9HwTzMjeoym +w8sXcJpejJQp1+5YaK9Du5TFzM9WFlWClo7/mFNHnqze43G6fAyvzIXx9OwyBvNGtlv//L4i +D7rW8oHFkvPQshL8SuBr4Pe346nIEhiAZTVrB70E8Bg8S0jaUP3/FYpM1MaInAQQAQIABgUC +Vu13bwAKCRAazzEtMNO5iUWoA/9EXwjXIwH7uOwkD4t3MQL0ZYpnhqB3gEdAi2Q7u1DFcc5k +PYq+WehHjXSxIjLF2KnNdHR98djl81AInGxupjHsltZ/b95Kmxv/syHUEbVQCb1jFKV0TxNp +BUe3M+mRu0J3WTf6q6nYN10DieHrAR38ToqIKGOuJnmWqu1qgDYY+4icBBABAgAGBQJW7Xdx +AAoJEDvgSJbOT31A8YkD/38hb8/dyTsav6jrBXLEIRoPZCykFm6dpf2iISLuQKcMa+IqCxxB +xqFJHhpxAJrZwWj/NcEnswROGfdZPfVC1a1OhNdL4zCJ9q94Ap85jEMNCQQLnJ2uhqTCnmfZ +6ToCHGYvNY5XJqHuDkqi6u9Z8vv1qNBGfD/TrS6hcFaTGsHKiJwEEAECAAYFAlbtd3MACgkQ +EuMcuky15TAFDgP/VIi83QmAvsvCL+0Mgx6WuSzq5rNOW4PnZdNwMkun8fLljMnn3FspUMNG +livfOiyia2gK7RCN5lsu0ahHRIBdMaDXBo5AAIGmzjhNcIZ4j/fUaGvyH3VfEB1CDQgQc9y/ +rshFswA88W4FWn5KfNzblZLKa+VEijOxtgSFKLUB9iqInAQQAQIABgUCVu13dQAKCRDzkk1n +9NZ/jrfEA/4yKhtfhHPjGFRMjlhU/KGEdO69rUlqwBYeeZNN2NSmgFaRxGAPPJREiD4esSaJ +RjXHGXIAaWH3y5XtPdiY+iGb6T/dtV+XJ3YUGPvFEQPLTCCQPEtQeoNU8b/aYfvgk7SocP6y +5r6o46Lzf9frU3ymrVQQOZf6sKYs2OBl8OrfQYicBBABAgAGBQJW7Xd3AAoJEEyOZdkTmaNk +1+AEAJ4q/ppm1fdl7IavNo1w5zK2zQYcBav/63/3x4iMO8xaSOKEgAf2QNVWiacqRxLw9tOY +pANXsy9w0bYdAF5VCXpUFm/z98VPRvP8zlIfbQelAbxChIgRiwEcS09mes72wxyGE9o+66oW +pFyJxIJArlBnIdixjAheKwZWy9VQrysWiJwEEAECAAYFAlbtd3kACgkQacdY8PEn7GDYVgP/ +YEZ+SGBkli1ssSJUuV998+KAi0cDEly4KQaZOCRq9InJduySG8FqlKx+/6mu+JhQyEleUVzi +hP1t13m+QRBdsI8PcoVDFJKj6SnP2mn2IiM9Fc7AgFrm299Fqa7Kr0Teuc1atStcsRlBylKX +dWyCmyN7oUD4qi85mHTapYK3ICOInAQQAQIABgUCVu13ewAKCRAU31FALXBQkAO8A/9N5Tzq +BUvAx+FvmB8QXkXWgbSPE9p48rkupscng4rhAqyh15w1b0iqf80b8inSWgJUOgWdtDxtQ9HX +r9sRnvEG6aLcUBsxvUwNpkrL+8Z4gKbQ7bGVGR9NP/doCuIeD3LueyZ1DK1mV/eTA/LD7JQ8 +/ehztiSMptJVzBGCPNP4IYicBBABAgAGBQJW7Xd9AAoJECeIQXrvEW/N7fcD/jlLY+P8TLj9 +bJMeep5o5jlzI1KMoavqqAtmVny9RatzzM69nF0eZrgqKei+pok4C5CyrVJM0+r+0lpOJhoC +dx+2NF/6s1/dU0IfnDFQ2E+UK7PZc2RYD100s6p8j0TWFS8RX98TGTs/1UQpBktOisYO3+4w +FwlGEE3/toMgIrvXiJwEEAECAAYFAlbtd38ACgkQs45tcR/Coij8RwQApwxiKz45qfSDvlt1 +SbVCaEjI/GxYwPmzhvSEJb8i2nPfKlljIQdS0tc6BgKYI32c7RfUCad3p9pE/sCJRLEbXamc +d5cO8p3BLI4Cirne15VrraDdnwDuUuDcLcNOZ1XOfQE42odny3dgzamO4Ejg/hVvhMMBQ/6z +XLdMoPn3kZOInAQQAQIABgUCVu13gQAKCRDlfq6FsCID3QtXA/4vi3fY1guWTEP19cGmK6Ot +zOfqexS4GP/IXg0rj5n9iS1UHsEM50eBUXBzQSiv0w/aTWN12AJWEWIWsZFhIAugFZnFQpBb +4ziFlVEwWogHwHMAS7OrLRJxiAazMOCrnsW/HxxbbUiAt57uizyPEY/J/lnYp2b4El4E3Ck7 +WTTM/YicBBABAgAGBQJW7XeDAAoJEDDMNhXnPDpJzZ0D/0ryb2jn9yygYwRJo/kV1RnNZh7j +JxUeKYgbXkArZmFOLOb46kqEO70fFlrxcc9OcigQ17i+HfhULkJk/BZ2E//Xa4CxY4Fkf3Op +DFM3OH13UgTK34AGgFnIb9EkGtpWVUH6MCfH25FxOAhj8fJqvkW2ZuZXL7UIxy0Zn/4A20iU +iJwEEAECAAYFAlbtd4UACgkQ+rimOtOhxTlkHgP9Fjf/lwKD87xVrC+oa9OxdluJz8XDqork +mDulQ6l/ViravpVnukvg6y9zBwfxegOWjOCZWduN55BULw+8LWLjv9wjx7XL/6eq1+oHdwuv +/CQ7vxprw5CzLivvxw28EZfsiwNko+wrjimQh9wBy/N4gHTNtMSvPnEF1Tx71uRCJKCInAQQ +AQIABgUCVu13hwAKCRDssEKIdZEsSlIlA/0VOvjFtu1PS9NACdsa7dZizWhHxQHyblBkZrmf +yugobID6DVQY8Na6+8qNO4o92GnTBa5JUPJVL0gA6VBFiFUayhN1m+IliWzH7J0XZF/JMSJb +wU8VjASqUfOjEtD9KxOWBOJVrvuwhNUOZ34iJMh0QzyrUAbhrS1ALqjFJX5o+oicBBABAgAG +BQJW7XeJAAoJECVauwOCwDZUe3cD/jXVqKbZRl/sjKUCyq0GECSPKir9xvIY8l3wJWkEsnSm +cRQaQFhdsarU3K/TIF20cWxWF1gQWgxySlL/Im/PXOmLHjaMpYkH132xEPM4d36329ryaTYi +fHVflMsbuBDEhJkKOI/jq2fcvzqyDtkAZNuMhCcFQPbKrT/tIsxHeEgEiJwEEAECAAYFAlbt +d4sACgkQzrwUsNNXlpkzLgP/aIRiMQ3rgGUlWEJA+THx9RqOI1UJCtIUmfiz+gEPzobdeLwQ +6u1pmG2x3M+3lSxoFWWkc1OigXQzwUYRgUAEOTh9BA54ikMh/kneclB25i6kwZ7ebR4u0Grn ++EsGmjHij1uTT/GC1frxDD8CFwxA2SG/Rzk3nEEpJu5TGabIDrWInAQQAQIABgUCVu13jQAK +CRAHbM9LMxeRWz17BACgMfcrM1Bx6oBEVX29Btb0b/X4vsD1OeCKfZpNZw1n4SlBB9UecK1U +Obe9OAQXlFDRI+X5XOZwDr/Qp/AiDcj7GL2ZgFHuFQWwnJA30TFpVK6i23IAcYZiwVyZUanQ +iR64gx9T6JmF80K+xl3Ai02wM8cC6gfDAACCsBak3z5qaIicBBABAgAGBQJW7XePAAoJECOW +TmLPTdeAg1gEAPfZ1TFONNHvjH88omAk8yKCrq35Y0TIisx82KxONJoQvveelGRuWmciwbQQ +Ddt6y1GDsKA6t/oZJyeDcjFeVLWby4AAvYt56nQJ1FZo5rf2eoMnrKhEQRRtUYIngNH089dj +DaC3SzJX78CIkBwIU0nUFLHwTO6Fxg0heLQ0/qVRiJwEEAECAAYFAlbtd5EACgkQbv5qmke9 +FViy7AQAhHlVOFKjgqwc2Vyi+E8EgI/XVQ6mWtECBe3SLf6uA9FXoJ19qY+VufAIO2CcN839 +IbX+RZ1tQUQ/a/UJ2T4MQNfbqQZSArETv69Fc+7h7aEzLFiP/xpZT7UgDmCOKYGwhVgSnTYB +8K7H9pOWj1hr+gkBxlwrZkJ3j2RxU9GxCzmInAQQAQIABgUCVu13kwAKCRBK5yoQ/n+BXYFV +A/wNwaByWO3rTpCtNgrKMOI2xDc/HrRxYSIgoUzWi9jOtcjZSglsvuJqrxES1KtkhUWHurPq +CV96Wv00kEayRdqAJ2P6mgeIE9mdiWiPEbV9fN4sg8WloGXccHVoHtFrv180jajthg89ibch +CQM41sN+YO0Zb4ECQq+LijiknfJofIicBBABAgAGBQJW7XeVAAoJELSnEKctSrpBq7YEAItH +7olKR3SJjylCbmVOPOHHjl2vmfldoZr5KHTTohXjFOuUgVQvGE3R5lg2QeyJS3YBWub0Jcjg +/9TgIf6SQ01nQ3rDW/Lr2wM62zgqOGZezqkw7ZT8AOfglPP3NUOiGDYpImprGR3LKCclHieM +M3Kqc89WFczoUlDmLr0KORpRiJwEEAECAAYFAlbtd5cACgkQPtTSp2o/u+KACwP/ahp8Q0n6 +NQyBlc0ZJiTLZgtEF9R4hkiElc5lLgLsMGmu0HlDpRtgtWQGWBCEF9j44MWzCrO9roQ8iCbs +MX0XdeBmpolnNq9x7Knl/vK9RwiJi0Z47RXDJ6EZiO/TmPI00Vupkhf8SPOzpw0wJheg49A2 +XZ2wAqxltjeiCOxnKbSInAQQAQIABgUCVu13mQAKCRDlp/BDfl03bPVzA/9xx9ODQpkd5upN +8fehhakEAzD/DA+OsEViBpUhJ16MnJSADgle1XjuWykxISpI6HJTXqh7vdk5BiuhZt+4jfWD +8OAdbnXIHemOLw3mBu34tq9Hmb699BsIiOPWpl8OomqtOzGkfrmggjj7IHDOCGgUFwZwl3Pc +e3ukTMh8I4M7OoicBBABAgAGBQJW7XebAAoJENpLE8Sc6+CoFD8EAMOihmw5MZRNuMmGPdc/ +SCfDLPKv5QmKCfLcJ5ZP7gHtUc9ahPMKXskQu6ze3LNOdDdkD8FGIWDPu/RqERkQcIRwSm78 +D5RkqVVnjp8hk2zpQyquwmPg/AAFzKjL6VJMBQQuchC5/fvGDRjmgVUKXS37nQ/qDlbFMgEW +lAW2e69wiJwEEAECAAYFAlbtd50ACgkQCB76RVis7RZFyAQAg5Z/gmL5kAA/J03lGRjCxLE5 +W3ToWbmlNX0cm7Y0WeQ/al1L6mayeNYtpX11W6NUoexUZ3w2aJEfGkYEl7u378Uoyx2tZmh2 +7SHvYkKtBEVwsavUFg8St3bHeBQaeiJre5GWLa9JUyE3KDLzHQMlTz9k/p7Pq6Ytg+/CONHh +Ut2InAQQAQIABgUCVu13nwAKCRBe9fTowMNqUoHoBACXqElLXe4J7zSRVeCyi73XcvWqs2dT +ZNXEze/dtPguLMNjOLJv96Lqcks4HuOfH0R8gAksVz2RaXq9reLiX1zfwZT2ry7dLB5Q5Gpe +HqVcWUqrq15d26bwy7YDKpmQtzGWRzD5ixJDxTBz7GbOtEXNSaiEOHZVIUPxkmIIZeTBhoic +BBABAgAGBQJW7XeiAAoJEGKcH0YDjsVPYCYEAJ+/DCiQfgWy3Kbl4OJBmNai5sUo+ElRsK6p +vyVHAe0NKyK5efdrZ9Hj3x+EddxxCc8ilRTfldd7+zh4jbu1pI7BdpC7VUcyXU5+IwFDscvm +hqs9djPAmXSeAr51js3DYhLBxolD2gZTJVONUNU2jONJSdMJZSdvvf3GPS0/SBqAiJwEEAEC +AAYFAlbtd6MACgkQcMKNtIzdBnqIBwP/W09MgSK+kGN0wrNzA6zulA/Clnb2pckBKbptsEsi +RCCphZ1JTNZ724wMvu0QbWxTDVBt0BWd3KmyZE17q1dpPhPjc/jdZvL2p5beAmiYfE8hxvTI +QX/c41eK3Bhov1IagaVljCgPMXxIRqfeMLi3nxEkicNKuatSPrWF0vauOKSInAQQAQIABgUC +Vu13pgAKCRDZ6U+jJdbDwo8WA/9vpGgprEWue2LMfxPUcC3dIYYgBCBR27zHCMeNlTfbZ77v +jOtGfAWdi4kmgp3xMmNF8iROD3Tav8vv3ZG5dnPjdk11Vx0GNk5d5mchZc/YZO9YInZqgqFZ +++hM4hpzPmHg8kjC+/iY4jzaiKLvRWVtxpsGiydpy2bxm2sqV4jtNoicBBABAgAGBQJW7Xeo +AAoJEKp6OA6whXX0BjUD/0CcpwlslAJegLELW/1i0OZQwzhjT/pirPG2cL/to5bj+ki/NYC6 ++isJ+kTPfCxB+X93i5kXQaSVKiFxUwcO8xVrlt68yxCFPCdniGcbSfjqIEI0k3pTDd6jPQm7 +SCmGaAPGqTg4Bjlmoo4QHtBwe6UekCEVfhgh1J3xThK6c0HGiJwEEAECAAYFAlbtd6oACgkQ +5pnQL0JdFjHftgP9Fz7cds/qTjMTlQw44Pl4sVezO2DLjc5aXBNrdya5E9zIfuQ48xfFDlhO +cnXvW5p/xgS/NgdOPlOTByHKV5l5Vh7pJmCinxXRHGFjJuGUsBGgaqsPtBDy3Pn3WjV0XLvi +fGHzdaqCGF8+Vit+SaaScXtMmYKEwCCa6o17Sn6chqOInAQQAQIABgUCVu13qwAKCRBIm8yB +bUWQdkXMBADJiO5G3riafVmgywAHOvCstAFKOD3n73a6dqt2+F/InhYO3KUewxZAjQpvxG3d +LUITcMrhLioHwKK05dNZCkMk8X20jVg2j+p112Y5HidKZzJg5XioZp+abHTjQGM2pBJbg3ZS +T+xs2ghK4s6vZXU5PcNcYdvRv4qbU/X1qlGhbYicBBABAgAGBQJW7XeuAAoJEOJXCrQ//+NL +ce4EAJTHIRdXCX9dUK1Ksksk/n4/fS5krbFoDKFyAAArYX2/aT+/YnDOjbU5eRUdeYdwI4V0 +D+atjydJJT1YE/H8TwTmccC4XFmvEm6Sibd7ilE37PvX4Ow35jHDsRlpwklY/P/rtqdSMwry +JJ0jdK1cKEtTTP4O47D3RooKOJ+ZASYuiJwEEAECAAYFAlbtd7AACgkQskhePjCx0s9zEQP7 +BZ1SG0oPgNbqn6o4AM0n1ra/wfQsdPTOhWMvrluyCIl/EF9Hy6RZPkvDzMoJaGiANM0TH0q8 +0fMpDEPKnq1NuvTNrqc5QJIkizmLqR6IEPLlMlrtagTZ0rDjJzROP2jcAO8CIHQiwjstIeuc +6imPb0EoXhXzV+/JtBSqi19UvBKInAQQAQIABgUCVu13sgAKCRASMNbvm/QhRqfTA/4nhT1w +7ozyyt1ldOpsiVepVK+g6fkWUdb1iuh7T/ViiyYTlRWb4Q6OI6rghApC6DQrKeL02xHvstc3 +Oaesdi+bnzBFoEGBLsPPz2xrjHRSYtwyB/Lt+Tl5lh+mGGrjD7jLO0CfsuVWzYucvYf4XXCj +K5oUxnByO8xs/kdfMAYnaYicBBABAgAGBQJW7Xe0AAoJEITKljDqjzTER0UD/2vBs1RVtEDD +glRDkqBLD7c2azAvor9WF8AV2u/UBpIfrySCmsOy57Vksa2ckLQUmkcU3Hbhj8AdYKM53VKo +ktWkyX5JtpI6J7aVGEMnDPqmU7/JsIxHbZpdrdxzZAc4CGrGA9C+fnYdbDgzlrZPI9sAdyl0 +2OAeenIXTb5u48DPiJwEEAECAAYFAlbtd7YACgkQ4grrXFhfWHwIGQP9EjzOv9G4cBVVpzeS +5NM3me6oY0rlUmIDzv5mxp6PZLmNicEIzXC5i7j635jcDWYf21YyQEPQNd+5WBIknt5lSHWW +YWmCjgsRiO+vBuBAvYIjqu6eZzYXBP8Cc27h9kCOR1NHpvIXJ0ZMSSmpa6kq09pNXMsDxNHt +Q4kr3sFDUxKInAQQAQIABgUCVu13uAAKCRC0NstmuWihTbdBBACywwWov+KY3QB7ybOFAiCg +FYquqbYCRS8qr08taLcZ3jawxPpu8Ub+jaJUDY0CJeNP96o9/pdGH/z8hrCVJHnJo5P9jxoX +p0eED17Gkogtjs2wfAl0k7V7jb1u2ZhoWVBFRH0+TopNKsOV3JUupr1lEm60MwGUlKfOWBV5 +QKgTDoicBBABAgAGBQJW7Xe6AAoJEPsxFlj6W7hfwpQD/AzN8vX9w2YrHEji6UYPrkjBEIBb +dra9GiogZTXqJLP6zVGbBDwoowAKO+JNMnN04ugFEGUN9swHByl1HVGwg+r4XQIHwQuFmfll +jyJy0nyZwOVv6+GKyKPP34PEbiyEPTAvzJjZ5QX7efa1jwR8LeI8Oc8UZ4xjODGouBbZ7wYA +iJwEEAECAAYFAlbtd7wACgkQAzYIcj9svzB1bwP+L/4TL+xmC2rSF9DdeCvnGDwZ/LN4Wyci +oC167QntwoDV5p1jR62GLNRBA4V+5D4UwsXkz6J74lICFSf2ZpBlQ3/HoJqSSE0Z3so45Ehc +0QSe+ZbOwRB8o6UBxaMzQmljFlVq6zASkqXG/qc6UBTD9XSid9JKvmWBW6aCyYxt+8qInAQQ +AQIABgUCVu13vgAKCRDCP1HTBf+mxOuDA/4gNL1gX1wUC2W0jHQFm91mbyGWOOcZqLsCwtXk +RO1rpAtXXSy2uWrDHIXrrspioGswRPZbI+VIXvD2bJFpjmmTnLWvwLMYKj3x9DPIOW00TYRj +LRBGdzpbvjyJDgbCpn/VyHLGwloX6EtaYwq/TiAtlojN9pcNyHhi94mVF0UcTIicBBABAgAG +BQJW7XfAAAoJELbdm1BXlSVSZV8D/jlNDEQlMeoK97h2fWH84HpecmRfVyNpuzEo/DYzPxU9 +yMAXMz4PVr474W7wObRdSg1Hmu4r1Ds2AQvijv7Ss/4bjvh4aRTSjhRw24GtOuqWJWBNe8Vc +yuIK4D15RO7YQnbDAoTcmeCq7v8KJn0SazRYiSMUzVwbNGUWSekLwn5aiJwEEAECAAYFAlbt +d8IACgkQi5tEvF2gEk237gP/RJNB3SMtWbkzQ6S8E63Wn9eRgRs283DZbbEmfOghbMx7xuKO +aCs/Ywnf7iw9WarJPS2Ts83HajwT1KxIVenVDroMVaXjhaqpkcvljJPoc5mCyVsAmFrlb6iW +TMU+dbqieBBEJ9TDoNM1+pQ8XzjBuHxxF1T63vF7Bi1WwfkFKZiInAQQAQIABgUCVu13xAAK +CRDi4nLJr6FYo1c0A/9HXGyLDh9IZwcxrxOoauVO/4I49kKYSsiZa6Qpy/Xn4Exsj6Ww8zHY +JdiRKjBiV+mY0Enj01fE02istmnmSrztqxC2B7qSuKrOIiT2+lBVvuKadwmXXE8K/QpnorI4 +qZq2gFGn6CJYQhNV5xCUIdP3dy02XWJM48wpEcxIH3kKO4icBBABAgAGBQJW7XfGAAoJEOYz +6osYj1xS4ToEAI137SFaYy6OLAU7HfJpfDJGP+dYFj1QAl+XlcqHu5S0AROBZ0xVJOEtgVos +j8Rhbtw8JaOLot6jL4XQNeR3167Ipg1nG0zTHzUCZDEpgasiW6ZaayatDtm1XLhW+QccZC57 +6LoAGQnBPco7niCep4IWN84f6YmKkObpWhhveC9qiJwEEAECAAYFAlbtd8kACgkQ7Xn8AlHj +bl/+qQP7BxdKhHhn4e9QLBpikHveT7pLuy87/WKDoXI7u0AdUYKVUKPxfXHfa2lcp4vRysXf +i3dMCkDjpazUKPd5ixGXdnWR9qm7EZ/yuRarnuUnU8cu0dgWX2yfA541KTKtP8aJyHDTBUAf +iPS4zrzWYY6QNXxl4RlesMcRvYp6vIkchdaInAQQAQIABgUCVu13ywAKCRBiVRqfuGzXQx6m +A/96V9LoVZ4xwpMD05jbwkLM7QVgbGaaE3TemraOe0Q/qE+fa/eWcyKoE7vne+0TfGPeNudH +BwkBg2p8feKX8X7uU4lC6/t9GRf/P9XaJqxyN7vqKyuePPGVeV6VQhnAPMwqchFys1GsUsy0 +JuRwRRdpRIh18b7PvA7eNC5i4r5nY4icBBABAgAGBQJW7XfNAAoJEAVBrzyYktKr7egD/irW +ClaCtdIFFe3eqMQfCI4hOAOfoGvzevWZ8Vz+SVJFaX2mmOEB4WCNV/cMzzklM8msG400Rwvi +6xIrBs870Pyd01Ag35Jl305r3/cPP2mYNskFge6Rvi8cLVctH87eKSJGR8ErONHsZbfREIZ+ +uTbRMbIZ2MYlugA9V0GUiQRyiJwEEAECAAYFAlbtd88ACgkQN0qNFOeDQpurEAP9Fp+vytp2 +c/PpvV3al0m4vfytY3ciD+am8AcKF6VcUJbQLI/WGUgNMFYw2HrCFglCnBdE2yLs6JiZYfop +UNbMy8mdmjIIC3ao9qMYuibsMrvQ0Wnm0bmq99Wi/nfUSNeByCCmZ++TuSz8zSOdhJKeWoKk +gyoWSbFMUWAvXEsieGGInAQQAQIABgUCVu130QAKCRDgdwNFg6tsc7ojA/4pQCl3jYqr0ie7 +AC66cTGokcaX4Ze0L5lB+kqn1uOSQ7TsQXgDDnJRglaz2v5ycxPeAAU5eWm65SctG6nj4MLL +tZxojSxWhzwgNtztuXEtadEV2d8mdcv/5AC8lPeZT0v31meplE4No32kvoEQGyCF/NR4RHSc +v5w3tiqIleQDWIicBBABAgAGBQJW7XfTAAoJEPSIR8edsPKczssD/3iIrZCEQelBW+x3Lrgj +UZkz09HhlKQgA4j6FfgfFoPL3DWA5Ns38w2dKVyCJxbNL0IpKjmVKrmyiCCTZX87IgBwMMaq +7Can3jBZ29naNESPIUC98KEcdXZlWgJWD5Fc4Q1WZn/5lsIP7iTxhSC1QQpN0mGdkuQ4uz/m +HahPN4hMiJwEEAECAAYFAlbtd9UACgkQNncBdLUClI82YQP/e3xa4v4zPW4uGmffy+Prv5HF +kZouCthO1Ptq59tbHiEnNwtkyqOJ7W+2DllVGs1hUBIsqoGjP1k725iOoZyKnR9wEkcDYOnU +s6XBpndk6Mvw0EFj+RxofNlMHYnw5zC0c2nK8ALk48GUzwYz2Q9KOsfQtUEQ8G09EHoEGkPq +qyWInAQQAQIABgUCVu131wAKCRATJYEymH9lxDPoBAC7TZNn8Kz7JyucjWhw6WyjdvndfJIE +HLLNfsb3nsscDE16aoj6cqqrekAEF3ACqDCTJMT1cSRk1AigU8su7saxhCl41UMPP4Ds929H +nggUosObbDqGUyMcjV+23F+UJKWpa5zgdf+ttUICu6GMjCriGPIaOSjX4epDDf0DQvJYsoic +BBABAgAGBQJW7XfZAAoJEDmgJno13DKOnDsD/1vY7x2t+sjYwGDYZYkP+CadyiU8/vMqXaxs +jolmpo+BveaXDbA0ptLkCVVKuyBu5zvqArmCRpkVznpJvIZuQ0eZUKy4kIzmF5b2ZeZVFWSt +ihSKeFj+sGgAV6sWdPagnZB3p8EFyZ8mCgAhoS6/lJsPapSLDKHazMtNihJ1VcGaiJwEEAEC +AAYFAlbtd9sACgkQ7lRmm8ekTtgGhwQAofcy3FOmWIixB5tKP40E0WtLWirPl1ShLL4B/EYV +eCb3whrcOBwK/D7FN5f5Iah6x4ss6jcnUUUValTtCuuF828n8QMGeJIf2K1EE+GJjgF24Zya +CF5wSMhellJIj3OCmds+TXzU+ljNsVHpzv6l8pqvqRieXyRQEM4FE8q+f9GInAQQAQIABgUC +Vu133gAKCRDE/MkbZk2Tu5T6A/90a2BVeqRQjyxJFdxi2ASIPMigUpFOzwxpGBQ5vUtoSAEq +ZMBxGc8Eu+zOeDOkskUKmuZF7XXQ74nLq8Ef2X9rlB0Bc+LCwEnunw3pVEF0PfmbQEA0IZ27 +BFSr+zzrMb+g2LZOAm+670GMIqsCjA4ilDqWnykFwaEnPbHxRu7n5oicBBABAgAGBQJW7Xfg +AAoJENt7dubESsKu2vgD/2c2B8kyqR/IZ1+kIT1ljUCRVJOrxG4PUoxhZrfG9kZjFYfa68cV +efA9h78LXfFwVxVgzyQL+v53HMuqyhOSpUfUTpGiGIiRKY2LGiRbwSIFr4M6Njfzlom5sDOS +6Kk4MsYthcnI7ddViTjTzfgIPK8onWjDa614edbOm37g3d5tiJwEEAECAAYFAlbtd+IACgkQ +wTuzW0j1kmn9egP/VlSN+ZQymyiDdYTcBFDhCsit5WTox6MaZxYl3baoscaVL9Qh1sEQcFGJ +DZ9e7V+wAXbnNN+LrNjpgLZufXimX2f0dFQ+XqipFAMqtRYJhRc3htaHyFjns6r6qQRlAorx +JbSnPFCr+aMDgjG7RE+UdHL0Rw2zw1L290k2pGLBJpyInAQQAQIABgUCVu135AAKCRCC735a +obcabxCBBACIxD1ptWq95HhQt14g2t7YBnrXHt9yVQDGhjz0+ZEf14aMlrtdQ1EXfl0t79qh +WvlkmNxNJppUfEEuoYYujvJIYo14hnUXg4SMimC38BVuvzeUBSVuVlyEM5QOWChTiJsG2CMl +A/kGO+kPcDh7F9VOimqzrNJqeV5BUsZPsp954YicBBABAgAGBQJW7XfmAAoJEEPtmRiF5osg +iQED/1P3REN0m3gAFzlmE8yP7l4WTJBcVcyuEPe3ltdgCb7dnIuLf3TBiFYVR4jQHHbUCZdN +/V8Kous4wWk5uRoZvZnAf3cTyvsol7eWbld0zPsyw5zU37AnV+cl1rugtVSfccgGVQIUMzfp +BS0qNJ13BA+s4EksTvzgypQvhLgaTylgiJwEEAECAAYFAlbtd+gACgkQE8EeIHx0d6miXQP/ +U4mO4A1f2pOAVDkrLgyJmv3Xw0ewcwRXdtzamQPCwhZILz4qd4qPE+xQaV55KPjPe8fD1hNI +rcjdep9EEPztGxIBFLM0ZV+EhWyTxmwOu+QszL+bD9b4Uh8SussLAuhCefK54jffdbSH4cb+ +usEBJUSH4HcEQygwKrpUVFnT9o6InAQQAQIABgUCVu136gAKCRCWcsU+yK4COQrAA/4iDFM3 +bCM/1R/i/N9TMIZQVEyoYbxKVDRpC3V6PRz/NHy/ts83pTtgCSu1ztFHgMHT7YoplipfB/hX +7zyY5GahQOpVf25hJosne4Ms1n4iqEIcHw/r70vUz7eAf7oKsC5pBUECR/N7tZmaTnEzMV0Z +iWmw72K+ifC+ZRK1Zk9eyYicBBABAgAGBQJW7XfsAAoJEMQs15/NiYKPppwD+wZFuVDcSqqG +5Un+S4RmTYHE9plekW4uL9AVqPmCi/CBf2gspiUNTOnb98LZZlzSm/Ofu0hAAPTxo2q68+xj +I9Atvjky+P4sQZXIfIISNDjnVwHIAexUqayhm44oJqrdr8qwFnXku6IYEtzbFBzRFQRbIzEf +XCcwrvQFICh8BoXniJwEEAECAAYFAlbtd+4ACgkQJG82nVCdbtlZ6wQAlahjWqh9FAcxL1Yv +iGYtspecmEn1lh4KgwUo4QiclIDp4eG0XW8mYGgAX6Ckx3UWwfr9oa5v0rZyjKxFVpwamm5s +OQJ0wtehuWIBnH3Wy1Ym385IbxPMs6CtpwQ0HetIUgOwhOIav+H2O3vEFX4svNyZfHenzNmv +RHKm/XoEt9CInAQQAQIABgUCVu138QAKCRCLDHciN2IvGCVqA/4puRBzPtF6FeaKeAn+C6mM +d7AujiGuo3vGRZm1CtcevXJyIP4IV7sHNnHYqnzl2Hj6tCz50AENqTjw5fn9MNzet6x3ZXQC +DJFAjmxCp5ax0O0d/u8InsQty7mSNvPmQkFRN/ukfCI57Yn6mMgvK6i6/GIaK15SexO7clQ7 +KmSPYYicBBABAgAGBQJW7XfzAAoJEAX2TGTCrEj8Bv4D+wRaDEpUK+PIorwTC3dMSd3JWxnm +IV2sBodSB6XI7ghlaJ07YHxi5/F7puLsPdk2giGno7s3IykqsDyb/W4p/nB8IR7rKRLA8OtZ +By3u3dT/4+jcoMmVMtF3rpqhcvdoMmpCK0dtfi/MJ3QDYlFigOIJMTO1n23QBQtcY55EsdTo +iJwEEAECAAYFAlbtd/UACgkQ3BIsoEMTU/yCkwP+LkDF3+Hi05d5LURR+VzBmL9AB5VP/r5u +D46LBGQ9pBa965a58/w7YoC5jIC2RFE5z696wbyxt5kp0q8mQ8tkRytXALNYCAt6oDkJSIKx +YRppPKkhj1tkuSGyylXw6fmGjnfQth83CR8bPzGsq6jdAz/lKmHAaQglzyG1/iZATgqInAQQ +AQIABgUCVu139wAKCRA8/6HyvfNRh3WkBACfWk7Ba40/Nr6T+j1INbp8XE247gDWB40UxmLb +NvH9eAevzq5Ls4GfjDWE8+4u9vcziJmPapB4MNu+WH9PgpoJWb/M5QeO4ReQ8woaeCa8N/XX +6udKLClF1sxPuWmnvQ11X0MNNIrDDTRwFMAHNzFB9gtmBKDf6RoPlqyDsSLodIicBBABAgAG +BQJW7Xf6AAoJELFcVml5jVyUCigEAIF2Gx9nPJFcfpj5J0y9/OJyXtX1wdLmhE8U1xOzk3KG +ay4vR8IWurSEN9MSEYLZHTKfKOobUsBxKM2FoJtT9Xo+d6M6j0bNI7wtn7zgvNKBM8atlfPz +EGpfkYYTMExuZrbo8kbdLE+VQedhmHgurdj8Dk49D+xzWECnEOjfgQS1iJwEEAECAAYFAlbt +d/wACgkQOFtpzkCNkhULmwP9Ew+hqFvyZwSTw0zbAxGs4z9IRxlrcShegme6V5mSkDEiPOsw +Cc/xCts4W3JMsNXLi44+ZzHnw2ce27rZl8AaIV9PhzotPjWxJxHI0xtdAsYzm0692BSCLix+ +zjcz5A/JOEUlCoDEUpqF7TbcQsOmkXRcRerXIWA5ZkByQc+k1B+InAQQAQIABgUCVu13/gAK +CRD4QzxJ2ymhKE4nBACOsJ6WRxZ411xPDHFmc+aZBrCTkL/nfOzBmaQfnBs0A7TNoPOu5Pyo +3h9COBh6jsqugsGEQaVZYrPgQrGmKEGNLgZPUro1LqBIx9dCVUapYg0F6IN14/Nxow3DFVv9 +A1jHC/zrgbsaclz9aqfIzR+txxXA2OmLND+6sNNra47SzIicBBABAgAGBQJW7XgAAAoJEFmu +M38epL7xn8wD+wcN0VSa1R7sff98YPu0jdTAPKhQXtgovTdoyZCNilgrpdZGaL998uDfnabB +x8eW+6ZfrPQTxXXY+42ANWiXGf4Y52j55DARVw2f/vOEmHP+PZCaYq+omMRwSt3B0zKShlRV +0VHy2rx6Nde1hn835G6GC70j7JqLAcGIc2eJ1ynZiJwEEAECAAYFAlbteAIACgkQMENi6XLH +YQpMpgQAq2tNETONKX39XPuJ4oX+6Psc7NtAgpgQNzNq2lk0IJ85CryfJOvl8I0tAWppswy0 +in74LvY16EbwoRmgHVUve6gLQyaOq6Q+evxa87AqEZP1L4iJF7oZ5Na7JAyQCN3iE3dMsSfN +UtfzU9B7p4HH6yCpcBqgnOzjEnQ/82TE1VSInAQQAQIABgUCVu14BAAKCRCX9MuD6+AYEW3U +BAC7MY6v+hDS6D1cOIqenCFn3DGuJyyxnXS9FIRKdN3a9xIZ/U+qDTWu0v5KD4fg9NdEHLfS +AOfxUnir/LwtIt9UxXligq5pC5+8dEnVQFuADHIP0Onvw2pA9Cfym10AIcf7l7qfwKxobaRn +Y+U0zw39kPavAegLon0xfUsjiKdNK4icBBABAgAGBQJW7XgHAAoJEJkoD6jyispS5jYEAILG +G2AVSZ93q1RQCvZXSkUGcl5odTdZGaazUAC50flqBmrHpssHRoDVPfDR73IKc4AFevZoLiG4 +fk0qhqkQ7BEIjg+WN267C2U2zwHCOZuHr3HkedI5iRMuhoE2/e8PTmZVjI7qZrUgP2WxwtVA +xngoYrfQDxEukJhZYgQG9duOiJwEEAECAAYFAlbteAkACgkQekRIZjq+z2qPzAP/ZW8NQ5x/ +0DDa2zYjBajpREykbjdYYfQ+IcMAiza13Hl3R2TO+d3O5zda+8jmL02JI1Kq9fssw5mjf6/K +m/QskvPUqhU+j1pwP7FAg4hrP3lNzdKp/Lh8N7OzdXKhfFKb3thbJ+nhXmq5t0ndw8mv9JoE +PE7Kr6W/q6aKLpNX/NWInAQQAQIABgUCVu14CwAKCRAbpqfRKIaBXHNdA/4ytRbWFVo6xDKD +Qjmf9pNPTKeY/Ey5QejuI1jJvtPZM5nQiTF0Rv8Gjv6IXkCG7lH2MPWP/NiynxRT1gCdSPZj +eRbobo8AYXHWYOB5r9/zaThAG8wJavuRT6z4pIfKkALRGQQ2UGg9zYg92FHB763e4hco5PbZ +/lL91WVQWHSPqIicBBABAgAGBQJW7XgNAAoJEAhAeD0vs7aVdGAD/idMu+Uomzm650E+N2We +1AnGVyGyzltcE97HJVoi+m/bANbT6Z/9fxyqMkU+4JCphLisMwB62CD5hsFK4s72N75/Y/zC ++NqbHp3plaJL0k5yiFIkco0Uhhar9Zyv8LSLVDEGk5DNDSAaoVGks8J/DHbhyHMfYVDTr25C +eQL6rwuXiJwEEAECAAYFAlbteBEACgkQbXgfZJ+4gZkGogP9Fkw3CTDEpkjzJREMTcFs6Tek +T3msLnLe1E9IFduAdDSKdh1ohUAlOKiHqJeiP+1O+R+KbN8s4XVFT7HeZw7wJzvWjtVSBWgM +JCwG2O6U5rFQqVs0G7uo0KrM4HH9bnVEmDgq8NDQbCzBwp10hqs1gXufOw2KDOFswG5md4B6 +6ZGInAQQAQIABgUCVu14FAAKCRBxpwGKFJFI3z9AA/9Hzo0Rjqm4U7a2/XkjAcCoLslGU/GJ +LRISRy8fu///NS2AuEH2SPc2lpJZN1Q6j4TkbhhNRYtOYTc1VJkin+SR8tskBerlPKOrNhta +123mKzRMCMYQtyGSk2GGVPquo30REmCnKZYhXYW+TV8355c/MK96R5CI/2OQVhxo9E24UIic +BBABAgAGBQJW7XgWAAoJEPyU/mSUdCvHvsYD/AgmQfEJiiAO/6vVOoDkGE0A1TUdnc7VaPL0 +rM4RmRd85UddMh/vwJApZpOw45BdaRsQWDrQCS6c4DbDE+cyLFxqxzK74M+hRazixuX9YFYf +LYebi52heJ7j7ONVFUcbZ5SWqUa4SEshOjJtocbPR1BBKEocS/q8y1smZEEcIPsNiJwEEAEC +AAYFAlbteBgACgkQoRXXHR8NMBERxAQAgyQlLDzPk6Wd0FP5vGffVjRqB3J0rnXMfh9bP+99 +n0y8U5QbuMdWzGsaPwF7Tzs9SfFE2eqZaSwKS0gOZgRp4zpbiBwi7KnphPv41+GC38u4YNlh +aT2euglMN13cvj5TUyzLnEW9Ughx7FBaYWZaRsK64cCp3vp0aXiB4ykBRseInAQQAQIABgUC +Vu14GgAKCRApS/Y45BdMlvkaA/wMyUFBGBCctCwcEI758XwwWYmlkhqK1GrCPF88SVQ53LcU +l/eMF3YKQ0SYXLvX5P2Yja476YK+rsUCET63FeUzVD5Jnxnz4zs62YwF/zBd+8MRMSUAS4w1 +VnyPKxoqRKdhplSPLiHfuk9M86byWk9FJ9aba1xfVl2wGy3D0X4gLIicBBABAgAGBQJW7Xgc +AAoJEAI9FJf+uhxee+MD/i4RLhgNRboupCzsakbB7wovLQ7+LoMRks4LEJxW8ibY030nk/4d +QFoVgUvc/LNPibIk5z/Iuheu/rfI5DjY1fiqYkz2I/1HKRBBtbnzJ5I2oSZCb5b1XcdcRTZ1 +v0csJFSQJdyaM1EjL6W2rN3XU73y1eOg1oYKgA6JUo8fd4zxiJwEEAECAAYFAlbteB4ACgkQ +rAxvKoFLwMQMdwQAnmrpwRhvrSo6Am40aMkAAMfvK7WR0GseUGJ7QJFHysDRgD/AlV9OS8lS +82rov1i4VbgLo9TNoqO2f9aPa7aHbXnOxKTwUqRnNBtq/BuXDkx6BrvIkBnFvtCJ6nTW/V9V +lPAPd2fvhwXeqe1v7U9sFBWwnZrZgv+a2YcjnXI/JomInAQQAQIABgUCVu14IAAKCRCBvieW +tlDkgEr+BACs3rkiUwwlcmV5RvEkuHPhQucPWDgDozgYhQrkIqPtWrlyIPZE0KN1p60GB3qp +NKeUBg1hf0/gJEuKmwE0t9WOsLJ+/Lkz7iwL/eokABLAouGN4tGOIZBUoDOCDKeTDB8O+MXA +Jt6BvHdbjqoI5kJrhVdD6GwySe06+1v4IuzOQYicBBABAgAGBQJW7XgiAAoJEBB/pAHcRcZF +yRgEANEfeBuKTh9vcL/kGBXvdcfyACFy+KqWmdXUYoE+s6TyZ6A6y2GrGDuhyXGcbVMEeLb5 +4/uau9mFiBDq/o764jbHNAo9ipyz3WdNC8MfOyu9y9xWj9k2BYObDzPHhhqqm36sUuFwSMch +5TEaJ4fl8hpKx4J3BYo5JmmdevHLTBzpiJwEEAECAAYFAlbteCUACgkQSM6bq1hpHboQZAP/ +aNIKF116qZWqAl3JjlkiAvVfdVQjZlEHop8MBW/fV8ViUaTX0+MFdfbtEKjNLVZgLKMmX52d +bw2vZzsN5Jfi1z/vKh5s6iNdrta4AqkWCDvYViNa6uAzmTC6Jqx2zdP8aTArEUH2PsDYuhSZ +IJs0vCh30YHY4VjoUs2nUjKx6a2InAQQAQIABgUCVu14JwAKCRBx30pvuM8AINXyA/9qtNnK +X1x3XxM87n0rQE56ST4EHZeyDb5MEZ5ngr9WrLtiwDQ5Ar7DLTOkDLwekuwoODkhnQjB7n3g +lqZzgXRu7VIWEx+fQPbbi0nOsUV+H2cz8j7NyOpDWCxGEMn9wDw89biw2SNVorPPprNx5aBK +3FdIokFKfMsKplhfbUTTRoicBBABAgAGBQJW7XgpAAoJEKC9nTAarNHEeu0D/2Ck/AL6RJQm +GbaYkKq22+tJIOtUCOmRwDleI8QkPD9DvXQylQSo44EjnWn8uqLk/VTQ5DC3idWbHvnDkJ69 +hSF3Kvl7DZ6EucsX1URC8lxMBO5iHUvK3lJ+j1UhLrJ/Mo5Zqg8QJvC5+l5c+mxX4L2o3X4m +Z2ub9iB5dSb8aHheiJwEEAECAAYFAlbteCsACgkQboZmSip9oq3FvwP+OEA90hz4TkXVnyWc +uQykIXSMTzYZAZuqDIPXyYfUanKuLsdfOBPk6ppeUj9FBnsmzKpcA7dqpe3Gj/kTaib2ZunX +3WPoCiEVS9oXXvUHK/0ORib9r09Unrw/sNMNDPvOFkIIPIlLg15vUGT2FNFA9fif38Ye/X3F +bAyLHgsDeRSInAQQAQIABgUCVu14LgAKCRDID11fE1VjkjFJA/sG5aXAcdRTfPht9oAZejKe +TFcxM3HVkBp7Paf6I/EiM0pQwxZLC/QXruuaLtNfv3OLB9CYezTLbklHhDvwUnKn+3x9ekwW +dOVgGTq6kYAo4CT/mWeav3A6qcJxet117yhdZ7maOUm14Xn2sYfGdORhVVj7dBBgT1jarKTT +J9Jhx4icBBABAgAGBQJW7XgwAAoJEF48JFzfY8q79XMD/3ukct/AGB4Z4I+vbudmOqR4zLWK +7dYEoptiMTIn9ecQis4J4ozAgggS3NGDuYlOjsm6MasCbSVySixPSqaEKguV+ps807EoCP1u ++AdCO7MLLAQDOi8EnXeje0667j49aez7ezgGu6tL2YoGnHgTWo5PIdbInHG3RUSuTkWbfX3E +iJwEEAECAAYFAlbteDIACgkQMY0JpMqxYH8fRgP+KcgdHfO5OYBb4Ro4PcUsC0UNPYpaBamg +vgArWjiJtYEm2E+BS07Obq8BzGlqANTlrWbJKN3KJk2PknXfNo1x8QZjiW5UpiR7z4MQCJ1t +R02nZLb+DZQmiHpPMwSFHLm0nKUo+cYnQUadeOzeRkbxIThcns4c2uRtVEBAriSo3JWInAQQ +AQIABgUCVu14NAAKCRA/VaUHCQQR1atRA/9thCNrbAffjHqlaJ+jHowyhXGqs4OTzu0ZKt4e +CCatAFu3Oa6QD2kDUGyLjXI3KqZD+/JXDOlBBjRs/XoEBvv3RLzZktb+jEH/O+C0SmBneit9 +sYOp0JTD0Vr6Gla7AkggypVZ6MfdZoiYyoceEtlK6PHuzVoVi9ijHx9BsaJhyYicBBABAgAG +BQJW7Xg3AAoJEPLxG0G5VZ40DEsD/1NbzGgp5j3siqVeB5SPdXZ5Xq8beo/MV2OulZsnCo5Q +4KqNah6toku0TsB8YvffBhhq2rOIY5ssbNxWWU8h1pyH5+okFPXqKqYBXkMQ3033L44CCUkv +97wiVTtIPxds4Yz4cMqndKsyF+1jXHX0Mgw5iSWVT+Y92ivrovbf377+iJwEEAECAAYFAlbt +eDkACgkQViHshykK2ePjEwP7Bs8WO4piIFi27LnrM3qAdfgkk+/jYCiN9oZBe8V6j+HRJncK +pV3nOWIX6KN7CatDC5bP8vGQ66cICVkBIf/DdOgriGwmSSUqvKauF9NcOEARNpjfkFC/AKVD +ea9pW1KeHpHkpWfwzxbsw8Mr3g6ONysv4b+VJn3lUNa5DiN5JMiInAQQAQIABgUCVu14OwAK +CRAbHEqzAlFRhG9nBACSrSnDbOdH9uzhB+QepM1HbpMM8YqMUeDzHpIH72HLIWWf6YA6a9p9 +5XV+KeEFTAHFpLqRpeTQX6l9v9yM4nqvO0pdrwAg73SuJX2S4TO/ODIeuZm1CHrJC1cWABIw +db8ngF9GIZyTKFo2f3ZVseBn8fZTS7q3Kg9p+qxcHl9pWoicBBABAgAGBQJW7Xg+AAoJEPtx +AJRdhthi9qUD/2YkqtwRFXxtwwVr/NBNRAgz4V0Aoc2iw8WD0Mg1OALaeobCvSM9R+C764nl +sAGbNIJk4cPIhOovgG/UpVguHDTlKPIDcDoevMz2zHGLj4dojs5oV+RliPG7JfdR+PUD/qFH +CPrY86lnIicfHJ1ZfHXsaUEU7UNEDiKSUcuSYumjiJwEEAECAAYFAlbteEAACgkQoZO0FauC +JwBNKgP/SGAuULFgirOFrFLR+4B/rtnsoz0bz2GfU9CtVV0odbvil94lklvzAKZ+TJv+q8jy +LrB4KqBGatRHCj4KwMNhhmtxR1G3AlfKDPccxm6rG8vy6BFLOup3lC0N4vpGuillyi61G0Gj +KuUK2kjV0O31la7ealIBTMRUIRNbf/BDqpGInAQQAQIABgUCVu14QgAKCRAPKygBPu6mTPwU +BACImjWl9gAAjEsaFoJlpT9g96h7e73z8L/OD+lOGaJO/EXF3RLCoqjprDbvPDeuwgWwbI8K +MBH6A+9J0Fr7fnaIRwM8SweEcp+yUmI1En5YtG2N/CCNRY9Bn6pKydpPIo0gEANnHn9hssX8 +R09NkulnOQAlYrcB8Un1JCzu4lTHgYicBBABAgAGBQJW7XhEAAoJEN+vIC0jYlfvMdwD/ivr +iAO255OE0lZ4IMQR5Ciedva7C8Kk5y1A9B3K9xFiR6M6xGHW4MCJH21KcUkLuztXkT8yRsyN +swSDcc+FiOtUlWrWPkmShIx1MfraFFur27AKZBapYcaHOrWzYH5i2c6ozhK3hNPb+Qb2MPlo +6kYmTkK10TUXDwZEACP1DW44iJwEEAECAAYFAlbteEcACgkQiYliFH5v2q6RbAP9FnAGDm6v +6m5vPIJp6exhvqC/dR1FP8CLTutz48Dcn5Zk8IiuUXXYohqhnM1LI6ncWo4GkImRUKc5/cBs +kufUxDAf3ydnV4kz715tHU+WYmgPNZC0ZBqzJUHBn+cSjyA6zkXce4a81MJO363Ua7kNvXxq +wndzj5hJ9HWX0lDoT4SInAQQAQIABgUCVu14SQAKCRCpXb1NWb2+1B1+A/0c1EDNCQhFoE92 +qsG4YCHiF7LnKkrHWTOlDY8+TD7+66dhfZHCZTwmCrf8RF0qqnpDXNZf4V5aYtIrn7EfSZCl +3Zn/NNLCItEOdRfCqI9ltUIYcHgnm0HAOqiM3TCsrwyoAUMwottdtqh1YEOaTMiHp/PJ0kTn +NhGjNLgtZrr1uoicBBABAgAGBQJW7XhLAAoJEKE/Ft0bmz7jO04D+wUmfjZULbgjKvS4JnG/ +eIAVMUVPLx0SsH6OgEyA/3WWXl2cL4U7oaTlcb5NpC93yjGezVhompqRcCR4Qp+i+lFPk3sq +Fsp6LsZ+a1k9SYMguOjCoG/LDI2vJgmvTeu2jBAtmR0OPZzx7AjZhMYNfctXNzx/3lh0WOY8 +ELdMpRCliJwEEAECAAYFAlbteE0ACgkQmYHZB5R8JWVHsgQAke9aX9jV+4cjj33/d9FjlLxY +qVqBzF3jJS/lzGc94nrAC/XL8NCqGOwGCCTsJnv99S+P3WqOYsDN8mAV5J7wcmqZAKBhfSNS +ur3HXS9LISR8qIl12UkqW5c+znl+hkrUBrJE04MtMrShxgrElfgvalriqdqCwP9FmrRtHhs5 +ei6InAQQAQIABgUCVu14TwAKCRAE4DVl4wvEfP40BACgo7CTclB1DcbSjRuEle38OdsQpNqX +r3D/w6TSdDKcgyrWmkWvlyhVUARv5SVpp8wIW422ZyMDf2jF/ZwF4CcKZDsDhT0YVgmd0ui3 +CuPHkss6CN5g0dKq55vp/YmQAMJVcueLy8zjqS1YCBzwQcb5shXsBVpvJ18PdbOpNhbzYYic +BBABAgAGBQJW7XhSAAoJEK7vtwYu9cLgvI4D/jar1ORQQYsFbjSdUXfhgY8IhNi+7yujE00G +5vGwp2rHf41I2prc+2mXBqULdtwZtJqKMkTa4kWwFlBVTjMkoOB6Z7F7RFHUz6ZZdR22Hfm3 +yacFqA1hInQ2hA+8z9lEdF7XnZZKZU9K7dFoxugNBncODMKTOvWPLnppJj2zgv0GiJwEEAEC +AAYFAlbteFQACgkQKR246HWbRStn0AP/VgiUFXXvQyLkYs/1V/CFSiUKag8iMqGrzpbeREN4 +mcKYL3Ge8xBbLjZVEVxx9SuQK4XIk6/Ha3StoR7WhQ4O4c6vC8ARxSKlqmS2/aal6bFUCwWM +g7Fe9tx+xDLJpsbM+ckbdXclY9fIGFTFm+svFJdj0TJlBFqvr0z7UFfukLmInAQQAQIABgUC +Vu14VgAKCRAqSM59xJllg6FQA/9IKECoQRydmsd8HtijfzStDrRx6Bvr4b7zAvqbWdaTTPRC +gB5z/PdvfIKNztN0CLCBvE07avEfUIKTwfTxlFfmUmU4xgEfyYSosO8YBS/gMTYmu3+GV8JK +fQbWH1UGXa3TyklAhGpgFF6Nh7IdjzEAljavZVyPMMT9Hjf6/ofZh4icBBABAgAGBQJW7XhY +AAoJEKeBXwrK5Hy33SID/0HKHdw42uGKUpkgAov7eEeDNn1+Fpd0zqgz+1g/KMOipawLORto +yHmCe/6kTR0Xf6f7Vx/7BmPhfEDggeXNWColuhhh3lXllWogTbGSsXXGPfhxY8S/04Apz+kX +FO5G9GkRaIOMVB9f9lVcqPMJcX5WX01a3pGFairEmoklnGXkiJwEEAECAAYFAlbteFoACgkQ +GYp/7F5FTfaBTwP/Vk92lbhLZ4AO23au/VG3tOcKi8PmeMVOgkULfwr5nE9RBClKYYZxdfPN +4a8W7bUmQ4BpCigJtqNwVXdMFgIZmYMd8xu1p+9W3N+g+PR8+LjoCQuU3SY4ertdj2jUhKfn +kZoVDNxPkjT6o5CWWijU0ChmMg2PV7vd/BZKP+ZyMhCInAQQAQIABgUCVu14XQAKCRBlfV3k +2o1JErKEBACxcFxc84E5XjaJTwIRgBMwS5r40qxwx++XhnFTQeRTdv32+KHuIa1QM2ROgqv+ +HHWLYxT4Yvv+G1vKXTibu+67ubkGqeXgdycLRbYvStML4RhdlmuqfN8vAeLbNTnCXot1SRai +g8+KTMmBBvJnjcAqjlIvlxe5E1KF9Exo+lW4coicBBABAgAGBQJW7XhfAAoJEMfFm9x8Ma8D +G2UD/jZTNyvbD7kTRQ5LmTzEPLjWKxyVNnVM+iunfp/7yiIriBAsmcAf1uYOpFUAyCG+M7dC +Z/CbHnbX3kmKHo5LEGsl4v3+v7p+Alfz3OOM7/LXQNq5pBBZDUVBcjCxihA3cuWuEFgba89Y +5+4JsICaiHt/zS2ehlASE2XqoJSZd6foiJwEEAECAAYFAlbteGEACgkQtJhgfFrzA2ZIIwP/ +XyKBRgqQe5bthS8WOojmmC8Z9piglyGEcKMhLRklC+EuDE0RxR5eC3uIELnUKEhAXzuQMaPc +BoaT7CMK3GVUJqGTgn29QxQw8gGwxeMAXo9gtsxvfV/IPBxeOn4lD3jbHA8RL1Qy3aVvGHC9 +l6nN2PC/JzTUn52oKn/NsZulrQCInAQQAQIABgUCVu14ZAAKCRDxXm//vCWIM9d8A/0YzYOK +HcstbNLDb2tDOkYSe/oLwzdmW1r4R9TLKS7WCfk7AKtKie0UwvemQZm64To1IFBiXFewP3tx +FlTbudxwMXkJKThOILVAukL7QALDjzPF8AapGRQUjrFBJPxq918YTFR1W+KlszMHBOzNHf7U +S5SKLhApApJAIoRZcSAGi4icBBABAgAGBQJW7XhmAAoJENi4+wB+bucEIswD/RrY/bQ5/zqm +4+GhYeHd6KIy/y2u/5nMnFY/RQ1q/BX3bZL7+WSB+Ws0VMHiUb7U9vdYfa8KaH5Kv0j5o3aK +gLmFJZHkVxL6THv+fYtin1XdnneQ7d0sv6Chp8VIInDhiEvPWnoEPWber7eGFybFdJn/4qxW +iqLrWg6MusWVaml5iJwEEAECAAYFAlbteGgACgkQ/txjf5gVjqvEKQQAgz4MlsADj7f8vy6Y +p1IXL6kXlnh4xTsZGjnNSYiAN1V3Y8xcnSIRRGFVt2NPmauHx+lv98rRe+ayrJaC+3kbbnJJ +WTsA38h6hPPTy7hEy7uSLnYNNRXdO0CMAVKv6Yz2AVN4wJJSD4WpfwPipAgTqsehanLmylUt +L3Rb3nO+4qKInAQQAQIABgUCVu14awAKCRBw50+3TcWE7DYiA/0ZR944CYTdRvY7JEZ132Wj +GzqysgLaTgEg+tyScDbV4MmklcgKjdHfhD78aEeb1nysOLsB0gDnjYEgF16pE9TI8oytcSQV +nJ0vq2xgk3EisxT2APi9k8iAUmYyJ6H4teP/nyWBiSydQWKn1fKppwXOkMfiHoTlNMlab51q +f38jr4icBBABAgAGBQJW7XhtAAoJEPJwCuEH44uBbPkEAJgIILx5wWu0ZN+h6JApNujYKWFa +GL1dinBg97Qe2WO4sWzQ815hh1j9KiSW4m0CrW54GTFJfaZig9Q9pQuwNI4yluNau2NrqSLn +/KRTqaD43T+mBbfs5lIBSL52TWZ7g/NTit+rDEfu+dWnODjuPoQorWnWhbES7Ys3xmpSqAwV +iJwEEAECAAYFAlbteG8ACgkQmYsV50jIkA5h7QP9ETbZmrLZKkWuPzA4uXkS5dgdlo/Esh9h +MqzuRg5l4ihXqaF190eQFaWhFrqewFVtfRxxPZCZh227RQGEEUguuB3vjedr/WB4G1w/I4ou +ByffEHgtaKuWqz8e9g7JByaSjagLSysTcOxnhUb3RGHtRrgi4uqzE9tX4TxZfgYz3l+InAQQ +AQIABgUCVu14cQAKCRCKo06bYUAP85LcBACCX+243mWL8LT84I6YUdmB8eAIG8KgsJMp5lod +DErkAJODyTsJy8cWP1ZR9DmbGqiZRs8nF477o8iSi5aA91jdS+bVFt6BBiyGssT0QAm2wBpW +rGxztsOeHCSZQMeM+8qbknGQSVS59z70gTQMqnsyDduJ3bkxFCL5+FLwzKUZ9oicBBABAgAG +BQJW7Xh0AAoJEHre6oth6cN1uYoD/0XgFOmDaR/f1AjdiCg7a43to1Vi1ZNuhjGU4ycM31EG +4CgXGjzwdPkC1QYGF7rHK/KuSDDTErRKVKZ8rmWsa6NGI0UWjHOGMbEOUWszAKGLSbNxjWiC +2drJN47GjDW35wfAdcYlGQHOOU69fh0P9vqaVwyztvmxNme1irISSi1CiJwEEAECAAYFAlbt +eHYACgkQdg7EEO5OA1bsNQP/Rzzffv6Ec6gH613pYaYN2mozFGxiL7LpkSylC3sHahnL86XL +OpO3HNXmEpDwKZ/EyX+OYixconPy1ntNlxW4ecZdPuJxdi/pj5VRugzz9cqmv/PZWrRDOuGJ +N81fSZmNkBe+Kftsq/90RS3nB/wJtzBTKh/uHyi2YwiLOlJklIKInAQQAQIABgUCVu14eAAK +CRBogLyHqzSpmx7sBACs1xCgd2TL1ofwTuG+uf/0OwwdwGD11DGFhPL3wKg7rcnMyDG8i1JI +7VtnO6XRqfA0ZsObtfhJEQszt1yRiG1Khsom1lYAupeX8VQH8Jpvc+WF4xPs8y+CGTCFPoxC +0VwdGHPxvQdezEI3myYSxBdy8ZST3dqY1o9EyRAgkwenPYicBBABAgAGBQJW7Xh7AAoJENSj +WMxckbypoJYD/1yVFNnPOw0qrB0VNrILZadYYR/Ko3JdOQHUKRP4KOgaL84pMc6CPrjFgXGZ +Rb/IxgVo1W9kw8O/5Z3kX7oQ/m8i2ByNso2O3xhPcB6+WvvkWCm8hMDttPz+FuAHRVznArJ2 +GqX8sPJ0AOwtE3EM63FeO0KHNONcl08bDw232id1iJwEEAECAAYFAlbteH0ACgkQApsZPS+f +LL0+LAQAgYDMg8t3SyN6odB14omdDFTPVPaGGpdscbZkMqxbwJs+lDQO8bayiCZBfx7QSOPa +XEXaESzQ8gD/GTp3HIknbkWUY365NasaneF5RSY6tUpqC5w1VVPpP4kRiJ7vx9hjt135n0Bi +w0ipksm38G/2tF+xzkOwpn2MXeLFVEPrhf6InAQQAQIABgUCVu14fwAKCRAf+MxKX2tm2rai +A/9Jzx6ionbHG3hhCtMTaGSWuIjfHooeEIdNhV3iezWQoSi9BIFSdr7/yUi21fUfmJqkJIZS +k7igL8qWh3oBhIgnDGDz7mvnHADv9LS9d1cuw5NeKY2ESe85z3AqDI76Dupu4OE0LLBqKRjR +1TLLEEV4Q1o9LG5JleNVkgC4Zhmnu4icBBABAgAGBQJW7XiBAAoJEAs92Dmm3xYnpqUD/0Vu +wjNGSXwjAtrXMXtqHHgXaVOgRE0oV/Rdq0ak1SEdORFvv1OELwP2Vjg8XDI7MLFk8Wi9d/cP +gGlQtbjOQ3vJBqLAlshSRPRHmbKOuQXE2ZrIyXSIvz75tZ52EIddcuoEg01Ykv/1pQig0YWx +L+HjxEZJCmomV/TOIaBeTiK0iJwEEAECAAYFAlbteIQACgkQbZVCJcbRcnEBBAP6A+zsKQaB +AEl22SIpBCphi41cH7ovDarKN0wIU0IqkQ/OIzOqmTrY13P2+vbhSA4ZavDz7WDBd9MAMP84 +zGj6hKO81qosQvFkoaXLdYrDbalRmpVa0ZEk4IgUsuuOXlYz3JT/tylZLIdrNKBuYE/JN3KL +8SM3sDWSgjpuCyWfopqInAQQAQIABgUCVu14hgAKCRCLNuuC6dV7gtDRBACH1sAEDumukhlL +JGE0BdCQFbO6HWClT6HVJ/nrokD5lZzXjpCsi9u9fdc+S9PV+j0E5k6OIA3GayashQDU/HJ3 +yftpc0if9q5Zyv0bUGIXEaVeomBisA5KtKEPrncjzRA3QCZsdWP/g/A9wbmFfUYkT5PaWbDJ +52fWwyp3ZdYYgYicBBABAgAGBQJW7XiIAAoJEFiFuRdGP42Egr4D/1GwLhMIb/0XrZGICf3/ +dWhKgiuaVAjfYTlyUIF8Hk7ukRfq1e+Z9rqvejObRU52cvvXPmy03XXsfhtbcPlXFyXxeURg +AsvKY9wM/YEupLAhFE95HfraqeCu/4thkIDjlhp6D9j8Tme28U/kEuima6XkPkSsVSzD0ei/ +4C/cHpNaiJwEEAECAAYFAlbteIoACgkQ4WVe1EYIcGPT5gQAqnwdQzsl050KTZAspXuovySt +IJ0O1vyPIwMH7V6lXfwE1ZdM8r8y2evk2JIERXZeOF1BE7+iMQBTXfLJL2+EM3b4EnFVRKku +4IA/UrmlRR2GdTNxFEmZkXkBM9JLbE+jOY+cEgoSCHBVtBdy3EHmLdZqSmIEuec0T9qomKxU +pj6InAQQAQIABgUCVu14jQAKCRA+cFH3k3Sz3O+XBACESdFv316p5QsHrM1fR57dawUnarPH +/T1ih6TnrGUkgWST1llzDkY+CwfNDqgNcNHixyCZ3tB61LczSQ/QHakgfxOWvNUd95VW8neW +LULaTUwknSPZIbzTolFCxjAJ0+Q+Jhaty2gxH3EeorCej+9Bj5obqgGw/4u3oMG/G8s99Iic +BBABAgAGBQJW7XiPAAoJEKjtvl8RhBEf1PwD/2GL6lnh5lUSgaJD0upA4Tyi7ogZfmWC2Ld1 +LXwlONxzUhpbEKSt/0XwKA8YvGgVxMQYbAyWTNilHOrwFqg+v2cMgQAiiQUV4hA0Z9FOS7HQ +9BXG0OSOoB3x5dkAm5isPntV5YmJDTpYTrAfAsnAgVQDmn1BaMUb+tvf5lXZR8HdiJwEEAEC +AAYFAlbteJEACgkQXyy8OeXPNazmiAP9FhVz4HN3OPikNwI5kyHMOy46LSydDueLm9Ir1+Dc +TheAUNEduBXdrA3gR3Gm0OPOgoq0lLHWtMRKArvUpyOXkUVw9wBzQ9Qtfi1lP0ziRBzJRrVn +uEBevY1CAdQqE2P/nCZJW7GLZZkwB8IPpXfFv+B5Qx+dg3EyUybZS+xRgbWInAQQAQIABgUC +Vu14kwAKCRDJ/FtWWla4ttmXA/9CGpzn3woI/q4sKBn8oDblcxRlesAzDSFk/RDjBNIcaJiZ +l8WRV2IwRhlQAFzghoQQ7FjdQik1ccN0nnw4fyuOlL8bH0a8r1aowQ4lIVfdAk3A8WIDKyWV +63bGKaoRksvE4ibXMdXeN17qcOay8amAgiGZVgGlGv2opU3NG/zu1oicBBABAgAGBQJW7XiW +AAoJEP45tMViV/G3L3YEAMXKK1kywAJn9gm0zkK03FkEsLY9TfjcXuvI5UwHb+j7a55HRbUT +0oWf/87d0qHLf0m4fjZfRaa9jOAKk5fN5OshwfI/4hv932vQ0d5TTFD5/pd9cqdzpDcWoCL6 +EijZqgO+9aRhQxbUngTxUhZ40dDblj0JtxU8g2sqi+S+uOL5iJwEEAECAAYFAlbteJgACgkQ +DdTYFwMe17Bz/AQAjeru58mEiHeXG29Zyfb5PArXvRGho8nz0dQToV3PKRpd59p9vLgMTAwj +ozCE9E27+xVPbhIbMV4ePj7gdCJ2MIFuY7NFTLG1o1SJ3BMZc9mZPXoP0Y+COPpG6Nl4KK/1 +C+pZPKcb5P82suX4P1wglR/jAO6qByWhuGsHUnciWzKInAQQAQIABgUCVu14mgAKCRBpH+Fa +Vmz4cm/rBACsCITkJgYlGB8CzLeEz1NKRhvBoFq8wFD3XpHboolspWQ2G/wVX6Rnel+VSgCv +AsTer3tJ9byhDE+FsQS71ECZesPExIYH8lkpa2hxSEddpaPxGZsqz7eCeEGY8jhN/SAQOrvk +d6bh2BFd7DZZz44rWbbmhNhk0BJWRbzIb1FrhoicBBABAgAGBQJW7XicAAoJEFvLzM3iXSI2 +eSAD/2ukBS0VzY/u7u5PLZUOQpVUFrDHQUctI8DUPYaiRlk8NKqdo3x3kw51miHgGUi0tWlz +841dIy3q1dPvu0MEk6gcBFVI5c+71DHCSqTXjdG/+Rgof5SMO1C42LXAYyVaj5pRAv0Ko+S6 +Ph7tRKusGoW9wIu+ltByZHWRZ/hNOxKiiJwEEAECAAYFAlbteJ8ACgkQITL00h3yA/KZ1wP+ +Me0OVldFuTRMvGv16XOdFoT3dyuUyi1G3SdHRjMFt72J4oaxAAic7lg+ZrgXbXWTMypsqCT5 +2zVLbqu1+yGQ3qcDDOn+4TQw2GJL/Zqm5V5dRjEGv2zruZvyEoMBl8W0g8+FFPvC6uK3P/Rr +3M39tJfrI31FLPWySG6AzcHFZ/KInAQQAQIABgUCVu14oQAKCRB56ISQxV8iCCyzBACRMRmc +dg2qLPT2RxA3XSEe9a9cNgs8NOlOVV1qlKGD+j9yK4IfHN5+FyO92QHi8+ypfsrV+RwFIfBd +LP1dinzHj5mgTAehyZXIHU/wieAIZWjxeJ+5rs+rXL4YhqdsFDR9j1F1M384NmEn7zOom+kE +dK4Xs/IQ4uGqCM52yJYv3YicBBABAgAGBQJW7XikAAoJEKrPqpffEu2HeAsD/jEScC5OcoOb +hsS7Du2/aLz3conTU0C3Gun/PWptociW/YULPvBZOqCEDGs84zihMpl/jh/we1vEqkonqWi5 +doYJ/S8ex7O7c2nC/yiOX21SKVQrPF6cmnsbd7vm7SEsgEjudVl62rCrCX2bvzF3flrWoDz0 +6MuSuCWOqkahmtI2iJwEEAECAAYFAlbteKcACgkQjCu3kjYsv09CywQAoDJXkDq7sLprEzkc +62gSBXTxZPtijbiqtxFhSE0kbGcBAb+JX1ifVgcjQvyX8jL6vAeL6fIcNmZdoOuhoBh30Qea +xQz9AfpkxY7VHkQg3dP4c5qtpb3AGZPeJnkG1xNRs7Feb8Efj7xGVqQ88ihfSQxVS5az33S6 +zvZI6fbd/XGInAQQAQIABgUCVu57dgAKCRCbDlxsCyINlDMeA/9E0rnpB3AbZV8jZ7JRaiiY +ZTIL9qNgnSHZ2zHMgf3QxuCpC8HSnIFxw4lOffSEKtoT7UQkIo9D8FqRxGs0cHTOAgFch4C0 +hsZyRB3ktjLILBptCkOnrTJeoLLozp082xIz5eEjs4XbTA+06NLLCUGqH/iNnFjPK85Szmez +R3Ef+YicBBABAgAGBQJW7nt5AAoJEHXp6+Oa5J9gp7QEAIeXU96eJNt8CazbAxaYcNWyO8M7 +VCuRC0U6RbcU/xvLNkrrHoM0L7KhbBRn8khvPcc74i6gRI+aAjl7Z4xl4diaRx+u4jv3xqOA +/nNcxh6my/3nC6K1+7jjU3kVGN/gUBlZ6fYKSFQtHjqaF3eBAh+lSxw858l6bsc8zrXiR8p6 +iJwEEAECAAYFAlbue3wACgkQ3HGfaLITTHzwzwP/ZjhBMzwXaMTQQnGh0mvX19YozSeMj2An +ww4TqmPr22DXnG7qb67Qm7jwC/4XhaDFcz/3LU0vy4xgyJgdactYqhJ+OIuMyFZzpA4vidyk +klNGcteUqjMK+F6oI7c54PchFNm4iexQ8avGJbc4j9/DtjWXtbT5XsGMCi0ukBGOXsKInAQQ +AQIABgUCVu57fwAKCRAPKBpP4YSrHZN1BACn99fHkIo3IR8EI6imcfNhiIn9oGiMl6ZM3FFl +A9m5rB/dH9ser3ATIYLEICmo1alChgEDXY9GJWJAhYbGZBMWo2scZMP0Fa7St+hd0cJgDJoK +QjL2tDyhlXS0QDDrc6ImNfa8D4ZBKw56myIZbw7OoskGTfmRTHklwxcJG0dxyYicBBABAgAG +BQJW7nuCAAoJEN/gQnzHtB1Whr0D/0Ljio0EZjO5efBOZ4TveRRoCEGYWZ5hKev6P76/apEs +iXrZBdwFzJIM3BDrj5ns6vPgAZ7zb2aFfXnx3ckM4pdTZVDeVt5DloDbKSYheyZO4OWhjhzs +jhB4v8Wi7g9+OI2G+GgDxsY4xgZnF2BxLVr5V8PwjY4QLMWF2E/3KhopiJwEEAECAAYFAlbu +e4UACgkQJIJedmjw+Ca3mQQAyoetUr96o5LCsf2dAomt6b8A3cYyVzfxTkXXFIRr2uIjp5Bj +X56r4n0kzX4OwDVBWZixPTiXKU+ncsl8carhR4rrtCriKKXZdAuTMYaCt5l4dXcdLe4bgUe/ +JrmZiKMOOw0UxoRvfODziES+arjMX1P0UADmvFD/6YXYRm4UGAiInAQQAQIABgUCVu57iAAK +CRCSQ40JHnaVOjgmA/4r3kTA+i34vvqNXXYj2P/Y5CTVjvaNw4rjdo3k8rzdP8FcJVLNpbUL +WkiorPgOklrNBt2JpmGWrbVi2PTIpmpHni1p2Z5FMjrD+S+UI8FabUMfMK/F7lFcsgZk7JXM +9rqPiAwc6MYBY/e9XBt3g7s4IMAMctwAL95OJykB1BRzaoicBBABAgAGBQJW7nuLAAoJEF93 +bgrJTlgucpoD/1T5ZDauefAtkGKq41nf8Hk+KnR1Svyqw3fkNwknvDXjxkXgcQgtj0v9w5uH +sHHHJZZr+gqz7ZQ8xSMCuR6byeC5uuBMf7la1T9yRAz9LLVhm7JvcueBhm7E8m/wotqMGUNs +1jm2GtGgHfJME42N07kHxVs929MGH8XpWqDeRjTLiJwEEAECAAYFAlbue40ACgkQ4daZmtya +YPD1kgP/TMQXhUMRGxnXoSATUEZd/kwAgBaT2b8hrce+9G456dRHql3aIVjkB5YyD33vb9pr +S/4r7yB05TbC0j0vwEfCTcib3Gm5YqiCU5HH8xyia9lLlwkGBC0tgObVN6LISBbibQxN/z+a +tFQkZTYpJKWwiAZPWcN29PgwuOS4vC2ToaCInAQQAQIABgUCVu57kAAKCRCexsSiMmmrrR1P +A/9fdskGrP+OjqfqyXpZcbKyaq8DW2UwIwDWfyaKmo3h0mAgX89zlNVTZ1BQHBA1kuYkFZUm +KUWFfgNAIkkCtsgWshBKzzN/mHaM+bbXWMsuMHe/fLvPchuMFH0l+PFRVodrA+LvDbo7gOHY +QWK2bJHSPa+QOCPX2b+2F9btr0hS/YicBBABAgAGBQJW7nuTAAoJEFhmohgRY/nr4sUD/RlV +h/msY13i0EcEPem8yR0t9sTz+h6nLj9iK4HLe5gkRmXu4yypGO66uw9RdYXKIMH5DSa8lg45 +Er+ULBjA+2WhxakP0TA2ocxWIjpfcVIoG8KJ/C6gjF09eTKjozfbd8jq5HkZsFU0v/8AU2yY +MgYDEGgP57ChKcnqyHV+9tCqiJwEEAECAAYFAlbue5YACgkQ38mmy52AWktrXAP/aPgXtSWL +UcWhsDz1nAY3IPfeAIRcXFn6sWzdf1+TYnPySHFORi7Mz8GJuwO5qIBdzRoXkLgbiaXzudiH +hTFas0d27LQQDu83by8abx96E4w9v1HuZjdobaiHoLYJ0dizKpRjy7Gz8w9qgFBThbV9Iy3u +dqEQOw3dvdzxa2svKRCInAQQAQIABgUCVu57mQAKCRBnTrff4R3yfW8bA/0ZxC+P+8qg5Isk +Mx0VEHi+3rTqlqfUTHVRMcm+RSTWwJYPfGxM+o8B/zBQNSL3rJ7zGmC250sHIGDLpLx+tSN6 +IixsOKpQMpJ6CCzeHTWppQD6wV3TzfOfKLg7Brh+Dwkm/PtdAM1FC9EbubAoJgiVsovpK18N +po8NTZCUKFg8aIicBBABAgAGBQJW7nubAAoJEP8TPftBgLfh5CEEAJW6ChVdmcnXKzhHZUai +0jWkLYvQzCUmz3bgbmnnpmieEK128Avqnt7g5FPFeTYdNDsopRvNYxplQPmeu11i9DcgC9F/ +VCpy1SYIfHEsvn2LKIOTgj9L9LqCLMLaDAeORRbCav8oSvyflQD6+hav8yMYGSa1bfZ+QKXV +gh0i74kMiJwEEAECAAYFAlbue54ACgkQfONObbjWB84rsAP7BMFWJR59GIkun/0pDvpiVLp3 +fRNW9Qi8lFLpP0OMwEysOK3EZhiifJt5srxBgkPFb0OkaGoOZbMknYHnOrp1ODltcRXavXtc +KHoQWruQyAGCW8ELNT8+L63PKBhRpwPhL1p6fCDt5agi4QTx8OAyfkVgq2s7BUkqz8yeQ2Bd +wYmInAQQAQIABgUCVu57oQAKCRAYX1F/q7vVgKlNA/9vTqSHQzbieQgnHpZ2i7incAVNIJSk +cGnfCRVw67accYVtHm1xEqKMnOEeVya2eZ2LsOS1sbfWDwRqCERIXbBp8PTixZTe1gfBnT13 +tVsAHcFa2F/2SyL5zFzr8gHcP1BB/PiMXtN+kpxpQaoJKmq0BhpBLdgZR569nUttaT4QSIic +BBABAgAGBQJW7nukAAoJEDUsJcMco6EpgU4D/jfcvS6DPY2pD3VTz6w380C+UaKEKVfufvDR +90BnywKCIQuCUDm6CSMIuvHwSXjHnUxOVpMYS8pVRryTIiBEdFd5M+43fdVJXgD/FTbQfUM2 +VWvKFUNHNN0lyZ875ykWEfAdoUcEgR6EGPUoMYhDP67YUurbDf2VpAAfAv9/DsIHiJwEEAEC +AAYFAlbue6YACgkQSo5B9kni7JH+FgP9FVIyrJqtIY3y16IlQgjXWL4vsJbQIt5BjbUdzbiC +OVseWUzh8zrDRk/7b8vkV3yr9Ni/aE+EmDNIRggbDa0Vw3QAMjWcH01y3InAxWYq2KC08TP1 +Eg3k0RK/+wPCLrbj97/p6YUUdxyNaKlrHOGtTFYivg9zHez6TnmV9S9LGAiInAQQAQIABgUC +Vu57qQAKCRADb0ZsHkMSzBFuA/94nN7AENPxT3WpNUfn5CuB9KAUsoV+N62XcAxyv2Fiw35Z +iptFkr3D1NZPvYhWB46ZnQJoA1n+9e6NsAvJdafb2TDVuNaUpzKJ2lAsEMWOAjveqKAuqHHI +dI/rz0uknH28q2MnYJWr1XPw5TCGemlcUxwxKqJdWKQMg8RyUJh9RYicBBABAgAGBQJW7nus +AAoJEEBkeCmkAEi1kMgD/1UtEFAPoUBxLYja/ZviktJglBzwiLDCU+3szSRV1F3qrKj3Iqb/ +xgca83e5pitbP3MIGtRJTV7C/brmEKR6YAepx9ZZcqrr348Fji8xsjk60VlAS7lxOyAy6Wx3 +uBLx2qLcrVG/5/FQhWc+aPvcHL9W8mG5IEyqpnvCNyQBY2sYiJwEEAECAAYFAlbue68ACgkQ +cq4WWxGJXIM3bAP+Ii8fzPFIGgzJB/8k8t8edjieGTDjvHUraC1oaGzcWDcjhGJCm6Qx6xQB +Tfrr3fJhwzwi0ZwR6+dxepZWELfv+5bnBMSnyqSW+GYYwBmUx1m6gfiNaaFa5DGiHweQyfvp +FAoM/ujZEbYOlP4xMGbLuvpLY8jRQAJa8qO7Rbc7spKInAQQAQIABgUCVu57sgAKCRDogp+x +oF4Q4bmBBACST6oVtcHpMIzlyIy2ul196Y8KZcvEH27N4ybye4q/5knT3Ew8S/RNL0vNBEmU +yeUOeZEUylkDLsUXZekdbi72WQdaKtH2YPd2i2DqhUwpkqqauSTInvcgfpU27XtpNzp5UOVs +WDlcXT/MxTj1n5qpQaUeKFIWfg/ja1E2nWmfd4icBBABAgAGBQJW7nu1AAoJENkTXs3+cFUy +25kD+wRH81rt6H3Y/62+ELNajdB0/bUrEXkmZ7Tf6bYCiUQq+OCMsKGddacTmuJLGG6nuEhE +i8hx0yLoIdRz8V08kAHkjpS9QPKqUY1BHPvDSDueIpMSuY/0KXvt2eRC4xPqgmq+pvbMJfXx +QHyNl80tm3s1z5K4XfnGnISOmx8QXeO1iJwEEAECAAYFAlbue7gACgkQYjfslXukBQY2DQP+ +J7LMorMJP2nN3EnKlLX6ojXZ9BpCMYfmt2qJBtHbJhL5Ug0GB78ruASDuJ7SZhfmTezpzIUj +qD3UsEhVNX9CA2ZB/TKYRAOZTMy7E8h+zN9HZF8hpBpXJF1oRUnEMiYg9SbvVw+MvAW+OP5U +eaNB0gYD8NRSvtko546WDbyCxrWInAQQAQIABgUCVu57ugAKCRAa6IkcehBC/WoQA/sFHP1O +KHBcWMGiJ0Qi9l+0Nzo9b1/2W8FCAvUvNYjdG/3ZinidNQB1Sf3wQYnj0dWmLUm0JNXRQYrL +prT1cNKdVsKKLCRv9bz/NW19ZMt8wmX7Do05DdbqJIGfLf8ARA5qa5SUFlsZuv38xqUQY/P2 +FW6J8jMAmg478k2ySwkN9YicBBABAgAGBQJW7nu9AAoJEC+7avUNFTYK8nQD/1GRKM/kjvtA +fLZgbH02wa1pkRJs7D9Laqpgq9ppxfkzCxjx/Ci5bERKF4vMmZIw9f0BsSD0Vo98PAOa1vwp +WntO4OD0iQu+JjWFN3DjWrVo915FRVOfvgPyKMV35DlsiKBhSk3kSNg9H+XfbxD+l7Cf1feU +PSpbE+RKyJ+5j/iliJwEEAECAAYFAlbue8AACgkQoFjG6NNmtipP6AP/YnYREZClMu0sq84C +rMpld5UIO/s/Vud5pvAVFLRfx8CsKi5YJTTl7lABFuXsVJQ32Deab7QbJ69FexFA5j2SdyP/ +2rmTGit5aqaxssXVrBzdzD4HgPTA96Pcwm9ZKyeiBF1BADieYl8xhR+QFbMT63GgLgWYvcma +IoeC7xqkk7SInAQQAQIABgUCVu57wwAKCRAkL4cW0oqUQIbCA/9j7xrQ+0QmF0sOmeYvsGUt +WRcZIUfyB3zOj9jQy5ybED+NAJldFFAZMGv6T3hMzZD3cCAAHQH9WswXjcAAotcWiXX5S2Hp +fW1N0wXvQl5qp43OMp2AN5hNDkX8FO5nhnYCmSamgM0zgIosiyaHz2jIJZyBwkQdjhfW53qC +5aXkToicBBABAgAGBQJW7nvGAAoJEJOD9KCkd6YH0fwD/0Dgna4CTCLhbCCl0HnXmdZL0x5S +K1ZsolxJoo0zCAwuWD0I0PB5nH+rkSp2h5SJKe4kJsrZCOQXS9rUM+TzqVDJgnFfckh3Akcn +vP9PvGme2foZzTOpnGMX5F4cYC31GYilEMxIPYLBbpNSM3CH4puz3ucAnyw1yl5DvfaZjQ3r +iJwEEAECAAYFAlbue8gACgkQpHRb/MBLgp1DqQP/QSW66/156rZSzhOfl3PTSK4UTOTrYY4Q +vFtAWozvjJGCthQ9Pn3Jr/ueOHT9ckmt9NGLn86NSxZCas4zs5Vk5ESSuLHyDjxpCmtEdAke +uFXHFG1CIROnUQ8ZYzcg1ns6b/NPzX8T3Og9UJfYEZB1muApd9eKQuMp5dGrTGh9zCSInAQQ +AQIABgUCVu57ywAKCRCgcZ4sEcWGacYVBACkntpQpi1MeZeSyjtafgZFwm0hIFigasiZqJEK +NS1IjsfbY9mwFtZbIeI1E23qJqhsAOSaXEAT17/Oba4iFNPmm+jfE9ftWOg9fyZ5H9fjefqC +jwVzIHz7dcZ44NzDY19z0PK1fFQGbDANBfTzfpOcH5EBkdReiG84FcijyOl1+4icBBABAgAG +BQJW7nvOAAoJEGNrTDHZcNDpDp8EAJCnyVG+G4aAPnAE2YWKPvugm3Tb5CsC2y24qrkt9de5 +nyxKMx+JscJEbqNPqa86TmX9YtuNoXAl9j9Mbfmw509dNy8VMMnZEG/79pp+k8z+0Yg1ZeZX +pO6UR7V1+zgBpevGUlwDzZTeM3FwYcNFTL7kYdkWOxfq8mlClqst7LQXiJwEEAECAAYFAlbu +e9EACgkQ7nFrTrZvExXLnAQAxt8mcgykRwXZzTwU4Fz0GHTjxBrciQIkyoKFJv9RWlMml5rj +blaNPc0n9iVK3HitIpjgbr5p/f8WSmQB0K+8CSwiSNwNAn0kM5LRzOohh7oCRI+VRkhgaZSt +ctPgO+JuaVVrRzSK2ebtiT4uH3jEIAPw0vwAIn/U0altuxfHfn2InAQQAQIABgUCVu571AAK +CRCU30ajtedRNsEBA/4v3hKeuPxXIfFKupGJm6BbHzuVGF87AVWH7YlHR3jQ/bmkOlfXQZU5 +U4IKfA6SIw8kgGo99Ju/ZqNavtNpowJEe53Lz18Xvyc/58Eb2V5UIfjLO44pmsl4L2FN9BGS +qnkFZqs2cE3MXYOyfLwur9qZTHpkMk54VO9Dh9XopyR8hIicBBABAgAGBQJW7nvWAAoJENZ0 +uzhirDDlyMgEAKwGhWuzv8GW/jQmSnoyl12qjkIIEDQFiWxtt/0+6DKh+u6H+2zFryVCuyuw +3z+rLRpFSTEUI5sr5INCgGfd8v0X4IWxtqkSLTBLXxOiMbdb8oxUFps+0r2U6zJ+MC6AQc5w +GmzJQOKNT0lNHGFnbAAVpIMzDOX6acRYfZXkwonViJwEEAECAAYFAlbue9kACgkQLaz8Zg87 +mAQZ7gQAg8i5Hpes1t7drYJEF82px94Xelh1tck3RW6/DyVfq7jgpn3yd0ZtgpdFJDP1O6Wl +S/Soebez6lDOI+hh46MFnQx9s0ZJwn8s/wLoC50TAY3oUvn/cRVOON4NQIumQ71hp6PWIy4r +Idm6k3v7/8ffOtnl/9XhET4gBG8dUSGNbBuInAQQAQIABgUCVu573AAKCRBf+6Ig0bf2GK5S +A/oDqO6pah+QgTq+2j5OXBfNjq/BHGBVBZvSnhweRWRPNieBK9WILgwWMNEsNRivYm/fZ8BH +udsLh2zfJ9AzK91sVMs5/WS8FvM72QkaKxWMvdfJTnz5NUeTfC66spwaiceycZ+MfoAhQU8u +kbpKFMn9/ERce5s6D9bhcztATFtRToicBBABAgAGBQJW7nvfAAoJENijmIKh9BV57k8D/2c8 +coWHoOtsJGq9pyzU6nALXSJgB4+r68EF4iwdh7Ymo1a21JodfvIWyfw/LYPxwsyojhA4L2Rl +tOdWHVd+oId7N1CA7tQTfdjus/X5EyXF7BKcmiaJLZn/kS2gvXt4FQ6YziCM7Q24Ej/5QA7Y +gwVpgYO82YXLaXV+hnUuUPTliJwEEAECAAYFAlbue+EACgkQInulyvH0LMxPYwP/XPT2e3qP +CPpak6qai6RL8QVK40kfrc23HyNxkmN1y1BGGhR3M2UW2e66PMi59lIZLJlt7rjfJYu1yLVE +H++2I13Hyz3GADcfXbNVyqgpfioqoGLolPgBaIUNu7BX9If7VBzrTz3ybn/xsxOS9/MD62n2 +eNT3DzTMmAAfe+VgaiuInAQQAQIABgUCVu575AAKCRB3t/ZE3he37hblA/0ZnIQtQEDq+QFF +34PN5zj/A1nSFoWuxoBjylK091UdnJwE8K5W++zhrFTO3QI1j3ZoW7FzHeuXUPm6wbXnt4IB +9Zs5y1HG3UUymvDr8Vq40aB+yRrLsxnjoyY+xt3Hx3/dtkkioVrRfrOD9dR6Kx8ppO231Epw +6iTRwpNfd11hUoicBBABAgAGBQJW7nvnAAoJEE8Mg6USEQoZnVED/iNM/AVuA/qqZz1YTvAY +pYHKxPvQxdsKJj79hIWWC9IWnzPmfecvDfrEBnJQu2VQHLpPeexKnLuzr8DEbwh7KVF3oNjm +U3w+zRxA+IJq3Hwzye224WgPMvHMHvgwBGQb3Fb2AzOZt8G3V13s7G+yHAwXjwF8nduDOPS2 +9ziRLdDHiJwEEAECAAYFAlbue+oACgkQlLyP30Jk2oD9IQP9EywsODJTeA08bMS0Dirubz4O +aSIoLEzWmJXeoKCoYeHZsKuvRpOqI9PyE1h82DIsgrhDppEmr8VuVFwmJcRFD3dC8+lE2RjJ +w8hhGuGA2Ds1C5KzN/e+lfCJfAtQicYMzfmwCfUFRGeH2IqT0MCvPmMXEjc6FjYetZGBMVsc +MFSInAQQAQIABgUCVu577QAKCRCl57Zr99WgClwEA/4rI7f+aQLY23iYgwIcTSiaA3qFAvqo +9XbsrHdc6fKXDg8dPuqDDsfjoZEUdL5L3e4E11V3C4507y7gwHTWHrc0hVrN/wAJIKpJHo61 +QQff70LgvcRc3gkM0DwvQqJHPYLnj76yGpPELdbP/7QwQL3PKJN8TvOQl7M2EVNCu0rrIYic +BBABAgAGBQJW7nvvAAoJEMKNDl0dvTwHDQED+waVUnFgrvN4Y5hOVSKggmjDaZXkFk9qVNWs +388squ53QcEEbxevSvUqwBDTdUVi//lEnFJv7sPTE6htnqh6wFFQA9JCB1/FI1M4Vx/97/R2 +vf3IwpVjLCCIitHvwxkJbY8/QkLOOc0UNklbpYWE5rs8qZ96KJt92pKfF8el7W84iJwEEAEC +AAYFAlbue/IACgkQ8JISTFGUXBPjFAP9F6xFyesnReCDdnqP6Rbseh2oAk/TAPDwyD7aq8rH +0gSAPhQKvCrCauroWyLFRB2+DqxrmxKCBHtRp4fBdXWLU7QTbgCKiHGATterORo3TUeyC9dj +geqSXpyLHyC+B5OnXyS8O1A+Hplisl+gFk6KFw3PeTMXAYQDUSM+lowRaXaInAQQAQIABgUC +Vu579QAKCRCDNtG2SmSRqiuaBAChefh4m48xzVKVkfo3lh6AcXAK+dUaNfTf65DWBq9d2V8v +4JDGZzlY53oF/L/6kPJFr2JeGdAcIK/mVOW93MqVtfj2fKI0c8ngkbIqX09SaQbHKYdmabAW ++5CU8zztlWdOVR02/3FE1t1q+zQZu/bO13jo7mNDBnFtQ0DW/pAtc4icBBABAgAGBQJW7nv4 +AAoJEP2hpPEUQ/x+rDQD/3IO29LLTKLsX47lPnM75+zkTM74fHsO/G2ztCZfL1w6UO9Q3+IB +h2NzlNgMVHmsZBU2W99t2JWBUgucY4nh+JXAQNUzR1+IIR6aTr5y5J4qVjhl4qF9shuUXrMW +N/mtwBodeg31koN0tqwTL8YHtLPLf2OG1PoVH0TN7IXa49AtiJwEEAECAAYFAlbue/oACgkQ +rDRl5ceBHRmB9QQAhkr7qjnrEZFrzRaHbVFSBW+1D6pzFunRXLU5cBHz3xQvhtusPgOS0vqr +X7xYU63E/0FQrbs7l6++0slXyXc+68unOfqBvCxHGpAo681fAH7/3HlwHnFqoAhdBOha/Ckp +9x/ZfZAZP3KFkbUf4BCEUBNuMdkfO+KsR+2h/0XQ+viInAQQAQIABgUCVu57/QAKCRBf4Tkh +gktI6HNxBADLcHXp0YtHaC/F3sGnpNhGYSzmOFOBAF/70cUAN7tynJJyrn2PsKq1v/Twhj0S +1EfoeyFVqXODTBVqt+oSAbFxXM2Bw+BEc/KPrUNHMcmWMqyZ2dIW1EkOodA8U8WekxRMpbms +irfKnO+/vkyz+RJWvly2hkq+zTLwnNn3MW2KVoicBBABAgAGBQJW7nwAAAoJEMYEqlWzfwDe +MFcD/j7OwAP38KrfKnbMK+zl4EnKM/I1QHvoz7if3psJCuGCgm8ThjwgYb1RfZDD/ONG42Uk +TEhhmuq34UDyKUumsSCaWsxfjSZXEvbw22kHa2QKleACZ2i2XW6zFdnUeCNNlqto7QJppbZW +hey7pqtnq2oWgZFUQiMa43/IRYMq5JI2iJwEEAECAAYFAlbufAMACgkQsk+9OTNnhjLGTgP9 +EoQYsEBKq+QMK8WnOu2SdH9Ax+qOFeiJqkWqS0RSDFPx68hmys/IXg26RQQbi2lZW4Elmwb2 +CzwCHE/kt/F8XaX4P/neL7mFz1OH71jLjtzymBobHAD1CR0qpCMVeaW0E07lruYKNiyWMsj4 +bP9DLejh3DDjQ1DA95AkaMbVU6SInAQQAQIABgUCVu58BgAKCRClBpMSNTYEZu/pA/wJJkMk +dOtJfIKFnav3jtYm0cPbNyqj6/n3SfzeZ3Hn9cAYqUjYnwiItsg8WX10FH8aVHb2/OD6PswG +ZSzgd8aOm+Ye0mLbWvvjx+S1FYCRI6NeLj1EKVx1XvZGw/G4kW2J0W7r11ELJ6urGHNeg2sw +qzdhEZGzMoIwNWIlfqyTWIicBBABAgAGBQJW7nwIAAoJEAaHtdNiediMk0ID/RNUxop5Fqrh +9MVohtL55WezQCqFM0sJnGOo0qyk0bu+3b54xT7d9xhIMLOYznvpHj6t7lMFgi9HnwsY/7rj +yl2VRfX8Vlkmgh64AaiEMWwa/5DEwHJWhQ25iHVXXJJ7EcfPEzbt67Hwskv9NSDExqzxDbM6 +Ftqaculm4a3i2ou8iJwEEAECAAYFAlbufAsACgkQVkFXOppEv2nr9AQAoORrm0udtqZYRU/V +Y2rucPy6UACe4D6IMMzBn4SqIt7BHVeoBrTHbIoI8t/XzQLP2CeTEVh4LmXcnxYVR7tQbGKn +m9A08ElT6ek+8QGCp+w4aonVNFwkxcoX68EiV0Qq28JjWmgh6MbYjMqXoAvJYAuUh7Ies7iO +cb/pbmMmNSyInAQQAQIABgUCVu58DgAKCRDp/iQ7gQYKFafGBACDmXa7q3O1qlIUDCibwHAW +1eWvG6ptdNIeDpNSP0Ew/QYRJA2EbJgIFVN0d8TYjpsd/CRbS6YGTBhlxFRRHL9D8kFgrXld +h0CbHXpLwrd77bZRVfS770VBpP7oeIqUMP70EmLw8I2n8z1veC4ShHDS/Wp+Sytl7tA2tRR1 +uVGssYicBBABAgAGBQJW7nwRAAoJEEb3m70SqM5NBQkEAIPJ7dkW1304/r0V+DV6dhQjqnaE +MwlC11ZH+iOmKZb7VxF1J/EMUstfk4plK9C8amxAyOkTyBrpc3N1RbpXD/7n8ZaaWFQej6QE +QQdgx+qF+RJqE008q56u5jptcOlTSVAh9htWTKULAZFn7MXxsDg5lFURvvOyV/0nJ2KDl2Jg +iJwEEAECAAYFAlbufBQACgkQ3eWXLiezI6PaygQAkRfFR+twNomxz25R1eSbMBS/NqcLjUjZ +Jm++tWYyYueZAWQRZDuMOleUvPwTloQNhl5A7ICAZNCLiwWPqqoUlufv3tq1vFze+IzaPKQP +a6wp8yTohK1XMcywOIsFDWlP1jgVBZnEBBE0F7k1qJ6BAQ3MQVrTutY2nr/59L6JTZKInAQQ +AQIABgUCVu58FwAKCRB4y93ShfQeVbq8BADM9Xm+MTYBzg2t0UBDQ2b/txH22RsKKBG+q7Zr +5BAnC7cgzkUk7sNea8dx4xXuV00WSiZZvBQLpXDcel9yCKRjy9RALg4A8+a41d32r6ZyY9Qz +KBvjemtK/vD6cVkD3gfXuyo0AddZzJECVVUzPgNm1zWrfhXqwJXdiMEfRmnUGIicBBABAgAG +BQJW7nwZAAoJEIYXBInblPinkg4EAKTp2xyx4CmoouTQA3vosc5apFyvzXUwM4h3/J81Wp6k +7/DRZz1R6whaq91i/Zgkyfc0j/192hJUBuALOAgsItBsVq+MSwrMiQqcbN+859SiEB1mBytu +JRUse+CaC0rZCg8UWycXnv6pqzsfFmKIbGG5M766J8Uu7VvdxMSSdR33iJwEEAECAAYFAlbu +fBwACgkQyoCJS0QEA/WFvgQAg4+EUwvLnVoZZlAAsFejCdpRBRSXvai0wl7HAv9EaWSOECEa +uSIjU4RKaxxwikVCf+pN6e9KrjZEgj8c7M00Sp514DDg5GxlnGfixBZhkCTwbepvmJbWFQFt ++GpvGo0AW9SRTptJkelwiqRC7TYqpR4KhiD9iYkxI9wulaTbA5WInAQQAQIABgUCVu58HwAK +CRC48hf91E5kmnY7A/4w5GovFARCzKAC53Mr5oOlsc4rfhz4imG5+8Y9mN5epOfsLwVy0H6T +5EQsSdxE1h8g06Ai4mmarWweI8Oe27+MVMvuECv/t+xTURbpQrwS+OPoMk2MH+65iCNv/RxF +zWwJAXgn80w3NymjymZxxRmBVn9M/+ibAABePiQA3l3QCIicBBABAgAGBQJW7nwiAAoJEK21 +Et7dZfiqdo4EAKmZIXPX8U6ozD0tDofF1oDAZW4tntq+aMNyUZYsRdDfaROy7IFkt/xrhpEV +WE34lUY8iJ5xTBFPr5Enzlkg2rANYI7ZSuHcS0q0Y+GN8/asMp92HxFvc1jc1bguMg72vEbD +6NA8FZXurQS7yUBHVGSgww+ur8cNNDRvsLRfuDdoiJwEEAECAAYFAlbufCQACgkQjQue3u2D +tBw6VQP+J2mZUjBfcJbvo2O/8o0M8Yw3i2ZjsLeCt4JqJumOuVIogtsUrVz7BYVg3VAb8StQ +DCwjjLiGiUWoum6mabQpIsH7Jmmup8EqnChoulpDZdTVjZrq0dXDOCP2XrdiLUb9HK+F4B+C +XQgbjArV4kqgSsWG/zhnj0E0tukzvU6RXoeInAQQAQIABgUCVu58JwAKCRAROlGXhjTKhvmh +A/9KBug9in40TROJ3mIOFW0gwxeF4qapA2jFBjK+/IN7gfQeclgz6igSYr3UkXYyuyF7M0u6 +EwQVMDZfuaK9ekaHQYn4X/ZoE/UBAnv9JpxnIoQTN39oPdMsOi3mK+s5PIznV6gVVcBbiOKN +Iep+Lnhlz77y+mpfZf17qPIJfppT1YicBBABAgAGBQJW7nwqAAoJEE5OAy8esalm2yUEAKE9 +2ojMAt2KQI9AW3w5BSRRsJSd8aQWq548DGVUvX08NtV1tpJjc52+GhorFlRHDBpUtuJDSxDG +IhcBayCSUiswGpOz2DsZuZbW9MpAym+rtbuf1Dk/rW5BHhGrcL88CP7vaED7728MvRe7OCZh +q64TDZKaKWgccQK5wZ0A6TOniJwEEAECAAYFAlbufC0ACgkQYWukb3dm179TxAQAwe0q2PCi +rlKfsFwJD7n5G5FEBqDrtartjYqCUVOimqhse7ZnfuUK5/JAJrxZYTJ72wKpJkzObRy5TCgF +TeV1gTnDpTRNACWEyAhc3bmQAY0jM0eQ/pDmU+E3zskBiXb9IOBJyAsVdA6zjYytihBZMIcV +WBe0Zjb9jykqoMHIJmKInAQQAQIABgUCVu58MAAKCRCSxDpmBK23V2/xBAC0pZUQLNB9NfdD +2paxgIyg3vik9PlgmsgE0KNN4r3JeICiZ5zxIxTQSQjfcFcvVZNPnXrjtHi+w1JaiQczlC19 +vhAN2F26yAGMe3zYCdRxGKcwODbJzhlzHHclAPXmD/BpLYAcfDDLQYipgkqCP/0keDlL9F2a +JmGrTPLWZ3HceIicBBABAgAGBQJW7nwyAAoJEKr4wWRiofvrfRsD/1OmnPPQ5yq24f+pRHAv +mpcphKiQZxwQyQYX7jggKIomkJ/DvNbsmAclJDr48k5ULLY9YKE/AlLFreQEemRzQ//1KmXn +KmHHKLqlGVZiRCMPsnecB935bONfhT92T85K0LhKZxw7urq0Jwq4HeUVzZjlQ8Xc0kGp/teC +r5mhEtSZiJwEEAECAAYFAlbufDUACgkQIxprT1DdM39wnAP9FbMyfawi9A3rMlOQSlkCyYIu +OY66TwDNSnRZUxdwPN4CqV6lyYWaWjvPslDduiILXJIbprKqvUjorfy7uGKlPwabWhrKIl+L +0wPkaKvJgIqaaxIa2snEA87mHuODf/eEiaJ4+oMXzduJ4auSHYDGpo+dbJhBBMrRxE9IPChV +RMOInAQQAQIABgUCVu58OAAKCRAdnhKeA2i/GnrvA/98E+nF04qSXOG6kQm5q+a4u/Wz12u4 +0Mp+r+y+GgrhCECpStS/uatCYa8wIKMS/6YNKDCYlx3AS+Qj/0uFSdVcNox9bikwc0ApclH9 +khe9qV4H0YT4pMZb3YXsya61daOP11sA5LBU1gZ9tLPWc3OjFbe2vTxNT3QDjs3+VPENkoic +BBABAgAGBQJW7nw7AAoJEIEhrhIbzz9tIMAD/3EmYCV15NUqJ8uqS/LrU3dedjSZtOl3+4Lv +Q0teBPZ+WIwMs2O+G1oXZcTkR5nMA0MM2OKiXH2zYJluYHuL9X1cfBwgDFfZq56GftSZD/FQ +spnjzlZMdGRy7CNA8NRh2cHgvdjQY54Uh+E43vdkNOrUd/OmpNRUh8EHPsEjF7/4iJwEEAEC +AAYFAlbufD4ACgkQcTiNjoqsG6BisgP/W3XDp+WHnEpuOv4jc4szCk8OCZVXjywhQ+qHzk6Q +sKvbICU0ZuhBn/Z19r8AfLVgyYgPh1yWuXinHqHNkISFL1nTkoy9LFqCO16p32ihHg6ISrtp +TrEFNEgliy6sWy3GGJxdrlycqp3rmvL4CBpphYvUu339EnNEtmYKOCTMsoqInAQQAQIABgUC +Vu58QAAKCRDWewgv8m4j7/w+A/0aykAIuRqF6XQbVf6cRJG8lYQOxEvwCs2Fcvf8c+/3Q6/F +Gx9dhXBbJCavGI46I1ux/KZVkWoo7R//n4iy1NrjxmSsBh42rYoBPNmYZPHtyTdyd96CyB7A +wiP0Qwev68PzsZYocxfziSAaCDoUuPs8lisA4+3S2oTKqgSPz8H2KYicBBABAgAGBQJW7nxD +AAoJEN9vn9gLq1N7m78EAK8pCfSFgpRHJIjMFyFRwYwApQi1fszpluDtBRPlgXyQSsRR3Lfp +8dvav87ZVGr8zGRyc11d3HhG0BwRqYNi+EJZ8r78NJHswRCcq3Y7xNpuzcwSiJ+VqjHeekp+ +TTKTLhBMA+aXhaZSh9uqH1e2aewwIv/YS0/UzGNv1CoFjrqyiJwEEAECAAYFAlbufEYACgkQ +Pju3bYKYoHWW5wQAiX/dcQfvaqygXUlObFEsKPa5O9G2GacWKZP/qqVdkTzjPR2tUziaQpSc +qGw00lwWyGqXSimP8Cj8XakCQSbkVYdujyitzIQbCfDf95wRSFF8hdWQ0CdHshYjzTkPyvv2 +NJkjbh8NzriBC6HnJ1rnHRrG/QWEqsRPcNuB86YTe1CInAQQAQIABgUCVu58SQAKCRBOlAEo +kSlBi66QA/4/76C+dphR3cn/Qr8vep6pz54D7xGqo8okZwN/vRN0FS5JJXp9CTiEwgwR4xq+ +2P1iBAuUor1BOi+xoPxedDf8c8dg6CwO0FfQGa0sSualGBXouINMXKjSK1M6khImlXy9MA8f +IQ1pG/Y2de/yUojqv9dK3v1YbAdU3qmc0u9tkIicBBABAgAGBQJW7nxMAAoJEBlLWPr2PLf6 +vhUEAIU+K8gm6A/7eHW0rMZ3fNPjCWuJ5osIGQAygXq9HfEros1YZGuT6N+EK6vxazKKeZwu +hgi+pHskd2ujN/iT0dGsxmeGXQOlP7bDua7/ZWevE0+6xAQUblR/KVOgTCG2iCq603/yfjKD +7n7B1FucHkZXCvDvaPR36IgoCGaKQoQwiJwEEAECAAYFAlbufE4ACgkQp4yCt6JGzLKFewQA +jj3cp4zWl8C1V99su/r+SAQ9LUuuzMtdNydhAODWgEa3YOsti6MHPigZiqzWHG09OqIQsm9T +84TP63ynE4WnpRU5c3TiONFrsGFrlTuDFd4Cjm2GD7ZwFzAuwVFrPWOGeUCaLtegYenKszd3 +huOYsQHs3njIPHUPj7YLM2MTsUmInAQQAQIABgUCVu58UQAKCRBYJQoLwReIphTVBACw1Mtg +d6hGovO2RdIfsGRaLemPfrW8U9/UC0UasWHaypmCPnbP5axzuwtxoasyCU+1+B6f9z9+QK9P +QXraxpCO6LROnXkqKa48Xv0z6ZsuqNC2o9uFJiOQ9SHe16K/bnGu2xkwvxzS2ARmifY6iHd5 +cckJr67bLdGgJVFp9cue64icBBABAgAGBQJW7nxUAAoJEPfHAtKdsRvTJboD/AuH7ks7KZu5 +WtZtD5LWVR9SjAtbDhJRzEk3eXpzM1OfKl9yviQ1mKFM7HGvrpGgyFiiHHUyzTrvcI3zMvd+ +p6IRJANDRnMURokYWg84vEtzD0mAZMFkIYBoeuR59iHJokkmqW65ez1CJvQBLrvTk9higjHv ++ZuzekRsmcgrOl+aiJwEEAECAAYFAlbufFcACgkQZd+NvP5pGamxXAP7BV5mjtoRSUVTA4jp +ZznhYNH4wt4+/kSPpjp2aVF/DFTt4SRDMXu6Malq09lwzeflNZTrCV4bpTS83FvHXPijwD9a +0ZZUcnFniDoSA4y5XWqIQXDJ/BwRGaVn7QyLBcLNT0j75tivVuOmFIAzY7jCJNLZUaTbFmeo +QLuBlLeeZxuInAQQAQIABgUCVu58WgAKCRAMsQ3Eu36G7bMHBACQckGtg71g5HC/iatcotMI +bU5MzdONnw1uT4yfwdokZZ40OsJ0c1FF6zenRQADPXrGqkn8AnLOtmdn5OHP6YeZ9XFE9wSe +yKIXV0v5hCWngEMahbYw/TjIrQp4Y7LOjx7hXgRPGCDnkZquvDxd9iDgIvV5t/0iav8RtGs4 +e7lF3IicBBABAgAGBQJW7nxdAAoJEMJsz5mMWy20iisD/jbWKGgblP0MEZO8nndRYB2AOYPC +xInnEic02u1Zgc9Pnb5db4eMXpy+oeOr7iuYL9IwvuK8Rjf4Ez/K7rlC/l4i85m1O8AQItso +VFWpIlTMTI1S3H1rQuV0LT+COoKuPC2lVQNiSjJreqFXnmGKZCldQO0mcK7MoUF3Rsmszg7H +iJwEEAECAAYFAlbufF8ACgkQSKmtBCBbjUIwwwQAn6RwYTD0aPaxCo/Sh4MXhxuhXl4kOJ7L +g2dyZ+fKt4rlKrB7j3fdiEPB/kUdimoEsrWM7oKEGIipl2OA4DIVsr0A8sBsfSZX5t6uwhAC +GPDnEZGgYi9D4dtCarujDaOGKZ2+27LmxecbEYhbOXwBHyKGDUCBAqWfuYI1EZphrS2InAQQ +AQIABgUCVu58YgAKCRBtl4d5BlV1zBJiA/9097ivp/ALPSv9CZX2wqPdebTtpHNllUKc74my +ZiXyBgvBQlTnauls4aalSDOZLf9XSic5RvRngbSnDNt7f9JHS4TULlDozCDX4E12Ki2EwnEv +4F1Bmk3a+1QU+TA2fFs91myOqJ1voN/TRUzvyxoI1GJHGQ5M9+3aE8BGUN9Z84icBBABAgAG +BQJW7nxlAAoJEPy3Mhxnu1nNjXAD+wX9poNPQmiA8CLngqMexNFD/C1ck+UTTfXzXRe3PnDd +SyMVtaJmxk8wrrcrn7cp66+BeLuA4wiEiLMSfoQpFky9X2L/ZlIzy/PbvFsEMPVezHTZj2Hq +x48ApYoXGJOhqjB39VPbfkBkWba6POH9E9JwEH53d/Uu2VMmQfmyU3kIiJwEEAECAAYFAlbu +fGgACgkQ7Qv/1+0VWi/iUgP/Wr5pB3SMaPq3MbE58G4dtX1jxcaEHM6LLOG41AXVePFRb1mp +LXhT5fGJYkHXYQRmBCwe9Su9cm8R6Y8FeIBLcWR86CEPiaR7oZd84uLDkK5A0lIi5MvoJy76 +ud3Pvm36/tZRktbzHJ89Vb2ZaYcedjpt0rH0Ygs7+ynxvcqtH96InAQQAQIABgUCVu58agAK +CRDuYi/Quiw3htPlBACyuQN0W0HFPSnQLYS/a6YQi8ZiolyTVjrCk8qGiMTlqw0jSiUmTlWT +eKS6z+TcKTAexJQp1UiVDFO36BevWabHjeZQYRCpCND1RnNhWGa4Nb/oCuCpfMH975AlFu/q +Bn8N+yy70+JxVa9kmeLQUslVHL5QDoCRoed7AVNbRlRZ/4icBBABAgAGBQJW7nxtAAoJEHPO +HNmMOF9q5boD/iofcFLLcyitsooVKiRxvKdBc6eid/RsXpU5EwCU2ZxtK45FvJEWWU5xzNTP +phoVFU5h/GvetoMq9l4ODdeU1tSpBhZFbITfOok8euVvIvYpOJ/V9ldj+bA8YGW0aSw03Dlh +HoBj9aMJxwviEzZroSRnmwlKwAzW6XIFijEbfg70iJwEEAECAAYFAlbufHAACgkQwkW5BKr1 +XbsFfAP+LyAILl35vvEOC9iNnqkn60QgMVO4rRZS7xOWH48+vQW6YEiIuF+REleh04occuZi +fk7Q+Leaa/9JOZAocOmOnA0z4GTV1eEdoFstTzmQp+WBMPypbUdfP2/t8nqj+l725V3y5sbZ +itIMCuErKmNStFYl8AksHPhqMfAeuwCz3GOInAQQAQIABgUCVu58cwAKCRCrUx11jXLQIW9r +BACoJcNzuTp6M3oD/zsA7tBygWRfrHE13vkkZMy8ZgxAC10bNphLMidwcSvrKj1ye9ivuk+M +Y1iqK6q9JE7sVD26MligxIMGT2oO01szjR/dXbHTZBlW/aX1kf4R1UqW4YAziNVdjaoOdl4U +gLhI3o4sJz48ABik2cLyrJF/t++Of4icBBABAgAGBQJW7nx2AAoJEARwhjlm9uK/gMED/iIg +Kpq07ugEMRWbyrRL62TxnCAkGQFUuKlJOTROOaXBCE7HJRSE5SIgWoLBoqWlosMebVDMXVXU +aLtpph4PbvrvHLzz14rfJLCEgdINH/87oW+Z7tcp4YWjD9iz5B6YOEpwxtG/Sz++EaVS0t9w +gMpkkcooNEIl0QiSOs4++OyaiJwEEAECAAYFAlbufHgACgkQNTPaR9dmM0SdIAP/SjiaRm55 +DRiKdhMS/HqVHQoiVIujfyWsKlEKIElFlbT1SGfPByS05RZrfvi/K4h+dlCDPp2AVMY1EV+J +MdSFkMQ2VFoJgPXNR3xK9Ui3cZ5isBwirPtyRfwsyN3xxH/i8GHb3Kjcvg1BqTk5uhbqky7d +TwqwYZcy2vY6H7pOUNaInAQQAQIABgUCVu58ewAKCRDeW298S5/6HL71A/9w0Tw98hxCPjoY +h96OtFYiz5G0HZyXsx4pRA0KULJMtnPX8oLlEvvagKzYWvA3lfyQA2pvNwt48vrquuHrjL0A +cJT62H02/MUFKjmKJHfHTqLZI/COTaGtjEBullKy1G76Z4qZ2hgMB7JNYWyZiwcvibBI9Lpq +yvqNHwXx0lxq34icBBABAgAGBQJW7nx+AAoJEGqIIkTDXvq8XnYD/i0NXIHgyVINN1dOFOrQ +NLCL26sg6H0ENsXUd8bxhuEVA1JFIbDGsMEwifNu3zUT9VBr9UPeIUw4IypGoIT0pjC5CRMF +7PIqK94/eolN9Lnq58Wha7QhZf4OuWItMKGKUfxlwr7bMil1c0JWeRo9AD+nCnPeojatIqKV +Bx7+ch/xiJwEEAECAAYFAlbufIEACgkQd28a//V4J0F/WgP+ILH7B4ti1/PbeRAsRVzR510c +xTkhXKqoqcZeWpMTjZDG0i5PQEl1Q8ggUcWpKrUfn2lRRl2SP3jBolQoc24UDA6n5+Kw6uH7 +1i7tXp9zg2lSJ7dKTu+Oy1NSRnz328h6tiDrMZwZGcgIOQEVkIGvMLuJBN/5aIbzVu0aGn62 +6oKInAQQAQIABgUCVu58hAAKCRAWiKh6TLrGzazaBACJlodcBrXn7I69XKyB7A2EefAUgQJ9 +/omnV80fLd/DXnljaY8NrmGmZtnGlfOmk32VGd3Lw5eiG3ITYZRZcjfNG7I9ghTs62mAGF0/ +83n4Oqidx2EMxk9GQHBaKTC/R8PQSI/SYlX7rIp0M/3bGJl5j7OSIs+L9k17AvUE5Rp/y4ic +BBABAgAGBQJW7nyGAAoJEFE7YcWKb8MeCAsD/ip3pVj9757Sj2BCFk9wBtKS7DnFxDGYmwrZ +MNbmkgAMW99TcDcv0FdhsES5QOwbpEmKaQ11CUS9KcJvcqV+eQV4ngGMKpWOVln/8o6/iCgQ +e9gX80LZiSHl/oAoK8xMepOh+L+UozFxJljAPGkMbG4a6MhH4TBWCBo3ouwoTQVUiJwEEAEC +AAYFAlbufIkACgkQx7Au2RAjJ15dpAP/fTXLTg7MY5AAHa1uaLC+AFzMBi8SpMweLDWfG6Id +Ey0WgxYXJE6CQBoytSr9esSRXzy37kPS+YfTnW0+w+qKMoYYO2okVxAiQC1/qZKudbwr4Gvt +oTmM16vFKRbNa59TWgquUE5Q0EtFI2mhPsfIbaILivdVxorqq3rg8bBDNCmInAQQAQIABgUC +Vu58jAAKCRB2Qk9IXT7+YUFXA/9ijRLnZJrRiAUCANxgv4mDHOZ7/LUfZPfdeMhAoHWqIh/L +z/6ev/wRlg397BjF+v3mPaUoyJdkDQu9fdHgy9OkicLkk2mTJokSXNmuFdsU7wKgRasr8K+F +FcbHuCdlkR+BhiH2HwIP9DniYg0LWO31m5/PWjicoP5uD14MaIeLlYicBBABAgAGBQJW7nyP +AAoJED1caa+WiNJkLYUD/R1l+AGTKvfHIXjxmcj9NrmCXWKVpzpkUj1IUp6xLdcYnvqmAbDa +/it/8HXbMNdDQqsLS2GhAH5j+gYTKEhjOqHeEaFcimXs/ji6HKdT7IIhxcFKwrfhYVrCbq6A +sAWhjmaVpGouKgKn/ODJxTxHvhZApltiWKXuivKoKMTZm6h8iJwEEAECAAYFAlbufJIACgkQ +7H3DAFurHuH9uQQAiylvlxcDYGTPETrCXlLsu59P1GPmTuQlpqQLp1NoGU50hyz5+bnrJxu4 +nrSpo3aAU6wly61dZWBkeoMTPF0tDRwRVxSAq+XCeMao1rgi+TgrQUactTUaTevgl6ndLBfG +5CW9diOMVtKobHUl1NRd1be2Y/iTBmmiwnGPvd/R+4GInAQQAQIABgUCVu58lQAKCRBaseAu +aaXPKzeuA/0WphiwVE0G8PZ3IejX1H8KkMO4UFmIFiAiI73f5WWuxWteUAHcQSopTYfVT5en +F0bmXXgKajT/Ygx0rzdF/rUUPmCXG3+fQlyTlm2mAfWzIkeQRm2SeKwentcnh7efvYsJAz8U +Rr6/wzoMdlj2hbCNUDPbphjcumEdyU49+0jWYYicBBABAgAGBQJW7nyYAAoJEAwh0gDzzZIq +jrkD/2s9+vmOCwl/DTdZIHcnGLZA8zzEigvGNBbrQLiRKWrLZM1Zcssa5ePUQK23ebvQtZjo +bYusXfGq3GcN16tdM0SnF4/mESIC+qMLRXO25RJqvIGS6P6m2YdrpXDlPLHRvMyqdHowtwZq +a1iz/pAJJ/dbqp1w/hAFZeYbd13rvDsHiJwEEAECAAYFAlbufJoACgkQ4Ltsg3LQOM22ZgP/ +Uu4ei5DrtH5qWoQ84WEnEGqqxZufJTuUMczgDd92I9e+yL2dJayQtly3Nls5mLF7KQKuF8+d +5TTzLRq+ck6p1roY+I9Z5NrdOjEe6pnydxgp1OaJrK9K9zYILy9zdSxQqzYwVCaZo53afZBa +E4NaVkKsToQ3ZCqB7bH+p9qpxkGInAQQAQIABgUCVu58nQAKCRArRCxYJ8DXWO3kA/4qesEX ++qTYITlFS47mQ+u+MaRkb2r+wlDE3QIVSNSsX66CpdpFjyKxcEoFAnQm07S8C84tfG2Y/9cG +yho7kRMKSZb1zKEJYtAONJuR17a8erw2+bKzbrqHjkVlwivL/zybfcMmxRYbHFXTwsYdFECO +EhJV4kxaiedfwOf983SowIicBBABAgAGBQJW7nygAAoJEGEAzpRFtZId3GAD+wdyoKbAOUh9 +XLJZPTJyXCBG4ym7G7HokO3trgvJyhRMyr35Lgve0zQ48t+QtWcmwISqTgY5IdI0HuUyME5X +dJRYnYf9s0DLsOUcpYaIcwvHQLdB/3r9pMn1zvvF/uFQNApGQT8pQnjxk5WPuOsfa0DgnbEm +aABYCq6tGGkfydNFiJwEEAECAAYFAlbufKMACgkQPOJLg1II9Cx6YwP9G4NLN9mgfmbLIJEE +D3jYbS/QbTqMHMLzs6nSZoU7ZdRYuKwmS2Z+ICW+rZHU6hwEQ4VRzt5udnGZDE3JIjmvf69m +PJ6oC1k7LMOi7LS8eVulJmDlIIV6O9c+HYw0msBeJFzqH38+9lnDWIMN2IEsnSMnOax88Lrw +xLaL6cwUSzOInAQQAQIABgUCVu58pgAKCRBFhUlHNAnakMNIA/9gGufomwDDoVcOT64xZszr +oDP+beCJUhtyctLuEP8UYQE/suMcudq6k7T+PXzGmotGm/QS83GUeU1ZoOnG9YpWCQQDq+in +vmjUmPasZnL0oSZbDPx85h+4o09ReKPRZKwA/u8GqAVbsq5gzuigIviR23L7zBFBX2X+25EH +Qs60PIicBBABAgAGBQJW7nypAAoJEHfVFFyzj0okPn8EALSFZfNKzSkmJLQHnaO1/HbJROhD +UKPEMtogbG9w09ojd+//IX2JMRJBr7wiOLe4siY31OpkT617lYTt+e+RnnfTmAt151H1fnC+ +nAKlufMxcajtMcwKbVLl4XADlI/KOdobUYES5P83tkDB7RnKMaEVIdF3LlxJzViCPvOy3Mid +iJwEEAECAAYFAlbufKwACgkQUEzQ5BT/ScwuAQP+PJ/4OBqrPjINkOpVa0Zut9uw4MKUkj3Y +W9CNHL4tnQU1JPgePMT+5TKtVi52/K1Ck/PYQ2e9arSba4zEfnzeJy7d4rzfD98ezJCXAQYZ +bTNkyM1lG3MetfD67FSQS+5AinKg8fvrL2dHmAUNLtxsLBWzJIBG7TYSlmjJduXbkq2InAQQ +AQIABgUCVu58rgAKCRDvPlQ5n5SNjkoXBACIg8ntrJtQs2dnoACA+Pe1fkbLE8jE6X59LZUP +yCQFgLj5H7T82yuCEDn9Bsvo+3HssNZX4XN2Ss3okPs8NJn9ZPVWSB2Hi1nc7Yjx/qZxYmZa +7u7Vvunf8x0v8Q2AFd2JbNQT5WLmWdpDAEZkA1MDpgH0LB2GLpJWJh2dZfcFKYicBBABAgAG +BQJW7nyxAAoJEHXBTFRW3me77xUD/2IphusDNBe5Uz+ssiBfpD+l/ySsr3LVJAfOQGLp5Cdh +isOTjvMY+6Q/TzMQs5glquHdEAyrB6hweLTM7wlH19ZW/7ygEkmYgKQzznWFN0IiXmfhcpAh +tHShRym4LBAJo3bl9Eh2UA8H0MYDHc+I5kjG5pgrW3Z6tjrGJSaLtFP4iJwEEAECAAYFAlbu +fLQACgkQIbEljLErpFTUjAP/RxKhxoHCLwvUM2zlyuj2U7CKYGHC1PC/Z6LSlfgQVB3GMT4w +Y9xIF7TYaUaCdNjv+WrQkVWAFnNep4Pj+XKtaGJDb+Cb7ZAQU4wVHqEo/GxURBRDdeiVzhOE +vBnY42+Ux1S5lv++9kLQ9yVSvV+mok9/N4j78cKLO4kWXC3u+L+InAQQAQIABgUCVu58twAK +CRALHiOPcd+EnpKZBADsIPW8aniTEH/ZWn3xujv4kAa2637zyXyZJRule9zTFxaT3s57KkiT +qLWtjVde1CXXY7stAeH6H8B27ayEQQTx9h1gecwcKAkh/u/8IaCzLAUPanedSEhRci4kMAH0 +2tuuFprzvXNMYyiB0aR3xAFpJACj29q8bVV62ppDVWfMwIicBBABAgAGBQJW7ny6AAoJECZl +oJHb8ezq8KkEAIXq6LC20o9iiQDXW5lw/DeKM3g/PagNiE5xGGrAEZo4Os9Fxngn/eau3pbs +JcU4oycWculRxe+2fboBTP7AzuWSm8C8yjxZQaKUpB/xezCVGukiCVUme8ysFEt2lmm6mitd +JYyh0412s8/61fuwyxHa0s2qfgeWWbVWa/yATtgWiJwEEAECAAYFAlbufL0ACgkQRnTosM/2 +YlikFAP/XDXMO0D8oconWnulB4Rqh+O5Ddu4NV5hV9JIatnZ8YoivupG7RhOc6k0BJrXajZM +nejhClQqE80RLT4qJn7ooE6dhZIqOsryvt9SVtp7R1A6uFlA3aQVxeAe+GYLDQYvhTEdiV1Q +ifov29vPU3scrMBBZa2IWLHVYjMqrw1gt+OInAQQAQIABgUCVu58vwAKCRDPoc+YOJ5vjjKL +BACYC8MMVbA3FnMGtjVIznaYzUZaFPYsS4lxcwew8+3C1Kwnqz02mw1cuSjOnchEEGW3Y+v1 +cygv6hiVEDWu0oZxJVChZLsEdwX27ihD2ObrGdRPdRSqLxECdu3veplodhxip6PwbFxdrUO+ +F1fsuu0iXvcwdR3bscEsJE6xDLxa6oicBBABAgAGBQJW7nzCAAoJEB0T0NZs4KeDV18D/0on +LsqrQWrP4xqgE35DcXXQNvEMfry9tvAgffaUPbuprZM01XyluM//U1oIsjfeoPNp3WRxbuIY +QiWcq0dnbEM/z9/VYuIxpppgfEevHOL95FIay6LueA8vJpnvRAFQ6+Ov+1+TsYuoscQi4eVb +C7FN8pBUfkOr/DnymKE2EWI8iJwEEAECAAYFAlbufMUACgkQ1UEVC/w5ZvqynwQAwDV3XodB +09hjROaVKnoU0zmuj/h2v9sppjjYFT5DWbMQOEuKpBNMZ0J4piDRQMObzFm3UT6g/JOL3HYH +KHTc0AosaI3roEefoZO25QiT3I5SNqRrCU8CmJblKyn4czHQD0EFsTfmQZgKwNhZgeMMyI6T +ZWZM3Nd8isFqA0eZFKeInAQQAQIABgUCVu58yAAKCRB/CmEFobuNIQ+HBAC3njgq2EKhA4b5 +R71+IfPffI6uWyvxAY3D+Tw1to676y5BOEu6bTXN0zP3kg5muu2WuIj/W96jkdCrZJE6tGr+ +rMrYh+GeyFG/HXVNim+uBY4x8Z4Df1IvUxE/3gVGnzySq4I1FPW5owoF6/sLO7l0S2x5MU9j +zm6XfjSihoEvO4icBBABAgAGBQJW7nzLAAoJECVgldsuMsSqfL8EAJL5iJisdAqA+SFNIz0k +ZxkqWddj6svVtdVU9vayeCKs2Ncaj44CN6CF2T3mhTMyLCqx1DUn34FHadJZ/zkYzfEstFiJ +ZzPxBDLNsJjGz0FIfdoqk5pHQcBxMSqZH1BFZJmEMF9hNKrS76+j0d95W1GNsbu5hcUlQDJw +8fmSkgHaiJwEEAECAAYFAlbufM4ACgkQTnki34H1PN8NQQP/XKow1FN3fsIuIKGqBPnxGDTl +29VsnuU8xgTCH/8paYGdGRBEFzL/QXjn6Bc/a+7y/FIppGOBmFxS6k0aK1aECAIavQj7g/3m +uBDVV4+GvxDMq0QmdVcmXagv+gkYEFUsb9YOfss9e01pwsaUMIgHETBrC6XsCzcdLitY5G/K +TZaInAQQAQIABgUCVu580QAKCRAbdrX78/D1kJWkA/9Q5AHugIdGY+fLKT4VTu1mGo2OZppw +X84ZOVaSOe9fAmjEXWCwBW85GVh1o2NZO/7KPousgrei98jDQGDwbHlnyn0MK0Gh0ZbuldE/ +Zrxjjwp2lfuR07O/dVdQgZP4wA5L39LPLRFTX5xSPmp5WxCgjm3AqljUY8pjDKaPYLw5soic +BBABAgAGBQJW7nzUAAoJEJ51N7O8CpO8yNUD/2qVhUWbWqJ2+Btn0kjCtuBiXr944qARklL6 +rIHJUAQ/O6pcK77+dVqI6idn7nXhxvyHV8re8OavMwHMkzq8JUf8pF5sTjQmjl3hJDUGIiJu +3J8KM+rCETGw3/Xj/4x+7zn0Xmn+U0RftoArHTh+PxcJ61kZExWJY+yjRSs8Fs3LiJwEEAEC +AAYFAlbufNcACgkQ0hmKGfHUXizL/QP+O8CRhGi5aWvYVcpjnspEdLHXauCN7ASs6e5usQ4v +lIZzEN/UicsJpc07whV5QHN8qWZ3fMhclDm2GE+0HEBf6xHEoZBkJS1jWQDAAQaxCYMy1ILG +zGKoHNm2e6snM+hQQFql35VrFIaMWVQCtr4JRfwZkFaPcIBFGrbYMyo39+GInAQQAQIABgUC +Vu582QAKCRBIndBmPeNuDGzHBACK4axsnqyGSnwysqzIk/hu5CuSWICLpN85TLBZFXXyUnwt +bthQEmSvlKliJqFD2N3bbfTDFK+QEvmwFOvb6G7j3MnjQBgu+mxuqQfcdmh+p5veCRiD93Ag +zkJDjmSLf5Lg36zzC339h5JXCSpnAY7cpnBXe+YHOMl/nPSjixY+LIicBBABAgAGBQJW7nzc +AAoJEH2v04+yAm58BhUEAJVFUroUfmhh5uVceBbBPM874A3H+JaoU1vBFl9uW7FelBjwV6+p +AyW5oY/oULHMSfz+DtY3ma0zi0NIsMLFWBbKllki1MpPp26frS69PGEIrSCkrcMkEC0zb5rZ +KZzbDpOJPDsnVFFM5pBbV5B1f4a9lPj+AjjBFlaeABekkaeFiJwEEAECAAYFAlbufN8ACgkQ ++Oelr/M4iz87WwP/XqCFV4cz9afRLBT9mHEw6HNDYPaFlZyhGE4IBiaAYbV0qnI0u62h9S1j +T+H7NBevvCpy9EPG1OqMFqIEllx1iUJ0qZ4s8uWlsfgUnBWTol9MKKdsdmMNs0B4WbtgsadB ++wyzGMMYyug2HBZCAD9p5yT4f6DPSFMokfg2Z5G6ygSInAQQAQIABgUCVu584gAKCRAMWB6H +0TktSs8GA/43lfykpDrMx0spdiAv2jthpEjvCsIw7M/hhzxo7Nrq4yt5gHanraf4YzAYADwO +HoQ6EG/BXO4t0RrIN9dgcKFx0eVshc3InKUE9ge9STEXBa9L6mwTyqq7cUkQwaEqw3S6yBwx +FmoM91zsOBh+jpnILnVgPaP16GWbi/vRPc4xy4icBBABAgAGBQJW7nzlAAoJEHyZoyTbfo/z +LoMD/2io+FrZyiBHI6p9KEfGzGv74mpVJ9737XGYJWHkXDp8hQGRjp+Pwx5alFtfcc4byJj+ +VSc+UvgEbGuloc5XXMZIHHgiooltckJIIv9bBBkKcZDvaVvMNJ+1DZJK1hr7o+k/CXm5e8u2 +rhswcCQBr9jLVjrjF8pUQOzPRZ6BBSyRiJwEEAECAAYFAlbufOgACgkQDi06X1zC+ErF/gP/ +bd+hWwI9nFjT1nNrl0gIbyaahUbD6jY8QyN9OiLUgzgp95BTpNR9gl8UHVlWXdFHrNeN/j/g +n1jz0f2DNh2zu2GGGCmDkZo5y6ciU2NdI4lQag8q79F1rjhO3dclOfwN9QkvSYZOL0f/WNwt +EkXHotzmL3pqiyqlcE+ZKjavleaInAQQAQIABgUCVu586wAKCRD4NHQ/XJRqEcPKBACIBPzr +4mDonlgo6wzEtyT9/sptNssvlhQEVy+audbHA+St+NcIvUCK5Ltl5f21CgI3XJcYflhnIZ0D +DE3/hQ3HiS7daLKC5JMLo2dT7PwpmvZdIca6Kxp1sHi+O9ibxzqj1OQZG4uafhIJzKY3VLAI +dAU6U2/EZA+Ac07vOfOS4YicBBABAgAGBQJW7nzuAAoJEMXFJCzuHwQtrCUD/jLpy973MfkR +aFV0D/OgMcWWdw23SBaqY/nBNmvGrF6nchZb5i1Hzki1w5rfbei8aWBh0pHx+FUNV4c6PNiq +gxGoea8HadNX5j5H+9syIwq4Iihrqpy/K/OB7KL6Q1pNePTeFCQoE2kHD+UYYuBLHkdMFVGY +RiEFKX3LEpkcbngXiJwEEAECAAYFAlbufPEACgkQvzk6dfMcyvXORAP/d4WOJgOzCrZPGgX9 +ZWIyd7bFCK2xezc+c5cCd/q0aPCci/nraHYtpJ/cAXJlFYAB/SCU7fvazlkSsc7wWQNGUJ9c +J1EyLeW/SFlGqTyst1e3ukC1r3DYuDmF3fI3xG/5R4qFOe4HLsVioA49ysjpb+C51Pc5Dg9i +8IBverN5C+SInAQQAQIABgUCVu589AAKCRAajlAKb0LryBXlA/98Qr9bTBF8DE8M4mw5ZWJn +FHiBuSvyEEOvkZVcFVondvNhWw6toGXg8K6RsOtIKlc/4B0QLJlzTnBymwaq85zur4VoCZUi +mYSfjss9QZMsol1GqVafuyeHNZEqXLg6jxAoewoMDNtH0w66hKjb9YL8sa+jFbG13S/HvcQA +gEtH3YicBBABAgAGBQJW7nz3AAoJEOgXAoi98rhv0MwD/Ra2TZmQoJbxSyK/XofomKnJowbr +vl2xj1FyiRXTpUkXqnFlQyrWnT3mYGicgERtWZrcq4WVqXxZqqFLK6vtHGbz/ryPn/cC4+Cy +C/WmohUFX4lk09ZGRVuGJwopsb//o6USN1SLcIiQK0CFLOa7W521kB+A7w3p6oskyYrCTb3S +iJwEEAECAAYFAlbufPoACgkQU32x+vyOAV8iMAP+LEPIGH5MNir2Rfefcs77LiG9IkNWWhWk +5QicdqdnyBoLskkLWV5J9EgToA3krry6B97H4xbI8bXRBL8kDit6aybnZG/3mannZEfvQ1qA +ADMDgkKaXLl0BqYrI7wLSU29sBPdqKwOPrZ0m0wLbqh9C4nvqww7AEf3tW2CFsMuCeqInAQQ +AQIABgUCVu58/QAKCRA3mkzrMRexsFVSA/4mnoAWI9ht7dAYDL619FcGuEzAvFyI7uK9Dl2r +mHJc8GvdaMWELXy/ytJiOcMFms1yJGb05PnVqAP7Pp8J/2Vs6gcsVUfTSR+u5C3JiQe3Fd3I +tf+Fgj67Uf66Jr8hHhQcLa12ip9w44JWWJ1Sxf2osYUM6t8XMM+r6qd2/TmfjYicBBABAgAG +BQJW7n0AAAoJEPdO8VIfKkFCPOwD/jDX/trTsz/cIgGsusLUdEaj4xnpn6eMZRILhZ8dvXMI +5zTZNiS7fdfy6QiGzaASHTMDvHqCtcnIrJ8II/z6kTP998wj3b4Gm+OV2UkFhzlDG8++padD +CjQMmd+nSrcHq+Mdwj4EENZL0vqzSuV06VjcaC1emctaWfzL3EwJRr44iJwEEAECAAYFAlbu +fQMACgkQ36G1+W5p4+pDLQP9GUWqnKOaizlvf/Bvs12zZt6F/HWpmVtq4zGn1ftWXu4Jr5aY +iBLaszi97XcLFNcV/DXb1Sa3DvIGOSHhhFjRU73Hv19UZuDihDn6WPVc5DVfg+0tkUnnC3+H +H9ozJ+vMRAMx8kMprsH1/bhEOfwgcYvNPggkIuxAsBLOTCrhkKSInAQQAQIABgUCVu59BgAK +CRAV4wNm/+e2oQXYA/49KYLJmMMNmtAnUTuM8NSmVKezZkCwDr73cS1JOOoPZB068+Ehdc3K +WXKcRQ+OKsegGkBVzQpaLkAtaiREEpSU9yRpNB4jRrJQYIEFOCemHu4NBj/LdzBtKHdCyN1/ +SnQ/r5CyFOl+e5ka/MOQ5bsb/hbqCgZUyHOR57H/SpQmMoicBBABAgAGBQJW7n0JAAoJEOuI +ARZms+/l0H4D/1Khj+Q+Zct35Drmxog11WG+TEE47/SgRataGJcmoTHrskWQk4mfhpTIjskf +9amEYmu9tpTx+ILaqCf7MVrpAH08LOr8E/O+z4mePtaZ7LMM52HVhMbNh/Zerzji8eIWN4Q5 +0jW1+GxZuHBbdll0lKnEpefDboQRuS7/3RTk8ReXiJwEEAECAAYFAlbufQwACgkQik2c9O4l +0olRgwP/ftHsqf4uH+TIcFfGz7154OvlwVswiglsn5CVvNM0g9+LqICz5cHuCgNeajGYjQBc +Wvnlr3pbYImM1GZ8P5NcnrRx1s3Vu5a3ptToOAAMHqIeV8tsRQRvTGIATrtOjg/fHp0vibqO +pLYBGbxZTjZg76++pcDUwZqK2WdiOr9dIVuInAQQAQIABgUCVu59DwAKCRD+5ea84nWb63nI +A/445SmE2kSMlFDM7gkL+4FJpPCXL62JFCQLhgmllxDkaWe0Lt+ovilN/JoeJpuSGC9rlTbU +/h3zAdm7X33Q4iNJzjBtnxTbrdz7UghgHi1W246DE268oVkdUQ8+OHiSW9cWFU2VoGMXDgk6 +PtyIeWUVjRW41gC+1QAUHZK3ZkntbIicBBABAgAGBQJW7n0RAAoJEMGBL3kuYHDuR3sD/iW3 +o8UGIxjqE4yozSr8qpETi3oYCYRgr/Z47/y8y2o/rUG9t02aiCWxn6JJcqggU3iS68+axYKN +iyO+fZ6go+tkx4wOcBh10ghEQXK2xXA4N5/RcV6wSOzBY4xU+8tqEoow7ptgSPp4XX/k9433 +KBCg6kI3jhj1ESk/DucMUoYniJwEEAECAAYFAlbufRUACgkQIycH5vy3TfzaSwP+JVzAuwSt +J90m6b75By1CWA6ELao9QvHHij3AKRv+ySyjNsas0k+ee8vEjBTaSjGMuxnG5MR6bcJodrxg +KI5dtu6VCmghPIlP2lK/OrjaSopkjLrgE9XbpcYpoz785snEwHTRTVDF/wkcpouJUA/K6Pdo +hhPvu3gCI3UnCgEtpfeInAQQAQIABgUCVu59FwAKCRATpsHT8yhRggR4BAC0uzftgO0QuPep +Z5oMz3ru1wVZGstcj8afZ97qmg0E1Atg9NCXpXfFDpCtVjXUPU9/gx4cT40r9fGIO3hT1HM0 +dI3KjID4qJrkEdn0YGZLBxGqB+ju1CqG+SB3VdsroXLmbGMS3wo5bi9SsSer/A8YIAuzwMvb +fjkHncSUVVcY0YicBBABAgAGBQJW7n0aAAoJEJ9Spfmdibyw+UYEAKDASfrH/tYAyFU6IRIJ +U9SAt67rD/wX50wPEMk8tGeKZ+ittnoX3SzMYAhUPcJ4akIPC6uYT3/RIIxVW+YONZgTceQP +nqJg2WgLWfv3s/BcEbU0FE8hWVXf/dpu0C0uD6Ln/iyhk2jfjDTR1+qJyno5gdQu+pngquOj ++eKwH/4KiJwEEAECAAYFAlbufR0ACgkQFBg//rVtow4llgQAobKpN12Q33xxMo1+VBDEIXzk +qevoPT7OCm+14iw/fm7f4IQLCZsEdWRJHqeZZUtlpNkQL7iojdc+4O2tcBsAOGzqTCJpkJb7 +q2ril3RTYbyoge7o/YbIDk2DniGNdU8M8F8JQ7P5zN80cgEkDTrn7mJX1gtsz2tVyNz+fH4U +vluInAQQAQIABgUCVu59IAAKCRC8f94OJ5amqYa2A/9Ty2Y5GKjbUV4dl8GHL8M7UCj9MQo9 +K+w7SH+yAv6/jDwu6hcwiERYcjx9qYQlZkjtr5HeHrwt2gTZmB1PSNyOtktusNj0XyxLQ/gf +mS+hpkb4uqnjt5wzdp5oXbqdpqanOpHCGRjvKTxmvvSkA+btfek6nNPHHdZnL/XM5aNJPIic +BBABAgAGBQJW7n0jAAoJEIEVaKm6adbVZokD+gICbgonKcXQqEaUX8AlyRIjkZaBPQet3TPh +of+sDq6Tc+r/RlERGRi4bCVeezRbEF1QkW6BDVRIe+KMdsveNIPGkrQjU4UXnwJhL9TF/73I +uMpT+uRZKD0sTq0YR1c8EBoVa4UAQsIQH8VJEqFwPxt4nJkMn9YOXt64iA6pMPRgiJwEEAEC +AAYFAlbufSYACgkQ7n5t44iIRrTsqQP8Cil9zPV9LfoiSivdzdpK3rWvvZJhpg7Nn4SJ595X +iDoOXVi9Tfkts8210o2VsFGaqH94wFA/Knfu/yWwT8LkngNW2A7WcJSYopKK+948EcNZr53m +yvyoNZjYA5nKSBwom49UfIGjkDjp6KgYSzLZf5Ui4odw8QMR7VtwbAgk4c2InAQQAQIABgUC +Vu59KQAKCRCa557xQSWnciojA/0Qv3EsnxtoRAN3xfMjyrrItjyhWn4hQZNpetfGfBVnwd9F +GHMyppPiPkhAbMbNXBYWwRMnKtZZye3vYLDjJR1I5Bwjn/AM1tjllhke4ia+q+rDbL3KVwgR +ubvhbiMNFpPzVs3y4QUE6M8twTyLdI5K/CnGOeqnRwi5snseATOK8YicBBABAgAGBQJW7n0s +AAoJECv2HSokA1diiXwD+wfYguaRirsif0OYY860PZ6iuTdGPHRRyx2mASe6oPWJ2Vaxc05h +he54D8rHjKXNGJTgI0bWFkl9yMgIpvCYQTpKJPTtEJ7xdxnSIsYRXpoCucaAzq6rmwTcV9ZT +B4Ia+KONPIGc6MVEL0V24YV1I6Ezmo8Y4KWXHFjojzcl0/gTiJwEEAECAAYFAlbufS8ACgkQ +mz0V9IuJoXpyYgP+L4LrIeNY4e+tx34zZsQFoankh508diPzMC4eETjrytpJ5I09oSaMaTm7 +WrEDajnpToFybdOIzOaZHi6w2YyvSarcRrteeNkA7qAgyn32f//U/4Iq/w3QcBPcIo1kZ1s4 +GCOrJufr3491FERdDPYNAFTTg+qTvZh4EcqZoAg4DL2InAQQAQIABgUCVu59MgAKCRBqMf/L +NXiJ5WTfA/92dl2KkOjPGnyesutSrdMoGtmpL0uwNmO27K3ycWJgv6Suj8Prbm95qBLZvgZD +uGye5C2O9FgGeqXzGwa5Buh36Z1iucZgWRW6UdZGJkbfIeLJGelQobsMbpPfMp8OZVtQpnhR +uja7tNKV9bJaFvgFCqV6xZvA1NOsJzlnKLMlgIicBBABAgAGBQJW7n01AAoJEPMWjHtFDj62 +VBMD/08jF0O3TDR+MQifT8WVspuRlnTlZcSdflTD306RFGLb14UJHb9f/wg0DWzq/FD5e/iY +KjIYnHaOHxn+6jWkSMiMfHmAhkti8rOImJO6gqMR1Pf/51qvk+GiWd88CGEXnoeaHiSyE8my +yYoS48KPhLa7w6CKR/Rz6jkMdDpD0/cQiJwEEAECAAYFAlbufTgACgkQm40QDbsc95M8igP9 +GMNfK7z1QR0u4/fEevjqQ0/SCnaGTq3RUx6xK8c13yjZ/CxnZar9nhtjOjRRv9H6W8rO9eaz +G13+Bs8BGJP7tOtpq6sn7NywyEo3V3XoZZLPm+HF1PMMLgRRHdLN9xG8ucpR/dxQvUC9sobp +nKWSewKoPeYUcJSb2Ugh03G6CEKInAQQAQIABgUCVu59OwAKCRBz+V2I3StpWaSiBAC3Yjah +uT9DD3kWXUxqJYnTrXskxqHYI+KNRqbBWhpUyx3cVgu9UPf26LOV6L/YUAefzi2reRNVlwo5 +3QvYw0W7o1VVKQYLcaRdSi1VlhqrpGG4rwkc4dcjs4328aAfelkyg9wtMOYlX3zekkY/lEXH +tIO34q1fapiX8eAf2nsXG4icBBABAgAGBQJW7n0+AAoJEP7aQMVMtImV5dkD/1jsK2Ky2g4Z +gJiJN+AiI5ppMFkzBTmNXRwrmZWs9htJ4TrRGVUjySSyZ+AKm6RApYagGU3iP94b9deGAp4r +/dTTr1fRvzOVZXPavzZWOixy6z0E9NR+KJucdgIWsKysSnI9snLOmCwq39DBtDs84mAyoQw1 +Ax6ZhnklDrj9YuXAiJwEEAECAAYFAlbufUEACgkQb8DFHXVOZ4w91AP+JzItCOIVkmmwkFNZ +vBMxoyiwOfN7tvs9JaPhM5YcfqDlG7wArp3/YM9aKbUqrXdLLhHvukPxdHq6WdsTP8Q7IgwG +2tZb9LjxoNk4N48szwGC9+gXqBp7sqh59BTDuFcbRs/7EVpcoHG+QAXCz/sJFwmbyysmXvJL +RakPMx2lCfKInAQQAQIABgUCVu59RAAKCRDSv1tBMOF5iargA/42Jjokw/QNDeyN7gq+i6gs +X8RaUxpljoS5WpclLmy4m6fwUc/JBgSrEUK8n6S06lmEoKUKGHicLX2qFeFNYNCyIZmAgjU6 +JEEqxuoTR3tMEWGZyQWxuHs3W0ogIIrz32jEMWpIUWv48uV/h7Ndk4XIFbefTKVAwMG75uoI +bzcuyoicBBABAgAGBQJW7n1HAAoJEFYgbD1KspIzG7ID/jfC98iI4XyHDG9RxtoZ0c23h56w +uc+jg+L1UyOjy/uDAT4NBQaSfjyle1y+bVXAlmvzdU+YCgMf2F4VVSIQEgF4CfGL8YIsXkn0 +TMjPKG4jOip91ceoOyutZFgyl7+F6fdFVfdieDfMWfz0WsQ0t05QOK0wnTs/qplueawqE6xL +iJwEEAECAAYFAlbufUoACgkQa9fpZb1NLC4kYgP/QO3VFzGuNunPpgqF7G61DlIOX6QNU6qj +XxxKH3patRwnwKUIeR0GxGGJFpV4HCMYx/kqfnkP0tLClNYnqujNIEVZ+hXOPlseWoXsswkJ +BxAuhsgnNEUREYsr4IITx7gUCk4SmMA4T12wuGGPUNTZTEnGxC3OTBEwtebua9cx1CaInAQQ +AQIABgUCVu59TQAKCRC3aSx2CmvnFYe2A/415wJrwMnnwVfecCHnDu+AkE63GXpFZvoaBjdm +BMJKYpSVAmWv++DapD1wkTXFfR7h1QXfZvq+Mz9z1vzwNesh6BIv0uOsaLgdAhUpnlWKFhpO +Sg10hf09oJ1YXhM5gdlcGAjZ6vdbmqB32WgLzKAO3lhips5Ro/XNQ2fF5Dkv3YicBBABAgAG +BQJW7n1QAAoJEKucIhNPrK5hxqQD/3vcld7VDAF9SpAdxtR7G7MiqF81PeEKcvbILjpXt0db +tE7S+KhrGPwK1gVdPcSEYZ4/txDpVJ5voAQZPHU3QW72nIMOifO7ujBY9O7bMVtiI5sODrJL +ViB2JJkBbq4mRdW7nqrJu0X0avas11niDA3BplOig1XLhqBNl5hNUO8OiJwEEAECAAYFAlbu +fVMACgkQzeUsQ8A9iuDCwwQAszYWZSDPLHRb1JVtsaHEx8Ds0XsurJcBaeIM/EOL91km7fzz +2F9zheiXX9Q3ydOWrGz55DDjsSR3TveRDC4ExXN66ft5L6lPMebLBXqWvIYFpOFqy1sHTIsn +mwiu4i9k2FvpWni72qXVdZV4usnAxrrq6SRcpVBMZOTfIEM1CvWInAQQAQIABgUCVu59VgAK +CRCmgoNBVFXDLWIWA/97flhEbHtDvXnmA9a6vqAg0XcufUtNS1BjJYOajOwhI62HLwvszNg0 +hBCZEx1w6PcXnuW8gE1/3/iw5d4U65nJ89bKDoRZeOfkk7GMzF6uWgt81XeuSwXEqAD77XFg +mdsVAPCkcYGk3+S3wQ8aIof7P2phERKVcfuvH8nACTD3i4icBBABAgAGBQJW7n1ZAAoJEN4P +zG4KrWjF7EsD/3Fd1JJqkD/48KLXMBiYfnZLffM8h6BQXDHQjUYyyo1FklVDQn7TomnsR0un +nGasYmpjAq2jps8aMcQAyHESWXDzpl5FaVAtXGZYnEzlPNzcvQ04cBJzlIPOUA/eJOP405T5 +yL8WC/A7Pt2JB7unddTnynacm0FHPIzvPd90UvIRiJwEEAECAAYFAlbufVwACgkQYwZZ3HEW +LLORzQP/RhRqKn9NQMRRiTgmkvR3OGt8NiFMJ9p6PlIoRDQa8/92bJOpR2dx1Ht37m14Z5qn +qAO+2Cf5T2jemgHzuZbH4Bq5tFfsBuodrrrMfcOaOJP7RoPuGvS7ytBEge9R+cFJxNKTTUee +vfV2N2IvMaa133VBdcFpZFJi6lEaPmULaqqInAQQAQIABgUCVu59XwAKCRAYazsNMnnng4B/ +A/9SnaNwbWodgV2HYNKj+WQLn2RhRfwqY/Mp2rcVBTu8IArPIzb1Ik0//H0uqEFC3XAEB+6Y +KBgua2ZvG8F4x7jf3sjKyCsR2CMOL2O7R54nvFxv2rVmGtmeV8OA/+AlJMQ/hGJorgvbkGap +CcIJ/r6HODrgRqK/cpeN/AAk0Tuwd4icBBABAgAGBQJW7n1iAAoJEDv6PKVCN51LRrUD/3Pg +vPkxgMvUxRUQ3vNHpfCvg6u/hWKL7f3olYmScDHJY+jas0zm8OZcZEgW36avrRQ4jPu/CDup +E9oLh3eB5S9P6eh1AjvD8Iwah54lNijApw6PnItmcvg03Awa3s4Bnin6E5AAj7WzbYeZkZce +GEHy3TWbc59C82RkGx0PmUkCiJwEEAECAAYFAlbufWUACgkQUdAW1FUtq3J43wQAkren9aaK +NHPfsOjG0aMyzO/W2osc7HKM/GRm9r5rt/Z4I+RUoQSW/kx39XqEZ5dLbC/65o+M4S8xT/y5 +b9ktNeOKOxJOnnPz7XLcxJ/HwMQJD8CBRRLbn5hkqKdGCu+rocAxc4UY9aoHWE37YNSA4AZR +3/Au3pePK0R8zJE8MQKInAQQAQIABgUCVu59aAAKCRA0idC2dVg9ZLCWA/9gq6Mr6TkINYtM +/zDcYEiyn0lv7GOQLAe+sI16fU9fVWUXgH1cJbTMDkX2M5qzI21LhCumLvASOKg0rMXuAnUv +bh4Mjx6EzGgGXD66iuPIx5cUlIstTmZBefqDrrRHZMJPS8d/Q6iusQa1+/glvtRZ5hmygjrR +ca7sZvMuxtaJcYicBBABAgAGBQJW7n1rAAoJEPfrC3daV9Sc4OkEAJO4AlOkTyrVYZCAr57F +aRpjcJuvAViIQUZjwnM708eNWoHs/G9zbFrDIhxdaqL+g6stTmJtt9408xbA0Y/ad7thiFU1 +QwyUzrt71zeAyv8Xg4XiyM9tR6f4cP1nKx1kcXoVwbXuotL0oUeap/gtAtlsBfwTjW05z4rV +Ga3WY7D5iJwEEAECAAYFAlbufW4ACgkQlJTkFecfwuUNBQP8CcYHPahwxXWwCVfielHLeKj0 +BTvqlSg82ym7x8WajTl0YNQ2+73q7STme6IO6xqpZH4niCtc2RQt4fFs4707ODye0DTw/czg +c0EMSgUAZC9Ljra2FD6Jq8hs4sqM9rJtyetQTuh2dk342BcS6HIxq1j2xmAl4YIPoH0vl6Ks +JS6InAQQAQIABgUCVu59cQAKCRBuyWeBNZ5e7zDsA/wOp4ivxDMSUUp+sR1VksYRAlekKrWg +p02MDgWq6ZzN4SAO9w8VJM65edjGV0SERaofrj8MLWB8ZNP9NvjEGscI0hTONySQjXFOUtvx +uC0mniQDWfpJVjUTSKeJMpvGqGzGc8Qb00g+JVeDEUIeNLii0CBSOokYoA5gpsNXr1pddYic +BBABAgAGBQJW7n10AAoJEBMSbNr+1n1eM4AD+wYcROEU7ea5/fOtg7Ihfo9CW1BKtadS1zZm +hHkXTbUd9vzaMRBNtuLRRFntv718a0xtObNS0G4dxoxKJv0JvKL3TZJjgY09rZtQEexD3JPJ +AHN0S8xsKZJcyqSiG15ZqJp3L2iBYS2dyhcF1qtQ8wL26gmHEMoiLKFbdGNPMHPEiJwEEAEC +AAYFAlbufXcACgkQEqchJybMqeJfpgP/ddr2t3U0FzONeVJWCxnGFmM1E6E29tP8NLYTHWyT +fHeWXfcPJWLg2Dkn6n4r5l8CcbxQWwxzCwR6A8FDZJ0vGjg7j1UNAL5leSWDYpndJyLLuecH +MFEK20xGSGLYHuuCfyc296SIux8MziRJEDdZD10GzAUgkfPp9BbqfjX0gx+InAQQAQIABgUC +Vu59ewAKCRDqMgSHo4JNs8aVA/9Rdu11L2au6y8CFGEIIVmwL6rT/LU9PRjVJPv/Foey1o4J +LoWOAyvsalUFiIIqYy+dRFgsySADp9AEh8Co3yoloXs6MspNexP6StfDSiK8/ceKN0qeriAl +kAOjcYVMWeBXm7XS+pTns/IIHvddTjr8FkS0YY4/jLyhZ1r91+kR+IicBBABAgAGBQJW7n1+ +AAoJELhP+eh0HGTeXasEAI9j7kLSHgOFo8DfIxZ1c7uQt0Y7d6rRo/t/NpDfdqGrf/gzc4RX +MF95c+m2xiMTxaQrseutEz2pVKs7WhdoJNKFeKHQX1OAcSi7RP/kkWg+3KygSQERDaG+5TH+ +AjeMmK1MklcspevLW70It0LgbU3LpF6M7o1utEX7djWDLjHniJwEEAECAAYFAlbufYEACgkQ +S/kPUbPUvwYxbQP/X6sdKZtfOaNhjkE+R5hYsOmhjQdKncxu9QCZnLVqrywq7mQ4IGuWTgY3 +R4fL7ABuwi4p/zLj/UQWpgPinzlxycr7IiNwZ+LnVb0U3tdhibJTjyJk5mnafuj9C8OIwfEC +p3CXFJDUtje1OhwkJFow9wbEbP4SRRD/2yvZh44mCP+InAQQAQIABgUCVu59hAAKCRA1Y0Cf +MAeFhY8ABACH3IeRKQJIaa4+R6jkYM1S5cVmlghOyJGlk0EKWnlS4uyt13dt1owao6ScCtaB +fuCeGXvng1Zd3XZb8cod5z6EuYCHM3b+n66is4g3dJxphBuBxqrJ5YTSGoZXZcng0ThoKrEJ +j/Bbfy2o5YCKlEf7WUQIgMaXUFIYjX/42HWNM4icBBABAgAGBQJW7n2HAAoJEDvl2frEQJTk +79YD/A4WfOk1CJpfMU9FJ/Iirxn4eaVJcXVQ2O8Do8DDfD0gwhtN0Ikutr5ZuBTRGqkw7xur +0CnaOKJly04Ut+JobyZ3tGVyTLJ8Tld5Fy4QcsSFtjWGBMQX8iBcQsl4pSCT9EnaMDjnaz0m +YwkdjeVDTLMsts+XHpxj/FjUqAXW9zEpiJwEEAECAAYFAlbufYoACgkQoWFRbo2OedIUCQQA +qvTs2l5pLZy1mvBrC45UFEiBuflQlvltjoeJBvtQOEaNmyrwme1bXAffLBKGZUjPYCIAWHyr +0ISDt7Cdo2zBkS8p4J27X+QHysNWHGXgvZ42NZObRJ9W229H5zdvl4rY+z8SDXRaiKxHgMdU +KnYr0W7OByVOcK5jgdYPO9OB1c2InAQQAQIABgUCVu59jQAKCRA3+YNuaqTe2m0NA/0Ri7sz +imWT5RFw9PjQKqcDTg67F98XBc1mLTIURftxR+Q1jsCdbc9eiBqq6wQK/6lCkK5d46rx74RM +vaeNj/rS4p8aqT97mRHGCo/BLxTWOh9RWqPEXzUC1NtzhHzE98QRTFpdZrMaicPqzvyeCDZX +QIMWEFR2Brz1wbdiSBti1IicBBABAgAGBQJW7n2QAAoJEHHcXzMqFlbLrv8D/iP61yC7EjPY +XG2y8ZsRRHh2naAdZWtq9iIs1zG8gOiG7FqVfABNX0m6GdLARXKe4t4qCovr2DZ0BVHw4D7A +Pm/Vc35uFyXKepny0xdUpwJXuy72Ye0zioanlhUQd0+8owVl1Ipw7u2SDqwstfTBXE3f9wuw +8dAZJ9L9hbN9PtPFiJwEEAECAAYFAlbufZMACgkQCryDSqJAKD/aUgQAt+qK6bZFEc40jEsV +zKbaZLEpIpMwdKdxUMwz0ze9kQrDl+HhRUKWUaVuYZwGgxju2K6pkxYBoHZ1UtqNFzDlU2um +Dly2dLA7eZxC++tT4C81a6zlQVH9822RkO1/Msc8/hUpbsa6CAXRpnMxR2wQx08QEay20tiJ +gbfL2CxF9BaInAQQAQIABgUCVu59lgAKCRBnA8JXuOV/5yMXBACc7UeLhoIIaHvcVDvIu082 +zKgeYXEinUoJpXT2Qx/zeVn4u11IOLnxG+EvUifYk8TC4pmKFHvNXtcBIUoATKL2xj1RyJRY ++15xiJ1hBWWchGQtaCNqXViuLvw+Asnt6lmIbfCRhWkRe8SOoY1WfpJUrVhGUk94AhyNq3qd +TsSOZoicBBABAgAGBQJW7n2ZAAoJED4QaICjdH0exFYEAK9rYnPn4vmI2u4UPIvVe7iVS8kC +6PBWmT2pkGHz1dG7h/TFxIBlmyYddEdIEyldQJAoVDNrzj6xSi3Y73gX5eldsxQdqJAxdvbV +1T9BjsV3LnkCX/90iauChxnm5pDHvkosUEh0O4FlAXeMGtwHgyZrwH1IJm2h85ol9UF8VduG +iJwEEAECAAYFAlbufZwACgkQdIfabscAL5qA9AP9F1AJ8Do8nNokLkq5RjSjljSWUF9+k/6k ++5GmJqrXqhho3pn4+u2rWIVvzp0IsUx1YftMMz/biCV+E2A9SCjJN1k+FvSv3qEajAjX16Ts +2tqstjzMb7ZWyRQ1zrkO1JXz4s1jMHlGPIX8kub11YbEJ4wATYIIzE8/e7vJQ99eXYGInAQQ +AQIABgUCVu59oAAKCRCYmT2+NTY+9GrOA/9ng49PGgZvDuAxF/oNvEnbN98teSpzVy5gKtnh +WiVZ/4Kjx66I8rjBiXOcJ04EwiBvo0i1Ies5Uj+W/1UImZC9l7wjuJVlsPPRosUa/MdH8BWM +rz14hdbu95RNjC8hzYpDJXHpH7PF7SbX5vTs8/puy0VOlvZvlLmeZNI/pZf06oicBBABAgAG +BQJW7n2jAAoJEEtMDfPdscb/Gn4D/2+S35VBOU0w5VLu5OMYRHI+IIfe0HxmD/x7Ql9Luiiv +aRe/vYlKt6FNha4dOMqvyZarC3z8hNDu2jLZABvIV34g9Sbq1Nnasf51WA/26ZC6ib4Hl0Ui +w/PoVYdIxP9/jh6QIK5TNHGmNmKdFYfJ/mnZG02ay4H+MiMrSlhW1UQaiJwEEAECAAYFAlbu +faYACgkQgivHGd7a59c01wP9ENbDLVhd52LcecmYqHryTKbb2MWey6LmFXQEOMuf9PD5fvJb +3gEM/JJDTrfBAdxFO4u/o0izjDYVynLV8q8VTXnAZto3hOfk8RZucgRJB42Xcz2/QWlHvysn +6E+m47+gS+/pTHZhgLHvCsvKrcNaHU7F+9vuJXFB3CjA9d6Ltk+InAQQAQIABgUCVu59qQAK +CRD6w4f86WOC2LetBACpyOJ4W0pqHK8KgVziduWdcYo9ucqo7XnulUBIoAx0hyKztEPIBFmS +VRfSVoGagqWn9RwXEQdNEEDBHmqURttitH8jPMO//Ikj/Y0zmxk+u9yx6HRRSkQed9KJOT+l +mhIkZtUvPW2uOdbUGmO+6QsDWrtF9+0q1iQHes1bXv8CKYicBBABAgAGBQJW7n2sAAoJEKpN +cWXhyLtUgT4D/0dlMszoO9kN3pktdeonRE6BXUMcBKpInMlFrcugJW8VELHiXsANqjS2zFQu +/4Kr5YZvoIkJHbunMaeKJfGI6pdMUK6DsSAMu8quFnEq8jYcSof+QGay7yp50bZFXqXwWi2B +Ts/JjOvU21Nnaleg3EdPSScrB9QmOjsW61gFopcViJwEEAECAAYFAlbufa8ACgkQA00u0bew +jT2VOAQAsPTylH88sPG8HNDCQ+6Vted5T33bwE9SRSZF3wEwX4ycZP+gVFzEH0NSRlXjIj34 +rmC241fIVstIMGhSjLv7gz/Wsc0FI90AX4hutQjhUfeQ3Z6NIlwrOQS0cQVd8ugusYMkM61s +WJIT5U2kXkjPK/eq6wtoyca0Bg5p74lQ8suInAQQAQIABgUCVu59sgAKCRCrvB6q/XTz4h+H +BACm+U7BHsJ8vkR3kSRfZMT8+cyKEBgSTKJZLZNAq/GWJg7lRcnpJeqzu7H8A0YleK+i2AzQ +Hjf8DnY7kr4YbagtwZRMj6WxF/G+9Ub0rq6QEhDrfKGa7v+PQROGVU0uYkXiX8gx8WOXEGjS +UcqWS+idvVcLFSmzKS0pBNhCiqeOrIicBBABAgAGBQJW7n21AAoJEDPZqGdlDvXGSloD/1nj +FJUysYKqDGLkg/TatCIM4qmTEVkN9hEff5B9QOjwvJwWm8EsCnXIbpH/Gk6uDEdpITc7BGOu +xfAB7SVyg4Izdn7njQBK2GB3lx6h9Wn2jaFineOE+vEhwVEhLWxiNClF6oJI5WWzz9cpa9jj +JoNl42fmkJteEswODWoM4y5hiJwEEAECAAYFAlbufbgACgkQqBOsnktvViMTVgP6AvgMyNn0 +ASHkn8ubqMLYzarpgjsFhpjD8r7ghJre9D1hZPIJY+iDY5VhOGT9vdEVgvY51MPgDMRcB3Qe +l+bNGGQBzSF7wSaaDuNYuO2VHaj8BhfTNLpVb/+XZs7CWXL2QKtHEMpXVmE6153kq35athJL +BlL5J7ulUKMAeG94j0OInAQQAQIABgUCVu59vAAKCRC3ZmepdGMyU3RhBAC4/RFklimSizGG +0PEjwi7TvmRhC3UUpyS9ruCoxrAwJIK7cGGJfp6ItLY/A/nUHo17xdnhKsTR20MVs8GidzC0 +ifwiMLqe6PmyfIyxDSiIfyIWnrIknT5Aj8pWTv6pVFhQ+cMkeLm8PI8smioT54crgpFbbe8n +EzkNqfAF6aYWDYicBBABAgAGBQJW7n2/AAoJEHmY0UR6kSEGl+4D/jOkQMss/fua3YWOl67D +yufO33vq2RtWz82eNWN0Vsh7ItXa1CQ7Q3g3MEAbtrpCNdCkClYuncU4/qHAJgHR0ZQdyhOn +rQJnGZkJ1DX+TZQQIxhCidFb4jiP1gMM+P57Pq/vWUjTy6DB752GqKz60OT5cXf5p0J8sJ/A +7aH9UnOCiJwEEAECAAYFAlbufcMACgkQ5pVdV4VeqP7hGQP/SZmSvnO306HKAhkPOemH72rJ +0TsA5etzz8rJ4nLfWfEE3o9qh3Zm/Z5KcdshdQh0jZrelBntnAvGgY9wbbAx4rol0JrbH8OR +vXeULr0ygfVKek7riVdm95YUMfb+6RpXHwC02uixTboT211Ag7xqYDJW1Bz9iauUACA25VqU +EoKInAQQAQIABgUCVu59xgAKCRBgfhp1AsUGdae/A/93gpxrpg5sGQivZtqrR0zur3qWzgUP +ywAowlQ+NiWMN6N2Ty1BWGkwSclK3RR028tHafvciFa57KAj9dG39znMAZXi4PFD6CKjuImi +uMQ1ynBWK8lLCs+Xj3JiMPGvn59jUKj9TrVUuAN/JKHY8lf+ZWd3vPSNmK4axCu7/jY0S4ic +BBABAgAGBQJW7n3JAAoJEFwAphP/NePR4RcEANPe+hujjFJlUMvIhV3yS+NJznqHi8njWlOi +6h4C0g0lN6HqnNeBI77iepdlzE/UeZwld+kiilEzTDH6Pe6OpIpGdpwLbyiMpq0kKYqAzozo +3YTLyIgcdmITGayGjMECLL2fUjcQfdcz5IRB2QivUpbt2ZM5jJ1tgi5CDsFKnn7FiJwEEAEC +AAYFAlbufc0ACgkQxfZaHoJPeJM3egP/YjW54uUAMKQXHbkYeJTgyli618rGW6ena7msnoCT +MrJwi4qrAQotky1vcUQL6yKvb64oFqgHZ6iNsd4fSql1e+YBLU607TtlUuclZMOt1kNiKHUK +NSX5ku02znW9s/h209lPwqv4I8ldWxub+1yoWjgxL5KWTklYigyNBH1mwTOInAQQAQIABgUC +Vu590AAKCRBOnBCtJhp6VGlpBACeY2vcKvhFFqlBJzK3Tju0FNkPpvZJPJKoDANMpPckP+8Y +SW5i6/+btm1XZLXYSU/rQKoEMthy9UGRKP2JQBoKFL8ktR4eSzKuwbGMYBx+3B3R5iu/0rrM +Sx8smz2aZetwQks6xiY9Tnlc540RVcrtAuwqn+i3lbnNw1+Jd8EQX4icBBABAgAGBQJW7n3T +AAoJEP4S3lzOIGu9u4kD/jQ1/846ys6v1h84wd5IHC6anAvdkPHUETjkwOHRQ17uK1+W84t/ +ewOnDrJPrszN3vYry3NTFcp6d44XhPTVmmX+2rYVF16fK9W6aPFpynRjcY0J+YzN+1IlxXLR +5TCBfqKnGXx3oFBNT/QhLQhu28bfq/pW0X5k2s4dWkVWjpSXiJwEEAECAAYFAlbufdYACgkQ +E3vrg55aQff4dwQAlbzPEs11ZzcvhQItOnkLzdOYOd0KzbhmUQA0/G5muWVepoZj37k2FK/5 +fw/5dOMl3vb5afIFWhTJkNbc1qLf6qw0j8d+MXe00H9uP54Ucw49ZrKA6oDs5t6jlQJGJ2x1 +RczaqOswWgjRtUS5/LDrVJp+ODHNk/iDLRphF6NIlOaInAQQAQIABgUCVu592QAKCRASzArs +q+3h0FKsA/9IWGDxRzUM/tPeLpRGqBv9pNc1JI9GBp47V56U42LSkrZLs+BJ2COu0EJY6CFW +6cWN3qrieeaV2+XC7u6PZ/OigWRswFTUqrzO/berQpoPGP9yPpmsD9R1uxNeTpiKI4keaR/D +wQ16MnzOz+jhr9kIYZM01yOlRX5aMzAKVYcadIicBBABAgAGBQJW7n3cAAoJEPlnUQOCHJMM +xLsD/RkkUyPbk5qc+57BV4PVYwLu/3nyIHi7vFI6leLJBFNiHZhQmbJ8ep2JvpL89BySotu7 +gVHEHep4X5HI0A93RptuidzaLT3EaeM7kl5DvZhwu6nZH6PXO7C/Oj5nbSdINZIN0NBm7SUX +SCJGOlUXH+pN2xHtn3FxPv0nx9nHWHO6iJwEEAECAAYFAlbufd8ACgkQgNxYMAu86jwhjQP/ +QFJQE47o4+chlP9EuO1ySTwMGGI7p0bb9xvGgZ/FGkcHF9BzZOsfkLFykwVMno1joIzyo/Un +pqTajPud9tMozGElqaPHGaoG67BhoNJ8ErGANNmMbOUJUoEzWsczbEA/xVq5tRyTSono8M9N +W8gomvigfu4mmN0j6rIc4zHYKXiInAQQAQIABgUCVu594gAKCRD/DQaG9/IbKaFhA/90yjLl +qVYMUEFVOo0SRdyotfgOMckMppTsKmkiiOrImSTN7vUXVWxOjMfEfGKmP6kQqrHJuC6cxVjJ +jtFS9Vw0X62YBhGjOW3JzLqtxAJs1DPOh9/dDxhKzTYrwWnDPoxF9ITXgJEMH50V09z4S2TW +tYoKYx+mSTyF+yMlH8S7wYicBBABAgAGBQJW7n3lAAoJEHhJRg6fcbYCLwsD/2PLB1TKP9nG +fmeKC/xf0KqQy7TafHSnjI8nV7+udjzJ6uvntSlSkgMjAuDMqcNspzCHNq9pITiAy0gAJhU/ +L/qbSmd2ak0B7CX+MKQiJljUY+7UX7YXJCda7Ppx94S6TqYD8q2feX4AaqeuKzvSALeGUOhs +yrFRt3X82PT+DjbliJwEEAECAAYFAlbufekACgkQbk0uOhMXtiUNLAQAlD8Yycojv5yUgzXh +TEeGQguZMZPTNikhxL34FxWd0efjwFVp78XXognYMpZYyfAA2rV4n7/3I1sNiUExsne2hFEA +kwJ0D+tZ77Pbzoue5INia4Hr1Jcz0z4KVYpcbt8l7PTbwrCBHRu9R/X99LCm2PCPJRQverbA +mdTTJFYXOvuInAQQAQIABgUCVu597AAKCRDIt5C44cbkXLDOA/9gpZk3hMxj7BTz9TMwliyp +dsXKZUw83VM8l1ASSuO8Ygn7yGReABoCJBaoT8RQD9iE/uLKskzs4GqD8JgjiRie8+zD3Lw/ +HjniJdTi4DGS9mjBvgnEXQ4mqJGhOVpLipVykMjGfBkNt1BlvIVAsXrLKr1ESkkhbpl1Csqt +/eU6roicBBABAgAGBQJW7n3vAAoJEBLsG396Ue0CJJgD/RH5tx147dPkfu2PbWpKQUwP4Xqy +QoxelWgacx06dtRZaURnMd8gE5SB2zjusqX+GNsZ3Yk1m+DkLkP9z0lS35dqgGac/N2RMIM0 +l6LRNsQ4lT93LGIHH3Qxi3mNJcu0Ny8H2zxG5IrpyeP18XhbG7huIC3MyVnk4rYLZz2KoXzn +iJwEEAECAAYFAlbuffIACgkQHrQLU9wT5RrMxQP/cnSA9mslvMa5SGW0tI7jWOBNaELCc+5q +GD9rPta0VfXExBFw9HaVjHn6KU3KGHS9J+ou8J6kr/ySjg4LQYWt9Wm9jGav7ByS7IlDGTJP +LCEoT9qVk7zEAKBbFOs+lsqdP9TaB/iMrSVsnW8hAzZtFtKMVZ26PHGS/49jPUucnVSInAQQ +AQIABgUCVu599QAKCRBX585y4GrV//kqA/9jTSWrhZJntgFleMwLPSZMmVcuZ//QoW6M5ATU +1d1P/9A4g09RRVjLj7tWJ1AupQgz3iu9+DdzGsm/tODDDeif/NDp3MrEFYcOb9XqbJY4V1w7 +AXUXY8Cum9bD7J2Mh4QumCc84g2KD/GwMf7SMW99Dq7VPE431YtdxzfpisK8i4icBBABAgAG +BQJW7n34AAoJEBKsALu/Uk48AGMD/3a8h9IdmUy059bLCS7jAe9AI6+Q95lxblrF+GyR0qYE +d6FRI0+/vZzfZF0TSNXqY8YNA3ncHBSyqVREhIgYMbXM7amnJNKrwyN02cVT1QxSFXyIlLIC +jvFaKrPo1TI8XCdkSlUPUuNI05suW74e+K0kW3PUk/d5qnFVrM7ps9SBiJwEEAECAAYFAlbu +ffsACgkQczF0H4I1XAatIwQAjQObbIB36rqaQJnq2+KZwNjI3Wnhk4QicKEJe+mjAK4yK6nZ +mUM+FtlgFo7WFVmHMeR3RSP6+s5IAOSEus4iZ5E2n83dFFqvabA5bT+eFNNkhcaILWaJUG4f +OWoOupNnumjTdUMzYyfiADQUwqWhrN88DPY20OZpGvqr4RNUXVWInAQQAQIABgUCVu59/gAK +CRBBIvUX4i2DdO49A/9SGcd71lrVQbQbV8AHL2a8bpbImhWF0ZDz7AY9tK/zimC0RgdxO+uD +m/0PFmL/8zghO38Z1GIzyR8L9hQ140E2aCpYZ3VgJ9SoQ8p+5roBnVIt7h3AQM0OsfFt2Vvl +i0n/WLV1IqJEYQhb5Q7w349qlZirshNhd1cAdQWborbT64icBBABAgAGBQJW7n4CAAoJEG4J +08NnQPAxGrwD/1nt/bq6hXPqXO1L39IkG2ysQXbCwS+9r7DhEHiore9lqzpeB+q4cKxXKcwM +H2088Rhxr7kZSlYHYD1LSD5oF9SwlS3hAsjx8KiAVW0IeK5NqcNtHjLKmcaaC4+Harx4M3xK +gOTmV7XfvwHz7TA+8W+KN6mIYb1/Cqiba1iUAwS2iJwEEAECAAYFAlbufgUACgkQSfn+Y7sI ++vwZtAQAiX8/oms34AazU5WKNLOBFG5dT1s8bR/aXlVZ+39AyD4v/wFZ/QADVzkbCoyoRHCV +K/2fITf63l4ecko3KzT0ANMgf2YcExERpTMXnrLuq9mhHrKNRSVz8egL6kvPurfYLPMUzIc4 +P44zrVgZChxpruF35lx6lDsS0AogdqUvbMyInAQQAQIABgUCVu5+CAAKCRAIK5vDaKzGqj9s +A/92k22j5ICjoLUBdmxmeC03Hes6bhcVprmbXzvzn7ghQcg1JY9ZSpy1zDR+GWkeSHpMuV+S +Y/QnLQr+zIpqqg2OFaI0NJOivYTsB75dutDhHDWVS+uPkLOl9RR/fajmz4N5hc2obj4uPrWo +suxyrM+hoa5abCU1+AgFjSTESKS/loicBBABAgAGBQJW7n4LAAoJECcTJSEYGS2SRw8D/2WF +Qz9+FoBmaAv23X7eM7qLPCXhxISoNF8MOn3Y6+PYHD7LtJAPQBav8qC+1vRplvX5DhkvPbta +Ypax17odELYSZtrKXIs8fa/r56GJISqTAxetcU379hBFR2z3rWVmvw0n7uCaYWgsSx46de9h +IE+8S1jV6VJYohqAp0ivnn1qiJwEEAECAAYFAlbufg4ACgkQ2RRDG8Ws+ngJYAP+KVAsYJ1u +OiD4Hg/CLXrAboEDYZpUhciBW+AS6TzoIFYdjyHL6uD0U6f3ZaqGo8ytWsGTBYbPKOBtBfr2 +j5YYRZbKJakysMpc3DXxvOFuDI97uoRCjqBJuXMFac9ivsXvqPN2KVfKZ8EUiLZKnIUXGrRH +qqTMSp9g9RCC+cTkjmmInAQQAQIABgUCVu5+EQAKCRDcrSCpvNDQ2GydA/99jTkg6EHWX8vW +oxuKYk9JPM+7YLGfFCpLF/2k74mLHnckdGth1GpCxGrk4fj0gYIrRnuPnpmffEDLU+HKeVIZ +HYvjvVMFLO2Dq0+ARubjtQTZx07BNd8w5hQKzhpiNo5qns2UFqSI2dxnJMPhwKc+bQ0Mb1iI +fXrM0VbGRSg04YicBBABAgAGBQJW7n4UAAoJEJ3iMJHqBFAZ+o0EALgipEBnghEkWUyOsNsp +ZBOqAtymjq726X9HT7fRWjyvaOiajMVa91nXfhYrADbQAFoQCvxwa0bbTmuiVY/Eibk3Xzvw +iQbDgUYJQr6PGtarBSauZWEkS6c7+1mcpGcpWaxz3kB2/ab+Uh2QIhDT/IJp25RKVWX1oVZL +BzFPU37wiJwEEAECAAYFAlbufhgACgkQi+Vxxo3KOj2RmAP9Hp4l2w9v3BOxW6+Apa/61H5D +wr/MKhNFhJVxkUh7ESvVKeKScHGJ0HL9U4M3CHdftrcBqDzAQTlhi4LmN33itGUwG7xafYba +tZKflBnrtT4JyhHlOokz4h9/6dWmUcy/VqNB2subsWd/Up0s4EYWWtqtKeTdRJzQ+CjceQ8K +YniInAQQAQIABgUCVu5+GwAKCRB+vCrm+VsZNIIUBACWz7OFiJ2uh4zGv3fo431r/MHjZSIw +3UC3a/ixskEIVNPKrdV6wCfOlwC8pKN7usemk4CBspFnx5DdBATqjIIGwf4KEJrO8RszoepD +748QkqCx3nluS7keomR9smsfv3LgSea7M9hBYVU8mBM78pKOp7qi830RmILEN2zezU2raIic +BBABAgAGBQJW7n4eAAoJEMPqqFHwFlw2qbAD/RsQapVD9yoowJZgLJBSYhAv6k6aHLPTBx2U +hLVXsKhQ200SNTS9jb58lay5eXah4ky423XtlDu502gBk+RPaRPeFWfwsA8A74o9MFiqEICK +iu96p+B3HOR/PGuRztoJiH7pv9JEIpejAE1xBqdyklJY+GKp1RDB62zMw0BcUauBiJwEEAEC +AAYFAlbufiEACgkQIFxHUmdA9XQjhQQAh2kLgdX0Q3hMGoJjzWMeRouzsnW6oxKRxa3pWUAJ +7MoVqFHElahsbw32tOI8it/TU2LGt6IuEiavxb9qcw/5PmGt93/MoX8TMG9Ps8o8Qqeu6+3R +JLzT1KRD2JJPivSpKN7kCpXWDEFLO4rDLCjzxyc89qIskjLJliDzKMphgEqInAQQAQIABgUC +Vu5+JAAKCRAttd7zPE4PetLKA/93B2QVxslULiBSmXz/CnCUF96myudG3GZO5XlZJkAoUt0d +W7/y9tH5A+wSLY+Gx3Tb04JZEYkIAX3d6qhGfzWIK39Ihmrr35e+GywUstcbnrQXVDRd+Ttg +B15XxPgNYnSGw8xciY44Ew4SyJiK0ixveTVh323govQf3ImGN9qBDIicBBABAgAGBQJW7n4n +AAoJEJScolpHoMIrMEYEALaCQ46myIhmrFsfwKJxT3HOsl38p2Qn128AWPAEdbQ2shn53lqa +kMCKMBJXjo92aUOgNMR84Zx6OS20/nAjY2U+8w5heQKfbJPT1QDap6QxYaYKstrSuBsXEpzA +UPCoWU1QCyTq6A4gGJOtY3C1JEbY+hkgU9DP1CfzGBapYAQdiJwEEAECAAYFAlbufioACgkQ ++2hq63rN2KXK/gQAkJfDFbmaxT+yO6Ksa3aUM43R/onbF6xyEfLrzaSZ883Sjn3TKLEdRr0h +JkANJQ0iw31I3dOpkrDFjh4rUgRzvo1j7f4/IfnDDsmRiFIepz8HoLMILaVdASKwCMMj4hif +5+J25g05qjYUmL5qbkNAm0JK7pI43mGeaCnL8XUpBXOInAQQAQIABgUCVu5+LQAKCRBz3guv +2yljjOXOA/4/WQe6HEfgUlpZzpyHrpFko7tFLicGAmDAb4E6uI78cQW0+acv9hIsXcZCe84P +xDB3i4sqsRhqcWJ6/UThlQha+jgiqq0XiE31G2A2vD8L6wkjPhFTYG91wauNcWCS5bfq11cp +gfK9GJFd///sjXQUpJWZjYrD7OZB8M7ZNUx4K4icBBABAgAGBQJW7n4wAAoJEICIjOEPVEh9 +E2EEAJbSYGvWwatXDPW2Fi2A0JJCCewYFuMIUEXfVk45R5aUNXRRLQjG9k7Sobz9tj7CiEAt +Of1ru3e4pRrgm/O8BQ6g9WhjBAwqXN66frF+XD3sn9vzpTzHH46YI9umSYwp6NNXXL0B0SjK +j7SzzD1MdWivnsZIUaR7bwAAxyCotLGniJwEEAECAAYFAlbufjQACgkQrHF1GdN9mZbO1AQA +r6+/k2ry+PLO7VxzTsNofJ5GN1tWmx/XVMa6H0MbbcJCUkwztd11OcY6KZeI3gbn0Md9ssv9 +5Kx/J3hIHo5R98LTnB871Wx98YRpE12yWHjxwhIHDPj4tTGq0NU4h0qdstogVAL/KKId2VpJ +x19i3x2ynP2fU+VCcjDtr39yhGuInAQQAQIABgUCVu5+NwAKCRDS97N7HgzuUDqCBACp8Msu +0yW2jF42tsIb837QrldcnkHpvaOrirI+dEttHixqlyV9ezZkXl5UqkKrQUFK/5crAti4spUH +836IohsOSsdSE4oGjlvQz5WvwP+6Dl4kOE1xNjcHo5ahgdywxLX5kB9P6AirhBTJEYyVtCQF +ZvDnFIHMPOg1q/IWZ+g5zoicBBABAgAGBQJW7n46AAoJEDuytchrfZaPJLUD/2cRIKJYb7l1 +JhcwoLIrvyO7K4SZMrXV6mLj1adkeGRXwOcGa7ZkL+51qlEffw+RZStCJLUdvzg/VrIuB3dh +vjoqRdWlz8MGA2f393KMmaqueDiuAqCLMVjMV2JJjr60xcKp5b2EGCG1ahI2JeOqcrGA+0e+ +z0SOiBtmbjfMdFTkiJwEEAECAAYFAlbufj0ACgkQk0jF+svNcabsLgQApEaKJM1iw2dHhtZE +Z0gQdcYbTbajyE28diR2SdFiqLoy808SLYCLa4euyT1ZMfTIPJSnfyYLaFr/pbsnit5OO9f4 +qnNfZQlW7d49sR06ybLa/dxbrywfq2P/1/dU/mA1UrUFbEYZcUFeVibClGxi/sFcUA1jUedi +O2R7K89Gpt6InAQQAQIABgUCVu5+QAAKCRChalNK9iPwEfG0BACUEq7VIdwJLCd1FHhr3Lkt +pXzfdORRybcThAUy5QPfpCDmv5FxnEMc4638sk0C4nmQ1QYJDMZ98AaaJr9jxREzEyL7+sjo +e4JbwSGK6wPnvDUkdwkqfGM71GjfE4MZQSJJDfXfnmMH3gcvxR+3mTsfmxM5H8VdGMFisCSp +4jLHjYicBBABAgAGBQJW7n5DAAoJECOKOK2idWaVH04D/jVtCogg/sOUR5ZmILAr69mN6Bb1 +RK/RCGGKEChnJe87vQd5OnVCP4u+/bCAGmMlD+VnnuZZhMjMRc2jxx+dApERvf7XbiAgklF3 +mK7khm7qWdYZG41T2y+dMDwQpMaFlTI+jHf6xS8OwhEIdhzQfCbwIQ+Msgyd7baYruOBf7uH +iJwEEAECAAYFAlbufkcACgkQJ9FxGgxBGs7y/QP/elkheQdaAy5Gz6tRAOpSlGl+WAfMnUQh +lu0S41CsTcta42IhUMQYNWOeaNv3g3Ai1vRQWR/dP+VsPqjOLD33kzRcZp3hhBJgmUDGUH5I +6G64PCct+1A4qaPW0+yXs8IU+hZmproAkBXYvdDrY5fiOOBQxvl82upR4xlThKmgnHiInAQQ +AQIABgUCVu5+SgAKCRBFdmChkkXaPpvBA/4sKPDyJOSXAEuEHxW6jfKM3dX3NGaGqWc+m8Lk +n8NNKRUV8w7S9J2iSf7JjRcPsK2FibDUEYd2oZ4mGzEsauPULIkAXrhfTW13/vWp932Ri2RD +hm8c2qV2MRnSMQA75q8PwjEEHQoG4NAl+ej2cVa7DI7DR5g/vrqjaDQWxHbycIicBBABAgAG +BQJW7n5NAAoJEDS38MS695Dp6uQD/igy/qCJD8B4BbzY1B8wFgGgp9HDqiTH0+ucImLJO3nm +jxxMeyr7kMDYVwO9Lgvyvx69JCaNIwMvFd2O8VCQSpKkX7M8tjT+qRlFFcNQWfSunOdjWdg7 +GYxcKnpgeno7NjD0QHi7iIlP86iON2dMNne7MrLSeuBYkzrI/w4o9Yh9iJwEEAECAAYFAlbu +flAACgkQbianB/AhgT5MdQQApyTHSrJwg9LByaGz/rMgzX0iiB0GT4Yza+K0v6+YkkLbzTkp +I8otdeRUZyyxeCJU61lh7dLBCSWMhXuIUK3egYqSWFbacSDmcgjn4lL8YIBeYgbDjxc6CeOg +JWQWHiZmMEdZGrYvhWeSPK/TGrYunts0DgGsKiWXFcRhnVBWSpqInAQQAQIABgUCVu5+UwAK +CRC8Ai/L27U4q+7CA/9R/aI0/IYpkX4xBPYfz2RwKAqAnCekthXWDc948HRX2dVbGkOpEDlj +YOC6rZGUU2I2oRUiOTe3C28OxVTxxKDHkmFOBwE1O8ww6IouwS2DDKMVsu1dJ0p2vijNSAjS +bxbGEBe/1Jt9XWwKQO03Jy2h7Ab1DPPtM0AFK17Wu/sRi4icBBABAgAGBQJW7n5WAAoJEEHm +Ppk2SZHV2FQD/jHep+yx8l0AqaLNx5coU5W1alscAga6cQSxvTncCSgmEMA8tbgd7g/CU24K +mnVFIbaL/AIEKwqTmLrMflcwyfqj04IekYDqCz8vw19xnPSDSZy7RsdUScndnq1qgyOfT3eY +l2ZR9hboBAtJAOTtmEdHHXRhC8aAvbMIdetrFfvEiJwEEAECAAYFAlbuflkACgkQoHR67ltO +l4L2nAP9G60ZI1EiQP7whxcwvvEO44I26qeCAfX2ERs9DiUixIC3eHEqjuop8cc1v/MPHmia +kPozFJBvyNtfdqBab+TM/iT9Jl99H7+e1lln5V6Yz2xWC+58WsolADQHXWBSLtdC0DKyH0An +eCV9XPr0cPqYLZdKJYfwE2Ts2ZhpmatFvTKInAQQAQIABgUCVu5+XQAKCRCc2XoHhf2HBgue +A/0aGw9Yy6H0QSLOO39UcVjXib/bOKDXK2U2vrBFKAzA05kyVTu84/uTybz/XvshyP0TF9tJ +PMrD5IcizyfQ4wbFirsTBZSJVPJI473FRiUO/WoI/JCGOqTmRT/5QyUanFQzBZwCyBENDYX+ +oLhA34EmCNmSPqVMFKWW1jDncQ94N4icBBABAgAGBQJW7n5gAAoJEGdpzGx3pTu3wBwEAIg4 +6jvnrliCBc+ySdUf0o3cXD2yK/6z4bDLxGdtnijhbiWLgoZ3k4HHBn5gtnO6GhHGTZiWsVgH +Qof5yTwMdo56M6pnX9/g+gxrzkL1pt0SyqvV6/UwleJlpigBKSNcKAP3FcF+GhKYCwHq5ply +COe1d36tKEHp/h5sa8GYnz/eiJwEEAECAAYFAlbufmQACgkQyY4kE6VrbzZSxwP/bg3aHqTW +doo3gsaJSbfSURpCnokjFtT3fpydmSNvUvTWkRFkYF7jpHMt/7IFGbI01dwvkNmS8v7pIkx6 +Jz+VYIjhjW19Q0CSkaeP0jpn1dt72eNhlptCD7wbq9/tNtBfel9ziN2NFipR7ixnhjFzwuEa +SbropVj/+b10CX1JDfGInAQQAQIABgUCVu5+ZwAKCRDDbjObEQ4WjMmBBACjNmLoFDH3bXBp +TMcsQxkIAHdlmFZHcAIIYRa/CA+HIJVQgbq5ZWmrxdvdKzTVTN0ObyXEz21us4bzRBb3B1rm +I/atZ2DpAF6Hcn9loIUixwJtCFsD+OEQCYrJE7tux+XDFy/dGbSNGzvbm/fgr8uYkT2kTcvf +vPZvGhXq+9TwkoicBBABAgAGBQJW7n5qAAoJEFNNjjzZ8WoQPBwD/RjcS3Cx9o3VkX/TaTnO +0V9KughAMocr73yv6QwgNVigaPBOMHBk4XyaQEPtLAdFtrZusPnYntBzu+x4TZJMGRRlkdZt +F2ph0N5jftCfLwCU9D3d8P2B2sKSJH5OIxAqcd0TDNpmejcmnq6mmGrWiFg2zv9qpjPq0hWY +5RA89ZHkiJwEEAECAAYFAlbufm4ACgkQLi5jqK9ndSRhEQP/dn8qCLayEcHM2Z7GJ7Fdwa8O +OX2iC2Ec2JeNe1DhP+6sqiHV2GpLM0ntUI07sNMEzv11jsqjTO+PPbrMLjTm0xSyk1K6YesL +V7+tbEmFsn4AhUpmKa3kA8xRrAnDKsDIo5PKprnylG+fndj/2eEzYakXRklUFqZZIJpzIxDp +CoSInAQQAQIABgUCVu5+cgAKCRAWTNEmqoYqYbGBBACSQrN0xGVMlDCvJI42P4N/AjBH6VGm +x0LlVf+2/haEJ5L8or/oE1mMTMlZCM3WtWu0DLSVnIYhi04m6lWlzALWrRQXGdSEqHPGdJxY +NETaWZUEsnnIrnIpG311UwH7EdI+/Ib30xH4VNBqI9FJ0T/au/LKq8drUaaN1zO3GguO6oic +BBABAgAGBQJW7n51AAoJELG5SAT1Y+BdTbkD/R20pAgBcy0Wr+Xh2c33ihgkh7UC9jVk9Vf3 +stV1KgXkG81Nqht3jpoM3X64d3IBBaJG+ohHmbWWqAqivZObCk6iJgbHIWgh51tOo5bQmJKB +4z0+puHGoleIAGRcUXw9DrgOauf9AI5d4X2ZzRLmqmTGE+x9zht//UEt0i3mBI4IiJwEEAEC +AAYFAlbufngACgkQSSgtXsmDC1TiYgQAraxCqGfFop7WRCOGvwYKat9UULLhyCL+e+mWZLJF +7mXE8+WRZ+m78LTskcBDk5Z8y5l2QusVs5ZT01gwurjapV4KUbEO93VQio6awVcBLFO5hrsB +vjsSxAnS+NUNbxa/YMI0tZqu3BnSZArZU05JV+HNJ6sfDM0ynF7kaXFzTYqInAQQAQIABgUC +Vu5+fAAKCRDGEY81ntQxF9BABACb+Ik6G9+34NlWeRxjoNevQ/uXMFLQLUvxCCIM2NCVIY/s +aBrtTA2EadRj+e3n6WkV6xeSNItjJy6hKdMv6U9Ni7mrKNWU5kQoQmFOHzBoq6zXf8E20RHh +217ve8n1FkNWVhaZUSsj9ERniUzoh+jY6JalklYevgiGz34xM14pQYicBBABAgAGBQJW7n5/ +AAoJELHhKsubxNkzpugEAK9stsJMIvh6aX66H8g/PLRQuMO0K4uDWvmj/vvBRrHqTbUa6t8X +EBYxEpIOO3MknpZKbaXStm64zfFm4zYwjShXR3W5DVC+V9ChJaAmaBFb7W/tgOZ3UdBdnENh +W4ewDCZaMR584IEymdSLOVm8vsdsZmBSX/kcc6h1CRmxrWJ0iJwEEAECAAYFAlbufoMACgkQ +3XbXah7f7j0negP9G47KnXVM4LF1kb+MyVEU/he+NgCoxQV24ajbxxnXE/GA81Bayzj/8v9Z +XXW/MQe33b/H/seqrv57Q/CnxXx8zyGCIEiuiLd0i1SJgj4v6KCzhjeBrGEwi19zCYuANvbV +7YCeHENoF2pQSp2I+MTUOA0vgKwRV3loUkn5Gm2Flb+InAQQAQIABgUCVu5+hgAKCRCaWd9e +4AJYj/T9A/95HYxE0IzJW2C6setfom2Wj+lvG69mil3RxUziPyAnK8lEEK+/IwOEWRv6LY8U +NL5ic7zwND9ciqg75UIlXn05NPbKv83FlgrgmQm2TNJgQqJ9BmDOaxEMd52GcD/e24QVFKiZ +bFT59uIpXGtMQa6HpJYKzq/SudSEzgUENTxoboicBBABAgAGBQJW7n6KAAoJENyAwsElmElu +BHwEAK7o0bzixq15gCvWRmQxf99qmjEkK9IeDnJso46JMLKx7mRCudAcjs1HwNCzb+OWy9r5 +Z1QnQFgKv8UUiRWT7J3yQ5Lx3yRgNiOPPKiJneBATfuy/9blFeD511XdGvcqpTSInAK046H4 +8K/ZGeI7gOXeU0fQ4WpBYmtRiYWSv70XiJwEEAECAAYFAlbufo0ACgkQJUFWQ7ejEqgSLAQA +t4XpfscWEQe2/HDSHQVzER9Dx8D4QuckbDnGU2W/6LXFYhmxcNw2Lzuzhbd6iwrGeLKhwnVx +7WObFRMRrWCWkP1w20c7AkLKrqFdIxxWMcFBYqHE0dGyEnzWrDM6AK7svVN+/QzKT/fNd98K +Mx8q4i3/Jn2Tb0V0f/6XRZT+q3+InAQQAQIABgUCVu5+kAAKCRCLKMkNS+nnbEHuA/9dTiN5 +m/YuQElB3TTfUGcfeWF0z2f147KjZxt2IgDHP5Yl+IJPZjnHzWuWvo/cUoA8Ml87fquXVfpc +CyF+pZ4feegW9/VhzMaEGlO+zu5fpt9L1QH9b4UMak59EClVsfaNfEMqaQ3EeGLziXZjVb5u +7EdUd3JEu1S+Doa+SjIqloicBBABAgAGBQJW7n6UAAoJEFa6zOU/aq9UNLID/iS90/Sd4bNP +PybjHbN5LSeeSm6FHNjGiw6RQw3wV7cm/uvlMYT07e+bySJplqULQqfAY9od72XV2DmtuiGA +UthtXYeSld3oGN71BZySM7N6fhR5wEhrCzmWuEZjQGN2CnmiHmRm5GEi4NaGDyjj6wsMSTxt +59C947Y/d8JsOvJXiJwEEAECAAYFAlbufpcACgkQiyJ7lO2KqR5j4AQAg3kUfLQmqxPX+BC5 +MRSXZqAFS4JRskpMqJrtUpkiqgolRCh0JJxHi46i7cFjc6AJfEqH29TFx0PeXoys2fKoqROI +yuYzxs38d/Uc5PQWB10dS+FuvYRlRGc125FMHKLDYscWopEqHd4BQT8GL7jjn0oHYmNErHX2 +o8S+EOQsvpCInAQQAQIABgUCVu5+mwAKCRDnZDUa84lufdunA/9rRCrOdilwvMHxCqOU5G+4 +gC499vYVdJl4ZAxM+Y+fDRKq1q/G/9jrbNyN7LE6UqfkBDckH66H2bm0VIPh+ynKXkOO4MMt +lnyTisBGsalTgz4gppJz25OX3/YZdYAewmSVnQMeM9JTvFfGTgIlB3J7rmoQEat6uycMm7to +UEc/HYicBBABAgAGBQJW7n6eAAoJEAPJXEXUUvmqxY8D/0mWj1XHCtcshMoCtvZD84NmbaoM +Sf8iWXCumffWDYQYidETQzEEqy1pYXhtyp26w9n8mzCeUf145/LGd8f0+7OYUcQRkTLEx8iJ +7NJHHR5ya7dAXtv9YAqhxHvPMbBYB/TKPBxU2GX63dHG0YQlNBD+YbuX+exogcJVcKOOA8Jy +iJwEEAECAAYFAlbufqEACgkQJBlcyrOhI72mnQP/eU7CO6buKwxGLkuOmzUaIOPcwYqRieua +W5Cwr/cJkc8Jsr0QHcWQZrlHQNx0n+Z11k8axiRm/xr0zI4NtFN+jSr/ZKE2In5i6sNXlzBD +B0u+d2RWbVnb6N3HrDaeflP7tXTKso4q3UB6KR1mJ5puKGyxf4aR2zaBOqJQL8l/m5qInAQQ +AQIABgUCVu5+pQAKCRADjb0n3CsUfPNvA/9DVkypiDO116jTJHUe7TUTpBt/drSgOFT/FKe8 +d4Zk7TpRGRFh9IT0H5GwFkTM9vXrDtnP5cTdBANZ2wttIMI2Znmq35q+h+8XcDZQsMTWEzsA +HkLDrd3ChQPzfUvFLCWtSlkS+r/uPjH/4VCcyGDlHKBs3E6aS9y0UIxMhuL2mIicBBABAgAG +BQJW7n6oAAoJECdY+kqGl2XsrH8EAJjZf1O2GZmKtk+aHW1tUUzV1AkVRAuxCzMOjJw2w0Yn +Li0axpObJEU47MimyeWRls94MLfV9ghJkcvP2RD8wPjCDUw9E7YzZcOvW4T5Hi39JVIIZbm/ +38ZTYPUdXi7ecG0Mhyl/fy+oZE+tpLXBdIRQlD1q3HNxJhw764q71nEViJwEEAECAAYFAlbu +fqsACgkQA68KdVVNfr84iwQAr3/O8od8zmTXTo/g1rAwVmFoeUppLI67t7FXZOn9DP9W+ysQ +eg+x+BaeXBrNZGrnC9ClUrM9eNzhPKYwphMGq9Y83nee1XWN7xvv+OkbvgjHQ1xzHo/YBXpe +ErWxrR08MtwjNj+PMQ3MCJQYhCEESMFDWYcCZsaxTaoynQxKhVKInAQQAQIABgUCVu5+rwAK +CRBL8p9EYTWf6IT4A/9M3lDnphEsxF9ZNdXvtJVpnYw+sFDmdBcJIPYU/IkiogUxotsh/Bla +5yYy6p1rlA8ovgxb/8foiih1DA31Xpf/v8llY/b1sdFYUGWkUAu/QAAHN2un8WN6IZbkxu5X +JXqFUnAEItMT4m1tTfvxZbn6dZWY+0loBeQ2FNXrFYdzOoicBBABAgAGBQJW7n6yAAoJEGmD +1dW6QVfSH0wEANWnRU0RXLF0H/1VpCl/7JyOVJ9qAG091IQguCPkiPfbLezFQP450objAMy9 +r++wMlaBLmSMNbBfjhGYY9E0OcccMlWc0sr/FHzFnrkD2K15nwQmoH4BJBzAkmVkGHJhC4bb +EdYHHdmb92mViQ2oiu4vFR4/JzPudZ6qlIW2Tq1biJwEEAECAAYFAlbufrUACgkQ7DYSt3Fc +9S1VmAQAhscy/ZuI1xXm+FhRvXwEorF4hTnGCJEUwpvr++zoTIED9G/DCwP6EWg7Q+5fO6sc +peITR/kSxaLweMr2yrkxsctPIOSgWoDhqyCfpPiFlBltDUBRJZj+rTD9VE6pD8jhxWru/K6j +mJoTdM1C1tnSaHg86o+gQxP9u1oan07yr+OInAQQAQIABgUCVu5+uQAKCRCpCk1YW0B387hP +A/9a7Bz9njWA97JYgY1GYyuHnw0Q1XZRLGnz34yg7t9vC1KW9EiwALhb6VkY+lrgwPkDsPm5 +K3X4frhYOC7zeN7Q/Q8chUbiJJbCebeImyWDJmoK0e1gQA6ADA52FczUgqnqWRKsvwK0mFID +jvfGJFlf5tIynE8WRclRtpIh5OvOxoicBBABAgAGBQJW7n68AAoJEJFSw+WWEhhBuR8D/jZ9 +r7vpdt/YLGye6nKijpzPW0BIIpX9YPVjr8ry+oujkyo9i+6Bs08hdy+f9c3Ux9PpVVig985D +uakO+ZKFTq97HVwjGugjv7Yy2synqHFDEDTIXjqnKwKQC/RIWptTLq7AQR53hqYVVCF0JkIF +KoqSBEsDZgA/joVye6L7NfWliJwEEAECAAYFAlbufr8ACgkQOtEOrx269TDzYgQAkrCq4y08 +SYijKfBJ8pPdM82RCB3YXb1l3LwszklM6XCnntLkj6vzMN/AdBOOYrkxnE1LpnplLX3Mp1y0 +iTzrKfxuzgkP4s6kKHcFrbtS/+c+RTsM91LPjn1widFKb9WGoBp00klY5khaOWnWqWIzMQfi +dIDteWJ3+RSClKPje6mInAQQAQIABgUCVu5+wgAKCRDxu8uDhDwTMVl/BACMVTyu1sI2KG71 +kpZ4MJq9YqwHKnUlY9q/cAZ1t+wmq/kbEXzfHqdKDM+ycWpntd6sANgy6rm7Lq5NvuBvzeUd +c7K7a47e1DRXMUa6pTVNIq7Dklpr4g/1ZR3ABD4hs8Z8zIj90jt/U/e+Dd8YjdEDgoUBkNVT +ggUhdYallV1I5IicBBABAgAGBQJW7n7GAAoJEPPhalfAKwwevVsEALF1uE+FGwMfSH8KZC/1 +0Zrm3t2kAghvAipQGb/gvqWh4IK2o2XIAQZvk8hF9USnbuzH6lKTk6Ojfn3IeCt493iswhN1 +yTXid24evhRzmgTcpJDjGss6Lb4JF73zokgokyT6sDdGR3pM+lQXlDB1z1lGehcHZ/eD2/Mu +b2wxP9/3iJwEEAECAAYFAlbufskACgkQy02CtCsRmomUZAP9Hj4W4I9W74BofcVLaYR6+eHU +IEH+iLGKqmfn2TMnr5s3Rcuz+ebjGxlQartKde4qdXerv0TtvlKsvifMAZoZzJ7Vt4H7j9wA +MXHgSFS/L4m+BbPrR9O+USKSf0/U9aSPqU/LM7cvtxW6cEomSyaZVuZYYSAj6Tfnyqy+Q2JF +sFWInAQQAQIABgUCVu5+zQAKCRAKaFhALZf/EnWTBADG9h2YFInQDCCPRn8w+8XVsKoRVcyY +YQreSp8OD28A+mWrzTneUibthCRji/dCSQhfo39KdD9sGIHktNxbONVmVHW89wB7wUQ2Xqb7 +xfrJoP/oHgU02COQygXILJFvF5S7igKh7QHHeyB5PCRjfk23iNNwa8hIhQeLKvXoTMgWQIic +BBABAgAGBQJW7n7QAAoJEJfTZNwMv0qq9uAD/0MuvWuO84fkmTC9syp6dGIfAI8vd/qsttkm +wDbJCrcy3aDToVod2Ns73OeEhTNRfj5dtI8wGXCvUUGyrHX9s7YM4lFYRRb4dUrX0ZvVaIIQ +SBNJsE2MRb5Csb24i9lGjEg0NUdyy5cNtz8Oa6CGTJRMtalauKDKEdy8wsjMGu9WiJwEEAEC +AAYFAlbuftQACgkQZgqfFBNE/OXI3gP/SH+l7k2Uan7uj1MnAk0EAY+PN6U5rhL85dbhTGl8 +IFnT4t7d1jyx3lyJpPp+LtKqMUOrU9IYpoSjoOsTFqsaYwo12Y0JRbwktLxsGsgJA7NuWXbW +3juoxkZvPxdBV97XM7+4/rD+TGZ1pJqJGZ5xaXTSfP93UlhtofIevXkTXXyInAQQAQIABgUC +Vu5+1wAKCRDI4W7fHk2ljxcSA/92gbkqEf5xRRukQsTv9/c00mOLE+BpqXMoXg7eu8SrIKy6 +16SI6dYv8UjdbY11eHtVZ05qZZHWHcSyDHBREuLVbB0dJhtpYiVgMd9yMjpOgtgncOfVj9hC +Hac8kJhiGnCTpF6+UAs3GjB6rmVh6IsKOBFDhsh4gdndwbUb6lUgnIicBBABAgAGBQJW7n7a +AAoJEE5z0h0iAZXSvk4D/04M9r29pG1dTo0XNsvZY3hy+BseEh3hv9yPotwTC396hJcCIniI +c3gxjWFZkpK398Rq6qqYlc+8cuGiVKom89n40AuVY3RgN2H5N6h913Rcc0EV1BmH75m490IY +N4kWuIlNPCAdT/OXlu9+WoHlRUKhOdcw/ovXBJr23TPG7eXeiJwEEAECAAYFAlbuft4ACgkQ +F9vRPWOEk7XkXQP+OMeDcN3+po5HZYYuzescYUf6hxYHlTrUmR9FGlWtR5iETrM0u8mIq4y8 +FzDmrWDDcgYAmcP6pfzn+GDcj87ESuUBUnEcs+c/8uMucbRrBlwTuMAxduuKCljDMYEw7XSt +bdIUz614FkJBbBpDFcAaQAHrghFzx9E1J1xjCzeTKM2InAQQAQIABgUCVu5+4QAKCRA/HmEw +X0Fbx0cqBACgVgH3uqv44wsPYqbFl+jx8K95aHwdCAZ7OQhPeKMIFTV/fdvYceJLCX3mF+Jq +4qCn0Zjtmnb9rUCeD2sACm5k1qqYOXNlW10LBXb8vwHwkWAr2KxmPqhcmhZnnIuDl5LDoAmY +MCw80cR4QmQf5daTlNidwOYWRriEH8xpq/NrNoicBBABAgAGBQJW7n7kAAoJELlWg7WWKVSM +3qcD/1tls+mPZFShO8sVNTJHVC/BKeJaTJCxmavkfzzJOa9l0qIEmuzb/94ZWDvw1iyF05fa +v7dhH8DXHvZWn1jzHYp/yygK9u2oGG1t/dstzC5DwRPnKlBuD5UJczei7v5e9TMle95pX1LV +WJDJOcAnQu31cF/KJmd7FYdo8VpUIDemiJwEEAECAAYFAlbufugACgkQY+AZ+rW7vdtQBwQA +qZp1yJKWIaWvKYQUKsqQtkxGB2LTiesWznlb0kQielt4iKcYUz2qUfr6v8hkiYOqZB6f2hMC +GHBn1HM21aGt1qDGWHOihz/Mkmic2RmN2us143pQS5oP/EjGuclqdMtwu1XMmIo4cTnijBXs +9PrOj/iFgpuHqLfJUWoL+KWetC6InAQQAQIABgUCVu5+6wAKCRDIWD6pwqHXyt8nBACHW6GL +lXIVe4qN+t281o7f3PyLiystIuMBTHhW1fNu9pZfI1eDFYAEue2isa4PA6lcMQImIAPTlTWx +trAp0o+e6zcQak2Y9hc96JzCKuJJlu+0FTiVoei5trx40Zze/OZQENfFtNP2uKxdJTq2Avb7 +CEOiw48aRfuvL+1y30r+CYicBBABAgAGBQJW7n7vAAoJEFbmeya0qqGlMBMD/3pEwotakQ2k +Aeq5ZWc8GxTO03wTgbmDanB9dngaDHF7I0TNj8YMfbYOhkR4SDL+jrHh5zGQJ5300I8Z9mHN +AvJyrGtRl48zS3d2ruDfEejop/d0F6K/CxUUGKTDgVScdHqA9a1Es79Ku2RIJf6H4RBiy48v +nUvZJXgWu3sTeZQBiJwEEAECAAYFAlbufvIACgkQT8tXeBgYqwGavAP+OLaTdY4mJaqVo6XL +mfPOOESdRi25AaBOOSl3x3c0VHGQqjrU3gS1ytOQOq+JLAD6uglp2cwsCPTVDU1SdfKuImWy +ouavIw2r61lOSPTIbu713qv95CzknyZxtmxDL42iS/xThPiRsyEpDtPlrVPmSiaBeam9cV3N +b1QZ9tjJGYqInAQQAQIABgUCVu5+9QAKCRAP72MTWmEvNU/UBADH5j51teSE5jHkyOXFf3ZQ +n0wZQ8MUe/35evMXnzY605RQX8wRiyggO20IcT1AwzIu5aXVtgKlM1FszAoaTLBQ7RUiJTE5 +F766agDA1XOqGZm3kUVr1nIk7CM72TnQ9/11M3v83xsaS8R8gfo1YKmoS7wKlRqAAr9g7Tqh +Fe0YCYicBBABAgAGBQJW7n75AAoJEL86KH9nuv7ms+AD/j0+6JkJ2adnpMxogb2yW2W/GTlh +a12KYxzyCSjgMkdi8mJeSIAysn2+AYx6nGN7IGKxtWBUYUjuEsIGg+RvomGKCkuhhRnynomu +l8/hfbqY3efbFIwhHgRYteQmg5YGTww5Kd/9slZ5fRa4xKCMxV3ZT8zrbfHHcz5H3iPubdjF +iJwEEAECAAYFAlbufvwACgkQ3kGvBmR7ZnoRewP9HAG6NDB5q+KvKf/d1nyV5yfv0IFDgxY2 +zJezFThOIWIpwHnxXv7CmjWp5pike/WxInD1C1Wq/RVSmkt2vIwtuT8ChNafmBAoPfBhzcBj +oLr/gK2qDG5AOlAugKwS/NHvvpnH3da28zWyoZG6Z3a03P1FzA3OU8vPsoL060IhS62InAQQ +AQIABgUCVu5/DQAKCRA08NhVAAyQCxbXBACdf8sTox7MQW7RHHlw7i+TtBiSVZdFBo5aUO8+ +B5c3GBVBvk6l4nDg9wwrGhCAnyPl6kZgJOyWNyTbKhbsW2tLxbSlyKVgZvamMbBezPf8fkZJ +OlIwmannht5m/wZMS2gAiCEp1qjQ0CSs7Jhy/yREiFDoD6lwvMt+gN+OJvTMK4icBBABAgAG +BQJW7n8RAAoJEPDtkg3QypXAExYD/3C7Ze4IsNsO9NthHXzvJj0aFWcO6lap3/UZXL+EU/UR +7UAcpSbes2YZxxge5AU5K5YYAQE2XiCjy6UASY8qvpdfufHs+7TxMjgGD6MLwSdWQ/PBK3lC +48gQXhkX84mc71hBJLPC0OhmhwT5SregzczvBAKiUWLkGujCba9RPv/6iJwEEAECAAYFAlbu +fxUACgkQ0h7KbuimxgQRuwQAnLMJ4py8N8Hi3r0QCl98osifn0NtiR/NpAn/PRLrgnjxctiG +0/AgnxyoE30YkTQKnjeJwMMgcwt4ihcxOssaYo4H8dv4NyTWL6QfvkPAesGvO9gPywaqHV9j +NtpgwRUIKDWHviOqydeJjTna6pOstyS5PcnNN+OutPgLF8v3YYWInAQQAQIABgUCVu5/GAAK +CRBTje2gLO7ucyNVBAC1AD5yT6FjOaqTpREHfKI4mVg1fg2hKQB0e5QSqHlrerBhaiXMIjIp +/yk1TvmDgmm3JlUpbwcGMFw3zr3Q31DRtSCU+J+O39VeuHx1AVFUfT793wfZV0aMbWHGXj8h +S3ivC4NaO02qdKGXMlGu+WGgQG23Pp6iVqLs8bq3kXzL1oicBBABAgAGBQJW7n8cAAoJEMVc +RgIICoLTjfcEALlkMSTwY35IQlLXJyY8M4nxhqyl8UTYhhHEnH8+gyGdzHY5MDfD/lNsYuEn +7bqNesncO2aNZQ8DUHaEHJ7qwtnMsxclivd4wBwDJyIKeuNPSXZod+ims3upl+26XOGMRL5X +6azkW5oE+T9oyHxckicdjTuCtbcqbARbmj9XewCIiJwEEAECAAYFAlbufx8ACgkQ5SGiyjUT +bFYhXQP/a04B6igpFX93ghS6mvNokv4OpAdmgjMbfd8XzU6OU3xKEq3BQJOqBlOgaYmW40GZ +yAk9Bo0WJiEjHjgVbaVMAKGA+KWCTwB4LfF0m4tyZ60LcsWRBi9QTKs1kPRcfq58KPjfbXIw +jLSDvSyMuDhqQAH1/4oMiNjIPYBLQMUo7daInAQQAQIABgUCVu5/IwAKCRA+Efo9IPZM8wMR +BAC2wdEGDfvHKoUORF6+4wYO8Zs0zMcpKdffRUt2z/UJxPO4RiTZ2iAl83Mjw9iI2HKgO09T +HUAAutZzxnedrAmmowQ8aZGmxuN0v+0ZU0TCU4/b98k2/Xotyo76aKRcJvK+VWH+kNVGLXrU +yRuhr4xV+BSxncmr9RyeMuIxTE0FsYicBBABAgAGBQJW7n8mAAoJED1dZyVbuseWWj4EAJc0 +flUQAsx3BYO48qktRRZpRP57WUzeXofd2kjTHjhAphzKpiQjrmIq0d11mbUdypj7ZhuGGmtp +q+4t8QlSUcIG1GksDZQirGKVsNK3r/JZgFN2HAXXL8IG+oqWwlnYRL0UPBt/kqTnOJRUrizM +ookMUChZzjtgJLrgDxStEkEBiJwEEAECAAYFAlbufyoACgkQnDE/u1/IRHOAhAP/Y4lEkJXL +HCgROGAj8mjckRIaBavctrt+E1hYuitqPs+tobMSJDGhjRyKhb4KJgYUb2TNHgdbVjHHkTeY +eCHu5URGFYnuQDr/nppBPEriF8GhmHQwR1vYoURw9qjiogfV2GGXk05DIujsrp9zH84fYErF +Wv7yNyoMfMO5/3WXVg2InAQQAQIABgUCVu5/1AAKCRAuCaXFiIEoMLyxBACFllE+NYRk9CoB +3je5sBDaBzKglYCC/dTFEmFrdJc8NJWw2saxXFz5sGGYK4m8SqTReZE8tpNclXCPdVU4MqbD +oVzJeLKC0y+pDip0QCZNpzyT4lL2aE+Xlb7uA85g2HDPYHWigroDuuZZMA42ep1WY/rjckjB +TChSJjiCyZ8fSIicBBABAgAGBQJW7n/YAAoJELWPTLe1smPG7oID/R0jwG/gzG5BeaDie8Zq +vTwwc/uy9L35ZpuiaUQplChTaS8m7LoL5KK0gWZ7Hpb50WNivVUm+jPHv3Vq+Wtek+Lw5+Sa +jXaMvWnzbTmI974i+6YRk+wOsLTd9RudpTvqYtnoKx7tDkyIap8qR2t0NWvLfz1ki6gz0wmD +pP77YbATiJwEEAECAAYFAlbuf9sACgkQCDrn1g0f7cHSMQQAmvmxGcfwKtt0y4fwuF49VPY2 +meaD25KdPR02WwIzTiuVwrZyvJ5p4OPCKwZKqoNdYaMXBKD+ay5riGqjif0iv8acrGkdLghx +4VkjpkPDaF7ON19GXpUmeCX+jEzL9R+1/YjRPULv69U9rihQ8hyytvEbLvB6OiW6FlwhbbyC +4xWInAQQAQIABgUCVu5/3wAKCRBBrF8+TAz9NHEwA/9feJgtI473LMa6sI5y2CXProKnIGCt +iutxX2OQs9PBWnqiN6fHLV6Y8hngfXATTxG6NZmydLTVl7vQv6i2X8+G95cJkkwZvNAfyCgw +3zKGiXUgiy01YfjOajQw4hbE/Y/akzUkqJeZHHs6Btj6/uJG79EcV6RZdY8Ezluvtt7aNYic +BBABAgAGBQJW7n/jAAoJEJ3JyX0sqbJu9h0EAMsnwqyTVcu1c79VRiUNEkvxkuazIpOY5p1K +NSYB8pqs7OzzOq74GagqXq4o7MRunQvyPVK3U9V+RTJ5gQn6uzJAtyMiTWj677KKJVBE/xS4 +Aiy6DcF708TyzHdpH96g7GyoFtz5fdzkAHgPdkDL6+d1TtrSlFYW+7FT/OGJffZCiJwEEAEC +AAYFAlbuf+YACgkQo44lXw6qZSUYKQP+K6lgqsomd9j+RRMLo6cMijqDtqwmVvt/yvMxq6Cn +hB8FRuhhXsO84YCFYPuJtBoOyLCkdb9/fx6P0RNYQebQtJp9lIDeCGUGKQHOiVA4pmT8T9F4 +Cja+nTlvgBuajYxIv6g3n0vJ2/FaVqr+Ixtgs5mC/sqU0/59Q/oykBHhntmInAQQAQIABgUC +Vu5/6gAKCRCUJO/8ymBBdcjMBADBQxQltdOpzdBRZIKBhnJ9kwr5KVJwesN7mBrjYEcwI1+7 +njgVF7JpBuRt6TBgt1z15frxdum18BQjlX5FLMi2KgjGNiQoJRziv59ndFGfMVuHNLaLcSbX +kWzxmWxRIaIq2Q+RIJatjL/MUSSm2OzwwZeCielrmor23/gv+xAKYIicBBABAgAGBQJW7n/t +AAoJEIJbjJ6pi3fXAwkD+QEiDbReLQQ5XeNNHxlINVjtYGCITZZrrR5/AW4U3kjy1NDZuH85 +3Pe/OZFZ3qnKw8HjhH9g1TQcFULaC+1dtPuC2tvQKg4hBclIMM1KYA6bHlmVppphU3jN9jxE +Io88k3yP5eROBc2ZN43KuIQ0nNAOqAdv3z/DOnnqz84pNqv6iJwEEAECAAYFAlbuf/AACgkQ +CD7CxhCwI6cQVAQApNxp4aDkEF4A/u0IqGEa4vBh5Qtb2vyiYtH4M1F3YYmgRbJcGq9UlqwF +gkD4rtkP47c8Cv+8/mTpNGp9otzHPtSnZEuoZ5oR39rVjZ5LxNC35V7P2w1LP6ZQ9S28lqWp +A0e4cmSEhhn7/7Tdfz11ZH6KFv5YoGD9tGt6kkfbrcyInAQQAQIABgUCVu5/9AAKCRDkJXlb +Hznh+Sr8A/9ad0Ncsd4AypzL2oL607gjubrx+M6XLVJJUUU0NKjRdjmBktHKteNEzchzvlB2 +l27HRcSxTKqRD7PUCHTtPZp1Fw+9vMn2U2ALsRaRyKCtPmn7AXkQsKg2zi4gsCNq4YWkgK8S +Mbpl3B2ghkhEQ6cazX3j/CKU1H+Z1VSsEODM+IicBBABAgAGBQJW7n/3AAoJELn2EJWn+RCm +GNgD/34kG0Df1NiO8y3KKL3wBOU3BY6zzKI4tib/Az9R4untMYbmrUMDqmTTuQ8vtzFlDXTg +vqqZHR17ow041nB4ef4Q9BObHoiSgCn5SZSIeoZwNLaCFU0RpHH6FeIeENNJfuSN5CluiQse +ebX6DQpMn1CDY3HGMga+mBMh7PklpqnRiJwEEAECAAYFAlbuf/sACgkQpjsOvfvNI5p06gQA +oRTlDn4reCj2o2c4Q1obry6/awONyjQIwQp7Dzs57WxRyFtYaoO+UdbqGONnhm+oDa4pEzON +p6U5D7kTarEDmR0Noxd6N9Spljw59ua4G2Y5+aj6ZTQxVjcXjBSiskjCZHpgDwVCRroy5zyu +/ehgHL5LLh/W/prXuVamS0NxC1WInAQQAQIABgUCVu5//gAKCRA/Kb84TnPbddz1BACOgawy +3+CkYkpaQ4hj3+ypwEhu+B7kCSHkr/lQiKjSWlkdLAund6HPM+Gk1jaxf3FSabC8VOtkCTj/ +j38IkV6c/jc2BhYdZsPkaxkX4XPAjlHYVXATahZNmLkbT2KAAxlRwFPan5vWROZNfGtjVdIn ++A1GG8GDMs7qQzoRS/yXcIicBBABAgAGBQJW7oACAAoJEN/pXKHtkjMyABAD/0HUW04GYzQn +T1jvDBIRnjwY0rjE/EcXbcpIjs24DgG2wxH+PtxILwwqx3mpvWe3aEmE9yLZq5rp7Ubgeklg +X3M7MW25OKdq5jfoAr1NwiNcp5zs1KKr84s0zdQrUOZFVNxYdw9f8oSJOmToF9MjDGDQbr5M +w5TnjPJtNroQfTMGiJwEEAECAAYFAlbugAUACgkQlHfLHN8995OA9wQA1c2gIZFuX79pqIZL ++OToMfJ0sHrm8DO7CKERPU7NhwNHCzil73bf6RhHc9Ijn8Er8CqU1Qmq24E5hdPGsfZv1nXW +fAOhvAE09/fAhqls2E/uKwyGKxTMSsVeqV5DTHIynnTc11U2Rujh4y0fe6DJRdscCROfbvLE ++thLbixmkdyInAQQAQIABgUCVu6ACQAKCRBbHZHGZ+Hp86OPA/40T8/fWAFsRTbVDs57xRhJ +eIQsOADzcpq+VgeWCH+DfOwr7tsMMVU/486FgQYGCEul86/imfxfSEDrpziCKS7hnYeyzKTu +cmQSaJdKnqjw4L8tY8IMEk5UkjHoZ88BF5I2qn5OqSBkzj6zWC0fnfE2ZYvFHGhlVUVzINrf +1XIqpoicBBABAgAGBQJW7oAMAAoJEBVTLrEqLYhJidkD/iuA6urE9PHqczZTszdWtlSRK27c +MtN3TBzFu36tZbvZ8PWf/OVglbQc0X3bzu/zZ2loMARqgrnxm/UGz29Pmo6xOqE2zonmLjCA +cMKQVQfoxM9bj++pvqZGsFoPo0CXSyCECwNUrvy1G3OOgV99CEaFP84butc6W8XHq/IliMsW +iJwEEAECAAYFAlbugBAACgkQkIAQov5VeEurAwP+LmBPkqkm18C6fLWLE2PyClFBSHxlYfz+ +XQ0LOqasgZLWaZz1PUs4kR/BQe8wg2jTLlnUZJmQnMb430DrrhMhc7K2Y/SMKyhfT+lyo3gC +Y4pTVwdyN4MSdm8iFlP420ytbE4pzETpSvtKdl1emHesHQUyrFvFd0dvrL5N5CVWyrmInAQQ +AQIABgUCVu6AEwAKCRDYJrfiHVskJEt0A/9CFR6S+Lg1qX3tsZ5+nuf8UloKXJpc3xofXNNf +eebDxX/RhIqL44LOEflZzStr80Y6waSUZ9kqz/j/AXo2MiK483yhM+YOeCdIRF0hy1kNY6qH +z3Laq0R5GAClBSLj1HPwyDyVhMNcxPFp8UNnQowi3z+uy4JYC8t3up/WBvvVGIicBBABAgAG +BQJW7oAXAAoJEB8DC+0iL6W2btAD/3B87sulCJEvdON3gV5BeghvUaUrHHsKyd4lM0Y/ZGUS +yXBCxRSVJk4Ehn/Ja+1x6MSBZaybD8tISKUsCENLCAJLLk35C8kA4YCHuuHK9dx3lt3E+gqB +QZJeTGQ8/LKwqakGC8hJPHzgLNPD6kJcXfBQPYG+/aLEyzVtVj6PGyiiiJwEEAECAAYFAlbu +gBoACgkQWVvpm1DESzi5jQP/fOvf2de2cV0UcI7Plo2KYOCPvkFEHlbT3NLNfk1FaKrKCIY8 +W+j6htr1NTqRzj770nThX+2TwUEtMSj9cyR84Yi42nFvO+oXHg6W7zPrra7xHXfuC8U7DSH6 +sQ6hPT2hpfHjdGYnNz501B+EentvBtMDphyNW6T9jmw2UCFNpYKInAQQAQIABgUCVu6AHQAK +CRDyy5egGxf9yH/sBACSw0GQvqkw4aAN3dGSsr/FZdoWYd/karY4xsjxR//5CHjco1Wvc/iL +s1UNTeGNcMCtVJ9rGGVjFVHpRAY31OKUVuIo9ghUKd+iAUklbkQR3tIDYL8/R3ZIYKCmhDrh +FM+6BCZ4iypkkN39WxS6HqtVjN0avjmIeum162g/EhJ4OoicBBABAgAGBQJW7oAhAAoJEMed +eEHZchxoTrgD/0u9tBc8IeRbVHXNE6wa28BPtavLkL+CbqwFAvQuuEgokC6sgU2KIyvNlsHA +8Ri0E8MtCW35CkRimOi8kmo60v4+WzptJWGCQLvoIFqzpB7Yrqhmaa9XZ3kYPpR4sVpSej4l +/owLRAsvR0DnQrX7QRIdCVIWZZybztu1qTgfBDbYiJwEEAECAAYFAlbugCQACgkQLG4PFKJY +8Pz64AP+IlIOIULxdFa6rzDEoZUHoDgDCsAxEu2l2FOzlhNOMkJc9VMEwqI1QnGSUoF+BtQs +XEEcgMaYy8bzqN8B6584Otq0gVnGFEfvtVZ+MuafnXWva6TWj2h1/zXrIUHB53ttcO5Y8sFj +AVaPZhLb4psX3EzZbj746nQkwP9G0ye9qZKInAQQAQIABgUCVu6AKAAKCRCGVARgdOfW+EtM +A/9UuV3MVL8EkqaUh1dVDXBEyYWIx55coj5Bhqgx8qmkFGzaQqXPeevuEBFz5hwgpm+8Kaes +vytGyl5nMrefkiOCP8LhCuKZL8atlnQcMFShhB1sWCiB7Oi6F/KTTpw8PIQOfJUc1lqbnNWG +0Sprf7IoRl7grJVTHODhXyypk/iOx4icBBABAgAGBQJW7oArAAoJENhsh4ptfoiCrg0D/1eZ +5cKE3HN6UVJsX9Iz1+YUhlIKaIm2SK2+oORQHp1rhzprqeKMc3t+feV3P8Kyw66uEHDi/eBf +25HncAjS+4BMPgjfO+y6Glr3/yyu2mZJM8Usw+DBU12kz3U1fQ7wQcFJ+EKl9t7IFPnFgTsu +hTjua2+LwfgYz7c3LyxzykyTiJwEEAECAAYFAlbugC4ACgkQuakkoTg/7hbm/gP8DJy6HAqE +xGt5Ww98XijJv2D82QSKFx7Z4HhXU2xbSgJacuvWNurhzu6URrMOQELa6D28vc3wqYbhHwLy +Z+MnsL373bLrOQ5SKHDp7WMdGSnOyb31jLsXoh1Rxv5njgN/FoxcwWP0zqnpqMwbuY7n4UF7 +7w8qlpMUS8mh8B0KDy2InAQQAQIABgUCVu6AMgAKCRBL3CzZCRz8UKUJA/0ZNywOBqr2M0tM +NBiKAfj9XvUTMlfXqOXRWkhTzWCOupLBjb3B31DCQopaB6TtqrT9dWHtKmvlneo3pwecXknz ++rQrb042CSksVE6BOD89Swn+BfT4JpYXmb9GDVMsdf1Gz4nt0TXw5+YBqbgJrdQe/tcw1e28 +00bkJojUADepxIicBBABAgAGBQJW7oA1AAoJEOF+DdPUo9AJ3pUD/18sWEHKeF8QzRWL9mjJ +urlvf6QnV6jKm5mNHot/NCbb5R7ppdwUPjLQ1KR9dAz/WBYm8hGRnFI4Yt4umPulTvqOw7qB +CFghv7YeSGQ1iorS7h5uQZFjc3R9Sf8zFhLdsD3mk2sOXgf7lHmoYJTNItoMYywisWqovVyg +7NccIgJpiJwEEAECAAYFAlbugDkACgkQPswIUvKsEJgR4QQAo5uegkKV3Kbhrzx4KW1LqGUe +0Up2Q/7vahY9rJ+C4kYomSRZNIEYhwsf10giZ3ACZ7at/l/H4RpMhVfRYGty0JP0jLxlEpJG +gocon8RBUuuQ40iIvFlu1n8l/trX+RX44CH5EQTCcgbKycriGWVHj4kE2vrotQFCkmh6Dvwq +iUmInAQQAQIABgUCVu6APAAKCRBtPicXXO4n4i1VBADKWgf8AV9ze/OJ9vmwp8HdM04uhtj5 +U8vvSRlrrsxBgYlFN5vuWyFmKiZDh0PCHvihMvYWuqgRB3SwXWcLqw/4KiKzGSiBOYQW9Bl7 +a9ANPApPvA8NPSvzg7qooi+yRTGl/oFO9NSNakm20InFnlbfcYO/2/rv1D86i2LaC7YYf4ic +BBABAgAGBQJW7oBAAAoJEP5N7O0lIdyBAg4D/2aamqMCioJFHBA6zfDiHZLC0KUNjUkzPf0K +0QuVbrykb3LUTXejHBnNdVkzJwzHd+D2pJklHFvQzvkp+ultkMPHgAkSGnSpL89dPDroy4nh +bso1/VPdWD8Njy0qBV6Balyxm6z2WKAUl6gx16QkpRimsbAXFJWyophlR9J3DBediJwEEAEC +AAYFAlbugEMACgkQScbs8OZTjPiuoAP8D2q3cQ350zpwByXyMPGA97lr4TMZX1YnrNVOywzY +j25//pgF7Ej+85OsVL1qe5LVbpg99hh7odB0AL0tuROejpDuQFStr30kgvXP0hJ1EIaJd3K+ +6mZQrenMGtrnkrUwLaQme3N4XrOy3pImfRJFPU7bZEE3uGJXk7VUi7gZH96InAQQAQIABgUC +Vu6ARwAKCRCP8yVwkALsGGUiA/9MrbCWNXkiJkq5rC/pCBPddS2FCZDSKURk5cjzi2IPWrEG +kXPwSntW0z8DC8cCK6mANigSECpyzK21wVffGAVYf236w/Vndhu4tJiaEb1vG2ueN/xWmuk+ +EJ85mUrrMdE5g9QdX5k4M8h/Stvh89lDPDYV4GGWkGIzolcF6PWoCIicBBABAgAGBQJW7oBK +AAoJEKf3h01YKH3hIc8D/1ThEwT6UwW689mmX0HgpOil5fNYrWrHTMyo2t4HxjfWUQutLvh7 +48g8MG75y2Gh/0sZrp3/seI6dGKL7w+IXrLjslKY3zb2gvaqNAOcjoI4cDUoOQTWjt2dkR0W +PtOd/csqj07TM1v3dBrlRqmGafIO6ncHurTka2oZvl/rpk/CiJwEEAECAAYFAlbugE4ACgkQ +aNNxKoxzrLDDnAQAmtvRA+837HLs2BAHXG81OKn7C1H6RJAihcRK1HaqFSAR+md/MYpr1UQ6 +lvrsI+dptuQ4ZeREeC1EV/Su5RwHwgSdbIHHd/FxpAdJd+DaiTOJB1rl3jN2meOdI2BD8fpf +9zRbwNnmTkIDw+/Xdm6GbH69NqmYtM6DHh5W+1VX4D+InAQQAQIABgUCVu6AUQAKCRBONVMa +lil6SAn/A/4hahCx8F8dscSaESAFcNGmmAAWAQL47Xg3KhRG3NC+DXJD1ypyn04oLe5Ydc38 +QVRStXjnJ/Z/ftV3bSSSK6X6OBjZ68ajYJ+U83IvxDzj4+WmqHmnwUfvjyMv2OXjYxDxVDMl +rnYGYRdmkxShzAwC/UXrUcg8eD3vFvogrWKaTIicBBABAgAGBQJW7oBVAAoJEDyUc5pcFkVF +OH0D/3vpzAkQckaYNaz0gbl+39/wZH1HTfxZejKS/Uby/tXrqosyvIIUXjrg5GXQ3vSJsQjK +pvaX0qJ/c02QiG0GHYOHy5GP5m94CrkIKi7k5ILrtvp52wiCAjjgPO9cAZos/xS3Y9poChHb +T/8vezhzoB/oBcpmxpYpBLpvSe0Zq0NKiJwEEAECAAYFAlbugFgACgkQu5NW9YMJg7cgJAP/ +YcZF4x88s8lOskM9u/NdImVDWcE59zzTN/pwxyifasjZJiBpdhRtXaVEt//Uuyi1IpVSyGMP +K71xI0dQTj3C9sb9pXtdkntKjhlMPIs2oZ9NoepjX5M79BmEngiPVzoDakWYteFpC1Js+Lcp ++ptg/fVmEyGM8+60mwanq0Fr6ruInAQQAQIABgUCVu6AWwAKCRBdg9sCGY4yNdjJBACNbxHW +SkN/ujCq8O8pbuxJd2FO4P5wUooHVt3HZaQKoEumAs1/jtm7ifOX5ZP+gPz9rcWWVdUUpIA2 +7PT6PArg7pBUVfkuIAmBIUj7yiiSdsgU01i6LSnCXG6Hvk5SVhNUF13YKNjAslB6Wh5vYkyj +vKOX++uPmaht5p1/UMtBS4icBBABAgAGBQJW7oBfAAoJEMaavi6CRvMXuFgEAL9w9xhH3Bg5 +lUpSTdpzLvOKFKC/IYHQ9MsXA5gfkYmqU8Exb5MpYmpf1p15RjLbld2wpyO6BIIgkGRQ01KY +s0B/T+LdlR080UW6dLHzdHT7M800ZgO23SflEXLNdRWuHw4xDGRlDe/PdxzeZaMddkGBltH6 +4xB8C9DfrUMjSchYiJwEEAECAAYFAlbugGMACgkQTdkpp+mMWDLnVgP+OMoqTGIUhZR+47si +fVuWK1KYEI5UR5yfQ/V2vNBiC0AOGFmQjCtHjeB9HcgdmEKwKXdTIWJ59bQO/dbYFtgqMTqL +hRKpSaARev73ysCiVvyJ6ZQ9n7Ngre99Dwike0PsqPHG1CR2lN2QNPD95cE8B3WO9fBIPTnn +cqNxGS9gUHaInAQQAQIABgUCVu6AZgAKCRAL7EMJ2z+IqWnQA/44V+OnpNTjSsrUePfgBQlW +LQsOPURDXf8pFbL4FXWqSqO7QwfTbVoGFQ6lGH66yT/mvBAlXsH/BYKvpXEBsmh5AhP75zp+ +rC/QLdvlE8gKG3I1qQvmbthhz9DrqhvOwP3odLuVHKqHXK8rh6NYqVkx3jCzsRcYyXR+sWtA +uUXvw4icBBABAgAGBQJW7oBqAAoJEDvQb9bPhqolpjYD/0WeQjjkEi+T5IavdTIWLA1yACM4 +ZfgAYTWT39jw2w3B5sV0F7Ob6x0cOI7sddv8TZI5wUfG3PSGZ8cWp9Nn61AstnHMEeaGqPWQ +EHADpWc9q5cdl27rB/32H4vzJVufoo83GZXejvixFmpTrX6ouhlkVWfxV9Il0lZcUHz1zfbE +iJwEEAECAAYFAlbugG4ACgkQ5UxwVvNf1StMjAP/XUGDwGqVO/Un9aA5zE4KnVWCMJhqfqk+ +9XYptbaTNgPUKSQdxyga4a926orFXlAsdZuPxlHk3cVCwy5aF1leCU7JC9MgeXkiG5wM1Bvq +nE2U1qUkxBHljY/Yguo7S0DqLJPkZ7uA3Ozd8DDHSlLe7Oh1gEtENo89iKEztWyw6DeInAQQ +AQIABgUCVu6AcQAKCRCBK9NKYcAXd75nBACQ+wBFo0t3jHNOHMHo7i/EhcVs+eaCX4a0hCFd +7ba0/A4Gq4wgWS43MBAJH+mmVCs1g/1UG1LPAXApgmfpQk7uRKXCH9wyYS01ryeUMlBvWMY6 +AtW5KmCNlx5IAkah1T82HQGYf3k2PtuVyJ9RlEDqTMB+Su3D5f1YRSs1BOACwIicBBABAgAG +BQJW7oB1AAoJEJ41zTf1L6iaSeYD/2si+T/AkiTsOkrx6OtOduLHWSxfajyGXMugm+4PBJ6h +HbVVjlcHL0FHHStEOUx/9Twp0QEngzVO1h8d+EsTBNxMACH/NnU12dNfL70bT0oSXGMsq5kn +68jQ4UazuOvtB68fuS8DC85L7s+ZhMowLGUss3/9SViMOQzoaNDk0vbXiJwEEAECAAYFAlbu +gHgACgkQSX2R/WfgPw9FwwP/f3MpwZifXIMgSXVmxLI8ExactqsLN6YrqD/NrXSeh+gtP4+Z +3orfnxgIZK1MKdZVbKLjh9EifMP1IdOaTW6BF65BGn9YONQ9p4jjl14g/2JPUcSar/NX1ZhK +MCcaUyrkznIJQeD5CDQR3RWms9MNXVavsFiuab3NBOga0X1vp8+InAQQAQIABgUCVu6AfAAK +CRAZzqEQhZMEyA5YBAC1JrDil3FLwHvvHSRzJ7/LHzV/FeLItvok0cwWXXMrHCCef3v2GDeM +xO/bzUVfuZZHHRLhUdIiQ44iggQNgFSQF34Xt8a8tAoNsMqPPmV5l/bBvEUvqDEt7o5BmrvU +e7vPwXAICdO+Dxr4oU28deuII/u1Q7+wLkJ1Meswf2r1x4icBBABAgAGBQJW7oB/AAoJECnV +65nQVsEf73QD/RXqaYeCx6L2ZNodTKwoytagijHLhPCu5Tg+pad+MZDnxA6OU40/Om/l1w3e +llZRaBRx3fCSjBJcNDsbZ4OWAQhWxfnWvTypddZdtH3twFG3JcLaaMNr8LTF7ZVh5UpyJlec +WjbErcSPE2n5RC9eVIvShIIIDFDrT909dKfAM8n2iJwEEAECAAYFAlbugIMACgkQrCNr0Qs1 +8XPVkAQAjys6oQNtVyHxxXO2OIA6PlUuAaNWuhb5dMtX9xL0YUTDEaZpyKxmhiW4VLq7PrhT +zn5EJVQDS7fGkSgt9EI1VGqy/xOO5Y9LyxWrRiOZKFKr2hR9erJroGbrU5J3RA0I/htuBNEQ +bY9yVI6gC+IzHodp8bbX1xsXRcK47CWOW5OInAQQAQIABgUCVu6AhwAKCRC3hNgtzDmK+xPr +BACQ8/Vk2xZwkEbyZDxtlDysj+cbd6Vd1gmZmWaVE493JtmydrdAfxdnuKehL9SS4DIaXfaJ +WK9bal3FLHFx8agUq0OdkII51YnKRNGDG25D9Anvd4nYDr4xnZEIKCwLcwBUcYyZ2bCqHx9k +iNBtc+8p+cwYmJK0GllxekIRrJ1XaIicBBABAgAGBQJW7oCKAAoJEEiooO1zejVfNCcEAIm/ +OX1/Y8juh8R3/s2zycdmppu/fA+J7RaipHWhSeWpFYwxL6QPmsxqLSFnxmZhexh8KnY1uVY4 +xdHBMCfgeXvKpeVx4B1Fny5ZKTDXcuzw5DZz5XtIHTWfZWTvxHrMzX70wPyiJ44CMwA0fv5n +9DM6AYKlBjv4C8TdxviY2fUBiJwEEAECAAYFAlbugI4ACgkQ2mzZYA7eI+IsQwP/Y0m7QJbf +K2WRoeoSXcDKSkW23c1IJlFkDH00tC963u0dZnsbH/cqYF4nZcdm1ktsfRU9wwEuLAAp880x +gcfJSpD/HFJx/cSncUOgcvCYGpQ1tjCeqSxilMt3rSDI8oi2ME9m55nqapknL/ObI8xvYgW0 +vI4LV4cOLkY16QZ9PmOInAQQAQIABgUCVu6AkQAKCRBWIavMQyIHqcsIA/9oQUN9DCyC0cOw +vdXQQSI5FJ7ZwGqE44GDr3mJzQf5IjF9r2jN0Ke8X901N4H0WMkKYB1CaPylr1v/zG76l9JH +XTm0HpRafF59UB7rASzohcLuSQiDK173CgLxQ2qq2UYmKhIvLg6KRtHu1HBqM/mqvU8n1l4u +tPA4xXhRgyBvUIicBBABAgAGBQJW7oCWAAoJEMZN4A/JfxBdjmkD/3lQNpBP20JHMwPXndT3 +3KLtljvQEnileq9dk4y0aDtvSDAW5BKYmqtIAAmehRDL/Kl72Ax3IhnAVhPmHfGWRr5EroMW ++D/JRu4TC3h38Vr6M4FCDhK4hQein86p0c0T1DRsVLCf8YrX1hpMWoJ6UhJfQGaHw8zKWFlM +U8dMQdDhiJwEEAECAAYFAlbugJkACgkQTDBfHivrC0KB/gP/cnQfjA4zNzflA03YJ1zcfPpr +IEly/43tohCDnTyEX+S1k4k7R8fdz6D5ZjqnF7HWA9+20OvvxxujlbJ06RH2xxtEXqLUeOGG +3GV+MLzz4RaLRrSJ2uhkfHFnvQn3gRe3HOyXzW/vy0m3+udRVAurmTUFXVp6haIWXGEb9Tty +bY6InAQQAQIABgUCVu6AnQAKCRAy7dg1/FygAzt6A/0e6/6/FekPA5oVaEd0t/kdW9VFulG4 +9oIrLLDlihpAzw2JRmGEz46rb4RSLmnt12xRizvO8l0ULYrR6eW+amIQxtMVrOZeI4Q3smE8 +K/L5iuuFR3b/0J0QKdOM/lc37UhCkZr7q1chWsee9zOHpeuoIIRsaueWAldJH/rLXys/yYic +BBABAgAGBQJW7oChAAoJEFJ1uHI3kUdwM8ED/iExtTQF1X+29kdvHzsIl8xcdbDR80n6u0VY +uHwouYqzOQCFrKv0tuV/D3MLMU1s10+qxW03mmiC0qU5xtkpze8gxv+hBSgyORNYyao5qDoM +iayDpKc6DFWHSO1xFMWei2MSInavtmNboHQxca50gAgO/uMbAf3Ppuh7MmxPqBJiiJwEEAEC +AAYFAlbugKQACgkQvU5sFmefYw75QAP/axwLfPsaZ7rzA+Z1iwiqd6Qym2qeLHBrP9/efF1t +sU94vz5qms1A8VqiDq/5IzwqYIeLKo8aFJaUGYF10BHrkHqQiL8KJ1SWTp4Xa82reBZ2Q6j1 +VB0EWcdcH4mwWQs10HUMUc2tijY0FmKOe2ow8NuTcSeiXXd4d/5MUxZLbOuInAQQAQIABgUC +Vu6AqAAKCRCgekZJx/SOSnNBA/4xkrmPzqVPoiFQFbkp6umMZ8mA2DMYuY0LeIg16UgUIH5E +dSqm5IrImXq7XrhQb0dgWV9v12ZD4x4o/MIuqvhVfR6TZuFpvY8pMkWX1VjVmh6TTkhUqC5P +GAGfQzj1i6jdmKEQbUESx+NaSbNvoLz9yPnb9oRWHrgiJd41wfGhiYicBBABAgAGBQJW7oCs +AAoJEB56USXlD5hxTsMD/Re1gLpx93v6fEl9Ychdtp+4zKPWC0ehHbrSI5lambOj3Y3Y6Dub +qkGKa8F5AgZpIh7AuFSWfWzW0gUw5x/IwJX7Py9wpHFYvZ61Ri/QkmCaO/A5T0okMtYjSCCD +8XwcO9R84G8eBe4thf5ldAl25v8pbkdcMQRUU+sx3Lt+wlcFiJwEEAECAAYFAlbugK8ACgkQ +BLiSe95niDEwJAP/X7oQ5d1BBU0yYT1hwVt2NpKplg3OKQMo63WJuS2eCOShkw+7Y9VLFZ1N +uN8k9mMQhDjqOwmqK/iA0bXidIe9ZpJdTZnelEw1UYfsQtiGO8i90SncAeoUkdswj99BWfcv +9UwbKg88q5d+X1ed4ww5hJyAYGiWg2X/1bu5sCddAkaInAQQAQIABgUCVu6AswAKCRBFUHXW +wKuCalqJA/4m6T8iVkuXn++MrKplWecoHJUw92RxhkGcGQjEDMPW9tRnVG//7kQx/95GXbZi +E3hnCnAxmWDPBJdZB28+1Ijfs8BAj4FPy+q3yeUlclQmjb5Mbp/m/mCzlVZ+9niXY7AfDKES +cYKlbObEc3buVJz70yc0SvwKlkquv7nMnmCZNYicBBABAgAGBQJW7oC2AAoJEC2T//H0cEpo +3NMEAKlIGryInfwF2wZeSydykjtt37+++R2aA4MLslH2Tx/QI59sQb8/THXYspL0V4769VpZ +TZQ804pjY+pBh3pXe05DZllwzFcLJq/qSRj4OIrsngQfy/pXRY/ENVXC2gn+vVGXcUu85k/4 +R1MHzxVOPZtmHYQDnRlRv4oLmcVUaD9NiJwEEAECAAYFAlbugLoACgkQEsRKYaG+HbefigP+ +P8H/AbtkzUJYXKgbkjHCLi/Wa0J7CXk+BDwrEHspTqSxnxy2ZrA/5ouiRZiVY45soSFJQoak +KWSyy95Rdu/X9F5Unz+E1vmu8JGOOk7V64px2Ivre/vn49t7sZoz3PgS8IRonyY163qEapEm +8h1UDf5/6e+kUBI8D7B0lE/lKZ+InAQQAQIABgUCVu6AvgAKCRCV1HntWpw8ftbmA/4gu+Mf +R44j+UGMVFpgKkT9gqaDBy6IQcb1L7wZ6DsSc+0sRpxnYhcHbLdKxhpte/6BhjjCK2bkp2E2 +LGT/+23wFNuYYvyGnT7+Tc+V+8EWeuxm1tHzKkoeLVdn/faInWhv1r6K4Ptc3kjtwEgld688 +uuQSc3Bai9YepJ1P9PKGOYicBBABAgAGBQJW7oDBAAoJENj26gfIgrjZGv4D/j2LqDpD5KOT +UPOTJlvHqG6dQ7N1IWJwuXG1uXsrumZ2b803wsgx1DnwdRi44GdequrVlz98wDKtsxRa/KRR +nfPYcdha4BYRxqgJyAIGrwuCLae6/kF9/7ORrtSN/dazLqQDYkyvPnGv1iIYDFYG0clKsZ4y +boIdqfDozq8jer4ciJwEEAECAAYFAlbugMUACgkQKqgCmifUnazY0QP+K+MvugafuC7miEOA +nV23esenb8ruXTnrmhQ/nPMrxJ6INxzoQ1v8xSLZRWjnHUWhrVC8Tldxx3G2/7nHpqlGzpTs +Fr9/kew8GPpKgZfJCudz3RMCdcqgn9kdPmfcv22c9EGsk2x1avtw6AOfKc9+Y4thvGAczxHG +c1uPyYTQpLGInAQQAQIABgUCVu6AyAAKCRBmhPFeWqaRrJHbA/oDhMBNiwkdFwUpyiBg1Cvl +lmRq/vuOGudL+1iaAvtxd5vHnmQRDMLmon+awDoL+WTWT/QuV4A/kBgIuqPNBQ4jNrUlMB+s +c5PKcBW7BFpaTUHlrPwIwjadUAidmYzTy4pq98JPdaSdjy2cczF2aGZ+lrGzfQzpy65onyT/ +2apGfoicBBABAgAGBQJW7oDMAAoJEDnbCfdyd/DUcaoD/ijUE+Do6EixZcU7GD0XL9DDrTSn +M1S6CU1d9duf2+KMDjXuKGoB1bCiQHEO5vvM0D6mQiBxCmIUlzDK6MGfP1bNN9y7LSoInlb2 +kWQAA7P6BA9BUgjlWtn8WmdD5w+AZ6rUE7uobwH6Dzmi6eYAtGM9eWe2IGvFxrZ/6c1C9eoN +iJwEEAECAAYFAlbugNAACgkQY41CK+bi3vyucQP/aTkTEj+N5XGQtuCsfVANlkOmiPQGwTny +YT99VvjMxhT0w9+O3kHXMMs3nN+tWvUFnSHdsfxAwrwf1Im/vpuh1LgfCphHpaLBzDW08Bsz +qoizsS6ZW8/SVtBHytYb6cUbrx4nLO560/VridRWRhCDOxMLGfa5gFmvKa5cnllkyeqInAQQ +AQIABgUCVu6A0wAKCRDe6CQtqU03suGTA/9LJCbBkKWQU6p3g9Yld+/n2WhqQuQgGKH0Ktpi +pUXbcLQg3iQ7ACrepVh9EdkArYApHRLYJOwi/Tq8ZaFKtVI/5h5Sobceae5b6KyPhhk18XYd +0ql85aoU/SCmxOJoXXKOFOO7liW/Ew8vzL6GtIWjMnsXys2Tce806dXe6Z5G6oicBBABAgAG +BQJW7oDXAAoJEFt6MiGom1HPhEYEAKJX5N2wnfwmREjyBBF0/onYCBk5U5yKsEbvb5Hy7mbW +f7CFx06Mu71BxVsQFlO0vsM3X7DRJ9VGjUlwlkZMTH0H0WvA8Z44IHnj7ox6c16x5g092Msz +FB8xEelJPopf77aa662HGPaNEqF5x1RDmqtv3AFe43s3JoIEhlF/OtnBiJwEEAECAAYFAlbu +gNsACgkQyR0V/UCfKkzOOAQAlql9XLDb7E9Z4+ENyUN0JvXs8fEBv3RFdijO9fuxaE1FZjgL +IWFoR2I0Ckw4MZycsAOfuWpv0BGOa2DYHFWzq4OMiQQAKp7PImpHY0sGbfijqp5ar/qCPyiz +9lWcvZn6njEeAtuWjL0/03Ml9lCO5bZbOS16i3qN7WbLfzBpp52InAQQAQIABgUCVu6A3gAK +CRCtK2f7JuxDQtc6A/9lc1YRWVtyeiMIR2EC8s1ExEUUNMwLHesHEIpzIwXlQXNLrAPvohY/ +j8EQZBF9kyv1eTbb8WUbb2YgUXpLXUMCS2ixHTsa4Uj9d55o6HaFt6aWGklZTgk7zZLg8mHL +TlXiFFYNYGjbylQSEpaMEa/sY5m1+zscMc1DNv4vAt9ClYicBBABAgAGBQJW7oDiAAoJEFZ2 +NiiVe77fqRkEAL4eUvqrtgKiCivHCqLWi4VkNosf6Zx0/CRNKwLq/y0v9ob2f9OMdOewRik5 +leym9C11clCdVL9yhw9ECXU4tuJMyAgh/yT59P5dF02Am6nDuE2QebEHHpaBm9Kz83CfndMX +I8Pr5HHrbeRNN/8Bp6ka0F2gQvhTZXWqJe507OZiiJwEEAECAAYFAlbugOYACgkQvZ/+wjXU +ZBo0TQQAphldVn4U4gcrB4zx04XmXcj/5kgfmLDDadNl2LSNAQ3pCbC+j+xH9+8tItX+ypkv +PJCWusqvXwh0p13p8sJ6jTxvkuoQsMky0l87yeT1FeJMUP5JBvQJxF8VAAJRqb7FOnM+mpbb +LAUFvEbCPP7b2oRWZFUJorj7OLJgvBe3A4SInAQQAQIABgUCVu6A6gAKCRAeNxJVfopdWm/Y +A/sEJbV+1qV7eNg70n1RE2PiTBO9devTLmrWXuL1tI6KkhmjOWNx3nM3NllbF9EUdQqMwrHp +zDk6XgideASiV3GtDjNJ/Qg2n2K/Fx5qGtxVCpNjYrfH3DcZ3ejyS/Rj1jIO7xkdLgxYCpd6 +LNpg+YXRuksrfp0myHpWDUaQk94kKIicBBABAgAGBQJW7oDtAAoJEFZd1ynZyti7H38EAKmF +vjdjaqJC+F7btcCMfBr9iLaLij74FwZAN7VxrJIyvsLoH/dCDuErZmDORFTVnYl974y6Qmzi +bHAcGixspxR8TSwVO7uYHW4BCr+mOc6VRF/sX7Az6bEQYcNaHy++jqSNYQFDWO8V+L8UOzoi +Pxi8+C8M/TgCXZG2ATAINXUEiJwEEAECAAYFAlbugPEACgkQPWSbK5lDI0NJiAQAnm4HUWmS +TMVqMfCKIxL7bR2C5fXu3SuNK+UBEKmbnBmPQIamg+SiNBACi0fZ13QXxFzj1DPa9ock4iXq +VTPsqzzgsrO2cDaNtY+HFJPtld2ZTih3O9+kZI77ngYP/W7vzn3YmAwbu71JG7rC+S6Fzup5 +qTuKGLNCp93WKxyeshGInAQQAQIABgUCVu6A9QAKCRBwQV/jdh0yGhJpA/9GuEpdsLs9mHup +yVp/BzATiC0Y1QkPaEJJm8LzAoodo2L80wSjhcTHlhhljonqdKOq3Z2synZ7Dnvicqi3h5qV +y/YeJj7NlrbiRY1ISgChyxsvIj1DdRpvL4vXLtF0Xnv0D2Y9aMME/d8pPbW7VmOB2hQn+RVf +71UEu7DgFI0fBIicBBABAgAGBQJW7oD8AAoJEE0CvT6NwU8zMo0EALoeDYcR+RTghKEP2Vds +usIrxdyT1PVRdIOP2TLpKlpcbpXessH62giwZkHUA1gSvDK8ezjOch1GRRgOEeImJxzxtXM4 +j152K+26HJo8Z/qEDjSZ78vvry2ZiAvdO3xoXkVO2XK8bB/aEd4rgXWM2AdBjpGQWWl2Kwt/ +bUv0HXRviJwEEAECAAYFAlbugQAACgkQnDxU9fSp6En1MAP/Qd7mloHZtNViggzqVPYc41OZ +Txlkl2In8IyUxWh93a79bqx5difnEbzOCua1E+2mlIgTIOprqlxZJDfqCeg/1mexTFZgRX4i +fIBjweQIY5I2P6qif/GmOJo2SwB7ICpuotOhSyFYjOpR/HvpOU58qEVQE5X1xsEEfUXE/n+6 +boKInAQQAQIABgUCVu6BAwAKCRBDPPYqj3BMG0oLA/90rNADHZipRcHX5aD0hpVVa9xRyU4X ++4oA32FNWljqdL8r3uGK42DWcmeFFHkPUwSL2LV8+A4G9LWRqJ3pjpsKB0CtlMLKavWqnmGP +YWM7cImkMrGUGpVIS3LHfjGrNKNLZkymMdOYl7Khb7/Fub9L4zLofyr3n/KP+Mt8yz1Fwoic +BBABAgAGBQJW7oEIAAoJEP7uhBIw3YwNSkgEAM1eVLXDftORotuAzddgk6R7tHQJ3eCN4Mc3 +O8a8yw69G4ai6tut1zTICMb9RJU2tq8d0R/+YgxeQ54Ezx2SpDKqS9CC9bUvz2fkBYPs917m +SzHn3nTlwie2/r+c0ttz098g4eTmbFlDFuRnmR/CuAbBxZzlbiJuAShSStk/y4XliJwEEAEC +AAYFAlbugQwACgkQ9ct6uyrXKNvkQgP+KeOG5OgfNglND9iqABbzkmFXl7K3Xn+qV6MwabDn +LKfBvgmdRTOyUisDq7OacB/uqnW4cAAh3CkrgzccjnAcHCkRiVLMbv4aVnwiRBWwOefMC99Q +AITL8zN1+dUMJ0gq3jJp90iL6V9rv3MOV/Q+IcIq0q1LU4T8NxQ+EiOkWQGInAQQAQIABgUC +Vu6BEgAKCRAPmFOTDBLJgj+3A/sHhiI7Eu65e/jUKhaJlMDRwODVziJbcr1jGbkLri5mSsw9 +bwUXE7ogr8VPq1UtKTTb8lMduJCT8L0nAPTcf3WP4erhw9ia2UFiw5Fjo7KiCBxpn1sUKrCr +26kuHQYIIN7sIhLPylCoTfBya+hO7E8VMVa+P35/I++tXvJPnKIx4IicBBABAgAGBQJW7oEW +AAoJEN/a6/DUTo5xsdAD/2LbUKyd+iUmb1E6FvGJbHXAjTvQwLtAecbF/GVwXtzg9OzFs/5W +B1hdg1EEAP6ncYJMrfLjnzWu5G65LoZbyj/SyKrk7f03twma1caO1fC4IwwiK4nbE/+fqW2v +KjXgQ/+96Q5idF4Tkl0wRown6YqIWEmsUSroBfaXeoPGzs8/iJwEEAECAAYFAlbugRoACgkQ +TEzlCFTiC+9tvAP+PcqjFeWwd844NN/y0nX3lmImiW0lI513nN5WT5EDep6T1v4fQ6HnBwUe ++uEPyh/TIHBPEhWUWIuzfcRlXzrTj3O8WjQpxwJvwulxV3U5mZdSUqctG5adcgxpF89OKgj0 +08Bz0Aur48bAeFMnF3LJYSs0xu5nE7SprQEhwICdrlKInAQQAQIABgUCVu6BHQAKCRCZ0FC3 +xVvgHWBYA/0RwPPMQTc2Lsrm8QIFYpy5m7w6p5sYH6gxC85eGBirouzkg9MWsBuMwEdkSkZ5 +j5toNOEWXJD8RJIPM6XVdcC/R/xSXbFrUlKzGHe6XZhPD6pSgeF+T8meOacYEemVt/rIEe1+ +kM+c2yqzvak6Uwil7MdYqyQ8lzXlhRk6ZvOIT4icBBABAgAGBQJW7oEhAAoJENPKAtLX9CXC +D1UD/3mOwUYRknqxClbER98sjMbWJJbsq5xHYD4Yf8c7tY6PFuXQRHNVtHAVjGyOPhc8Aq2t +X+7nzwQN3eXSvX7XCEpRRvxataWhP8dYu94Pza/LVJpO5JFAhLHf7ygoNoI+geUSVZd2dWNY +a315VwzEYM7LL0prDB4SJX6Z8Xm/6qmAiJwEEAECAAYFAlbugSUACgkQ69eyb0yJFi3guAP+ +KuHXlm6TtIxj5bQxsyENbZPbddmI7mYdN+sonk2wIYHlJrxi/DpJjtme7PB86Kq8VyXU+BON +7PLPB9yHLmQYHvCF+iXt8yabI3VfPXKqltbFnnk4AA/bXyIE8L7Kr9WZnCWrsuqnwFDA99x/ +k9ggNHDh2A371nwDdfgSvDaaYsuInAQQAQIABgUCVu6BKAAKCRCIMNc0Xpiz3VkrBACPSfCW +OlgLls9lErLUjEU1wbtA4H0TOj6s/sXq2YmhIiCGO6HN8LoJqeXO1xdDiyG3LYI292AR6pFF +DuprMYb+8ZtCV+PmJEs3yzMaivcWXWploaXPOOCpJPdeUnuAIvhI1QSbuGDpom0nluwgHamx +KQBmhy0uFuSHmoQJleHovIicBBABAgAGBQJW7oEsAAoJEMUK+Y1pYxlwRLoD/1lTDxUBWXHd +X4ckzqMfjynyIetTOHW0yLD8mzi7RUa1W+noUr42ExRFZIuR9X5PD3DgabTaA0h7oHBrxraQ +VaamjnLClNLvjjSJlIsgvh8SbUDwlXWEu/anmEHuV2ONXE0S4NtxUrA6uOHokMCifjJjW6He +DqAibC52m2xf4sIkiJwEEAECAAYFAlbugTAACgkQ4Osxaj0D5KouqAP/Tro701ZiXzauX1bo +CroIfHNLoaF7TPgh4GSCbE9iR6b4+VudTCiVJyr/2r+EeuVha12qrk8ajiBE7OLAxSrV6K+E +zGC98k0gfXD61dACvaSrPCy4c+mhsmbL6zRfvxW9ZDWkNQ/Sfa7C8mApLjw0QZ2Nh3IN3grC +XITlQgylshWInAQQAQIABgUCVu6BNAAKCRDxmvBPFD8pgGwQBAC1xgiIEx5WG+bAu9vkXDiW +GcOHAde/EfvikBxHsARzES1K2g4Q4nIK4Ftkq1MaT6/lQ1RTm1hm1K/42UP+SiHDR363LLG+ +NKsVE/NtfUGLIUABYNKlr4FUJAwA7bHoUnBqWJorpU7XIB06pa4viy06K6hQ1cOdz9NXUH4v +SKk6QoicBBABAgAGBQJW7oE3AAoJEJmKa6yylVVrRLoEAJm9YvqNn35CMDwGQrpcIu3+R7x6 +OtE0SYgvF+vw83Q/gyoQQZK4ImAQpZdbyWMyqRKJYbIf55T0MZS45d7efT8kSZJqFsESAxRv +L69BxRdZVCSJI7jphDfzJKNRBmARYiy5C7QiqKZf95s1ww6ZMD6KA5Q1xDPKlAvRWdHKwVvO +iJwEEAECAAYFAlbugTsACgkQdWZ7+IrT996TogP7BOFp2SLDOKAlIDETVnS6skk3IFnukKh3 +2IiG9+98E7W8q3bto2Jvc/CSiAuUIb8gLYpq4JPXNqlSNIW64rUN9AjhdZCwNNNk2BrpikEG +t4Vx/ISfPvDExx2x9/3crcv7QUdFoEb/a0NyWsAFTtpM+DCN0rf6ztEEMu5XwlwXqCeInAQQ +AQIABgUCVu6BPwAKCRDDmowqn9l/cL3VA/9N97ZuElYiezT8AtxQCWgZWq5mwohr+mZbqe4R +gE+CNh1rX5Dv/AcQmEIK1KceiZ6EUBJ/LrJZ6OcINfe1dmtPLBQRtRzkdrDw3jjyKcCJKdAI +2UksXToujx+oD42HNpw65INYibFpExtpGGsJBWUOePl22C9K1Wi3DyFQaWJaq4icBBABAgAG +BQJW7oFDAAoJECGdY6hW4Dw7PFsD/1IaMuhYkUB29xHv9C11v0c5L+iVQ+ZoJRfCS+IgqqUp +V90JhRvYv+jxRbzu4gOoD1ismdnbDyW0L1YgU6rFiQDGPuj5Z1zT2KajOYyPPVgmSoIxXJcJ +MNQUBio9D+MHrqiKeJWxUb2IPvP6RAnE6kGXuS24klH9x06QPUR8YuYriJwEEAECAAYFAlbu +gUYACgkQMvIngbbkUMvSXQP/XDdtt29JKLxFWbEuFBcIg5l8qHOlpNJy9rm06E8ymDXqcMFY +dqWKMnV6gviIH2PznHswrDtMlxZJhU3PbZ6w0Dmt3dvV7vU3JZa2xcOXfpuurNDcg+MdFI0R +0WXpZNkFcb7SPIjGQbA0CmnFYCYundNtrUi5PKdGta828sgQXMmInAQQAQIABgUCVu6BSgAK +CRD2xNJiOCa9sZXVA/41N6OENyQZRx/LXoVsC84nk49G5/G711PzTcF9Mzg79NMq4rEHRUke +TF6D4dx/rkXTo6/q7fZZWraHx/DqrQQjrPBc4o7jXxvkBt4xl0nGfHORSiXtg427NWyAyYet +hN4f+JtM0av//EU/FFsWr2xpSEL0N78skEktcWyTUZlczYicBBABAgAGBQJW7oFOAAoJEFeV +sA/KLRKTnNMD/R4P/SXKZT7i1V8nEO2O+u3+pwKSaipR+FvpNRryvAebUJ/Zzd1pYCLkuQ00 +Ut53cUg+Om0ZTuyfkCWH67uDbnHZSUvnsyFI5L1nN/ZQGfdz6zX2XdA/0h5KN8pdPleReqML +3WCva+c5uogJ9gJig6ppNsLzxSqVVjUycT42PUfmiJwEEAECAAYFAlbugVIACgkQRHw1CqkZ +1LDn0QP/QVpyPDcxwjtnLg9L//2ER1dzksygdHQaRe2KILuJic3cKH4MwxIuXyi5kXc8BhKD +Yxw2R5RZQj3GKJwLvRzUoq4wz0gDDyzqpRmOA/4z6J9h+8iPCDNciiQaeca9hXCLAG+c/TkM +Hh0PZ90/Q+7n1XyaI/vzofBemf9pGo6HePmInAQQAQIABgUCVu6BVQAKCRBq7863TVwUcSME +A/9y/G7DYWiUS1bzI8OpyDOkUgrLpuHl25Nt77BF+X94Ws88E9SzCrkMgSV4bCQe7IKdoWC6 +Y4XY2G8gqf6N2vMMvLh2wqjGtyatBlW+DIQhQsHW+iv604r28/sPMbjiaBBdfoocP/KjbtBQ +JnnuRFh2/YAdNiZ6+/fscp+yikIdbIicBBABAgAGBQJW7oFZAAoJEBu5mU5IkjRFjyYD/iwm +IKNf4tGps8lj6R1QbpNBXrG9wiZ5d5SjC1fG6Y1A+VYloXHnF4rFPi7ysGo/lZudZ2kAdFRQ +HyU7hWpNYwmT8FoZEzSug6z6ycgSYW0qOzCkDYJDGso6NJy4axK+MV6E1bx5dx8QHK4gBKG6 +oA46E7qBBNSlIA/g7le6dIlFiJwEEAECAAYFAlbugV0ACgkQ/opX2gloGOZvkgP+LIeZCPcB +F3ExNEK75spQj11cMUE1UaO1Uv7ouBZE5g4WKWpoudRnqlVEC1hN5cVxSu3MLGl6jj+jR3zW +iCxzCBImydLULDQINqPOnqIREi9sjJpO7QSQG3kOOP0thIvFQIzGTnlvhU2Bbt3QN1Xq9EN8 +f9MQcqQOYsBBarG+rB6InAQQAQIABgUCVu6BYAAKCRCXkcPdIjsl2NaIA/9KiB8HQZ5LfC5q +PkTR5iJb4mIb+tA2D361HjNWp4UK9aOCIE+R336gYenLtyA0RyO8RwKTcdVdhFDsXHBRMB3/ +T/CEZ1mPjp5GqLmTKwD8ulijxlP3bBEUwAbUTu2fugqAxaSOdsoTaqD68ijiBjaObIqlEaw3 +iaz1/CEHalJE24icBBABAgAGBQJW7oFkAAoJEEcDvoXsU6kSGKcD/0X4kzSIazdtjMLn8Mt6 +wC4nKCmvOux7Pgo2X5t9EfHPAUbv/zGi1NA4AHzZM6kCW8cCKSEVN5GL7SGwKa1j98tgmXpI +nu7UE4aqHjZk0vCIX2ZdREcbdSKV4mNowjsqbOGT9tKD5JWG1hpO4ZGOsacy7tYd9/OYUHsO +zq077/1IiJwEEAECAAYFAlbugWgACgkQqUiN7IQwcKlMqgP/abCn8cN1kY7c/wpYpj00RVKQ +vmVBVQg8ZmJS6R6TnKlDj+YTk2xilb1n4Kpf+2rLLou0cULeSZmEgroS8aYZKq4q8zHPgOrS +alMcdkn1vT+CUE8dx2htnNPAKLE6aCh729Tl7aspp9NHQ/5KR57aWrjVCcwJPosphl0G/0JZ +JbeInAQQAQIABgUCVu6BbAAKCRCRwR9T8tSuwu9gA/9Eojd5GUHbtcnWCtcTgsPR0HpTllnO +k9+Y9w8gItnprjbaG0rwF97rBM5jzTDmIoBEvYC4Cp4U2K0JkkwNYfGkVE9MYbCDUno0AnmS +74FQjqbLX262mQeujerQoCdJfLHtWu0KDJNnKsrSPV7ZYDMChOKuQuvkLNfMirMKeFUFvoic +BBABAgAGBQJW7oFwAAoJEC5BAUj2qoGCIUMD/jmesVxKhnHw8iJjMf5BTNTbe1oyJGxI9PaV +aAckdBdfVOHyLijg0B8wjTLYmxFGaKIaImEoNPhcDZuZhEHoi5v4z7PqP7V0DoiN4oN3ia61 +7ob9ZejOEE+SwlEWjW/Cfgw1R0JU2VMv7UTwDcMHN6hW41Vtyf4MdT49a8cIM/nRiJwEEAEC +AAYFAlbugXMACgkQDjNpM9DKyaKOewP/dKLQZsS/ku7+1n+NtZukPA3XEpU00z2Ji+9ZDorx +ZtzNZX+Rr6CGh8h9Feyt27AgaeQw3bKUQtI3tscG7nS8hU/p7svQgTziUr/TX4P8u57fQ1nL +Ilp4eGLdhkmUS7YwSfbgRrFFZ9pDRIzFKFmL30+AL18zrspbk5ftCjlwIj6InAQQAQIABgUC +Vu6BdwAKCRAVdPccMTsi3I48A/oDFbNaBrJxvmz3GXlJnhHhB9TaR/YJkgT+BkRLDuMvfw0+ +U/RPskfbvRKnqqmuwIivwqzUCC5vnhf21Br3M5ORBCEjuWR+qtVGXDN5+tKvRdKkm+5iXyCT +wjWX1SPMDrt69b6CLnmVBdX3f9V/0UcmpRmnQC00EMDyg0+wtceKI4icBBABAgAGBQJW7oF7 +AAoJEDeo4+pK+v3I5jcD/0JPPHBeKbremL0Y63ANny39S8HcvdJGIckJ8bcSBl+fjT8IRgBM +xc+DcYcqhI5s9eGYw5zUd2FfREgDsYnaHanT5AmpC8AG3CrP8rs1zLgiMctLWMHXi8x3sLgF +vOANHfl59BpFJEyxmKy4r2OMSO6Gh9OxmDhBF859t0nqSKvtiJwEEAECAAYFAlbugX8ACgkQ +UKMOFWK3OeHXOwP5ATbVFnveObfwD3SG5Molu0EUgmJ77dTDqR7yULCLXM2NbY99eNk1Xf50 +jwaQLReP0/4I4ejFj0kkZxcxog0ZzXUA0LXwz3zrvXQo98VEeZ/mOi7O2hVrtPqDcj/BDRzk +UhYgJZjKt9nnP+NQ5OWboXGtadm1BXNm2zWCrYLrTOuInAQQAQIABgUCVu6BgwAKCRCljq2D +D5/x6r8sA/9xORTWQgNN48mXe96V3WydOh4fjEtzFAJBr8K5g1pfi1OpWQwhm7Vf0+rGMFZ8 +C3T/hjhEIF3d8sSBn9INlynp/JEBgGULt2WEbEFxKHJrhKqp2ANxIDwHTxlGnkYAOK4QxAdn +HTSh8KECBwteXovO/mXn3LfsywooPCKD4BI9ooicBBABAgAGBQJW7oGHAAoJECIUOU+z4ycL +2ccD/iQPd49QMvJXMo7EnXMWKYVDNAJPQADn3izpt4SSe3kMQc3ffp2p3jOKgPeM6C7i3SHR +zNdevlRKvhNF3eRn3xEqQ0znAol54tdL9wz8gzZxpZ+IbSxNXcoPSAgYfdbBL/fiU7kAgZyD +oJuqPx6rg+bYuHCXh5C40EE8/2fzHkUbiJwEEAECAAYFAlbugYsACgkQKgoM6UD5w4ipzQQA +iO6XyQYaP1arzgO/Lpnl4iO0NOo3a5dsABMdUy3zJ1LKfDCXZj6ZkB2kgjVQ3aNzOYqYgdFT +h3aHhqpx9NwqcD3/RByeiVdhNLJs0ZOfwYCgxLr+7C7fMnxDvPXPZobvAIS+77CVWoykK7ij +6gnTBkwf1MMuSx/PGKJ9Yjd1UQGInAQQAQIABgUCVu6BjwAKCRALfyp6yB0pWxX8A/0UuET1 +LdEhRSZvw2mMzRAbuMnrNBHvhvnYEov0MsLe6AsjBR3Lrhc+n07b/Qpc5M10c+YRQhC1Mmlc +GnjK8EiF8EUVurMUwP+UE44Q23SSEhlgd9DhPp/C0uRRFQZbAxyB0G0FGPg5fIBh3/xh85fq +coaV9UKKyAkDBvKbQ+Z1T4icBBABAgAGBQJW7oGTAAoJEO4U6cT50jvBgQwEALPTprNfpKFx +fTWAALiMY2ZGZUku2KhNouz311djR9KEZiKFyyX2AbtyYGDtiVE3gCxXi6lF4kdoahwYziKy +sA3zX4ZKkD+aWXNEZZraX30FluBnnzWOqKXE8llmW5VF9QIr/youGR5V8EvbwnwaZ4DoDfFu +pkRUrpV1JXeUiplNiJwEEAECAAYFAlbugZYACgkQBPTkk1W5r3ivxgQAkbuO8Z8UAjOD5uFy +M+FzS0+u3VwOmvOGx2+od9WpOg73Ok2ijklHeBxnQhcC7ZuqDCkbAN719LDONafezGSydkWw +zQZHbLru0cxaRpH68k+WWVkTRfrYrjnzOydIXp8DkaoSJJ+4hf2KTdm8h8ZgAJZTHFW4EghT +Am4d8RuBN2mInAQQAQIABgUCVu6BmgAKCRCSOpxDrXvkX61mA/0cIKimsOjr1xUrJ1tzIRza +UaoDAguNBp4bE8nbydTC2/oqnq/yxLEJjsd1kbdQ/zo6iL/67FhebiLJrNgZBPdEdByPq/6v +HWgjLuUDIhBQBjbhxaw8tZN5qVW9KY8J/+0j4A3l9W6+CEmkdGeAnGc9b19K3ina+teaLTEJ +r8Ood4icBBABAgAGBQJW7oGeAAoJEH7WRZ8icH4D6F8D/A90DtNN8Ux+L/AS9TfcmrQjXegd +Ejhp0mdgUVKrnbQqbdUscQlNVvU03VumvXfzuaYdWUFP3hQk3JBxQuRgo7EDXDU5KIpWFrc5 +05eDm/aw3ebNGb4pwSWO0TQB3uUDkdAqneu786mlCYkGiIv3Qe/jfnQRahFPlcXIUxGYK+kH +iJwEEAECAAYFAlbugaIACgkQJrg7Y3Ec0GPk1AQAqFZNNcVOXbg6kW+bwv7Ho63eAKemOKsw +aEfFnhFzRD9fdNszRhJe7x54qaQT1lMYB6QH2j0lHI5tXy5jiP/kNwq5+NY9dfgaukyBzEbp +uZz9pQvKdhLEn2z13pWV479u8fOPxfVObsUx3PRjhbrzxlz/IMu1TelaxDu/oe67K6GInAQQ +AQIABgUCVu6BpgAKCRArJbr/QarcAHEVA/9sFONgYuR/MaQdM+CC2KzxjWLIIgEar+dGj7Gw +acjxewYXHD+P2vghbSxhlinm6MpQQJyHxv35C5obDzuBDU4ikREcTK7pKCmk4SzZzU/gKBGL +tPlrrtYLQ2fTPpz3CHyivG9wgyF3dLRnUo/rtIQxPfxnwzxUd6/L6vZV+cBO34icBBABAgAG +BQJW7oGqAAoJEGrjx+WCor0s6JAD/3so1ua86gDrRzYmrpfybvLG4oSPC9fQ554Ovo0MtheI +J1hMOthzX5soUXdAioQuSOc9QEDT5x0X21A0UG0TBK5d6YtM1o4Sn9Bnxia3E9ypFSKPtSnU +kWb6cnPdexUB4a87yZeRdLWkeuuljzEgHnlPT00zg4/mwm8ea9mHh+YYiJwEEAECAAYFAlbu +ga4ACgkQc9hiTF8U8OMBuAP9GO/NurWAKqQ+YQlCRnwycZalHjJKF9MjfCINCeKXJAqAPF8f +iHIFCeBNXeJcO6aHTfq7HmNJOfr+8uRrk9h+iALwp4locfCyKDTfdAyO1uBGke8EPDIIsG1I +Ph5emiaqWwWijyJizCJVUQFUPgnqyGhNr2Qw1ZKPuh3+S46rEPOInAQQAQIABgUCVu6BsgAK +CRDUutsDBRpuSdS0A/9jaKqo8SY0l+/XtbIRMKbl/dfd8z9xGA0CJwUzHRMMDI5PfX5V/l50 +qCWgX7PBvIV8jDYdyUQ+s0EDzsTDl1tBph0Ho5U6oYKtMaeLhRUk59U34iyfesSXakDEtqgd +YC6ctscpuoUHOUsEMsf+hP+6knpK5/s/6SQMySidUGZFk4icBBABAgAGBQJW7oG2AAoJEFuN +kuQ/o50XcQ4D+gKZI4WFn9bLlSYe34abr2Cno/J5UieVVyfPDD4/35BjeOyl+P6Ka9Srq3Qb +99Q5zssVP7POLsFdMQCs6Gd+goX6jfVC8S5CwS5ywe5Bo8/M6/LysR3SX0f0yMUUWtMMmug+ +hERf1wWku5PLBxMVe8yrzykMXU2yThPmjUCqAXYliJwEEAECAAYFAlbugboACgkQaZxvdFiO +lm6CzQP+I6Y1Dfo5IOC2Q/stnjts9CX1JoslLwUcSOKmhHFhpHufDp4W33L1jIibjelANmdO +EoENNAk9r/5ljtaj9MapoAuIEk99hOc8cFycGSfsXwbFdRQHUanXMjTi7w9dRGk+zHVLtaen +I4Nhz2Z9KUPy7/tU8kxkAlwXRxW+bQsaKB2InAQQAQIABgUCVu6BvgAKCRCwvDXDb9eYYCUV +A/wMwigghrw0k7/eS5vBYURuyj1Xlz4SJ+czRvdc/0AGRnrR7xy7PZdLiBRHWJgo8onAUACo +lR5RQ5YmINqMeDDyxA/qwW6sSFCDw+4wb7+PgX3SvNDbllqBVdOsB8zDfM2rCOwRj/seg8Kg +5CG6l784gF3a731yU7vrzJCI3aZQjYicBBABAgAGBQJW7oHCAAoJEL7bKqNxTLHN1dMD/1wZ +CBIiGe+BYEXJaBxUb4w4NnVnpRUEILG20u2vIyL0ESnc7nkmkiO25eN60RyP9VG1anYDlwbt +WEkcFl9Vfpm2N1CPD5vowdAqTQWxdQfgh3C5Re0D7kU2bcXadF/Pp7D55Zw4nKdlwzFc1S5w +XOWFxZGkE8oFrBLpM/gBN9ZQiJwEEAECAAYFAlbugcYACgkQd/2r3ZXi2BuMXQQAqWP2OyzN +XBj013ru8FZiCg/uqL7LXiUsUCDKZmmqFb4A8Md5uJYhLcNxSioY7/Te4hwj25sOoFt6hCnW +8HTg1YM/zXpxHnCh+vRIkmvRiKSSyl2kuan/CK5+RDW+qqEgEHf4y4BEZT39n5w/+7a6cPc9 +L4RQ7oLzShRg4WhMEP6InAQQAQIABgUCVu6BygAKCRDeY101g5WU6BjaA/4ldBModbRVUsJF +B1Saoj484Gd+ipVvpiXNnYGtZI4RC2BFPDO7TYY/auQWOxXzN0q13IWRhrc3CR0eomClKCNF +GD05jx5+uEgonUKtCE46ISegzzBYjeb7JJCeCbFnmHxvD5ENXlBY55p5O2tvkHUHcS5cpXA1 +NFOu4cUVT3NmC4icBBABAgAGBQJW7oHNAAoJEAJR7uPcDeLlI/4D/3Y3umll4cP8AdYXRyhp +LTIPOTGeta10FZccvN7y+YWnpBE0v9zOGY9f7iokucmV2CoRC7+nUbdoxWLI3X97GUXIn6Or +zv2dqJNFu1BVXA2HPmXROrrGKy1V8s/emhruaeYGeEUPHxiFxaUvhXUQ08RA/4Woh53UVHzJ +uysM1TlDiJwEEAECAAYFAlbugdIACgkQwohYseXYAq6YGAP+JddTRlalBHbxhCn14Vo2wU7f +qtjTCm+XNyuEfSvyOa7dR0uLp68cz/kipZ7PPhU+x52+hyViiMloPgST8NpYhN/2719OksJ7 +FnQM6d1KE0ng7jgiYr4U69bgsbqTvgWJo1L5N53Pf20GVgzhR6yaviI6DPMtKltceV8GMfIi +3m6InAQQAQIABgUCVu6B1gAKCRAQnMVjtZYOcVq9BACT1d865zKa6Bh6Sd/tuLdTOrnIJZW9 +Zl+KJjz3DgD3PRiCrTCS9QKNDZ340wFkEqMb75tR/6wdaHJ0G22TgKzBucSQjas6htFrnbFy +uGDwlSOOn1w0mQSaBFofupCxzmKvNxNX+V98kfN8upxXkhKzTZ0liW0AFY7lTJ/b2HqGLIic +BBABAgAGBQJW7oHaAAoJEDA9/DfaNvMlzUID/RGRCwJlGOueA2XS4N5MOQAFPp+gy4RiMl+e +St5Bfnanu2kvh6uxlu4YuxDWd3Jmoxw5bRTgrzi31Nu1fAxMY3L1KcsDwZMN5fFaD8P/FAWx +BeclVB+sTgBT7ngnqFgpP6vw9plvgt9CHRmsx5Edc1cB2yo/71JgI9qjXde1STdViJwEEAEC +AAYFAlbugd4ACgkQk/4UnSv8CO8FiQQAz0ydp9XAa/sSrTyfzMoF+tQYrX+Yfg3anNJiUXjo +jZHscqRAZ5Le3BLNkNmCC6T7anfz8HIX4mDt/xtQIaD4pbxozUgx+TgVgiZT6s3USUii0wyN +5tWfYuFUTo/f/BpELbHtclLKLgLyrGCxBvJszYpXvWhHldv0btqpZ9wL7NSInAQQAQIABgUC +Vu6B4gAKCRDbsIkJoxyR9FrrBAC2qegU/eF8NxNF7yjrBhf4d729gZd2O9lmeR8YXjXKzwho +dgK+UaJIu+TXnAPWNs5d/8uQRrI5UIcP8vsytG8PfT10uG9TG0PwRpspoS7GC097rAYEQeWQ +mxk9wfbgpRabwvhMT00D+pLOi+DAtg4tkKUSudotUlDtXmoRD+UvBYicBBABAgAGBQJW7oHm +AAoJEKwbEyxLN/p1jukD/0YAXZb57qAfEYvIO7n61v/qOjjesIq4d+/Fk687uhkNDCROlHgj +t3nu8dmjxxlhEpNiSPUvo05zTJQEYeV3oAs4eSlzJKU1ktXv9MLThC4K0ZdlilOlsYhh3EfI +57ec3cqTRfK68gaSyIrEgR7nk4Qt3/iuP41E7JXqpoGVEWa6iJwEEAECAAYFAlbugeoACgkQ +ojBb36RRuhnPHwP+J75bR01YYeOPVJUP0kztwKkCWa2lQup8v85soYnH6QuqIEUTHaqlLnQi +nzU5NK+cBgWchoaGenw9xx/I+uaFE1l7jOeWzGXYOWXvEPj5A7xsMhFMKkEKip4uG6V9EAJX +aDdag/Qx0vQG/Uff6f7L4HepeY4Q/l1vv4HbylnpGa6InAQQAQIABgUCVu6B7QAKCRB3mVqF +64BMrPDmA/4iwJS6IhCYkqugWmpNCUOv4+sONb0uM5i9/lq40gooNkW6raDIIhxOc39zasNc +TGSqKHZKvx5w5vwzj8DNRZkjTpFAG8AgObe4op+tgCeZ6mnbpOZaKbYy0oIGehXPYIBn5n8g +LXMpV9JQdHVI5J9OuLFR2qgUobwckc9Ia+vNQ4icBBABAgAGBQJW7oHxAAoJEFe84HRIGpvy +KSoD/R2f5LIY3jB3OXzQXbwy8Bk0cd7AyWRWBqZjwzJqHi+nVub8sOiDvvb6kSj/9ARJo31H +VNI6Bsl1ucrvM7YzeO2b7G1uHiKG8y0yINYCNBqAauHWCicNeSIw4L9V0lPHcrXJsososrhM +NUm82rGvXSJ+mArKlxL8AWFL93jXF7uniJwEEAECAAYFAlbugfUACgkQh8fW05PZKR1ojgQA +wQlSNoXuzsTuqpBGeD+qkBsoA10XIF7vF7a2WsjEMArCgorVhrk9HjSknfbucDXiez0Wffcs +qaf1G7iGODp7+0kmdyghUoLbVyDi3tvkaEQlemY6HmBF9FiA37N4o4bMM4Af+35EIaVwCYZV +CJkmCJ8sUumo+3hEdp8E2VL5leWInAQQAQIABgUCVu6B+QAKCRB+QGYveQDXDJyUBACT8yON +21MufwQBPkirK6fbNpSWUcXqpYIyeXxzTyK0Y4ZTuERfdEvgB6FOYavCU7eStW3IM9biS00u ++Ls4Zh7ywU2kaiVybsw/Nyd8iI8NH24Z1GytaofYPldGJ6087rwKT/bAPkjKtHPdgEd9Ufrq +cWvWuzrMhggeodE5j4CUW4icBBABAgAGBQJW7oH9AAoJEMhssnWT3jc1HwkEALK6jZCXoEkr +kruloPJgImCSzIzbCR0tZAkkQ7JiK+b1wyrEItolpVI3oZ4Fz8izB/wj4+mYvEmo32OuDjy2 +tMryfNG/1u6j5pATkOEMDmThBfK0VAzLSq9dCuhh+eytF3Tk19PuxFThwyRYgFmSGQzBNIa7 +eZhSiuMMSRsKbd+BiJwEEAECAAYFAlbuggEACgkQPd8fYGjbvfd9xwQAvNFuwKt/SvJd4wdr +nJA9rbU9JVQUE+tw6VuNS8GeQtuuDcdLovgnHTDy6ulkTereHflpg3cbMWOrqtTATafjPBgT +0LDYWhwk5c+bzQsAg5q5UaEX8s1RzNGjltyivmwbIVUEtMv4f2UVcnPcpai/mhsO8AhGaX/0 +swxoKmbM5MOInAQQAQIABgUCVu6CBQAKCRCnKFFr5/V8bCjiA/9UhtWUaswAgIPzm8spR/DS +dVIFv03WXcuPqLWzqtsjroRma1hAuVokNvYI76SBjv8H3Qpb+qVbpO/Axyu39Je2B45ZbunP +KBNWWv2DtPFJoDbSQ9MpuY+ICQ2Sth7FG/FZBqpm2fHR4M9RyjmwN0sAmlpRRfsgyqHYasAL +PyZd4oicBBABAgAGBQJW7oIJAAoJEAurQRjjvDnhD+0EAImru5Ve1FE0huM69UTzgIsONVkY +X4sWehoRzPUowpH/ZlohkulircIYyR4b2zryZNmTOlLNnyJu3PXcde27JA0I1qgEhmBo7TMt +CUDTlisgaaFGg00MpH1ucBQUz2poAikBMM1Ho/OQ1gWx1QZV/Uckh0DqYfTyss4bqlRatDva +iJwEEAECAAYFAlbugg0ACgkQEwGZGcLlgC53dQP/fFeZyu+FcGBSSS9qJaA3p7DhpLl40FO0 +J9+pROb5cjAjTH5MIFe7bM22p8T3vZSYoyygAd9iC7fYoQGx2lP8nZezRIoUVJJKEsNZRlyK +WhYJpsW58Z2ACZWl9yZK7+uXAxnQW1rS384bBoslkXIsZtkg1pH8K7X4dvj0ALr/lZKInAQQ +AQIABgUCVu6CEQAKCRDk8p3uLFXlqAsxA/0TwDf7WHH3F/VvwmW+94SDrzDmRcrYm16+TbSJ +BVwGhG4tukuOmvze5jwKd3PQ24kNIbdEnhKuPO1OeHfGtxEwoSMIQcf2Dy/nZd+4qYy66Afb +B6tFgaTGs/aEKyK/HyFCksf//uDkYZT+Qc38kIU2MWp0Bon/xWvmCTEIXwSkm4icBBABAgAG +BQJW7oIVAAoJEJPng/I4+d8QWEYEAKMhixbeqADGNwpD8FyiTcj19qSvj3bhNWcw2AQXNwbY +VI+9cS4apEsNHeuLEqTO7S9XO+ba7om7mLdyu4HKWRiaWjpXWKDqQY5nRHfWXQNdfMQ+Ne1c +ztAioBZMP7ScK9jK66On49JpfQrwpMX01PFmaktMuM5PXDl0dfpgHe3/iJwEEAECAAYFAlbu +ghoACgkQHvoRjcRe4zo9AAQAt41LsdbDD8FMYM4nv5vxMPf1QoRCTH//tGcM+SwxL0ivJV8E +ZOBO01RmjgbmG0nnkt6RiDRsvtV3Rct2DUSeuj2CLpeGcZJPO5ybsrG1jp1jnZwsWy4rNDwc +UITn0tkBWa+Zw6MJtKzGawSOZo/1ABjhYjoO5zw2r3wcbUqPvQ+InAQQAQIABgUCVu6CHgAK +CRCRFEoNvMM8Ycu0BACrJWjjkpz/M/dgh3Mm9knEjHgbaZTr/poOYOBYtvlJ9EdFFnk023TA +7bCTk3/Nb6hGeMwC5LJrplAWHRTHz1VW3LoWH4qtU5oAtTjNp4yzjWqS/wFauGrxZWajjXej +cN9607YQddqCnV0Q/sTRzFGbyH/cGNvhxiST3vlxbFWOxoicBBABAgAGBQJW7oIiAAoJELBg +zVptSO0aLqwEALI/OIr2yeYXcQL0kfSZg+h+QfK6rdh1E/7z7LwpBRe+rTHc0tNHQUGEaG8Z +dChiFAo+wiRZ397SbiyngZXvqBHqDsaWN1y7+kKouS8TKt0Gqq+zqRRqv6qoE87jcMovnSZS +xw1QZ2T7ym65CHt62I/lJDOcQyATp/4xp74qdfBjiJwEEAECAAYFAlbugiYACgkQuhZL/4ki +jcMVCgP8DqO1J7pPUdidcDJZZu9IvTtYFxlDFTPRWGoCSS6iB0riehsFV7Y3lURI/Y7DAvkj +XIqE+MKLwdKnJLZScgkg31QxphVH0iZRCn84s9T3EagPHaynBLWzwnDZiPvyMj1RK4y19zLk +bOKMdRbORnBq84jJaKl6A5YvoqBCCZ9wYpaInAQQAQIABgUCVu6CKgAKCRDX7JbPUDipYVaV +A/9ZFq66jOw8x1x24esepNaGdOSf99/ETkIT9UnRqyD9IQQm9Z0OJCUEx91wfwO5vs+INO2P +BTUkHh/MAPpPNMD4viEMTmy/ZCxoY57oANNh/86qc8wQebkz3mNd9fpnzLx+jf8VSvpnE039 +VLef7DCipu/43E+q0iALx/bjEmU2eIicBBABAgAGBQJW7oIuAAoJEDgRE15fTQOOFfQD/RyW +tH38yfJbF6qyCldUlJVaDgKpypmd8huKauA8jiFkEtj8X1ATIHEDjsuNzBaOc3gbHuZA1UEQ +18l09LJaG6BDNYEEalGEnSbVG33+aitMtZASdF2uoC2rCNMs+vtnbEk7XCaMsYQSw9rcGsoN +YLUa6I6lRWTJ+JwnSmCuSpv2iJwEEAECAAYFAlbugjIACgkQEtS6vsndAmC31wP/e1ZVDrUx +jABMnzdzYvsek6aF1CUijhj2rhiLmkoOfVbBFRaE49WiAfCGokz7W79oWGL98M7fW0PfbL68 +VCN0pXutpkAU13iC6InGMxXlntpfNNRQVJi2cP+k7DV71YSphImVrAl62Ax7Bbn/CTYtCMcm +YRJ73kDqxVjmMlIX7ySInAQQAQIABgUCVu6CNgAKCRAVLwe3krv9CHcrA/wNCXNtfH31ZBRP +1K0I73W+2ueeaHATgovJtReoTWU5kevf0ZCc7iz6mdNXug3rrcKm8ZV8DAqmBiJbGaUokKy4 +BTAUytARzjVF7NKDE28T5LSv84QJa2Uv1ozluRfH3JoP6Y2mx8UzdB59PdjhZGJj4Q/5JOhq +defaB6h8dndb+oicBBABAgAGBQJW7oI6AAoJEMlVdDXNRGNLfA8D/A9VTT0LDN2SHrfDJ18+ +Nmf5fpPl7UwcccveRbuxqkuBhc0NCLlbS+VToflVXg+PN2yPZcd7ngpWJF1saA+Ik+x+N0Gn +Drlh8brF9MWP8+ptBlFkKHx1bn2mNILiPagX/AtgM/3igzr9eNiw+pCN2Ma2b51vdLNSmB29 +7Z+hsKXliJwEEAECAAYFAlbugj4ACgkQPdMkOhV+wi/0MwP+Nd916Y33YDY7BlUfHHb9Co2C +KkZuEMc64c5uDt5ifdSFHmK3LzSqD5dA4olLm8jdVOx+14hhxQGxvMePM9+0w76KAl+Ax1yc +Pfc4Vrcw2p8STxgvM3qwNTDaBXeovpZbbOw+2DxWceP7nibMQCI8JuvfJUaPvpW5HxuKwCkg +Ob+InAQQAQIABgUCVu6CQgAKCRAWC+7hg3o16kT4A/4vrCZDKeQ+Ke+FYk2W+I593ONnEZLu +R4trDJE5rz39K6A9rbyW9wkYHMaox6wFIbREB+qRpEY3IIIwdHCjUtmSMwZSCGQynW3jdaIP +wfd9ofUfm0a7Mj6zSNF1gQNE6LgXo1aohsg0OFZmfykAKPHzC2EhlNT0JizeYqYvGCBEM4ic +BBABAgAGBQJW7oJHAAoJEMu3YQcTH0FSdJMD+wYEMnzVO9vNcF/WSkyop+nchW7+hOPeiueV +a50OAT5dmKXDKvDwnkou4EVBoaCGF1GKvbzvCI6UTIGp7k8vO5UBcLglGUA8WBvC+BQRDmku +gjTj2jODJNl0AI4MdMRlq+3WIry4xPYkDQfKtPZJ48p7AG8Yh91Ws/0A4+xnlRaSiJwEEAEC +AAYFAlbugksACgkQw9004S0pFDHiEAQAidXJO9RJgKpD6YWjsuiozsbDg6wuQwnPbUtIDOCi +0XIR7Ch4PwNTFiwedjDQdfOK7xCJ0appeo0uRSjGBtzqzBAHBjMMajsy0g84rSzjoYGmyGF8 +Mgh3Jf3sXUgkjHM5KzEoiQ/kBwwjxud03Z6zNo7G+nJfQ4KjdCHuANFzYAWInAQQAQIABgUC +Vu6CTwAKCRDQuanRL631t+mWBACRUcVJR/7bPoAoDMuxQmP9pr+IfsD/MyKDit8UCMm9VHkb +hjBybhxTIHQZ1dRWq1JAk2/ImiUxM5OV6ep15/wGaob4S/pR0l1B1eUnbORsoYiZ3P2feF0d +gCOOJmN0iAONajNrDtN3ejs/US55QgYpRdiNYajFBuY6VgY+vDUaqIicBBABAgAGBQJW7oJT +AAoJEPvvdHVnVQY2aqcD/10zP2wvwYHZpqmvmEyJxcQ7C1+e9JnSWnVjpea84UKEy+MxQcaZ +m/BEX22YTWJb+1z8tGG3pXsjh0xUfbmA1ha1+H93p3CRgocG4qUXiOmdRXKut/C07kI6XEN9 +3AEX7W4lxgv8NGlUWYGO28BBI8D3H69x8lYY09Id+6ifDTV1iJwEEAECAAYFAlbuglcACgkQ +N/qG71UskVedhQQAppvvwPb7ar/pSlgUUdv2yxjiYKoejrCPilQmbUAUsaU1KOIXLTXny0Ja +Cu17Cf2iUOXkhD4phH1fTpql6Qv1e78+DbP7nULwalSwY4pALCz+jIg42bSqIJtbOXxVoReR +0fdTHo9iuE4tDy26w31xppaJfmLmA6xqkejI1ckcoGiInAQQAQIABgUCVu6CWwAKCRCukqHK +ry5HYOP0BACGQvj5gmdfu0Rz0qioy6Ctsfqts6VXZ1rZRk1i2zqWoMYxtPckGxpI9tp8Kt+U +RpgtpTt1sZz4NZMEbyJe4hdlgE0yG41+a6rFUSDx225o0daUlw4okCXHRGuOse7/PF/m4z6V +EhVTDACSoRquwR85JQ5KC8Ftnp1oL59q6WwZiYicBBABAgAGBQJW7oJfAAoJEM2PR38qDaII +t0UD/0fnj4RehiggLO6AHmz7CuSLX5VTJlFvIGy9C8ECrRmYxZyv2uMRttS567j+gxROgadt +fo0FEBcrjcMz/i2UUE2Bs1UhEcIyjCZ0vDlEwCeVI02iw5ISvBsd0BWiv4dAsOdKCGaqzM2x +RyZ1OheimOMDtRtcchkiByHPi/t/Hdj/iJwEEAECAAYFAlbugmMACgkQ2fFpb4CIySBQjQQA +q4wR/Rzc5/DUGy6AfHEeaxXKBsRqJ7XgVO8c7cqjokkKadAAM2b6CI1kfS++uiEP9mMb+ECQ +2p56qZB02QqaC9/xHrLX8SAmzTZjQUi6byaN02JsEQf5gev05eMLB6q6KxIvxVkImr3PZiUL +0ZNYYbD/mk+1L5fwRl8wcpZo5ECInAQQAQIABgUCVu6CZwAKCRBpJNYt7WVP/yVnA/9Jhru0 +jR7blqlReLEzuMOMoAcGI/7wopc7PGwBm/ydVJ5/T0c9sZEiis5wW4TVfXlB39L0k4AaQLIe +s7V6eB4Eri0hExBPpm4Cs9Kkfzer+ryRrm3OJ7glA+6k5eVt3rBnC1/xwOJBS3wH6UbVy2dr +SsJ/y+tLks32M19PF/sl64icBBABAgAGBQJW7oJrAAoJEPiUmxRjEJDlINEEAKKodwjxafDw +aCYmNA8nyofPZ/wOaoGPmrrWyhcAaEhB7xh2SdIEQlbTVKKDk++dbAiRixq/CTNy9SDob2Yl +enzBsDAoQCm2pAyBSUiO2PG3ucCx4ha7087paeqxt1XY5SXxz0NdJSg+qzCRli/0s7pjOtfU +r/9EqaSIkgNY6ApbiJwEEAECAAYFAlbugm8ACgkQE3bezjX9FgZ3OAP6Av9EjTWG3iLewqqu +J5UY4Nasmi2s+jnGy6HRafJkhTD8HelQcW4YTvMotnkjAsj4Y4IheUztxJXWq3EYTMc0SSru +l0ERUxG/SuQPD/NOAWDPZMo99JuOBzoTdEVE9NMGXCl8LXo+DrE86gtVKivquyA25DbUwO40 +SX57JIyaNfuInAQQAQIABgUCVu6CcwAKCRAe7t+RsATnFU5KA/9ppzHYwjGS3v7DVif4vqk2 +JKohT1SFOEW/+hqcPHDW0mI/xVDoFZ3x5PHvNJMnsgZ/EMxff2KTgDIHFObHnfZNgIPEhNeg +12k9qe0Jn8FKa1lD6peqKH+UXButHf19F5SlLtjJswLPKkgit+7A+j0lroylOnaZlGuNNgPq +HiN3WYicBBABAgAGBQJW7oJ4AAoJELfPR6VsPElwLj0D/i7xv9hJ27FAX26vmCiUC2Wzr0kH +mM4zqjY114QCDSCls0P6FZD4YHjJynl5lZs5p0VKRn5/6xjuhEwpXmtOdKjY/50VdKM/ofDh +nr4mWiFTfPi66k61BDF/g2wVzwQRGyL/mokV8Ye9qh1KFbzKbqAKkWMmdB/L1eBkRQ1wZTFI +iJwEEAECAAYFAlbugnwACgkQzKuFjbPLGxGCCgP9GsNftAnByl7nxrhIZjlRlm82NQuAy5+Q +JPfgmih+xJZpNuFEeZ8cAACwDdz9z8UrOonOcBTkLTLAXP56i/E2otr0ap6gszOwWWh44Vdp +8a/t0nxhtYuI28gmz1KvKU6apZPqhvhCwB94NmbJGyfijTw/BajU1i4Rirq/WGmCClmInAQQ +AQIABgUCVu6CgAAKCRD5NE57puHQAHqlA/9LL0MePOkHZPaX+qGh8+Ookbt7WNBkQua3VW3b +kiYCiAJEW728UIFMlES8e8QX/vdvUBpNxDX14L+UzJTy4xTsG7cUWO5/eWGH1kngJk6Rzpv/ ++7MtUP8fditZ7mKGOudC3MpMVGXTgYlBcWYQq2ygcUVpM/QOBljv9PKe9akWwoicBBABAgAG +BQJW7oKEAAoJEIdkw8m7hbCcOtED/i1XhsLuNNAZjyC3vahPLXJU1+G2n1xvc0/xC0wRLfCV +WbrSGEo9RO04YQtS6Fgf5Twtl46FDvXDd2Q1jDT9CqK7F140dgpPHSSYLIykzG1wvwaTD/cd +PIpn94Cx7/JOCYeODN9tHDXojyyhwhb7IxBQTs3jviUER3bL9JKlH+xyiJwEEAECAAYFAlbu +gogACgkQO0j0inSxpItGGAQAhemFjx8uAeJ1lUhVEjaAigJU+gPCRMiQlopY3nPThMq6QCkc +jWYj11grj7bVc1wpqqL9Cf9qhj/Ji0VNT1YsoZg5M7imbuuyUMD4+ahub9dZVDVtWmojlpMM +3Ng2yKnwxs80OzUX9RhfCMNpe3ZyLO9eDAnQvx/SE7dND3+MHb+InAQQAQIABgUCVu6CjAAK +CRAK9yb1pmblZUxgBACPbYIzUvtPsUJ5ON1KhfhcQvMYj8CNUO/pNvTyRXe1qdf84YcU3pRE +ebEltcL7bXf2tJ75Ls3a3/ouhanpUqmJSx6oiBk9TgIvcgnCVvUgEersNJxivgRHThtDPfbC +gIE1a0R5zAxvgFwuDNR83uxj/NUHCqQJ5lZdoW2a0g07gIicBBABAgAGBQJW7oKQAAoJEEih +L9XhuNVuDfMD/iTCFQGFX4xFTp5v9gpR5aolleRu5ziK8PbiawGoyjrDsvcat5f+Bh7QTy/I +ic5KaPiT752DuunnS1gxh4iZUiZrJET39i6m4aS6UNYNSvYiGEP9vRTlWRDYFkUN3lWq+/T2 +yHSe3PuMDEYVWBmoIOt9o0e1pOiOkjKXvwX8IePPiJwEEAECAAYFAlbugpUACgkQcO+eSMVg +elRjbQQAooF9RZfgPH7XdqOx5YnASAJvJ76IFB4ZO8IHSn7Xg4BLJ2vXHZn9Kof0NXB8CbaR +VHstNWCe/bp/Cwmu91jd5KrUYk4nptZ+ZjdLYFE/8uib9wz3EIT/MFBGK1X1Zc/rgWf2Ohzp +sYH7p0aX1G43fx375FJkEnJ/G1lA/PmbefKInAQQAQIABgUCVu6CmQAKCRDXb2BTG/fV2N0O +A/4h6q7KaDgspxlN3y60TbpWl1tGWusgUU9pt8Jp+yn3c9ksB11yo9vsD/PaLOwdBtmmAnPM +aorSrGteDVYkuDlEkxK+QD2oUw1XAQXl1CzJRGB4dGLcjIFsTzTlWNpQqT1iavpvKevMu6td +rvngYt2u3VzxuxIM/j0uUV97k1tdhYicBBABAgAGBQJW7oKeAAoJEK9dSX5A1JN4C8EEAJtE +Yc2x5QWJczTl3GPphuHyZ+Am2UOhmoek+8C4xTZn/+8YjY/4iveX8qXBycI9LXE6VWHrqBMT +XeeUjLNPVkOCrPdhE1KvMu4mqAJV2GYIHSFgOEJZAIJ6hgDjIelNIr+i/2ozHsVV0NTVs6ct +mapQ96l5OxtnW7Hn5ZLv1LD/iJwEEAECAAYFAlbugqIACgkQDO8APrA3dw7AyQP+IhuhzeO6 +mJhcA9DvFiatmB8BHd7uZ85LCa+Bwx4dcBkfclxxLTh/kPuDTHCE81HLSwUkyaIGqMKH5ZVA +Ya949J71Rpd0g5H+D8MYowFbHYi/zRPD306q9jsg1X5iWgTKzVVsURWCmuqkMG81wZLaHSaz +Kh35SxyINQeZEYkb9OiJARwEEAECAAYFAlSmhD8ACgkQrEbv5t5QCz50XwgArCXVnHHyHmAS +saxE2vfzAz4jHjSldft2YzG0SRTjuqUmVpM50IxwwszvhhOqSqxFeKk/iQZdR3Za3UkNg+um +F1Mv2ogxO4D31R5x1WKVpPJaD//QVK1THkv2O7/lqBZMi2qZiiBeQVkZNB6VV/cv5s6gKj3q +MeyXq53J2kkrER+tPsgT9iIhL1sd8M4fvxxXqOB+oBOaiNr5e30JqiIakH2yRUAjeklSETGd ++T768NGteG9opjt/SXRM9m9nu2SZufTlJ4i8bZ+1LSGoU3TFue7fUfVfF46bBvYET0WRXTvh +R/BdOT4kw5bdxeug61RCOQPB1cceFuPx/BXk/69/dIkBHAQQAQgABgUCVr4IyAAKCRCdL82+ +pj+WzyvIB/wK/VfOAqaOZWNzzuPEEsO067Hq1Aarb6O5cAjrouE9fjnUKoDt1V/AL5D4rez5 +KeAkJMZVyXju/lF0vxykv718pMhc84ZUop2SlmBCDPvy50qBEM/ZWA1OM86JN89rEZsQaK5o +D25/FCDywhsQkg2afjNPfboPw09bu6m91yG5KxMYT31qrZ0ZvHu424jxuqlZXef3L0KR0ZKV +LYTVM32oLvGM/aczLukehyqww/7sLZCyVXiij0IoBNGEZSVNgnCxG+LxgwIjUxhiA+4Ks+7s +x02i1RUyCEjRG7dgy2CdUud67qxv+748wqU0IQ9F212F0cmKM+epEpojiAjaqKyBiQEcBBAB +CgAGBQJWKjQMAAoJEHGMBwEAASKCMHkH/37n38OHzrPiAT/pRvYdYa58LIKGrpO2vNb60kHX +77H6L//KGVhg/FiRzpBnQjWdsCIHaqVntsVDRkUiGttZEBnXlnrWZ1s2rVLDmkRQdCVzdR8r +61GF0nC3Xo5d7CoyjS0f8kMs+UeK1FF3nr6ExiNB3KMdBEM0m4irRUmU11dtGCVoizTJqfCn +Lnj23RA8tB0JtNYaiejXnZjEJEIWm7hyN8j008rQEbTIH7D+f3JZved3ou0MKOZvCtqq9lO3 +ckASQAUZBeiubeA3lE+yKBKRB5ByUFn7bug+1KlahEFLkp9zQt7oLJUZDpeBdgNw9lqzPgNH +9wxi+WFG6kf8/WKJARwEEwECAAYFAlMzOuIACgkQA3Opy3d3Wvnq+gf/c9xQG9nNOiqf3xFU +CReZDRoHGs2WSQsR3XXIz69zi0ql5rWmkelV2o8jVb+5fqcygFm8S7s0K0HLAhXuIpFlzA3c +tZs5Zso3Yh/7S5SlE4d+mFaCj5LE+/xfXB3dp/i6AX1XL68KyWa9nRTQteGVLd8Y2ttmWzeW +p6EpXlLq+nCEZ8PBMlQLZUSG11sZJmy72W0oOOvjLXFZ8c8b0kB6Nlixtbn0KsIVkXkUeNoW +GsKt1VAy+Mcpl0vWuah+UAC7dutMygE4zT9doTKRUjE/9YfG6a/y1uoTXpjHSiQOBoLU9B0c +ollDpdOad02OtD9/ZS5IABlMZYC3eR2LLV+qFYkBIQQTAQgADAUCVgilPAWDB4YfgAAKCRDO +APZMwrXiqD1kB/YrutHiGw2LdTjyfVbRjh1xgN2dEPxIwRG3wYOUBOiLyierfOCU2brexUCf +jWmkWOgNBJhD2pqRAXcPBklPl9U/QSBCcxU7NMjNIUTTYIWcf6IwcgKC7cbZ3m0pBOc61zAg +Z+E8uCOUFv/TPJSq7XOClr6Ws0eqqO2zw3uSzZcOehoVO+KKn4/oMu855nKgVZz+qriauAiM +KzAuLXWPaYm6AHMf3PxBlikUVTNRp+VGlRb/jFw+6Z4h4RxduhuP5rIq6sRhr942Xkq9Y6HO +/EbhqZT8YOD60j/ThYNfSXXNGmLPEB31e9xXra+UnHJAhwGRSU3H9Bn9K3s83z84qcaJAZwE +EAEIAAYFAlX1d/sACgkQIjrgVb2U4VTZXQv/f/6xOebbHCpp0HBex54BbKYjZTa1mpqxQnpk +xTs5ng1RCD4m092w69IKExDw3UZX8sVYohJyPSL9I7jE101KSPEOLVEut9ctKjNDBWMyJY3X +ojYG/BPeTR1HUnVlgZDwQaBSw+RgCb+qX8/FsbiOMsniN/+yYDDBAmCxo3J3qu2EOPoJh/yd +Ew3bW0V7yjsb+K9Hunghzgpv3p8+rNSySdbmuLgErNDxEbcr3yTwiEfUafz41Y5Z7aiKkr1I +lr4X22ZjqX89tl8W0Szdeu5NtKoWaMx2om72U1ZYMhP1SOomBm93uouv3mjbFwj/8JAoGSD+ +C0Ug45v1XmOKbBkKZKqcOgN5/Rm4sgiCSBeBQRZi4tYZiHIT34qBUF0RWyQNw/nEdo35HuH2 +TAcTI5PxAmIo49zEvEWA8raFXck3kuFX5/IrLDPJtcHXpEuXHLAuh4MDO2ZmGbkLfc7+neAg +ItgY4H83i2kit7Y4af6m+vSjtwVj5PjMMl8JpByp0TK/iQIcBBABAgAGBQJThHkiAAoJECx8 +MUbBoAEhGFgP/RYcpOgRrjjIULoGNctkYaQC/2B13vNEh87VdDTq5CzhPBYUGCj5vgp56twU +dwmYUIMLkMfTHMlkc27VKPZfOLBAHfuQsd6f5fm985vhZl5ZVZmd0w39UGGLHWL8Kw/hDGJp +YEbstXKqpo6ZYJSbFX7UWCVVGIzJhfZpg6A5BmahDdix07Gsc+UkikDW4vdfD8z+oT0bCzJA +5JQ8uAa9lhTCliBkmX/ahnO/1BEzSI7Zr7+7djSec42cA0Z8zSlAkoxCdXxQ4pwGJoNRSxpH ++GjSnRzMZQL45NVE30Mgzec6/TX01+Z14CRDnBoQ7Hgaqw0UtLUwPyhmLcibUaG0MPummSl6 +5jLReZ3FLlkFIsYRSd19IDfWzBVB4PCIbB3k7/u32p4wBbf/fqhBfkwRWscJ+ZM4sfh46E/e +CFJyBmd94gPB/DdeKP3r2STH0YMdv+2Oozu3zMmR2ViikRQkF0KnrD6C01/4uFdIIuh0H7It +uUniS39qGvH9No+wSRO3O3x/BJZVQ8Ii+j++OjtDZIJuPP3849BIlUEq1u2R51B8p3a68V1u +UEJc7o/0FSO24Ew83lglKL4up8qF5uCrFSfoehJTMO0DmClWovPZKm1k85q70UHzWJJmabdc +qbkt0T8oaSXU9Jq9m74A0EV32mUQWismoiVUOLTiVt6PY6bjiQIcBBABAgAGBQJTidJ1AAoJ +EK0JIAgRoKr0wucP/j4y3fT75XMd1mVquZwkSL94DO/jEweBsJLCXcLxYcSPfJhJrgJjPOh+ +xIHyIi8g7In8sr4awQKFIPmtmeyopYxBEUX9NNyIOt0oo5GGdbmB0Y34/05sdC25c7/qdV2S +KhI8mBtjZWulHiKULo+1GjpK/mJxAi6teYFP+qLMsCtnFzn2nbDMn0lRGyWif1Q++yEoePa2 +lVdGC5RWjGBkI5uMlspgUMl9SssNgxbF1wkWvv3AChqMmUTXhGw/cQMiH0gwAi2IfYhKQ6qo +BADjIC+WeqSP8BhQX2PfsXg2vm/tCXj0Mgma9g6/wgra+HwY1lJqVas7SsE37mtWUMAK1JAA +Y9ChDkW012Ge+fXCAnAAEzjvUNy5+GHs3o4WqSLNpSQO97Nf8WCKL6D4dPLhaeRGNaPrsxP6 +47Uune+TtGsdX9i2PZnK1yvvQJRrrhVuISL/xeXN9eulDDuKnosSFMkAyj7VF/DFWQLpC7Dx +S5aJtAJK8QzQS5CzjSV8KhbAvpGUsXOVRSVAGtp/Fc6nVDUBOjHv62QZoZwhYKSvIBI6/38E +bW8d90GdbaLtl2XQ9KkaTYEwZeFTBCExU3mi6/OhMWjnyBtrxKbceD6Lu4hfQ/zsTR9nzmmr +fOHtmf3ECONXRv43sHy+AT9r/7rfthKduXUKfiN3LWQD2RXTuY0wiQIcBBABAgAGBQJUzqU8 +AAoJEC1BaJ1RnLQBuwMP/jWmjuMphrRYyFIoCgxGrfbrZQg5jAibmip/0dL7DQ7W/Tw3GPVe +qllhydzWVR6tPPl1cxXaINp5LkFSPL6/UnnQBWMALeOuuRe2yffHD8gfLF1d9w/wN+bkUI6J +HrzMwqIF//pXRtD4LvuTLCFLTqPS6ww+5s21bZnVyv6MD7+lf6d1d1zWXuzyVXDin15xw3Hc +TiGt9XiyrcNeNVRPpxi7FNBoh28uuMkN2nS05U785w3KLNKgBLpv9Ry04skWMd0tvFIHRU8A +/lXdBG9zvvNeEj1jMIoAcK784AW7HlRnF1X9wZTfkKm4BgytxS3A5rgYQNoDz1w4Ow7KKHV/ +b+z815NQ4+qBoTbSRU+JMCaf4j93hhHFA7iUyC6B31NrAbSpb7tszDPFHeA/XwQAxc+3unyV +6bRZgvR5nMTFxj4EDWVtR+Pi/cAvllzy9g/hwfXFeUaYFpNcKe2HOOs9M4q+rdTA2CBM6nR/ +BJ1DC1bcIN++WLNH/F1mkLG6+bvyeJRjmxN0y11pzO1ffecEBOkg87jBkntSB7K/ZlPKpaHB +EjlKNTGjcl8+V6sBt5r4O/gl2kZNPyNU9WyzSZnO4YynaA4nLVSszIn4I65NWnOq8bOIbtD1 +Q+N9ABp7AqzkNlRv6g0TKOZf0z1UudvBbUW0/m5Oc/AmV4VEaqqqdgLBiQIcBBABAgAGBQJV +0biUAAoJEJe6nOdhoJY7LQ4P/37H9TqSzXHBOziQ79k8p5HRdxumYBlcgy5P5hQVwASpv4hO +OZYYbnTtBVOY3cKY9SJ4o0tReKuaTcOPF9ABCGJq+pA8P37PBkC31RfIk799jamGcNbUKg1I +l9YI2fnPDTJKyR8x5Zm5n8ulKFICLOxBtI0bgK+5upZY9WSwTTWGPM2DGmJijCgeu7jhsf22 +XUowCWuoMUzXP7Jp3FXOC/g0CF4Mglu+8yRE4jLqeJNkkveVoBYhVI2Ty8w6FvGeleeVl4yr +kExpEk9xIk0fXc4sFAfu9eUNBtm/uj/wZYPcxp4dXPuCM7vD6nMZJsrD7dlxzN4tpOToDaQn +pwkbm+wtjlly9clQrOF5z3foChFFqysBIPf4hIPc9nRyi7w5LZqvnjQ6AkesbmDaS5v3Z54X +ESuwJJlepGOTAonHQLydwpxpPxDwyDu9xBdj/fHD7y8WQoEBvlfFfCUxSCkRaRjZJN0+C+7C +wrDqMDjt8klI46/SsoJOTmkjh4G8yNtjuv/WXpotl2JKvA7iXbQIhImr9Ep+wkE/x3FQYdRR +d86oieVWJZi5BwmAnI+CD5aXSmAPn+DCAMF7s7cRZX0vdVc02tv2YRZzvw11XmOaEjqW1va1 +8VLU6YxXEVH0sIFde4zX6ddWwJlg6Joxv0xqT1dTzPhWDJlotv7gSzLKH7qCiQIcBBABAgAG +BQJV1cVkAAoJEF7nbuICFtKlWWoP/2elx72GT1fbdeL7+8ePhzIx13cSFI3vEC8/QFyDEn/g +y3Xi4ZZ9up7nggcq+QbLNd7Zlm4+P0CWOKLnaxw8L4m4Y4JH/XeoA7itbnN2TMC9F+AnQkfg +MdclkBMy77JqWJwzh1aueY4Xa3sBgzuC2AosvEDtXsTYRrwRUpVUCBKM5MrvWLPEv6TSxCEg +h0bzQbbxpi6trmP7lpFtU8jIRDIqRmAzNTGxHOctEKHLSepY2S8wOUyaxca+KX7aBv/eh5j6 +lxcwOJEIf+JctxeIWRDno5o3Zb8WPDxjBOfzuon97A9HjSx6+0IhLED3yvotgptbRZtZGmIP +ZFRoYjG1U1d8A26ZiHj3QtKWq0mRL1NPG1rB10senEmWQyZVF9H5nH2wMNi/RcxMuK8nLgl/ +42xLIuddIYM9kU+zKSpiU+Kh6tYphcd1S+4dpJSYyrt09qeZFeD9ClPwnqwVAd5vj4YO9b3U +JNQ3Zvmnqp9sTprt9wH5X0xiEBQd0WIVZAMJ6gKHr0ry1c7kuHU6k/9KOD8fqK4cgU5WTKdP +agtPw1vs2XMOKItrhMf+BGTLNhn3+Hofzy7/Uzt3noR/KgHo0DdGOikNAhxuQcw8C1oYWwzN +kkeDePnGPkh8NGhRPpwll9mkVI13JHrbauutVpjJCeC0nYdTtxdJ5SnYyeJTkWQoiQIcBBAB +AgAGBQJV10khAAoJENmtFLlRO1HklOQQANIq3sJrIbGpMg1Amg6+jSfRy/SpJGoeetLWMOc7 +p8rcIlU8XWTcbCWE4DfrVm2jLQmqNhT+AS7CZmPZ32yBUJjOodEl0EVj5nZDOpZ6h38nvFwf +VMOIdKS4q/XIZOtSMac3Rg7Mq4B7s0N5BOMuQ7uptVWpYDEbOS+jqEcDMAGy4rmwpDpf3G2R +HhWRpVh+1SDe+i6CxKbyBvd5nJFzFwpTVcZlndqcn67BW8BbsCcfOPCoOZNH7+Bec0bpWWtq +AhigLM4Hk75+GNAHrbD2DCFMjIxmy5N5qtU/oAxPrVOYOf9rrgfj+2J0whbV2SaimZ8qE8k4 +qYmgPSdjiqExEbWXVoZ9aq8JmeWZQ10Lgpu5QqUqFsrC+sbOe1H6v88iG3+eQgG1i9K+oQFe +/hC8yDumz7EulfAnuM5oRJ/oeyDaHIMob+X6ezpj5OoqIEylceuFv6Rs1jKaxEW30aAAec8W +6OapP0IURUNaYRSoKNDXWK/gHMu1wu011ka8LP5HE/08kF3Si8bQXsI4Ypx8WxTScikOE4++ +GyamVR0yEaxH4e+u3DbpxK2vD+NDCZIKN4Oq/MbtacyFF5w4v8y3HwlNABMH3FZXJ6Kt2OKr ++wLRCZOkh+q+VraPp6BQCQR9g33Wv9KvuUZBtpL+0yVj8XWeWD7P0arrFhHz9p6lGoawiQIc +BBABAgAGBQJV2wETAAoJENfTQC4BBmMMOPUP/33Sy1uVepOsN59v21QarcLinDDfh9f4dumD +eEiMnk6bCeksLHgeCH++OqT5iqty8fvIsy+B11hjvsxrrUP7Sge7i/xTYAJI+V3KlnUl7blk +5DuAErfyKagBD5IFwOorCjqWTEmxnAEZ7/LJapCTVhhAPnaOZf71osSfczUwmqQcimPKF4xe +bXcxALQXPxFkScXDcwLfAzbEKv6tmmvML+aljyqawm8KV2BFirsXXWZAz3PgIUFBmh1m7aAB +ESMmXFrg12W+0gFEqzyyL5YNe9KrHY3k1wVBD/xXowHtCTIDRSvRWbI8+Z1bC55wNFoNkDx2 +opNnqArm0i+2/vk6IHtzLNVoz9QOtntbHy0KC3ljPyHZuhsXIVPu9EtmdLoDDTwfGMwgoLVk +6IaJPxSJGhkYGCXX9JmpuOZtN6o6RpExyvyBpKaRaxLGrBLrAjP/t+Dliafr0U1hm8S5j4y6 +/4fR6CNn2vbGRySMhB735T/hV54bQ29fVRX9Y3VEH/5BbWzrRv1o1CpueQgxgDj3z/C6NVm1 +zQVgY0YYRtaI1nmXY6oBUvE4rg93411U68wI3wG0w5NMaj1T7nWz7aDj2cwZmjOYWU5rZhaA +zrAxP6/3e/gyf3z9zwlPhlx25pON5CM9GPMz5PEs+YHk3y+KelVTb3fWgW+gfMERWbkNLHBq +iQIcBBABAgAGBQJV42HTAAoJEIPn6maaGcuUoIwP/3nbtk5M3Dqw8f3hgukHcDgoeslwCWOI +OFjV6WzqDZxxYjbj/y6Qm+U3wJftZU+Qd+d1kM0AZIngJtNFRjVtVmrwwkWFeG2ZURhIZM/W +vkBX5DBOXUCYKHaALZv1nT6eaJTk9+fJ7QQjXGDXzOKiQCbxAOm3HYvoPP0a9akANUORqCtr +sNd0EYolvbLFWVUW1mjzBGPu0xXcn4sHaEdgR1RmsewtP2CHz3xq08muCEqC8lAzhJ0WTRIQ +uQdbt4JZaVz2PP9l2kuB9Mu54/M8LS1VUBnixCfLrGe+QRMbqPVng0hlVA19/RK8TLvH3zWX +7hE7NXCicLvyEaPP2C+fxejEY3od7QW0aTiud5d278kiiJIMhSkmvnEt5g3PZdnSNGIitxsX +P97Nh6hxn6rUORKUheLh8huCgLmd6XaoxuqUVHSzH06HJn9Uoz5D13Vg0H/Yv5TzT+Bdu8Ve +vzR5hIMR3BfhouOo/zeH/IISLzefKBSTPOk3f8gOiH+1xCrtCmLYBleMXVbUjMvsy3xFjX4v +s0chYnjPW8upsOpBX0cLfZ/U/woRh0ElC4UiScfT7p4z999vepp15fVNlSJ1+pUjsm+IT82c +zxQSq64QcSyjVjwuXjBA/+/c8+YwypaBUwLrG9WKYpReUkAAJWVjxlfAEzMcTU4hXGPwbWlV +wU/ZiQIcBBABCAAGBQJS79+8AAoJEAt/i2Dj7frjhgwP/RY8dfwTy6H+3ourlBs+l1+MmEeE +d0LmJNY21sIljoUiWR3SujkTvsiVwg7+uSxoRtniC1TZZ95Vr1JhZUCa8EPkaXnYZV0m3irE +k3hx01ZleL6KcgxJghWSlvba0s5TBugODzPe+D6LGaxNcX7lbwlwyS41Kbbn48FETBG+IQ/U +eJDWmZT6UZF53dJ+VhjJy7v1bv/g44SiXqlq7GuqV+0QCWzjXrDwsxE6m8B1l90kkBuQYjY5 +Z1nDpmUljeYfx1vlebkVxt3NgQQMzRSI+wZKbQE2g+q9a2x8hykdo6L0kURQOSUiF5wtdmzU +VylDL5xBkl2ncL/HQhKmiyEEbVyutPqjCJpvQaXTUngl/a396SKRIOpd9lkbQFKTHmBHviCp +SdGQYzBK384MwouyHQdAyh2RDatr8fAViSyEjYhT7fg7t4CyNExXT+oFE++ERGZi61D2eEwf +UQj6fpDK/55io0xLTEP1XqauGgbFwTLK0zFlXkshb87lcfbbflEsOXucMaLAXcq9PS/6NA69 +HULJj8CnHfoo6r6p5sQoXX2WMnksJ1Caz3913VRBZQJ44vplV3Zb2TjJ1lj/ULblmwYSFset +dKoA7urESP/93E+FNnvIUhfjV/pd6L1eakB5qCV2pb9mIJK2Iu4XT0TmGZJOgLI/dsUbUabQ +76snpMyaiQIcBBABCAAGBQJVEFDAAAoJEMfjV8s1Xuv9H90QAJi90HcM2L91pEUuy3vcVfGC +jpPw14zHV/blwt9sU6UU4j9EKTk/J+/LeXFw4JghniOnEZQdTdZW8WPdNJ+ndfSzvoH3gFk0 +848OB6V+hwlDZ8OQSr1JtbJtGSC3TUCiUY+ysyvCnfM8k50z/oRNpgKSHPEV1a9SEzkZaZtJ +bb4pI4JsF69/Z66HajuXkJLCV9lTwqevxNLrch/qVrd2X9dJPbUxG8W9S9s91bDv6pfncel4 +2gzmxKZwB+V6Wz/C36TCL3AHKYNMB8po4qP3t8FKR4gVAGbLc2/Gmf+UhN4c+u2bENgQxXna +6szyas+6qgkNgXCnHyYYDmqxoyIkufZKPZpTQ0iYZBABa1F34aSyi13aqAX9SvVpbcRjC5V8 +hMEgyB73nM3OKIihPONpx45MrpxhB6VopWtrzvbxxoZdm6z8h7H7ZSWkTzxywPJJ0M4yB+9T +/u4x+UCbP2C3J+gjEFNjrEVgKoTTXsXJMS08mEvsCKaVlVtmOhH1D8++KHTHqOJ9sMasO2JU +hSWYKy8LahboRlhPj2x12henljnwInJxCs7YFneNJ2pMqHNnmIUlgkcLill7IPDLXSwrcZPF +1dhEP0mbYnSTCGgOC5IYbjlgHySJQiDYPmMIns0kdebvbcZQYou80jqRxRdDb9i/9bwVG/x8 +3gbVeMqcPlrZiQIcBBABCAAGBQJV0zY3AAoJEJwxUDxthmOWMh4P/3SzlcpM1ryCjrnqR7hR +IO8VJLLU3eX7X3tzL0jO23OElnLh8yu5fMtCua901Gb50kV0Q6mGoJDDzZLfwuE8smGcpuQz +2LlYYki/nZuFpB5qDl1KrKet3ggTSO3PwYJG5vHY3Sxl7TM1mFFSgD/K2WjarHBe/lPvX/nk +pRZp8h+4SEq3LVtQP11SUT8yIUBdwTQJU2OlD3fnnzoDnNWwuQc9ddYlPXFm4nFBjQ1o9CLm +C4pk1Sbg2sVfpnWLRsORnz9hYgEjBRrzLxetQMuaM6ve0sMaUzCYgE+wXWiTMWzDBMKA/Jts +avxEn0IQuk8WKCBesEuO7o1g8C60YDnsmCe68Apsugtz0EaZVqwT7oOvgSt2C1ECSIfqG1et +yGc9/DWLuiutEOGCflE5TzKeoUpHw5ywbmx0njgloeFK3XUb0PoK1Pk9T+E/ICVOZjdAs1PG +NP93UtldQfa5Pr8th3EQkrCQgjuBhniI3Z+o/5sDObZXLmCIf4JKplh24VzpBnVcwcockDFH +yKgRpb3NOHf3rjT8M9aRc9RFtFSf9Eo0Zb3wDRvLcll5UtmgkPNFTMpcv9G+FfD1NP/DVPHG +slk6paGNkNxG62z3OZFvqCr9jZ/C2v+MUTJwcbnddLZn6OdXJThbmzzX7hW6UAB9wqYIwFy1 +S5eb1lFxaEfJIVJ8iQIcBBABCAAGBQJV1KuhAAoJEExaa6sS0qeu0bcP/A8+daD5gCJnctKK +WML7On6L6/IshJcTUjj+aCN3r8eKMnITjik2fLg2nUFa0XIR5hnPpge/QuC/V66RDKSGhKJT +rsh+Dvn4UCl0rKnYQc1CEfHT0DHPC/J5ccnQdC11cEtGgHjDnJw2xVCC18IDXwNepef9yNsN +BA5ryAva0F/XJy+6rpdUxsgu7g9SwJe6u6dy5IMk/vx3zWhWJfDhTX6PJjjBoPXUznrh+kGe +vuJ44bqFbo8G1YuhKIJQD87f1LO3DyV6nN+HQl45b5Cp9+ucH6Al9mFAR2OCDHPlDTSUHiJY +Ihg9pBdlDeU17dlK7LOaskiAKH9lHVziyc4xpVjEA5dTG3htgCNSFGBNYeAYDXIqnl/NAh8b +KtySVB/DWB5hgzRrjD1HWUrBYllRsqYnTUFe53Zn67/+JkwgtYp8cZ63cFEraCQx1PrpNl4q +sybyDzPdxJp1SecPQocA/6Y5Kdal6PQnOrnnPBJBtfRzaKP0KTOMiUbUMMITbKGHsKu2wSYE +1pseh7gyRrNXiPKCHseQtZTMY9z91l0wH89q37gFlwWoo4kvdt7Vxx/H5lmrSOe9+rfPj0ld +pnpCCI7wzQT1KOb6oPBuAXX7Q+Q/f9j+OS57OV87yIVjXVi+2YvQ1LTQLJ0hxntEcR10/h7o +2PYYydT9M+zVBlTc2JZjiQIcBBABCAAGBQJV3hUgAAoJEGl0DlyzX+w8EjMQAINNIE/wnx7J +hva/JUGunHTsN2jEsj05SUdecIoxYGNnElmyGB66XqFRbPKoZJ+oF6onf7pZTNAWsO91QBWD +WYg7QCgg5aH1JAexbr3fR8CQm9JW2Km8Y+5lUJ0PQzMCgiSiQF6na3HMSzSj4N9fQqa1W3wc +P0Pa7gPhOGVwv9xSbOJ5LlzenNW1oGltfohaYdNUdXPA58ywbNz8r5SCLRfBHke2Po+qEHlw +xOtdr925dmFRD94BzpIB0f176q3bSZ+ybef5lZHV9AxAp2ANaMy/Lz0bVSGQpI7LExlf3KaR +SX4NwOjukmp89bGIGQetX3GMvSYkepSVs4p9dNVR9YykUu9wAucbmnjIfa2VWLn/JUCRfzjt +n0yW7Vwc15qx3jgIHcbqXRxBKrMEBSkP176gnAjeslKKFzZIifO8g/1FgSLHmXbIYGAsCedb +7IHt6J9Q/Zk1QhvcQpV0UeREF3wtWDw0KU54RRe8loGWF0vrzB6IKDDE6Kd621GW7aX+s1JD +gfku8lOEJ9WNGTYNc6ZMFfAj+BmoMG3jJDKHeQ9RNGLiR2nVnOIbw6410LSpOWzxin8c2GPa +Mq3GduPWvgtJLq79577Xq3+IXxLngWtspEIhx8HA4TwSvZQWUADFTEj8jiiOymK0ozJb1EAW +ALxDGVzp/UjLhODC1fW4r/pEiQIcBBABCAAGBQJV9XhkAAoJEHCm3RXb2qxWC1cQAJ/yjwfZ +8BNFKCUUHRuSwsaQtN32Kl8hBwJqkW6wnAGLPsD+CI5NhQ6QBDV2AvqH91WXP10RyAaHvfAL +bWrz4vM1gW6f+FplsN/gFT/LS7G0nfUOhReMJjTIFQpWYcXt93IVbn1joStMIavWreSEDnFO +PpHqcGqGMV4KKmdpDkCo3FChWNT73A1j3ISqzY74+Ibl+mdqCtX1XFUo63nWCZrfuamflV8V +34VCZZqCEA1Wy6UTtvR3a0pTIZGMK+Ta7fAkxMopSAs/6WKRKmJetQjd1stqSf5zqvpx/k3A +E0qrBiTeSEtrBYoi7+EHnPUMpaNKJjMfyl5nlDRMxddlY0UJHiJ6PnBAmqrME50Fz/IwIoiI +xgOc2LSY+lEqf8q6KozasKHiquhJlU54iabZbYNXtxtJBa33K6Il3IFZ3Pnw6qwyNvY4aDVL +AKendZBl2gdnUNibPbpB+XRP6DBsV6HU8ZObw00FaCoBa5TC9CylDch/Gn/4KcrYRX5ln/7E +oSanyMOXrnltk8UPlRFodUxcAq95o2O4RMG3UGFTkl8Waa80mJLcsElzMLHx1ov203IHhLxS +pFRo8Rs+CFd8h2uWZAs28uYgx1vHiz4BOPa5wY82upLlX/85olZad22xYbgE1INlYD8o4Gvl +YgknTT91ED1lvejZFkLg4d3kAElSiQIcBBABCAAGBQJWXrVzAAoJEAeizD58w2wv9jwQANRV +lD9cmLWaxVgDmTeLOSzxxeQMCX9R04hOkg6Vc//3MZKe5k18Kn2ET5RPAyf/rmdKWYiCVoM8 +0GYb5bWcfNqUopKP9WHAs6+XzeICzFk30UhecSfFwVwstXgmHZf5K39aRzRZBuqgecAvkmND +/RrSN6AnmUi1B59OoC6xJZ36DE5wnMEGDQFRQLM3HpUL+2AoRkHDJOPhuV6RXuqB8+1Svj9s +hs2Mkc2hRzgvWef6GcketBSJBvI38oQ7nswt0cqavtl0IrVYRDzVANsHop20ZSZLxUKPhvZY +GBXF4pAgV3Lv8PQDwsw/+cDllU083cxt/iBCqx4kZXKrs5cUE/jVhdEMNVmdZ5tDQktRRMvg +0SJheU6TDRTnVpSwccnznsU8tnxoFwv/Cj6v7jhhzk1WN54ZOyUFyJY2fYVyUw/NlTeOai1i +YcQ0zrAm7YYeB0YG50ax07U4yP0hKDgoOVShoyw0378U1oYWJGS/iNvsldxiZhzwnQay59FC +nc+WrjmWCBOzH0isK7aDasT/fMaZ5xdO0xC3HNpDXKlEmDkFrFw1WJ250Ay8pCNTkMd6WMhi +Fw1FvDcrv6d2LF+1NJt+m4uSPhjVsVUxdeJL0hkg3pMy5cL/EmO+roSV7iBiqXzJcUsHVw83 +Y/JNjUJqedPC2sdtViX2j+AWC1mO8DXtiQIcBBABCAAGBQJWhrVoAAoJEGo6ELMcEJUX6qQP +/24pgL9h5/szLA1rL4sPBnfWWWJz+pgqcWtMzVhGtrdcej9/iJ3pLosCLgvS1XZwu4W4GiX/ +M/tgs7lPJ8gGfPMa7PiEkLUwen7HbZG92r2Z+S+lStpsaKE10ZQHGyteEjKHjgitXAiEIf3F +mthsVjFuwpdONz90jlddIRs80K3ddezDMUMdzM1moioataGy6lVdtP0M7kXTULMvUja3exvo +AbLJmIdWwPmxW0Di2Oas/SvD4GbOfzwOTptcwLrHSFEehDins+ztAgvFeUhpphrszIMctiuK +e632V/6XrGWZVoYOwuITgLDhmgWsknX7cU3rCsuI3LTG1fr22Gep2or5J8HQjc3U/2J35uyJ +tTrKZfP81gyjdfL+a6ebiY5Yxp434KJQVPb5mLzK5dKsCfy6KggBrFOQh5JNanHXd75/+xUR +KEH0NjwTcReczzf1GcCNNB+UYOad8d/RjRv8hSPZ+x2xr4n9aO+T0w0sZ2sUcYUTDXji/YmL +86Xg6j/nJs3965yyfRWujAi1qY2JakLNZcI2kTr4oCIQLQxYJwm3snysSZZor3qUTeKSlRml +BEEWTqgnkz0httxCQa5GQX3Sv/fvC5pc7BFG1cxzUkuoimc9HdyMubj3ringsLT+7iNuFm2X +BflD79+cL7X6r98yk5SOYFBtWBtVidEDoo/NiQIcBBABCAAGBQJXuHq7AAoJEHAJ/+fDsczT +dOQP/j+K+uNFeLo/6BosfNI8S4bUB2TxwnjdtZWouk+SNYveWf4MvkYeiPerh0zqlh7op3hw +ipc5+57G0Kj/Ip/7sWEhs2yzUp5HuXdcNlyyMU7tzBy5za/y8X7b37enr6LKsU0Sft/3LRLf +a87DMbxVocn1GkGW4s6MKDAcrUyj0SZWkmo4+Ks5d5cEwPo5n2+hXhZIvh3wokeg5wWX6SSH +9qaXTmhBhdsBuhUj9bcy/wZx4SYrp7J399lnn1toGbt8M8G9mt7H+F7CUb3MiXFnkA5H7ESX +g2CNk2f7zMHu3KiUbKlNd/30jVjXZUo4Y4fjCv1mcDkAwl1+xesyPe+7A+1yHpeMU56HCOEP +IR+rym5n23/i4FrQ0NIyWtZuZnPuPKQBtZ5VK3Ge4N3g2BBlnDPznVXtU+ww9djeA85y1hjo +i7pVWEvlxltetbJYDl+5DMqhn9+7LNM9VbFCXn636HmosPgwjOF+wU9mV5Z7Z2cmvKflaI5Z +aVuN9qQLTazz8DT8MqJUa86oJ6dZMZD1JhbAJj/2QckZ/WbvUjTcQLDDVG9U7um4+29QFq5g +Put39tpYZ3JvdX0sNzoXLIdXmSThNP4lX2hROZGfPcgKsgmv9Cv2ql8hzyTHKxDzYvpQ7WvW +Tds8SiSxk5MxwJQ29i2E8dhksQfHiUyuANbrAOaPiQIcBBABCgAGBQJVNT80AAoJEBU/45iC +HIOUGOQQAIfqQ2jf/ZRW06donZbBgKpLfl8d2iqDS/Ro3okqx3HXFNPodMI8m2ix+Yr4r85F +IlGGGewhv9A1CBvp5fuKK2QAvG4YEk8bHD5+AaDDdyUUkkqfwvZ9lMJsWAKCm+et+wGiLGNi +FpxGsdMp734wXcx0EwtoNWfwa2HL1fu88TAxWcgSrxYEziXn+3VtyYvwoSHYX7sMXV8u4vaf +LBH5LHbsoZZ3OT3GCSrAa/iC52PMcA4ywPFYLMpYHUA27Xfv9B+a0yrAwheKnnZxS2nT9VYS +7NrPlG+B3F5MDz7xwg5iumAugRtsJbfc+hfvMojNayJRpXF8ahp2RzwHi9X2HPsIvLzLTZmO +HuUV7nYINX7P0tsvjfZS0ORTBMplXaFHvDBDyyxGJnLsM0aQYUg+tLZvRwJ/c9WbkEOJtRj0 +B93qgVkc6gmuWIUcIsJ860v3zdx4zysZQ7F4naqE8q1aEO8JE1EwBod8kV/fkSeH5w9hXc/d +0mQegQge1R0iDuvwDkOXTqoPyhCcnaz/eU4EHgruQeuFhZSUHnvtI1EwD5QH6y/0sxuCvSTl ++SshGhphvXthsXKuQMAbGgKdefpJ/kHBprWZc0LVQGo4ZMpjKSOUfmiz7dQD7fu2Nf7phy74 +qbwUtF+6XcUATSVC8iXBB9hhBKgPMJIo+gRyK5fUygv8iQIcBBABCgAGBQJVNiA6AAoJEJLG +p4saT4gztaQQAJJ9Iz+xX/S+VdY0bgfEL/w93Gw2e4gzQRy4TMWWFkO0QWCjU9+j80+cPMjB +Ji/IR0+IXv4c6yFXOxlIHVagwfpKjCV67pzIi0KUkYhScCgQV1NkS1dFTHS1/jngxgPJzWZb +Lr+ie43NTZ/mQ9DTQbezkKbMMeiVfAbNQ0HRUeuVBDgHuMGc/GBmQWphUxJs8rkJrkQwHgVo +6KSt2nev90MMlKUool+b8TRrLe6gnnrkVYw1Si5kKdoNbKLU92Dw7YwyKl/Njgf+Ja5MdnNf +sehC1yrNtQ3uAxOs7pP8I/tFeAzCzL7JQ8vLb/KwiYoSD9DRR9velZo6paiV/865muSMxLDx +BDP4/TbsT60b0YUrktOgSd4hAQaH0ces4Er98dRPv3pslW2flnU9cHMlkMJzHFrux5KSKkpB +OuskUD+hI4ZtwFDwfe3hV6/k6e7XsgPJjIsaPxYLKiHEHBghvXugg/1tdnjgrZmLKtPg4rwm +lkf3MIJ9IXCHqsQqj+okXChimBNULGqBpEJJmgfMV8c/HfI/W1bAgk8qK0GU0hNBI12ZhTOm +4RYnOz+4voN7qq3mjrW2bYXjqEkiU5NKmxxKni+mHvvKr2p5onN6gRKfDST//c1cMGqZVQsd +Io7z+NIuJYl4MWGsTAoS7sXUzj2dbyHsvu7dsNuRx23qfDYNiQIcBBABCgAGBQJV2IutAAoJ +EICtc3NCdb2vTMwQALB9v91f2PWzwM6MZJ50cE+9lS6l5aCWzWfIhzAUGP5rITbeZ8cSHX9p +83c4wcD7E5Fv1QiOnzzbvpLIh2q6Xn7jzatkC1DJ1u4t9eLyYNmRkz7Sejl6naNFRwYLhyeB +MDXoH0FbfhNZe45yTyuPW53Y2RJYFX8UXQYH2S+oGBSQkJ99HYmuwHVapPFZm9VRMafuKuPw +oi50+ck7xQ1c986BdaK3U8a9WkTkqV8lWXH1rgvchZMI39qphP8BifKCBcmu/j7OJtWhTv4u +EID9LEDu/HLmobPSu5EPG/mHAF78h20To/97+c8olimRvfrntLVpwtom7inQ5sojXIR9LOGl +EaaUaZX9e0KkgpOJO8xZPkLFwel0hbakIcW+0Xoioc47QQvUvj2+RrUd3m0554cbev+XuFs8 +HYtrnJGQ/QVDbGGn4mMYvWPKfvTxbtuDBdCRCSRuQhBP6DuBADqO+XIcbFl11tIZqiFUh9e+ +iAhxMdac0rqwGaVNAILh1f9PHVgRbpFSgYSfSpG70yjZ3XFZsG9TbpkNVxSQAxGz1wyXPzRk +1GoVbAg1lwQIHd5JVWCeSMVbItvv/LCPocBzBUmd8vIL8frO1y9qy4yuAmr+m3R1IBc18pEK +QziVWZ5zyYOdd49/oGbbFxLxYfH+9WYAXTUB+e9OESC4Bl8O4YA4iQIcBBABCgAGBQJV4L0f +AAoJEGCuQuxJOXONWW8P/j3VswzzV47HEHs22yRkr7uNt2zfdsOE3QPGYE6pMXqZEChSl+7n +APGWHMwv42QwzxxP6ZyovP8g8rmZJuWiq6r0Zb3VekmAzmsYXXqoKuAARrZ/shUkFdK1IaJZ +S1F1kuC3dmYdlqVgNfjULZZbSr5uNZ1PnPKPAgK+qqlZlJTUmRwPZONH3KXBHj+RnB578TcQ +BsSWz4h2toB1KgyCs88tJ0JtVJlY17+4titDQy1zmHeiD2ptdP2L/wloteUo135Ll6o2HS9v +l4F7YgK9tcDwshSk6iiQLsNjngEHS2q7AEGxUflfF0Oz+kKLSnKGbz+hLDAY0lD6pJLgn0Io +oK6B5BgPkgLvbxjprGvcxdsRT3vwpjUOHpWddlYvbU17Jitk3a71E8EI6tGSiVo53RFtb3pP +LGCiYhJxqivvtHiw6WD0UYNODZT8lfsnxXDRtqFp4USWy/iPg+xOFF3fpGLsM+GoVavF2B5O +nNPmBEilLbyvswqToiDlj24lQaCYiLF2JUWgT/7lONP/gwrBvx1sN0vDFecmkW7XrrYAbVdQ +yMliLtqd1UxwWOsCREJyPF9saW6YzGql0Oto5WqcPA3mNpEtwoW3z6K5KaE9LYF28QT99GVf +WnA/Lt1KpIC8wz9eUZLZa/hyGU3vcVv+xuNJotpQSr7XZLwkn7/mAHNHiQIcBBABCgAGBQJW +KgsiAAoJEHvRgyDerfoR5OoP/0iLTIaoy9na0QykBc3FYYiBbbA4EZC1l5aEzv7z5lFkMLE8 +1SjprhiX4YGUL/w2UHv/8cfsTF9uZwIH8Jl722kdW1pjYSRVzJhuafGRpWo1maZjGYCpNR9i +y2CnjD6tHkBMR2+1e1wY5KgM6j+CXQvIjr5fK+ngthUyMQ1ybGCBQSl7WPPNPe1DCWjPI8Bv +DZdzd5bcNk8xoOb/UCvckxol9TBRuq0vWCQxLvbPajLIZd6aRF2ZYCXE6GZQzn8oNSf0Nwsy +H9IuwGjO+G96qZBTRd/CrBG148OAhrj00+D+nALgx9LvB3QoZAKoh4VyokBhvRsT+sUGkUwA +vTC588iIs9VLKNetGP03eALCXpzW1wVfpMOuuuXz0wDPUcZO4JMT4uXmZSTLq9DX7Ey4O3Wk +Q8q/Q4hr/hHVgJ5N0mIdAGCLQr+qNzT98+k4EnQv4/r5u2mGPyTFKIzve6Na5PYnrD3xXo0t +aBzceMCK/Yl/viOJ2Gi2ozkJhxPiTvZ8XYCdV+sM14j7Ct/23pjcqbuEtZFIdGnUTizgsYsi +3ml5FZbDqa6O6w/ZhU9XPbc915LMFl1RzyxYHCNSj0eTEcS4uoGbTobLdp0szcu31pNSe9Aw +Q2/esUYaKkJlH2xFdCZPGEO33G5GmFofDAwt6tdIOyYh0x2uFLyIiYk+3NaCiQIcBBABCgAG +BQJWN0/oAAoJEO1FZ42hTyzcCO0P/AmjSZTH6N5OWR/4hX/ranE4A1OB6d333APlH3L/yH9b +PdA7k/pphJslkrM6tv87UsLwPdG9FqquYEXpO7Phakz/+c7C5yAkVlSbKmGZaqMPYPQv0ysZ +Z4azlMWbWRdNpslCgq1iyWv0g8X3X4AEbEZKOj6qV8mQCtelR9cutjgeHF+grNRP/Gst/rzT +tK1AE0/xLQJsG1Pj8y4nGZK8UuXhq0lFcpA0bxj8zdreSO2uBRGb+w5hOJOtf1xIHPxhhGnF +ICZ4oxgzq0PdVMALPoxjzpwjKZYmIwK6qi3QWAyzcnB8UJSM/gvvemo0tdnc0IbXGHRT0pia +GBqul1jaSGPevOldmR6D6ty7XUhhkCe4QFzuIqQN0cBWP6wM5KGDaaJ+g2gvj93+nLfXd5jD +tb8oK04WRhoRAiVOeQG8A013OD/MIaSO343/p8iXRBsWm/cXP9C5uykte+SNNzDvaFziAPoE +eRAoHTOHyArW0baMor0kn8wdb5uQZTZr9gfNsj5K4SFeTZAE/E1nQmWFFiSf2QbBt7GcOOCZ +U1mF7gcqQvVmYUd3XU/V7eGrRz0t6FryRQq9ZPPxUjN125fcg7aV3+YMjvOBopytMRYNQ3V1 +TEnaembB6rO9wpSDiybepgvClc7G6KfH5rwzrg4X2KFiIifx6NEarYPWjNwkdyl5iQIcBBAB +CgAGBQJWQTCNAAoJEDknjagQnmJEEc0QAKcxAfYrkYk9n1rqJnFyjO1NZiE6TIeN+4wCihTr +3fr2HfOiZVZ0njXU26/4i275oYPNwkK4ZOT3+L6lczR0AeR4PXsC+fldYF/zbovGiNlJrD89 +2rx0/eUstSiRWNIdEgOVt5bJNfa5JKulWjJDOJAVOg4tRZ8fsJg4Bz1jgrB8DjIIXW6esHlr +8JxqS12oAq8SyaOurloUm1CgJHRv0wX18K1JWqrilcR3rNSw6eklyulihpbE1NiYo0XrmFp0 +E2lVME4aATXKjxpjt2hIskv27sQie9eYdAt3ftBQqcc+TFYB9VQO4584r86+voASSJNiy3lm +qBWFrRhDtOQB20D5dJLRsGb+Q7gggMYHCLwm+mMUrBhaww+y6kV+O4i5AYCBWVRCRdnNbacP ++yMGRrlKu9OyYSg+HjOGeMnxUktGnN++LpDYlK8YW+VBfyIhzrXcI32gx7OE0nwpkR0MEJbz +bTTw4Yt/zC4OuZhmTCtDF1Ymr5WDXcIE+5GoAwkvjqHUm2igAVWPbWTgs1/xAisj6XryuuB0 +FXVoK3yWzOeUWbLg8o+8w9dSm/wlexyJ6KawPeRdvzLcnw/BtcUi88nIbDHRD0rWrD+GdcdC +AvCLqC82lPAqajyc5hlvJXYhD6Nw+oDVzPs7GUh4CHKE27gzDTQAeQbA9MYTiPuVijV7iQIc +BBABCgAGBQJWsH3SAAoJEOnijeoAqlVW598P/ROHbv61RaD/sxfMNHj695S+WCAZxR2LKBx0 +JiHMEEe3vr+tYJZTIwlgshp56C2lTJ0XH5TF7XKGnT7pMKppebPYu2GxQeGSoPSTbxr9pfUY +YHhSzAka3uKJBPu3qJlY9Eb+QZXPNXEFPUwrsw7CYwPi4dq7yV5UNvFx7ySM9E2sxAfIm6Zn +Uwp705g7nBdYP1PZRgwzEZi/3MdhsuayHDGakelLbpJ+hYYpjEKWi07Rvv4fJk8i6TlOrgJI +oqUJj7n/abQSBz7OKQy7ZGMmooHqbTibyNzNTxjrQDwKAa6UGbs85WQvU6QVcc44aOawvRF7 +Rcs0z6VJDqZ0H1buyeu84d3JA9WNYhor377ZW/YA8gh235uxjB/c2x+8DaI4W6IweKsVXT+5 +0UaNZavx65S8Hu/pM9P7/Bu5+EnVmVl4ziL1KM8UR6RH1sGOw0818xvgydb0I1lWXKvGOuG2 +aDpxYJ9Dq+6I992oQN333ogrX/mBhJNp4zNTaG1TmlzozYK4p9leomAU6t99/Yt4ivfR6w1y +qhvk72dSqPwSZ5fUizfajvsFRwxx89DQjj1uGQFod053fE8NUhC+lISuPpX94LmGDNQkRUVL +z4E4ZxE+xghnb4fsecMgoxpRYvmEL9U1CJAUkX7c50ykLUTorPcnWyC+lRql+SVidsiNRpSE +iQIcBBABCgAGBQJW+r9VAAoJEJeZ1wno3NaQKdwP/1huDGaVcre4+Qzns3zFFL9xLGFKPmcN +hQnL7of18KDe3yzMVyZAHxSm8nW/NdFFGvE1/7uKFMhcyArPIDt+6HXWaMqNActgpl/XYJ1q +zt/X07XJjH9bqBAakPi/oJT6qHivz+r+WjXyFzoUkDbJfJIyRvKImlD2bW7/SblGIlvCjSu6 +1D1YHFaOtVES7eJ1TPf9En2kUi+11lPBYsFhSAeNlxiHo9xRFYwsxUQhz9fs57tWXuoI45pM +QjxDhR6NAN1Hl5W7uHalrTzDQb88yhcftttjLhiee04rciDiiR7GsybK9NVetsJs9mMlRjJ/ +z5F9EGbnnjVns8/smtNA8ZDxO75jJL6LaPdC3QKgPm9DJX58XHA4INwPtVJRHqYhqKH3Tihe +Zoh0PjJcwZtKdK08VSzEJw0uJ6+jJN0lh7HLxzojgN8YJJv7rlzZ81EgCIjPgK/+5f0WePQX +KRvYhNY98mlb/SJ8CGOGXECveDP+m2x+30ibN3WLjetDyCSaqqDjZPV2+Jbcl9qNM39H0Fya +GHvz7sXd/txlJhS0x6UGEvVIRX0W5iht1bumxTULk6MRCYaLFaZNQIoZOry4bUNpdGjqPwj/ +N0cJh+nR6O+AQ1YXbmLdB9X8YXwxAE9almrVhknhZ+Vmc/KdRr34uLW5+mWhJ711xSNgpSNj +X5yPiQIcBBABCgAGBQJYMqRwAAoJEC30ndRgwBr0K84P/1MBZTq+aL2l1ACq7xv47v1ap+yZ +nxVvoyixSNmLki8Tyh1Q5xWDFC3lKqnDaeSBfloNYlAoE1rFa+bOKN69EL9tejlwafPOyp9U +Uj5fIZ293qMtdKskrr7XdH82RcgWW8EhUMCPhf/R3S/eQEcc4/KKASosEtoZ/VEBQ6c0rRkS +Ge2tqSH2ZwfA/8iNyppxzf2Z9KuHsix9dAEL5LvV2PbBhfGkK3cAqd6miZjx57GNjSXskG3H +Jf8DV+vxyahwK4GxLGtryOUl8dh76vPsPIFTFVQ/NCM8j/CgSjJDksiIsq4FbrCIxa98xi9m +elEm+0lwbYBKyqXdNdAE5qiOcfLNesSPsO+n2M5y0kvp1nL3O+I8HiqdfgP9bZJxDSUeCMKs +21YyHYpVWlBHQWM10SJfmxrYOfLaG6jfWQhhyUxSGun4HzxUcyU4FSZPqs6xN86R/9FwoeQJ +mO6amRwbMfKoi9ExPp1oSz300xNu2f/JQMqMIxjJFn31IIo9cxFYfEn/+nIqf5IfzkKXHaOM +ExMH11rf3u+h8eb76/q3IBD7iDxpI/Npjm6AMr1uMivvV0RFUJqqsrnD8cPMGsX0XBrLGc3v +7qMFSnQtAKZ345Ntu9ZLizzVvSAfgo5veaBYSlQdjUTPdqc+NTOpyKqaoBdG1nKXr2TfLLa/ +O3nPUpz+iQIcBBMBAgAGBQJX2+YJAAoJEOKxk63LMx8ml8QP/2MErohRv3v70a4hGOd2rEt0 +YjNKjvh4VCSTzpnTwWfijPwqz46w0nk69Wczt5RSmQzCZ+DHD8SUNZfNV2kfeMn6Kgo4y+Br +snQkvVJnZDrmp/HeRYqK7CW4G+blO+3E9w6dSvMUdd8195UXOrRFVcxuOOFdQMqkyuV16VaR +nUcyvMmlqQNb3AY1TPBE9QsTBgFx8TcOeCKcxPD2XmYoOxBzH9ypS1uZISLcibkb/Qbho3VB +soJZKbyNw9yC87R9oq4N3aHGrPXTOyhGqViNgYf7MNpPzBFS5MdpLdMl9ee2Q6t9CeZLm6Z6 +AmFowu8zBV/DIGlEGuUaLcQdZUHGT14YMEISQUhEdplgRdkUv5DO/vGp3n1xMoJZdam7eTky +hWJ5vGyyC2W1W2V1dN1QI20FyQyE3jeBobEBhY1FYS0V8TUvCjQFpqJO+qVa4ABk7umCtA0x +HTJJahuQKdPjC81KBzD0CrfrBqkpvDpv0NDN+YPqWY+Cq5BOTzeyBU1oOB2ERXnCczOkWIYH +wqe//6pWyLyoK/oiRI9VBp/yt/ds5G5ZgzyGMBozT+77NZQfG0hRhaVGIh3u7jr795azAxWk +BDvbT22vyEEN8FMhrL6Mba/9VAKuArYWaZWDVvpj4tP1TTIqELSKvjgcDF9yFpvaaQJr42f0 +6C4wzwVsxKKYiQIcBBMBAgAGBQJYpB5/AAoJEMZ0wPQ++4UqUg4P/3vHTK7EEZ3JwR+GoGa2 +bflBSgsR5cwPV6yDQN+F6BRZ4HFhBtM5mYggJjqHPYyvm5D0SsmyJ2II2MJXCIfyfQcCJTXe +0jiCvk+mD08O1km5KAfnHVJfotO+OH5Cwg/KoKYRTIh1tWRm5YzDcKgJ5xUfvqOMo4FAp82f +uOqD1AHsw3b5qqyK60Uzi5TQdLGyZPfg7BnVLj+7vYi+a6PsVck11eJ16pNaBd2U7HqLKxiA +bX6WQ94FVoD1fCuivsnsvIAyYX4mRQEkkmLf7tTMaLxaAhePjYgMYsijlvOdvOh0mi5i2/WA +ymsjMks1AclNg65YUrQt2kB0z0U6/oDKVIMmbXC/A+z6Ro8wPz1a1d+PmeJvKUZDNqBKRBWc +5CUtkezioCCaxVe+n0CUiaUjC/GimZ/nSUUOSvCgEGBUnQI+bgVzDH/rLUDQ1M3ddaWll6QN +UVFSsU8+nURaXREEBqGwHuQI0wD9i/Hl7eSD1w9YKrUfquczF512jURLKiemxK4AlZNuv0rK +nAXGRseWJLAgz3Bfo3qZMVJh4FzcTIu5H0DbD0hMl7lfI2qFFBLGuUqFkNR09mQDI1XzVEli +GLRW06DKxisd1j8M9ArU8chHnaYgbaxafVu8w+qG4WzSk4PgIEhuJAuPH+F+Qn/F/klwhwoB +3aha/Y3ENV+8BMqWiQIcBBMBCgAGBQJWiWkXAAoJEC3/Umuxf3bGqy0QAKT1twD3hqa3QY9u +ZNk7+B4/DUN51e1RtVzxYQsp7wQP1b2hmJal9VCr9TVBls2/TxggaIyIjYUM7YghsH3H7uRJ +dcrhgeVXMDGlHkweTv+08NyRpYDoMp8+657kVQKCWhlxE7lGciSx25tEUFROmZpptH2oZ5W2 +FSTvKi1JGiMZxQxvFKnNhiBhIKrPsimd9x5moQJxskVSGaopfvJY7XdhOByuvQDOrrPNCLV8 +adIROIa9HcTIs/QgGMMwyuOBZ25Hlbgvb3D+IIjP4s4NuTwKrGD7LAmnZoPXVHOpS/Fxy37s +KD0OZJTtzm3zk4GoxKMDAw0TPgSJ7DFqVzjX02GYOlpSqtEUyxyZxUEPuHJCy2bhrZNaRiI/ +Hq3HvT4Pku+KoUjahp9nanRtTT3vb87mHm1WbuJoEpJ/Qfe7iV3flRvRmPuH94ndSqvyadK3 +hKFoDQUTiV3wBWlz18sYjXaguETbcmtpuKmMERooxdxNYkVWKe5v1AtJ+ZOdo2Fe7vZ2FykX +1/ptr5xw741WF4+EEJtNfMp9ujYqSUpxhlfMmSOP5hDUWjJ2XiMBcGkTYgQ2rnj1GK4t3v7d +zhd94QGhGVCI7J950Lm8d8dFvgaVmJInShkBzRKSDeZSnYOw62Gtihx0FqVEPoVMgZqptZvq +dYjMWbNcZGQw7ka+nojaiQIiBBMBCgAMBQJU14+2BYMB4TOAAAoJEN/+jeMacgX0rJcP/3UV +o12PPehe8nReuFeZbOVySEjdVCToJcr7u1dem3yGwuhffsI7CtsQ75B5bUwa0zxzaUMRv6qq +8McaHpqV637dbr9ERdBya9SKJbB7SUOtSD2+zmnXU3o+txdty/c2tzjzhlw8HGLZTIeWL9Cq +ocAlPGosOcSKtjP/XvLa/XwzTogPvBbO3Ca+cnRUt1g9CZarznAtOZP3xKWtQYrmkAd38+Ul +8r7lk2YfrZf+EGu3JwjAeO3X9zlMXRNVFQOJ2/Y6lUdZpkfK7edOjWtzXNqtXmDVoumMVHye +IJ1WHooeLdoMEdGLNmcP/RP+/ZPVY4h1sOj7chkc71lv7GwsGAlt7sPofXWIyFEGF2I97Yk9 +Cd12TyrfFvgn9iAzen2wApnFQ1MQK8p6qAllwrsqbYgddTjkA/QFkK875Xz1W6iEw5DkW4G9 +hAPh7TDNGNCRD/JYNMwiFn4XUHnlfHCqpM2wfDrYVWUciwZwplR+XEU+FjtA2TuU1/cSfAXP +G0FwJgMB6KExJ+5cjLYLhgAEg0FhRdw7nOvlCHXR4LOA13iAK/Xxwyu3H/uRh+OmNoscBtyX +EiduWtlcHQfW9C4j9FGmYxZPJQoMD3qFA8LT6/kdtJQkiHaBNFKKoQ+b/KzjqgQ+axuMRCqz +Wr/rJy7E29outtA1AKxZJT9pSrL8cL+ZuDMEWGkjPxYJKwYBBAHaRw8BAQdA0K0DzgTy2/ax +iLxZQNhe1SakbYfH2TS5Wz9vE+oIFVKI5wQYEQgAIBYhBIBhWHD1utaQMzaG0PKthaweQrNn +BQJYaSM/AhsCAIEJEPKthaweQrNndiAEGRYIAB0WIQTX/8BjtAoilLlm20f/gK6dHew1jQUC +WGkjPwAKCRD/gK6dHew1jS6LAQCwByUwaJ+GQ47a93AM9e6UbxVf1S5bY/BvteFfD9l9GQEA +rHDXgN84v5XQsSVQdEY+yY1HnNvs6kXwHBZ42MFZHg7+NQDdG3NJ7BJx2BeB7LWubomumKUm +ferZs9L8z0V2cgDg9tnT8ChxKUeeK+yDn3xPMlct1zJBZaroNGoZLbg4BFhpIvgSCisGAQQB +l1UBBQEBB0CRjBczEn9r8mRvrj0IGhiudxEckDuQYxCwd1Be//EnQAMBCAeIdgQYEQgAJhYh +BIBhWHD1utaQMzaG0PKthaweQrNnBQJYaSL4AhsMBQkDv4IXAAoJEPKthaweQrNnJNoA2wfQ +XsuXzkEK7VSbwW6jVB/rcxiB3g3iLXOFwmwA4JzgUvfjd6sk7h/WwDGBxoANRYnga/ZFskh2 +Cwa5AQ0ER+O0zwEIAKzCvn79PPqcNrAhdA0LZO9e00sh5nJp/Hu53RlxAcWVsv7EFqGayiq+ +f4JpAh9ztKf7EmYYo3ws03hJRTtAEhWkgL2l3EKoVJ4xHCOInNyi2yO30qqKoL5CfKsHyBaL +2/IzDv7QUIDZmADg0wZZy6ucySL076ahAHjwWXXfdEhogurzQA2dOA+T25d2XVzcGpL9cvni +3OI52D3AJKrH/FO/wpaRnGgAzywtCqdZTepWAV0VekF6RGtKodiU+Dxru/fNYRVbyowXbwpW +8+hPCN2kp8vGnFBemwUVfvx/ZNpVvcaw+/hN6GwVyeeQlji+Mp6EuvYotl8lUMcls/mu2ZcA +EQEAAYhfBBgRCwAPBQJH47TPAhsMBQkHGo2hAAoJEPKthaweQrNnLqkA32A695fRmxTcQGUr +/x0lynGeTCcrOUy330GD0F8A30c1eopishiZiOrQGg1QICwzZXeuCwz9sK3Dnsy5AQ0ETrgV +WAEIAKGQKYyt0Ipb89a4FCzb+VxOrPeLfco5QLKfKPVo7N6f0dQlUfKYmc3h1lOOrcBGVJO4 +JKgmZDByaibTCMNLYv2qoKdRy13IigXFN62cw/cmQGEniPkjG3CRPOdZrRKASO8F01SQtMEb +/eWB8wWiqVA2HWivTvCwdL4uW9rG8WeoyjOywqpgsL2ZNWpZ9e9N5GwLNgu9nqPLiupsmcMg +nMeCpXcrpzKoDk1xmqhaPw5A1RtL6xUJTyeRiQNhADvCbafCiUR9E5J0W1JOYvj081BLVXcx +R0tRvtJ+wObB+bn1IOYlSniLDcXnfk/96L4blwFjMc7SM3SfNQf+x8zueOMAEQEAAYhfBBgR +CAAPBQJOuBVYAhsMBQkECo5HAAoJEPKthaweQrNnpMoA3RYw0XN7GY+9yJqprYvJRVQj+G3e +y7D+2VVIYMIA320JYXVQUGtA5GByumBAF80o+RR0DHHKIOtd9nW5AQ0EUsWF1gEIAN/7ECH9 +2tNgsBZZqwrv4IpxQQCkHVuDfQwFjAIycwaK0SoEwdyebYzqLx1Bb19luxIdl7jGrkNCqGRQ +jknb4wpq0MNXef6hnVB16sCXrdy/1BmCN/QrfxHbgxti145Z9lg2lPoKQpT8t6aMy0U0V7Ey +/aPqt1Yuy8hH3ezxEr8xCKMdzkg43lTjYIA9JC7GPADWqOZZDhEWVx+nuG6K+okwl7Rl9TnE +R4x4oriPD36qPPMgxXscSs9JCIBfMOI2gMDZRqwve9CT9eFcwzIhA+pVByVdgjysj2h0P+y0 +WpRBmNrhElw//bksOBCLZ2R1hzhkI6SHXZcgy/NrX9WDuvcAEQEAAYhfBBgRCAAPBQJSxYXW +AhsMBQkFogmrAAoJEPKthaweQrNnQXwA4KxJiLxQ/CcUXKHpo2jt8Ato/0rdyF/fRmS01ecA +4Nbz4Zu+i5fI3PMRlWzK6/T6WADryq/gnGB6N3e5AQ0EWGkikAEIAKyRIKMf3zPPZ1kWtVA0 +LtpfEuCJkXPF/vwPEmQbQouJDRlCo9J62qmlymN2n7F88Mfce21oIsLhxpp1+DgtffmO3m13 +qa4/KAlnuiu0xXuiKb4M2H+y2l8E9xJWsctCyQkz5hFVLiiiXytaUnnwOaeog+IqsbdIO3j7 +lgzC+/WCbfzU/ndDy53QK6NiqEoEmxfX8trfcK4L+SSG0jqc/OaWh5jdPGu6UBRTDPael5EX +Hd5H80zymvWoBttPJts7LYytLTKUqTnxtuZRfAyZMYLAgMVJ0oIF1xGFZ3/uxf7QGJG+0l0Q +cVwO32Zb/Rbf7xx3BzjGbRjGJ8dO5TJZivkAEQEAAYh2BBgRCAAmFiEEgGFYcPW61pAzNobQ +8q2FrB5Cs2cFAlhpIpACGwwFCQO/gpEACgkQ8q2FrB5Cs2cfcQDdGDY3Ne5y9qV8Jq790v7e +Zr8ic3arP7eNFTfhYQDfd7XWH+XYY23RpJ2QN7yo77e6IWCBS4NcTrMizbkBogROsUyGEQQA +lCMDC6m1nkcdAK3MV884airO5/akCJhT0CWjd6LxbM27SremsW7HSaUoOSNXSXpPgktdDcA7 +y6Y8cXteGm9+/ZHwNoXgYWnTpWjk50qLre0iCNLcpT1V0cMEev5B/2YXOiog/7obnI+tjG/y +7V41bNzAceKehSFbSi5hyz7EAZMAoIbBb88QRdsh1RKmtHdVXsjuvldpA/0cp/wmWwWEfWMG +KvtCk5i6Ayl8T6YHRjtqZwnMFrNbjEssulkQ0XpDGRcAyO92utp12sl7h8DWl4OSEFh6rnFV +JPrII8YQXahrAchB7Mtc5AzDFFmgJqvJdp8WEVnx+nLl9shaRifHUSdLwdt909p+1CFm8ChD +l7+eZE7YbvEWGQP+JNA0DHFqNSxCFzs667Cnic7op3BkaUN13zNuR1aVpepxUEhkk6LfiiHm +QON7QHVAqvtq/TO0svyy8nAeFhlWqcXX84tuoobmnsCowa137CXYV/SD7JVjy5X/b6cbs2sI +ty37eJLjoffnxQHvN+azf+JtxtTXhMTedhBQAgdlBGaIoQQYEQgACQUCTrgQCQIbAgBSCRDy +rYWsHkKzZ0cgBBkRCAAGBQJOuBAJAAoJEE8FQNV3+V+VkpoAnA5MTmFbkcoM4N4OYwb3YGMf +oAD0AJ9j2e0iEo9fhMfcSoKG9xssLopUTOj0AODNadm6ajGAly1Ioam+eLSbqxHfSkQEHOxh +MiFjAN9q4LuirSOu65uR1bnTmF+Z92++qMIuEkH4/LnN +=Qnjt +-----END PGP PUBLIC KEY BLOCK----- + diff --git a/crypto/test/data/openpgp/eddsa-sks-pub-keyring.asc b/crypto/test/data/openpgp/eddsa-sks-pub-keyring.asc new file mode 100644 index 000000000..b56370ddc --- /dev/null +++ b/crypto/test/data/openpgp/eddsa-sks-pub-keyring.asc @@ -0,0 +1,13 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: SKS 1.1.6 + +mDMEXl1WjhYJKwYBBAHaRw8BAQdAoPlx4e6UlAd0tDq8SPjwNHqUciv+FybLYrPocBJ6Ze20 +HlJvYiBEZW5uaXMgPHJvYmRAdGVsZWNvbTI2LmNoPoiQBBMWCAA4FiEEtDGzEElVJ9+SNbQu +ZgxU5RXBR+oFAl5dVo4CGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQZgxU5RXBR+oS +ywD/RowXCrbr8dj9uVpuVKe2FFN+SdlWk/xae0LlniAeJ6QBAK+SnvX2bVStf1XIUxupqheZ +zj+W8kojFNXPK9UBECwIuDgEXl1WjhIKKwYBBAGXVQEFAQEHQBC8TTeQKgW1ml2S/uMrYETD +w56ilf/FTTTdViCJjiVGAwEIB4h4BBgWCAAgFiEEtDGzEElVJ9+SNbQuZgxU5RXBR+oFAl5d +Vo4CGwwACgkQZgxU5RXBR+pY+QD/ap3BMh/ottU4nzEg7Vo2lF/IxsBTLKkKXaXxN4a19O0B +ALUL3OLNjjcGZzKaNkkg0MGjwg/S+1xod7+75Jk3CmMD +=GN3J +-----END PGP PUBLIC KEY BLOCK----- diff --git a/crypto/test/src/cms/test/CMSTestUtil.cs b/crypto/test/src/cms/test/CMSTestUtil.cs index e98810c84..e7ec50f53 100644 --- a/crypto/test/src/cms/test/CMSTestUtil.cs +++ b/crypto/test/src/cms/test/CMSTestUtil.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.IO; using System.Text; +using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Asn1.CryptoPro; using Org.BouncyCastle.Asn1.X509; using Org.BouncyCastle.Crypto; @@ -455,6 +456,15 @@ namespace Org.BouncyCastle.Cms.Tests return CollectionUtilities.CreateStore(crlList); } + internal static IStore<Asn1Encodable> MakeOtherRevocationInfoStore(byte[] ocspResponseBytes) + { + var otherRevocationInfoList = new List<Asn1Encodable> + { + Asn1Object.FromByteArray(ocspResponseBytes) + }; + return CollectionUtilities.CreateStore(otherRevocationInfoList); + } + private static AuthorityKeyIdentifier CreateAuthorityKeyId( AsymmetricKeyParameter _pubKey) { diff --git a/crypto/test/src/cms/test/SignedDataStreamTest.cs b/crypto/test/src/cms/test/SignedDataStreamTest.cs index 37f41783d..3d7892c6d 100644 --- a/crypto/test/src/cms/test/SignedDataStreamTest.cs +++ b/crypto/test/src/cms/test/SignedDataStreamTest.cs @@ -38,6 +38,40 @@ namespace Org.BouncyCastle.Cms.Tests private static X509Crl signCrl; private static X509Crl origCrl; + private static readonly byte[] OcspResponseBytes = Base64.Decode( + "MIIFnAoBAKCCBZUwggWRBgkrBgEFBQcwAQEEggWCMIIFfjCCARehgZ8wgZwx" + + "CzAJBgNVBAYTAklOMRcwFQYDVQQIEw5BbmRocmEgcHJhZGVzaDESMBAGA1UE" + + "BxMJSHlkZXJhYmFkMQwwCgYDVQQKEwNUQ1MxDDAKBgNVBAsTA0FUQzEeMBwG" + + "A1UEAxMVVENTLUNBIE9DU1AgUmVzcG9uZGVyMSQwIgYJKoZIhvcNAQkBFhVv" + + "Y3NwQHRjcy1jYS50Y3MuY28uaW4YDzIwMDMwNDAyMTIzNDU4WjBiMGAwOjAJ" + + "BgUrDgMCGgUABBRs07IuoCWNmcEl1oHwIak1BPnX8QQUtGyl/iL9WJ1VxjxF" + + "j0hAwJ/s1AcCAQKhERgPMjAwMjA4MjkwNzA5MjZaGA8yMDAzMDQwMjEyMzQ1" + + "OFowDQYJKoZIhvcNAQEFBQADgYEAfbN0TCRFKdhsmvOdUoiJ+qvygGBzDxD/" + + "VWhXYA+16AphHLIWNABR3CgHB3zWtdy2j7DJmQ/R7qKj7dUhWLSqclAiPgFt" + + "QQ1YvSJAYfEIdyHkxv4NP0LSogxrumANcDyC9yt/W9yHjD2ICPBIqCsZLuLk" + + "OHYi5DlwWe9Zm9VFwCGgggPMMIIDyDCCA8QwggKsoAMCAQICAQYwDQYJKoZI" + + "hvcNAQEFBQAwgZQxFDASBgNVBAMTC1RDUy1DQSBPQ1NQMSYwJAYJKoZIhvcN" + + "AQkBFhd0Y3MtY2FAdGNzLWNhLnRjcy5jby5pbjEMMAoGA1UEChMDVENTMQww" + + "CgYDVQQLEwNBVEMxEjAQBgNVBAcTCUh5ZGVyYWJhZDEXMBUGA1UECBMOQW5k" + + "aHJhIHByYWRlc2gxCzAJBgNVBAYTAklOMB4XDTAyMDgyOTA3MTE0M1oXDTAz" + + "MDgyOTA3MTE0M1owgZwxCzAJBgNVBAYTAklOMRcwFQYDVQQIEw5BbmRocmEg" + + "cHJhZGVzaDESMBAGA1UEBxMJSHlkZXJhYmFkMQwwCgYDVQQKEwNUQ1MxDDAK" + + "BgNVBAsTA0FUQzEeMBwGA1UEAxMVVENTLUNBIE9DU1AgUmVzcG9uZGVyMSQw" + + "IgYJKoZIhvcNAQkBFhVvY3NwQHRjcy1jYS50Y3MuY28uaW4wgZ8wDQYJKoZI" + + "hvcNAQEBBQADgY0AMIGJAoGBAM+XWW4caMRv46D7L6Bv8iwtKgmQu0SAybmF" + + "RJiz12qXzdvTLt8C75OdgmUomxp0+gW/4XlTPUqOMQWv463aZRv9Ust4f8MH" + + "EJh4ekP/NS9+d8vEO3P40ntQkmSMcFmtA9E1koUtQ3MSJlcs441JjbgUaVnm" + + "jDmmniQnZY4bU3tVAgMBAAGjgZowgZcwDAYDVR0TAQH/BAIwADALBgNVHQ8E" + + "BAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwkwNgYIKwYBBQUHAQEEKjAoMCYG" + + "CCsGAQUFBzABhhpodHRwOi8vMTcyLjE5LjQwLjExMDo3NzAwLzAtBgNVHR8E" + + "JjAkMCKgIKAehhxodHRwOi8vMTcyLjE5LjQwLjExMC9jcmwuY3JsMA0GCSqG" + + "SIb3DQEBBQUAA4IBAQB6FovM3B4VDDZ15o12gnADZsIk9fTAczLlcrmXLNN4" + + "PgmqgnwF0Ymj3bD5SavDOXxbA65AZJ7rBNAguLUo+xVkgxmoBH7R2sBxjTCc" + + "r07NEadxM3HQkt0aX5XYEl8eRoifwqYAI9h0ziZfTNes8elNfb3DoPPjqq6V" + + "mMg0f0iMS4W8LjNPorjRB+kIosa1deAGPhq0eJ8yr0/s2QR2/WFD5P4aXc8I" + + "KWleklnIImS3zqiPrq6tl2Bm8DZj7vXlTOwmraSQxUwzCKwYob1yGvNOUQTq" + + "pG6jxn7jgDawHU1+WjWQe4Q34/pWeGLysxTraMa+Ug9kPe+jy/qRX2xwvKBZ"); + private static AsymmetricCipherKeyPair SignKP { get { return signKP == null ? (signKP = CmsTestUtil.MakeKeyPair()) : signKP; } @@ -341,7 +375,83 @@ namespace Org.BouncyCastle.Cms.Tests Assert.IsTrue(col.Contains(OrigCrl)); } - [Test] + [Test] + public void TestCrlAndOtherRevocationInfoFormat() + { + MemoryStream bOut = new MemoryStream(); + + var x509Certs = CmsTestUtil.MakeCertStore(OrigCert, SignCert); + var x509Crls = CmsTestUtil.MakeCrlStore(SignCrl, OrigCrl); + var x509OtherRevocationInfos = CmsTestUtil.MakeOtherRevocationInfoStore(OcspResponseBytes); + + CmsSignedDataStreamGenerator gen = new CmsSignedDataStreamGenerator(); + gen.AddSigner(OrigKP.Private, OrigCert, CmsSignedGenerator.DigestSha1); + gen.AddCertificates(x509Certs); + gen.AddCrls(x509Crls); + gen.AddOtherRevocationInfos(CmsObjectIdentifiers.id_ri_ocsp_response, x509OtherRevocationInfos); + + Stream sigOut = gen.Open(bOut); + + byte[] testBytes = Encoding.ASCII.GetBytes(TestMessage); + sigOut.Write(testBytes, 0, testBytes.Length); + + sigOut.Close(); + + CheckSigParseable(bOut.ToArray()); + + CmsSignedDataParser sp = new CmsSignedDataParser( + new CmsTypedStream(new MemoryStream(testBytes, false)), bOut.ToArray()); + + sp.GetSignedContent().Drain(); + + // compute expected content digest + byte[] hash = DigestUtilities.CalculateDigest("SHA1", testBytes); + + VerifySignatures(sp, hash); + + // + // try using existing signer + // + gen = new CmsSignedDataStreamGenerator(); + gen.AddSigners(sp.GetSignerInfos()); + gen.AddCertificates(sp.GetCertificates()); + gen.AddCrls(sp.GetCrls()); + + var spOtherRevocationInfos = sp.GetOtherRevInfos(CmsObjectIdentifiers.id_ri_ocsp_response); + gen.AddOtherRevocationInfos(CmsObjectIdentifiers.id_ri_ocsp_response, spOtherRevocationInfos); + + bOut.SetLength(0); + + sigOut = gen.Open(bOut, true); + sigOut.Write(testBytes, 0, testBytes.Length); + sigOut.Close(); + + VerifyEncodedData(bOut); + + // + // look for the CRLs + // + var crls = new List<X509Crl>(x509Crls.EnumerateMatches(null)); + + Assert.AreEqual(2, crls.Count); + Assert.IsTrue(crls.Contains(SignCrl)); + Assert.IsTrue(crls.Contains(OrigCrl)); + + // + // look for OtherRevocationInfo + // + var x509OtherRevocationInfoList = new List<Asn1Encodable>( + x509OtherRevocationInfos.EnumerateMatches(null)); + + Assert.AreEqual(1, x509OtherRevocationInfoList.Count); + + var spOtherRevocationInfoList = new List<Asn1Encodable>( + spOtherRevocationInfos.EnumerateMatches(null)); + + Assert.AreEqual(1, spOtherRevocationInfoList.Count); + } + + [Test] public void TestSha1WithRsaNonData() { MemoryStream bOut = new MemoryStream(); diff --git a/crypto/test/src/crypto/test/HKDFGeneratorTest.cs b/crypto/test/src/crypto/test/HkdfGeneratorTest.cs index fa540e41e..fa540e41e 100644 --- a/crypto/test/src/crypto/test/HKDFGeneratorTest.cs +++ b/crypto/test/src/crypto/test/HkdfGeneratorTest.cs diff --git a/crypto/test/src/math/ec/test/ECPointPerformanceTest.cs b/crypto/test/src/math/ec/test/ECPointPerformanceTest.cs index 18051226b..49ae6d195 100644 --- a/crypto/test/src/math/ec/test/ECPointPerformanceTest.cs +++ b/crypto/test/src/math/ec/test/ECPointPerformanceTest.cs @@ -29,7 +29,7 @@ namespace Org.BouncyCastle.Math.EC.Tests private static string[] COORD_NAMES = new string[]{ "AFFINE", "HOMOGENEOUS", "JACOBIAN", "JACOBIAN-CHUDNOVSKY", "JACOBIAN-MODIFIED", "LAMBDA-AFFINE", "LAMBDA-PROJECTIVE", "SKEWED" }; - private void RandMult(string curveName) + private static void RandMult(string curveName) { X9ECParameters spec = ECNamedCurveTable.GetByName(curveName); if (spec != null) @@ -44,13 +44,13 @@ namespace Org.BouncyCastle.Math.EC.Tests } } - private void RandMult(string label, X9ECParameters spec) + private static void RandMult(string label, X9ECParameters spec) { ECCurve C = spec.Curve; - ECPoint G = (ECPoint)spec.G; + ECPoint G = spec.G; BigInteger n = spec.N; - SecureRandom random = new SecureRandom(); + var random = new SecureRandom(); random.SetSeed(DateTimeUtilities.CurrentUnixMs()); Console.WriteLine(label); @@ -98,7 +98,7 @@ namespace Org.BouncyCastle.Math.EC.Tests Console.Out.Flush(); } - private double RandMult(SecureRandom random, ECPoint g, BigInteger n) + private static double RandMult(SecureRandom random, ECPoint g, BigInteger n) { BigInteger[] ks = new BigInteger[128]; for (int i = 0; i < ks.Length; ++i) @@ -107,7 +107,7 @@ namespace Org.BouncyCastle.Math.EC.Tests } int ki = 0; - ECPoint p = g; + ECPoint p; { long startTime = DateTimeUtilities.CurrentUnixMs(); @@ -129,7 +129,7 @@ namespace Org.BouncyCastle.Math.EC.Tests while (DateTimeUtilities.CurrentUnixMs() < goalTime); } - double minRate = Double.MaxValue, maxRate = Double.MinValue, totalRate = 0.0; + double minRate = double.MaxValue, maxRate = double.MinValue, totalRate = 0.0; for (int i = 1; i <= NUM_ROUNDS; i++) { diff --git a/crypto/test/src/math/test/BigIntegerTest.cs b/crypto/test/src/math/test/BigIntegerTest.cs index f5973c197..8f477d684 100644 --- a/crypto/test/src/math/test/BigIntegerTest.cs +++ b/crypto/test/src/math/test/BigIntegerTest.cs @@ -773,11 +773,13 @@ namespace Org.BouncyCastle.Math.Tests BigInteger x = new BigInteger(128, random); object y; +#pragma warning disable SYSLIB0011 // Type or member is obsolete var formatter = new BinaryFormatter(); formatter.Serialize(buf, x); buf.Position = 0; y = formatter.Deserialize(buf); +#pragma warning restore SYSLIB0011 // Type or member is obsolete Assert.AreEqual(buf.Length, buf.Position); Assert.AreEqual(x, y); diff --git a/crypto/test/src/openpgp/test/DSA2Test.cs b/crypto/test/src/openpgp/test/DSA2Test.cs index 507afceae..54c2cb2b5 100644 --- a/crypto/test/src/openpgp/test/DSA2Test.cs +++ b/crypto/test/src/openpgp/test/DSA2Test.cs @@ -73,40 +73,40 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests [Test] public void TestGenerateK1024H224() { - doSigGenerateTest("DSA-1024-160.sec", "DSA-1024-160.pub", HashAlgorithmTag.Sha224); + DoSigGenerateTest("DSA-1024-160.sec", "DSA-1024-160.pub", HashAlgorithmTag.Sha224); } [Test] public void TestGenerateK1024H256() { - doSigGenerateTest("DSA-1024-160.sec", "DSA-1024-160.pub", HashAlgorithmTag.Sha256); + DoSigGenerateTest("DSA-1024-160.sec", "DSA-1024-160.pub", HashAlgorithmTag.Sha256); } [Test] public void TestGenerateK1024H384() { - doSigGenerateTest("DSA-1024-160.sec", "DSA-1024-160.pub", HashAlgorithmTag.Sha384); + DoSigGenerateTest("DSA-1024-160.sec", "DSA-1024-160.pub", HashAlgorithmTag.Sha384); } [Test] public void TestGenerateK1024H512() { - doSigGenerateTest("DSA-1024-160.sec", "DSA-1024-160.pub", HashAlgorithmTag.Sha512); + DoSigGenerateTest("DSA-1024-160.sec", "DSA-1024-160.pub", HashAlgorithmTag.Sha512); } [Test] public void TestGenerateK2048H256() { - doSigGenerateTest("DSA-2048-224.sec", "DSA-2048-224.pub", HashAlgorithmTag.Sha256); + DoSigGenerateTest("DSA-2048-224.sec", "DSA-2048-224.pub", HashAlgorithmTag.Sha256); } [Test] public void TestGenerateK2048H512() { - doSigGenerateTest("DSA-2048-224.sec", "DSA-2048-224.pub", HashAlgorithmTag.Sha512); + DoSigGenerateTest("DSA-2048-224.sec", "DSA-2048-224.pub", HashAlgorithmTag.Sha512); } - private void doSigGenerateTest( + private void DoSigGenerateTest( string privateKeyFile, string publicKeyFile, HashAlgorithmTag digest) diff --git a/crypto/test/src/openpgp/test/PgpECDHTest.cs b/crypto/test/src/openpgp/test/PgpECDHTest.cs index aa4fc2117..45dd641f1 100644 --- a/crypto/test/src/openpgp/test/PgpECDHTest.cs +++ b/crypto/test/src/openpgp/test/PgpECDHTest.cs @@ -51,6 +51,41 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests "6HiuFH7VKWcxPUBjXwf5+Z3uOKEp28tBgNyDrdbr1BbqlgYzIKq/pe9zUbUXfitn" + "vFc6HcGhvmRQreQ+Yw1x3x0HJeoPwg=="); + private static readonly byte[] curve25519Message = Base64.Decode( + "hE4Dg5N9lpwvavoSAQdApL1xhvz/28almLuqHjyrzwVRnB+37yODIRZCkfPk" + + "GEIgd9uff5j8mYbI9ErePgRI47fDnQPu8mI4hTOhe8pHzyXSTwFf5CesSdME" + + "Td9g+UG6cYt/i+cHQWMQD7a53fMNFxPGVYLUFXC5cQh+KvBPghfdoFQMhbR+" + + "GDgauMrgtk//Os0WCYWJa7VZkD5ak3sbMwk="); + + //private static readonly byte[] curve25519Pub = Base64.Decode( + // "mDMEXEzydhYJKwYBBAHaRw8BAQdAwHPDYhq7hIsCT0jHNxGh4Mbao9kDkcHZilME" + + // "jfgnnG60N1Rlc3QgS2V5IChEbyBub3QgdXNlIGZvciByZWFsLikgPHRlc3RAd29v" + + // "ZHMtZ2VibGVyLmNvbT6IlgQTFggAPhYhBIuq+f4gKmIa9ZKEqJdUhr00IJstBQJc" + + // "TPJ2AhsDBQkB4TOABQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEJdUhr00IJst" + + // "dHAA/RDOjus5OZL2m9Q9dxOVnWNguT7Cr5cWdJxUeKAWE2c6AQCcQZWA4SmV1dkJ" + + // "U0XKmLeu3xWDpqrydT4+vQXb/Qm9B7g4BFxM8nYSCisGAQQBl1UBBQEBB0AY3XTS" + + // "6S1pwFNc1QhNpEKTStG+LAJpiHPK9QyXBbW9dQMBCAeIfgQYFggAJhYhBIuq+f4g" + + // "KmIa9ZKEqJdUhr00IJstBQJcTPJ2AhsMBQkB4TOAAAoJEJdUhr00IJstmAsBAMRJ" + + // "pvh8iegwrJDMoQc53ZqDRsbieElV6ofB80a+jkzZAQCgpAaY4hZc8GUan2JIqkg0" + + // "gs23h4au7H79KqXYG4a+Bg=="); + + private static readonly byte[] curve25519Priv = Base64.Decode( + "lIYEXEzydhYJKwYBBAHaRw8BAQdAwHPDYhq7hIsCT0jHNxGh4Mbao9kDkcHZilME" + + "jfgnnG7+BwMCgEr7OFDl3dTpT73rmw6vIwiTGqjx+Xbe8cq4l24q2AOtzO+UR97q" + + "7ypL41jtt7BY7uoxhF+NCKzYEtRoqyaM0lfjDlOVRJP6SYRixK2UHLQ3VGVzdCBL" + + "ZXkgKERvIG5vdCB1c2UgZm9yIHJlYWwuKSA8dGVzdEB3b29kcy1nZWJsZXIuY29t" + + "PoiWBBMWCAA+FiEEi6r5/iAqYhr1koSol1SGvTQgmy0FAlxM8nYCGwMFCQHhM4AF" + + "CwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQl1SGvTQgmy10cAD9EM6O6zk5kvab" + + "1D13E5WdY2C5PsKvlxZ0nFR4oBYTZzoBAJxBlYDhKZXV2QlTRcqYt67fFYOmqvJ1" + + "Pj69Bdv9Cb0HnIsEXEzydhIKKwYBBAGXVQEFAQEHQBjddNLpLWnAU1zVCE2kQpNK" + + "0b4sAmmIc8r1DJcFtb11AwEIB/4HAwItKjH+kGqkMelkEdIRxSLFeCsB/A64n+os" + + "X9nWVYsrixEWT5JcRWBniI1PKt9Cm15Yt8KQSAFDJIj5tnEm28x5RM0CzFHQ9Ej2" + + "8Q2Lt0RoiH4EGBYIACYWIQSLqvn+ICpiGvWShKiXVIa9NCCbLQUCXEzydgIbDAUJ" + + "AeEzgAAKCRCXVIa9NCCbLZgLAQDESab4fInoMKyQzKEHOd2ag0bG4nhJVeqHwfNG" + + "vo5M2QEAoKQGmOIWXPBlGp9iSKpINILNt4eGrux+/Sql2BuGvgY="); + + private static readonly char[] curve25519Pwd = "foobar".ToCharArray(); + private void Generate() { SecureRandom random = SecureRandom.GetInstance("SHA1PRNG"); @@ -105,6 +140,41 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests PgpPrivateKey pgpPrivKey = secRing.GetSecretKey().ExtractPrivateKey(passPhrase); } + private void TestCurve25519Message() + { + PgpSecretKeyRing ring = new PgpSecretKeyRing(curve25519Priv); + + PgpObjectFactory pgpF = new PgpObjectFactory(curve25519Message); + + PgpEncryptedDataList encList = (PgpEncryptedDataList)pgpF.NextPgpObject(); + + PgpPublicKeyEncryptedData encP = (PgpPublicKeyEncryptedData)encList[0]; + + Stream clear = encP.GetDataStream(ring.GetSecretKey(encP.KeyId).ExtractPrivateKey(curve25519Pwd)); + + pgpF = new PgpObjectFactory(clear); + + PgpCompressedData cd = (PgpCompressedData)pgpF.NextPgpObject(); + + PgpLiteralData ld = (PgpLiteralData)new PgpObjectFactory(cd.GetDataStream()).NextPgpObject(); + + clear = ld.GetInputStream(); + MemoryStream bOut = new MemoryStream(); + + int ch; + while ((ch = clear.ReadByte()) >= 0) + { + bOut.WriteByte((byte)ch); + } + + byte[] output = bOut.ToArray(); + + if (!AreEqual(output, Strings.ToByteArray("Hello world\n"))) + { + Fail("wrong plain text in generated packet"); + } + } + private void TestDecrypt(PgpSecretKeyRing secretKeyRing) { PgpObjectFactory pgpF = new PgpObjectFactory(testMessage); @@ -215,6 +285,8 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests EncryptDecryptTest(); + TestCurve25519Message(); + Generate(); } @@ -240,7 +312,7 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests { certification.InitVerify(pubKeyRing.GetPublicKey()); - if (!certification.VerifyCertification((string)First(pubKeyRing.GetPublicKey().GetUserIds()), pubKeyRing.GetPublicKey())) + if (!certification.VerifyCertification(First(pubKeyRing.GetPublicKey().GetUserIds()), pubKeyRing.GetPublicKey())) { Fail("subkey certification does not verify"); } diff --git a/crypto/test/src/openpgp/test/PgpEdDsaTest.cs b/crypto/test/src/openpgp/test/PgpEdDsaTest.cs new file mode 100644 index 000000000..c5b25320c --- /dev/null +++ b/crypto/test/src/openpgp/test/PgpEdDsaTest.cs @@ -0,0 +1,334 @@ +using System; +using System.Collections.Generic; +using System.IO; + +using NUnit.Framework; + +using Org.BouncyCastle.Crypto.Generators; +using Org.BouncyCastle.Crypto.Parameters; +using Org.BouncyCastle.Security; +using Org.BouncyCastle.Utilities; +using Org.BouncyCastle.Utilities.Encoders; +using Org.BouncyCastle.Utilities.Test; + +namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests +{ + [TestFixture] + public class PgpEdDsaTest + : SimpleTest + { + private static readonly string edDSASampleKey = + "-----BEGIN PGP PUBLIC KEY BLOCK-----\n" + + "Comment: Alice's OpenPGP certificate\n" + + "Comment: https://www.ietf.org/id/draft-bre-openpgp-samples-01.html\n" + + "\n" + + "mDMEXEcE6RYJKwYBBAHaRw8BAQdArjWwk3FAqyiFbFBKT4TzXcVBqPTB3gmzlC/U\n" + + "b7O1u120JkFsaWNlIExvdmVsYWNlIDxhbGljZUBvcGVucGdwLmV4YW1wbGU+iJAE\n" + + "ExYIADgCGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQTrhbtfozp14V6UTmPy\n" + + "MVUMT0fjjgUCXaWfOgAKCRDyMVUMT0fjjukrAPoDnHBSogOmsHOsd9qGsiZpgRnO\n" + + "dypvbm+QtXZqth9rvwD9HcDC0tC+PHAsO7OTh1S1TC9RiJsvawAfCPaQZoed8gK4\n" + + "OARcRwTpEgorBgEEAZdVAQUBAQdAQv8GIa2rSTzgqbXCpDDYMiKRVitCsy203x3s\n" + + "E9+eviIDAQgHiHgEGBYIACAWIQTrhbtfozp14V6UTmPyMVUMT0fjjgUCXEcE6QIb\n" + + "DAAKCRDyMVUMT0fjjlnQAQDFHUs6TIcxrNTtEZFjUFm1M0PJ1Dng/cDW4xN80fsn\n" + + "0QEA22Kr7VkCjeAEC08VSTeV+QFsmz55/lntWkwYWhmvOgE=\n" + + "=iIGO\n" + + "-----END PGP PUBLIC KEY BLOCK-----\n"; + + private static readonly string edDSASecretKey = + "-----BEGIN PGP PRIVATE KEY BLOCK-----\n" + + "Comment: Alice's OpenPGP Transferable Secret Key\n" + + "Comment: https://www.ietf.org/id/draft-bre-openpgp-samples-01.html\n" + + "\n" + + "lFgEXEcE6RYJKwYBBAHaRw8BAQdArjWwk3FAqyiFbFBKT4TzXcVBqPTB3gmzlC/U\n" + + "b7O1u10AAP9XBeW6lzGOLx7zHH9AsUDUTb2pggYGMzd0P3ulJ2AfvQ4RtCZBbGlj\n" + + "ZSBMb3ZlbGFjZSA8YWxpY2VAb3BlbnBncC5leGFtcGxlPoiQBBMWCAA4AhsDBQsJ\n" + + "CAcCBhUKCQgLAgQWAgMBAh4BAheAFiEE64W7X6M6deFelE5j8jFVDE9H444FAl2l\n" + + "nzoACgkQ8jFVDE9H447pKwD6A5xwUqIDprBzrHfahrImaYEZzncqb25vkLV2arYf\n" + + "a78A/R3AwtLQvjxwLDuzk4dUtUwvUYibL2sAHwj2kGaHnfICnF0EXEcE6RIKKwYB\n" + + "BAGXVQEFAQEHQEL/BiGtq0k84Km1wqQw2DIikVYrQrMttN8d7BPfnr4iAwEIBwAA\n" + + "/3/xFPG6U17rhTuq+07gmEvaFYKfxRB6sgAYiW6TMTpQEK6IeAQYFggAIBYhBOuF\n" + + "u1+jOnXhXpROY/IxVQxPR+OOBQJcRwTpAhsMAAoJEPIxVQxPR+OOWdABAMUdSzpM\n" + + "hzGs1O0RkWNQWbUzQ8nUOeD9wNbjE3zR+yfRAQDbYqvtWQKN4AQLTxVJN5X5AWyb\n" + + "Pnn+We1aTBhaGa86AQ==\n" + + "=n8OM\n" + + "-----END PGP PRIVATE KEY BLOCK-----\n"; + + private static readonly string revBlock = + "-----BEGIN PGP PUBLIC KEY BLOCK-----\n" + + "Comment: Alice's revocation certificate\n" + + "Comment: https://www.ietf.org/id/draft-bre-openpgp-samples-01.html\n" + + "\n" + + "iHgEIBYIACAWIQTrhbtfozp14V6UTmPyMVUMT0fjjgUCXaWkOwIdAAAKCRDyMVUM\n" + + "T0fjjoBlAQDA9ukZFKRFGCooVcVoDVmxTaHLUXlIg9TPh2f7zzI9KgD/SLNXUOaH\n" + + "O6TozOS7C9lwIHwwdHdAxgf5BzuhLT9iuAM=\n" + + "=Tm8h\n" + + "-----END PGP PUBLIC KEY BLOCK-----\n"; + + public override string Name + { + get { return "PgpEdDsaTest"; } + } + + private void EncryptDecryptTest(PgpPublicKey pubKey, PgpPrivateKey secKey) + { + byte[] text = {(byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o', (byte)' ', (byte)'w', (byte)'o', (byte)'r', (byte)'l', (byte)'d', (byte)'!', (byte)'\n'}; + + PgpLiteralDataGenerator lData = new PgpLiteralDataGenerator(); + MemoryStream ldOut = new MemoryStream(); + Stream pOut = lData.Open(ldOut, PgpLiteralDataGenerator.Utf8, PgpLiteralData.Console, text.Length, DateTime.UtcNow); + + pOut.Write(text, 0, text.Length); + pOut.Close(); + + byte[] data = ldOut.ToArray(); + + MemoryStream cbOut = new MemoryStream(); + + PgpEncryptedDataGenerator cPk = new PgpEncryptedDataGenerator(SymmetricKeyAlgorithmTag.Cast5, new SecureRandom()); + cPk.AddMethod(pubKey); + + Stream cOut = cPk.Open(new UncloseableStream(cbOut), data.Length); + + cOut.Write(data, 0, data.Length); + cOut.Close(); + + PgpObjectFactory pgpF = new PgpObjectFactory(cbOut.ToArray()); + + PgpEncryptedDataList encList = (PgpEncryptedDataList)pgpF.NextPgpObject(); + + PgpPublicKeyEncryptedData encP = (PgpPublicKeyEncryptedData)encList[0]; + + Stream clear = encP.GetDataStream(secKey); + + pgpF = new PgpObjectFactory(clear); + + PgpLiteralData ld = (PgpLiteralData)pgpF.NextPgpObject(); + + clear = ld.GetInputStream(); + MemoryStream bOut = new MemoryStream(); + + int ch; + while ((ch = clear.ReadByte()) >= 0) + { + bOut.WriteByte((byte)ch); + } + + byte[] output = bOut.ToArray(); + + if (!AreEqual(output, text)) + { + Fail("wrong plain text in generated packet"); + } + } + + private void KeyRingTest() + { + SecureRandom random = new SecureRandom(); + + string identity = "eric@bouncycastle.org"; + char[] passPhrase = "Hello, world!".ToCharArray(); + + Ed25519KeyPairGenerator edKp = new Ed25519KeyPairGenerator(); + edKp.Init(new Ed25519KeyGenerationParameters(random)); + + PgpKeyPair dsaKeyPair = new PgpKeyPair(PublicKeyAlgorithmTag.EdDsa, edKp.GenerateKeyPair(), DateTime.UtcNow); + + X25519KeyPairGenerator dhKp = new X25519KeyPairGenerator(); + dhKp.Init(new X25519KeyGenerationParameters(random)); + + PgpKeyPair dhKeyPair = new PgpKeyPair(PublicKeyAlgorithmTag.ECDH, dhKp.GenerateKeyPair(), DateTime.UtcNow); + + EncryptDecryptTest(dhKeyPair.PublicKey, dhKeyPair.PrivateKey); + + PgpKeyRingGenerator keyRingGen = new PgpKeyRingGenerator(PgpSignature.PositiveCertification, dsaKeyPair, + identity, SymmetricKeyAlgorithmTag.Aes256, passPhrase, true, null, null, random); + + keyRingGen.AddSubKey(dhKeyPair); + + MemoryStream secretOut = new MemoryStream(); + + PgpSecretKeyRing secRing = keyRingGen.GenerateSecretKeyRing(); + + PgpPublicKeyRing pubRing = keyRingGen.GeneratePublicKeyRing(); + + secRing.Encode(secretOut); + + secretOut.Close(); + secRing = new PgpSecretKeyRing(secretOut.ToArray()); + + var publicKeys = new List<PgpPublicKey>(secRing.GetPublicKeys()); + + PgpPublicKey sKey = publicKeys[1]; + PgpPublicKey vKey = secRing.GetPublicKey(); + + int count = 0; + foreach (var sig in sKey.GetSignatures()) + { + if (sig.KeyId == vKey.KeyId + && sig.SignatureType == PgpSignature.SubkeyBinding) + { + count++; + sig.InitVerify(vKey); + + if (!sig.VerifyCertification(vKey, sKey)) + { + Fail("failed to verify sub-key signature."); + } + } + } + + IsTrue(count == 1); + + secRing = new PgpSecretKeyRing(secretOut.ToArray()); + PgpPublicKey pubKey = null; + PgpPrivateKey privKey = null; + + foreach (var candidate in secRing.GetPublicKeys()) + { + if (candidate.IsEncryptionKey) + { + pubKey = candidate; + privKey = secRing.GetSecretKey(pubKey.KeyId).ExtractPrivateKey(passPhrase); + break; + } + } + + EncryptDecryptTest(pubKey, privKey); + } + + public override void PerformTest() + { + ArmoredInputStream aIn = new ArmoredInputStream(new MemoryStream(Strings.ToByteArray(edDSASampleKey), false)); + + PgpPublicKeyRing pubKeyRing = new PgpPublicKeyRing(aIn); + + IsTrue(AreEqual(Hex.Decode("EB85 BB5F A33A 75E1 5E94 4E63 F231 550C 4F47 E38E"), + pubKeyRing.GetPublicKey().GetFingerprint())); + + aIn = new ArmoredInputStream(new MemoryStream(Strings.ToByteArray(edDSASecretKey), false)); + + PgpSecretKeyRing secRing = new PgpSecretKeyRing(aIn); + + IsTrue(secRing.GetSecretKey().IsSigningKey); + + PgpSignatureGenerator pgpGen = new PgpSignatureGenerator(PublicKeyAlgorithmTag.EdDsa, HashAlgorithmTag.Sha256); + + pgpGen.InitSign(PgpSignature.SubkeyBinding, secRing.GetSecretKey().ExtractPrivateKey(null)); + + PgpSignature sig = pgpGen.GenerateCertification(pubKeyRing.GetPublicKey(), + pubKeyRing.GetPublicKey(5145070902336167606L)); + + sig.InitVerify(pubKeyRing.GetPublicKey()); + + IsTrue(sig.VerifyCertification(pubKeyRing.GetPublicKey(), pubKeyRing.GetPublicKey(5145070902336167606L))); + + EncryptDecryptTest(pubKeyRing.GetPublicKey(5145070902336167606L), + secRing.GetSecretKey(5145070902336167606L).ExtractPrivateKey(null)); + + aIn = new ArmoredInputStream(new MemoryStream(Strings.ToByteArray(revBlock), false)); + + PgpSignatureList sigs = (PgpSignatureList)new PgpObjectFactory(aIn).NextPgpObject(); + + sig = sigs[0]; + + sig.InitVerify(pubKeyRing.GetPublicKey()); + + IsTrue(sig.VerifyCertification(pubKeyRing.GetPublicKey())); + + KeyRingTest(); + SksKeyTest(); + AliceKeyTest(); + } + + private void AliceKeyTest() + { + byte[] text = {(byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o', (byte)' ', (byte)'w', (byte)'o', (byte)'r', (byte)'l', (byte)'d', (byte)'!', (byte)'\n'}; + ArmoredInputStream aIn = new ArmoredInputStream(new MemoryStream(Strings.ToByteArray(edDSASampleKey), false)); + + PgpPublicKeyRing rng = new PgpPublicKeyRing(aIn); + + aIn = new ArmoredInputStream(new MemoryStream(Strings.ToByteArray(edDSASecretKey), false)); + + PgpSecretKeyRing secRing = new PgpSecretKeyRing(aIn); + + PgpPublicKey pubKey = rng.GetPublicKey(5145070902336167606L); + PgpPrivateKey privKey = secRing.GetSecretKey(5145070902336167606L).ExtractPrivateKey(null); + + PgpLiteralDataGenerator lData = new PgpLiteralDataGenerator(); + MemoryStream ldOut = new MemoryStream(); + Stream pOut = lData.Open(ldOut, PgpLiteralDataGenerator.Utf8, PgpLiteralData.Console, text.Length, DateTime.UtcNow); + + pOut.Write(text, 0, text.Length); + pOut.Close(); + + byte[] data = ldOut.ToArray(); + + MemoryStream cbOut = new MemoryStream(); + + PgpEncryptedDataGenerator cPk = new PgpEncryptedDataGenerator(SymmetricKeyAlgorithmTag.Aes128, true); + + cPk.AddMethod(pubKey); + + Stream cOut = cPk.Open(new UncloseableStream(cbOut), data.Length); + + cOut.Write(data, 0, data.Length); + cOut.Close(); + + PgpObjectFactory pgpF = new PgpObjectFactory(cbOut.ToArray()); + + PgpEncryptedDataList encList = (PgpEncryptedDataList)pgpF.NextPgpObject(); + + PgpPublicKeyEncryptedData encP = (PgpPublicKeyEncryptedData)encList[0]; + + Stream clear = encP.GetDataStream(privKey); + + pgpF = new PgpObjectFactory(clear); + + PgpLiteralData ld = (PgpLiteralData)pgpF.NextPgpObject(); + + clear = ld.GetInputStream(); + MemoryStream bOut = new MemoryStream(); + + int ch; + while ((ch = clear.ReadByte()) >= 0) + { + bOut.WriteByte((byte)ch); + } + + byte[] output = bOut.ToArray(); + + if (!AreEqual(output, text)) + { + Fail("wrong plain text in generated packet"); + } + } + + private void SksKeyTest() + { + byte[] data = Strings.ToByteArray("testing, 1, 2, 3, testing..."); + + ArmoredInputStream aIn = new ArmoredInputStream(GetTestDataAsStream("openpgp.eddsa-sks-pub-keyring.asc")); + + // make sure we can parse it without falling over. + PgpPublicKeyRing rng = new PgpPublicKeyRing(aIn); + + PgpEncryptedDataGenerator encDataGen = new PgpEncryptedDataGenerator(SymmetricKeyAlgorithmTag.Aes128, true); + + encDataGen.AddMethod(rng.GetPublicKey(6752245936421807937L)); + + MemoryStream cbOut = new MemoryStream(); + + Stream cOut = encDataGen.Open(new UncloseableStream(cbOut), data.Length); + cOut.Write(data, 0, data.Length); + cOut.Close(); + } + + [Test] + public void TestFunction() + { + string resultText = Perform().ToString(); + + Assert.AreEqual(Name + ": Okay", resultText); + } + } +} diff --git a/crypto/test/src/openpgp/test/PgpKeyRingTest.cs b/crypto/test/src/openpgp/test/PgpKeyRingTest.cs index a5dc4963b..821a7f295 100644 --- a/crypto/test/src/openpgp/test/PgpKeyRingTest.cs +++ b/crypto/test/src/openpgp/test/PgpKeyRingTest.cs @@ -1346,6 +1346,35 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests + "WDoIM5gfjeZgwht1vl6+7J+h20yjFrBdf7gJj9OcIGmwlpQ56qzbT4U++mw3" + "pW2tN2VuYtreceEoI4B6yUGMEhI9t/asLgn7wEAU2lpuE7ACAAM="); + private static readonly byte[] curve25519Pub = Base64.Decode( + "mDMEXEzydhYJKwYBBAHaRw8BAQdAwHPDYhq7hIsCT0jHNxGh4Mbao9kDkcHZilME" + + "jfgnnG60N1Rlc3QgS2V5IChEbyBub3QgdXNlIGZvciByZWFsLikgPHRlc3RAd29v" + + "ZHMtZ2VibGVyLmNvbT6IlgQTFggAPhYhBIuq+f4gKmIa9ZKEqJdUhr00IJstBQJc" + + "TPJ2AhsDBQkB4TOABQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEJdUhr00IJst" + + "dHAA/RDOjus5OZL2m9Q9dxOVnWNguT7Cr5cWdJxUeKAWE2c6AQCcQZWA4SmV1dkJ" + + "U0XKmLeu3xWDpqrydT4+vQXb/Qm9B7g4BFxM8nYSCisGAQQBl1UBBQEBB0AY3XTS" + + "6S1pwFNc1QhNpEKTStG+LAJpiHPK9QyXBbW9dQMBCAeIfgQYFggAJhYhBIuq+f4g" + + "KmIa9ZKEqJdUhr00IJstBQJcTPJ2AhsMBQkB4TOAAAoJEJdUhr00IJstmAsBAMRJ" + + "pvh8iegwrJDMoQc53ZqDRsbieElV6ofB80a+jkzZAQCgpAaY4hZc8GUan2JIqkg0" + + "gs23h4au7H79KqXYG4a+Bg=="); + + private static readonly byte[] curve25519Priv = Base64.Decode( + "lIYEXEzydhYJKwYBBAHaRw8BAQdAwHPDYhq7hIsCT0jHNxGh4Mbao9kDkcHZilME" + + "jfgnnG7+BwMCgEr7OFDl3dTpT73rmw6vIwiTGqjx+Xbe8cq4l24q2AOtzO+UR97q" + + "7ypL41jtt7BY7uoxhF+NCKzYEtRoqyaM0lfjDlOVRJP6SYRixK2UHLQ3VGVzdCBL" + + "ZXkgKERvIG5vdCB1c2UgZm9yIHJlYWwuKSA8dGVzdEB3b29kcy1nZWJsZXIuY29t" + + "PoiWBBMWCAA+FiEEi6r5/iAqYhr1koSol1SGvTQgmy0FAlxM8nYCGwMFCQHhM4AF" + + "CwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQl1SGvTQgmy10cAD9EM6O6zk5kvab" + + "1D13E5WdY2C5PsKvlxZ0nFR4oBYTZzoBAJxBlYDhKZXV2QlTRcqYt67fFYOmqvJ1" + + "Pj69Bdv9Cb0HnIsEXEzydhIKKwYBBAGXVQEFAQEHQBjddNLpLWnAU1zVCE2kQpNK" + + "0b4sAmmIc8r1DJcFtb11AwEIB/4HAwItKjH+kGqkMelkEdIRxSLFeCsB/A64n+os" + + "X9nWVYsrixEWT5JcRWBniI1PKt9Cm15Yt8KQSAFDJIj5tnEm28x5RM0CzFHQ9Ej2" + + "8Q2Lt0RoiH4EGBYIACYWIQSLqvn+ICpiGvWShKiXVIa9NCCbLQUCXEzydgIbDAUJ" + + "AeEzgAAKCRCXVIa9NCCbLZgLAQDESab4fInoMKyQzKEHOd2ag0bG4nhJVeqHwfNG" + + "vo5M2QEAoKQGmOIWXPBlGp9iSKpINILNt4eGrux+/Sql2BuGvgY="); + + //private static readonly char[] curve25519Pwd = "foobar".ToCharArray(); + [Test] public void PerformTest1() { @@ -1744,15 +1773,12 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests [Test] public void PerformTest4() { - PgpSecretKeyRingBundle secretRings1 = new PgpSecretKeyRingBundle(sec4); - int count = 0; - + PgpSecretKeyRingBundle secretRings = new PgpSecretKeyRingBundle(sec4); + byte[] encRing = secretRings.GetEncoded(); + secretRings = new PgpSecretKeyRingBundle(encRing); - byte[] encRing = secretRings1.GetEncoded(); - - PgpSecretKeyRingBundle secretRings2 = new PgpSecretKeyRingBundle(encRing); - - foreach (PgpSecretKeyRing pgpSec1 in secretRings1.GetKeyRings()) + int count = 0; + foreach (PgpSecretKeyRing pgpSec1 in secretRings.GetKeyRings()) { count++; @@ -2486,22 +2512,22 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests [Test] public void PublicKeyRingWithX509Test() { - checkPublicKeyRingWithX509(pubWithX509); + CheckPublicKeyRingWithX509(pubWithX509); PgpPublicKeyRing pubRing = new PgpPublicKeyRing(pubWithX509); - checkPublicKeyRingWithX509(pubRing.GetEncoded()); + CheckPublicKeyRingWithX509(pubRing.GetEncoded()); } [Test] public void SecretKeyRingWithPersonalCertificateTest() { - checkSecretKeyRingWithPersonalCertificate(secWithPersonalCertificate); + CheckSecretKeyRingWithPersonalCertificate(secWithPersonalCertificate); PgpSecretKeyRingBundle secRing = new PgpSecretKeyRingBundle(secWithPersonalCertificate); - checkSecretKeyRingWithPersonalCertificate(secRing.GetEncoded()); + CheckSecretKeyRingWithPersonalCertificate(secRing.GetEncoded()); } - private void checkSecretKeyRingWithPersonalCertificate( + private void CheckSecretKeyRingWithPersonalCertificate( byte[] keyRing) { PgpSecretKeyRingBundle secCol = new PgpSecretKeyRingBundle(keyRing); @@ -2523,21 +2549,20 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests } } - private void checkPublicKeyRingWithX509( - byte[] keyRing) + private void CheckPublicKeyRingWithX509(byte[] keyRing) { PgpPublicKeyRing pubRing = new PgpPublicKeyRing(keyRing); var en = pubRing.GetPublicKeys().GetEnumerator(); if (en.MoveNext()) { - PgpPublicKey key = (PgpPublicKey) en.Current; + PgpPublicKey key = en.Current; var sEn = key.GetSignatures().GetEnumerator(); if (sEn.MoveNext()) { - PgpSignature sig = (PgpSignature) sEn.Current; + PgpSignature sig = sEn.Current; if (sig.KeyAlgorithm != PublicKeyAlgorithmTag.Experimental_1) { Fail("experimental signature not found"); @@ -2581,6 +2606,26 @@ namespace Org.BouncyCastle.Bcpg.OpenPgp.Tests } } + [Test] + public void TestEdDsaRing() + { + ArmoredInputStream aIn = new ArmoredInputStream(GetTestDataAsStream("openpgp.eddsa-pub-keyring.asc")); + + // make sure we can parse it without falling over. + PgpPublicKeyRing rng = new PgpPublicKeyRing(aIn); + Assert.IsNotNull(rng); + } + + [Test] + public void TestCurve25519Ring() + { + // make sure we can parse it without falling over. + PgpPublicKeyRing rng = new PgpPublicKeyRing(new MemoryStream(curve25519Pub)); + + PgpSecretKeyRing priv = new PgpSecretKeyRing(new MemoryStream(curve25519Priv)); + Assert.IsNotNull(priv); + } + public override void PerformTest() { TestExpiryDate(); diff --git a/crypto/test/src/openssl/test/ReaderTest.cs b/crypto/test/src/openssl/test/ReaderTest.cs index 78b06abc2..8cb66d6a6 100644 --- a/crypto/test/src/openssl/test/ReaderTest.cs +++ b/crypto/test/src/openssl/test/ReaderTest.cs @@ -3,6 +3,7 @@ using System.IO; using NUnit.Framework; +using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Asn1.Cms; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Generators; @@ -42,6 +43,23 @@ namespace Org.BouncyCastle.OpenSsl.Tests get { return "PEMReaderTest"; } } + [Test] + public void TestGost3410_2012() + { + string data = + "-----BEGIN PRIVATE KEY-----" + + "MEMCAQAwHAYGKoUDAgITMBIGByqFAwICIwEGByqFAwICHgEEIIBidanaO5G6Go8A" + + "thlDjR9rk4hij/PpjAQvXJr+zTqz" + + "-----END PRIVATE KEY-----"; + + using (var textReader = new StringReader(data)) + { + var pemReader = new PemReader(textReader); + var pemObj = pemReader.ReadPemObject(); + PrivateKeyFactory.CreateKey(pemObj.Content); + } + } + public override void PerformTest() { IPasswordFinder pGet = new Password("secret".ToCharArray()); diff --git a/crypto/test/src/security/test/TestDotNetUtil.cs b/crypto/test/src/security/test/TestDotNetUtil.cs index b83a94a36..5d0177ead 100644 --- a/crypto/test/src/security/test/TestDotNetUtil.cs +++ b/crypto/test/src/security/test/TestDotNetUtil.cs @@ -22,6 +22,36 @@ namespace Org.BouncyCastle.Security.Tests [TestFixture] public class TestDotNetUtilities { +//#if NETCOREAPP1_0_OR_GREATER || NET47_OR_GREATER || NETSTANDARD1_6_OR_GREATER +#if NET6_0_OR_GREATER + [Test] + public void TestECDsaInterop() + { + byte[] data = new byte[1024]; + + for (int i = 0; i < 10; ++i) + { + var ecDsa = ECDsa.Create(ECCurve.NamedCurves.nistP256); + byte[] sig1 = ecDsa.SignData(data, HashAlgorithmName.SHA256); + + AsymmetricCipherKeyPair kp = DotNetUtilities.GetECDsaKeyPair(ecDsa); + Assert.IsNotNull(kp.Private); + Assert.IsNotNull(kp.Public); + ISigner signer = SignerUtilities.GetSigner("SHA256withPLAIN-ECDSA"); + + signer.Init(false, kp.Public); + signer.BlockUpdate(data, 0, data.Length); + Assert.IsTrue(signer.VerifySignature(sig1)); + + signer.Init(true, kp.Private); + signer.BlockUpdate(data, 0, data.Length); + byte[] sig2 = signer.GenerateSignature(); + + Assert.IsTrue(ecDsa.VerifyData(data, sig2, HashAlgorithmName.SHA256)); + } + } +#endif + //#if NET5_0_OR_GREATER #if NET6_0_OR_GREATER [SupportedOSPlatform("windows")] @@ -29,7 +59,7 @@ namespace Org.BouncyCastle.Security.Tests [Test] public void TestRsaInterop() { - for (int i = 0; i < 100; ++i) + for (int i = 0; i < 10; ++i) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(512); RSAParameters rp = rsa.ExportParameters(true); diff --git a/crypto/test/src/tls/test/LoggingDatagramTransport.cs b/crypto/test/src/tls/test/LoggingDatagramTransport.cs index f675b72fc..0ad15e065 100644 --- a/crypto/test/src/tls/test/LoggingDatagramTransport.cs +++ b/crypto/test/src/tls/test/LoggingDatagramTransport.cs @@ -34,25 +34,86 @@ namespace Org.BouncyCastle.Tls.Tests public virtual int Receive(byte[] buf, int off, int len, int waitMillis) { +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + return Receive(buf.AsSpan(off, len), waitMillis); +#else int length = m_transport.Receive(buf, off, len, waitMillis); if (length >= 0) { DumpDatagram("Received", buf, off, length); } return length; +#endif } +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + public virtual int Receive(Span<byte> buffer, int waitMillis) + { + int length = m_transport.Receive(buffer, waitMillis); + if (length >= 0) + { + DumpDatagram("Received", buffer[..length]); + } + return length; + } +#endif + public virtual void Send(byte[] buf, int off, int len) { +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + Send(buf.AsSpan(off, len)); +#else DumpDatagram("Sending", buf, off, len); m_transport.Send(buf, off, len); +#endif } +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + public virtual void Send(ReadOnlySpan<byte> buffer) + { + DumpDatagram("Sending", buffer); + m_transport.Send(buffer); + } +#endif + public virtual void Close() { m_transport.Close(); } +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + private void DumpDatagram(string verb, ReadOnlySpan<byte> buffer) + { + int len = buffer.Length; + long timestamp = DateTimeUtilities.CurrentUnixMs() - m_launchTimestamp; + StringBuilder sb = new StringBuilder("(+" + timestamp + "ms) " + verb + " " + len + " byte datagram:"); + for (int pos = 0; pos < len; ++pos) + { + if (pos % 16 == 0) + { + sb.Append(Environment.NewLine); + sb.Append(" "); + } + else if (pos % 16 == 8) + { + sb.Append('-'); + } + else + { + sb.Append(' '); + } + int val = buffer[pos] & 0xFF; + sb.Append(HEX_CHARS[val >> 4]); + sb.Append(HEX_CHARS[val & 0xF]); + } + Dump(sb.ToString()); + } +#else private void DumpDatagram(string verb, byte[] buf, int off, int len) { long timestamp = DateTimeUtilities.CurrentUnixMs() - m_launchTimestamp; @@ -78,6 +139,7 @@ namespace Org.BouncyCastle.Tls.Tests } Dump(sb.ToString()); } +#endif private void Dump(string s) { diff --git a/crypto/test/src/tls/test/MockDatagramAssociation.cs b/crypto/test/src/tls/test/MockDatagramAssociation.cs index ef317c7b6..3612bec40 100644 --- a/crypto/test/src/tls/test/MockDatagramAssociation.cs +++ b/crypto/test/src/tls/test/MockDatagramAssociation.cs @@ -58,6 +58,10 @@ namespace Org.BouncyCastle.Tls.Tests public virtual int Receive(byte[] buf, int off, int len, int waitMillis) { +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + return Receive(buf.AsSpan(off, len), waitMillis); +#else lock (m_receiveQueue) { if (m_receiveQueue.Count < 1) @@ -81,10 +85,45 @@ namespace Org.BouncyCastle.Tls.Tests Array.Copy(packet, 0, buf, off, copyLength); return copyLength; } +#endif } +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + public virtual int Receive(Span<byte> buffer, int waitMillis) + { + lock (m_receiveQueue) + { + if (m_receiveQueue.Count < 1) + { + try + { + Monitor.Wait(m_receiveQueue, waitMillis); + } + catch (ThreadInterruptedException) + { + // TODO Keep waiting until full wait expired? + } + + if (m_receiveQueue.Count < 1) + return -1; + } + + byte[] packet = m_receiveQueue[0]; + m_receiveQueue.RemoveAt(0); + int copyLength = System.Math.Min(buffer.Length, packet.Length); + packet.AsSpan(0, copyLength).CopyTo(buffer); + return copyLength; + } + } +#endif + public virtual void Send(byte[] buf, int off, int len) { +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + Send(buf.AsSpan(off, len)); +#else if (len > m_outer.m_mtu) { // TODO Simulate rejection? @@ -97,7 +136,27 @@ namespace Org.BouncyCastle.Tls.Tests m_sendQueue.Add(packet); Monitor.PulseAll(m_sendQueue); } +#endif + } + +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + public virtual void Send(ReadOnlySpan<byte> buffer) + { + if (buffer.Length > m_outer.m_mtu) + { + // TODO Simulate rejection? + } + + byte[] packet = buffer.ToArray(); + + lock (m_sendQueue) + { + m_sendQueue.Add(packet); + Monitor.PulseAll(m_sendQueue); + } } +#endif public virtual void Close() { diff --git a/crypto/test/src/tls/test/UnreliableDatagramTransport.cs b/crypto/test/src/tls/test/UnreliableDatagramTransport.cs index bdbfd6e67..7769db9d1 100644 --- a/crypto/test/src/tls/test/UnreliableDatagramTransport.cs +++ b/crypto/test/src/tls/test/UnreliableDatagramTransport.cs @@ -37,6 +37,10 @@ namespace Org.BouncyCastle.Tls.Tests public virtual int Receive(byte[] buf, int off, int len, int waitMillis) { +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + return Receive(buf.AsSpan(off, len), waitMillis); +#else long endMillis = DateTimeUtilities.CurrentUnixMs() + waitMillis; for (;;) { @@ -52,10 +56,37 @@ namespace Org.BouncyCastle.Tls.Tests waitMillis = (int)(endMillis - now); } +#endif } +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + public virtual int Receive(Span<byte> buffer, int waitMillis) + { + long endMillis = DateTimeUtilities.CurrentUnixMs() + waitMillis; + for (;;) + { + int length = m_transport.Receive(buffer, waitMillis); + if (length < 0 || !LostPacket(m_percentPacketLossReceiving)) + return length; + + Console.WriteLine("PACKET LOSS (" + length + " byte packet not received)"); + + long now = DateTimeUtilities.CurrentUnixMs(); + if (now >= endMillis) + return -1; + + waitMillis = (int)(endMillis - now); + } + } +#endif + public virtual void Send(byte[] buf, int off, int len) { +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + Send(buf.AsSpan(off, len)); +#else if (LostPacket(m_percentPacketLossSending)) { Console.WriteLine("PACKET LOSS (" + len + " byte packet not sent)"); @@ -64,7 +95,23 @@ namespace Org.BouncyCastle.Tls.Tests { m_transport.Send(buf, off, len); } +#endif + } + +//#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER +#if NET6_0_OR_GREATER + public virtual void Send(ReadOnlySpan<byte> buffer) + { + if (LostPacket(m_percentPacketLossSending)) + { + Console.WriteLine("PACKET LOSS (" + buffer.Length + " byte packet not sent)"); + } + else + { + m_transport.Send(buffer); + } } +#endif public virtual void Close() { diff --git a/crypto/test/src/tsp/test/TSPTestUtil.cs b/crypto/test/src/tsp/test/TSPTestUtil.cs index abe153ac1..4e08bd76d 100644 --- a/crypto/test/src/tsp/test/TSPTestUtil.cs +++ b/crypto/test/src/tsp/test/TSPTestUtil.cs @@ -347,7 +347,7 @@ namespace Org.BouncyCastle.Tsp.Tests else { _v3CertGen.AddExtension(X509Extensions.ExtendedKeyUsage, true, - ExtendedKeyUsage.GetInstance(new DerSequence(KeyPurposeID.IdKPTimeStamping))); + ExtendedKeyUsage.GetInstance(new DerSequence(KeyPurposeID.id_kp_timeStamping))); } X509Certificate _cert = _v3CertGen.Generate( diff --git a/crypto/test/src/util/test/SimpleTest.cs b/crypto/test/src/util/test/SimpleTest.cs index 0a2b5e991..21b4daabb 100644 --- a/crypto/test/src/util/test/SimpleTest.cs +++ b/crypto/test/src/util/test/SimpleTest.cs @@ -168,12 +168,12 @@ namespace Org.BouncyCastle.Utilities.Test private static string GetFullName(string name) { - return "BouncyCastle.Crypto.Tests.data." + name; + return "Org.BouncyCastle.data." + name; } private static string GetShortName(string fullName) { - return fullName.Substring("BouncyCastle.Crypto.Tests.data.".Length); + return fullName.Substring("Org.BouncyCastle.data.".Length); } private static string GetNewLine() diff --git a/packageIcon.png b/packageIcon.png new file mode 100644 index 000000000..076d9323b --- /dev/null +++ b/packageIcon.png Binary files differdiff --git a/version.json b/version.json index 58b079483..8902c71d7 100644 --- a/version.json +++ b/version.json @@ -1,16 +1,29 @@ { "$schema": "https://raw.githubusercontent.com/dotnet/Nerdbank.GitVersioning/master/src/NerdBank.GitVersioning/version.schema.json", - "version": "2.0-beta", + + // Don't increment build number during prerelease + "version": "2.0.0-beta.{height}", + + // Maintain assembly binding compatibility on .NET Framework + "assemblyVersion": { + "precision": "major" + }, + + // Start our build number from 0 "versionHeightOffset": -1, + "nugetPackageVersion": { "semVer": 2 }, + "publicReleaseRefSpec": [ "^refs/heads/master$", "^refs/heads/release/v\\d+\\.\\d+$" ], + "release": { "branchName": "release/v{version}", + "versionIncrement": "minor", "firstUnstableTag": "beta" } } |
