airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From samin...@apache.org
Subject svn commit: r1515978 - in /airavata/trunk/modules/integration-tests/src/test: java/org/apache/airavata/integration/BaseCaseIT.java java/org/apache/airavata/integration/ForEachCaseIT.java resources/ForEachEchoWorkflow.xwf resources/comma_data.sh
Date Tue, 20 Aug 2013 21:35:02 GMT
Author: samindaw
Date: Tue Aug 20 21:35:02 2013
New Revision: 1515978

URL: http://svn.apache.org/r1515978
Log:
ForEach integration test

Added:
    airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java   (with props)
    airavata/trunk/modules/integration-tests/src/test/resources/ForEachEchoWorkflow.xwf
    airavata/trunk/modules/integration-tests/src/test/resources/comma_data.sh
Modified:
    airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/BaseCaseIT.java

Modified: airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/BaseCaseIT.java
URL: http://svn.apache.org/viewvc/airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/BaseCaseIT.java?rev=1515978&r1=1515977&r2=1515978&view=diff
==============================================================================
--- airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/BaseCaseIT.java (original)
+++ airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/BaseCaseIT.java Tue Aug 20 21:35:02 2013
@@ -138,7 +138,22 @@ public class BaseCaseIT {
         log("..................Validating server logs .............................");
         // TODO validate logs
 
-        log("Reading test server configurations ...");
+		setRegistryURL(createRegistryURL());
+
+        log("Configurations - Registry URL : " + getRegistryURL());
+
+        PasswordCallback passwordCallback = new PasswordCallbackImpl();
+        AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
+                passwordCallback);
+
+        checkServerStartup(airavataAPI);
+
+        log("Server successfully started .............................");
+        log("Running tests .............................");
+    }
+
+	private String createRegistryURL() {
+		log("Reading test server configurations ...");
 
         String strPort = System.getProperty("test.server.port");
 
@@ -166,19 +181,9 @@ public class BaseCaseIT {
         log("Configurations - serverUrl : " + serverUrl);
         log("Configurations - serverContext : " + serverContextName);
 
-        registryURL = "http://" + serverUrl + ":" + port + "/" + serverContextName + "/services/registry";
-
-        log("Configurations - Registry URL : " + registryURL);
-
-        PasswordCallback passwordCallback = new PasswordCallbackImpl();
-        AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
-                passwordCallback);
-
-        checkServerStartup(airavataAPI);
-
-        log("Server successfully started .............................");
-        log("Running tests .............................");
-    }
+        String registryURL = "http://" + serverUrl + ":" + port + "/" + serverContextName + "/services/registry";
+		return registryURL;
+	}
 
     protected void checkServerStartup(AiravataAPI airavataAPI) throws Exception {
 
@@ -523,4 +528,8 @@ public class BaseCaseIT {
         experimentMonitor.waitForCompletion();
     }
 
+	public void setRegistryURL(String registryURL) {
+		this.registryURL = registryURL;
+	}
+
 }

Added: 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=1515978&view=auto
==============================================================================
--- airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java (added)
+++ airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java Tue Aug 20 21:35:02 2013
@@ -0,0 +1,386 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+
+package org.apache.airavata.integration;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import junit.framework.Assert;
+
+import org.apache.airavata.client.AiravataAPIFactory;
+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.commons.gfac.type.ApplicationDescription;
+import org.apache.airavata.commons.gfac.type.HostDescription;
+import org.apache.airavata.commons.gfac.type.ServiceDescription;
+import org.apache.airavata.registry.api.PasswordCallback;
+import org.apache.airavata.registry.api.impl.WorkflowExecutionDataImpl;
+import org.apache.airavata.registry.api.workflow.ExperimentData;
+import org.apache.airavata.registry.api.workflow.InputData;
+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.InputParameterType;
+import org.apache.airavata.schemas.gfac.OutputParameterType;
+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;
+import org.testng.annotations.Test;
+
+/**
+ * Integration test class.
+ */
+public class ForEachCaseIT {
+
+    private final Logger log = LoggerFactory.getLogger(ForEachCaseIT.class);
+
+    private int port;
+    private String serverUrl;
+    private String serverContextName;
+
+    private String registryURL;
+
+    private String gatewayName = "default";
+    private String userName = "admin";
+    private String password = "admin";
+
+    private static final int TIME_OUT = 20000;
+
+    private static final int TRIES = 3;
+
+    private AiravataAPI airavataAPI;
+
+    protected void log(String message) {
+        log.info(message);
+    }
+
+    public Logger getLog() {
+        return log;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public String getServerUrl() {
+        return serverUrl;
+    }
+
+    public String getServerContextName() {
+        return serverContextName;
+    }
+
+    public String getRegistryURL() {
+        return registryURL;
+    }
+
+    public String getGatewayName() {
+        return gatewayName;
+    }
+
+    public String getUserName() {
+        return userName;
+    }
+
+    public AiravataAPI getAiravataAPI() {
+        return airavataAPI;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public ForEachCaseIT() throws Exception {
+        setUpEnvironment();
+    }
+
+    public void setUpEnvironment() throws Exception {
+
+        log("..................Validating server logs .............................");
+        // TODO validate logs
+
+		setRegistryURL(createRegistryURL());
+
+        log("Configurations - Registry URL : " + getRegistryURL());
+
+        PasswordCallback passwordCallback = new PasswordCallbackImpl();
+        AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
+                passwordCallback);
+
+        checkServerStartup(airavataAPI);
+
+        log("Server successfully started .............................");
+        log("Running tests .............................");
+    }
+
+	private String createRegistryURL() {
+		log("Reading test server configurations ...");
+
+        String strPort = System.getProperty("test.server.port");
+
+        if (strPort == null) {
+            strPort = "8080";
+        }
+
+        String strHost = System.getProperty("test.server.url");
+
+        if (strHost == null) {
+            strHost = "localhost";
+        }
+
+        String strContext = System.getProperty("test.server.context");
+
+        if (strContext == null) {
+            strContext = "airavata";
+        }
+
+        port = Integer.parseInt(strPort);
+        serverUrl = strHost;
+        serverContextName = strContext;
+
+        log("Configurations - port : " + port);
+        log("Configurations - serverUrl : " + serverUrl);
+        log("Configurations - serverContext : " + serverContextName);
+
+        String registryURL = "http://" + serverUrl + ":" + port + "/" + serverContextName + "/services/registry";
+		return registryURL;
+	}
+
+    protected void checkServerStartup(AiravataAPI airavataAPI) throws Exception {
+
+        int tries = 0;
+
+        while (true) {
+
+            if (tries == TRIES) {
+                log("Server not responding. Cannot continue with integration tests ...");
+                throw new Exception("Server not responding !");
+            }
+
+            log("Checking server is running, try - " + tries);
+
+            URI eventingServiceURL = airavataAPI.getAiravataManager().getEventingServiceURL();
+
+            URI messageBoxServiceURL = airavataAPI.getAiravataManager().getMessageBoxServiceURL();
+
+            URI workflowInterpreterServiceURL = airavataAPI.getAiravataManager().getWorkflowInterpreterServiceURL();
+
+            if (eventingServiceURL == null || messageBoxServiceURL == null
+                    || workflowInterpreterServiceURL == null) {
+
+                log.info("Waiting till server initializes ........");
+                Thread.sleep(TIME_OUT);
+            } else {
+                break;
+            }
+
+            ++tries;
+        }
+
+    }
+
+    @BeforeTest
+    public void setUp() throws Exception {
+
+        PasswordCallback passwordCallback = new PasswordCallbackImpl();
+        this.airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
+                passwordCallback);
+    }
+
+    @Test(groups = { "echoGroup" })
+    public void testEchoService() throws Exception {
+
+        DescriptorBuilder descriptorBuilder = airavataAPI.getDescriptorBuilder();
+        
+        log("Checking host description ....");
+        Assert.assertTrue(airavataAPI.getApplicationManager().isHostDescriptorExists("localhost"));
+        HostDescription hostDescription = airavataAPI.getApplicationManager().getHostDescription("localhost");
+        
+        List<InputParameterType> inputParameters = new ArrayList<InputParameterType>();
+        inputParameters.add(descriptorBuilder.buildInputParameterType("data1", "data1", DataType.STRING));
+        inputParameters.add(descriptorBuilder.buildInputParameterType("data2", "data2", DataType.STRING));
+
+        List<OutputParameterType> outputParameters = new ArrayList<OutputParameterType>();
+        outputParameters.add(descriptorBuilder.buildOutputParameterType("out", "out", DataType.STD_OUT));
+
+        ServiceDescription serviceDescription = descriptorBuilder.buildServiceDescription("comma_app", "comma_app",
+                inputParameters, outputParameters);
+
+        log("Adding service description ...");
+        airavataAPI.getApplicationManager().addServiceDescription(serviceDescription);
+        Assert.assertTrue(airavataAPI.getApplicationManager().isServiceDescriptorExists(
+                serviceDescription.getType().getName()));
+
+        // Deployment descriptor
+        ApplicationDescription applicationDeploymentDescription = descriptorBuilder
+                .buildApplicationDeploymentDescription("comma_app_localhost", getFile("src/test/resources/comma_data.sh").getAbsolutePath(), "/tmp");
+
+        log("Adding deployment description ...");
+        airavataAPI.getApplicationManager().addApplicationDescription(serviceDescription, hostDescription,
+                applicationDeploymentDescription);
+
+        Assert.assertTrue(airavataAPI.getApplicationManager().isApplicationDescriptorExists(
+                serviceDescription.getType().getName(), hostDescription.getType().getHostName(),
+                applicationDeploymentDescription.getType().getApplicationName().getStringValue()));
+
+        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 {
+
+        AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
+                new PasswordCallbackImpl());
+        List<WorkflowInput> workflowInputs = setupInputs(workflow, inputValues);
+        String workflowName = workflow.getName();
+        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);
+    }
+
+    protected void verifyOutput(String experimentId, String outputVerifyingString) throws Exception {
+        AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
+                new PasswordCallbackImpl());
+        log.info("Experiment ID Returned : " + experimentId);
+
+        ExperimentData experimentData = airavataAPI.getProvenanceManager().getExperimentData(experimentId);
+
+        log.info("Verifying output ...");
+
+        List<WorkflowExecutionDataImpl> workflowInstanceData = experimentData.getWorkflowExecutionDataList();
+
+        Assert.assertFalse("Workflow instance data cannot be empty !", workflowInstanceData.isEmpty());
+
+        for (WorkflowExecutionDataImpl data : workflowInstanceData) {
+            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());
+                }
+            }
+        }
+    }
+
+    private List<WorkflowInput> setupInputs(Workflow workflow, List<String> inputValues) throws Exception {
+        AiravataAPI airavataAPI = AiravataAPIFactory.getAPI(new URI(getRegistryURL()), getGatewayName(), getUserName(),
+                new PasswordCallbackImpl());
+        List<WorkflowInput> workflowInputs = airavataAPI.getWorkflowManager().getWorkflowInputs(workflow.getName());
+
+        Assert.assertEquals(workflowInputs.size(), inputValues.size());
+
+        int i = 0;
+        for (String valueString : inputValues) {
+            workflowInputs.get(i).setValue(valueString);
+            ++i;
+        }
+        return workflowInputs;
+    }
+
+    protected String getWorkflowComposeContent(String fileName) throws IOException {
+        File file = getFile(fileName);
+
+        BufferedReader reader = new BufferedReader(new FileReader(file));
+        String line;
+        StringBuilder buffer = new StringBuilder();
+        while ((line = reader.readLine()) != null) {
+            buffer.append(line);
+        }
+        reader.close();
+        log.debug("Workflow compose - " + buffer.toString());
+        return buffer.toString();
+    }
+
+	private File getFile(String fileName) {
+		File f = new File(".");
+        log.debug(f.getAbsolutePath());
+
+        File file = new File(fileName);
+        if (!file.exists()) {
+        	file = new File("modules/integration-tests/src/test/resources/EchoWorkflow.xwf");
+        }
+		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;
+	}
+
+}

Propchange: airavata/trunk/modules/integration-tests/src/test/java/org/apache/airavata/integration/ForEachCaseIT.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: airavata/trunk/modules/integration-tests/src/test/resources/ForEachEchoWorkflow.xwf
URL: http://svn.apache.org/viewvc/airavata/trunk/modules/integration-tests/src/test/resources/ForEachEchoWorkflow.xwf?rev=1515978&view=auto
==============================================================================
--- airavata/trunk/modules/integration-tests/src/test/resources/ForEachEchoWorkflow.xwf (added)
+++ airavata/trunk/modules/integration-tests/src/test/resources/ForEachEchoWorkflow.xwf Tue Aug 20 21:35:02 2013
@@ -0,0 +1,679 @@
+<?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>Workflow3</xgr:id>
+    <xgr:name>ForEachEchoWorkflow</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>comma_app_invoke</xgr:id>
+      <xgr:name>comma_app:invoke</xgr:name>
+      <xgr:outputPort>comma_app_invoke_out_0</xgr:outputPort>
+      <xgr:inputPort>comma_app_invoke_in_0</xgr:inputPort>
+      <xgr:inputPort>comma_app_invoke_in_1</xgr:inputPort>
+      <xgr:controlInPort>comma_app_invoke_ctrl_in_0</xgr:controlInPort>
+      <xgr:controlOutPort>comma_app_invoke_ctrl_out_0</xgr:controlOutPort>
+      <xgr:x>318</xgr:x>
+      <xgr:y>91</xgr:y>
+      <xgr:wsdl>comma_app</xgr:wsdl>
+      <xgr:portType>{http://airavata.apache.org/schemas/gfac/2012/12}comma_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>26</xgr:x>
+      <xgr:y>74</xgr:y>
+      <xgr:config>
+        <xgr:dataType>{http://www.w3.org/2001/XMLSchema}any</xgr:dataType>
+        <xgr:value>dsf,aaaa</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>35</xgr:x>
+      <xgr:y>165</xgr:y>
+      <xgr:config>
+        <xgr:dataType>{http://www.w3.org/2001/XMLSchema}any</xgr:dataType>
+        <xgr:value>sdaf,bbbb</xgr:value>
+        <xgr:visibility>true</xgr:visibility>
+      </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>650</xgr:x>
+      <xgr:y>98</xgr:y>
+      <xgr:config>
+        <xgr:dataType>{http://airavata.apache.org/schemas/gfac/2012/12}StdOutParameterType</xgr:dataType>
+      </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>188</xgr:x>
+      <xgr:y>104</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>515</xgr:x>
+      <xgr:y>91</xgr:y>
+      <xgr:config />
+    </xgr:node>
+    <xgr:port xgr:type="ws">
+      <xgr:id>comma_app_invoke_in_0</xgr:id>
+      <xgr:name>data1</xgr:name>
+      <xgr:node>comma_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="ws">
+      <xgr:id>comma_app_invoke_in_1</xgr:id>
+      <xgr:name>data2</xgr:name>
+      <xgr:node>comma_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="ws">
+      <xgr:id>comma_app_invoke_out_0</xgr:id>
+      <xgr:name>out</xgr:name>
+      <xgr:node>comma_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="control">
+      <xgr:id>comma_app_invoke_ctrl_in_0</xgr:id>
+      <xgr:name>control</xgr:name>
+      <xgr:node>comma_app_invoke</xgr:node>
+    </xgr:port>
+    <xgr:port xgr:type="control">
+      <xgr:id>comma_app_invoke_ctrl_out_0</xgr:id>
+      <xgr:name>control</xgr:name>
+      <xgr:node>comma_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>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_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>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: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:edge xgr:type="data">
+      <xgr:fromPort>comma_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:edge xgr:type="data">
+      <xgr:fromPort>ForEach_out_0</xgr:fromPort>
+      <xgr:toPort>comma_app_invoke_in_0</xgr:toPort>
+    </xgr:edge>
+    <xgr:edge xgr:type="data">
+      <xgr:fromPort>ForEach_out_1</xgr:fromPort>
+      <xgr:toPort>comma_app_invoke_in_1</xgr:toPort>
+    </xgr:edge>
+    <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:graph>
+  <xwf:wsdls>
+    <xwf:wsdl xwf:id="comma_app">&lt;wsdl:definitions name="comma_app" targetNamespace="http://airavata.apache.org/schemas/gfac/2012/12"
+  xmlns:typens="http://airavata.apache.org/schemas/gfac/2012/12/comma_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/comma_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_44f0ea5b-82f5-4eba-a5df-1461ec94d8b0">
+    &lt;wsdl:part name="parameters" element="typens:invoke_OutputParams">
+    &lt;/wsdl:part>
+  &lt;/wsdl:message>
+  &lt;wsdl:message name="invoke_RequestMessage_e46e083d-e7fa-452d-af88-388efc5e90c8">
+    &lt;wsdl:part name="parameters" element="typens:invoke_InputParams">
+    &lt;/wsdl:part>
+  &lt;/wsdl:message>
+  &lt;wsdl:portType name="comma_app">
+&lt;wsdl:documentation />
+    &lt;wsdl:operation name="invoke">
+&lt;wsdl:documentation />
+      &lt;wsdl:input name="invoke_RequestMessage_e46e083d-e7fa-452d-af88-388efc5e90c8" message="wsdlns:invoke_RequestMessage_e46e083d-e7fa-452d-af88-388efc5e90c8">
+    &lt;/wsdl:input>
+      &lt;wsdl:output name="invoke_ResponseMessage_44f0ea5b-82f5-4eba-a5df-1461ec94d8b0" message="wsdlns:invoke_ResponseMessage_44f0ea5b-82f5-4eba-a5df-1461ec94d8b0">
+    &lt;/wsdl:output>
+    &lt;/wsdl:operation>
+  &lt;/wsdl:portType>
+&lt;/wsdl:definitions></xwf:wsdl>
+  </xwf:wsdls>
+  <xwf:image>iVBORw0KGgoAAAANSUhEUgAAAvgAAADYCAYAAACeEZf8AABeL0lEQVR42u2dCVxU97n3uY1GE2+S
+Jn2TJmm2Jm+bt0nb3Nb0tn2b2+aNvZrcNGarbVNNb26Wmt2Y1ZjExJ1FFHcUFUVEUUBccQcBUVSU
+TfZ9ERXFXRQkz/t//nPOcGbmnJkzCzDAbz6f70dmgEGYc858z3N+z/MPqKmpIAAAAAAAAEDPIAB/
+BAAAAAAAACD4AAAAAAAAAAg+AAAAAAAAAIIPAAAAAAAAgOADAAAAAAAAwQcAAAAAAABA8AEAAAAA
+AAAQfAAAAAAAAAAEHwAAAAAAAADBBwAAAAAAAIIPAAAAAAAAgOADAAAAAAAAIPgAAAAAAAAACD4A
+AAAAAAAAgg8AAAAAAAAEHwAAAAAAAADBBwAAAAAAAEDwAQAAAAAAABB8AAAAAAAAIPgAAAAAAAAA
+CD4AAAAAAAAAgg8AAAAAAACA4AMAAAAAAAAg+AAAAAAAAEDwAQAAAAAAABB8AAAAAAAAAAQfAAAA
+AAAAAMEHAAAAAAAAQPABAAAAAACA4AMAAAAAAAAg+AAAAAAAAAAIPgAAAAAAAACCDwAAAAAAAAQf
+AAAAAAAAAMEHAAAAAAAAQPABAAAAAAAAEHwAAAAAAAAABB8AAAAAAAAIPgAAAAAAAACCDwAAAAAA
+AIDgAwAAAAAAACD4AAAAAAAAAAg+AAAAAAAAEHwAAAAAAAAABB8AAAAAAAAAwQcAAAAAAABA8AEA
+AAAAAIDgAwAAAAAAACD4AAAAAAAAAAg+AAAAAAAAAIIPAAAAAAAAgOADAAAAAAAAwQcAAAAAAABA
+8AEAAAAAAAAQfAAAAAAAAAAEHwAAAAAAAADBBwAAAAAAAIIPAAAAAAAAgOADAAAAAAAAIPgAAAAA
+AAAACD4AAAAAAAAQfPwRAAAAAAAAgOADAAAAAAAAIPgAAAAAAAAACD4AAAAAAAAAgg8AAAAAAAAE
+HwAAAAAAAADBBwAAAAAAAEDwAQAAAAAAABB8AAAAAAAAAAQfAAAAAAAACD4AAAAAAAAAgg8AAAAA
+AADo8YJfW1dNm5OSaEZYGH3zzTegk5gcGExRMVGUn5+DDR8AAAAAAILvGwoLC2j69Om0a1cyHW04
+Ti1Xia4ILrcSNQsutRBdFFy4QnRecO4y0VnBmWai04KmS0SnBCcvEjUKTlwgOi44dp6oQXD0HFG9
+oO4sUa2g5gxRtaDqNFGloKKJqFxQdoqoVFBykqhYUNRIVCgoOEF0RJB/nChPkHuMKEeQ3UB0WHDo
+KFGW4GC9hf11FvbVWsiosZBebSG1ykJKpYVdFRZ2lFvYLthWRrRVsKWUKEmwuYRok2BjMdEGwfoi
+onWCxEKitYKEAqJ4QdwRojWC1flEsYJVeUQrBTG5RCsE0TlEywVR2UTLBBHppyhsdRoFBgfTnj2p
+2PgBAAAAACD43lFXVyPlvrKqmlrbSHJFEfxmRfAvKoJ/XhH8s4rgn/ZDwT+gCH6mIvh7FcHfowh+
+miL4uxXBT1YEf6dG8Fnutylyv0WR+82K3G9U5H69IveJitwnKHLvruAvPUwUKQhPbqCg4CBU8gEA
+AAAAIPjekZSURLuSk+mqIvdmq/dawT+lCH6jIvjHFcFvUAS/XhH8WkXwqxXBr/RDwfe2eh+nyP1q
+Re5XKXIfo8h9tCL3UYrcM0sOWVgYt4miopZhBwAAAAAAgOB7TlhYGDUcO+624PsqnsOUK4Jfqgh+
+sSL4hYrgH1EEP08R/BxF8A/7oeB7Ur1nuV8siEg7QUFBQdgBAAAAAAAg+J7DjZ5t31KXCb631Xsm
+q4cI/qIskq/H+vWJlJ19EDsCAAAAAAAEv/cJvrcNtv4o+FFRSyWpqcnYGQAAAAAAIPieCb6rBtuO
+EvyAgABJV+Tv1Z+9y4sG244UfAaVfAAAAAAACL7bgu+qeu9sgo7ZBlt/FnxPq/d6E3TcbbB1Jfgc
+18EOAQAAAAAAwfep4HtbvXc2QUeVbLXBVr2v0qdvX/rfDz5MyzekWwXf/muuvbYfPff312lfdatV
+8NXPaQVffYwF3/45mM6O52gn6LDc6wn+8uVR2CEAAAAAACD4/iX4zvL3WsHn6r16/6X/eYvyjrbS
+orjt8v5d995vnaCjfs3Lb34kq/evf/ClvP/66HGmBd8XFXxfx3MidASfwQ4BAAAAAADB7/aCf6Di
+rDWew/e/c8011niO+jUphU1S8HcXnZX3b/3+ndYGW77f99p+EHwAAAAAAND7BN++wdYfBF+bv1cf
+sxd8bf5exnn69LXm77WCr07QsZ4YVNoKvtkGWwg+AAAAAADoNoKvVu/1Jui422DbWYKfVnzWpoJ/
+2x132Qg+V/3V6v22gvM2gp9sJ/iuqvd6E3TcbbCF4AMAAAAAQPA7XfC9rd7rTdAxarAttxP8YjcF
+/7/f/kQK/qvvj5X3Xx31pVXwf3DP/fKxsJjtlFrZRkP//k8Hwe9//QB5f03msQ6P5+hN0LFvsF14
+EIIPeiEVpXTq7Tfp3IDrqbFfP6p97VWqLszH3wVgn8A+AQAE318E390FrlTpVsdjagX/iJ3g59gJ
+vnXSTp++corO3qpWq+AvSEinH/74YVnFt/96VfBHTZhL1w+4wfp4V+fvIfigNyJFRux/jYJ6QSWP
+zRVCg78NwD6BfQIACH43FXxP5t+rQq63gq3ZGfj+toJtBCI6oJciq5QakSniq3X9+uFvA7BPYJ8A
+AILv7RSd7iz4BzSCz3K/T5F7bYMty32qIvcpitzrrWALwQegc2kUMmMjMoKDQmaSkpIoLCxM7hMA
++JppIUGUEBdF+fk53WKfOHDttRQXt4ZmzZpFEyZMsPld+D7vK4sWRci1UxIS4mn7ti20O2UXZe7b
+Q3m5h6moMI/KyopwzAGgNwn+t9+SVfLdbbDtCsHnha0YT1ewNareO5ugY7bB1l3Blxl8NNmCXkzt
+22/aiowg7ve/p+TkZDp+XOz8uOHWAbdTp05RWloahU4Loj17Uv1+n9g0ZAgdOXJE/r9bW1ttfpe2
+tjY6ffo01dbWUmlpKR0+fJh2795NW7ZsEbKfQEuXLqV58+bRtGnT5HvM9OmhFD5/PkVGLqa4NbG0
+efMG2rljC2Vk7KbsQ/spL+8QFYoTgqqqchyjAOjWgn/1vOAcfdt6VnBa0ETftpwUNApOCI7Tt1ca
+BEcFdfTt5VpBjaCK2porBRWCckEptV0qERQJCqntYoHgiCBfkEttF7IFhwWHqO18luCgYD+1ncsU
+7BVkCPZQ29l0QapgN109kyLYJdhJV0/vEGwTbBVsoatNmwWbBBvp6qn1gnWCRLp6cq0gXhBHVxtX
+C2IFqwQr6eqJFYJoQRS1Hl8mWCqIFCyh1mOLBBGCBdTaEC6YL5hLrUfnCGYLZgnCqLV+hiBUMI1a
+60IEwYJAwVRqrZ0smCSYSC01EwTjBV9TS/U4wZeCLwRjqaXqc8Fngk+ppfJjwUeCDyH4oNdRXVFK
+ZUJo8gZcLyv3LPeVBQUwUNw65dbQ0CDEN8ivKvnafSKzTx/aOHgwtZw967Pf+ax4Lv69KysrKScn
+R5zg7KEdO3ZQYmKieM+JooULF8orAnxlYNKkSTRn9iyKXLKYVsfG0LrEOHEysJn2pO+iQ1l7KTfn
+gDipOIJjGQD+Kfiq3J9RBP+URvBZ7o8pcl8vpF4V/GpF8FW5LxNS3y74F5qKqK6mhMrLy6isrGdQ
+XlZCdRWZdK42RhF8Ve6DLIJf2y747XL/jSL4X7ULvpT7MYrcf6IR/NEQfNCr4VgOV+5xw60zb7uT
+N4pj7TK/3Cf4PYElvKtufLWgsbFRngzk5eXRgQMHrCcD0dHRtGjRIuuVgWnTQuTJwPKoSEqIj6Ut
+SevEycAmytybQrnZmVRUmI2TAQDB7xrBd6d6by/4qtwXU9OJniX2ejRWbdap3k9RBN+uel9jrnoP
+wQe9Ha4aIpaDW6fHdU6eoKCgIL8VfI7ldIfb+fPn5cmAGhPiCBSfDMTFxcmY0Jw5c+TJAF8VCAub
+QYsiFsiTgfWJa2j7tvWUnraN9mcmU35eJpWV5FB1VSmOiwCC75Xg21Tvm3Sq94rgO1Tv1XhOe/X+
+wuniHi/3Kudqlpus3o/Tqd7bC/5oaqn4AIIPejW8/eOGW1fceNtbvz6RsrMP+t0+weLck258VUDb
+M8BXBfjK3caNG+XJAF8V4JN9PhHQngysiY0WJwOrafvWdZSemkT79+2k3Ow9VFKUJU4GSnAMBRB8
+fcFX5N4az7Gv3qvxHOfV+7raUr8R8NmzZ9P3vvc9OXGnI56/rmKfTvV+kk71Xo3n2Ffv1XjOhxB8
+ACD4fnlTp5b19J+pPfampiZjn/CT10V7MqBGhLQnA+qVAduTgXBaHrVEnAysEicDa8XJwGbav3c7
+5R5Oo+LCg1Relmv9XXDcBT1c8M/ox3O01fsrRtV72+Zad6v3S5YsoZ/85Cd07bXX0t13302BgYE+
+E/DbbruNtm7dar3va9EvLyt2qN63x3Nsq/eDmn9IyQ0vO63et1SMguADCD5uEPwuFnzGXyr5nuwT
+9os7+urvaf88HfVzPH1uV1cGtDGhL7/8kj744APlZGAxJcStoC2b42jXjrXiZGCrOBnYLU4G9lNl
+hf+PFq2traJNmzbRjBkzMAK3E/lqwgSaGzHX7Qb9ThZ8++p9o0H13llzbbEUfHcEmcd3sYTHxMTI
++xkZGfSPf/zDZwLeUZV7LRbBn2IQz2mv3ge0ioNTcwANarqP0mpHODTXWgT/fQg+gODjhpMKPxB8
+jut0d8Hv6NelI1+njt4G+vTpQ9/97ndtRovq9QxMmTLF2kAcsXA+rVoZSRvXr6T03Rso+/Aeqqzs
+2j6BgoICCp0+nXbs3Ek1dfV04fIVOnfpMp252Eynzl+ik+cu0vEz56nh9HmqP3WWak+eoaoTp6ny
+eBOVNZyikqMnqbi+kQpqT1B+zXHKrTpG2ZUNdKiing6W1VFmaS3tK6mhPUXVlFZYRbuPVFJyfgXt
+yC2n7TlltOVwCW0+VEybsopp/YFCStxfQAn7jlDc3nyK3ZNHq9JzaUVqDi3fnU3Lkg9R5K5DtHjn
+QYrYfoDCt+2n+VszaU7SPpq1eS/N3JRB0zfsoWnr0yk4MZUC16bS5PgUmhSXTONX76KvY3fSVyt3
+0Bcx22lM9Db6bPlW+nhZEn24NIk+iNxE7y/eSO8u2kBvL1xPby5YR/8MT6TX562l/5mbQK/MiaeX
+Z8XR8Jlr6KUZsfTX6avoz9NW0oshMfRc0AoaGhhNf5qynP5rchQ9OWkZDZ6wlP44PpL+39eL6fFx
+i+k/voyg332xkH47dgH9ekw4/eqz+fT7T2fTsM9DaPzkSW6N2u0awTfZXKtfvS+WozHdkeMnn3yS
+QkNDDT/PM3+HDx9O1113nYQ/5se0Aj916lS688475c760EMPyTN19XNa7IW/sLCQXnzxRXnlgGM8
+Y8aM8eiEwOxoTJb7gPOC04LGABpS/0NKrv6bJp4zCoIPIPgeCj6/Gf/iF7+gvn370l133SWvDKo3
+foO+5557rJ/j+84qhXyseeSRR+Rxhb+H/92wYYPHX883jgvy115zzTV000030VtvvUVNTU2mfjdX
+32v//+nXrx+9/vrrNrPSzXyNp1Vb/p0ffvhhSk9Pl+MX+f7AgQOtX3/lyhX5GHNWGfVo9jXh29Gj
+R+XX8n2+wqveuFr5ox/9SP4u/DfXfs4Xgs8LRvVUwXf2Gmqr4f/85z/l39eoim5Gwt3d/9TnM/Pc
+ZvYro2ODmb+BfQMxjxYtLi6mzMxMcQK4Xq4tMJ3lWpwU8HbOt87cNurqauTPL6+spMstrXTpSgud
+b7YI/ukLFsFvPHtBCv7RpnNS8GsaLYJfoRH8ojpV8I9JwT9ceVQK/gFF8PcWWwQ/tcAi+LvyyqXg
+b8sutQr+xoNFUvDXZloEf02GRfBXpucogn9YCv6SXVlS8Bcqgj9vS7vgh220CH7IujQp+FMTdkvB
+n7jGIvjjVlkEf+wKi+B/unyLIvibHQR/pCL4rymC/9+z46Tg/z1stRT8v4RaBP+FYIvgPzO1XfCH
+TFwqBX/QN0uk4P9h3CIbwf93RfB/+clc+reP59J/fDKDJk+dYrqS3wWCf8qgubbeoLnWcTRm20X3
+BH/AgAFStI0+/8Ybb9Af//hHys7OlgwePFg+phX8oUOH0sGDB6mkpITGjh0r32iNKvja+yNHjpTP
+l5ubK5+bTzY8EnyTozG1ch9wTFAnqAqgQWX3UHL5XxTBfw+CDyD4bt7UN/lnn31WCmRzczN99tln
+Vrngz/GxgW98WZ7vayVDfYOfO3eurORp75eXl8uP77vvPo+/XpVHPtbxLT4+Xn4Ny5NZ8XT2verP
+/+ijj2x+x3Hjxrn1Ne4KPssUS+D27dvl/fvvv19+/m9/+5u8z3lpvq1atUre58fdfU1OnDghJZ4/
+njlzpvXzISEh8jE+SeFFnlju+T4XjHwl+P5y7O1IwTd6DfnGr4/e6+SO4LvzWr/zzju6J6Xe7BvO
+jg1m/gZmbvy8q1evpvDwcCn5nT1WeNeuXXSl9aoU/IuXLYJ/9mKzFHyu3rPgHzttEfw6J4J/pPa4
+FPycqgYp+FnlFsHfV2IR/PTCKin4KfkVUvC5eq8KPlfvWfDX7bcIfrxV8HOl4EenZkvBX6oI/qId
+FsGfv7Vd8Ll6z4Ifuj5dCn7QWovgT4qzCP43iuB/uXK7IvhbpeB/pBH89xTBf0sR/Dfmr5WCz9V7
+FvwRM9dIwf/bdIvgvxhiEfxng6Ktgv/U5GVS8P9zQqSN4D+mCP5vPrcI/qOfzpOC/8hHc+jnH86m
+96YGmR6128mCr8ZzPB+N6YnguxLqW2+9Va7Gp97nj7narv1+bUWfJZ8r+WYEn5+bF/dQ7/PHngm+
+s9GYX1lHY+rJfUCZoEiQH0BD8u+ltJJhEHwAwXfzxm/IvO/W1dU5fI4rdvw5tarHb8Z8nx+3FwkW
+Re19VTbUCqGnX28kWDfccIPH0QXt96o/3/535Kq2O1/jruCf1Sy8pP2dVVH65JNPbISfH3f3NXnw
+wQflv/Pnz7f5P/EJFD/O1X212uyJnPV0wXdVeTd6DfnG24be6+ROBt+d1/rixYteZ/Dt9w1nxwYz
+fwOzNz4W8OQfrux39ljhow0NUvCbr1gEn6v3LPhNFyzxnBNOBL+04aQU/MK6E1Lw86otgn+owiL4
++0stgp9RVC0Fn6v3LPg7NYKfpAj+BqvgH5GCvzojTwp+TJpF8KNSLIK/eKdF8BfIeI5F8Gcr8ZwZ
+G/ZIwQ9OtAj+FEXwJ6zZpQj+Din4n6/YJgX/k6h2wR+1xCL470RYBJ+r9yz4ryrxnH/MshX8YYrg
+Px+8wir4T0+JshH8JxTB//1XFsH/v2MXSMHn6j0L/i8+tgj+z0bPllV8s6N2O1/wjUZjOmuuveS4
+cq0vK/h6wu1M4O0fcyb4rr7XvOBr4znGozGdyX1AdgANzL6N4gqflq/HSy+9RC+//LKVn//8Z/Tb
+3/6GHnvsdzRs2J/F5/9Ko0ePoq+//pJCQ4MpJmY5JSdvF3/LfEgi6HWC7+yNX+9z6uV4s7lib++n
+pqbS73//exnlYXlwpxnRzPd68jvqfY03uWs9sbv99ttlRZMjHnpCZ+b/y7LG33vy5ElT8ueJnPXm
+Cr63r7OnP8fVtmnmuT3dN9z5/dy58RUrzu539rbRerVNVu9Z8LX5e63gN2gEv7rxtBT88mOnpOBz
+/p4Fn/P3LPiW/P1Rmb+3CH6NFHxt/l4V/K12gs/5exZ8zt+z4HP+ngWf8/cs+Jb8fZbM36uCPzdp
+n43gT1MEP9Aq+MlS8Dl/z4LP+XsWfM7fq4I/OtIi+Fy9Z8HX5u+1gj9cEXzO31sEP0Yj+Mul4HP+
+ngWf8/cs+Jy/Z8Hn6v3/1eTvB35iK/gPfzDL9KjdThZ8V821NQbNtbbV+7aLR9ySY47IOMvgc5Wd
+m16cVfA9FXz7Cj7/HG8E33g0piL4BnI/MO/7tLb4GbpU8Q61lL8rX49FiyIoPHy+lcTEeIqNjRFv
+OJFS6IOCpkrBf+WVf0jhZ/m/77575RvpjTfeSA8//BANHfoMffzxhxQREQ7x7wXU1ZZTeWkuFRcd
+pEMHkmlfxjbauX0drU+MpdhVURQ+f54cH8dj5OwnAQQHB9HcubMoIT6a9u/b3W0r+DU1NQ6fU6uQ
+apXOWQWxo+6z6PJ9FhK12mdWJMx8r30l0tnv6OxrfCn4ahSD4xL2USB3XhOegsYy+Nhjj8l4hX0F
+X1t99XWTbW8XfKPXyR3B92T/M/vcZvYNZ8cGXws+T+/hTH5ZWVGnbhstV69a8/fOGmxZ8LnBlgWf
+G2xZ8D1tsNUKvqcNtguUBtu5XjTYsuBzgy0LvqcNtiz43GDLgu9Ogy0L/r9pBP+hD2aaHrXbuYLv
+cjRmjdPRmGr13l3B5yk6LNqxsbG6U3TUnDxn5Dkrz3l8+wy+p4LPz825e35e5qmnnvJQ8J0311pm
+349xkPuBBULsS54VYv+ebK7l/H1L+Ttev8lkZ2fRxo3rhMxNlycAXPUfMOB6evDBH9P7778rP1dR
+gdUBuw+VVF6WR3m5eyk7K41Sdm6Si7wkJqyiNatX0MIF86W4c6aVm634DYYzz7yMPGczeUwcx9i4
+OYzfgPSaKrl5jD+Xk5NDCxeGU+SSiG6ZwX/++edlFECbs2Wx5M+xcGpzxXoZ4I66z5PC+D5P6WAJ
+GT16tGmRMPO96n01EqP+jurvbPZrfCn42t4EhnsT1Ju7rwnnm/njYcOGWT/PeXw1g89XCfhvw9v7
+M888A8H3keAbvU7uCL4n+5/Z5zazbzg7Nvha8Pk4GhwcLLebDRvWuT060ReCb9Rg62yCjtkG2/jk
+vfSnP/+VBvzrDTJJwf8++fwwWpaU4naDrfp31k7QcbfB1tkEHfX5XTXY6k3QcbfBlgX/p6NnOQi+
+s1G7XST4ajzH7GjMEpvqfdvFfLcFWZ2Dz5fYeA4+z6fVTtFh4edJN8yIESNsIj3eCD4/N79h8IbK
+3fc8RUcb/3FH8I1GY2pXrlXl/tcld1BcmRD7ylHW0ZgWuX/XJ4JvRHz8aln1Z9HnkyqW/aysTAh0
+F8FLsJeV5FJ+3n65NPvulCS5VHvi2lhavjxSirs6no3FnfcTHie7bds2Odc5KytLXhKur6+Xcq5O
+cPD2xm+U4fNni5PttG41RScqKkpOyuDjCFf2tFN0WC7USqKriS0dcT8lJUVO57CPEZgRCTPfqzcN
+xNUUHb2v8aXg843jE/zY448/7vCc7r4mnMHXNgnzjV9jHqrAfxu+eslyz5IPwTefwXf2N/fVFB13
+X2uzv4PZ/cro2OBrwbffhlasWE7FxQUdvm24arA1M0HHVYPtWiH3N9/yPfpft32fwmPXyQk6c2PW
+0vduvY2+Kx5fuinZdIOtVvA9b7B1nKCjbbDVCr5Rg63eBB13G2xZ8LnBlgX/J6Nmmh6128mC721z
+bYHHgu8vsDTxwcd9wddrrtVW7y0r1w4sv53Wlj8vxH60zcq12up9S/nbnfImw3n91157lW655Wb5
+LyI8PhT36lIqKcqh3JxMIe67KXnnZtqatI7WrI6hyMhFNGfObDlP2bLiYphszOLc5pYtW6ziztVP
+FndfSbu7tyO5e2nlyhWYg99NbmabDzt7rnx3u/UkwcfNP7ahjl4RWRV8owbbRh802LLgP/3iX+Tx
+44vAGTYTdD6dPE0+Pvi5YdYGW/VYo22wVR9jwdc7aVPz9/aP9+GRu4OepnFC7NUGW/Vz2gk61klM
+ERt0n9++wVZvgo67DbbaCTqcv9cTfKNRu10g+HbNtWZHY15qr963XczrVlLPcR+O57BU2cd/zOI4
+GnOcQ/Xe2cq1UvCV6n1nCb5KRkYqDRr0hMzss/RD0I0pLy8U4p5L2Yf30b6MZCHuSbR+Xbwi7oul
+uKtLpfPiKDx7mcWd5yNzfwdX2ysrK6mxsVFeyvXnW9PJOpo5MwwyA8GH4EPwcfNiG+roxdL457lq
+sD3mVYOtZYLODTfeJI8f27IKbfL3G/ZbhJ7jOmqDrXqsURtstYKvTtCxjha2a7BVH/+PZ/8qG2wf
+//PL8v4fxL/2gq9tsNUKPufv1ft6Dbb6E3Tca7C1n6BjJPhGx5BOFvwTOs215kdjtgt+rhCh7iP4
+48ePl027/fv3l4teaUdumqG8rNhJc2179d4i958ocm9cvW8pf6tL3mQmTPiG7rjjdsrMzOh14l5R
+XkxFhXlC3DMpPT2ZdmzfLMQ9QZx5L6NFEQutjakcHWNxj46Olvl2FnfOt2vF3UzcoTvczp09RRMn
+TpRvTlyBKi0thMx04I0jEHq4+/3efI23/wcIPvYJ3By3odWrYztF8O0bbPUm6LjbYKudoMPxZRZm
+vQZbOb1KfF5tsLVEAK+1maCjFXxusNUKvrbBVn386+WbZP7+K/GvnKZ18/esE3QsP6+vTYOt+n1q
+g616377BVm+CjqcNtr+wa7D1Y8H3bjSmRfDzqO1CLtXVFHfbmI671FVkKILvRfXeRvDf7LI3Gc7n
+czW/U9+8Kkrp1Ntv0rkB11OjkIna116lah/FhaoqS6ngSDYdysqkzH1plLxrO23YkEhrVq+ihQsX
+yFz7hAkTZFMUN6ayuPMqyByTYXHnmAwvYW7UmOpP1dmOfqNatSqm0yRfHo/aLguaLVy9qHBBcF5w
+jr5tPatwun0VbptJYMoVSWvRQlO4sB7b1OObzjHOWsiwK2bI451a0Gi/asnHvbYLOYJswWEL57MU
+DgoOCPZT27lMhb0KGYI91HY2XZAmSBXsllw9kyJIFuwS7KSrp3cItitsVdhCV5uSBJsFmwQbBRvo
+6ilmvWCdIFGwlq6eTBDEK8QJ1tDVxtWCWMEqwUpBDF09sUIhWrBcEEWtx5cJlgoiBUssHFssWCSI
+ECwULKDWhnCF+YJ5grnUenSOYLZglkIYtdYzMwTTBaGCaYIQaq0LVggSBCqrhE/RjCJW+53srprK
+wop67LWPR2qOwdbj8Mc6xZYP/Frwbbd9vW1e7z3cyfu400Kduk2r2/Mhg21ZbxvW23Z5m92m2WY3
+a7ZZu2315FqDbVS7fUbrb5c22+QCnW1R3Q5nKtugZvurU7c/dbtzskK9QZ8db2f221BMTHSnCb7a
+YKs3QcfdBlv7CTpqBX/74WKZv2fB5wWu1mfmy8ev/9cbrA22WsFXJ+i0C/5BG8G3b7BVH1cbbHmC
+Dt//zjV9rBN0VMHXNthqBX+kneCrDbZ6E3TcbbDVm6CjNtj+n/fD/FnwG9xorjU6KOTQhVN53aqK
+7w1nqxe72Om11Xt7wbdtruXqfXPJ2132JsMCx1X8zozqSLkXO2GjoF5QyU3QQvKNl+WuooryEios
+zKPc3Cwh7uni/7uDNm/aQCtWREtx51y7Ku6cb+eJMs8995yMYP37v/87/fSnP5UNXzxOVF2oyBcC
+7m7zZHcS/M7IkuoL/iWN3F+wCI5Vcs5oREddx+OkXT+RVnjspaf96mT7MU5znLMKkFrMUI93BZpj
+nuWqZbsM6QnRQYsQWaVon0aMMhQxshV8iyClKIJkL/gaUXKQpY0aYVqvyL0qTQkacYpTxMlI8KOt
+EmUs+IsMBF8VKj3Bn6kR/OkGgqXKfaAiWVN0REtP8DXHXiPBtx6H9QR/lJ8Lvs5277C922/rtU5G
+XJfShdMlVFdb2mver8vLxO9buZ/O1a60O8EMcXpi6TSGa3elvrO3IVXw1QZbvQk67jbY6k3QefoF
+SwZ/bOB0KfjqCrYfT7Jk8P/z2T9bG2ylkH/nO9YJOhFb9tgI/kI7wdc22KqPfxO9WQr+l1EWeb/x
+llutE3T4/r+I51cbbN8Jj2tfldhO8NUGW70JOu422OpN0NE22Pql4M+YEUrH6gsNm2vNjMZsf6Oz
+vME1HT/S4w8WJyrXuxiN+blO9V59QxmlG88pSPtURiO66k2GF9D64ovPO+3nycq9Ru6LBLn9+onP
+lVNuzmEhlbtp3bpEufzzrFmzZFSGK+8LFy60icrs3buXiouLrRNl7MW9IyW5owXcXwS/o7OkrgX/
+vBPBt6/e6wl+vaHgO1bvy5xU7wtsixoXdar3hhVPe8HXVj7TjKv31iqofSVUW73f5KR6v9ZJ9V6t
+jq50Ur1fpsi9XqVUqZbqVUytVVP7yqlWrlTB0pMstYqqV0lVCyvqsddO8OXxVz0G6xValGJLtxN8
+M9X7epfV+6YTvUfs9Wis2mx8culh9b6rBF9tsNWboONug63eBB1ewTZul2WKzvdu+z7NW5koBT8s
+ag3dcuttdJN4fPGGZOsKtt+/07J68diwBbQ85RD9v2detL6Pcf6eBb9f/+ss41JjNtmsYKt+3e+f
+e0lO0PnDC8MtmfwXRlgn6Hz3tjvkY3/+dAqNjtxEP/3DkzaCz/Pv+/TrL+//depi3Qk67jbY6k3Q
+sW+wffA9PxT8tQlrKHnHBuXg4NloTIdLeuLN7cLJbKqrKRIHkdIeVAEolrGcc9WROmf1Bju9qeq9
+JZ6zNCJQTljpqjcZzuKPGDG8035eoxB8G7kX7O/bV4o8jzbjuAzPOK6urvYqKmNGknl02z333CPH
+Bzob5WZfpTfz3OosZh7TxiNZ33rrLevS7eqNm3J5lJv68+1HuWnHG/JouPT09B6VJbUV/A6K51z2
+Np5T4GU8Z5+X8ZxtXsZz4rpBPCewS+I5fEz2a8F3Wb0/ZnICXhldON275V7lXO0KnW3P8+o9v9d3
+peDbT9Bxt8FWb4IO5+/TlQWuVu/YQ089P4z+9cabZCaf/x387IsUuSnZ2mDLgj8xPIru+uEDsopv
+//7Fgs8LXP3t3U+p/3XXWx9XV7B1XJm6D/1y0NP05YqtUvB5BdsR46bT//rBvbKKb//16gJXv/vb
+P6mvchLBjPCiwVZvgo5eg+2D/ljB5xGJLJV1VTkej8a0rWJpq1faNzajrJ79m5g2p6e8cVnftPQy
+epo3Kc2bk2M+z0w2z+7NxyGXp+745kZj6lfv9Ztr0zZPkGK7eHFEpx4gGpI2UvPjf6Crt95Kzf37
+U+Htt9Oxjes6ZdurfftNG7k/INj57LN08eLFTq2Cs8zLisPYsfK+ugqn3mIs77zzju58cVeyzOs3
+8C0+Pt66wqf9CcCz4nfnlR71FmPhkwL+udu3Wy5R8gqNnSn4HZ0ldRR8xHPcjuec6g7xnBlexnPG
+exnP+Ug3ntM9BN+geu8yYmtbva+r9V/p5mMhD77wZNFJ93vo9jnGc7yo3vP21VWC722Drf4EHUuD
+rdkVbFnweQXb1Rl5Ng22USmHlRVss1yuYKu+302RM/CTacIaywq2aoMtC77ZFWz1Jui422CrN0HH
+qMHWLyv4zL594o8bEiJXyDxel6dzYCgzaK41asgxaMbRfTNz1ohj34Rj92blsgHHWfON/ZuQUeON
+447vq9GYzaXvUUH6GFq2KFDKfXj4PIeNoyMPECz33w64ni3Slj7X0LHE+I6fGV9RSmVC8vPE/yGz
+Tx/a+vTTdLUDRki6yslzxZzvq1V1Z8up2598eJLBl1MBbrjBel9dTr2urs7w/64u9a4+xlcDeuJE
+kfvvL6fU3Zf14znW6r2n8ZxaL+M5R7yM5+z1Mp6zFfEcl/GcsQ7xnEHN91Ly0ZecxnP8WfDlPpFy
+Xqd63+h29Z63bW+r9+rilLz4JC9OGRgY6DPp5tVpt27d6nQxS19ekTcu4tm+zw9qvp+SG15xWr3v
+KsFvab1qI/juN9g6TtDRNthqBV/bYMuCr65gq07QYcHnFWy1Dba8gq1F8C0NtuGK4Ns32GoFX22w
+5RVsWfDVBltXK9hqBd9+go7ZBlszE3TsG2x/MirMPzP42ko+NyryOED+T4LOgTP3fAVFr3LvbKEE
+X9D82O8c5V7h8q8e7fQqFY8p7Yocu9GKhhyHcfUcrp47NTVVruh53XXXOay4aOY5OmK1RX8W/ICA
+VkEz/XHQecrYc97NeM4JL+M5ZV7Gcw55Fc9pr957Gs9Z72U8J9rLeM48v4znBLSK/aU5gAadupfS
+av6uG8/xheBrr4a23XgjXf7tb3xyNbR9nzhLGemnnDTX1puanOONFCckJEgJ51W1+X5GRoZcbd5X
+0t0ZlXubhSpNVu+t21DTDymt7hXDK0RdIfhtbd/Kxa44g3/GzQZbvQk69g22qQUWwecFrrQNtly9
+VwVfnaBjWcE2z9pgyyvYLtOsYLtQEXz7FWxZ8HkFW17YimHB5xVsxysr2KoNts5WsFUn6LDgv6YI
+vrsNts4m6Ng32D7y4Wz62Yez6GGlgu/Xgq+FG+r0ZBN0Ph3Z3MhvREaCz29QnS34p06d6hLBV5dR
+V6vkzir47j43L43On2fR5xs3ANt/j1rBr6mpgeALkQkIOC84LWikJ4c0Uuru04jn+CSes8a7eI5V
+7v04nmOt3msEX4hZwHnBaUFjAA2pv4+Sq//iMK7Ym22+I6+GOu4Txyk1+YRH1XtvBf/JJ5+k0NBQ
+w89zkWb48OGyoMHwx9r1ZeQIxKlT5TGXc9wPPfSQHE+sfk6LvfBzzJHXq+ErBxzjGTNmjNcnBGaz
+947b0P1iGxrucKW+KwRfd4Sq4Umgdhup8miIin4M275wkWoQw95mEMM2GJVqf6xyOiZVL4ZtfyxS
+j0NG41EN4lkmh6h0C8E/fPggRUdHQbD9gOzsg71G8DtqhVdXQjxu3Dj5ec7e842z+EYZfHefm6td
+/HluFma5Hz16tMP3qBn8559/XsaE9DL4vUfw20UmIOCYoE5QRX8cVE2pKY0u4jnHvYznlHoXz/Fo
+9j3iOR0Zz5GCrxGzgGOCOkFVAA0qu4eSy4f5RPA78mqo8T5RSam76tyq3vN27Y0QDxgwQIq2s9Xh
+eSRxdna2ZPDgwTYrxPNxa+jQoXTw4EEqKSmRx9pHHnnEsIKvvT9y5Ej5fLz6PD83n2x4L/jmsveG
+21D5vZRc8VIXC7598UNvwtJRt4aoXGgqorqakh7VjC3HpFZk0rnaGP3xqE5j2Hq9F44j0LuF4DPp
+6bsh2F1MSsrODn2N/S2i05WjJlnu1Uq+syk67ub7U1JS5NQb+3iO/XPx1CCeosNfx1V/+yk6vUfw
+HUUmIIDf6IsE+fTkkCLKSD/mYTynxst4Tr6X8ZwML+M5W7yL55iq3i/3oLnWbDxnepdMz9ETs4Ay
+QZEgP4CG5N9LaSXDvNrmO7JY4nKfGFxAGamVpqr3vE13ZITmVvF32L17t/U+f8zVdu33ayv6LPlc
+yTcj+Pzce/bssd7nj70XfHOTc1xvQ/dRWulLbm1Dvoh06Y5QNVW9Nx6i0nSipMdPWZJjUjtgiEq3
+EXy1ks8REc6BQ7g7B/5b89+8Iyv3/tJki+XYu8+S674QfF4sKzJykTh5mihXTuZ1F/7rv56i34o3
+tgcf/LHS7GwsMgEB2fTowHxKiKvpmHjOpa6O5yR7Gc9Z52U8Z7mX8Zy5XsZzpvo8nsMVNmdiFpAd
+QAOzb6O4wqflNs8REC1GJ/D2NBjIPXPa5HMY42qfyKWE1aWmV63tyAq+nnA7E3j7x5wJvqvv9Vjw
+TUzOcb0NfZ/iiobKbejll1+28vrrr8vjGx/n+HjHx73Q0GDaMS2Y2q73/r3X+QhVu+Oh4RWe9mPf
+hdPFvWaE6rma5T4fotKtBB/0fGQV4bHf0YXrrqNL/frJyn1nyz0Ev2cKfn5+tpT5IUMGUz+xbT38
+8EM0dOgz9Pbbb8rH+Y0uJmY5xcbGyBWUMzJSDUXm0YGFtD6xnlqamxDP6bXxnG/cjudIwTcQs4F5
+36e1xc/QpYp35FQz/43oGO0TR2j92gpquVhrsnrvveBzRMZZBp+r7GlpaU4r+J4Kvn0Fn3+O94Jv
+bu698TZ0O60teZ4uVX5greAuWbKYwsPnW4mPXy22pUh5vPv44w/plVf+QQe++12fbC/GI1SNGrCd
+V+95ZePesg6CHJPq9AqOfSFBf3KStmkfgg/8Ej7o8EJXXTnrGbfuK/j2l5sr7r2H/vPmm2XVKiIi
+nLKzs0zKjK3IPDqwRIh9gxD7015Oz+mMeM5BL+M5u7yM5yR6Gc+J6tp4Tm3HLG5lL2YDC4TYlzwr
+xP5dm0UH/bfJ1n6fKBZiXyXEvt6N7H1786S3U3RYtGNjY3Wn6Kg5ec7Ic1ae8/j2GXxPBZ+fm3P3
+/LzMU0895b3gm5x777ANFQqxL31BiP2HHlVwfRXpMh6hesKgAbvaaXOtN9V7HpfK/RVGn+d1Xvhr
+OntSkvMxqUZXcIwWNnM+Ah2CD/xW8L/44vMuXszljHOB063M1ph+Y7OVNfv1Gw67zk/bRCucrTi6
+VX9SQNMGnWkBeus6xBrGJxwrqy4iE7oTBKa7XKbd3Sypntx8e437cqOKzG9+XUkJ8cep5fLZzpme
+0ynxnD3exXOscu9pPCfWy3hOhJfxnFAv4zlfux3PkYKviNmvS+6guLKhQuzft5meoy466JMxmY/9
+jtpuudmSqfbR1dD2faKcEuJqhdg3mJ+c47BAZaHXYqTOwed+IZ6Dz6O1tVN0WPh50g0zYsQIm0iP
+N4LPzz1s2DAZ+eEVwXmKjjb+45ngO6neawXfug3dSXHlLPb6qyJ3tuAbj1B1NT7V/tjn/dUd7qfg
+/jHtFRzt1Rb+HH+NP1XxLe95RtuA3sJmn+k217q7GjYEH3QqXL1/4YXnuljwT7uxFLuzioTOYkXW
+qEW+zurLRqO/Mk3MLd/lZLG2JLsF2zQrMp9yJmGOKzO7Fi/7iqqObNks5KYzRUBzqdId2fFlPOHO
+OzNp/bpGIfbnTM6+NxvPqUY8p6PjOdbtzdN4zhQv4zljHOI5/CY8sOz7tLb8OSFloxwXHFSq974Q
+/I5C7hNr66nlkrur1uovUNlTIhbJycmyb8c7wTeq3ttWbweW3yG2oWFiG/rEieCZr+D66pjpOEL1
+GKUmH3faXGvcn+H9yd/HH39sc8VGO12JP6d3EsertPMJG58Q8hUAvjrDj/P46J07d8qP9+3bJ79v
+//791tf+vvvu84Hgez8a0/L6j4LgA/+F88933HG7XPCsawW/yWDMl7PYRZWOsDmLWuTqrL6cZbAC
+s7NVmI2q9zpRilMbjGf96s371V2Z2Wh15oV2KzTP02ShjSqpIU5XcXRHdnw5QcQyFcJ+caszruM5
+1m3E03hOScfHc3w9+x7xHJfxHL0qq3Zxq+4g+HKfcGvVWv3mWvWEtTtLPYsiC2BWVpZD/McbwXdW
+vXfeXPmhRxVco6uebd/5DtXHr/F+hOoT6ghVo5NAnRNAH1zd4WjWzTffbJV0Ji8vT/Zh8OfsBf/9
+99+XryOPTS0uLqa//OUv1sjX//zP/1BwcLD8mNdO4OdQ7/NVo1deecV7wXd7NOZnhid37ozaheCD
+Toc7/UeOfKMLBd9VNOeoyWhOqcloTra5aI5N5dVeyoziFPaVVicjDG0ErGujOapcdb3gn+u8xa1M
+xXPyOiGes9PLeM5ar+I57SeRnsZzZnsZz5nsZTznM4NL6MobsV71Xonn+L/gn/BJ9Z635+48JWX8
++PFS9Pr37y+nHGlHbnqUwTa6UuS0emskeO+7PyZTE+mqufce+vv9P6QBQvx/9atHrVN3wsKmW4cR
+8CQyLsYxmZkZJkaoHqGM1AqXzbW+Enzmtddek/Ep9T6vdcCyrhe7so/08MnADTfcID9eunSpzO3z
+x3wSoPZg8H2u9PPnvRd8Z6Mxv3Ly+jue3EHwgV+TlZUpq/hff/1l1wk+ojldGs1RKxldFdFxXJnR
+bDynAfEcl/GcVV7GcxZ6Gc+Z5mU8Z5zb8Rz96r1jPKel/G0/F3wz1ftKl9V73pZ5AaPeMinF+RSV
+DJ0rRZ5X7y+UfOCTbYgHErDMc2z2/ffflZPHeNQmw5EkFW52dj1CNUcZoaqzjXRQfIsnJ/H/j/P2
+DH+sXRvBvudC7ddg+D73dqiZfv5eruzzqsjqv+rjvsjz2x5vPBuN6clq2BB80CVwheDnP/8ZPSak
+jT/urJ9rmQZwBtGcDo7mDLr8I0o5/rZhNEcVK1802XoyQURuB7svGlfvPY7nVHkZz8n1/3jOScRz
+PI3ndA/BN6reO1/Yyn57vtB0pNfMOnc6B7060vXcczeq9/WHPqaJEyd26jbkcoTqBWfjUzsuvvWn
+P/2JZsyYIeFpR0aN01zBV3P1enDl/quvvqInnnjCep/jOup9Xwm+6xM858217k7iguCDLqO0tFDO
+Kr/llpvldJ0kIXAdv4KpZhpAWiOiOR0UzQloDaCA5gAadPpHlH70bYdojnqg82hMpjgpbP3ud+nM
+v/wLNT860KMJIu3bwXnKSD/TifGcYi/jOQe6QTxnpZfxnAVexnNCvIvnVHdcPMfvBd9H1Xv1ONh0
+vKBXy/2Jyg0uR2O6U73nbalwzxdyBfTOFXz7EapFmhGq2u3EeDSm9r3SV3/fxMREeuihh+inP/2p
+/NhI8D/55BMp6+r6BtxUy9Er9fOTJk2SDbgs+Xyf/+WI1oQJE3wk+Gaaaw1ef4erge9A8EH3iuzw
+whwc23nggQek9HMWsKKitAMOVHbTAAYfo9Rd/hjNSTYZzdmoE81ZazKaE20ummNTvXcWzWlvrGW5
+DzgfYF16fcjRH1NK3T8dDnSeyA5nQvnqD28zPtsOhhyn1JRTXR/PudAd4jkJXsZzlnoZz5nlZTxn
+kpfxnE89juf4v+CbvZJZ5qLQ0b4dXziVR3U1PPu8dyxuxJn7uoq9SuV+su+q96Xv0pU3B9KZ/tfS
+sT59aO+QwRS9MLyTBF9vhKrZ0ZglDu+Vvvx7P/rooxJXqw+z5HPkhqM5PH519uzZDouZbdmyRd7n
+f/m+3ihOTwXf9WjMMaaq9xB80C1hoU9MjJfixgLHTUC//OUvZHU/KGgqbdy4Tq5a6t2BymgaQIUQ
+/Wr3pkVo3tQuNBXIzGlPuiRdXlZCdZUH6FxdvJ1o2UckHBtrtXKvXZ1xUMUDlFz1mvVAZ/ZAxVOX
++KRvxIjhMhPKayl4cwJouB0MqhKif8xE9d7TeE6Rl/Gc/YjnuIrn1Hkbz/nKy3jOKMN4Tkv5W91E
+8OtMLmxlXL03F1E0uoLprMDh5OqlYXHDKJboqudovn4k0abfaJrOpDBzC1uZr96PEnL/KJ0T0tko
+qBdUClKE5HfGNmQ8QtXZSaD9NlLQIYLfHdDfBsyOxvzApnrvTpEAgg/8Fpa6yMhFUuaGDfszPfzw
+Q1L6Ga70c36fZ+pzgxBPAeCTAF6mOzx8rmweYpKTt1unAfCVAnPTAMpNTouwvKk1nSjq8VnTxupt
+BtEc/Tc6PbnXLr0+5Mj/prTy1+SBSl1qPSxsBk2fHkpz5syUDdg8aYknLvFrfeONN9KgQU/I19jb
+kzyL4LvYDoYUUUZandvxnPZtxtN4To6X8Zw0L+M5mzohnhPZa+M5/i/4R80tbGWyem98FXOfi/4j
+d3uPjKKJroYKuIolmokkuh4m4Gn1/kLJR1R/6DMZy+HKvVbuiwTZffvK7ScmJrprRqiaHY15yfYE
+sLcJvtNtwGxzrQd9PBB80O1gwdu+fYus6LLQc8WfBZ/HffGJAEuhOg3gvvvu9WAaQLGTNzTbitWF
+psJe00h2rna1y2iO+kbnTO4DsgNoYM6dFFfyF3mgevnllyWvv/46vfnmm/I1ZLlnyecTPI7kuNvA
+zd83ZcpE63ahbhMPPvhjuS243g7yKCGuqufFc6zC5MfxHGv13tN4TrCX8ZwvvYznvG8Yz2kpf7Mb
+CH69D6v3h31cvbefHOZP1Xu9UcAT6Xz5RKo+PImyd0+mPVsnU1L8FFq9fCpFL5lK82ZPpenTplDg
+1Ek0efIkOZ6TXwct3FDLmfuGfv1s5D6XF2RSBH/16tguGqFaa3o0pvYEsDc1X3Nky/gKjvnRmJ4U
+CSD4oFdhPA0gn9YniDPtC1VuRXP8aRQcZwq5MUhvmXafjHur3O8ymqNepjaS+4H5d9Lasr/TJXmA
+G+cT2eETPpb5IUMGUz/xJshXenjkG/dy8ON8EqjOd1av6BhvBwW0fm0ttVw64WE8p8LLeE424jku
+4zkzvYznTPQunmOVe/fjOd1D8P2xem8fz/FF9X6px9X7C1UzqCY7lHLSp1HG9hDasjaE1kQH0+IF
+QTR/diBND7VI+6RJE6W0cxNnYOBUCg4OEsejafJq5axZM2nevLm0YEE4LV4cQUuWLKJlyyIdtg2V
+PX962kbuDwg2KRGd9esTu3CEqrnRmJZtxHICWFdT3KvGpFqONd6Nxmw/jrwJwQfA3DSAQiH25ULs
+q91YyKW9GuFuJWLJkiWywYdn8d59993ioB/oswPJbbfdRlu3bjVsMvJFJt9VNEetYtnL/cDCH9Da
+8uFC7MfZyJRHU3Qe/4Nc9IoXbam49x76z5tvllX6iIhwOdvZs+2ghNYn1gmxb3SRv6/3Mp5T6F08
+x1q99zSes93LeE484jlexHNayvxd8H1Rvc9xMUGsa6v3tvGc9u3wQu1CqsmbTzl75tCOjTNpQ9wM
+WhkVKqQ9hObPCRLSPlVI+2Qp7EbSPmfObBtpj4xcbCjsbiOea5eQ/Oz+/WXlnuV+udJk29Gjpl2P
+UNU7CTTaRnJk43VvqeKfrV7sk9GYluPIW9RcgogOAC6mAZRRwpoqZX5vrU4V1tXUHPebhRISEqSE
+x8TEyPsZGRnW5bJ9QUdV7m2ahVxEc1SpUuX+16V3U1wlV+y/0ZGpL30yB//ba9yfg287FaKBWppP
+9ZDpOalexnM2ehnPiemEeE6YV/Gcrph9r1be/F/wva3e5/q4er/Nq+r9leMrqfbIMjq8J4LStoXT
+5sQ5tHrFTFq8MFRIewiFTgukqTrSPm1aiOwHmjkzzEHanVXZu4JVq2LkyOmO3DZmzAilY/WFhs21
+ZkZjtm8jlu2j6fiRXjAmdb2L0ZjOmmtH6cZzCtI+Nb0OAgQf9Cos0wCqqeWiqypsuU68wrHy6s7O
+zstfh4aGGn6el0MfPny4XEWP4Y+1S6SzwPPiG3feeSf16dNHzv/duHGj9XNa7IW/sLBQzv3lKwcc
+4+Elvj05IXAVzVEjEQPLf0CJlS9Tszyw6TUYfeW24PtyJVu5HSQeE2Lf1HGz7/XiORcRz+n4eE6Q
+l/GcL7yM57xnGM9pKRvpt4I/LSSIzp0q9bB6rxPP8ap6b9xce75hHdUWraGCrBjK2BVJWzdECGmf
+Q1FLZtG8uaE0Y3qwlPZJQoLUDLurSru/SbszuKGWM/ccy+HKfUfLPbM2YQ0l79igHAs9G43p0J8h
+to8LJ7N73AhVy5jUDDkm1fG9z2B6kqnqvaVIsDQiUJ6AQvABcJkzrTUZzdE5WIk3NHd2/AEDBkjR
+Nvr8G2+8IVfQy87OlgwePFg+phX8oUOH0sGDB+Xy2WPHjqVHHnnEsIKvvT9y5Ej5fLm5ufK5+WTD
+I8G3j+bU6zWY6U2Q0L9E6Y7scCzHSPA5ruP2dmCzuJV99d7TeE65l/Gcw17Gc3Z7Gc/Z4F08x7B6
+j3gOV+/9WfBnhk2nkw1HPKze53lVvb98KplOVCVRcc5a2pe6ijatW0LxsQspKnIuhc8PE9IeIgQ9
+0NqIytI+efJkCgqyyI6aaZ87d46cyOXzeIyPWb48Skp6YmICbdq0nrZtS6KUlJ2Unr5bHN8zxXH6
+EBUV8RXiIr+ZaMd/57qqHI9HY9oe54y2D6OTP6MTP4OrOg6RLf1+DONeDGeN1nbHH4cRqer7n29H
+Y/IxJG3zBHmVibdvCD4ApnKmOm9mutUqx4OVLyM0POVn9+7d1vv8MVfbtd+vreiz5HMl34zg83Or
+q/gx/LFngq83Hi7YIA5hf4BzvETZtYJ/2ongG8RzLnsbzynwMp6zz8t4zjYv4zlxXsZzlvTqeI4/
+C37UssWUnZXsRvXeSXOt2HavnjtIJ+vSqOzIFspMT6AdSTGUGB9Jy5fNp4iFs2nO7BkUOi2Ypk6Z
+IoXdWUSGpX3hwgUuG1H9Udr37dvjl9LuLvx7TAsJoe1b19Hxujyd7cToJNDoBNDg6o7T6JZRbEt7
+zDKKbBlNU3I2Scn+OGQ0RclxgpKvRmM2l75HBeljaNmiQLl/hIfP093+IPgAgm+YM3UvmqMerHxZ
+wdcTbmcCb/+YM8F39b3mBd95NEdf7r/Rr5KKg1xXRXTaBR/xHP0qWFfFc+Z3g3jORx7Hc/xZ8Hft
+2ibEey5dPldmWL2/dCafGusPUsmR3ULaN9L2pNW0Nj6KViyPkN87e9YMIYHBNGXKZJowYYJV2jla
+GBwcLCMyLO2zZ8+iefPm0IIF82nRooV+W23XSntS0ibasWMbpaamOEh7dXV5r1mbZsWKaHECNs1h
+nCfoOPgEmE969Sr36nYKwQe9nvvvL6fUXce9juao1Sp35JgjMs4y+Fxl1y6NrVfB91Tw7Sv46tLc
+7gu+uWjOoOYHKPnYa8bTAxSB8kWTLfVxv8nWVvDdiefUehnPOeJlPGevl/Gcrd07nlPfGfGcsd7F
+c6xy7xjPaS7x3ybbqqpyWro0UmbVV6xYRrGrooWAzxVCPl1GYdR4DIu7pdIeSCEh7ZV2lvb589tz
+7UuXLvFbaY+LWy0z7HrSnp+fQ8XFBb1G2j2F/37dpW+hp2M0JhWCD3rZFJ1WQTP98Ykmykit8zia
+owqZu1N0WLRjY2N1p+ioOXnOyHNWnvP49hl8TwWfn5tz9/y8zFNPPeWF4LuO5gS0BlBAcwANarqf
+0upeM5geMMazMZmP/Y5av/tdOvMv/0LNjw50W+6tUyGOlnVAPKfMy3jOIa/iOe3Ve0/jOeu9jOdE
+exnPmedlPCfQr+M57kzA6Moq7a5dO2jnzm0yFsOVdn+Px/AkGSNpP3z4IKS9A+C/a3R0FATbD8jO
+PgjBB4DlPiDgvOC0XM10yOB62r2zyu1ojlptdVeQ1Tn411xzjZyDz5c6tVN0WPh50g0zYsQIm0iP
+N4LPzz1s2DAZ+bnpppvkFB1t/Me84LtaudEiUiz3AecFpwPkqrZDjj5AyTX/7dC86Ek1k1e2/fnP
+fyZXMPZqKsTOzYjnuB3PWeNdPMcq957Gc2Z4Gc8Z3wnxnHcc4znFb9CVN/+NTve7lo6J/W7vkMEU
+rcww9zfB17Jhw7ouk5YVK5bbSLvahLp//15Iu5/ArwcEu2vh/cLQd7CRgt4l+O1yr13NdNATZbR7
+R4l7Y+CEjHXXUV7Jycl01113eSD4IU4bGdUqqVbutavaDir/ISVXvGyNPpgVfK4q8mq0I0YMl1dB
+vvjic6qoKPV+KkRNoX/FczyafY94jr/Hc1juz4kT7kZBvYBXJE1RViH1Z8HnMYy+lBGu+KrSvnVr
+kjgO7ZA/g0/auQrJ0l5SUkCVlaV4v+pGlXx+PTn6BOHuvJgZ/82NKvcQfNBLBd9R7tXVTAMC8mnI
+f+bSnpQC04u4dCep57gPx3OysrIc4j+mBd9wJJitROnJvbqqbUB+AA3Jv5/SykZIwecJGQyPuuM8
+75w5M+nrr7+kkSPfoP/6r6fogQceoBtvvJEGDXqCgoKmCgnI9t1UCCH527dtpONHS9rlvkPjOfle
+xnMyvIznbPEunmOqer/cx7PvZxk31/p5PKe59G0qSPtMVu61cl8kyO7b1+8Fv6KihBIS4lzMZV9h
+bUTdsqU9HrN3b7q1EZWlnZ8L70EAdKLv4I8Aujtc/YmPX00REeFSDN9//10aNuzPUgh/+9vfyDgH
+V6sZZ3IfEJBNj/7yMCXE5jmJ5tgu4tKdFujgBjlu2u3fv79c9Eo7ctPsAh6uojmqQDmT+4DsABqY
+czvFFT0nBf/ll1+WvP766/Tmm2/K147lnl/LyMhF8vXFVAjQnSdgNPTrZyP3uYL9iuAbTcDwF6qq
+ymSVlqMxzIED+6zTY1BpBwCCD4APqkmltH37FpoyZaKMavzqV4/SLbfcLCMbv/zlL2jo0Gfotdde
+pdGjR8lKL8thbGwMbdy4jjIyUiVGcv/oL3NpffwRunLOXDRHFXxeha+nL7etUlexz2U0R40/GMn9
+wPzbaW3Jn+mSUhH1p4kimAoBOoo9f3raRu4PCDYpER2jCRgAAADBBz26Os+yzvLOMs8iz9XdsLDp
+lJS0UVZg3Yvo2Mr9o78sEGJfKMTeKE6R62SFxgN04eRhKi/vHYJ/rma5iQWtLPEHe7kfWHgHrS1l
+sf/EJtPsT4KPqRCgw4hcTLuE5Gf37y8r9yz3y5UmW1c5WgAAgOCDHkNUVKTMXw8YcL2s1nM1vrS0
+0AcZfIvc/+bfSyhhdbEQe7PLr9tGc7T56KZjuT1e7k9UbjIVzVGzzarc/7rkBxRX/qIQe/2GRX+b
+CY6pEMBfJmAAAAAEH/QYOFLz8MMPydw8V+l91VCpcuedmbQ+vpSunNeZduJGNMd+usmFkxzXKehW
+mXwzmXuO5Vgq90EmqvftjYsDy++gtRV/oUuyWdFoWe6P/HLRH0yFAP4wAQMAACD4oNvD1Xmu1N93
+372yWt9RP4eF0nbmfbHJmfeHXE83sRtbaDzRxH4Wuf0c8nWaGeSaEYVOp5do545HulhQSDOO0GFS
+yQyDGeP24wf1ozkOU0mczhMf7beregIAAAAQfAC8gKv0nK1/4YXnKDs7q0N/lkXwtdV7+znlBiMM
+7RcfchhdqB1bqJ1J7mRcoc1CQxtcjCjUzh+3l3uDsYT288Yd5F47ilA7hjDUxYJWkw2jOfozxfXk
+/kMIPgAAAADBBz11Mo7aOOvNwkVuCb5hNOeIuWiOVfD3uphJrq3e28t9kkH13n6BIXu5X6VZWKh9
+1VDjFUPtFxMyWCXUYca48wWtjKI5TueJ2y8UVPEBBB8AAACA4IOeBo+0fPzxP3TazwsJCaKzjTmI
+5nRxNAeCDwAAAEDwQQ8kKytTrlDKs+0762fODAulxvosRHO6OJpjWQF0FAQfAAAAgOCDngQvWDVk
+yOBO/ZlRSxdR9oGtiOb4LJrztclozsc20RyW+5aK9yH4AAAAAAQf9CR48SoehdmZPzN51zaKXCxk
+90KBi2jOYZPRnHST0ZytjtGcJr1oToJONMdV9V6Re5vqvbNozmyT0ZxAk9Gcr0xGc7TV+/cF70Hw
+AQAAAAg+6Ek88MADcjXazvyZVVXlNHfObIpaGkH52TvpWE0mXT6T7Vi9l3KfZTKak+oYzXFZvVfl
+fr3JaM5Kk9GcRSajOTMdozn1etGcKTrRnPHmojk2jbUfOlTvIfgAAAAABB/0MO6443bKzMzo9J/L
+kr9r1w5aujSSpk8PpfHjx0vRVOH7U6ZMpumhwbRg/kyKXhZOCWsW057k1ZRzIJHOHE0xGc3ZbjKa
+k2gymrPCZDRnoWM0x6axVpX7GTrRnOBOieaw3LeUvwvBBwAAACD4oCfRr18/KizM7/L/B68qqRXM
+ZcsiacmSRbRw4QKaN28OzZo1k8LCZlBISDAFBgbSxIkTpZhOnjyJpoUEUvi8GbQscg5tTFxMKduX
+U1bGKjpWvgHRHCfRHIvgvwPBBwAAACD4oCfBq9YmJ2/v8v9HamqyR0vO80lARASfBMyl2bNnyasB
+ISEhFBQUSJMmTZLyOmXKJHklYP7c6RS5aBatWTmPdm5eTLn7oulY2epeG81huYfgAwAAABB80MN4
+7LHfUUzM8i7/f5SWFtKqVTEeSb6Zk4AFC8KtJwF8JWDatBAKDJxqvRIwadJEeSVg/txQWrpoBiXE
+zqbdWxdQ7t7FVF8YSZcbontcNMci+G9D8AEAAAAIPuhJvPLKP+iLLz73i/8LS35y8g6Kj19Dq1fH
+UnR0VIcIvx6RkYuVONBcmjNnts1JAF8J4J6AyeIkIHTaVJo9M4giF4VSwqowSkmaTbkZ86gqdz41
+1y8wOfN+hsmZ95PMzbyXcv+5yWiOtnr/Nl0oRgYfAAAAgOCDHgWPyBw06Ilu8X8tLy+hkpICOnTo
+AO3fv1fGenbu3EYbNqyjtWvjafnyqE45CQgPn29zEsBxoMmTJ1tPAoICJ9OcWYG0dFEIJawMpZ0b
+p9Oh3dOpPn86Nddo5d71zHuL3E8wGc35zGQ0p716X581Wl7FgOADAAAAvUDwa+uqaXNSEs0IC7OZ
+bgI6lsmBwRQVE0X5+Tmd8jpnZKTSLbfc7BeNtr6gurqciosLKDf3kDwJ2LMnlbZt20KbN2+kxMQE
+iolZ0eEnAYsXR9icBISGTqPg4CDrScDEiRNoWsgUmhU2lZZGBNK62GDauSGIsncHUl2OmcZaVe5d
+Ndaqcv+Brty3lL9Fhemf0ZQpUyD4AAAAQE8X/MLCApo+fTrt2pVMRxuOU8tVoiuCy61EzYJLLUQX
+BReuEJ0XnLtMdFZwppnotKDpEtEpwcmLRI2CExeIjguOnSdqEBw9R1QvqDtLVCuoOUNULag6TVQp
+qGgiKheUnSIqFZScJCoWFDUSFQoKThAdEeQfJ8oT5B4jyhFkNxAdFhw6SpQlOFhvYX+dhX21FjJq
+LKRXW0itspBSaWFXhYUd5Ra2C7aVEW0VbCklShJsLiHaJNhYTLRBsL6IaJ0gsZBorSChgCheEHeE
+aI1gdT5RrGBVHtFKQUwu0QpBdA7RckFUNtEyQUT6KQpbnUaBwcFSTjvydW5I2kjNj/+BTvbtS1eu
+v54u//Y3dGzjul6x0/GVAD4JOHgwk/buTaeUlJ2UlLRJngR0VC+A9iSAG4Pnz59n1xOgXgn4hiZM
+GE/TgifT/Dl8EjCF4mMmU2rSZMpNHU+VWV/T5UrvojktJSPpypu/oNP9r6VjffrQ3iGDKXphOAQf
+AAAA6ImCX1dXI+W+sqqaWttIckUR/GZF8C8qgn9eEfyziuCf9kPBP6AIfqYi+HsVwd+jCH6aIvi7
+FcFPVgR/p0bwWe63KXK/RZH7zYrcb1Tkfr0i94mK3Ccocu+u4C89TBQpCE9uoKDgoA6r5LPcfzvg
+eqKAAFv6XEPHEuN7/U6pXgngvz+fBKSn76YdO7bRpk3rO+UkoH1E6Fw5InTGjOlyROjUqZbGYD4J
+mDplIoUET6LwOVNoReRkWhM9kZI3fEPFe8dSffandLncOJrDcn9OvN6NgnpBpSBFSD4EHwAAAOiB
+gp+UlES7kpPpqiL3Zqv3WsE/pQh+oyL4xxXBb1AEv14R/FpF8KsVwa/0Q8H3tnofp8j9akXuVyly
+H6PIfbQi91GK3DNLDllYGLdJyNayDnmdmx/7naPcK1z+1aPYMU2eBBQV5dPhwwdlHEh7EhAXt7pD
+TwLa1wkIt64TYH8SYJkONIFCgibRzOkTad7sSbRg7mRJU79rbeS+SJDdt6987piYaLy+AAAAQE8S
+/LCwMGo4dtxtwfdVPIcpVwS/VBH8YkXwCxXBP6IIfp4i+DmK4B/2Q8H3pHrPcr9YEJF2goKCgjrk
+db56662Ggt92443YMTvgJGDfvj2UmppicxLQGY3BixYtpPDweTR37hwrDf362ch9rmC/Ivg8wQiv
+HQAAANCDBJ+rfm3fUpcJvrfVeyarhwj+oiySrwev8pqdfRCC30MpKyuiwsI8a2Mw9wNs25YkTwJY
+tjviSsCePz1tI/cHBJuUiA5vb3hdAAAAAAh+j2mw9UfBV6WMx0IiotM7qawspSNHcnx3EhC5mHYJ
+yc/u319W7lnulytNtr7czgAAAAAIvh8JvqsGW28EP0BIJNMVDbbqz9ar3utN0JkRm06Dnh1B1w24
+gfr06Uu33nkPvfDqRxR3+Lxug21HCj7jq0q+UZPtt9egyba7UlFRIpuCc3IOUWZmhowD8ToB6kmA
+mRGhvMgYPw/+ngAAAEAPE3xX1XtnE3TMNNj6q+DrVe8f+fXj9M2CdbSx4AptLGqlv745Vn7/75/+
+m0P1Xm+CjrsNtq4E35fxCTkm87HfUdstN8tYTsn3b6OQF5/HTtkLpgPxlYADB/bJqwEqeXnZ8vP4
+OwEAAAC9UPC9jedoBZ/lXr2v0qdvX/rR/3mYVm1OtzbY2n/Ntdf2oxeHv06H61qtgq9+Tiv46mP7
+ah2fg3E3f7+pqE1+X1/x830dz9FO0GG51xN8bsrsqNc+NjaGHnzwx9gpAQAAAAAg+J4Jvlq9V+8P
+f/UtKjnRSssStsv7d997v7V6r37NK29/JCv4I0d/Ke+P/GicdYKOK8H3pIJvL/gz1uyT33/73fd3
+eP4+QkfwO3JGOa9mO2DA9chgAwAAAABA8H0j+LnVZ63xHL5/zTXXOAj+3pImGc/ZW3ZW3r/19jut
+8Ry1sq9tsNUKPjfXeiP4C5KO0Pduu1N+/1fz1/U4wWeGDn2GQkODsWMCAAAAAPQkwbdvsO0swdfm
+79XH7AVfm79X4zx6gn/ATvD36gi+/QQd+wZb7Qq201am0r/edLP83ncnLOiUCTpdIfhff/0lvfTS
+X7FjAgAAAAD0NMFXq/d6E3TcbbD1peBnlp+1qeB//467bAT/O9dcYxX8lOLzhoLvTvV+3Ly1MnN/
+bf/r6Is58VLu9SbouNtg64+CHxERTr/CmEwAAAAAgJ4r+N5W7+0n6GgFv9pO8LUr2BoJ/qvvfCIF
+/41Rlmk2/xz9pVXwf3Dv/fKxeau2U2ZtGz0//J8Ogt//+gHy/rqsY6YE/93xc+XXc/V+2qp0n82/
+15ugY99gu/Bg5wt+RkYq3XHH7dgxAQAAAAAg+OYXuNIKPo/H1Aq+Oh5TK/iFjfqTdl4Y/jodqmu1
+rmC7ZF06PfDgw7KKb//1quB/NGkuXT/gBuvjrgRfb/KOSkfHc7pC8CsqSi1XV7BjAgAAAABA8Dty
+BVtVqt1dwVY7A58Ff4+yiq0nE3Q6cwXbiC6K6GRlZdKtt96KHRMAAAAAoKdN0enOgn9AI/gs9+oE
+nQxF7t1psO1tgp+UtJEeeOAB7JgAAAAAAD1J8L/9lqyS726DbUcJPk/HYTxdwdZZ9Z4baPVQJ+hs
+UeR+syL37jTYuiv4MoPfhU224eFz6fHH/4AdEwAAAACgRwn+1fOCc/Rt61nBaUETfdtyUtAoOCE4
+Tt9eaRAcFdTRt5drBTWCKmprrhRUCMoFpdR2qURQJCiktosFgiOCfEEutV3IFhwWHKK281mCg4L9
+1HYuU7BXkCHYQ21n0wWpgt109UyKYJdgJ109vUOwTbBVsIWuNm0WbBJspKun1gvWCRLp6sm1gnhB
+HF1tXC2IFawSrKSrJ1YIogVR1Hp8mWCpIFKwhFqPLRJECBZQa0O4YL5gLrUenSOYLZglCKPW+hmC
+UME0aq0LEQQLAgVTqbV2smCSYCK11EwQjBd8TS3V4wRfCr4QjKWWqs8Fnwk+pZbKjwUfCT7skjn4
+U6ZMxI4JAAAAANCzBF+V+zOK4J/SCD7L/TFF7uuF1KuCX60Ivir3ZULq2wX/QlMR1dWUUHl5GZWV
+9QzKy0qoriKTztXGKIKvyn2QRfBr2wW/Xe6/UQT/q3bBl3I/RpH7TzSCP7pTBT85eTv169ePMjMz
+sGMCAAAAAPRMwXenem8v+KrcF1PTiZ4l9no0Vm3Wqd5PUQTfrnpfY65639mCP2jQE/T2229ipwQA
+AAAA6HGCb1O9b9Kp3iuC71C9V+M57dX7C6eLe7zcq5yrWW6yej9Op3pvL/ijqaXig04TfBb7hx9+
+iEpLC7FTAgAAAAD0TMFX5N4az7Gv3qvxHOfV+7raUr8R8NmzZ9P3vvc9OY2nI56/rmKfTvV+kk71
+Xo3n2Ffv1XjOh50m+Pn52fTSS3+lX/7yF5SdnYUdEgAAAACgZwr+Gf14jrZ6f8Woem/bXOtu9X7J
+kiX0k5/8hK699lq6++67KTAw0GcCftttt9HWrVut930t+uVlxQ7V+/Z4jm31flDzDym54WWn1fuW
+ilEdKvhRUZF033330rBhf6bCwnzsjAAAAAAAPVfw7av3jQbVe2fNtcVS8N0R5ISEBCnhMTEx8n5G
+Rgb94x//8JmAd1TlXotF8KcYxHPaq/cBrQEU0BxAg5ruo7TaEQ7NtRbBf9/ngs8RnMjIRbJiz/Pu
+WfKxEwIAAAAA9BbBN9lcq1+9L5ajMd2R4yeffJJCQ0MNP3/kyBEaPnw4XXfddRL+mB/TCvzUqVPp
+zjvvpD59+tBDDz1EGzdutH5Oi73wFxYW0osvviivHHCMZ8yYMR6dEJgdjclyH3BecFrQGEBD6n9I
+ydV/08RzRvlM8FnqY2KW08iRb9CNN94o59zPmTOTKipKsQMCAAAAAPQewT9l0Fxbb9Bc6zgas+2i
+e4I/YMAAKdpGn3/jjTfoj3/8I2VnZ0sGDx4sH9MK/tChQ+ngwYNUUlJCY8eOpUceecSwgq+9P3Lk
+SPl8ubm58rn5ZMMjwTc5GlMr9wHHBHWCqgAaVHYPJZf/RRH899wWfI7a8Gq0LPAs9FypZ6nnCTkT
+JnxDGRmp2OkAAAAAAHqf4KvxHM9HY3oi+K6E+tZbb6Xdu3db7/PHXG3Xfr+2os+Sz5V8M4LPz71n
+zx7rff7YM8F3NhrzK+toTD25DygTFAnyA2hI/r2UVjJMvh7h4fMls2fPounTQ2WsJjQ0mMaM+ZRe
+e+1VeuGF5+hXv3pU/g4s8z//+c9k4ywvWLV9+xZU6gEAAAAAIPhORmM6a6695LhyrS8r+HrC7Uzg
+7R9zJviuvte84GvjOcajMZ3JfUB2AA3Mvo3iCp+Wr8fLL78sefXVV+WVBo7YcGMsj7b84ovPhfzP
+pfj41VigCgAAAAAAgm8k+K6aa2sMmmttq/dtF4+4JccckXGWwecKdVpamtMKvqeCb1/B55/jjeAb
+j8ZUBN9A7gfmfZ/WFj9DlyreoZbydzt1oSsAAAAAANBTBd/laMwap6Mx1eq9u4LPU3RYtGNjY3Wn
+6Kg5ec7Ic1ae8/j2GXxPBZ+fm3P3/LzMU0895aHgO2+utcy+H+Mg9wMLhNiXPCvE/j3ZXMv5+5by
+dyD4AAAAAAAQfF8KvhrPMTsas8Smet92Md9tQVbn4F9zzTVyDv60adNspuiw8POkG2bEiBE2kR5v
+BJ+fe9iwYTLyc9NNN8kpOtr4jzuCbzQaU7tyrSr3vy65g+LKhNhXjrKOxrTI/bsQfAAAAAAACL6v
+BN/b5toCjwXfX0hOTqa77rrLA8HXa67VVu8tK9cOLL+d1pY/L8R+tM3KtdrqfUv52xB8AAAAAAAI
+vq8E36651uxozEvt1fu2i3ndSuo57sPxnKysLIf4j1kcR2OOc6jeO1u5Vgq+Ur2H4AMAAAAAQPB9
+JPgndJprzY/GbBf8XCov7z6CP378eNm0279/f7nolXbkphnKy4qdNNe2V+8tcv+JIvfG1fuW8rcg
++AAAAAAAEHxfCL53ozEtgp9HbRdyqa6muNvGdNylriJDEXwvqvc2gv8mBB8AAAAAAILvK8FvcKO5
+Vq96z4KfQxdO5XWrKr43nK1e7HQ0pm313l7wbZtruXrfXIKIDgAAAAAABN9LZswIpWP1hYbNtWZG
+Y6rxnLYL2YLD1HT8SI+X+xOV612Mxvxcp3qvxnNG6cZzCtI+pYkTJ0LwAQAAAAAg+J6zNmENJe/Y
+oAi+Z6Mx1XiOKvht57PowslsqqspovLy0h4j9Zy551jOuepInebar/TjOaaq95Z4ztKIQJo2LQSC
+DwAAAAAAwfecwsJ8KZV1VTkej8a0VO9zFME/JAW/7fxBwX5qO5cp2CfIEOyhtrPpgjTBbrp6JkWw
+S7CTrp7eIdgu2CrYQlebNgs2CTbS1VMbBOsFiXT15FpBvCBOsIauNsYKVglW0tUTKwTRguXUenyZ
+YKkgUrCEWo8tEkQIFlBrQ7hgvmCeYC61Hp0tmCUIo9b6GYLpglBqrQsRBAsCBVOptXaKsnKtudGY
++tV7/ebatM0TaNKkSbR4cQQEHwAAAAAAgu8d+/btoWkhIbR96zo6Xpen01xbZtBcq1O9l4LPcn9A
+I/h7LYJvlftUHcFnud+mI/iq3K8TsNwntAt+42pF8IXcN8ZoBD9KEXxV7hfrCL4q93MUwZ8ppD6s
+Xe7rpymCH2QR/NqpitxP8tlozObS96ggfQwtWxQo5T48fJ6D3EPwAQAAAAAg+B5X8lesiJYryXKj
+J+gcOHPPV1D0KvfM8uVR2GkAAAAAACD43rF+faKubILOh18L7DQAAAAAABB8rzh8+CBFR0dBsP2A
+7OyD2GkAAAAAACD43pOevhuC3cWkpOzEDgMAAAAAAMH3bSWfIyKcA4dwdw78t+a/OSr3AAAAAAAQ
+fAAAAAAAAAAEHwAAAAAAAADBBwAAAAAAAEDwAQAAAAAA6Gn8f6RXULseWHNPAAAAAElFTkSuQmCC
+</xwf:image>
+</xwf:workflow>
\ No newline at end of file

Added: airavata/trunk/modules/integration-tests/src/test/resources/comma_data.sh
URL: http://svn.apache.org/viewvc/airavata/trunk/modules/integration-tests/src/test/resources/comma_data.sh?rev=1515978&view=auto
==============================================================================
--- airavata/trunk/modules/integration-tests/src/test/resources/comma_data.sh (added)
+++ airavata/trunk/modules/integration-tests/src/test/resources/comma_data.sh Tue Aug 20 21:35:02 2013
@@ -0,0 +1,13 @@
+#!/bin/sh
+FIRST=1
+for var in "$@"
+do
+	if [ $FIRST -eq 1 ]
+	then
+	    echo -n "$var"
+		FIRST=0
+	else
+		echo -n ",$var"
+	fi
+done
+echo



Mime
View raw message