airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From samin...@apache.org
Subject svn commit: r1516063 - in /airavata/trunk/modules/integration-tests/src/test: java/org/apache/airavata/integration/ForEachCaseIT.java resources/ForEachBasicWorkflow.xwf
Date Wed, 21 Aug 2013 02:58:15 GMT
Author: samindaw
Date: Wed Aug 21 02:58:15 2013
New Revision: 1516063

URL: http://svn.apache.org/r1516063
Log:
additional test cases for foreach

Added:
    airavata/trunk/modules/integration-tests/src/test/resources/ForEachBasicWorkflow.xwf
Modified:
    airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java

Modified: airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java
URL: http://svn.apache.org/viewvc/airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java?rev=1516063&r1=1516062&r2=1516063&view=diff
==============================================================================
--- airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java (original)
+++ airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java Wed Aug 21 02:58:15 2013
@@ -36,6 +36,10 @@ import org.apache.airavata.client.Airava
 import org.apache.airavata.client.api.AiravataAPI;
 import org.apache.airavata.client.api.ExperimentAdvanceOptions;
 import org.apache.airavata.client.api.builder.DescriptorBuilder;
+import org.apache.airavata.client.api.exception.AiravataAPIInvocationException;
+import org.apache.airavata.client.api.exception.DescriptorAlreadyExistsException;
+import org.apache.airavata.client.api.exception.WorkflowAlreadyExistsException;
+import org.apache.airavata.common.utils.StringUtil;
 import org.apache.airavata.commons.gfac.type.ApplicationDescription;
 import org.apache.airavata.commons.gfac.type.HostDescription;
 import org.apache.airavata.commons.gfac.type.ServiceDescription;
@@ -46,15 +50,13 @@ import org.apache.airavata.registry.api.
 import org.apache.airavata.registry.api.workflow.NodeExecutionData;
 import org.apache.airavata.registry.api.workflow.WorkflowNodeType.WorkflowNode;
 import org.apache.airavata.schemas.gfac.DataType;
+import org.apache.airavata.schemas.gfac.HostDescriptionType;
 import org.apache.airavata.schemas.gfac.InputParameterType;
 import org.apache.airavata.schemas.gfac.OutputParameterType;
+import org.apache.airavata.workflow.model.component.ComponentException;
+import org.apache.airavata.workflow.model.graph.GraphException;
 import org.apache.airavata.workflow.model.wf.Workflow;
 import org.apache.airavata.workflow.model.wf.WorkflowInput;
-import org.apache.airavata.ws.monitor.EventData;
-import org.apache.airavata.ws.monitor.EventDataListenerAdapter;
-import org.apache.airavata.ws.monitor.EventDataRepository;
-import org.apache.airavata.ws.monitor.Monitor;
-import org.apache.airavata.ws.monitor.MonitorUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.testng.annotations.BeforeTest;
@@ -218,16 +220,46 @@ public class ForEachCaseIT {
         PasswordCallback passwordCallback = new PasswordCallbackImpl();
         this.airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
                 passwordCallback);
+        setupDescriptors();
     }
 
-    @Test(groups = { "echoGroup" })
+    @Test(groups = { "forEachGroup" }, dependsOnGroups = { "echoGroup" })
     public void testEchoService() throws Exception {
+		executeExperiment("src/test/resources/ForEachBasicWorkflow.xwf", Arrays.asList("10","20"), Arrays.asList("10 20"));
+		executeExperiment("src/test/resources/ForEachBasicWorkflow.xwf", Arrays.asList("10","20,30"), Arrays.asList("10 20","10 30"));
+		executeExperiment("src/test/resources/ForEachBasicWorkflow.xwf", Arrays.asList("10,20","30,40"), Arrays.asList("10 30","20 40"));
+		
+		executeExperiment("src/test/resources/ForEachEchoWorkflow.xwf", Arrays.asList("10","20"), Arrays.asList("10,20"));
+		executeExperiment("src/test/resources/ForEachEchoWorkflow.xwf", Arrays.asList("10","20,30"), Arrays.asList("10,20","10,30"));
+		executeExperiment("src/test/resources/ForEachEchoWorkflow.xwf", Arrays.asList("10,20","30,40"), Arrays.asList("10,30","20,40"));
+    }
 
-        DescriptorBuilder descriptorBuilder = airavataAPI.getDescriptorBuilder();
-        
-        log("Checking host description ....");
-        Assert.assertTrue(airavataAPI.getApplicationManager().isHostDescriptorExists("localhost"));
-        HostDescription hostDescription = airavataAPI.getApplicationManager().getHostDescription("localhost");
+	private void executeExperiment(String workflowFilePath,
+			List<String> inputs, List<String> outputs) throws GraphException,
+			ComponentException, IOException, WorkflowAlreadyExistsException,
+			AiravataAPIInvocationException, Exception {
+        log("Saving workflow ...");
+
+		Workflow workflow = new Workflow(getWorkflowComposeContent(workflowFilePath));
+		if (!airavataAPI.getWorkflowManager().isWorkflowExists(workflow.getName())){
+			airavataAPI.getWorkflowManager().addWorkflow(workflow);
+		}
+		Assert.assertTrue(airavataAPI.getWorkflowManager().isWorkflowExists(workflow.getName()));
+
+        log("Workflow setting up completed ...");
+
+		runWorkFlow(workflow, inputs,outputs);
+	}
+
+	private void setupDescriptors() throws AiravataAPIInvocationException,
+			DescriptorAlreadyExistsException, IOException {
+		DescriptorBuilder descriptorBuilder = airavataAPI.getDescriptorBuilder();
+		HostDescription hostDescription = descriptorBuilder.buildHostDescription(HostDescriptionType.type, "localhost2",
+                "127.0.0.1");
+
+        log("Adding host description ....");
+        airavataAPI.getApplicationManager().addHostDescription(hostDescription);
+        Assert.assertTrue(airavataAPI.getApplicationManager().isHostDescriptorExists(hostDescription.getType().getHostName()));
         
         List<InputParameterType> inputParameters = new ArrayList<InputParameterType>();
         inputParameters.add(descriptorBuilder.buildInputParameterType("data1", "data1", DataType.STRING));
@@ -238,17 +270,26 @@ public class ForEachCaseIT {
 
         ServiceDescription serviceDescription = descriptorBuilder.buildServiceDescription("comma_app", "comma_app",
                 inputParameters, outputParameters);
+        
+        ServiceDescription serviceDescription2 = descriptorBuilder.buildServiceDescription("echo_app", "echo_app",
+                inputParameters, outputParameters);
 
         log("Adding service description ...");
         airavataAPI.getApplicationManager().addServiceDescription(serviceDescription);
         Assert.assertTrue(airavataAPI.getApplicationManager().isServiceDescriptorExists(
                 serviceDescription.getType().getName()));
+        
+        airavataAPI.getApplicationManager().addServiceDescription(serviceDescription2);
+        Assert.assertTrue(airavataAPI.getApplicationManager().isServiceDescriptorExists(
+                serviceDescription2.getType().getName()));
 
         // Deployment descriptor
         File executable = getFile("src/test/resources/comma_data.sh");
         Runtime.getRuntime().exec("chmod +x "+executable.getAbsolutePath());
 		ApplicationDescription applicationDeploymentDescription = descriptorBuilder
                 .buildApplicationDeploymentDescription("comma_app_localhost", executable.getAbsolutePath(), "/tmp");
+		ApplicationDescription applicationDeploymentDescription2 = descriptorBuilder
+                .buildApplicationDeploymentDescription("echo_app_localhost", "/bin/echo", "/tmp");
 
         log("Adding deployment description ...");
         airavataAPI.getApplicationManager().addApplicationDescription(serviceDescription, hostDescription,
@@ -257,20 +298,16 @@ public class ForEachCaseIT {
         Assert.assertTrue(airavataAPI.getApplicationManager().isApplicationDescriptorExists(
                 serviceDescription.getType().getName(), hostDescription.getType().getHostName(),
                 applicationDeploymentDescription.getType().getApplicationName().getStringValue()));
+        
+        airavataAPI.getApplicationManager().addApplicationDescription(serviceDescription2, hostDescription,
+                applicationDeploymentDescription2);
 
-        log("Saving workflow ...");
-        Workflow workflow = new Workflow(getWorkflowComposeContent("src/test/resources/ForEachEchoWorkflow.xwf"));
-        airavataAPI.getWorkflowManager().addWorkflow(workflow);
-
-        Assert.assertTrue(airavataAPI.getWorkflowManager().isWorkflowExists(workflow.getName()));
-
-        log("Workflow setting up completed ...");
-
-        runWorkFlow(workflow, Arrays.asList("10","20"));
-    }
-
-    protected void runWorkFlow(Workflow workflow, List<String> inputValues) throws Exception {
+        Assert.assertTrue(airavataAPI.getApplicationManager().isApplicationDescriptorExists(
+                serviceDescription2.getType().getName(), hostDescription.getType().getHostName(),
+                applicationDeploymentDescription2.getType().getApplicationName().getStringValue()));
+	}
 
+    protected void runWorkFlow(Workflow workflow, List<String> inputValues, List<String> outputValue) throws Exception {
         AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
                 new PasswordCallbackImpl());
         List<WorkflowInput> workflowInputs = setupInputs(workflow, inputValues);
@@ -278,19 +315,17 @@ public class ForEachCaseIT {
         ExperimentAdvanceOptions options = airavataAPI.getExecutionManager().createExperimentAdvanceOptions(
                 workflowName, getUserName(), null);
 
-//        options.getCustomSecuritySettings().getCredentialStoreSecuritySettings().setTokenId("1234");
-
         String experimentId = airavataAPI.getExecutionManager().runExperiment(workflowName, workflowInputs, options);
 
         Assert.assertNotNull(experimentId);
 
         log.info("Run workflow completed ....");
-        log.info("Starting monitoring ....");
 
-        monitor(experimentId);
+        airavataAPI.getExecutionManager().waitForExperimentTermination(experimentId);
+        verifyOutput(experimentId, outputValue);
     }
 
-    protected void verifyOutput(String experimentId, String outputVerifyingString) throws Exception {
+    protected void verifyOutput(String experimentId, List<String> outputVerifyingString) throws Exception {
         AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
                 new PasswordCallbackImpl());
         log.info("Experiment ID Returned : " + experimentId);
@@ -307,9 +342,12 @@ public class ForEachCaseIT {
             List<NodeExecutionData> nodeDataList = data.getNodeDataList(WorkflowNode.OUTPUTNODE);
             Assert.assertFalse("Node execution data list cannot be empty !", nodeDataList.isEmpty());
             for (NodeExecutionData nodeData : nodeDataList) {
-
                 for (InputData inputData : nodeData.getInputData()) {
-                    Assert.assertEquals(outputVerifyingString, inputData.getValue());
+                	String[] outputValues = StringUtil.getElementsFromString(inputData.getValue());
+                	Assert.assertEquals(outputVerifyingString.size(), outputValues.length);
+                	for(int i=0;i<outputValues.length;i++){
+                		Assert.assertEquals(outputVerifyingString.get(i), outputValues[i]);	
+                	}
                 }
             }
         }
@@ -355,32 +393,6 @@ public class ForEachCaseIT {
 		return file;
 	}
 
-    public void monitor(final String experimentId) throws Exception {
-        AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
-                new PasswordCallbackImpl());
-        final Monitor experimentMonitor = airavataAPI.getExecutionManager().getExperimentMonitor(experimentId,
-                new EventDataListenerAdapter() {
-
-                    public void notify(EventDataRepository eventDataRepo, EventData eventData) {
-                        Assert.assertNotNull(eventDataRepo);
-                        Assert.assertNotNull(eventData);
-                        if (MonitorUtil.EventType.WORKFLOW_TERMINATED.equals(eventData.getType())) {
-                            try {
-                                ForEachCaseIT.this.verifyOutput(experimentId, "\"10,20\"");
-                            } catch (Exception e) {
-                                log.error("Error verifying output", e);
-                                Assert.fail("Error occurred while verifying output.");
-                            } finally {
-                                getMonitor().stopMonitoring();
-                            }
-                        }
-                        log.info("No of events: " + eventDataRepo.getEvents().size());
-                    }
-                });
-        experimentMonitor.startMonitoring();
-        experimentMonitor.waitForCompletion();
-    }
-
 	public void setRegistryURL(String registryURL) {
 		this.registryURL = registryURL;
 	}

Added: airavata/trunk/modules/integration-tests/src/test/resources/ForEachBasicWorkflow.xwf
URL: http://svn.apache.org/viewvc/airavata/trunk/modules/integration-tests/src/test/resources/ForEachBasicWorkflow.xwf?rev=1516063&view=auto
==============================================================================
--- airavata/trunk/modules/integration-tests/src/test/resources/ForEachBasicWorkflow.xwf (added)
+++ airavata/trunk/modules/integration-tests/src/test/resources/ForEachBasicWorkflow.xwf Wed Aug 21 02:58:15 2013
@@ -0,0 +1,675 @@
+<?xml version="1.0"?><xwf:workflow xwf:version="0.9" xmlns:xwf="http://airavata.apache.org/xbaya/xwf">
+  <xgr:graph xgr:version="0.9" xgr:type="ws" xmlns:xgr="http://airavata.apache.org/xbaya/graph">
+    <xgr:id>Workflow1</xgr:id>
+    <xgr:name>ForEachBasicWorkflow</xgr:name>
+    <xgr:description></xgr:description>
+    <xgr:metadata>
+      <appinfo xmlns="http://www.w3.org/2001/XMLSchema">
+
+</appinfo>
+    </xgr:metadata>
+    <xgr:node xgr:type="ws">
+      <xgr:id>echo_app_invoke</xgr:id>
+      <xgr:name>echo_app:invoke</xgr:name>
+      <xgr:outputPort>echo_app_invoke_out_0</xgr:outputPort>
+      <xgr:inputPort>echo_app_invoke_in_0</xgr:inputPort>
+      <xgr:inputPort>echo_app_invoke_in_1</xgr:inputPort>
+      <xgr:controlInPort>echo_app_invoke_ctrl_in_0</xgr:controlInPort>
+      <xgr:controlOutPort>echo_app_invoke_ctrl_out_0</xgr:controlOutPort>
+      <xgr:x>387</xgr:x>
+      <xgr:y>137</xgr:y>
+      <xgr:wsdl>echo_app</xgr:wsdl>
+      <xgr:portType>{http://airavata.apache.org/schemas/gfac/2012/12}echo_app</xgr:portType>
+      <xgr:operation>invoke</xgr:operation>
+    </xgr:node>
+    <xgr:node xgr:type="input">
+      <xgr:id>Input</xgr:id>
+      <xgr:name>Input</xgr:name>
+      <xgr:outputPort>Input_out_2</xgr:outputPort>
+      <xgr:x>66</xgr:x>
+      <xgr:y>72</xgr:y>
+      <xgr:config>
+        <xgr:dataType>{http://www.w3.org/2001/XMLSchema}any</xgr:dataType>
+        <xgr:value>10,20</xgr:value>
+        <xgr:visibility>true</xgr:visibility>
+      </xgr:config>
+    </xgr:node>
+    <xgr:node xgr:type="input">
+      <xgr:id>Input_2</xgr:id>
+      <xgr:name>Input</xgr:name>
+      <xgr:outputPort>Input_2_out_3</xgr:outputPort>
+      <xgr:x>62</xgr:x>
+      <xgr:y>186</xgr:y>
+      <xgr:config>
+        <xgr:dataType>{http://www.w3.org/2001/XMLSchema}any</xgr:dataType>
+        <xgr:value>30,40</xgr:value>
+        <xgr:visibility>true</xgr:visibility>
+      </xgr:config>
+    </xgr:node>
+    <xgr:node xgr:type="split">
+      <xgr:id>ForEach</xgr:id>
+      <xgr:name>ForEach</xgr:name>
+      <xgr:outputPort>ForEach_out_0</xgr:outputPort>
+      <xgr:outputPort>ForEach_out_1</xgr:outputPort>
+      <xgr:inputPort>ForEach_in_0</xgr:inputPort>
+      <xgr:inputPort>ForEach_in_1</xgr:inputPort>
+      <xgr:controlInPort>ForEach_ctrl_in_0</xgr:controlInPort>
+      <xgr:controlOutPort>ForEach_ctrl_out_0</xgr:controlOutPort>
+      <xgr:x>213</xgr:x>
+      <xgr:y>139</xgr:y>
+      <xgr:config />
+    </xgr:node>
+    <xgr:node xgr:type="merge">
+      <xgr:id>EndForEach</xgr:id>
+      <xgr:name>EndForEach</xgr:name>
+      <xgr:outputPort>EndForEach_out_0</xgr:outputPort>
+      <xgr:inputPort>EndForEach_in_0</xgr:inputPort>
+      <xgr:controlInPort>EndForEach_ctrl_in_0</xgr:controlInPort>
+      <xgr:controlOutPort>EndForEach_ctrl_out_0</xgr:controlOutPort>
+      <xgr:x>588</xgr:x>
+      <xgr:y>155</xgr:y>
+      <xgr:config />
+    </xgr:node>
+    <xgr:node xgr:type="output">
+      <xgr:id>Output</xgr:id>
+      <xgr:name>Output</xgr:name>
+      <xgr:inputPort>Output_in_2</xgr:inputPort>
+      <xgr:x>847</xgr:x>
+      <xgr:y>184</xgr:y>
+      <xgr:config>
+        <xgr:dataType>{http://airavata.apache.org/schemas/gfac/2012/12}StdOutParameterType</xgr:dataType>
+      </xgr:config>
+    </xgr:node>
+    <xgr:port xgr:type="ws">
+      <xgr:id>echo_app_invoke_in_0</xgr:id>
+      <xgr:name>data1</xgr:name>
+      <xgr:node>echo_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="ws">
+      <xgr:id>echo_app_invoke_in_1</xgr:id>
+      <xgr:name>data2</xgr:name>
+      <xgr:node>echo_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="ws">
+      <xgr:id>echo_app_invoke_out_0</xgr:id>
+      <xgr:name>out</xgr:name>
+      <xgr:node>echo_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="control">
+      <xgr:id>echo_app_invoke_ctrl_in_0</xgr:id>
+      <xgr:name>control</xgr:name>
+      <xgr:node>echo_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="control">
+      <xgr:id>echo_app_invoke_ctrl_out_0</xgr:id>
+      <xgr:name>control</xgr:name>
+      <xgr:node>echo_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>Input_out_2</xgr:id>
+      <xgr:name>Parameter</xgr:name>
+      <xgr:node>Input</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>Input_2_out_3</xgr:id>
+      <xgr:name>Parameter</xgr:name>
+      <xgr:node>Input_2</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>ForEach_in_0</xgr:id>
+      <xgr:name>Input</xgr:name>
+      <xgr:node>ForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>ForEach_out_0</xgr:id>
+      <xgr:name>Output1</xgr:name>
+      <xgr:node>ForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="control">
+      <xgr:id>ForEach_ctrl_in_0</xgr:id>
+      <xgr:name>control</xgr:name>
+      <xgr:node>ForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="control">
+      <xgr:id>ForEach_ctrl_out_0</xgr:id>
+      <xgr:name>control</xgr:name>
+      <xgr:node>ForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>EndForEach_in_0</xgr:id>
+      <xgr:name>Input</xgr:name>
+      <xgr:node>EndForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>EndForEach_out_0</xgr:id>
+      <xgr:name>Output</xgr:name>
+      <xgr:node>EndForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="control">
+      <xgr:id>EndForEach_ctrl_in_0</xgr:id>
+      <xgr:name>control</xgr:name>
+      <xgr:node>EndForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="control">
+      <xgr:id>EndForEach_ctrl_out_0</xgr:id>
+      <xgr:name>control</xgr:name>
+      <xgr:node>EndForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>Output_in_2</xgr:id>
+      <xgr:name>Parameter</xgr:name>
+      <xgr:node>Output</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>ForEach_in_1</xgr:id>
+      <xgr:name>Input</xgr:name>
+      <xgr:node>ForEach</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="systemData">
+      <xgr:id>ForEach_out_1</xgr:id>
+      <xgr:name>Output1</xgr:name>
+      <xgr:node>ForEach</xgr:node>
+    </xgr:port>
+    <xgr:edge xgr:type="data">
+      <xgr:fromPort>Input_out_2</xgr:fromPort>
+      <xgr:toPort>ForEach_in_0</xgr:toPort>
+    </xgr:edge>
+    <xgr:edge xgr:type="data">
+      <xgr:fromPort>Input_2_out_3</xgr:fromPort>
+      <xgr:toPort>ForEach_in_1</xgr:toPort>
+    </xgr:edge>
+    <xgr:edge xgr:type="data">
+      <xgr:fromPort>ForEach_out_0</xgr:fromPort>
+      <xgr:toPort>echo_app_invoke_in_0</xgr:toPort>
+    </xgr:edge>
+    <xgr:edge xgr:type="data">
+      <xgr:fromPort>ForEach_out_1</xgr:fromPort>
+      <xgr:toPort>echo_app_invoke_in_1</xgr:toPort>
+    </xgr:edge>
+    <xgr:edge xgr:type="data">
+      <xgr:fromPort>echo_app_invoke_out_0</xgr:fromPort>
+      <xgr:toPort>EndForEach_in_0</xgr:toPort>
+    </xgr:edge>
+    <xgr:edge xgr:type="data">
+      <xgr:fromPort>EndForEach_out_0</xgr:fromPort>
+      <xgr:toPort>Output_in_2</xgr:toPort>
+    </xgr:edge>
+  </xgr:graph>
+  <xwf:wsdls>
+    <xwf:wsdl xwf:id="echo_app">&lt;wsdl:definitions name="echo_app" targetNamespace="http://airavata.apache.org/schemas/gfac/2012/12"
+  xmlns:typens="http://airavata.apache.org/schemas/gfac/2012/12/echo_app/xsd" xmlns:wsa="http://www.w3.org/2005/08/addressing" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+  xmlns:globalTypens="http://airavata.apache.org/schemas/gfac/2012/12/xsd"
+  xmlns:wsdlns="http://airavata.apache.org/schemas/gfac/2012/12" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+  xmlns:gfac="http://airavata.apache.org/schemas/gfac/2012/12" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
+  &lt;wsdl:types>
+    &lt;schema elementFormDefault="unqualified" targetNamespace="http://airavata.apache.org/schemas/gfac/2012/12/echo_app/xsd" xmlns="http://www.w3.org/2001/XMLSchema">
+      &lt;import namespace="http://airavata.apache.org/schemas/gfac/2012/12" schemaLocation="http://airavata.apache.org/schemas/gfac/2012/12/GFacParameterTypes.xsd" />
+      &lt;element name="invoke_InputParams" type="typens:invoke_InputParamsType" />
+      &lt;complexType name="invoke_InputParamsType">
+        &lt;sequence>
+          &lt;element name="data1" type="gfac:StringParameterType">
+            &lt;annotation>
+              &lt;documentation />
+            &lt;/annotation>
+          &lt;/element>
+          &lt;element name="data2" type="gfac:StringParameterType">
+            &lt;annotation>
+              &lt;documentation />
+            &lt;/annotation>
+          &lt;/element>
+        &lt;/sequence>
+      &lt;/complexType>
+      &lt;element name="invoke_OutputParams" type="typens:invoke_OutputParamsType" />
+      &lt;complexType name="invoke_OutputParamsType">
+        &lt;sequence>
+          &lt;element name="out" type="gfac:StdOutParameterType">
+            &lt;annotation>
+              &lt;documentation />
+            &lt;/annotation>
+          &lt;/element>
+        &lt;/sequence>
+      &lt;/complexType>
+    &lt;/schema>
+  &lt;/wsdl:types>
+  &lt;wsdl:message name="invoke_ResponseMessage_f692c670-fe14-4397-8077-d81eaf2434b8">
+    &lt;wsdl:part name="parameters" element="typens:invoke_OutputParams">
+    &lt;/wsdl:part>
+  &lt;/wsdl:message>
+  &lt;wsdl:message name="invoke_RequestMessage_d2bf2d35-fb8a-4eec-a9ee-65639a99faea">
+    &lt;wsdl:part name="parameters" element="typens:invoke_InputParams">
+    &lt;/wsdl:part>
+  &lt;/wsdl:message>
+  &lt;wsdl:portType name="echo_app">
+&lt;wsdl:documentation />
+    &lt;wsdl:operation name="invoke">
+&lt;wsdl:documentation />
+      &lt;wsdl:input name="invoke_RequestMessage_d2bf2d35-fb8a-4eec-a9ee-65639a99faea" message="wsdlns:invoke_RequestMessage_d2bf2d35-fb8a-4eec-a9ee-65639a99faea">
+    &lt;/wsdl:input>
+      &lt;wsdl:output name="invoke_ResponseMessage_f692c670-fe14-4397-8077-d81eaf2434b8" message="wsdlns:invoke_ResponseMessage_f692c670-fe14-4397-8077-d81eaf2434b8">
+    &lt;/wsdl:output>
+    &lt;/wsdl:operation>
+  &lt;/wsdl:portType>
+&lt;/wsdl:definitions></xwf:wsdl>
+  </xwf:wsdls>
+  <xwf:image>iVBORw0KGgoAAAANSUhEUgAAA70AAADtCAYAAABzuxLGAABdGklEQVR42u2dCXhUVba2c5tRuUKr
+F1u5OPz6t6h0S2tr/3rbqzhcW3tAW6UnwEZxRK9KOzbatjKDTCpDmAwkIYyBAIEAgQQCAQIJBBJI
+IMzzPCPYiOvf36465cnhVNWpqlOVSvLV87xPUkMqSdU+p/a719prJezcuVUIIYQQQgghhJCaSAJf
+BEIIIYQQQgghlF5CCCGEEEIIIYTSSwghhBBCCCGEUHoJIYQQQgghhBBKLyGEEEIIIYQQQuklhBBC
+CCGEEEIovYQQQgghhBBCKL2EEEIIIYQQQgillxBCCCGEEEIIofQSQgghhBBCCCGUXkIIIYQQQggh
+hNJLCCGEEEIIIYRQegkhhBBCCCGEUHoJIYQQQgghhBBKLyGEEEIIIYQQQuklhBBCCCGEEEIovYQQ
+QgghhBBCCKWXEEIIIYQQQgih9BJCCCGEEEIIofQSQgghhBBCCCGUXkIIIYQQQgghhNJLCCGEEEII
+IYRQegkhhBBCCCGEEEovIYQQQgghhBBC6SWEEEIIIYQQQii9hBBCCCGEEEIovYQQQgghhBBCCKWX
+EEIIIYQQQgih9BJCCCGEEEIIIZReQgghhBBCCCGE0ksIIYQQQgghhFB6CSGEEEIIIYRQegkhhBBC
+CCGEEEovIYQQQgghhBBC6SWEEEIIIYQQQii9hBBCCCGEEEIIpZcQQgghhBBCCKH0EkIIIYQQQgih
+9BJCCCGEEEIIIZReQgghhBBCCCGE0ksIIYQQQgghhFB6CSGEEEIIIYQQSi8hhBBCCCGEEELpJYQQ
+QgghhBBCKL2EEEIIIYQQQii9hBBCCCGEEEIIpZcQQgghhBBCCKH0EkIIIYQQQgghlF5CCCGEEEII
+IYTSSwghhBBCCCGEUHoJIYQQQgghhFB6CSGEEEIIIYQQSi8hhBBCCCGEEELpJYQQQgghhBBCKL2E
+EEIIIYQQQgillxBCCCGEEEIIofQSQgghhBBCCKH0EkIIIYQQQgghlF5CCCGEEEIIIYTSSwghhBBC
+CCGEUHoJIYQQQgghhBBKLyGEEEIIIYQQQuklhBBCCCGEEELp5QtBCCGEEEIIIYTSSwghhBBCCCGE
+UHoJIYQQQgghhBBKLyGEEEIIIYQQQuklhBBCCCGEEEIovYQQQgghhBBCCKWXEEIIIYQQQgillxBC
+CCGEEEIIofTWFHbtkDlZWTJo8GD55JNPSIzo3rufjBg7XkpL13IMEkIIIYQQQii90aCsbIMMHDhQ
+cnJyZe++A/Kvb0W+UZw7L3JW8fW/RM4oTn8jckpx8pzICcXxsyLHFEe/FjmiOHxG5JDi4GmRA4r9
+p0T2KfaeFNmj2H1CZJdi53GRHYrtx0S2KbYeFdmi2HxEpEKx6bDIRkX5IZEyxYaDIusVpQdEShTr
+9ousVRTvE1mjWL1XpEhRuMfDyt0eVuzysGynh6U7PORt97Bom4ecrR4WbPGQrZi/WWSeYm6FSJZi
+ziaR2YrMjSKzFDPLRWYoMspEpiumbRBJV0xdLzJFMblUZJJiYonIBEXaOpHxitS1IimK5GKRcYpR
+S4/I4MlLpGeffpKfn8fxSAghhBBCCKH0usnu3Tu18G7bvkPOXxDNN17pPeuV3jNe6T3lld4TXuk9
+FofSu8orvQVe6V3uld58r/Qu8UrvYq/05nqld6FJeiG8873CO9crvHO8wpvpFd6ZXuHN8ArvNK/w
+hiq9Y9eIJCkSc/dJbyW+jPgSQgghhBBCKL0ukpWVJTm5ufKtV3idRnnN0nvEK72HvNJ7wCu9+7zS
+u8crvbu80rvDK73b4lB6I43yTvUK72Sv8E70Cm+aV3hTvcKb7BVe8NVqD4NTsyQ5eRzHJSGEEEII
+IYTS6xaDBw+WffsPhCy9bqU2gy1e6a3wSu9Gr/SWeaV3vVd6S7zSu9YrvWviUHrDifJCeMcoEhcf
+lL59+3JcEkIIIYQQQii9boFiShe+kyqT3kijvKCohkjv6CLR78fMmRlSXFzI8UkIIYQQQgih9NZ2
+6Y20iFU8Sm9y8lhNXl4uxyghhBBCCCGE0uuG9AYrYhUt6U1ISNBUxX5e43fnRFDEKprSCxjxJYQQ
+QgghhFB6I5TeYFHeQJWbnRaximfpDTfKa1e5OdQiVsGkF6nOHKeEEEIIIYQQSm8UpTfSKG+gys2G
+eBpFrIzrBnXr1ZP/26KlpMxa6pNe62Pq128gT/7lBVmx47xPeo37zNJr3AbptT4HiHVqs7lyM4TX
+TnpTUpI5TgkhhBBCCCGU3niW3kD7ec3Siyivcf3Pz70qJXvPy+ip2fp68+tv9FVuNh7T4ZW3dZT3
+hbc+0tdf6PKxY+l1I9LrdmrzKBvpBRynhBBCCCGEEEpvDZPeVVtP+FKbcf0Hder4UpuNxywqO6ql
+d3H5CX296Y+a+YpY4Xq9+g0ovYQQQgghhBBKb22XXmsRq3iQXvN+XuM2q/Sa9/PqVOi69Xz7ec3S
+a1Ru9snytsrS67SIFaWXEEIIIYQQQumtptJrRHntKjeHWsQqVtK7ZOOJSpHeq65pXkl6ER02orzz
+N5yqJL25FukNFuW1q9wcahErSi8hhBBCCCGE0lvF0htplNeucrO/IlZbLNK7MUTp/Wvnd7X0Pv9G
+V339+Tc/8knvf153o75tcFq25G27IG3+8tJF0tvw0kb6+pSC/VFPbbar3GwtYjWykNJLCCGEEEII
+ofTGtfSGEuU1S6/Rqsgsvest0rvWIr2+Cs916+nqzcu3n/dJ74hpS+X/3NxSR3utjzek981uQ+XS
+Rpf5bq/q/byUXkIIIYQQQgilt4ZJbzj9eQ1JNfbzFnr784bSoxfSm7NV4qqIFdObCSGEEEIIIZTe
+KEjvt9VceleZpBfCu8IrvOYiVhDePK/wLvIKb45XeM1FrCi9hBBCCCGEEEpvDZPe774Tn/iGWsSq
+KqS3fv0GGqv0RhrlDVS52WkRq1ClV+/pZSErQgghhBBCCKU3etJ75swZOX36tJw6dUpOnjwpJ06c
+kOPHj8uxY8fk6NGjcuTIETl06JAcPHhQDhw4IPv375d9+/bJ3r17Zc+ePbJ7927ZtWuXer6dsmPH
+Dtm2bZts3bpVtmzZIps3b5aKigrZtGmTbNy4UcrLy6WsrEw2bNgg69evl5KSElm3bp2sXbtWiouL
+Zc2aNbJ69WopKiqSwsJCWbVqlaxcuVIKCgpkxYoVsmzZMsnPz5elS5fKkiVLJC8vTxYvXiyLFi2S
+3NxcycnJkYULF8qCBQskOztb5s+fL/PmzZO5c+dKVlaWzJkzRzIzM2XWrFkyc+ZMmTFjhmRkZMj0
+6dNl2rRpkp6eLlOnTpUpU6bI5MmTZeLEiTJhwgRJS0uT8ePHS2pqqqSkpCgZTZZx48bJ2LFjJSkp
+Sb766isZM2aMjBo1SkaOHCkjRoyQxMREGT58uAwbNkyGDh0qQ4YMkS+//FK++OIL+fzzz2XQoEEy
+cOBAGTBggPTv318+++wzSi8hhBBCCCGE0htt6bUK7+HDh/1Kr1V4t2/frqXXEN6aBMQdQg5pthPe
+0aNH+5Veq/AOHjyY0ksIIYQQQgih9MZCeoNFeQ3pdRLlhfQiylvThNcKosr+pNdJlNeQXrPw9uvX
+j9JLCCGEEEIIofTGQnqdRHkN6a1twmuA9GgnUV5DeoNFeSm9hBBCCCGEEEpvFKTXSZTXkN5gUd54
+SmtGZPXKK6/UlZ6j8fzYd+xPep1EeQ3pNYS3b9++lF5CCCGEEEIIpTdW0uskymtIr7GXN1RxhDTe
+euutUr9+fbn22mulT58+rknpVVddpYtYGdfdll/s8XUa5W2xs4W8NeWtgFFeSi8hhBBCCCGE0hsF
+6XUa5TWk11+UN1TpRbVkiCkqI+M6KjM/++yzrklptCK8ZgJJrznKm3A+QRLOJsjN5TfLW6lvXSS9
+EF4IP6WXEEIIIYQQQumNofQ6bVMUzn7exx57TIufv/vR0qhdu3ZyySWXaPA9bjNLbe/evaVZs2ZS
+t25due2223RlZeM+M1YJRtukp59+WkeYkQL9wQcfhCXJTtsUQXgTTimOKQ4lyC2rb5HXxr1WKcpL
+6SWEEEIIIYRQeqMkvaG0KYL02kV5Q5XeRo0aafn0d/+LL74ojzzyiO7fCx599FF9m1l627Rpo/v5
+ItW4a9eu0qpVK7+RXvP1l19+WT8fegTjuSHg4Uiv0zZFZuFN2K/YrdieID9e9mPpPKazll4IPKWX
+EEIIIYQQQul1WXrdaFMUjvQGk8ymTZvK4sWLfdfxPaKy5p83R34hvoj4OpFePHd+fr7vOr6PRHqD
+tSmyE96EzYpyRWmC3Jx9s7w67FVKLyGEEEIIIYTSGy3pDaVNEaTXKryhVm4OFum1k9BAUmu9LZD0
+BvtZpzhtUxRIeBOKE6R5bnPpMLqDfj86dOig6dSpk45IP/XUk9K+fTt5552/yYAB/SQtLUXy8nKl
+oqKMY5gQQgghhBBC6Q0mvZG2KQpXepFeHGhPL6KxS5YsCRjpDVd6rZFe/J5IpTdQmyJ/wts8r7n8
+dfRfpWefntKrVy/9fiQmDtcMHowqzwO06Hbr9om88cbr0rbtM3LvvffIDTdcL3Xr1pEWLW6WNm1+
+Jx9++HeZNClNyspKOa4JIYQQQgghlF5/0htKmyJIb7jCa1RvhnxOmjTJtnqzse8We26x9xb7e617
+esOVXjw39vHiecHjjz8elvQGK2AF6UWbIqvwNs9vLs8lPSe9+/XWBaywn9eQXqfpzVu3VkhWVqb0
+7dtbOnZ8Vu688w5p0KCBlmJIMKLBHOOEEEIIIYRQemu99Ebapihc6TX36a1Tp47u04sWPubqzZBg
+VFgG7du3r5QOHYn04rnbtm2r06WbNGmiqzebU6fDlV67KK+WXq/wXr/ieumY0lH69u+rqzabhbdn
+z54R7+lFynNS0mgdEb7iisu1CA8ePJCp0IQQQgghhFB6Kb3htCmC9BrCW1FREfW+uNEiNzdXmjdv
+HvLPBYvyGtJ7beG10imlk/Qb0O+iNkVuSq81EozUaER+8b8hIozbOO4JIYQQQgih9NYq6Y20TVF1
+lV6kSiO1uaio6KLU6Uik1yq8gwZhb+5AvX8ZkWyr9BrC26NHj6hVb8Z+37vvvksLcG5uNsc+IYQQ
+QgghlN7aLb2htCmC9EJ40TKoOknvp59+qgtjNWzYUJ5++ulK7Y+cgP/XSZTXkF474TVHeaMpvQYf
+fPCeTntOTBzK8U8IIYQQQgilt3ZIrxttigzprc4pzqGyatUqv9LrNMprSC+Et3v37jHp05ucnKQL
+XmHvL48BQgghhBBCKL21VnpDaVME2d24caOmtkhvenq6ll4nUV5DegNFeWMR6TWLLyK+y5bl8Tgg
+hBBCCCGE0ltzgYwhQhtJmyIjygvhLS8vr3ZpzuGwYMGCoKnNTqO8hvT27dtHR3tjIb2gS5c39R5f
+FrcihBBCCCGE0ltjSU+fInPmzPYrvU6jvIb0oqXQhg0b9NeaJr/4fwoLC3V/YWsBKydRXkN67YQX
+sjtgQH/1uM9iJr2QXVR1RtSXxwIhhBBCCCGU3hpJWVmpljEUcQq3TZE5ymtIL56vtLRUSkpKdIXk
+4uJiWbNmjaxevVpXS4Y8Yk/sypUrpaCgQFasWCHLly+XZcuWydKlS2XJkiWSl5cnixcvlkWLFumW
+Qjk5ObJw4UIdZc3Ozpb58+fLvHnzZO7cuZKVlaXkfY7Mnj1bMjMzZebMmTJjxgzJyMiQ6dOna1FF
+OvLUqVNlypQpMnnyZJk0aZJMnDhR0tLSZPz48ZKamiopKSlKApNl3LhxMnbsWElKStK9hMeMGSOj
+R4+WUaNGOW5TBOl1GuUdOHCA/jpmzKiYSS9AYas2bX7HY4EQQgghhBBKb81lxYp8LWWZmbO0uFql
+12mU15Beq/CuXbvWr/RahTc/Pz9k6bUK76xZs/xKr1V4J0yYEFB6rcI7cuRIv9Ibapsi0K9fXx3h
+hfAmJg67SHijLb1ZWZl6by9TnAkhhBBCCKH01viI7/jxqVrQUEyJxAakNSOl2S7CC1JSkqP6vkN2
+UcmZBa0IIYQQQgih9NYaZs7MsBUwEnvwXkT7/b799p9KRkY6xz4hhBBCCCGU3trBmjWFkpqaTOmM
+A4qLC6P+fqOC86RJaRz7hBBCCCGEUHprD0uXLqZ0VjGLFi2MyXtN6SWEEEIIIYTSW2sjvkivxb5S
+SmhswGuN1zwWEV6DG264XgoKlnHME0IIIYQQQuklpObRuHFjVm8mhBBCCCGE0ktIzQMR3hYtbuZr
+QQghhBBCCKWXkJrHkCGfy5///Ee+FoQQQgghhFB6Cal5tG/fTvr27c3XghBCCCGEEEovITUL7OO9
+5pqrpbi4iK8HIYQQQgghlF5CahbJyUncz0sIIYQQQgill5CaCfbyvvHG63wtCCGEEEIIofQSUvNS
+m5s2bcr+vIQQQgghhFB6Cal5pKWlSOvWD/C1IIQQQgghhNJLSM3j179+XBITh/K1IIQQQgghhNJL
+SM0iNzdbrrjicp3izNeDEEIIIYQQSi8h1ZZ9WZlytvUD8m3TpnKhcWM5d+890uupJ6Vz51f4+hBC
+CCGEEELpJaR6C+93jS4VSUioxHnFmuFMbSaEEEIIIYTSS0g15ux9v7xIeA3O3X0XXyNCCCGEEEIo
+vYRUX5DS7E96kerM14gQQgghhBBKLyGUXkJqGlsr5EjnV+Rko0vlUIMGsqvT87KjrJSvCyGEEEIo
+vYQwvZmQ6o8WXnUcHFLsUWxTbFbiy9eGEEIIIZReQqoR/gpZSd06sj8jna8RqbXoCK9JeMsV6xo0
+4GtDCCGEEEovIdVRfBHxPVG/vnytJvWI8FJ4SW3nkJLeSsKrKFTHR1ZWlgwePFg++eQTQmzp16+f
+jB+fKqWla3ksEUIIofQSEi/k5eVKIzXJLyhYxteDEMWuzq9UEt5Viqn33y+5ubly4MAB4YUXf5cj
+R47IkiVLtPzm5+fxeCKEEELpJSQeaN++nXTs+Cxfi2rAhg2lUly8Wk2q8yQnZ4FkZmbKlClTJDU1
+VYYNGyaDBg2SHj16XBR96tu3r3z55ZcyYUKaLF3KiXgwdmytkM1KfEsaXaojvBDebRs20Oh4cXzZ
+t2+fFl9GfAkhhFB6CaliKirK5IorLpfs7Ll8PapKsHZsk7Ky9VJYWCDLli3VKbSzZs2SyZMnSVpa
+miQmJmqZ7dWrlwwcOFDL7cSJEyUjI0OJb46sWrVK1q9fryfZx44dk/Pnz180AT916pS+b+3atfr5
+Ro8ezdfeIXg/EOHlhZdQLxg7ycnjeBwRQgih9BJSlQwePFDuu++XfC2iwLZtFUpmS6WoqFDy8hbL
+/PnzvJHZyTJ27FgtnxBZRGIhs1999ZWW3Pnz52vJKioqkpKSEtmzZ48W1m+++caVifiFCxdkyJAh
+SrCX8H1ydIwMZkozL2FdDh48qLMseBwRQgih9BJShTz88ENKvobytQiB7ds3S2npOiksXKnTjOfO
+9URmkTo8ZswYnUbcv39/nWYMYUJUderUqepxc30yW1FRoWXWLZEN9bJy5Ur1947n++kALErwwku4
+F4yfmTMzpLi4kMcTIYQQSi8hsSY3N1uaNm0qW7dW8PXwpnpv2FCihLBAR2bnzZsr06ZNk4kTJ/hk
+FiILEClFtBYyu2DBAl24BlHZbdu2yaFDh3Q6cTxfINyffz6Y73ucSm9CQoKmJl+q4n+sit+J8ZOc
+PFaDooE8pgghhFB6CYkh77zzN13Eqqb/n5s3b5L160tk1aqVsmhRro7MTp8+XcaNGycjR470FX9C
+dBYyi6JQ2C8LmcV+WbPM2u2XrY6Xo0ePSvfu3XUEChNxCD+PCUovpTe60gsY8SWEEELpJSSG3H77
+TyUtLSW6v2drhRzp/IqcbHSpHGrQQHZ1el52lJW68tyIUJeUrFViWiD5+UuVpGbLjBkzZNKkSTJi
+xAi9T7Zbt266giqKP0FmsacWKcaQWaQY79q1y2/xp5ouOObJ+MSJaRRfSm+Nv8SD9GKhiccVIYQQ
+Si8hMaC0tDgmqc1aeNUk85BijwK9Tzcr8fX3+F27tsuWLZt8rXmWLcuXhQsXalmFtEJmsU/WkFns
+l0Ul4yeffFIeeeQR+cUvfiE/+clPpFmzZtK4cWNdtMmtibKVmiS9TL10X3qRQfDjH/9YGjRooMdj
+nz59LnoMUuTvuOMOqVevnjRv3lwXM7Mbc7i/ZcuWsnTp0ko/j0Jo1113ne/ncd3pBen6eO46depI
+kyZN5NVXX9UZAP7GPf6PF154odICkZPHOB33gf7nEydO6Os///nPfY/HfnjcBnC/k9fD/Dv37t2r
+H4vr5vfGyfsWyXGWkpLM44oQQgill5BYgKrNbds+E/XfoyO8JuEtV6xTk8kdO7bK2rVrZPHixTqV
+GKnGX3zxhU4zRoQWacfmNOPly5fLxo0bfZWMrTIbTXGMtpTGi/QyAuWe9H722Wf6PYUAYqxCnHB9
+wIABF0nnE088oaXt7Nmz8v7771caExBRCGR2dra+fuONN1YSXtzWtWtXff2jjz7S152KL/6vsrIy
+/X16err+2Zdeeumicfn2229Xev6PP/44pMeEKr3+/uc//elP+jq2G+CCxS5cx+1OXw/jd6CqMsQW
+33/++echvW+RHmeAxxUhhBBKLyExoGPHZ9VErl/Uf88hJb2VhFexsl49LbfJyck61XjNmjVKgndE
+lGbsRBydRoGs0Vwnzx0sauZGVC/a0ou+wDw23JHeG264Qb+XiCbignFtlVZ8j9t2797tdzwbEUzj
+Nowv44IxhNuMcYbH4jpuD/cYuuyyyy76G6zPj+hnKI8JVXr9/c+GBL/77ruVJBi3O309jN/RokUL
+/XX48OEhv2+UXkIIIZReQqoJd999V0zSWXd1fqWS8K5SLHziCTlz5kxMo6WhRIFee+012xTOSKJm
+kUb1YiG9aWmpPDZckl5/KfFmaQ00ruzu8yeJ1sdg0STYJS8vT+6//3655JJL9N9kl7bv5Pkj+Ruc
+/j7zbRDYq6++Wqc2I/3YTmid/L2Qe/zs4cOHQ37fKL2EEEIovYRUEzDhi0Wroh3qd2xW4lvS6FIp
+qFtX5v3mN/JtFNr5BNt3G0oUyCrk4ezptUbNIo3qxUJ6ORl3P9Jrfk+tF2NM7Ny5MyzpRTTV/DtC
+ifRCHPFYyC8uSOUNFnkNdMyE8zeEI73GYhUWlKxp1E5eD+P55s2bp2X4vvvu0wtQobxvPM4IIYRQ
+egmpBhQXF+mJYFXIw/r166tkX2y4USsnzx1u1CyUyT6lt3pJL/aJGntDEZWEVObk5Mjvfve7i6L/
+v//97/VijF30P9CYgPDhOkQQF2QxON3Te9VVV+nHYmsB/rYuXbr4HbNGOrHx/Mbvc/oYN6UXFdfN
+x9eWLVtCej3Mzzd58mT9fdu2bUN633icEUIIofQSUg1IT5+s05urQh6OHDlSJdIbShQo1Od2EjWL
+NKpH6a1e0osL9my3atVKL4QgFRfiBIEyX7CvHfu88RiMI+s+72BjAoJnjO1QqjcvWrRI7xu3LtIE
+q6YcrHqz3WPclF5csMCE21q3bn3RcwZ7PazPhz295kJcTt83Hmdbo9qOjhBCCKWXkIiZNClN7r33
+niqRh1NRSG12IomhRoFCeW4nUbNIo3qU3uonvdX94jSNn/2Ea+dxFmo7OkIIIZReQmJKZuYMadHi
+5holD04m36FGgZzu6XUSNXMjqsfJOKWX0kvpjRf8taPjOYMQQii9hMQFBQXLpG7dOlJRUUZ54GSc
+0ltDxy1Sc+0I9ecjeUykfwOPs/jFrh3dqvr1ZerUKbrnerdu3fT/boDrgwcPllGjRukFQFS5R0Gx
+3NwcWb48X/dtX7++RH0ulfO8QwghlF5C3OGKKy6XjIx0ygOll9LrYNyiqNG5c+d0WvrXX3+tK3yD
+06dP65T9kydParBX/Pjx47rnNEAqO/axozXOoUOHNAcPHpQDBw7I/v37Nfv27dN9Yffs2aOre4Nd
+u3bp/d/oXw22b98u27Ztk61bt+riTWDz5s26sNOmTZs0GzdulPLyct06a8OGDRoUjistLZWSkhLN
+unXrlFysleLiYp2OD1avXi1FRUVSWFioWbVqlaxcuVIKCgpkxYoVmuXLl8uyZcskPz9fgx7SS5Ys
+0fvYweLFi3XGA/puA+yBXbhwoWbBggW6Ddf8+fO15IC5c+dKVlaWzJkzRzN79mzJzMyUWbNmaWbO
+nCkzZsxQ56gMmT59umbatGlalKZOnaqZMmWKLkY1adIkmThxombChAmSlpYm48eP16SmpkpKSoqW
+rHHjxmnQLzspKUlnWoAxY8bI6NGjtYyNHDlSM2LECElMTNR7fsGwYcNk6NChMmTIEL1VAUDsUPgK
+IgcGDRokAwcOlAEDBkj//v01n332WY09zuza0c3+1a/0mMOYt+7rxtYPHBMY2xi3GHsYNxgLeG/x
+vuB1xuuG1wyvJV77r74ao9/nzMxZagzNU+NusRqnq9Q4Xq3Geok6NrbwPEUIIZReQuxp2/YZ6dLl
+TUovpZfS62DcQnit0gvhNUsvhNcsvYbwmqUXwmuWXkN4zdILKTBLryG8ZumF8Jql1xBes/RCPszS
+C+G1Si+E1yy9EF6r9EJ4zdIL4TVLryG8dtIL4bVKLyTHLL0QXrP0GsJrll5IkVl6DeE1Sy+E1yy9
+hvCapRdiZZZeQ3jN0gvhNUsvRMwqvRBes/RCeK3SC+GtydJrbUeX+eij8i8XWz3hWMLxgXGPMYux
+h7GEMYH3E+8VXntEkHv06KHfF7yfeP8xTubOzVJjM1eN4xVqrBeq42QDz2eEEELpJbWxmFXTpk1j
+muJsFLKyRsQgB9aImJ0YQArMYmCVgmBCYJaBQNEvqwRAAKwSYBYA8+TfHPEKFO2yTvox4bdO+s0T
+/kARLicTfeskHxN8Sm9o0msIr1l6MZ7txrQ1yms3roONbbvxbR7jGN92Y9w6zs3Sa4xz61i3jneM
+det4txvz/qK8Zuk1xr117FvHv12U18kxYHccWKO81mPB7ngwSy+E1yy9hvCapRfCa5ZeQ3jN0tuv
+X79acZzhf8TYqqoLoso4vnCcYKxjHBuCjHGA99iIION9wfuHsYAxNGvWTDUW5+gI8qpVBep4WauO
+p/U89xFCKL2E1BTuu++XMY32YsJhlwbqT3jtpNdOeO2k14kM+BNeO+m1E1476fUX7QoW6fInvNYJ
+vz/htUqvP+Gl9EYuvU5Sm+0WcuwWc4KlNtuNb7sxHiy12S7Ka7fAE2pqs3WhJ1iU127Bxzr+nRwD
+wVKbcRwES222Hg92qc12UV5rarNdlLc2Sm+02tG5fcExi2PRSLHGWMY4xdjC+MD7jPcP0WO8rxgP
+GDO4f/bsTDW2F6ixv1gdN4XqOCtRx2YFz5OEEEovIfFe0Ap7e5OSRsdUev0Jb7Aob6DUTzvhDRbl
+NSQgWJTXnwCEIrzBorz+Jvz+hDdQlDdYKqcxwaf0Oh+3EN5gqc0Y08FSm+0Wc+wWdIKlNttFeYOl
+NtuNdSdZDXZj3mlqs93Yd5LlYHcMBEtttlv8sVsACpbabBflDZbaDOG1S22uTdIbrXZ0VRk9Nu9B
+xvGB8Y2xinGIcYP3H3JsFmSMP4xRjOfs7Pnq2ECK9XJ1DK6hIBNCKL2EVBVZWZlyzTVXq4lYUkwm
+RsEK/TjZ7+hPeANFeYOlezqJevkTXqv0+kvvdBLlikVasxHRovQ648Ybt6j38pxtanMsC1g5Wdhx
+ksJvN96DpTZHWsDKbvzHqoCV3fEQLLXZroCVNbX55h03yxuT3giY2ty3b99aI73VqdVWNAXZSK82
+C7IRQbYKMsYjxvLMmTO8lawXqmNumTpWi9SxXOr7X3geJoRQeglxUXw//PDvamJdETPpZVpz1aQ1
+G5N7Sq/DD4OE84qz8tBDp9X7e8pRASu7sR0stdkui8HJfnW7xZ1YFbAKJbXZSQEru4WfYKnNdgWs
+nGQ92B0ToRSwSjivhORsgtxcfrO8mfKmbZSX0htcTgP1NndDeqP1e8J97mARZHOKNXrLv/XWW3pM
+YtxOmJCmjwfsQ0aa9bJlS9TxXKTOCRt5riaEUHoJcUJRUYE8/PBD0qLFzVFLd0bEbO7cU0xrjnJa
+c8u9LaXr7K5+o7zGxD5eJuP7sjLlbOsH5NumTeVC48Zy7t57ZH/mjDiS3rOKU4pjikPyP/9zSL2n
+x4OmNtuNbSfF2aJVwMpuvDsp2BYstTlQASu78e+kgFuw1Ga7Y8HueHCjgJVVeo0CVhDehFOKY4pD
+CXLL6lvktXGv+YSX0ls1EVl/0lsdo8p169aVH/7wh5XaPNntQe7Vq5evSBfGLsY8jhMU6EJqNdOq
+CSGUXkIsQHhvuOF6XeRq1KhEVyO/RsSsdeuTaiLMtOZopTUbEajbNt8mH07/0G+hnniYjEN4v2t0
+KWaPlalbR/bHuI+0/3H7vfAmJOxX7FZslwcf3Kne28NRKWAV7715A0V5w+nNG8sCVm715jULb8J+
+xW7F9gT58bIfS+cxnbXwUnrDF0Zr9LRevXrSsmVLPQ7NUdOXXnpJGjRo4Dfa6kRMIY3XXXed/h3N
+mzfX14NFdJ0+N8YNHlOnTh1p0qSJvPrqq/ocYb5gfN5xxx2+348x6vQ1sBbpwrkF5wUcyzimMI6R
+fo9jEv3GceFchxBC6SVk51YtuoMHD5S7775LF7pCT18IMPYYuRkxe/jhA2rSe7BapDWHE+UNVLHW
+SXTLn/AGK15ljUD9ZN1P5P309y+a2MfDZPzsfb+8WHi9nFPjLz6k92LhTUjYrChXlMojj2xU7/f+
+uO3N61YBq1B687pVwKoqe/MGK2BlJ7wJmxXlitIEabGghXQe3pnSG6H0QhIhtxhPuH7jjTf6HtO1
+a1d9G77ignTgUKUXgmv3HGbxNZ7jtdde039LKEKN1wbHJy4Yy3g8RN0qxU888YReQEPBvPfff9/x
+a+C05zGOG4xviC/nOYQQSi8hFpYty5N//vMjuffee/Rq+u23/1Tat28nffv2VhPWGSH1+fUXMbv/
+/m1q0rvHUXEff8JrCEFNAVIDSYEwBIvyWiNa/iJQt668Vd6Z8E5cSS9Smv1J7+l69fSCi0Hr1g/o
+cWiAVHxERQLRqNGlfvfdOce/8CYkFMsdd5Sq92KXK7153Spgxd680Stg5ZPeAMKbUJwgzXObS4fR
+HfRx9vTTT+vzZocOHTQYmzfddJNvLD/11JN6jHfu/Iq8887f9PkVWTcZGen6HBzNWgvxuqfXuA5h
+M9+GiKlxadasmb7NiJzisaHu6cV7YfccuN36HChiF+meXtx/2WWX+a5DYHEbzgP+XqNAr4HTy4UL
+F/S4xzHOuQ0hhNJLSAAQ6U1Pn6wlGJO0li1vk7p16+jJgTFxw6QN9w8Y0E9NRlN8kzYQLGL24IMb
+1ER4h6O0Zmv0qyYD2XCSxmlM7oNFoFouainvJr8bkfRiscN4X52AYmmTJqVdxJnGjf1Hei+5RInI
+UNufA3l5uUF/b6TZCZ7FGvvxescdZerv2Kvk9ljUC1hVZW/eSAtYhdOb160CVtHszevv+Gqe11w6
+jukovfr2kj59+ujjbOzYJPX8w31Yjwlk0uCc+cEH7+ne6RDkX//6cZ1tgyKDOM9ikQcLP506Pa+P
+C9RhqA2R3lD364Ya6fX3HEglDvYcwZ4bx8v9998vl6hzGUQ11PRrJ/9fKBecF3A8cT5DCKH0EhJG
+KjQmcJi4ISUak7aOHZ/VUQvsC77zzjt8UbdgEbNWrdapiekWR9Gv2iK8BhCGYGnNxsQ+WATq+rzr
+5aXxL/kiUGacRj8R9Q8WZTUwR7QAJu5G9Hbdj66qBunNlcfrnXdWKPnar+T2eNz15o1lAatAe9mj
+VcCqKnvzmqO8Wnotx1fz/ObyXNJz0uezPnovL4S3d+/ermVU5OZmazl+443XddHBxo0b6/oLkODs
+7Lm1UnqNSK8RCQ0U6fV38fccdpHeUP+Hq6++Wt+P48aItlp/xoj04viPtvTiPIXxvXlzOecvhBBK
+LyHRkwd74W3Var2aCG5Tj9kTUlpzPIGJ8ZVXXqknI9F4fghLsLRmn/T6Ed7r86+XzhM6y5DhQ/SE
+noWsnI5bz3j9xS+2KdE6qOT2RMx687pVwKq29eZ1q4CVVXohvD7p9R5f16+4XjqmdJS+/fv6KjZH
+Q3rtgOwiMoxo8K9+9ahegKxN0vvxxx/r69iHa97jG4r0+nsOuz29of4PV111lb4fxx6Et0uXLhf9
+jLGn9/e//70+h9jt6XVLelHoCmMUY3DWrBnqfLGWcxNCCKWXkGhHzH72s41qkrpDTfr3Bi1e5UZa
+Mya9t956q9SvX1+uvfZaPSl1S0oxucEE37jutvxCdIKlNRuTeqvwYlL+2qTXZGji0EoT+rhqWXTf
+L+XCFZd7WhbdfVfcCC9o1qxASdchJbinAvbmdauAVbz35g1UwCqc3ryxLGAVaW9eQ3jBtYXXSqeU
+TtJvQL+LevPi3BIL6TVvN0CWDQoPRqvlXFXt6Q0kfG5Vb4bwGhHfQNWbQ/0fcJyg2rI1tdn6XBiz
+qN6MxyE6bK3e7GabJPN4HD8+RZ1LNnB+Qgilly8CIdGImP3855vVpHS3mvjvD1qt2a3iVZhEQ0wx
+ScZ1TOqfffZZ16Q0WhFeM8HSmn3S6xXeG1fdKK9OfVWGjRhmO6GvDVVl3ZrQnz59WguvtTevXZQ3
+nnrzulXAKpTevG4VsKrK3ryBClhBeNECZsCAAZr+/ftf1JvXEF6jf2q0jzOj1/XZH/5Qjv/bv8nJ
+n98Z017X4UgvL1VzsY5H1EbgeZ4QSi9fCEJcjpiNH79HTfydiUCgtOZQpfexxx7TE1R/90Ma2rVr
+pwuOAHyP28xSi0ksogF169aV2267TU/ejfvMWCUYYoL9sogwIwX6gw8+CEuSg1WmNSb1N6y5QV6f
++roMHznctg2LMZmn9IYuvRBeq/S61Zs3lgWsaltvXrcKWFmlF8Jrll5ranMspDcetghQequv9M6c
+mcHzPCGUXr4IhLg9MQq2x9FJr1JDAEIRxkaNGmlJ8Hf/iy++KI888ogvMvboo4/q28zS26ZNGy0L
++N3Y99WqVSu/kV7z9Zdfflk/H0QEzw0Bj1R6/QmvXYEeO+Gl9IYvvYbwxqqAVVX25g1UwCpavXnd
+KmAVjd68hvCapdcutRnCGyvpjYde15Te6iu9kydP4nmeEEovXwRCoim9/oQ3WE9eY/LvZvpx06ZN
+9aTeuI7vEZU1/7w58ou/ARFfJ9KL54ZEGNfxfTjS66QqrT/htdunSOl1xo03blEid8Y2yhtPvXlr
+egGrquzNaxfltaY220V5YyG9gXpdY498rM7t6GFrtzhkV+QtUOq/097sdgXd7BZ/7I4Bu73sTlL6
+7VL57VpyOalMblegzWmF/mDne7vK48b4tY7HtLRUnucJofTyRSDE7YmRG2nN4UhvsEivnYQGklrr
+bYGkN9jPOiVYWnOwCJZ1EkTpdboX/bzirDz44Ck12T0eNLXZrd68bhWwqm29eaNdwCpQarO5gBWE
+t2fPnpTeANIbTHhxPNSm9nQ4znGs4lgJVrvBLenleZ8QQuklJAoRsxkzDkec1mxM/EOZTCC9ONCe
+XkRjMcEPFOkNV3qtkV78nnCl10la8627b5V3pr/jN6053qTXKMKDybuu3nzvPTEtwhNces8qTimO
+6V7TjzxyUAnd0agUsIr33ryBClhFqzevWwWs3OjNa5fabFfAKpbSGy/pzU6F16n01jbhtYLjze0o
+L8YupZcQQuklJEYRs/vvP64mvvvCTmsOR3oxoYZ8YvJsV73Z2HcLUYA4YH+vdU9vuNKL58Y+XiMK
+9/jjj4clvU7TmhPOJ0jC2QS5ZdMt8u6kd/1Ogtin1+m4/V54zb2mH3hguxK6A3Hbm9etAlahpDa7
+VcCqKnvzulXACsIbC+mNl0JWbkZ5a7vwGuB4CXUrC6WXEELpJSTOImYPPrhPTXRDT2s2Jv7h9ulF
+L0T06cWk1Vy9GRKMCsugffv2lX5HJNKL527btq1Ol27SpImu3mxOnQ5HegNN5iG8CacUxxSHEuS2
+4tvkrbS3LopcxcPkJx6iVMHH7cXCa/SaTkgolYcfLleStyei3ryxLGBV23rzulXAyiq9gXrzGtLb
+o0eP2LUs8va6PtuwoZQ3/Y+YLhrhfwwkvKFKbzwLL8YHsoBi0aYOx62bUV6MXUovIYTSS0gVRczu
+u2+Lmuhu87uv0V9/0uq6eg9paN68ecg/52SfIiZAZuFN2K/YnaB797ZY0ULeTH4zrvZ2BdqPeLpe
+PWnb9hkfrVs/IPfee4+PFi1u1q9jIBo1uvSillKh4194ExKK5Wc/K1Gv3Y6oFLCqyt68gaK80erN
+61YBq6ruzRtr6TVTXFwkVyj5zYih9JqLvbmxlzfSc6yxwIkFTCxw4r1x6/yNfu8Y57Ho0Y5j36n0
+4vVLV8cOpZcQQuklJM4jZg88UKomvxWOKtdi0l+dRBep0pASyIc1dTpc6fU3+bET3oTNinJFaYLc
+svAWeXP0mxFNfioqypQk5TkmKytTyUvaRZxp3Nh/pPeSS9T/NNT250BeXm7Q31tWVurCuLUfr3fc
+UaYkbJeawB+qFr15q3MBq6rszRtuAauqkl6Qlpait3N06fKmK8eA060rrVufVOPhmG1l81hJL8YS
+xBRjxW4rS6TEIsJrxmmU9/y5c3L25EnZqM4HaerY8Dd+Kb2EEEovISGydWuFFov09Mnqw3WgfPDB
+e9Kx47OVonI33XSTL+oWLGL2058Wqw/xMr8Tf2tqZ3WS3k8//VSnxDVs2FCefvrpkP9+vAbB0pp9
+0htAeBOKE+TaRdfKc2Of05Mf/C1mnEY/GzRoEDTKaoAxYI7QYmwY0dt1P7qqGqQ3Vx6vd9yxSQnY
+HjV5Pxy13rxuFbByuzevkwJWVdmbN5YFrAL15jWEt6qkFxQULJM2bX4n11xztXTu/IpeKMI5OxZb
+Vx5++IB6/w+HJbw4JiI516J+QqCihTh22rVrJ5dccokG35vPxzi/4X1s1qyZ3oZy22236fFr3GfG
+KsE4PnEeRYQZ53tsZYlUkp1KL4T3lHqdj6nX85A6j6xRx3Cq+lnrgg2llxBC6SUkSGQPcvvhh3/X
+stKy5W06dRQTqruVnGBy9fLLL0q3bp+oD9d+6oN6tJ5k5eZm+6Ju/oT39ttL1Qf6JvUB7yyt2Zj0
+477aUtAE4hIsrdmY/PgT3muXXCsvjHtB+g/qHzcr/tWjkJVnvN5991YlW/vUBP5o0Iq00SpgVdt6
+87pVwCrWvXkN6e3evXuVH2fZ2XO19GI7QOPGjfWiE64jiwL3uSHCgYq9ZWbui6n0BmtPhywbZNsY
+xwoKGFqLFrZp00YfMzj+unbtKq1atXJctBDPh+MRzw0Bj1R6ne7lNQvvfvX/71a/f7s63perY3Cs
+ejyllxBC6SXED6WlxXpi9KtfPaoje5g0tW/fTk3qumsBxv2RRMxuv71MfaBv1rLrbx+vvygvJvzV
+LdobCZCFYJMfn/RahPe65dfJiykvyoDBAypFrOKqZZG3CI9uWXT3XXEjvKBZswIlYAeU4B4LWJwn
+nnrzulXAKpTUZrcKWMV7b16nBaziRXqt0V+c07FA+fDDD3kzcBJ0KjQWL3Gu//Of/yhvvPG6vPPO
+39T/11svYpq3GWCvsHkLAZ4z2NaVhx4qU2Nil+N2ddFMP8b/inEdqD2d+bMFx2Ggnu2B2tPh+1hJ
+r53wblbHcrk6XkvV8bhQHT8j2J+dEELpJeR7iooK5KmnntSRXEyCkLqM4ihuRczuvLNCfXhjku9s
+P2OgtM7qXNAqlMJXTtKajcmPIbw3FNwgL0x4QQZ9Mci25QonP84r06Iwj11xHjd688aygJXbvXmd
+FLCqyt68bhWwCrU3ryG88Sa9/oC8QmiHDPlcZ+tgLzCiwcY2hF//+nHf9oQ777yj0vYFiJ6TYm9j
+x26LifQGi/TaSWggqQ2lUn+wnw0HpxWbAwlvsTrWFqlj5is1vs3bWv7yl79Ihw4dKr2fWPww3mt8
+/puLCWKxBGMDC99YDElOTtLjBhkDGENuzBNITWG7/gwwimaS2PDRJ92k/9Dhan6wltJLSDCwwn/D
+DdfrNGas4LsdMUtKwiR/R8BIl5MJv3myj+/xWPxcTRFd/P8QFiPC63S1H1xXdJ28POFlGfzlYNvq
+nUYhHkpvaNJrCG+w1Ga3ClhVZW/eQFHeaPXmdauAVTz05jWkt1u3brXiOPMnvD/72Qb1fu1Qx8F+
+R8LrhvQivTjQnl5IOsZ5oEhvuNJrjfTi98RKev0J7xJ1DCWp+zF2MW7N43HUKDzXcF/UHsUBkcVl
+RPUR4YfcGkB2Ib0AWV+QYnPtDqTP4/9F9XBkhiGbALKMBRTU/Bg1KlE/r9tzCxJf4HNqgDpvLlBj
+cOfuPXL63Ddy8utzcvzMWTly6ms5fPKMHDh+SvYdOyV7jpyQXYePy/aDx2TbgaOyed8R2bT3sGzc
+c0g27DoopTsPyLrt+6V42z5ZvXWPFG7eLQUVu2TFpp2SX75DlpRtl8Xrt0lu6VZZsG6LZK/dLHPX
+bJI5qzfK7KKNMnNVmWSs3CDTVqyXqctLZVJ+iUxcuk7G562VlMXFMi53tSTlrJYxCwtlVPYqSZy/
+UobPK5AhWSvkiznL5fPZy2TgrHzpP3Op9MvIkz7T86Rn+iLpMTVXPp2cI/+ctFD+MWGBfJiWLR+k
+zpf3U+bJO+Oy5G9js+StpNnyxphMeX30LOk8cqa8MmKGvJSYIS8Mmy7PDZ0mHYekS4cvpkq7z6fI
+nwdNkj8OnCjP9J8gT3+WJk/2HS9t+qTKb3ulyK97JstjPcbJo93GyiOfJsmD/xwjrT8eI//90Sj5
+5Ycj5d6uI+T/fZAod78/XO5/70tp+/fP5J/deqhzUR6l1zG7dsgcNYEZ5O3nSWJD9979ZMTY8SGv
+0rixZxcfUCBa1T7x/wXryesvyuWkWq1d0R5/+xcD9SENlsLppBWL3YTeX3EeJ3sU/U18nPZotEvR
+pPSGJ71OUpvjrTdvpAWsrMdFLAtYVWVv3kgKWNUu6a0svD/72Ub1nu1Wx8LBkPbyGsdDpNWbIZ8Y
+Q3bVm419tzhecPxYq+lHIr14buzjNT6fHn/88Yil14nwAqvwLlOvQ7J6LMavebEmFuMR2WKo2A/J
+hSwjVd5IqUckGVJspNVjjznuM6SYQly92b17px5zW9SxfO5f5+Xrb/4lp856pPfYaY/0HjpxWkvv
+3qMntfTuPOSR3q0m6S3fbUjvfi29a7bt1dK7yiu9yzd6pDdvg0d6c0q2aOmdX1zhk97MwnItvdML
+PNI7ZZlHeicsXeuV3jVaer/KKdLSO9IrvcPmfi+9gzM90vvZjCVaentPW6ylt/sUj/R+PNEjvV3H
+e6T3vZS5Xumdc5H0vuyV3k5e6f3rl1O19P5l8GQtvX8Y4JHep/p5pPd3vb+X3l91H6ul9+FPvtLS
++8DHoytJ7y+80nvnu0PlZ+8Mlf9+d5B079nLsUvUauktK9ugB21OTq7s3XdA/vWtyDeKc+dFziq+
+/pfIGcXpb0ROKU6eEzmhOH5W5Jji6NciRxSHz4gcUhw8LXJAsf+UyD7F3pMiexS7T4jsUuw8LrJD
+sf2YyDbF1qMiWxSbj4hUKDYdFtmoKD8kUqbYcFBkvaL0gEiJYt1+kbWK4n0iaxSr94oUKQr3eFi5
+28OKXR6W7fSwdIeHvO0eFm3zkLPVw4ItHrIV8zeLzFPMrRDJUszZJDJbkblRZJZiZrnIDEVGmch0
+xbQNIumKqetFpigml4pMUkwsEZmgSFsnMl6RulYkRZFcLDJOMWrpERk8eYn07NMvpFWaSKsw48MI
+q7HRqu5pyIOT1E5/wms32XdStMef8AZK47SLZgWLZDmZ0PsTXrs9ik5SNf0Jr78ejbGe/NQU6bVr
+wWJXldaN3rxuFbByuzevkwJWVdmbN5YFrIL15jVSm6tLerNbW1fuumuLen/2+tp4ORFet6XX3Ke3
+Tp06uk8v3jtz9WZIMCosg/bt21dKh45EevHcbdu21enSTZo00dWbzanT0ZJejF9DeAvU8TZePR7j
+167wWjyNR0SXIboQXkOKIcKIGCN6jLR63IcWXKHWECFVAz4D8HnxzflvtfSeOeeR3hNnzmrpRZQX
+0rv/mEd6dweQ3vW7DmjpXbt9n5beoi0e6V2xySO9S8u2a+ldVLpVSy+ivIb0IsoL6Z2x0iO96T7p
+XaelNzWvWEvvWK/0jl7gkd7h876XXkR5Ib0DZi7V0tt3ukd6e0z1SO8nXun9aEK2V3rnael92yS9
+/+uV3le90vvi8OlaehHlhfS2/3yKlt4/DfRI79OfeaT3ib6pPul9vOc4Lb3/0y2pkvTe55Xee/7u
+kd673humpbfV20Pk9r99KZ3++Zk6vsdRep2s0mzbvkPOXxDNN17pPeuV3jNe6T3lld4TXuk9FofS
+u8orvQVe6V3uld58r/Qu8UrvYq/05nqld6FJeiG8873CO9crvHO8wpvpFd6ZXuHN8ArvNK/whiq9
+Y9eIJCkSc/dJbyW+sYj4YiUW1ZijKbyGPPirWuskwuVPeANFeYNN8J0Kb6Aob7AJvZPCPP6EN5S0
+Zn9RXn/pmZReZ+D1w/i0S22OZQGr2tab160CVlXRm9eI8vbt20d/X9OPM2xdmThxvzoWjoTdpsju
+eKgJ9RiQ9hvJc/g771vHcJE6DtPUMYAx7G+hM96k1x/YG4x9wqgn0qnT8zo6jBojEGGkSyPNGpFk
+fj7FHzh/7lXHOqT37Dce6UWUF9J79LQntflgAOmt2HdYS2/Z7oNaekt2eKR39VaP9K6s8EjvsvId
+WnoR5YX0LjRJb5ZXemf5pHe9lt7Jy0q09KYt8Uhv8iKP9I5Z6JHeETq12SO9X3pTmwfNytfS2y/D
+I729vNLbbUqOV3oXaOn9+/j5WnrfTf5eet/8yiO9r43ySC+ivJDe572pzc9+UVl623ql9/f9xvuk
+9ze9kitJ70Ne6b3/Hx7p/a+uI7T0IsoL6b3jHY/0/rTLl/Jfbw/SxzylN9gqjTpRf+sVXqdRXrP0
+HvFK7yGv9B7wSu8+r/Tu8UrvLq/07vBK77Y4lN5Io7xTvcI72Su8E73Cm+YV3lSv8CZ7hRd8tdrD
+4NQsx6s0kYAPEuzjifbvwcGHSTzTmqs2rbk6TX7igfT0qfq9D6WAVVX25o1FASu7Y8ONAlbx3pvX
+aQGrnp9+Kov++7/laIMGsr9uXVn+q0cldWRijT3OcC6xWxDyJ7w1WXqRKo1jE8egNXXaTel1utBp
+Xaiprud9LMpDhCG8EF/UHsHcBdXGsXCPqDE/r+LjXHBeCQSivJBe835es/TuM0nvjkPHtPRu2X9E
+Sy/280J6sZ8X0uvZz7tX7+f1SO9OLb3m/byG9M6zSC/280J6sZ8X0ov9vJBe7OeF9Hr28xbp/byG
+9A7NWlFJevt7pbePT3pztfRiPy+kF/t5Ib3Yz2tIb5ckj/QiygvpNe/nNUtvO6/0Yj+vR3rTTNKb
+oqUX+3khvdjPC+nFfl5IL6K8/2Xaz/vzdytLb8u3PIXrZs7MUHOEQkqvv1WaffsPhCy9bqU2gy1e
+6a3wSu9Gr/SWeaV3vVd6S7zSu9YrvWviUHrDifJCeMcoEhcfdLxKE0kPR3xwxCpihskA05qrNq3Z
+KMBD6XW63aNUv3YYk1XRm9etAlZu9+Z1UsCqKnvzulXAKpzevBDekwkJckixR7FNsUiJL6W35kd5
+P/30U10Yq2HDhrpCciSt9XAuCGexsyZKr7+9w2irhTRo7BNGZXHsH8YifrQz14j/c8G/vv3Wt583
+UBErSC+KWEF6UcQK0htuESuz9IZbxGqEt4jV0AiKWEF6UcQK0htuEStIL4pYQXpDKWIF6f2ZSXpv
+e6tyizIUqqP02gzYC99JlUlvpFFeUFRDpHd0kThepQkXtKho0+Z3MRlbmJBi4sy0ZnfSmp1OfGrD
+5CfarFiRr18/vP8Yr9EuYFWVvXkDFbCKVm/eWBawimZvXnzF/YjwmoW3XFFcr16Nlt5gwlvbUpvd
+AMexm1Hemr7YiUV87A1G5WhIMFKjsR+Yn2FVJ73+ilgFqtzstIhVeu5y+e0zf5RG/36Z3juPr4/9
+vq2My1oUchEr7M0H5srNoRaxClS52Xj+YEWs7Co3h1rECtL7ky5fXCS9wJ9LUHqrqfRGWsQqHqXX
+ySpNJPt5kSoUi7G1cGG2/uA2R7ec9OT1F9lyUqHWn/CapTdQJMtJRVp/whssyhuoII+d8Dqd+DiZ
+/GCyTukNPeI7fnyqr90TIbYV+Lt3l31Kes3Cu06x0iu9KSnJtVJ6nQqv8XlA6fVUonZbemvDHnOQ
+m5utWzBiPzBSoSHDkGJ+lkX/XBCsiJWTys3BilhNV8J7+RVXyn9c9SNJnDRDV24emjZdrmx6lfxQ
+3T52dq7jIlZm6Q2/iNXFlZvNRazM0uuviJVd5eZQi1hBelHECtJ765sXSy+CaJReG+kNVsQqEuk1
+3vyqKGJl/G67KK9d5eZBk5bKw0+0l0saYSWpnjRtdp089fzbMnXNKdsiVtGU3kCrNOGnsw+Up556
+MiZja/v2LeqD+kstc3l5i7W4QnKdpHP6E95gUd5A0Synac3BoryBoldOqtD6E16nVTudTnwove6B
+Dw7ra0eIQf5vf1NJeFcpZnvTm/1NOqr7vMGf8IYrvTWp73o44DPJTeHFOb9//890ZkJtO+8jDRpV
+oBEBRgp0t26fRK01I6X3k4BFrA65UMQK0vubp/+g5/If9hlUqXLzez3769sffbKtr4iVMe83F7Ey
+boP0Gt+bMfbzWm+vW6+e/Pzh38jHSnaNIlbGfebKzcZt2M9r9/zWIlZ2lZtDLWJlrtyM/bx20utv
+0bVWS2+wKG+gys1OiljFq/TaRXlb/b/W8smIGZK54RvJLD8vf3ylq/75+3/zp4uivHaVm0MtYhVM
+et2aMO3LypSzrR+Qsz/8oZysU0fO3XuP7M+cERPxzclZoCQvSX1AD9D7n8xRElxHiiA+sPGhPmrU
+SCWFY7VYQjwhtE7SmoMVrwokvMGKVwXqOepkf6I/4Q1WvMqttGYjJZPSGz5r1hSq9zGZgkfsSRoj
+OUp8ixs21BFeCG+Kt5BVtLaqxKv0hiO85q0utUl+8b/jMw2fKW4WsOqnzvdLWreuNYXVApGcnKS3
+dKGqNtKfERG+aH5Uvl7O5iyUb9Vn/gX1eX9uQbbsV7fxs8/ZuSBYEav9ERWx8lRuvqxxEz0Xn19U
+Vmk/76yVHslFqrNRxMqY9xtFrMzSa1RuNq5bi1gZt//3E3/URaxaP9NBX39AfbVKr7mIlVl6sZ/X
+uG5XxMq+cnNoRayslZv9Sa+/453SG8XUZrP0QnjtVlJ+fEtLmThnqa+IlfUx9es3kKfbvSBrdp/3
+Sa9xn1l6jdtW7BLb1ZZQ9/POLr+gf66e+v1upzabKzdDeO2k143UOAjvd40uxQtSmbp1ZH9GepVG
+zMaNg/iNVh/2I9QH/BD1oY4P9EHqA7yfFjaj7yX2z+HDHB/4mAzgdZk0aaKeLEBgmdbsX3gpve6w
+dOliyh0JiUWLFtbYeUOgaubhSq+T2g5O6joEK9jmpIhhpPUcnNRycNKeLlThBRDe2lRYzWn0F+nP
+6At87733qPdgtC5+BeH9buYMNaGbXpmM6bJ/Qwk/+xxKr7WIlV3l5lCLWJkrN2MPL+bidkWscHsd
+db9RxErP2evVr1S52Sy9KGJlll5zESvj9n+mzNb7ef+hvuL6ZZdf6avc7Pl99SoVsTJ+zihiZVy3
+FrGyq9wcbhGrOyxFrCi9cSa9RpTXuN7u+Vdl08HzMm6aZxBde/2Nviiv8ZiOnd/Wkd6Xu3ykr7/8
+9se+ys3BpDecSK9VegdNWaF//uprb4z6ft5RNtLrxgfU2ft+ebHwejl3910xHW/YpxzO5BFiPGoU
+xHiomgB8oaPG+KBHX0wIMV43T8S4n5ZmTBQwicBkA5MSTGJqa1qzUXiH0utOxBcLN1h0odQROzA2
+olmMMB6l1y3hjZb0hlO530nV/kiF103pNRgwoH/Awmppaam1+hxeUVGmC3refvtPtQBvHjf2YuH1
+ci57Pj/3QpBeo4iVXeXmUItYWSs3G5He7DUb9X5eSO/cNZtkZkGpvv3Sf7/MV8TKLL1G5ebvpbew
+kvRai1gZtxtFrFC5Gdd/UKeur3KzIb3mIlZm6X3ZIr1GESu7ys2hFrGyq9xsFLG65Y3BlN54lt51
+O074Upv1IKpT5yLpXb7pqE5tXr75hL7e9OpmvtRmIwJsLmJlll4UsIpEekdkrZcrr2qmf/4fw2dU
+W+n9Vp3Y/UnvhcaNY/6BM3FiWlQmmxDjESMSfWIM+cWepj59epsixt21KA8aNFBPJDDJQDr1xIkT
+9CQGE5yaltZsVJql9BJC4ll63RRef9IbrvBGQ3qt53+c+3HO95zvP/ee5wdoke3Xr68+pxvnc+tW
+IaOoGs75gQqrTZ48iWPY15N9shxV75U/6UWqM18nZ9JrFLGyq9wcahEru8rNv3nKs6e3a5+BWnqx
+nxfS+04Pz57e/3niGV8RKy2pP/iBr3LzqLn5laR3pEV6zUWsjNs/SZ2jpfejZI/QNr6iqa9yM67/
+m3p+o4jVa4lTfT/3qkV6jSJWdpWbQy1iZVe52VzEitLrtLG0pYhVrKTXvJ/XuM0qveb9vEYqtJ30
+rrJI73Ib6bVWbrYWsYLwzvcKb/8JefLvTS7XP/t6txExqdxcG6TXEN/c3AXqA2eK/gCO5V7JpKQx
+3lTqobrIllmMjYmEIcaQSEgmHjtmzGg9acFEBpMcp5MdpxMep6v8TouYWKWX6c2EEDfnDW7v5a2p
+UV6c+3G+x+fO8OHD9OfO558P1udunLdxrsY5GsLq+fzpoT+PILmQXXxGQYDxOYRF3TFjRukFXmwN
+YmG1yME+XkpvZOcCo4iVXeXmUItY2VVuXlq2XabmeKo3X3nVj2TYhAwtvYOTp8gVTa+SJur2MbNy
+9X5eSO+PmjX3CPLgEZKyaLU8+LunfS6A/byQ3gYNL9HXe6XN9u3nNUvv/U/+WVdufuCpdp49vk+1
+91Vu/uFV1+jbnnmvl3RJmi0/eeCxStKL/rx1GzTU1//Ye4xt5eZQi1jZVW62FrFq8b+UXsfSa0R5
+7So3h1rEyk3pLdhyolKk90fXNK8kvT+oU8cnvYs2nvIrvaFEeT8eNl3v4a2vDooPh6Rr4bWr3Bxq
+ESumNztjy5ZNakK0QU1wMKlZrlOiFy6cryYgM9TnUHrUU0sNMU5MHF5JjCHCmJxgYmKsqCOdGgIK
+McWEBvIKsQ0mvE7T2kJJbQsU5cX3taV1BSGkekmvW8IbTHpDFV5/0gvhhdiiQCPO3Thn4xyNDCKc
+k/FZ0auX57PCn8jis8UssvjciUVhtWi0QqzOnF2Q7Vd6j2RwgSAU6bVWbg61iJVd5Wbs54X0Ll6/
+TSYvyJfHf99W/r1xE73HF18ffeJpSZqd6ytiBentnpgszf/PTTraa63rA+kdMX+l/On196ThJZf6
+bof09jdJr0GdOnXlzod/Ix+Nn6el9+/j50v7jwfKf/zn9Traa3089vNCen/5p5eknlesQfsIiljZ
+VW62K2LVgpHe0KU30iivtXKzWXp3WKR3i1d6KwJI7/Ovvaul98U3PVWUX+rykU96//P6Gz19tiZm
+S8GuC/L7di9dJL0NL22kr88o2u9Iel//dKh+PKK8/Scuda0/r13lZmsRq5GF0ZFef4WsvqsT+0JW
+brFjxxY1YdqgJkartRjn5+epCcxcNWnJVJOTaZKWNj7qYoyJilmMjRQ0Q4y7deum5RMiCkGFtEJg
+IbQQXDvhdbqXK1jxKkN4DenF31UbW1cQQqIzb4hUeGNRwCqUKC+EFxFcfHZgywvOz5BSRGWRYozz
+q53IYkEU9+NxVpENFI2tCrC1CJlWHMOVKzfbFbK6MG2aPNjqdnn44YfUmEjRRa/4evmX3kiLWNlX
+bvYUsVrilV67IlazizbKzFVlPumdurxUJi8rqVTEKnnRGknKWe0rYgXpHT6v4KIiVmbp7aV79OZK
+tyk58s9JC31FrCC976fMq1TE6g1vf16jiBWk94Vh020rN4daxMqucrO/IlaM9FaB9FqjvLtPVJZe
+tCoyS6/RqsgsvWWH7Cs8P9XuBVm9+7wWXvDVjKVyU4uWOtprfbwhvW/3GCqXNrrMd3sw6bWr+GwQ
+7dTmaEmvr2XRfb+UC1dcrlOaV6jXs2TU8Bo/vhExhhgXFhaoidFSXU01K2u2FuNo7S02izGKbyEC
+XHmPsREx/kSJ8ae+iDHk1Zg8QXAhuhGnNSvxXnz//WxdQQhxDZxzILPxEOUNJL2QXERup0+fJhMm
+pGmZhZAOHTrE2yXgM18WjLEnNlhENt5ENhAoWoUtREhpRoSXwutffBHxvTBrpqdlUfZ8XbkZrxd6
+/KLdUcuWt6nxMJCvoY1D/Ov8t5WkN/QiVhdXbjYXsTJLr7mIFaQ3s7DcJ70oYgXpnZRfUqmI1bjc
+1V7p9RSxSvRKr7WIlVl6jSJWn072SK9RxOqDVI/0motY+ZNea+Vmp0WsnFRuthaxuvXNwdzTGy/S
+G05/XmPgOenPaxSxsvbohfTmK8Kt3Dxnk7gW6XUivdFKb7bjPiXA6F9X20/YRsS4tHStFmO0pVmw
+YL6aKM2MiRh/365pqLdwyUAtwBBXzx6vT7zpyT212EKaMVEzvgZLa4bwsnUFIcRNcJ6CtIYqvG5I
+L2QXEdy5c7Nk2jTPdpevvhqjs2RwDjUWFo0aDTiP4nyIlGPcZ+yRhfgiU8f11OIoVAOHuOLzCJ9L
+8+dn6cVbfFbhMwuLuuXlpeq1LefYjCKTJqXpeRMqPnfu/IosW5bH18XrEBcufCffKPHFnt7jIRax
+sqvcbC1ilbfBI705JVsqFbFClNeQXqNy85RlHuk1ililLF6jpfernCJfEStI77C5BZWKWEF6P5ux
+RAfYAKS3+xSP9H48caGviBWk972Uub4iVpDe/zVJ78te6e3kld5Qi1gFqtxsLWLV6m9fyk//9oW0
+9EZ6Kb0hVG+uztK7yiS9EF6jcvMyr/CGUsSqtkhv27bPyIAB/XjSdijGmFSgXQ1Sqc1iPHXq5KiK
+8fd9jBN9fYytYmxEKIyCVYhUYIIHjtSvz9YVhBBXSUr6SkdS3YzyIoKbm5uj99FC8iB7WBD8Pirb
+zxeVDZReDJHFzwUr9hSPIrtiRT5FNs5BxLxTp+flmmuuljZtfufr91ubHeLMmTNy+vRpOXXqlJw8
+eVJOnDghx48fl2PHjsnRo0flyJEjIVV7D+W8EWpmiBv7/kMpchdqRfdQ2pfZZf5Reh0M2O++E5/4
+hlrEKlrSi6rMIBTpdRrlRZEqO4zKzXO9wjvHK7yhFLEKVXr1nt4oF7Ki9MZWjDFxyctbVEmMY1F8
+a/TokeokOUxPEg3YuoIQ4jY5Odl62wYmqP6EFxNVTEYxycSEEZNBTPowsUNmC0QWWSpYrEP9A0Nk
+sZiH25FeDJHF1hAs+I0YMVyf4+I1KmsWWWyhwfkfnwNWkcVnBcdQ9Qdpzr16ddfR3xYtbq610V87
+6bUK7+HDh/1Kr7/FMnN2SE0B4g4hhzQ7aWFmll6nRU0pvVylqZGrNJHy1FNP6v0p/PCKHVi1Lysr
+8RXfwso+VvghxpgsRSNizNYVhBC32b59i65cjG0Vyclo5ZaqP+fwmeapWdDDV8zPE5HtU6lmAUR2
++PDv98mOHftV3IosFi1xrrQTWWyLwfYYiiyjv2+88brcdNNNeu/vyy+/qOaj2bXGIYL5gyG9Tovf
+wR9qmvBaga/4k14n/mBIr7W+C6WXqzQ1cpUmUm6//afq/5jBD6w4Y9u2Clm/fq17YszWFYSQKFFW
+Vio5OQt0SzlPbYIhcZ9ajHOoP5FFpg5FlkS69xdR3yuuuFxuuOF6nQqNuVZNTYH2J71O/MGQ3tom
+vAYIvDnxB0N6g/kDpZerNDV2lSYScALGyZgl+KsnW7du0hOztWtXS0HBMj1hw6TTEGMn7ZrS06fo
+5+HrSQhxA/RRryqRHT8+pZLIGoWesHBIkSVVRUZGunz44d91BLhx48bSuvUD8s9/fqQ/t2uSQzjx
+B0N6g/lDTQyY+QMZrf6k12n7SjiEuaAppZerNDVylSYS7r77LnVw9OaHUi2oSo2I8apVK/Tkz6Ck
+pJiTP0KI6ymebopsaur3qcXz5mVJbu4C/TsgDMXFHpFFSzpkx/D1J/EO9vsOGfK5dOz4rG6BBFAI
+C1IMOa6urZAgqWeUQ9hJrxN/MKTXyBKNZE6ObRRt2rTxe/8TTzyhH4MiufGSPerUHwzpDda6ktJb
+i1dpMEiuvPLKqA3wqlylCZd33vmbLrzAKC8hhBA3M1CmTZsapG/seF+xp7lzv08tRg91o9gTRJZZ
+KKSmgz2/KCbavn07vd2sUaNL9Vdcxzxt1KjEalEY6/y5c3JW+cNJ5QrHlDM42RoZqNp7pBJ59dVX
+63o/1vtwG+7DY+IpeBZIep34gyG9RttKSm8E0huLVRpI46233ir169eXa6+9Vr9pbg2mq666Shex
+Mq67Lb+hrNK02NlC3prylmurNOHsvfr1rx/Xwsvm6oQQQtwvcLXZ19oNIMvEqFrMiCwhgedo6emT
+dfoz9gQ//PBDuicw0qLvvfcevTfYkGEIc3FxUVz83RDeU8oTjikfOLRlixxQHFaeYEiv0wK4bmWK
+vvPOO/Liiy9edDtuw312LvDqq69KkyZNtIcgUoziurj9xhtv1IVx8T0K6eLnUFjX2OJ4ww03uCK9
+oRTAhUP48wdKr0PpdRrldXuVBtWSIaaojIzrqMz87LPPuialsUhhcLpKk3A+QRLOJsjN5TfLW6lv
+RbxK4xScGLt1+0Tv4UVFQUZ4CSGEEELiH6TzoxfwBx+8p+dwkGHM5yDDKJaF7Wq4Dfd16fKm3rqW
+mDhU125BpBgyHc2/zyy8+8vKZHdxsWxXYrh99WrZp7zAn/T66+kd6ZwcXWAuv/xyn7gCdIlB1ifu
+s7rBG2+8IY888ojuFoMOM3/4wx98HvLcc89pocT3aKWG5zCuY+7esWPHiP9eNwrgGtKLv5HSG6H0
+RnOV5rHHHtNvnL/70dKoXbt2cskll2jwPW4zSy3e5GbNmkndunXltttu05WVjfvMWAc62iY9/fTT
+emUHA/mDDz4IS5KdrtJAeBNOKY4pDiXILatvkdfGvRb2Kk0gSkuL9UkS+0WQMoOvNalwAiGEEEJI
+baaoqEBHhxH9hRSjbVLbts/Ir371qG6dhH3DDRo00HPba665WqdPI2qM+/E4Q5QBeg4j3RpAmlGF
+GhjybMWQaTvh3bxkiZQvXCilc+ZI2aJFsnPTpqD+4Jb0gk6dOuk5vXG9a9euWmDtAmLWdGgI8mWX
+Xaa/R7Fa7APG9xDjl19+WXsLriMijPvdkt5QCuBCeu2ivJTeEKQ3lDZFbq3SNGrUSMunv/uRjoCB
+htUZ8Oijj1ZKW8DAxcDDCg1SjTGwW7Vq5TfSa76OwYvnw2oQnhsDORzpdbpKYxbehP2K3YrtCfLj
+ZT+WzmM6h7xKYxZcnJSwuof0F5zUcJJDlUCcvCi7hBBCCCG1db99hZ4LomAWRBZSi/khRNmQ3j//
++Y9ahA1phhwDQ56tIKCCOXMg4S2ePl1K1Netap5tJ71Wf3CrJtDixYv13wgvAPget9m5AL5H8MsA
+1+vUqePbwoifRQQYgTfjq3G7G/uD3SiAS+kNUXrdaFMUjvQGk0zsZzAPVHyPqKz5582RXwxARHyd
+SC+eOz8/33cd30civcFWaeyEN2GzolxRmiA3Z98srw57Vb8fiYnDfQwePEjS0lLU14E6TdlYycPe
+XCPFpUWLm3U0F/s98Nhop7MQQgghhJDajT/h3ZCdLTs2bAjJH9wshPvb3/5WSyJ4/PHH/boAIr3G
+Pl07EHj7xz/+IQ899JDvOuTSuO6m9IZSABfSaxXeXr16UXpDkd5Q2hS5sUoTLNJrJ6GBpNZuBcfp
+feHuAXa6ShNIeBOKE6R5bnPpMLqDfj86dOjg44UXXtCrbZBaVPUz0lAgtyhmwKJUhBBCCCEk1liF
+d+PixbJr40btDk6CZtEQXpCRkaG3PP7kJz/R3/ub67/77rtaYI0gGApXYeujcX+PHj10kSuIL67j
+K4Jv3bp1c+XvdKNNEaU3ROmNtE1RuIMW6cWB9vQiGmvOtbeL9IYrvdZIL35PpNIbaJXGn/A2z2su
+fx39V+nZp2dIA5YQQgghhJCqwhDeLcuXy141J4Y7hFoANxrSC+666y5NsAAXxBfpykhrRjcZzN2t
+bjB37lx9HV9x3a4tkhvSG0qbIkivWXh79uxJ6Q1VekNpUxTpKg2qN0M+J02aZFu92dh3iz232HuL
+tALrnt5wpdfYkI7nBUh/CEd6na7SWIW3eX5zeS7pOendr3dYqzSEEEIIIYRUFQWzZ8t+Ja8ImIVT
+ABcOYfhDRUVFXPXQjQVutCmi9IYovZG2KYpklcbo04sVFvTpxRtqrt4MCTY2mLdv375SOnQk0ovn
+btu2rU6XRuoCKr2ZU6fdXqUxhPf6FddLx5SO0rd/34hWaQghhBBCCKlKh4i0AC6lt7L0htKmCA5h
++ANSsSm9YUhvbVylQaNppDdEa5Xm2sJrpVNKJ+k3oJ8rqzSEEEIIIYTEm/SGWsAK/uBGNeTqBP5f
+N9oUUXq5SuMIpEojtbmoqOii1Ol4X6UhhBBCCCGkKh3CjQK4hvTWpmjvqlWr/EpvKG2K4BDwh+7d
+u1N6uUrjn08//VQXxmrYsKGu1mZufxTvqzSEEEIIIYTEo/SGUgAXDoE+uKC2SG96erp2iEjbFBn+
+wEgvV2lq7CoNIYQQQgghVQXmtpj7R1IA1/AHCG95eXmtSHNesGBB0KCZU38wpLdv3z7aIyi9XKWp
+cas0hBBCCCGEVBXp6VNkzpzZfqXXqT8Y0otitRs2bNBfa5r84v8pLCzUnWusWyMjaVNkBM0GDOiv
+HvcZpZerNDVvlYYQQgghhJCqoqysVM9tsT0w3AK4Zn8wpBfPV1paKiUlJbr2DlqXrlmzRlavXq3r
+8EAekW25cuVKKSgokBUrVsjy5ct169OlS5fqPrp5eXmyePFiWbRokS5Wm5OTIwsXLtTz9+zsbJk/
+f77MmzdP997NyspS8j5HZs+eLZmZmTJz5kyZMWOGZGRkyPTp07WoItA1depUmTJlikyePFm3W504
+caKkpaXJ+PHjJTU1VVJSUtS8PVnGjRsnY8eOlaSkJN2lZsyYMTJ69GgZNWqU4wK4cAin/jBw4AD9
+dcyYUZRertLUvFUaQgghhBBCqpIVK/L1/DYzc5YWV6v0OvUHQ3qtwrt27Vq/0msV3vz8/JCl1yq8
+s2bN8iu9VuGdMGFCQOm1Cq+1zalZekMtgAv69eur3QEekZg47CJ/oPRylaZGrNIQQgghhBASDy4x
+fnyqnu9imx6JDQiYIVhm5w4gJSWZ0stVmuq/SkMIIYQQQkg8MXNmhu1clsQevBeUXq7SVPtVGkII
+IYQQQuKJNWsKJTU1mdIZBxQXF1J6uUpT/VdpCCGEEEIIiTeWLl3MOXwVs2jRQr/vD6WXqzTVapWG
+EEIIIYSQeHUJBG6Qscj5fGzAa43XPJg7UHq5SlOtVmkIIYQQQgghJBQovVylqVarNIQQQgghhBBC
+6SWEEEIIIYQQQii9hBBCCCGEEEIovYQQQgghhBBCCKWXEEIIIYQQQgiJH/4/HttjpucRkhMAAAAA
+SUVORK5CYII=
+</xwf:image>
+</xwf:workflow>
\ No newline at end of file



Mime
View raw message