Return-Path: Delivered-To: apmail-jakarta-commons-dev-archive@apache.org Received: (qmail 54776 invoked from network); 27 Jun 2003 16:40:50 -0000 Received: from exchange.sun.com (192.18.33.10) by daedalus.apache.org with SMTP; 27 Jun 2003 16:40:50 -0000 Received: (qmail 4326 invoked by uid 97); 27 Jun 2003 16:43:13 -0000 Delivered-To: qmlist-jakarta-archive-commons-dev@nagoya.betaversion.org Received: (qmail 4319 invoked from network); 27 Jun 2003 16:43:13 -0000 Received: from daedalus.apache.org (HELO apache.org) (208.185.179.12) by nagoya.betaversion.org with SMTP; 27 Jun 2003 16:43:13 -0000 Received: (qmail 54610 invoked by uid 500); 27 Jun 2003 16:40:47 -0000 Mailing-List: contact commons-dev-help@jakarta.apache.org; run by ezmlm Precedence: bulk List-Unsubscribe: List-Subscribe: List-Help: List-Post: List-Id: "Jakarta Commons Developers List" Reply-To: "Jakarta Commons Developers List" Delivered-To: mailing list commons-dev@jakarta.apache.org Received: (qmail 3172 invoked from network); 27 Jun 2003 16:14:29 -0000 From: "Ross Mason" To: "'Jakarta Commons Developers List'" Subject: RE: [Betwixt] Derived Class support Date: Fri, 27 Jun 2003 17:10:30 +0100 Message-ID: <000001c33cc6$a2974680$1ad9c150@RossMason> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_NextPart_000_0001_01C33CCF.045D3520" X-Priority: 3 (Normal) X-MSMail-Priority: Normal X-Mailer: Microsoft Outlook, Build 10.0.4510 Importance: Normal In-Reply-To: <9C884A7C-822F-11D7-864F-003065DC754C@blueyonder.co.uk> X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2800.1165 X-Spam-Rating: daedalus.apache.org 1.6.2 0/1000/N X-Spam-Rating: daedalus.apache.org 1.6.2 0/1000/N ------=_NextPart_000_0001_01C33CCF.045D3520 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Hi Robert, Sorry for the delay, but things have been very hectic. I've attached the source code and a CVS diff of the changes I've made = for the derived bean support. I'm going away for a few months next week so if you need anything else please let me know asap. There is a minor bug with this patch that occasionally throws an IllegalArgumentException when trying to set attributes on a bean. Even though we get this exception the bean's attributes do get set. I think = is caused when new rules are registered for a derived bean and the digester becomes briefly out of sync until the top object is popped and a new = derived object is created and put on the stack. I have not had time to look into this, and as it doesn't cause any problems we have ignored it in our = project for the time being. I've enclosed a trace for you. Ross WARN [main] (MethodUpdater.java:156) - Cannot evaluate method: setName = on bean: com.estafet.smse.persistence.Occupation@1ee2c2c of type: com.estafet.smse.persistence.Occupation with value: Nurse of type: java.lang.String INFO [main] (MethodUpdater.java:197) - Caught exception: java.lang.IllegalArgumentException: object is not an instance of = declaring class java.lang.IllegalArgumentException: object is not an instance of = declaring class at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java= :39 ) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorI= mpl .java:25) at java.lang.reflect.Method.invoke(Method.java:324) at org.apache.commons.betwixt.expression.MethodUpdater.update(MethodUpdater.= jav a:152) at org.apache.commons.betwixt.io.BeanRuleSet$ReadContext$PrimitiveRule.body(= Bea nRuleSet.java:576) at org.apache.commons.digester.Digester.endElement(Digester.java:800) at org.apache.xerces.parsers.AbstractSAXParser.endElement(AbstractSAXParser.= jav a:579) at org.apache.xerces.impl.XMLNamespaceBinder.endElement(XMLNamespaceBinder.j= ava :646) at org.apache.xerces.impl.dtd.XMLDTDValidator.handleEndElement(XMLDTDValidat= or. java:1972) at org.apache.xerces.impl.dtd.XMLDTDValidator.endElement(XMLDTDValidator.jav= a:8 78) at org.apache.xerces.impl.XMLDocumentFragmentScannerImpl.handleEndElement(XM= LDo cumentFragmentScannerImpl.java:1144) at org.apache.xerces.impl.XMLDocumentFragmentScannerImpl.scanEndElement(XMLD= ocu mentFragmentScannerImpl.java:987) at org.apache.xerces.impl.XMLDocumentFragmentScannerImpl$FragmentContentDisp= atc her.dispatch(XMLDocumentFragmentScannerImpl.java:1445) at org.apache.xerces.impl.XMLDocumentFragmentScannerImpl.scanDocument(XMLDoc= ume ntFragmentScannerImpl.java:333) at org.apache.xerces.parsers.DTDConfiguration.parse(DTDConfiguration.java:52= 4) at org.apache.xerces.parsers.DTDConfiguration.parse(DTDConfiguration.java:58= 0) at org.apache.xerces.parsers.XMLParser.parse(XMLParser.java:152) at org.apache.xerces.parsers.AbstractSAXParser.parse(AbstractSAXParser.java:= 116 9) at org.apache.commons.digester.Digester.parse(Digester.java:1322) at com.estafet.smse.message.JournalMessage.create(JournalMessage.java:92) at com.estafet.smse.message.JournalMessage.(JournalMessage.java:46) at com.estafet.smse.test.message.MessagesTest.testJournalMessage(MessagesTes= t.j ava:210) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java= :39 ) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorI= mpl .java:25) at java.lang.reflect.Method.invoke(Method.java:324) at junit.framework.TestCase.runTest(TestCase.java:166) at junit.framework.TestCase.runBare(TestCase.java:140) at junit.framework.TestResult$1.protect(TestResult.java:106) at junit.framework.TestResult.runProtected(TestResult.java:124) at junit.framework.TestResult.run(TestResult.java:109) at junit.framework.TestCase.run(TestCase.java:131) at junit.framework.TestSuite.runTest(TestSuite.java:173) at junit.framework.TestSuite.run(TestSuite.java:168) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTes= tRu nner.java:392) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunn= er. java:276) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRun= ner .java:167) -----Original Message----- From: robert burrell donkin = [mailto:robertburrelldonkin@blueyonder.co.uk]=20 Sent: 09 May 2003 16:05 To: Jakarta Commons Developers List Subject: Re: [Betwixt] Derived Class support hi ross that all sounds great! the best way is to do a cvs diff -u against CVS HEAD and either post it = to=20 the list or add it to bugzilla. - robert On Friday, May 2, 2003, at 03:26 PM, Ross Mason wrote: > Hi James/ Robert, > > > > Just to give you an update. I've got betwixt working with most of the > functionality needed for Derived class support - > > > > - Population of derived class attributes from the BeanReader = now > works. > > - It also supports population of beans with common = attributes. i. > e. > 'Person' has an attribute 'name' only, 'Consultant' and 'Hitman' = extend > Person. They both have a attributes hourlyRate, but the attribute is = not > derived. I needed this scenario supported in my code. Currently, = only > primitive common attribute types are supported. > > - To demonstrate this I've written a new test case in the = derived > package. This tests all the old and new functionality and also tests > round-tripping. > > - I haven't had time to write support in the .betwixt files = to > specify whether the className attribute should be written for a bean = or=20 > made > the attribute name 'className' configurable (as James suggested) . = I've=20 > been > testing the code with a derived XMLIntrospector that checks to see if = the > bean being introspected is of a certain base-class type and includes a > className attribute descriptor. Maybe we should let users register = derived > classes with the XMLIntrospector and determine whether the attribute=20 > should > be written automatically? > > - I've been running my project with this code for the past = week > without any problems and all the existing test-cases work. > > > > The code I've written does the job but there may be better ways of = doing=20 > it > (especially the support for common attributes). Betwixt as it stands = is > pretty hard to extend and it's apparent that certain areas need > re-factoring/ re-architecting. I would be keen to get involved with = this, > but I'm pretty busy with other stuff for the next 6 weeks. > > > > Anyway, what now? How do you want me to get the code to you so you can = > check > it over? > > > > > > Ross > > ------------------------------------------- > > Mobile: +44 (0) 7745 944 082 > > Work: +44 (0) 20 7503 4811 > > Fax: +44 (0) 20 7503 4811 > > > --------------------------------------------------------------------- To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org For additional commands, e-mail: commons-dev-help@jakarta.apache.org ------=_NextPart_000_0001_01C33CCF.045D3520 Content-Type: text/plain; name="cvs-diff-27-06-2003.txt" Content-Transfer-Encoding: quoted-printable Content-Disposition: attachment; filename="cvs-diff-27-06-2003.txt" cvs server: Diffing src/java/org/apache/commons/betwixt/digester cvs server: Diffing src/java/org/apache/commons/betwixt/expression Index: src/java/org/apache/commons/betwixt/expression/MethodUpdater.java =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D RCS file: = /home/cvspublic/jakarta-commons/betwixt/src/java/org/apache/commons/betwi= xt/expression/MethodUpdater.java,v retrieving revision 1.7 diff -r1.7 MethodUpdater.java 106c106,117 < --- > > /** > * A convenience method to get the Class for this updater > * @return the class on which this updater updates > */ > public Class getBeanClass() { > if(method!=3Dnull) { > return method.getDeclaringClass(); > } else { > return null; > } > } cvs server: Diffing src/java/org/apache/commons/betwixt/io Index: src/java/org/apache/commons/betwixt/io/BeanRuleSet.java =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D RCS file: = /home/cvspublic/jakarta-commons/betwixt/src/java/org/apache/commons/betwi= xt/io/BeanRuleSet.java,v retrieving revision 1.5 diff -r1.5 BeanRuleSet.java 2,4c2,4 < * $Header: = /home/cvspublic/jakarta-commons/betwixt/src/java/org/apache/commons/betwi= xt/io/BeanRuleSet.java,v 1.5 2003/04/11 21:27:42 rdon kin Exp $ < * $Revision: 1.5 $ < * $Date: 2003/04/11 21:27:42 $ --- > * $Header: = /home/cvspublic/jakarta-commons/betwixt/src/java/org/apache/commons/betwi= xt/io/BeanRuleSet.java,v 1.4 2003/03/20 19:29:00 jstr achan Exp $ > * $Revision: 1.4 $ > * $Date: 2003/03/20 19:29:00 $ 60c60 < * $Id: BeanRuleSet.java,v 1.5 2003/04/11 21:27:42 rdonkin Exp $ --- > * $Id: BeanRuleSet.java,v 1.4 2003/03/20 19:29:00 jstrachan Exp $ 63a64,65 > import java.beans.IntrospectionException; > import java.util.ArrayList; 64a67 > import java.util.List; 86c89 < * @version $Revision: 1.5 $ --- > * @version $Revision: 1.4 $ 107c110 < private ElementDescriptor baseElementDescriptor; --- > ElementDescriptor baseElementDescriptor; 137c140,142 < --- > public ElementDescriptor getBaseElementDescriptor() { > return baseElementDescriptor; > } 184a190 > 194a201 > 196a204,213 > > /** The rules for a derived class that need to be registered = on top of > * the rules for the current context. The rules are indexed = by path > * */ > private Map derivedRulesByPath =3D new HashMap(); > > /** This determines if the current bean is a derived bean > * This is a bit ugly and probably need to refactor into = something > * more self descriptive */ > private boolean isDerived =3D false; 202a220 > 206c224,225 < addRule( basePath, rule , baseElementDescriptor, = rule.context ); --- > > addRule( basePath, rule , baseElementDescriptor, = rule.context ); 212,220c231 < < Iterator it =3D rulesByPath.entrySet().iterator(); < while (it.hasNext()) { < Map.Entry entry =3D (Map.Entry) it.next(); < if ( log.isTraceEnabled() ) { < log.trace("Added rule:" + entry.getValue() + " = @path:" + entry.getKey()); < } < digester.addRule( (String) entry.getKey() , (Rule) = entry.getValue() ); < } --- > addRuleMap(rulesByPath, digester); 287,290c298 < if ( < log.isTraceEnabled() < && childDescriptor.getUpdater() instanceof = MethodUpdater) { < --- > if (log.isTraceEnabled()) { 325,327c333 < if ( log.isTraceEnabled() ) { < log.trace("Element does not have updater: = " + childDescriptor); < } --- > log.trace("Element does not have updater"); 336,337d341 < } else if ( log.isTraceEnabled() ) { < log.trace( "No children for " + = childDescriptor); 355c359 < if ( beanClass !=3D null && !Map.class.isAssignableFrom( = beanClass ) ) { --- > if ( beanClass !=3D null ) { 380,384c384 < Rule rule =3D new Rule() { < public void body(String text) throws Exception { < childDescriptor.getUpdater().update( context, text = ); < } < }; --- > Rule rule =3D new PrimitiveRule(childDescriptor, context); 385a386 > 415a417 > add( path, rule ); 419c421,474 < } --- > } > > /** > * Add rules for a subtype of the current bean. This method = determines which additional rules > * if any should be created for the deriving class > * @param path the digester path to add rule at > * @param elementDescriptor the ElementDescriptor > * associated with this rule > * @param context the Context against which the = elements > * will be evaluated > * @param aClass the deriving class > * @param digester the digester to register the new rules with > * The current implementation only adds rules to the = digester when > * the cotext is created, however this doesn't allow for true = run-time > * rule registration. May be this should be changed so we = don't need > * to pass around the digester > */ > private void addDerivedRule( > String path, > = ElementDescriptor elementDescriptor, > Context context, > Class aClass, > Digester = digester) { > > isDerived=3Dtrue; > BeanRule rule =3D new BeanRule(elementDescriptor, aClass); > //reset the derived rules > derivedRulesByPath =3D new HashMap(); > add( path, rule ); > // stop infinite recursion by allowing only one = rule per path > addChildRules( path + '/', elementDescriptor, = context ); > > addRuleMap(derivedRulesByPath, digester); > isDerived =3D false; > } > > /** > * Adds a map of rules indexed by path to the given digester > * @param rules a Map of rules to add > * @param digester the digester to add them to > */ > private void addRuleMap(Map rules, Digester digester) { > if(rules.size() > 0) { > Iterator it =3D = rules.entrySet().iterator(); > > while (it.hasNext()) { > Map.Entry entry =3D (Map.Entry) = it.next(); > if ( log.isTraceEnabled() ) { > log.trace("Added rule:" = + entry.getValue() + " @path:" + entry.getKey()); > } > digester.addRule( (String) = entry.getKey() , (Rule) entry.getValue() ); > } > } > } 430,431c485,488 < // only one bean rule allowed per path < if ( ! rulesByPath.containsKey( path ) ) { --- > > //RM* > if ( addDerived(rule, path) ) { > // else if ( ! rulesByPath.containsKey( path ) ) { 434a492 > 449a508,593 > * This method checks the method update for the current rule = and updates it > * to the current bean if necessary. > * @param rule the rule to inspect > * @param path the path for the rule > * @return true if the rule should be added or false if not > */ > private boolean addDerived(Rule rule, String path) > { > Object existingRule =3D rulesByPath.get(path); > if(existingRule=3D=3Dnull) { > derivedRulesByPath.put( path, rule ); > return true; > }else if(!isDerived) { > return false; > } > > if(existingRule instanceof PrimitiveRule && rule = instanceof PrimitiveRule) > { > > Updater u =3D = ((PrimitiveRule)existingRule).childDescriptor.getUpdater(); > Updater u2 =3D = ((PrimitiveRule)rule).childDescriptor.getUpdater(); > if(u instanceof MethodUpdater && u2 = instanceof MethodUpdater){ > MethodUpdater mu =3D = (MethodUpdater)u; > MethodUpdater mu2 =3D = (MethodUpdater)u2; > = if(!mu.getBeanClass().equals(mu2.getBeanClass())) { > //RM* : The = addDerivedRule method uses this map to determine if any extra > //rules were added for a = derived class. Basically if the rule doesn't > //exist it will be added = here, then the addDerivedRule method can register the > //rules with digester > derivedRulesByPath.put( = path, rule ); > return true; > } > } > } > //RM* : This was an attempt to provide common property = derived support for > //objects but it doesn't work... > // } else if(existingRule instanceof BeanRule && = rule instanceof BeanRule) { > // Updater u =3D = ((BeanRule)existingRule).descriptor.getUpdater(); > // Updater u2 =3D = ((BeanRule)rule).descriptor.getUpdater(); > // if(u instanceof MethodUpdater && u2 = instanceof MethodUpdater){ > // MethodUpdater mu =3D = (MethodUpdater)u; > // MethodUpdater mu2 =3D = (MethodUpdater)u2; > // = if(!mu.getBeanClass().equals(mu2.getBeanClass())) { > // //RM* : The = addDerivedRule method uses this map to determine if any extra > // //rules were added for a = derived class. Basically if the rule doesn't > // //exist it will be added = here, then the addDerivedRule method can register the > // //rules with digester > // derivedRulesByPath.put( = path, rule ); > // //rulesByPath.put( path, = rule ); > // return true; > // } > // } > // } > return false; > } > > private class PrimitiveRule extends Rule { > > ElementDescriptor childDescriptor =3D null; > Context context =3D null; > > public PrimitiveRule(ElementDescriptor = childDescriptor, > Context = context){ > this.childDescriptor =3D = childDescriptor; > this.context =3D context; > } > > public void body(String text) throws Exception { > childDescriptor.getUpdater().update( = context, text ); > } > /** > * @return > */ > public ElementDescriptor getChildDescriptor() { > return childDescriptor; > } > > /** > * @return > */ > public Context getContext() { > return context; > } > > } > /** 578d721 < 583,585c726,727 < ElementDescriptor typeDescriptor =3D = getElementDescriptor( descriptor ); < //ElementDescriptor typeDescriptor =3D = descriptor; < --- > ElementDescriptor = typeDescriptor =3D getElementDescriptor( descriptor ); > 724c866 < if (className !=3D null) { --- > if (className !=3D null && = !className.equals(beanClass.getName())) { 726a869,877 > //RM* > // introspect and find the = ElementDescriptor to use as the root > > XMLBeanInfo xmlInfo =3D = introspector.introspect( theClass ); > ElementDescriptor = derivedDescriptor =3D xmlInfo.getElementDescriptor(); > String path =3D = pathPrefix.substring(0, pathPrefix.length()-1); > > addDerivedRule(path, = derivedDescriptor, context, theClass, digester); > //END RM* cvs server: Diffing src/java/org/apache/commons/betwixt/io/id cvs server: Diffing src/java/org/apache/commons/betwixt/registry cvs server: Diffing src/java/org/apache/commons/betwixt/strategy cvs server: Diffing src/resource cvs server: Diffing src/resources cvs server: Diffing src/test cvs server: Diffing src/test/org cvs server: Diffing src/test/org/apache cvs server: Diffing src/test/org/apache/commons cvs server: Diffing src/test/org/apache/commons/betwixt cvs server: Diffing src/test/org/apache/commons/betwixt/derived Index: src/test/org/apache/commons/betwixt/derived/ManagerBean.java =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D RCS file: = /home/cvspublic/jakarta-commons/betwixt/src/test/org/apache/commons/betwi= xt/derived/ManagerBean.java,v retrieving revision 1.1 diff -r1.1 ManagerBean.java 63a64,66 > import java.util.HashMap; > import java.util.Map; > 71a75,76 > > private Map properties =3D new HashMap(); 88a94,109 > > /** > * @return > */ > public Map getProperties() > { > return properties; > } > > /** > * @param map > */ > public void setProperties(Map map) > { > properties =3D map; > } Index: src/test/org/apache/commons/betwixt/derived/TestDerived.java =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D RCS file: = /home/cvspublic/jakarta-commons/betwixt/src/test/org/apache/commons/betwi= xt/derived/TestDerived.java,v retrieving revision 1.1 diff -r1.1 TestDerived.java 65d64 < import java.io.IOException; 68,74d66 < import java.io.StringWriter; < import java.math.BigDecimal; < import java.math.BigInteger; < import java.sql.Date; < import java.sql.Time; < import java.sql.Timestamp; < import java.util.List; 80d71 < import org.apache.commons.beanutils.ConvertUtils; 83,88d73 < import org.apache.commons.betwixt.io.BeanWriter; < < import org.apache.commons.digester.Rule; < import org.apache.commons.digester.ExtendedBaseRules; < < import org.xml.sax.Attributes; 125,126c110,112 < checkBean((PersonListBean) reader.parse( in )); < --- > PersonListBean bean =3D (PersonListBean) = reader.parse( in ); > > checkBean(bean); 132a119,150 > public void testPersonListExtended() throws Exception { > > BeanReader reader =3D new BeanReader(); > reader.registerBeanClass( PersonListBean.class = ); > > InputStream in =3D > new FileInputStream( = getTestFile("src/test/org/apache/commons/betwixt/derived/person-list-ext.= xml") ); > try { > > PersonListBean bean =3D (PersonListBean) = reader.parse( in ); > > checkBeanExtended(bean); > > //RM* :need to serialize/deserialize to make sure we = can round trip > //This will not work yet as betwixt doesn't currently = support > //writing out the className of a bean in its = configuration > > // StringWriter sw =3D new StringWriter(); > // BeanWriter beanWriter =3D new BeanWriter(sw); > // beanWriter.enablePrettyPrint(); > // beanWriter.write(bean); > // String xml =3D sw.toString(); > // StringReader stringReader =3D new StringReader(xml); > // PersonListBean bean2 =3D (PersonListBean) = reader.parse( stringReader ); > > // checkBeanExtended(bean2); > > } > finally { > in.close(); > } > } 139,140d156 < < assertEquals("PersonList size", 4, = bean.getPersonList().size()); 153c169 < /* --- > 155,156c171 < assertEquals("should have a derived property", 12, = manager2.getCheeseSize()); < */ --- > assertEquals("should have a derived property", 12, = manager2.getCheeseSize()); 158a174,202 > protected void checkBeanExtended(PersonListBean bean) throws = Exception { > checkBean(bean); > > assertEquals("PersonList size", 6, = bean.getPersonList().size()); > > assertEquals("PersonList value (5)", "Milady de Winter", = ((PersonBean) bean.getPersonList().get(4)).getName()); > assertEquals("PersonList value (6)", "Rochefort", = ((PersonBean) bean.getPersonList().get(5)).getName()); > > PersonBean consultant =3D (PersonBean) = bean.getPersonList().get(4); > assertEquals("should be derived class", = "org.apache.commons.betwixt.derived.ConsultantBean", = consultant.getClass().getName() ); > > PersonBean hitman =3D (PersonBean) = bean.getPersonList().get(5); > assertEquals("should be derived class", = "org.apache.commons.betwixt.derived.HitManBean", = hitman.getClass().getName()); > > //RM* : Test common (not derived) properties for primitive = types > HitManBean hitman2 =3D (HitManBean) hitman; > assertEquals("should have a common property", 1000.00, = hitman2.getRate(), 0); > > ConsultantBean consultant2 =3D (ConsultantBean)consultant; > assertEquals("should have a common property", 65.00, = consultant2.getRate(), 0); > > assertEquals("Should have hitCount value", 7, = hitman2.getHitCount()); > > // RM* : Test common (not derived) properties for object types > // NOT SUPPORTED YET > // assertEquals("I'm a Consultant!", = consultant2.getCommonObject().getValue()); > > // assertEquals("I'm a Hitman!", = hitman2.getCommonObject().getValue()); ------=_NextPart_000_0001_01C33CCF.045D3520 Content-Type: application/x-zip-compressed; name="betwixt-derived.zip" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="betwixt-derived.zip" UEsDBBQAAAAIAM2G2y6RabFPzhAAABtNAAAfAAAAYmV0d2l4dC9jdnMtZGlmZi0yNy0wNi0yMDAz LnR4dNU7aXPbOJbfXeX/gLi6pqUMTYkUddiOU5O2PRXXTtKpJL2z+xEmIQkdidSQlI+Z8n/f93Dw BClKds/uopKySALvwsO7APj3CUlYfM/ic3LN53MeLkgS+4Pf6T0dRPFiQDfUX7KBH63XUZgM7lj6 wB/TQcAXLElZfHzkHwiBPW5iliQ8Co+PbsOAPZ7vOWzwiaXLKPhtE1AgxMaBx0eXL2/HR1+vvpE5 X7FzMlhGa6DhPtls71YcqftB45SeVql6MeXW/fFRzNKYs3sUYAx/sCdx7OnxUQBiJacx/CYmnp3h xIf/luNA33fHR6enp8dH7+EfkW3w9m328JZ8IH4U3rOQs9BnZC3gkTQiC5aSdMnI1YomCZlHMTzx hGwlqhwagPgLULqNQ9HdF92B0ocl95elMepvUhw7yB+kSBU+wP4Lo6F46PXJvwpjVOPzniT2zWW4 Xa2MfXRT9Mn+NsC+ZkBnDJJVCC7qY58JWyWsA1TEbhqfv3o+fFXwaK/VwKMBiu3rdsW+sfT//how 0Nus+eOC5o9JnU/X8nz4DzqPSvnTR0YDFPcfTi+SRtzhcDQYegPHIa5z7k7PPZfEARqzHzwkN48b 8pMm7Kti6VwMzF5fw9o4N8L5Sa/hfztfnqJnNHCHxDk7d8/Oh0Pye5KCAQBANOPsfY0zL39d5KwM CbpMhv5kqGVwG5zXJnaHgAviLQipEVAzRyV+JiM68azJGOHx9SaKU4Ig7DuAmdi3YRpHyYb5KTB7 8+izDf64qHbepnxlf4hj+vQ3nqTweeLRydTYS3WYTfzZmRAGmlWwFkL16xqjOW3sJaTvDKe+40jh QtvE/B5mgtys2JqFYAMTP+abFCz7HU1Y7e1FAQ3ZY5AzAqze0HI8t+B+lClURr4ODQ2+CaDZ+CvT 20RCwfA6M486Z0PhAJ0zj7pDR/2ewG/Pcp1RyTkK90i+gyeLQXWk46MEFhy/Z4HybumSpiRkTPjJ O+jJFhyDH3gB85BGGxLNSzS/JcI35hCFp9zGMRCO7jdlj6lNClhpzAhHsw8g757IhqbLCsCi59RN T/AnutEUo/4nvzx9AQDkEmh+IB9psoQO0ufV+QZ3HTDgZc1DoIPPS6Si9hPokQsE31QoEzBEpzue ku1i9URoGABx0R29gwctuJjNqY9Tz0N4SiL0zmDxK9DWEYgiYas5oJQzDHgr3Gu+76JoJSm8VuRd kjkFLw6sukOXuq7UAxcCJNeFuXfHem3oRgMhsp5QLZSaJWaEWGZdk19tNYWkf1GPtqrt5RhcxwXS h747csQCK3NwC5NHhVhTYD/O598GuPETGMNe3+aqk9CC8niI24CaHk/tJU0+A85eXyzBci9soEX2 DcIkAjJg62Wv+oDeDsXoGgZsoFg9sooWNk++g+VlNyHoBgtgtTcgw4b90U6z3smHIIDpRe7OT8if JQEY2P0nXW0ZQPkzOSF/wWVT/vwf7AnYMVL0bHqp0xo7m7XetxTjxn4FJkxfDzv066TU0T1XjGK1 KWS4SgvzZ2XUCCWYTS33DJTgbNYkLmwo57bv2EzTsGvMn/5EfFCUIFdUZFnlIcA0D5OUQkIRzcsp ipzdHfxLsk1kieEjd2yN3Kk/Go12sb63iulWUDW1JEkQgUEMo5QsKVggldOcE9SviijMCqbbrtnv jvwEEY1GE2s0mgYjz2nCqlKZgwWS00NOPkeSW/AHwpM1sD8aj/3R+KwKVZBwpxM78uZSZE+oTW/Q dAj3CuR9gLR4Iaj7axytiyMUrQYBNoCWGjMbWqOZ58P/KkW40KQBlu5RrPIGeajg5T7i4Pii4EnZ AoKWuQ+OMo4eEpKFg80ybVs5tpzbng4LLJLZ/Q426/nCKJsqk19ivuboSAW3FXIsjVrM42xMR7OJ 8GieM6aeM221Wz0RqyiXhgA858z3XMfypiXR1xfBs9FrFmsV2N4SsPyl0CzZ3qVPGwYhVy1UESEV RCKqqFGIa2RxAujlOFN0JSFWMIFG0fCJJMtou8JIh/gxg6kJsghOBEGoAEJvK6PB+8R0LcQhOyvj rd5EiF2KiabmoawWJCOcd34UsPe1OOHdQLyvQAKyIp8Loh94qsoxiNSMUUcZOZ4r+UZBJ3RB0bJn xR2miaxy/8Bh7YHI2D14QcRvRkivVEDdTZiZDEsCFbGkjMDFB9RwqSHIcwXSO/7+e0FNIBGTDFCx ZKMQo9UgSBQAAF1C9bBk1XBXKF0kxAayVSpikWX0wO6ZKpqh9Q5/TgldraIHqT7xFldkeJrydXUy hFJIjmJBlg2h1hNKUwAr6CMkrAuY2iQiD0BkhCgwuq5SGIHOJZhURFsIxIsMvRtwU6hqDq+F3QPh XOepRa/NjbU3ZTuFuTgcSj2RrK2aF0BX2p/Z4hdAEnou1f0FYK61ImahoMiOa75QJ0CXqGcX1c+6 MFJ0Cfpdry4/RbapSKrbYBCzRBWMdWpYN6nQuqWlDVhM/qWZIpJgJs7DOQ8h3YEFBWteFEogoRYL EdVPLPgoVKLYKPPcSsIVukvBgCQGAqCfBz9bBsUjxaxtd0qI7NflUw77G+a5kOhWkVT9qtGjYra+ pli3UIavUnzQhnAByMKMILORlgCoqEJk8KS/29Oqo4eEd2v4XR7ZUvvQRkoLFKkQJFhNi4eYG5/L 5MtO+D8xInxPhq39dTPk342Zd4tO6NaUjne1IN2T9K4Qd6QR+5q2V0zqu6J+7t71tQoAu/C1kGT4 BK+80dDyRo7vzcaWN6vVAMD8ZaZNVO1kpIlmD0Sc2zlDevamVDRCE4YxHzIpTUEpBWszwF8/vW3+ LFDlwYRYa5ZAkOkR8GBoeSrbkVBv5FHvzBXEet4ZHQ9n1vhsVLFFxUTBXzL/h4xK1RuZlNVKt1Ko of4OZrMayiu7WS6gzsHj+SxJKOhJsw3NSsYIBBjD7QZz7yzHED80kaYwX2/UYvSparsCQx5TUrEG AYTwJ4LWqIK2tfZamNIsxLCKwV6/OLrFXvx69zswTNgjhMEw9qsMVYozDkusJyC2rC+w4kUIl7v3 inWre2J7s007xx+6FSTe0vtZaXXvTebSG4hU8Jq8vW7mbFq3ilSK1bpSaQALM3Fbh34zDlNcWm+/ 6aMB6Jh6ZdhFEvt2W9GkwzxkiFwDpvg1MIBQt411T5QkoG4si+7j0Utw10JyZWDbPXxhFZprAOfu FR303qy3dvn8hs3+sQWF7QH4ypf9ghndhG8h5wQz+XJCmhnsBINOYdMhAAQDmhV/dFkHwp6YHoJa mCBIuGNtLA1bhDYkWTThPjjcp5KhVZWAQ/CK5YBRpa6tSOxLIMRCBPL8jVkcPkYAhRrJC/jGMpIx AejUXsmqVls3K1ttHeLAfeKyXCtB7R4o5EDgDtOUrTepqMHE0T0PsFiEZy/wEcKw9ClTnGS7EYcC QJ3qkCPhDRNytxUqoAtKD1H8w7ZFEGGOlrLSf6PBz4oBBluvv7UGZLqVTXk2tGzFgxbz2hG8W4Yf vxDuy812O3zduprtw6A1m+1u8A40292A6/aqZntf1K9ltvfF+9pm+0C+q2Z7PzCdzfZB1L0ixKoj 6Db6eXfXli4tPqIxWq/G5zqNkgeMykE4qDwLg0Tu4rWH1fVyeCWoJZdN51V1q9S8CwOax6iN0fK2 4k5aXq8w3yV8RqtSDfGBucqbDtGDBJRJR/06OBfbf1N5F4EHbi93jnPyVq0ll1tWb2jrYyjl6tZ2 VvCqzKP5lGC1qdXYfcrbZ+7fwr3WdORZ/tyP1721szTdgsXxdBZMXXnWbDwbWePZ2J+6E2vqTttO jdTnDffpS4sPmKof+MwO+kGX9pM0g0EHHEFxonefPDK31+IFJD11PX82mTTxhZVN4QQ+0zXTp1ia zry0DhKnarK3OpbLTsigWcAPOpiDGaWzyZk1m7ac8MiKuvt5ZZ6dlxbV0jlX29AGsUYYAxIqq69x JGqP+8/Xf336G0art+E8Io/rlfh7WSADrGL+0ENc6njRAblnnQkVLZXUQ1FhG9XkELSFkiqAxz9f Yjbnj3ayvUvEt97QKr5fsXCRLnv9U6fj1lO1Vbb+ZaRW49UquBYl1rYtzLzBav58TYR+HX5bZsCD w4erMxdPh0MQJzbYogVCzJJoG/tsd4+kuUsKwmz/ikTu7qHY6NxR87v3AC2ggwcOlJ6VbkN1HDP4 REO6YDFahP/9K1GHEt18L8op3ItySJ1ZdZcFD/HVL56ocxcXxo/qAzgHh07H1nRSsBvFywaqlsUh 0ayf5pjN6JlnOcOzktEpB0+mYMlwNxBxgQH9kqHrFTYgDEGRCoJy8grm57mdHLmztqabdopE2J6U SEIiYVw7ZSWJrZX8ZXs+SMe/Qz9lnf//6HiV6K46Xmd2Mg4m4oBpUYd5ZN/+WryeNZlZUy+QwVel o3Snf4/xfMZF9fsayxO/8MU18/marhq/34LjWxjGJ/9Y2XgJzvjhO183f0hSut7UvpaujA2DqVPo AGK3pdhtJXZxaQ2HJPYVXvWN09/wAceOrBnE9qNdw8WsoZTQquQyah+WHZ3AaOGiY98bUetgAd4F E9UmAx4IpeyEPtofUpizu20qOjnu2HLcCd53sxzHrYbXYksfqe/1vrA4iUKUHj73QcvwPqUNCz6B vJiHRF4Q2ZEplKHIjf1L0gF4e+yV04kQsbMzcqnjnFnOeGi2PrjYcrRagL2G2kEzalFRF+Qqqosn A8WL1jhVcarLlXmxuCIqech/lxxuw802hTXJwAiD1C53R6tI6l/BUhVG9tBZoK3A972TfSzTRtB8 ugKiTyGWRZ07aT/Jg4er2gWs2x+kOrplKpSpglYl42BVlNe38iA243TF/8lAFNlv/LCmPxhJtjHD s8aiMC1PE0PUbwYrt8Gw6I33VnCnijyxFFM7JexsF0udjlk96T0wM8AHMDzizOZWHjTNM95ojrcN UY4gJp4mmILM+WIrj08rxqspa9Hik+RBaXvxbcP+UW4EBU71M18sanDyYB6ej7GZODoH+VmaPn0B vGkDxsIQFALLZ7SBK0w3gaLkwU4j+aZxL0x+Vgs/KT4UBaIMAIBtgmPQane3WpcQZjpah25WanfH kmgpXULiIXZ5/rV7QXG0WRFQu2eVFG8fj8Bwe8PAGU+Oy1c1QXXBEd/IosxJLiSCx01PLOJZ8goL hrvZx15fnUYVjmE88p2JuGI1eJufx3PG4AjH4AinTjM+dd5LXCbL98D0ljSgd1wLVrzIJMTe39WS gTn4liF/J4Lhiod8ZRzOeEadqWe5QzfHAuNT5uOFFuH86nph0MNuZfS66zVo1q5pm+yctn2A4uUZ RnrjPkA++cRXNMDjAuTvYClYDO90MCNXlhExHpLz+v1Ctc+gxLsImAgCvkYgojmY5+6YxzXMdeQ5 IDTbyXaV0jDNLcdO3nbykx9uLG32Ikst0a7qiyGzogkpObEKRAqlVVvlGZfHR7v5XPJ0XXT6O6X4 B/P4kaefaKj4k8QZeatxlu3oQ1ilD7b00N0H+hBjIdHFDfeN3iIUBfTa9RBCclIUIcKJ5G/76nVX iSjzUzl0g9ZnOBzaw6HmV1igr7g11rfIsMZoWQsKOiDIK3/t519LVO5H32QsqCtgaqfQhONbAQew eQURm1rTgGBaYv2j+lyYZO2F95xieVQpn18N5vOv38m33758+fXr95tr8t8334sfq5Tf/rwGqeRy fXNSE8WVoEUeE5ZKqg7cG8IIE/CPgvk3JyUxtAD9H1BLAwQKAAAAAADnhtsuAAAAAAAAAAAAAAAA DAAAAGJldHdpeHQvc3JjL1BLAwQKAAAAAAAxh9suAAAAAAAAAAAAAAAAEQAAAGJldHdpeHQvc3Jj L2phdmEvUEsDBAoAAAAAADKH2y4AAAAAAAAAAAAAAAAVAAAAYmV0d2l4dC9zcmMvamF2YS9vcmcv UEsDBAoAAAAAADWH2y4AAAAAAAAAAAAAAAAcAAAAYmV0d2l4dC9zcmMvamF2YS9vcmcvYXBhY2hl L1BLAwQKAAAAAAA3h9suAAAAAAAAAAAAAAAAJAAAAGJldHdpeHQvc3JjL2phdmEvb3JnL2FwYWNo ZS9jb21tb25zL1BLAwQKAAAAAAA8h9suAAAAAAAAAAAAAAAALAAAAGJldHdpeHQvc3JjL2phdmEv b3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvUEsDBAoAAAAAAFCH2y4AAAAAAAAAAAAAAAA3AAAA YmV0d2l4dC9zcmMvamF2YS9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9leHByZXNzaW9uL1BL AwQUAAAACADnbJcufDHBbQQLAACVHwAASQAAAGJldHdpeHQvc3JjL2phdmEvb3JnL2FwYWNoZS9j b21tb25zL2JldHdpeHQvZXhwcmVzc2lvbi9NZXRob2RVcGRhdGVyLmphdmG1WWtv20YW/ZwA+Q8T oUDkVKHiZItFHDtbWqJtFrLkFamkQVGgI3IkMaFIgQ8pRuv/vufODB+i6DjdzRKOTXHmvs69c++h 0n/+5DF7zn64EtwXyQnrr+K16HvbdJPPw8Drf+KfeZLxF168XsdR2p+LbBd8yfppQmtb3o+TZZ9v uLeCVGOP+LJJRJoGcdS/Ftkq9mcbn2ciMUiwt2XHxj/Zq5cvX/dfHvePX7Hj1yc/vTp5+Zolfhx9 DiJmfdmwH5R7U7ENSNGJFNIPh1B20qpBbpCbzr7DVSpzV4KZMlbmxItsxxPBRoEnolT02HuRkIdw 8LgUGMSb2yRYrjLW9Y7Y8Zs3b17A3Vetii7iPAI8UGEwZoYhk4Kp1AMYRbIVvlFqngo/SLMkmOck wXjkszwVDKilcZ54Qj6ZBxFPbtkiTtZpj+2CbMXiRP6N80yqWcd+sAg8abbHyI2NSNZBlgmfbZJ4 G/i4yVY8wy8BRWEY74Joybw48gMSUv6R4FpkJ6V7x0bDw5TFi8I1L/axPU8zxJVxuEy6+Tze0pIG TGrBFcUZAO5hS5CyEApJT2VdhrnvGqx6IQ/WqLPSnVeH7sBsDZ7CHcTs53Dx/+QRrBZqaIsfe/la RBkvcojTxGKsJGxNByXgYVqlQeYPi4WGejxVqK8NWV0i8l+gIJKGjSDywryuDDHX9fRYsCj08+i2 p3DRUo2wuPc5inehWArSf1KI4eq4hI3CspROkX5d6r7YijDewI35bT0iuu4/Fqy7yrLNSb+/2+0M 1XIM6j5HRqdQYIZALQJ04a1O0L6TgPWW8c1GcEqFjKd0KshSES56hapgITO5QzLgbcLS3CPAgsR/ sUFHvG1oTlEXyZqHYaG/ysg/VEYivgYGHbr9RTVVdpPEn4SXdXqsM1C9E7dktdNAoXCqAqOjMoNi ZHNBRx9FF1PW4wRtAGUE9NdxJoospAA9CdBCClULrCuISgR0Y4BIQG0ioTYQqYYgu7gB++XzQk+1 3GObUPCUjgzKDYlXOfq5SlWFyU8GBb/nWJtHlC4dogdsRYlMmXGgLncVz/ezGyQa9tbQDkOgo5xV vfkyifNN5bR7ZTvMmVy4H8ypxXB/M528t4fWkP3xh+ngwbNnzBwP8e8js369mVqOg7XJlNnXNyPb GkolkJ2aY9e2nB6zx4PRbGiPL3vsfOay8cRlI/vadiHlTnqwZxWiNTGpZXLBrq3p4AqPzHN7ZLsf peUL2x3DKruAUZPdmFPXHsxG5pTdzKY3E8dicFzKD21nMDLta2uIYWOPYZpZ762xy5wrczSSls0b c4A/ZbwXk9l4aLr2ZIyQpBLbddhgMnanNryfTB12bsF/83xkKQcAw9CeWgOXIq3uBoAMbo/UUXNu rIGND0DMQqzm9GOPIINex/r3DBuxyIbmtXlpOax7iJhUUkcNSRnMptY1RQOYnNm549ruzLXY5WQy dEi5Y03f2wPLectGE6A1uZBKZo7VgyXXlA5ADdDEFtyfzxxb4mqPXWs6nd0QCkfsavIBoMFXc0aJ RgJUbsYydGA4mX4kFwgTmaMe+3Bl4fmUIJfImQSJAwQHbm2bUjNFOFO3FjMbW5cj+9IaDyxanZCm D7ZjHSGttkMbbGX6gwm7M7eoFMomPFS3tRLuyZwz+4KZw/e2rFW1GaXi2LqsNDjObHCl0yAPxPcm VvVTj/6RYiZJyrCNwxzdBGOauko1vtegqzQ91phSUkWAAYw5mdPIxEGeixUPF43z3M61qKmtY91k g4jogJo3cfSAcNnxUqGkT9sn1DsFmfz1g+2fsP+NDvefPIbuz3xJjX5ZGNLs29Ds26jY99snj588 DtabOMkY2TJCHi2NRCxCDB9D+VLf06qUR0A+TI1BHGEcZjP68PZrImG8XIImGKN4+a37LjA14uRW +tJ/Djg3706JLL7bw+u0L5+xXH5MZY68PElovpOfslLEl4zwBuAoEpodkrGwD+j8QmmrKJCDusLq loe5KKaQYL9ejxjPVMkJrQuVIkI5743T/uadfKhWfuY5lCbslLMVkD3rrHkQZvHJJ3ArhMuj2hjs vPtFDiVHL532+TutZatfIlpeeFTe5VsZA51M0/0qYkA41FSkePQnAUkTjsAEvks8Iy1y6GHoYhNL iRl6tMqQCXbGqjwYS5HhU7dRrsr40du6cnWHCDDVlwlf0wnyJBtKRSYVlzt+Bn3ia8bJIuFc+q0O HVjMbhUorpXqQFPM7tAnNYWWIggFh45hGwc+2ZM+k3pp44hgYPpSIXJVk/TgTv2pIiF+tlYFAlco hqIPyNpqwqdraV0corqa7HYjig60CBLQNRm6oNTox9pSU+tAhi0L0oWSt00nzzXNQnHllKomIHsJ 65YIHARbJkWe6igQkbevF2imhZNgkmBKYL7NVBZwrUo4gNycXka38WdwNo2fPpbPUoWk5t/qFLfn dT+MPaj3sgov1WK38OWoSu8j/CDW0mmTHCmDrVKNYpcOKewxBVQFKv8SKKGA8cKaJzocuQ+x1cpV by5akxRCSI90PEo1DJ0DAPlB5ebRo2DRVZ48PYvyMNRPH2lzaomO41DALHUrLf2Wtt2hKaEe9kRI i1rEr7uWjM8e6p5le1yCnUf7TbJZAYWMxK+4lzWgkPCbApHYvZeaqhIgAQki1hpm9qtCHnMl0y2M aQfA3Ob0RlXq3ysTvSajPCtEDJ2OblEydOHlr6v2PT2TUO53kXJLGUaAI8NRTzjWGqgDAbr6fZaB ylBjUWMUgviAY78OMsAsW0Z6KFfaOWP1+WtoLV3WVVaPyp29qnuwemR03X0tknsDpgv+Y4Z5n5n8 SijAT1p0Mi9GDQFdioCmd1P0UJm0+7Ty0whSE3xlGfF5KC4whiuvKEnFeTlqd40udHcDFC3qtlgr rs6AR/RKKTs7GgcdV3W+TliH/Vg7a2O0atj7EY8loeSR2kF39+un7eroIKRKoBZBTffX1fC0NjD0 DJyriVLqrtD7Vq2gM0ibkm7B90E9zWoqLtV4WhZRbs/7zYeNimwuH25Rh/e33xlPlrmiOWfsz6pu 7xqW6Zy1lIksOqqTIB2Keb60ZLX53Qeqyqe9D5SV4pj/dUk9kDZZU2Vr3E/f38jU3eEj7Z6a1qrt 9Woot2lpZs/jGUZg1/riiY1kcaIVzfoMoZolOJDFbrP5HLF/PVCaiJ82dlp8e6gJFA1AkBs0d75b quTexTcd/DKj357NA+37MB4KtSUObxt+KMo8dcu5Kb4yJPTtXSvhvySGWKOyig3tAnTXGgVU3/M2 yF6po06rWhlkq3gbVyRypangXgXuEan7qH/pj1PEJKkwBzNSfESOOoy86tX6b3Phb4ikeI3RcdxP e8kXQxs824+NLll1aJiSU5QbqAhviqlC1ZMeMh8toZnAX3+pB0YooiVK9vSMvTzsltkqiXeyQdlh KJY8NHUHqYpNffldxENfX684OA+YBH2LkuGciWrgdfbq964RdUVuzpRzv738vTWtfWbvv18qFNJi +cX3uiqbbQWFN/1MLG9rrxuc/htFfffN1VdaeKiOJ+pLQ5YyP1gsBJHz8NZo1lob654L6rCaddP/ XkRFyRatOfZA9w8ZuaLiVQeXDE/vZX4uG/f9lZvEGaYzdsribXaZA5Z+36CQgzlaxF3q0jn9v2np t+p54LWi/nK3h3cZ0lSedvpGkfCWgKRikYfyra74vqkCQDeHr+1uP6l6nmWxumltOR1V78VXMr+p Cjirhg019t87VUj4+Q9QSwMECgAAAAAASIfbLgAAAAAAAAAAAAAAAC8AAABiZXR3aXh0L3NyYy9q YXZhL29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2lvL1BLAwQUAAAACAA6bZcuFgP/q58iAABr nQAAPwAAAGJldHdpeHQvc3JjL2phdmEvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvaW8vQmVh blJ1bGVTZXQuamF2Yd09a3MbN5Kflar8B0S3taJsmrS9ex8iWT7TEm3zTpYUkoqTSqVqhxyInJic 4c4MJWu3/N+vu/EcDOZB2dm7LGo3pmaARqPRT6CB6T/69hv2iP3pHQ9Cnh6x/jJZ8/78NttsZ6to 3v8t+BikefBknqzXSZz1Zzy/iz7l/SzFd7dBP0kX/WATzJfQyqkTJf3XPIjH2xWf8LyH1bu37Fnv r+z506d/6cP/nj9lz74/ev790dOn7LcsTwFMELPhpw37k0BrzG+jLEriI2omH54FOT/ywqAKVOnk KxQNbLrkbEBjZJPkJr8LUs7OozmPM95lP/IUMQQEn+kGp8nmPo0Wy5x15oeA3vffP0F0vYDeJNs4 DHIA0WNssFoxapgRnJRnPL3lYU9DHvMwAkJFsy22YEEcsm3GWRSzLNmmc05PZlEcpPfsJknXWZfd RfmSJSn9m2xzArNOwugmmlO3XYZobHi6jvKch2yTJrdRCD/yZZDDfzgAWq2SuyhesHkShxE2Evhh wzXPjzR6z3oOhhlLbhRq8ySE6tssh3HlAaCMsINZcouvJMEICpQ4yYHAXagSZWwFABGO6Z2GWUQN ep2vgmjNU0Ot52V0oFuLPAodGHO4BRR/J4ygVwUGq4TJfLvmcR6oOQQpYgm8SdkaeDuNglVmpoHm D14qCPZ4zFD/0iPu4nH4BBgidfqI4vlqawODMdtwuiy6UfCD+L4r6CJbOcMK5h/j5G7FFxzhH6lm UPanSBtBS906g+mXrB7yW75KNoDG7N4eEZZqsWCdZZ5vjvr9u7u7nlA1PdQ6h719BWCwAqrFQLrV vZygIpJA1nsWbDY8wKmg8Wikojzjq5uuAhXd0EzewWQAtinLtnMkWJSGTzagCe8dyBnwRboOVisF 38zIX8WMxMEaaLCPP/9bKFN2lSa/8Xm+32X7p0Jnwk/sdd+hgkLKEGNfzAwwI5txFH1gugRnPUlB DQAbAfXXSc7VLGRA9DQCFaJA3cB7QSJNAakYoEmEaiJFNRALhZBlpJfemOcKjnndZZsVDzIUGWA3 mHgxR6/MVBma/GcPB19AzIcRTpcc4hxoyzVl9IwD1amWel6c3SiVZPcOrTwEFOXc6Oa3abLdGKSn 70YTNrl8M/0wGA8Z/L4aX/44Ohuesb/9bTCBBwcHbHBxBv//mQ1/uhoPJxN4dzlmo/dX56PhGQGB tuPBxXQ0nHTZ6OL0/PpsdPG2y15fT9nF5ZSdj96PptBqetmF/oaqqdWMoFy+Ye+H49N38GjwenQ+ mv5MPb8ZTS+gV/YGOh2wq8F4Ojq9Ph+M2dX1+OpyMmSAOLU/G01Ozwej98MzMDajC+iaDX8cXkzZ 5N3g/Jx6HlwNTuEfPd43l9cXZ4Pp6PIChkRARtMJO728mI5HgP3leMJeDwH/wevzoUAAyHA2Gg9P pzhS8+sUSAZonwtRm1wNT0fwB1BsCGMdjH/uIskA7mT4wzVUhJfsbPB+8HY4YZ0yxQiITTWYlNPr 8fA9jgbINLl+PZmOptfTIXt7eXk2QeCT4fjH0elwcszOL4Fal28IyPVk2IWepgNCAMAANaEK/H59 PRkRXUcX0+F4fH2FVDhk7y4/ANEA18E1TjRMgJibCxo60PBy/DOigDShOeqyD++G8HyMJCfKDZAk E6Dg6dSqJsCMYTjjqTVmdjF8ez56O7w4HeLbS4T0YTQZHsK0jiZYYSS6/jCAfq+nilNwNgFD8dNi 4S7NORu9YYOzH0fEq6IysMpkJNlKEmdyffpOTgMJxNd2rGypB/2RgU0il+E2WW1Bm4CZRq1izPca 3FS0HmuwUgQiAgMMdnKLJhMEecaXwerGkWe/r4VKbZ1IJRvF6A4Ie5PEDY21xsu4aP3Cb6FeCpLR f/40Co/Yl7nD/W+/AdgfgwUq+oXqSHrdPel196Lk+Ntvvv0mWm+SNGfYC7wKoMII6JhkGzA8MITh pznf4I/jYlUg86o3SNPg/hymwvfyXZAt3wcb36uqJhXVR2C0gzxJbXxrBjbIBR/wM57N02gjWja3 G67IUu/Y6qf35zhbI+CLtvUNgVv2EUYLngER3Mbv+ApsUysQ/NMGggSy0qcgKPxTvmuz9xxMZHi9 CdHz3LVxm2Z6lMj57WqeyR/t4YJE1VZeJYsFOK+982TRtt6bAOfivlj903rVy4JPhhkz4t7+I1AC m5eARcZeYJzz8rUg1os+/cUEsqhdUsA2w+CDBQwFk0GMkGW9F/3NSxByUoygLl4FW5iWlL0I2DLl Nyf76yBa5clRGibxxyi2nKv9l+NkxgG919s05RA/nlGNF/3gpQR1KyNUTzQtlAqF+gIPW0UxGPdK ernq0T+xEWP2f3HsQK4FOMsIjTwr8OyAL1iG4ccc3zIgLDthhqy9Bc/hr05BJwoUDo9d8OIXWCPA AAGBy6u8X7AFiuAajiJ6FAMC8RzIrQC8Ah8+WLMAMUIdL5rCX7qJGrIwBThN5JoKzKBf0b2Ep4Yr CChHe5tEIVgGGh32g50dKsJhEaQIBCvig8/ueK8zLrqFDiOtGIhdshKRHeVhNSA1pGBiADJDo7UJ IAQEUwbzdbeM5jIcJK68i4B/gLJBniN7haW+JsD1EAIinCsA44DngnTg2StVKwkoe9bgSiqZ3vsU dQF7lBasGLISYqc0P/gS+YD+slpPIAhYhWx01h+djYdvMjt2AqMPNBCknac8EEsgICnJNoOortTT LElWiAi1G53Z3QQYIuNKABJQqAfJqjgd0U0kekxAIFdJIJYL8vsNJ49HYEBYVVCdePAC4hqtfICN 9vXTfVdsJMc9Yq9ldAYuxRa5oqfe6BpSLmzWseTD4TAlK4qCFoe6ABWjaAJkBLajFPyTLL9f8cNd eNLXRZmfDPKldy76YtJNj74ONFNZgOlvBexumWQYt242OFNFzCVXuXAVA7GsHXf+lwJQ1DqW3usY HeOWOiXRrW7myHuXVVdtKdN1IDxCXIObK4gFHYvas1dg5xOfYtRVNaOeuMqtUKU8yJNa1VVobJjo xKupdGXNGSeultGWYk/OfhkhsKuvfRh1iD57eynPt2lcifXe57L+UMtYKqwy2k0I6xz1sq3k5Bob MJ3Sd2kk1hE1TNR7CE86QcTvQQ5/zsGXwcXhTQLzpVfrQPLXQVlvgc+FyIX8JtiucnYbrLacgd08 0FrxQHtW1MAIoaRD9diUCBbUtfADVAOBvF8upejAdJyW9HanwKsSk7J6N5NenhNyNfMHTIyZAf8M Nc+MhvB7T5HQkx6z97tNmvLdPFNWaYTLesdrqJunF8KI/pOGQo54Zvvm5KhaHGLoB5QfC9aixVCI GIBSWZbMI3Jy5FYATEUqYNqzYAN5AX5DEi9eXiQ5f9GXfxiYGW0D4XLtHCOQOAevKdtuMGTiYYP0 xdvVqkl8LlRH1+ORV3AQSIUnrTschKEVeRFjA5csolseS3OuXBJp0St9JBV2Wp6A0xQhu16M9oOx Z+3ShKFxCzyMCO9xukcqjNFuk0aiQI4xD0K5CACkMb9PWMzv7LcdM4jDMhO6pAMOGKBMkOwY9hHj oj1CcHsypS4WabBZauKxQayjMNcfYjxAEkUglf98tYrij+w/3AF/RkUhdgB6Vdz5YclxD810g02U r8vDrkSUFhhlx7jVQrTHmdLLCHYHjgMuFIhNX4vsdnhiQgiIS0XHpB4FTtQyAi/3k6gQGVff7u19 sBHAXt+PQpg9mj657NZRE4aljENjl+RoV3VKrV/fSz/I7XVvr6o/sZih9nNkqIyMEXNB4xnuNy4i JDM8wPXVZIPsZADCXHqkRSoUNZAeszqlvTtnYAV4OMq9PXt8EsNx7TAVAHewEe5Y5bhlFCOJbwoI EuvjtqOmgmVjBDoEgarMopxtF7hjGNNu+yyYwR+KVikYSuWiJyxL1hzmMl4UYOGyNcNtSx1qQ5/e aVVOcpSdScRO2E2wynjlSAsdnRI3Z67qlAJEDsjaFqJi6/Yas9CsoD5nwsX3xVW2+qSWfaXEsNj6 rl5vWiCgqHiKOpP8oZ51TED7mO3391m3Ksgp+vs2X1GHe3t7UtcZkEJTVYPEtz0l0g5EZwzAnR1c ZurhtM+2i2EMLMZDsJ6FgauCNUOs12H7A9KLaQLmnNCByUDROmL7MGR79ELOzfPK0bLPzMXVDB+l zlI7XTNDFpDPZZQfUqr4XHgH82W0sn0E4RtYS1mgz8SzDYho9MkGYMOSTC8rBQ5kyqgBLdAxnEia S1T3wJEaxgrwXJB6jdLg6oMjGcdavxBPlAgGiwBNqBQ9YcyUpHH02smsWZA92kZ5LaeIHqnZTk24 bxfp7gky1K0R2KUc/Jao1RaUsutavlw5KQuYkK9pCp6plq9K8cLNPN5B6aIgwpk+lKHyRIOQvcI3 giglqarDr99HFO84WckAbQpYXnSOQJwDEeHBS7nwtEqSj9sNcUaSRosoDlYlaEEmeKxMcsUjB0vK EDog47AMbjEkkAPV4VnWl0vEWa/Uw08//XQk+pBoacs4w4ypmMukIXYB7Gr6z3o9B5ZnMRDGW1iy gaiivD7imQGX5v1+C+BGDAsLsqo0IPvLr4Jo1ggBZrGTng//rONiS1agBOy7EwqY/JYAmbHDKKqH Xp92WRb9g4JXB0pvxeNFvjyGai+oDvx6/NgPk+AiU/nktQjX09Mv0a/Hfpg7yaAqlixepckctzG1 PJIUFrt3SapKhUXyP5W67e/bYEWrMBjQlkeKk/qDXaU0n6rQvDrQ6iZVFTN2tj9axAlitV/icbug NoziLd+NCkqXC/9aGsLHRYwrIIIekJFLSIEc8uM6+Ijgsm3KRVSRcpDUDD1epU0qgeECGHi7ervQ 1RWqtCV0j+OfmUdXeKYPZqPe+Pz5z344wJkbnub3EkytxKpiMTY57WLxJAanfy4cOSRlmXL7ddMv VvcgxIJpfPKsriIQymXnKPuQBptTMAoi4yQbxVL+G0SUAMpeBfP06M/Lm05hLuowJxiAlISD6Df2 iQVYRlif+CAHI7bZ8LjXa+FC2B70ZbLJ2BPblBlg9eKmSoPYqdLgFuPspXyd3PIJuOVGFHs8DrMP Ub7sQARz+F/Pjp429CMFef9R33gjvWw7y0jOBY276rkwDJ3DJ1bXdWP+zCEYbZgZmBXwVsinCBTn Kk9CL1dTlFwl36r4zC3aa1THPklsYWXdgmyHICUlkPna8Z5F5scI4Jenv7a3CarU8ETNKx2LbigG c0S5y6qiTrs8zFb4fBQctUwsaqv9HuQLYLHUppxr4LOMbUX3bL++9WPW6RTypw5rx3KIf4n6Hfot prRWPOrHXOouyq7SaB3hetAUBKMq4rcLTH6hzRdzApaaETGU+CakMOQI5YGKKIWwVLhoEL7gI0Ru d0FfpBCaUGgKgt5CqXtdtAdqBKdzxdTgARReKKXxkj1tnjgsnv1fDQ8DHRs4KJQWxkdtvOiWP0h/ 1TzZXS1hccggwHoJQa+0JWlPDCxf3RWxC6noxyfsoH8Asu8g3IIEqrSr2U5S7FJ0udu3wwK6zOsf 7O8f4b8PHm+LxbuGKg2vGxXJOrifcb0YIlZgAlyzAp13K/e7aV1krjmkH2AKdD1kma1iJXV41MUE OtuuglS59EIpt1EY3pzgkn63+m+h6rH8LuoeS8MktmbmJmekNVK7+0LNSHr8hTDhGW1/k4MqPYfK uKqwQ+2WZqv1pTbp97BF1m5D0ftqZsjy0iihIAaJyL2izQeKO+DHAz0lZ0VaaHFU4g/geE83ziPr T+un+YWbDwORKSryd26jhcw2xpNwpdXajVQdLJnhqUHlAxmAj+xdihBUeIyEvFOnd3X7KOuxqMd7 wLFYAd/9Br/K3dqgzYIxJT/TSnGU25sNPbv6VKze4PqtWrYNtnmCJ2vmdEqyYhG30OcYMcH+ppdn l70cZoPWgRLa8b1J7A7tZnrnRYzX8omAJKGbleyS1YakSSFPqlZvrsgUFAc25UNJzW86khvjSEvT gT0Ya0fFm9fnWbMu1/MMvySGZdNVbtXaepH4G1i18Vqe3lepBOvADfu0XtG/xZxNK5+zYPcqJFVO jYTl1ZOVatIj5GxOqbgdfXKK8Ur1hmrtLkjjDh7wRVlA82ClSdtbpzrTlXHvUKq1CxZc49Q9EJtj Hk5Oe92GAbKEbgmgHZ4YXaEDsFSLJC/CkgQrs4KFVaVGs6VigKkBAe2c6513vZksVt0JF1K0Qaad sUh6Yw3yjepb5xTQX3Ram+lctqqccRuKo/il3RYwGhLH9Rn6WRLe0yB88Hfbb8Vqak229bar2m4t +3N+trSLtUjfZo+05QZOe1DOhmsr17VYw03S0FQgClQZ9sNjBwzQT7maBAxl8N+Q33lp6v6IHO8m GohAocDLZR4tDb3bvN1fnwVke5Ae6FU+pBPZIOjW7asY0Z6ISXDDMa0sRCsgGQMQlVkr0GeT5xTI aS5yG7qAMn0WOMzTTvC6nnYco5UKC21b8aMBUMmHNpzKTOavzJo2uDKbyrIDt9aruR3UsmbPpoqt JKIeRJO2Jh+wpEmZPHKy59Oxbhe49YZpoeDhQwCTc7VZiYf678XROqRMEgOHoxNDgDaSR8vgamK+ HSTWjuUsEuGgCrLH3AzzgGXbmdmaKmaKUh4rcOuatgLstFLBf7hGhR4mmEmCWOiHLqi5V0kyVjq1 CjwoA1UfVSi0fZicfzWhbSe1X1tsvXLr6y44lZnLbWhYSGo1fyQ60ZleoNkQTIGjLcB5EdG5GMUX zsFjYvMA/QrRXAb9uiPwAIrpxcRjCZEr0lnoXbZM7ugaIxHDJjzDvWgSJsEv6RYlKX6CafgFeMQF YiypvDHjfUC5WHaOFrLfMogXQFGIMe4o4j8Qed9F7DCLNMOkbbxEozCUF/3oJVZCmarVnmcme7tD WgWLoy/l05YaT9Z2lFvXvCB+EGxhnvqTiR19qNKtT5DCjlKp9S08iAoEUDVB7/1+Sud/NJeqoxjF PlqluldoZurli5SxAPxA/buHBw32ChnC5dH4E4ULpLcy3ff2PtO70iEGV4Ojb74O6GyCkDv3hIGU Q5kcLFHw6QfRPKBzBxqa6w21UCdyFxSz7O12hbMNtn+B5NJnObrMz6xA3ehG5F33MHtPbLKpV3vq YhYW4eEhUQ0mLL3HM8aHvUi+VjwkpmsPlDAwQSfKe8sgu4DZlJtrJDSAUm+IIBgBArAd/egQ+unF 1EAC3GtYUhaCWFw8lnJAa8XUB674/IinDTuHlK/+Si8l69f/w+/F9jvB+yz/1SeCtL8uD/8dOi1Z l3WwwmG5QwVUwKT/Nnvw0osIlAn2e+7skY+BiDst8y3UtOMbPcRjd7uTq0RkOegUjA5CIbLNtnOM dm+2KxWH2INwGFj9ds+qkE4qKHajLaWuJRU1fv9IsrJwPqXcE193qaVkl34fatHODlX9TrC0UCR0 ogK9CJxRQcWKfYsdD1Vg8Rys2MpUPGJGpjY2iEGJfemRVsUuwM9K4NwX9og227zR27Zm0fO2+KR6 V+wLSaKSUFm43azwNlJL9ZUI5Qdnl91IicVG5kK6aqyDS6kBztbhjiCGn8BbUueUjlRTNS2gHTqS Kf0zW/OnnC735FYrlWKHGvMln38ULq58IleB3BN3QovE6n2GpqAAVRrC4gG4G3AxUP4DUIa1akf8 wKtDaEG8UqFhXfqh8MOGDfpIQjceKs0l3o1J5CMsC0vfDbpIqRWthLq2crJzfIVluhT7SVwyAzU7 8XPCsTLFduWTE9w/0Xau7Pt4BRyrFoUa7Y5Uep3vtFfkFUyHvbTd8qGnD9qCV1NYcsUN5LSuwqFw uZUC35N5cWyL3kCnWNXu8bBXl1R37AB77oGWtoUCY93a+BeS+3CAAL7q9aH2dQqN1jS8Ys3tcUXV 5566z4/3tFfU+W69Rbz1YTtwx2RKOjR23ljul7CW7IhhyFmMpbQiyLg844MOMJ7pVMsSaskBPLQ0 MACJoyHmS5WEeY4B9xhePiS3fm3pVKGoAUczjmqmcLyT4Uo33unL5XXRXtwxzd+Ou0tIRtYSunrZ SrAU6cuypf1F7eLZEmXoDQRFz0hcCsXXm1zuCuDlzkxcO2e2iBXx5P0JSFIXrtiuzthsS9RShLxL 0o90FIqcHWmya0RXB6EeqVXvjPPkyKquUBTTsFK2HCDPi1DSVq2/VDYFlJbSWVG5Uj5l/QdJqGz7 NWXUgPxKUmoAfl05LSFalFT1uq2sOuBq7KWqWZRr+fSz+qV+CBnfxQsrXh1RNJQwSZhjKcKafxpL 27i9yk7UZSd7pWWrwjv6j7xKpLgv2ryFqzSe24Gyb+KKmxJizpNju7LGUP463lM4fi6hS4sZuM+o btwRGw75MsWMKZN9IbGpM+o94bx29MoesxeZPptJ25PL+Xu4BKlcSvln30bOm5ZzWkSho82uutjJ R5nPKoxt1a+aCuxN/Cz3IklroHv409kwJAakM3VzedGDvt5B+f1CcrOKNKUil2ub4jI4s4pjz+RF Ikb5y7M8mb5N0u7P7rM8F6FNY18viox0SxQuoasdAeQzyTZZZYeOPHj6GMmLV2ag4+InQALMmNuA Pgsp/Xieb0nFyhsHRcYAUbyqSxWGyPV8JHDF0Oy9JgKZ65sNK8dTzAKrAGwuMuCF+3JERFMJ3AqR rgiCA76JKYpP8JMq+vpKYQbR0IdBGpoDmuKGL8pmrN+S6rnA3b/VouxO+1yi9kylVir2xbtLCrsh dg8mi810QH9bq3GlGyQVEJfyxfsgfbmBZkDdUg6gP18PuLlj53p6TrnSTSjdAmwDtW5HFUtp4ivn XS2Lmrs5hK6qWiVlxZVL5iwtCKYsLrfTZaTuSiX7t2GI8vT6Sklwa67gtEs9t7WDsQNPVgO0MK+p 1Q45KzuzuhJqcWOVvzrDz+jGY/B4yhnFSunvpu7+z5i7cT8/N/d6w0+1W8/MhfNZBeQqiaa1Q/du HWr5x5eVphQ2LDvIypeKStFI+DPH69q3SMHB0ig/r53LrllH3RMvvrBlvcoO/9+IRqPed1y7Shvw R5A16SJ+sbC1lJTfwTK1lPPWMmotfrHCDUKqUkWzcmRdUdHw10mlx68rWzN8Uvbgy412Pn3vXlbC xX2JKmBBs1d5gM5qa2b0BDfbDNlatCUCnBROYLRodWV4/ETt3V55r+fCUr+nh8XRZn0ml2lBnm6g Q/d10+3ArUu570a9emUlslN8S6fMnGC9pT41F4KJxU59TbL6rqINs0GZ2KtGiFbHfJrF6sfLivbe 7an4zpxYf9SMJDaALeGsl3vcet5YFs9tbl/uo65n8PDNV5AwvPzFjP5cXkViPUJUzuUJ+wq+x05L MFSekK8BFjspR7c9ajoO6xa6h4yuHzqRl5CduJgcs+iFvnmsLUrnyTxY0c68Qwl8TvFsVHsdhwXq ejzyAMI7qluDoGP0HiA/NGDiIVqtbmnDYeoGPtxHoEhDbnabe5UXeON8ysV98HEIYY9IdkjmmBpY DdFcNKhv9MPDaAGu4Mw/0qdPxCqXyHLluLtAdxfq65pJRVd3ALyy4rmVNRd85LQWjh+/pczgO5UK wIMs4uKM5jZjx08Oy1CtpTZWvivXLeU3cvtfk00vy7sVdzk3SfUNRIEjomgJaJ0Ym8atrtMp0sBJ EqppJnyQXiY2uaxe6wRCp9ttttmyo5rUtah+83XvvXQg73AHZj2cB1yQ6YD4ossyxe5OeRQtr8m0 rCHtpHgwrJ+gHNNHcd8hTbaLJWYT2w5BIwhtVgxSv/xqIFijbbDWvms1PcDrL/gRyYe+zltJGpaq Szd9UHe9eNMunrH5+qjoufoiTrs01wAOQJ/PfE86oi1m0Di4NUJbz/Tl9LvgHqWWzjTntpPYqguR HXGQsb9vKX09mW0z1zutaIrYRSEP8BwF7Y3dJ1s6uD5LwP+xPqVB2zvgN8h9B7ymqlUH2FBnztLm XSY4BTvBof6d7j9qhiUjYvFJFde5E5nILcNbz4Qrb+awZaxbAcJ4Vk23YWKpkzRVmmugTEqiCBls JR5Y6kjZDgKWClI4GydtxlrhHtulHTkedDmeKo5Pz67H50Wv1cM1bUaHxcBuT19VBDaaw47aJAm7 pXIUNuPuPhhipH/ZDOvEKvmvV4O7WVVNQM1gJNg2jcgcKjSsm4WEYLU2iapISOVEDgHvKxC45nXN q+o38uJCWs5Cwz46E99wiwqf8HAKUU1/9a2ROsIB1F8MUcmCczBxyRp71LMvzFUraJG6YPWG85VY u5YXCKkc7zXHs35RtmZrstCqf3ECsFUnWcKigzWEa8Gt6AJtLDrPqyDnaT0Iae2isMrU7Udh8/26 IhoKd2NFmbVHH+TpHIp8sijstotvsOzOZc0xvjftDEvD4h2mpTQs29WssUHrjpdmRFg7cKykrP8p cAjIC/lV9/i5KUrFkbsem8AcMpCbH2K5Tn/7QmfSqCnxd1JWlOFO+rEc3KuYV7JIxSeEPDDweOWJ Ffwmm9qFOF2RUsC2eHUlejf1i3FuQE6+UEUnTRcxl4J7gzrnH2uMZCWfquK1GbXjesC5I1XcNV9U KarvG8+CLy7p4qJw2yNImjWwYSKSVATQEqfUao0ajVFpFBvVUfP9hl+JshfJH4moX6Zr3RE8YtMo vIfxuxFcnVrFY9bZ0q9Z+33fM3YKVjQ1B5RpATVLhNm+4wcpp48A3jPrEiI8ZMvCZL4t76tUdTRT dq83x/5KOspLGYdGfTYq3m4gk0rdas37Vi1LGYemWXvE5HfpVaq6SZ8smRZ3XanFLpfZhTebIu53 qMWnnkUt9S1oWafUgcpaX5pV8vIaeXnfPck5fhNRmSBrGdmg1bRpVsGNE87F0qu8Wg4PvNAQWkNA /3Dq3C1BHm30D9RBYkkHnEc8nilXi0D6wY+U1zRWAiWnRx3NzO7BZq0r64q7gmnlaCFuyUyEX6z9 XOHDgoXCTYyDKEz5zQH5IXFy590FKT/z1CqrESww03kSJsLFiejzgvqkrLpXJsEvpcSUTCH20nEL 2QvLrHzjQlOqvjOYi68M6rNIq9LGs2jvGUjLuEV77tBnjfMOb6v9d+m3I4RWLoITI9HBV9DJLJgl wEdJiidK6kIyzTuK8rcciJbRNS2SiYSqDbIM1KlcKmyEB6pe7JcBe9/QhaY4pJoITbYTO1g0Gpos 0FFbjMHEcJbJHZ2mVVoWozigEKa0VrC7KibIZ/tv6G4WEtr6OEqqj5nYHnKCI/hTTVTjujlBaB2J fdE6lj3Q98ixKudEpYB8SQyHRX1XnZdS9O1SA8TG8EKZgxuck+rZ2HUnWBWdatYqJ6j60lb3o9gV 0q3fazNTJ+YGmrWA9J1+qo7TaZSxH7mk2qQSnE+CG40obHuON1NVA7DoBV2qq1UEz9OLcwBPD7Af emIGUzVidZGFOpBmXROLGwV6/8OzXydudQ2Ee4Gf7FR7e0z92PFSXT1A2tir2CaUZ/EKG0YNl+wW R6xAO98J06lU1reFnnbt5/rbQs8Mfupf54IocdqvhGrXBEtqrNU3CVkzNLw4YzRLvvcVMv0gdWUr Af0dLx3+gM1HdVWYJh+UCoyM1yjkBjxb9antf+lNyNKxtoeV62wpjZ2W6sphlr//bhc3hMP/mEfF l54ls7fyki08aatcdPE5MRFq4dcybqNkm63uKdCCl4fio96NSXASb4RMEHGOBVDr6+FR0+kO7c3j dU9FI4yzUSaIZaGoXnUkh6WRQGMBTn+hGiKnAHMCwfMgfximfgF/tqWGgQPUdmA0UELE0eq4aCJ+ +GNp2dk+EotyLX+x0padlE5abTCrFiflRYxf96tpKH/CP5+RmN9+879QSwMECgAAAAAA7IbbLgAA AAAAAAAAAAAAABEAAABiZXR3aXh0L3NyYy90ZXN0L1BLAwQKAAAAAADvhtsuAAAAAAAAAAAAAAAA FQAAAGJldHdpeHQvc3JjL3Rlc3Qvb3JnL1BLAwQKAAAAAADzhtsuAAAAAAAAAAAAAAAAHAAAAGJl dHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9QSwMECgAAAAAA+IbbLgAAAAAAAAAAAAAAACQAAABi ZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9QSwMECgAAAAAAKIfbLgAAAAAAAAAA AAAAACwAAABiZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L1BLAwQK AAAAAADdhtsuAAAAAAAAAAAAAAAANAAAAGJldHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21t b25zL2JldHdpeHQvZGVyaXZlZC9QSwMEFAAAAAgA426XLpuYSqw6AQAACQIAAEkAAABiZXR3aXh0 L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2Rlcml2ZWQvQ29tbW9uT2JqZWN0 QmVhbi5qYXZhXZBdS8MwFIavV+h/OIxdaMFEb7euDEdlA91given7VkX1zYlSasg/neTphMZhJBz 8r7P+eD8bZPC83ad7tbp3Xb3tIdNekjDAMKgxfyMJYFUJUMbnIjlsq5lo1lG5lN8GVaQEj0VizAI Ax5F1hYBxG0S57KgZD2o99kH5eaRsIn5kAahAcGQNpBXqDUcpYKRBJnVgS8DrZItKSNIO/AAX2Fn TlYeI5wUHZfTGkVl5FxJrVmNWjarvMuEtp2y7jxNDjYPLy4fc0w8oielhcXPDtQL95rDA7uHmfvl duwuq0Q+tnY9AnyHwcSe1naLhuDVKNGU0GPVESyh6apq4RXDOiauniLTqWYIuLN6/ugsybw7883t gJ54sQc60o9b7T9Yiwpr0IP5GtlLUYC+AMcCXjrSL3365B/fXr9QSwMEFAAAAAgA6W6XLqsH7AVy AQAA9QIAAEcAAABiZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2Rl cml2ZWQvQ29uc3VsdGFudEJlYW4uamF2YYWS0WqDMBSGrxV8h0PpxVZY7G47K2XiaGFroewFojlt s6qRJLqOsXdfotnatZSBiPlzzvf/52AYvs5TeF4k6TJJ7xbLpxXM03Ua+BD4Nc33dIsg5JZQc9gh yUVZikqRDPU7P2jCUPIW2UPgB344Gpm2EUBUx1EuGMaJKW0KTSsdhZ0AXAEFjUpDXlClYCMkOAZk SCvoDaCWokapOSqL7LAz2uidKY8o7CRupoOS8kKLiRRKkZIqUc3yJuPKZCTNfhCvjQ4vVo9CGveI FqXiBj9cY8vt1wTuyRiG9jY0AzdZwXMX7Rj+0QbDg8aKKUjLuhAfiJ34aef2mDB9CJJqhCmMydis w0u6QVbZG+Y9ID8RTFnVFIWtM0+3OM/mk6gbWXUHE8dzeRx/i3ptLG5ura3n9bWdq+V8dVGOqJpK WgI7Z7WCM1CO5MDsh9gPwBzu31wXI5qEp9pZ0tMFXE9s/4Jrof/AL9xtp3M827W9+XU0r29QSwME CgAAAAAA3YbbLgAAAAAAAAAAAAAAADgAAABiZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29t bW9ucy9iZXR3aXh0L2Rlcml2ZWQvQ1ZTL1BLAwQUAAAACAA2s8guDPx3/GoAAAAxAQAAPwAAAGJl dHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvZGVyaXZlZC9DVlMvRW50 cmllc9N3zS3Iya9MTXVKTczTy0osS9Q31DPUD8koVfBNLFIwMlAwtLQysrQyMACyDYz19Xm59H0T 8xLTU4tI0BGQWlScn0eyBp/M4hISNIWkFpe4pBZllqWmEKmjAGyNbg7QHr2K3ByCGlx4uQBQSwME FAAAAAgANV+LLhAuJDg4AAAARAAAAEIAAABiZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29t bW9ucy9iZXR3aXh0L2Rlcml2ZWQvQ1ZTL1JlcG9zaXRvcnnLSsxOLCpJ1E3Oz83NzyvWT0otKc+s KNEvLkrWL0ktLtHPL0rXTyxITM5I1UdXk5JalFmWmsIFAFBLAwQUAAAACAA1X4suVk9pjS8AAAAw AAAAPAAAAGJldHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvZGVyaXZl ZC9DVlMvUm9vdLMqKE4tKkstskrMy89LLit2AGK9xILE5IxUvfyidCv9jPzcVH2gYEFpUk5mMhcA UEsDBBQAAAAIAKCjdC61EFgDuAUAAO8MAABFAAAAYmV0d2l4dC9zcmMvdGVzdC9vcmcvYXBhY2hl L2NvbW1vbnMvYmV0d2l4dC9kZXJpdmVkL0VtcGxveWVlQmVhbi5qYXZhtVffT+M4EH5H4n8YVSst rEID7N0DXRZdSF3wqiS9/IDjbd3EpWaTOIqTdqvT/e83dpK2sJzu4fYiaIPt+eabb8ZjY384PIAP 8O6Ws5RXI7CXMud2slJlM89EYj+zb6yq2Uki81wWyp7zei2+17aqErvmqrZl9WSzkiVLtHq1BgHF iqc2yctMbji/5qwYPrMVs1ZwNjyD89PTjzb+nJ/C2cXo/GJ0egrPqq4QjBVAvpfwriUX8JVQQhYj Y9YNjlnNR29imAVm0eef8GzBoiUHx0QKoVzUa1ZxmIqEF4pbcM8rzVAT3Bq4stxU4mlZw1FyjPQu Lk6Q7vmbQBPZFCmrEWII4GQZGENlcCqueIVCDrfIAU8FCiXmjbYAVqTQKA6iACWbKuFmZC4KVm1g IatcWbAW9RJkZb5lUxuYXKZiIRLj1gJNo+RVLuqap1BWciVSfKmXrMYPjkBZJteieIJEFqnQRi0/ bZjzerSldzZ8xVCBXPTUEpni8kbVGFfNkLLGZnO50lOdYAYFn0LWKLCFS4SCDAE1zs67CfMlNfSa ZEzkvNqpdf4jHXS7J09PB2NOG6T4PzFCrz2MXpLKpMl5UbM+h7iXQOJMBTnWdiVYpnZpMPnDyR5h P55dqB+Hprp4kZ5gQVSvfIgiyZp9MIx5H8cCsejxWbGxWl06q1dhseRbIdcZf+Iaf9Sb4TOItDat lltrhenvSj3lK57JEmnMN/sR6eeftwUcLeu6HNn2er0etg1nqHvP8XDQAzgZqlagdNmmS9BLkijr BlhZcqZTYeLZkhK14tnC6qHEwmRyjclAthWoJtGCiSo9KbEfbl4hK6yLKmdZ1uPvMvJLm5GC5ajB QL9+aVsqzCr5zJN6YMHAbTsnvmqvg1cq9KR2YgzazGAxwpzrrY9FJ3XWZYVtAMsI1c9lzfssKOh6 cQ+1wPlWoq0CXWNAE6HbRKXbQNE2BKVMX5rsxnuc3bQFZcaZ0lsGyw0T3+bot12qdpr8OtTBvyD2 FiOdri7EBLXlW2W2GUfVzap+/GV2RdXJ/mZoP4agt3K96803lWzKHenoloYQ+pPowQkI4Pss8O/p mIzh61cnxIH378Hxxvj7COSPWUDCEOf8AOjdbErJ2ICgbeB4ESWhBdRzp/GYejcWXMcReH4EU3pH I7SKfAv9kd50z8yg+BO4I4F7i0PONZ3S6NF4ntDIQ68wQacOzJwgom48dQKYxcHMDwkgcWM/pqE7 degdGeNhQz10DeSeeBGEt850ajw7M8fFr228Ez/2xk5EfQ9DMiA0CsH1vSigyN4PQrgmyN+5npKW AMowpgFxIx3p7s1FyZD2tN1q4Yy4FP9AxQjG6gSPlpYMcUPye4wLcRLGzp1zQ0I4+lExA7KvGibF jQNyp6NBmcL4OoxoFEcEbnx/HGrwkAT31CXhJ5j6qJY/MSBxSCz0FDmGAMKgmrgE36/jkBpdqReR IIhnWoVjuPUfUDTk6sQ60ZiANjeeCR019INHTUFrYnJkwcMtwfFAS26Uc7QkISroRnvLWpgAwwmi vZjBIzdTekM8l+hZXyM90JAcY1ppqBfQ1vWDg37jqK8UnU1k2L7ulbBlcg50As74nppabRdjqYS0 K6tOnDB2b7s0mA3xsy9W+7se+4fCM8lcGVYya7Cb4DGtu8ru+M7xsqpPjxxPKQMh8ADGc7LRRyZu 5Dlfsmzxaj+/fdfSTS2XXZMVhb4OtOeNLP7FeNvxFG+tL98+oa5ayczHO5qO4D/eh+3DAwT/xp50 p3/qPXWX72F3+R52ffXT4cHhgf0ByZVXl/rqdbXv/dI2Q8BAMRzm224819Qu7fIKHZosIfffWINt tIJLBsuKLz4PciayWo62FPd6/eDqi+m8YTd1abOrDmXV3ZTfuNW3sZl/PADvTEq9kAr4d2zbqYIZ IsjCDP2prQDaz85y3+bouF/y1+EB/vwNUEsDBBQAAAAIAOZuly4ny51EmgEAAKwDAABDAAAAYmV0 d2l4dC9zcmMvdGVzdC9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9kZXJpdmVkL0hpdE1hbkJl YW4uamF2YY2SbWuDMBCAPyv4H47RD1th2n1dXSkTRwt7o+wPRHOtWdVIErvC2H/fRdOua1cYBDFn 7rnnLkbR2yyFx3mSPifp9fz54QVm6SINfAj8huVrtkKQahUy2hQY5rKqZK3DDM2H2JqQoxIb5OPA D/xoOKS0IUDcTOJccpzMhHlidRx1GxAaGBjUBvKSaQ1LqcDlQ4ashh4OjZINKiNQW1yHnLLWFHQ8 ZlAoXN5dVEyURt4qqXVYMS3rad5mQpNf2K4vJguKw5ONxxGb9IgNKi0IP1jgRti3W7gJRzCwXyNq ts1KkTu1XvzeSuHWYM01vFK67EOfge/R4pJSEBQzCHcwCkc0BU/UBgphEtnSC0VtLOn6esneMTf3 P432ATpUt2U57pndDD2rq9C0qu42ZOc5PVdzhWZBZS+vOhevP9uZWM6XvY0DVMMUq4AfszZScNCO 5MB8R+yb4g7ndesffrZ9kpu5CRwJ7gZzXlKck9wTbQXhsAeDFn8x/3Y8uQ4SPowdSR9e1nlx+wOf c/8FP6luM13Fo//CftlXpMc3UEsDBBQAAAAIANh9ly6VzYSBiAYAAFoPAABEAAAAYmV0d2l4dC9z cmMvdGVzdC9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9kZXJpdmVkL01hbmFnZXJCZWFuLmph dmG1V11v27gSfU6A/IeBUWCTQrXS7L0PddNgFVtOtHAsX0lObt+WluiYrSQKkmw3u9j/fg+pz7gu 9mH3Cq0tk5wzZ86Qw4n59uyU3tKbe84ino/I3MiEm+GuyLarWITmF/aV5SV7F8okkWlhrni5F99K s8hDs+RFacr82WQZCzewOlgDQLHjkfnAUvbM81vO0uEXtmPGjt4P39PV5eXPJv5dXdL7D6OrD6PL S/pSlDmwWEr2t4zeVNw8vhOFkOlIm9WDE1by0VEMvUAv+vQPPC1YsOFk6UDJl+tyz3JOMxHytOAG PfJcMVQEW4OxzF5y8bwp6Ty8AL0PH96B7tVRoKncphErATEksuKYtGGhcXJe8Bw6Dltkj0cCQonV VlkQSyPaFpxESoXc5iHXIyuRsvyF1jJPCoP2otyQzPW33JYaJpGRWItQuzVI0ch4noiy5BFludyJ CC/lhpX44ACKY7kX6TOFMo2EMqr4KcOEl6OW3vvhAcOC5LqhFsoIy7dFibhKBsoKm63kTk3VgmkU PKksIbCBJaKgGIAKp/Ouw3xNDV7DmImE551aV9/TgduePA0dxBxtQfH/xAheGxi1JJLhNuFpyZoc 4iiRxExOCfZ2LlhcdGnQ+cNkg9CPpwv156HeXTyN3mFD5Ac+RBrG2z4YYu7jGCTWDT5LX4xKl9rq ICwWfk3lPubPXOGPGjM8g0BpU2nZWhdIf73VI77jscxAY/XSj0g9Pz4WdL4py2xkmvv9fljVm6Eq PRfDQQNgxVAthXTxS52g1yQh6wuxLONMpULH05ISZcHjtdFAibXO5B7JANucim2oBBN59C5DOXw5 QC6wL/KExXGD32XkX1VGUpZAg4F6/bWqqLTI5RcelgODBuOqcOJVeR0cqNCQ6sQYVJnBZqQVV0cf m06qrMscZQDbCOonsuRNFgqqS3EDtcZ8JVGrQF0YYCJUmchVGUirglAUui5Nu/EGp5s2KIs5K9SR wXZD4qsc/dKlqtPk30MV/CtixxipdNUhhtCWt8q0GYfqelUz/jq7Iq9lPxra9yGoo1x2tfkul9us Ix3cOz757jR4sjyb8L7w3EdnYk/ot98sHwM//UTWfIL/n8n+78KzfR9zrkfOw2Lm2BMNAlvPmgeO 7RvkzMez5cSZ3xl0uwxo7gY0cx6cAFaBa8Cf3Zj2zDSKO6UH2xvfY8i6dWZO8Fl7njrBHF5pCqcW LSwvcMbLmeXRYuktXN8mENf2E8cfzyznwZ7gsnHmcE32oz0PyL+3ZjPt2VpYY3y18U7d5XxiBY47 R0gaxAl8GrvzwHPA3vV8urXB37qd2RUByDBxPHscqEi7tzEkA+1ZddT8hT128AOK2YjV8j4bSjLg +vZ/lliISZpYD9ad7dP594ppkL5qSMp46dkPKhrI5C9v/cAJloFNd6478RW4b3uPztj2P9LMhVru VIMsfduAp8DSBAADNbEE77dL39G6OvPA9rzlQqlwQffuE0QDV2upEo0EVLmZ69Choet9VhSUJjpH Bj3d2xj3lORaOUtJ4kPBcdBbVsF4CMcLejHT3L6bOXf2fGyrWVchPTm+fYG0Or5a4FSunyz4XQbN TlHZBMPqtbeFDZ1zcqZkTR4dvVerxdgqvlNvq1ocfzm+r9OgD8Q/3Vj1Tz3qR4E7SbcMOxlvUU1w Tauq0l3fCXpVdXskuKU0hMAFjHtyq65MHOQV37B4fXCej/daqqglsi6yIlXtQHXfyPQvjNuKV/DK +vr4DXVTSaY/3jjRiP5eO2yenQL7KxBIFdXaUd16D+vWe1iX1Y9np2enIslkXpJyNYSA8fCeFZsH ln08MlUNn52abxFPdnOturWbHuFrU48Qo4IliL+t3ysVzbWZ3YCjziui/YVtUXhzuma0yfn60yBh Ii7lqI2qdzsMbn7Vtdqvp65NdlOj7Ore+sjfAZUc+i8VQpdVFH1xiX9DnY8KssFUvnCuB/9QZkTV J26EHRoGJL4kEEGj7Yvf+cdjS6CMuk5xXZQCPD9RyvdUK3l+UZs0NhWjHpfzi8bxn9UXBK5NECE6 4W2u+rOyGTNfASl6z7wctww7OPXU5t8F8KfK5KEzn+NsqZ3dLR92TNDdsKQ3pZuX3k+0GQX/Acud FJGa7dF8resr0uquH/aQP/2A/4kmf9LJpH/A80mrcqbEWbS5Ob/AJDydnNTCdGkD8MkhahVywrJD 4CaeHrLyhZWtg1cbItFnp8LHx/8AUEsDBBQAAAAIAA9+ly4tLAPkpgEAAIMFAABHAAAAYmV0d2l4 dC9zcmMvdGVzdC9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9kZXJpdmVkL3BlcnNvbi1saXN0 LWV4dC54bWy1lEtTwjAUhddlhv8Q2bBrC/hahDCIzuiMKIML1wGuEG0TJkl5+Ou9TaFgKQsfrHpz 0p775SQN7aziiCxAG6Fku97wwzrpsGqFDlBS8lEYewNcolKteB5VSwmajCNuzBOPoV1TeurzOR/P wB+rOFbS+COwS7Gy/gS0WMDEv4vnkVoDpD41ltp4lE+BNa9okD4zRaIdG6oRDVzlugWunetNiEfn ORJLBZS2mnvdKZlzc+ecqc6za2fK5P4bgyB3+Ob4xzVmXhuaiy3NVnUEA6VPx9PnElvqIg5+AgZe xCewBma0Nywgt0qRu5rHokiMhFohpBVgdqJHQVq93hM8+gFr1leJsSk6DdLh/vSCRwkwqxOcy+o9 t6Bghzkddj0WXmF1jevS1d3Wu9ryqeTyNHvSQzGJLJe2uC2aW2CXF34Y0sDVhd04L+Xti4hP1mQC 5FVIC/pgXzKQ59E7jHd/TB70Qz0mnOygzg5SxwNS5vBPcdwLi6e0NIpGGIbHwmg1S8MYKuz1hr/U QQozYXsqkZbhdZPXPwsJUWMufxvQdri5uGhQuFq/AFBLAwQUAAAACACgo3Qu4cTEQP4AAADIAgAA QwAAAGJldHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvZGVyaXZlZC9w ZXJzb24tbGlzdC54bWy1kl1LwzAUQJ872H8Ie+lbaieiD1lGRd9Uhv6Cu+7SBZrckoRt+utN0w+1 DBmIT00O6bmnH2J90jU7oHWKzCrN+VXK1nI+E5uAyDwp5+8RTCDzWZIIOhq0rKzBuRfQuFqQrTg0 UO6Rl6Q1Gce36I/q5PkOrTrgjj/qpqZ3xNazkK0mEVChXN6KrL12xASdfKWtyOIqTsviuDibsUQ0 Y5JsQUADi8cj6czLL3NHo7Pwe3Kjvxdko+GH8Y/P2Ln6mpuhZqCxYEP2/3qewYSRdpoTbkGHb+oD ZR7e0bftJPn6bHJhQatLiyfK/O6s8iEtrIfKgPldO2z7ry+yyf/5CVBLAwQUAAAACACgo3QuIIQt 1sUGAABmEAAAQwAAAGJldHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQv ZGVyaXZlZC9QZXJzb25CZWFuLmphdmG1V2Fv20YS/R4g/2EgBKiVMqLjth+i2EZoibJZyKJKUvYF hwO6IlcSHZKrLkmpRnH//d4uSZFydMmH6xG2TO/uvHnzZnd2ZL59/Yre0ps7ziIuh2RuRMrNcJdv y2USh+YT+8Jkwd6FIk1FlptLXuzjPwszl6FZ8LwwhVybbMvCDaxerAFgvOOROecyF9kNZ9ngie2Y saP3g/d0cX7+k4mfi3N6/2F48WF4fk5PeSEBxTKy/9zSm4qax3dxHotsqM3qwTEr+PAkhl6gF139 Dc8BLNhwsnSc5ItVsWeS0zQOeZZzgx4QIRgqggeDkdg+y3i9Kegs7IPehw/vQPfiJNBElFnECkAM iKwkIW2YaxzJcy4h4+CA7PEohlDxslQWxLKIypxTnFEuShlyPbKMMyafaSVkmhu0j4sNCan/irLQ MKmI4lUcarcGKRpbLtO4KHhEWyl2cYSXYsMKfHAAJYnYx9maQpFFsTKq+CnDlBfDA733gxcMcxKr hlooIiwv8wJxFQyUFTZbip2aqgXTKHgyUUBgA0vinBIAKpzWuw7zmBq8hgmLUy5btS6+pgO3HXka Oog5KkHx/8QIXhsYtSQSYZnyrGBNDnGSSGBGUoq9LWOW5G0adP4w2SB042lD/WmgdxfPonfYEPKF jzgLk7ILhpi7OAbFqwafZc9GpUtt9SIsFn7JxD7ha67wh40Znl6gtKm0PFjnSH+91SO+44nYgsby uRuRev77saCzTVFsh6a53+8HVbkZqMrTH/QaACuBahmkS57rBB2ThKzPxLZbzlQqdDwHUnGR82Rl NFDxSmdyj2SAraS8DJVgsYzebVENn18g59gXMmVJ0uC3Gfm5ykjGUmjQU6+/VgWV5lI88bDoGdQb VXUTr8pr74UKDalWjF6VGWxGWnJ19LHphMq6kCgD2EZQPxUFb7KQU12JG6gV5iuJDgrUhQEmsSoT UpWBrCoIea7r0qQdb3DaaYO2CWe5OjLYbkh8laNPbapaTX4ZqOCPiJ1ipNJVhxhCW35Q5pBxqK5X NePH2Y1lLfvJ0L4OQR3loq3Nt1KU25Z0cOf45LuT4NHybML73HMfnLE9pt9/t3wM/PADWbMxfj+T /Y+5Z/s+5lyPnPv51LHHGgS2njULHNs3yJmNpouxM7s16GYR0MwNaOrcOwGsAteAP7sx7ZhpFHdC 97Y3usOQdeNMneCz9jxxghm80gROLZpbXuCMFlPLo/nCm7u+TSCu7ceOP5pazr09xmXjzOCa7Ad7 FpB/Z02n2rM1t0b4c4h34i5mYytw3BlC0iBO4NPInQWeA/au59ONDf7WzdSuCECGsePZo0BF2r6N IBloT6uj5s/tkYN/oJiNWC3vs6EkA65v/7bAQkzS2Lq3bm2fzr5WTIN0VUNSRgvPvlfRQCZ/ceMH TrAIbLp13bGvwH3be3BGtv+Rpi7UcicaZOHbBjwFliYAGKiJJXi/WfiO1tWZBbbnLeZKhT7duY8Q DVythUo0ElDlZqZDh4au91lRUJroHBn0eGdj3FOSa+UsJYkPBUdBZ1kF4yEcL+jETDP7durc2rOR rWZdhfTo+HYfaXV8tcCpXD9a8LsImp2isgmG1WtnCxs65+RMyBo/OHqvVouxVXyn3la1OP5idFen QR+Iv7ux6p561I8cd5JuGXYiKVFNcE2rqtJe3ylaVXV7pLilNESMCxj3ZKmuTBzkJd+wZPXiPJ/u tVRRS0VdZONMtQPVfSOy7xgfKl7OK+vL0zfUdSWZ/njjREP6n7ph8/UrQH9ha1Xn142fuvEe1I33 oK6qH1+/ev3KfAtq2+tL1Xhdt74vTT1A6pqknKUIBrrBFSTQ3eShSVBdPipwzvPBpbm9BgudOITz iZWorJIuGW0kX131UhYnhRjKSGRf4qxT/HvXnlhyWdBNKSVHfzvWKy5Ndv1tqPsY8fNkMGY7/vxJ UZaIvYKs50jPdaB2dTN+4otDJaD+ZkNoy/K8kw36Sy0gqj5xWezQS2BP4C5b84+n5nzsSfRC6pY5 nq8ctNBnffrr399eUfsxuqD9enVNTD05L6w1P8PK/sej0RnWn2mjevyUP+VkXSH0u6hoxUuZdeI8 ZbwTcdT4r9kegajbe6A25tV3gOoI1zXpU0w6kn6LirY/EuwlHzUKQt/BqyEKUb0oSs2KDqneP3v0 YwUL7iO1fc76gzaMH6k3VKFfqWVKCAxoz3pAM8HIv3rfILIUIlFbkf+hatkZuUvVI5JYPtFRbGhQ z/ToFWIrcZ76DckV7JpQO9w16w3LNyMcIXCFHcw7I9/ZNR3Tr7PV6nYSED//AVBLAwQUAAAACACg o3QualCKaFAGAADpDgAARwAAAGJldHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21tb25zL2Jl dHdpeHQvZGVyaXZlZC9QZXJzb25MaXN0QmVhbi5qYXZhtVfRbtu4En0PkH8YBAU2KVQpzd59qNMW q9hyooVjeSU5uX1bWqITtZIoUJK9weL++x6SkuW4XtyH2ysktkLOnDlzhhwyztvTE3pLb+44S7kc kfMsCu4km7pqV3mWOF/ZNyYb9i4RRSHK2lnxZpv92Ti1TJyG140j5JPDKpY8w+vABoDZhqfOgsta lLOsbm44K+2vbMOsDb2339PV5eXPDn6uLun9h9HVh9HlJX2tGwk4VpL3Z0VvDL2Qb7I6E+VIu3WD E9bw0VEMbaCNPv2AZwcWP3Nyda4UiXWzZZLTLEt4WXOLHpAlGCqCO4exqF5k9vTc0HlyAXofPrwD 3aujQFPRlilrAGETuXlO2rHWOJLXXEJKe4cc8hR6ymzVKg9iZUptzSkrqRatTLgeWWUlky+0FrKo LdpmzTMJqb9F22iYQqTZOkt0WIsUjYrLImsanlIlxSZL8dI8swYfHEB5LrZZ+USJKNNMORl+yrHg zWhH7719wLAmse6pJSKFeVs3yKthoKyw2Ups1FQnmEbBU4oGAlswyWrKAahwhug6zdfUEDXJWVZw Oah19T0dhN2Tp6eDnNMWFP9PjBC1h1EmqUjagpcN62uI3UQCM5IKrG2ZsbweyqDrh8keYT+fIdWf bb26eJm+w4KQBzGyMsnbfTDkvI9jUbbu8Vn5YhldOq+DtFjyrRTbnD9xhT/q3fCcxUobo+XOu0b5 u6We8g3PRQUaq5f9jNTzz9uCzp+bpho5zna7tU3LsVX3ubDPegA3h2olpMtfugK9JglZX4hVFWeq FDqfHamsqXm+tnqobK0ruUUxwFZS3SZKsEym7yp0xJcD5BrrQhYsz3v8oSL/MhUpWQENztTrb6ap 0kKKrzxpziw6G5veiVcV9exAhZ7UIMaZqQwWI6242vpYdEJVXUi0ASwjqF+IhvdVqKnrxj3UGvNG op0CXWOAS6bahFRtoDQNoa51X5oO4z3OMG1RlXNWqy2D5YbCmxr9OpRq0OQXWyX/itgxRqpcXYoJ tOU7ZXYVh+raqh9/Xd1MdrIfTe37FNRWbobefCtFWw2k4zs/oiiYxo9u6BHeF2Hw4E+8Cf3xhxth 4KefyJ1P8PuFvH8vQi+KMBeE5N8vZr430SDwDd157HuRRf58PFtO/PmtRTfLmOZBTDP/3o/hFQcW 4nm9656bRgmmdO+F4zsMuTf+zI+/6MhTP54jKk0R1KWFG8b+eDlzQ1osw0UQeQTi2n/iR+OZ6997 Exw2/hyhyXvw5jFFd+5spiO7C3eMr12+02A5n7ixH8yRkgbx44jGwTwOfbAPwohuPPB3b2aeIQAZ Jn7ojWOV6fA2hmSgPTNbLVp4Yx9/QDEPubrhF0tJBtzI+30JQ0zSxL13b72Izr9XTIPsq4aijJeh d6+ygUzR8iaK/XgZe3QbBJNIgUde+OCPveiaZgHUCqYaZBl5FiLFriYAGKgJE7zfLCNf6+rPYy8M lwulwgXdBY8QDVzdpSo0CmBqM9epQ8Mg/KIoKE10jSx6vPMwHirJtXKukiSCguN4z8zAhEgnjPdy prl3O/NvvfnYU7OBQnr0I+8CZfUjZeCb0I8u4i7jfqWoaoKhed1bwpauOflTcicPvl6rxhhLJfK7 ZdWJEy3Hd10Z9Ib40Rer/V2P/lHjTNJXho3IW3QTHNOqqwzHd4Hrqjo9CpxSGiLDAYxzslVHJjby ij+zfH2wn4/ftVRTK0TXZLNSXQfMeSPK/+K863g1N94fj59Qn41k+uONn47of74RO6cngP/GnlSv f+pjdRdwu7uA211nvT49OT3JikrIhlQoGxrmtisle1EUro9MduOnJ85bZFV9VjTVAaOu/PrSo4tT cQEBPjrVZ3DSpUSCv7IWvVZSKFYcmDetlBy32Ykov+nbjzLZdHflI/d6k5v+54Nwa6rrA7HoL0VL t20kh6O+m9dzYltyea0mX5vscu0o0ycq+XYYPr+4Ng6dmwn/OvD5Bf31n11sY6Ehn3gzWCorY6Ie 3G9bWXZBuxCHGBuRpcTS1GCc72VT6ddXgAbJhvl5NzugDvxRtM4FWnccBtx+yjmSrI6LhAIl5NFc jMQHqewHjDgWh9o32tIeiODaxAozqi9E5g2LqubNcU5amrpnc1jnV+zUvcE2iJ++54iPvwFQSwME FAAAAAgAOm6XLk4oMo0ACwAATiIAAEQAAABiZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29t bW9ucy9iZXR3aXh0L2Rlcml2ZWQvVGVzdERlcml2ZWQuamF2YbVZ+2/ayBb+uZX6P0zRSoWKmiR9 XDVpq3XASbwiwLVNstVqtWtgADfGw9rjUG7V//1+Z/wmzqPb1mqJM49zvvOdx5whnedPHrPn7Jcz 7s54eMg6S7Hinel1tI4nvjftfHKv3FC6L6ZitRJB1JlwufE+y04UTjuSR7IjwkXHXbvTJXbtrIFA 75rPOg7W9ZJ37ZN77bav2b62zw729l528O9gj+2/PTx4e7i3xz5FMoQsN2DG5zX7JcFm8Wsv8kRw qLalgz1X8sNaGWqBWvT+Bzy5MGfJma4MZbaYy40bctb3pjyIeJtd8JAQEsB8Q1est6G3WErWnLYA 7+3bF4B7UCvoRMTBzJUQoTGm+z5TGyMlJ+QRD4m7XLLFZx6I8iYx7WBuMGNxxJkXsEjE4ZSrkYkX uOGWzUW4itps48klE6H6KWKpxKzEzJt7U6W2zQjGmocrT0o+Y+tQXHszvMilK/HBIcj3xcYLFmwq gplHmxJ8tHHF5WEOb1/bQRgxMc+gTcUMy+NIwi7pAjLJdifimqZSwpQUPIGQILiNJV7EfAgkOYV2 ZWYVGrROfddb8bBg6+AmHKgt0ZPBgc2zGBB/EiJozcTQkpmYxiseSDfzIVKJCcyEbIXYDj3Xjwo3 KP9hMpNQtqcw9aWmoosHsxcIiHBHhxdM/bgsDDaX5bSZN8/ku8G2nfCS7toxy51eBWLj8wUn+YfZ NjwNh7hJuMx3R3B/Guozfs19sQaMybZsET23pwVrLqVcH3Y6m81GS+qNRqWnpTUyAboP1gJQ529T B1VBgtYtc9dr7pIrlD05KE9G3J+3M1HeXHlyA2cAbciieEqEeeHsxRrlcLsjOUJchCvX9zP5hUde JR4J3BU4aNDrb0lFZaNQfOJT2WizRjcpnHglrY0dFjJQBRmNxDMIRjbhlPoIOkFeFyHKAMII7K+E 5JkXIpaW4kzUHPMJRTkDaWHAFo/KREhlIEgKQhSpunRSjGdyiuk2W/vcjShlEG5wfOKjXwtXFZy8 1sj4CrA6ROSu1MQpuOU5M7nHwbpalY1XveuFKe21pt00gVJZFrX5NBTxugDtnJk2s4cnzqVuGQzv I2t4YfaMHvv7b93GwLNnTB/08P8jM34fWYZtY25oMfN81DeNnhKCvZY+cEzDbjNz0O2Pe+bgtM2O xw4bDB3WN89NB7ucYRv6jGxraZuSMjxh54bVPcOQfmz2Teej0nxiOgNoZSdQqrORbjlmd9zXLTYa W6OhbTAAV/t7pt3t6+a50cNhYw6gmhkXxsBh9pne7yvN+kjv4kdu78lwPOjpjjkcwCQlxHRs1h0O HMsE+qFls2MD+PXjvpEAAA090zK6DllavHVBGWD3k1SzR0bXxC9gzICtuvWxTZRBrm38d4yFmGQ9 /Vw/NWzWvMmYElJmDU7pji3jnKwBTfb42HZMZ+wY7HQ47Nkk3DasC7Nr2EesPwRbwxMlZGwbbWhy dAUAYsAmluD9eGybildz4BiWNR4RCy12NrwEacCqj8nRcEDim4EyHRwOrY8EgThRPmqzyzMD4xZR rpjTiRIbDHad0rJEjAVzLKdkMxsYp33z1Bh0DZodkqRL0zZacKtp0wIzUX2pQ+/YySKFvAmEyWsp hNvK58w8YXrvwlSxmixGqNhmGlYpOfa4e5a6QSXEj26sylmP+hHhTFItw7XwY1QTHNNUVYrje4Ve lU6PFU4pJcLDAYxzMqYjE4k84UvXn+/kc32vRUVtJdIi6wXUDiTnjQju2ZxXvIgnu9/Vn1AfEsrU xy/m7JB9XzvcefIYsq/cBRX6RaYobb21tPXW0rJ69OTxk8feai1CyUiV5gntxPO5GaxjacuQu6uj GwvunMQ4jn9L3RYq0uPAk9o8RMHdiPBKIyOP7py1Y0/y3SWSf5axp+atOAiqOu6wV58opiRt7MIp Rw/ZBHOOuRuUjHnyuPP8uXIQW7phwKOIGkQVCMVKeEFFLvz5qxvjaAnZO5ctQz5/31i5ni/FYe63 0vnX+PCbOo3sdOpdx/2QSrlObw81N53E4eouxtBHAlApfBjYwqkfsV3z2RfayljymW6PqA2cIqm8 GTLHC5osceYff6KFX0Ssle2ip/CAFsZYGpG3mi3WOkrWfL1dgaIvW18SiX4/DgMW8A3L/d8sJ4Oy 7y4FpcXNBDujO+gAvFY0RTFO9WY+dYdERQYtHMEFIuij8gC0XIZiEyHnpnytisEXCo1MehEJMEn9 eK+MKsabpLLTKQynQW3B5e/nfROFTERrdH4C67SIy75YNH2xyGAWT1kGFqRqbAS2z2lT4w+ngvyw QPBnowoB25Uq6r2buQStPzz9q49zoP8XnUZGGUKNAfVY08mQLwCBh4ShS45ssgIZDSbuZVUd2Vup 5lD39r48Rw8ZvlO4mgyEEgE03mx8yxcSawXsBd3ftM8rv9GqoJI4b76UQT569KhqCg4Yl0A2q8Ot jAvcESLeJENKcpUcoJpe0domiWgdsbKhX4vXOW6ndJ34UqXBIxYFZJfxfs2F5BH+6PbwNlTJQALd FuZA+cAIx8rvcj721/kdw49+mr9foGSWfA5Vde7+Yf4uHJ7znjh+N9d3A56eTsc6f84OA57c7yL1 nYD3Pw678neaWLlX6EJiusTRVSlgITUpiGNvXSdU9Vsbz/fV7YrOY7bluLBFLOWNzQSPgmeSTeMw xPUWcYiKSqdpnTi6T1ElphsWHZTK01R3qf9yE+rADG7Y1MXNvUUcqv6pjoGi5CRPUuQvoYEu4Zus ApZGd0pt8hDf6aZJ8VrEcLo12tRtLnZoPHAnPh/h4JLbEXTKWm2lDcQFzz1cbw1D9AFLtNGkSEZq pWbL0zyMyr+UaUjzEULrpdRE8sH9oVxRVwnqmxrqQ/zgRq5/VZ+lykb5UalotChdnZaydSgkjkok gCplRfmsMau+oGUQkg1qsdgEikTaRKfykH6vlFREMA+lE8ZUaJYi9mfoB6/p+y9KrExEo52KegqH xMin+rMtEWb8Q7eTXNyE5199qIShr4Hu7+c1Aye32HJOdmTqyYSk6LbolVKv2XoIlIJDdu36MWfN /Rbh0NHTEqBmsyCtlbNV7pTo9+Ze6xa992k7UNpGqCvfpG//3+p7mViHW4j3DeoO/q26V0pd75ke SncRKH89UOXL21TWhjNPY6LI6nsJvNWKHxqdGbBvCNCSWbjc45IbPtiqg59l1XkCJDUqhXWrTQUG VMpMHcoYehDp4fpHXyLQuat6cPryGNM4fjVNK9goZJR0Z5pV9S6Nt7KJ+8xXFczdxbSFTfsHuV0H yrAlR4dho70gm3JY9FlqMW8pzfkp8OASfbMtpjH6f2uKRcAG4G/a9fEQpdDvlZOm6muVquee7862 IIhd4qxX9f2BCftqN2HvV/lGqbQETJ+jAj5c1+ubuuh/KXPoK7TYl24gH5w8r+pAf1/adHMUaeYU sG5JnlL8V+xZenJV7r/vJeiH23LmSWRcakcC5xuKWtrHJ1+MJCpYk2pAKr5Vrg9z9ecbb4WmGukq t2sekTUFglS/KgPFaCsdvt30NP1T/eXs39vb0/b2MsNUBbBc+vamzfZ20r/6VnVxycEKXHW2Vcw+ sFDdRPrmtcJZ0rODtdpxVoXbJeGwtItWLk1GSP5PxfqzdLoSlJRmWfP7jf4UE/pLX+bMTAj9xcce j0ZDi/568dFwys11Fbv5bAVCCkKfNm6wkPwNcag0JSF5QbZlJgB/8uNuFWeKhKeNCh13ic5Pha+U tv8HUEsDBAoAAAAAANqG2y4AAAAAAAAAAAAAAAAIAAAAYmV0d2l4dC9QSwECFAAUAAAACADNhtsu kWmxT84QAAAbTQAAHwAAAAAAAAABACAAtoEAAAAAYmV0d2l4dC9jdnMtZGlmZi0yNy0wNi0yMDAz LnR4dFBLAQIUAAoAAAAAAOeG2y4AAAAAAAAAAAAAAAAMAAAAAAAAAAAAEAD/QQsRAABiZXR3aXh0 L3NyYy9QSwECFAAKAAAAAAAxh9suAAAAAAAAAAAAAAAAEQAAAAAAAAAAABAA/0E1EQAAYmV0d2l4 dC9zcmMvamF2YS9QSwECFAAKAAAAAAAyh9suAAAAAAAAAAAAAAAAFQAAAAAAAAAAABAA/0FkEQAA YmV0d2l4dC9zcmMvamF2YS9vcmcvUEsBAhQACgAAAAAANYfbLgAAAAAAAAAAAAAAABwAAAAAAAAA AAAQAP9BlxEAAGJldHdpeHQvc3JjL2phdmEvb3JnL2FwYWNoZS9QSwECFAAKAAAAAAA3h9suAAAA AAAAAAAAAAAAJAAAAAAAAAAAABAA/0HREQAAYmV0d2l4dC9zcmMvamF2YS9vcmcvYXBhY2hlL2Nv bW1vbnMvUEsBAhQACgAAAAAAPIfbLgAAAAAAAAAAAAAAACwAAAAAAAAAAAAQAP9BExIAAGJldHdp eHQvc3JjL2phdmEvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvUEsBAhQACgAAAAAAUIfbLgAA AAAAAAAAAAAAADcAAAAAAAAAAAAQAP9BXRIAAGJldHdpeHQvc3JjL2phdmEvb3JnL2FwYWNoZS9j b21tb25zL2JldHdpeHQvZXhwcmVzc2lvbi9QSwECFAAUAAAACADnbJcufDHBbQQLAACVHwAASQAA AAAAAAABACAAtoGyEgAAYmV0d2l4dC9zcmMvamF2YS9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4 dC9leHByZXNzaW9uL01ldGhvZFVwZGF0ZXIuamF2YVBLAQIUAAoAAAAAAEiH2y4AAAAAAAAAAAAA AAAvAAAAAAAAAAAAEAD/QR0eAABiZXR3aXh0L3NyYy9qYXZhL29yZy9hcGFjaGUvY29tbW9ucy9i ZXR3aXh0L2lvL1BLAQIUABQAAAAIADptly4WA/+rnyIAAGudAAA/AAAAAAAAAAEAIAC2gWoeAABi ZXR3aXh0L3NyYy9qYXZhL29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2lvL0JlYW5SdWxlU2V0 LmphdmFQSwECFAAKAAAAAADshtsuAAAAAAAAAAAAAAAAEQAAAAAAAAAAABAA/0FmQQAAYmV0d2l4 dC9zcmMvdGVzdC9QSwECFAAKAAAAAADvhtsuAAAAAAAAAAAAAAAAFQAAAAAAAAAAABAA/0GVQQAA YmV0d2l4dC9zcmMvdGVzdC9vcmcvUEsBAhQACgAAAAAA84bbLgAAAAAAAAAAAAAAABwAAAAAAAAA AAAQAP9ByEEAAGJldHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9QSwECFAAKAAAAAAD4htsuAAAA AAAAAAAAAAAAJAAAAAAAAAAAABAA/0ECQgAAYmV0d2l4dC9zcmMvdGVzdC9vcmcvYXBhY2hlL2Nv bW1vbnMvUEsBAhQACgAAAAAAKIfbLgAAAAAAAAAAAAAAACwAAAAAAAAAAAAQAP9BREIAAGJldHdp eHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvUEsBAhQACgAAAAAA3YbbLgAA AAAAAAAAAAAAADQAAAAAAAAAAAAQAP9BjkIAAGJldHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9j b21tb25zL2JldHdpeHQvZGVyaXZlZC9QSwECFAAUAAAACADjbpcum5hKrDoBAAAJAgAASQAAAAAA AAABACAAtoHgQgAAYmV0d2l4dC9zcmMvdGVzdC9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9k ZXJpdmVkL0NvbW1vbk9iamVjdEJlYW4uamF2YVBLAQIUABQAAAAIAOluly6rB+wFcgEAAPUCAABH AAAAAAAAAAEAIAC2gYFEAABiZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3 aXh0L2Rlcml2ZWQvQ29uc3VsdGFudEJlYW4uamF2YVBLAQIUAAoAAAAAAN2G2y4AAAAAAAAAAAAA AAA4AAAAAAAAAAAAEAD/QVhGAABiZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9i ZXR3aXh0L2Rlcml2ZWQvQ1ZTL1BLAQIUABQAAAAIADazyC4M/Hf8agAAADEBAAA/AAAAAAAAAAEA IAC2ga5GAABiZXR3aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2Rlcml2 ZWQvQ1ZTL0VudHJpZXNQSwECFAAUAAAACAA1X4suEC4kODgAAABEAAAAQgAAAAAAAAABACAAtoF1 RwAAYmV0d2l4dC9zcmMvdGVzdC9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9kZXJpdmVkL0NW Uy9SZXBvc2l0b3J5UEsBAhQAFAAAAAgANV+LLlZPaY0vAAAAMAAAADwAAAAAAAAAAQAgALaBDUgA AGJldHdpeHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvZGVyaXZlZC9DVlMv Um9vdFBLAQIUABQAAAAIAKCjdC61EFgDuAUAAO8MAABFAAAAAAAAAAEAIAC2gZZIAABiZXR3aXh0 L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2Rlcml2ZWQvRW1wbG95ZWVCZWFu LmphdmFQSwECFAAUAAAACADmbpcuJ8udRJoBAACsAwAAQwAAAAAAAAABACAAtoGxTgAAYmV0d2l4 dC9zcmMvdGVzdC9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9kZXJpdmVkL0hpdE1hbkJlYW4u amF2YVBLAQIUABQAAAAIANh9ly6VzYSBiAYAAFoPAABEAAAAAAAAAAEAIAC2gaxQAABiZXR3aXh0 L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2Rlcml2ZWQvTWFuYWdlckJlYW4u amF2YVBLAQIUABQAAAAIAA9+ly4tLAPkpgEAAIMFAABHAAAAAAAAAAEAIAC2gZZXAABiZXR3aXh0 L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2Rlcml2ZWQvcGVyc29uLWxpc3Qt ZXh0LnhtbFBLAQIUABQAAAAIAKCjdC7hxMRA/gAAAMgCAABDAAAAAAAAAAEAIAC2gaFZAABiZXR3 aXh0L3NyYy90ZXN0L29yZy9hcGFjaGUvY29tbW9ucy9iZXR3aXh0L2Rlcml2ZWQvcGVyc29uLWxp c3QueG1sUEsBAhQAFAAAAAgAoKN0LiCELdbFBgAAZhAAAEMAAAAAAAAAAQAgALaBAFsAAGJldHdp eHQvc3JjL3Rlc3Qvb3JnL2FwYWNoZS9jb21tb25zL2JldHdpeHQvZGVyaXZlZC9QZXJzb25CZWFu LmphdmFQSwECFAAUAAAACACgo3QualCKaFAGAADpDgAARwAAAAAAAAABACAAtoEmYgAAYmV0d2l4 dC9zcmMvdGVzdC9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9kZXJpdmVkL1BlcnNvbkxpc3RC ZWFuLmphdmFQSwECFAAUAAAACAA6bpcuTigyjQALAABOIgAARAAAAAAAAAABACAAtoHbaAAAYmV0 d2l4dC9zcmMvdGVzdC9vcmcvYXBhY2hlL2NvbW1vbnMvYmV0d2l4dC9kZXJpdmVkL1Rlc3REZXJp dmVkLmphdmFQSwECFAAKAAAAAADahtsuAAAAAAAAAAAAAAAACAAAAAAAAAAAABAA/0E9dAAAYmV0 d2l4dC9QSwUGAAAAACAAIADiCwAAY3QAAAAA ------=_NextPart_000_0001_01C33CCF.045D3520 Content-Type: text/plain; charset=us-ascii --------------------------------------------------------------------- To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org For additional commands, e-mail: commons-dev-help@jakarta.apache.org ------=_NextPart_000_0001_01C33CCF.045D3520--