Ingress Base Template
Imperative command
# kubectl create ingress NAME --rule="host/path=service:port"
kubectl create ingress web --rule="example.com/=web-svc:80"k create ingress web --rule="example.com/=web-svc:80" --rule="hello.example.com/store=nvc-svc:80"Why Ingress
We will start with a simple scenario.
You are deploying an application on Kubernetes
for a company that has an online store selling products.
Your application would be
available at say, my-onlinestore.com.
You build the application into a Docker image
and deploy it
on the Kubernetes cluster as a pod in a deployment.
Your application needs a database,
so you deploy a MySQL database as a pod,
and create a service
of type ClusterIP called mysql-service
to make it accessible to our application.
Your application is now working.
To make the application accessible to the outside world,
you create another service, this time of type NodePort,
and make your application available
on a high port on the nodes in the cluster.
In this example, a port 38080 is allocated for the service.
The users can now access your application
using the URL, http:// IP of any of your nodes,
followed by port 38080.
That setup works
and users are able to access the application.
Whenever traffic increases,
we increase the number of replicas of the pod
to handle the additional traffic,
and the service takes care
of splitting traffic between the pods.
However, if you have deployed
a production grade application before,
you know that there are many more things involved
in addition to simply splitting the traffic
between the pods.
For example, we do not want the users
to have to type in the IP address every time.
So, you configure your DNS server
to point to the IP of the nodes.
Your users can now access your application
using the URL, my-online-store.com, and port 38080.
Now, you don’t want your users
to have to remember port number either.
However, service NodePorts
can only allocate high-numbered ports,
which are greater than 30,000.
So, you then bring in an additional layer
between the DNS server and your cluster, like a proxy server
that proxies request on port 80 to port 38080 on your nodes.
You then point your DNS to this server
and users can now access your application
by simply visiting my-online-store.com.
Now, this is if your application
is hosted on-prem in your data center.
Let’s take a step back
and see what you could do
if you were on a public cloud environment
like Google Cloud Platform.
In that case, instead of creating a service
of type NodePort for your wear application,
you could set it to type LoadBalancer.
When you do that, Kubernetes would still do everything
that it has to do for a NodePort,
which is to provision a high port for the service.
But in addition to that,
Kubernetes also sends a request to Google Cloud Platform
to provision a network LoadBalancer for the service.
On receiving the request,
GCP would then automatically deploy a LoadBalancer
configured to route traffic
to the service ports on all nodes
and return its information to Kubernetes.
The LoadBalancer has an external IP
that can be provided to users to access the application.
In this case, we set the DNS to point to this IP
and users access the application
using the URL, my-online-store.com.
Perfect.
Your company’s business grows
and you now have new services for your customers.
For example, a video streaming service.
Now, you want your users to be able
to access your new video streaming service
by going to my-online-store.com/watch.
You’d like to make your old application
accessible at my-online-store.com/wear.
Your developers develop the new video streaming application
as a completely different application,
as it has nothing to do with the existing one.
However, to share the cluster’s resources,
you deploy the new application
as a separate deployment within the same cluster.
You create a service
called video-service of type LoadBalancer.
Kubernetes provisions port 38282 for this service,
and also provisions a network LoadBalancer on the cloud.
The new LoadBalancer has a new IP.
Remember, you must pay for each of these LoadBalancers
and having many such LoadBalancers
can inversely affect your cloud bill.
So, how do you direct traffic
between each of these LoadBalancers
based on the URL that the user types in?
You need yet another proxy or LoadBalancer
that can redirect traffic
based on URLs to the different services.
Every time you introduce a new service,
you have to reconfigure the LoadBalancer.
And finally, you also need
to enable SSL for your applications
so your users can access your application using HTTPS.
Where do you configure that?
It can be done at different levels,
either at the application level itself
or at the LoadBalancer level,
or at the proxy server level, but which one?
And you don’t want your developers
to implement it in their applications
as they would do it in different ways,
and it’s an additional burden for them
to develop additional code to handle that.
You want it to be configured in one place
with minimal maintenance.
Now, that’s a lot of different configuration,
and all of these becomes difficult
to manage when your application scales.
It requires involving different individuals
in different teams.
You need to configure your firewall rules
for each new service,
and it’s expensive as well as for each service,
a new cloud native LoadBalancer needs to be provisioned.
Wouldn’t it be nice if you could manage all of that
within the Kubernetes cluster
and have all that configuration
as just another Kubernetes definition file that lives along
with the rest of your application deployment files?
That’s where ingress comes in.
How Ingress is Implemented
Ingress helps your users access your application
using a single externally accessible URL
that you can configure to route traffic
to different services
within your cluster based on the URL path,
at the same time, implement SSL security as well.
Think of ingress as a Layer 7 LoadBalancer OSI-Layer
built into the Kubernetes cluster
that can be configured using native Kubernetes primitives
just like any other object
that we’ve been working with in Kubernetes.
Now, remember, even with ingress, you still need
to expose it to make it accessible outside the cluster.
So, you still have to either publish it as a NodePort
or with a cloud native LoadBalancer.
But that is just a one-time configuration.
Going forward,
you’re going to perform all your load balancing of SSL
and URL-based routing configurations
on the ingress controller.
So, how does it work?
What is it? Where is it?
How can you see it, and how can you configure it,
and how does it load-balance?
How does it implement SSL?
Without ingress, how would you do all of this?
Well, I would use a reverse proxy
or a load balancing solution
like Nginx or HAProxy, or Traefik.
I would deploy them on my Kubernetes cluster
and configure them to route traffic to other services.
The configuration involves defining URL routes,
configuring SSL certificates, et cetera.
Ingress is implemented by Kubernetes
in kind of the same way.
You first deploy a supported solution,
which happens to be any of these listed here,
and then specify a set of rules to configure ingress.
The solution you deploy is called as an ingress controller.
And the set of rules you configure are called as ingress resources.
Ingress resources are created using definition files like the ones we have been using to create pods, deployments, and services earlier in this course.
Now, remember, a Kubernetes cluster does not come with an ingress controller by default.
If you set up a cluster following the demos in this course, you won’t have an ingress controller built into it.
So, if you simply create ingress resources and expect them to work, they won’t.
Ingress Controller
Let’s look at each of these in a bit more detail.
As I mentioned, you do not have an ingress controller on Kubernetes by default, so you must deploy one.
What do you deploy?
There are a number of solutions available for ingress,
a few of them being GCE, which is Google’s Layer 7 HTTP load balancer, Nginx, Contour, HAProxy, Traefik, and Istio.
Out of these, GCE and Nginx are currently being supported
and maintained by the Kubernetes project.
And in this lecture, we will use Nginx as an example.
These ingress controllers are not just another LoadBalancer or Nginx server.
The LoadBalancer components are just a part of it.
Ingress controllers have additional intelligence built into them to monitor the Kubernetes cluster for new definitions or ingress resources, and configure the Nginx server accordingly.
An Nginx controller is deployed as just another deployment in Kubernetes.
So, we start with a deployment definition file
named nginx-ingress-controller with one replica
and a simple pod definition template.
We will label it nginx-ingress,
and the image used is nginx-ingress-controller
with the right version.
This is a special build of Nginx built specifically
to be used as an ingress controller in Kubernetes,
so it has its own set of requirements.
Within the image, the Nginx program
is stored at location /nginx-ingress-controller,
so you must pass that as the command
to start the Nginx controller service.
If you have worked with Nginx before,
you know that it has a set
of configuration options such as the path to store the logs,
the keep alive threshold,
SSL settings, session timeout, et cetera.
In order to decouple this configuration data
from the Nginx controller image,
you must create a config map object and pass that in.
Now, remember, the config map object need not have any entries at this point.
A blank object will do,
but creating one makes it easy for you to modify a configuration setting in the future.
You will just have to add it into this config map and not have to worry about modifying the Nginx configuration files.
You must also pass in two environment variables
that carry the pod’s name and namespace it is deployed to.
The Nginx service requires these
to read the configuration data from within the pod.
And finally, specify the ports used
by the ingress controller, which happens to be 80 and 443.
We then need a service to expose the ingress controller
to the external world, so we create a service
of type NodePort with the nginx-ingress label selector
to link the service to the deployment.
As mentioned before,
the ingress controllers have additional intelligence
built into them to monitor the Kubernetes cluster
for ingress resources,
and configure the underlying Nginx server
when something has changed.
But for the ingress controller to do this,
it requires a service account
with the right set of permissions.
For that, we create a service account
with the correct rules and rule bindings.
So, to summarize, with a deployment
of the nginx-ingress image, a service to expose it,
a config map to feed Nginx configuration data,
and a service account with the right permissions
to access all of these objects, we should be ready
with an ingress controller in its simplest form.
Ingress Resources
Now, onto the next part of creating ingress resources.
An ingress resource is a set of rules
and configurations applied on the ingress controller.
You can configure rules to say,
simply forward all incoming traffic to a single application,
or route traffic to different applications based on the URL.
So, if the user goes to my-online-store.com/wear,
then route to one app, or if the user visits the watch URL,
then route the user to the video app.
Or you could route user based on the domain name itself.
For example, if the user visits wear.my-online-store.com,
then route the user to the wear app,
or else route the user to the video app.
Let us look at how to configure these in a bit more detail.
The ingress resource is created
with a Kubernetes definition file.
In this case, Ingress-wear.yaml.
As with any other object,
we have apiVersion, kind, metadata, and spec.
The apiVersion is extensions/v1beta1.
Kind is Ingress.
And we will name it ingress-wear.
And under spec, we have backend.
s
Now, remember that the apiVersion
for ingress is extension/v1beta1 as of this recording,
but this is expected to change
with newer releases of Kubernetes.
So, when you are deploying ingress,
always remember to refer to the Kubernetes documentation
to know exactly the right apiVersion
for that release of Kubernetes.
So, the traffic is of course routed
to the application services and not pods directly.
The backend section
defines where the traffic will be routed to.
So, if it’s a single backend,
then you don’t really have any rules.
You can simply specify the service name
and port of the backend wear service.
Create the ingress resource
by running the kubectl create command.
View the created ingress
by running the kubectl get ingress command.
The new ingress is now created and routes all incoming traffic directly to the wear service.
Ingress Resource - Rules
You use rules when you want to route traffic based on different conditions.
For example, you create one rule for traffic originating from each domain or host name.
That means when users reach your cluster
using the domain name, my-online-store.com,
you can handle that traffic using rule 1.
When users reach your cluster
using domain name, wear.my-online-store.com,
you can handle that traffic using a separate rule, rule 2.
Use rule 3 to handle traffic from watch.my-online-store.com
and say, use the fourth rule to handle everything else.
And just in case you didn’t know,
you could get different domain names to reach your cluster
by adding multiple DNS entries
all pointing to the same ingress controller service
on your Kubernetes cluster.
Now, within each rule, you can handle different paths.
For example, within rule 1, you can handle the wear path
to route that traffic to the clothes application
and a watch path to route traffic
to the video streaming application,
and a third path that routes anything
other than the first two to a 404 not found page.
Similarly, the second rule
handles all traffic from wear.my-online-store.com.
You can have path definition within this rule
to route traffic based on different paths.
For example, say you have different applications
and services within the apparel section for shopping,
or returns, or support.
When a user goes to wear.my-online-store.com,
by default, they reach the shopping page.
But if they go to exchange
or support URL, they reach a different backend service.
The thing goes for rule 3,
where you route traffic to watch.my-online-store.com
to the video streaming application,
but you can have additional paths in it
such as movies or TV.
And finally, anything other than the ones listed here
will go to the fourth rule
that would simply show a 404 not found error page.
So, remember, you have rules at the top for each host
or domain name, and within each rule,
you have different paths to route traffic based on the URL.
Now, let’s look
at how we configure ingress resources in Kubernetes. We will start where we left off.
We start with a similar definition file.
This time under spec, we start with a set of rules.
Now, our requirement here
2nd type
is to handle all traffic coming into my-online-store.com
and route them based on the URL path.
So, we just need a single URL for this,
since we are only handling traffic to a single domain name,
which is my-online-store.com in this case.
Under rules, we have one item,
which is an HTTP rule in which we specify different paths.
So, paths is an array of multiple items,
one path for each URL.
Then, we move the backend we used
in the first example under the first path.
The backend specification remains the same,
it has a service name and service port.
Similarly, we create a similar backend entry
to the second URL path for the watch service
to route all traffic
coming in through the watch URL to the watch service.
Create the ingress resource
using the kubectl create command.
Once created, view additional details about the ingress resource
by running the kubectl describe ingress command.
You now see two backend URLs under the rules
and the backend service
they are pointing to, just as we created it.
Now, if you look closely in the output of this command,
you see that there is something about a default backend.
Hmm, what might that be?
If a user tries to access a URL
that does not match any of these rules,
then the user is directed
to the service specified as the default backend.
In this case,
it happens to be a service named default-http-backend.
So, you must remember to deploy a such a service.
Back in your application,
say a user visits the URL,
my-online-store.com/listen or eat,
and you don’t have an audio streaming
or a food delivery service,
you might want to show them a nice message.
You can do this by configuring a default backend service
to display this 404 not found error page.
3rd type
The third type of configuration
is using domain names or host names.
We start by creating a similar definition file for ingress.
Now that we have two domain names,
we create two rules, one for each domain.
To split traffic by domain name, we use the host field.
The host field in each rule matches the specified value
with the domain name used in the request URL,
and routes traffic to the appropriate backend.
In this case, note that we only have a single backend path
for each rule, which is fine.
All traffic from these domain names will be routed
to the appropriate backend
irrespective of the URL path used.
You can still have multiple path specifications
in each of these to handle different URL paths.
Now, let’s compare the two.
Splitting traffic by URL had just one rule,
and we split the traffic with two paths.
To display traffic by host name,
we used two rules and one path specification in each rule.
Excalidraw Data
Text Elements
Nginx
use same ingress controller but two different classes
use 2 different ingress controllers
Traefik
Why?
we don’t want to type the ip address+port to reach a website
routing
path based
host based
centralizaed ssl management
Get two IP addresses with ssl
- host
Spec
rules (list)
paths
- host
http
http
paths
Embedded Files
1ffa6a11dda9f6539be89a429d840c3f7fe338c1: Pasted Image 20250621105435_523.png
b7a2f1e710642b8a0b2406e35d119a81fdd0ae05: ingress-20250507-3.png
bf6d3eae90f448b9b797a0d77867950c19a318b9: Pasted Image 20250623205021_624.png
163362a254229f2246a091a717583beeed80ca25: kubernetes-ingress-base-template.png
6afc5e72e453c893536ea94b54cc1c8e715f0f53: Pasted Image 20250719180559_971.png
Drawing
N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebQBGAGYEmjoghH0EDihmbgBtcDBQMBKIEm4IeP1nADkATWUAZQ4ARxbcAHlNAGFJboB2ACUACQBxAFZUkshYRAqAM0CETyp+
UsxuABZx+O0ADgAGHnj4/sS9gDYeAE5r+LXIGG5neMvtC4u9+J5E/oPrvbXA79PYPCAUEjqbgHbQHOH/PbHcbjRKnTabQEXRKJMGSBCEZTSaGw+EApEotEY65YnGFSDWZTBaFg5hQUhsADWCG6bHwbFIFQAxDx5tcEOipqVNLhsBzlOyhBxiDy+QKJGzrMw4LhAtlJZB5oR8PhGrAmRJJDKNIF9RBWeyuQB1SGSbhxcYstmchCmmDm9CCDy2hWEj
jhXJoe50iBsbXYNRPSNwsHy4RwACSxAjqAK00gAEFnIMeGwALKYeJsfMALWrgwAqkMAKIAKQAGv0ADIQOkAXTBi1wmUz3A4QmNYMISqwFWrq2jCqVYeY2bHE+jYWW3BO4x4h2uKOuYMYLHYXDQe02x6YrE4NU4Yi2e0B53RHujhGYABF0lAt2h5gIMIwU0YQlSbYJMmybM8n7aMhDgYhcD/Yht36cYDipa4eE2D5aWmCAiA4DlR3HfAwT5WV/1QQ
D8GA6NsCEVkDC/ZDcG4YoCPtb0OjgKAz2zTiCMkAlJCIQk/zVVA2SEBAHlKPQOFZawoAABUCFcRHEaTSFk+TIEtZgOiEKAiO02j6LzSBhFMqcEGdYgoTQA59JjPiBI4ukCPUKcOCnZRt30gR9DYNgfI4ALnO0d8rIENkQn0MziRiqyMFCfyKjMnV9S4qJSCgTzYpmXBECklyvIIvA4G4GS5Iq0oQlYCLMrs7L6oAXyCjAlUK2KICqmrdLqoroBKp
hBr0+rIEajKJCygUOoq9qvOW6ZOujOA2CnHJ8i83M83KqyDi8uC8326YYXhBFyVRfp0UxbF9Mu0lEXiZFbvu6lsROvswTgDTmC0mCvKjA7fo3Qh9HHZCEHU8MtO4CzhtKfBQigHl9H0NQUNUra9TQNd8EKdaSiEspUIkDoKEdTtS0GGA9n0AB9cYhHrRpugANQAaQQRJqxaW1Zm0iBFgQZZyHnAiNjQLFrm0TZ/kwi5xn6foeA1q9o0TVAXm0VE7
kw/prnVskdn6MEIUc100ABbQAXiA4Lk2bFxkBNFcXxCTuH6bQ/h2b5jZ4C54hdngUvpCL/UO0puK5FV+SFEUxQlECZTlRdlV5RP1XIJTtV1AqByNE0zRFy1sGtJBPQdeyXTdaKa+9X1/TtXlyjBENJGXbNQdKWMZQTbdk2jVMEMzYG8wgQtizLCsq1rBtm3bLse2mU7SkHYcKdQQnJ2nGX0GrDZO7A4ge9I9cuPFnfn1V/pXmufDShPW9z1QUOI4
YG8z3vDhHzQNsXCVw/h90gJ+H8wQUKIyAsjSAoFFTEAghkLIO00CwTBAhJC0DIzoUwoCbCwCtYESIiRAmZEKJsCojvJGYJGLMX0KxKIvVY5ei5LxfinBBIVSkKJcS0hxpoFqq5RSylshw00jaIRQ1XKGWMrZMMMC6JwP7iZMyDknKoBjgRWMnClIsO8iJDgflmqRi6swEKYUjGRS0Y3eqdp4pDiSlFCOBEZqmPQPNHKrCdQFTQEJKeURSrMimv1E
qE0VFuPSh4wirUFqxRJqlLIO8AmVXCdIyaI0gmCJ0pkvq7ibGxLDG1BJS0Vp0kSZATa21J7THOiUbRDSTryXqWAZwMJxjYT+AiRWmx1aJGdk9aKXS4QAl6erZ2iRml7QqpsBIVInbPj2NiYE1xiF5j1q8cYit4jUn3NsPc/RplnQqhcaKuyH4HERNsXZiJn7TE2XsbZBxdmfH+AcvYRy8wbxKK0vY2gbggiSGrD4Ic3aggqnrNWXwjgHmOJsU4T9
jl1Iqo7WE6E7gXHVs+A4rt7klChUC2Fu5Q6Iqmd8lpqK4joixTwJ2ztbg/ERPpZwcRfhXNxU/EOgIDiq02Mi35qK5mazuSHB+iQEV9JZWyv4hxEhcsfryu6AqwCtPiGczp4wQHvUSD8U4FxpX2yxBhTY2EjgDN1acFVar/m/Dtby3luFTXrIeXEL6JqzU/CxMcL569KVWTpQkHYyyJWqwuE7P4BrIXJGRFcXlQJNh7kSCia1FVjj2xuFyxWJsMRS
ujdFLVdLOmYSTSmilMyA1zMSHCO6uLthPzwXwSFczQ48s+M+FZxtxipoDWcrFb10R7mOMHFELK5l3XVcCT5PwQTxp7XmG4sJE0Stesst6WqWXjH1hK6td9nbh11fy8tJyrLVoBTwNWGFXjO0dk7Td26XZXKefulEOF53TFRArJIb0kTbEwhuyFW7sSPr3Ym19R6/UVrzNiBIdxw47HpbhZN97gO7ufWBw976SjJuinG4tiblkoijVZZwW6Rk9KNu
HT53bj0otPf83csb5VYmBOq1xbSNUXMdtcnYAJdxYbAIrfYX0sUEODhG9jzhOMm24zhXjTyeACcTbCL4/QLgAixcm4NLLpOXJ47c/jtHBVWRdgC/tD9CPoj2Tp85MmrlyYM4pozqrZlbv/Revp1G7h9JdQS3Tsmbl8ac5Bk9eZcL7B+L8NW8qziHps7xvTDmgtKflrshFXwsWdI1sHYjGz/P2cCwpgTGF7bqz3LhPcTtFb4o47ZxLhXDMhbo3mXc
Qa1OXE6WCp5Er4tcYK/JxrJQfkuasiifWIH0MHtxb1uz+nkvOdaVq/WTtOkrs+rq3LDz8tzaKwtiqnSAXdLGZR5EayWW+xODhE4hxn2RoEyHd42bzXZtDlcc7CRvgIteFcrVd29tWWdrCE4kaL2XIGZtvzdWAsDeC0N/1eYVZ+0BPuDWhDtlNpI9tpLu2mvGYR/89C2JSXOtU2AyHCXoeOYEw/P26qvhAnUw/Y2FtIUXc+9dn7WKnbU7mVctTPw4
TFpZyRtnV3vu3e5/9vM6FDvVpwjmuEb0Zv1Zh9T32vLLtBxDi7GrUmof9ap1L6YIIIvYV3SCPcGEIe1Ypwb+buORt5i+AC+EK7Q4+eBMryn9u4dQemIiUrXwougrepce95Hjt9Ko+hATl4/aFsVhZ9C/Pw8XtGZeE71HY9kYRfuz4nwSUY42UBndT6tUYbfUbkonyEhp5pdstZHwi8PJLxN8vB7K8O7+f8oEOw+nhtlZeMnbTx256nf02dnSBNAl
hL301qtg03GbwS0fk6QQT8OFPqvYAZ+fF1RhU7AvThjvmW2pZnaDzT92BezVA7dVq0TSf1tDPz/Vq7dP6lIdk3JpOL8NLT+Fl20Q1VkaMu8Kon5YRnltl58EU7gIUSMY1C140S1CNyUwCrI1kAV5VthnZjVgUWVEC8ME1S00DfdQtphMDlkkQ7o+ktV/hhcNlCCi1iDUDp8t1E0MQ3YXZJ1XpDV3VMJPULUfVp8zkXl0JOkEUtVkQ80SM3VjUBC6
UvVLVfUyDmsKC+1HZxN5UTYjg7o+D5DTVFChCrVt8TYXcbgv9lk7pbh4DGCC0iCUDv9p9fZFDqQkgrDTUAR9Dk0FDzVvUTD0C8wzCu0m8Bk1YTYfhvCPUjD/CVCwBhtWk7ZzhlkaRg03wojfClDhDTDbUO1UjXh0j81Y1mDHCy1AiKDciUjXYCjtgCD7CSiCMnDvlwYCJ/p4YNJdo8wyduj5IeiQZeiBj+ihiujBiRjhjpg+ixipiJjRiZjxiShJ
i5jpiFjZiVj5iwBFi1jliNjVidj1jNi9jtiDjjjdiTj9jTiLjziriwZcc7RIZoY/wJFAYpEaJYEKI0YMYsYZBlhcZtpL4iYShEkyZygJB5h5h9AYAmYOA6goBEhRhuhSx0YAAxUsUgbmAAIRbBqCFngBFkhmiGrmjEPitwVhNReTDVuETzBB1ik3lioz33NmwlOFsMgCtk0W+C3QfnBSdmA0009lEj8Q/g1j9nU0lU+Eu0wjAQgAZGjibnjmzikm
gDzi1B1FQVtGlFlDHiVATkVI1HzlVL1GLmNBbhFkDA7g3DYTrmtjdDlJ9DLgqDNNQlPj8G7nDECmjAHnjFgGHm0QgDHgzCzE6IIhnhLHLErBrDrEbEGFbA7G7BaM3nIG3n+P3mIBnAkGrCeGdKXDdPISvljhvm3F+GWThHU2vFPE4G3AwjLLfj/gAQ/hViQxNlVknG/F/GoloWjAQXAkglQVqVJh4RBPQHTBbBaG5i/HROYEGAoEaEwEoC/HGCRK
+FIE5jYG8WgFxIqB1HZCoHKVuKwRhh3lOBNTEyIQoinDIV3goWjEoi5BoTeItOQiYgqEQCVAyiNIQBHAkHiDBNwAuFwBOGICQmuHmBVnlU0AQEBFwETWuGIAz2wESHmH6HmD5nOGwHiFtGYHcG0nqW6PjMgGwHZGqlzIBLACBI/B3ggHRL2FGHoGIFGGUHDiEEIEwAOCgFHPGAoHrEwE0BxLmFBKWBWFtEPjujiGDhuT3GpHDQ1mpOeCW1oLJCfT
U1uGpEtnriiiujJHXQ+ipBpH5O9nUpehukpAenuWlKjm0l9Ljm5AVKTlFHFE2HVPTi1KzlVAqD1JVMLltENGNPtItCtARltI0Rtl4DsVylrhNIdPbidIXGEFDBzI/jBE9KHiTF9P9IniDNKAACs2wLh6wKAkSoAah8B6xOZMrsAvxsAah5hHRJBsB8Acpp4ixQz54Iyl5oyV44zbit4Pyd494PwD5ZwjBgwz4L5iKWQCy0Ab83pfgsRqyzxuBnw5
q7wHxtJqQtUVlfgWzIEEAcFXjlEQIz5kEoI0EcwfkIB9zdqjz8FGU3YVLrzzzkzryqFbylFLIFImIoAWI2IDEHFa4OEPJ/EeERJCR+FJIIkREuEohxEAYEYMlIkpBQh5FnE9q3qdE1E7IgqQlUpdEAbUBUkZgjETEbFh9gpQpwobEOlzFHFEo7JkouoCkWpikBQqbfEDFvIxoyogp8L0lclIkGpolCkvEOp6aepAaRoBo4aubRpglJbQkGa5o4k1
4rJVo8wVbASKk/o8YTr6lWlGkwBjpt9np08jKaCTKhkNLXp3pjKvpSD4i8KIA2jJFwgMrDiLp7bWAoZUZHiYaXiOySEPiDAvicYtb/jiY1hgSKLSAABFOAbmfMTKzQKmdEzsIgfQSQIwTYNsegFmXikWMWCWSgISws1WMzd5TVHlHrbWbcb4JHXceg3NdVTbcENS3gf5eg9tcOIOIfF1KQL2IkNAGnTfOlbEKjU4G4MEGUiy20nU2ylOBytOTUzO
Ge3OTUAuNUo00uP0cufym0QKlu90W0iKiQR04al00ahKj0uMZKj+EeAiNKwM9BLyCAbK3K/Kwq4q0q8qyq6q2q+q+SRq2eMMheSM5eWMpW+IgcRMnqx6giKcVMw+aUg4U+7MlcGB/M6iV6LFNZHYJa9+X/XB2s7SJIZNIEQEM4Latsu8/azsw6ns6CfIM6i66iK6rCKjE2M84iNByAG89s+8yqD6r65hMWsKnidyLhNm3hEGgUnJYRHhURKGtSH2
7SWR1KORdGxRACPhqeGydRFuvWtyPRbhPqcKIm90vqCxMm6xOm+xe0BKZGym+xeWzxRWlm/KNm0obJTm0JCW3mqWpxopEIeJZWkWlJbxnmlR4xjm8GuWgWxmwJ8BtaMpVWjWjaLWvsx3C6J6ATGEK4F2J+YEH4AECVdWLJ7fXYT5W6Jkh+A8aa4fA28okoKtP4dCN6CNJZNWfSa/DEEEbXPpPZble7fYPfGdL6a5RatNBWJssrQEVbD4NTafe2IE
CS0PX4bYTpfSOZW4PvbYY2V4WLUA1QvHCY6lT5S4d3Y2cUkp05IZqg34UZ8OdEATUOe2J5HXM4dCMVZZfSeWW4I4d2N2VZsFJ5s5J5M5m4bZZPXlTp5IM4D4eSi9FWJ9J532DEatJ2XQ9dDCFkhYkFt2EOcF2gsHJ5gnSpn1XZXcVEXzMAH4BII4bZMIz5BFOTYlv2Ul04clvVKlvcWfdrREVWbCBTA5iBv3BY+WZNblXcdEHwj4fSCVI1cNb4R1
VER2OIhI1FMVrVLZHCF2K3a3ITN2aQnQ26zLATQNcNU1cVd2HzFWDZzZ9al5YdAvLEU18plEZPFEbAl2ZlWZH57Z/lvZm4eIU16lIFK3HkxNch/bLdVWBECVF2bYS4R57fGlzQ+l0TCdXZfScNXDfFw4DWZ2VbU1mF4OLlFppIA8Ta05M5LZD4X7ZddVIN5NqtHYXVMkb/Y2A8LNsV4ELER2AZDWAZPYU1zZ5PDWGZrNUdCqGncXVNiVV4Z8U1rd
cNF5N6PZYDbFsAQe3lYe/fVTG4U1s5TWDCBNYEEe63Lduuket2Me64A9/YBZY4b9VEcNDd6dm7Wd9LBd5NlFs4cFrZFEEs63dTe2XVI4BFK5K4OlW95Ntuk2Du/l8rUOLt5bNTVEXFSDwd012D3lzugVyVZDt/Xt9Dgdz4H6W4x25452x+o4y4mj64pYhjrYxj12pj1jlj9js4ujrj5jsnep4Vrie4r22GJR16uBQiAOzGbGH4kO4isOwoCOiobA
HkJipmTAJmZwSQA4JseIGAfQdEuAQYUsUsbAXOhYASyWIuyMEh+PJ5V4HCS8azKu22eWfBQtddFWBt1S60tAGDJnDWYtGpxNKF6MPEAU7gc4FTZnCdFjXdCe8yrG1hWuZe9AYUOy1OTspypemyle/Uzyjeo+9ACuKuDCy0zGya0KxL5uXygMKK0+uK1BsxS+web0lKlMBUAM9J5+nKvKgqoqkqsqiqqqmquqhqkMuecMxeKMmM1ee27qz8y8vM8B
AaiQf85B8+eKvq6+Zhx9i1L6XB4eHu1+X+Fat0ZZL7D4KUiBSh0Tg6xBI63shhzBRCA8tCY8m6shjhi8zblGZ63h6h/hhhJhdiYRyr9hMR/REH0oYGsSaRqSCJyqSGlSJ42G3xoGxG9R8yLRtGhRK0zRfRnG8RyHjxwm2aC+8xyxcm6x8x6m+xirqefxrxVxwU/G4qGWrRKWnx+H+n2JhWpmhJwEkJ9x7moi1HrJKJ2WkaBnxWxaZW3cgX1JmpF2
3W0php/WoZXJ+VN/QpjPW2tVqyLp053pi5w4a3Pj/jtQ7DWvV5IjXZM1B+FlA3np85vZSXVXzZwLnZuAsrKl5wZIb4a3gZW3ulB+BZ355ZgFu6U7FlAnSQ3FF5ZNNWdCCDQ5jJhYv374B5y90FXXJIVluFjFBFjCb6Mppd66N5W4KShFB3lF4s9Fi9TFq5ZFhWWvqSrk5EK5aVa/G4AZGlAdTpId5NnJgQy17zd16VQ9uTJWRPM94d/WFtm4O5N1
rZggjpOFcNCF3cY4c4O9o9qf09jbAgmFse8OIEQLotLDnl+DruxjAg6Nk9nYYOP4NZRt1Xs9TVcTDfjWdwggkF+VXZQOVppBwEyfpLwvSD4GbkfjogCCKLY1JeB3QJpSO2+XVArE+B5M1MfSD2NGhgHJo4BeTZWAP1f5H8ysAXPvEWmgEoCcB8beVPgOAFED/Op/UgcFwQLYCuC8Amgc0XI5KN0mnHHjrR14H0c2OPAwQfJD45nUPaDxYTu0Ux7/
cUYEnIOtJz+Kyd5e/ZWBhRXmBsAYABwasFHWcCaBSAZgNsOmAuBIl8wbYIwIkBnKmd+KN8CzmCEPi94IstBXCK2m0xOcP4QGY2DyiARiVUWXnTROiG3S7IrkocP5kzj0r91UATyaKOlmPZbI7kplSeglzihJdsuKXZOPZUcqL0z4yXJUqvQNJFxow3lTeq3CK4BULStcMriFS/hWUCubcIMM6Xq69xEqV9FrjfVSrtd0q1HAiC/R67v1+uX9Ibr/
VG5NVxuwDNqtN06qHNRYUDebt9yW7wNNyPANbufTmF2gJqH8CVEqnA5SkjuFZKzl/F2EcBCGw8Mhvy3YYfhWyUCP7qjQgBdkkEdDbWow2e6XU8ErDW6gwW4YPUxqT1ahDdwYgCNGE31SHr9VEaGMJG0PUGjIxkRyNEe0NKQdE1Ubo8cefw7Ghj0qH49weRjVKCY1J4k07QFPKxi4ipqBAnEtNIkY4x57OM+eTPIXtLRyR60FI4TaEZL0pEBMSkwT
RxqLTxphMReXPdmmzz5H80mogtaXqUll7JM1omtRXl0KOYNIVeKfVpO0neA4RNeBTeVDrxZQ5MVR+TfpMdl17w5MmkKcpmcERRks4UVyaDqry1F5Mte6o6rA732Amig47Lc0YCCeaOi2W1TOuoCENQWtVYY7A8Aqlhzm9ZR1LSZqOwkqzNvgvoqZgGKjHBi9eTuD7JckpLA4n4kmP3scDWqB9GU5JJ5uUyxC4QrCsaODhu1ZThj/RkYoMU81L5kh
y+1IMDnU2BZYFE0tyRfp8nlEhjU+GxGvmi1b4N8N2xoz0Ry2dgECFRqKElqaJdEUskOFUGFkhlYF4C+kvwJ5j803wghn21hYHPpCXbksZqOwA1mcCeQutz0WaZwdsn75ZsbmuqO5liD5ZJtVewpTzIAPDYXoOx4BfWCrExA/Y4Ow6Itn7BLZhEA48qVbJ0wLESo984hdTHcln4/5W2i/O5p21RQwtwc8LNTFizHFdjWk4cd4IrlXZ74V0nTQ9hKi
zHPgfgbsVVgaJKDBxz0f6E9rFmDidNJxzor0V6kokitqWP7VtsGneiAd9I6aVHD33PH1pMJiY6YNy3bpkSEOl4T4PxJHaVjx2PfMouOIDRisnUNBXQuHA8z8S1JzsDSRegPT6iOJi6HQpcDugtMZ0j0OcZ/jgFwcMByqJAav13Dr9aCX/c4LK1/53A4MXJJ2HuGAHX4A+IcXMdsllZiswixqEOP8EpLACbJaAvSacFDQbNymO6HAVbnTFapaBs+J
NEmgfhvR0ItrQIaQxCGHJ82wAzZh8AdZKsTg5JDZm3Qty1s7oWKNWMALv6YQNcj/d5MPlNT2w/WuzadHcGAGHtQ4ng23iq29ajYq0X/CIhpk+bJ8sJc4zyf/3r5W5pK+2EFhcnUzgp4MQCYASwNwHUCkMO4n5gijODz4wO6EBMVRLAARc+cJsaLtWjlxAdymocbzOqhoIXojJ5BbDGFKxQRTHYNhI8KcirSfZE2MbHvsAJ+modNWUUn0VW32C3oK
JwCT6Rb2uk/MQ4b0PCBKjJCAyAc3bVDn2ww6IDX+aMncJjNNSIgcZ0ualOCy+iaUF8SmDpE8gbz+xMQ6mc9tGwPFiopKwIeZtvgRQu5KSoOCmTgynYoscItaO6dVlxRKZkpOuA1k7HTH6RjYAKE2GajSz98fgSmalBRIkoC4vJmEJWT8wHZJAcsFfZ2FrNJLTpAQesoIVS0ODRCucNIJ+AeEwhKZkgVyVEFmIPCmp0O1uZ3OyyilfZjYyaN2Spk9
m28G8vs/SM7i7SGEG6Xkl/ipLCwwtgQB4tps+HQHRzdgscwhEPgTmhzmmac0TBnMGQVQA8sBO+LGmLTIzQxpmQuYAJBAly7Z2c72bnNgL/8C5qchue01LlWR/ZKY5/mSiFZiTGmKclplbkbmfJe5TuXYAHNTFDyyOUwijkDBdpCCOOfA4QQIPXlby15u8jedvO46bzD5B8/gcfL3k7z95vHd2oJxhjI9faWPcTqyE+JSdiAvxfGAtxIpkVVBDpDg
JoA5A8BMAUdeIEYEdCZVhyFwboH6AAAqQga4IMCsHoB86glOwdwCBAwgi0xwNmRtibo0lkgP+IEOy3awbiWSzdbzqgHlRGpSZNIcmchhC591BSjsWeTsCanYp0cb2aMIkOcjT1UhEAVLnPUyEZxshPC9ymvUNKFCS4tQ0obvXKHehKhB9GRVyFqEn0GhrpBrmT37gtCdYt6NrmmE6E5gn6PQt+n10/qDcf6I3f+mNyAatUpuHVcBmdTm69UrysDZ
bugFwCJBlhG3Jxeg0PKVNzgtwD4d/HLJ4NdUBDE7pGDWSMo08l3S4TtWuFic7h93ehugieHYJmGrwsTO8M+5cNCIv3KhjcPoSfVARQjbkVPCsr/VCeJSqeBCNh4Iip48jJHiJwl5VKkRyNP2tozRF6NXIBPCHpUsCQk8PEeIixlYlJ4ONqeJImmho1sTsZporIxnjYzyjM9QknjJIXUqZF5Ikksy0URyPyRciWeYSXkcyMiYCjDlGy4UXE3ZESjL
l6tSUQrySX6KvpavCqGbxHn61lRNotUXqM7EvLHeZzdEMb25RfKrp1KWMVWPBxqYHR9nJ3n8pd4XAlMizXqV71dgxiIxikuZrCu3wgthmt484A8x97u8EVAbY2LHj9ix9q0SQe+EnxsyXBbmFzHFdAQWYDJjWP4/nNGNZyTN6++eU5u8nYkPKfmSzf5h4TBQsoxWX4hsU8jg55SnmOTV7IiAFzRYXklMh5Gim1yfAB2PMiwpdI4knAsCQIQnLinZ
aP4jR6ffzgcl9nOsym4Eosb8BLF3IHexE1sQCHbE8qUZNdbpr8r6aqqL0Dvf5Cq20JRT3oA0spsasz7D1s+nfU8UJLBQiSnmwai8aGrwjSp5J0zQMUpJrndjc+sLPSVlnQlPppUXEv9kzL7HorVezzQPm1NrbqosZw+X3k5I/6uSt+okq6aWsimKwK1hYu4IfyylUErCO4L4E802avNsQ7zTVjM1v7DI2pD/LnM/xrG4S6x+4BsQvwIKQy/pMMy0
UnImL2rSJTqsdGPKLmTyiVZTXFmC29nJ4+2Y6FFiiAqYYQNYQcOad8p9WntfmWzQ8DK0AzlMcIVwDCErHFKhwWWToqphyzCKbpJpWY02JcFmmri5+ErbVj4TVjL42kbsWEAXmRCxZt2mssphq2g1SsMIcGnTB0gu6VZ829aSDeKy1bYb1VOmZIO2n+DYgZJdzO9U2rXFKo10WKU1JgMxwos42waIIYh1NZD8LW7hUfgvnOyzz32dLOdkshPHdZ3W
2INZOiB953RlsoOTVtsn+kMbjJfvOli7HTZMtairOEFnCGKa944QOzWCfPzbaXqmBGyZWdhD1TYKzZ6mh5ThOXY7g12K6a3M4Bjmtz7O7cr9o+PzU1NC1DrXXHHjuCR8QQzg5ZNhAv5lZghG1EtoxMhQ15SV8fClRlOTY/NZUrGiyXahC10kyJNG3cBEUbUcSQB6IZWOpj1QEIPhBKO4LXSBQvo4Waa1pL52P4kDQ4ZAyFBAVFUvtOkamOnC1PHW
KxJ1T/GQhsgPDRRLUisHtgeHUyDT9gf/byYAL3DCqUWvKA2DcEkJIhgBbdT5JLMrVx8yxtwQ7A51s5JBlxJWh5RQuxC/TSNq64VT8z+Z3AI+OzS7SjOu3hS7tAMh3nCGigGSZJmrdELsghmUKMZ1CoppJkYVBo3pcG15sHE1VXaSZYO4DBDp+0dJ/tuEQHbARB1uFkdWMwjGjr+3YpMdvTYHRwKXlcDV5l86nRfNp1nyad9OunafOZ1HyWdJ81nR
zvZ1c6DioglkDfO9rwjNGMg7hnIJflvzBShMOTioNKCDkIAXYSQBcBgD5h0SNQWoOMHmBGBiAnMfQC0FGB7B0S6FMEMLAqCBBsAUNRkISWlg+xlMoLdVPX2fBN4ZKaAX3nMlViYsh1L7StgRDZLBVpquEhWde1JDH46FYXC8D3U4Xs8FF1lVyhIEFDxAEA8e+PQIuco5CRF+QryhIuq51DzSIjJ0PvUPpZ7lFMVM+vFSlJJVWh2i0eB0Ifr3Luh3
XIxR/QG7f1huf9J+pYpaqTdQGM3LqjMMcWLcygLi6UvPWL0oMsRHjDcj5xSZbdb46sHDecACWHDtwGIUJf/CIZ7M3klaihlcLyXxLaGKCO5fUlSTkwTdjQa4PgH0BQKKA2JVyMbvVBYACocvEMedWeFpKPUJZD2U3VITZKeGO+qXUUHIon6z9F+q/QgugD37LOqAfnArE0lJ89wnnNwaynliKwRmE6OTV/B93V1XdVCu3f9Pckh79KkBqjSHFHE3
ZaU4cOLhbqSEgj5SMelLonoT2W6pQmXIRbQdyG5d164inylvUir1Co9cigvdwePq1cVF59MvZop9I6Lx4Ne+pF11fq9dG9Awsxa3qnjt6JuIDdqmA1m697slcDNMq4smBZl1uai1YZuEPI3rqssBfbpGDDzRhDhxwyMAlNAo4at9sSnfbd27L77HhT3VJYeVeFoLPdX8L/d8JIS5KURHjcAxIFGA7VpIFANgKgHTCqQAAOhwFwCAUAY4QZIxCHUC
oAVwyh0oJLCgURH0AURqADEbiMJHUAqRsgOGHCCoAsjkgHI8wDyMGhOAUARoIQCMBEN5YkyR2IWLIbYRX1BEdQdkCRJDgjQWio3ffvzDiR34/UVBONDLL8R3A0xgkLMaxiAUmQdCVo7gDsikB5ucuzsArqV0q61dGurXTrr10G7bQ/IAkFOAICFHMAgpCACUbKPxHVIlRtIzUeYB1G1ADR3I7aFwAmQ2AgwcIB0eUYnKAmwwehduABSgEv5Muiiu
mBBM8AuKUCg4C4DqDOB0S6YBAPQHrB1BuDRuifegFN3m7NjRJVBRiHtjj4LudadVE7t1gmzcJ3wJqZKVupSkMDgCF5M3x8zIgSUEW8IYKXDQUHZSUenIXHoYNJ6F6gixBKnuVKiKChQxzPYIZq68Hc9uPYKs3moN2kVT2e6KgRC7iiHmhzXLRbfVKD31Ouhi+Q/0NMUt7hhgDDveoYmF2LIGQ4aBsEZl2D7fyHitRQEnXJ8VyFU+7xa9x3QsqrDv
APTQRDsNhKP4Xweznmx7pXdt9YR+BHvuOrpMj9supEmwFbCNA9gpkNcrfvQB/hHjCTNWikpe64I0ptvTzFqaCMfzKEvwoXWED/0KcJA2Z3M/meaP+mRYJZxU+sFQUy4UN3+Q3gUQZMvAL0QaIudVi+bRhOT5Cqk1sl2bklP1gprYKlh5lfj1Y90YPQRAj2WVLS4p+g1KYy5ZDZTwi+U+nvy6F7hDfB/PVHqUW3mDTsVVRU0Ka5elTT7Q3RdIYMX1
7rTJi5vUMIsUjCrFnejQ93qmEOKdDXp/oD6dXBeKBA6w6kMOmTRV9bDP8PYbwDupRmMLRwmM+7nn07NTKSZ1wymduFpmHuyS7w5WY/jpL3u5wkhF8IbM/CXqzZsTn2YqBMQEAORt06gH8gAxUAikL0MaCYCoBNAJkMo8kccBgkmAqCQS6jBXDO1O4lAB408a4s8XMgfFiKAJaEvsgRLpAMSxJagCxHUA0l5CoXHkuhAwguQAcK0faOdHtw3R7guG
36M5ZbLIxsY/gAmPRg+zKx5QLMbEDZAFj6F/KOYAIB+W1jJAYgOSYR7ZAdjYYPY4ieROon0TzgTE9idxP4nCTHpUgLcZSP4BVLnFsIBpe4v8Xwwgl1o3peCAGXxLpR4y3EbMuyXsgllxSzZY4VAmQTrABy00s+FhgoToej+LCdbMAGJAhAegFidGAdAsY3QGoOmHiCOgOgbAa4HAE2DDBhg8CokwGYgCknEhKC22NsFrp3AQZWMgJTrADyPwIldK
C0VZj8HBUdkPJyPsiB9SXg1zssX0vue4WsGJT9B5PVl1YNp68unB4oaaSfOg8NTNpB8zebVP5GXzRp989fUr131q9lpv830IAuDDzFbekC46fGG2KtDbp2YQhYH0LCVuewOCz9SLOkFKkaw5hnkUM1jbIAi+yak/BX11lb0uBI4KWQuHbVdqbS1M3dweEZmByFFXAJoB4A1Bw0mAJYTfuJNgHSzj+isy8Le7YRMl91Thh6e4ahG2Lw17+StzFsS2
DgUt0Axxb2uoBVZCQS4OcFxR3MMZDJmvFiHDRN5cCfwHuvOeAzvBlkhwd5tWlwiKre6A17qSq3QnTodzASj62KZ4XfWGDv1lgznGLOXnAbSprg63CL3qn+DkN3U6nZhsl61FYhk0xIar3fmUbchtG03oxvNGCw2NtQ7jc0M96Cbfe8iP1RJuuLrg5NjWzTcPKFizgTsTNiFbfjhcXrfd47qvrdBdph049bm9dzYvuH7hnhmCIrdf3XUVbH3NW19y
Js/6yLHFiQOpZ4CmXCAMliy2VZXAVXsgVVm8MkeDAqWij51Yq7vcauH3tL5V3S7yGqvMAL77lto2CccuPY0OfR1WW5cKGtHRjWMLy2Y3COPGIrineY8zRCtLHwrMxioOseiuMH8K2x3Y/sbGsTWprhAGa3NYWtLWVra1jazlbyv3Hr7O9vewfbktH3vjz9/S2/a4AT0OroJ7q6LxRh2R+rBB6/HCfDojX0AfofAMQHoDyhrgqkZgBwEGBQLBg8wQ
YIIFiOG6fLstna/F1Nvlt5Y1TVjc+AjlamdYwpadAPhvH/o+8t1rYNydzSPX+Tg94SNCbQCIbsIT8W2epiix+3w76po85KZQe3DmD55/6wnY4NJ3gbPBnPWDfTvqnHz0NyAIadL3GmPzBdpG0XZdqyHehxisu0oftPNVq7Ni2u5Be0Pt3dDCDXAPmDbu9KZgxJqm+NTSUOtr28qcM+DlZtr7osnsyMzLpiW82H5CSwWy7UzMUUoASJbmE2ESBQL0
S6JQs7LY4sK3qLStpe2wwCX1nVhG97W8oP/263izfTgZ0M5GebXez4B1R+XhJVOoTe/wNjAyaEzot98RZZA17tKDzmac8bDtmlldhnZ8DEQnCAWmSLd9IOisJ5CKanoR2vrx5zxxqRlPakLzeQxO5vGVMp3QbyQ2RfebCdQ3gnkT2G9E/hsV6zTkAC04k6tOl3FDdp4Cw6cydd7JhT+qC3k69ObOR9Rh+C/3tMPcBGcopR/uGb6QL7cL9hjYbqkR
DFlolPNuJTPcSVeH4IL+3w8rZmdZL27CzlGuxevtQLyACAQ0CRGUsUBCrEgGV7gDleEAFXgD7IPZa6M/3ejK6f+4Mc3hAPPL3l7yFMYQcSBArYNRY2FfwCQOJASDmKwpDQcJX9jAjoRyI7EcSOpHMjuR2wAUc6Jcr/gMh6WZVeyv5XAJ5h11fBPrLITNjwa+HB1sInNynSXAHsE0Bfh8TmgPYIME5jMBCnnMdEtTGqhbOTdCAM3btYpNWdsI56Ta
YcBNkdaGTfurZj+mcm5Txm3uluvdfMdrNLHPdULgQbsfd9HHDaY2D86oNWV3HP16UyntBfsGxFAT8J4i+1OhOwby7/U9ncaFgPrI4h1roXakPF3knCh200BaxsEuxhWTiCyS9yfMXnFzd6Ut0GKd+nKbQZxC9RHZQvYWXQSrYKiHqfDxzg/LF5C4bafC7yLAtue1054RFm5b/ZlZxAE7DKAWwjoGAOOG5hln7aTDYV9M9VuMX1bd7n7k2clfJvwE
FFRD8h9Q/4B0PZbu/aWd2fAcMQXtq4CcFBQkKtFb7Q5LykRCLI9Cc57t2cmQuxCnrp0gdwm9efvQyJXKTWD9gndcK/ncd3hQC5js+OFPAN/xxC+Tsg2Inq7uF+u4RebukXOdt8zoj3dtDJDHXLF6jZSe4uz3Khqu5e6JcunCht71Yfk83JfhinJh9YYqxViXqdhuF7gO33/f7D6c/wcg5PeTPT2aGEH9M490Fc+HXuOHle3h7Xv96JXfN2DxUBqD
+AT4C4K+2G/QDZepwuXoY3Za/vhK9XLlw103WGO9PTXO72Dw6/QDWvgrOF0K8sctfoAnXnjoS/FaYD7HcAabjN1m7qA5u83Bb/MEW5LfXHg3dxgq9faK8cASvpQQE59U6vle2HvVhAJw4iHcOSPx+iQDADbDOBfeMAesKpC/BGAOg+nGoNFZgAth8wbAdiDR5JMVuyTnjw+M6iwLQSl8yB98QRC0XAdA+Rhd5keNdv70cMFo3to7GhXYWoeCb47Y
Ch6b1svJsnyPW48jvpD0uBEIF3O98dgv1PBoSF9vUrhlC07+9OntqY3d1dXzDX8vZ+fM96KMEzn+u9BYfe4AkSz7p+q+5uXT6tgLbf/t+/7sD0/b0Zke5NTC8UzNYIH3l9F48OxeZRyzwJGM52fC2KgmgOoOmFIDadHQqEFaPJG6cVBhyo5ccpOWnKzkKA85RcvEGXKrkZbW1rcmwB3Kq0Dfav7e9UDbBCBMA9ATQIMCEAwBSMzANZPgE7AWBqwo
zh36QG3JlnXfqUWXXUA6BOwtQ9ATKtzFUhMxRgTYUgI6A4AHB0SgwOoPMAj8ixHfzv3n9MEN8SADg+gCgEYH8vzBMq4wOiPn4qrOBhydQYsMX83JR+nfGHvckK8S+VbI0nWMVwR81tEekY+32XRr6186+DPPZtyqr6t22OZ8+q16EJIpYMm6UnGUZMiG6yM4SF850zJ4W9kkcOXUpQdy86/iuOwb4prH8Ppx/eOQX+Phd3B9FjE+KgUizx1ZTkWU
+ah+nmnzhsTPfO33d4nQ9zi8hjFzyJs3PFblGBPPIm1pcRfUNGRxRfAL1lhTKMXzZsIiIsh3AZfNwzl9Z7BX1OpJnRe04IrsaCVH95nLW0ldJjArwgAaqGAAAB+S+yVdr7BgOYCP7HVzdBfSWr2AdxjBr18tOvOYyCsYHNrzgd7XIQO69bQXr3QcKKI7xO9EgM7wu8rvG7zu8HvJ7xm9SHebzoD2AqNzW8WHWNzE4zIHbwYUhrJZzbN0AbYAb8YA
DOlbsXvMoH0ACSCAxBBHtQdmpATYffBOdA0TWDs1VVFtgCU3bTCAVgaCLLBeQJWV614AxsH72OATNZ2DWY0fA8xSEX/DykJ8vHM82f9VPPx0XcNPQJz8pSfaRXJ8yFKUn/9M7aF22tkXXOxicEbdF3KDEEFYQQD1hF8Cec2vYX3rJDuVlxjMu0A8GvUpSLD0S9UWGSTCC8Asi0xcqLAgP5d57SgPXtqAjL28p3TdAE0B+gXABFB49S5H3Qc3XAAO
AxbVtT5hxgYgBOBrgdN2/JAKA4DVdeUDCiwoqdEGHtoYA1xWGBpAwih+pD4RpAgAdYF4PnMTgZTDdZUQcVQ7RJ2KpQR9dwf+hSMoAEQAIBKha9DJwIAEELBD8AEwNQVBsam1Jcx/BxEfJswB2mSQMoKfwopOYdMFwBcQhikaBjbJfwHMB6OPEvUrbeHTWQjgBk37YEgbXETY4+G8QCCW6azisJeUfdGf5APCIKrIOFeLjk8MfL63v9lPDIN1Isgt
/yKFJFHem/9SuCn2qFLSanxEMUXYANidQA802RsIAhMlZ8yXdnxbB4Aml3WENsXCHQ4DhNANjMMAjoPF9IhCmSOATgYYKi8cfCiwP0vISv3QAhAD3y98ffP3wD9xgIP02AQ/MPy78VuHvzL9rlKYT6CqzfBGYx0OP2zmdpgifwfkt7dAAoBuLYgE4AAAclKMKAFSGkg4jYWGkg8QPizgBkjKowBgAAak2h8oXMNQASRSuEqM6jBAHsA1ATxwKNr7
FMNMsMwrMJzDPqaSFxICw0qzgAPjaoxXAKw/kDqs4jWsIaNcABsKbC/wLyjK9WHOlA/s+A0B0a5zXCByEDggeYDf8TwcQKa9oAWMGkDXXfrwbtEqWb3ytlXZMNTDOwuo27C8wvsPUABwocPLDKw8cJrCQgOsOnCUw2cM8dVvYEwMCyLYwITc9vcwL4cIAY3zHIJyKchnI5yBciXIVyUA1L8IDPlGVFLbF6ROl/gBk3VhooBtwNYuMQdhMcB6USnB
QJkNTDlgkJaxwGsJtIlC9ZnkBVibob/GFxoMFPPhQyFZ3P60yCCfbIKJ9NPT/2lCSuCoTlCBDKF208onSoNRcGfA9ws8xgyAO1CUQ24OlJqPSl3PoX3Yk1hxqbRAOtCIJOA1QCf3QBF0iayfCznZ3oF23tCaA8YM6cZI0oAjDaLIrUtxuZOsyYsqAhMLA9qkZ0IeU9aZ5SulsIqjH0cyI7QnYxqImFFojW1MIMXkn9BS3RhA6MXRk4UQ5SHyh0SO
BlJ4/TdIGOp9jMEghIoSGEjhIESZElRIMSLEgap1BehGShWMdDnnY9mdZifplAHml2QkNNZA+kpCVpmbIn6Q0EwAFBd+Ul1y/aaCVBEo18g8QUoh4XddjvU73O9Lva7zgBbvLy3UDnvVqKoQnyKKGXFYgtZFAED+aqNqj/6NqI6iJdMiDfdUQ/KHzAQwvEFSNslZJEOjtyY6JFsQw20CCBQIFMN/1QI+D3dDnAT3299fff30D9g/UPyMBw/ewKQj
TbU2HPRFccrHpZwvAHzdBkQakzd198F5HrRwfIoNMxNtIjCalLgEzQiDb0DNDNwe2atHz4Egz6xYjhQ9iNjsxQriIlCP/PIOK496MhXkV4XUoNEiKg4zw0UQAszykimfexSgD+9BSNwBuwQwxUjufNSL2jNIl6WowKJJlwMjh7OshVtpqKrDMiMvDp0g8rIyABsijyJfGfQjgHCCmC0vGYIfk3I7Wg4lPI/tWSAkYsFR6Y0Y1FF+17HOVRYx8+cK
LOpIo5+W+JX5WKJMMFlPqMcABop+lSjUEYaIUClA8aNUDpox71mip4YqIWjdYGEFDQ7pHCDrQjNKEJqiRebORAQ/gE1R7swhVqOYpto0Om6juoYgDdjkoz2KGicQvEIJCeAIkM2j5o7MCVF82BqIsIHdI5w6Z1okXiAwR0ZdGRxbeWanTj2op2MUEP5QWIWVzop30ujTopUAHiKAIeODDo/MEFuinfOJWxCKgBPyT84AFPzT8M/LPxz88/AvyL8/
o66NNsJCAtGkJy2ULy/hdHKIS0k3wRPDuhDgeGPZIqTadBEpusK6w7jKIrhzlYV0f0S+BGWLU0YjtTO/zS4H/Jg3SCXKTiNf8M9XiIpiyfEJyEiM7ESJXcxIxmN3dmYxG3VCEnRWOmE5I1zy9Nr9ZSPipVIgM3UiKnHeGHoitLtFNC9I1ABtYh7ZaitCFMCZE9lZY9pydCBXAiGViLpAVjoJIsTWMbsQjFyJuFdY9JmV4nlATBeBb49WHvjX0Esh
qxztcbCeRsUPZkTRbY94ifloox2PF1sleKKgA84j2Pp5C4ioHkDRo5QImipo+7yDiioiuOeAI4+DCxYfbA/HQx/6eOO3ANUJ+BwJIpC3D/dO4zOKUElnHqNzikojxBdjfEUePHiUQs6KOiQgK6MnjowaePujROOeIkBMqYYAu99AfMAuAinewJNtq3VAC+wLbFwIwFUQHDR7odYWAmZMXkWVQZRBcQiPITRCDtngw/8GjRIVL/QUjBiVvfkPR9b/
THz/iRQoBJJiQE6811Mv/ASNhdqYv/wVCAApUPEiVQ6oK/NwA1BORCME9nw6B9QrhODNIwIrQ4IUNcM1ZUWgiWK6Mu0TlFNR6EsD3liiAw/Td90AMsFGBrgUsB4AkPPoEwA6gbUEGAOgTAC+BGgQWHt8S/a6P18XQ05IgAWgasFOA6gTmARIvwOAFLAEACgCgBqqL8CSS6gdxXeTu/aPwmd4vGixYYztG/FMo4wrWJ4SpXOgIVB+IZqEVdLw2oPx
SAoTgI28lwrVzq8QHM13AcoAfcK3CdwpgD3ChAz6lLcGIY8MStslG4xDdtAp4zxS3ydq30CY3WpS294QyMDMDSKXh3g89gCgA79CAPYG5hXQNJJJDIAQ+DJVpE0FkRBxCcFTcEDxCLCEkXbaFC1MPg/4D9gbCFWDKwVYVc2edGk6/xaTEg70F/j+FImJU9uklIO4j3/MBMK5+IqmM0QaYvTzpjYEhmLp9TPJBIxcNQmZI5ilk+YT0NpSKOkWSCE7
cGfAc0L9VITWgxWGC8P4XvDCJMIYi1adZfR0Ji9KLWvWl14Pc5MuTrklsFuT7k3AEeTnk+IFeSgw1xU+SrlBe2w9OCbjFHFOExs1YtzI9cKeNJANgFZAxLUIC3BCU6+0HTh06UDCB5/Wry4CJfZcPq81w2lPpS5XRlPa94HVYzcpDwrYzitZArlPPDQ3AdKHTSjadLHTBU/8OFSereNwGsQIyVPk4wI/oGrBlAC/XwBDgYkLo8MkvVLdhfZQjFXQ
GTOuk/FtWCLUdQjXVkhboTgXYHjRUY1HEMJe7Z+Kv88Y+T0VJWI7HwATgXLpLcpxQ0BNyDvU/IJlDBIoZPlDwqUZOL1t3ZdIQTVQlmLADpI4gJZ8kyHUNjTa0hNI3BvPYdDvgE+cM3+8X4S0LZt/eaCnKSIvUiwdCpQRhKFs4/Cij+SAUoFNLAQUsFIhSoUmFLhToPWWyQikU5hIH9IwjtMDh/g9h3w9nI3tIy8kwh2mQgGjM9Pn9WwugO1Bsjcz
PnDtXclJ4CTXalIECLXLdLmg1020F3C7XfcNZSjwvdLddTwkhx5SiU6zLMzR0+fz/D1vVh3h4b0rhwlT4TUjwqBy0q5JuTugO5IeSnkl5LeTFHSPwiTl/TJP5lQ4AKOzQv+HBX59dgX4DEoxCTlUiI+PMhWVlJPH/BmYB2HkJc5MIcrXQEAQZnAYj7U/GJQzCY08wwy5TUmJwypQ/DIGS89IjOEitPINKM8Q0xBJqDRgujNkiGM+SK9My47BN9N+
YvBMFj1hdCAIRdCNNPmpAEIX22S6XY3iikDkm4SOTi05nw0yEvLTNs4IOZfVXtv9bWNci0mJXieVAVDiWcAGsimSay4UWrNGw2s+TR7ZyZbrIUTryUXRUTnYhANdjfEmxEGjPDfY3iTEk5JNSS5okqOd0YQY0L6ZKs1GLjQ44nmjOQ1YHAxdkcAnVJDiM47uM6jdo7OOSRNEpHILiUciihlS5UhVKVSscsOKriH4AtlFJ+mMrDsSeadghJ0ZqJfF
uR8Ud/y7jVEzxPvTcoAJNCSTo9uxCSLosJIRTe/KePwA7o2eMeiU3CQCkz+gQFOBTQU8FMhTHQaFPzBYUxCJ3iMkl2F9gH+OFH8MFZUykKSdgfWAmQdkdrFVVTKeczMIkgXFE+RHYaAmvQIgz4BeYAQHtgdsNxBIV6zkM2ejYjBsvH2AT3UsmK9SEacbN9TNTYZJIzA0izODSKMtyAWypk2jLuytQ1bLmSmMqBS59lfHbOzihYr4D+8yVcMy9VKE
vCytC9mP/G1xuXKez7TRMotIP020/oLRTCcbtJYsC00oD4Svso6B+zeVC7Aekg8x1HSwgOHvGRwo8hlmL514e2ntjlE4Oh7j/EhKMRyfqL2OyBUchJMtyUk0xOxzbED4AzxnwDEHXykgYXJF5ScvnKzEi+IFCpylTGXLhzjQPaMZyj84ERPyoAfYyfSX0qBTfSkGcuOvyq49GT6RcUcyTgN4Mu+g2j3E2nJ2i/8+vP7ilcwLLcQR4nAo1ypYBqG1
yZ4h6PlylfRLIkB0wRIGYBxgTmHmBuYBZOVTP0/LOfASVE2EwYQJGLFpCS6M2U1gGyXNIqS3pQ7Ejy2TTlDvQbUwL3es48wUIJiOkl1NFCsMkbN6SShH1LvMps6BJmz88ubMLz6fOJ2QTpk5bPLz5gyvIKd6wFjL59IwcrHugG4rZMwtK6Owvby6ye/CoJLsoTNA9rssTKg8JMioGr9a/ev0b9m/QYFb92/Tv3hSJ43v3UzrIzTNsjXObVh2Yx87
hMMzEw6+2tdyAIgCMA1XYgEaN8AVAGSNHAlI2UBPDFgKJS0iggA6MsinIryKOAAooJJjqOzM/tFwxzI8tnMwvMEC3MzxA8zbXDrw6KDwtlNisogfdPbtuUub1KLUEdIoqLlgKovyLrAOotSDIsgCOvSgI29PiypU/XPQA/Cuvw4AG/Jv2YAW/bADb8WwDv2lscsj5LyzSQzJIgJgQL7E7pPgawi38rgAFCkl4Cz5GVgKk9VJvwvWLu0kJTKBpIWp
5YVNPvzV2cDhIVv4qd3aTnUpPI4i3UhU1Gys9fpKzyG4YjKq488wAOVCmYqjLDS/SCNKMKDQKNJTImMx0BrzvIAWPrzGgmag7Sjs+wqpKnC7SD+Bv8H4BW13CifP5t5fW7KHyqzVWPYTeQlLzezsUqUXciUZA2O3wa1a/CT5zgb4umpo5AEsFwgSiQm4woc/2iUTJOWHP3z4c3xCZzj8nRMO8RoxQLGiVAyaLUCTE6Ap5zLoNZFQ5WxDznNLp5c0
xFy/YXyUuwf0N6U2Tv8jxN7iGc3qMAKSnDAG1KhyGgroKGCpgu5zK4jpD7YAQJ+EQ4h1YnJfyXcRPicTU5S218xpct0q6ivE/aLpSCClXPwK1c5XObTzi6aBILokxZ3IKLAiACMALgRvzYBEgXOM2BOweYHjp8wKAA6BX5RYBOKSSra3xIii5wJrw1qekpJ0fMBkwLxx1XZFRB1RXlHQNu3I4HmQF+CQifgHpCIKLRDsUlAiI+cfziQzZCmEqvMo
S4mKUKekoGzGzKY9Qr9Sc8lEpgTtC8jPUVKMyZMZ9pDdmPQToAr0zbALC5ZMyTxMV4pqCmbIUgtCglNl0fZbOXti1MSLDwt30B8phOiKHs2Isq0FVYPMSLCPZIrA9lIUEPRCXyd2NJTODeYNuEQKYgESAQgBACBB5ge6E0BrgRYJNhNg4gGhQsGDCDQpDgn4KIqLgggGwp9ie2gIpDwzxISyDvdAEuSmYUsCbBuYTo3zAWwTl1GA2AegAFhszTn3
sDlHSg1Nsg8d4CKyOQxnHOBXc1BV+1bOVTAqxLgOH3Ayig1rGDgM8fbJ/SwM/2yHcXCS8HDgrgNFljzKDAULaShQ+Qu3LXU3ctTy4SvpLULCg48uRLFFUjOfMdCy8qLzMSxbJxKy8vEvvLOYr0zqBiS8fQDNynVjOogw4IvmdhfST8q+BM07FFdgrUq7JAq2SwUtLT1iiADbAUjFsGIADgOoCEAm0zLyiKlYmIquooKv9Ht5Xs8V3eyWzPXMoL0A
AqtwAiqkqrKrmCt/0PhqVAFE4IbxLFgPQGTTFEWZsCFDUblcICpOUxlKU/yyIUqyQsmo7U6ytaSmI6PTkLISx/0AThsvcqXd4StysgSNC2mLPK0S8ZIxLry1mNvLXTCvIfL2fX6M2zqXaNI7sHExvH3QQlNvLpcaStlz39DgGjSbogKlkvA9sqsCqqqIKmqrNQ6qqUkxTnq9LxSK6AxoEQATOcdIRqkahovnTeAZoqpT+Atotcz/LKBxEDPMplO8
zJAqK2ddUHfzJPCKgLip4q+KhAAEqhKkSrEq2ACSqCzRi6+0RqK3PQMvSNvGLOWK4spNxaqOK8EArcDgUgAOABK7mHoAeAQgE7AXYDkHGAoAYYHmBss9spFgpK8mogA+q/mU34jgMDmAwmS8GOc4YQZ2VOZ0cBfA5MW6TAhM05ytFkLQNYpavITpC1aodTmI/rPsrtqobPndnKlQpJ9Dy9yuzzPKnU1Oqxk+BP8rLqmjLZibqkwruqmM4OOztR9C
mzKdds5hnDLNCN5A2TXgTNK354dNjABr80/AMLSQa8TKnhZdYzk0BgQUsGIA2y2vO2d5bVtJIDsPKCr3wGbIpFS9YapqoQBYk9AHLrK66uo/TeqhakRxYYg8Q8wZMMrOc4yMdURBBzalphmr1cGs2ZCfbLmwQzBSHkuaSXavrITy0M+BCf9MMnLh9r9yg6szyjywOumygnc8tp9dC0NMCqUE3ErQTbqsKvZ8eKXmM8UDQ5hjCCz2D6scLq6JukwD
tIDOXeZ20TKr5dLI++pYS0pYPnzxZnJyPjD4Km4WMzdIYIAYcAACiIBWQAAEoSi6+yQbajNBs/AoALBrJSmixdNaK/K9ovxqrXaByJqN0iQN6KpA3dMGKAsioBTDsAMWolqWwKWplq5axIAVqlalWs0DgsnBvHA8G9BsIbuaqLMMCOGbb2AjVih9Pg8WwMR2YBqwBAHaQ2wFoGeSmwIwBaBhgTsDYAmYKmFAMNaj71QVa3L4EVY7pTXn2S3BFVhb
RTpE2QT4g8CpOtqBCbEDtrPnCIMKzlpNdAIRNUdctsrNqxPM9rk8zcvBceI3DIzz/ao6o8rz6oQ3pjfKvOwCqS8qOvoyY6p+qYzkax6qTroqlOsPJc0U9joINk2STbzfy67CLQhg5ksLr+84uu8LS6iinzBxgeAHrBcADkCDLsRFX3rrEmfv3Bq8EKCojKWbBqpRC4a5RG7rp4RprgBmm1poHqIDW9FSx7c9VGQMVRApJOFRKAZEZQQJC9GwgKkh
7Fk0zUXNOwY3E1eohj/G9aqdSgm9DJCanK2Et9q+Ik+oDqkS2JtVNZsi8sSaI6gwtLy7yx+uequY7QsTr27IWILYwvNmSKbTsqhLZstMBGXzqeXKptZLCA9ksbrB/M1H6aMU2BqxT4GnFKeNnAVAEnS3/SzMxbsWk9PRqHM0hpxryGvGoCtqG7os3TKGrrzJqevDlP2NFGlcBUa1GjRr2AtGnRr0aDGogushD03lIqAsWnFokbFizb1izdvORtLT
hawYG6B5gRoEkBMAZQCQpCAf3xqAWwIZyEA3YTKlgtJKt7yrd8srBh6kYfX/DRZ6TGxuuL3gFjGywaQTt2ucra3nFcaVkDkOl9Harxq5IfGrZgoiN60Uw3Lt6/+N3qdq72uuaj61yruboms+s0KL6s6rDq9CtUPDS764Kofq0m75q9MWwkahwTts7SBirLC3gG+A3GiCXaCyE4dEzTP4WjQHZAKgurIsbsnKooKoquurg88q1SFwBMqC4FGB0SUY
CeBKq5/R6bIG+zHXxYK8f3RbRmxtubbW29tumbTbNmSeLULEFG/Rm3ezAAkKpDrT3AbDLtzIUdm7Qius8mbYEOb4fAayaTI4TevjzY9AbOCboSq5q3L9qkNqib1q3/yDrFQsjKvq/KmNuoz3mlJpWyk2gkoKct4rJv+bGgzlyuAlkFvMdhM0u3jxZEzCtpEzYWiYM1CwalFN6azUS2wNlBmgzKBrjMwVsJaUa/FqFbiG7SApTSvFotJapSChopbC
aqlroaaWiAAYb2Uyms5SJAaVtlb5WxVsNAVWtVvRINWvYC1bBG9mroD0O1kGFar00Vv5rxWwWpLKwIyQEyoUTbUE0B2kKADbASqmAAuAKAfQD2AYAVSCUi1a8t0rcVHDJNuBkpUaSTxg+ZtykSuCpQk/hr44KhcbTUNxsFwPGl1tnlvGn4I9aVq71oCb3araouaz2g+qDbL21QtDab2qBJOqtCqNvmykmm8smDUmwm3SaCnNCp8q/m70p580yoWK
9YE2M1A2SvCEppjMc68lTg4QGiyIViS0mttaqIAKOnmA4AC4DgBMAUgA89wi4s3ANO2iBoVkoOd2Bgb9MuBt1zRO+DxK6yuirqq7x2jJMYVfYOFlRYn0aOKlItFDrUtklmY2H+AgQurP8E2UAKI5Cf0ONgXLnO35x9bj2j2o86dyrzovacgg8ogT/O46oDSQ6h9qACLqtF2SbrqiLtwLPTdny5zYuqlzUT1hQEu7UW8mkIy6O8qrHA0kgKFt7y5Y
rwtQSGuvpua7+2nJX5KfLCdJkB+i/I3y8B06HqJaSGylJXCaUmYHJaCam11gcSa+hrpa/MphqpqLQCTvrApOmTrk6CTRTuU7VO9Tv7g+WolOkBZAfjt5qITITtMCRO9itl14gYYA4AawNZFGB6wdEg4p9AesGwAkSAqnoAagTJo06JAYxogNfpWEDnZPgODHdw/bcbs/QdmcAUx1zG33LtaSQKzsdb7a0TwDt7Ot1sc7AxNbsndDzCEvOb/Wr2uS
DvO/buPrr2nT2O71q+9p8qXmqoMu6wumDsTbIu5NvZ9CASKtKccmsko/qDkPkxdLGbM0IeZs629FhQBTSpsrbAegrtdDRYfAESAo6BACRIEAJsHKrxnBuuRSpnSrRY9o4sHuGbmqjrryr5gdPsz7s+3Pp6rnA7k3A0KpOAya0jOihULwMQT9WrQtmubrusFurZiW6KWKAUdr92sykPaNutIS26bey5t26wmz1IiaES0+oeaI2uJuebH215q96rq8
Lvfa/ez9s3JMqZ8vfcfFbpDkwBkFvLdhi25IjcIZYxPsg7gauFsHyEWyMOL67dDNOQ62umFsy8LQBHsw7P/X/spSMavDuNcCO1cLJaNw3opa9RAnjNob9wqjoGK+vWjvQBOe7nurBee/nsF7he0XqgBxeyXpp6tAunoAG9zaNyZ643FnphM2etYqK7MqR0HwB1IUYEdAOYBCiRJlATmH6B9AWR3oBs+oxt1btO/Vuu1ztOAlzxvgFXu3ArrF5iRB
3CBVhtbtKzREs7bamzudajmwBGN6VmC6z8a+Qiftc7fWzpN2rD6nzr9rDu53pibV+p5svrzuq8q37I667t37bumNIKdNXR7r5ja68Llya3QDkhIl7OFvO4yo+n8qMjK1KVmFM7+vvKg6wGk5J8KJAegCUhugKACgV8wQPpq6Kqgvvuy4OyBo5IyQMvs7rRmqIeYAYhuIYSHTixfxYKLir8XeBAxJ+GtlysCeqFJTU/9G7sLxZhUP8W6SGMKZ7HIP
kqjVuk5p/irenerSDbelPPt7wmg7oKCw2lfsC7I20OpC63muNsMKE22ZNjqCnbs0zh6g9+sPJK1WjTA4W8hixgHDIq0OD4YUOFBIVAar/qrbQarttSHGu9IfGk9M9up7TUO6+1Cy2rA0zh7nyUzKeGQBxotw6salHpcyIBijqgGaG5lJx6Njelpo7Uc2gfoHGB7oGYHWB9gc4HuBs8IIGHht4cZ7os5no4dZGygfka8q5QHRJ8wRoDYBiADkA4B6
AC4GYBNgGoAJA4ATE36B8THga07pK/rsdRFmdzkqx0OZt0XLTmcgLjRkvW1rIV5B6zqdaHa5QcyTVBgFnUHPWg9pc7Tmnob9a+h2fvjtlC4Nt86nen/wC6TuoLsmHr64vO97I00Kv96mM/QCD6F/SfVD7O7DlwqYrHHYeOzyFHdt8HdhuskIwlWL/PAQIOkIYf7oOxX1T7VIDXSMBrgIwHyo8+uruSHwKi4eL6pqaGtRaO67FKHbfR/0cDGG+1R3
NbVmLj07Qp0Dkdz5n+bj0tpPkFkLIUWhjdq8kmSajE6HNB6Ue6G7K9zpn7POxUb2qHeq9qMG1Rl3qp9vKrdw37PeySOsGd+4wr36m7JjMYcf2uKO89KWeziIxanQ1UcK2XbcwOQE0XLqLrH+s4eB6mSCMcyGIe/tNeH1Ad4cicXhiQEeHEer4ZJawBojvR6qG0jqx6eiijvgGXXMEYopcR/EcJHiR0kfJHKR5QGpG/sukcRGhGqzJRGmHIVNIGjA
jEZWKsRyVtl0mYNsG2AoATYFwBRgQYA5AkSasFZB8wFoCu9MqFsDlGYPTspMaB6RDWjj4UGdD5NTrMQYi5VVZWADh0Jd4vVR9YKLRCCnEkWRFGcIOIEGCQUBx0fgrK8sfBK7evburGdu2sf0H6xlUcbHZQ5sZKDTu93vbGJI/QpmGPm6Ot7H73WNIrq5R5YbfrnqoWOe07kabSA7i26kJP5LsOceqaFx7sdg6i+gYycSgQVcfRbPQNEOfJMQglPQ
r9jdYauBlg9HBuB5gfgs2C7gXACZwAWcChvhDgPAHDh6K/0BwpeiZiseC2KqgeFqoFHgHzBugDmHpr4gZwCbBnAGsCbABgBADqB2W0A0wmZm3cB7xwMWVE0JI2I2vIU1YACQf5boB6UTQm6E1I7VHamSS6GOJgYa4n5RmsbYM+JoYcd7BJwjJMHxhtfvMHlJjscknsS+Ns+aP2vsYQYK6gw0HGvPD+uTwgud/p/qfOJKt4yvhj5l7Ze+2BjdGAe0
Cqern+2yK5KPWVaV5LGqtcZ8QkK6yf6iYujTwwq/yeYGwBxgBAHVhxQFEGwAXwIjBCA1kTQG2RsANClenHpt6HmADgeYBRBApxiqOJQp1ivdLSKcAFOhpSOADgBTQGGF6hoAPEEyAWob2DWAGAQgHBT0SPevFMwSAme/b3qKP29i/wfQFNAkgwJrQz+oEQELh0wMmdxmA2zifBcaZkmdPyyZpEnJi8MqJtZm6ZsmYpnBknqfwpaZ0mYyABZrytRL
MZxiDZmQCsmcGAC8gj15nRZ/QF4gdRwoCVn2ZjIGzNQBmlI1nZZrWYXCDx9Welm+ZjIFUtV07cMlA9Z+mbFnsCnMtu7rZsmabBsywePVyIiogsdmMgUeKgUlHM+CtnMKKqyfLAEd2XTE82bLHgLn4O0BYrjQCKud17oBICJQis7cxXrIAIwFCgjRkHgYACAWSGSgLU01D/1PZjgbTa1FWoJ6hMZ+UBIAgBmOGxLK5v8Cbjy53K2IBSwQkZz6UjTQ
GCAqmmuf3relSil5BI6ZQGlAUGn1GoAc2i2FHmR5jpCIbowEE2UBoYRUlIAB53ACHnq0EeYFxV5leamUsGguZNnUEcWYQBylHpTJhqlCSChE43epThEnaEVIRojIDHjIsdGDGk6VL6MEWBEcRAZX/ohlSnnJFSlGnjJEplf+il5qRJ+nUSJGZZRsq0kA5XWUhRUnjZEgmLxO8SJGTnhOUPGcXk28oFmJCForlFWkSRE2kE2nBcrLRIag25juavm6
qQgAgWxOFIzRnr0++cmVaoAubsBMqN72YBmgEqGbnUyZ2dFtiFkTOlIzdMawQAoFUKHqpM5mDzCBggXhYrI6EAER9mAzFDq/7FgAwEaB0gcRffgMvSKPzBeFxgAEXeQLOOhn5cz1Ko48aZaHaggAA===%%