diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/.gitignore b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..7913c9beebc7f8a17a72343401f27a01c881bbcf --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/.gitignore @@ -0,0 +1,8 @@ +/dependency-reduced-pom.xml +/A1.log +/.settings +/.idea +/*.iml +/.classpath +/.project +/target diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/Readme.md b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/Readme.md new file mode 100644 index 0000000000000000000000000000000000000000..a2e19948b9b691d724975e2abc6dfc4956840198 --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/Readme.md @@ -0,0 +1,52 @@ +Hibernate JPA 2 project template +================================ + +Usage: +------ +A basic JPA CRUD example using surrogate keys. + +General: +-------- +This project contains: + +* `src/main/resources/META-INF/persistence.xml` + + Two persistence units offering a 禄drop-and-create芦 + (re-creating schema) and a 禄strategy_none芦 (don't touch)JDBC database + connection to a Mysql 5 server. You may want to adjust both database + type and connection parameters. + +* Important classes (package root `de.hdm_stuttgart.mi.sda1` omitted + for brevity): + +|File / Class |Description | +|--------------------------|-------------------------------------------| +|`...model.StudyCourse` |Class representing study courses | +|`...CreateStudyCourse` |Persisting a study course | +|`...ReadStudyCourseById` |Retrieving a study course database instance by primary key | + +* `src/main/resources/log4j.xml` Configuring the log4j subsystem. + +On executing i.e. 禄`mvn install`芦 Maven will +[generate] +(https://docs.jboss.org/hibernate/orm/current/topical/html_single/metamodelgen/MetamodelGenerator.html) +meta model classes like `StudyCourse_.java` during the +禄`generate-sources`芦 phase. These classes are being required for +[type safe criteria based queries] +(http://docs.jboss.org/hibernate/entitymanager/3.6/reference/en/html/querycriteria.html#querycriteria-typedquery) +not being used in this project. + + +Targets: +-------- + +* `mvn test` + Creating and re-reading a database instance of `StudyCourse`. + Connection parameters being defined twice in two persistence units in + `src/main/resources/META-INF/persistence.xml`. + +* `mvn package` + Creating an executable jar persisting an `StudyCourse` instance to be + run like e.g.: + + java -jar target/intro-1.0.jar diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/pom.xml b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/pom.xml new file mode 100644 index 0000000000000000000000000000000000000000..32f90625e9122f5c3a0d26b5bdec6f8832980424 --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/pom.xml @@ -0,0 +1,183 @@ +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <groupId>de.hdm_stuttgart.mi.sda1</groupId> + <artifactId>studycourse_surrogate</artifactId> + <version>1.0</version> + <packaging>jar</packaging> + + <name>studycourse_surrogate</name> + + <url>http://www.mi.hdm-stuttgart.de/freedocs/topic/de.hdm_stuttgart.mi.lectures/sd1SectUsingMaven.html</url> + + <properties> + <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> + <querydsl.version>3.7.4</querydsl.version> + </properties> + + <dependencies> + + <dependency> + <groupId>org.hibernate</groupId> + <artifactId>hibernate-core</artifactId> + <version>5.2.12.Final</version> + </dependency> + + <dependency> + <groupId>mysql</groupId> + <artifactId>mysql-connector-java</artifactId> + <version>6.0.6</version> + </dependency> + + <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + <version>4.12</version> + <scope>test</scope> + </dependency> + + <dependency> + <groupId>com.mysema.querydsl</groupId> + <artifactId>querydsl-apt</artifactId> + <version>${querydsl.version}</version> + <scope>provided</scope> + </dependency> + + <dependency> + <groupId>com.mysema.querydsl</groupId> + <artifactId>querydsl-jpa</artifactId> + <version>${querydsl.version}</version> + </dependency> + + <dependency> + <groupId>org.slf4j</groupId> + <artifactId>slf4j-log4j12</artifactId> + <version>1.6.6</version> + </dependency> + + <!-- Required for executable jar generation to avoid ClassNotFoundException: + com.fasterxml.jackson.core.type.TypeReference and similar dependency problems. --> + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-databind</artifactId> + <version>2.9.3</version> + </dependency> + <!-- + https://stackoverflow.com/questions/27412287/junit-tests-fail-with-java-error-when-using-intellij-within-maven-module-after-a#answer-34374834 + --> + <dependency> + <groupId>org.hibernate</groupId> + <artifactId>hibernate-jpamodelgen</artifactId> + <version>5.2.12.Final</version> + <scope>provided</scope> + </dependency> + + </dependencies> + + <build> + <plugins> + + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-compiler-plugin</artifactId> + <version>3.7.0</version> + <configuration> + <source>1.8</source> + <target>1.8</target> + <compilerArgument>-proc:none</compilerArgument> + </configuration> + </plugin> + + <plugin> + <groupId>com.mysema.maven</groupId> + <artifactId>maven-apt-plugin</artifactId> + <version>1.0.4</version> + <executions> + <execution> + <goals> + <goal>process</goal> + </goals> + <configuration> + <outputDirectory>${project.build.directory}/metamodel</outputDirectory> + <processor>com.mysema.query.apt.jpa.JPAAnnotationProcessor</processor> + </configuration> + </execution> + </executions> + </plugin> + + <plugin> + <groupId>org.bsc.maven</groupId> + <artifactId>maven-processor-plugin</artifactId> + <version>3.2.0</version> + + <executions> + <execution> + <id>process</id> + <goals> + <goal>process</goal> + </goals> + <phase>generate-sources</phase> + <configuration> + <outputDirectory>${project.build.directory}/metamodel</outputDirectory> + <processors> + <processor>org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</processor> + </processors> + </configuration> + </execution> + </executions> + </plugin> + + <!-- Build helper plugin to add generated sources to classpath --> + <plugin> + <groupId>org.codehaus.mojo</groupId> + <artifactId>build-helper-maven-plugin</artifactId> + <version>3.0.0</version> + <executions> + <execution> + <id>add-source</id> + <phase>generate-sources</phase> + <goals> + <goal>add-source</goal> + </goals> + <configuration> + <sources> + <source>${project.build.directory}/metamodel</source> + </sources> + </configuration> + </execution> + </executions> + </plugin> + + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-javadoc-plugin</artifactId> + <version>3.0.0</version> + </plugin> + + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-shade-plugin</artifactId> + <version>3.1.0</version> + <configuration> + <transformers> + <transformer + implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> + <manifestEntries> + <Main-Class>de.hdm_stuttgart.mi.sda1.CreateStudyCourse</Main-Class> + </manifestEntries> + </transformer> + </transformers> + </configuration> + <executions> + <execution> + <phase>package</phase> + <goals> + <goal>shade</goal> + </goals> + </execution> + </executions> + </plugin> + </plugins> + </build> +</project> diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/CreateStudyCourse.java b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/CreateStudyCourse.java new file mode 100644 index 0000000000000000000000000000000000000000..5cc21b890605f7f55e5f32c2887d1a0c7beb978d --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/CreateStudyCourse.java @@ -0,0 +1,46 @@ +package de.hdm_stuttgart.mi.sda1; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.EntityTransaction; +import javax.persistence.Persistence; + +import de.hdm_stuttgart.mi.sda1.model.StudyCourse; +import org.apache.log4j.LogManager; +import org.apache.log4j.Logger; + +/** + * Create a transient {@link StudyCourse} instance and persist it to the database. + */ +public class CreateStudyCourse { + + static private final Logger log = LogManager.getLogger(CreateStudyCourse.class); + + static private final EntityManagerFactory factory = + Persistence.createEntityManagerFactory("strategy_drop-and-create"); + + static private final EntityManager entityManager = factory.createEntityManager(); + + /** + * @param args Unused + */ + public static void main( String[] args ) { + + final EntityTransaction tx = entityManager.getTransaction(); + + log.info("Begin transaction"); + final StudyCourse csm = new StudyCourse( + "CSM", "Computer Science and Media"); + + log.info(csm); + + tx.begin(); + entityManager.persist(csm); + tx.commit(); + log.info(csm); + + + // See http://stackoverflow.com/questions/21645516/program-using-hibernate-does-not-terminate + factory.close(); + } +} \ No newline at end of file diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/CreateUniversity.java b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/CreateUniversity.java new file mode 100644 index 0000000000000000000000000000000000000000..1d8e5854614283122005426fb96a0e4e54257b24 --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/CreateUniversity.java @@ -0,0 +1,57 @@ +package de.hdm_stuttgart.mi.sda1; + +import de.hdm_stuttgart.mi.sda1.model.Student; +import de.hdm_stuttgart.mi.sda1.model.StudyCourse; +import org.apache.log4j.LogManager; +import org.apache.log4j.Logger; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.EntityTransaction; +import javax.persistence.Persistence; + +import java.util.List; +import java.util.Vector; + +/** + * Persist multiple {@link StudyCourse} instances. + */ +public class CreateUniversity { + + static private final Logger log = LogManager.getLogger(CreateUniversity.class); + + static private final EntityManagerFactory factory = + Persistence.createEntityManagerFactory("strategy_drop-and-create"); + + static private final EntityManager entityManager = factory.createEntityManager(); + + /** + * @param args Unused + */ + public static void main( String[] args ) { + + final List<StudyCourse> studyCourses = new Vector<>(); + studyCourses.add(new StudyCourse("CSM", "Computer Science and Media")); + studyCourses.add(new StudyCourse("MMB", "Mobile Media")); + studyCourses.add(new StudyCourse("CRB", "Cross Media Journalism")); + studyCourses.add(new StudyCourse("IDB", "Information Design")); + + final EntityTransaction tx = entityManager.getTransaction(); + tx.begin(); + studyCourses.forEach(entityManager::persist); + tx.commit(); + log.info( studyCourses.size() + " study courses persisted"); + + final List<Student> students = new Vector<>(); + students.add(new Student("Jill Evans")); + students.add(new Student("Peter Brown")); + + StudyCourse csm = studyCourses.get(0); + tx.begin(); + students.forEach(s -> s.enroll(csm)); + tx.commit(); + + // See http://stackoverflow.com/questions/21645516/program-using-hibernate-does-not-terminate + factory.close(); + } +} \ No newline at end of file diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/model/Student.java b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/model/Student.java new file mode 100644 index 0000000000000000000000000000000000000000..194a0c3db901f8ea842ae268288baf3a64062652 --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/model/Student.java @@ -0,0 +1,33 @@ +package de.hdm_stuttgart.mi.sda1.model; + +import javax.persistence.*; + +@Entity +public class Student { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + Long id; + + @Column(length = 30, nullable = false, unique = true) + private String name; + + @ManyToOne + StudyCourse studyCourse; + + public void enroll(final StudyCourse studyCourse) { + studyCourse.add(this); + this.studyCourse = studyCourse; + } + + protected Student() {} + + public Student(final String name) { + this.name = name; + } + + @Override + public String toString() { + return name +"(" + studyCourse + ")"; + } +} diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/model/StudyCourse.java b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/model/StudyCourse.java new file mode 100644 index 0000000000000000000000000000000000000000..82a082fb475fa9ed96eccc223cd1eba2339d4068 --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/java/de/hdm_stuttgart/mi/sda1/model/StudyCourse.java @@ -0,0 +1,42 @@ +package de.hdm_stuttgart.mi.sda1.model; + + +import javax.persistence.*; +import java.util.List; +import java.util.Vector; + +@Entity +public class StudyCourse { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + Long id; + + @Column(length = 3, nullable = false, unique = true) + private String shortName; + + @Column(length = 150, nullable = false, unique = true) + private String fullName; + + + @OneToMany(mappedBy = "studyCourse", cascade = CascadeType.ALL) + List<Student> students = new Vector<>(); + + protected StudyCourse(){} + + public StudyCourse(String shortName, String fullName) { + this.shortName = shortName; + this.fullName = fullName; + } + + void add(final Student student) { + students.add(student); + } + + public void setFullName(final String fullName) { + this.fullName = fullName; + } + @Override + public String toString() { + return fullName + "(" + shortName + ", id=" + id + ")"; + } +} \ No newline at end of file diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/resources/META-INF/persistence.xml b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/resources/META-INF/persistence.xml new file mode 100644 index 0000000000000000000000000000000000000000..87fad1499be03c470f537f02261197aed31dedd7 --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/resources/META-INF/persistence.xml @@ -0,0 +1,96 @@ +<persistence + version="2.1" + xmlns="http://xmlns.jcp.org/xml/ns/persistence" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence + http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"> + + <!-- + The <code>persistence.xml</code> file configures at least one persistence unit; + each unit must have a unique name. + --> + <persistence-unit name = "strategy_drop-and-create"> + + <!-- + Hibernate will scan your classpath for mapped classes and add them automatically + to your persistence unit. + --> + <exclude-unlisted-classes>false</exclude-unlisted-classes> + + <!-- + setting the previous option "exclude-unlisted-classes" to 'true' requires entity classes to + be listed explicitly. You may want to uncomment the following definition and add more classes. + + <class>sda1.Airline</class> + --> + + <!-- + Standard or vendor-specific options can be set as properties on a persistence unit. + Any standard properties have the <code>javax.persistence</code> name prefix, Hibernate's + settings use <code>hibernate</code> + --> + <properties> + <!-- + JDBC database connection parameter + --> + <property name = "javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/> + <property name = "javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/hdm?useSSL=false"/> + <property name = "javax.persistence.jdbc.user" value="hdmuser"/> + <property name = "javax.persistence.jdbc.password" value="XYZ"/> + + <!-- + The JPA engine should drop and re-create the SQL schema in the database + automatically when it boots. This is ideal for automated testing, when + you want to work with a clean database for every test run. + --> + <property + name = "javax.persistence.schema-generation.database.action" + value="drop-and-create"/> + + <!-- + When printing SQL in logs, let Hibernate format the SQL nicely and generate + comments into the SQL string so we know why Hibernate executed the SQL statement. + --> + <property name = "hibernate.show_sql" value = "true" /> + <property name = "hibernate.format_sql" value="true"/> + <property name = "hibernate.use_sql_comments" value="true"/> + + <!-- Choose Mysql. Set 禄innodb芦 backend by system property --> + <property name = "hibernate.dialect" value="org.hibernate.dialect.MySQL57Dialect" /> + + <!-- Enable Hibernate scanning for entity classes and adding them automatically + but not for hbm.xml files. --> + <property name = "hibernate.archive.autodetection" value="class"/> + + </properties> + </persistence-unit> + + <!-- The subsequent persistence unit won't modify the database's schema + javax.persistence.schema-generation.database.action=none + --> + <persistence-unit name = "strategy_none"> + + <exclude-unlisted-classes>false</exclude-unlisted-classes> + + <properties> + <property name = "javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/> + <property name = "javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/hdm?useSSL=false"/> + <property name = "javax.persistence.jdbc.user" value="hdmuser"/> + <property name = "javax.persistence.jdbc.password" value="XYZ"/> + + <property + name = "javax.persistence.schema-generation.database.action" + value="none"/> + + <property name = "hibernate.show_sql" value = "false" /> + <property name = "hibernate.format_sql" value="true"/> + <property name = "hibernate.use_sql_comments" value="true"/> + + <property name = "hibernate.dialect.storage_engine" value="innodb" /> + + <property name = "hibernate.archive.autodetection" value="class"/> + + </properties> + </persistence-unit> + +</persistence> diff --git a/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/resources/log4j.xml b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/resources/log4j.xml new file mode 100644 index 0000000000000000000000000000000000000000..d0b36bfbf7b46c34d824ba0f6a8217a20ab7fd40 --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_surrogate/src/main/resources/log4j.xml @@ -0,0 +1,26 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"> + +<!-- +Not using log4j2 since Querydsl depends on log4j-12 series. +--> + +<log4j:configuration> + <appender name="console" class="org.apache.log4j.ConsoleAppender"> + <param name="Target" value="System.out"/> + <layout class="org.apache.log4j.PatternLayout"> + <param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%t] %C{20} (%F:%L) - %m%n"/> + </layout> + </appender> + + <logger name="org.hibernate.SQL"> + <level value="debug"/> + <appender-ref ref="console"/> + </logger> + + <root> + <priority value = "info" /> + <appender-ref ref= "console" /> + </root> + +</log4j:configuration> \ No newline at end of file diff --git a/Doc/Sda1/Ref/JpaIntro/ideaConfigAnnotationProcessing.png b/Doc/Sda1/Ref/JpaIntro/ideaConfigAnnotationProcessing.png new file mode 100644 index 0000000000000000000000000000000000000000..428c8d90a0a9db92e52f927472c6b782473efdbb Binary files /dev/null and b/Doc/Sda1/Ref/JpaIntro/ideaConfigAnnotationProcessing.png differ diff --git a/Doc/Sda1/Ref/JpaIntro/ideaConfigAnnotationProcessing.png.marked.svg b/Doc/Sda1/Ref/JpaIntro/ideaConfigAnnotationProcessing.png.marked.svg new file mode 100644 index 0000000000000000000000000000000000000000..7d4cd79cfbf96591b72bea8f9935578c1f03c4e8 --- /dev/null +++ b/Doc/Sda1/Ref/JpaIntro/ideaConfigAnnotationProcessing.png.marked.svg @@ -0,0 +1,1151 @@ +<?xml version='1.0' encoding='UTF-8'?> +<!--CREATED BY XMLMIND IMAGE MAP EDITOR. PLEASE DO NOT EDIT BY HAND! numberPosition="NORTH_WEST" numberTextColor="#FFFFFF" numberBackgroundColor="#000000" numberFontSize="10" shapeLineWidth="MEDIUM" shapeLineColor="#FF0000" shapeDashedLine="false" --> +<svg xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' version='1.1' width='1420px' height='701px' viewBox='0 0 1420 701'> +<image width='1420' height='701' xlink:href='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABYwAAAK9CAIAAAAITL8KAAAAA3NCSVQICAjb4U/gAAAAEHRFWHRT +b2Z0d2FyZQBTaHV0dGVyY4LQCQAAIABJREFUeNrs3Xt8E+edL/6vfMPY3MzFCBICkRSZyKROiJM0 +N5MEG6WlMo2pDd022dMUUTA5p4citpzTPYvp2fTHLiLsLsWwdrpnk922G6uwi5W2ke1ccChNGofU +ia0gVVIKIcEhBBuMudjI+v0xM9LMaGY0kiVbNp/3y6/WmstzlYifr57nGc1M7W1EIeLs+NH3CQAA +AAAAAAAg9b7+9a8TkUajYf43KxyhYMITzzzzDNoIAAAAAAAAAEbBT3/6UyJatWqVRqMJhUKamVoD +Ee340feZ6AUAAAAAAAAAwGj6r//6r8rKSo1Gkzl5yswdP/r+qlWr0CgAAAAAAAAAMPoWL17c3Nxs +NBqzKBQiolAohEYBAAAAAAAAgLEyPDys2bt3r8ViQVsAAAAAAAAAwBhyOp1ZhGkUAAAAAAAAAJAG +EKQAAAAAAAAAgLSAIAUAAADEEBo48V//4jx9s+XpVYvzM9AeAAAAkCoIUgAAAExcoaFzXa+5jnaf +GRjOnDzrptvuXv7Yl2ZlSV97/fyH7/oyF99tnJ4pfhnKzCuYM2dIWzgjP3vo8iD+bgAAALhB/PSn +PyWiZ555Jt4bf/aznxFRdXX1tGnTiOjixYsOh4OIvvvd7yrfiCAFAADAhBU894dm1wfnM+cYlhTS ++Y8/6c2cNiU748pgUOLaoTN/eO3NP9268L7igtBgMCR8mXNz2Zqn86bkZQYvD+LvBgAAgBtGYWFh +YkGDefPmEZHD4aiurmZ+YY7ETCp2kKK5ufn9998XHbzrrrtWrlyJDgMAAEhnQ32f9hHNXLb2ycdm +BweDpMnM1ly7QMNXTne0tv3hT19c0+QW3v7w48uLp59/+9B/dl0hcv/7LjfNeazqNs/LkZfLv/v1 +zJcbWz7Tmr/3zeLJA12/bGi5VvLAgrN/7DpzWZO/oPSrX3tgweQMun6+q6X59RPnr0+99Z4vhf74 +u5PaVbXf0OcMfvZeq+stz7mrlJk3W1f6+OOlhdnoGgAAgHEkgSDF6tWrDx48OG/ePGYCBROhWL16 +9cDAwEiDFE899dSLL7746aefho/o9fo1a9Z88cUX6CoAAIB0llWwcDadPPv6Lw/So6XFN03P0hBR +aOBPrkNv+umW+7+yRNPdcqz18NR5T5oK5s3O+uTT4Xn3rVg6d/rCecNX52R98gnzcoZeO9WnIaKs +/BnTcgYvhYior/Pt3DsffuzWj393zP+Htq6Sp+/N633/ty0nztN0w123ZfqPeQZJkz21YGrG2WOv +veE5l3/7I+b5Q2c+HphbOH1SxuWrQczGAAAASF/79+9nfmFmUtTX1zMvN27cqDKFS5cuheMU4bDF +pUuXYv/1EjNIMTQ0tHbt2hdeeOHKlStENGvWrOrq6nPnzqHbAAAA0pxmRsnXVl542dX5/muO999a ++MDKr5TeNOnaJ50fDVHBsq8tv3fm1cJzXS/8wftR8JGltxUe6fg0OGfJvffMG7p2/ZqucNKxT7iX +gxciQQX2z4ap9z7x9eVzr/75Urf/7YufXZuUk/Wp9zOi6Q9969uPzx36OK/+n9v7iIg0lJWpIbpy +7vzwHV8uv2dOfo5m8NIwVowAAACkMyY2Ef0yrikVn3322S233HLq1CkiuuWWWz777LO8vLwkBCku +Xrw4ffr0VatWvfzyy5MmTaqurh4aGsJyVAAAgPEgY6rhkW8a7jvzx1dfPuI/5jy60Lo85+LlYaLe +I/V/e4S9aPKloawczTDz3/ZQ8OqVy0NDQ0Hey2vXgqIYBU0tnEJX+y8NZmQQhYZDmozrl68R0bS5 +0+jKxUs0ZTJRHxGFKE+3/PG7Wl9/7/3Wpvdfm7P0a19/cFEeHhACAACQ1tatW8f88vzzz/Nfql9R +ceXKlfA+FER06tSpt99+u7q6evLkySMNUhBRX19fYWHhvffeO3/+/IyMjL6+PvQZAABA2gtdv3I5 +mJs/SZOrLal4zO9/+fRn5zPyDVMmZxDNuH9t1ZKpGiIiTdbUuTmZftIQhULMHwahUEj8kk2S+7Mh +IzMjdP16+LgmI2tyDhFdOnfp+lBW8OrFa+GgRub02x6uMT3c193meMV9/FjgHv0dk64Po3cAAADS +l2jxRAJrKcIRitWrVxNReH+KJ598MglBCiL6/PPPS0pKrl271tvbiw4DAAAYD4Yvuv/zF++E5t08 +Zwr1fXSaKG/hgmk5UxZ8aVHO6UDHm8ezjFM1V/o/759+X8XkaZlTJxENeFtffmVm1qw7S2fzX5YU +81d7hAMWoeEQhaMUk7WGQjpz9ne/Onz15qE/d35BpCEiGu7rcrV/OmVeYX7wegYRZedNmZIb7BvA +phQAAADjwB133EEjeLrH6tWrmVkO4f0pkvB0j7AzZ86ghwAAAMaR3ELDwmndHwe8n1DmlJvuXLHq +KwuzB89PurW8avlbb77d+ebrQdJMLlxSMWVyVsY045fv8L76wan3Os7rH39gmvb2++/wtrEv78/P +jgQpiEJSAQvNtOLyR8++0u754N1rhjsXz/jsgwtERKGs3Mz+j9796ASRZnJh8VeeuHOG5tq5EBaO +AgAAjAf33XcfEZ09ezbeG2tqaoLBYHiWQ29v7+rVqzMzM2NOytDs3bv3kUceQdMDAABMSBk5U2ZM +z5+UlUEUGh660n/h4uWhEBFlZOdPmz4lNztDQzR8/fLF3otXrlNG7rSZM/KyNTR89cK5viuhSZGX +X/TTjDnTs4cufHbucigzb1Yh+/uwJmvK7DlTM6+dP3v+2rAmO29GwfTc0OmXnzvw1tUl3/nhEwV9 +5wcpd9rM6XnZGUQ0PHT1Ul/fwHWEKAAAACDKG2+8EcdMCgAAABh3gtf6vzjbL3F88FLv5+LHgAWv +9H1+hbfzlPDl559yDza/PhD5PTTUf/bTfqLQwJ9aW/80STt32uRQn+fdi5RtXDI3e/jacGg4JEoW +AAAAQAaCFAAAAJAEoYzcycOfnzj+5yGijMlzih6zrDblD/b143GjAAAAoB6CFAAAAJAMk256sMq6 +cnZBfk6mhigUHLraf+78lSD+ygAAAAD1EKQAAACAJAle6f3sCh4DBgAAAAlDkAIAAAAAAAAA0kIW +EWkX6NAQAGnlI2+3Xq9HOwAAAAAAwA0lA00AAAAAAAAAAOkAQQoAAAAAAAAASAsIUgAAAAAAAABA +WkCQAgAAAAAAAADSAoIUAAAAAAAAAJAWEKQAAAAAAAAAgLSAIAUAAAAAAAAApIWsBO4ZHLz2YXeX +1/PhmU8/vdTff/XqFbQjQFhOzqS8/Pw5cwqXfKnk9uIlubmT0SYAAAAAAABqxBekuNTff+T1tnfe +/v1txqK77lr69VWVM6bPmDZtKtoRIPIxGRjo67tw8uTJd48fP3zIcfc99z26fMWUqfiYAAAAAAAA +xBBHkOL3v3vz1ZZXHnjoof/7f/+2sHAO2g5A0pT8/Cn5+TffNP/BB+7v67vw69/+9rm/f/bR5Sse +fuQxNA4AAAAAAIACtUEK129e9nrcP9z2w1sWLECrAag0Y8b0b31z7cMPPdjQ0NjX17uy8omMDGwE +AwAAAAAAIE3VeMn1m5c/OX1q2w+3IUIBkIBbFizYtu2Hfee/+HXzf6I1AAAAAAAA5MQOUvz+d296 +Pe7//swz2HsCIGFT8vNrN9WeOvnnN994Da0BAAAAAAAgKUaQ4lJ//6str2zYsAERCoARmpKfv369 +9fVXWy7196M1AAAAAAAAosUIUhx5ve2Bhx7CKg+ApLhlwYJljzz6+qstaAoAAAAAAIBoSkGKwcFr +77z9e/OKCuZlIBA4ePBgfX19fX39wYMHP/roIzQfQLweN5vffeftywMD6VAYp1Wr1Wq1VqfkSxGv +vUyr1WrL7N5x3gXK1UQt0s2ZM2fGddekuqfGXfvgnQ8AAADKlJ7u8WF3V9Hi22fPmkVEx44de+ed +d8KnTp8+ffr06fvuu+/LX/4yGhFAvRkzphff8aUP3V1333PfCJPy2suiIgZGW3u7zag2AY8nJXWU +KpilsafRkhY9kKpaq2qHuPoHiIho7969P/nJTxJs9DF4343eG2xk7TNO34spbN7oDyw+r6nT2/HS +Sx29gkO6FRtW6NAySRFoOdDSW7pmTWkB2gIApPS89vqPX70kOLSktP6b89KnhEozKU64u5cuXUpE +gUDgnXfeyczMXLZs2fe+973vfe97ZWVlmZmZb7/9NuZTAMTr7qVL3V0fpOzPbPVfMRpt7T09PT3p +Ej1IWYMIZ3+Maa2ji3NjSaT+P//5z1VOFvDay8SJO62j/o37aL/B1LcPEXmbm73Rv6Zv74/x5zeu +f0+BiP7fB33RP/KX61Zs4JngEYpAy4GWwGhmWDCzYByVFgDGXFdH7Y86jqcq9Uu//kdn7T96e5IS +pDhz5lOd7lYieu+994jo/vvvv/POO3Nzc3Nzc++6664HH3wwfAoA1Fu4cOHnn59N+pgo/Ge7szk9 +/qqOFGzsAiGjPxBTagf2S1mvfd0NGqZIqDtuvfXWv/qrv4p9ndPKDmYtjT3hBv+abatlgjeq2vbh +dYDFYhmDD0cC+Y3J51cUBnHuunGDignZ/PAi/g8ahBv1+0ZzzK9bMbKgz+iWFgDGzrx1z1rqn7Vw +cyjOvPzapZTkc/bTd+Mc+igFKS4PDMyYPoOIPvvsMyJasmQJ/+ztt98ePkVEra2t/8jT1taGbgeQ +NGPG9NTsSWGpZP6q9ni87KhNtHhbvK1EzNXd7AVarbbMPvJJ1lxqXP5scXgFiOSnjf5KXMvD3BGj +guHZ21xGMneJEhdkzJyxOgWXJPrdqtHWzgx8vPZdMrlHMmcLLcha+Vto6VoIK8+/sMzuZX8vs3v5 +d5fZvbzeia6wTDfFaCuZ7ohp+/btra2tx44di/HuYmJz4TZmXjzPm6wfo5fVN0KMrom9aYJSj5fZ +vbwMktc+/BhFZWNldJQi5ltd1WdBrpHlet/rXFemjf5op8Pn17KVDSp6PIq9I5+73D9cSv/W8d9y +Wq22bJ3Tq3hcqQAyZVZIKkl+w1PU7z527Jiq92dYb8dLB8IEi0J6O1460BIgCrQwJyW/7Bfczt4f +aBFd3NvxUuSIZLKyeXEHRIVjs5A6y+XOnhOvc5G6l19Y2ZLIN5S4vjJllmyumKUFgAloyeKVhURE +PZ/xHkHY1VH7Iyf7w58Ecdb74/DxHzlr/7Hj+FnFW856f/yPnh4iOuthbny+a2RBiqtXrzBPHg2F +QkSk0WgULn700UdnzpzJ/D5r1qxHHnkE3Q0gaUp+/uDgtRQkzA3TKiuTsoraaRUMGKwj/j7R0shM +JWCH6Ow3lNyoUjyzmrdAPGrStbGoSEX51X0DGpW4xBRvQVNEvUwkkMRNd1GotWQvlClsaypdC+7t +EJlgE/0+Ed0dNcc+PEkh3gLzXib8hfSjjz5633332e32kbz5VfRyHI0QV9fEKIm4Ab3N69gDqt7l +atuHF6MwFhWx70OJiQox3+oKFyg0snzve7xe6fTT5vPL7wdx7yjnLvcPl+x7IHpXDK+GjPLH1b2x +BWWWTyq5vioUx52BlgMvdfRyC0FW6KI3r/Ax+y1IrxAR3r6mtPQetdsySCYbdTDQcqAlUMAcWVNK +osIFWg600Ao264LejpeYQIFuxYY1pQXh5S3SO0UEWg68M3MNd0HUcgupksRoKH6pZMos1VyqSgsA +E5R27lTml57XXq/9JW8x6VnPj5mgQzjiEDlFVKh0y/FXPT3xlyRDzUVz584log8//JB/8MSJE0RU +WFjIvMzKyvrqV7+alZUV/gXdDDAaIl+LMWNSwZfHIw95cJPn498/jv99XXivPqZwTqvVym4WwH1d +yQ5JuKn6bNyCH80QTONXURhLI3ed0jJ2ceLMNdEDJOH58GyVuBUVGaNzl6q1OGe2LtKLeZRqYWRX +PHB3Sg/n2TaKtKwwW267QjUFlm4rdd0h7ZFHHjl27NjHH38cZ/PG28sqGyGurpEuiUIDer1ephzq +P3Lq2oeLUVRWGrmGklxOEfOtLnOBUiPL9r5gURh3S7MzHT6/XCKC95Swd5Rzl/uHS/49wBaL3yiN +FpI/rq76gjLLJpV8/8VRDEgcEM4d6O14J8DfQVO3Yk1pQW/HO/xJAQFaITdy7u14J0AFpWu42wtK +S9WueZBMVnyQLR57pKB0hbhwkaIXlK4oLYhr2UQ4XbYGgXf48zSkS6LUULHLPILmAoAJpuvEr88S +Ec0vnEJERGdefvUSES39pqX+WUv9s6VLieis5+UuorMXe4iIpqz8PnOKOyt/y9JvWv5m+RQiosKi +v3nWUv+sZd2SkQUpcnMnX7zYT0TM9plvvvlmZ2fn4ODg4OBgZ2fn0aNHichgMISvZyZQPPbYY+Ep +FQAQ7dLAQE7OpNTFLHYlZUsKdkDGjXCTNT8jPGJ2MiGKRvYP5PAg2CqYFu3xeKNKktzmEifOTnUQ +jd4i59kRS3KeMaBQ68joqlLYAVJD4Ri1YF8xd7L3c8EhroJs6uFuDmcr+DpfTYFT0FZvvPHGfffd +t2DBghT3srpGiKtrEunxxngjgqraRxCj4P4vOkoRs/vkLlDZyNGxgJEspErF51e4ukT87w6/d5Rz +l/uHS+E9wN0vnsUjd1xl9flllksqBb7OURqWi/fN7D3fK9rwsUCvF431dQbZkXTv+V7mhgRIJis6 +2Hu+V3CoYGYBc5D/WvJFbKJqzyzgJyxZklgNFbPMI2kuAJgYzjzPLM1gZkAsKWXDB2f7PyUiouO/ +ZNZusBtqfnr2Ei25aSmRxEaYCrckRClIkZef33ehj4h0Ot3SpUuDweAbb7yxf//+/fv3v/HGG8Fg +kIjefvvtc+fOhW8pLi5m9qoAADl9fRfy8vOTlhzvKzH2a7SkPNAg4akCUgXjfynMGx3z/nxXyG7k +JYmrmjLfxSc5Q2bYq6Jqqub8x6oFL0rBxSgqLYq1lsk2pX0ho6ur6913392wYUPib1uVvayyEeLq +mvgbMN5kVbYPN27lhuDcxi1J25oykY+S0xqJBbQn8p1+ij+/kdkckr2jnLtcXyu9B3jhBKajrE6l +4+qqL3xHyWWRNHve/DPzi4qZFJJBBvHgXjzWjzX2T/ChFpK3iQ72nu+Vmv6RCjFqraah1JV5RM8A +AYAJRLv80cgjSNnpEpLmrft+kZa9zPPjcIBD6ZZEKC3KmDdvfiDw0S0LFhDRww8/PH/+/Pfee4/Z +KXPu3Ll6vf6dd965cuXKoUOHqqqqZs+ejd4FUOPkyZNz5hSmIuWiIiMlaw+0ZKYlHJfs4u0UuM5e +yfzFzGZntLVHfYvsTVVJpKuZ2nE492U7M5ZQqDVxe0B4PBRzyXjMWli22oxOu9fZbC/ySMUo4mwu +yQKnyk9+8pPFixdXVFSoKZm3udlriypaanpZVdfE0YDeVLaPbDBCusVG56MU2ew00bdTKnpWfXGU +c5f7J1T5Q2S0tffYIjtHOK1WZ0+jReZ4YtWXyyIZvnPHDCJidslUnEOhNDTvPd9LugLReDy+QIcu +NQPvgpkFRAUrRuNhqTFqrb6hYpU5hc0FAOPAvHXPli7t6qj95ZmeV19/vpBbiFE4TUtnemjKyu8/ +ujJ6yFJo/JtnjZHNKbo6nu+yrFO+JX5KMykWm4qPH488LVWv13/jG9/YtGnTpk2bvvGNb9x1111P +PPHE5MmTmTjF559/jn4GUOPd48dNS+5IQcIy45DwJPS4ti4Mb/HGrh5J0jeu7DQPo62Rv4dmJDuJ +XMQlofBiEbUVVJjbHZW4MIqQ5AiFVTSFXKHWUbXjLpKKL8SuBTu732m3e0cQo1BVYHWDe/Vee+21 +H//4x7H2OeKaVLSBJfNOSVEvq+maVDRgAu0TLmJj1A4QySqLykZW6n2Z9TLp8vmNM3e5f7jUvAeM +tnbJuIHo+EiqL5dFkvxGKK4wgGCVA/X6/b1KKzyib/f7e+XH/fxUE4tSpOrpnMIiRS/nSLShFMqs +2FwAcOPgVnkc/+XrzM4UVDh1PhHRpXe75BdrFBr/ht2NQvUtZy9+mpQgxe3FSzwnPjz3xRdyF8yZ +M6eqqoqJUxw5cgRdDBBTX9+F7g/ev920JGkpRvanDO9OyS6iCD9JwprIgm/R3eLlyzKHJQvGe3pg +eHNPC7c5hXADTeHT8axOqXpotdZmdRXk5jkrFJbbFUOYRnivDDWBB9XtED11W6HWMjlID4Rj14K/ +p0jCMQp1BY41plPRZnwPPPDAAw88oLpook0OmpPSy6o6X1WzjqgBE24f6TCKyk0jVL83lBtZovf5 ++yNItcMofH5TWWW5f7jk3wOCh4myAc2iIvnjCVRfNqlkekCKyihA6QrBky0CLS919BaU3qNTe/s9 +Ogo/VIOIAi3MrwUzCyiyrWSgJcHnahaU3qMjwYM31CZVMLOAYsQ3ejta2KSYGuiUHkyivqEUyqzY +XCmLxgBAGlr6TWb6w6Vf/5LZZmLe15ZPIaKeV1+PPFKU2WaC/5BRduOJKfMKFW8h0hYyDw1ht8D4 +8WuxN6pQClLk5Ey65777XS2tCtfMnj27qqpqwYIFK1euRAcDxPSKy3X3Pfclc08K8V/NgmcT8OcT +x/vNmaWRd7l4cTa3Y1sc22mGv+Nm/0aP/H1dxjyEIqp43B/5USvDIydiVFDNHoTi1ONqpzjbwdIo +WnivUOvwBYJekCtZzFpEba6XmJgFVq5+AtP6bTab+qKJ0w+Pv0bUy7L5qeqaJDZggu0jN9UjyVGK +GI0s0fvCQ9E7QKT885vaKsv9wyX7HojaFYVdEiJ3PIHqKySVJgpK12xYoeM2UWgJFJSuiechmMzz +M8N7MHDDbyaVcKqU8JINUfoHWgIqN3XQrVih4/aGkNzJoqB0zT3nXzpw4MAB9qmgMUqovqEUyizT +XLFLCwATzZSV3yzSUuS5odrHeFtUMJgtMwunaUU3cus7ZG8hoiWl7AM+VNPs3bt39don5U5f6u// +B/vOH2774S0Jb6sOAJxTH3+cPXnapf7+KVOnKl/5kbdbr9enb03Y9czp9wfuxGkHbsm46tFvTOxq +k+QleIP3OloSAJIi0HKgpTe+aEzsBGlUNs8AAEgBh8ORoXzFlKlTl694/MCBA8yzSAEgYZcGBhoa +Gt9847WYEYpxgNmeTfQYyxvQOGqH8FKbrRhXAwAAAED6yop5xf0PPtzXe37vT3/63595Ztq0qWgy +gARcGhio31d/84JbHn7ksYlQH0tjTw96dXy0Q3gXfyLElQAAJryAL0AFpXhmBwCMYxlqLvrK11bN +m3/Tzr/beerjj9FkAPE69fHHO3f+3bQZBV/5WiVaA8YMlicAAExkvR0vMdtIKG67CQCQ9mLsScH3 ++9+92frKrx8qW7byK1+ZMWM62g4gpr6+C6+4XMuWm4+81rbssXL1N6b7nhQAAAAAAADJ5nA4stRf +ff+DD9/xpTuPvN62davtdlPx0qVLdbpbZ0yfgTUgAHyXBgb6+i6cPHnyj3/8Y9cH75fcdfel/v64 +IhQAAAAAAAA3pqy4rp4yderKyicqHv9q9wfvHz/+3m9/+9vLAwNXr15BOwKE5eRMysvPnzVr1pIv +3bniK5aJsE0mAAAAAADAqMhK4J6cnEl33X3PXXffg+YDAAAAAAAAgGTJQBMAAAAAAAAAQDpAkAIA +AAAAAAAA0gKCFAAAAAAAAACQFhCkAAAAAAAAAIC0gCAFAAAAAAAAAKQFBCkAAAAAAAAAIC0gSAEA +AAAAAAAAaQFBCgAAAAAAAABIC1loAoDx6MSJE2gEAAWLFy9GIwAAAACMOwhSAGAMBjDRIIoHAAAA +ME5huQcAAAAAAAAApAUEKQAAAAAAAAAgLSBIAQAAAAAAAABpAXtSAMBoePHFFyWPl5SUlJSUoH0A +AAAAAIAQpACAsfXRRx8REeIUkCbeOpnxd7/Pv0Q5ypctmnb9b5f1z80fRosBAAAAJBeCFAAT1leb +nySi31T+W/oU6amnnuK/fPHFF1esWNHS0kKIU0B62Pn7/Pwr/TOGhyTPZmYQEQWHKXM4+9lj0/+p +4sLolMpp1Vo9tvZ2m1HuLDX2NFrQfQAAADABYE8KgAkrf/r0/OnT061U/3H8kxDv5a9+9auLFy92 +dnaivyAdDFBOTvAahYajf3IyQz/97tx669yczNC1y9c+/EI6yu+1l2nFrE607Ig5rVptmd2LdkA7 +AADARIcgBcCElZk7KTN3UrqVqs1/vvGtk8HhEBE99dRTorkVAGMuNDws+fMXD01bOCc7U8NeoJiG +pbGHD5McwuNr9fEaqYuLioxoRbQDAABMdFjuATBhXQ8G06cwy5YtY36ZNDnnj59f2dMeeObBRbnZ +megmSDehkEQAwjh/0ur7pxHRlkOfXx0KatBMCXA2O4kqE73Y0tjTgzZEOwAAwA0AMykAJqzrweCY +xym++ULHt/79+Lf+/fj/fvOL//3mF99p+kCTmZk1KcfbN/i3rX+6cGUI3QTpJjQcZH5ys0L5OaHQ +cDA7Y/gHlXMyMzT/fPTCOyevMmcTGaRbtVqrk5zW8DoQwbR9r3NdmdIaEQ9vIYnShAS59Pnk81Iu +ZIwqkGi5S+QkeyN3J3tCphiSF3MHY2SkqpDyV4pz4BUjck4+66izoiaQ7HfhAqHwOZnj/HaIXVNh +1cRtCAAAkJYwkwJg4nj4peqMTDbymJ07KW/GdCIqf/mpoavXmIPDweE31zjUJNXxVFVmhlIQMzg8 +XPrioZjpTM6blD0pO/wyIyNDk6HRkCZ7UvaZy9fqj/75f1Xcho6DNItShIhock7GP9feQkRb/9/p +laXTFxXm/PmLoX94rXeeJqgJhRJP3GnVOi2NPT0WIq+9rMxeZi3iVoMYSUO29h6bkbnMai2z8/bK +9NqtzexZr72szKq1Su6V6bRqrU4js8mm115WVlZGUhtuKuelUEjls8wSDQtbMqdVa+XytzT2tNvL +yuxFglLLFEP64qjskTPxAAAgAElEQVRqSmakqgqipDy29p5GmYZttmqdHq6MsbMWnvXa7R7mhGy/ +OK1ldoqk77Raib1B+ng87yh+pkyAgoiw9AgAANIeZlIATByTpubnzZzB/ORMzQ9laEIZmhzewUlT +81UmNWv6tHlzZin8zJo+TU06msyMzOys8I8mMyM4HBoKBodDoUWz8mofXoReg/SLUQTZH6K5M7L/ +Yd2CbzxYQERbDn0+aWhoMl1nzsYKRcjNibCEh8BG2/M2I7OsgTsVHmVbttqM5PV4+HEF2/PsWaOt +vdFCzl3R0wO89l3OSDJG2/M2o9e+S+qrc+W8FAqpcJbNPTzEtzS2y+avqhhy1GSkXAXpMkg0rNNJ +jT284Idy1l77LiebCpugzaLcL16Ph4yVlcZIYZh75Y5Lll+xO7jC85oaAAAgvWEmBcDE0fbVf+W/ +/MqbG4not8v2J5DUrXv/NSlF+llVMfPLyZMniWjhwoXrDp/I0GQsnpW78d6bJmNPCkjLKAURDVwL +rvnZpz9/+qabC7KI6F/futB58soizRCpmkVhkZ0CYCwqknmhcB0RiTZLLCoyktPjIdG36x6Plyxb +LcJUPB4vWZSGp1F5KRdS9qzH4yVjJf9qY2Wl0W5vdpJFxff3Cq0hoiIjte0sPhnVsJZKi/qsPR4v +GW2VRqkCy/RLZaXRbi/TNoueMCt3PI53lDhTNk18wAEAAEEKABgrg9eupk9hjhw5QkRPPfXUtSuD +Dy4qsN57c2YGNh+E9IxRDBNRiOh07/Vv/uunr/2PBRqi+vYLWrqmCQ2HUpm1+IEWFtmxtPSw2+vx +EHmtWq1wFBt3XonxejxRz52IGXhIpBgJZaSSOB3RaxVZSzx5Q6lfjLb2HpvTqrWWae3EC2/JHY+z +O/B5BgCAcQjLPQAmrODQteDQtXQrVYW+4HtfXoAIBaRvkGI4GBoOaoaDNw9f/vSLwbv+v1MP7P74 +6oUrucND4T01E9s4M9ZoXWv12NrlHlsqXAghvSzCWFQU9fjTnp7ob+Jj5TWC8b3H46WY5RxhMeLO +KN6h/YiyFp1V1S/suUaLKGgjdzyRcAsAAACCFPFos5lKS0ylNlcapgYwfg0PXx8evp5upXrqngWI +T0B6RylCzE92KHhT8HL/1eBnF6/PHL4WPs7+JDlG0ezk7TohNVgWDH49Hq/UKLSoSGnzBfV5Jaao +SLyphLe52SteMJGEYsSZUYywRHNz7IZVmXVRkVGUXjz9wm4bER3lkDseu5WEmcabAgAAwIQOUgT2 +V5aWmPg/Nft9qcnKFwigWwGYIEVweDiYVkV6UQp6CtJHXnBgKHNSeLpE9vDQrUN9i4YuZAqnUeRO +yb19VlIjgMLhrdMa/dBMr73M6uT9Ztkq8dAO21bRl+5SKcXOKzFG2/M2Iy93p7XM7jXatvK3ieCN +mhWLIb44nozijVLY17E5yzesyqyNtq0WXkcROa1Wp2K/8C8mZs/OoiKj/PG4umOrhdeswhQBAADS +2JjtSRE4UFnq39NhNyc7YcP6Q+716FgAoqOWg2gEgLj88MuXdv5+3pWsKcqXLZwy+KMH+uXPO4X7 +D6jYUMBoa2/0cBsQkNHW3l60rswjOP88rSvjkpVNkX16Jy9/S2NjnHmNJEzR3lNk1YZzNwq2fbQ0 +Nlq0VuakpbGnUbEY4ostcWQUb5m3emI3rOo6itrf0qjYL8aiIsGbhctf7nhcLI09jeFdLcjS2G7b +VYaNMwEAIP1p9u7du3rtkykPSeyvrDngI/2mpkObdERtNtO2Viag0Lxez72sSEXMAmBc+sjbrdfr +FS44ceLE4sWL0VAA+IBAwpxWrdWTeHxjvPHay8qaK9vxKFIAAEhnDodjbPakKN+4SUcktzQjalMJ +X0OVeIUIe02JqbRqX6B1M/uL1O3My22tvFtKmBAJx7+vhr8Upep/tvnx3gAAAICJBHtSAADA+DC2 +G2cadLpEbuMmYhARkX9fjYo9MgW38F/699Vw0Q0uQQ3p8cYAAACAcUy4C4WKDTcAAADSw9jsSdG2 +n4kL6HWJhANcbUx8gV0e4muoqmxQMfeh3O7eWUFErm0lm9uIAj4fVRgo4AsQhReeAAAAAEwA4n0t +EtvYAgAAYNSNbpDCv6+mZF/4lW7DpvJEEuHCChuZDSwM5RWGBn+sZ4XoN62vYH/T6Yn8FPD7iQxU +8Xg5udrI11BlauC2zAAAAIAJz9LY04PqAQAApJkxW+5Rbnc3bTQkcic79yFZzDvDgQlmcwoVi0cA +AAAAAAAAIOlGdyZFUqYq6Aw6cgWSW6rOTZHNKVo3b2tlFoYApLUTJ06gEQAAAAAAYCLJSt+itb7S +RuZyImrdJ9hyQm/QEQXI19biW7/RQORra/UlITv9pqZOA7NdBcC4sGzZMjQCgKQjR46gEQAAAADG +o3QMUpSbzdTqInJtKzFJnTeXV1BbKwUOVJYeGHFmrZuj1nck+MwRAAAAAAAAABiJjHQsVMWepg2R +7Sp0G5o77Gb+ee45HRIXx01nEEYk8JgPAAAAAAAAgLGh2bt37+q1T47rOrTZTNtak7ThBUB6+Mjb +rdcrRctOnDiB5R4Aco4cObJ48WK0AwAAAMD44nA4MsZ/LXwBZhdN8ZwIAAAAAAAAABhPssZhmX0N +VZWCrTSJiAzrN5rRnQAAAAAAAADj13icSRG9saV5Zyc2kgAAAAAAAAAY38bjTAoqt7s70HUASeao +0dQ4mF+rm0JN1YmnQonfDgAAAAAAN7IMNAHAROCo0YgU17njuN9dV1zjMG3vDoVCoRBCDAAAAAAA +MCYQpACYMKqbQpzu7Sb3jmJNeGpETN1uN1XX1ZmSXCTe7AwAAAAAAIBYEKQAmIhMdd2hUFM1OWrU +Tahwd3enohgOByIUAAAAAACgHoIUABNWdVNTNbl31PECBbxVIeHohaNGoyne4Q6fZE64HdXFvMUj +vPkQjhrRDA13ndScDe4yQaoAAAAAAAAKEKQAmMCqq6uJursj0YjwvhPd22lHMRM4qG4Khbq3m8LL +RbrrTERkIg3xtqhQOyWDl3eTRKoAAAAAAAAKEKQAmMiKTSZyu7uJiNx1dQ6qbmKDBaY6x3aTcJaF +SPhSouq67eFkAAAAAAAAUgZBCoAbRLfbzcysYJmKi3mzLJSZiovRgAAAAAAAkHJZaAKACazb7SZT +dTGxW2O6azQawXmlJRjiJ3PgsaQAAAAAAJBimEkBMIE5HA4yVdeYiJ0MwXtIaUhxpwhHjUZT083t +SREKNSFCAQAAAAAAqYcgBcCE5aipCccomO0p1D4S1OFwkGm7IxzBiHpCKX+ZiLvJgQd3AAAAAABA +MiBIATAROWqYx4bydr801dVVC5dwyD+xo9hkIrejKfxUkOIdbtHJ8JabopMCpuJiUh0YAUgHwWE6 +/ufhf2oLbnhh6L89P7ThhaHnXMG3A8NDQbQNAAAAwGhAkAJgwnDUaDg1DmZph2CZBvNQ0MhVNY7i +YunVHqa67qZq945i5ro6U3f3dhP/JC+ZGmqSXwxS3dRUzRWrBrEKSHe9A/QT59A/tV4//lHw6mCI +QqGrg6H3TwX3v3p9x38O9Q4kJxenVasts3vR3OnCadVyrE40RyLNl97thk8cAMC4g40zAcbG6Y9P +JTO56qZQSMVlprruUJ2q4+IEu0MKl1dHrhXdp7JcAGOud4CedQ6e65d+w57uDT3rHNy2Mnv2VI2K +MRF/0GZp7Gm0pGz0ZfXY2tttRvRfgrz2MqvTOEHaEO8HAACYGCbUTIo2m6m0xFRqc92YfXmDV388 +ypaBlgEYZcFh2ts6+PnF4ZC8zy8O73ENXh2KMeTVaq1OsjT2MBotcX/TLIpxxFJUhBHpCHg8XrJs +nUCj+hG9H+J876WpiVELAAAEKVLL11BlKi0x1ez38Y8G9leWlphKq/YFkpdRIJDiqvj31ZSYSsM/ +CAcAAEwIfzwV9J8NEoWUf06fH+48FVQIUayze4229p7I1AlLY09Pu83otKqebu5sVj++sjT2pGyW +xo3B6/FMoNqM9P0Qz3svjWMUzYhQAACMd3EHKf50ontw8Fo8dxjKKwxEFGh18WIIvrZWHxHpKsy6 +pNXFsP6Qu6PT3WE3p6KlAvsrxSGV1s3bWpOStq+hKrnxGhgDf3XonegfNAvAuNB+4jqFQuGfudMz +//5J7Sv/Z9E/fGfe3OmZ/FNHvddlB0e77JLfyhttWy3kte8SDJ089rLonRC4SRfsLglsYMPrXBe5 +VjArgz9Jg/2dt8GCXFwk+kr+985eexm/DJFzXl6Jo9MWnOWdliuP8PrIObnjigWQLrNCUuGildm9 +wuZOoPpOq7bM7uXVlDkbe6uLpHeEeNKOwpshqr+k33ukrpcjF8i+V+PtceXGkctIqRYqPhoAADBe +gxTnzvb88Z3fnz710fDwsMpbdCvMOiLy+yKDcL+rzU9EhvIVhvHRTq2baw74iIgq9nR0ujs63R2d +zevLN62vSEbibGvAuPf3Vffwf9AgAOPFh58GQ7xQxA8ss760KJeIFt88adsTs/mnPGfkZlJ4PR4i +S6XUF9mWSguzsCAyYLM2V7b39PSw8yzYQZalsafdZiRutQi7t4CRNGRr5y0fkR1iOa1aK4Xv9drL +ZGe9O63aXUXRBeA0M5sbsDmGB+LcKpZGi9dexiuF8Gy7zcZGapxWrdVpZNJpt1HkHqe1zB6uU09P +o4VdpCB3PFYBJMosn1S4Vxp7pJo7/uozA222PZmG12rDPRGzy5LYEeI3g2TjS/eX9HtPlKBkLwsC +cnLv1fh7XLlxZDKSrYXXXsYlxbQaFoQAAEyoIAURBYPBj/8c6Ox46/y5z1XdoDeX64nI1RaedxDw +BSLH2ShAZBlFZE4Bs1SkssHPLQ9hVliIll1U/U9mkC+xKQM/2ZLKBl4sgLl4Wyt3Vwn7UlKby0VE +pN/UFJmmYVi/e5Nu5Bn599Uw9eUqta1VvuKKGUE6eO0VZ/jn8bwe5hc0C0CauzoY4i/sKLk1L3zq +9gWT+aeuDsptBevxeMlYVCSbh2BlgdH2PDt+MtraGy3MLAw5lsbwYMuy1WZUWKMQ2aSTyUB+5nsk +TYkCOJ3UyB+meu27nPwNQC2N7TZjeG6I177LyabCJmiz8O7iQi2258P3eD0eMlZWGiOFYe6VOx6j +AFJllk1KhfiqL2pPtmcj7RGzy5LWEYJ3m2zjy/aXMpV3ybxX4+7xmI2j/kMhfT0WhQAATLQgBfsn +3dUrHvf77vePXx6I+Vg2g07HG+qHf9EZmEF+YH+lILIQHrdzoYq2rZXMRAadXh91lsivIb1EruJk +yddQJQ5DtNkER0QvOWx4RW5xykgyatuvsMpDWHF1GcGYe+xxC/8HDQKQ/nKzib/3xLsnPguf+sB/ +jn8qNzk72wq+1i8qMqreHEEpDCI8qf7K6AKIJoREx1+MlZXhcZ7H4xUMNPl38RMyFhWx80mMlZVG +r70sata93PEYBZAqs2xSasRVfenG5nXwqHWEusaX7S9lCdzFK2ncPa6mcdS91eP9aAAAwLgOUjAu +9PV+8N4f+nq/UL6s3GwmImp9pY035mcPkqvhgI+Iyu3MMoo95UTk39fAG3sH/D7dhuaOTnfTRgM7 +CyO8A0X4lqjIQoNwgcbOCumggCBfooDPJ1cLnUFyccqIMiq3u5s2GIiI9JuaeLdLVFx1RjDmwpMp +0BQA48LieRn8jSd+8m9dTJziA/+57T97j3/KqM1QiDsohRr4IyPRQDPWmIm3mj4lzy0QF0D02uvx +RD01QnSJxDMlvB6PsOT8yfrM7qLcdgThEzLHVRQg+rVMFvE3h5rcExg2p6YjVDS+TH/FG1qL770a +Z4+raJxUfygAAGAcBynyp0y9/Y67ZhTMinFdxePlRET+gD8cqjCXM6Nxbq8KbjXE5rboYEHFnqaN +BmFSsTab9HOxjI1mQaBEtAGEPryvhF6nZ+ICca6gSGlG/IqrzAjSAKZRAIwvy27P4m88cUEz95l/ +ePue//bv1r8/ejFjHv/UQ0VZSmMo6Unkzman8FtoYTBDcRaF06oNb0sQ2ZoguWJM4+B9Cy93i+hs ++K7ws1g5vLULFt6eDfxhZvRxFQWQJpdF/JGDRHIfi45Q2fgS/aVCrLtivVfV93iMxhmNDwUAAIzL +IEVWVrbeePsdd90zbfoMFZczIQlfW4sv4PPzYg3c/hSKmMUO4aR2HuI2g2D2cZB8FGh0stzqkoRJ +T7JIQUbSFU9lRpAU4cd5YCYFwPhy58KsW2dHJlNkZOZMnbu4YOG907SmjMyc8PGbCzLuXJglOyLe +ajNKbS7BrOYXzpQXDPeUdrNwNjt5G1gkbXTsbW5WWQAiqUki3ubm8HKCoiKjKL3IXSpW/jObBUSP +f/nHlQtAiWah0ghzH7WOUNn4cv2lohGU71L7XlXT44qNk6IPBQAAjOsghSYjY/7Ntyy994FC7XyN +RqPyLuZr/4DfxTx8lFvrER5p85dvuLkFDjKYlRHhUIXko0CjB/AqoiFy+bFzHwRPUU1FRsoRi9HK +CBLCf6IHZlIAjC+ZGZrNX82fPUXDX9kh+pk9RbNlZV5utvx/9djtCctEDxUts3t5u/ZxgQvu8QLM +b+Enl4rnYwjHhgqPiYh3cGxfx6YkKoBsxXhfcjutZXav0baV26Nzq4X4z0twWpn5D7atoq/GueIL +H67g3GX3MisJ5I7HKIB0/WSSSkD8uY9NRwivlGt82f5SmgukcJdcHEPwXo27xxUbR/FDoVgLAAAY +H7LivWFGwaxF+tsm5+XHnVXF4+Xkamvd10AUWetBRHqDjihAvrYW3/qN8TyRVL+pqdOwjVseEnWW +TbZhv2u93UyRbTvZiEM8DOs3mhtsLvLvq7EZOsIP+Gh1tVWYy5OVkd8XIFKaGZHMGkEKYQIFwHhU +kK/5P6un7vlN/0dnJR4yevPMTNvXpsyemhFrONveY3NatVarVssd4z2MgXfZ87SujLtGcIWlsdHC +3W9p7Gm0tTd6tNYyrZ29sb1oXdnIvzc22tq3eqQLIFuxIqs2XC2jrV24cKPdXlYWqbSlUfo4WRob +mXGkk3cwnL/c8ZgFkCiwfFKJNVdcuY9VR/DJNb5ifwnfexblBNm7+GWTe68m0OMKjWNU/FAo1wIA +AMYDzd69e1evfXJ0Mos84aJiT2SoTxTYzz7Dgse8s3NPOfkaqiob/KTb0ByZWNG6OWp9h2H9oeb1 +ei79cOISV1K5ndtvkrlYv6mJnZHB5iUqG4c7K1HIEWckvF23oblpI0lUXGVG0uWHtHP641PZ2dLP +CRgaGhq60q/XKwWfTpw4sWzZMjQjgKQjR44sXrw4gRuDw6F3P7r+5ofXPvzk+tWhUG62pmh+1gPG +nLt12UpzKMYVp1Vr9SRtlA3p0xFOq9ZKE2RYjncpAMANy+FwZIxmfjq9gftFMPrSbWwWj6vDO1ZI +pCJa9cBGKCRU7IksCWGvFDw7Ix6G9Ye4x3CE6bmSjDCjij3ilOWvTF6NAABALDNDc68+e8vXpjz/ +vRn//kzB89+bsdUy5cGinAkToQAAAABIc6M6kwIAwjCTYlxx1GhqHMyv1U2hpmrBCRIcGWGC6cRd +V1y8ozhti6ck4ZkUNwJ8Rz1BO2JCdSzepQAAN+6f3aM8kwIAUj+q1GiK69zjZ+g/HkrrriuucZi2 +d4dCoVAo1FQ94mKLE8QbFwBGwGsv02q1sbbdBAAAGCey0AQAE4e7yeEmIkeTu67ONDpZOmo0jmq1 +42ypi4uLTenerN1uN1U3CVt0RMWWSnDsewduFJbGnh60woTqCKOtvceGxgEAgIkCMykAJg53k8Nd +3dRU7XY0jdbsBIfDMYKLq5vGwzwCd3d3cosdlWBa9A4AAAAAQBpAkAJgwnA3OdwmU3GxySSKUjhq +NJoaBzlqNBz+YgXls0TsIpLok+yN3J3sCbejmnd1eOMFyYu5gzEyUlVI+SvFOfCKETmnUMfiHW5h +ucXFFmevVELJBJXrLltm6XYTFVKxwZk7+Uek2y3qMtFSHWEBIqWP2aEyJZGuslQ1VTY7AAAAACBI +AQCjy1G3w22qrjGZaqpN7h11jqjBcQ01hUKhUKh7u8m9o1gwQlQ466jRFO9wVzdx+ye4dxSzw8Dq +plD3dhMzsSAUCnUzyxdMpCHebguOGuZq6YtFJZTJSFUVREnVmbq5K3l7VEYS6mbKyEyIUKxjrHKL +Eub2mujeTuIKyCcYs+7RZeafKt4RbvJQqKm6uNikpsGVyx/qNtUV72DLYKqpNgnnZTgcDjJV10QX +vnv7dnatUexKxS4Nr8rS1VTZ7AAAAACAIAUAjG6MwuGg6ro6E5Gprq5acmkFO7o11Tm2i4acsmfd +dXUO/uMnqpu6t0uEQIQZhQfE1XXbTeR2q1ncoCYj5SpIl8FU191UTY46/rfuDmriD9oTqKNSFbhg +TZ1DbSoqCiAuM//u7m4uXMDeneBSFGH52TZmid9TkRiFu67OQabt3Vymprq66qS0qqjKstWUbnb8 +gwAAAACAIAUAjHWMopobEFZHRSlMpmLei+Ji4d2yZ7vdbuFJiS/VFURlJEtFRspVkK0OFZtEkZJw +OyWljoJ0+EmbiouJurvdyai7uMyia907ike+zCGqGKaaapOgAOES8eZRdLvdguBB8lpVWGXZako3 +O/5FAAAAAECQAgDGNkbBW5hf40jOronu7u6oB1nEDDzw9geQ3bohKRmpJE5HOHROWtbu7m5h3dVW +Xk0BRGUWnqvrZldTxNXkaoohjhmw76nIrB2GxF0jb1VxlWWqmXCzAwAAAACCFACQwhgFt/g/sh3E +yKMUUpMBFJ9N4ajRhDcSkNo/IWkZxTv6Tn3WpuJiEnWCur0gklIANuOmaoragiOe8itmUc2umxHM +2iGSnC6Sog6NrqZMs+PfBAAAAAAEKQBgjDCr8oXrASRWfCQiaqkEuZscbtnFBw6Hg0zbHYKNBFKS +UYwGETzdJHrhQWqyLjaZEmvyJNa9uql7u0l5jQn/pLvJ4VYof7dbkE513XaT290tjFEUm0wk9cxb +FZWSLUlc1Uy42QEAAAAAQQoASEWMQnJEG/7ee0RMdQ7B4zEcNcU73KbtddwuicXFgnUlwhGroyb8 +eAipi+PJKN4m2VHN1txdV1wjXJuQsqyZzSX58xi4R5uMrJFj1bWO/5gTR90ON7fMIrrBi00mimxe +Ke4fpvzFgpYTFrSm2uSoqRFExEx1ddXEf9SKo4aZ4aBcKcWSxFVN6WbHPwsAAAAA41QWmgBgQsQo +oke0zFyKJnfdyAZsprruUHGNpkajYV9v7+YtYahuaqrW1DAnq5tCTXXdTW5NTbFmB3fp9upit9zF +1XFkFF+Zt3fXuYu5hKKziq+O6lU3hbrriovD6RBVNzWNvJFj3Ftc7ODlKHyihqjBTXXd3RQpYHVT +qMmhqeHd2r29uHgH233is2yUYscOtzAiFlXr6qbYlYpRkjirGd3sm/APAwAAAMD4pNm7d+/qtU+i +IQBG2emPT2VnZ0ueGhoaGrrSr9frFW4/ceLEsmXL0IzRHDWamu7E4xugyF1XXLyjuCmU4FNOR8+R +I0cWL16MDgMYQ4cOHUIjAACMO1VVVcwv7e3tJ0+eTG7iOTk5d9xxh8mk9He6w+HATAoAAFBHbtYO +AIDiX7oAADAu8OPLJ0+efPLJJM9muHz58sGDB5WDFITlHgAAoI67rnqH27TdgRgFAAAAAMQvLy9P +zWUIUgAAgDJ3XTGzs2V1UwjraAAAAAAghRCkAIAJpbopFEIrJJmprjtUh2YAAAAAgNQbN48gbbOZ +SktMpTaX5EuRwP7K0hJTadW+wDjvHuVqohYAAAAAAAAwkYzSTIrA/sqaAz7hMcP6Q83r9SoT8AUC +o1Yw887OPeVp0TupqrWqdtBvajq0SYePCAAAAAAAAIyWMVzu4WuoMgXs7p0Vai42rD/kXj/B+8LX +UFXZQPzQwJjW2r+vpmSfbkNz00bDDfnRiO6OtNPd3Y1/wgCSKyMjIy8vLycnJysrS6PRXL9+fXBw +8PLly8FgEI0DAAAAMAriC1J8+MEf+3q/iD4+o2DW7XfcGfv+yJfzrm0lm9uI2lwuqjCPfTOkw6wB +v6vNT6RPk3bwNVRVNvgpcOAHDSvUT3iZQNKhOwBgdOXm5ubl5b322msHDx48evTowMBAfn7+Pffc +s3r16i9/+csh7HaSSk6r1uqxtbfbjGgLAACAG1t8e1Is1N2m0WhEBzUazULdbXHmay5nJlAEfMyC +hqhtC3wNVabSElPNfnYNQsx9DdgLkrQVBZdaZYOfGbLuqykRFqB1M5tddI78UyWmba0qKujfV8Mk +wmUkc5coca54vDJva+U1BZdO/AzrDzFrXnwN+2Vyj9SarYsga+VekK4Fmw6/vmyCVfsC7O+VDX5+ +BSsb/LzeiX6HyHRTjLaS6Q4AmNgRisuXL1dXV7/44otr1qw5evToyZMn33rrre985zsHDx789re/ +feHChdjjbKEyuxcNCwAAAJDCIEVefn6hdr7oYKF2fl5+fpz5utpaiYh0FeakzF9oswlGmNvE20zE +rdzOTB9gh+ht+/cFiEi/qcluJmZjTv5gODymjT5FBp2KGrLpxxKVuK+hSjx+FjRF1MtEAkmtr7RJ +5s6rtWQv1ChsaypdC0N5hYGfo9T7RFRlX0OVMCDSujkc2IqvwLyXKrsDACbOfwszMi5durR27don +nnjihRdeWL58+cyZM4lo2rRpjzzyyAsvvPD0008/88wzPT09sVKyNPawGi3ktZdprU40rxSnFU0D +AAAAIw9SENGCRbqsrMgikaysrAWLVMcZIt94b24jIv2mncnZ74AdylLFno5Od0dn/MsT+F/Fs+NY +w/pdm3RE1Lp5m20zM3Yt38iuVWk44COicru7o9Pdweyy6d/X0Bo5xZVEbWHK7e6mDQZi4iCd7o5O +ya06xIkz17/sTMkAACAASURBVESPqAUFIwr4EgzZ6PSG6Nylah2Ja+zsdHd0cnWJxBrU1kK3cVM5 +v0PZFAzlK/glMaw/xMslqt8Dfr/qAku3lbruAICJY9KkSZs2bXr66af/8i//kv/fuLC1a9c+/fTT +W7ZsuXLliso0LY097TYjOZsxFJeKUaBZAAAAIElBiuzsnPkLFoZfzr95YXZ2ToKZR40YE03Hx4YV +NjLbW3BfyI+QftN6Zvzc6mJGwuxI1S9cosIEXJjxrbgkSRWVeLnZTMTtnhBVbCK9TjBoT0ruUrUO +q3icGerrVjATH7hYQxy1YKdvtLlc4f+lik2CQI/eXK7n58KlIJq0oqbAKWorABhvjh49mp+f/61v +fUvhmrVr186bN+/NN99Un6yxqIjI4/ESUXhWBbcmJDyNwGsvU1ggIjjLO81bWiK4R3h95JzcccUC +yJaZeKWwOvmFEVzida7j58qdY+/ibhNkKV0vr70Mi2cAAAAQpJA376YFk3JziWhSbu68mxfENexv +YucXcN+f2za3jbwS3MYWI4lHhAvWwdtBk5s6IYw7KGQ38pLEVU2dIaWbfQb8PiIivUGnrmo6vX7k +tWAjDq2vtHExDi4GIVdrmQU1Ke0LAJhYfvWrXz399NOScyj4vvvd7/76179Wn6zX4yEqKopsBdnM +7A7JrgZhxuRldi+3RqTR4rWX8cbiwrPtNttWZltJp1VrdRqZdNptFLnHaS2zE3OcSY/NXO54rAJI +ljk6ULGrqJ0toVGwisNImnCujRZyWpmk2Tkm3NKYyF6ZXnsZlxRTFCwIAQAAQJBC3T0Zmbcs0hPR +wlsNGRmZiWUsXEowMikbq/NWUvgatnK/s9mxiw7CP00bDamNGkQnntpxODcPgslXodaRoIY/CbVg +50242vYzx7mtMRJsLqUCQ1ry169asmSLCw0Bo+mtt9666667Yl62dOnSzs5OlQEKe5m2zO412rZG +RvZOJzXyxuTkte9ykqUxPPi3NLbbjF77LmfkrNHWzp012mwW3l1sOkbb8+F7vB4PGSsrw+lbGpl7 +5Y7HKIBkmaOFi8IW1rkrHOWInCLLVpuRidqQmqSY67lFIUZbe08PHvwBAACAIIWC2YVa7fwFs+bM +TTRfX1ur1EYJ4V0MWvc1qJ93z3zVH3kOhUzi8WpltqIwrLdv0hFvcQqXXVuLL1ZJSLzkIWYF/fJx +h6jE2dUQ3FKF5EYotrHrI7gpJAq1jqpdoMUlG1+IXQt2tU7bgX0BiiwhiZuaAsceL0/86Ridvo/5 +P5983ot/FuEGNDAwwOyUqSwvL+/y5cuKl4SXK5TZvUZbu2hkbakUzEXweLzMkpAwY2VleGju8XgF +oQX+XfyEIotKjJWVRjY4IrhD7niMAkiWOYrw/qIiuVCE8LrYSam4HgAAAMbUX/zFX8j9MhJZCd95 +qyH+rzT8+2pK9vEP6DYwGyVSudlMrS4i17YSU/xlMZdXUFsr87xJidPsUxv0m5p4SznkC2be2bmn +nFzbbC4i0m14bn2FQVexb1srtdk2t3XuKSfz+g2GtgO+wIHK0gMkvEuiJOV2d7mKCuoMeiJf+ALd +huao7/zNO+3mUptLVM1y+x6Vw/g424FJPLzxp0Kt+aENXu2k4wuxa6FbYdYdYKMD4rUe8bwrVBRY +lorumJjOXbg0HAotKJw5gjRcW5a0rOjabSaYAG6U3szLyzt//nzMOMUXX3yRl5eneAlvWkLMcXrU +apDoS0Rnw3d5rVqtMGnmf23tPTanVWst09r5hZE5rqIA8cYKRJeLn+FhwWcKAABg4vjFL34h98tI +ZIxhlcrtvLn3FXsiD2sg0m1o7rCb40oq8vyFij0dgkG4LxAgiu9xp76GKmYegXn9RgNvCO3aVsU8 +hCKqeNyAPPJgCF4ARVUFhRdIE1fNsP6Q+gdPxNkOFXtET7VQqHW4UoJekOvBmLWI7GeZ6FoPdQVW +rn7s7pigzl8cEE2vYH5Uj2pbsFRjAsUobpTevPvuu48fP658TSgUevvtt0tKSpKWK39fTUEIIkJ0 +NnxX5EmnPT2ijR24c40WUYgg+riKAsSLd7vTqg3vZiG7owUAAACASNboZKPb2NyxMd5r9nR0CsIQ +HST7MuqIualzE/sr+9gI0WMsYxXskHu94LV5Z6c7agwfX2WVKyh5Y3Q1Sb8pUjVSvtiwnl+LxNpB +InIhezLg90sUOM5aKMQUxOlEJSKRkUyBY7RVXG1yw/LXr1pVH1m0pK89fLjWt4XdTWLLEtcW9pje +tWXJFtrN+zLeX79qVb2Bd8S1JbwJhXn3Yb3cZcyFvtrDh2v1UQXQc4eFxyOH2dvlS+KvX7XKX9u1 +m9jSmHd37TZLVlMfVWxBNqqbS59QkaTLqVjxqEbuWtHCy9fv+sEPtrSEC8cl6JLqzbgrPk5UVlY2 +NjaWlyuFMS9evPjSSy+tXLkyedkWFRnJ6fFw8yCIyNvc7CULs41FUZGRnM3NXptoL4aiIiPZm51k +UR70WxrbbWVlzR4vWYxyx5ULoDIsISgis0aliJiHjBptz0d2xfR4iLCCAwAAAGLJmPhVZPZlFD3G +8gY0jtohvBvIRqwYSFuuLavqqfZwF2u32aDXE5l3dx2uZf6/q6urS9Xw1bVlyRaXnk3qsL4+PM7W +m8164Tf5rhYXc5TItWXJqno/m0/X4dra2vD4mXecGdHXx/Fg2RYmDMLcLFdNcbEP11KMbOTTibtI +MgeVKy5o5HB4IxwxIU24cLvN5NrC3Cndm/FVfNx46KGHLly4cODAgeHh4eizoVCIiVCcOXPm4Ycf +Tl62RtvzgudhOK38rTaNtq0W4j/iwmll5j/YtoomSXCPzRA+D8O5y+5lFnPIHY9RALVRCvs6dq8L +Jh8L8wySoiIjE/IQFJGreVERCbe+iJEFHkEKAABww8ia+FVU/PL/BjIe2iGwv7LmALfPJeJK6czv +93HhAiIiMu/enWBC9fUuMu/mwhn62udqXdyoV19ba67f0uLaze5M4mpxkb7WrGfv0tce5gbt+lpu +EkW9KzKzgMi8+7Dft6q+3lWrclMFl4t2dx02x6ymsNhsqeWzGUlziYokfVC54qJGZk/yQgvm3YfD +v9bW1rvq/T4ifez+ilnx8SMzM3PXrl0bN24MBoNPPvlkXl4e8zjS69evDw4OXr58+dChQ//xH//x +3HPPTZ48OZkZG23tPUVWbXiHCaOtXbhwo91eVhbZf8LSKH2cLI2NzNDfyd+sgtt7Qu54zAKorMJW +Txl3fyRpo6290cPtgkFGW3t70boyD6/AFq2VyVZxHw8AAABAkAIgPUIqdkyjSGN6s1lfX79qiWuk +s/19fj/pzQZxytyIeYV5SzhKEYlRMHfVmvUxU2OTiwQ6YjGvMKupps/vJ3Nt5FK93sAclB7aj6i5 +hEWSPqhccXFphY0sLqvi46HjrPi4UlhYuH///q1bt77xxhtr164tKSmZOnVqf3//hx9++POf//zs +2bPPPffcvHnzlJKwNPb0KIYjbMm7Tfq4XFKKWciflS9zYtm298ifjE6Dd0RtQQAAAABBCgCS3NAh +MdgGIn2UGBYoRylqD3fVurYs2bJqST0R/0v8uPj9PiKFpQ+8KIWrxUXm3ZEhvsRdUqkpj7ljjdBl +qun3+4j8zFYNvItT0lySFRAdVK44c1YxE5doAYhZqb/iqfj4i1P8y7/8yxtvvHHo0KG//uu/vnz5 +cl5eXklJyeOPP/7II48keQ4FAAAAACBIAQDq/eiTfNGRZ28aEIYQdneZdzMj3C1LiBKIU8QMIZhX +mLdsqa+vNetbXGTmZyDx9b3U1/oqRuixRFdTrzcQGeINzIy8uRSbUbbiMRo5vMkEGwBybVmyRTEj +w+6J/EjSzMzM5cuXL1++HP8CAAAAAIyJDDQBAIwMs0WBz6+wfyL/pN/lirww6EWbY4rTMdfW6v1+ +n6vFxVviYNDrhcnwj/t9vCN+l8svWBshW5K4qhld7BE0V+JFUllxxUZmVtE8F56iIkxGKiM8ZBYA +AAAAEKQAgHTir1/FWx7gqq/3c6sN9HoDCYexBr2e2W+RuXaLYMtGfW2tmXdMmC5zhdmsd23Zwo9R +MHfxr3Vt2eIiZiNHPW/pgmvLqnq/vpbbQ0GxJHFVky02b42EYmryzRV3kaQpV1yxkYUBH3H3iHsz +zorDRGdp7OmJc59NAAAAAGVY7gFwQ4u194TcoFhvcPF3JhA8WGJ3i2sLc9K8u2u3WV97+DCtWsVd +bt7dtbuFt6CAfdYEs1lD1Fnidnn0C7eKNO/uMugjiYYfmKGvPdyl37IkfFzP36oyRknirKaoAEqP +7JBPJ+4iyYcpFCpO5t1dRNyOGGTefbi2flV9+Mbd/vApfe3hw7U/WOWP3CjqzfgqDgAAAAAQJ83e +vXtXr30SDQEwyk5/fCo7O1vy1NDQ0NCVfr1eaT/CEydOzJ49O6UljL0nxSjx169aVT+xN0IYiyZ1 +mUf4ZJa0du7cucWLF6OnAcbQoUOHqqqq0A4AAOP0n+5/+7d/e/LJJAcKgsHgL37xC+VkHQ4HZlIA +QJoPqF0u0RM005f4KRlElPijT1JIcQMRAAAAALjh5eTk9Pf3T506NVkJBoPB9957b9GiRTGvRJAC +AKSN0bwJEX/9D+r9+trnxscsCvYBHunGX7+qXn+Yi5Qwe1LwH+cKAJAShw4dQiMAAIxTd955Z3Nz +8/DwcBLTXLRo0f333x/zMgQpACA9+etXMVsymnd3YTw9IuI9MdJxcgcATDRY6wEAMK4VFRUVFRWN +SdYIUgBAmo6saw931aIZkiJNZ3gAAAAAAIjhEaQAAAAAAAAAkBYQpAAAAAAAAACAtIDlHgDjVXFx +MRoBQNKRI0fQCAAAAADjEWZSAAAAAAAAAEBamOBBijabqdTmkjnpa6hSODvKhQEAAAAAAAC40aXp +co/A/sqaAz7+Ed2G5qaNBpWxgG2BTU2HNukSydnXUFXZ4Jc6o084TQAAAAAAAACILZ33pDDv7NxT +TkRszKKyhtTGKUhnSDSaYFh/yL2e+dW/r6bKVX6oeb0e7xMAAAAAAACAlEttkOLDD/7Y1/tF9PEZ +BbNuv+NO9enoNjbv9Ju2tboCG2NHH8rt7g50LAAAAAAAAMB4k9o9KRbqbtNoNKKDGo1moe62kSQb +tbmDYHcJpa0fWjeXlpiYn22tiWbv31fDJVJaErU2RPms9GWm0qp9AbwZAQAAAAAA4MaW2iBFXn5+ +oXa+6GChdn5efn68cYGGVirfOLItIVo3l9pcug3NHZ3ujs5m3X75CIJyIlX7AhV7OjrdHZ3unRXC +PSyUz0a4tlXtI7Yk7o7OPeWJr08BAAAAAAAAmCBS/nSPBYt0WVmRRSVZWVkLFqkcj7u2hScabKWd +ne6dFSMpiK9hv4sq9nC7WhjW70og5MEm0mE3M6/L7c3r9b6G/S4VZ3n8vgAZyleE99cw7+RuAQAA +AAAAALhhpTxIkZ2dM3/BwvDL+TcvzM7OUXereSc70cDdsdFXU2Kq2e8bQUH8AT/p9Lw9MPXmcv2I +EyFDeYWBWl9pi32WhFn7GqpGWCMAAAAAAACACSVjFPKYd9OCSbm5RDQpN3fezQsSSaJiT9MGQ+DA +DxJZoMHw+wJEOoNhRDWRSkRn0Ks6K2BYf8jdYTcHDlSWlphKSza34Z0IAAAAAAAAN7zRCFJkZGTe +skhPRAtvNWRkZCaWiMxoXzV9MjZ90Bt0RAGfYPpDwOdXdTYau3XFnnJybUOcAgAAAAAAAG54GaOT +zexCrXb+gllz5iacgni0H/BFHofhd7XFnmGh1+mpzcXfHsIfiHtehl6np4Cff5uvrdVHFY+Xxz4r +x7zz0CZdIoUBAAAAAAAAmFAyRi2nWw3GxG9u3VxzwEcVm9briYh0egPzvA8iYp6UoeL5nYb1G83U +upnbBsLXUJXA5AXD+l2bdK2beY87rWzwG9ZvNKs4y+PfV8N7SGrb/n0B0uv0eDcCAAAAAADADS0r +jcvm2lZiirziPTVDt7G5iSprbKZSIiIqt7t3ukzbYqZXsadpQ2XNgcrSA/HcJaLf1NRp2FayubSE +eW1Yf6h5vV7d2UgiBl1r+BoiMu/s3FOONyMAAAAAAADc2DR79+5dvfZJNATAKDv98ans7GzJU0ND +Q0NX+vV6pdk1J06cWLZsGZoRQNKRI0cWL16MdgAAAAAYXxwORwZaAQAAAAAAAADSAYIUAAAAAAAA +AJAWEKQAAAAAAAAAgLSQhSYAAAAAgNTJyMjIy8vLycnJysrSaDTXr18fHBy8fPlyMBhE48CYCw5T +56nho76Q+5Phq0OUm01GbcaDt2mWLszIzkTzAIzFfzXQBAAAADC6vPYyrdbqREM4rRO/HXJzc2fM +mHH06NFNmzYVFxcvXLjwS1/60saNG48dO6bRaMbL+/BG6Kkb8+PZO0A/cQ79U+v14x8Frw6GKBS6 +Ohh6/1Rw/6vXd/znUO8A3p8AYwBBCgAAgOg/DCPK1jm9aBRIM06rVltmT/93Zm5u7uXLl6urq198 +8cU1a9YcPXr05MmTb7311ne+852DBw9++9vfvnDhgoqqamVGYErn4IZ6pyWmd4CedQ76zw4ThaJ/ +TvcOP+scPNcfwvsTAEEKAID/n727D27krPNF/5NnzMuEQBKywcNbSLdGGloVDMHhnr1ZNGyQIudF +4uCUdFO1lQubRN4x2iSrpB18bu0pa/45mFjEC4OPjRS4S53aql1py4CUwCjSsoyzW+wSnwWHo46l +kbSHJNw4syEEsksCzlj3j25J/a6WLHtk+fupKZjpl+fl1y3F/fPzPA1wMX8id8fL/uSmKOmnso0c +rZ34aVMeKkTjokbb6XT096UcGhr693//9zvuuOPTn/70N7/5zU9+8pNXXHEFEb397W//xCc+8c1v +fvOuu+760z/9083NTSuNzGQtbcPnq/el9exO669vjwvbdDr/u3/79Xbd2L/9ensh97vXt3B/7v2V +3eObBP9FQ5ICAACgX3/AymTJwa8m/dK//cnNzeY/DuJPnJ39TA57Fm3Fndmvl/LNb35zJBK56667 +PvOZzxw+rLMO2h133HHXXXc9+OCDr732mllBDp73a5tZjs9nye/34/O1m6X18k7rs2+Pnzx7oXr+ +gu4YCsV4ipe315+9gPtzr6/sHt8k+C8akhQAAAD770cvacavNHy3NfxZMTlEMSq6HHfLT2n9kqax +YcR8GLXssHBWM+XYoBDpMJMqDHbpt7acvUc+96XRAMNoWKvX7NdV6sk2qibqF6+Zj62Yy214IZR1 +te+FSdt6ctE7iXZjo86sdcX4/Hb1dn5jl+Nuq+P//+Ef/uGSSy75oz/6I5Nj7rjjjqNHjz755JNm +BZVLzoCfsvOKWsuZTNnBTwdMbyFNQ43vQ/O7yOTjaRaMrm5asytu0P5OSzP/tjEKSze3t+ZT1ovv +0q+1ue2tWd14g+r15p93vePQw3eOnPmvH/iLPz76rnccku/6h/IbB+D+tHQtTP4T0+l/F7opqu03 +rXl4DfZa+owAkhQAAAAXiT/gp3L8Hu2PKP7k5irvEH+tuLkp/l09OSTpL8fdqh9vMuGRcIlflaaO +kDSk1CFuWeVJc0Lrh6bmYZtJUo1DNS8kGx4JU7Od5bi7dW6b2jWtdZCNpEZsJv2UDYvHG0bDqHBF +d1ad80Y/BGbD7nizws3NpL85zrx9qM3pXQhZgas8P92mF8Zts1KXlYveUbQb5wQCDuXvALOZrLjV +Ur3d3tiW/O3f/u1dd92lO4ZC7u6773788cetfDQzmbLyGVDsp/KjYdJyq/ehhZylxU9xV2E0vOLZ +8Mi8c7Wx0eLwdNP7p4uwdHJ7633KevFd+idmt71lz/x/F+qyVMQD/nd+6ANvIaLj733zzKevlO8q +vXBh4O9PxXeg+bUw+E9Mx/9d6LSoDr/VdcJrsNdadYAkBQAAwMXKUiTFn5SsrHYmjuZNNsdCS+fO +y39yzlJS/hOPdIq0xcE/qj5B7zDZ36wV0mqTg3+Ub/0w3+5EdWuVVfuneQeVSyXzaOgVruqO2Cjd +MkolxYOGPyn1w0Ko2/zUrnchZBN7HDzvN++FYdus1dX+oncUbeMsRethzXq9Hd3YDn7V6k/x//RP +//SRj3yk7WHXXXfd+vq6pQRi6ylQ9xnQvOWW70Nr8bH4Ke7+pjW9Q8SbV/XLe9p5d9qGpYPb2+hT +1oPvUgc/7de/7Tvw+u/q8okdo9ccae764PveKt/1+u/qg3l/Gn8Hmt63Rv+J6aIx1ouyeiuah7en +n0dAkgIAAGCPiL/yWeUd4tBPk99llUplcjidJg+M4k+uqlPkmxxOp7hRW7LiTMVPu+0KUbRJ/o+2 +tataq46Moq/Ups2ywjWBMnqacAQCjnLcrQ26lVC3f4RQF6jTCuNeGLbNUl0WLnpH0TaMhOxhrbt6 +exJtyX/8x3+IK2WaO3LkyG9+8xtLl7D5FJidj+v8ntq85ZbvQwvxsfgp7kkYjW4Kp9NaHqvTy90m +LNZvb6NPWU++S/0Bv+5t34G3DJN87Yn/ufFic9dPqy/Jd71lmAbz/jT4DmxzLQz/E9N5Yzooytq3 +uvXw7vzzCLvpMEIAAACgm6rgqRx3u+PusFN34bhyqaRZ9l79Q5bq3+VSiagcHhlRHqRfslHTLBbS +xYl6PyKqh5T7Oy9cL1BmYc+GR8LukTi1fslmJdSdP/LrNMksRAZta1tXJ9fLarRVQZv2x8OZLPnF +pzZ/knfs+D7ZUbRl2YeXX365bZ7iF7/4xZEjRyw8kkzzDncmU+Z5h6yfllvewX24s89Rr8O44zxW +x5e7g1rbRcNSyV18l4pPqNrbvhPHjw795GetxSb+2//4X//PnfTR4+/6afWl2a//mN50TavykUOD +dn+afgf27L7t+luo21uxo/D29vMISFIAAADsVapi2h8Pl0pl8jv0f0JS7TNPL4inOJPtFss3/9HJ +YiE9OLE5mVj6YTsbHgl3U3invx5Lbm5KtYVHwsnNpL+LUFugc13bhkjbtp6FvZNok8HjGmWy5G8M +nt7RfdKTaH/0ox/9l3/5F4/HY3JMvV7/53/+59HRUSstCwQc8fh8lg/I+mm55b16IunkU9zzm1b7 +UHaRUx3tomHw7dmLWPkDfgrPx8t+p/7t0NaJDx7+8c9aLxf9le1df/oX//zG678+9Oa3ve337EPU +muLxB87Dg3Z/mn4H9uy+7fpbqNu6zMO7q59H6C1M9wAAAOiOdrR1OZMpm86ZcDotDS/VHiYfrGux +kK5rbz41Z7KKedHmI8tNCjfvjnGuYpV3SEdaCLW8SMUCdsbXTucoiyGSt61HYe8s2jqPa9lMNpvJ +ymKyo/ukwxtbXyAQSCaT5sf8+te//pu/+Ztbb73V0mOIOD47rOin5ZZbuA8t3UUdfIp7etOqj1GP +X++0tB19PK1+8K01pLtbzj/NO8qlUtbodmjnw1cfvubKoeb6mEOH3nTpu45ffvXH3j7CDR16U3P7 +ey8f+vDVhwfz/jT4DuzJx39n30I9/y9yb/sFSFIAAADsGdWaA+Lge7+05LnD6VS+S93BP6pYYT8b +dsfLDn7a5Gcecbk3+Zj+xisc9A5r7FG8oMNyIV3Xrv9DrOpQnWgYFm7eHWX8ZXuy8/GyND63Taid +Tge1VkCzEg0HP+1XVJcNh7OmvTBsW4/C3lm09bIUpfl5xbOR1cvd4Y3dwStI/+AP/uBXv/rV8vLy +9va2dm+9XhczFC+88MLHP/5xS59Q8SkwmzX4mJm3vM19aPkusvwp3sFNa3DFW68eElvf+HLqrjQr +3zY7ub2NPmU9+S5t3A7ZcLjLHAUdGrJFb7nkyrfZ5G8bVf258m22B2898pZh2wDen0bfgV1di87/ +u9BpURZuRfPwmvar8+pgd2G6BwAAgPzHonJcXHNA+rlmtbV4uD+Z9I+Exem14ooEDn510xkeac64 +VRxu8DSZ3FyNu92ySbp+vd81+5ObyebyB+RPrvLz7ninhXRde7M3yVKzDQ5+ddV5j7tEhtEwKdyf +XOXd7nizO5vJjN5cBofTmZVPX5at+2Aaage/ukqtmg3LNw2FP2kaIpO29STsnUZbm6UIh7PkVzxK +WL7ZenBj6z4EHjo0Pz8/NTV14cKFO++888iRI+LrSN94443f/e53v/nNb1ZWVv76r//6kUceeetb +32r9kTgeLhmuKGjectP7sIO7yGJgd3LT6l5xB786XXI3ipPfCN2URpbCsqPb2/hT1ptbTpxgUe7+ +t+GXX2L7r7dfuvDdV//1vM5LRt97xSH+trddean13+nuq/vT6Ors5OPf0X8XOi3KQvjNWt4u+B1X +B7vJdvr06dvvuBOBANhjzz/37PCw/mrRW1tbW6+9yrKsyekbGxsnTpxAGAF0nT179vjx44PVp3Lc +7c4EVvH+dth3zp8/Pz09femll95xxx2jo6OXXnrpq6+++swzz/zVX/3V+fPnH3nkkaNHjyJKbWXD +I+ESj68A7RdjfMdrHlzYrv/Pf33jyWd++8zP33h9q/6WYZvz3Yf/T8ebPsoMWx1DAQC9k06nB2Uk +RT46xueIfHPrC5rVmXIzo9ECkScuzHlx0QEAYD/qaJY4QB+56qqrvvGNb/zgBz9YWVn58z//89/8 +5jdHjhwZHR0dHx//xCc+YXkMBYCGuKrA9E5/6X1oyPYxdvhj7DAiCtAn+i5JcW6jeDVjf9Ob3tzV +2blCnjyqTET+TAHXGXbfQytPaTc+PHE9IgMA3fzsHXfPO1cbvx2Upp8n8TtU2J8OHTr0yU9+8pOf +/CRCAb38mrwnXnbwj2JgPsDA6bskxUvnN3/5i3979/uufvd7rx4a6mRdTzYyySwmcjny+mRbK4ml +HHl9nnwOFxt2myoloZu2AACwQr0AAubIAgBIynG3uPqiP7mJ3C3AAOrH6R4XLlx47n/X/m3zhauZ +Y1dcIhYiLwAAIABJREFU+XtWT6tWmCkf8YuJqm+yOZe/mitU7ZPz4zV5kqKa+/x09O+qjX96F9bi +PqJKYiKQYMS/Swo8N1OLpFYiDDVnlBARMSczqSl76xhaWPOd0d0LB833z7TWBR4/Iv3zxnE8WQBA +h/zJzU1EAQDwlaDl4Fc3eYQBYHD17ytIX3/9tZLwtPD0v/zmP/7D6jnecQ9VCk9UmhtqT+RqrM+j +Wn+QJRtFUuvC2rqwFvdRPhpaqhDZPV67cm5IrpAnxutrZiiYk5m1dWFtJULLgdBSqxbKR8d4mlsX +1taF1El7bTkwk8etdXDdOO6X/0FAAAAAAAAALBrq8/b96pVf/vTHP3rll7+wdrjP46VaPleT/lkp +5CtSlkF52Jw4OIKIvJFJlmrVKhExN/kYyhWa+YX8mQLZPTfZG3NGFqTxEWxk7qS9trxYkBfYWLCT +mXpkkqVCDrNLDrTvn8mKfxAKAAAAAAAA6/o9SXHJ2y794LUfuezyd1o83uPzUTVXEKdy5BcTVTHL +YMLONHMYrM8jyy8UcjmSRmFUa1Xy+FrTQBg7K25snGhndAuEgwrDKAAAAAAAALrQv68gPXx4+GrG +/nvvOmqzdfKCYm9kkg0UnqhMTtkLuRx5FyZZnaMKPKeYkSG9EMQ+OeVL8GcK5POILwqJRxgiqlZq +RDWeG1OUgVUnQO2hlafGjxDJVqZAngIAAAAAAKCDVEAftsk2NHT03e997/uvOXS4i+bZPV57Ynmx +MDVeyJMn7tMckJsZjRbYSGpdmvFR4LmZ5k7vuIeihTx56EyBfHNi8oK1M0RMXJjz4oYBQ+KrPbBS +JgAAAAAAQNf6Lklx2eXv/AB77K1HLum6BOYmH7O8WOCplWWQy58pkH1yvrEmBVVqNaLWBA2fx0sz +uVyBcuSVlpkgYhmWNC83BdCHpSgAAAAAAAC603dJig9e++GdFsH6POxiIp9jTmY82r2MnaGcOB+E +iAp8IFGVJynI4/PR0mKiKh+FIU4DiY7xzReU5mYmKpPN1TcBGjCGAgAAAAAAoGtDg9gp++SUj8hg +yUw2kor7asuBsVFubJRLsJnUSeVh3nFPtVIjn0c+CsO7sLYSYfJR8ayx0WiBsSNDAQAAAAAAANBD +ttOnT99+x50IBMAee/65Z4eHh3V3bW1tbb32KsuyJqdvbGycOHECYQTQdfbs2ePHjyMOAAAAAPtL +Op0eQhQAAAAAAAAAoB8gSQEAAAAAAAAAfQFJCgAAAAAAAADoC0hSAAAAAAAAAEBfQJICAAAAAAAA +APoCkhQAAAAAAAAA0BcOIwQAAAAA0FsrKysIAgAAaE1MTJgfgCQFAAAAAPTe1NQUggAAAE0vvvii +lRQ2pnsAAAAAAAAAQF9AkgIAAAAAAAAA+gKSFAAAAAAAAADQF5CkAAAAAAAAAIC+gCQFAAAAAAAA +APQFJCkAAAAAAAAAoC8gSQEAALCXynH3yEg4i0Ag8gC7TIi5bLZQuu1x6ZClwwAA9gaSFAAAADLZ +8IiSO17eH63eFw1FxKD/4BEdAKCvIEkBAACg4k9uSpJ+Ksfd/ffr92xY2yan04FL15HeR0zvuoA6 +IXCx8gEGVQuxWJqCweCgdBMAYN9DksK6SmKCG+Nz4j8KfOvvAAAwqPzJzVXeQdlMfz15atrjT25u +Jv24Xh1d2d5HrN/ukz6UTqf7rGohlRZ6n6NII0MBANC1QUtSFHhubFTxZyaPqwwAAN1zOJ1EpVKZ +iJqjKhpzQpq/NS/H3SYTRGRTSFS/Z8+GVZs06yYoSh5xx8uNU6RCxcrU5Ri3RzpS1iTDSQ/KqhXH +tS3foEfWAigr0aidJm3rPPKGrTKJkrXrYh4rTb1f066a0ZiWUo679/38lMasinTIZrPZbK6YQEQk +pIMuW4ts/IEQc8mPb+1qbBC3qSdryPZKVRhV3chRcLOxYOMwV0yQlSAeqKxP3SVrdRl3s+NKhZis +JFlX9IKjdw2MzgQAQJLCwLmN4u9+99tuzsxHxZSEJy6srQtr68Ja3EdkZxhcZdgLD608pf2DsAAM +gHKppJwYkAmPhEv8qjQbRHyOdMfLjTkiSX857pY9TWbDI+GsQzx+c9U538mDprLkVZ6f5h3S4I7G +nJRV3mF+lro9UpOoeXo57tabopANu+MkNXtzczPpb8agbflttAmg2E116FZ5alVj3DZVHDqIvF6r +9Gvv5Lq0j5W83j8JBFTDdrKZLDkCgcGYyBNM1YuzHFEwVa/X6/VijCMi4shGs8V6vV6v11NBSoeU +D8/pkC1UFPengo0NaU46I0WqaRXyvcVZOuUSS9OvupGjCIa4VgbglMsW46TzOeGUy2azhSil17yO +6jLtZmeVuk4JUtn1VFBoVKtpUr3IxVynhPbBAQBAkqKNl85v/uSpHz7/7L9ub293cFp1McTnyLuw +ti7MeRsbvQtr65lJFlcZ9sjDE9fL/yAgAAOQoIi7R9zxsoOfbk0MyGYpKU8NlOPzWfInm3MH/MlV +3lGOz2flexvHO/hHeYf12uez5OBXGyU7eN5v8SzD9jS2NXaLDdKZplAulRRPx/6kdIaV8s0zL3oB +1OmmMnQO/tFmNYZt04mD1cgbXFad2ju4LhZipazXwU/75VejlaNw8Ku6GamByF00cwbB2CxHglCU +PVenKSXLKUgLSDTPCKaKs60Eg2ovF0vPcsKpmMnMC02OQt4eLpae5Yi42aKYHlE2r9O6TLvZYaVS +vkbqf7NaVXCkoroODgAAkhQtFy5ceO5/19bX/unll/7N4imFpcUa+ebiPpNjakuBMT5HlJsRZ4KI +K0pUc5+fkE0PUS0zkY9anTYiOzK0VMGNdWB9/0y2+Wf8yKb4F4QFYL9pjvJ3x8sOflX1bOgPKB5J +S6WyOCWkySH7fbhmbwe/Fi+Vyl38Ft28PeIGRYMUxypOknI0HZffhl4AdbpZKpUVh7bm3Ri2zbSd +bUKp0yr92ju4LlZiparXH5BlKQZqHIUlnMulfrZXrhZRFFQLSHChIGe4l3O5iIpFoZMcBcepmuBy +cXrN67Qu0252UqnyWC4U5BpLYGj27ig4AAAXzeG+bdnrr79WEp5+x2WXf4B1HrnkEtNjK7UakXfc +077UMzOjudrJzNqUXdrAko0iqfUIIyYa+GhoKZMS9+ajY3yOOSn+s5KYCCSqRIxBhqJ5ZHUxNBEI +UaMQOHhuHPer0haICcB+I/vdt87Tu/KhXjMbRHGI3t6OdHyueXs64OBXN/lseCTsHonLYrLz8vWO +1ulmuVQiKodHRpQnm7WtXRw6aJVZ7Zavi5VYaaLhD/gpnMmSX0xW+JP8wOco1G/CCBo/vQvFIpHL +MOdQLBIJIZtNmQCgTnIU2oQC5+pFXebd7KRSWf5CmcPQ27uTBgMAXCz9vnDmr1755U9//KNXfvkL +06OqtSoxrIV5HfkcxQVl+sA3txKRMg/eyCRLtWpVTHwklnLkXWgcbJ+cjxisbqE8ko3MnbTXlhcL +uLkOsOZgCoQCYPDJ19VUPJx2nx6QU5W80/Z0ka6RFmlovFyzt+WbdNPhdMpfBru5qV6CQ9u2HSdm +rNdu6bp0Fyt/wE/Z+XhZzFEEBvydLemQrbnmRGvdCeOHd5er3d7Gcg1Nsskiqrpjp9rnKHpTV4fd +NK1UNfhBKBZ3IzgAAEhSGLrkbZd+8NqPXHb5Ozs7TTb5QjmDw+fxmpwmX2VTk/hgfR7WMEXi8bVm +mjB2VtwIB9aN437xD0IBcAA4nQ7Vk2c5k2lOFXA61TMhNI+38g3lTKasLFm+oQft6TZXsco7pIZa +KN+wR8YN1jlKG7q2bTM/vaOEj0nt1q9Ld9fCP807yqXSwchRpNPEzaZb61gWi+YnuDhO9X7PoiCY +7G1Xd7c5is7q6ribZpUqF7OQv0G1h8EBAECSQs/hw8Os44PXfuT6t7/jsnbHskxrBAQRiUtmCopF +NKUD7drREPK3lrYWnqhWakSM3cKUjWqlpnr1qWphCzgwmq/zwEgKgIPEwT/KO2S/y8+G5Uttiish +hhurJ6jfpOF0Oqi1kGLruNa58jOyYfGvDqeTDJ/fzdtjmbKl2fl4WZq40KZ80x4ZNFi/m1LoZIMk +GqUZtk1TrHHkyUqrdGvv4Lp0eS0cgYAjGw4rchSD8ApSkn6dL3tSdnEcCelU8+WdyrdR6BUQi8nf +diHEXPIpFNJe2bSK1qHqqtPpNAVj3Q8k6KSujrtpXGl6lpNVmg65TrXeoNp9cAAA+isV0Idtsg0N +HX33e9/7/msOHbbYPDvDEOXPFMjn6ayq3MxotMA21qQgKvDcjHE6wyBDYmeImLgmIQIHjPg6DzEx +gTEUAActTbG66QyPNBcwcPCrilkJq7zbHRdXTyB/cjOZGQnLTl0lt7txqmov+ZObq/HWbiJ/Uvq/ +pH8kLG7WLshg3h6rnXI6s/IlGWTVmJbfpke6jLup2k7+ZNK8bcpiTSLfnlHtHV2X7q6FIxBwxOPl +QRxHEUylgraQuDJCMFVPxYopwRZy2U4REXGzxeJs0CW0KaGeCjVPCaaKszHXKfneYszlki29EEyl +9KpOUZqCXc666LSubrppnKYo1l0hW7NSbrYom7IRTBVnXa5TzeDUU2lbyEqDAQD6KiFw+vTp2++4 +s38a9MxPf/IB9thbj1zS2WnVxdDEYs27sKZ8wUeB52ZI2lhbCoTyvtSKbGmJfHSMr06uNF9TWklM +BBKMeLz877KMRqMKWcnaI+Hg0h09oZuzeP65Z4eHh3UL2dra2nrtVdZ0mZWNjY0TJ04g4AC6zp49 +e/z4ccQB9q1y3O2OO83Wb+1/KysrU1NTu1+PEHO50sEiFlcAAOh/L7744srKysTEhMkx6XS676Z7 +fPDaD3ecoSBpuUrKR8dGA4nWtI9KrWZ6FmNnqFJ4otLIaMjPtU9O+SgfbbxPtJKYiBqshSkdKZvl +kZuZWKzhHjyQmqtRyP8gLAAA0IGdryJygMiXXQAAgEFweGB6wkxl1qZyM6PRxASXkG/3Gv86mo2k +4pUxPjC2TETEnMyk2AdCzTyFdyF1MhBalvZ64sJcrjEZRMW7sLayGJqIjo22tszh5gIAAICOleP3 +xMsO/lHkKPQIMVfMVWzM0xCXXQimMIwCAGCAHB6s7vjm1g3T6cxUZk076tC7sLYu/3dmzeQUr9Dc +64kL8iOJjaTWI7ifAAAAoFvluFtcG9Of3Ox4FZEDgnO50rJFFcSFF4KICwDAADmMEAAAAAD0AQe/ +uskjDOaCqXodUQAAGGRDCAEAAAAAAAAA9AMkKQAAAAAAAACgLyBJAQAAAAAAAAB9AWtSAAAAAEDv +LS0tIQgAANApJCkAAAAAoMcmJiYQBAAA6AKmewAAAAAAAABAX0CSAgAAAAAAAAD6ApIUAAAAAAAA +ANAXkKQAAAAAAAAAgL6AJAUAAAAAAAAA9AUkKQAAAAAAAACgLyBJAQAAAAAAAAB9AUkKAAAAAAAA +AOgLSFIAAAAAAAAAQF9AkgIAAAAAAAAA+sJhhAAAAAAAemtlZQVBAAAArYmJCfMDkKQAAAAAgN6b +mppCEAAAoOnFF1+0ksIetCRFgedm8ootnrgw58X9AAAAAAAAANDvBihJkY+O8TmSZyXy0TG+yjA7 +Lzo3M3rGs77gwf0Cxh5aeUq78eGJ6xEZAAAAAAAAiwYlSVFdDPE58i6sxX2tjd6FtfVeFJ4/UyBC +hgLaUqUkdNMWAAAAAAAAYGRAkhSFpcUa+ebkGQqtau7z09G/qzb+KctoFHhuhhbWfGfEsRhExJzM +pKbsJJs/MjPKybcD6Pr+mWzz7+NHpH/eOO5HZAAAAAAAANoajCRFpVYj8o63GezAko0iqfUIQ+JM +kGhoSZZxyEfH8r65dcFDVFsKhJYDM3ZhzkueuJBaCoSW2TlM9wBrVCkJedoCAAAAAAAATAwNRC+q +tSoxLNvuMN/cSkRaocIbmWSpVq0q9jbSEMzUI5MsFXI53B/Qne+fyYp/EAoAAAAAAADrhgazW/no +2Cgn/eF1cw129YKarJ0x2QvQiRvH/eIfhAIADpJy3D0yEkZ+FqA/CTGXzRZKIxAA0OcGI0nBMqph +Ed6FtXVhbV398tECzzWTF6o3lQLsXHOlTIykANin4u4Rfe54GdHpUDaMuMH+kA7h0R1XEAD6yGAk +KewMI72Dw1huZpSbqUVS64Ju/gJghx6euL75dg+MpADYp/jVTckq7yCH8p9dP6of4KEFTqejxyUe +7HgOyOPkxXqaNKhaiMXSFAwGEcD9qjdXsG1gexJ5XD4ASwZkuodnKsJQboY3XkUif6ZA9sn5xpoU +4lqbALugOYwCgykAgLKZA/st4E9ubib9iCcon9HS6T6rWkilhf2Uo0jjEXdXrmDbwPYk8rh8ANYM +ypoUbGTupJ3y0bHRQKI17UOWiWDsDFUKT1TEfxV4+WFtMHaWKFfA9BCwoDmGQv4HYQEYoKRDWH8K +SFk5U8QdL4vHhrPNc3SmPuidpbdLcWqjWOWhjS3luFteaetIZV2tEjvpkXlAVCMc5O00bJVR7XoN +Noyncaw09X5Nu2pGY1pKOe7G/JRdfr6WxuSnQzabzWZzxQQiIiEddNlaZL9mFmIu+fGtXY0N4jb1 +UH/ZXqkKo6obT7jcbCyod7rFwlvlG+w1OVG/jwYxMeyFtXrb/AZfiMnr1LRSvwbNPAvFsheGV1BZ +V/uOmLRNdQWNbyftNVLcUPq3B3UZeb0Gt60FAAYuSUHETGXW1hc8VElMNBeeCCSab/1gI6m4r7Yc +EHcl2EzqpN1q0d6FOW9jPQser/wAADjAGYpwVpoEsspT3N14pM2G3XHZXJGk3+l0EPmT4jQRf1J/ +yoj+WVJF7nhZOm8z6S+3qrIkEx4Jl8SSxbEMygJXeX5abEyHPTILyOaqc968kXqt0q9dv8H68Wwf +K3m9fxIIOJTDMbKZLDkCAQdu790XTNWLsxxRMFWv1+v1YowjIuLIRrPFer1er9dTQUqHlA9v6ZAt +VBT3p4KNDWlOOiNFqtHz8r3FWTrlEkvTr7rxhBsMcTqnWy5ctpek8mc54ZSrda75ido+GsREvxcm +hSu6U+RirlOCcQbJdapZZ72eCrpcXLMQ1ylBqrOeCgrq5rfPTWmuoKzA4uxsrE1HjNumvYLmt1M6 +ZItxxcY1ak69MLw9zG/dDhvcthYAGMAkBRER+eYaS040/6Sm7M1cg3wjM5VZi/vEPZ64sNZ8O2lz +S2Ov9E/xXNlGAAA4SMrx+Sz5k9KzsYN/lHeU4/NZIiqXSornXH/SyjQHw7OkippzJfzJ1WZV1pIp +WUrKcyLl+HyWHPxqo0AHz/t70CPl6eL5nbZKt3bDBhteFLNYKet18NN+eZailaNw8Ks7WXwEdpC7 +aD6uBWOzHAlCUfZUmaaU/HFOXH6geUYwVZyVPeop93Kx9CwnnIqZDCBQPuHusPBgSnoKF3c2h/a3 +O1Hdx3YxUfbAuHBVd8RGGRVTLJLsUZ+CKakrUiGNnolBMQ+qKkehdwW52WKjQC4mDoIw7ohh23Ry +FO1CJw9HMRWkdKzr8QxdNhgADmCSAgAAYJeUSmXyB1oPyw6nU9xIjkDAUY67O5wrYHhWqVQWC1cc +2slyDPJmNgrUGSywwx5p2tlmQIJOq/RrN2ywhTboxEpVrz8gy1JgHEWf4VwudQpDudZAUVAtP8CF +gpzhXs7lIioWBWs5ih0WznEu/Y60bZX5egramJgFRFZ4URBUjZJ3R1VJKMgJp1zaOQiaQsRSOlhb +QecKKrIKbTti2Da9HIV56JQ9cXFm6Z92umswACBJAQAA0CvlUkmxhIJ8aQMHvyrNNNBbnMEwS6F/ +VrlU0rwWQ/kc3rZgnaN1pmvssEd67eygVWa1GzTYWhvUvddEQ5alyGay5J/G6ImLTDavX7NugvKp +koSi2SOlUCwqS2uzDIPqCbe3hVs/UdXHtjGxWLhQLBLJJ0YYVRBKExEXK0pzORSl6BVinjXRJAp0 +eqfTKrMoGbTNIEdhNXTmHWm7lkd3DQYAJCkAAAB6xuF0NpdDaJFND5D2Jf0dvSZTe5ZsRIHyYXxH +VAX2oEedJU46jqdOgw0K6ThW/oCfsvPxspijCGB144udoGisWNBataCrx0ppb2OtgybDuf/p2CnF +E25PC9/BiZ3ExKRw8+7IzmmVL21MBZtvytQbi2KezLFCZ3BL2yhp26a9gh3eTmYd0Y3PjhsMAEhS +AAAA9JDTaWnKhbjKgqVHbIOznE6H6km7nMkop0bIiy9nMuX2Ldc7aoc90p7eUa9NajdqsMGR5rHS +69E07yiXSshR9EGOIp0mbjYdszaYgcQR+sqpBkVBMNnbrm7Fb+F7WLh5m3sYE5PCzbtjmsAoznJS +JkE7JULzxk95ykFIpYX20RDSKaHLKMnbprmCbUOnrFg7lWUXLqu8wQCAJAUAAEAviUsuyocUZMPi +mg3luFs2ziA7Hy83piA4nE4yehI3PMvBP8o7ZBVlw+542cFP+2XP5c2lIRttaNtyeXXZsDhmo4se +aQPSqF95zk7iadhgbTzbxMqw7kDAkQ2HFTkKvIJ0L3AuF8mf7JRPrOmQyesnpAJiMfkrG4SYS/47 +ammvTf5ejcah6qrT6TQFY4rxDN0XbqXNVk80jYm6F2aFm3dH9fSu2JmOnRKkORlcLC17DYbUntYb +P10cR61lNC1cQLFV8nefpEPSfBOjjhi1TXsF299OwqmgIhzN8zWBbXfrdtFgC7UAgOgwQgAAAGCJ +P7m5Gne7wyMjrS1J8dE5K9uofNtE0j8SFnfKNpP5WQ5+ddMZHmnudfCrrXkQDn51lVqt8Cc3k5mR +cIct9ye77ZGy2FXe7Y67R+KWW2IlnqYNVsfTNFamWYp4vIxxFHsumEoFbaGQzUbi2zBixZRgC7ls +p4iIuNlicTboEtqUUE+FmqcEU8XZmOuUfG8x5nKJFTRq1Ks6RWkKagbyd114u153cCJnGhN1AIPm +XS7Oulynmt2pp9K2kNEjeFpWgvx9HlysWHeFbM293GyxNamBixWL1KrcrArjaARTplEyaFs6rbmC +XLvbiZstxgRXoyxZJ/UC2+bWDXbaYEu1AAAREdlOnz59+x13IhAAe+z5554dHh7W3bW1tbX12qss +y5qcvrGxceLECYQRQNfZs2ePHz+OOICxctztjjv1cy/QEysrK1NTU7tfjxBzudLBooXFIfqtcNhT +6ZAtVJzFtQS4uF588cWVlZWJiQmzT2s6jekeAAAAcMBYWbkC9geL6yz0YeEAAKAPSQoAAAA4UMrx +e6ysXAH9SDnfX7WwQF8XDgAAFmFNCgAAADggynG3uDamP7nZfuUK6EPq+f49ndm/q4UDAIBFSFIA +AADAAeHgVzd5hGFfC6bq9f1ZOAzujQMAvYXpHgAAAAAAAADQF5CkAAAAAAAAAIC+gCQFAAAAAAAA +APQFrEkBAAAAAL23tLSEIAAAQKeQpAAAAACAHpuYmEAQAACgC5juAQAAAAAAAAB9AUmKfanAc2MT +izUEohkNPoc4AAAAAAAA7HeDkqTIR8dGubHRaEFnX25mlBsb5WbyfdLWSmLioKUYpEvQ/NM31wIA +AAAAAAD6yICNpMgVtE+/+TOFvmpjNVeoNv73YoRoRj+Vs1tqS4Gx0WiBfHPrwtq6sLYSYcjOMH3X +TgAAAAAAALjoBihJwUYmvVTIqYb9VxJLOfL6PH3TzNoTuZp3Yc5bKTxRuQjV73HKpro4s1xhTmbW +1hc8jcuUWs9Msn3WTgAAAAAAAOgDA5SkqFYYn4/yiwn5CIVqrlC1T06NK4/MfX5CNvtAWs6gkphQ +L22gWPpBmlHCjY1yoaWK4hg+Z7RXo1LIVxiWZVh7LZ+Tz/ioLQXG+FxrZkSzJdXFkGyihKJwk0r1 +djXWbpCqCC39vUmXtf1Sz9Gw0OXC0mKNfJNTdoNLpnshtO2smBysmxmRRSyQqBo2eyavXM9CGWqs ++gEAAAAAAIAkxQ54xz2kGKFQeyJXY30e1e/tWbJRJCXOPoj7KB8NLVWI7B6vXfkL/FwhT4zXx4hP +tnyOOZkRJyzQckCdLOBJnM6QOmmvLQcM11zILyaqds9NduYmH1NdTKgPOzMzGq2JtcR9UskTizXv +wppUeKT1wF9dDC3Zm71QVGrQWk9cSJ20U2PmRWrqD826LJbTqCJ10l7gubZVqDIytZp4UQzoXwht +O+0mB2sirIjYnLeSmJDlKeTNXl8geY8oNzOxSNIuYW19wcPYGXxDAAAAAAAAIEnRLZ/HS7IRCpVC +vtJ65JYdNrcSkTZ6I5Ms1apVImJu8jHyVS3yZwpk99xkb8wZWWg8LUfmTtpry4sFeYGN6QzM1COT +rHbWiaSQy4k16k9Oyeco3ngmJ5LqZSMpMWFBxExFPMa9aJTWtrUtzFTEo99ldRXMVGbOK46MsF5F +tVYlhjWZ2qF/IXZwsNSwtUbEPPHMJFtJLOlFRl4gEVUrNVXfG4UAAAAAAAAAkhTd8Ph8rTUpG8MW +TM+QLeLI+jyy/EIhlyNpFEa1ViWPr/XIythZcWPjRPmv3E1WhcwV8q1yPD6fZuUFn8erecjXSbKY +V9qutZoa9bqsrYIY1k7VSq3jKiyysppm24O1aRH5ABl1s5Wd9XnYSmLCfLYOAAAAAAAA7KLDg9Yh +b2SSDRSeqExO2Qu5HHkXdNdoVMxcICIpNWCfnPIl+DMF8onjCzzxCEPi79ipxnNjyufkjtsmPior +yynkqZWYYHXmFzD2DivqsLUen4+0XdbD2NkuqqhVqya1G1yIbg+uVmqaiKmabZwJsU+uCJP56Bgf +GFsm+egYAAAAAAAAQJKiO3aP155YXixMjRfy5NEZsZ+bGY0W2EhqXXoaL/DcTOu5d9xD0UKePHSm +QL45byt3wMSFOe+OWiYmTdZkTSrw3EwuR16zaQW1SoW8neQpOm2td9xD0cRSxWOXdVm/JVUitpNt +739bAAAgAElEQVQqfB4vFWqVGukOBjG9EN0dzNoZTcRUzW4XjYW1dam6mdEo8hQAAAAAAAB7aWjw +uiQtLSGODtA+RefPFMg+Od8cL1Cp1TTP1blcIZeTrfjIMsbLTFhVXUzklXMN9Gd8KJ65GZZULwGx +kqXosLW+yZP2WrWq7LLY5sbEGfFpv1ppPOdbrcLj81F1cUZ/hUvzC9HdwSyjXquiUshXGv3SNttw +FszcSoTZ6QQWAAAAAAAAOPBJCmlpiXyOORnR+TU4Y2dkbwAp8OpXVHp8PqqpEgr2ySmf+GKIxpbc +TIfvp6w9katpkybecQ/lEoaLINgnp3xUXQw1681HDd8bojrLoLWMnSX5Spnixpt8TD46o8mhEFUS +09KJtaXATJ48U2KawHJAvAtzXqotB8ZGo81cTIGPFtpdCHU72121Vt/nI4ysYQU+kKjaJ6d88sg0 +Vp2oJCZarVLEWXp5Ksuw+IoAAAAAAADYO4cHsVPi0hJV/SUz2UgqXmmsO0DMyUyKfSBUVSYO+GiB +fJNexcP22spiaCI6Nip7/O6gSeLv87VJE5/HSzP5XG3KYEKHpl5P3EJtJq31Lsx5uRlxOYnm3BPW +52EXE1VNDoWNpKYqoVGuUbVsfoflgHjiwlo+OsbnZhrlEPnm2l4IdTvbXTV5m9ftM6PNhtknVzKt +dUm8C2vx5qoT5IlnJpcCCelEO5OXdQdrUgAAAAAAAOw52+nTp2+/404E4mCrJCYCCUazXkYtklqJ +MIPe8YI3k5qy733dzz/37PDwsO6ura2trddeZc3e3kobGxsnTpzAvQug6+zZs8ePH0ccAAAAAPaX +dDo9hCiAuPaEZq7Hgeg5Vp0AAAAAAADoH0hSQCUxvVhjI5Pewe+quLJGq+MT0QL5Ji/GMAoAAAAA +AADQOowQHGCVxIS4AqVvbn2wp3VIGDtbENe5kGDhCQAAAAAAgD6CJMVBZp9cESYN9nniwtrg9di7 +sLaO6w4AAAAAANCnMN0DAAAAAAAAAPoCkhQAAAAAAAAA0BeQpAAAACCictw9MuKOl/uycdlwL9tW +jrtH5MJZXH4AAADoE0hSAAAAEJUzmXLjf3dVNmwpKaA8zOl0OAIBRw+b4eBXNzc3Nzc3V3lHNty3 +2RkAAAA4aJCkAAAAoOx8vOxPJv3l+PzuDivIZrJdHObgV1d5x640yMGvJv17kZ0BAAAAsABJCgAA +gGwmS/6A3x/wK9MD5bh7JJyVT49oDm8w2dXY3dAYpiCeIk7eaBwu/l1Rgs5h2bCieL3C2zfJkNPp +UJTQaFTjbIPqDHfJ+iRrgKKnjWN1N7bpoLJ5BiUAAADAPoVXkAIAwEFXjs9nHfyqn4imeYc7kyW/ +X5bACLspubnpFx+Iw+FwdjPpN99VjrvdceJXN3mH+A+3m1ZXeQe/uukMj4Qp2SyBnE4+meT91Cgi +u5n06xymzAvoFt62tYZKJfmjfTY8kvVLRZhXlw2PhLMOaReVy+XGxpK0LRseCY+Ek5tJfznubm4l +KmezJJam3di+g7LmGZSg8vOf/xw3OQAAwEX3nve8B0kKAACA9jmKTKbcWPHBEQg43PPxsl82ucKf +bDzm+6d5RzZTKpPfYbZLnDsiPTmTg19NlkbC81leL1vg4Js1+QN+mpcVrq9d4SatNcjQuMNZ8idb +HRYngLSvLpvJkj/ZzB44HA6SxqQ0CvMnk/6RcCZLfqey0369SEgb23VQ0bz2xVr/kQgAAAD6AaZ7 +AAAAchSt+QXueFm1QIPD6TQ6VX9XuVRS7XE6HarhCrKkQ7ijyRntCjdprTo30egw8avy0RaKFTpN +qtPuko7X65KDf5SnuFs5I0N3Y9sOypunWwIAAAAgSQEAALBPSb+4l9mD5TNlmYJwqfGejfbzMnqo ++XaPzc1eL8kpK1rWLXHrqpRTkJIXuhu7qGwnJQAAAEBfQZICAAAOMmnJTPkmzfKZnT43O52qwRil +Ulm2OqVyu3+6kSMol0q9LLw3CQfj6hxOp7bJuhvVOYWkKr6KjV11ULdYAAAAQJICAABgv+codp6l +8E/zjnL8ntY7PcJZBz/tVzx1E5E4kaFRUesEzWEdFd5jJtX5A37KhpvzLMrlsnS8bCOV4/EsEWXj +ygkdYvD1NnbUQf0SAAAAYB/DwpkAAHBwxeez5NfOsvAH/BSej5f9ge6KdfCrq+R2u0fizX/ysqU2 +R8LukTj5k5tJ/lE+4w6PjIh7Vvn5e0jvML/FwneDaV82k2GxlY1/OtTHE/mTPBGV4q0tjbUvs3ob +O+ugfgkAAACwf9lOnz59+x13IhBtFXhuhhbW4j6EAnri+eeeHR4e1t21tbW19dqrLMuanL6xsXHi +xAmEEUDX2bNnjx8/jjgAAAAA7C/pdLrPp3vkZka5MdmfmfyeVl/gubGJxRruFAAAAAAAAIDd17/T +PWpLgdByhcg3t77gIaLqYmgixzB73g7GzuA2AQseWnlKu/HhiesRGQAAAAAAAIt2N0nxzE9/8sov +f6Hdftnl7/zgtR82O7O6OLNcYU5mUlN2aQsbSa1H9jg6nriwhnsELFOlJHTTFgAAAAAAAGBkd6d7 +XM0cs9lsqo02m+1q5pj5iYWlxRr5JpsZCq3qYqg1DSSQqMrO5bnQUoXyUeVe2cwRPic/eIzPyQ5W +zCiR9uqSnRJaqjQ315YCY3yuVZ3R6TCgvn8m2/wzfmRT/AvCAgAAAAAAcPGTFEcuueSqkXerNl41 +8u4jl1xiel6lViPyjnuM9uejYxOLNe/C2rqwti7MeSuJCUWeorYcGFuyp9aFtfXMJFtJTHBjo1GK +C2vrwlrcR/moPK1A+WjjYCF10l7gLax8kY+O8TnmZGZtXVhbidByQFEgnZkZjdbEvVho8+C5cdwv +/4OAAFwUb7zxxlbDhQsXtre3ERMAAACAg56kIKL3fYA5fLg1qeTw4cPv+0DbRR6qtSoxhq82qCSW +cuRtvWjDE89MspXEknzMgm9uJcIQEdkn5yMMEXMyM+clIiJvZJKlWrWqdzAxU5k5rziOw4TUAGkq +ChuZO2mvLS8WWimMHMWFlMkwEBh0zcEUCAXAxVJv+NGPfrS9vV2v1xETAAAAACQpaHj4Te9+39XN +f777vVcPD79pZ0VqUxh2j9dO+TOtNAGrXu2SsTdTBnb16pvKgxnWTtVKrV0DPD6frHBW3Njg83hx +ax1oGEYBcNHV6/WnnnrqwoUL11133WWXXYaAAAAAAOwLe/F2j6Pved+LL/z8t6+//ua3vOXoe99n +8axatUqkNxihWqkpkg7NNIEJu/XXgrQrSmpAjefGlFW0/srihSAH1EMrT40fISJqjqFAngLgYqnX +6x/5yEeuvPLK8+fPv/zyy4cOHUJMAAAAAPrfXiQphoYOvf8D7LmN4tXX2IeGrPyY6PN4qVCr1Min +87TP2hmiWqVC3lZeoFapErE9aW37olg7Q8TEhTkMlwAZ8dUeYnoCuQmAi06c4rG5ufn0009/9KMf +xXQPAAAAgH1haG+qufKqkZF3v++dv/cui8d7fD6qLs4oVqNsJQkY9aISlUK+YrbQprlqriBfdLNa +aTcUgmVYKuTw2g7QJ3/BB5alALhY6vX6T37yk3q9fu21177zne9EQAAAAAD2haE9q+kau6ODo70L +c16qLQfGRqPNlSYKvPh3++R8hMlHm2/3LPCBRNU+OdX1ezQqiWlppczaUmAmT56piGmSwj455SNZ +A4hyMxPma23CQaF6tQdWpgC4iD70oQ8dPXqUiF566SVEAwAAAGBfONy3LfPEhbV8dIzPzYxyjW2+ +OfH/2Uhq3T4zGh0bbWQNVjKTXc/2YCOpqUqoUYvHyjwO78LaymJootkAIu/CHO4mAIA+88ILL/z0 +pz+97rrrEAoAAACAfcF2+vTp2++488D2v8BzM7VIaiWCpS5hjz3/3LPDw8O6u7a2trZee5VlzRJv +GxsbJ06cQBgBdJ09e/b973//j3/842uvvZaIjh49+sorrxh94gAAAACgT6TT6cOIAgAADKQPfehD +IyMjL7zwwksvvXT4sP5/7zY2NhAoAAAAgD1z/Phx8wOQpAAAgIFlZbqH2+1GoAAAAAC0vv3tb19x +xRVt0wrWWfn9EJIUAAAwmJ5++ulrr7322muvvfLKK1955RWjw7a3txErAAAAgD5x0JMUnriwhrsA +AGDg2Gy2D3/4w1ddddXm5uYvfvGLQ4cOGR2JJAUAAABA/8BICgAAGEBDQ0P1ev38+fNPP/302NiY +zWYzOhJJCgAAAID+gSQFAAAMIJvN9uMf//i666677rrrrrjiil//+tdGRyJJAQAAANA/kKQAAIAB +ZLPZrr/++ssvv/yXv/zlK6+8MjQ0ZHQkkhQAAAAA/QNJCgAAGEDi/I5XXnnFZrMNDQ1hugfAQPnW +Z97+mW/JNxz/Lz/60X85PsA93vjCxz72BeWS+J/+5q+/+WmDiCj26RalidjGFz72sW99esDDCAC7 +5JbMnUT03cD/6ElpSFIAAMAAOnzY6n/gkKQA2H/qdaL//Jev/OV/JiKib3/2ss9+4WNvf6a5YQBt +10neZfnX18bcf/pPcxuyvd/+7GWf/czbv/Utg3hs14mINr7w31Y+L9+/XSei+ja+EgGgC5e84x29 +/CkOAQUAgIMMP5ED7D/1xgM1EREFvvHyD52///tf/Na3tgOfGtge14nqde0XVumLn5nbcH7+hz/8 +vLPxdRb4xssvf/6Lv//7n/0/vvDDH37eqVeU0+ksffuzn/nWy//vp+Sb63o1AAC0degtb+5haUhS +AADAgYafyAH24edW+vA2P73HHMeJNp55ZtvvpNLDN9xQeuilr9PdV979HSL61Ndf+vqniIhKD99w +w8Ml6QznQ//4jw/JH+AVe2W7vyMVoz5HeXxrn9F20wYYtrnZ47q6y6LvzH2xRJ/6+vQx1Z5j0w99 +6ot3f3HuW9NfV+dttutE9KlvfL10w91//MffatajHElR+s5dd92daXZD1p7v3H3lw85//Efnw42w +iB2RhUnVeKMAAsAAeePCBSQpAAAAkKQAOKiUIymIqLSxQeR0HNve3qbtOlH9O3ddmSlNP3l+2il9 +zDP3XHVPhgKPnn80QESZe66654Yb6k8+OS0+Miv3lubnS/yx5lnO6SefnHZSaf7jH2+ek7nnhoep +UT5R5p57SDpBfzuZN0C/zerMgnacQ2ljgyjg9+t8kfn9AfrOxsYz236nTpKivu1PPhr4zj0Pf5H3 +t5rQSlIcq1OzG5l7rrrn7hscDrGt9TqVHr7hSuf0k+fPi0F5+IYrHyYKPHr+fEB9sHEAAQBJCiQp +AAAA9Fzo6X9WAWAvbNeJaFv69JbjJ058qUyOBxO3XrhwgWh7u06ZTD3xwg/8zQ94Of5whvyJF74m +HkK3fu3sgxsn5h/+9gMJv7TX8eDZxl77Aw/YL1y40DjrB+K/7A8kHvyOdE75mQ1y+G+zN8q/9Wtf +owsXLpDR9jYN0G2zssfbdaLMPVdd1UpCJF5I+J/ZKJHjtmP6p9SJShvPXLhg1xZV396+cOHWBx90 +nJi/+4u3neUdss2Nlv/gVqkptz74oCPzpUZJ23UidVC+RM3gKQ42DiDuYYB97uN/Exw6JL06bfgt +bz5y2TuIyPPY/731+m+lr5oL20/+X2kkKQAAADp/2MFICoB9p14nemzy6NHGvx0P/P3fP+iQPs7b +dSK67bZb5R/ujVKZHLfJ50TYb7vN8aVHMpntW28T9z5wm139dbBRKtNtD7YKsjscRKWNje1bHbfd +5vjSl04czYoVk6JUne1tGqDbZm1a5rav/fxrtym+veomq13W9QdfyIZM2B/42gPZP/xSeP62v3/Q +YbJwpt3haJVUrxM5jrV6sl0nIoejGTz5wSYBxE0MsL+9+dJLhhvrUNgODdWHbET0pksvGT7yVnFj +M1uBJAUAAACSFAAD/7klotuWnlu6Te+jXK/X6dgxxSIN5zZKRM5jiiyE/ZiDpFUetonIcUyTozi3 +USI69yfveY9i67F6fXt72x79u+eij029b+oP3/OIvDEG29s0QK/N6oxDnXTWpDh27Bg9Vt7Y3rbr +B0mvTPkKmfbocjR74yNfykSXnKqFMx+bet/UY7LTbpMqFxMVreM0TW8tGGIWQNzEAPtb4Za/lP/z +5ieniOh7J5Z6UjiSFAAAgCQFAOwrmjUpFB9q7ZAA9piDqFQqbd9yrJWCKJWIHPXt7W2q14nKyr3N +sxz//Wf//VaDr41bFn/2s0Wixz939eem3levNw/Ubm/TgPbv/zRYk4I95iB67LHs4i3qNtLjjz1G +x/7sVtZkJAUREftn0VsXPjd18pbCsdbmxz939eceP/ZnhZ9FxeY+/rmrPycfSSFvqqbprYvTNoAA +MCh+99vXe1gakhQAAIAkBQAMdJKC7PZj9Hi5tL3NNlME2cfP0S1/dvP29ra49/Fs6f4/U2Yp7PZj +9OXHHtu++RbT1tz81SfuL9/03VJp++ZjRtvNG9B1koJuvv/+Y49/eeGR0s3Ktp/7i4XH6dj9t2hz +FJq6bv7q4i2PRz43dexYY/N3H3ucjt2/eH/j5HOlMtGxzpMUVgMIAPveha3f9rC0IQRUpcBzY3yu +q1MriYmuzwUAgIuWpACA/cbsw9uaztDC3vfV++zfjVwTeUz892ORm758zn7f/ePS3vtuoXNfvqmx +d/uxSOSxxnbZWdvbj0W8C+Xt7e3ygre1cfuxv/jyOTpmZ423t2mAbps1ndLtMnvfV++zn/vyTddc +I2v9Ndfc9OVz9vu+eh9rKT7jp0/fQufOnWtsttvtdO7xx8qypsoqJ1Kcri2udXGMAwgA++jb1tJP +U29sb7/Rq5/NBmQkRW0pEFquKLf55tYXPPjpGwAA2iUpEASAfabjkRREzL3fO2e/79i97HfvJSIi ++73f+969TOOg8S+f+x57883NvXTzV768va2zXdyxzdiPfVe2kW7+yrkvj5tsb9eArkdSSAXf+737 +jt2naOW5r9xs8P2mV9f4vffav3u6Im1m7v3eV84du8/HfqXZ0HtvrnQxksI4gLiHAQbtp6levivN +dvr06dvvuHMgkhRsT7ISBZ6boYW1uK/zUyuJiUCC6e5c2PceWnlKu/HhieuNjn/+uWeHh4d1d21t +bW299irLsibVbWxsnDhxAmEH0HX27Nnjx49bOXJjY+No6wUBAAD73pn7nfefsf/p44/fa0cwAGCn +isXiFVdcYfHHKos/epmXlk6nsSYFQM+oUhK6aQsA6Df4lR4ADJKbFhbGz0S/euv97DML4wgHAOxD +A56kqC0FQss0uZKZFH8nXV0MTSwycWHO2/pnrXEwczKTmlLknDWjKjRjJfLR5iIUnniGUVUv26so +XFkvsZHUSoTBzTgQvn8m2/z7+BHpnzeO+xEZgL4lzvQGABgUvkeykXP+xegHz1Wy2QiLgADAPjPg +SQpmKjNX5WamFz0rEYYqienFmnch5ZVlELxSxqG2tFib6nBUXD46xuca2YdKYiKQqBIxenuri6GJ +QIjEI3MzE4t0MrMmVZeb4QkZikGiSknI0xYA0IcwkgIABs01U9/5X1P4hgOAfWqQkhS5mVGu9a9G +9sETX/CMRmeWfHP0QKLqm1sRB0FUEks5YiOpxpgIZqrTsQyVxFKOvAuN8RH2yflIoTU+QrmXjcyd +zIWWFwtTC55qpUZ2z03NhIhvLo77cNA0ExMYQwHQ/8rlMoIAAAAA0CcGKUlh9DoP31zcN8YHQkSe +eKZxQLVWJeakbwdDGKq1KjFe2RA61udhFxOyvZ6p1gqajJ0VN0qHTXAFzewSGBjITQDsI5/+9KcR +BAAAAACtWq323HPP7XGlB2PhTG9kks0lKDLpVWxm7DvIEVQrNZMSqpUaUY3nxhRbG2MuVoTJfHSM +D4wtE16VOkgeWnlq/AgRRlIAAAAAAAB05UAkKWpLDySqRLQ4s+STD16oVSrk7TZPwdqZdntbK3Rq +eRfW1okoNzManRmNIk8xAMRXe2ClTAAAAAAAgK4NDX4Xq4szyxVPXFiL+2rLYraCiFiGpVo+V2t7 +eq3SOqaaK1Sb/2AZlgq5nLymmtleXb65lQijOBH2ve+fycr/ICAAAAAAAAAWDXySQnqjx5yXyLsw +560kpsW1Le2TUz6qLoYarwilfHQmrz6ZYe1UXUxI23Mz8veGiiXko6GlilTRRLSg2dt8BWnrdHml +RIWlxRqxDN4ONShuHPdr/yAsAAAAAAAAVgzu2z3IN7e+wCzJ3+hBnqkIM9GY9OFdWFtZDE1Ex0al +Ezyat2wwU5kUBUKNpSU8cWEux800d3sXUicDoWVxaQmdvaryybswR0SsncnLNmJNCgAAAAAAAAAi +IrKdPn369jvuRCAA9tjzzz07PDysu2tra2vrtVdZ1myAzcbGxokTJxBGAF1nz549fvy4lSP3+KOU +DtlCxdliMcb17kjoihBzuU65UvVUsP2FoPaHAa4XAMBAEt/uYfHHKos/epmXlk6nhxB3AACAfpAO +2WyumIC+4B5o/UNBL6JCzKW3Qzo3lDaoxGjfjlu/55UaE2Ium1qX9Xd5P1u6ggAAoIYkBQAAQN9w +ufps6EQ61PVzZd/1ZT8KpuqSVJCEUy711RBSaYFISKf0H37T6bSlbT29AXZe6a4EsBHFbnvdup87 +ikm7KwgAABpIUgAAAPTN82i/DVPv9tmyH/uy/2+P4iynuiJCKi0EU6mgXpaCm50Nai+gEIulKRgM +7tIN0JNK+++2V9zPO/hQaK8gAABoIUkBAACgfqRyGQzQFmLiL0Ibw7ibvxSVjesOpSkdMh1XLjtY +Xrr2rKKsIeryDArRbaFUssEpJKSDLp0R8Y32SKe1TjEqR9U6VTnKELWtXTzRFRNkJ4q1GRVkduHI +9DyLnWp/oc2vrMUqTDIALhdRsSgochQc53JxnE6WQhBcwSClY4qqhFRa4GZjQSvd178BjK9Xx5Xu +wfUyuYwGV0S3180LrdmbjbnU7TOZGyK/goZfJuZhUU5iaf+pVE16ae4z2t7dFyAAAJIUAAAAuyUd +srlOCY0x2qmgcMqlek6QFrVsDR5Ph2yhNCduqafIfCy4cMoV44qy0g0PFk6F0kHxyOIspxhiLq+x +OEvqJmpaSM0VBaXSFPVyZKPZZpMoHRJLk37x2xivLi3i2aZq46g2eq3ui0HtzWg1ThRbbbM1u6E6 +2PzCKa5RkYu5TqkDZqFT5hfavBCT+FvPnhWLilk06dgpgQuGOC4U5IRTMW2BwWBQORVESKUFLhji +jPsla7n+DWB6vTqrdLevV9t7Uu+K6Pe62Tn1Xn8oqBockU6nSdtd/Suo+2ViHhbZ3uLsbKzNpzId +cp1qXq56PRWUKjfa3tUXIAAAkhQAAAC7RhyX3no7QDBVnFU9/6XTlJI/ukinNLYEU8VZ07UYWodS +MGY6+pubTUtHcrFiqvX7aWWNXCytaqK6hc3HK6lXXCytrFfdJEEomsfHsGoLvVb2pW3tysqIuNmi +1A3FweYXTnWNpKI67JT5hW5biEn8rd2ZLpvrlGJAQjqdpmAsxhFxsVhQt0BVwkA3XdDpNW17t3RQ +6W5er+YTtdG4jx1ekcanVBV7wxyFzhU0+jIxC0vrAyBWbRoQoVhUNCaYEs812t7NFyAAAJIUAAAA +u6goCMRxLvkziOY3paq59UVBUG7iQkGTH+AVpXMul0ljFCtPurjm46C6Rs0sAL3Z/1brNW9S26qt +9Frel3a1K09UBkV+sPmF0+xVXCOLnTK/0O0K6eC66z5ju04J3GxR/nCYTsvWeQgGLWQpGiMvenNN +jTtisdJdvl7NTITBupldXhH97jZjr8lRmFxB/S+TNmHRyX8YB0QcY+PSTBox2t7NFyAAHNQfmCxA +kgIAAGDHNKOxdR5fVI/Nwg7+I9zJg32rGUKxqPoFsWrmgObB3vqjcJtp5m2rttgzZUit1m7SN/ML +p7e3406ZX+geRcb0GVv5eJtOp+U1htL6KzoGY7ONBStaIy921vL218tapbt7vfaQLEuh7a7xFTT4 +MjH//tEJi1lAuFhRmrOh3GGwvYsvQAA4qIYsQJICAABg53kBnd/JtslC7ORXsG0yJoqxBq1mcC6X +5s2K9e7HX6dDtuYU83bTzHtUtSykndTe9YUzv0YWO9WTQnonnU5rRwnoZSmaC1YoRl5023KL18tS +pbt7vfY8SxGLCUbd7eH3j86IkbYBCcoWcZFndLTbu/gCBICD6oMWIEkBAACwc9qJCEIqLZg+d7g4 +9Wz2oiD0pDGKhwXZOGxtjTt82G0tftHukaTbqpUvn2j1pbPau75w5tfIYqd6UkiP6L3T02jGhzRe +P2T0/NxJyy1fLyuV7vL12tMsRWyWE4TiDnMUVsKi97JZiwERV1HRZjnk27v4AgQA6D0kKQAAAFrP +VrG04uUT6ZB6qTudU2LydxwIMcV7G4SYq9sXTlLrFRBioY1h5FKNird9dFmF+sEnHVK8RoFzuZST +CEyqNu+pcCqoCJDUF9Pae3fhzK+RxXj2pBC9fEPnd4j+g2NQ+/JPecIgbXAfm7VcfQNYv15tK931 +67WDbwH1bd9+LxcKculQaIc5Cithkb8YJh0Sxz8YBkQZuXTslCBO5jDa3s0XIAAAkhQAAAC7nKYo +1lPBxgzvUJqbLbYbSR5MyWZ3u4RYm9d7WG3IbLE4Www11tyTrbjfeBGifEECwxn8FvrbarwtxhUV +rQ+mxLHgrXnr3VXNzRZjgkvbF/Pae3jhpLcUNK+Rcp6CxU6ZX+geXpSuchQ6L/+UP9UbvhbTtOWq +G6CD69Wu0j24XuJTts3W8fIV2tu+7V5pac8dDzloFxZFx5u1GwWEc7lkAQilG588o+3dfQECAPSa +7fTp07ffcScCAbDHnn/u2eHhYd1dW1tbW6+9yrKsyekbGxsnTpxAGAF0nT179vjx41aO3Aibwe8A +ACAASURBVJ2PkhBzudLBA/2jfTpkC5H04JMO2ULFgXzS6f2FlscN9t3NcMqFawcAg6ZWqz333HMW +f6yy+KOXeWnpdBojKQAAAHqrV2tSwAG70OlQKI2XJ+xPWLoBAKB3kKQAAADY2eOJYn63cvmIAyqd +HsSH7V280OLo+lCagimMrd+Xt0YQSzcAAPTMYYQAAABgJ6T53a0NwQM85luIucTFFIOpgXvY3sUL +HUzV6/gk7fMbvo70EgBAbyBJAQAAgCfMnj3Ix4r12KCGBxcaLNzwAACwQ0hS7G8FnpuhhbW4D6EA +AOhOrVZDEAAAAAD6xIAkKQo8N1OLpFYizF7UlpsZjRZk//bEhTnvoHYWAGDAMQy+TQEAAAB0XJTf +5WAkRYcXaSkQWq4Q+ebWFzxEVF0MTeQuws+3jB0/U/ebh1ae0m58eOJ6RAYAAAAAAMAiJCk6UV2c +Wa4wJzOpKbu0hY2k1iN73ApPXFjDtehLqpSEbtoCAAAAAAAAjAziK0iruc9PcGOjjT98joiIKomJ +5t8lBZ4bm1isGZ6iVlharJFvspmh0Kl6MdQsZDSQqCrqCi1VKB9V7s3N6FVa4LkxPic7mJvJk3qv +LtkpoaVKc3NtKTDG51rVGZ0OO/b9M9nmn/Ejm+JfEBYAAAAAAICDmqRgyUaR1Lqwti6sxX2Uj4aW +KkR2j9dO+TOytSRyhTwxXh9jeIpKpVYj8o57jOrNR8cmFmvehbV1YW1dmPNWEhOKPEVtOTC2ZE+t +C2vrmUm2kpjgxkajFDeoNB9tHCykTtoLvCJPYdgAPseczKytC2srEVoOKHtxZmY0WhP3YqHN3XTj +uF/+BwEBAAAAAAA4wEkK8s01F5X0RiZZqlWrRMTc5GMoV2g+6ufPFMjuuclucopStVYlhmUNKq0k +lnLkbb1owxPPTLKVxFJOr2H2yfkIQ8SczEgrbupU2moSM5WZ84rjOExIDZCmorCRuZP22vJiKymT +z1FcSJkMA4HeaQ6mQCgAAAAAAAAOeJJCzt5a1ZL1eVgq5KSsQSGXE7eYndIBbQpDM3aDVa92ydjt +hpUqD2ZYO1UrtXYN8Ph8ssJZcWODz+PFDb9HMIwCAAAAAACgC4OZpCjwnN5qDvbJKV8ja5Ar5Mkz +1XqLp8EpanojLMQUQaWmSDo00wQmOsiGtCtKaoC8F+qFJ1i8EGTXNVfKxEgKAIBBlQ7ZbK6YsEsF +pkM2Jb2qhJjLpA3mewc3npZCBwAASFJcBLmZUW6m1lhgYl2Ykw8f8I57xBkf+TOF1sgC01NafB4v +Uc1gOANrZ4hqFcVKFrVKtVe9al8Ua2fEF3+sy/9kJlnc5Hvk4Ynrm2/3wEgKAIB9nogIpU32u1zc +LtYeTNUlqSAJp1zqtgiptEAkpFO6z+Dmey9KuNoe3LN4tgsdAAAgSXER5M8UGis+EJG02qUy0VDI +5Qq5XGsJzDantHh8PqouzuisqUlELKNeVKJSyFfMFto0V80V5ItuVivthkKwjGwyC1xE8hd8YDAF +AMA+zFGk0+bPwang3jQkmKoXZzlVe4RUWgimUkH9PIT53r0PV9uDdymeuqEDAAAkKS4Gxs5QpfCE +lEco8Ir3a0iJhtpiIi9bvqHdKS3ehTkv1ZYDY6PR5koTBV78u31yPsLko81JFgU+kKjaJ6e6fo9G +JTEtrZRZWwrMKCen6BEns0RlszxyMxPma21C76le7YHxFAD7khBz6Q4aV2xXjCVPh2yumCAbcC7u +lQ1AN/iNruUThZhLXUhrnLyywYqmyUpSbe6gwUI6KK/A5LfTygLSodbB8r/r98igqUJM/H14Y3do +wSwUiuto2GypMXrdbbRT2qctVadTRtfZetyMcS4XUbEoKLIQHOdycZxeHsJwr7ap6tvEeK/Jza8f +LoOO6x6svjFMP2VtGmkcOs1dlG5bndlXgVEbjD6JJp9Q4wYYthkAAEmKfYaNpOK+2nJAXJchwWZS +J5Xvs/COe6qVmnwVybanyHMccfH9nbkZ7QIWbCS1vuDJRxvb7ZMrO5htwUZSU5XQKDc2yoWWK564 +0SSU/5+9u49u47wPPf+jLEepUzuR41TuOrmtZkaUDLViT8Vkq5tTa68CCJRswg1zyOZ4kzrZWKgY +RHZhwQ7u5g/Lf7hlJNqMpfCSgZxuc+vrc0ucpW1SlggDcSu7uepeUz2H2gomKWB0WtdbyXas1Hlp +FVnA/jF4mcHLYEBCFAh+P4cnEefleZvBmM8Pz/OMJYYyPR5Q8gXo7AgmFNahAIA6RfvaNj+ezA8b +P/vYYwcOuMq3j/UmH99s7VE8vrntgOuscZIr+fjmtra2PhnLDz2P9lXrUDk70dXXW/K1cDQaFVdv +n0uifZsfl8fOFse5FwbPR/va+qKux3Jpi7XEdRTYJW2FDGzqYs4uOyb1zAGwL6qx+6yxdyxYvSlK +Oqm2xY725aufPfuYqzAJIfcNfH7iwNkDrtolr5ROHe1mHzE7e9YyHSJ64PGkq7fP5errdSUfP1DS +wjX29hWusHHJLRfIZm/1m79yc1WpeO22rfUpq1EF+6az3EW9tbOzeRRUvlerfRJtP6H29S0vMwAQ +pFhOCh1yz1BhUYaxfk3pnyi8FlRERLwDM8npmSF3Sffe7pSyWIBl3QdzUkbiFdaDcA8mp8dNQyHU +wFj5ASWZmjIyRyjMR5aepRZX1pieKe5S+icsuQMAqvRrDhyIiuuxs/n+gOvAgd7C9t6xQj+hd+zs +Y6W9wN6xfBftQPQxl5iS6T3wmEuSybNVMnV0ouvAgV5z17zQMU+ePWvpofeO5U7OldmctrXEzgtc +ONKmLtbsjBaqq9ltihqNylixT1u1Kao2bMViF/e6Dpwd65XogYUttGiTjpN2s22WzW2bH0+6HjvQ +a65r74EDrvJWqL1XTHewccmtB1Tb6+Tmr6vla9wGNT5ldlWwa7qSu6hWdjUeBRXu1WqfxFqfULv6 +lpYZAAhSLBfxYDhe8vpPAAAW4GwyWbG/ezaZFJdrs2lL2dAG626xfIfr2ry5ep5OT+ztNXU7ix1z +40vzzeVD1c8mk9LbW+yjlU4cWGCBq+0qayJXX6+rjma3K6plZ/WmsFNWbGv1N7vqDiHUmY7tPWBR +mEuw+fGk67Gz5j5qNBottoWlFWrvLSmqfYOY9zq4+etqeftPXx2fsvKUbZqu/C6yz87uUVD5Xq32 +SbT9hNZq2JIyAwBBiuUQnsi9a9MzNNavcTkBAItX4VUDZQPHHfS9ymIAC+v1Vu6aF78yF3EdOJsb +KW6ZuZ48e7bktYw1Zl/YFdicTuVkKjWRUzWLWla0Kk1Rf7Hr70nX1SN3XgBz5QqvqCidEhGNRs1p +9kWldERJ9b0LtpCbf0EVX1BGTpuu/C5ykF21R0GVe7XKJ9H2E1qjvgt+igAAQYrrpjAhYtDLtQQA +NIT5G3xz16Fke/Ls2aUuWW9vbjKB5Stzc+9srLfwikfX5s3WTpvDNRYq9jfz0+KrT41fTC9/AUW1 +aYq6it3oq2lKp74COLoS0WhJM42VjCipvneRcZd6bv6FVnyJP2UOsqv2KLC7V8s/ibaf0Ov/VAEA +ghRwonQBCwDAEtnsckmllyaUj+JPjkWTSz4Wu/fAY65k8mzVjnluJQij47PZ1ZA3MEajUXE9Fi30 +wqp1o8qzO5ssHd5e8pIKm3MX3RQ1i229zOUj7x2HJaqk47TdnGd04EC0+rwX+72L/1A4v/kXXvEl +/pTZZ2f3KHDQqOZPot0ntAmeKgBAkAIAgOblOnCgV8zvDIj2GV96Hoha3twQ7Stdla+OvubmWu9O +tClfX68r2tdn7o4mD5jfcBA98HgyN4TcWDvR/G3ugl4vYe2sRfs2P56sWJdcdvkcrMXKJVNYE9Ca +zIKKWqEpzOWxK3bu4Md7LWUtzBlxbd5snShhf8mqpOO03RzfNxX7r/kRJfZ7F/uhsL35S5vLtuXL +2raOjBr/YbfLrvqjoNq9Wu2TaPMJXdL6AsCysZomAADA1K8by549sHlzX1tbYUOuz3I2u7mvrbDd +9djZ67Hovquv1/X440lTd9S1eXO0WFqxvi2gpC7SOzZWf1fu7FiyrW9z2+P5aj/WuzlZuenOPrZ5 +8+O5I3vHzj52YPPjpmTOSrEsvWPZsWhbX/Vmr13U8qaoq9iux84eSG7O52dqNeP1C219Rll6x7Jj +tgMsqqXjvN3qiFGU91+N0RLDw2Kzdyx54MAiu/N2N39pc9lWvPTg3joyugZhCvt6VX4UVLtXq30S +bT6hTfJUAYAm03bkyJEvfPHLNASwxP75zX+68cYbK+66cuXKlX/7qWr7wprZ2dnt27fTjEBFJ0+e +3LRpk5Mjl+FHKXlg8+bHN481YIWDZV/Uhacf7WvrO7vA/mC0r61PcpkuJp2KCQIA0FR0XX/zzTcd +/lnl8E8v+9Si0SjTPQAAWD6YtN5iTRHt64vyDgcAAIqY7gEAwLLplx/ofTzpeixKjOK6NYWxLGQj +YgqFxQh6xxjiDwBAwWoR6Tn4/9EQwBJbc+Udm+kef9r7YZoIgKVPvtlYgLB3LLvCe7TXqylM+TYk +296xbJYbGwCAUoykAACg+bkOnM0eoMwNSnZB8YEK+RJnAACg4QhSAABWNF3XaQQAAIAmQZACALCi +KYpCIwAAAFT05ptvLnGOvN0DAAAAAAA0BYIUAAAAAACgKRCkAAAAAAAATYEgBQAAAAAAaAoEKQAA +AAAAQFNosbd7rHlgv/I1efe+J985vxyKu+NLdz6xrtGl3XLHqS/dYt5wPq7fF7/MvQ4AAAAAaHKt +FaRYd8uOdSJy8+fWvfPMxaXJ8pYnDt78w0ffemXBB1+8fA3iKe9/K5/Lji/d+YRHObXurW3Pvs/t +fk396R+vK9/4f37P7ka8cuUK7QYAAAAABS0VpFi/5eb1Z976ltzxwJY1zyzN2IEtN+8Q+eFCD37l +2Te2XeMCvvLsG/d5lOc8N++Q91/hfr/GSkISFcMWBZdv/HXbxC7RngAAAABWmlYKUqz53JY1589c +Pi+X12+5ZX28OIdix5fufELe2nbm5sI8CPMMCPu9IiLrPvHc/tvW57uW339SN4Zp7PjSnU9sERF5 +4uAtxbPW3fLEl+7YUeicnskNYah4cC7rwhiHKhk5KmR15y9eFlmjrJNXLsp6j/Lcune3PStPHLxj +h6l4NlmX7TVlbZpaYimP9Xi5mJ/SUm27bQEql9kmqevqmfszxV/+/V+euV9E5IEfsPgLAAAAAKyo +IMWW27627vL3z1w+Lz8977ntgS3vfOuMee8dp7a8/61H33jF6PR6lCcuvlE8wGav0Q83xxr2K/Kk +/szFwiCFy98yz+C4KCLv3vfoO+dz597xnOfyffHLlQ8WawmrZOSoCtWtX7dG5LJeDDrc/MTBW9bH +9W2FmIJ91ta96z2fWG+KUORDM594br/ynBhxilue2H+bFNO/5YkvyXnjH5W3O6h7aZmrJ9UESkIS +lrAFAAAAAKC61vmCd8eWW+TMu89cFLn4zjNnZMeWW6z7i8s0nI+/9f2LJQdU27vmAU+x8ywirzyr +f//imq95bqlekPe/VfhK/8y7379oxAhqcpKRfRWqJLv/zuc8a87H3y1GRrbcIs++YRqFYZ/1mgc8 +t8jFd+/L7z0ff+cV01m5dC6+86345fWe23aIyLo16+XyK2cuF4udG6xRZbuTupeUuWpSzeJ7X7pi +/PCIAQAAAIAVGKS45XNb5JUz+V7umfeNBSCKLv7S9E27eViB/d4169cZ0yWKe3945nJp4lWVZVQ9 +mlA7I/sqWFvjiYN3njp456mDytfWXf7+k29YJ4a8/8MzzrNes36dnD/z/vlKBS40uJgmlcjF91+5 +uOZr++98zmONzlTb7qiRrWWumlSz+ONnbzR+eMQAAAAAgHOtMt3D6NB+6c5Tpm2f2/LWK2cWl+y6 +NeulpP9c+mu5wvITOWeuVUbVvf8tmxeOWIIdjrKuUJJ1a9aLrLc2uIhx2OVnnnzjmS13nPqScspj +LkyV7U7qXlLmqllcZ3/6x+vk3/9FRApjKIhTAAAAAMCKC1Ls2GKZL5CPFNwiZxY3C+Di5fP5NR0K +20p+tbrliYN37LiYX5Mit+DltciocRxkXaEkFy+fFzn/bPVFMc68te3Rt4wGeeKgFIMI5dsXXPdq +WVwnxqs9jJUyiU0AAAAAwAK0xHSPdZ94YItl6oFUnPGxEJfPly4qseZzW9bImZ9WWfzy5h1y+fvP +Fl4zsUZZd20yaiT7rC+fvyjrt9yyvtJZDhbFeP9bT757vkI7mLcvsu7Vsrhunrk/Y/7hKQMAAAAA +KyhIsX7LzetL11kQOfPTV+SWBxa7ZsHlZ55997zpRZs7vqR8bd3l78fzq0hevGwsh5Fz8ZfnZc2O +LWtMBxfTKj24noyuaZDCNuvLz8Tfl3W3PZffK1vueGJLfrvpLJFbntj/ifUisu4TxYNFdnhuW2+s +oFFt+wLqXjWp6++BH6wq/+FBAwAAAABOtMB0D+Nb93fLvnV//4dn7nhiyy3r4+8sKvmL79z36OUn +Dt5x6uAdRqf9++ZXY55561tnbnnCWJrhzFvbnn3nvmc/lF8oQc7H9fvidzy3rtrB79eR0TVVq47b +nvzlc/sLe+WVZ9+quF3OvPUtEbl4+fwW08bCghHVti+g7jZJAQAAAACWrbYjR478t3/6HA0BNJUn +/+CSqqo2B8zOzm7fvp2GAio6efLkpk2bnBzJRwkAAKAhf1Y5/NPLPrVoNMpAdAAAAAAA0BQIUgAA +AAAAgKZAkAIAAAAAADQFghQAAAAAAKApEKQAAAAAAABNgSAFAAAAAABoCgQpAAAAAABAUyBIAQAA +AAAAmgJBCgAAAAAA0BRWi8j4o/8LDQE0lfPzl2gEAAAAACsNIykAAAAAAEBTWE0TAABWspMnT9II +AAAA1czOzi5ldgQpAAAr16ZNm2gEAACA5sF0DwAAAAAA0BQIUgAAAAAAgKZAkAIAAAAAADQFghQA +AAAAAKAprPQgRSLk6gzFHByYivQ4PBIAAAAAACxECwQpUpEeV2fPsO50e1WJUH3HX99kAQAAAABo +MS3wClLN7dEio7FEOuBXTZvTsURalL1epa7EFE1ZbHli4Y4p98yQu8HJotk9Ov56+caDPZ+mZQAA +AADAoRYIUoiy06uMDideTvn7tcJG/eWYLpp/p+Y8HfdgcnrxpYlPJUTcDU8Wy0FJSKJi2AIAAAAA +UE1LrEmhet2q6PGYaUpFKhFPGdtFRNKxb/a4OjvyP1WWlihdnyIeLJwSjlsPrZJgPoVYuMPV2eHq +G0lVSDY93Fc4scMXSZcVwJSvkQKWkVemJgs/XTddMP5BswAAAADAiglSiObv9xrzOwpBhERa3P2B +3CQLVdokMDaTnJ5JTg96JR6s3fmPBztDMWXvxPRMcnpmQhmxRBOqJegeTI7t1US8AzPJ6ZnkWL9W +IdmeYd0zND2TnJ5JDnhSkR5ryvFgZ0hyp+/V9FFfaXwETW9HV7f5hwYBAAAAgBUVpBDxdLkllXg5 +F3rQX47p4nV7Cru9A+P5gIUn4FdFT6dtk0tFRmLiGcpHGTT/oYB1UYl6E7QkOz3oNX53D0741VRk +JGZJOb+ehdL/lF+VRIxXiiw/hcEUNAUAAAAAONcyryD1uj2FGR+pRDwlni535SM1pfYilmk9LYpq +WoezMHNkgQlWSVY0t0czlrHIZ2ReYtN5ymguDKMAAAAAgAVY3TI1cXu9Eool0gG/GHM9vOa9iZB1 +XQmPbVrplC6iaHaLbtaXYPVkFU3lLmwZj46/3nWTiEhhDAVxCgAAAABwrnWCFOLpcksw8XLKLTFd +vP5i1CAW7ggm1MDYTG6CRiLkCtsnpdq/MbT+BE3J6qmUeExvIUmlRYhTtALj1R5GeILYBAAAAAAs +QAsFKcTr9kg4/t3vSUo8geJcj/hUwrKoRErXRWpMo1AVVSKxmHgKwzHSejp/1kISLCabSKdFCkEK +Y2ZKwM2d2EJYigIAAAAAFmZVK1XG7fVK+uUfpsXtNc31UDTFtKZmImR9m0Zlmr/f/BKQVKQnmHCW +oKKpIrFEvEqyhwJKPGh6Zakvktb81pkpWNZKXu3ByhQAAAAA4FxLBSnyi2Wa3+shogbGBr36qK+z +w9XZ4YqoE2N7NQdJDRlvAO3scHV2+PT+5IDHWYKeoQGPJEKuzg5XIRhhKczMkDseNM4NxzX/+ISf +2R4AAAAAAIi0HTly5Atf/DINATSV8/NnVdUufDU7O7t9+3YaCqjo5MmTmzZtoh0AAACWl2g0uopW +AAAAAAAAzYAgBQAAAAAAaAoEKQAAAAAAQFMgSAEAAAAAAJoCQQoAAAAAANAUCFIAAAAAAICmQJAC +AAAAAAA0BYIUAAAAAACgKRCkAAAAAAAATYEgBQAAAAAAaAoEKQAAAAAAQFMgSAEAAAAAAJoCQQoA +AAAAANAUCFIAACAi84N33X77XYPzTVm4yT2NLNv84F23m+2Z5PJfo6YGAAD1IkgBAIDI/MTEfP5/ +r3Un2ElQwHrYxo3t7T5fewOL0R569cKFCxcuXHg11D65Z0V3y691UwMAgHoQpAAAQCYPDc53Hz3a +PT946NoOK5icmFzAYe2hV18NXZuOc3vo1aPdSxGdadpLv2RNDQAAHCBIAQDA5MSkdPu6u33d1j7r +/OBdt++ZNE+PKHznbrMrvzsvP0zBOMWYUZA/3Pi3JYUKh03usSRfKfHaRapq48Z2Swr5QuXPrpJd +1V2mOpkKYKlp/tiKG2tUsLR4NctToWVy+65NU1epFAAAcGI1TbCsJUKusAxND3ppCgBYsPnBQ5Pt +oVe7ReSRUPtdE5PS3W0KYOy5S45euNBt9D737NkzeeFot/2u+cG77hqU0KsXQu3GL3fdJa++GmoP +vXph457b98jRQgqycWPo6NFQt+STmLxwtLvCYdZ+eMXEa5a2qrk5cz96cs/tk925JOyzm9xz+57J +9twumZ+fz2+cy22b3HP7ntv3HL1wtHt+8K7CVpH5yUkxUivfWLuCluItuGXu2rPxmjR1lUqVeOut +t/jcAQBWmjvuuGMFBSn0EV/faMq8xT2YHPDkf4kHO0MxEe/AzJC79NRYuCOYyB9vScdTrfOfO6Vy +XksTmNADY+MBhdscABoRo5iYmM8vQ9Du87XfdWhwvts04r/7aL4D2/1IqH1yYm5eutvtdhlzR3Ld +VGkPvXp07vY9hyZDlfrB7aFCTt2+bjlkSryyWonblLZKhOauPZPSfbRYYWMCSO3sJicmpftooc/e +3t4uuTEp+cS6jx7tvn3PxKR0b7RWurtSS+Q21qqgpXgLbJlCubqvcVO3V8nB4V9pAACsQK003cM7 +MJOcnklOz0z4VUmEXOF4aXAhES87KT5lDjco/RPT4wFFxD2YrBih0Ed8nR3BRCGv8YAimrL00QJF +I0LRbB4df738h2YBlkmMojiq/67B+ZIFGto3bqx2auVd83NzJXs2bmwvGa5g6gnvqWtyRq3EbUpb +GpvIV1hCr5rHEViWjbTJrnxX7vhKVWoPPROSwbus0x8qbqxZwWqrWtbVMnZXZHFNXbFSAABgRQYp +CjT/+IRflcTIsF7Ypgb8HknEYtYjU5GRmHi8bocJp4fDoyll78R0YUSGGhibmfCrS1q9agEUXHcH +ez5t/qFBgGUh93W5yRIsn2mKFOyZy79no/a8jAYqvN3jwoVGrxNpStpULWPrq7kOfC54UXHjcteS +lQIAgCDFYuMUpaMb0inF65X4cCRt3hhLpDV/f5fDRBMjw7p4/f2aTRSjr8PVmfvxmfNKhFx9IymJ +B617Y+HC8aGY+eDOUMx0sGVUSG5vRaZT+kaK81/0EV9nKFbMrtrpWLRXpiYLP103XTD+QbMAzRyj +MJbMNG8qWz6z3k7qxo0lgzHm5uZNq1Nat3c/ko8RzM/NNTLxxnS4q2fXvnFjeZErbiztwB8taV/L +xgVXsNaJlmI5SXNxTV2xpgAAYMUGKSrxdLkllXjZ1HV/OaarXrfTcRApXTcSkaoBgp5h3TM0PZOc +nkkOeFKRHkucQh/1dY5oY7kJKalIj6uzIyiDyemZ5PSgV+JBc1hB4sH8wcmxvVql2SuVChCKKXsn +jHkoMuqzJChT4Y6gbuxlIMa1tKOr2/xDgwDLLUax+ChF9yOh9vnBB4rv9Ngz2R56pNvS1xURY/pA +PqPiCWWH1ZV4g9lk1+3rlsk9hUkN8/PzueNNG2V+cHBSRCYHrRM6jMavtHHhFax14uSe/KiGyT17 +rJe9gU1duVIAAGCFByniwXBc3P0lS0t63R7R47H8HJBUIp5SPF7Hizuk9bQoarWQhjFzpLjWpntw +wq+mIiPmMQvegdxql5r/UEARUfZO5Fbc9AT8qujpdKWDRemfGPBYZ69UL8CYMdBDDQzs1fTR4eKK +G/GYDCbHbIaBoHEKgyloCqDJDR6qEKPIdb8PLXxJgfbQq/nR/rlFHwpTKrqPHu2ez88DaA89E2rP +reBw19wjpnkXlsMcJ34t2NblQr6Ut99++12H5sqOv/32uwaNfvqc+fWfklv7suLGhVfQ/sT20NGN +h/IrZZhW32x0U1euFAAAcKiVXkEaC3e4Cr9UfOOG2+uVUCyRDvhVkfhwJK35D2ki6UbkntbTonjM +IQzN7dEio1MJya95oZaudqlohZBB2fwU68GKqkk8pYsotgVw93tNiavGRlGLMRosDQZQAMtF6NUL +oUrbu49euFDpgPbi7+3Vd1XaXSHtCod1v1r5MMsvVROvUSQHZau8p/rxpQWrenzF4ypurKeCdR6x +scrOhjZ19UoBAICVFqTIvWFUH/H1jaqVO+SegF/1JV5O+fu1RCwmnqF617zU02mRSoMR0indEnQo +hAls1PFakFpJ5Qqgh1yd1iyqRT1wLTw6/nrXTSIihTEURCsAAAAAwLnVrVclpT/gKP7cugAAIABJ +REFUHg2GQ7FKKy8YoxuGE/1dibi461uawev2SEJP6VJphoiqKSJ6KiWeYlxATxWHMSxS7aRUTRFR +Ko0fwdIwXudhhCeITQAAAADAArTkmhTegcGyF3nkKTu9isQSoalE/dMf3F6vpIfDltUoi0ECpXRR +iVQinrJbaNNeOpYwL7qZTtUaCqEqavk7VnEdmF/wwbIUAAAAAOBciy6c6Qn41VTkkUorTapetyqJ +eEzZG6g7fOAZGvCIPurr7AgWFqRMhIx/a/5DASUeLLzdMxHyRdKav3/B79Eoll8f8VVaB7SE5u/3 +iqkAIrFwj/1am2i8kld78IIPAGgC7aFXL1zT5UUBAECjrG7Remn+Q4FEz3BfSCub9KH5+72RUNq9 +s8LSEvqIr280JcbiDqZXdRS4B5PT8WBnyLxIp3fA+H81MDajhTuCnR35jMYn/Aue7aEGxvpTfflc +3E7mcXiGpseH+3oKBRDxDA1wjwMAAAAAlom2I0eOfOGLX6Yhmkoi5ArrgbHxAEtdrljn58+qql2I +a3Z2dvv27TQUUNHJkyc3bdpEOwAAACwv0Wh0Fa0AAAAAAACaAUEKAAAAAADQFAhSAAAAAACAprCa +JmhC7sHkNK0AAAAAAFhhGEkBAAAAAACaAkEKAAAAAADQFAhSAAAAAACApsCaFACAlWt2dpZGAAAA +WDKbNm2yP4AgBQBgRbvrrrtoBAAAgHIvvPDCrbfeWjOs4JyT74cIUgAAVrRMJkMjAGgSzz333H33 +3Uc7AFjJCFIAAFY0ghQAmko2m81ms7QDgBWLIAUAYEUjSAGg2R5KBCkArGQEKQAAK70/QCMAaKqH +EkEKACsZQQoAwErvD9AIAJrqoUSQAov0/Jd/9cvylz/7y8/TFFiOCFIAAFZ6f4BGWKZ/hN9/y/3P +F3/9/A/e/8HnF5ncG//5f/7P/7ypcUWc/bPPfObPZjeVpjr7Z5/5zPOfb2xWaB3ZbJbnEnLPDyl/ +KFXbbv1PW+6/b9xIWCK7J74sIsd9f9mQ1AhSAABWNP6GW5Z/vA/83u8NzIr8wV/85C/+QETkha98 +7Cv33/L88/nfHXjhKx974Q9Mh2ezIps2tjf0hshkjS7Fn45/01yuTFZEsvQfUPWhxL0BkfZ7/2DT +nw08P578ZtgS5Bx/flY2he+1f1hl808Z2hFL4yMf/WgDUyNIAQBY6f0BGmGZmfv2/QOzG7956tQ3 +N+avn+/P33vvm9/etu0r/+ufnTr1zY0OEnnx+RdE7jVdft+fv/deo++HbDYrGzdunHvhK/c//97/ +da95M9+Ww+ahxL0BEWm/996NA99+/vk3HjU91Oaef35WNn6zRoyCIAWW2g0fXtPA1FbRoDAkQq7O +UIx2ALAy+wNYRp4f+Pac3PvoIxtKtm945NF7Ze7bA8/nDvvqrbd+9fnM81+9Ne+rz2dMu14UedHY +t23gjeLxBW8MbCucmTskUy1ly26zrIjc++ffv1de/Ko57cJIikwmk3nj+a+YcjKX4fmv3rpt4A1T +RsWSlh+cse6pWiQ0Nx5KMD3UfPdulLkXnjd9mN94/oU52Xivb0ONp0fG9N+30oeb8XQzb+HRAduH +khMfXL36wdWrjfrbrNVGUiRCrnDcssU9mBzwNG15Y+GOYOL6lTYRcoX1wNh4QKGbAmAFBylohGVl +bnZWxNfdXeHKdXf75MXZ2Tcy3RuNLxInvnbb7COvvf32RpG5Q7//+1+7LZt9+xmfdB99+7X23//9 +QxufefsZX/42sHzxOPHArz0wIb7c/okHfu2Bz342+9prj2wUKaT8ou+Zt9/2GSkf/Oz/0Z5Py3x3 +GWl2H33G9+IDB78d6jYSsE732JAVeeS1tx/ZmMvpa59tbzdyymZl7uBnb9toVMHI57aDIrmMrQcb +Zd74yGuvPWIcayoxlmHklHaAyIbQI76DD7z4whuh3Ed57oUX58T3TGiDcYvYPj0KD7SyURXGI8jy +uOPRgUVqYISitYIU8aAxEKDYz48HO0NppVn73/qIr280JeIdmBlyi0h6uK8ndh1Kq2hEKBri0fHX +yzce7Pk0LQM0uasN/c8qrr03Zuek/Z4NFS9cJisyN/vG1ata7s/w7sjfPKxdvXpVRHv4byKzv+4/ ++O037g61i2QyWZFsxpRKJisixob5wYMT0h35l+/dbey/+3sn989uP3TwhYcj3VJIOb9beziy/8Xt +T774wtW7u8t6m1nJZjJXr969f3/79kNf+/Y9J/OZZzOFzO/+3t/cnbsR796/v33iyVwNSqqQy0f2 +n8xlbDk4V2bLsYUSY7kFKXguIefue7pl4sUX3ng41C4i8y+8OCfd++8u3CD2T4/cjWT+d+HJlH/+ +8ejAAv3+X/WuuiE3LePGD6+56WMfFRH3sT+68u+Xc/fZ1cxrfxhd2UGK9HBfKCaeoelBb3GjZ2h6 +pnkLHB5NKXsnxvq13BY1MDYTWOJSuAeT03zCGqckJFExbAGgCfsDNMKykrVZdTJr+n4wmxVp37DB +dNyGDe0yOTebyWil3yRa0hWZnZuX9nvMp2r33NP+5FMTE5m776mQstbeXpKYOfCRzWQyGe3h7z08 ++Z+e3HPonr/e326zcKYlqdKMMlkRaW/X8hvMB8/Ozcs9++8uHKu1t4vMzc5m7m7nnll+DyWeSyhG +Ke6RyckXZx/e3y7zL05aP+f2Tw9HIyl4dGCB1tz8kRvz61C03bAqu6pNRD5080duvOlXjI2FaMXK +DVIkRoZ18Q6YIxRl9BFfXzowPSi5GRaFiEZ6uK9nWM9/vP3jE37VGv6osDcV6fFFFEtMJBFyhfX/ +/Q/lv/1Vhe2lUypyBS5EKCqGXaqUKhFyRdSJMW04v4SEsdc0c8QUrEmEXGEZmvZOFdabMM8oye2t +2G75kSkiYg6mVG1GiIjIK1OThX933ZT7dUcXwWiAIAUaZcOGDXJs3gg1lF1NY38mkzH+bV2dUtvQ +LvmX8mWzWbG+oK/4xr5zs3MiGzdo5nvDfG55ytXe9mdeIVMLjgYndzz15ERwZGPJwpnH+j/Vf8x0 +2j35tQlKMspms4XqVSrzuT++4w5rW7E6J0EKLHe7775Hjk1OzAUflonJebknuNt8e9g9PaTCvwuP +Eh4dWGwHfPdfmH/d9Vq/iJzYPtKQxFsjSJHSdRFPl7v2kVPhjpi+d2K6EB0wuuL5nnYi5Ar3+KQQ +Eai6V3N7tMjoVEK8+Uxjibgoe//wC/L//FWF7V6lrgLbl0pEH/V1qoGxmSHFCJf0uCLGsAiPcW6w +b8Q0RiMe7NSNg0Uf8fWFXOGaK1/Eg52hWC42kR7u6/H1iSnB8maESUlIwhy2AECQAoumbmgXOXZs +cnj33aW7Xjp2TDb8yd1qYSSFdbjCubk5kXbjb2+7kRTqhnaRubm5zO4NUunc8pSrLaRvHTKh/knw +7qGv9+/dndhQ3PzS13/j6y9t+JPEPwaNzF76+m98vey70Eyl5MrL3P5f/vG/3M0Nvuzx5hdYoxS7 +75Zjxybm7pZj5+RuU4zC0dND7EdS8OhAg/zy8r83MLXWCFKk9bQoHrX2gfGYDCbHiv3zVGTEMknE +PTjh7/FFRmL+Qa/9XmWnVxkdTsTFnVv/Yiohmn+npqgB92iwfHs9BbYvlcE7kBuaofkPBRI9w7J3 +Ihd38AT8aiySTotoZQeL0j8xkHaFR4Z1j81imbkC5KISamBgb6xvdDjRP+Su3IwoVQhMMIYCIEiB +htv10EMbXnp66Km5XX+ywbz93HeGXpIND+1Wi3+Xn3tpcu6hwlFz8+dkw26tZpBCNG2DvDQ/l8kU +/kt9bvKlc7L7T3YtKkghsuu7w7tfCny9f8OG/Objx16SDQ8NP5QrtJybmxfZUH+QQjRtgzx97Fhm +127ukBZ4KPFcgvmZt3u3vPTSk09K8SkkIg6fHvmH4dxcZtcG0/MsfySPDjTG1SuXG5hai76CNB7s +7HDlfiyv1fS6PWXBAtUcLNDcHk3iU4mae1WvW5VELJd4IhYzthhZVNpeZ8ylaqlEREQtXe1S0Qoh +Ca109U3rwYqqSTql1yqA2+s1Ja4aG6s0I0rt6Oo2fmgKYLn0B7CcqA9+90Ht3NM7168PHMttOhZY +v37n0+d2H5l6UDW/Nu3c018fms9kMpnM/JAncFx2P5jbr2obRI6/dCxT6Y196oPffVA7Higkfyyw +8+lz2oMPdRWPNL7srvS2P8sbSAvzOvK6jhzZLefOnctv1jRNzr10bN6UkSmpkozKkzOX+cHdYipz +JnMs4MnVHbyCFMta167dcu7EiXOye1dXcWvNp4eYD3z6O8esB/LoQENfQZrJfJDJfNCov81aYySF +qqiSMI8dyC+ZmQi5wtW760Zf3dS9L3TIHewVzd/vjYSMmR2xRFzcg7mxCW6vVyptL6FbBjs4LlVl +mvPXgtRKKlcAPeTqtGYh1UMkMDw6/nrXTSKMpACWW5CCRlh2lH0nzu078eCGB/epx/fltu06fO7w +LrGOMtD2nXjwnDcf9991+NzTXfkDup4+vOt47vxdh88d3mUZDaHsO3FOe3BDIXlt34kT+5TczoWP +pBAR6dq3Tzt+JJXbrOw7cfjchge96uFCNvt2pRYwkkKk6+lzJ9RduyxN8jT397KNnNIOMD02unbJ +8ROyq6vLdGs4e3oYB57IFp8Nuw6fO3xiw4NZHh1o7IOLV5BW7KLHzStBOAxuaIqInkqJp9gD11Np +EbX2XjEWlQgm4uKWqYR4i6s8eLrcEoyMpNyadXuR1+2RhJ7SxavUW6pFq52UqikiSs11K2BlvNqD +lTIBghRYKt7vzM19p/q1zP2NbjnKcoR5TyaT8X5nbs5yREn6xT3GkaWHVrqXlG+8NPeN0h25jYXN +pfV4qZBUaUZlyZXmW0ia25sgBVrycVdyZ9R6epQ+PPK3mHh5dKDB/rb7/yZIUcrdH1Diw+FQrM43 +TZQNwZBUIp4ST8Bde28u1hCOxRISE8+QKT7i9e/V+tLpRLpku6nAXq+EhsMj3rEKa0/WzLdO6Vgi +HSguuplOiepVajVLJBYTD6/tWAhWygQIUqAprqywAiGWJW5bACtciwQp8os7Bjs7zG/rTOm6iF13 +3Fh1MtgZKrxHwxdJa/5DXgd787GGkeFIWtzW4Iiy06v0BMNSur3IMzTgcYVHfZ2j3oGZXCAjEQrK +4JDbQb51SkUeGXaPB4y3e4Srz0ApNku/NxIqFkAkFu5J+ccDzPKoiTEUwHLsD9AILXppc9eXC4xl +91DitgVAkKIVKP0T0/2xcEfQeB9ncbv9Wz/UwNiMFu4Idnbk++emN33W2Csini53KJgQr79kZoTq +davDkbTdApPuweR0PNgZioU7XPlt3gGH+dZFDYz1p/ryubidzOPwDE2PD/f1FAog4hka4OMCoBXx +jWXLXlmRsvUggGb3u7/7u5cvX6YdAKxkbUeOHPnCF79MQzRaKtLjiyhDdU4/abxEyBXWA2MMglhu +zs+fVVW7uNTs7Oz27dtpKKCikydPbtq0ycmRs7Oz7733Hi0GAABQ0a233urwzyqHf3rZpxaNRlfT +6NdEOpZIi7ufNR0AoNl9/vOfpxEAAAAqOnny5BLnuIpGvwZSkUeGdTXg5+0YAAAAAAA4xkiKxkpF +enyRtIh4B2aYYQEAAAAAQB0IUjSW5h9P+pupQO7B5DSXBQAAAACwHDDdAwAAAAAANAWCFAAAAAAA +oCkQpAAAAAAAAE2BIAUAAAAAAGgKBCkAAAAAAEBTIEgBAAAAAACaAkEKAAAAAADQFAhSAAAAAACA +pkCQAgAAAAAANIXVNAEAAAAAAHDo7NmzNY/ZvHnzwhInSAEAAAAAAJxateoazskgSAEAAAAAAJy6 +8847r13irEkBAAAAAACaAkEK1CERcnWGYtQOAAAAAHAttFiQIhXpcXX2DOuL6aYu4nQzfcTX2eEq +/PTtj+nXtTwisXChPLXSLCl8Z8e1672bStXh6uxwheNLesc0tIUBAAAAAIvSWmtSpGOJtIjEEumA +X3XYQ55yzwy5zdsUTWlE1zccF/dgcsCT/1Vkgck6LU+luhSlIj3BhBoYGw8oEgt3BPtC2vSg1zZB +70DV1BpDH/H1jaaKGaWH+3piirLkt00jrriIPDr+evnGgz2f5ikDAAAAAA61VJBCfzmme4YGJBh5 +OeXv12qfEJ9KiJj74e7B5HQDChJLxEXZO2FEKBaTbB0nltXFKq2nxT0YUEREvG6PJPSULl7lOl6t +9HB4NKXsnRgrXCk1MDYTWOJSNOiK55SEJCqGLQAAAAAA1bTSdI9UIp5SVFVRNT1eNrciPdxnnnwx +ksovQJCbbtA3kpLyVQksZ/ki6eKe3JHxoDlN5/3zksKIMcPCVB6jGObylOdYmBlRsS5WqqJKImYk +ldL1Bg0fqFR9fcRnaav0cF+lSRyJkWFdvHaxJNvG7xtJmXI39ppmjpguok27if06FFUubuFKVTzp +lanJwk/XTReMf/CgAQAAAIAVFqSID0fSmnunpuz0KunhSNza2+wZ1j1D0zPJ6Znk2N6Av19zDybH +9moi3gFjY3lv2XrWgCcV6bF0lSUe7AxJ7vS9mj7qy/d+vW6P6KMPWw62LUx+31S4I6jvnZieSVae +ixEPdo5oY/kcjUklIlK7LqL5+70SD4bjsXCHLyKBsRpzPZxFKEIxxSjteEBGfUZPXumfGPCkIo8Y +Cz2kIo8M656hwqCSQkRJ10U8XW6bxG0bXx/15Ztiwq+mIj2uzo6gDCZzTRcPWiI1VdptAbUzX6lq +p+7o6jb/8JQBAAAAgBUXpEjEYuIJ+FURNeD3FEYNiEgqMhITtdgtV/oDDpZaSEVGYuIZKgQL3IMT +fjUVGTF/f15ctUHpf8pfHKqQP7infCVI28LEYzJYMcRgynHcmLJhxAKM8QjOeAJ+VRKhoL53Yjqf +iC3LkpZlvfpc++RKqwYG9mr66HAiV/0hd3o4PJLSRx6OpL0DFQIiaT0tiqouqvFztdD8hwKKmObX +eAJ+VfR0ehHtZle7wpWyOb8wmIJHDAAAAACswCBFLBEXtzffp/V6jTUaiv1hT73rL5T3ojW3RzMl +K6KaZ0xo1hUfNf+48SW/JELm2Qr2hfG6PbaFsuQoiqpJOuUoSJEe7uvwRcTobJsGBcSDJTMprCGY +5HT+p2woRFpPFxtcRBRNNTbmzh306qO+vtGUe3ABq2/W2/hGAbQq12IB7WZfu9pXimEUAADAlp6I +5CV4z1irtuel01GuL1C3Vlk40+i+hlydpm2JuBR6kqYerMNuckovO0vR1DqLpfnHk35JRXp8kZ6g +Uhh2Ua0wan3rRDguT27OxfSgVyQwJr6+UV+fTIz1a4lYTNSAW62/wdMpXUS3NriIqV6egF+NRSTg +r96Z19NpyymLanzN+WtBardbzdpVuVKPjr/edZOISGEMBXEKAMA17QBFT19au7W3d+vaks26UrIR +178PnbhUuFSXTkcTuunKWfde37It049CE7UnAIIUIrm5HkPmdRwSIVc4FhNPboueSomnnjiFqill +Z+mptMgCOvSav98bCaX1/Nl1F6baf1EclicdS6TF3V+YYDKRi1PENdMrP+qkaoqIMlg+wiJfthFj +SY7h8Ii30gQW2zeMNLLxF9RutWpXkfFqDyM8QWwCALCE/bPT+la3QkM0v7Vr833mS5cuieK2dqGL +e5cgKKErfus9s3S5X5MPwXVtTwAN1hLTPdLDkbhlcL5YZnyoiioV3vdRqxeulK5rkErEU3ZrPTpP +tu7CWMINxf/CpFOOBl8U+vx5Sv/E9KBXT6fM70ldQEVMC3+UXpHwaMo9mJwe9FZbQNTt9Up6OFz5 +lSiNbvy62822drWYX/DBshQAgGvf79UTjCdveorbXwwLXLp0yWbvNY9R6Pp1zP1axShaq0bAytYK +Iyn0l2O6eEunFXi63BKMjKTc/cZAhuG+kJYbahEPhmVowGMM+4+ZZ4WYaP5DgURPsDOUG6CRCPki +ac1/yMFLMdLDfT0x9/iE3/i2Ph7sDMXEM+RXJT+qokJhnElFHhl2jwcUEX3EF44Xx0HY1sXr9kh4 +1BfWjKEBuTdlKKqm5+d91N/qRkWK7SMSC/ek/OMBJT+7ZMwjIkMDHlc4X2brBRoa8LjCo77O0eL6 +o4lQUAaH3Itp/Drbrf7a1cAYCgDAUnd+3ZeiiURCr94pM6aF5KMa1QbB64lIQtx+RS9MoVfcpm71 +6Wj00la/WxLG7sI++8Qte0279UQhF8s51uOL+6ptty1A1TJXbZxiAvatYVeFKrXOJehWCuddSkQi ++d2X8ntrtJuzy2pT+ELupsyLZVtAyo4un22brzVPgqk/X0ftabpYipFMfm9p3Y1CrM1tqXoL2Vx9 +S169jOYAVmaQwviOvfyFHV63R8LxmN6vKZ6h6fHhvp5gZ0dun3vQ1E82lh6wzhYREVEDYzNauKNw +luYvxB3sqZoiw5EeV6Tw58NeUyCgWmGcUANj/am+Dlf+RNN8BNu6uAeTA6H8XpHCe0n0EV/fqK8z +Hhgbr3/SR1lFxDM0kJvo4R0Yzy9i2h9QeipP+nAPJqfjwc5QLJyvkYh3YJGNX2+71Vk7AACaMUyh +RBKnT19SKnUIjS6TYuqSRaNSbbK+nohc2trr9681umeJSMLSM9cTEf3S1l6/pe9YPXHr3kunT18y +RShyXbtLp6PRwjl6InpaiunriYTkTqi83UntyspcUuFqKdu3RtUqVK918XL5/ZaOsIjIpeqXrDwF +RxWvUnjF7e8tzbz+lHXF7fcruQ59NLE2f6xNY9as3ULzddiepuhTJCEidfzhW/m2t7n6+bzyQRcC +FcDKC1IYi1NW4B5MTlsiDoEax5T9arzhQmomXrql6lk2hVH6J6b7a+cinqHpGXFYpJp7K2Zqs700 +EScVqdLyNatTR+OXZeG83cxHOqmdTeMAAHDdwhRbt66Nnk6cVspiD5dOn9bNYwAUd+/WaLT6KhaK +O5/E2q297kvW2Ieui9vfqzhM/NLp07qs3dqb37t2a/7r8tN6MZ+1W91b9dw5ly5dkrWKstYUfTHy +qbLdSe1Ky1zSPNVStm+N6lWoWmvnnKTg5LLaXkr73GumnN+dq7qui6LUakz72i0iX2c1yjdGLuFL +dcQoKt/2Va++ueHdW/W68gIgIi30ClIAAICVau1W99a1l04nyvpDly5dKllAcK2irC1flSC/03ro +2rXW2f6KtUton3hpn9V8ljmhtWvX5hYVWKsoay+djkZKu3XVtjuqnWLXja2asn1rVK9C1VrXEaRw +kIKDite4lI1K2fSLfWPWqN0i8nVQI8tNUPflqXDb2119SzEXdSsAK9ZqmgAAAKAVwhS5L3TXWvtT +pf0559270iNLfneQeIW8Ll26VFg+wHRgrhK9/q16IpKIRk6L6ZvzKtud1K7kd+vaBG6lWo62rWFX +hfpa2GnLV2rDui6r0yIt6oZx2pjV7ooF36i1a9TAi2Fz9SvVAgBBCgAAgJUaptiqnE4kEnpvSXe5 +pJvmvNdW40gHiVdIYe3atSJrbYIBitvvz4UTLGtilG9fQO1yiTjLsVpr1KrC4vvFi2/5BRZpcTeM +w8asdlcsKl+HIYYGfM5srj7xCaAxmO6xbLgHk9MLWN6SdqPdAAArhOJ2KyXvIy0f5n9J1y9VnQNx +SdcvWTuTdn08+8TXrl1bkl7xrGrTTSyV6d1aaYqCeXudtas3x6qtYVOFarWurxNcKwUHFa/vUi70 +hqn78tndFY27lPb3W1mpzBtqX7waV79GXgAIUgAAAKywMIW5X7R2q9t4w2Su46Qnoqcvrd26tfrb +SvPrWlw6HU3ootit+2if+NqtW5VcKvndCT2/3XRW7rxCloWtp0/nOtbVttdduwrVrZKyfWtUr0LV +WtfRqXaQgpOKV72Ua9euleqrkiy8SWs0ptS4KxZ5Ke3bs3B9SkqZi46cPq2XXMfaCVa9+tXzAuAQ +0z0AAABaJ0yxdeta3dzPWru11782ESnMoc+/HrFK/6t366Vo/lC7FRqcJJ573WVx+r7irrw99yKI +tWvX6ua5/vn8q22vt3YVyl89ZfvWqFYFm1rXE2qqnULNitsW3q1EEsap5dd4wU1q35g1a7fIS2nf +nu7CShmiuHu3no6eNlW3V4rFUdx+tx5J1HmBzFe/d2s0erqQl4PUAJRpO3LkyBe++GUaAmgq5+fP +qqpqc8Ds7Oz27dtpKKCikydPbtq0ycmRfJSAAj0RSVxqWMeQ1qDwzerS6WhUV2geoPF/Vjn808s+ +tWg0ynQPAAAAACsE60QAzY4gBQAAAIDWZF0ZwsFaKwCuN9akAAAAANCaStfKcLDWCoDriyAFAAAA +RHH7/bRCS7QGl5LmAJY1pnsAAAAAAICmQJACAAAAAAA0BYIUAAAAAACgKRCkAAAAAAAATYEgBQAA +AAAAaAoEKQAAAAAAQFMgSFEuFelxdYZiyzDxBkuElk1RAQAAAAAtoMWCFKlIj6uzZ1i/7n37hZch +Fu5wdZp+wvFlVHgAAAAAABZudUvVJh1LpEUklkgH/Op1LYmiKfWfpI/4+kZTIt6BmSG3iKSH+3pi +irI8Co9Hx18v33iw59O0DAAAAAA41FJBCv3lmO4ZGpBg5OWUv1+7XsVwDyanF3Baejg8mlL2TowV +Sq4GxmYCy6PwEJGykETFsAUAAAAAoJpWmu6RSsRTiqoqqqbHY+YJC7m1FeLBwhyKvpGU5VTTrpLp +FfqIrzMUK87CKKzRkB7uK07K8EXSZdk5SNwsMTKsi9cutmKbY99IypSRsdc0c8RUnvLWMJfKbh2K +Kg1YuYkspV1BU0hemZos/HTddMH4Bw8aAAAAAFhhQYr4cCStuXdqyk6vkh6OxMs62CEZmElOzyTH +9mr6qK/YM48HO0MxZe/E9ExyemZCGbH0/0VEZCrcEdSNAwa9uVN6hnXP0PSDmFwYAAAaiklEQVRM +cnomOeBJRXrKz3KYeC7Cousini531drVyFEf9XWOaGMzyemZCb+aivS4OjuCMpjMlTketMRl4sH8 +wcmxvVoi5GDlC3NFxgMy6rMGekqaKBbuGZZcrZPTM0PulTSFZEdXt/mHpwwAAAAArLggRSIWE0/A +r4qoAb9HErGS4QD5hR5ElP6n/GrhgFRkJCaeofwkC81/KFDanY7HZDBZnIWRPyUXsBBxD0741VRk +pHwAgoPEc9J6WhS12kIaTnL0DowbiedyUfZODHhERIxm0dPpSgeL0j8x4DHGcdiwVkQNDOzV9NHh +RLUmSqd00dw7tWJ2+ZKvEIXBFDxiAAAAAGAFBiliibi4vfk+vNcr8amEeb9q/iZfM61GWRYdUL3u +0liB1+2xDyhobo9WmqPTxJ1wkKNaOlRB0bRK9a1wsKJqkk7ptQpQaF4RUTTV2Fi5iVSvW01Fesqm +1awYDKMAAAAAgAVolYUzje56yNVp2paIizW4ULH3ndIt/flKSvr/lU5RNHWBiZvo6bSI5jCdyjkW +ac5fC1IrqVwBdGvzWopaGiLR/ONJfzzYGfJ1jop5GEtre3T89a6bREQKYyiIUwAAAACAcy0SpEjE +LLMhRCQRcoVjMfHUmmWg1r9WgqopInoqJZ5iL11PpUXURSTudXskoad08SqLyXFBaielaoqIMpgc +8NSTrmdoekZEYuGOYLgj2PJxCuPVHkZ4gtgEAAAAACxAS0z3SA9H4pbJCFJxxkeV/reilixgYZ7F +UPUU6xIPqUQ8VWnZyzoSd3u9kh4OV54f4TxHhy0WS5gX3UynasVTyivinLH+Rc1WbR3mF3ywLAUA +AAAAONcKQQr95ZheumyE8aaMWKT2mgiav9/88otUpCeYqHnKoYASDxZe1ZkI+SJpzd/vXVTinqEB +j+ijvs6O4jGJkPFv5zk6lIo8klspUx/xhePi7g8oDlrJ9HbSWNjmraLp4T7zS09HhnVRFXVFfKJK +Xu3ByhQAAAAA4FwLTPcwxhQEysYUeN0eCcdjen+tJSE8Q2N7fX2jxuoJ4h5MDsRcYftT1MDYjBbu +CHZ25Pvw4xN+dbGJuweT0/FgZygW7nAVajFQb45OqIGx/lRfPhe3k3kcnqHp8eG+nkIBRDxDA1XT +15S46cgVsyYFAAAAAGAx2o4cOfKFL36Zhlg5EiFXWA+MjQcU2qKJnZ8/q6p2UajZ2dnt27fTUEBF +J0+e3LRpk5Mj+SgBAAA05M8qh3962acWjUZX0egAAAAAAKAZEKQAAAAAAABNgSAFAAAAAABoCqtp +gpXGPZicphUAAAAAAM2HkRQAAAAAAKApEKQAAAAAAABNgSAFAAAAAABoCgQpAAAAAABAUyBIAQAA +AAAAmgJBCgAAAAAA0BQIUgAAAAAAgKZAkAIAAAAAADQFghQAAAAAAKApEKQAAAAAAABNgSAFAAAA +AABoCgQpAAAAAABAUyBIAQAAAAAAmgJBigoSIVdnKEalAAAAAABYSqtboxr6iK9vVB2YGXIXNsWD +naGYeIamB72L7NuH9cDYeEBZyNmxcEcwYfrdPZgc8Cxdsyyu8ACwIpw8eZJGAAAAqGZ2dnYps1vd +mq2YHu4LxZS9E2P9moOjY+GOKbc5wFFC0RbQyddHfH2jKRFvLnSSHu7riSlLHy1YUOGxAI+Ov16+ +8WDPp5uhbOfPn+cCYQHWr1/f8nXctGkTFxoAAKB5tGSQIhbuGdY9Q9OOIhQi8amESLUIhXswOb2A +IqSHw6MpS5REDYzNBJa4IRZYeCxUSUiiYtjiernxxhu5QKjLlStXaAQAAAAssdZbkyIV6Qkm1MBY +ySyP9HBfh6sz9+OLpHOb8ys1xMIdrs4OV99IqiQ581IOuX/Hg/l0KhyfO3JkWBev3yZKUqU8Ri59 +IylTLsbeXAk7OyxLS5QXKRyvXPhSVWqhj/jMDcIyFvV6ZWqy8NN10wXjHzQLAAAAAKzEIEUi5Iuk +vQMlqzDEg53G2IqZ5PRMcsCTivTk4gLuweTYXk3EOzCTnJ5J1p4eEg92hiR38F5NH/WZgwKFQImu +i3i63DaJVClPLlIw6usc0cZmktMzE341FelxdXYEZTA5PZOcHvRKPGgJjsSD+YOTY3u1RMhVqUjl +tYgpeyemZ5LT4wEZ9VmjLVPhjqBu7F3cih4r046ubvMPDQIAAAAAKzFIoY/4wnFxD5asLpGKjFhW +0HQPTvjVVGRkYWMEvIXlOZX+p/yqJGLl6aT1tCiqWiUFJ+UpxFk0/6GAIqLsncituOkJ+FXR0+lK +B4vSPzHgMcZx2MgVIBeRUQMDezV9dLi4wGc8JoPJMYeTZVBJYTAFTQEAAAAAKzNIEYuMqm6PMZjC +PmSguT2asRRF3VTzOpTaghbCdFAetXS1S0XTqmZqPVhRNUmn9FoFcHu9psRVY2Oe1+3ho7EoDKMA +AAAAgAVopYUzjTEOsXBHMPLIsLsw4yOd0i2d/EK3/NrS02mRSoMRFlKeOqIhtauWTukiesjVac2i ++E+VF4Is0KPjr3fdJCJSGENBnAIAAAAAnGu9t3t4B8YDfT3D4RFvfjqDpojoqZR4iv1wPZUWuXZx +Cq/bIwk9pYu3Qm//GpendlKqpogog8kBhks0lPFqDyM8QWwCAAAAABZgVQvWKbfIwsP5SR+qUrqI +QyoRT9ktbLlobq9X0sPhyu/+aHR50rGEedHNdKrWUAhVqbyUBhrD/IIPlqUAAAAAAOdWt2StlP6n +/HFfpCeozAy5RfMfCiR6gp2h3FqViZAvktb8h3KLMiiaKhJLxKWRCzF4hgY8rvCor3O0uNBmIhSU +wdrlqV+qML0lv3RowDZIofn7vZFQsQAisXBPyj8eYJbH4jXtGIorV65wdQAAAAA0udUtWi/NPz6k +dwTDPcNj4wFFDYzNaOGOYGdHYe+EX7UGFIw1Gkwv3Vgk92ByOh7sDMXCHa78Nu+A8f/25amXGhjr +T/Xlc3E7mcfhGZoeH+7rKRRAxDM0wKdhuTl58iSNgGvqn/7pn2gEAAAALKW2I0eOfOGLX6YhlqlE +yBXWA2MMgmg55+fPqqpKOwAAAABYOaLR6CpaAQAAAAAANAOCFAAAAAAAoCkQpAAAAAAAAE1hNU2w +rLkHk9O0AgAAAACgJTCSAgAAAAAANAWCFAAAAAAAoCkQpAAAAAAAAE2BIAUAAAAAAGgKBCkAAAAA +AEBTWC0i5+fP0hBAs0mn0zQCAAAAgBVltYioqkpDAAAAAACA6+jv//7vme4BAAAAAACaAkEKAAAA +AADQFAhSAAAAAACApkCQAgAAAAAANAWCFAAAAAAAoCkQpAAAAAAAAE2BIAUAAAAAAGgKBCkAAAAA +AEBTIEgBAAAAAACaAkEKAAAAAADQFAhSAAAAAACApkCQAgAAAAAANAWCFAAAAAAAoCkQpAAAAAAA +AE2BIAUAAAAAAGgKBCkAAAAAAEBTWE0TAAAAAACulw8y8ta/Xv3xL7K//CDbSvX60A1tN32obd2v +rlp7UxtX2TmCFAAAAACA6+ODjPy///LBuz+/+uOfZ395taWCFKva5GMfXvXOz1f9+s2r1NtuIFDh +EEEKAAAAAMD18da/Xn3351cv/DSTfvfq+5czLdXZXtW27uZVt//qqmx29a+uabv9ZhZbcNZuNAEA +AACAZjB3/uJ/n/zbn/7sZy1To4+sWf0fO/7D//b7n1mzZk3Ng99+++0f/ehHP//5z1um+qtWrfrU +pz71mc/YVf/Hv8j++OfZ9LtXP3rTqo47PnRDC3XkL3+QnX37g/R7H3z4xrabawUpVubVr4ggBQAA +AICm8N8n//Zf2u68fNtvZNtuaI0avZe5/Hf/OH/5FzGfz1fz4B/96Ee//du/vX79+htuaJHqX758 +OZlMxmJ21f/lB9lfXs2+fznTcceNrnU3tNgt/aEb5GT68i+uZC/XWm5jZV79ighSAAAAAGgKP/3Z +zy7f9h+ybatEWmRtgsyqD53P/Jbyr7NODv7Zz372m7/5m6tWrcpmW6T6H/rQh37nd37nH/7hH5wc +3CbZbDa78ROtE6eYe+eqcSmdXM8VfvXNCFIAAAAAaA5ZycoNkl2ptc9m29raMpnMiq1+JpPJZFpn +fclMJuM84rDCr74ZQQoAAAAAaJaO+gqvfiu1QL11WeFXv4AgBQAAAIBm6daJrPRe+kque+sFKeqq +DkEKA0EKAAAAAPTSl1+ftiUvfYu1QF3TPQhSGAhSAAAAAGiiXt1Krv1KXpIgvyZFS13NuuIOLEhh +IEgBAAAAoFk6qkz3WOHVZ00KEKQAAAAA0CS9OqZ7LKfqH/+G8g35rv7d3Y2rfrPcAA2pWl0X9Ppe +/cZeykUiSAEAAACgdX38I0/90Uc+Wfz9g+h/fS/64+Lvn/y9W5/atlp+/POH/+vP/7nkFPPGJVFP +N/X4PnXfcdPvu4+kjyxtHzOb71w3ru5tC0ot9bTXe1gejMUe0pqsaku2cGbqaa/3cHvZLXB8n7pP +HNwYjb2Ui0SQAgAAAEBr2nb3rwXbS3tAvX/0a9tOvffw331Q5aQ1wesXoXC4KkHq8K5dR1Iiuw6f +O7wr9/sJVVvqNQ2MlS4blWt+TYq2+jvox46nROT4sfl9D2pNVLVMxuj2tzX26lfOy1h1tDQJp/Vo +7KUkSAEAAACgVTTwu9z2j+YiFD/+2cM/MMINq3vv/3jvx+WT224N/vji0LwlY8lmRVb33v/RbSIi +/z70g5/983WovYPqp47sO5LS9h0/vk/LnaDuOz6/b+nXNGj41+8Lm/GQOn4itevpp+WhI8fP7dun +LWXVjDkabW1tbW1tC7yaizi+rMDlJXZ6iZpqJMUqHoMAAAAAmidK0aifbe0flmK4wdh4JfqDn5wS +EZFt7WvK1unMfnLbR3s/LiJy6thPTjWuJI1toBNHjqRkV9XeeOrEg7vbix46UTzxofb2h07IiYcK +O3cfSZWEP8ynFvfanHL9pU6cSGnahg2aljpxwly48vqaGqPGXkuLWHeceKjYClevXn3qqad+8Ytf +LJsXczi4lM5ahiAFAAAAgNaPT2QbZ83vGcMo5v/tf1i2/9spYwDFx2/4ZH6pxlzmGz721LbVIvLm +/3j3qbkGlqS+VQlqOXfunEhXV1e1/aqIfOOlubm5ubm5p7vkxEO7D5/LFSMrcuKh9oeyT8/Nzc3N +vfQNLXVk94Mn8ieeeLB995FUl7Fz7qVvfGPfN9Tc9odOaEaSL31Djuy2JOjgmjWu7pWcOHwkpXV1 +qWpXl5Y6cviEKV+jvkfUl/L1PfFQe6G+tfdmJZtVu7o0OXHClOqJEydE6+pSs9lsNnvlypVIJPLt +b3/7Jz/5ydWrV6/91bdv5vKLYb1Ezi6lfctcu5ufIAUAAACApoxUNHTwwpvvflCy65/fvSIi8vHV +n7Qc+eFg94dFRH7806FTv5RGDqOoo5eeqW0+lRJVVasfsHNoMqDk/vmNgCqp1Hxuj4hI19AbQzsz +mUwmowS+E1Bl6sTxTCaTyZw7fHhK1MCx3M6MEgjsLGzvyiepBL4TUFPfPXK8mGDtEtfVRc/U6fiJ +KekKBJRMRgkEugrVMdU33xpKYHKoS6YOHz7ndG+uHSypHj8xJaq3K9fAH3zwgYicPHny8OHDP/nJ +Tz744ANz2eqN0WQWIZvNikw9tLHEQ1PFS+T4Utq3TJ0IUgAAAABA/T5+46dy/7g5uO3G6xahcfDN +dNbhgdlsNqtomvUbclXVKu89l0qL2tWllA3cSKXF6/VazzmXSjXJSIqpqali8bxer0xNTZlbylLf +rKaqkk6dc7g3VzVLqlNTUyXNJCKvvfbayy+/HIlEfvrTn5aPp2jo1bdvZe9QssSQt3iJnF5K+5ZZ +gpEULJwJAAAAoDlkG7hwZi6dT338Bsn+0rzjkx+/UUTk3Sv/bM3r1ORbp9rveHijfOo/fqx3/u3o +u9cnSOGkXunUuWxWqXZE7OHND8dMv3sLkwGkZG1K03KJWRHRVKW0AOlzKZF00OWybFVLwiWNC9DU +ef1jUzERsRZvaiq70ysV66uomqXCDvaKyE6vVx42Uo1NxcT71NcLzWT8v6Ior7766mc/+9kPf/jD +999//0c+8pFVq1aJSL3VWdTCmZUvhmmr40tp3zJLgCAFAAAAgNbzb6fmZNtGkY2/sm3y304Vt//K +to0iIvLjD940H/7u+9E5eXPuvVMbb90mN/bdc/Pf/cVP31zyCIWDbuDOnV6JpVKp7E61Uq99/2/t +j6lff/Efvq4Wfrd0PsUmSFEhVUXVRLQn/+FJb4UO9XV/u0csFhOvpXCx/b+1P5aLUpTXN51KiWim +MIT93vzOnTu9sn94OLVTjcXE++TO4jnGv65evXrnnXf+9V//9fbt29esWfPFL37xpptuWrVqVTYr +Dt8/6vjqVz9dagUpHF9K+5ZZAkz3AP7/9u49tqnrDuD4714/8gAnHW0SYDwaO0RbeRilSyRUxkON +PU2oDYSGCqRJQUuGo67hkWX7AwmJP/ZKVKoSaFgL6v5DS1r/0Ugo9jR1k5ZoogiyTdVEZ5s/AAUN +AmQC4sSPuz8cO4mTGKdL4Dr+fsRf5/iee3/nWEjnl3t+BgAAgE7MZ7nK/usjsazEsXrLqvE2Y139 +si0iIqGu/idJL6RrmqZpT977fERE5KWCunJ9Fs7UnE6n+D88dtY3Q5/H4xFb03tN8eMIPp9v6mv8 +MltZRZvVJn5P77RBbVabeDyeWU+ezOtxj7l9A3xnP/SI0+lMnpz444omSSH5fH6xWW1p9k6E5mxq +svl9Po9n2v00TUTC4bCmaXa73ev1Xrhwwe12J37vQ0+FM9NdytQzQ+FMAAAAANmVp5i3f9fvHe0L +xTIO77eu+rR11aetJfteEhG52TfUdS+pqmXiquGueyIiW95ctkWPhTOj0er2dqf4O3dv3NjSG2/r +bWnpjUajVqtV/J5eX7xxd6dfphRETLqHJHpLXS6n+Dt3J4YcH7HU5XKKt2XKrWrO+hamcOacKjL6 +ej1+cTqqkybH4RTv2dgDioj4O4+NP63vbE2LV5wuV+nEY6XunRi11OmweltavNPvFxWRSCQSiURE +pKqq6tKlS52dnT09PY8fP47Vp1ig8GcqnCkzT3500hKns5SpZ2bhC2dy3AMAAADA4nSz/85bXxe8 +f7Bw9URbqOuTO12p6k2EunqGtxwsXC35LQdDRz/577M89JHmntbRNjDgaN3c6m21e1vjbe1tmlbq +crf7N7fusZ8TEbG63G7Xz2r98WGnH8/QJt3U0TbgttbWTgzpaG/TtBnaYx1a0uXzEftc/vYe8HgD +4mhyJF/gcDjE6/X4XS7RRKwud5N/j90ef/CBtsQFT+2dHFqp02k9dy7gcDhmeMBwOGw0Go1Go4hs +3brV7XbX1taazeaySmc0mj/vqz9bbm/8XYiZ2sdb01zK1DOz8EhSAAAAANCNed8J3R0+2jacKpHR +N/hW39wuee5JChGR6rZr12a6OLn9s2tJPZPuEWuZtBU/9Nm1QzM8TnL7lAHnuyZFmqONP9P0zyfC +9MWGnDIhk073pOydFpqmiYjDUT31fomaFOFw2GAwxPIU1dXVFy9ePHDgwMF3zUXrd2pa7jNIUswy +HdPiSGMpU88MSQoAAAAAWZWi0LI7fi3LY09/BioqKlL0Xr16dZZakpOTFGmX/Qx4/xgQx6GkHIUk +alIYjcZIJBJLUojIrl27zp8/39DQWOPKiayp1jRTBq3+3GZmAZCkAAAAAKCjrWo279K/2Rn+xRR+ ++jNw5cqVFL3RaDSW9JhtxNS9UwU++vnvAtaf/Ob15E8nalLE3qRIvEwhInV1dcFg8J13myt+tCS8 +crumGTNl9ecyMwuCJAUAAAAA6GWjns2x/58/w5k8YGzDneJNitl74258tG/fxzdEpPrXXzaWTq/4 +ED/ukaCqqt1uDwQCsVsER0b+9vtfrF97/jslr2bK6qc3MwuIJAUAAAAAnexTs/1NimxOUsz7DLz+ +q8uXZ9/6p+6Ne7nxD5cbZ08hJI57GAyGoaGhvr6++vr6hoaG06dP792794liuTdqvB20mMy5kUg4 +U1Y/vZlZQCQpAAAAAEAvu/Qsjz2zZiDxJsXt27dra2sfPnxYU1PT2Nh48uRJVVXXb668M5ofHbYU +r8ozmsysfppIUgAAAADQx5Zvke7TVFWd06Y328Kf+MWNTHuXJPa0t27d2r9/v81mKyws7OjoOHHi +RHNzc09Pz483bTPnLskJLTXnmtL5DmT5lz+BJAUAAAAAXbDkm/6jBaNKzmIKqqzgbnFxcTqfNJlM +wWDQbDYvpvDv37+fOnyzQTGoismgRMQYjYb8D5QMii4YVERk39tvv7zula0/3DM2NvrBB788fPjw +kSNHTp06Ffj6X8FvF5UUGPJMSo5RYfXTRJICAAAAgC68VmFTfbeuP7IumojKCu+W5VzftGlnOh9e +t27d4ODgmjVrFk34Dx488Pl8O3emCj/frHwrT1lZoA6O5JkNWigUyqAAx4IGEVlZ/uqGHW+qxWVL +jKbi1eVnzpw5fvz4JvvmP3/5VaH5+z9Yoby4RC1aqrL6aSJJAQAAAEAXtr9WGXzksQ5/sTjCUVW1 +uLh4w4btJSUl6Xy+srLS4/H09/cvpvC3b39K+Mst6tBj9cV89eFI9O9DeSJ5GRRjeMy88Y3mkg3b +hpetGYkUaBFtteOd37b/9E9f/OUf//zqe7t3bLPlLMtXX8hRV1hUVj9NSkdHR11dHf8hAgAAAACe +vRv3IzcfRoceRR6FMqwsQzQSGRt9oqoGozk3VnwhNDb674G/+gb6Stau++6mqvKytUWWvFeWG556 +3AMx3d3dvEkBAAAAAHhuSpcZ8kzKYI4yGs6wypGaZtA0k6IoiqIkWsqLdgS3VimKUmBZsuKFnJUF +BoPKIs8BSQoAAAAAwPO03KIutyyarbxZZClr+o2R0gEAAAAAALpAkgIAAAAAAOgCSQoAAAAAAKAL +JCkAAAAAAIAukKQAAAAAAAC6QJICAAAAAADoAkkKAAAAAACgCyQpAAAAAACALhhFpLu7m4kAAAAA +AADP1/8A1SEA4lRLJJAAAAAASUVORK5CYII= +'/> +<g font-family='sans-serif' font-weight='bold' font-size='8pt' fill='none' stroke='#FF0000' stroke-width='2' stroke-dasharray='none'> +<rect x='605' y='398' width='400' height='30'/> +<g transform='translate(605,398)' stroke='none'> +<circle cx='0.8em' cy='0.8em' r='0.8em' fill='#000000'/> +<text x='0.5em' y='1.1em' fill='#FFFFFF'>3</text> +</g> +<rect x='600' y='367' width='450' height='32'/> +<g transform='translate(600,367)' stroke='none'> +<circle cx='0.8em' cy='0.8em' r='0.8em' fill='#000000'/> +<text x='0.5em' y='1.1em' fill='#FFFFFF'>2</text> +</g> +<rect x='873' y='218' width='179' height='47'/> +<g transform='translate(873,218)' stroke='none'> +<circle cx='0.8em' cy='0.8em' r='0.8em' fill='#000000'/> +<text x='0.5em' y='1.1em' fill='#FFFFFF'>1</text> +</g> +</g> +</svg> diff --git a/Doc/Sda1/jpaintro.xml b/Doc/Sda1/jpaintro.xml index 705a88a797612ef39403a418777ccd2a97e13d37..0f7e1367dea163c30e5e7563d0e5d3ca67a62ac7 100644 --- a/Doc/Sda1/jpaintro.xml +++ b/Doc/Sda1/jpaintro.xml @@ -231,6 +231,30 @@ <section xml:id="sda1_jpaintro_sect_Tooling"> <title>Notes on tooling</title> + <figure xml:id="sda1_jpaintro_fig_jpaMavenConfig"> + <title><xref linkend="glo_Maven"/> <filename>pom.xml</filename></title> + + <itemizedlist> + <listitem> + <para>Library <link + xlink:href="https://gitlab.mi.hdm-stuttgart.de/goik/GoikLectures/blob/master/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_basic/pom.xml#L19">dependencies</link>.</para> + </listitem> + + <listitem> + <para>Metamodel generation by annotation processing supporting <link + xlink:href="https://gitlab.mi.hdm-stuttgart.de/goik/GoikLectures/blob/master/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_basic/pom.xml#L109">Criteria</link> + and <link + xlink:href="https://gitlab.mi.hdm-stuttgart.de/goik/GoikLectures/blob/master/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_basic/pom.xml#L92">Querydsl</link>.</para> + </listitem> + + <listitem> + <para>Build path adjustment <link + xlink:href="https://gitlab.mi.hdm-stuttgart.de/goik/GoikLectures/blob/master/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_basic/pom.xml#L131">adding + generated metamodel class directory</link>.</para> + </listitem> + </itemizedlist> + </figure> + <figure xml:id="sda1_jpaintro_fig_ideaConfigPersist"> <title>Right click 禄Add Framework Support芦</title> @@ -260,6 +284,54 @@ </imageobject> </mediaobject> </figure> + + <figure xml:id="sda1_jpaintro_fig_ideaConfigAnnotationProcessing"> + <title>Criteria / <xref linkend="glo_Querydsl"/> annotation + processing</title> + + <mediaobject> + <imageobjectco> + <areaspec otherunits="imagemap" units="other"> + <area coords="873,218,1051,264" + linkends="sda1_jpaintro_fig_ideaConfigAnnotationProcessing-1.2" + xml:id="targetMetamodelGeneratedClasses"/> + + <area coords="600,367,1049,398" + linkends="sda1_jpaintro_fig_ideaConfigAnnotationProcessing-1" + xml:id="configAnnotateProcessCriteria"/> + + <area coords="605,398,1004,427" + linkends="sda1_jpaintro_fig_ideaConfigAnnotationProcessing-2" + xml:id="configAnnotateProcessQuerydsl"/> + </areaspec> + + <imageobject> + <imagedata fileref="Ref/JpaIntro/ideaConfigAnnotationProcessing.png.marked.svg"/> + </imageobject> + </imageobjectco> + </mediaobject> + </figure> + + <calloutlist> + <callout arearefs="targetMetamodelGeneratedClasses" + xml:id="sda1_jpaintro_fig_ideaConfigAnnotationProcessing-1.2"> + <para>Generated metamodel classes will show up here. This directory + must be <link + xlink:href="https://gitlab.mi.hdm-stuttgart.de/goik/GoikLectures/blob/master/Doc/Sda1/Ref/JpaIntro/P/StudyCourse_basic/pom.xml#L131">configured + in pom.xml as well</link>.</para> + </callout> + + <callout arearefs="configAnnotateProcessCriteria" + xml:id="sda1_jpaintro_fig_ideaConfigAnnotationProcessing-1"> + <para>Generate Criteria related metamodel classes.</para> + </callout> + + <callout arearefs="configAnnotateProcessQuerydsl" + xml:id="sda1_jpaintro_fig_ideaConfigAnnotationProcessing-2"> + <para>Generate <xref linkend="glo_Querydsl"/> related metamodel + classes.</para> + </callout> + </calloutlist> </section> <section xml:id="sda1_jpaintro_sect_mappingObjectsRoundTrip"> @@ -1223,6 +1295,158 @@ where studycours0_.shortName like <emphasis role="red">?</emphasis> escape '!' < </figure> </section> + <section xml:id="sda1_jpa_sect_stduyCourseEnhance"> + <title>Enhancing the model</title> + + <figure xml:id="sda1_jpaintro_fig_BusinessSurrogateKeys"> + <title><code language="java">Business and surrogate keys</code></title> + + <glosslist> + <glossentry> + <glossterm>Business keys:</glossterm> + + <glossdef> + <itemizedlist> + <listitem> + <para>Application domain semantics.</para> + </listitem> + + <listitem> + <para>End user visible values.</para> + </listitem> + </itemizedlist> + </glossdef> + </glossentry> + + <glossentry> + <glossterm>Surrogate keys:</glossterm> + + <glossdef> + <itemizedlist> + <listitem> + <para>Representing object identity.</para> + </listitem> + + <listitem> + <para>Implementing references.</para> + </listitem> + + <listitem> + <para>Opaque values, only equality comparison.</para> + </listitem> + + <listitem> + <para>System generated.</para> + </listitem> + </itemizedlist> + </glossdef> + </glossentry> + </glosslist> + </figure> + + <figure xml:id="sda1_jpaintro_fig_RdbmsSurrogateKeys"> + <title>Database generation strategies</title> + + <glosslist> + <glossentry> + <glossterm><xref linkend="glo_Soft_Mysql"/>:</glossterm> + + <glossdef> + <programlisting language="none">CREATE TABLE StudyCourse ( + id bigint(20) NOT NULL <emphasis role="red">AUTO_INCREMENT</emphasis>, + PRIMARY KEY (id),... )</programlisting> + </glossdef> + </glossentry> + + <glossentry> + <glossterm>Oracle, DB2,...:</glossterm> + + <glossdef> + <programlisting language="none">CREATE TABLE StudyCourse ( + id bigint(20) NOT NULL <emphasis role="red">GENERATED ALWAYS AS IDENTITY</emphasis>, + PRIMARY KEY (id),... )</programlisting> + </glossdef> + </glossentry> + </glosslist> + </figure> + + <figure xml:id="sda1_jpaintro_fig_RdbmsInsertIdentity"> + <title><code language="sql">INSERT</code> omitting <code + language="sql">id</code></title> + + <programlisting language="none">INSERT +INTO StudyCourse (fullName, shortName) +VALUES('Mobile Media ', 'MMB');</programlisting> + + <note> + <para>The <code language="sql">id</code> attribute is being omitted + and to be generated by the database server.</para> + </note> + </figure> + + <figure xml:id="sda1_jpaintro_fig_generatedIdentity"> + <title>Generated surrogate <code language="java">id</code></title> + + <informaltable border="0"> + <tr> + <td valign="top"><programlisting language="none">@Entity public class StudyCourse { + @Id @GeneratedValue(strategy = <emphasis role="red">GenerationType.IDENTITY</emphasis>) + <emphasis role="red">Long id</emphasis>; + @Column(length = 3, nullable = false, unique = true) + private String shortName; + + @Column(length = 150, nullable = false, unique = true) + private String fullName; +... + @Override + public String toString() { + return fullName + "(" + shortName + ", <emphasis role="red">id=" + id</emphasis> + ")"; + }}</programlisting></td> + + <td valign="top"><screen>CREATE TABLE StudyCourse ( + id bigint(20) NOT NULL AUTO_INCREMENT, + fullName varchar(150) DEFAULT NULL, + shortName varchar(3) NOT NULL, + PRIMARY KEY (id), + UNIQUE KEY ... (fullName), + UNIQUE KEY ... (shortName) +)</screen></td> + </tr> + </informaltable> + </figure> + + <figure xml:id="sda1_jpaintro_fig_createNewStudyCourse"> + <title><classname>StudyCourse</classname> creation</title> + + <informaltable border="0"> + <tr> + <td valign="top"><programlisting language="none">@Entity public class StudyCourse { + @Id @GeneratedValue(strategy = <emphasis role="red">GenerationType.IDENTITY</emphasis>) + <emphasis role="red">Long id</emphasis>; + @Column(length = 3, nullable = false, unique = true) + private String shortName; + + @Column(length = 150, nullable = false, unique = true) + private String fullName; +... + @Override + public String toString() { + return fullName + "(" + shortName + ", <emphasis role="red">id=" + id</emphasis> + ")"; + }}</programlisting></td> + + <td valign="top"><screen>CREATE TABLE StudyCourse ( + id bigint(20) NOT NULL AUTO_INCREMENT, + fullName varchar(150) DEFAULT NULL, + shortName varchar(3) NOT NULL, + PRIMARY KEY (id), + UNIQUE KEY ... (fullName), + UNIQUE KEY ... (shortName) +)</screen></td> + </tr> + </informaltable> + </figure> + </section> + <section xml:id="sda1_jpaintro_sectpersistLectureInst"> <title>Persisting lecture instances</title> @@ -1462,11 +1686,11 @@ insert into Airline (icaoCode, name) values (?, ?) <co <listitem> <programlisting language="sql">SHOW CREATE TABLE Airline ... -CREATE TABLE `Airline` ( - `id` bigint(20) NOT NULL AUTO_INCREMENT, - `icaoCode` varchar(255) DEFAULT NULL, - `name` varchar(255) DEFAULT NULL, - PRIMARY KEY (`id`) +CREATE TABLE Airline ( + id bigint(20) NOT NULL AUTO_INCREMENT, + icaoCode varchar(255) DEFAULT NULL, + name varchar(255) DEFAULT NULL, + PRIMARY KEY (id) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=latin1</programlisting> </listitem>