213510 2020-06-23 05:59:59 -0700 iOS 14: ITP causes issues for hybrid (WKWebView) apps using cookies for authentication etc. 2023-03-11 09:37:46 -0800 1 1 1 Unclassified WebKit New Bugs Safari Technology Preview iPhone / iPad Unspecified NEW https://bugs.webkit.org/show_bug.cgi?id=204109 https://bugs.webkit.org/show_bug.cgi?id=213879 https://niklas.merz.dev/corstest/ InRadar P2 Normal --- 1 niklasmerz webkit-unassigned adamdport ahill ajuma alexmh1 aurel barteo bfulgham cparkinson daniel david ddkilzer dvpdiner2 ekampf1 guo.li hadeja6100 juliosincesar maciej.zabielski+webkit msenn nuavel pablo.caselas pradeepgupta.6259 ricardosohn samiulla.hunasimarad tarsitodd tudor.dumitriu tudordumitriu webkit-bug-importer wilander woodywoodsta zaitsman oldest_to_newest 1665350 0 402550 niklasmerz 2020-06-23 05:59:59 -0700 Created attachment 402550 Test project We found a bug in our app (using WKWebView) on iOS 14 developer beta that images that are loaded from another origin don't load because the necessary cookie is not sent. This bug was already an issue in iOS 13.3 and fixed in iOS 13.3 beta 4. It now appears to be a regression in iOS 14 from the bug 204109. I added a small sample project which opens a test page in WKWebview. This page has two img tags. One of the loads the image from the same origin, one from another one. Both images need a cookie, otherwise an error is thrown. The cookies for thesse images are set in Swift code before opening the WebView. If I run this project with two devices and iOS version, I get different result: * iOS 13.5.1: Both images are displayed at app launch * iOS 14 Developer Beta: Only the same origin image is displayed This bug looks to me like the bug in iOS 13.3 and can be reproduced with the same sample project and instructions: https://bugs.webkit.org/show_bug.cgi?id=204109 1665400 1 webkit-bug-importer 2020-06-23 08:46:19 -0700 <rdar://problem/64645720> 1665640 2 wilander 2020-06-23 20:32:20 -0700 Hi Niklas! Thanks for filing. We have yet to publish the WWDC video session on what's new in WKWebViews. The title is "Discover WKWebView enhancements" and it'll go live on Thursday June 25th: https://developer.apple.com/videos/play/wwdc2020/10188/ You should find it useful. Meanwhile, could you explain to us what your app is doing, how it makes use of cookies in cross-site requests, how many different domains are involved in these requests, and whether those domains are part of the same organization or spread across multiple orgs? Thanks! 1665650 3 niklasmerz 2020-06-23 23:16:08 -0700 Hi John. Thanks for the suggestion, looking forward to this session. I noticed some changes to Safari briefly in the keynote. Our app is an hybrid app using the Apache Cordova framework. Because it is built with this approach basically every external connection is a cross-site request. When the app launches it loads a web app in WKWebView running on a custom scheme handler with an origin like "ionic://localhost". If you want more information how Cordova works and why some things are like they are contact me. I am happy to discuss this and I have done quite a bit of troubleshooting especially with CORS issues for Cordova apps. Users of our app now enter their credentials for their on-premise installation of our server side product into the app that is the second origin. The app running in the main webview on our apps internal origin should now use cookies to connect to the configured external origin to load resources like images with the uesers session. Basically there are just those two origins involved but not always the same two. Each enterprise customer uses its own origin (server) and one origin is just the internal origin the app is running on. We need this flexibility to run the app on one origin and connect to a server the users configures in the app at runtime. Cross-origin cookies are important for the connection to the server the user set in the app to make use of the user session the server solution provides. We had this exact problem with iOS 13.3 and fortunately we got a fix from you really quickly in one of the betas. 1666615 4 wilander 2020-06-26 14:32:29 -0700 Thanks for the clarifications, Niklas. Could you provide us with info on what app this is and perhaps with a test account? You can email the details to me. Thanks! 1667855 5 niklasmerz 2020-06-30 23:34:34 -0700 (In reply to John Wilander from comment #4) > Thanks for the clarifications, Niklas. Could you provide us with info on > what app this is and perhaps with a test account? You can email the details > to me. Thanks! I hope you got my email earlier this week with details about the app I am talking about. I thought about mitigations for this issue in this particular app. Using WKURLSchemeHandler is presumably the best way to handle that. Probably we will discuss this more with the Cordova project https://github.com/apache/cordova-ios/issues/922 I started a poll targeted to Cordova developers on Twitter to ask how many use cookies in their app. Not that many people participated but 30% for yes on the first day turned to 50.7% for yes until today https://twitter.com/NiklasMaerz/status/1276417185204916225. That means to me that possibly some Cordova developers may notice issues when they test iOS 14. Using WKWebView (in Cordova) with this use case where the app runs on one origin and needs to talk to unknown servers on another origin has been very troublesome for me in the recent versions of iOS. iOS 13 had some challenges and we face very similar problems again with iOS 14. Living in fear of a breaking app with every iOS update is not a great developer experience. The "Discover WKWebView enhancements" session from WWDC 2020 was about the ever expanding API of WKWebView and I strongly believe an open discussion with the WebKit and Cordova communities would improve developing apps on the Cordova and iOS platform for many Cordova app developers out there. You can reach out to Cordova via email, Slack: https://cordova.apache.org/contribute/. I am happy to provide some insights around CORS and Cordova from my experience the last year or so. 1668136 6 wilander 2020-07-01 20:40:39 -0700 (In reply to Niklas Merz from comment #5) > (In reply to John Wilander from comment #4) > > Thanks for the clarifications, Niklas. Could you provide us with info on > > what app this is and perhaps with a test account? You can email the details > > to me. Thanks! > > I hope you got my email earlier this week with details about the app I am > talking about. Yes, and thank you for that! I've shared the information with the team. 1668493 7 niklasmerz 2020-07-02 23:40:02 -0700 We just found this change: https://bugs.webkit.org/show_bug.cgi?id=213889 How does it affect this issue? As explained the app is running on a custom scheme but needs to connect to a server that is selected by the user at runtime. So it won't be possible to enter all servers at build time in Info.plist. 1668504 8 wilander 2020-07-03 00:26:26 -0700 (In reply to Niklas Merz from comment #7) > We just found this change: https://bugs.webkit.org/show_bug.cgi?id=213889 > > How does it affect this issue? > > As explained the app is running on a custom scheme but needs to connect to a > server that is selected by the user at runtime. So it won't be possible to > enter all servers at build time in Info.plist. I don’t think that change affects you. It’s making sure custom schemes can be included in what we refer to as app-bound domains. You can read about app-bound domains here: https://webkit.org/blog/10882/app-bound-domains/ 1668505 9 wilander 2020-07-03 00:27:20 -0700 (In reply to John Wilander from comment #8) > (In reply to Niklas Merz from comment #7) > > We just found this change: https://bugs.webkit.org/show_bug.cgi?id=213889 > > > > How does it affect this issue? > > > > As explained the app is running on a custom scheme but needs to connect to a > > server that is selected by the user at runtime. So it won't be possible to > > enter all servers at build time in Info.plist. > > I don’t think that change affects you. It’s making sure custom schemes can > be included in what we refer to as app-bound domains. You can read about > app-bound domains here: https://webkit.org/blog/10882/app-bound-domains/ Or, I should say that change doesn’t affect how you use cookies. 1668510 10 niklasmerz 2020-07-03 01:11:18 -0700 That's what I thought. App-bound domains are not a solution from this problem. You commented in the other bug: > If possible, it would be nice to test that this'll work with the ITP relaxation for app-bound domains too. Why not relax ITP for custom schemes or webcontet from the apps bundle in WKWebView in some way? I am thinking about this for some time now. Cordova implemented a custom scheme to serve web content from the apps bundle. (The scheme and hostname is configurable now). So ITP does not protect users from malicious websites because the website is part of the app code. The webcontent in this case is just like a native app that want's to talk to external servers with cookie sessions. Why not introduce a custom scheme for serving local content (like localhost) and relax ITP for that scenario? Using file: has other problems with web content and CORS. Just thinking out loud. I am not sure about further implications and other problems. 1674174 11 niklasmerz 2020-07-23 05:05:50 -0700 I just noticed that the new behavior with ITP enabled only happens if the app is built with Xcode 12. The same app built with the release version of Xcode and installed through Testflight or the App Store works just fine. I was a bit confused at first so sharing this for others here. Any news APIs/options for hybrid apps?. We can use WKURLSchemeHandler to solve many CORS/ITP related issues but these solutions always feel very fragile and not future proof. As a Cordova developer I don't think it's good to have user apps break every major iOS version and us as framework and app developers needing to find a workaround for these breaking issues. WKWebView should be a solid foundation for hybrid apps. General web content requires other security considerations than web content that is bundled with the native app. Hybrid apps would just a need a good way to server content from the apps bundle and make requests to the internet without these security measures (CORS, ITP etc.) that are critical for the general web content. WKWURLSchemeHandler is a good start but it could be better. 1695172 12 tarsitodd 2020-10-06 09:00:20 -0700 Just wanted to add my two cents that this is a really big deal. All cookies not working in Cordova is a serious regression, and even though some solutions help, none of them fix all of the problems. We need help from Apple's end and it seems very discouraging that discussion stopped here nearly three months ago. 1695424 13 wilander 2020-10-06 18:12:05 -0700 (In reply to Todd from comment #12) > Just wanted to add my two cents that this is a really big deal. All cookies > not working in Cordova is a serious regression, and even though some > solutions help, none of them fix all of the problems. We need help from > Apple's end and it seems very discouraging that discussion stopped here > nearly three months ago. Thanks for commenting. As far as I know, we have received very few developer reports of this being an issue. That may be because developers aren't testing with betas or something else. I could also have missed them but I hope that's not the case. Niklas Merz tested right away and has communicated plenty with us on this change, as can be seen above. However, it would be good to hear from more developers both at WWDC sessions and during the long beta period after. There are a lot of changes that go into major releases and bugs that need to be screened, fixed, and put to test in subsequent betas. In this case, the change is deliberate and we'd have to understand more user cases to be able to consider any adjustments. The questions I asked Niklas Merz back in June are still valid: Could you explain to us what your app is doing, how it makes use of cookies in cross-site requests, how many different domains are involved in these requests, and whether those domains are part of the same organization or spread across multiple orgs? 1695429 14 tarsitodd 2020-10-06 18:41:45 -0700 Generally(In reply to John Wilander from comment #13) > (In reply to Todd from comment #12) > > Just wanted to add my two cents that this is a really big deal. All cookies > > not working in Cordova is a serious regression, and even though some > > solutions help, none of them fix all of the problems. We need help from > > Apple's end and it seems very discouraging that discussion stopped here > > nearly three months ago. > > Thanks for commenting. As far as I know, we have received very few developer > reports of this being an issue. That may be because developers aren't > testing with betas or something else. I could also have missed them but I > hope that's not the case. Shoot, I wish I could get feedback like this every time I complained lol. > Niklas Merz tested right away and has communicated plenty with us on this > change, as can be seen above. However, it would be good to hear from more > developers both at WWDC sessions and during the long beta period after. > There are a lot of changes that go into major releases and bugs that need to > be screened, fixed, and put to test in subsequent betas. In this case, the > change is deliberate and we'd have to understand more user cases to be able > to consider any adjustments. I'll try to be better about testing the betas in the future. It can be tricky because I work on one mac, and doing the iOS betas sometimes necessitates the XCode betas and the Safari beta and all of that. It can be tough to check > The questions I asked Niklas Merz back in June are still valid: > Could you explain to us what your app is doing, how it makes use of cookies > in cross-site requests, how many different domains are involved in these > requests, and whether those domains are part of the same organization or > spread across multiple orgs? So it's mainly one organization. Our organization's staging app is using the domain of https://staging.silverstreet.io for all of its networking, but with how Cordova works, our requesting URL is ionic://localhost. Maybe I'm able to match up the domains somehow using the custom schemes in Cordova, but I haven't figured it out yet. We also feed some data to google tag manager (analytics) and Twilio (messaging), but these aren't crucial to all requests after login like the onsite cookies are. We don't do anything fancy or non-standard I believe. We have an onsite log in flow that uses secure httpOnly cookies to authenticate the user. These cookies are used on subsequent network requests as well as websocket upgrade requests to subscribe to real-time updates. 1695528 15 adamdport 2020-10-07 07:31:31 -0700 Huge thank you to Niklas Merz for leading the discussions on these issues. I am also a Cordova (hybrid app) developer. I'd imagine there are a lot of developers that are just now seeing their employers prioritize the transition from UIWebView to WKWebView and will be facing this issue soon if not already. Our static content is packaged into the app and could be served from a custom schema (eg. foo://mydomain.com), but every XHR request will be over https, (eg. https://mydomain.com). A login request works fine, but the cookies in the header of the response are NOT set, and therefore subsequent API requests (which require authentication cookies) fail. I have NOT tried XCode 12 yet, but in light of the "very few developer reports of this being an issue" comment, I decided to make an account and chime in here. Cross origin cookies are critical to our app, and the track record of this issue makes me extremely nervous that it could break at any time: * broken in iOS13: https://bugs.webkit.org/show_bug.cgi?id=140205 * fixed in 13.2: https://bugs.webkit.org/show_bug.cgi?id=200857#c39 * broken again in 13.3: https://bugs.webkit.org/show_bug.cgi?id=204109 * fixed in 13.3 beta 4: https://bugs.webkit.org/show_bug.cgi?id=204109#c25 * broken again on ios14: (this issue) If you're looking for more developers to say "this is an issue" I'd be happy to start posting a link to this issue from the github and stackoverflow questions about it. Thanks all for sharing your experiences/ideas. 1695544 16 wilander 2020-10-07 08:23:31 -0700 (In reply to Adam Davenport from comment #15) > Huge thank you to Niklas Merz for leading the discussions on these issues. > > I am also a Cordova (hybrid app) developer. I'd imagine there are a lot of > developers that are just now seeing their employers prioritize the > transition from UIWebView to WKWebView and will be facing this issue soon if > not already. Our static content is packaged into the app and could be served > from a custom schema (eg. foo://mydomain.com), but every XHR request will be > over https, (eg. https://mydomain.com). A login request works fine, but the > cookies in the header of the response are NOT set, and therefore subsequent > API requests (which require authentication cookies) fail. I have NOT tried > XCode 12 yet, but in light of the "very few developer reports of this being > an issue" comment, I decided to make an account and chime in here. Cross > origin cookies are critical to our app, and the track record of this issue > makes me extremely nervous that it could break at any time: > > * broken in iOS13: https://bugs.webkit.org/show_bug.cgi?id=140205 > * fixed in 13.2: https://bugs.webkit.org/show_bug.cgi?id=200857#c39 > * broken again in 13.3: https://bugs.webkit.org/show_bug.cgi?id=204109 > * fixed in 13.3 beta 4: https://bugs.webkit.org/show_bug.cgi?id=204109#c25 > * broken again on ios14: (this issue) > > If you're looking for more developers to say "this is an issue" I'd be happy > to start posting a link to this issue from the github and stackoverflow > questions about it. Thanks all for sharing your experiences/ideas. Hi, Adam, and thanks for commenting! “Broken” is not an accurate description of how this works in iOS 14. It’s an announced, deliberate change. WKWebView now has tracking prevention enabled by default. The same questions are still valid: Could you explain to us what your app is doing, how it makes use of cookies in cross-site requests, how many different domains are involved in these requests, and whether those domains are part of the same organization or spread across multiple orgs? 1695545 17 niklasmerz 2020-10-07 08:29:09 -0700 Thanks Adam Davenport for putting together the track record. That's the timeline how it changed in the last year. 1695547 18 niklasmerz 2020-10-07 08:41:20 -0700 I tried to change the title of this bugzilla entry since it's indeed not really a bug. I am currently working on a built-in Cordova feature to get around these tighter limitations. But it does not feel right. Let's see if it becomes part of Cordova. Like said previously it would be awesome if hybrid frameworks like Cordova would have a way in WebKit to serve their bundled web code with a kind of special origin with the same freedoms like other native apps. WKUrlSchemeHandler is very powerfull and serves us kind of ok for this purpose but if WebKit could smooth out some rough edges it could have a big impact on many apps. 1695562 19 adamdport 2020-10-07 09:02:37 -0700 John Wilander by "broken" I meant *my app* is broken, sorry for the miscommunication. What worked with UiWebView now no longer works in WkWebView. > Could you explain to us what your app is doing I'd imagine all Cordova apps are roughly the same; I have a static website that makes XHR requests to a remote server, and Cordova packages it up into an app that I can deliver to customers. > how it makes use of cookies in cross-site requests Users make an XHR request with credentials. The response has authentication cookies which are required to be sent with every subsequent request. This isn't happening. > how many different domains are involved in these requests 2ish, the "fake" domain defined by my app scheme, eg. foo://mydomain.com this can be anything I want afaik, except http or https), and my remote API hosted under https://mydomain.com. > and whether those domains are part of the same organization or spread across multiple orgs Same organization. As I'm just a consumer of Cordova, I defer to Niklas regarding what Cordova is doing under the hood. I'm not done with my investigation, but in response to "it would be good to hear from more developers" I just felt obliged to say "I too am struggling with this" 1695607 20 wilander 2020-10-07 11:17:36 -0700 (In reply to Adam Davenport from comment #19) > John Wilander by "broken" I meant *my app* is broken, sorry for the > miscommunication. What worked with UiWebView now no longer works in > WkWebView. > > > Could you explain to us what your app is doing > > I'd imagine all Cordova apps are roughly the same; I have a static website > that makes XHR requests to a remote server, and Cordova packages it up into > an app that I can deliver to customers. > > > how it makes use of cookies in cross-site requests > > Users make an XHR request with credentials. The response has authentication > cookies which are required to be sent with every subsequent request. This > isn't happening. > > > how many different domains are involved in these requests > > 2ish, the "fake" domain defined by my app scheme, eg. foo://mydomain.com > this can be anything I want afaik, except http or https), and my remote API > hosted under https://mydomain.com. > > > and whether those domains are part of the same organization or spread across multiple orgs > > Same organization. Thank you! This is useful information. > As I'm just a consumer of Cordova, I defer to Niklas regarding what Cordova > is doing under the hood. I'm not done with my investigation, but in response > to "it would be good to hear from more developers" I just felt obliged to > say "I too am struggling with this" Sure. You're not on the hook to explain Cordova to me. :) However, we always try to understand what the needs and requirements are before considering solutions. "Allow all cookies" is an obvious solution but it has downsides that we are deliberately trying to remove. What it comes down to is how to provide just enough functionality for apps while not re-creating, in this case, cross-site tracking. As for hearing from multiple developers, it's very important for us to get details from a diverse set of sources. Sometimes you have a single developer who is very vocal about a use case that turns out to be very specific to their app or website. With a more complete picture, we are able to create solutions that serve many more developers and is much more stable. Hunting piecemeal use cases can get you to a messy place in the end. 1695789 21 dvpdiner2 2020-10-07 21:18:18 -0700 For the case described by Adam where an app needs to communicate with one domain (or a small of domains), would listing those specific domains in WKAppBoundDomains allow those cookies to work as expected? (Guessing based on bug 210674) 1697279 22 pablo.caselas 2020-10-13 09:22:28 -0700 My app is broken too. I am using cordova-plugin-ionic-webview (which uses WkWebView under the hood) I am sending xhr requests for the user to log in: (from ionic://app/**) and even though it receives those cookies (I use one as session and other as a way to know if the user has previously logged in with the device and if not, send them a mail whenever they login). As a hack for this, I am using Niklas proxy to do native HTTP requests, but it's not ideal. 1698011 23 bfulgham 2020-10-14 20:29:26 -0700 Would any developers running into this problem be willing to share the following? 1. How many different domains do you need to share cookies with? (It sounds like maybe two or three in many cases?) 2. Does your application need to interact with the general web using script or style sheet injection? 3. Could you share the name of your iOS App? If you are not comfortable posting that here, feel free to e-mail me at bfulgham@apple.com. 1698390 24 bfulgham 2020-10-15 17:11:42 -0700 (In reply to Darryl Pogue from comment #21) > For the case described by Adam where an app needs to communicate with one > domain (or a small of domains), would listing those specific domains in > WKAppBoundDomains allow those cookies to work as expected? (Guessing based > on bug 210674) That's an off-by-default experimental thing that isn't available in normal use. To clarify: When App-Bound domains are in use you have this behavior: (1) WKWebView would only have script injection and style injection capabilities on the sites listed in the set of app bound domains. (2) WKWebView marked as 'app bound' would be unable to navigate to domains outside of that set. I.e., if you wanted to support general web browsing, you would need to create a separate WebView for that use. This flag would have the following effect: (3) Cross-site cookie access between domains in the App-bound domain list would be permitted, and they would be protected from deletion. Is that behavior sufficient to meet your needs? Or would you still have problems with that mode? 1698404 25 dvpdiner2 2020-10-15 17:36:45 -0700 (In reply to Brent Fulgham from comment #24) > > (3) Cross-site cookie access between domains in the App-bound domain list > would be permitted, and they would be protected from deletion. > > Is that behavior sufficient to meet your needs? Or would you still have > problems with that mode? I think that would be sufficient for the common use case with Cordova (assuming a local scheme like app://localhost is counted as permitted). We already have a Cordova-enforced list of "allowed navigation" domains, so we'd likely want to encourage opting-in to the App-Bound WebView behaviour too. 1701233 26 alexmh1 2020-10-24 06:27:42 -0700 Hi all, I've submitted my fe(In reply to Brent Fulgham from comment #23) > Would any developers running into this problem be willing to share the > following? > > 1. How many different domains do you need to share cookies with? (It sounds > like maybe two or three in many cases?) > > 2. Does your application need to interact with the general web using script > or style sheet injection? > > 3. Could you share the name of your iOS App? > > If you are not comfortable posting that here, feel free to e-mail me at > bfulgham@apple.com. Hi, emailed this, thanks! Did we have a status update on this? 1701446 27 daniel 2020-10-26 07:23:51 -0700 (In reply to Brent Fulgham from comment #23) > Would any developers running into this problem be willing to share the > following? > > 1. How many different domains do you need to share cookies with? (It sounds > like maybe two or three in many cases?) > > 2. Does your application need to interact with the general web using script > or style sheet injection? > > 3. Could you share the name of your iOS App? > > If you are not comfortable posting that here, feel free to e-mail me at > bfulgham@apple.com. I emailed also my feedback to you. Any status update highly appreciated. Thank you very much. Daniel 1706312 28 david 2020-11-10 19:14:33 -0800 Thought I would chip in here also but seems Niklas has done a good job in outlining the problem. For my apps and we have 4 or so in the app store we need to have access to a list of max 3 domains per app. Again and like all the others it appears to only occur on latest xCode 12 and using xhr requests with cookie stripping (ITP). I believe you have all the information needed but if there is anything I can add please ask otherwise I am awaiting a solution. I am in a critical release window right now for a major update and thinking of compiling on XCode 11 as I am reluctant to implement a whole heap of bespoke work arounds. 1706779 29 daniel 2020-11-11 23:25:37 -0800 Hi All, Are there any news on this? Is the behaviour you described: "(3) Cross-site cookie access between domains in the App-bound domain list would be permitted, and they would be protected from deletion." testable? Sorry if this was announced somewhere else, but I could not find anything. Thanks Daniel 1711591 30 zaitsman 2020-12-02 20:12:26 -0800 Are there any updates? With iOS 14 and XCode 12, even if I request Tracking permission from users, and if I specify `WKAppBoundDomains` in my Info.plist and `limitsNavigationsToAppBoundDomains` the Cookies are not sent with XHR requests to those third-party domains. Is this expected? 1712028 31 samiulla.hunasimarad 2020-12-04 08:03:43 -0800 Did anyone got this working with by adding NSCrossWebsiteTrackingUsageDescription as suggested in the last part of the below documentation? Intelligent Tracking Prevention in WKWebView: https://webkit.org/blog/10882/app-bound-domains/ Best Regards, Sami 1715338 32 tudordumitriu 2020-12-17 01:34:12 -0800 I managed to get it to work only after adding NSCrossWebsiteTrackingUsageDescription and going in Settings and enabling 'Allow Cross-Website Tracking'. But since this requires user intervention is not desirable so are there any updates / plans on this? 1715354 33 niklasmerz 2020-12-17 02:53:47 -0800 I just checked the issue in Cordovas bug tracker again and just looking at the thumbs up count I suspect there are quite a few developers affected by this issue. https://github.com/apache/cordova-ios/issues/922 1717928 34 ricardosohn 2021-01-07 05:10:29 -0800 Our app too was affected by this change. Our use case is very similar to the one described by Niklas. We have a hybrid app using the Apache Cordova framework. As Niklas already said, when the app launches it loads a web app in WKWebView running on a custom scheme handler with an origin like "ionic://localhost". Using that approach, almost all external connections are considered cross-site requests. In our use case, the user provide a server URL (every client has their own backend server). The app then proceeds to load content from that external URL (such as full pages and images) with the user session. The content only loads if I set the 'NSCrossWebsiteTrackingUsageDescription' and go to the settings and enable 'Allow Cross-Website Tracking'. For the rest, I can fully quote Niklas: "We need this flexibility to run the app on one origin and connect to a server the users configures in the app at runtime. Cross-origin cookies are important for the connection to the server the user set in the app to make use of the user session the server solution provides." 1720146 35 ekampf1 2021-01-16 13:40:48 -0800 My company also has an app that has been affected by this change. It is very similar to the apps described in previous comments. It is Apache Cordova with web content bundled locally. The local content interacts with remote content in our hosting domain in the following manner: 1. The local HTML includes an IFrame to load HTML/JS content from the remote hosting domain. 2. The IFramed pages makes XHR requests to the hosting domain, which is the same domain from which the IFrame content was served. Authentication with the hosting domain uses cookies. Our server is emitting the cookies, and has taken the necessary steps to support CORS (Access-Control headers and same-site:none attribute on cookies). We run our app on multiple mobile platforms. Only on iOS are the cookies blocked. To clarify, by "blocked" I mean that the cookies are returned to the iOS app, but they are neither persisted nor included in subsequent HTTP requests. 1727748 36 nuavel 2021-02-10 13:48:50 -0800 WTF? No really, WTF? Why on earth app-bound domains (in fact all of them are: primary domain + subdomains) are not sharing cookies? This is do dumb. You guys haven't heard and not aware of session cookie commonly shared across all subdomains (ie. *.myapp.com)? I understand the point of ITP and apperciate Apple for taking care of my privacy by blocking annoying tracking bloatware, but why you didn't think about legit stuff? There are a lot of discussions going on on github, SO and other sites regarding this breaking change with no way to easily work around the constraint without dirty hacks or regressions in UX ("Allow Cross-Website Tracking" is confusing and misleading, because user session is not "Tracking"). What we should do given that WKWebView provides an essential part of our app hosted on dozen of subdomains (apps, resources, cdn, content, api) and we are a team of web developers and have no iOS developer in house? Now most of our team (Engineering, Management, QA) struggles in trying to find a workaround ASAP because otherwise our app would be broken for thousands of our users. Shame on you. 1727765 37 wilander 2021-02-10 14:13:25 -0800 (In reply to Mad from comment #36) > WTF? No really, WTF? > > Why on earth app-bound domains (in fact all of them are: primary domain + > subdomains) are not sharing cookies? This is do dumb. Cookies matching the top frame registrable domain (eTLD+1) are available according to the regular cookie scoping rules (domain attribute etc). No blocking of those. > You guys haven't heard and not aware of session cookie commonly shared > across all subdomains (ie. *.myapp.com)? Session cookies typically mean non-persistent cookies. What you refer to are same-site cookies or perhaps same-party cookies. Regardless, the cookies you refer to are available and not blocked if their domain indeed matches the top frame registrable domain. > I understand the point of ITP and apperciate Apple for taking care of my > privacy by blocking annoying tracking bloatware, but why you didn't think > about legit stuff? > > There are a lot of discussions going on on github, SO and other sites > regarding this breaking change with no way to easily work around the > constraint without dirty hacks or regressions in UX ("Allow Cross-Website > Tracking" is confusing and misleading, because user session is not > "Tracking"). As mentioned, the "session cookies" you refer to are available. > What we should do given that WKWebView provides an essential part of our app > hosted on dozen of subdomains (apps, resources, cdn, content, api) and we > are a team of web developers and have no iOS developer in house? > > Now most of our team (Engineering, Management, QA) struggles in trying to > find a workaround ASAP because otherwise our app would be broken for > thousands of our users. > > Shame on you. We try to use a respectful tone in these bug comments. I hope you are willing to do so too. 1727840 38 nuavel 2021-02-10 15:18:20 -0800 (In reply to John Wilander from comment #37) > As mentioned, the "session cookies" you refer to are available. We use a similar approach (Cordova) described in the comments above and having the same issues. The only way to work around this is to manually enable "Allow Cross-Website Tracking" toggle, albeit there is nothing related to "Tracking". Session cookie is a valid example. Typically web apps have more shared data required across app-bound subdomains, including all sort of cookies (not only non-persistent), non-stripped header values ("Referrer", "Origin") and custom headers (CORS). Everything worked perfectly until this breaking change introduced along with ITP. It has been 7 months since the bug was reported here and still no good solution available for all cases. 1727842 39 wilander 2021-02-10 15:26:23 -0800 (In reply to Mad from comment #38) > (In reply to John Wilander from comment #37) > > > As mentioned, the "session cookies" you refer to are available. > > We use a similar approach (Cordova) described in the comments above and > having the same issues. The only way to work around this is to manually > enable "Allow Cross-Website Tracking" toggle, albeit there is nothing > related to "Tracking". > > Session cookie is a valid example. Typically web apps have more shared data > required across app-bound subdomains, including all sort of cookies (not > only non-persistent), non-stripped header values ("Referrer", "Origin") and > custom headers (CORS). Then the domains you refer to do not match the top frame, they are third-party cookies, and subdomains or no subdomains doesn't matter. If the resource domain doesn't match the top frame's registrable domain, it is considered a third-party request. I just wanted to make that clear so that you don't think this has anything to do with subdomains. > Everything worked perfectly until this breaking change introduced along with > ITP. > > It has been 7 months since the bug was reported here and still no good > solution available for all cases. 1728003 40 tudor.dumitriu 2021-02-11 01:22:58 -0800 Hello there Need to say that lots of us share Mad's frustration in regards to this issue, and even if there are workarounds they are time consuming and hard to implement. Here is our situation, we have a cordova application packed and working perfectly on ios. The app is upgraded to latest cordova platform, hence running under app://localhost and is connecting to 2 different APIS, one https://db.domain.com:1234 (that is used for authentication and data) and https://db.domain.com:4567 (for other functionality). The problem is that even if the first call to https://db.domain.com:1234/_session returns correctly with the header Set-Cookie: AuthSession=yyyy; Version=1; Expires=Sat, 13-Mar-2021 11:23:42 GMT; Max-Age=2600000; Secure; Domain=domain.com; Path=/; HttpOnly; SameSite=None The next call to https://db.domain.com:1234/ doesn't have the cookie anymore and any subsequent calls fail (and ofc any calls to https://db.domain.com:4567 as well) So, just to get things a little clearer the problem is the fact we are running the app under app://localhost (top frame registrable domain (eTLD+1)) but consuming an API from https://db.domain.com hence (which is not matching the same site rule). Since we cannot control that the only option would be to list these accepted domains in a setting. So the questions is, is there any chance of getting this fixed by the Apple team, or is actually someone working on it, are any estimations on when will this be shipped? Or should we just try to find alternatives (again, quite hard to implement) Thanks 1735332 41 adamdport 2021-03-03 09:58:37 -0800 To respond to the "has anyone got this working" posts, I finally got my Cordova app working! The authentication cookie set by the login response from my remote server now persists for subsequent requests, and even seems to persist in IFrames and the InAppBrowser plugin! > The App-Bound Domains feature takes steps to preserve user privacy by limiting the domains on which an app can utilize powerful APIs to track users during in-app browsing. Applications that opt-in to this new feature can specify up to 10 “app-bound” domains using a new Info.plist key — WKAppBoundDomains If you're like me and your app needs to talk to 10 or fewer remotes, you can add your remote domain to your plist file and opt in using limitsNavigationsToAppBoundDomains. https://webkit.org/blog/10882/app-bound-domains/ AppBoundDomains only affect iOS14, and don't exist prior, seems to work fine in iOS 13 without them. You'll also need to configure your remote to enable CORS, including adding the origin defined by the scheme/hostname (eg. app://localhost or foo://mydomain.com) in the cordova config. This approach won't work for OP (Niklas) since his app doesn't know the domain of the remote at build time. For most of us, however, I think the issue with authentication cookies not persisting can be resolved by setting up AppBoundDomains and CORS. This does NOT work out of the box, however, and I've created a github issue for Cordova-ios to support AppBoundDomains, since I currently need to both modify my plist and opt in to AppBoundDomains after building cordova. That issue can be tracked here: https://github.com/apache/cordova-ios/issues/1088. In addition, you'll need to set withCredentials: true on your XHR requests to enable cookies to be set/sent cross origin! https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials Kinda frustrating that this isn't all documented somewhere (cordova docs), but hopefully I've done that here. I hope you guys find this helpful, feel free to share successes/failures/questions to help others. Thanks all. 1737047 42 adamdport 2021-03-08 06:32:05 -0800 I tried changing my app's scheme/hostname to "foo://bar.baz" instead of "foo://localhost" and I'm no longer able to persist cookies on XHR requests to http://localhost. Both "localhost" and "bar.baz" are listed in WKAppBoundDomains and I added foo:bar.baz as an allowed origin on localhost. So it looks like in its current state, hybrid apps will only be able to persist cookies on calls to one domain? 1738599 43 ahill 2021-03-11 13:35:05 -0800 I want to throw my hat in the ring here. I have a similar app setup to Ricardo Sohn. We don't know what server will be connected to until runtime as they are customer hosted and often times there is a load balancer in front of that back-end the app may be connecting to which will also be inserting its own cookie. I am currently using Niklas's proxy similar to others in this thread but there has to be a better way. 1739305 44 hadeja6100 2021-03-14 21:36:12 -0700 i face the same issue on the roblox ids application get from this website https://robloxidshub.com/. Still looking for the solution anyone here guide me? 1740659 45 aurel 2021-03-17 04:31:26 -0700 Hi all, Let's consider the following situation (that I am struggling currently with): - I have IoS app A - IdP SSO Proxy - 2 federated IdP's -> IdP1 and IdP2 1. The user choose IdP1 to register with 2. He gets the confirmation email 3. Open email app and click on the confirmation 4. The IdP1 process all the data and perform a post back to IdP proxy 5. The IdP proxy cannot find his cookies, because is no shared cookie storage between apps developed by different developers and even if the use is authenticated, throws a 400 because can't match the correlation id None of the cookies are cross-domain, the only problem it is with the cookie storage, and basically it is very, very difficult to use federated SSO with native apps, or at least in this moment I am running out of ideas. Regards, Aurel 1768230 46 cparkinson 2021-06-09 10:30:36 -0700 Has anyone found a resolution to this issue? Now that building with Xcode 12 is required, we can no longer get our cookies to persist between ionic://localhost and our iframes without setting "NSCrossWebsiteTrackingUsageDescription" in our plist. We have tried using App Bound Domains with the few domains that we need to support and have been unsuccessful in restoring cookie functionality. Setting "NSCrossWebsiteTrackingUsageDescription" is confusing for our users because we aren't using cookies beyond domains that we own. We have also seen that the opt in rate for this setting is around 4%. https://www.engadget.com/ios-14-5-users-reject-app-tracking-165309407.html This doesn't work for us because without this setting the app will not work as expected and we can't have 96% of our users reaching out for support. 1768687 47 ekampf1 2021-06-10 13:04:19 -0700 We found a work-around for Cordova mobile apps, so not sure if this applies to your case or not. In the config.xml file for your Cordova app, you can set the "HostName" preference to the domain name of your app, like this: <preference name="HostName" value="domain.example.com"/> Where the domain name is that of the content you are loading into the WebView. After doing this, iOS stopped blocking cookies from that domain. 1774162 48 juliosincesar 2021-07-01 10:44:44 -0700 cookies is the main pain point of WKWebView users, if you don't receive a lot of reports is probably because users are not aware of this bug tracker and they report in the regular Apple issue tracker, which is a black box. I have reported a few issues there in the past and as far as I know, they have not been fixed not received any response. Also, most WKWebView users use it through Apache Cordova or Ionic Capacitor, so they report the issues to them instead of reporting to you. I try to point them to this direction when they do. In example, you can see this Capacitor issue about document.cookie not working when using a custom scheme with 60 comments. https://github.com/ionic-team/capacitor/issues/1373 there are others about XHR cookies too 1774187 49 wilander 2021-07-01 11:47:25 -0700 (In reply to jcesarmobile from comment #48) > cookies is the main pain point of WKWebView users, if you don't receive a > lot of reports is probably because users are not aware of this bug tracker > and they report in the regular Apple issue tracker, which is a black box. I > have reported a few issues there in the past and as far as I know, they have > not been fixed not received any response. > > Also, most WKWebView users use it through Apache Cordova or Ionic Capacitor, > so they report the issues to them instead of reporting to you. I try to > point them to this direction when they do. > > In example, you can see this Capacitor issue about document.cookie not > working when using a custom scheme with 60 comments. > https://github.com/ionic-team/capacitor/issues/1373 > > there are others about XHR cookies too I'm not aware of any cookie bugs for WKWebView. There is cookie blocking according to the rules of Intelligent Tracking Prevention on by default, but that is intended behavior. Do you have any bugs to report that you believe is not intended behavior? Or do you have enhancement requests? If so, please file separately. Thanks! The originator of this bug, Niklas, has reported actual cookie bugs to us a few times and all of those should be resolved already. 1774195 50 juliosincesar 2021-07-01 11:57:39 -0700 yeah, sorry just wanted to chime in to give you some insights about your "very few developer reports of this being an issue" comment. 1774207 51 wilander 2021-07-01 12:14:48 -0700 (In reply to jcesarmobile from comment #50) > yeah, sorry just wanted to chime in to give you some insights about your > "very few developer reports of this being an issue" comment. No worries. It's helpful to know, especially if we can get a clear explanation of the use cases. You can see that in the conversation above "Could you explain to us what your app is doing, how it makes use of cookies in cross-site requests, how many different domains are involved in these requests, and whether those domains are part of the same organization or spread across multiple orgs?" 1774376 52 niklasmerz 2021-07-02 00:14:56 -0700 Some time has passed and I can share the sentiment that cookies are the main pain point of WKWebView. I have been watching a few Cordova issues where some people try to figure out solutions for cookie problems. Aside from some weird behaviors of NSHTTPCookieStorage, I never really fully understood, there are no actual bugs right now AFAIK, but ITP brings some app devs in trouble. Probably many don't identify it right away as the cause of their issues. Maybe that's the reason we don't get many reports. What could help here would be a way to debug ITP in WKWebView, like a special indication for blocked tracking in Safari Web Inspector? A handful of Cordova developers got directly in touch with me because of my bug reports and blog posts. With some of them I talked extensively about their use cases of CORS cookies and possible alternatives. The biggest use case is similar to mine: Their app connects to a backend that's either not in their control or does not support an authentication without cookies. Often it's just one or two domains I think. Cordova/Capacitor apps are almost never a general web browser, but load web content from the app bundle. ITP does not really make sense in this context as WKWebView is just used to built a "native app with web technology". If Cordova apps browse web pages most of the time the InAppBrowser plugin is used which opens another WKWebView where ITP would make sense again. Is it unthinkable to have an option to disable for WKWebView instances? Maybe having ITP disabled when a WKWebView uses WKURLSchemeHandler to serve content from a custom scheme would be a good compromise. WKWebViews used for web browsing where ITP is good won't be using custom schemes but Cordova/Capacitor apps often do to serve their content. 1785049 53 pradeepgupta.6259 2021-08-17 22:46:25 -0700 Hi John Wilander We are using an app with SSO feature where our enterprise customer can you use different domains to login. This is working fine since we are not using App Bound Domains yet. Now we wanted to survey our users for NPS using Delighted(https://delighted.com) which uses cookies to survey user once in the throttle period and this don't seems to work as third party cookies are blocked. We can't use App Bound Domain as this feature would restrict us to 10 domains only and would impact our customers who use SSO for login. Can you share a workaround for this. Thanks and Regards Pradeep Gupta 1937396 54 woodywoodsta 2023-02-28 07:32:16 -0800 We've now hit up against this issue as well. We have a Capacitor app which makes requests to a backend service that we own. It employs token-based authentication with a refresh token. The auth token doesn't need to be secured, but the refresh (long-living) token does. We intended to use secure, httponly cookies for this refresh token, but that is now not possible due to ITP. Presenting the ITP modal to users is unacceptable UX, and there is a high likelihood of "tracking" being rejected, which means we would have to compromise on security anyway. This puts us in a corner whereby we'll have to implement the authentication mechanism natively. 402550 2020-06-23 05:59:59 -0700 2020-06-23 05:59:59 -0700 Test project WebKitBugiOS13.3Beta.zip application/zip 44669 niklasmerz UEsDBAoAAAAAACtrbE8AAAAAAAAAAAAAAAAVABAAV2ViS2l0QnVnaU9TMTMuM0JldGEvVVgMAOSk yl2ypMpd9QEUAFBLAwQUAAgACAA2a2xPAAAAAAAAAAAAAAAAHgAQAFdlYktpdEJ1Z2lPUzEzLjNC ZXRhLy5EU19TdG9yZVVYDACtpMpdx6TKXfUBFADtmc1u00AQx2fTQG2hgoUqJce9IHEIKB+UwKFS COGQC0JySw8FtXYcNa4crxU7dSEE5dKHgBdAnHgGjogHgPfgAWAdT1FqsJVAD1E7P2n9X2t3xt7J elezAQDWHFoVgCIAKBCrdg3+ioLlD3Ko12Vh0h7gCLqwI4spawRBEARBLCMsFiVl3ycI4hITrQ8c tYE6iZVhew41P2OjoXLUBuokVob9cqh5VAVVQ+WoDdRJrLhoMUw+GD6ZYYbCNFSO2lhoyARxqYhy 9zV4CgYEYJ/J322pYdsRHdMRJsSf9UdZbv+cMrXOsDRD30PLL6bn2H5QLn9juZX8lauriqoq6pr6 Uu+JUA+MYOg3jcFudPfMCHom1reEcH7XDfO53Q33tPXHwg0M2+0Opsa21ZVdXuzYriXCphi6lr87 0zB90J5WHI2qD6slXn1QH5f4qF4vl/i92v3xWFUKtyqb7f3+q9ejN+O37+KYnK4xcCMRrPfZQz7S B64j3AOI18dCek+4C8fQAQGWvPNgIGuHZ0PNColQL+jNOajoHdH34hf/+n1xD33RauH7KNsf7nza PPn86F+8WOfgxevNjIbx6Hozw8OWvPqyzU/E9CQR07l8LNlErtU2Sry2Uf7viTzX4BNTej3DZhva qYH/kQj83H4uavDnDkDiByCIc2MllmKU/z9JP/8nCOICw/ItvdWE9B0myrW5LPunBpB9EMBm/jBc uoMA2v8JAn4BUEsHCOK6KG0mAgAABCAAAFBLAwQKAAAAAABGa2xPAAAAAAAAAAAAAAAACQAQAF9f TUFDT1NYL1VYDADkpMpd5KTKXfUBFABQSwMECgAAAAAARmtsTwAAAAAAAAAAAAAAAB4AEABfX01B Q09TWC9XZWJLaXRCdWdpT1MxMy4zQmV0YS9VWAwA5KTKXeSkyl31ARQAUEsDBBQACAAIADZrbE8A AAAAAAAAAAAAAAApABAAX19NQUNPU1gvV2ViS2l0QnVnaU9TMTMuM0JldGEvLl8uRFNfU3RvcmVV WAwAraTKXcekyl31ARQAY2AVY2dgYmDwTUxW8A9WiFCAApAYAycQGwGxGxCD+BVAzABT4SDAgAM4 hoQEQZkVMF3oAABQSwcIC4jAODUAAAB4AAAAUEsDBAoAAAAAAMtEE08AAAAAAAAAAAAAAAAoABAA V2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlld1Rlc3RzL1VYDADkpMpd3kNaXfUBFABQ SwMEFAAIAAgAy0QTTwAAAAAAAAAAAAAAAEAAEABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVX ZWJ2aWV3VGVzdHMvTmF0aXZlV2Vidmlld1Rlc3RzLnN3aWZ0VVgMAJ6kyl3eQ1pd9QEUAKWSwW7b MAyG73oKHreL0uwwFDutSIdil6GHFt2VkelagCwZFO3MKPJAfY092Sgl6bLBxVDMMAxD5E9+5K/V yqxWAN9Q/EQPtJ087e4oS7Z551t5JajHNbJhQqEGtjPcUDNn+BqF8QGZ4KbfdpAirD/a9YVdX9qD IA0z+8dO4OczfLhYXy7qLFyFADUvA1MmnqgpBYzx/ZBY4PumcJjPol/cBoLj+R+oxriAOS/wfzoW 2GAmeDIG9EkTMfuGoB2jg0xyP7x7r0E4Pop/O0oJjAO4pIkdMVm463yGnqRLDeifwxDKRqhNOo10 ihan5BRBl5FaIHQdFOwXTaxZFdXWbvslICHk67SLS0wl1mjs31jYCvF/UR1hsnz5gf0Q6G+e2ldf jECHjFIfq650w3Do43T19lx4r1aoK1dZ7RaVN+p8qLfrJM0gCXQpvp1hTiPXQhkGTs3oDrt2iZmc lEszBnmF/JZYzekxOnrjEMNv5dIUmUJre8I8Mp0VPHeqMqpJyg87jFJGOilKUHxfe1UTXyrsT3Ps zS9QSwcI/gwO+5YBAACxAwAAUEsDBAoAAAAAAEZrbE8AAAAAAAAAAAAAAAAxABAAX19NQUNPU1gv V2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlld1Rlc3RzL1VYDADkpMpd5KTKXfUBFABQ SwMEFAAIAAgAy0QTTwAAAAAAAAAAAAAAAEsAEABfX01BQ09TWC9XZWJLaXRCdWdpT1MxMy4zQmV0 YS9OYXRpdmVXZWJ2aWV3VGVzdHMvLl9OYXRpdmVXZWJ2aWV3VGVzdHMuc3dpZnRVWAwAnqTKXd5D Wl31ARQAY2AVY2dgYmDwTUxW8A9WiFCAApAYAycQGwFxJRCD+KsZiAKOISFBUCZIxxwg5kdTwogQ F0/Oz9VLLCjISdULSa0occ1Lzk/JzEsHSpaWpOlaWBsamxgZmltamAAAUEsHCHAajcBdAAAAqwAA AFBLAwQUAAgACADLRBNPAAAAAAAAAAAAAAAAMgAQAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2 ZVdlYnZpZXdUZXN0cy9JbmZvLnBsaXN0VVgMAJ2kyl3eQ1pd9QEUAH2ST2+CMBiHz/NTdM0O20Gq l2VZKgZoNSSIjRaznQyDqkSgDVQd3371z7JMx659f+/T59cUDz+LHOxFVWeyHMC+1YNAlIlMs3I9 gBEfdV/g0O7gezL1+DujQOVZrQGL3MD3AOwi5CiVC4QIJ4AF/pwDw0CIhhDAjdbqFaHD4WDFx5SV yOIYrBGrpBKVbgID65oFK9UpNNec6b90zGmaJdru3OGtaGxv5O7KNBdE7EUuVSFKPRNrk8boODap WldG3n54JHRBgymb0JAvAyccR86YPmF0mV/x6KdIdjr+yMUtiL5RL+KOG9Bl6EzaGX5qbLJVJqpb BptNSeTxpRuFxHB8Yqz8kU9n7bRyJYlpbrrFVbM4v8k1+Nnqte2HcfFHl2+Pf4uwONnGa8EbdUNw jX7b2nwjK30RnZ8S19v9dt2Wgv2fPEbnj4DR6ZvYnS9QSwcIhcLZAE4BAAC9AgAAUEsDBAoAAAAA AMtEE08AAAAAAAAAAAAAAAAqABAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlld1VJ VGVzdHMvVVgMAOSkyl3eQ1pd9QEUAFBLAwQUAAgACADLRBNPAAAAAAAAAAAAAAAARAAQAFdlYktp dEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXdVSVRlc3RzL05hdGl2ZVdlYnZpZXdVSVRlc3Rz LnN3aWZ0VVgMAKCkyl3eQ1pd9QEUAJVUwW7TQBC9+yvmmBzqNBxQhcQhSqHKBXFo1F439jhesd41 u7MxFqrEb/AJ/Aafwpfw1nabUAIIX2ztzL735s2MF4tssSB6p0Qf+I53B83ddnPLQUIeOl3JH8MI DLG1ZyVc0q6nGy77QBsrXt0pz3TT7GpylpYv8+VlvrzKxwuu7b3e10Lfv9GLy+XV2Xs5rYyhIS+Q 58D+wGUCyDLdtM4L3a+TjiwrjArhrMRXU85aBabPWUZ43IG91yVTFW1BgWXbzuYI0vRA4fsoKRBb KhwSa/ac022tAzUstSsJX4UyJhXNlYNgqZm0PbgCIlCvq4hVUZOA++mOHbIGsXl2SrextN0MuYG0 JPAYIuB7oOO+OAriWtJNw6WG1Qh0NVtSVCltIuhdUUQP1EfQwlnRNvKqEvZvp6TXSDeBf6F+4m0i mIyCJfUgU7Wt0VM1UitJh/2Qm9O103aPAwhFUaNRnUazGvWBKSQulFEDgm0g+PObGUel9+vtZnXk ms3zUcRs/heLfnz5itcwBMqOBrFMPdCilYFh8IkuIAbEKumEEZUqYJXXbGUs7AJz9TFqjz4mlb2L fuI4trUnH23qPo+zcjICivYOX61JuBBRusGUsbiHc9MmrPy16+y5gUuxErF/z5xKXf3/kTtRNYkJ 8uaTalrDz/VssS6eC+fLodOO9vAXnvq0552Hxzh+bEj+/CZ2bhWwr0LKlsAxw+8hcSalIeHBFV31 p4633pWxGDcJxGCXtPXRyFH6Q/YTUEsHCDQZZa45AgAArgQAAFBLAwQKAAAAAABGa2xPAAAAAAAA AAAAAAAAMwAQAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXdVSVRl c3RzL1VYDADkpMpd5KTKXfUBFABQSwMEFAAIAAgAy0QTTwAAAAAAAAAAAAAAAE8AEABfX01BQ09T WC9XZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3VUlUZXN0cy8uX05hdGl2ZVdlYnZp ZXdVSVRlc3RzLnN3aWZ0VVgMAKCkyl3eQ1pd9QEUAGNgFWNnYGJg8E1MVvAPVohQgAKQGAMnEBsB cSUQg/irGYgCjiEhQVAmSMccIOZHU8KIEBdPzs/VSywoyEnVC0mtKHHNS85PycxLB0qWlqTpWlgb GpsYGZpbWpgAAFBLBwhwGo3AXQAAAKsAAABQSwMEFAAIAAgAy0QTTwAAAAAAAAAAAAAAADQAEABX ZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3VUlUZXN0cy9JbmZvLnBsaXN0VVgMAJ6k yl3eQ1pd9QEUAH2ST2+CMBiHz/NTdM0O20Gql2VZKgZoNSSIjRaznQyDqkSgDVQd3371z7JMx659 f+/T59cUDz+LHOxFVWeyHMC+1YNAlIlMs3I9gBEfdV/g0O7gezL1+DujQOVZrQGL3MD3AOwi5CiV C4QIJ4AF/pwDw0CIhhDAjdbqFaHD4WDFx5SVyOIYrBGrpBKVbgID65oFK9UpNNec6b90zGmaJdru 3OGtaGxv5O7KNBdE7EUuVSFKPRNrk8boODapWldG3n54JHRBgymb0JAvAyccR86YPmF0mV/x6KdI djr+yMUtiL5RL+KOG9Bl6EzaGX5qbLJVJqpbBptNSeTxpRuFxHB8Yqz8kU9n7bRyJYlpbrrFVbM4 v8k1+Nnqte2HcfFHl2+Pf4uwONnGa8EbdUNwjX7b2nwjK30RnZ8S19v9dt2Wgv2fPEbnj4DR6ZvY nS9QSwcIhcLZAE4BAAC9AgAAUEsDBAoAAAAAACxobE8AAAAAAAAAAAAAAAAtABAAV2ViS2l0QnVn aU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2ovVVgMAOSkyl0Un8pd9QEUAFBLAwQU AAgACAAsaGxPAAAAAAAAAAAAAAAAPAAQAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZp ZXcueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvalVYDAAUn8pdFJ/KXfUBFADtXFtzm8gSflZ+hVaV h02ykSXZGyfls6fOCEYyGwQqLk68LxSWxjYbGVQIre06tf/99HARDAwCJNlJ7XEebAu6m56er3u+ GVo5Omr/9PqtaYw+vn3906v/vmrZ/uzW+YtcEH/leG77t3b/7FVrtrBXK7KCTyDxN1zwrv4ksyAV +rW3uRhJvTp62x6SG8dtT4dfh2tnMR85C9JegQDVeHv0qtU6FhA+xf1fB/3TDz386VOvhz71BsNR G3TRcimSBbmxA9Jd3TvXQRtM6d7an4Ebb4/oM5yVDb+y5s/a1/BTI9dwPTZ+Us/426OzNh1X4tMp T+3CIfeC5wa+t1gQfy+3PtS2n/cM8TQntuN2V4HnP155tj+nTmlk1dytj3WM5z0SYqUhE2LAS7Dq Pszs8I+dPRrWMZ73aMRTku21O7vVZz4hB4mV2OQhOQ8HiKes2AFk3hdy9RcAwSArGOIeGBt8avSM nIfHv1Zqm9LePh6fNHxK7CUIYXdeWlqY4kMzChBMfCkgd1Pfe3jkVaHBB54nfPVofKDa2oyxKEVD 2Zoll6eeH9iLzbh7n3iJBnq0gLajOkrHSm0sqTXjcUniWtxq+eTOC8h44V3ZC0nUA99xb1Jc9vKm MzqSe+2BJBNgejs78f3/80Ck2NqOHAZkowjYxCfujL/K9XkDZZ7ftZfLfO4wds/a5GG5cGZOQC/H kbj3QQ1WC/gJt2z63DNIxtliPYdRSu6cPIBU76y9tIPb/JCp1lk7Kn4G1Cy4PzQl2bCmmiqagqFb oqSxtbX2grptHEAngs+ud+9mBhJ5MfPmsYmNxwXjOY87/7rxvfXy3x3W0SZL7MF85dmv5y43EYb2 iuzgHi2zmdXnrO3ad+HcgrmNq/RDdwFJ9edRboWv53DNlbmx795iTuFM9QHO9sK7SZHAWq/nJ+b5 +UyBLaEDtRwf9HiO08LVhUxf7QLbgDwEkXL34W6xcTi1Wc+xamoQLdkPs4BU+rmlpM2ur9bunPKG uvUs+9xmda0xWzpYySh7Rr254GbhDwCSYy56uczu+WHCPrkZUHagrE8DFeYp9eaEy3G/I1hSqlXK n1iW5UO5vff8b6uQ9k9vaRXnkK0e5i2mqTaPuPJsh4Txin5E4TMm9uobSA/6J6cnH48/nJyGAnRR oIceP9MPbyKSuXZVd/E48nyRLBfe4x1xg6m3CmBRgA3SKqKpvRzzHgx40/PDe83dB/+oXmcQV4El BnhjClou0oonJvnBhrrRJugWHgQIT/xPGMpx5dYAHvlLRmPwsd5ilVM7Pq5bunKK/UHJLm2+nqXC 0XSUpDsLmkqDO0Sx9gaLiWRjLsMEdIdFLhOqmDwmw24QvlqI2SGGtTd3DDqa7LQYxZrHjYxOzW0H o9PwqI4BSDULz8wob52uP60N0rr53DYmuEwUqmlmRRRC2/VD0ahUNQ/GDiSOyftqIlURjth6dUDS BauwBjErVGTdsP0bEnDPnwqnYbVKRtZsukJDXl87N2s/PG2S6YA3B7pclIUrbHuW1WqHcbr2/ILz HcapTnL6d7VZpVe5yeyJvKGlh9HZmavBDBnxEU88+7ogM8+hh9q6QFDmZElgP+LOnPydeAEolotl tCQoFfdTxrw59Ky9CmbtxGS+M/PuwnNE0o1vvA/gTvZosVCyqhOpNEsbY4v7omkPbIWe1QDYgHsk zgdYDRLPiHPr3AEAltg/5dmHsEQBERPNRy4zKangW9BZECpCtDnlagDV6CSgu3YduADaBbxyXw3W XVcaI5b7tD0QG/tWB7PcZCnBbPUWjhHnnqgeDrPH3BTaCbPZZXYLajliRdzuQvZ3QK4T4hZ2rUUG ULbGM0QgeXfG26zWe9lWgH0sEQ7GDgLfuVoHSTMI/JPtVaBTlmQu57BHEG7JjO7c+71+uOuOBMzl jW/POTdVbYwU6Q9kSKqioAmmIRqT+eMK+FTg219sn7THd1e3nUg8Gj0qelHOczYSLcEn4OBcdQ3P W6wyLS69bvRCMa4VrS3LWyNrLYqHyGVJbFe8mSw8vFg9nuHh0a+/65S3nsDDU1V5S/BWwvMgPYAw O1fOwgke03F1vtLz0Pan7nEnrh9/kYW3pIc9GkA/lCFueAvKoT6zXZfMR56PXdCDbFolh0Ctb/QI M9JJKw9xowpH391kasod7EUj3r0Zc2HPmqsarHjlQUeiTUMiOv402it0OtnrmucF6cUgnNF80azH 75kyXp+6MWpNVtA0lEwh49QopoZt1pKKY95Kdl4oZRzLOxw8HqLPiDmg2KWFijGwS1dYBue7nfxW ctcnCv8+Pldylx/H5zRfKvKByR29VuZUbJkLQShY3SNrduytZPC+S8/o3niv2AY+ZdD2aRjce9wV W4mnHPd+bYi7jjzNvK3ZxORdYXPCazJssBsvRDUvkyEDW8gdjwVkNKOuts3WvFETZP7ItsG27XsM rlljYwEJ2+aXAcKF7Tu2G5S+Mqz71qMQo6zhrW9xtrWSFTfM+eYveqveW6iGr1V2H9C2Fq7igMqa rioHlk522RymE/1VGBY2R7zZPuamvEiu1jeFkPBspqVTJ0EQb2SiTSCSv6BL3dIx0oRzy9SxZk2R ca7T0w012swJMlLGFlKQfPkH3FZgi23KMghcYp0vYU6G8Esd/o4FwxJU5QJrOuzMIxULjcca1nXp Ame1ha9fLfqHicbY0g2kiEijG87Ojbt+965/0ikIS0MNaZdUZOFczd69YySwgoYytiaqaMpYLzob 3wcfBQuGvl3gC0afixJfkKZYQ1kVPlsCmhqmhi1kGqqGZYx0SRmXaaiqXAhKQUpQJxNUek+hASqG tiAp4qmGBWRgMRqINJnKeIIVIzwp4YQl0pI0OnGRho4AFTAn8eRhTVO1ooYqmBuzoe/wocw8nkyN SwiDeFkmAACqHpukjCRFMrAFzprbBWtEClANiDKwhmSLwrtaYxNQSZAMcMJAkgJ5JI+2ySePqGdd U1VwXUa6vjX6GvyFLVlVp1EO6lJZ6HVDk4SwL81QjcspLzEiOVOfwrBUU4cMusAlUibNVk0EcKEL JMloKMHwLrdmeaynYSSch/klqGKZeUs0aXABvdYEG+eqaE2QIZwz0qBt6dIYJlkExEVP7zjTW88l UB/D0x3iJ4VBnV5a03Ok4zAO00yJE/HQHFNEqdokwnD0F4jM723/OpKKS0IcxHCGJvpYx4qY9SmW MjDkaDYi0d2xIFgCt9BBnev3UyHxUkETSQBgWjAVGV/pTbhIk0yN64+ef4I6NaRJfB5qyfgCy5uT q/A+VAXAgADzo2pQJMJEigtCtGa2OmFIfut3fok/v/7ZcW+J7wRk/ia++CY1GE7YhxPLUK3jgTWU yjJuI4uGqhlmjQkfKBSLCN/ImoqIARcaAA3yC0qTqnFtmko4DiRLf1BMQi3WS8CYUYElT7RGpiIY Za7GMhdIk+jMZmWk6bmqYFWnhVZWL2nVswykjTFFTn+QnKJODDlZT1KkgYSkCLJJEayamoBT2RHS DQp2BuuqIl9aCNy8wHTFYu7p4mdaK+CSs6TY91bx9S/SyEiUADFTyNK4RCviZspDn7IKXPh03qsu mO5kjnZjrhQSkTyR57ahaLCzTpvmX0jLC2l5IS0vpOWFtByatHRC1vL+3glu389Xj3cdhpooMFAd imaSTonBevymNoOpIikvnGEXzpBMVilP2M4FsiRgEsH4/tZbkDtvvl6QOiQgxtIFhEykMI+/5JJx gSEH8ZKfpwfco+jDnGgAtA1IQCSr43i4sK6jKdQGGEjcHYCWS2kWmylJSETbK5J8pCe9nby0blyG U4vWgXcHbs2SvIRYqdNoYjGagMTpifzx81Q8/zCJMQBzCWUCZm8khSaYA8ijzDdfakCm3z2JxGTR 0kyFMqGEGiWsKCH1HBLf6vyHPJDZOrCvFsSibaZHadMOS/TjmbaGkFwAyyhYIwnTzKINKTdOl7ad dIuthhvVpDnj9c+R/+GFN52N0IVEsx94CIUVjY2lT7GQPCR+eR0DNC0VJ91BdCMyCokHcyAJGBJk IsnhbPZ/GdRlrtw25UMx1xdwvoCzJjhLKif3wPyQZ8EYNkKwaobDSFb3eOMiseQrjrWsIjEKAUQO A27OVd1482yIDN/cFWD5ZHgDmYVnz4m/Nx5n/l23pPG1Hib3gVprM1OR+eI3Vt8cFVq+2St1C2pJ u8QhjwJeMPuC2V0xy6+zJ9xO3e9TZ58ej3H/wz8CkdlG7OfCZMZoPrT1iuQJt7HgexXJF8D9owDH Vri4Q6Gq+SDbplBs3+b1Ax64kzsP+YITKeKZW4X2r63dE8xXMiteWmTaRObk2l4vAubB0urCWTkA wXbyso0npWxl90/x1ceDBXLroQ0TyIo99DME8sm+53ewaG7dyDHRrCDQzxDNJ/wO2qHiuZ2wZeNZ tdY+XTw3pXd7QaWR9z0vUKNvUzX+fw7/fvU/UEsHCDizL54SDQAAklcAAFBLAwQKAAAAAADLRBNP AAAAAAAAAAAAAAAAOAAQAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVw cm9qL3hjdXNlcmRhdGEvVVgMAOSkyl3eQ1pd9QEUAFBLAwQKAAAAAAATdBNPAAAAAAAAAAAAAAAA UwAQAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9qL3hjdXNlcmRh dGEvZ2VkeXNpbnRyYXdhcmUueGN1c2VyZGF0YWQvVVgMAOSkyl3lllpd9QEUAFBLAwQKAAAAAAA8 dBNPAAAAAAAAAAAAAAAAXgAQAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNv ZGVwcm9qL3hjdXNlcmRhdGEvZ2VkeXNpbnRyYXdhcmUueGN1c2VyZGF0YWQveGNkZWJ1Z2dlci9V WAwA5KTKXTSXWl31ARQAUEsDBBQACAAIADx0E08AAAAAAAAAAAAAAAB3ABAAV2ViS2l0QnVnaU9T MTMuM0JldGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2oveGN1c2VyZGF0YS9nZWR5c2ludHJhd2Fy ZS54Y3VzZXJkYXRhZC94Y2RlYnVnZ2VyL0JyZWFrcG9pbnRzX3YyLnhjYmtwdGxpc3RVWAwAn43K XTSXWl31ARQAs7GvyM1RKEstKs7Mz7NVMtQzUFJIzUvOT8nMS7dVCg1x07VQsrfjsnEqTc5OLeFS UFAoLc1MUbBVUDIzcrQwczO21HU0dTLWNTF3MdR1MnR203VyM3a0cDN1MbQ0MFYCaSipLEgFaTAE 86BWgQSMgJYBjdaHmG3HBQBQSwcI6phYN3oAAACMAAAAUEsDBAoAAAAAAMtEE08AAAAAAAAAAAAA AABdABAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2oveGN1c2Vy ZGF0YS9nZWR5c2ludHJhd2FyZS54Y3VzZXJkYXRhZC94Y3NjaGVtZXMvVVgMAOSkyl3eQ1pd9QEU AFBLAwQUAAgACADLRBNPAAAAAAAAAAAAAAAAdQAQAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2 ZVdlYnZpZXcueGNvZGVwcm9qL3hjdXNlcmRhdGEvZ2VkeXNpbnRyYXdhcmUueGN1c2VyZGF0YWQv eGNzY2hlbWVzL3hjc2NoZW1lbWFuYWdlbWVudC5wbGlzdFVYDACejcpd3kNaXfUBFACtkDFvgzAQ hefwK1xnhku3qnIctSFVI6EUCVDVJRHFp2AVMLItSP59TSiJunXo5PPd9947HVud6op0qI1UzZLe BwtKsCmUkM1xSbP0xX+gK+6xu/BtnX7EG9JW0lgSZ8/Rdk2oD/DUthUChGlI4mibpMR5AGx2lNDS 2vYRoO/7IB+ooFD1ABqItWpR23PkzHwnCIQV1MWM7r/WcV0hC8u9GfvCM0+KEmvMDOrE5hYZDE03 +2FGaJdb2eE7fnYS++BUmItoYm/wSCstUL/Kxl6BGXM/PKLmCwZTOQjhDzGH/dyUuUYx3x/+MXIq bu/lWNz7BlBLBwhqUwFH8gAAAMMBAABQSwMECgAAAAAAy0QTTwAAAAAAAAAAAAAAAEEAEABXZWJL aXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai9wcm9qZWN0Lnhjd29ya3Nw YWNlL1VYDADkpMpd3kNaXfUBFABQSwMEFAAIAAgAy0QTTwAAAAAAAAAAAAAAAFkAEABXZWJLaXRC dWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai9wcm9qZWN0Lnhjd29ya3NwYWNl L2NvbnRlbnRzLnhjd29ya3NwYWNlZGF0YVVYDACfjcpd3kNaXfUBFACzsa/IzVEoSy0qzszPs1Uy 1DNQUkjNS85PycxLt1UKDXHTtVCyt+OyCc8vyi4uSExO5VJQgClXsFUAa7ADidm4ZeakBqWmgdhA kJOfnFgCVVOcmpNm5QfklqWGpyaVZaaW61UAbUgtKMrPgmrWh+oG2qQPt8qOCwBQSwcIWZ9zrHgA AACeAAAAUEsDBAoAAAAAAMtEE08AAAAAAAAAAAAAAABMABAAV2ViS2l0QnVnaU9TMTMuM0JldGEv TmF0aXZlV2Vidmlldy54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS94Y3VzZXJkYXRhL1VY DADkpMpd3kNaXfUBFABQSwMECgAAAAAADmtsTwAAAAAAAAAAAAAAAGcAEABXZWJLaXRCdWdpT1Mx My4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai9wcm9qZWN0Lnhjd29ya3NwYWNlL3hjdXNl cmRhdGEvZ2VkeXNpbnRyYXdhcmUueGN1c2VyZGF0YWQvVVgMAOSkyl18pMpd9QEUAFBLAwQUAAgA CACZVRVPAAAAAAAAAAAAAAAAgwAQAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcu eGNvZGVwcm9qL3Byb2plY3QueGN3b3Jrc3BhY2UveGN1c2VyZGF0YS9nZWR5c2ludHJhd2FyZS54 Y3VzZXJkYXRhZC9Xb3Jrc3BhY2VTZXR0aW5ncy54Y3NldHRpbmdzVVgMAJ+Nyl2CBF1d9QEUAH2Q QU/CQBCFz/Ir1r3T0ZsxpQQoJCSNNLYcONbdQRq33WZ3Su2/dwrECBpPm8x779s3E04/KyOO6Hxp 64l8DB6kwFpZXdbvE7nNV+MnOY1G4X28WeS7dCkaU3oS6XaerBdCjgFmTWMQIM5jkSbrLBfMAFi+ SCEPRM0zQNd1QTG4AmWrweghdbZBR33CsDEHAk1a8jdn+lUdnupSUTS6Cz+wj+ZtaXRiVUHsyKg3 GMIwZ9mT49bR1iN3Sh3u0fEq6EO4KBfEovVkqytQ3je/OK9oWDtibmN0/Oq4oOKW9UP6t1SM+6I1 dBtfe9/iqjSE7s9YdrDdTA0tMnXACje16W8ZyaDa1ik80fyyLt4M6m8UuRaBrwjnM4ZwOnI0+gJQ SwcId4pYQR4BAAD7AQAAUEsDBBQACAAIAA5rbE8AAAAAAAAAAAAAAACFABAAV2ViS2l0QnVnaU9T MTMuM0JldGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS94Y3Vz ZXJkYXRhL2dlZHlzaW50cmF3YXJlLnhjdXNlcmRhdGFkL1VzZXJJbnRlcmZhY2VTdGF0ZS54Y3Vz ZXJzdGF0ZVVYDAB8pMpdfKTKXfUBFADtvQd4E0e3MDyz1d1y77bcZIplZFmSJVdZkuVecKEZMLIt WwLbciQbMCXsAoGEFAgBQg2x6YFAQiehBUghIQUIkAIEQkggJEAKIYWQf1ZrudDe973/vd/zfc9z cSTNTjlz5pwzp8ye3dS0NJptrRLJpwACDOCAACSg6P30gWEx441Wm9nSPCzGUjPWWNtqGx5jsNaa zKi6IqbV0uIN4KyXt3hhlYAGTsAH+AI/EAf6gf5gABgI4oEYJIBBIBvoQQ7IBXkgHxSAQlAEioEV 2EAraAPjwQQwEbSDSWAymAKmgsfBNMAAFkwHM8BMMAc8DeaBpWAZWA5WgJfASvAyWAteA6+DrWAn 2APeAHvBQfA2OAo+BCfBp+AL8CW4DL4F34Er4AdwF/wDAYQQgzgkIAkp6A19oC/0g/4wGEbCKBgN Y6EIxsFBUAIToQzKYSZUQz0sBIdhERwMK+EQOAJWQQOsgfVwLBwHG6EVtsF2OAkykIVPwWfhc3Au fAEugIvhErgCvgQ74Sq4FW6Du+ER+DZ8B74L34OfwlPwNDwDP4Ofw6/gBXgZ3oA34U/wL3gH/o3h GIE5Yd6YD+aL+WH+WDAWjiVgMiwFy8A0mB7LwQqwEsyI1WMNmAkzY2OxcVgj1oQ1Y1asHZuETcam YDOxJ7BZ2FPYHOxp7AVsAbYQW4KtwDZim7BXsc3YFuw17BB2GDuCvY29g72LvYcdxd7HPsGOY2ew z7Dz2DfYZewa9hP2N3YX+wcncWc8AA/Eg/BgPAQPxaPwaHwgHo+LcTmuwJPxTFyNZ+E5eAFehY/E R+Gj8Wp8DG7Ax+GNeBPejD+Gt+Hj8Qn4RHwBvhBfhL+IL8aX4EvxZfhyfAX+Er4S78RX4+vw9fhm fAu+FX8DfxPfix/C38NP4CfxT/Hz+Ff4Bfx7/Br+A/4z/gt+G/+L8CK8CR/Cl/Aj/IkAIpAIIoKJ eEJMJBCDCAmRSEiJJCKLyCb0RD5RQJQQpUQFUUkMJ0YQYwgD0UA0ETailZhEMMRM4gnieWI+8QKx gFhILCKWEyuIl4jNxBbiNeJ1YiuxjdhO7CB2Em8QbxIHiIPEe8Qx4kPiOHGCuEJcJb4nrhE/ED8S 14kbxE3iJ+IWcYf4m7hLUiRNOpEC0ouMI/uR/ckB5EAynhSTCeQgUkLKyFRSS+rIbLKILCZHkKPJ arKWrCNNpJmcSj5OTiMZkiWnkzPImeQT5FPkPPJ5cgm5lFxGvk5uJbeR28kd5E5yF7mb3EO+Qe4n 3ybfIT8iP4abyE/Iz8jPyRvkTfIn8mfyF/JX8hb5G3mb/J28Q+EUQZEURXlQnpSA8qKCqGBKQiVS UiqJklFySkElU0pKRaVTOqqQKqIqqSHUaKqGqqUaKBPVSrVR46kJ1ESqnZpETaZmU09S86gF1EJq CbWUWk2todZS66iN1OvUVmob9Sa1l9pH7acOUEeot6mj1CnqNHWG+oz6nPqC+pL6ivqGukz9SF2n blA3qV+pP6m71D80TjvTLrQrHUlH0dF0DB1Li+g4uh/dnx5AD6TjaTGdQA+iJXQKnUqn0el0Nl1C l9KD6TK6nK6gK+lqegxtoGvoRrqJbqYtdDs9iZ5MP04/R8+l59HP0/PpRfQSeim9jF5Jr6E30Jvo PfS+ypjmtsbGk8AZuABX4AY8gffQ4vKEccZ22wj026XnhsTUNhpstk7gDjwYjME7gQB4MQQLBzGy akGMTi5XaVRKlViTKFWJZTpttliZpZWLk7RajUSqkaEfXbXAN0+XPdRiHWdrMdQadZbatiZjc6tj Zn8QDkTrQAAIBEEgGISAUBDGkAzF0IwT48y4MK7rQAQQgkgQhbrEgEjGjXFnXmChGPWRMi8wqtEc eHNznWWC3mpoMlYLMnrPV2Go0VqaW62WxkajtVqh02l02sRksSRJJxPLkqRZYqU+MVsskUs1yXKZ VJuoROsSdUNEozUG61CDbYjZZq5pNA41t5rKzc0NjRzcakG/3jPxI6qLy8uMtlaL1YC6l7caWo06 Q6uhWhCBumbVtiKT8RDUBEE9s1osjTUGa55j1mpB4D0Y9WrymzxZEi+UTI0XTk6UyVBRqZBOneog rwSkANEGkAikIAnIgBwoQDJQAhXjwXgyAsaL8WZ8GF/Gj/HfAFIRedNBBsgEapCFylomAFH4fRYG szCMhUIWDkTX/RjVKIRNdp0ZLTLLakRrE6DrcpNlQrFhvLnBgKr5qu7Lnl55zbYWJFeOKp8iY5PF 2p5jNbSYdMaatoYGjhDxD+WfzmgzNzRzY8uRrW4dYjZOGMl99Yx1oFLZakYdzEZbtcA/y2ZDdt3Q 3MrjbCs0tFvaugWwBIwBoi0CASgFg0EZKAcVoBIMAUPBMDAcjABVYCQYBUaDaiaQCWKCmRAmlAlj wpkIRshEMlFMNBPDxDIiJo4DoQU1oBbUASMqNSAKmsFYjo6gCTQDCxLdfkx/ZgCTwqSiUjqiZSaj tlN0IvMUs5KT5WqBVGOst1iNRYaJ5ibzJKPW0tRisJptluYiS52xutJmtHZxnl+MvVYg7Lpoa2w1 tyCx44hTajU3Gazt/GKrBV4OGnVTbkQPhBGN9l4VViMC5juEd3b45vK2miZ+jnJjI2Kdsa6H83ZQ ec11xomlhlbTqC7S8+1ogM5Yb0AYlXLgbK1oz5cZW6xGGyoYWhF8jjXdgmRfB9ouzXUGax1iIwfI gTE31WgHQerse6paEN3Cr8+Bjd0bq+s7AxIwNEEXGnZovNj53bMEO0iETr9H0t5s68ZBAKoF3l2U LTTWt1ZYyswNpm6RegLMBqIOMIsZ2AGeZOI5tnrphlR0Uz6v1dhkO2Hv+gyY2wmeBc8xYkbOKB0A ngcLgfcqMB+8ABYwCcwgRrIKLEKStJhJRPKSxMhGIXB5dWid5nqz0TqSu+rRCAJ0yU1TZGhoNre2 1RmHd5PZOVo9Yxjg/p0AHaATrAKrR/AqvhmpzmF80WgbWVyuM9dyJEQU5nqtGVZcXmI3CQ4U14GN 96G4CaG4mVEgFJM58+BpJ34PD6PVzWN6zb0NbB9dXF7U1sppyiyr1dC+CtXtAGuQHbJf8t12gd2I j90de/BahZoQZgJwHKHzJpPGd98H9iPheKgGKewW9E5wAKz597qeBG+BQ2iSw8gdP4J4WVzeLfSF xuaGVhOiea+6IYbGNqMAMhk8Ru+Ad6t6tXaC98Ca3hUOir4PPgCil19mVI6Kj8AnnBh9zGR1gOOM hhOjWJ6NXaL3sJ3lAHAKnOEAnGa0HeAzRseoKooM5u7Ws+ACx8Fz4Dz4islm9EzOKnARKatLTC5S SeM5DvbvM519m5Qjpd7cwBs2Byvsatavb98uZXFvfY7R0mRstbbz0n8VXOsA3zN5TJUDqR/BLc4d uA5ugJvgJ/Az+AX8yuQzBUwhU8QUMyVM6TrwG7gNfgd/gD/BX+AOM5gpY2oZK9PA2JhWRjVSb260 m9yK9hZjVZcO41VGIK8lOCm6V0948bYKtXB7s9juRgQ5XJUHtIU42rInIvJz2rJnN1Y52irLCpHk trTVNJprE2wTzPWtYpulzVpr7FospKEb8F4NnaAzdIGuTDlTwVQyQ1ZDd+gBPaGAGcqMZEYxozlO BJfbR2qRIuLXlGCzU9iOffT9jbWcDNvXnWCpr7cZkQWIfGSvRnMzWlfofX1qUVFvaaxDTLfzDAYg nsFAZhhTxV+HgGurYSgM4z7McGaE/VMl8Be48OK/A8Z0crs6Wh1j3/xAQDjW3w8OBN6dsD8cwFQz YzphPHLqDEwNI6usRzPaRtd1EZLfZPx0UnDtZabKiyg5BRUwGVUooQqmwFSYBtOBllN+jkGWWjtz R/dwhttt9h5NaBv0VHOuF7cZS+odY3vamGbGyDzG1DH9qgWDhnHESOj2bLokggeX0K1EylutbbWt bVYjj3AWuLYKaqAW6ph6ZizTiGQd5sBcJOt/wnxYMKJnrko7FkiQTYyZM8NIhfdoI16A7CSFxbAE sYpzKLsFGk2KONSlU8zWTljKKbdH9ulCA5YBLSxgxqE9bx5VbLB7qMaa8WhyR4eh9g5ND+owEjWP gqNhNRxTVdcj9sNbzU3ICTY0tTAWpoVB1nJoPdqWKYMGDeI8GNugBmNdu82M1maYYLAaBznobhvU B/49Vw8nSC1EisYHmb17md8JjRwdHtTEj2yAJt6N78PShymKTmjmwP3b/UdxeOvMdYUWQ12//tUC cbcEFZhbE/gd5sArodTYYLC12Xp24EnYhMjbDMfAFjiaC85qDDYjshwJVmOjnTAMYNoYC78QG2yt LC5HtEdFsIYXvfHcVp3ATGCqkDj1hAlKhTJemJwkmTq19x6aDKegPfQ4nMbMYiYhkW9npv5XRX46 uLYGzoAz4RNwFpzNTGYeZxhmOjOzW/ThHDgNidQUZipjHtGIiMOxtl9/AeZon2cXuWmcyI3uy3ZH j4Xc5mHYR+wVR8+ldlgzHi7fK+0dnri/wxdwJFwN18C1cB3qth5J+gb4CtwIN8FXkScwHW6GWxBz tsDXEQZI2q2taHtpLY1tTc3FbU01nGLxNjbX3VfpVWsyWA3IOlrLDM0NRqTdkFJq7BLL7GZEcTQE VfFjC5Fi7gbnmKV35b3gLLXMbIG3IJR5UhDMAJ9/uv5VC0b+m3sQrR6Jp6atwVxSnpikMbYa/u2N uB3uqBYEoN1WYZzYeu+OWwV3wl3c/nlYhwdvVIe12AP3A9Fq+AZ8E+6F+5g5zNPMM8yzq+EBeBDJ wiHmOWYBkoYVjGoY55JzOCLng4tJHG53dwQwgndGOK9+uN1x51od0xyFH3HTvA8/gMfgh8xcZh7z PDN/NYhEUhIPYlCU1g8ZKSnnjYUMQb4PtydsHAAuZLGVGSbY3T/kEAX3be1yiMprLS1cNNWn0d7B YkUxCjLJ5hYuSEXB0f3QOZ/GyYHoF/As8u7gl8zCDniOWfSIKANeRFEG/BpeYl5klnZHGfBb+P29 Ljy8BmLgj8xitL4ljKybkNHqKbzn7hj6M/ztvqG30dA/mGVo6HJG1kNXNLa0z9i7GODw/od5qQNo ueMEhDeSJpul0Yh8NyTGHF/seGMkmNuBUczL3Thjzpg7mhhzwVwxN6aD6WRWrcI8gBYTMKsRqDWM rIpbdoG5ua7A2D6id4zsw1/kmrnDmXbk9NSOs3ExSlf3ar6ZnzeAmzeQWcsoT2Ah6DoUC0PuY22b 1Wp0nCJ0weGGM+uYo59hEZgQi8SiUO9oLAaLhQvBb1g/rD82AM7B4jExcjLqHu5PRtb38loTbHZD fa+P6mnr43S3I/lr7g3pPp+2+d55eptoNLru4T4sUqyDmdeY9cx7SElvYd7tZSiwQZiEMxSId5uZ DXZD0Y+nmhx5OpgCS8aUzCvMRmZTj7rvpawfoJW7qjCtverVh/sZGzk/g5nNeRS9beNGux2c7RCR UmwE8N6ADcbKsHKsAqvEhmBDsWHYcOZ1ZiuzjdnO7GB2MruY3cyeDVgVd6IIIrFqbAxmQL+1zBv2 Q8UXmP3MAeYI+n37X3rf9/vMNrRXi8zN5iZDywPdbtTMXWot441WQwNif8QD++Q1j+dDetu/6+Lf D6fV0tDQaKzTmjjTYPuvBgEcNlltrSa7XvrXMQJmQY4H1sK82RUjYDYUI2CtWBv3YfYy++yfKkGK wClanQB6awdsKsagmAB7HJvGHGTe6sRYbDpziDmMNjaHnN15NT4wMsBm85GBU6BA6AD2DDbXHmBg z6EA451ewO4B8J96ZnZjhy3CXuQPt+/TCJ3YYs7OPbCNH7sUW8Zbp/u1Uie2nBv84EbHyl7CVgPR Gmwl9jLWgXViq5gPmGPMh8xHzMdrsDXYWmwdth7bwHzCfMf8yUJnFrpwalbYZ5Hdx7MJ3e4bUgoP 6VKB3HnE+oe02i0r0jgOI9frIDjsIUPybDZkJR3LeR3bg8J+bCu2DduO7cB2Yruw3cxx5gRzkvmU OcWcZs6sw97A3sT2crsV7dODzGfM58wF+059gbnM3wToOgArQyjwh08OdLrONTmCTmwxIBGqs9tG vppz5nXtzYYmcy3n0yB+51gtbS1DDTbktTUaWmzGOk075zGhzYO6Iuioi0M0eIOF5D67mVO0dXzI Va4t4vZTm+3+5vje5+J9sOHPHrtHdOHc47VLkxPjhUqJvPtsH/sA+xB4d2DHmC86sI+YLx1Hbrz/ kWXjT674riewT5HNxU4yZzuwU8w5RnWPgu3q9jn2JWealzIzOrCzzPnuoyjsK+wi17CQYTuwr5mv GFWpo+Vb7Eo3EleZi4zM0fADdr17yhvM1z2wfsZuIwcL+xr7FbuFpvqKucR8w8zgKux/qIL/QwLr 2wfLyjxOCpEG8u5Tba/sAo4DHHOgg+PMt93o4BRO9zldw11wAdpBuCvuhrvjHrgnc4W5ynzPXGN+ WIN74d6cmOF+zI/MbbuI/W5H50ESdJ/khaMKvQHZ8zo7ZvfLAHejp7zWZGwy3t92r9g6sA3DI9C6 8HDmegcuZG48gtd4DB4HRJ14LC5ibjI/deL98P7Mz8wtbgEPINxDiOwAloAncsAG4RLmF+ZXrjAI FX5BAvBINijxVH5YCur7W69hD+XpoyQd1+C67tVnM3/0cDUXz+vL1UK8HIjW4kV4MV6Cl+KD8TLm L+YO8zdzl/mHhWAtnIZXAi2IwYeBSGYqCyHyNqQsdOJvvnC32exqljv6R84U5xTZSYxiFsdhdoXV gJwltPcddw0CdJqc7i3dpUJ4lzOw645ISXNje1lbczNitAbFeeNs98lMWK+eeQgCmpsPJu3QHIur weuBaBVei9fhRhZiLMRZSKzCG3ATiGEhyUKaj0v8HLj2EVb+rFvLO7GFhrbmWlM5v8QyYz2asbnW iHzmakEi6pVrGI9srbnVbGhsbHdA0ZZW8sf5HGYmc2MdGmMngt3+4ha85WUWUnb7hltx7iZC15l9 ubF1FappBWsqi8vRxcjk+npVUrKiTiFVSh7C+n/DWjnI0o7PAqJN+CR8Mj4Fn4o/jk/DGZzFp+Mz 8Jm4GwtdWYi+3VnowUJPFgpY6MVCbxb6sNCXhX7M1U34bPxJ9JmNtjz6oDgmnyvh81noz8JA+7c/ d88ZfSEKm+xFFgbZQxeOpg5DwZ0927qizj6mkHfi+vTlPH0bL1cOAnNS08jfZrHx0pNttVqs92uJ wN6A+o4K6rZRD7FNdueTl277zbTacfbb5naZtAeZmnYONR7brgokvNyJHtryvSe220k+wsRfxjsQ 8wN45rfiqzo5bvNNa8BcFMDdz+bkZEXPDt+Ab0TWAn+FhSEd+CYWhnK0jWxDZrfUykmnFYkfkrQG 5Af1hCu6rslfs8/gALUN38npnu34DhaGszCik1PldiXObQ37irhtVmg0jEOm3b4fkec8rKy7pWvX 6a2Wpu4TLgfwffgBR9CNH2RhJKPiUTgM5q7Cj+Bv4++wMIqFsSzs14PRUfzDe6Nl/COkgz5hYTSn fWI4dX7fHfNo9WN9XGP8FP75fWC+QGDOslDEgYljZH3vzEern+kTtuMX8cv3QfgWQbjCwv4chAEO RLpvn/NgWtR9wPyI3+CYdZ2F8R0gpusspJt8XYqNi/27pPIE/isadQv/jTvErENRbokX2VbjyLaD GE6QlFb3b2bZCYJoJ2cXVzd3D89gYWRUv3hxgkyuUKVnZGr4nBaEi0SYpBQmyiQSYbJcJZSgPy41 QqhMThb2tHIVUtm9rTFZOo02W6FLFidpE+ViWVZ2khh1SxJLJXK9VqbPypLJs4ZUF5enSBMfcvDI b5N780J4rdzlN/Y6zxR4efv4Bz0i98bXj3Fm3DsDAhkB48sEnAwJ9Q4Lj0BKAOnSWmT3m/nTrMrK PB1/ws9Z5j5N5eZJRi6ThnFD65NoE6X6LJlOnJWkzxInSjXZ4sRsqQ4tMkkplUuTJUqFZOTkRJUU bdZEiVIy9UR0TKzoQXeJR/edpTM2rucuMUKy/4AIe5YJN6lWIUlW6LRJYo00K1mcLc+Si5OykhLF OlV2skyarNXr5cqqrvwVlUQy9eQgiXeiNAmps+Jynn78HH3yfCL6tvXGxd6Dz25BMCZPTkxMjhdK FV1ZMhI0S7IqmTMy/r2yZ7qWLEcNaM3JytF94Xcmx3FopaQmcekyHOA+qTe9gN6fkpPMw1Rn9b2z ro4bLZmYXF9nVCpVirpaIzKGnsXlyAob67oyGqxfCbyz9Tm5efkFhUXFJaWDy8orKocMHTZ8RNXI kaNHjjHU1NaNrG8wjXLgal85kqYKcyuXC+BV7Wjgs5K4MCasuy/aLTzVuoU1T4ckkMsx4tJMEAHy bL06cZcIuSHF5ZV5ebph3CV3Q9l+91tvttpa0RwtFmTJrFXF5VpOSPjTrQDU3AOlB03Uq7y1vdFY ZLCNQ0Cq+9IbaeWQ3gMrzPYDwkYbf8njmWNtsWOCinl1E7s5xp+NM5AhGZrBnZydGcKZAQzFYF5q T8bJmQkUAMF+4AS8QDCIBmIgBcmgHAwHE8BCsBccBl+AG5CGHtAfRnK3KaEYDoJSKIMKqISZcAS0 wMegDbbB5XAD3Az3wEPwOPwUnoPfwG/hFfg95oWFYTGYGqvB6rB6zITNxFagMP11FN2+ie3DDmBv oVjrJ+w3HEeBiR8eh9zVkcirm4gvxlfZM0Hfwt/Hz+FXCZzwJKIINVFAVBC1hJFoIMzEOKKRaCKa iRbiMcJGtBETiEnEFGIqMY1geYOBQf4XmEGff8QMFibwJvp3/I9RPTkVSCWvQlV/gjWIt9yVQ9Pf ISgg2oD/jd/F/yEAAQkMYUQQyNWUsDCRhchmJLFQxkI5CxUsTGahcgOIIZwIZ8KFcCXcCHfCg/Dk TIuKxYJZLIzFxCxWzGIlLDaYxcrsAYEG2ZhxLRZzc6vNniFnsOcNBHfl7fS6hW/TW6yVZYW2kXwi HR9DIQD8JXJSdHa3uev8U1JosLVyrk6jEQHsyZXgh2kMyIOxDzS3tpcZWyxW7tDAoZ95KeIO8fkS l4/S3GDkmuwucF5zvQV1dzh53d0Deder7/kRh3IXQYkQIhqI1hGhRBgRTkQQQiKSQO5CCgtTWZjG wnQWZrAwk4XqdUQMEUuIiDiiH9GfGMDCLBaWs7CRhQtZeImFP7OYP0e9uEcdXBVaGhzlakFyn572 KKMe7XhNG/Lkkem6Z2g5d+RUY7FnY6X8G4djxZZmzvstb0c0buo5KftPT9buRfOe/g/IF7xvgfbv pFKrhTNE5W0tHGvvhdOnT7Ug/lFzcmiVIVt9T+YqISNSgGgNIScURDKhJFQs1LBQx0I9C3NZmL+G SCXSiHQig0DsLGRhMQtLWFjKQiT0vU6vCR13es1CbbVAOlE8kcND3GhpSBk0SKXR67LlSXKxQqvU i2VauUqsVCRqxHppdnaWNFuv0yTLewPK4wFl3wcoUarTq1QK5MLotAhQVpJWrEySSMVyebZKIdPJ lLIsbW9AxTygnPsAaaWaJJkKIZOkk0sQRlKVWJWtUYrlyJ/QJCZr5YlKZW9A5TygvPsAZes13Aqy xXqFPEss08kRRhJpslii0ckTZSqtRKtU9AY0jAdUcB8gmU6vUKmkGnFWsiZJLFNo5eIsiUQizk6U K2USuSQpKznbwa8qYhTyWomRLCzqgPGMgds9QY4dfO9Nx+4NW0PU3TPK0WIixj6kBalmrsXCwsH/ wUxIkT8E3mRiKtcyhYUVHcTjLBzSV4Jm8NSprBaM+m/IsuAUY0JjC9oagzjjnmDrVgQOdGYRTwPR amI28STxFDGHhUNZOIyFw1k4YjWMJ54lniPmMgYWVrEQraW6z+LR/kV2uec+k6370BhRAm3H8eY6 zkOJztP06J/ueL+vr81lj2q0hubxBtu9DQF5mpK2Vu5+wT25A10LeJFYwtFzMQtHdRBLWTjajiNn LgqaLROae40daq5rNaH450Lv+IdYSawForXEy0QH0UmsIlYTa1g4hoVozTUsrGVhHQuNa4l1xHpi A/EKsRFEsrCehQ0sNLFwLAvHcaHoiBEWS5PewOVCV2mNnDIu5SwgQp5TP8a6CktLoXG8sbGLYjpE qRjet87TVVi6ceUJUGqxmTkKFnE3nAK4xiwu9keW0NgzDZf5ZBxvRhrf4Mghjs78sb5Sue00dww+ WSlPkMmkqiSlQq6SyGVSKYrRExVJCVKFIlmRmKxAPmqSTD7VHu8Su8C1DmI3C81M1QjN8BHiJKW4 VdJN4L3EPv5YLjrzkz4xLPEWcQQF58Qh4jALm1ho6STeJlDI/BgLZ/YV6g94oUZ2fKpjy9eZbVzc 0VTT2I5k3MYdXVTXc35kZuM9p1npyfUGqUFaY1QYDBKRrfuQI9dgM6XLZEqVUi5RKiWKZGmiSqGS Jffq4hitqktS1skNkt44fcLjhGj8+H8JJ/uhl8xQL7kPp8REBVJWCnlSokyBNGCSCjHhPqTQcEWd IVkhkTioeZI4h9wz4lPiFHGaOEN8RnxOfEF8SZxloZWFNha2shDhO56FE1g4kYXtLJy0gTjP3/Mk viYuAS36/ZaFk/mbnixEyoVLukGl6dye+N/7nv/RfU/iZ25X/MLCKV03PonfwLXVxG2g5T4snMr0 s38xVQI8+sDNvjvjHxKz3/gkIXOQhUwnjCcJTo2y992tFMzrGkM6k272+5ukK1PNwhmPGOMY4U2G IokhfUhf0o/0JwPIQDKIDCZDWPgEC2excDYLn2ThUyxEev1pFj7Dwmc3kGEOiSGjOIkhY1n4XC+J mcdLzAv/KzH/scSQiUhiSBQeze2SGFKOJAYR2f6H6Mr/OdKjyTQykxeSDE5InucYnsUxfP59DPeC 0x2D9GQeLyW5nJQseMQgx4gSsgJZeLKUHEyWYfEsXMRCZCyXMltWk5XkEHIoiez9chZuZOF+Fp7s o7jJUbySfLFaUPHf4I1ktbTokAA1cDTvyurrmaqGn2rJf9HxKbVnZv8buW2952zg51z2P5fS6mDC WNIGROvJcWQj2UQ2kxayhXyMRHp9BQtfYuFKFr7Mwg4WdrJwFQtXrydbHbvUvkcns3BN9x7lN+j6 /5c26P+Z7TeL235I5611bL85aPuRTwMt92HhOk5hr7MrbFcHW+aTC/ndtIDbTRu43fQit5teuX8L Oi1wDFpOruXU7gryJXIl+TLZQXaSq8jVJPIbN7HwVRZuZuEWFr7GwtdZuJWF21i4fQO5jmcouZHc RL6KflGPHQ6W7mIh8r7e5Ip7/19i6/8tevdNjvF7WbjTwfgDXIqSAWi5D3MEsZz7VEWrfftYafJd 8n1eAR/lFPAejvvHOO6/cT/38Sccg46Tn/Iic5ITmX2PGOQY8QX5DScvX5JnyXPkefIr8gJ5kfya vMTCAyxEE7/FwkMsRD70ERa+zULkQb+7gbzcJS9Xye/Ja+j3Rxa+55CXYyz8kIWfcMXj/ysv/7m8 /MHJy58sPOqQl785RXGX/If7sPB9Fn7AfyNV4SvoH60e0EduKJpyscsN5czJzUdIBCg3TgQ+foDc 7BFQjmHelJ9dcihfTnJOPGKYY0QIFYskhwqlwqhwKoISUpFUFBVNxbDwUxaeYuFpFp5h4Wcs/JyF X7DwSxae3UCJHGmQ1EAuDZJKYOE5Rx4kC7/iEiFZePF/5eY/lhsqBckNlcrC811yQ2U8MBXSwb1s KpcXkxxOTC48PGPRMaCYGswLSCknIF//6wFDqREoAKeGUcNZ+A0Lv+2kqqiRLLzCwpt9/DjKwDs6 l6sFNd3BLnfkKm6yn8GKG7hDWOT+9A61M4eVPeCEtk+uSamBC2hbjdY+MXrviev5ib+rFiz8n584 +oEDuXyZ3o+NOUZKJVKF3EFJM9WMnGRqLDWOaqSaWHiVhd+z8BoLf1hNWagW6jGIPGekg6+z8AZ/ BujrYEleM/c8eq09MXtULQJuNZQamksttuF9roaNrjPbahstNmNdMSKDzaukfzTTdS8n+mDZwT4a ZgrFPgKdGdSMLnR+Qv9x6EQ77go5ADxFPcNJxhwKxX0ohr3VST1LPcfC2yxG95WMF3gG/VotKPz/ 7wIn2DnMHTf2nmIxP8Vv1YLB/00PrfSap2u9y6iVQLSKWk6toJA//TsL/2Dhn6uol6kOCvnUf7EY yWIUx7b4PncLuu5HPew098HdS63G8WZLm63CYG0wdtXZb5BWC0QP6F7N1/XuzWuP9Zw62cDCO0zV p9QmOIpLjKdepTZTW6jXhndrYhYik3SXhX+zGPHfzKTorLemryw74ZLooOJ2ahcnNTuonSwGWAx2 UrupPSyG9BDOqIbwuA/hF1It8L5/XX0TUe03J6mD1FuOxGEHXe57log6RB3m0qQf3e3BTxQ9EBHH gt6h3u2TUki9T33MbawPqGPUh9RHLObEYs4s5sJirqupT6jj1AnqJIu5sZg7i3mwmB8nMeJHiECf yi4Z+A9F5j8UyLiHS1i5uYHLSnS8siGgT0/uJqejxecB/XmRPMuJ5DkW8+wtkheoi9Ri6jUW82Ix AdrHSBCR5Owbd/3i5a8ddP2WuspJznfUFRbzZjGfTup7uJTFfJkZ9wvOg6Z3wPmJ+rkvw25Rt4Go g0KTBnRQv7NYUF/19bddt2CB1YJtDvvCfXG2P+V/5NG4TPtTe9wje+lJUpH9QmtpTE+UiozNdY5q VOQqpXIR74bY66VJXVcldrcmXZrgOPqlAQ37rJomaAp4d9BIaYV00DSLhfLZYFwGBp8W9MCUb9qN 9gfeG2h32oP2pAW0F+1N+9C+tB+LhbNYBIsJWSySxaJYLJrFYlgslsVEG+gA5C/G0MF0CB1Kh9Hh ADXEIX9RymL9WKw/iw1gsYEsFo+qZMNb7Sws1xWMMNuyG80N/Dsq/Plq/oZEnm2o2Yrkl5NtQXd/ ++Nv3B0R3959e+1hvtqeKNNq7Hp+wbt3X72hydzYXi3w611pT5fkbzXfgwTiW60V2fmR5haTpdlo sSUmJUiHOS6qBaq68a119r5ivjIl0YgciTqlrNZQX5OkrJFIlDKFQS6rSVTVJhkV9TUyGfo1JCkq DdYmhWyIuZQbNZz/UcZLHTxIpOXIEtFSOomWsVgCiw1iMckqWkEn00oWS2SxIhZL4/SKxPESoe6c ha78BkSQ8rYm7n0oPK/LjQ12geVTRfsOKWnp9faVvk32pCH7tqYzwNw1dCatprNoDa1lMcRbFYul s1gWi2V3pzbSejqfQz2HzqXzWCyJxdAC5KvoArqQRkgrWCyZxZQc6qL7JuuDaanVbLGipmrBwEd3 1Bhqx5UbW5BLZtdL/R/dm7+wp3BHq514f6cWCGMxIHzwdhhCj3jQeqrokRwrUlgs1c6KaHWX8zRY WGlPoHCMr6UbHjTeRJvpsSyWwWKZLKbmxgv48WUpD0GkhW59EKA2ejw9gcU0LIZ4ouNusN3ssyp7 qiU9Bf+txMt/9j0pluz0fzfFMpJ28hQEh4SK4gbKFcnKSFW6PQetpHzIiFENzdbxk6Z2vT6MT8Qc xuVx2QnNpwaOLC7PakUVNW2tRhuDMUIGH17eVltrNNYZ6056ebs8OOGRy3QkGJLLdKSYYMZvSHG5 HqlS1BNpRov1VFh4hNAlMio6Jha1cDmNaN56faOhwf6+mu5HZ1Ejp/Si1SKeMl5PChgnhmaCRieU 64vLuQePxRoUo51w6dd/AIpo+Vl6xvdCPZBx5tCNl8hWiRMG8SmUqxKlSYy7PbMxwJ6Eqa3gxlfm VdpQBNs92P7OGq6BQ7RXrdAxQG80cCqr3NjKZfrbenXx5DtwONphnvB2SUnrSGUEjD+HTUZWUGem mktu7NRo+bd3VQtC0BgHwEb7G7Z6v98ioLuVS+3uaREAAXWCyyz81y8BKizuTu5EI0oH3/vqntKy 4u739uQXVFQ+5J09FYXFqHnoMD5nsA/dO4cXP6AW9a4a2SUJnVXFp0ZXjzG41NTWGevRdEM5zT+S k4+mFqRSkcIb2SUs5Vwyoz0RVttma7U09VRqJEArESYKcCaEifjUZB7rMq4xp6miuDxPV4m+tFoE 124jBM5MKBN+wuLS8lhP3rKXCQmUydDS0ogh0WpChj6nLGv4sOEjhPRZ4AQCgCdIAJ6GWltLVmlp ISd+zQgxcN+/304De5LeSTEH6/72R/4jUSxYi365ALC9zlbbBABMA4C+UttibQXAmXvRSvSE1hau nIvKvuMqyrSoPBIAJ7eusdy/iBxjs9FqrhWi4LddmGNABkQoTZAKkf/HxQz/IVb/xr+mxrbuudHH zTauvAD9JiD8Z9YZdFxZicpbaw3Z5V3l78ebhxSjshoALKqlVVOGyvmoXNM2rjILleNReVO9VV+J yhmo/JmpLZcrywDA/SeZKoaicjgq5zfXFJegcgoqm2pt2hGo3A+VO03GPI5PiGb4++bWvApURvPh 162WMq7/AACItDqjLpuvJ+rHWQo4HKJQebttfHm2A+dJJm0xPxdxeqwhn3vmHSkg4ldjY04ZD4cM bmkt5WCia1LX3FhcyK+LXGS02deLrsnTraYKjmdSAKioVmtFGY8bVVFv1uehsh6VJ5qsuWX8eqn9 LY12OUM0oe5Y28oq+TXSemNzJQeTkwvGYM3O4WlF7wVDoAEYgQXUoO9a0AwuAiGwATMYby81AANo Qh8hwiAefXJQr2b0saIeNjDO3sMKLne3O0ZwY1pQiwXUo56NaJyjVmh/IR4/joNhQR/uioN7xV5X 2zVfAvpow9eANnRlAj+gdhMqFYEL9pqJCL8m9KtFtW2orQGVe8/Cjy+148rjIOzC/mrXLBY7Lobu cT24aVF7M5iEamyOlREBhIRIQp9UopBIJyT2UVbUox2I7fVp9jrHrD0r59Z2tXvWxxCuvVffm14O Gr6FRrWi60a0wuYu+tgQNnfQmHFdo+9Z57zgtn4tLYueG5w3em03FsLp1mpz7cdzbz6Ca/fPLu7D t5LecmGXlLr75ALNRZ4gPyHPk58CIfr9hjxFXkEl7nbFWfLzB1LF0k2DBvSxdEuAsQ9vjKhno32W +/Hs4RkP5x4IEO/umWWHwrU2oY/Z3sfWzb+2rlcu19tHi+/hXc698747ZW8gEJ5+5uBRINwk2PNe D7VPEbtHnnR7d0p987zglpbRa6f8ZWzpaeX4YJxd/FsxmB4veU3yg2S1ZJPkF8n5nh6SM5IfJack HajlGv4CvgPfh+/B38CPASG64lLA99hLm/C96O/1h0h4wwMknJOY2i6J5lpbu2Sqt+z3pmxWL2px /R0UHvsQee0tMRzH/j2MesPpqxGMPbvOI9oj0YP2GOAh98jygB6R6E/qoUalaI8oj0KPANSa6xHn ofMI6aaHQ9Ybuzhs7rO/eYyHo1aHJDTbtYsB9eR6GLrWe+8ahX1Wya3M3HtXQXe0q8y9dMKDdJGw z86qRGPNYIJ9vM2+25vt41r6yJ/NroVQDayy8/ABuBHhRCKRhzRQCRASWYScUHeVea3k0Et2ThGZ qDWD0BFKTo/10Qu1/xL73jvDSKVQcVQ2FdfTTumoXEqPfhO5emoQlY/KKq5XK/KxOSOvtbS0W7kX wQizkJdjFOY11ybEC6WSRGTdOJ+JdwV+GWz3haD/sdo263i+juC+SBQJeQJfEISsajSy1vxjGqnI ZmYje1cCKhBfR6N1mBDeVkTZKYAFs+yvSl8IloKVYDXYADaDrWAX2It07DvgA/AJOAW+RPbkMrgG boLfwF8QQhq6Qx8YBCNgLBwIpVAJM2A2LIRlcDgcAxtgM2yDU+AM+DScD5fCDrgBvg73wLfgUXgc fg4vwqvwZ/gnhmNumC8WhomwQZgSy8IKsApsFNaAPYZNwmZiz2GLsU5sE7YTewv7ADuFXcCuYbdw gLvi/ngkLsaVuBYvwUfg9bgVfxyfgy/CO/HNSAe8i5/EL+A/4H8QFOFDCAkx4mIuUUnUEo8RjxPP EEuJ9cRO4ghxkrhI3CTuku5kKDmQTCHzyGFkAzmBnEUuIteSO8i3kYa+TP5GUZQ/4k8y4ttwaiw1 mXqGWkFtoQ5Sx6lL1C2apoPogXQ6XUIb6FZ6Fr2E3kQfoE/Ql+nfnVydIpykTnqnEU7NTtOdFjm9 4rTf6YTTd05/OQucY51TnEuc65zbnec6r3Z+w/lj58vOf7l4ucS5pLtUuIx1YV0Wu2x2edvlrMsv rq6uUa4q18GuZlfGdbHra67vuV50/cPN222Am9ZtpFub23Nu69wOun3u9ou7u7vIXe0+wr3V/Tn3 De6H3c+7/+7h45HgkedR5zHNY5nHTo8THtc9nT1jPbM8R3tO8lzkuc3zY88fBM4CkUArMAgeFywT 7BGcEdzy8vFK9CrxavJ6xusVr6NeV7xpb5F3tned90zvVd6HvS/54D7RPlqfWp8ZPqt93va57Ev5 xvnm+Y71fdr3Vd+PfG/6efvJ/Ib4TfRb5rfP74I/7i/yz/Nv9J/rv9X/tP+fAWEBWQHGgKcCNgec CLgdGBKoDjQGzgncEngq8M8gYVB20Lig54N2BZ0LJoIHBA8OnhD8UvDbwT+E+IakhtSGzAnZGvJF KBY6ILQsdHLoqtBjobfCwsNywlrCloQdDvsh3D9cHT42fEH4/vCrET4RGRHmiAURByK+F/oJs4SN wsXCI8KbkaGRuZFtkR2RH0X+FRUXVRk1PWpL1Llol2hldH30guhD0TdjImKKYqbEbIz5ItY5Vhlr in0x9t3Y26I40VDRbNEu0ZW4wLi8uElxG+PO9nPvl9nvsX6d/T7tT/VX9h/Xf0X/TwZgA+QDTAOW Dfh4IDZQMdA8cMXA4/FkvCq+Ob4z/ozYTZwlHi/eKL6Y4J9QmDA9YVfC9UExg0YMen7Qu4PuSuSS RmTdvkz0TsxPnJ74RuLP0gHSWuky6adJ7kn6pGlJu5N+kg2UGWUvyT6T+8iL5LPlh+R/K5IVVsVm xdXkmOQxycuTzyh9laXKZ5TvqUiVRjVNtVf1R4oipTVla8qNVHHquNRXUq+kxaUZ01anXUqPSjek d6RfyBBmjMl4OeNCZmSmIbMz82t1tLpOvVb9XVb/rLFZm7KuayQaq2aH5rY2RTtVe1CH63J0c3Qf ZXtnV2YvzT6vj9I36Dfqb+bIcybnHMwlcwtyn889kxeWV5u3Ie9mfnL+1PwjBW4F5QVLC74uHFBo LXyjCCvKL3qh6GxxbHFz8a4SUJJX8kLJudK40sdK3xxMDS4dvGzwt2WJZVPK3i33Ka8uf6X8twpN xdyKLyv7VbZVHhriOWTkkA1Dbg/VDZ0/9MKwQcOmDvtgePBw8/DdI+gRQ0asHXGrKrtqYdXlkfKR s0aeHhU3auKoo6ODRzeO3lftWW2o3jaGHDN0zCtj7hhKDJ2GWzV5NctrbtZqa1+svVanrltQd9WY bpxv/K4+vX5+/ZWG9IYXGq6aMk2LTD+Yteal5p/G5o5dOfb2uJJx68b90zi0cUuTU9OYpj3N3s3j mo9Ywi0TLcdbBrbMarnwWMpjCx+7aS2wrrVB2yjb7lZfFGAea+vX9kTbxfEZ45eN/33CkAnbJnpN bJ54rH1A+1Pt303ST1ozmZhcO/nQlMgp7JSLU7OmdjwOH695/NC06Gkzp11mcpj1rAs7jv1wumT6 /Om/zhg6442ZYTOZmZeeyHli4yyPWdZZZ2anzl75JPGk+cmPnkp6aslTd+fUzXn/acnTi56+80zt M+8/m/js4mf/ea7+uY/mKua+NI+a1zzv9POZz6+f7zV/0vxLLxS9sHOBcMGcBb8urF54dJFs0coX XV5se/HC4sLFu5fELJm35M5S09JTyzTLtiwPXf7U8tsr6laceEn90uaVYSufXvnny+aXP+vI6djZ KepctIpaNX7Vt6uHrH53jXLNhrXBa59e+/e65nUX1petP7IhecOGV0JfmbsR29i28eqmkZs+eVX3 6u7N4s0dW/y3PP0aeK3tte9fH/P66a0FWw9tU27bvD12+/IdPjvm7IQ723fe3GXadWH38N3H9+Tv OfRG6hs73kx4c93eyL3L9vntm7vfZf/M/f8cmHTg1sGWgz+81fDWpUPVh748POzwp0cGH/no7YK3 33tH/87hd7PePfBe+nt7j6Yc3fO+8v1dHyg+2HlMfmzHh/IPd3yk+Gjnx8kf7/5E9ckbx9OO7z+R eeKtk7qT73ya9+kHp4pPHT9defqzMyPPXPis7rMrnzd+/tMX47/460sGOfFzzgnOLTofer7zq/5f bbmguLDvou7isa/Lv/7yUu2la9/Yvrlzeea37t8u+i7iuw1XpFf2XtVf/eT7qu8vX2u59tcPs370 +nH59X7Xt99Q3zh2c9jNyz9Zf/rn52d+Cfpl3a+yXw/dKr11/rem3/66Pef3oN/X/6H8490/h/75 3V8T7tB3Fv/d/+837hbcPftP0z//MGEn8gtsrfc8pWhrK+56RBG1TpjY57ins724zzXqMXmK4/Sw czJ38PT4NPuZUPdhWx1/btnJFD+w/v7HcY/PmFlhtVhaGXjPw6NVyHMyoWhvov3t308hL2QhWI48 kC3I/9hu/5+0vAn2gQPIC/kIfI48kKvI+/gbUtAZuiL/wxOGw2iohhqogwWwBA6G5bAS+R9VcBSs hgbkf8yHO+C78Bj8CH4CTyC/4yw8Dy/AS/Ay/A5exWgsEovGYrEBmBzLQL5HMTYUG4mNwyzYBGwK Nh9bhC3DNmOvY0ewo9gn2EnsPPYt9gvyP/zwQDwUD8eFeBQ+EJfgCjwDV3OvW8Hz8MG++3wP+B7x PeF72vec79e+N3x/9v3Hj/Bz8/P08/Xr7xfvl+VXjuxiFe+xdT90+kTfMx+/USxMcJxqT6NnAdFa Oodm6el0Hj2TfsJ+tq1nsRwWk7NYLovlraULYD79FD0H5sN8FlMwJhZDv4WMCf2pqgVRjz7y519e 8S866ewvhI77153szyf/y54V5ia+5wn6BbTKBfRC7sSQe2UGd9ez6cZztweyWIH95jb9Ir2Yl2Aj KoM1oyssdYZ2oaFVmJiUIk0SfM/fflkO5nYAdwbrudPyMt3Jvcwb1XXQq1istOvNE/Ta7p789Sv2 l2Hw5VfBtVeweOpp6jfk/ytQpKAikumdxGFmCwtvsViA/UlFnf3BxXzuwUWsnIUW7rV93XdL6b38 3dKK/+kc6wdsNfog/ValPR3LvtuCQBQYCOQgBWQSPxK/kIB0In3IYDKCjCSjyX7kAFJMDiKHkE3k JPIp8mnyWXIu+Tz5ArmQfBH5wOvJV8hN5BbydXIb8od3ke9QNCWhqqip1BJqO3WM+pz6gbpO3aR+ pn6lfqN+p/6k7lB3aS/ah/ajA+hgOowW0tF0LB1H96eT6Xx6FN2CPOQd9CH6FH2d/ssp3EnoFOUU 4yRy6uc0wCneKcFJgvxlmZPCSemU4pTmlOFkcKp1Mjo1OJmdxjk1OVmcHnOyObU5TXBqd5rsNNVp mhPrNMNpt9OXTjec/nQmnUOdM52LnFucn3Je7rzR+bjzd87/uAxwiXfJcil2GexS7jLEZZjLCJdm lwkuU1wed2FcprvMdVmE/OylLstdVrmscVnnssFlo8sel3dcPne55PKNy48uv7lCVxfXANdQ11hX KfLBU13TXTNd9a65rvmuha7FrmOQT251ZV2fdJ3nusR1i+tO192u+1wPIA/9uusvbkFuIrcUtyK3 ErfBbiPc6t3GuU1wm+n2hNsstyfdFrotdlvqtsJtpVuH21G308h7/9LtvNsFt6/dvnP71e0vt7/d /nGH7k7uLu5u7h7uAvc09wr3Rvc294nuk9ynuD/lvth9qfty95fcX3bvdF/tvtZ9h/su9z3ub7rv cz/g/hby/N92P4G8/z883D36e+R4lHuYPcajCID1mOHxhMdsj3ke8z0WeCzyWOyx1GOXxzlP6Cn0 7O8Z75ngKfFUeWo8dZ56z1zPfM9Cz2LPUs/hKFZo8DR7jvec7DnVc5rnTM9Znk96zvGc57nSc73n Bs+Nnps9D3ue9rzs+bvAV+AvCBQEC0IF4YJSwXDBGEGNoE5QLzAJ2gSMYJbgScEcwTOCVYJNgg8E nwhuCO4I7noBL8xL4BXmFeEV6RWN4o4Mr3yvCq8hXsO8Rnht99rnddLrM6/rXre9o7zjvMu8x3jP 817hvcb7de9t3ju8d3kf9H7H+wPvT73PeH/u/aX3zz60j7OPq4+7j6ePF4pQCn2G+gz3qfIZ5VPt Y0DxSouP1afVZ7wPiyKXeT7zfRb4LPJZ47PVZ7vPTp/dPh/7nPU573PB52ufmz5/+/zjC31xXy/f FN/BvvW+k3yf9X3Zd4fvUd8PfD/0/dj3uO9J31O+5/3S/fR+Y/wa/Fi/F/1W+73qt8Xvdb9tfjv8 9vsd9Dvkd8TvHb/3/I77XfX71e+uv6u/r7+/f6B/sH+of6x/nH9//4H+Yv9B/kX+Y/2f9V/rv85/ u/8u/z3+e/33+x/0/9T/nP/X/t/4f+t/xf+W/x3/uwEgAAtwDnANcA/wDPAKCA6IDpAEJAeoAlID 0gN0AfqA3ID8gMKAIQHVAY0BloDHAloDxgdMDHgmYGHA4oClAcsDNgS8FrA1YHvAzoB9AQcC3go4 HPB2wPGAswE/BxKB7oGCQO9A38CwQGVgSmBa4KjA9sAVKCb7MPBi4I9BrkHuQZ5BXkE+QX5BAUFB QSFBkiBpkCxIEaQMSgnSBuUHFQYVB5UGlQVVBxmCaoOMQdag1qDxQRODngiaHfRU0NNBS4LWBq0P eiVoU9CeoDeD9gUdCDoW9FXQxaBLQZeDvgu6GnQt6MegG0E/oZiPCnYKdgl2C/YIFgR7B/sG+wcH BsuDK4InBi8NPhj8dQgVEhuiCykKKQ0pC6kIGRVSH2IKGRvSGNIc0hJiDWkNmYpixLkhz4e8ELI4 ZGnI8pCXQl4J2RNyKORwyNsh74W8H3Im5GzI+ZALIZdDvgu5GnIt5E8USyaF5oeWhNaHWkJnhz4T ujr09dC9oftDD4YeCj0S+k7o8dCToadCz4R+EXou9KswLEwYlhlWHmYLY8Lmhj0f9kLYwrAXUfS5 LGxF2KawzWGvhW0N2x62M2x32Bthe8M+CDsX9mt4RLg2vCb8+fD14TvCd4e/Eb4v/ED4W+Enwy+E Xwq/HH4l/PvwH8L/jKAjXCLcIjwjvFDkKoyIjoiN6BcxICI+QhyREpEekRmhidBF6CPKI4ZEDIuo ihgVUR3RGNEWMSGiPWJyxNSIWRFPRsyJeCbiuYh5Eesi9kYcjTgW8VHE8YiTEacivo64FPFNxLcR v0TcFQIhJiSElNBJ6IOi4gBhkDBEGCaMECqE2cJ64XThAmGHcLVwrXCDcKPwVeEB4THhceFJ4Snh F8KzwvPCC8JbkW6RQZHhkcLIqMi4yP6RAyPFkQmR2sjSyMrIoZHDI0dHjomsiayLnBw5P3JlZGfk 6sh1kRsiN0bujtwT+Ubk3sijkacjP4v8IvJs5PnIC5GXIm9G/hx5K/J25B+RdyLvRoGokCh5VEnU 2Kj2qCVRa6NejXotalvUzqh9UQejDke9HfVu1FfRZLQqWhOtjdZHl0SPjK6NNkePj342+rXofdGn oz+PPhv9VfTX0Zejr0Rfi74e/VP0r9G3o/+I8Y7xiwmMCYkJjxHGRMfExsTF9I8ZGJMQkxiTFJMT Ux1ji3k2Zn3M4ZivYu7GusdGxipiM2PVsdrYwtjBsSNiq2JHxbbGsrEzY2fHzol9NnZu7LbYvbH7 Yg/EHos9Hvtp7JnYs7HnYy/Efh37pyhU1F8UL0oQJYpkIoUoU6QX5YkKRSWiwaLRIqOoQWQWjRNZ RW2iCaJJoimiuaLFojWiTaLNotdEW0V7RHtF+0VviQ6Ljou+EH0nui66KfpZ9KvoL9HdOBCHx5Fx gXGRcQlxiXGyuOQ4VVxq3PC4mrix8Zfiv42/Ef+3mBC7igPFA8UJ4kSxTJwsThGni9VirVgvHi6u Eo8WG8R14gbxWHGTuEVsE7eJnxFvEO8Uf5gAErwTBiVkJYxMMCdMTJic8HgCmzAzYXbCnIRnE5Yn rEzoTFiTsD5hY8LmhNcTtiWcGxQwqGLQzEH7B/0uiZPIJJkSjSRbkispkBRLhktGSqolNRKjxCQZ K5kgaZdMljwu2SY5KDkkOSJ5V3In0TnRNdE9UZCYnViWWJE4JHF44nOJyxJXJK5M7Ew8k/hN4neJ 3yf+mHgj8SepuzRYGiYVSqOlsdI4qUyaLE2RpkszpVnSYulgaYV0qHS4tEo6QTpTOls6R/qsdK70 eelL0g7pauk66SvSTdI90jel+6QHk4RJ4iRFkiopLSkzSZNUkFSUVJpUnjQkaVhSa9KTSZuT3k26 mHQ96aekX5NuJ/2ZdEcWKIuUJchSZRmyLJlOliPLlxXJRshGycbIamX1MrNsnKxJNlE2U/aS7G3Z V7KfZX/JRfJBcqlcLk+Wa+Ql8lL5YHm5fKTcLG+WPyZvlbfLp8inyVn5c/J58vnyhQo/RZQiRiFS 9Fe8otileF/xoeITxUnFacXnirOKrxRfKy4rflf8pfhb8U8yTEbuZ7JzsmuyR7IgWZxcmNySPD95 d/IXyXeVYco0ZbYyV1mgLFIOUVYra5R1ygalWTlO2aQcr5yhfFI5R/mscr5ygfJF5RLleuUryl3K vcr9yreU7yjfU36g/FB5VnlVeUf5jwpTkSonlavKQ+Wl8lUFqAaoxKpBqkRVkkqhUqlSVekqtUqj qlY9rupUHVF9n+KWIkkpSWlOmZAyKWVqyrSUJ1OeT3khZWHKiylLUpalrE95NWVLytaUXSl7Uvam 7E/5MOWTlHMpX6d8k/Jdyg8p11N+SvklFUv1TA1MDUkNT41MjU6NTx2UKk2VpypTU1JzUvNSC1KL U9ekbk3dnrozdU9aUJoorV/agDRx2uy0BWlr0tanbUzbnPZ62va0XWlvpO1L+yjteNrJtFNpZ9K+ SDubdj7tYtqldJAeka5NN6Y/nb4l/aP0H9N/S/8j/U763Qw6Q5Dhk+GXEZgRnBGaEZ4xMEOSIc2Q Z6RkpGVkZmRllGaUZ4zJsGWMz2jPmJIxLWN6xhMZT2Y8nfFcRkfG6oy1GeszXsl4NeO1jG0ZOzJ2 Z7yRcSbjt8zgzLTMmsyZmesz3838NvNG5s+ZtzJvq4HaWe2qdld7qr3UPupQdX91glqiTlIr1Snq dHWmulg9WD1aXas2qk3qJrVFbVW3qmeo56lXqdeqN6g3qbeot6p3qHer31TvVx9Xf6o+rf5M/YX6 nPqC+pL6svqK+vssOkuUlZ/VmDU/a3vWZ1m3Nf6aCE2UJlYTp5FoVJo0TaZGo8nW5GjyNAWaCo1B U68xacZpWjRWTZtmgmaW5inN05rFmhWalZpOzTrNBs0mzWbNPs37mnOaC5pLmm81VzU/aG5oftbc 0vyuddV6aAVab62v1l8bpA3RhmmF2ihtpna0drp2tfZ97Q86gW6Qrlg3VDdCN0pXrTPpHtPZdG26 Cbp23WTdk7pndXN183Uv6pbolulW6Dbp9uj26w7qDuve072vO6b7SHdO973uhu5n3S3dn7q/s0E2 lu2Z7ZXtk+2fPTn7yew52c9kz9XH6WX6dL1ar9Xr9Xn6Mn2lfpi+Sj9KX60fr5+pn6/v0K/Wv6rf qT+sP6b/WH9Cf0r/mf6i/hv9d/rv9T/or+tv5xA5zjluOZ45vjkBOcE5oTn9cwbmiHMkOdNynsl5 Lmdezgs53+X8mvNXzt1cmEvkuuZ65Hrl+ub652bntuauyF2buyF3U+7m3AO5R3OP5X6ceyL3VF5M njgvJS8zT5OXnZefV5RXmleWNzxvTF5b3oy8Z/I25W3LO5l3Ne9uvmu+W757vmd+aH5sfr/8gfkJ +Yn5Kfnp+ep8bb4+Pzd/Yv66/NMFoCC4QFKgKkgryCzIKigrqCwYVlBVMLqgoaC1oL1gSsG0gpkF swueKni6YH7BkoItBXsL9hXsLzhY8GHBJwUnC04XfF7wZcGVgu8Lfii4UbimcGvhtsLthTsLDxe+ U3i08Fjhx4XHC78q/LHwzyL3IkGRT5F/UVBRaFFEUVRRbFG/otSijCJ1kaYouyi3qKCouGhwUXlR ZVF10diiGUWLil4tOlR0puhGsVOxX3F48YjiMcUNxY8VP178RPGTxU8XP1e8sHhx8bLil4pfLj5Z fL2ELhGUhJSEl0SWxJTElQwoiS9RlahLtCX6kryS0pLykiElw0uqSmaWbC05X/JdyfWSO6XOpYJS n1L/0qBSYWl0qai0f+nAUlmpojStNK+0tLS8dEjp8NIxpbWl9aXm0nGlraUTSp8onV+6pHR56crS ztINpZtKt5RuLd1euq/0SOmHDcMaqhpMDW0NExsmNzzewDbMbJjdsKDhxYYlDcsbVjZ0NKxqWNPw fsMNU5BJayo0VZhGmcaYzKYWU5tppmmWaa5pvmmBaZFplWmtab1po2mz6TXTHtNe037TQdNR0/um Y6ZTpu9NP5humH423TL9bvrLdNcMzYSZNjub/c2B5mBzmHmqea55gXlp1zkPxv/Sh/qe85iX/39Q SwcIQigsCdNHAABAeQAAUEsDBAoAAAAAAJlVFU8AAAAAAAAAAAAAAABOABAAV2ViS2l0QnVnaU9T MTMuM0JldGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS94Y3No YXJlZGRhdGEvVVgMAOSkyl2CBF1d9QEUAFBLAwQUAAgACADLRBNPAAAAAAAAAAAAAAAAZgAQAFdl YktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9qL3Byb2plY3QueGN3b3Jr c3BhY2UveGNzaGFyZWRkYXRhL0lERVdvcmtzcGFjZUNoZWNrcy5wbGlzdFVYDACfjcpd3kNaXfUB FABVjs0OgjAQBs/yFLV3WH8uxlSMUkxIUEmEGI+ENtoItCmr6Ntb9OR1MzP7sfWrqclT2k7pdkWn wYQS2VZaqPa6okW+8xd0HXpszI9RfsliYmrVIcmKbZpEhPoAG2NqCcBzTrI0OeXENQDiAyX0hmiW AH3fB+VABZVuBrCDzGojLb5TF/OdEAgU1L351f/muKtQFYbeiN3lO0x4zJWIdGMeKPdlNZ9tFZ5L 27rBDAbCgWgfEpwIP5PBtxt6H1BLBwh3FXK4vAAAAO4AAABQSwMEFAAIAAgAmVUVTwAAAAAAAAAA AAAAAGoAEABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai9wcm9q ZWN0Lnhjd29ya3NwYWNlL3hjc2hhcmVkZGF0YS9Xb3Jrc3BhY2VTZXR0aW5ncy54Y3NldHRpbmdz VVgMAJ+Nyl2CBF1d9QEUAFWOMW/CMBSE5+ZXuN6T124VMkZAUgkpKpYwQ8cQv1KrjmPZLiH/HgcQ EuvdfXfHFufOkBP6oHs7p+/FGyVo215pe5zTvfzMP+iCZ+y13K7lt6iIMzpEIvarerMmNAdYOmcQ oJQlEfVmJ0nqAKi+KKG/MboZwDAMRTOlirbvpmAA4XuHPo51KssTUKioaJq5tT/dSarSbeTZC/vD ka/+tVG7MUTs5OiQwSQmL0SfLvOt10dtG8PgLtwx4fGkcQiVbQ4G1QP7aUxASBtwG2FwvcCzC1BL Bwir0DdV0gAAABkBAABQSwMECgAAAAAARmtsTwAAAAAAAAAAAAAAADYAEABfX01BQ09TWC9XZWJL aXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai9VWAwA5KTKXeSkyl31ARQA UEsDBBQACAAIAMtEE08AAAAAAAAAAAAAAABLABAAX19NQUNPU1gvV2ViS2l0QnVnaU9TMTMuM0Jl dGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2ovLl9wcm9qZWN0Lnhjd29ya3NwYWNlVVgMAOSkyl3e Q1pd9QEUAGNgFWNnYGJg8E1MVvAPVohQgAKQGAMnEBsB8SogBvHvMBAFHENCgqBMkI4TQCyCpoQJ Ks7CwCAVklpcEpCTmFfsk1hcElqQXpSYkuqckZqcDVV7BogFgOqS83P1EgsKclL1coAKS4tTU1IS S1KVA4JBigwN9Yzm9p6KBbHf3pupAKIBUEsHCLHgd66DAAAA3AAAAFBLAwQUAAgACAAsaGxPAAAA AAAAAAAAAAAANwAQAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRhLy5fTmF0aXZlV2Vidmll dy54Y29kZXByb2pVWAwA5KTKXRSfyl31ARQAY2AVY2dgYmDwTUxW8A9WiFCAApAYAycQGwFxHRCD +BsYiAKOISFBUCZIxwIgFkBTwogQl0rOz9VLLCjISdXLSSwuKS1OTUlJLElVDggGKTw771QsiI4R fGMBogFQSwcI2RAQClwAAACwAAAAUEsDBAoAAAAAAD1rbE8AAAAAAAAAAAAAAAAjABAAV2ViS2l0 QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy9VWAwA5KTKXdakyl31ARQAUEsDBBQACAAIAOBq bE8AAAAAAAAAAAAAAAA3ABAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy9WaWV3 Q29udHJvbGxlci5zd2lmdFVYDAChpMpdJKTKXfUBFADlVUtu2zAQ3esUE69kIKXiLopCQRaB03yQ wAnipF4URUFLY4sIJaokJUMteqBeoycrP7JsJVoELdBNBUggh+/Nn6MoCqII4CPDzVQUWgrOURK1 YSvtDmZUsxoXuKwNwkiccCqRakxh2cAFpo2CK8OkCyoRLvJlBqKAyTsyOSKT98QTRNlIts40/PoJ b48m7wd5BE45B4dTIFGhrDG1CoKA5aWQGh6vrpneboxTdhcECadKPQshNti+5BAW1zNas7WJSBRn yNGsEL4HAFBTCRtcWkJsYAu/PAjsGYgapWQpwqoqErB5OGPpjaBpOPZs93QL4+52yVbAUUMlOZzA 4/1NqLRkxTqGUaZ1qeIoKtiTcZ7kKL+RFOsoEVJpVHq0r9o+pSHqcGTNjsa9E+u7xK+VYXkr934T GrOxtd2Ht1BiPZhnouLpJS1SjlMhnhgqo0LLCnuUNjOE25hb/k7pj2D3HciXJVl2L1ltNL6P9uLp Fgr5irR2jUtdScLxIIQULwt74hBBh7eVUJnptdSHOtdC0rXFXT483PVkxON2pl7SSOJ2p0mCpb4T nCVNTxPZPyGUb2ijhnplbryyBQevz2RGrCXNmU4o5w2shASWG3uqF0fSubKNs8tEIooVW1fSJcNK FdN4RjV1aFf2XSA45NLsdvZmens/70S2w7zFOylK2yKfev2xi9qeo9TNNTYkFTllhen1Zz0+OnwF uaQ6M9ToVeCC5mjAGz+k3PV5Da2mvPoTnsKkkpZ4fnoz/zDqGJ8HEtbvCVYwHZZelblr8X5WxwfH HX+vvMaa9uzQS8fHQzXr1esvamWT4Omu63zRNkI+oVT/SfH+ZeHcza39jNu/xc9Hqpuk7Vn4ZeBX dQgpS8+NmyqD3SyMe7+8g/0JrJnmNsjt2HD71mwQmPc3UEsHCI0M7JetAgAAGQgAAFBLAwQKAAAA AABGa2xPAAAAAAAAAAAAAAAALAAQAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2 ZVdlYnZpZXcvVVgMAOSkyl3kpMpd9QEUAFBLAwQUAAgACADgamxPAAAAAAAAAAAAAAAAQgAQAF9f TUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvLl9WaWV3Q29udHJvbGxl ci5zd2lmdFVYDAChpMpdJKTKXfUBFABjYBVjZ2BiYPBNTFbwD1aIUIACkBgDJxAbMTAwSgNpIJ/R l4Eo4BgSEgRhgXU8AeJMNCVMUHEBBgap5PxcvcSCgpxUvZzE4pLS4tSUlMSSVOWAYKjaL0AcycBg jlCXm1qSCFSTaJXt6+KTmJSaE1+ZllmVlFVQZZ5kWpCYVFySlmhSVFBmkltQCdQ8r/dULMggTo8e HRD9qefwvcsSq14KsMh9PGkUmfD4c+7LO3V8dySWGu+vj+yu2MQz696Mwk2edWzeJYFzPfR35zpc OZn8uuy0afaUad6rpab9uD2j/EykZHttx+9fny4l+7fK5JW/ENuhAgBQSwcIDFfRB/YAAABNAQAA UEsDBBQACAAIAEJrbE8AAAAAAAAAAAAAAAAsABAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZl V2Vidmlldy8uRFNfU3RvcmVVWAwA1qTKXdukyl31ARQA7ZfBTttAEIZng1vsoCquhBSOe0HiEFUh rZpWFZLrhENuSEHhQCuwiQuujDeyHdw2TZVLH6K8QR+lT8CD8AAwtoeUOIkEJ0K7n7X67Xj+WTtj 73oBgJn97iaADgAqZKoUYSYqtSkKpMvYWJrDAQ/bMVgQzc4lkUgWiOTdfQ7voYdbc+L9deAFhBCD C58ganniyPaEDdlQ8Q7bxlVKmqWEGULcHPSF6PsCR5hj/EvO/TvnLoKZRic9engdAQj4POlh5bt4 7DjskeeP3fPcMKpWL1hhSXnydFnVNFV7pn1sn4i4HVlRPzStYD852rGiE5v2d4XwxvuW3XGd+EBf bQg/slzfCVKz23Uw5MOe63dFbIq+3w33b51IOzrQ1waD2ttahdfe1IcVPqjXqxX+6uXr4VBTy+ub W63D06/fBt+HP35ldWCMClLKFeh83s2etQPfE/4xpIMvxrTAx1IJjOlhlIvxubKxn7k/cRU6GOdg kRvo87FUSWYvfQiC+eVnl7k8kkcJPXLqysNehkQiWUCS8YGTGqSjTBmdL5Aqtzw6KSc1SEeZMoor kCqkKqlOykkN0lGmNGgxWnww6pnRCoXppJzUuNctSyT/DUuZ6Mn8vz1//S+RSP5hmNJsN00YLwim SOZaju3wxgCzPwQoNpmK1+BvLCc1SEeZyg8BieShuAZQSwcIw+23ZQACAAAEGAAAUEsDBBQACAAI AEJrbE8AAAAAAAAAAAAAAAA3ABAAX19NQUNPU1gvV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZl V2Vidmlldy8uXy5EU19TdG9yZVVYDADWpMpd26TKXfUBFABjYBVjZ2BiYPBNTFbwD1aIUIACkBgD JxAbAbEbEIP4FUDMAFPhIMCAAziGhARBmRUwXegAAFBLBwgLiMA4NQAAAHgAAABQSwMECgAAAAAA y0QTTwAAAAAAAAAAAAAAADMAEABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3L0Fz c2V0cy54Y2Fzc2V0cy9VWAwA5KTKXd5DWl31ARQAUEsDBAoAAAAAAMtEE08AAAAAAAAAAAAAAABG ABAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy9Bc3NldHMueGNhc3NldHMvQXBw SWNvbi5hcHBpY29uc2V0L1VYDADkpMpd3kNaXfUBFABQSwMEFAAIAAgAy0QTTwAAAAAAAAAAAAAA AFMAEABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3L0Fzc2V0cy54Y2Fzc2V0cy9B cHBJY29uLmFwcGljb25zZXQvQ29udGVudHMuanNvblVYDABcpMpd3kNaXfUBFACtlF0LgjAUhu/9 FWPXFvMjzf5KdDF06ShdOItD4n/PzYIuXJjbzQHPyx4fx4u9hxDmNS2ZxOiAjuMjQr2eKii4qNUe 81slGob9TyL5k+kgJBCSr31Or+8AsF4OvjtmZMHMIMxce5qYFp4xgdj1fRqZFp4JgcS1p5G5xJMW /zQpcE5c8t3zRFOL1jvadH2WaGzQakerns8S0wTSxKmjkbjacR9td6DGSqqQm5q2F9bxppzBBySM QY2f1zDOk6//+81ZqGh6E36wVnLRqE0wncf03lWi1cchFwVThMEbXlBLBwjcIB7L3QAAADYGAABQ SwMEFAAIAAgAy0QTTwAAAAAAAAAAAAAAAEAAEABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVX ZWJ2aWV3L0Fzc2V0cy54Y2Fzc2V0cy9Db250ZW50cy5qc29uVVgMAFykyl3eQ1pd9QEUAKvmUlBQ ysxLy1dSsFKoBnKA3LLUouLM/DyQiKEORCixtCQjvwgkolSRnJ+SqgQUruWqBQBQSwcIBazD/DQA AAA+AAAAUEsDBAoAAAAAAEZrbE8AAAAAAAAAAAAAAAA8ABAAX19NQUNPU1gvV2ViS2l0QnVnaU9T MTMuM0JldGEvTmF0aXZlV2Vidmlldy9Bc3NldHMueGNhc3NldHMvVVgMAOSkyl3kpMpd9QEUAFBL AwQUAAgACADLRBNPAAAAAAAAAAAAAAAASwAQAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRh L05hdGl2ZVdlYnZpZXcvQXNzZXRzLnhjYXNzZXRzLy5fQ29udGVudHMuanNvblVYDABcpMpd3kNa XfUBFABjYBVjZ2BiYPBNTFbwD1aIUIACkBgDJxAbAXElEIP4qxmIAo4hIUFQJkjHHCDmR1PCiBAX T87P1UssKMhJ1QtJrShxzUvOT8nMSwdKlpak6VpYGxqbGBmaW1qYAABQSwcIcBqNwF0AAACrAAAA UEsDBAoAAAAAAMtEE08AAAAAAAAAAAAAAAAuABAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZl V2Vidmlldy9CYXNlLmxwcm9qL1VYDADkpMpd3kNaXfUBFABQSwMEFAAIAAgAy0QTTwAAAAAAAAAA AAAAAEUAEABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3L0Jhc2UubHByb2ovTGF1 bmNoU2NyZWVuLnN0b3J5Ym9hcmRVWAwAno3KXd5DWl31ARQAfVTBUtswEL3zFarudkhSUjqTwJA0 0LRk6JCUQm+yvIlFFMmV5ED4+q5kQ2wI+GBrVuu3q7fvqX/6uJZkA8YKrQa0HR9SAorrVKjlgP6e n0fHlFjHVMqkVjCgStPTk4N+qnmxBuWI2+YY5XodszyXEE+UA7NgHIaFkCmYbjzSXLO5LngWz5w2 20Qzk8a3kyHd1e36uk5raW9eWum2O5243cM4M0tw14VyYo21xNWshklJbnQOxm3POAdrR1o5o6Vv VAElhYWzwmnJtrpwA3o3nlEiWaF4NuMGQFUhTJsbJtxISwncYQN2tzNjCzgzwJ5DXEttpszxDNIq JJRwgskbAQ9VAxLMgB62f0Qyj/TNlJ4cEHz6KeSgUmRYgC1DIZzLYjlRROCOEwvh/32f0ngy3J3/ F/4pVI1K5O3wc9zu0FYNn7OcJUIKtyWKeRL9mQjDQ5GSGrIssLilZC3UvDGHrziaD6GepWCJZRtI kQviMiC3KCIgx2ShzZq5PcDHO+B+6y0vfctBNUj6FEWeYLJjOIpq2yGfhPfk24COvy+iyZ/orDOm u6SQqJN7nLFtRsPOpjE/HEdjhCX2FNYJGF+hmU3f4r1gkhVsy3yvHhynclNkZ0AtZxLm+lxISUO5 v3AU9ZKo47rv4AVMg/2XmAuDM6DkERv1FtpW3weRugxt9eWIkgzEMkPt93pf6oN8A8rQJwaseELr T5ldlQVeRyvsmXhiiYRK/mWJRuyjSsFAJXzC+GppdKHSkQ9SYryn2pQsS3fiKpEFhAWTecbCKgDM crQE+qSwTq8xFr6j2o69vhh+2IcfyGWQ/4VXf9mRrdxezqM3X0VX42g4vHsPqd/yMHvE1GrqY09G LrHPTHtPk9p6UrsFJsNzYay7Bptr9IcpuxJ399HPf9GYtcMFZS5ZAnjlhVRSy30l2EUT6tWB+q29 xujnWqhKbZypDbOXmjN/RQbZHXWD6rzS6rdEK5R+dvezldHn1WVxcvAfUEsHCPcU9IrrAgAAegYA AFBLAwQKAAAAAABGa2xPAAAAAAAAAAAAAAAANwAQAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNC ZXRhL05hdGl2ZVdlYnZpZXcvQmFzZS5scHJvai9VWAwA5KTKXeSkyl31ARQAUEsDBBQACAAIAMtE E08AAAAAAAAAAAAAAABQABAAX19NQUNPU1gvV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vi dmlldy9CYXNlLmxwcm9qLy5fTGF1bmNoU2NyZWVuLnN0b3J5Ym9hcmRVWAwAno3KXd5DWl31ARQA Y2AVY2dgYmDwTUxW8A9WiFCAApAYAycQGwFxJRCD+KsZiAKOISFBUCZIxxwg5kdTwogQF0/Oz9VL LCjISdULSa0occ1Lzk/JzEsHSpaWpOlaWBsamxgZmltamAAAUEsHCHAajcBdAAAAqwAAAFBLAwQU AAgACADLRBNPAAAAAAAAAAAAAAAAPQAQAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZp ZXcvQmFzZS5scHJvai9NYWluLnN0b3J5Ym9hcmRVWAwAoKTKXd5DWl31ARQAfVTBctowEL3nK1Td bSC0lM6YZGKaZJhpJmmgmaQ3WV5jFVnySDIJfH3XMgQ7JOEAmt3l7eq9fYrOXwpJ1mCs0GpCB2Gf ElBcp0ItJ/TP4ioY0/OzkyjVvCpAOeI2JUwo10XIylJCOFMOTMY4xJWQKZhhONVcs4WueB7OnTab RDOTho+zmB76DOs+TmtpH15bDwenp+FghHFmluDuK+VEgb3E7byFSUlpdAnGbS44B2unWjmj5YQq rYCSysJF5bRkG125CX26nPvYwjDhplpK4A672UNmzjK4MMD2Ia6lNjfM8RzSXUgo4QSTDwKed90k mAmNn/4Gw3Hg+oaenRD8RCmUoFKkT4BtQj5cymo5U0RgxolM1P/9mL9wFh8ue4f/FKrFG5LU/xoO Tmmvhc9ZyRIhhdsQxWrG6jsRhpciDQ9kWWFzS0kh1KJD+g/U4VOove6WWLaGFLkgLgfyiBsCZEwy bQrm3gEeH4Cj3jEvkeWgOiR9CYKaYHJgOAhaaV9P/Pfs54Q6BcHvRSCyih6KfKFO/qHGthv1mXVH P5SjIyHhlXW6mEpmcRW6Wu+TNzqtJNwZvUY6UcVmUWkz1g0UCZh6uG4jejzK6zhkBZumvl483ATl sAfSbjmTsNBXQkrqJx0n0+AxC9bp9AM8j2nw6g1mZlA+Sl4mtF9bbbP7fRapy9F+379RkoNY5uiR 0eh7eweOQBn6yYAVW3wSbphdNQ3eRnfYc7FliYSdc5oWndhnnbz3GviE8dXS6Eql0zpIiantOKBk aQCUPyWyAn9gssyZP3mAeYluQot5yV51bWXs/XX86Ry1IL+8c65r4zQT2d1D0egxWqyC28sgjp8+ Qop6Ncw7e9jr7sc7FaXEOXNdPwekdZ61HpBZfCWMdfdgS43WMs1U6eol2PYDtTVHS5l1y98MHfWO fBP1PMLew3vDopt3T8LZyX9QSwcIShJwQckCAAA9BgAAUEsDBBQACAAIAMtEE08AAAAAAAAAAAAA AABIABAAX19NQUNPU1gvV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy9CYXNlLmxw cm9qLy5fTWFpbi5zdG9yeWJvYXJkVVgMAKCkyl3eQ1pd9QEUAGNgFWNnYGJg8E1MVvAPVohQgAKQ GAMnEBsB8UYgBvEfMxAFHENCgqBMkI4jQCyPpoQJKs7PwCCenJ+rl1hQkJOqF5JaUeKal5yfkpmX DlF3GYgFGBikEGpyEotLSotTU1ISS1KVA4JBikpL0nQtrA2NTYwMzS0tTFSvH40GCXe7iXGBaABQ SwcIbvQyBoUAAADjAAAAUEsDBBQACAAIAMtEE08AAAAAAAAAAAAAAAA0ABAAV2ViS2l0QnVnaU9T MTMuM0JldGEvTmF0aXZlV2Vidmlldy9BcHBEZWxlZ2F0ZS5zd2lmdFVYDACepMpd3kNaXfUBFACd VNtu3DYQfddXzKMNuHLchyLYAk3tpDGMJA1Qx9iHoii40kgiQpEqSWmrFP2g/ka/rGeo3Y3kLDZw BexCIud2Zs6Zy8vs8pLouuteseFaRc7DVlcxnf6soh54zZtB8xYn6fClZ1iVtBnplssx0J2NXq2V Z7ptNw05S1ff5VfP8qvn+eTgutHruon07z/07bOr50f9cro2hpJdIM+B/cClBMgy3XbOR3q4e6Nj lv34cIdqjS5QnLPvlLZZYVQIcwwrGP/CoXO2ZH9BC4+9Df2VZYRnUJ622pZuK17r9PYim+6q3hak Pvue/T7/Wi0DX1Cpy9fa6tC8VXBstK3XOjbvO7kNZNLh7mtFvy6c87fz2zc8rujajr+9OKdvfqAb 5wzKpd2Dpr4f2HtdMnVO20iV81T0IbpWf0rhSFWR/bzYXfr8EMVz7L2l6HtOZ38fh7zWxqCVurbX hbDhZAvOl1XeM2rbNowsDS+K0YHUxvWRoqPWDUyVdy2plEHOtN29hyiUpA8NPAplyRVF7ye87COG T3HsOJCrKLLwRPkR3gDv+13fz0JfNKSQEXltgR7ZmrrGWUZEcA6x7t/dU8shqJrP5ftQcw8e0h+9 BicfQ1C2JB1pw7W20y3obINOl4AgJxtVfKy962E6AZl35yHARXC1HBtXik+nkBAKqp3UGFX4GIRV QW0MbHXLHt8psR2U0aXQuPaqa3QhohG2i6PAktQhp1sFXBQa15tS0BzPKLXWsMxPMeGVLn+Sxt4c QD2FC0fQeihR4Tg0WAKliN71vmBADGrY9R4Q1cUc7rwLIDy2B1vX181iNqnZ8AJPWrUfCOIn+xFZ FtbCNwwYxPJC2L0z2ojiMGIUDdigTdp7Bv9+Mci76suYoe9kaYU5BfhPLvppU8w7kZhtDMtUQ2RV CpkfKfDDPv/qGDdPjk3c09xeA/zT5/ZyKg3y6RSWsOhsSfWk3Edk39F/ruHvqeGp+UnHsILylR33 EYtG2RpUbVUpCsBU40TmZeivMfSGIXB++qrCiouCTypKukNeheUlNSeNlHSGxWBdpJETRzzIcI5p aMNf7IYt2rVfYbnw45hB53nQrg9GFtYjmBfk0vZC80cQtwJ3m89DT/utUsVpvS548z9G/tXFfRBF TvciWNEq6cRd7zqvpxtGABPc6U2yOiDJ8PsPUEsHCHNokmNzAwAAlQgAAFBLAwQUAAgACADLRBNP AAAAAAAAAAAAAAAAPwAQAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZp ZXcvLl9BcHBEZWxlZ2F0ZS5zd2lmdFVYDACepMpd3kNaXfUBFABjYBVjZ2BiYPBNTFbwD1aIUIAC kBgDJxAbAfFGIAbxHzMQBRxDQoKgTJCOI0Asj6aECSrOz8Agnpyfq5dYUJCTqheSWlHimpecn5KZ lw5RdxmIBRgYpBBqchKLS0qLU1NSEktSlQOCQYpKS9J0LawNjU2MDM0tLUxU2UNjQcJSF+6rgWgA UEsHCKSW7N6FAAAA4wAAAFBLAwQUAAgACAAsUhVPAAAAAAAAAAAAAAAALQAQAFdlYktpdEJ1Z2lP UzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvSW5mby5wbGlzdFVYDADUpMpdFP5cXfUBFADNlF9v2jAU xZ/Hp8iiPWwP4PKyTVNKFRJTWUpDRJJqe0ImvoDVYHuOA+Wln31O+bMOSCdVmrS3KD7n53Ouruzd PK5KZw264lJcu/3eleuAKCTjYnHt5tmo+9W9GXS89+E4yH4k2FElr4yT5MOIBI7bRchXqgSEwix0 koikmWMZCOHYddylMeobQpvNpkcbVa+Qq0ZYoURLBdpsIwvrWkOPGebaa3b0P+LYv4wXZtB55z3A dhCMhrVgJYSwhlKqFQgzgYVVe6g5tqrKaBt+8OFjiO9xNE7ucJxNIz++zf1b/MlD+/MTHn6EojZ0 VsI5CH/HQZ75wwhPY/+unUGYTcPnHPQ5I5mMwzzIpsM8Di2HhDYVGRE8aaeJuQxtc9uN6u39bian 4M+9qzZ/TFcXuhxyvFokocUDXUC2VWcEP0miNlu6lNrsg6bPilN3vz1uS8H+qT5KJ/Cz5hoqkiyl gHF6tBhdAzrochLRWhTL1Ei9nUmq2aWB7DWFBhCnN+XkjnLx2z/i58vRKM59+4TMLikvIKCKznjJ DYfq6Kda0+bjSKJ6tf7yEoUOkj00rZWy8wVGhAE9pwWMNbcLR5sNeQWck0uGxKI05ebFjX9xRFSw qqAKIpi/xTbhi6V5e8Enrij79y0PjlxVnEEoN+I/mJCHdk+gh54fyEHnF1BLBwgJfYZ2+gEAALcF AABQSwMEFAAIAAgALFIVTwAAAAAAAAAAAAAAADgAEABfX01BQ09TWC9XZWJLaXRCdWdpT1MxMy4z QmV0YS9OYXRpdmVXZWJ2aWV3Ly5fSW5mby5wbGlzdFVYDADUpMpdFP5cXfUBFABjYBVjZ2BiYPBN TFbwD1aIUIACkBgDJxAbAXEdEIP4GxiIAo4hIUFQJkjHAiAWQFPCiBCXSs7P1UssKMhJ1ctJLC4p LU5NSUksSVUOCAYpPL3kVCyIZpunA3INAwBQSwcIbV84xV0AAACwAAAAUEsBAhUDCgAAAAAAK2ts TwAAAAAAAAAAAAAAABUADAAAAAAAAAAAQO1BAAAAAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL1VYCADk pMpdsqTKXVBLAQIVAxQACAAIADZrbE/iuihtJgIAAAQgAAAeAAwAAAAAAAAAAECkgUMAAABXZWJL aXRCdWdpT1MxMy4zQmV0YS8uRFNfU3RvcmVVWAgAraTKXcekyl1QSwECFQMKAAAAAABGa2xPAAAA AAAAAAAAAAAACQAMAAAAAAAAAABA/UHFAgAAX19NQUNPU1gvVVgIAOSkyl3kpMpdUEsBAhUDCgAA AAAARmtsTwAAAAAAAAAAAAAAAB4ADAAAAAAAAAAAQP1B/AIAAF9fTUFDT1NYL1dlYktpdEJ1Z2lP UzEzLjNCZXRhL1VYCADkpMpd5KTKXVBLAQIVAxQACAAIADZrbE8LiMA4NQAAAHgAAAApAAwAAAAA AAAAAECkgUgDAABfX01BQ09TWC9XZWJLaXRCdWdpT1MxMy4zQmV0YS8uXy5EU19TdG9yZVVYCACt pMpdx6TKXVBLAQIVAwoAAAAAAMtEE08AAAAAAAAAAAAAAAAoAAwAAAAAAAAAAEDtQeQDAABXZWJL aXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3VGVzdHMvVVgIAOSkyl3eQ1pdUEsBAhUDFAAI AAgAy0QTT/4MDvuWAQAAsQMAAEAADAAAAAAAAAAAQKSBOgQAAFdlYktpdEJ1Z2lPUzEzLjNCZXRh L05hdGl2ZVdlYnZpZXdUZXN0cy9OYXRpdmVXZWJ2aWV3VGVzdHMuc3dpZnRVWAgAnqTKXd5DWl1Q SwECFQMKAAAAAABGa2xPAAAAAAAAAAAAAAAAMQAMAAAAAAAAAABA/UFOBgAAX19NQUNPU1gvV2Vi S2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlld1Rlc3RzL1VYCADkpMpd5KTKXVBLAQIVAxQA CAAIAMtEE09wGo3AXQAAAKsAAABLAAwAAAAAAAAAAECkga0GAABfX01BQ09TWC9XZWJLaXRCdWdp T1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3VGVzdHMvLl9OYXRpdmVXZWJ2aWV3VGVzdHMuc3dpZnRV WAgAnqTKXd5DWl1QSwECFQMUAAgACADLRBNPhcLZAE4BAAC9AgAAMgAMAAAAAAAAAABApIGTBwAA V2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlld1Rlc3RzL0luZm8ucGxpc3RVWAgAnaTK Xd5DWl1QSwECFQMKAAAAAADLRBNPAAAAAAAAAAAAAAAAKgAMAAAAAAAAAABA7UFRCQAAV2ViS2l0 QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlld1VJVGVzdHMvVVgIAOSkyl3eQ1pdUEsBAhUDFAAI AAgAy0QTTzQZZa45AgAArgQAAEQADAAAAAAAAAAAQKSBqQkAAFdlYktpdEJ1Z2lPUzEzLjNCZXRh L05hdGl2ZVdlYnZpZXdVSVRlc3RzL05hdGl2ZVdlYnZpZXdVSVRlc3RzLnN3aWZ0VVgIAKCkyl3e Q1pdUEsBAhUDCgAAAAAARmtsTwAAAAAAAAAAAAAAADMADAAAAAAAAAAAQP1BZAwAAF9fTUFDT1NY L1dlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXdVSVRlc3RzL1VYCADkpMpd5KTKXVBL AQIVAxQACAAIAMtEE09wGo3AXQAAAKsAAABPAAwAAAAAAAAAAECkgcUMAABfX01BQ09TWC9XZWJL aXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3VUlUZXN0cy8uX05hdGl2ZVdlYnZpZXdVSVRl c3RzLnN3aWZ0VVgIAKCkyl3eQ1pdUEsBAhUDFAAIAAgAy0QTT4XC2QBOAQAAvQIAADQADAAAAAAA AAAAQKSBrw0AAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXdVSVRlc3RzL0luZm8u cGxpc3RVWAgAnqTKXd5DWl1QSwECFQMKAAAAAAAsaGxPAAAAAAAAAAAAAAAALQAMAAAAAAAAAABA 7UFvDwAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2ovVVgIAOSk yl0Un8pdUEsBAhUDFAAIAAgALGhsTzizL54SDQAAklcAADwADAAAAAAAAAAAQKSByg8AAFdlYktp dEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvalVY CAAUn8pdFJ/KXVBLAQIVAwoAAAAAAMtEE08AAAAAAAAAAAAAAAA4AAwAAAAAAAAAAEDtQVYdAABX ZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai94Y3VzZXJkYXRhL1VY CADkpMpd3kNaXVBLAQIVAwoAAAAAABN0E08AAAAAAAAAAAAAAABTAAwAAAAAAAAAAEDtQbwdAABX ZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai94Y3VzZXJkYXRhL2dl ZHlzaW50cmF3YXJlLnhjdXNlcmRhdGFkL1VYCADkpMpd5ZZaXVBLAQIVAwoAAAAAADx0E08AAAAA AAAAAAAAAABeAAwAAAAAAAAAAEDtQT0eAABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2 aWV3Lnhjb2RlcHJvai94Y3VzZXJkYXRhL2dlZHlzaW50cmF3YXJlLnhjdXNlcmRhdGFkL3hjZGVi dWdnZXIvVVgIAOSkyl00l1pdUEsBAhUDFAAIAAgAPHQTT+qYWDd6AAAAjAAAAHcADAAAAAAAAAAA QKSByR4AAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9qL3hjdXNl cmRhdGEvZ2VkeXNpbnRyYXdhcmUueGN1c2VyZGF0YWQveGNkZWJ1Z2dlci9CcmVha3BvaW50c192 Mi54Y2JrcHRsaXN0VVgIAJ+Nyl00l1pdUEsBAhUDCgAAAAAAy0QTTwAAAAAAAAAAAAAAAF0ADAAA AAAAAAAAQO1B+B8AAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9q L3hjdXNlcmRhdGEvZ2VkeXNpbnRyYXdhcmUueGN1c2VyZGF0YWQveGNzY2hlbWVzL1VYCADkpMpd 3kNaXVBLAQIVAxQACAAIAMtEE09qUwFH8gAAAMMBAAB1AAwAAAAAAAAAAECkgYMgAABXZWJLaXRC dWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai94Y3VzZXJkYXRhL2dlZHlzaW50 cmF3YXJlLnhjdXNlcmRhdGFkL3hjc2NoZW1lcy94Y3NjaGVtZW1hbmFnZW1lbnQucGxpc3RVWAgA no3KXd5DWl1QSwECFQMKAAAAAADLRBNPAAAAAAAAAAAAAAAAQQAMAAAAAAAAAABA7UEoIgAAV2Vi S2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtz cGFjZS9VWAgA5KTKXd5DWl1QSwECFQMUAAgACADLRBNPWZ9zrHgAAACeAAAAWQAMAAAAAAAAAABA pIGXIgAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2ovcHJvamVj dC54Y3dvcmtzcGFjZS9jb250ZW50cy54Y3dvcmtzcGFjZWRhdGFVWAgAn43KXd5DWl1QSwECFQMK AAAAAADLRBNPAAAAAAAAAAAAAAAATAAMAAAAAAAAAABA7UGmIwAAV2ViS2l0QnVnaU9TMTMuM0Jl dGEvTmF0aXZlV2Vidmlldy54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS94Y3VzZXJkYXRh L1VYCADkpMpd3kNaXVBLAQIVAwoAAAAAAA5rbE8AAAAAAAAAAAAAAABnAAwAAAAAAAAAAEDtQSAk AABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai9wcm9qZWN0Lnhj d29ya3NwYWNlL3hjdXNlcmRhdGEvZ2VkeXNpbnRyYXdhcmUueGN1c2VyZGF0YWQvVVgIAOSkyl18 pMpdUEsBAhUDFAAIAAgAmVUVT3eKWEEeAQAA+wEAAIMADAAAAAAAAAAAQKSBtSQAAFdlYktpdEJ1 Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9qL3Byb2plY3QueGN3b3Jrc3BhY2Uv eGN1c2VyZGF0YS9nZWR5c2ludHJhd2FyZS54Y3VzZXJkYXRhZC9Xb3Jrc3BhY2VTZXR0aW5ncy54 Y3NldHRpbmdzVVgIAJ+Nyl2CBF1dUEsBAhUDFAAIAAgADmtsT0IoLAnTRwAAQHkAAIUADAAAAAAA AAAAQKSBlCYAAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9qL3By b2plY3QueGN3b3Jrc3BhY2UveGN1c2VyZGF0YS9nZWR5c2ludHJhd2FyZS54Y3VzZXJkYXRhZC9V c2VySW50ZXJmYWNlU3RhdGUueGN1c2Vyc3RhdGVVWAgAfKTKXXykyl1QSwECFQMKAAAAAACZVRVP AAAAAAAAAAAAAAAATgAMAAAAAAAAAABA7UEqbwAAV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZl V2Vidmlldy54Y29kZXByb2ovcHJvamVjdC54Y3dvcmtzcGFjZS94Y3NoYXJlZGRhdGEvVVgIAOSk yl2CBF1dUEsBAhUDFAAIAAgAy0QTT3cVcri8AAAA7gAAAGYADAAAAAAAAAAAQKSBpm8AAFdlYktp dEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9qL3Byb2plY3QueGN3b3Jrc3Bh Y2UveGNzaGFyZWRkYXRhL0lERVdvcmtzcGFjZUNoZWNrcy5wbGlzdFVYCACfjcpd3kNaXVBLAQIV AxQACAAIAJlVFU+r0DdV0gAAABkBAABqAAwAAAAAAAAAAECkgQZxAABXZWJLaXRCdWdpT1MxMy4z QmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai9wcm9qZWN0Lnhjd29ya3NwYWNlL3hjc2hhcmVk ZGF0YS9Xb3Jrc3BhY2VTZXR0aW5ncy54Y3NldHRpbmdzVVgIAJ+Nyl2CBF1dUEsBAhUDCgAAAAAA RmtsTwAAAAAAAAAAAAAAADYADAAAAAAAAAAAQP1BgHIAAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEz LjNCZXRhL05hdGl2ZVdlYnZpZXcueGNvZGVwcm9qL1VYCADkpMpd5KTKXVBLAQIVAxQACAAIAMtE E0+x4HeugwAAANwAAABLAAwAAAAAAAAAAECkgeRyAABfX01BQ09TWC9XZWJLaXRCdWdpT1MxMy4z QmV0YS9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvai8uX3Byb2plY3QueGN3b3Jrc3BhY2VVWAgA5KTK Xd5DWl1QSwECFQMUAAgACAAsaGxP2RAQClwAAACwAAAANwAMAAAAAAAAAABApIHwcwAAX19NQUNP U1gvV2ViS2l0QnVnaU9TMTMuM0JldGEvLl9OYXRpdmVXZWJ2aWV3Lnhjb2RlcHJvalVYCADkpMpd FJ/KXVBLAQIVAwoAAAAAAD1rbE8AAAAAAAAAAAAAAAAjAAwAAAAAAAAAAEDtQcF0AABXZWJLaXRC dWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3L1VYCADkpMpd1qTKXVBLAQIVAxQACAAIAOBqbE+N DOyXrQIAABkIAAA3AAwAAAAAAAAAAECkgRJ1AABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVX ZWJ2aWV3L1ZpZXdDb250cm9sbGVyLnN3aWZ0VVgIAKGkyl0kpMpdUEsBAhUDCgAAAAAARmtsTwAA AAAAAAAAAAAAACwADAAAAAAAAAAAQP1BNHgAAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRh L05hdGl2ZVdlYnZpZXcvVVgIAOSkyl3kpMpdUEsBAhUDFAAIAAgA4GpsTwxX0Qf2AAAATQEAAEIA DAAAAAAAAAAAQKSBjngAAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZp ZXcvLl9WaWV3Q29udHJvbGxlci5zd2lmdFVYCAChpMpdJKTKXVBLAQIVAxQACAAIAEJrbE/D7bdl AAIAAAQYAAAsAAwAAAAAAAAAAECkgQR6AABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2 aWV3Ly5EU19TdG9yZVVYCADWpMpd26TKXVBLAQIVAxQACAAIAEJrbE8LiMA4NQAAAHgAAAA3AAwA AAAAAAAAAECkgW58AABfX01BQ09TWC9XZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3 Ly5fLkRTX1N0b3JlVVgIANakyl3bpMpdUEsBAhUDCgAAAAAAy0QTTwAAAAAAAAAAAAAAADMADAAA AAAAAAAAQO1BGH0AAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvQXNzZXRzLnhj YXNzZXRzL1VYCADkpMpd3kNaXVBLAQIVAwoAAAAAAMtEE08AAAAAAAAAAAAAAABGAAwAAAAAAAAA AEDtQXl9AABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3L0Fzc2V0cy54Y2Fzc2V0 cy9BcHBJY29uLmFwcGljb25zZXQvVVgIAOSkyl3eQ1pdUEsBAhUDFAAIAAgAy0QTT9wgHsvdAAAA NgYAAFMADAAAAAAAAAAAQKSB7X0AAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcv QXNzZXRzLnhjYXNzZXRzL0FwcEljb24uYXBwaWNvbnNldC9Db250ZW50cy5qc29uVVgIAFykyl3e Q1pdUEsBAhUDFAAIAAgAy0QTTwWsw/w0AAAAPgAAAEAADAAAAAAAAAAAQKSBW38AAFdlYktpdEJ1 Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvQXNzZXRzLnhjYXNzZXRzL0NvbnRlbnRzLmpzb25V WAgAXKTKXd5DWl1QSwECFQMKAAAAAABGa2xPAAAAAAAAAAAAAAAAPAAMAAAAAAAAAABA/UENgAAA X19NQUNPU1gvV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy9Bc3NldHMueGNhc3Nl dHMvVVgIAOSkyl3kpMpdUEsBAhUDFAAIAAgAy0QTT3AajcBdAAAAqwAAAEsADAAAAAAAAAAAQKSB d4AAAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvQXNzZXRzLnhj YXNzZXRzLy5fQ29udGVudHMuanNvblVYCABcpMpd3kNaXVBLAQIVAwoAAAAAAMtEE08AAAAAAAAA AAAAAAAuAAwAAAAAAAAAAEDtQV2BAABXZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3 L0Jhc2UubHByb2ovVVgIAOSkyl3eQ1pdUEsBAhUDFAAIAAgAy0QTT/cU9IrrAgAAegYAAEUADAAA AAAAAAAAQKSBuYEAAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvQmFzZS5scHJv ai9MYXVuY2hTY3JlZW4uc3Rvcnlib2FyZFVYCACejcpd3kNaXVBLAQIVAwoAAAAAAEZrbE8AAAAA AAAAAAAAAAA3AAwAAAAAAAAAAED9QSeFAABfX01BQ09TWC9XZWJLaXRCdWdpT1MxMy4zQmV0YS9O YXRpdmVXZWJ2aWV3L0Jhc2UubHByb2ovVVgIAOSkyl3kpMpdUEsBAhUDFAAIAAgAy0QTT3AajcBd AAAAqwAAAFAADAAAAAAAAAAAQKSBjIUAAF9fTUFDT1NYL1dlYktpdEJ1Z2lPUzEzLjNCZXRhL05h dGl2ZVdlYnZpZXcvQmFzZS5scHJvai8uX0xhdW5jaFNjcmVlbi5zdG9yeWJvYXJkVVgIAJ6Nyl3e Q1pdUEsBAhUDFAAIAAgAy0QTT0oScEHJAgAAPQYAAD0ADAAAAAAAAAAAQKSBd4YAAFdlYktpdEJ1 Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvQmFzZS5scHJvai9NYWluLnN0b3J5Ym9hcmRVWAgA oKTKXd5DWl1QSwECFQMUAAgACADLRBNPbvQyBoUAAADjAAAASAAMAAAAAAAAAABApIG7iQAAX19N QUNPU1gvV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy9CYXNlLmxwcm9qLy5fTWFp bi5zdG9yeWJvYXJkVVgIAKCkyl3eQ1pdUEsBAhUDFAAIAAgAy0QTT3NokmNzAwAAlQgAADQADAAA AAAAAAAAQKSBxooAAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvQXBwRGVsZWdh dGUuc3dpZnRVWAgAnqTKXd5DWl1QSwECFQMUAAgACADLRBNPpJbs3oUAAADjAAAAPwAMAAAAAAAA AABApIGrjgAAX19NQUNPU1gvV2ViS2l0QnVnaU9TMTMuM0JldGEvTmF0aXZlV2Vidmlldy8uX0Fw cERlbGVnYXRlLnN3aWZ0VVgIAJ6kyl3eQ1pdUEsBAhUDFAAIAAgALFIVTwl9hnb6AQAAtwUAAC0A DAAAAAAAAAAAQKSBrY8AAFdlYktpdEJ1Z2lPUzEzLjNCZXRhL05hdGl2ZVdlYnZpZXcvSW5mby5w bGlzdFVYCADUpMpdFP5cXVBLAQIVAxQACAAIACxSFU9tXzjFXQAAALAAAAA4AAwAAAAAAAAAAECk gRKSAABfX01BQ09TWC9XZWJLaXRCdWdpT1MxMy4zQmV0YS9OYXRpdmVXZWJ2aWV3Ly5fSW5mby5w bGlzdFVYCADUpMpdFP5cXVBLBQYAAAAAOQA5AIIbAADlkgAAAAA=