diff --git a/org.eclipse.rephraserengine-feature/.project b/org.eclipse.rephraserengine-feature/.project
deleted file mode 100644
index d82f054..0000000
--- a/org.eclipse.rephraserengine-feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.rephraserengine-feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/org.eclipse.rephraserengine-feature/build.properties b/org.eclipse.rephraserengine-feature/build.properties
deleted file mode 100644
index 318916a..0000000
--- a/org.eclipse.rephraserengine-feature/build.properties
+++ /dev/null
@@ -1,10 +0,0 @@
-bin.includes = feature.xml,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
-src.includes = .project,\
-               build.properties,\
-               epl-v10.html,\
-               feature.xml,\
-               license.html,\
-               feature.properties
diff --git a/org.eclipse.rephraserengine-feature/epl-v10.html b/org.eclipse.rephraserengine-feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/org.eclipse.rephraserengine-feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/org.eclipse.rephraserengine-feature/feature.properties b/org.eclipse.rephraserengine-feature/feature.properties
deleted file mode 100644
index 09b0989..0000000
--- a/org.eclipse.rephraserengine-feature/feature.properties
+++ /dev/null
@@ -1,140 +0,0 @@
-###############################################################################
-# Copyright (c) 2009 IBM and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    IBM - initial API and implementation
-###############################################################################
-# features.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Rephraser Engine End-User Runtime
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse PTP
-
-# "updateSiteName" property - label for the update site
-updateSiteName=Eclipse PTP Update Site
-
-# "description" property - description of the feature
-description=Rephraser Engine
-
-# copyright
-copyright=\
-Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.  All rights reserved.\n\
-This program and the accompanying materials are made available\n\
-under the terms of the Eclipse Public License v1.0 which\n\
-accompanies this distribution and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-March 17, 2005\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/org.eclipse.rephraserengine-feature/feature.xml b/org.eclipse.rephraserengine-feature/feature.xml
deleted file mode 100644
index 5c40fa2..0000000
--- a/org.eclipse.rephraserengine-feature/feature.xml
+++ /dev/null
@@ -1,83 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.rephraserengine"
-      label="%featureName"
-      version="5.0.1.qualifier"
-      provider-name="%providerName">
-
-   <description url="http://www.eclipse.org/photran">
-      %description
-   </description>
-
-   <copyright url="http://www.eclipse.org/photran">
-      %copyright
-   </copyright>
-
-   <license url="%licenseURL">
-      %license
-   </license>
-
-   <url>
-      <update label="Photran" url="http://download.eclipse.org/tools/ptp/releases/galileo"/>
-   </url>
-
-   <requires>
-      <import plugin="org.eclipse.core.resources"/>
-      <import plugin="org.eclipse.jface.text"/>
-      <import plugin="org.eclipse.ltk.core.refactoring"/>
-      <import plugin="org.eclipse.core.runtime"/>
-      <import plugin="org.eclipse.ui"/>
-      <import plugin="org.eclipse.ui.ide"/>
-      <import plugin="org.eclipse.ltk.ui.refactoring"/>
-      <import plugin="org.eclipse.core.filebuffers"/>
-   </requires>
-
-   <plugin
-         id="org.eclipse.rephraserengine.core"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.rephraserengine.core.refactoring"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.rephraserengine.core.vpg"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.rephraserengine.doc.isv"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.rephraserengine.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.rephraserengine.ui.refactoring"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.rephraserengine.ui.vpg"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/org.eclipse.rephraserengine-feature/license.html b/org.eclipse.rephraserengine-feature/license.html
deleted file mode 100644
index c6af966..0000000
--- a/org.eclipse.rephraserengine-feature/license.html
+++ /dev/null
@@ -1,79 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>March 17, 2005</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/org.eclipse.rephraserengine.doc.isv/.project b/org.eclipse.rephraserengine.doc.isv/.project
deleted file mode 100644
index 080cc8f..0000000
--- a/org.eclipse.rephraserengine.doc.isv/.project
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.rephraserengine.doc.isv</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-	</natures>
-</projectDescription>
diff --git a/org.eclipse.rephraserengine.doc.isv/META-INF/MANIFEST.MF b/org.eclipse.rephraserengine.doc.isv/META-INF/MANIFEST.MF
deleted file mode 100644
index fb75873..0000000
--- a/org.eclipse.rephraserengine.doc.isv/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,6 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: Rephraser Engine ISV Documentation
-Bundle-SymbolicName: org.eclipse.rephraserengine.doc.isv; singleton:=true
-Bundle-Version: 1.0.0.qualifier
-Bundle-Vendor: Eclipse.org - Photran
diff --git a/org.eclipse.rephraserengine.doc.isv/about.html b/org.eclipse.rephraserengine.doc.isv/about.html
deleted file mode 100644
index 9c7ba0a..0000000
--- a/org.eclipse.rephraserengine.doc.isv/about.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>About</title></head>
-
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>May 2, 2006</p>	
-<h3>License</h3>
-
-<p>The Eclipse Foundation makes available all content in this plug-in ("Content").  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 ("EPL").  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, "Program" will mean the Content.</p>
-
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party ("Redistributor") and different terms and conditions may
-apply to your use of any object code in the Content.  Check the Redistributor's license that was 
-provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
-indicated below, the terms and conditions of the EPL still apply to any source code in the Content
-and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.rephraserengine.doc.isv/build.properties b/org.eclipse.rephraserengine.doc.isv/build.properties
deleted file mode 100644
index d879a4d..0000000
--- a/org.eclipse.rephraserengine.doc.isv/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-bin.includes = plugin.xml,\
-               META-INF/,\
-               html/,\
-               *.xml,\
-               images/,\
-               about.html
-src.includes = .project,\
-               META-INF/,\
-               about.html,\
-               build.properties,\
-               html/,\
-               images/,\
-               plugin.xml,\
-               toc.xml,\
-               tocsamples.xml,\
-               tocconcepts.xml
diff --git a/org.eclipse.rephraserengine.doc.isv/html/concepts/introduction.html b/org.eclipse.rephraserengine.doc.isv/html/concepts/introduction.html
deleted file mode 100644
index ed1c0b7..0000000
--- a/org.eclipse.rephraserengine.doc.isv/html/concepts/introduction.html
+++ /dev/null
@@ -1,54 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	<title>Introduction</title>
-</head>
-
-<body>
-<h1>Introduction</h1>
-
-The Rephraser Engine is an Eclipse-based library that expedites the development of refactoring tools.  It contains two components:
-<ul>
-<li> The <i>refactoring</i> component allows plug-ins to easily contribute refactorings to the Eclipse user interface.
-<li> The <i>virtual program graph (VPG)</i> component provides a language-independent program database and indexing infrastructure.
-</ul>
-
-<p>These components are independent; some projects may choose to use the Refactoring component without using the VPG component, for example.  The dependencies among the projects comprising the Rephraser Engine are as follows.</p>
-
-<p><img src="../../images/architecture.png" border="0" /></p>
-
-<p>"Rephraser" is an acronym which stands for
-Rapid
-Eclipse
-Prototyping
-Host for
-Research on
-Approximate
-Semantic
-Equivalence-based
-Refactoring.</p>
-
-<h2>Features</h2>
-
-<h3>Refactoring</h3>
-
-<p>The Refactoring component extends the Eclipse Language ToolKit (LTK) and
-<ul>
-<li> contributes a Refactor menu to the workbench menu bar, as well as to the context menu for resource selections in the workbench;
-<li> provides an extension point that allows refactorings to be contributed to this menu; and
-<li> does not require any user interface code to be written for simple refactorings.
-</ul></p>
-
-<h3>VPG</h3>
-
-<p>The VPG component
-<ul>
-<li> provides a set of base classes for building persistable program graphs;
-<li> provides an indexing infrastructure by registering a resource listener and automatically updating program graphs as workspace resources change; and
-<li> contributes a "(Debugging)" sub-menu to the workbench Refactoring menu, which provides various actions for viewing, analyzing, and manipulating VPG databases.
-</ul></p>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.rephraserengine.doc.isv/html/concepts/refactorings.html b/org.eclipse.rephraserengine.doc.isv/html/concepts/refactorings.html
deleted file mode 100644
index ff13316..0000000
--- a/org.eclipse.rephraserengine.doc.isv/html/concepts/refactorings.html
+++ /dev/null
@@ -1,106 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	<title>Contributing Refactorings</title>
-<style type="text/css">
-<!--
-span.st1 
-    {
-    font-family: Courier New;
-    font-size: 10pt;
-    color: #800000;
-    }
-span.st2 
-    {
-    font-family: Courier New;
-    font-size: 10pt;
-    color: #000000;
-    }
-span.st3 
-    {
-    font-family: Courier New;
-    font-size: 10pt;
-    color: #000080;
-    }
-span.st4 
-    {
-    font-family: Courier New;
-    font-size: 10pt;
-    color: #008000;
-    }
-span.st5 
-    {
-    font-family: Times New Roman;
-    font-size: 12pt;
-    color: #000000;
-    }
--->
-</style>
-</head>
-
-<body>
-<h1>Contributing Refactorings</h1>
-
-TODO
-
-org.eclipse.rephraserengine.ui.refactoring.refactorings extension point
-
-<h2>Examples</h2>
-
-<!-- http://www.sautinsoft.net/rtf-to-html-convert.aspx -->
-
-<div><span class="st2"> &nbsp;&nbsp;</span><span class="st3">&lt;extension</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">point=</span><span class="st4">"org.eclipse.rephraserengine.ui.refactoring.refactorings"</span><span class="st3">&gt;</span></div>
-<div><span class="st2"></span>&nbsp;</div>
-
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- The resource filter determines what must be selected for these refactorings to be visible --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;resourceFilter</span><span class="st2"> </span><span class="st3">class=</span><span class="st4">"org.eclipse.rephraserengine.examples.text.TextFileResourceFilter"</span><span class="st2"> </span><span class="st3">/&gt;</span></div>
-<div><span class="st2"></span>&nbsp;</div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- Each group defines a new (separated) section in the Refactor menu --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;group&gt;</span></div>
-
-<div><span class="st2"></span>&nbsp;</div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- A resource refactoring which uses an auto-generated user interface --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;resourceRefactoring</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">class=</span><span class="st4">"org.eclipse.rephraserengine.examples.text.ConvertTabsToSpacesRefactoring"</span><span class="st2"> </span><span class="st3">/&gt;</span></div>
-<div><span class="st2"></span>&nbsp;</div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- An editor refactoring which uses an auto-generated user interface --&gt;</span></div>
-
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;editorRefactoring</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">class=</span><span class="st4">"org.eclipse.photran.internal.core.refactoring.MakePrivateEntityPublicRefactoring"</span><span class="st2"> </span><span class="st3">/&gt;</span></div>
-<div><span class="st2"></span>&nbsp;</div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- Same as previous, except the given label ("Increase Visibility") will appear in the menu;</span></div>
-<div><span class="st2"></span><span class="st1"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;when the label attribute is absent, the label will be whatever is returned by the refactoring&amp;apos;s</span></div>
-
-<div><span class="st2"></span><span class="st1"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#getName method --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;editorRefactoring</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">label=</span><span class="st4">"Increase Visibility"</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">class=</span><span class="st4">"org.eclipse.photran.internal.core.refactoring.MakePrivateEntityPublicRefactoring"</span><span class="st2"> </span><span class="st3">/&gt;</span></div>
-<div><span class="st2"></span>&nbsp;</div>
-
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- An editor refactoring which uses a custom user interface --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;editorRefactoring</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">class=</span><span class="st4">"org.eclipse.photran.internal.core.refactoring.AddOnlyToUseStmtRefactoring"</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">inputPage=</span><span class="st4">"org.eclipse.photran.internal.refactoring.ui.AddOnlyToUseStmtInputPage"</span><span class="st2"> </span><span class="st3">/&gt;</span></div>
-<div><span class="st2"></span>&nbsp;</div>
-
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- A command which is contributed as an editor refactoring --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- Note that this is the only way to give a refactoring a key binding --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;editorRefactoring</span><span class="st2"> </span><span class="st3">command=</span><span class="st4">"org.eclipse.photran.ui.RenameRefactoringCommand"</span><span class="st2"> </span><span class="st3">/&gt;</span></div>
-<div><span class="st2"></span>&nbsp;</div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st1">&lt;!-- An editor refactoring which only appears in the menu when the</span></div>
-
-<div><span class="st2"></span><span class="st1"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;PHOTRAN_INCLUDE_TEST_REFACTORINGS environment variable is set to a non-null value --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;editorRefactoring</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">require_env=</span><span class="st4">"PHOTRAN_INCLUDE_TEST_REFACTORINGS"</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">class=</span><span class="st4">"org.eclipse.photran.internal.core.refactoring.AddEmptySubprogramRefactoring"</span><span class="st2"> </span><span class="st3">/&gt;</span></div>
-<div><span class="st2"></span>&nbsp;</div>
-
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;/group&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;</span><span class="st3">&lt;/extension&gt;</span></div>
-</pre>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.rephraserengine.doc.isv/html/concepts/vpg.html b/org.eclipse.rephraserengine.doc.isv/html/concepts/vpg.html
deleted file mode 100644
index e93dcad..0000000
--- a/org.eclipse.rephraserengine.doc.isv/html/concepts/vpg.html
+++ /dev/null
@@ -1,65 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	<title>Contributing a Virtual Program Graph</title>
-<style type="text/css">
-<!--
-span.st1 
-    {
-    font-family: Courier New;
-    font-size: 10pt;
-    color: #800000;
-    }
-span.st2 
-    {
-    font-family: Courier New;
-    font-size: 10pt;
-    color: #000000;
-    }
-span.st3 
-    {
-    font-family: Courier New;
-    font-size: 10pt;
-    color: #000080;
-    }
-span.st4 
-    {
-    font-family: Courier New;
-    font-size: 10pt;
-    color: #008000;
-    }
-span.st5 
-    {
-    font-family: Times New Roman;
-    font-size: 12pt;
-    color: #000000;
-    }
--->
-</style>
-</head>
-
-<body>
-<h1>Contributing a Virtual Program Graph</h1>
-
-TODO
-
-<h2>Example</h2>
-
-<!-- http://www.sautinsoft.net/rtf-to-html-convert.aspx -->
-
-<div><span class="st1"> &nbsp;&nbsp;&lt;!-- This will automatically add some actions to the (Debugging) sub-menu of the Refactor</span></div>
-<div><span class="st2"></span><span class="st1"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;menu in the menu bar, such as Display VPG Database, Refresh VPG Database, etc. --&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;</span><span class="st3">&lt;extension</span></div>
-
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">point=</span><span class="st4">"org.eclipse.rephraserengine.ui.vpg.vpg"</span><span class="st3">&gt;</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">&lt;vpg</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">id=</span><span class="st4">"org.eclipse.photran.ui.vpg"</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">name=</span><span class="st4">"Fortran"</span></div>
-<div><span class="st2"> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="st3">class=</span><span class="st4">"org.eclipse.photran.internal.ui.vpg.PhotranVPGContribution"</span><span class="st2"> </span><span class="st3">/&gt;</span></div>
-
-<div><span class="st2"> &nbsp;&nbsp;</span><span class="st3">&lt;/extension&gt;</span></div>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.rephraserengine.doc.isv/html/samples/samples.html b/org.eclipse.rephraserengine.doc.isv/html/samples/samples.html
deleted file mode 100644
index 4760ff9..0000000
--- a/org.eclipse.rephraserengine.doc.isv/html/samples/samples.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	<title>Samples</title>
-</head>
-
-<body>
-<h1>Samples</h1>
-
-<h2>org.eclipse.rephraserengine.examples.text</h2>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.rephraserengine.doc.isv/images/architecture.graffle b/org.eclipse.rephraserengine.doc.isv/images/architecture.graffle
deleted file mode 100644
index c2ff03a..0000000
--- a/org.eclipse.rephraserengine.doc.isv/images/architecture.graffle
+++ /dev/null
@@ -1,1712 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>ActiveLayerIndex</key>
-	<integer>0</integer>
-	<key>ApplicationVersion</key>
-	<array>
-		<string>com.omnigroup.OmniGraffle</string>
-		<string>138.9.0.117994</string>
-	</array>
-	<key>AutoAdjust</key>
-	<false/>
-	<key>BackgroundGraphic</key>
-	<dict>
-		<key>Bounds</key>
-		<string>{{0, 0}, {360, 144}}</string>
-		<key>Class</key>
-		<string>SolidGraphic</string>
-		<key>ID</key>
-		<integer>2</integer>
-		<key>Style</key>
-		<dict>
-			<key>shadow</key>
-			<dict>
-				<key>Draws</key>
-				<string>NO</string>
-			</dict>
-			<key>stroke</key>
-			<dict>
-				<key>Draws</key>
-				<string>NO</string>
-			</dict>
-		</dict>
-	</dict>
-	<key>CanvasOrigin</key>
-	<string>{0, 0}</string>
-	<key>CanvasSize</key>
-	<string>{360, 144}</string>
-	<key>ColumnAlign</key>
-	<integer>1</integer>
-	<key>ColumnSpacing</key>
-	<real>36</real>
-	<key>CreationDate</key>
-	<string>2009-10-14 16:40:00 -0500</string>
-	<key>Creator</key>
-	<string>Jeffrey Overbey</string>
-	<key>DisplayScale</key>
-	<string>1 0/72 in = 1 0/72 in</string>
-	<key>GraphDocumentVersion</key>
-	<integer>6</integer>
-	<key>GraphicsList</key>
-	<array>
-		<dict>
-			<key>Class</key>
-			<string>LineGraphic</string>
-			<key>Head</key>
-			<dict>
-				<key>ID</key>
-				<integer>31</integer>
-			</dict>
-			<key>ID</key>
-			<integer>39</integer>
-			<key>Points</key>
-			<array>
-				<string>{172.5, 68.4994}</string>
-				<string>{172.5, 112.071}</string>
-			</array>
-			<key>Style</key>
-			<dict>
-				<key>stroke</key>
-				<dict>
-					<key>HeadArrow</key>
-					<string>StickArrow</string>
-					<key>Pattern</key>
-					<integer>1</integer>
-					<key>TailArrow</key>
-					<string>0</string>
-				</dict>
-			</dict>
-			<key>Tail</key>
-			<dict>
-				<key>ID</key>
-				<integer>28</integer>
-			</dict>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>LineGraphic</string>
-			<key>Head</key>
-			<dict>
-				<key>ID</key>
-				<integer>31</integer>
-			</dict>
-			<key>ID</key>
-			<integer>38</integer>
-			<key>Points</key>
-			<array>
-				<string>{244.141, 104.147}</string>
-				<string>{201.478, 117.331}</string>
-			</array>
-			<key>Style</key>
-			<dict>
-				<key>stroke</key>
-				<dict>
-					<key>HeadArrow</key>
-					<string>StickArrow</string>
-					<key>Pattern</key>
-					<integer>1</integer>
-					<key>TailArrow</key>
-					<string>0</string>
-				</dict>
-			</dict>
-			<key>Tail</key>
-			<dict>
-				<key>ID</key>
-				<integer>19</integer>
-			</dict>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>LineGraphic</string>
-			<key>Head</key>
-			<dict>
-				<key>ID</key>
-				<integer>31</integer>
-			</dict>
-			<key>ID</key>
-			<integer>37</integer>
-			<key>Points</key>
-			<array>
-				<string>{100.859, 104.147}</string>
-				<string>{143.522, 117.331}</string>
-			</array>
-			<key>Style</key>
-			<dict>
-				<key>stroke</key>
-				<dict>
-					<key>HeadArrow</key>
-					<string>StickArrow</string>
-					<key>Pattern</key>
-					<integer>1</integer>
-					<key>TailArrow</key>
-					<string>0</string>
-				</dict>
-			</dict>
-			<key>Tail</key>
-			<dict>
-				<key>ID</key>
-				<integer>16</integer>
-			</dict>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>LineGraphic</string>
-			<key>Head</key>
-			<dict>
-				<key>ID</key>
-				<integer>19</integer>
-			</dict>
-			<key>ID</key>
-			<integer>36</integer>
-			<key>Points</key>
-			<array>
-				<string>{289, 32.4996}</string>
-				<string>{289, 76.0706}</string>
-			</array>
-			<key>Style</key>
-			<dict>
-				<key>stroke</key>
-				<dict>
-					<key>HeadArrow</key>
-					<string>StickArrow</string>
-					<key>Pattern</key>
-					<integer>1</integer>
-					<key>TailArrow</key>
-					<string>0</string>
-				</dict>
-			</dict>
-			<key>Tail</key>
-			<dict>
-				<key>ID</key>
-				<integer>25</integer>
-			</dict>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>LineGraphic</string>
-			<key>Head</key>
-			<dict>
-				<key>ID</key>
-				<integer>16</integer>
-			</dict>
-			<key>ID</key>
-			<integer>35</integer>
-			<key>Points</key>
-			<array>
-				<string>{56, 32.4996}</string>
-				<string>{56, 76.071}</string>
-			</array>
-			<key>Style</key>
-			<dict>
-				<key>stroke</key>
-				<dict>
-					<key>HeadArrow</key>
-					<string>StickArrow</string>
-					<key>Pattern</key>
-					<integer>1</integer>
-					<key>TailArrow</key>
-					<string>0</string>
-				</dict>
-			</dict>
-			<key>Tail</key>
-			<dict>
-				<key>ID</key>
-				<integer>22</integer>
-			</dict>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>LineGraphic</string>
-			<key>Head</key>
-			<dict>
-				<key>ID</key>
-				<integer>28</integer>
-			</dict>
-			<key>ID</key>
-			<integer>34</integer>
-			<key>Points</key>
-			<array>
-				<string>{244.141, 32.1472}</string>
-				<string>{201.478, 45.3307}</string>
-			</array>
-			<key>Style</key>
-			<dict>
-				<key>stroke</key>
-				<dict>
-					<key>HeadArrow</key>
-					<string>StickArrow</string>
-					<key>Pattern</key>
-					<integer>1</integer>
-					<key>TailArrow</key>
-					<string>0</string>
-				</dict>
-			</dict>
-			<key>Tail</key>
-			<dict>
-				<key>ID</key>
-				<integer>25</integer>
-			</dict>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>LineGraphic</string>
-			<key>Head</key>
-			<dict>
-				<key>ID</key>
-				<integer>28</integer>
-			</dict>
-			<key>ID</key>
-			<integer>33</integer>
-			<key>Points</key>
-			<array>
-				<string>{100.859, 32.1472}</string>
-				<string>{143.522, 45.3307}</string>
-			</array>
-			<key>Style</key>
-			<dict>
-				<key>stroke</key>
-				<dict>
-					<key>HeadArrow</key>
-					<string>StickArrow</string>
-					<key>Pattern</key>
-					<integer>1</integer>
-					<key>TailArrow</key>
-					<string>0</string>
-				</dict>
-			</dict>
-			<key>Tail</key>
-			<dict>
-				<key>ID</key>
-				<integer>22</integer>
-			</dict>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>Group</string>
-			<key>Graphics</key>
-			<array>
-				<dict>
-					<key>Bounds</key>
-					<string>{{144, 112.571}, {57, 27.4286}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>31</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-					<key>Style</key>
-					<dict/>
-					<key>Text</key>
-					<dict>
-						<key>Text</key>
-						<string>{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf540
-{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
-{\colortbl;\red255\green255\blue255;}
-\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc
-
-\f0\fs24 \cf0 Core}</string>
-						<key>VerticalPad</key>
-						<integer>0</integer>
-					</dict>
-				</dict>
-				<dict>
-					<key>Bounds</key>
-					<string>{{144, 108}, {16.7647, 4.57143}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>32</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-				</dict>
-			</array>
-			<key>ID</key>
-			<integer>30</integer>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>Group</string>
-			<key>Graphics</key>
-			<array>
-				<dict>
-					<key>Bounds</key>
-					<string>{{144, 40.5708}, {57, 27.4286}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>28</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-					<key>Style</key>
-					<dict/>
-					<key>Text</key>
-					<dict>
-						<key>Text</key>
-						<string>{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf540
-{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
-{\colortbl;\red255\green255\blue255;}
-\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc
-
-\f0\fs24 \cf0 UI}</string>
-						<key>VerticalPad</key>
-						<integer>0</integer>
-					</dict>
-				</dict>
-				<dict>
-					<key>Bounds</key>
-					<string>{{144, 35.9998}, {16.7647, 4.57143}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>29</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-				</dict>
-			</array>
-			<key>ID</key>
-			<integer>27</integer>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>Group</string>
-			<key>Graphics</key>
-			<array>
-				<dict>
-					<key>Bounds</key>
-					<string>{{233, 4.571}, {112, 27.4286}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>25</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-					<key>Style</key>
-					<dict/>
-					<key>Text</key>
-					<dict>
-						<key>Text</key>
-						<string>{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf540
-{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
-{\colortbl;\red255\green255\blue255;}
-\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc
-
-\f0\fs24 \cf0 UI Refactoring}</string>
-						<key>VerticalPad</key>
-						<integer>0</integer>
-					</dict>
-				</dict>
-				<dict>
-					<key>Bounds</key>
-					<string>{{233, 0}, {32.9412, 4.57143}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>26</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-				</dict>
-			</array>
-			<key>ID</key>
-			<integer>24</integer>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>Group</string>
-			<key>Graphics</key>
-			<array>
-				<dict>
-					<key>Bounds</key>
-					<string>{{0, 4.571}, {112, 27.4286}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>22</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-					<key>Style</key>
-					<dict/>
-					<key>Text</key>
-					<dict>
-						<key>Text</key>
-						<string>{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf540
-{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
-{\colortbl;\red255\green255\blue255;}
-\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc
-
-\f0\fs24 \cf0 UI VPG}</string>
-						<key>VerticalPad</key>
-						<integer>0</integer>
-					</dict>
-				</dict>
-				<dict>
-					<key>Bounds</key>
-					<string>{{0, 0}, {32.9412, 4.57143}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>23</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-				</dict>
-			</array>
-			<key>ID</key>
-			<integer>21</integer>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>Group</string>
-			<key>Graphics</key>
-			<array>
-				<dict>
-					<key>Bounds</key>
-					<string>{{233, 76.5706}, {112, 27.4286}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>19</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-					<key>Style</key>
-					<dict/>
-					<key>Text</key>
-					<dict>
-						<key>Text</key>
-						<string>{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf540
-{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
-{\colortbl;\red255\green255\blue255;}
-\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc
-
-\f0\fs24 \cf0 Core Refactoring}</string>
-						<key>VerticalPad</key>
-						<integer>0</integer>
-					</dict>
-				</dict>
-				<dict>
-					<key>Bounds</key>
-					<string>{{233, 71.9996}, {32.9412, 4.57143}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>20</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-				</dict>
-			</array>
-			<key>ID</key>
-			<integer>18</integer>
-		</dict>
-		<dict>
-			<key>Class</key>
-			<string>Group</string>
-			<key>Graphics</key>
-			<array>
-				<dict>
-					<key>Bounds</key>
-					<string>{{0, 76.571}, {112, 27.4286}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>16</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-					<key>Style</key>
-					<dict/>
-					<key>Text</key>
-					<dict>
-						<key>Text</key>
-						<string>{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf540
-{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
-{\colortbl;\red255\green255\blue255;}
-\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc
-
-\f0\fs24 \cf0 Core VPG}</string>
-						<key>VerticalPad</key>
-						<integer>0</integer>
-					</dict>
-				</dict>
-				<dict>
-					<key>Bounds</key>
-					<string>{{-8.58307e-05, 71.9996}, {32.9412, 4.57143}}</string>
-					<key>Class</key>
-					<string>ShapedGraphic</string>
-					<key>ID</key>
-					<integer>17</integer>
-					<key>Shape</key>
-					<string>Rectangle</string>
-				</dict>
-			</array>
-			<key>ID</key>
-			<integer>15</integer>
-		</dict>
-	</array>
-	<key>GridInfo</key>
-	<dict/>
-	<key>GuidesLocked</key>
-	<string>NO</string>
-	<key>GuidesVisible</key>
-	<string>YES</string>
-	<key>HPages</key>
-	<integer>1</integer>
-	<key>ImageCounter</key>
-	<integer>1</integer>
-	<key>KeepToScale</key>
-	<false/>
-	<key>Layers</key>
-	<array>
-		<dict>
-			<key>Lock</key>
-			<string>NO</string>
-			<key>Name</key>
-			<string>Layer 1</string>
-			<key>Print</key>
-			<string>YES</string>
-			<key>View</key>
-			<string>YES</string>
-		</dict>
-	</array>
-	<key>LayoutInfo</key>
-	<dict>
-		<key>Animate</key>
-		<string>NO</string>
-		<key>circoMinDist</key>
-		<real>18</real>
-		<key>circoSeparation</key>
-		<real>0.0</real>
-		<key>layoutEngine</key>
-		<string>dot</string>
-		<key>neatoSeparation</key>
-		<real>0.0</real>
-		<key>twopiSeparation</key>
-		<real>0.0</real>
-	</dict>
-	<key>LinksVisible</key>
-	<string>NO</string>
-	<key>MagnetsVisible</key>
-	<string>NO</string>
-	<key>MasterSheets</key>
-	<array/>
-	<key>ModificationDate</key>
-	<string>2009-10-14 16:49:13 -0500</string>
-	<key>Modifier</key>
-	<string>Jeffrey Overbey</string>
-	<key>NotesVisible</key>
-	<string>NO</string>
-	<key>Orientation</key>
-	<integer>2</integer>
-	<key>OriginVisible</key>
-	<string>NO</string>
-	<key>PageBreaks</key>
-	<string>YES</string>
-	<key>PrintInfo</key>
-	<dict>
-		<key>NSBottomMargin</key>
-		<array>
-			<string>float</string>
-			<string>41</string>
-		</array>
-		<key>NSLeftMargin</key>
-		<array>
-			<string>float</string>
-			<string>18</string>
-		</array>
-		<key>NSPaperSize</key>
-		<array>
-			<string>size</string>
-			<string>{612, 792}</string>
-		</array>
-		<key>NSRightMargin</key>
-		<array>
-			<string>float</string>
-			<string>18</string>
-		</array>
-		<key>NSTopMargin</key>
-		<array>
-			<string>float</string>
-			<string>18</string>
-		</array>
-	</dict>
-	<key>PrintOnePage</key>
-	<false/>
-	<key>QuickLookPreview</key>
-	<data>
-	JVBERi0xLjMKJcTl8uXrp/Og0MTGCjUgMCBvYmoKPDwgL0xlbmd0aCA2IDAgUiAvRmls
-	dGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeAGVV8ty20YQvOMr5hgfBO3sE3sN8yjl
-	ZFuyc3DloGJIl1ykFVNKvj89u1hgAQKUJJZKQmmmMdPT07v6QR/oByl8jFfE1tJpR3/S
-	d7rePDFtn4jT52lLV6p1Kn3R+NuY1Ozp+v3utN398/zv/YFOD4B1LiMrumJuJTeSU21g
-	6zvaHun65sj0y2MqgY1NwS4Fk7at1V2MTQ7TJWyE1FrPwUyJqsAkLIFF22PZEjVioTxi
-	raUy0xfmSlSFJWHRo7BSli9BI5S8bwYVSlQFJWETqK4EmVhIY6PbGGNHnZfKbOxLiyU0
-	5FBQxsaQV1KZ7rtkVaJqQIMRC5bDbDP/wwCmYDIwF1QIBa6fwPXH3eH++eG/3ebx8Hh6
-	OO6eTw9bmTbkIQPuXGeUj+RDml8g6cEyO7LAY6t9A4HtIao/8P0ty2xzm1pWdLuBajg9
-	XMkP0SPqnGEHFlr8MvQt1KTIpmpMR8wYf6rFi7L3i/iKgpfqFFQwxkuhgoZN0LIJirAF
-	VXnOkzOjmH++w9z70jVd4aXG6hDI0t2xuf4N+kdnd3v6afMI4M/vf39Hd9/o17v8humu
-	aRnnlEHoZcpgVclAlORN2anSpH/pR4IyPxj5rN9lfhKsMKTcJKMgrjGEBc4UORYZzRiy
-	rjVOVC0M0RlDH3f7++0zNPb965SppnYlkX4UqRU5jDRdmjfsLulyjC7TBiBrkbKtubmE
-	JWNREGQdX9DWmIF2WDsRTxCBz5jRqjUmgLwz7Xy6eYVyZowwcCa7t6acQkqVUCYsClji
-	JS/zGuASMwVxjRnRTKFmQTSmw1pFz+eiATWrksH6Noz1Y1lheHy2VVZGlAOTgL96G+zA
-	0/q4h2TjepB5bhm9eBdsBUqCT4SXTUjisZbQUlfFF7Q1ujjo1lEXRUrpfJhJyVdEgQLx
-	n083032anPJShWGhRcwh9ways37S5eDcImRMkscqTDgZ8pL1ivWkHhMl+mVSBljs44yV
-	l0SUWeGQWJETvZnRwgZVWIx+0XtGfr4gwNJfsPW/a+tPhpvqU6rtYIpwE6wyzBZMGNsq
-	b0C8bq0KnaZDsl2FE0/hxPtyAc1yizOXLM5oHwOvoMkboo2G4HzOMu4ewv80tTnInaDl
-	gDHCaHWwuHvlQsrRe6k3MSWNMgDLTdWcZtVG40HKm5pLcNg2HU1TNbeEpnHx6LSGdkrV
-	qCSnjrwcSFKVU6EZOHhbczBgtGXlGnEkPHgPrnABAG/5BnFxWNIPkgIISreGCQRohiIG
-	wGkk/oajvX/Z2wbSiDWORctTAoK/vLpoSUpVK9+A1wkE7o4DYP5bHwl4OV+nL6tU1Kxt
-	iNDE/YawEjWFyYYwLqOyImP9zYUNSWi9zDlZUwz1hlRoZUMalmssVqTakCG12hCGVWBF
-	eH0gzeIZlzfEoUlpDv/UgLeyIX05YWyuX3/0eG4m1YbgoBXfTcpcQhs2JFdtokyy35Ah
-	ddwQwCUO7Hpzy9aWThbfyZJY4S89s4LTyRH1Wsk1fR5oSXkLQBwczrABeYgoKRiUh9M1
-	Q0R+94f/AZ7bFXwKZW5kc3RyZWFtCmVuZG9iago2IDAgb2JqCjExNTcKZW5kb2JqCjMg
-	MCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCA0IDAgUiAvUmVzb3VyY2VzIDcgMCBS
-	IC9Db250ZW50cyA1IDAgUiAvTWVkaWFCb3ggWzAgMCAzNjAgMTQ0XQo+PgplbmRvYmoK
-	NyAwIG9iago8PCAvUHJvY1NldCBbIC9QREYgL1RleHQgL0ltYWdlQiAvSW1hZ2VDIC9J
-	bWFnZUkgXSAvQ29sb3JTcGFjZSA8PCAvQ3MxIDggMCBSCi9DczIgMzMgMCBSID4+IC9G
-	b250IDw8IC9GMS4wIDM0IDAgUiA+PiAvWE9iamVjdCA8PCAvSW0xIDkgMCBSIC9JbTQg
-	MTUgMCBSCi9JbTEwIDI3IDAgUiAvSW03IDIxIDAgUiAvSW0zIDEzIDAgUiAvSW0yIDEx
-	IDAgUiAvSW0xMSAyOSAwIFIgL0ltNSAxNyAwIFIKL0ltOCAyMyAwIFIgL0ltNiAxOSAw
-	IFIgL0ltOSAyNSAwIFIgL0ltMTIgMzEgMCBSID4+ID4+CmVuZG9iago5IDAgb2JqCjw8
-	IC9MZW5ndGggMTAgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFnZSAvV2lk
-	dGggMTEwIC9IZWlnaHQgNjAgL0NvbG9yU3BhY2UKMzUgMCBSIC9TTWFzayAzNiAwIFIg
-	L0JpdHNQZXJDb21wb25lbnQgOCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0K
-	eAHt0AENAAAAwqD3T20ON4hAYcCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMG
-	DBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCA
-	ge+BAU1YAAEKZW5kc3RyZWFtCmVuZG9iagoxMCAwIG9iagoxMTAKZW5kb2JqCjE1IDAg
-	b2JqCjw8IC9MZW5ndGggMTYgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFn
-	ZSAvV2lkdGggMjY4IC9IZWlnaHQgMTAwIC9Db2xvclNwYWNlCjM4IDAgUiAvU01hc2sg
-	MzkgMCBSIC9CaXRzUGVyQ29tcG9uZW50IDggL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4K
-	c3RyZWFtCngB7dAxAQAAAMKg9U9tDQ+IQGHAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwY
-	MGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAED
-	BgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDA
-	gAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwY
-	MGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAED
-	BgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDA
-	gAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwY
-	MGDAgAEDBgwYMGDAgAEDBgy8Dww6HwABCmVuZHN0cmVhbQplbmRvYmoKMTYgMCBvYmoK
-	Mzc0CmVuZG9iagoyNyAwIG9iago8PCAvTGVuZ3RoIDI4IDAgUiAvVHlwZSAvWE9iamVj
-	dCAvU3VidHlwZSAvSW1hZ2UgL1dpZHRoIDE1OCAvSGVpZ2h0IDEwMCAvQ29sb3JTcGFj
-	ZQo0MSAwIFIgL1NNYXNrIDQyIDAgUiAvQml0c1BlckNvbXBvbmVudCA4IC9GaWx0ZXIg
-	L0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4Ae3QAQ0AAADCoPdPbQ43iEBhwIABAwYMGDBg
-	wIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYM
-	GDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIAB
-	AwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBg
-	wIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMvA4MuSgAAQpl
-	bmRzdHJlYW0KZW5kb2JqCjI4IDAgb2JqCjIzMAplbmRvYmoKMjEgMCBvYmoKPDwgL0xl
-	bmd0aCAyMiAwIFIgL1R5cGUgL1hPYmplY3QgL1N1YnR5cGUgL0ltYWdlIC9XaWR0aCAx
-	MTAgL0hlaWdodCA2MCAvQ29sb3JTcGFjZQozNSAwIFIgL1NNYXNrIDQ0IDAgUiAvQml0
-	c1BlckNvbXBvbmVudCA4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4Ae3Q
-	AQ0AAADCoPdPbQ43iEBhwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBg
-	wIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwICB74EB
-	TVgAAQplbmRzdHJlYW0KZW5kb2JqCjIyIDAgb2JqCjExMAplbmRvYmoKMTMgMCBvYmoK
-	PDwgL0xlbmd0aCAxNCAwIFIgL1R5cGUgL1hPYmplY3QgL1N1YnR5cGUgL0ltYWdlIC9X
-	aWR0aCAxMTAgL0hlaWdodCA2MCAvQ29sb3JTcGFjZQozNSAwIFIgL1NNYXNrIDQ2IDAg
-	UiAvQml0c1BlckNvbXBvbmVudCA4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVh
-	bQp4Ae3QAQ0AAADCoPdPbQ43iEBhwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIAB
-	AwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBg
-	wICB74EBTVgAAQplbmRzdHJlYW0KZW5kb2JqCjE0IDAgb2JqCjExMAplbmRvYmoKMTEg
-	MCBvYmoKPDwgL0xlbmd0aCAxMiAwIFIgL1R5cGUgL1hPYmplY3QgL1N1YnR5cGUgL0lt
-	YWdlIC9XaWR0aCAyNjggL0hlaWdodCAxMDAgL0NvbG9yU3BhY2UKMzggMCBSIC9TTWFz
-	ayA0OCAwIFIgL0JpdHNQZXJDb21wb25lbnQgOCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+
-	PgpzdHJlYW0KeAHt0DEBAAAAwqD1T20ND4hAYcCAAQMGDBgwYMCAAQMGDBgwYMCAAQMG
-	DBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCA
-	AQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgw
-	YMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMG
-	DBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCA
-	AQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgw
-	YMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMG
-	DBgwYMCAAQMGDBgwYMCAAQMGDLwPDDofAAEKZW5kc3RyZWFtCmVuZG9iagoxMiAwIG9i
-	agozNzQKZW5kb2JqCjI5IDAgb2JqCjw8IC9MZW5ndGggMzAgMCBSIC9UeXBlIC9YT2Jq
-	ZWN0IC9TdWJ0eXBlIC9JbWFnZSAvV2lkdGggNzggL0hlaWdodCA2MCAvQ29sb3JTcGFj
-	ZQo1MCAwIFIgL1NNYXNrIDUxIDAgUiAvQml0c1BlckNvbXBvbmVudCA4IC9GaWx0ZXIg
-	L0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4Ae3QMQEAAADCoPVPbQsviEBhwIABAwYMGDBg
-	wIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwZ+
-	AwM22AABCmVuZHN0cmVhbQplbmRvYmoKMzAgMCBvYmoKODUKZW5kb2JqCjE3IDAgb2Jq
-	Cjw8IC9MZW5ndGggMTggMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFnZSAv
-	V2lkdGggMTEwIC9IZWlnaHQgNjAgL0NvbG9yU3BhY2UKMzUgMCBSIC9TTWFzayA1MyAw
-	IFIgL0JpdHNQZXJDb21wb25lbnQgOCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJl
-	YW0KeAHt0AENAAAAwqD3T20ON4hAYcCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCA
-	AQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgw
-	YMCAge+BAU1YAAEKZW5kc3RyZWFtCmVuZG9iagoxOCAwIG9iagoxMTAKZW5kb2JqCjIz
-	IDAgb2JqCjw8IC9MZW5ndGggMjQgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9J
-	bWFnZSAvV2lkdGggMjY4IC9IZWlnaHQgMTAwIC9Db2xvclNwYWNlCjM4IDAgUiAvU01h
-	c2sgNTUgMCBSIC9CaXRzUGVyQ29tcG9uZW50IDggL0ZpbHRlciAvRmxhdGVEZWNvZGUg
-	Pj4Kc3RyZWFtCngB7dAxAQAAAMKg9U9tDQ+IQGHAgAEDBgwYMGDAgAEDBgwYMGDAgAED
-	BgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDA
-	gAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwY
-	MGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAED
-	BgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDA
-	gAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwY
-	MGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAED
-	BgwYMGDAgAEDBgwYMGDAgAEDBgy8Dww6HwABCmVuZHN0cmVhbQplbmRvYmoKMjQgMCBv
-	YmoKMzc0CmVuZG9iagoxOSAwIG9iago8PCAvTGVuZ3RoIDIwIDAgUiAvVHlwZSAvWE9i
-	amVjdCAvU3VidHlwZSAvSW1hZ2UgL1dpZHRoIDI2OCAvSGVpZ2h0IDEwMCAvQ29sb3JT
-	cGFjZQozOCAwIFIgL1NNYXNrIDU3IDAgUiAvQml0c1BlckNvbXBvbmVudCA4IC9GaWx0
-	ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4Ae3QMQEAAADCoPVPbQ0PiEBhwIABAwYM
-	GDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIAB
-	AwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBg
-	wIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYM
-	GDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIAB
-	AwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBg
-	wIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYM
-	GDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMvA8MOh8AAQplbmRzdHJl
-	YW0KZW5kb2JqCjIwIDAgb2JqCjM3NAplbmRvYmoKMjUgMCBvYmoKPDwgL0xlbmd0aCAy
-	NiAwIFIgL1R5cGUgL1hPYmplY3QgL1N1YnR5cGUgL0ltYWdlIC9XaWR0aCA3OCAvSGVp
-	Z2h0IDYwIC9Db2xvclNwYWNlCjUwIDAgUiAvU01hc2sgNTkgMCBSIC9CaXRzUGVyQ29t
-	cG9uZW50IDggL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCngB7dAxAQAAAMKg
-	9U9tCy+IQGHAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwYMGDAgAEDBgwY
-	MGDAgAEDBgwYMGDAgAEDBn4DAzbYAAEKZW5kc3RyZWFtCmVuZG9iagoyNiAwIG9iago4
-	NQplbmRvYmoKMzEgMCBvYmoKPDwgL0xlbmd0aCAzMiAwIFIgL1R5cGUgL1hPYmplY3Qg
-	L1N1YnR5cGUgL0ltYWdlIC9XaWR0aCAxNTggL0hlaWdodCAxMDAgL0NvbG9yU3BhY2UK
-	NDEgMCBSIC9TTWFzayA2MSAwIFIgL0JpdHNQZXJDb21wb25lbnQgOCAvRmlsdGVyIC9G
-	bGF0ZURlY29kZSA+PgpzdHJlYW0KeAHt0AENAAAAwqD3T20ON4hAYcCAAQMGDBgwYMCA
-	AQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgw
-	YMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMG
-	DBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCA
-	AQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDBgwYMCAAQMGDLwODLkoAAEKZW5k
-	c3RyZWFtCmVuZG9iagozMiAwIG9iagoyMzAKZW5kb2JqCjQ2IDAgb2JqCjw8IC9MZW5n
-	dGggNDcgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFnZSAvV2lkdGggMTEw
-	IC9IZWlnaHQgNjAgL0NvbG9yU3BhY2UKL0RldmljZUdyYXkgL0JpdHNQZXJDb21wb25l
-	bnQgOCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeAHtmF1XolAUhq38QvwC
-	UQRFTBQjUXLULNOJ0lyZNpZWljb2tWr+/z+YfaCZi7SkWWvOzIXvjTccH953bzj7YLMt
-	tUxgmcAygb+UwArS6h/LWG7t1n5x1tbW7EgO6zKut8NC4z7hjxYQTRRwEMLpdLpAbstC
-	V8MitBaYgPwYaKSHUE7EIAiPx0N+SrCAgJUARUCD954/o1SIBSgCMF6fHxT4hND1Pi9J
-	IuRv3js4cGayCJIEUICiKDrEfEohmqKCAb/fi4Au09/86pkwp9vtAVaQCjHhCMtGOY63
-	LI6LsmwkzISooN9HetyQJ4pzHs6EudwEsCiaibAcH4sLCVFMWpYoJoR4jOfYCENT4I+A
-	OAE3rzdXUIwuMAa+GEAJieS6JKUzspy1KFnOpKXUejIR56MRhgr4TNxcc1A0h9OAhcJR
-	XkimJDmrbObUfKGgWVKhkFdzm0pWllJJgWfDdNBv4MDcTKMY1iBGfzAU4eJiKpNV1LxW
-	LJbK5cq2FVUq5XKpuKXlc0o2nRLjURPnctjnmAMa5Ej6gnSYiyclWVG1YrlS3ant1RsW
-	Va/VdqqVUlFTFVlKxgAHYULp5phbWbU73B6vn2KiANvIAataqzd0/bDZbLWOFqrVajYP
-	9f3G3m61XCzkspIYYxkKskTmZqI0qkYCjOVFaUPdAlZDP2y1jzsn3Z4ldU86x+3Wod6o
-	VUuamk0leDYUROYgyjeFM4IkvAE6zAspGWC7Db3Z7nRP++eDwfBisYbDweCsf9rttJt6
-	faes5eR1gQub5tZmaShIX5BhY8mMogHs4KjT6w8uLkfXN+PJYo3HN9ejy+F5v9c5OmgA
-	TklDlmDO44LCzXizO90QZJgTUln1S7V+0O6cng2vrie30+nd/WLd3U2nt5Prq+EZ4PR6
-	taiCuSiqnHu2cNAkiEZH+ISkFMq1/eZx7+xiNL6d3j88PlnS48P9dHIzAtxx8+tuKb8h
-	CTyK8gMa9Eha0Sp7evukP7i6AdjT0/OLJT0/PSLc5eAbmKtBlJLIR2igQZu8acqVVYeT
-	IAMhVLZNbRuC7PaHo8n0/hFgP6zo5QVwd9/Ho2G/29b3Kqhw/wvNrBuuJP9Bl+B7ArA+
-	3bAFYHtz2bC+lW14dxzcuykMQdgmBRvWKQgKh3PCwzu9gjnkDtNkbnvFwZyH49Rhw3ui
-	MtyZpyoMp0UYjLCehNEgZgLB4t8/5b/OfUDE9AXjFbj8WSawTGCZwGcS+AmT1iHrCmVu
-	ZHN0cmVhbQplbmRvYmoKNDcgMCBvYmoKOTMwCmVuZG9iago0OCAwIG9iago8PCAvTGVu
-	Z3RoIDQ5IDAgUiAvVHlwZSAvWE9iamVjdCAvU3VidHlwZSAvSW1hZ2UgL1dpZHRoIDI2
-	OCAvSGVpZ2h0IDEwMCAvQ29sb3JTcGFjZQovRGV2aWNlR3JheSAvQml0c1BlckNvbXBv
-	bmVudCA4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4Ae2c+1dS6RrHrbwi
-	IiQXBRUFRC4ioiSiJRhmmZiXvNCkhmIXDMNKloya4pgykqVm5KXy0qiNOqblZNNtnX/t
-	PO8GD5NCdc5Z54e9z/7+4natWqv30/O874b3+3zDwkiRBEgCJAGSAEngf0HgCEH1b7EC
-	BkcDOkYYBdZ0FJb4A0h8HGD94eERhFR4OCwOYfkeDoyED0NkVFS0TzGEkH8xUVGR8F8M
-	QL5Dw08iIiISMMRQKLGxsVQqNY4ggqXAgiiUmOhoxOPbNBCKY9AZAAIwUONotHg6nUEg
-	0enxNFocEKEADh+NEI2CoYCaQCTiaPEMxvEEJpPFYrM5hBCbzWIxmQnHGYx4WhyiAbUB
-	jRIcBqoKVBSIBB04sDmJSVwuLzk5hRBKTuZxuUmJHDbwoGM0oDQQjCAHCoYCNopYKpAA
-	EEAhhZ+Wli4QEkSC9LQ0fgoQARxAgxqLto3gMI6gvSIqBoqCkcBO5AIHgTBDnCmRSmUy
-	Oe4lk0mlkkxxhlAAPLiJ7AQGlEZMFNpBDxcGlAWgiI6Ni2cwOdyUNIFILJVlKZRKlUqV
-	SwDBMpRKRZZMKhYJ0lK4HCYjPg4qIyI8SJdAWcC2ScFQ8PiCDIlcoVTlncjXaAtBRTgX
-	WoNWk38iT6VUyCUZAj4Pg0GBDTRIYRyBsoimUGkMZiKPL8yUZ6vUGm3RKZ2+xGAwlOJe
-	sIgSve5UkVajVmXLM4V8XiKTQaNSoqEwDjaJryxiAQWHlyaSKlTqgiJdSWnZufIKY+UF
-	AqjSWFF+rqy0RFdUoFYppKI0VBm02GCFgVhAh9ABBV8kVeZpTuoNZ89XVtVerG8wEUIN
-	9RdrqyrPnzXoT2rylFIRahN6HBTGoSaBFomMjqUdZ3P5Qmm2ulBXWm6sqTNdbm4xt1ks
-	7biXxdJmbmm+bKqrMZaX6grV2VIhn8s+jgrjUJMcOQrnKZRFYoogU5FXqC+rqK6/1Gy2
-	XLPetHXesuNetzptN63XLObmS/XVFWX6wjxFpiAlEQoDztWDGwZqEdgt2Ny0DLlKoysz
-	1pqaWq9abfY73Y4eJwHU4+i+Y7dZr7Y2mWqNZTqNSp6RxmWjHQOa5OtXT4xFfAInRSDJ
-	Vp8sBRQtFmvnbYez796Aa4gAcg3c63M6bndaLS0Ao/SkOlsiSOEkxAdlERlDpTOT+CK5
-	qkBfXm1qae+wO5z3XMMj7jEPATTmHhl23XM67B3tLabqcn2BSi7iJzHp1JjIQ3URHhkT
-	h1pErFAXGSrrmywdXY4+13235+HE5GMCaHLiocd939Xn6OqwNNVXGorUCjFqkrgY2DwP
-	9Eh4FIV2nJMskCg1xWdrLrXesDv6hkY9j6aeeGdn53Cv2Vnvk6lHntGhPof9RuulmrPF
-	GqVEkMw5TqNEBWERS4PtQihTaUvO1zVftQEK9/jkk5n55wuLS7jX4sLz+Zknk+NugGG7
-	2lx3vkSrkglhw6DFBmEBxwgzKTUjKw9axGS23nYOjo5PeedeLL1cWV3DvVZXXi69mPNO
-	jY8OOm9bzSZokrysjNQkJhwkh+oCjtR4JtouTpwqq/rJYnP0D3smvfMLy6uv1jc2ca+N
-	9Verywvz3knPcL/DZvmpquzUCbRhMNFBcnC/ABZ0YJGp1OjO1TZfsztd7kdP5hZerm1s
-	bm3v4F7bW5sbay8X5p48cruc9mvNted0GmUmsKAHZUGls7jpsHXqyy+2WO/0DnumZl4A
-	iq2dN7sE0JudLYDxYmbKM9x7x9pysVwPm2c6l0WnBqsLKoPFE0hztCUV9eaO7v6Rh9Pz
-	S6vrWzu77/be415773Z3ttZXl+anH470d3eY6ytKtDlSAY/FCMGCnSyQqgoNxoY2m2PA
-	/cj7/OWrP7Z3373/QAC9f7e7/cerl8+9j9wDDltbg9FQqJIKktmhWcCRCiwaLZ09rrGJ
-	mYWV9a03gOLTZ9zr04f3795sra8szEyMuXo6LY2IhUz4XRaVJsst55BnanZxdWN7dw9Q
-	fMG9Pn/6sLe7vbG6ODvlGXLessChGooFfGSPpjLYyVhdBGHxD5zry7dZfPUt35FjEfBx
-	BF475blFpRdM7Xaoi8dzS2ubO7vvP3z+gnMS8M//8vnD+92dzbWlucdQF/Z204XSolw5
-	vHjCB5KIYyQLkgVZF2SPBPY5kgXJIkAg8ETWBckiQCDwRNYFySJAIPBE1gXJIkAg8ETW
-	BckiQCDwRNYFySJAIPBE1gXJIkAg8ETWBckiQCDwRNbFf8uiMMj34Lj/IvxLkLooDPHd
-	b9h37kf+n+6KQrBY2Xj9du+vj7i/QYQFfPxr7+3rjZUfuDf7igV2nzr4a+A+9eMn3Otj
-	4D7118Efu09F9+ynjQ2t/nv25VebRLpn33y17L9nb20wnv72PTvmvyjA/Bd3+0fGp+cX
-	4aJ95+2fewTQn2/Bf7GyOD89PtJ/F/NfFHzDfxH7N1/OjTu9v3gmZ54vr61vbRPDl7O9
-	tb62/Hxm0vNL750bf/PlBPUo+fxa2flg72y6Zu8ZdD+cBr/W6vrm1utt3Ov11ub6Kvi1
-	ph+6B3vs15rA4JmfHdqv5ffxqX0+vm7w8U145xaWV9Z+3yCAfl9bWV6Y806Aj6/b5+PD
-	jL9BfXzh4O9MSPT5O42NZmuXc2DkwaR39tni8m8rq7jXym/Li89mvZMPRgacXVYz2HIw
-	f2cieF0P+zvDo2CSBgwYUvD9ltc1t9u6e12jDyamn849e7GwiHstvHg293R64sGoq7fb
-	1t5cVw6+XynYL2CaJojvF/zgDMwPnl9cVm0yXwc/uGsEnPGPvU9nCaCn3sfgjh8Bc7z9
-	utlUXVacj/nBGUH94GhOgOWfEzDCnIDV7ugdGB4dG4dBgSncC8YExsdGhwd6HXYrzAlA
-	i2DbBSvonMCxyGg0P5Iqkqk0+nNVjc0A466zb2Do/qh7jAByj94fGuhz3gUUzY1V5/Qa
-	lUwEdnCwuh6eH8FmrPxzRUWGihqYK7pu6+ru+bl/YJAAg0WuwYH+n3u6u2zXYa6opgLK
-	wjdXFHTGCj6oYvNm/AxZjqb4TEVN42Vz+42bt7ruwsAZAeTovtt16+aNdvPlxpqKM8Wa
-	HFkGDCJi82ZHD3jjsTlEaBKYQxRn5Wp1Z85X1ZmarrRdvW7tsNk6cS+brcN6/WrblSZT
-	XdX5MzptbpYYm0OkBplD9M+nwpRVqlCiUGuLDWeNVRcbYED1irkVJlTxrrZW8xUYT224
-	WGU8ayjWqhUSYaqvLILNpx6LiKJQYRIRhnUlilxNkc5QVm68UF1bV9/QSAA11NfVVl8w
-	lpcZdEWaXEDB58IUIpUSdXhuOQyLOfDNswOMrBy1pvCU3nAGG2g3EkFonP2MQX+qUKPO
-	yQIUf5tn/3r0LiwM5RxAEgg23M8XimWKnLz8gsKTKOjgNIQE4F6nUczBycKC/LwchUy8
-	jwKlgRwcW0YssPwLFPrA4aamizJlWcqcXPUJjaYAS8BACRJ4lrZAozmhzs1RZskyRemp
-	KAwERT6EyL/w5aL4YKTw04ViiVSela1U5kCkCAGUo1RmZ8mlErEwHVJiMBShclFQYaCQ
-	GBQHksDicJNT09KFIjEWmCMlhCAuRywSpqelJnM5LMjLgaoIkZcDLKBLsEgpyNZisjhJ
-	XF5KKgpSShcQIEpJIEhHMUqpKTxuEocFYTk0iNj6TqgUwIhBqVKMBCbLH7DFg4gt/IvH
-	88drsZgJDJQoFfMNFGH+CDqI2KIADcCBBa9hyWtsAgilrmGxa3QakICiiMQi+YLnru3D
-	QMmEMYAD8vho8QRK5IM0PojjQ3l8EE+4n04YAgWcq7BnYOmEKKfRH9SIkhoJIkhp9MU0
-	/otEiDQ+37uXjwYKa4yIhADP/QRPf/Yl/n/AkiKx/E4szjRkUfhfRCH9FYWeolxXIia7
-	olXtx7p+NWV28D18/3c/D8SEmIIF7q/1h3/C3yGYfnjp5B8kCZAESAIkAZIASeA/J/BP
-	zvUZIgplbmRzdHJlYW0KZW5kb2JqCjQ5IDAgb2JqCjI5NzUKZW5kb2JqCjUxIDAgb2Jq
-	Cjw8IC9MZW5ndGggNTIgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFnZSAv
-	V2lkdGggNzggL0hlaWdodCA2MCAvQ29sb3JTcGFjZQovRGV2aWNlR3JheSAvQml0c1Bl
-	ckNvbXBvbmVudCA4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4Ae2Wa3/p
-	WBTGtSUkccutRIVUKqiglFKlpUFLdbTojY46dabz/b/BrL3TnjM96ryZ/W48b/ySzd+z
-	npXsvWy2tdYJrBNYmcAG0uZK4eWVP/608MHZ2tqyIzl+Cl/D/S38P/DFTz9cvrBQwEEI
-	iqKcINeH0IWTotCS3Y6Jv+fh6hCKQgyaZhiG/SSGoWlYcSIkBq7m4agQC1A0YNweL8j3
-	U+jS43GzLENjIOKtxIEzi0WzLIB8HMfxgvhvCQLPcX6fF4gM4ln2lgODOxaMcrkYYPk5
-	QZS2A4GgLId+SA4GAwFJFHnO73Wz4A/KXeHOgjldNLA4XtwOyKGdsBKJRtUfikYUJRwK
-	BYGIeJY9wH1hbgOV6QRj4EsElBJRdzVtL67riXfpenxPi6lRIAYkgfN6wB7lQNkt4yA0
-	B4VhghQMKWpM0xOp/bSRyWZzWNmMYaRTST2u7UaBJ3I+wDlRdss0bA3K9PqFbTkcjcUT
-	KSOTy+cPi8XSEVKpVCwW8gc5I53UNVV5x1nmlrwBDepkPX5eksOqpqeMXL5YKleqJ7W6
-	pdpJ9bhyVCwcZNPJeCyCcCg7CjXiV9zGpt3hYtxeTgwCLJkGVrlaqzca56bZarXbrZZp
-	Nhun9Wrl6PAgk9Jj4E7we1lo7Bel4tRYgAVCUS1pHACr3jhvdS67vas+1lW3e9E2m6e1
-	Simf3Y+riizxPjft+oKGC6XdPl4KKTEdYMf1htnpXl0PbofD0Xg8Ho2Gtzd/9HuX7fPT
-	armQTe2pO6hWFpf6S6VWoR6/GNhR46kcwJrtbn8wHN89PD5NptPpZPL0eH83vLnuXZiN
-	k3LeSGiRkMR7WRo9JMs0ygWFSrISSxiFcq3Z6V7fjO4fp8+z2ct8Pn95mf05nTzeDQf9
-	C/OsWsxhc4LfzaDgvqbx26GIlsoWq2fmZf9m/DB5ns2/vS6wXucvsynC9TrNejmf1nfD
-	QdHv+R0NerCXypVOGp3eYHj/BLDF4q83rO+L1znC3fYvzdNKwUjElKDIeVjUhiVvDopm
-	fQKKbT93BIVeDUYP09n8FWB/I729fV98mz0/3Q2vu62z48MM0GTchuWmbmySpdlRF3hS
-	lVo0ol0g94TAa0ru6YUthNibZSP61sMZQ3JHIr1bwiFDbCe3ET1lIDiSJyDZ05ns5PAx
-	iMA5SGKqsZGduLA7a+oiMA3Cdkx0UkXbuwUEi/99in4/LYBIaMJ/B64/1gn83xL4B0Wc
-	GxAKZW5kc3RyZWFtCmVuZG9iago1MiAwIG9iago5MjcKZW5kb2JqCjQyIDAgb2JqCjw8
-	IC9MZW5ndGggNDMgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFnZSAvV2lk
-	dGggMTU4IC9IZWlnaHQgMTAwIC9Db2xvclNwYWNlCi9EZXZpY2VHcmF5IC9CaXRzUGVy
-	Q29tcG9uZW50IDggL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCngB7Zv7V1Lp
-	GsetvCIiJBcFFQVELiKiJIIlGGaZmJe80KSGYhcMw0qWjJrimDKSpWbkpfLSqI06puVk
-	022df+087wZPkwJ11untrDWL7y8u19a9P+v7vHtveJ7vGxYWUsiBkAP/DAcO/TD9V34B
-	1eHPOoJRn69yGC76DZBeMiAKD4/4QQoPh8sh0K8BEmxesMioqGivYjDJd/qoqEiwARC/
-	wudji4iIBLAYEik2NpZMJsdhE5wcLkEixURHI8LgfAjuCNQT0ACMHEehxFOpNKyiUuMp
-	lDhgJAGgly9AeQk48A2xxVHiabSjCXQ6g8FksjCJyWQw6PSEozRaPCUO8YF/UF7/eMg5
-	ZBxiowIZk5WYxGZzkpNTMCk5mcNmJyWymEBIJfjAPoTn5+Yl4GDBxZKBDdCAK4WblpbO
-	42MTLz0tjZsCjAAIfORYtPz84x1Cay4qBoyjJTAT2UDG42cIM0VisUQixSCJRCwWZQoz
-	+DwgZCcyE2hgX0wUujcOmgfWAVx0bFw8jc5ip6TxBEKxJEsmlysUilwsghPL5bIsiVgo
-	4KWlsFl0WnwcuBcR7qe2YB3cECQCjsPlZYikMrki71i+Sq0BFX53obOqVfnH8hRymVSU
-	weNyCDwS3Bp+zDsE1kWTyBQaPZHD5WdKsxVKlbrwhFZXrNfrSzAITlus054oVKuUimxp
-	Jp/LSaTTKGRSNJi3v7Re62IBjsVJE4hlCmVBoba4pPRMWbmh4hwWVRjKy86UlhRrCwuU
-	CplYkIbco8T6Mw/RQV2pAMcViOV5quM6/emzFZU15+vqjZhUX3e+prLi7Gm97rgqTy4W
-	oOJS48C8A6WFwkZGx1KOMtlcvjhbqdGWlBmqa40Xm5pNrWZzGwaZza2m5qaLxtpqQ1mJ
-	VqPMFvO5bOZRZN6B0h46DE8TsC4xhZcpy9PoSsur6i40mcxXLNetHTdsGHSjw3rdcsVs
-	arpQV1VeqtPkyTJ5KYlgHjxV9i88VFhYdUx2WoZUodKWGmqMjS2XLVbbrS57twOLuu1d
-	t2xWy+WWRmONoVSrUkgz0thMtPKgtF++Lgi6+ARWCk+UrTxeAnDNZkvHTbuj906/cxCL
-	nP13eh32mx0WczPglRxXZot4KayEeL90kTFkKj2JK5AqCnRlVcbmtnab3XHHOTTsGnVj
-	0ahreMh5x2G3tbc1G6vKdAUKqYCbRKeSYyIPeBceGROHCiuUKQv1FXWN5vZOe6/zrst9
-	f3ziIRZNjN93u+46e+2d7ebGugp9oVImRKWNi4HbYl9lw6NIlKOsZJ5Irio6XX2h5ZrN
-	3js44n4w+cgzMzOLQTMznkeTD9wjg71227WWC9Wni1RyES+ZdZRCivJDF0uBZceXKNTF
-	Z2ubLlsBzjU28Wh67un8wiIGLcw/nZt+NDHmAjzr5abas8VqhYQPC48S64cObll6UmpG
-	Vh4U1miy3HQMjIxNemafLT5fXlnFoJXl54vPZj2TYyMDjpsWkxFKm5eVkZpEh5v2gHfw
-	QImno2V37ERp5U9mq71vyD3hmZtfWnmxtr6BQetrL1aW5uc8E+6hPrvV/FNl6YljaOHR
-	0U27f90BHRXoMuUq7Zmapis2h9P14NHs/PPV9Y3NrW0M2trcWF99Pj/76IHL6bBdaao5
-	o1XJM4GO6peOTGWw0+Gm0JWdb7bc6hlyT04/A7jN7Vc7WPRqexPwnk1Puod6blmaz5fp
-	4LZIZzOoZH/ekWkMDk+coy4urzO1d/UN35+aW1xZ29zeebP7FoN23+xsb66tLM5N3R/u
-	62o31ZUXq3PEPA6DFoCOmcwTKzR6Q32r1d7veuB5+vzFH1s7b96+w6K3b3a2/njx/Knn
-	gavfbm2tN+g1CjEvmRmYDh4oQNdg7uh2jo5Pzy+vbb4CuA8fMejDu7dvXm2uLc9Pj486
-	uzvMDYhOwv8qXYXRfMMx6J6cWVhZ39rZBbhPGPTxw7vdna31lYWZSfeg44YZHimB6OAD
-	VDSZxkwmvPND96/vrk/B6b747H7oSAS8ZuFVIc0tLDlnbLOBdw9nF1c3tnfevvv46buz
-	wQk/fXz3dmd7Y3Vx9iF4Z2sznispzJXCywJetBFHQnTBPA95F8yd4MdC3gX3J9jRkHfB
-	3Al+LORdcH+CHQ15F8yd4MdC3gX3J9jRkHfB3Al+LORdcH+CHQ15F8yd4Mf+id5p/Hwn
-	w/Cl7JMf7zQBvpOFfeX77P/323YAuuX1l693/3qPoU8Bp3z/1+7rl+vL39AL+IKO6KMM
-	/Pq5j/L+Awa9/9xH+XXg2/ooqAd10lDf4utBLb3YwNuD2nix5OtBtdQbTgbvQRH9uwKi
-	f3e7b3hsam4BmlDbr//cxaI/X0P/bnlhbmpsuO820b8rCNK/i/1b7/ParZ5f3BPTT5dW
-	1za3cPU+tzbXVpeeTk+4f+m5de1vvU+/nVlv3zg7H8YVjVds3QOu+1PQN15Z29h8uYVB
-	Lzc31lagbzx13zXQbbvSCAOL/OzAfWNfz13p7bl3Qc993DM7v7S8+vs6Fv2+urw0P+sZ
-	h557l7fnTgx7/Pbcw2FekZDonVcYGkyWTkf/8L0Jz8yThaXfllcwaPm3pYUnM56Je8P9
-	jk6LCVqfxLwiEaYpB+cV4VEwO4YGnhhmPWW1TW3Wrh7nyL3xqcezT57NL2DQ/LMns4+n
-	xu+NOHu6rG1NtWUw6xFD+w7mx35mPTAnoxFzsvyi0iqj6SrMyZzDMMN76Hk8g0WPPQ9h
-	jjcMYzzbVZOxqrQon5iT0fzOydCMkeGbMRpgxmix2Xv6h0ZGx2DIOIlBMGIcGx0Z6u+x
-	2ywwY4TCEsuO4XfGeCQyGs1nUwUShUp3prKhCfBuO3r7B++OuEaxyDVyd7C/13Eb4Joa
-	Ks/oVAqJAMZkMEw5OJ8lJu++2XahvrwaZttXrZ1d3T/39Q9gGW47B/r7fu7u6rRehdl2
-	dTlY551t+528w4cUIhfAzZDkqIpOlVc3XDS1Xbt+o/M2BAOwyN51u/PG9WttposN1eWn
-	ilQ5kgwIVRC5gMP7pnhEpgJKC5kKYVauWnvqbGWtsfFS6+WrlnartQODrNZ2y9XLrZca
-	jbWVZ09p1blZQiJTQfaTqfDlUWD2nsoXyZTqIv1pQ+X5egikXDK1QCLl+6u1xXQJ4ij1
-	5ysNp/VFaqVMxE/1Wucvj3IkIopEhlQFxGVEslxVoVZfWmY4V1VTW1ffgEX1dbU1VecM
-	ZaV6baEqF+C4bEhUkElRB7M8YUSEzJuDArysHKVKc0KnP0UEoQx4hGJQp/S6ExqVMicL
-	4P6Wg/oytBAWhjJkkA0kYlpcvlAiy8nLL9AcRyGykxD3wqCTKEJ2XFOQn5cjkwj34FA+
-	cH+UB9ER+TsUcWOxU9MFmZIseU6u8phKVUAk8FBe7vtKXaBSHVPm5sizJJmC9FQUD0QB
-	twD5O2920YuXwk3nC0ViaVa2XJ4DIUMsypHLs7OkYpGQnw7ZSgIuUHYRmYeilSggmMBg
-	sZNT09L5AiER/BRjEsQ+hQJ+elpqMpvFgNwnOBcg9wl0UFsi0AtZYzqDlcTmpKSi0Gw6
-	D0tslsdLR5HZ1BQOO4nFgNAnBSLHX4n0Al4MyvTSEugMX+CYA5FjHOJwfHFjBj2BhvK8
-	MUHgwnxBcogck4APAImwNpHWZmIRSmoTUW0qBdjAuEgi6u4/q72HhzL4MQAIOXdKPNak
-	O6TcIeaOcu4QxN/L4QeAg6cKrD0ih4/2CPg2CaBdAtgEOwS8WwT+wxYg5e59Onv50EaB
-	iEjYYLG3w8K3EwLHD7hIJLG/gtgAEtA438sDdrCgbSJob8qP2Z2CrrO3NeWLNMD+t9ne
-	7z5CRPmjBJfcu/o3/4T/wa5vhgn9YciBkAMhB/43B/4NWOwBxAplbmRzdHJlYW0KZW5k
-	b2JqCjQzIDAgb2JqCjI5MDEKZW5kb2JqCjUzIDAgb2JqCjw8IC9MZW5ndGggNTQgMCBS
-	IC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFnZSAvV2lkdGggMTEwIC9IZWlnaHQg
-	NjAgL0NvbG9yU3BhY2UKL0RldmljZUdyYXkgL0JpdHNQZXJDb21wb25lbnQgOCAvRmls
-	dGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeAHtmF1XolAUhq38QvwCUQRFTBQjUXLU
-	LNOJ0lyZNpZWljb2tWr+/z+YfaCZi7SkWWvOzIXvjTccH953bzj7YLMttUxgmcAygb+U
-	wArS6h/LWG7t1n5x1tbW7EgO6zKut8NC4z7hjxYQTRRwEMLpdLpAbstCV8MitBaYgPwY
-	aKSHUE7EIAiPx0N+SrCAgJUARUCD954/o1SIBSgCMF6fHxT4hND1Pi9JIuRv3js4cGay
-	CJIEUICiKDrEfEohmqKCAb/fi4Au09/86pkwp9vtAVaQCjHhCMtGOY63LI6LsmwkzISo
-	oN9HetyQJ4pzHs6EudwEsCiaibAcH4sLCVFMWpYoJoR4jOfYCENT4I+AOAE3rzdXUIwu
-	MAa+GEAJieS6JKUzspy1KFnOpKXUejIR56MRhgr4TNxcc1A0h9OAhcJRXkimJDmrbObU
-	fKGgWVKhkFdzm0pWllJJgWfDdNBv4MDcTKMY1iBGfzAU4eJiKpNV1LxWLJbK5cq2FVUq
-	5XKpuKXlc0o2nRLjURPnctjnmAMa5Ej6gnSYiyclWVG1YrlS3ant1RsWVa/VdqqVUlFT
-	FVlKxgAHYULp5phbWbU73B6vn2KiANvIAataqzd0/bDZbLWOFqrVajYP9f3G3m61XCzk
-	spIYYxkKskTmZqI0qkYCjOVFaUPdAlZDP2y1jzsn3Z4ldU86x+3Wod6oVUuamk0leDYU
-	ROYgyjeFM4IkvAE6zAspGWC7Db3Z7nRP++eDwfBisYbDweCsf9rttJt6faes5eR1gQub
-	5tZmaShIX5BhY8mMogHs4KjT6w8uLkfXN+PJYo3HN9ejy+F5v9c5OmgATklDlmDO44LC
-	zXizO90QZJgTUln1S7V+0O6cng2vrie30+nd/WLd3U2nt5Prq+EZ4PR6taiCuSiqnHu2
-	cNAkiEZH+ISkFMq1/eZx7+xiNL6d3j88PlnS48P9dHIzAtxx8+tuKb8hCTyK8gMa9Eha
-	0Sp7evukP7i6AdjT0/OLJT0/PSLc5eAbmKtBlJLIR2igQZu8acqVVYeTIAMhVLZNbRuC
-	7PaHo8n0/hFgP6zo5QVwd9/Ho2G/29b3Kqhw/wvNrBuuJP9Bl+B7ArA+3bAFYHtz2bC+
-	lW14dxzcuykMQdgmBRvWKQgKh3PCwzu9gjnkDtNkbnvFwZyH49Rhw3uiMtyZpyoMp0UY
-	jLCehNEgZgLB4t8/5b/OfUDE9AXjFbj8WSawTGCZwGcS+AmT1iHrCmVuZHN0cmVhbQpl
-	bmRvYmoKNTQgMCBvYmoKOTMwCmVuZG9iago1NSAwIG9iago8PCAvTGVuZ3RoIDU2IDAg
-	UiAvVHlwZSAvWE9iamVjdCAvU3VidHlwZSAvSW1hZ2UgL1dpZHRoIDI2OCAvSGVpZ2h0
-	IDEwMCAvQ29sb3JTcGFjZQovRGV2aWNlR3JheSAvQml0c1BlckNvbXBvbmVudCA4IC9G
-	aWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4Ae2c+1dS6RrHrbwiIiQXBRUFRC4i
-	oiSiJRhmmZiXvNCkhmIXDMNKloya4pgykqVm5KXy0qiNOqblZNNtnX/tPO8GD5NCdc5Z
-	54e9z/7+4natWqv30/O874b3+3zDwkiRBEgCJAGSAEngf0HgCEH1b7ECBkcDOkYYBdZ0
-	FJb4A0h8HGD94eERhFR4OCwOYfkeDoyED0NkVFS0TzGEkH8xUVGR8F8MQL5Dw08iIiIS
-	MMRQKLGxsVQqNY4ggqXAgiiUmOhoxOPbNBCKY9AZAAIwUONotHg6nUEg0enxNFocEKEA
-	Dh+NEI2CoYCaQCTiaPEMxvEEJpPFYrM5hBCbzWIxmQnHGYx4WhyiAbUBjRIcBqoKVBSI
-	BB04sDmJSVwuLzk5hRBKTuZxuUmJHDbwoGM0oDQQjCAHCoYCNopYKpAAEEAhhZ+Wli4Q
-	EkSC9LQ0fgoQARxAgxqLto3gMI6gvSIqBoqCkcBO5AIHgTBDnCmRSmUyOe4lk0mlkkxx
-	hlAAPLiJ7AQGlEZMFNpBDxcGlAWgiI6Ni2cwOdyUNIFILJVlKZRKlUqVSwDBMpRKRZZM
-	KhYJ0lK4HCYjPg4qIyI8SJdAWcC2ScFQ8PiCDIlcoVTlncjXaAtBRTgXWoNWk38iT6VU
-	yCUZAj4Pg0GBDTRIYRyBsoimUGkMZiKPL8yUZ6vUGm3RKZ2+xGAwlOJesIgSve5UkVaj
-	VmXLM4V8XiKTQaNSoqEwDjaJryxiAQWHlyaSKlTqgiJdSWnZufIKY+UFAqjSWFF+rqy0
-	RFdUoFYppKI0VBm02GCFgVhAh9ABBV8kVeZpTuoNZ89XVtVerG8wEUIN9RdrqyrPnzXo
-	T2rylFIRahN6HBTGoSaBFomMjqUdZ3P5Qmm2ulBXWm6sqTNdbm4xt1ks7biXxdJmbmm+
-	bKqrMZaX6grV2VIhn8s+jgrjUJMcOQrnKZRFYoogU5FXqC+rqK6/1Gy2XLPetHXesuNe
-	tzptN63XLObmS/XVFWX6wjxFpiAlEQoDztWDGwZqEdgt2Ny0DLlKoysz1pqaWq9abfY7
-	3Y4eJwHU4+i+Y7dZr7Y2mWqNZTqNSp6RxmWjHQOa5OtXT4xFfAInRSDJVp8sBRQtFmvn
-	bYez796Aa4gAcg3c63M6bndaLS0Ao/SkOlsiSOEkxAdlERlDpTOT+CK5qkBfXm1qae+w
-	O5z3XMMj7jEPATTmHhl23XM67B3tLabqcn2BSi7iJzHp1JjIQ3URHhkTh1pErFAXGSrr
-	mywdXY4+13235+HE5GMCaHLiocd939Xn6OqwNNVXGorUCjFqkrgY2DwP9Eh4FIV2nJMs
-	kCg1xWdrLrXesDv6hkY9j6aeeGdn53Cv2Vnvk6lHntGhPof9RuulmrPFGqVEkMw5TqNE
-	BWERS4PtQihTaUvO1zVftQEK9/jkk5n55wuLS7jX4sLz+Zknk+NugGG72lx3vkSrkglh
-	w6DFBmEBxwgzKTUjKw9axGS23nYOjo5PeedeLL1cWV3DvVZXXi69mPNOjY8OOm9bzSZo
-	krysjNQkJhwkh+oCjtR4JtouTpwqq/rJYnP0D3smvfMLy6uv1jc2ca+N9Verywvz3knP
-	cL/DZvmpquzUCbRhMNFBcnC/ABZ0YJGp1OjO1TZfsztd7kdP5hZerm1sbm3v4F7bW5sb
-	ay8X5p48cruc9mvNted0GmUmsKAHZUGls7jpsHXqyy+2WO/0DnumZl4Aiq2dN7sE0Jud
-	LYDxYmbKM9x7x9pysVwPm2c6l0WnBqsLKoPFE0hztCUV9eaO7v6Rh9PzS6vrWzu77/be
-	415773Z3ttZXl+anH470d3eY6ytKtDlSAY/FCMGCnSyQqgoNxoY2m2PA/cj7/OWrP7Z3
-	373/QAC9f7e7/cerl8+9j9wDDltbg9FQqJIKktmhWcCRCiwaLZ09rrGJmYWV9a03gOLT
-	Z9zr04f3795sra8szEyMuXo6LY2IhUz4XRaVJsst55BnanZxdWN7dw9QfMG9Pn/6sLe7
-	vbG6ODvlGXLessChGooFfGSPpjLYyVhdBGHxD5zry7dZfPUt35FjEfBxBF475blFpRdM
-	7Xaoi8dzS2ubO7vvP3z+gnMS8M//8vnD+92dzbWlucdQF/Z204XSolw5vHjCB5KIYyQL
-	kgVZF2SPBPY5kgXJIkAg8ETWBckiQCDwRNYFySJAIPBE1gXJIkAg8ETWBckiQCDwRNYF
-	ySJAIPBE1gXJIkAg8ETWBckiQCDwRNbFf8uiMMj34Lj/IvxLkLooDPHdb9h37kf+n+6K
-	QrBY2Xj9du+vj7i/QYQFfPxr7+3rjZUfuDf7igV2nzr4a+A+9eMn3Otj4D7118Efu09F
-	9+ynjQ2t/nv25VebRLpn33y17L9nb20wnv72PTvmvyjA/Bd3+0fGp+cX4aJ95+2fewTQ
-	n2/Bf7GyOD89PtJ/F/NfFHzDfxH7N1/OjTu9v3gmZ54vr61vbRPDl7O9tb62/Hxm0vNL
-	750bf/PlBPUo+fxa2flg72y6Zu8ZdD+cBr/W6vrm1utt3Ov11ub6Kvi1ph+6B3vs15rA
-	4JmfHdqv5ffxqX0+vm7w8U145xaWV9Z+3yCAfl9bWV6Y806Aj6/b5+PDjL9BfXzh4O9M
-	SPT5O42NZmuXc2DkwaR39tni8m8rq7jXym/Li89mvZMPRgacXVYz2HIwf2cieF0P+zvD
-	o2CSBgwYUvD9ltc1t9u6e12jDyamn849e7GwiHstvHg293R64sGoq7fb1t5cVw6+XynY
-	L2CaJojvF/zgDMwPnl9cVm0yXwc/uGsEnPGPvU9nCaCn3sfgjh8Bc7z9utlUXVacj/nB
-	GUH94GhOgOWfEzDCnIDV7ugdGB4dG4dBgSncC8YExsdGhwd6HXYrzAlAi2DbBSvonMCx
-	yGg0P5Iqkqk0+nNVjc0A466zb2Do/qh7jAByj94fGuhz3gUUzY1V5/QalUwEdnCwuh6e
-	H8FmrPxzRUWGihqYK7pu6+ru+bl/YJAAg0WuwYH+n3u6u2zXYa6opgLKwjdXFHTGCj6o
-	YvNm/AxZjqb4TEVN42Vz+42bt7ruwsAZAeTovtt16+aNdvPlxpqKM8WaHFkGDCJi82ZH
-	D3jjsTlEaBKYQxRn5Wp1Z85X1ZmarrRdvW7tsNk6cS+brcN6/WrblSZTXdX5MzptbpYY
-	m0OkBplD9M+nwpRVqlCiUGuLDWeNVRcbYED1irkVJlTxrrZW8xUYT224WGU8ayjWqhUS
-	YaqvLILNpx6LiKJQYRIRhnUlilxNkc5QVm68UF1bV9/QSAA11NfVVl8wlpcZdEWaXEDB
-	58IUIpUSdXhuOQyLOfDNswOMrBy1pvCU3nAGG2g3EkFonP2MQX+qUKPOyQIUf5tn/3r0
-	LiwM5RxAEgg23M8XimWKnLz8gsKTKOjgNIQE4F6nUczBycKC/LwchUy8jwKlgRwcW0Ys
-	sPwLFPrA4aamizJlWcqcXPUJjaYAS8BACRJ4lrZAozmhzs1RZskyRempKAwERT6EyL/w
-	5aL4YKTw04ViiVSela1U5kCkCAGUo1RmZ8mlErEwHVJiMBShclFQYaCQGBQHksDicJNT
-	09KFIjEWmCMlhCAuRywSpqelJnM5LMjLgaoIkZcDLKBLsEgpyNZisjhJXF5KKgpSShcQ
-	IEpJIEhHMUqpKTxuEocFYTk0iNj6TqgUwIhBqVKMBCbLH7DFg4gt/IvH88drsZgJDJQo
-	FfMNFGH+CDqI2KIADcCBBa9hyWtsAgilrmGxa3QakICiiMQi+YLnru3DQMmEMYAD8vho
-	8QRK5IM0PojjQ3l8EE+4n04YAgWcq7BnYOmEKKfRH9SIkhoJIkhp9MU0/otEiDQ+37uX
-	jwYKa4yIhADP/QRPf/Yl/n/AkiKx/E4szjRkUfhfRCH9FYWeolxXIia7olXtx7p+NWV2
-	8D18/3c/D8SEmIIF7q/1h3/C3yGYfnjp5B8kCZAESAIkAZIASeA/J/BPzvUZIgplbmRz
-	dHJlYW0KZW5kb2JqCjU2IDAgb2JqCjI5NzUKZW5kb2JqCjM2IDAgb2JqCjw8IC9MZW5n
-	dGggMzcgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFnZSAvV2lkdGggMTEw
-	IC9IZWlnaHQgNjAgL0NvbG9yU3BhY2UKL0RldmljZUdyYXkgL0JpdHNQZXJDb21wb25l
-	bnQgOCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeAHtmF1XolAUhq38QvwC
-	UQRFTBQjUXLULNOJ0lyZNpZWljb2tWr+/z+YfaCZi7SkWWvOzIXvjTccH953bzj7YLMt
-	tUxgmcAygb+UwArS6h/LWG7t1n5x1tbW7EgO6zKut8NC4z7hjxYQTRRwEMLpdLpAbstC
-	V8MitBaYgPwYaKSHUE7EIAiPx0N+SrCAgJUARUCD954/o1SIBSgCMF6fHxT4hND1Pi9J
-	IuRv3js4cGayCJIEUICiKDrEfEohmqKCAb/fi4Au09/86pkwp9vtAVaQCjHhCMtGOY63
-	LI6LsmwkzISooN9HetyQJ4pzHs6EudwEsCiaibAcH4sLCVFMWpYoJoR4jOfYCENT4I+A
-	OAE3rzdXUIwuMAa+GEAJieS6JKUzspy1KFnOpKXUejIR56MRhgr4TNxcc1A0h9OAhcJR
-	XkimJDmrbObUfKGgWVKhkFdzm0pWllJJgWfDdNBv4MDcTKMY1iBGfzAU4eJiKpNV1LxW
-	LJbK5cq2FVUq5XKpuKXlc0o2nRLjURPnctjnmAMa5Ej6gnSYiyclWVG1YrlS3ant1RsW
-	Va/VdqqVUlFTFVlKxgAHYULp5phbWbU73B6vn2KiANvIAataqzd0/bDZbLWOFqrVajYP
-	9f3G3m61XCzkspIYYxkKskTmZqI0qkYCjOVFaUPdAlZDP2y1jzsn3Z4ldU86x+3Wod6o
-	VUuamk0leDYUROYgyjeFM4IkvAE6zAspGWC7Db3Z7nRP++eDwfBisYbDweCsf9rttJt6
-	faes5eR1gQub5tZmaShIX5BhY8mMogHs4KjT6w8uLkfXN+PJYo3HN9ejy+F5v9c5OmgA
-	TklDlmDO44LCzXizO90QZJgTUln1S7V+0O6cng2vrie30+nd/WLd3U2nt5Prq+EZ4PR6
-	taiCuSiqnHu2cNAkiEZH+ISkFMq1/eZx7+xiNL6d3j88PlnS48P9dHIzAtxx8+tuKb8h
-	CTyK8gMa9Eha0Sp7evukP7i6AdjT0/OLJT0/PSLc5eAbmKtBlJLIR2igQZu8acqVVYeT
-	IAMhVLZNbRuC7PaHo8n0/hFgP6zo5QVwd9/Ho2G/29b3Kqhw/wvNrBuuJP9Bl+B7ArA+
-	3bAFYHtz2bC+lW14dxzcuykMQdgmBRvWKQgKh3PCwzu9gjnkDtNkbnvFwZyH49Rhw3ui
-	MtyZpyoMp0UYjLCehNEgZgLB4t8/5b/OfUDE9AXjFbj8WSawTGCZwGcS+AmT1iHrCmVu
-	ZHN0cmVhbQplbmRvYmoKMzcgMCBvYmoKOTMwCmVuZG9iago1NyAwIG9iago8PCAvTGVu
-	Z3RoIDU4IDAgUiAvVHlwZSAvWE9iamVjdCAvU3VidHlwZSAvSW1hZ2UgL1dpZHRoIDI2
-	OCAvSGVpZ2h0IDEwMCAvQ29sb3JTcGFjZQovRGV2aWNlR3JheSAvQml0c1BlckNvbXBv
-	bmVudCA4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4Ae2c+1dS6RrHrbwi
-	IiQXBRUFRC4ioiSiJRhmmZiXvNCkhmIXDMNKloya4pgykqVm5KXy0qiNOqblZNNtnX/t
-	PO8GD5NCdc5Z54e9z/7+4natWqv30/O874b3+3zDwkiRBEgCJAGSAEngf0HgCEH1b7EC
-	BkcDOkYYBdZ0FJb4A0h8HGD94eERhFR4OCwOYfkeDoyED0NkVFS0TzGEkH8xUVGR8F8M
-	QL5Dw08iIiISMMRQKLGxsVQqNY4ggqXAgiiUmOhoxOPbNBCKY9AZAAIwUONotHg6nUEg
-	0enxNFocEKEADh+NEI2CoYCaQCTiaPEMxvEEJpPFYrM5hBCbzWIxmQnHGYx4WhyiAbUB
-	jRIcBqoKVBSIBB04sDmJSVwuLzk5hRBKTuZxuUmJHDbwoGM0oDQQjCAHCoYCNopYKpAA
-	EEAhhZ+Wli4QEkSC9LQ0fgoQARxAgxqLto3gMI6gvSIqBoqCkcBO5AIHgTBDnCmRSmUy
-	Oe4lk0mlkkxxhlAAPLiJ7AQGlEZMFNpBDxcGlAWgiI6Ni2cwOdyUNIFILJVlKZRKlUqV
-	SwDBMpRKRZZMKhYJ0lK4HCYjPg4qIyI8SJdAWcC2ScFQ8PiCDIlcoVTlncjXaAtBRTgX
-	WoNWk38iT6VUyCUZAj4Pg0GBDTRIYRyBsoimUGkMZiKPL8yUZ6vUGm3RKZ2+xGAwlOJe
-	sIgSve5UkVajVmXLM4V8XiKTQaNSoqEwDjaJryxiAQWHlyaSKlTqgiJdSWnZufIKY+UF
-	AqjSWFF+rqy0RFdUoFYppKI0VBm02GCFgVhAh9ABBV8kVeZpTuoNZ89XVtVerG8wEUIN
-	9RdrqyrPnzXoT2rylFIRahN6HBTGoSaBFomMjqUdZ3P5Qmm2ulBXWm6sqTNdbm4xt1ks
-	7biXxdJmbmm+bKqrMZaX6grV2VIhn8s+jgrjUJMcOQrnKZRFYoogU5FXqC+rqK6/1Gy2
-	XLPetHXesuNetzptN63XLObmS/XVFWX6wjxFpiAlEQoDztWDGwZqEdgt2Ny0DLlKoysz
-	1pqaWq9abfY73Y4eJwHU4+i+Y7dZr7Y2mWqNZTqNSp6RxmWjHQOa5OtXT4xFfAInRSDJ
-	Vp8sBRQtFmvnbYez796Aa4gAcg3c63M6bndaLS0Ao/SkOlsiSOEkxAdlERlDpTOT+CK5
-	qkBfXm1qae+wO5z3XMMj7jEPATTmHhl23XM67B3tLabqcn2BSi7iJzHp1JjIQ3URHhkT
-	h1pErFAXGSrrmywdXY4+13235+HE5GMCaHLiocd939Xn6OqwNNVXGorUCjFqkrgY2DwP
-	9Eh4FIV2nJMskCg1xWdrLrXesDv6hkY9j6aeeGdn53Cv2Vnvk6lHntGhPof9RuulmrPF
-	GqVEkMw5TqNEBWERS4PtQihTaUvO1zVftQEK9/jkk5n55wuLS7jX4sLz+Zknk+NugGG7
-	2lx3vkSrkglhw6DFBmEBxwgzKTUjKw9axGS23nYOjo5PeedeLL1cWV3DvVZXXi69mPNO
-	jY8OOm9bzSZokrysjNQkJhwkh+oCjtR4JtouTpwqq/rJYnP0D3smvfMLy6uv1jc2ca+N
-	9Verywvz3knPcL/DZvmpquzUCbRhMNFBcnC/ABZ0YJGp1OjO1TZfsztd7kdP5hZerm1s
-	bm3v4F7bW5sbay8X5p48cruc9mvNted0GmUmsKAHZUGls7jpsHXqyy+2WO/0DnumZl4A
-	iq2dN7sE0JudLYDxYmbKM9x7x9pysVwPm2c6l0WnBqsLKoPFE0hztCUV9eaO7v6Rh9Pz
-	S6vrWzu77/be415773Z3ttZXl+anH470d3eY6ytKtDlSAY/FCMGCnSyQqgoNxoY2m2PA
-	/cj7/OWrP7Z3373/QAC9f7e7/cerl8+9j9wDDltbg9FQqJIKktmhWcCRCiwaLZ09rrGJ
-	mYWV9a03gOLTZ9zr04f3795sra8szEyMuXo6LY2IhUz4XRaVJsst55BnanZxdWN7dw9Q
-	fMG9Pn/6sLe7vbG6ODvlGXLessChGooFfGSPpjLYyVhdBGHxD5zry7dZfPUt35FjEfBx
-	BF475blFpRdM7Xaoi8dzS2ubO7vvP3z+gnMS8M//8vnD+92dzbWlucdQF/Z204XSolw5
-	vHjCB5KIYyQLkgVZF2SPBPY5kgXJIkAg8ETWBckiQCDwRNYFySJAIPBE1gXJIkAg8ETW
-	BckiQCDwRNYFySJAIPBE1gXJIkAg8ETWBckiQCDwRNbFf8uiMMj34Lj/IvxLkLooDPHd
-	b9h37kf+n+6KQrBY2Xj9du+vj7i/QYQFfPxr7+3rjZUfuDf7igV2nzr4a+A+9eMn3Otj
-	4D7118Efu09F9+ynjQ2t/nv25VebRLpn33y17L9nb20wnv72PTvmvyjA/Bd3+0fGp+cX
-	4aJ95+2fewTQn2/Bf7GyOD89PtJ/F/NfFHzDfxH7N1/OjTu9v3gmZ54vr61vbRPDl7O9
-	tb62/Hxm0vNL750bf/PlBPUo+fxa2flg72y6Zu8ZdD+cBr/W6vrm1utt3Ov11ub6Kvi1
-	ph+6B3vs15rA4JmfHdqv5ffxqX0+vm7w8U145xaWV9Z+3yCAfl9bWV6Y806Aj6/b5+PD
-	jL9BfXzh4O9MSPT5O42NZmuXc2DkwaR39tni8m8rq7jXym/Li89mvZMPRgacXVYz2HIw
-	f2cieF0P+zvDo2CSBgwYUvD9ltc1t9u6e12jDyamn849e7GwiHstvHg293R64sGoq7fb
-	1t5cVw6+XynYL2CaJojvF/zgDMwPnl9cVm0yXwc/uGsEnPGPvU9nCaCn3sfgjh8Bc7z9
-	utlUXVacj/nBGUH94GhOgOWfEzDCnIDV7ugdGB4dG4dBgSncC8YExsdGhwd6HXYrzAlA
-	i2DbBSvonMCxyGg0P5Iqkqk0+nNVjc0A466zb2Do/qh7jAByj94fGuhz3gUUzY1V5/Qa
-	lUwEdnCwuh6eH8FmrPxzRUWGihqYK7pu6+ru+bl/YJAAg0WuwYH+n3u6u2zXYa6opgLK
-	wjdXFHTGCj6oYvNm/AxZjqb4TEVN42Vz+42bt7ruwsAZAeTovtt16+aNdvPlxpqKM8Wa
-	HFkGDCJi82ZHD3jjsTlEaBKYQxRn5Wp1Z85X1ZmarrRdvW7tsNk6cS+brcN6/WrblSZT
-	XdX5MzptbpYYm0OkBplD9M+nwpRVqlCiUGuLDWeNVRcbYED1irkVJlTxrrZW8xUYT224
-	WGU8ayjWqhUSYaqvLILNpx6LiKJQYRIRhnUlilxNkc5QVm68UF1bV9/QSAA11NfVVl8w
-	lpcZdEWaXEDB58IUIpUSdXhuOQyLOfDNswOMrBy1pvCU3nAGG2g3EkFonP2MQX+qUKPO
-	yQIUf5tn/3r0LiwM5RxAEgg23M8XimWKnLz8gsKTKOjgNIQE4F6nUczBycKC/LwchUy8
-	jwKlgRwcW0YssPwLFPrA4aamizJlWcqcXPUJjaYAS8BACRJ4lrZAozmhzs1RZskyRemp
-	KAwERT6EyL/w5aL4YKTw04ViiVSela1U5kCkCAGUo1RmZ8mlErEwHVJiMBShclFQYaCQ
-	GBQHksDicJNT09KFIjEWmCMlhCAuRywSpqelJnM5LMjLgaoIkZcDLKBLsEgpyNZisjhJ
-	XF5KKgpSShcQIEpJIEhHMUqpKTxuEocFYTk0iNj6TqgUwIhBqVKMBCbLH7DFg4gt/IvH
-	88drsZgJDJQoFfMNFGH+CDqI2KIADcCBBa9hyWtsAgilrmGxa3QakICiiMQi+YLnru3D
-	QMmEMYAD8vho8QRK5IM0PojjQ3l8EE+4n04YAgWcq7BnYOmEKKfRH9SIkhoJIkhp9MU0
-	/otEiDQ+37uXjwYKa4yIhADP/QRPf/Yl/n/AkiKx/E4szjRkUfhfRCH9FYWeolxXIia7
-	olXtx7p+NWV28D18/3c/D8SEmIIF7q/1h3/C3yGYfnjp5B8kCZAESAIkAZIASeA/J/BP
-	zvUZIgplbmRzdHJlYW0KZW5kb2JqCjU4IDAgb2JqCjI5NzUKZW5kb2JqCjM5IDAgb2Jq
-	Cjw8IC9MZW5ndGggNDAgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9JbWFnZSAv
-	V2lkdGggMjY4IC9IZWlnaHQgMTAwIC9Db2xvclNwYWNlCi9EZXZpY2VHcmF5IC9CaXRz
-	UGVyQ29tcG9uZW50IDggL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCngB7Zz7
-	V1LpGsetvCIiJBcFFQVELiKiJKIlGGaZmJe80KSGYhcMw0qWjJrimDKSpWbkpfLSqI06
-	puVk022df+087wYPk0J1zlnnh73P/v7idq1aq/fT87zvhvf7fMPCSJEESAIkAZIASeB/
-	QeAIQfVvsQIGRwM6RhgF1nQUlvgDSHwcYP3h4RGEVHg4LA5h+R4OjIQPQ2RUVLRPMYSQ
-	fzFRUZHwXwxAvkPDTyIiIhIwxFAosbGxVCo1jiCCpcCCKJSY6GjE49s0EIpj0BkAAjBQ
-	42i0eDqdQSDR6fE0WhwQoQAOH40QjYKhgJpAJOJo8QzG8QQmk8ViszmEEJvNYjGZCccZ
-	jHhaHKIBtQGNEhwGqgpUFIgEHTiwOYlJXC4vOTmFEEpO5nG5SYkcNvCgYzSgNBCMIAcK
-	hgI2ilgqkAAQQCGFn5aWLhASRIL0tDR+ChABHECDGou2jeAwjqC9IioGioKRwE7kAgeB
-	MEOcKZFKZTI57iWTSaWSTHGGUAA8uInsBAaURkwU2kEPFwaUBaCIjo2LZzA53JQ0gUgs
-	lWUplEqVSpVLAMEylEpFlkwqFgnSUrgcJiM+DiojIjxIl0BZwLZJwVDw+IIMiVyhVOWd
-	yNdoC0FFOBdag1aTfyJPpVTIJRkCPg+DQYENNEhhHIGyiKZQaQxmIo8vzJRnq9QabdEp
-	nb7EYDCU4l6wiBK97lSRVqNWZcszhXxeIpNBo1KioTAONomvLGIBBYeXJpIqVOqCIl1J
-	adm58gpj5QUCqNJYUX6urLREV1SgVimkojRUGbTYYIWBWECH0AEFXyRV5mlO6g1nz1dW
-	1V6sbzARQg31F2urKs+fNehPavKUUhFqE3ocFMahJoEWiYyOpR1nc/lCaba6UFdabqyp
-	M11ubjG3WSztuJfF0mZuab5sqqsxlpfqCtXZUiGfyz6OCuNQkxw5CucplEViiiBTkVeo
-	L6uorr/UbLZcs960dd6y4163Om03rdcs5uZL9dUVZfrCPEWmICURCgPO1YMbBmoR2C3Y
-	3LQMuUqjKzPWmppar1pt9jvdjh4nAdTj6L5jt1mvtjaZao1lOo1KnpHGZaMdA5rk61dP
-	jEV8AidFIMlWnywFFC0Wa+dth7Pv3oBriAByDdzrczpud1otLQCj9KQ6WyJI4STEB2UR
-	GUOlM5P4IrmqQF9ebWpp77A7nPdcwyPuMQ8BNOYeGXbdczrsHe0tpupyfYFKLuInMenU
-	mMhDdREeGROHWkSsUBcZKuubLB1djj7Xfbfn4cTkYwJocuKhx33f1efo6rA01VcaitQK
-	MWqSuBjYPA/0SHgUhXackyyQKDXFZ2sutd6wO/qGRj2Ppp54Z2fncK/ZWe+TqUee0aE+
-	h/1G66Was8UapUSQzDlOo0QFYRFLg+1CKFNpS87XNV+1AQr3+OSTmfnnC4tLuNfiwvP5
-	mSeT426AYbvaXHe+RKuSCWHDoMUGYQHHCDMpNSMrD1rEZLbedg6Ojk95514svVxZXcO9
-	VldeLr2Y806Njw46b1vNJmiSvKyM1CQmHCSH6gKO1Hgm2i5OnCqr+slic/QPeya98wvL
-	q6/WNzZxr431V6vLC/PeSc9wv8Nm+amq7NQJtGEw0UFycL8AFnRgkanU6M7VNl+zO13u
-	R0/mFl6ubWxube/gXttbmxtrLxfmnjxyu5z2a82153QaZSawoAdlQaWzuOmwderLL7ZY
-	7/QOe6ZmXgCKrZ03uwTQm50tgPFiZsoz3HvH2nKxXA+bZzqXRacGqwsqg8UTSHO0JRX1
-	5o7u/pGH0/NLq+tbO7vv9t7jXnvvdne21leX5qcfjvR3d5jrK0q0OVIBj8UIwYKdLJCq
-	Cg3GhjabY8D9yPv85as/tnffvf9AAL1/t7v9x6uXz72P3AMOW1uD0VCokgqS2aFZwJEK
-	LBotnT2usYmZhZX1rTeA4tNn3OvTh/fv3mytryzMTIy5ejotjYiFTPhdFpUmyy3nkGdq
-	dnF1Y3t3D1B8wb0+f/qwt7u9sbo4O+UZct6ywKEaigV8ZI+mMtjJWF0EYfEPnOvLt1l8
-	9S3fkWMR8HEEXjvluUWlF0ztdqiLx3NLa5s7u+8/fP6CcxLwz//y+cP73Z3NtaW5x1AX
-	9nbThdKiXDm8eMIHkohjJAuSBVkXZI8E9jmSBckiQCDwRNYFySJAIPBE1gXJIkAg8ETW
-	BckiQCDwRNYFySJAIPBE1gXJIkAg8ETWBckiQCDwRNYFySJAIPBE1sV/y6IwyPfguP8i
-	/EuQuigM8d1v2HfuR/6f7opCsFjZeP1276+PuL9BhAV8/Gvv7euNlR+4N/uKBXafOvhr
-	4D714yfc62PgPvXXwR+7T0X37KeNDa3+e/blV5tEumfffLXsv2dvbTCe/vY9O+a/KMD8
-	F3f7R8an5xfhon3n7Z97BNCfb8F/sbI4Pz0+0n8X818UfMN/Efs3X86NO72/eCZnni+v
-	rW9tE8OXs721vrb8fGbS80vvnRt/8+UE9Sj5/FrZ+WDvbLpm7xl0P5wGv9bq+ubW623c
-	6/XW5voq+LWmH7oHe+zXmsDgmZ8d2q/l9/GpfT6+bvDxTXjnFpZX1n7fIIB+X1tZXpjz
-	ToCPr9vn48OMv0F9fOHg70xI9Pk7jY1ma5dzYOTBpHf22eLybyuruNfKb8uLz2a9kw9G
-	BpxdVjPYcjB/ZyJ4XQ/7O8OjYJIGDBhS8P2W1zW327p7XaMPJqafzj17sbCIey28eDb3
-	dHriwairt9vW3lxXDr5fKdgvYJomiO8X/OAMzA+eX1xWbTJfBz+4awSc8Y+9T2cJoKfe
-	x+COHwFzvP262VRdVpyP+cEZQf3gaE6A5Z8TMMKcgNXu6B0YHh0bh0GBKdwLxgTGx0aH
-	B3oddivMCUCLYNsFK+icwLHIaDQ/kiqSqTT6c1WNzQDjrrNvYOj+qHuMAHKP3h8a6HPe
-	BRTNjVXn9BqVTAR2cLC6Hp4fwWas/HNFRYaKGpgrum7r6u75uX9gkACDRa7Bgf6fe7q7
-	bNdhrqimAsrCN1cUdMYKPqhi82b8DFmOpvhMRU3jZXP7jZu3uu7CwBkB5Oi+23Xr5o12
-	8+XGmoozxZocWQYMImLzZkcPeOOxOURoEphDFGflanVnzlfVmZqutF29bu2w2TpxL5ut
-	w3r9atuVJlNd1fkzOm1ulhibQ6QGmUP0z6fClFWqUKJQa4sNZ41VFxtgQPWKuRUmVPGu
-	tlbzFRhPbbhYZTxrKNaqFRJhqq8sgs2nHouIolBhEhGGdSWKXE2RzlBWbrxQXVtX39BI
-	ADXU19VWXzCWlxl0RZpcQMHnwhQilRJ1eG45DIs58M2zA4ysHLWm8JTecAYbaDcSQWic
-	/YxBf6pQo87JAhR/m2f/evQuLAzlHEASCDbczxeKZYqcvPyCwpMo6OA0hATgXqdRzMHJ
-	woL8vByFTLyPAqWBHBxbRiyw/AsU+sDhpqaLMmVZypxc9QmNpgBLwEAJEniWtkCjOaHO
-	zVFmyTJF6akoDARFPoTIv/DlovhgpPDThWKJVJ6VrVTmQKQIAZSjVGZnyaUSsTAdUmIw
-	FKFyUVBhoJAYFAeSwOJwk1PT0oUiMRaYIyWEIC5HLBKmp6UmczksyMuBqgiRlwMsoEuw
-	SCnI1mKyOElcXkoqClJKFxAgSkkgSEcxSqkpPG4ShwVhOTSI2PpOqBTAiEGpUowEJssf
-	sMWDiC38i8fzx2uxmAkMlCgV8w0UYf4IOojYogANwIEFr2HJa2wCCKWuYbFrdBqQgKKI
-	xCL5gueu7cNAyYQxgAPy+GjxBErkgzQ+iONDeXwQT7ifThgCBZyrsGdg6YQop9Ef1IiS
-	GgkiSGn0xTT+i0SIND7fu5ePBgprjIiEAM/9BE9/9iX+f8CSIrH8TizONGRR+F9EIf0V
-	hZ6iXFciJruiVe3Hun41ZXbwPXz/dz8PxISYggXur/WHf8LfIZh+eOnkHyQJkARIAiQB
-	kgBJ4D8n8E/O9RkiCmVuZHN0cmVhbQplbmRvYmoKNDAgMCBvYmoKMjk3NQplbmRvYmoK
-	NDQgMCBvYmoKPDwgL0xlbmd0aCA0NSAwIFIgL1R5cGUgL1hPYmplY3QgL1N1YnR5cGUg
-	L0ltYWdlIC9XaWR0aCAxMTAgL0hlaWdodCA2MCAvQ29sb3JTcGFjZQovRGV2aWNlR3Jh
-	eSAvQml0c1BlckNvbXBvbmVudCA4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVh
-	bQp4Ae2YXVeiUBSGrfxC/AJRBEVMFCNRctQs04nSXJk2llaWNva1av7/P5h9oJmLtKRZ
-	a87Mhe+NNxwf3ndvOPtgsy21TGCZwDKBv5TACtLqH8tYbu3WfnHW1tbsSA7rMq63w0Lj
-	PuGPFhBNFHAQwul0ukBuy0JXwyK0FpiA/BhopIdQTsQgCI/HQ35KsICAlQBFQIP3nj+j
-	VIgFKAIwXp8fFPiE0PU+L0ki5G/eOzhwZrIIkgRQgKIoOsR8SiGaooIBv9+LgC7T3/zq
-	mTCn2+0BVpAKMeEIy0Y5jrcsjouybCTMhKig30d63JAninMezoS53ASwKJqJsBwfiwsJ
-	UUxaligmhHiM59gIQ1Pgj4A4ATevN1dQjC4wBr4YQAmJ5LokpTOynLUoWc6kpdR6MhHn
-	oxGGCvhM3FxzUDSH04CFwlFeSKYkOats5tR8oaBZUqGQV3ObSlaWUkmBZ8N00G/gwNxM
-	oxjWIEZ/MBTh4mIqk1XUvFYslsrlyrYVVSrlcqm4peVzSjadEuNRE+dy2OeYAxrkSPqC
-	dJiLJyVZUbViuVLdqe3VGxZVr9V2qpVSUVMVWUrGAAdhQunmmFtZtTvcHq+fYqIA28gB
-	q1qrN3T9sNlstY4WqtVqNg/1/cbebrVcLOSykhhjGQqyROZmojSqRgKM5UVpQ90CVkM/
-	bLWPOyfdniV1TzrH7dah3qhVS5qaTSV4NhRE5iDKN4UzgiS8ATrMCykZYLsNvdnudE/7
-	54PB8GKxhsPB4Kx/2u20m3p9p6zl5HWBC5vm1mZpKEhfkGFjyYyiAezgqNPrDy4uR9c3
-	48lijcc316PL4Xm/1zk6aABOSUOWYM7jgsLNeLM73RBkmBNSWfVLtX7Q7pyeDa+uJ7fT
-	6d39Yt3dTae3k+ur4Rng9Hq1qIK5KKqce7Zw0CSIRkf4hKQUyrX95nHv7GI0vp3ePzw+
-	WdLjw/10cjMC3HHz624pvyEJPIryAxr0SFrRKnt6+6Q/uLoB2NPT84slPT89Itzl4BuY
-	q0GUkshHaKBBm7xpypVVh5MgAyFUtk1tG4Ls9oejyfT+EWA/rOjlBXB338ejYb/b1vcq
-	qHD/C82sG64k/0GX4HsCsD7dsAVge3PZsL6VbXh3HNy7KQxB2CYFG9YpCAqHc8LDO72C
-	OeQO02Rue8XBnIfj1GHDe6Iy3JmnKgynRRiMsJ6E0SBmAsHi3z/lv859QMT0BeMVuPxZ
-	JrBMYJnAZxL4CZPWIesKZW5kc3RyZWFtCmVuZG9iago0NSAwIG9iago5MzAKZW5kb2Jq
-	CjU5IDAgb2JqCjw8IC9MZW5ndGggNjAgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBl
-	IC9JbWFnZSAvV2lkdGggNzggL0hlaWdodCA2MCAvQ29sb3JTcGFjZQovRGV2aWNlR3Jh
-	eSAvQml0c1BlckNvbXBvbmVudCA4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVh
-	bQp4Ae2Wa3/pWBTGtSUkccutRIVUKqiglFKlpUFLdbTojY46dabz/b/BrL3TnjM96ryZ
-	/W48b/ySzd+znpXsvWy2tdYJrBNYmcAG0uZK4eWVP/608MHZ2tqyIzl+Cl/D/S38P/DF
-	Tz9cvrBQwEEIiqKcINeH0IWTotCS3Y6Jv+fh6hCKQgyaZhiG/SSGoWlYcSIkBq7m4agQ
-	C1A0YNweL8j3U+jS43GzLENjIOKtxIEzi0WzLIB8HMfxgvhvCQLPcX6fF4gM4ln2lgOD
-	OxaMcrkYYPk5QZS2A4GgLId+SA4GAwFJFHnO73Wz4A/KXeHOgjldNLA4XtwOyKGdsBKJ
-	RtUfikYUJRwKBYGIeJY9wH1hbgOV6QRj4EsElBJRdzVtL67riXfpenxPi6lRIAYkgfN6
-	wB7lQNkt4yA0B4VhghQMKWpM0xOp/bSRyWZzWNmMYaRTST2u7UaBJ3I+wDlRdss0bA3K
-	9PqFbTkcjcUTKSOTy+cPi8XSEVKpVCwW8gc5I53UNVV5x1nmlrwBDepkPX5eksOqpqeM
-	XL5YKleqJ7W6pdpJ9bhyVCwcZNPJeCyCcCg7CjXiV9zGpt3hYtxeTgwCLJkGVrlaqzca
-	56bZarXbrZZpNhun9Wrl6PAgk9Jj4E7we1lo7Bel4tRYgAVCUS1pHACr3jhvdS67vas+
-	1lW3e9E2m6e1Simf3Y+riizxPjft+oKGC6XdPl4KKTEdYMf1htnpXl0PbofD0Xg8Ho2G
-	tzd/9HuX7fPTarmQTe2pO6hWFpf6S6VWoR6/GNhR46kcwJrtbn8wHN89PD5NptPpZPL0
-	eH83vLnuXZiNk3LeSGiRkMR7WRo9JMs0ygWFSrISSxiFcq3Z6V7fjO4fp8+z2ct8Pn95
-	mf05nTzeDQf9C/OsWsxhc4LfzaDgvqbx26GIlsoWq2fmZf9m/DB5ns2/vS6wXucvsynC
-	9TrNejmf1nfDQdHv+R0NerCXypVOGp3eYHj/BLDF4q83rO+L1znC3fYvzdNKwUjElKDI
-	eVjUhiVvDopmfQKKbT93BIVeDUYP09n8FWB/I729fV98mz0/3Q2vu62z48MM0GTchuWm
-	bmySpdlRF3hSlVo0ol0g94TAa0ru6YUthNibZSP61sMZQ3JHIr1bwiFDbCe3ET1lIDiS
-	JyDZ05ns5PAxiMA5SGKqsZGduLA7a+oiMA3Cdkx0UkXbuwUEi/99in4/LYBIaMJ/B64/
-	1gn83xL4B0WcGxAKZW5kc3RyZWFtCmVuZG9iago2MCAwIG9iago5MjcKZW5kb2JqCjYx
-	IDAgb2JqCjw8IC9MZW5ndGggNjIgMCBSIC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9J
-	bWFnZSAvV2lkdGggMTU4IC9IZWlnaHQgMTAwIC9Db2xvclNwYWNlCi9EZXZpY2VHcmF5
-	IC9CaXRzUGVyQ29tcG9uZW50IDggL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFt
-	CngB7Zv7V1LpGsetvCIiJBcFFQVELiKiJIIlGGaZmJe80KSGYhcMw0qWjJrimDKSpWbk
-	pfLSqI06puVk022df+087wZPkwJ11untrDWL7y8u19a9P+v7vHtveJ7vGxYWUsiBkAP/
-	DAcO/TD9V34B1eHPOoJRn69yGC76DZBeMiAKD4/4QQoPh8sh0K8BEmxesMioqGivYjDJ
-	d/qoqEiwARC/wudji4iIBLAYEik2NpZMJsdhE5wcLkEixURHI8LgfAjuCNQT0ACMHEeh
-	xFOpNKyiUuMplDhgJAGgly9AeQk48A2xxVHiabSjCXQ6g8FksjCJyWQw6PSEozRaPCUO
-	8YF/UF7/eMg5ZBxiowIZk5WYxGZzkpNTMCk5mcNmJyWymEBIJfjAPoTn5+Yl4GDBxZKB
-	DdCAK4WblpbO42MTLz0tjZsCjAAIfORYtPz84x1Cay4qBoyjJTAT2UDG42cIM0VisUQi
-	xSCJRCwWZQoz+DwgZCcyE2hgX0wUujcOmgfWAVx0bFw8jc5ip6TxBEKxJEsmlysUilws
-	ghPL5bIsiVgo4KWlsFl0WnwcuBcR7qe2YB3cECQCjsPlZYikMrki71i+Sq0BFX53obOq
-	VfnH8hRymVSUweNyCDwS3Bp+zDsE1kWTyBQaPZHD5WdKsxVKlbrwhFZXrNfrSzAITlus
-	054oVKuUimxpJp/LSaTTKGRSNJi3v7Re62IBjsVJE4hlCmVBoba4pPRMWbmh4hwWVRjK
-	y86UlhRrCwuUCplYkIbco8T6Mw/RQV2pAMcViOV5quM6/emzFZU15+vqjZhUX3e+prLi
-	7Gm97rgqTy4WoOJS48C8A6WFwkZGx1KOMtlcvjhbqdGWlBmqa40Xm5pNrWZzGwaZza2m
-	5qaLxtpqQ1mJVqPMFvO5bOZRZN6B0h46DE8TsC4xhZcpy9PoSsur6i40mcxXLNetHTds
-	GHSjw3rdcsVsarpQV1VeqtPkyTJ5KYlgHjxV9i88VFhYdUx2WoZUodKWGmqMjS2XLVbb
-	rS57twOLuu1dt2xWy+WWRmONoVSrUkgz0thMtPKgtF++Lgi6+ARWCk+UrTxeAnDNZkvH
-	Tbuj906/cxCLnP13eh32mx0WczPglRxXZot4KayEeL90kTFkKj2JK5AqCnRlVcbmtnab
-	3XHHOTTsGnVj0ahreMh5x2G3tbc1G6vKdAUKqYCbRKeSYyIPeBceGROHCiuUKQv1FXWN
-	5vZOe6/zrst9f3ziIRZNjN93u+46e+2d7ebGugp9oVImRKWNi4HbYl9lw6NIlKOsZJ5I
-	rio6XX2h5ZrN3js44n4w+cgzMzOLQTMznkeTD9wjg71227WWC9Wni1RyES+ZdZRCivJD
-	F0uBZceXKNTFZ2ubLlsBzjU28Wh67un8wiIGLcw/nZt+NDHmAjzr5abas8VqhYQPC48S
-	64cObll6UmpGVh4U1miy3HQMjIxNemafLT5fXlnFoJXl54vPZj2TYyMDjpsWkxFKm5eV
-	kZpEh5v2gHfwQImno2V37ERp5U9mq71vyD3hmZtfWnmxtr6BQetrL1aW5uc8E+6hPrvV
-	/FNl6YljaOHR0U27f90BHRXoMuUq7Zmapis2h9P14NHs/PPV9Y3NrW0M2trcWF99Pj/7
-	6IHL6bBdaao5o1XJM4GO6peOTGWw0+Gm0JWdb7bc6hlyT04/A7jN7Vc7WPRqexPwnk1P
-	uod6blmaz5fp4LZIZzOoZH/ekWkMDk+coy4urzO1d/UN35+aW1xZ29zeebP7FoN23+xs
-	b66tLM5N3R/u62o31ZUXq3PEPA6DFoCOmcwTKzR6Q32r1d7veuB5+vzFH1s7b96+w6K3
-	b3a2/njx/Knngavfbm2tN+g1CjEvmRmYDh4oQNdg7uh2jo5Pzy+vbb4CuA8fMejDu7dv
-	Xm2uLc9Pj486uzvMDYhOwv8qXYXRfMMx6J6cWVhZ39rZBbhPGPTxw7vdna31lYWZSfeg
-	44YZHimB6OADVDSZxkwmvPND96/vrk/B6b747H7oSAS8ZuFVIc0tLDlnbLOBdw9nF1c3
-	tnfevvv46buzwQk/fXz3dmd7Y3Vx9iF4Z2sznispzJXCywJetBFHQnTBPA95F8yd4MdC
-	3gX3J9jRkHfB3Al+LORdcH+CHQ15F8yd4MdC3gX3J9jRkHfB3Al+LORdcH+CHQ15F8yd
-	4Mf+id5p/Hwnw/Cl7JMf7zQBvpOFfeX77P/323YAuuX1l693/3qPoU8Bp3z/1+7rl+vL
-	39AL+IKO6KMM/Pq5j/L+Awa9/9xH+XXg2/ooqAd10lDf4utBLb3YwNuD2nix5OtBtdQb
-	TgbvQRH9uwKif3e7b3hsam4BmlDbr//cxaI/X0P/bnlhbmpsuO820b8rCNK/i/1b7/Pa
-	rZ5f3BPTT5dW1za3cPU+tzbXVpeeTk+4f+m5de1vvU+/nVlv3zg7H8YVjVds3QOu+1PQ
-	N15Z29h8uYVBLzc31lagbzx13zXQbbvSCAOL/OzAfWNfz13p7bl3Qc993DM7v7S8+vs6
-	Fv2+urw0P+sZh557l7fnTgx7/Pbcw2FekZDonVcYGkyWTkf/8L0Jz8yThaXfllcwaPm3
-	pYUnM56Je8P9jk6LCVqfxLwiEaYpB+cV4VEwO4YGnhhmPWW1TW3Wrh7nyL3xqcezT57N
-	L2DQ/LMns4+nxu+NOHu6rG1NtWUw6xFD+w7mx35mPTAnoxFzsvyi0iqj6SrMyZzDMMN7
-	6Hk8g0WPPQ9hjjcMYzzbVZOxqrQon5iT0fzOydCMkeGbMRpgxmix2Xv6h0ZGx2DIOIlB
-	MGIcGx0Z6u+x2ywwY4TCEsuO4XfGeCQyGs1nUwUShUp3prKhCfBuO3r7B++OuEaxyDVy
-	d7C/13Eb4JoaKs/oVAqJAMZkMEw5OJ8lJu++2XahvrwaZttXrZ1d3T/39Q9gGW47B/r7
-	fu7u6rRehdl2dTlY551t+528w4cUIhfAzZDkqIpOlVc3XDS1Xbt+o/M2BAOwyN51u/PG
-	9WttposN1eWnilQ5kgwIVRC5gMP7pnhEpgJKC5kKYVauWnvqbGWtsfFS6+WrlnartQOD
-	rNZ2y9XLrZcajbWVZ09p1blZQiJTQfaTqfDlUWD2nsoXyZTqIv1pQ+X5egikXDK1QCLl
-	+6u1xXQJ4ij15ysNp/VFaqVMxE/1Wucvj3IkIopEhlQFxGVEslxVoVZfWmY4V1VTW1ff
-	gEX1dbU1VecMZaV6baEqF+C4bEhUkElRB7M8YUSEzJuDArysHKVKc0KnP0UEoQx4hGJQ
-	p/S6ExqVMicL4P6Wg/oytBAWhjJkkA0kYlpcvlAiy8nLL9AcRyGykxD3wqCTKEJ2XFOQ
-	n5cjkwj34FA+cH+UB9ER+TsUcWOxU9MFmZIseU6u8phKVUAk8FBe7vtKXaBSHVPm5siz
-	JJmC9FQUD0QBtwD5O2920YuXwk3nC0ViaVa2XJ4DIUMsypHLs7OkYpGQnw7ZSgIuUHYR
-	mYeilSggmMBgsZNT09L5AiER/BRjEsQ+hQJ+elpqMpvFgNwnOBcg9wl0UFsi0AtZYzqD
-	lcTmpKSi0Gw6D0tslsdLR5HZ1BQOO4nFgNAnBSLHX4n0Al4MyvTSEugMX+CYA5FjHOJw
-	fHFjBj2BhvK8MUHgwnxBcogck4APAImwNpHWZmIRSmoTUW0qBdjAuEgi6u4/q72HhzL4
-	MQAIOXdKPNakO6TcIeaOcu4QxN/L4QeAg6cKrD0ih4/2CPg2CaBdAtgEOwS8WwT+wxYg
-	5e59Onv50EaBiEjYYLG3w8K3EwLHD7hIJLG/gtgAEtA438sDdrCgbSJob8qP2Z2CrrO3
-	NeWLNMD+t9ne7z5CRPmjBJfcu/o3/4T/wa5vhgn9YciBkAMhB/43B/4NWOwBxAplbmRz
-	dHJlYW0KZW5kb2JqCjYyIDAgb2JqCjI5MDEKZW5kb2JqCjYzIDAgb2JqCjw8IC9MZW5n
-	dGggNjQgMCBSIC9OIDMgL0FsdGVybmF0ZSAvRGV2aWNlUkdCIC9GaWx0ZXIgL0ZsYXRl
-	RGVjb2RlID4+CnN0cmVhbQp4Aa2Tv2sTYRzGnySUBq1Rq3RyuEFKC1HeVhSdTG1UolXO
-	GKnt5OVySU6Sy3F3aQ04FCfpH1CFliwtRaSDW61TQVAHBUGwVRwdHNyCcZByPu8dIV2C
-	iy987/28zz3f73vvjwNiG5ptV6IAqpbnZK9eUu7OzCr9X3AAA4xRnNB0155Q1SlaerT2
-	Z0Tkq0+nZK1ftZHFzNi6vR1vNn/8fvG+R1JHTjicEIgkKRwvhZySnA85J3nesz16ypL1
-	slYgPyQnnVx2kvyMnCiF/FJyPuR3kuf0kszdJQurYFpANE4+XzBcnZwi5wuuXiWvkV9V
-	qzXWj90jj+i2w9zYY/JJuS/s2eYFcDFN/5OuNnMU2GgDQ8tdbXgJOPYN2Gp1tdZusFeR
-	obhbPDMelIsc3AT6lny/NQ30jwJ7O77/Z9P399Y591dgu63XnbnAy4VEPgD/GodrDqsD
-	Hx91qBeH+xK4uLbVFDC9AFynsMIY5vcNLgMq9VwK0bOvOxHuIS1APG26dkVrBIP/+ahW
-	6jynoPXxOWBYd26zTzCmis6VLHt+M2bva9dU9oOMRdPLyHsjPSuGe1n6jzCeIw0TLmxU
-	oKGBG6jBouLBQB0OFBRICscNeiSZfK8HLgv1m4eKCWGJt2JVbIkd8VOs7atQY77Kqhaz
-	NdaXMyC8S5wZ557yLHEr1/z+ZuzwglT2N894wHsGTNbshmOWyp4ywT/JSCoZSz+dVMaF
-	uIC/70CoUQplbmRzdHJlYW0KZW5kb2JqCjY0IDAgb2JqCjU1MQplbmRvYmoKMzUgMCBv
-	YmoKWyAvSUNDQmFzZWQgNjMgMCBSIF0KZW5kb2JqCjY1IDAgb2JqCjw8IC9MZW5ndGgg
-	NjYgMCBSIC9OIDMgL0FsdGVybmF0ZSAvRGV2aWNlUkdCIC9GaWx0ZXIgL0ZsYXRlRGVj
-	b2RlID4+CnN0cmVhbQp4Aa2Tv2sTYRzGnySUBq1Rq3RyuEFKC1HeVhSdTG1UolXOGKnt
-	5OVySU6Sy3F3aQ04FCfpH1CFliwtRaSDW61TQVAHBUGwVRwdHNyCcZByPu8dIV2Ciy98
-	7/28zz3f73vvjwNiG5ptV6IAqpbnZK9eUu7OzCr9X3AAA4xRnNB0155Q1SlaerT2Z0Tk
-	q0+nZK1ftZHFzNi6vR1vNn/8fvG+R1JHTjicEIgkKRwvhZySnA85J3nesz16ypL1slYg
-	PyQnnVx2kvyMnCiF/FJyPuR3kuf0kszdJQurYFpANE4+XzBcnZwi5wuuXiWvkV9VqzXW
-	j90jj+i2w9zYY/JJuS/s2eYFcDFN/5OuNnMU2GgDQ8tdbXgJOPYN2Gp1tdZusFeRobhb
-	PDMelIsc3AT6lny/NQ30jwJ7O77/Z9P399Y591dgu63XnbnAy4VEPgD/GodrDqsDHx91
-	qBeH+xK4uLbVFDC9AFynsMIY5vcNLgMq9VwK0bOvOxHuIS1APG26dkVrBIP/+ahW6jyn
-	oPXxOWBYd26zTzCmis6VLHt+M2bva9dU9oOMRdPLyHsjPSuGe1n6jzCeIw0TLmxUoKGB
-	G6jBouLBQB0OFBRICscNeiSZfK8HLgv1m4eKCWGJt2JVbIkd8VOs7atQY77KqhazNdaX
-	MyC8S5wZ557yLHEr1/z+ZuzwglT2N894wHsGTNbshmOWyp4ywT/JSCoZSz+dVMaFuIC/
-	70CoUQplbmRzdHJlYW0KZW5kb2JqCjY2IDAgb2JqCjU1MQplbmRvYmoKNTAgMCBvYmoK
-	WyAvSUNDQmFzZWQgNjUgMCBSIF0KZW5kb2JqCjY3IDAgb2JqCjw8IC9MZW5ndGggNjgg
-	MCBSIC9OIDMgL0FsdGVybmF0ZSAvRGV2aWNlUkdCIC9GaWx0ZXIgL0ZsYXRlRGVjb2Rl
-	ID4+CnN0cmVhbQp4Aa2Tv2sTYRzGnySUBq1Rq3RyuEFKC1HeVhSdTG1UolXOGKnt5OVy
-	SU6Sy3F3aQ04FCfpH1CFliwtRaSDW61TQVAHBUGwVRwdHNyCcZByPu8dIV2Ciy987/28
-	zz3f73vvjwNiG5ptV6IAqpbnZK9eUu7OzCr9X3AAA4xRnNB0155Q1SlaerT2Z0Tkq0+n
-	ZK1ftZHFzNi6vR1vNn/8fvG+R1JHTjicEIgkKRwvhZySnA85J3nesz16ypL1slYgPyQn
-	nVx2kvyMnCiF/FJyPuR3kuf0kszdJQurYFpANE4+XzBcnZwi5wuuXiWvkV9VqzXWj90j
-	j+i2w9zYY/JJuS/s2eYFcDFN/5OuNnMU2GgDQ8tdbXgJOPYN2Gp1tdZusFeRobhbPDMe
-	lIsc3AT6lny/NQ30jwJ7O77/Z9P399Y591dgu63XnbnAy4VEPgD/GodrDqsDHx91qBeH
-	+xK4uLbVFDC9AFynsMIY5vcNLgMq9VwK0bOvOxHuIS1APG26dkVrBIP/+ahW6jynoPXx
-	OWBYd26zTzCmis6VLHt+M2bva9dU9oOMRdPLyHsjPSuGe1n6jzCeIw0TLmxUoKGBG6jB
-	ouLBQB0OFBRICscNeiSZfK8HLgv1m4eKCWGJt2JVbIkd8VOs7atQY77KqhazNdaXMyC8
-	S5wZ557yLHEr1/z+ZuzwglT2N894wHsGTNbshmOWyp4ywT/JSCoZSz+dVMaFuIC/70Co
-	UQplbmRzdHJlYW0KZW5kb2JqCjY4IDAgb2JqCjU1MQplbmRvYmoKMzggMCBvYmoKWyAv
-	SUNDQmFzZWQgNjcgMCBSIF0KZW5kb2JqCjY5IDAgb2JqCjw8IC9MZW5ndGggNzAgMCBS
-	IC9OIDMgL0FsdGVybmF0ZSAvRGV2aWNlUkdCIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+
-	CnN0cmVhbQp4Aa2Tv2sTYRzGnySUBq1Rq3RyuEFKC1HeVhSdTG1UolXOGKnt5OVySU6S
-	y3F3aQ04FCfpH1CFliwtRaSDW61TQVAHBUGwVRwdHNyCcZByPu8dIV2Ciy987/28zz3f
-	73vvjwNiG5ptV6IAqpbnZK9eUu7OzCr9X3AAA4xRnNB0155Q1SlaerT2Z0Tkq0+nZK1f
-	tZHFzNi6vR1vNn/8fvG+R1JHTjicEIgkKRwvhZySnA85J3nesz16ypL1slYgPyQnnVx2
-	kvyMnCiF/FJyPuR3kuf0kszdJQurYFpANE4+XzBcnZwi5wuuXiWvkV9VqzXWj90jj+i2
-	w9zYY/JJuS/s2eYFcDFN/5OuNnMU2GgDQ8tdbXgJOPYN2Gp1tdZusFeRobhbPDMelIsc
-	3AT6lny/NQ30jwJ7O77/Z9P399Y591dgu63XnbnAy4VEPgD/GodrDqsDHx91qBeH+xK4
-	uLbVFDC9AFynsMIY5vcNLgMq9VwK0bOvOxHuIS1APG26dkVrBIP/+ahW6jynoPXxOWBY
-	d26zTzCmis6VLHt+M2bva9dU9oOMRdPLyHsjPSuGe1n6jzCeIw0TLmxUoKGBG6jBouLB
-	QB0OFBRICscNeiSZfK8HLgv1m4eKCWGJt2JVbIkd8VOs7atQY77KqhazNdaXMyC8S5wZ
-	557yLHEr1/z+ZuzwglT2N894wHsGTNbshmOWyp4ywT/JSCoZSz+dVMaFuIC/70CoUQpl
-	bmRzdHJlYW0KZW5kb2JqCjcwIDAgb2JqCjU1MQplbmRvYmoKNDEgMCBvYmoKWyAvSUND
-	QmFzZWQgNjkgMCBSIF0KZW5kb2JqCjcxIDAgb2JqCjw8IC9MZW5ndGggNzIgMCBSIC9O
-	IDEgL0FsdGVybmF0ZSAvRGV2aWNlR3JheSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+Pgpz
-	dHJlYW0KeAGFUk9IFFEc/s02EoSIQYV4iHcKCZUprKyg2nZ1WZVtW5XSohhn37qjszPT
-	m9k1xZMEXaI8dQ+iY3Ts0KGbl6LArEvXIKkgCDx16PvN7OoohG95O9/7/f1+33tEbZ2m
-	7zspQVRzQ5UrpaduTk2Lgx8pRR3UTlimFfjpYnGMseu5kr+719Zn0tiy3se1dvv2PbWV
-	ZWAh6i22txD6IZFmAB+ZnyhlgLPAHZav2D4BPFgOrBrwI6IDD5q5MNPRnHSlsi2RU+ai
-	KCqvYjtJrvv5uca+i7WJg/5cj2bWjr2z6qrRTNS090ShvA+uRBnPX1T2bDUUpw3jnEhD
-	GinyrtXfK0zHEZErEEoGUjVkuZ9qTp114HUYu126k+P49hClPslgqIm16bKZHYV9AHYq
-	y+wQ8AXo8bJiD+eBe2H/W1HDk8AnYT9kh3nWrR/2F65T4HuEPTXgzhSuxfHaih9eLQFD
-	91QjaIxzTcTT1zlzpIjvMdQZmPdGOaYLMXeWqhM3gDthH1mqZgqxXfuu6iXuewJ30+M7
-	0Zs5C1ygHElysRXZFNA8CVgUfYuwSQ48Ps4eVeB3qJjAHLmJ3M0o9x7VERtno1KBVnqN
-	V8ZP47nxxfhlbBjPgH6sdtd7fP/p4xV117Y+PPmNetw5rr2dG1VhVnFlC93/xzKEj9kn
-	OabB06FZWGvYduQPmsxMsAwoxH8FPpf6khNV3NXu7bhFEsxQPixsJbpLVG4p1Oo9g0qs
-	HCvYAHZwksQsWhy4U2u6OXh32CJ6bflNV7Lrhv769nr72vIebcqoKSgTzbNEZpSxW6Pk
-	3Xjb/WaREZ84Or7nvYpayf5JRRA/hTlaKvIUVfRWUNbEb2cOfhu2flw/pef1Qf08CT2t
-	n9Gv6KMRvgx0Sc/Cc1Efo0nwsGkh4hKgioMz1E5UY40D4inx8rRbZJH9D0AZ/WYKZW5k
-	c3RyZWFtCmVuZG9iago3MiAwIG9iago3MDQKZW5kb2JqCjMzIDAgb2JqClsgL0lDQ0Jh
-	c2VkIDcxIDAgUiBdCmVuZG9iago3MyAwIG9iago8PCAvTGVuZ3RoIDc0IDAgUiAvTiAz
-	IC9BbHRlcm5hdGUgL0RldmljZVJHQiAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJl
-	YW0KeAGFlE1IFGEYx/+zjQSxBtGXCMXQwSRUJgtSAtP1K1O2ZdVMCWKdfXedHGenmd0t
-	RSKE6Jh1jC5WRIeITuGhQ6c6RASZdYmgo0UQBV4itv87k7tjVL4wM795nv/7fL3DAFWP
-	Uo5jRTRgys67yd6Ydnp0TNv8GlWoRhRcKcNzOhKJAZ+plc/1a/UtFGlZapSx1vs2fKt2
-	mRBQNCp3ZAM+LHk84OOSL+SdPDVnJBsTqTTZITe4Q8lO8i3y1myIx0OcFp4BVLVTkzMc
-	l3EiO8gtRSMrYz4g63batMnvpT3tGVPUsN/INzkL2rjy/UDbHmDTi4ptzAMe3AN211Vs
-	9TXAzhFg8VDF9j3pz0fZ9crLHGr2wynRGGv6UCp9rwM23wB+Xi+VftwulX7eYQ7W8dQy
-	Cm7R17Iw5SUQ1BvsZvzkGv2Lg558VQuwwDmObAH6rwA3PwL7HwLbHwOJamCoFZHLbDe4
-	8uIi5wJ05pxp18xO5LVmXT+idfBohdZnG00NWsqyNN/laa7whFsU6SZMWQXO2V/beI8K
-	e3iQT/YXuSS87t+szKVTXZwlmtjWp7To6iY3kO9nzJ4+cj2v9xm3Zzhg5YCZ7xsKOHLK
-	tuI8F6mJ1Njj8ZNkxldUJx+T85A85xUHZUzffi51IkGupT05meuXml3c2z4zMcQzkqxY
-	MxOd8d/8xi0kZd591Nx1LP+bZ22RZxiFBQETNu82NCTRixga4cBFDhl6TCpMWqVf0GrC
-	w+RflRYS5V0WFb1Y4Z4Vf895FLhbxj+FWBxzDeUImv5O/6Iv6wv6Xf3zfG2hvuKZc8+a
-	xqtrXxlXZpbVyLhBjTK+rCmIb7DaDnotZGmd4hX05JX1jeHqMvZ8bdmjyRzianw11KUI
-	ZWrEOOPJrmX3RbLFN+HnW8v2r+lR+3z2SU0l17K6eGYp+nw2XA1r/7OrYNKyq/DkjZAu
-	PGuh7lUPqn1qi9oKTT2mtqttahffjqoD5R3DnJWJC6zbZfUp9mBjmt7KSVdmi+Dfwi+G
-	/6VeYQvXNDT5D024uYxpCd8R3DZwh5T/w1+zAw3eCmVuZHN0cmVhbQplbmRvYmoKNzQg
-	MCBvYmoKNzkyCmVuZG9iago4IDAgb2JqClsgL0lDQ0Jhc2VkIDczIDAgUiBdCmVuZG9i
-	ago0IDAgb2JqCjw8IC9UeXBlIC9QYWdlcyAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAv
-	Q291bnQgMSAvS2lkcyBbIDMgMCBSIF0gPj4KZW5kb2JqCjc1IDAgb2JqCjw8IC9UeXBl
-	IC9DYXRhbG9nIC9PdXRsaW5lcyAyIDAgUiAvUGFnZXMgNCAwIFIgL1ZlcnNpb24gLzEu
-	NCA+PgplbmRvYmoKMiAwIG9iago8PCAvTGFzdCA3NiAwIFIgL0ZpcnN0IDc3IDAgUiA+
-	PgplbmRvYmoKNzcgMCBvYmoKPDwgL0NvdW50IDAgL0Rlc3QgWyAzIDAgUiAvWFlaIDAg
-	MTQ0IDAgXSAvVGl0bGUgKENhbnZhcyAxKSA+PgplbmRvYmoKNzYgMCBvYmoKPDwgL0Nv
-	dW50IDAgL0Rlc3QgWyAzIDAgUiAvWFlaIDAgMTQ0IDAgXSAvVGl0bGUgKENhbnZhcyAx
-	KSA+PgplbmRvYmoKNzggMCBvYmoKPDwgL0xlbmd0aCA3OSAwIFIgL0xlbmd0aDEgOTA5
-	NiAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeAG9Wgl4VEW2PnXX3tK53el9
-	v7np7uwrCTQJpA1JSFgiEMQECSaBQIIwBsSM8ISJCigRGQVZlBmVUZFVmoDSwMAwPhhk
-	ngtuODL6xgVQ5zPPmXkw40jS/c69HaLM5/Pxfc/PrtR2qm7Vqf+cOrUFCADooBtoCM9a
-	0NIJL5AipLyC/visrsW+hz4f/QQAWQNAz5/TOXeB4cN//z0A8xWARjd3/pI5+9v7XwVI
-	ZtA3tLe1zP7bW6FMAM8M/L6kHQmaVD4L849iPq19weK76j7kHZiPYn7C/NtntUjpgQiA
-	F7+H9AUtd3Wqfqr5J+azMe/7ScuCtrplS3+O+QmYT+28/Y7FZC21A/OdmK/pXNTW+ev7
-	flKAeWyPfh1pBJ380wEHBzD2wU2DFIX8/wiowW9pjGVuv/mxmOSULA+qb8jfSqkxrUGv
-	Rb6SMNYPlSWDoKQNGBrZ4yCwRyGd7QYHkwdegPh76M/Jceym+EX2FAixBfG/0qVY+5Ds
-	qVh5GRyHh2AL7EUetmM6HWbCZjhN5sEhMgMxOEs8kIvyZSAKE+AVEo+/AXPgGay/GF6C
-	DbAPeUqHBWDG0rXEH1+K+TCmW2FF/FeQBiNgFRyFELa6FvriO+L7sXQKoroTduH3/0Ek
-	ah+TEn8+fh7HPhnbXIElb8QnxPeCEbKhAiYhdQUcI376XLwdbFCK3P0CnoSt8Fv4gtxL
-	DsTb413xM/GPgMJSF9SjW0YOkI/ovcyq+C/if47HEIl0yMRem2E9PI3t70V3HEVdRW4j
-	i8l6soEKU/dSB5iVrDU2gDhkwFh0NXA7PIAIHIIT8Df4J/mSstECvZg+GS+O/zfKYjyO
-	Uh5JG3Shux/dWhzTEcKRfDKGTCLLyKNkA3mLyqRuohqon1J3URfpOnoGvYR+i7mD6WXX
-	sJs5bexy/Ej8VPwdsIIbboFFsBxH9xKcgUvwNaGxLRfxk1JSQWai6yZbqENkKzlETSLH
-	yRlqJ/kT+YR8Sa5QLKWjzFQWtZhaT+2iXqJeozvoDfRj9J/oy8xolmK3shc4P//HWGts
-	dey1eGn8o/hXOGNVIKJkKqAOboUWHG0nDIOf4Sj2oNuLUjsBJ+G04j4hLuiDrxAFIEbi
-	IIVkIro6ciOZQzrIE+QwumMKL3+nUBCUmjJQVspF1VOt1AKqm3qH6qaddCY9jp5O70X3
-	Mn2WvkJfYVgmhTEzY5laWMMsYB5Ht43ZzvQyr7MhdjRbx05ju9nV7Bp6FvsGe5Zbzq3l
-	erkvub/w6fwE/nZ+DUrnNOrsb5U5cDVgSBpyXwg/gVmkkrTCRpTGVtICPahds8kDiFcn
-	pMeb6OX0WCofteEY/Btq6+OwDFbTM2Br/A/0TngXNWU+NtgNzzEV4GY3oXTuhXzUokEX
-	zsjMSA8G/GlSqujzetwup8Nus1rMphSjQUjSaTVqFc+xDE0RyK6Sqpt9kUBzhAlINTU5
-	cl5qQULLtwjNER+Sqq+tE/HJ37Vg0TU1w1hzzr/UDCdqhodqEsFXBmU52b4qyRd5tVLy
-	Rcn0yQ2YfqhSavRF+pT0RCX9sJJOwrQo4ge+Klt7pS9Cmn1Vkequ9p6q5sqcbHIojHBo
-	crJlwxEGrdxwBMa0LGu3YSTXqIo4pMqqiF3CNJbR/qqW2ZFJkxuqKp2i2Ig0JE1pwD5y
-	sjsiyCc8qJstzX4wGobWZjnVMqMhQrc0RqhmuS1DVsQqVUasSy/YvsleTVWt+VZhhPJX
-	t7T1VEfCzQ8iuHK2Wc61rMHc+HofNkutbGyIkJWDTMg8zkNOZXbbpCqZr+Z5vohaqpDa
-	e+Y1I7gwpaHXEXZUSS2VjRGY1NBrD9uVTE72IdvyUhFHfyjnhpwb5LhUtC1PxJ/el6C/
-	eVyObctPfIjx+ClDABC5J6kW+Yz4ZimdSMjsCDloGwE9s0YgTvhrJDjMDuRnTIRCnaH9
-	EdZf2xLprr/KRntlgrnmeZW9artDHkNzRSPWb+4RRqKksL4g+XouA4pQ6vviWkrLIIXz
-	C5dBLpQFPaQrEdJyNd2lAIOjbrdJ7bJ8uxSZYl6yVX2LgHkZGpnniClSOH5SgxjxNSIh
-	ClnZ46OgntSwj5C1jVESXxmFSvchUAN960wszpZVraMS+8dMTjYSMkVM5Wb7qnHU1bKu
-	+Hp8PbWze3zVvnZUJsavxFjQ1tOYhwjWNyBOMBV7DDc6h5JtjY0jsZ08uR38BKv3NGIL
-	8wZbwFgh5Q1gpfzs8SiVwKSGyQ2R7kpnJFzZiFJA9T0+qSFyHDW3sRFrFQxxihwv67AN
-	8lyIPBdkYnlRopV6bAObaOzpkdusb5DEyPGeHmePPN8S+SiBfyWEBwlRkKvgwKuipHsS
-	fouRJDplgiRKIrLVKGM6DFX6qkZFofj7ES4Z4hu/HI7cligIj/iBEA5dD8Ijrwvh0iFO
-	r0G4DHkulREe9eMhPPoahMu/H+HwEN/I5A3IbVhBuOIHQnjM9SBceV0IVw1xeg3C1chz
-	lYzw2B8P4ZprEK79foTHDfGNTI5HbscpCE/4gRCeeD0I110XwjcOcXoNwpOQ5xtlhCf/
-	eAhPuQbh+u9HeOoQ38jkTcjtVAXhaT8QwjdfD8IN14Vw4xCn1yA8HXlulBG+5cdDeMa3
-	EMYNbwUe6s7g2YsGHsqjUJ8VBVUeLn7oVQIeLs+gl/OYpt+PAoMeMM2/D4fxC4BpWYex
-	FRbj/IIig2gIoq9g1kb7P2aPfj0myky8sh9rUTA9fo5dyF7A3agH9oVLnewmspGlvcTL
-	3EvuZ1ensPUqepXbYDBzI920bqRZ7aE8HjtdQJUKBQaHT11gt3t9W8V5c2xZWXWXJvbV
-	CX+f2HepzxjKg/LyvnI5IfQV5I9ZEh4JLqs/JaD3OwNai7oQkkxCITEakgXehTkW6EJC
-	KIbW2HSFkGzEQOXgCglDMMjCHxHKhLKsrEQoE+5pIk0qYpVyiZQKBsFYVDi8ZHgRx3Oi
-	LxgwCMNLRInxkGGGl8STve/FLv/1y/fvGOV5ybFub+zdODx/YfdhMjadvRA7d2Ttttjr
-	sZOxWOw3Oxof+eyXR7e8SnaTqjMfK/jMir8nn3UgFSR4Izzaya0iKynaTbzsKrLa9aKP
-	DauSGbOFFhZYlluoZIshiVmVKhg8KUajmR+ZSptVSSMdaomSJNpjjJLxYYFmCuhSwZ/i
-	8GsKPPY0f5TM3S/O67wGvwGhz3AVQgXDsoEyhRRqIlgQMoYUSLOdIuhcfl+A+HVODSIm
-	YsABU0gommW07qRCUHv5QsJSGMA3ICrwyfiB1ZIyBKBYmJYiFosGKYggSldBDNIXN/2x
-	4GTax7tfiX1+kTCnCEvHhlEru/Pb6u77fezKr199+RjJFdlPJt0R+3Dr+thrsTdiX8cO
-	fkqoZ/v/6+jtWeN2vE0WkYXnzlCIJ8HTFZB1il5bcT+HSipfj+Rm4V2ArM5UXn5BSpFB
-	On36tKymqJ975bsdrK8BE7SEizt0HcYluqVGpsbUYGo3LTUxvMpjEAQN0Sd7CFAaFcUZ
-	dYzaZCpgHJZktR/sZkuUaPeLG1YnEB4ok1V0wGC0hlBDZVwRaIxIU0F+U4pYiCcuTkIQ
-	IBjASCwsKd5LbTjxl7P/GSs8RXffVXFHbDFZs+o59ugHL++OD6xnDo30xuhFD8tzCe93
-	2LuQVzUE4dGwkU+qJTVsI2lgO9jZprtYleUIHuTt4CSucIUk+gLNxoXGO0200eM1ucy0
-	6LGYmIAxze8BtdrJe7RUwOVU+fxmr99CFyR3OB0ZqoA/qLGnZ5wVNyTmW9nExHAu9b2N
-	DsrLysoHEsMJGayhQVUJNaHKZBXkkyaCoxmmjIsWC+WzJcd7iJdYrBarGdUgjwSUQoke
-	u+bpRaPmxBynqO3bF7y+oHXazSxPa425lzQ6RsfPDi2NlZ6iXZ3rfhnyxDTU1oKZAyu2
-	F0mLuk9Ozag2iSll0y4/XOAc6EFMduL8yUNMzGCBsrBkZYPsCIHWAMWOFNQW2mIxqf06
-	h434TXar7SlxwzXz4OoUKEPZEIPJapHneLGhyCDwlOijA3YiksVljW8N3FLw+9pVsTWx
-	NStrqTHs0f7FT817as/MJ+k1/adif10X+zvRrCPJdAiVbRjKqAT54eDn4cqHyVOECpOp
-	hLIQchd7kVBzmXb2AYa2p1N+I00z4DdyHIvzh+ZoZJlRqaxWB0PRT7BAnuDs/NqZtix7
-	nXDJNnEgFMI/e11VW+VFGwqi3FpmDJH7J+Zm3Z9ryxo/ZUlYR/DoTjN430Fx7P2qZcIJ
-	JZDlAk0LFy5SU0VEIkQg28jWPw189tbA5+zRK27mk69xQDhHcCWYEn9fudlIxjurMvgg
-	PCIzn2gErVPnChbVCB3qeQIfUhl1atpZyKep3YLOXZpF5WaUHiylSgsz/UaBZ1WuYKrV
-	FSU9KAq3lw+6c7WUu1hbxpeVuUx8Rub2NMdoZ4ZrXHJwhH3U6F+TTXihc4hshEHrdEmx
-	7+cHTlyVDFp4NPHyZJKVLLcvt09WOtQ9xT6llww3pwKx+0lJsgg2D5ori88kEjEVhlMi
-	ONxWkZhFDAZtU8Iu3QNomdIUWY8iepJM0ByZSQlKflhASuU5XhpNimT1NZiwEnahxxUg
-	GAjKUaB4WMnwFKJfVHdr40axvXBBa0E9OTDarLtv6UOlomY7+4+nj3bdafXrPIbM7EBT
-	pkU9/LW7Nxw9vKnn9enZtdseMbs4fZIrby6Zr8q25cyon5BZ/7stNTWbBza5Uml6pY6r
-	kMI18154YMMzKeS8POfx5os+w9SBA5zwXDjvOTvZbNuu2mmjx6kMW0w0beLcDj7JbdI6
-	eafTKgSNhA5SBodbE7TaXe4o4feLi5Z9Y/vLJvaFQt+1eg4Du8qvM2sCoE8RAol10445
-	XDdFZd3UWpICuG5ioLZxAXndFL9j3VSwBUti1URYEwgWydBRxQIU8dTZT6x7hUXLd4/L
-	f2Bd5332vZ6/HHnza2J828XURd6ddd/2BU9tfX/1T985SYou4rXdSOwfauLnGAfeuLnw
-	dtZPdOElm1SPOZ7z0qyeSmZNZr0x2WwK68ImVYaDjNe+SJ8iv6NPOf+gek991vsH6TPr
-	Z5L2lOGUkZqhYsW05Mct7rQQx/MW0e3iNW6L1s9vcj3nOuh618X4Lcl+F2vX6HiDPpjs
-	DrKOYFouH7TbA8G3xW1Ngxb+vLIJeXsAl0lUTXm1zGsa2o1cXUkVBa0GiWFpvM4kLMN5
-	cddgFFIEk8BwOn+qMy0APnAHiMettvIB0Jr1AZKklxwiklgMVDbEP0nAQFZfeYMib08w
-	lZmVeQ9Z2AQLm5oQanRm0YMaK29P9AT1l1M2LFCkmNtUjifUgbMjSoxC/5fsw5semppv
-	2sffWDBlyQ1TXo79mdg+Jl5t+rg9d29nicSMve2myfPH/erpk00lY0sfyZ3kEtBmcGhZ
-	KmKBO6vv3d9D3pdtBUFZAGVl38Rb4InhLN7Nadw0STaFLEmcUWNHI6ZPMmRYjbwxWe/V
-	U/p+k91m7xfnLh9EsCl0Ql4TBcWcycskrjPluMIU5BuHlxQV4nIh77o4c5FZMqArLip+
-	QSo/YEizuuzaKb7eA70bNrAVw2ZQ1DMUuen5tf2z6V+s3a7YsFGxUvoz1BUv5OArwMHw
-	xBJTrapW3aBqVD+g2+Hc7t4R3JZ1yKkNq2hLaob+hCYVzRTDZbjtGqNbk5zL5+ayLjrX
-	kpuTwTrydfpg0uhA0GXPy79fXFQxZKVCyhp//jJKf3AfipvRxAYqsXGS0h0erSHNLwQk
-	TyAA6Q4MDFq9CMl6XZLfnRogQWcGziedUVSkO7j7ROHecw/OIdw3WYuLDCbcbKYGgkUo
-	Ylm8igVKM+A0AsVQKbMLzRah7p5ZVLytrDN2es8X+oNJwVH3vR4O0CWblz0fu0L4w6Ty
-	mZ8dq/avv/ulG7NjbzAVo6Ux9/cXvtJ1bsuzNcGyddM+mDLpH8RNkkhubOvx3lsff+Ho
-	3lkrqBzEk8KXDCCluEDI54SSsIu/wKDwOVqjRhmjXmTwNBoO9U6xNQFO2cQTA2UnhsRa
-	PhFFKm+4DCjJFQfxx2ReOcsefeVq23QfysqO1m1muOAgd4qjGM7EBU1d3GKeNekok01w
-	szxwNq3GwTscoMtQO1wk15ZhB7sTlxlu/zcdDySmZUIiZSgPQyhE5I2sbO5TisxXjbpk
-	kLcosp3XE7NBIit2TdjZfn5S9kF3/vJwxrgROc4D5Dkmb/PMKU/e/KuBydTTrWWzkywV
-	xQs7Bl5HZhGJ0vh7jIg2WYfvN3Z4OFy0WbVReMzyLLNdtU3YYYmqXla9y1zQf27SjVRx
-	bhuvcxu1dt5uN1PBZIdTHTTbHc4oUaNlHrQoiVPNkC4lVAisTECbosbZb6AChLdiik3C
-	lMakCwARMFBZ0BDTegwU+yAHWag8aUZlE4bTB62vEY8uFK6HCeP74cr8CYef3bjxaXwk
-	64/944NYPzF+yi0myds2zny0v3fXefpc7IvYpdhA7HmS1Y+LYxg3IrAaFWEdMxYMcGM4
-	EKQDScPpsQyjVwmUXm1Q64IqWUQGjcqRQnKFDAPYjSlRUoWiSUx3nNwomos4zSeWnxg4
-	IVtMeRGXBTMolqH5bpBW7zI/cxtrcwtO4YF1B5i8QyVbKPoYTe1dNLBZtjvW+JeUmp2O
-	yE95ISlXc1xPoqQ87GcsISvN6TUGB+olvkJlgFlvTqa9NEX3W+x2B9qewVVw4Frbk5cw
-	Pn3CwHlFU2WLo2wEB9f9QLFsfra/uGtXwFyQ5DF5xwSXT3/kEXZ67J31A1UjUrSEWqtW
-	3TOXOrlesYsY4KtD9Cnrrclll8GQeB793ZWvOJmuxNZYqXLiA9zHy4cT+YcxlxHLwGdc
-	8lVbf5/2kaGSRDlACmuECiqEu8tTMJ0LwSxMn2anwV7MH0C/E9PDmDtgCgNQinENlrsw
-	HkVOwQqMZV9K7YTVSLdio8PQnSDzyQpyjppN7aY19NvMNNbHzsf5V8E9wVv4GfxuhYsU
-	fGej4Tac/xS+3QponID/TKPD91WZe4KvnolRcPLL7rS62mnjpmfVtM3valvcMasFa8jn
-	MvzF2/Dd8bt+KUikIYDvVNlo2Irx/TUElVCNr5m1MA5fLCcrb5Y3J+4oavGeohx9Mfqs
-	rBts0E22wcPon0JPQwd5EJagX43+MfTMUGoH5g6RB3sZVfgwWQIOMi6sZbxTTXavTaP1
-	vomm5MAT3vdsnxzBA1QSfETsvUmgvkGDG/gnYTZ4ybO481iKPKWTx/dnzPc2Y9EO6ETf
-	jZ5WQkJ29HoKvcdINvhxG+4lAfAw5EXvpwU53gsFUYr0el8KRhmMfuvBXDjZe9z9hPc3
-	7rneY+h3JYp2ZmCNF7073PO96z1R8nivdx3u4vCbRxLRnW789EXvgoyN3tkFSvmEjVFq
-	V683hOXTwlpvyQjRW+w+780LRlUE8znuCd7Mgle9afghVvNho/6wwetyr/eOxCKPuyo4
-	Ev0RspNsgUyypdc/znsYkzjc/bUZIzZGyb/tr0kvwGuEpeGSmvSNGTVBf8YErz+jOhjE
-	9LSX+RX8LfwNfCGfhY+cAV7knbxJZVQJKr1Kp9KoVCo+Snb3lnu5I2QXlCMsu/arOBUb
-	Jc8jkTlC9ijEPQdVjIpSgcoUjX+IB10CpijZdQBVigAmXuSUFBcle/BeSSbtCcv/Q0GA
-	UQoE1DI8nqMqoTJSREWh6kTIQ1EOVlq6ym3lxtGGUHXl/xY0KyVXQ8WOfndgI+7IRnzP
-	iOx0N+LTESbi7sarVXF38H/8Ft+JFdoqsuTz2v6uznlzlKcwqaqtGV/EIg924dNkd6vP
-	t29e5+A7X6C5dVa7/BbT0hbplNoqI/OkSt++LuU7mfyt4jlycZdUuQ/mVE1t2Dcn3FbZ
-	2xXuqsKnrsb9rRWLmq7pa/VQX4sqvqOvCrmxRXJfrcp3/9JXk1zcKvfVJPfVJPfVGm5V
-	+pIhqOqor7hjMWonPpfhc1V6faR28vQGfBVurIySbfIb2p3wPzSFGkkKZW5kc3RyZWFt
-	CmVuZG9iago3OSAwIG9iago1OTc1CmVuZG9iago4MCAwIG9iago8PCAvVHlwZSAvRm9u
-	dERlc2NyaXB0b3IgL0FzY2VudCA3NzAgL0NhcEhlaWdodCA2ODQgL0Rlc2NlbnQgLTIz
-	MCAvRmxhZ3MgMzIKL0ZvbnRCQm94IFsxMSAtMjIxIDcwMyA3MzddIC9Gb250TmFtZSAv
-	Vk5JVkpaK0hlbHZldGljYSAvSXRhbGljQW5nbGUgMCAvU3RlbVYKMCAvTWF4V2lkdGgg
-	MTUwMCAvWEhlaWdodCA1MTMgL0ZvbnRGaWxlMiA3OCAwIFIgPj4KZW5kb2JqCjgxIDAg
-	b2JqClsgMjc4IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAw
-	IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAKNzIyIDAgMCAwIDc3OCAwIDI3OCAwIDAg
-	MCAwIDAgMCA2NjcgMCA3MjIgMCAwIDcyMiA2NjcgMCAwIDAgMCAwIDAgMCAwIDAgMAo1
-	NTYgMCA1MDAgMCA1NTYgMjc4IDU1NiAwIDIyMiAwIDAgMCAwIDU1NiA1NTYgMCAwIDMz
-	MyAwIDI3OCBdCmVuZG9iagozNCAwIG9iago8PCAvVHlwZSAvRm9udCAvU3VidHlwZSAv
-	VHJ1ZVR5cGUgL0Jhc2VGb250IC9WTklWSlorSGVsdmV0aWNhIC9Gb250RGVzY3JpcHRv
-	cgo4MCAwIFIgL1dpZHRocyA4MSAwIFIgL0ZpcnN0Q2hhciAzMiAvTGFzdENoYXIgMTE2
-	IC9FbmNvZGluZyAvTWFjUm9tYW5FbmNvZGluZwo+PgplbmRvYmoKMSAwIG9iago8PCAv
-	VGl0bGUgKFVudGl0bGVkKSAvQXV0aG9yIChKZWZmcmV5IE92ZXJiZXkpIC9DcmVhdG9y
-	IChPbW5pR3JhZmZsZSkgL1Byb2R1Y2VyCihNYWMgT1MgWCAxMC41LjggUXVhcnR6IFBE
-	RkNvbnRleHQpIC9DcmVhdGlvbkRhdGUgKEQ6MjAwOTEwMTQyMTQ5NThaMDAnMDAnKQov
-	TW9kRGF0ZSAoRDoyMDA5MTAxNDIxNDk1OFowMCcwMCcpID4+CmVuZG9iagp4cmVmCjAg
-	ODIKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDQ0MDAxIDAwMDAwIG4gCjAwMDAwMzcw
-	ODkgMDAwMDAgbiAKMDAwMDAwMTI3MyAwMDAwMCBuIAowMDAwMDM2OTI2IDAwMDAwIG4g
-	CjAwMDAwMDAwMjIgMDAwMDAgbiAKMDAwMDAwMTI1MyAwMDAwMCBuIAowMDAwMDAxMzc3
-	IDAwMDAwIG4gCjAwMDAwMzY4OTAgMDAwMDAgbiAKMDAwMDAwMTY3MyAwMDAwMCBuIAow
-	MDAwMDAxOTY0IDAwMDAwIG4gCjAwMDAwMDM2MTggMDAwMDAgbiAKMDAwMDAwNDE3NSAw
-	MDAwMCBuIAowMDAwMDAzMzA2IDAwMDAwIG4gCjAwMDAwMDM1OTggMDAwMDAgbiAKMDAw
-	MDAwMTk4NCAwMDAwMCBuIAowMDAwMDAyNTQxIDAwMDAwIG4gCjAwMDAwMDQ0ODAgMDAw
-	MDAgbiAKMDAwMDAwNDc3MiAwMDAwMCBuIAowMDAwMDA1MzY5IDAwMDAwIG4gCjAwMDAw
-	MDU5MjYgMDAwMDAgbiAKMDAwMDAwMjk5NCAwMDAwMCBuIAowMDAwMDAzMjg2IDAwMDAw
-	IG4gCjAwMDAwMDQ3OTIgMDAwMDAgbiAKMDAwMDAwNTM0OSAwMDAwMCBuIAowMDAwMDA1
-	OTQ2IDAwMDAwIG4gCjAwMDAwMDYyMTIgMDAwMDAgbiAKMDAwMDAwMjU2MSAwMDAwMCBu
-	IAowMDAwMDAyOTc0IDAwMDAwIG4gCjAwMDAwMDQxOTUgMDAwMDAgbiAKMDAwMDAwNDQ2
-	MSAwMDAwMCBuIAowMDAwMDA2MjMxIDAwMDAwIG4gCjAwMDAwMDY2NDQgMDAwMDAgbiAK
-	MDAwMDAzNTkzOCAwMDAwMCBuIAowMDAwMDQzODI2IDAwMDAwIG4gCjAwMDAwMzI5NDAg
-	MDAwMDAgbiAKMDAwMDAxOTQ2NSAwMDAwMCBuIAowMDAwMDIwNTY4IDAwMDAwIG4gCjAw
-	MDAwMzQzNjIgMDAwMDAgbiAKMDAwMDAyMzc1OCAwMDAwMCBuIAowMDAwMDI2OTA3IDAw
-	MDAwIG4gCjAwMDAwMzUwNzMgMDAwMDAgbiAKMDAwMDAxMjA3NiAwMDAwMCBuIAowMDAw
-	MDE1MTUxIDAwMDAwIG4gCjAwMDAwMjY5MjggMDAwMDAgbiAKMDAwMDAyODAzMSAwMDAw
-	MCBuIAowMDAwMDA2NjY0IDAwMDAwIG4gCjAwMDAwMDc3NjcgMDAwMDAgbiAKMDAwMDAw
-	Nzc4NyAwMDAwMCBuIAowMDAwMDEwOTM2IDAwMDAwIG4gCjAwMDAwMzM2NTEgMDAwMDAg
-	biAKMDAwMDAxMDk1NyAwMDAwMCBuIAowMDAwMDEyMDU2IDAwMDAwIG4gCjAwMDAwMTUx
-	NzIgMDAwMDAgbiAKMDAwMDAxNjI3NSAwMDAwMCBuIAowMDAwMDE2Mjk1IDAwMDAwIG4g
-	CjAwMDAwMTk0NDQgMDAwMDAgbiAKMDAwMDAyMDU4OCAwMDAwMCBuIAowMDAwMDIzNzM3
-	IDAwMDAwIG4gCjAwMDAwMjgwNTEgMDAwMDAgbiAKMDAwMDAyOTE1MCAwMDAwMCBuIAow
-	MDAwMDI5MTcwIDAwMDAwIG4gCjAwMDAwMzIyNDUgMDAwMDAgbiAKMDAwMDAzMjI2NiAw
-	MDAwMCBuIAowMDAwMDMyOTIwIDAwMDAwIG4gCjAwMDAwMzI5NzcgMDAwMDAgbiAKMDAw
-	MDAzMzYzMSAwMDAwMCBuIAowMDAwMDMzNjg4IDAwMDAwIG4gCjAwMDAwMzQzNDIgMDAw
-	MDAgbiAKMDAwMDAzNDM5OSAwMDAwMCBuIAowMDAwMDM1MDUzIDAwMDAwIG4gCjAwMDAw
-	MzUxMTAgMDAwMDAgbiAKMDAwMDAzNTkxOCAwMDAwMCBuIAowMDAwMDM1OTc1IDAwMDAw
-	IG4gCjAwMDAwMzY4NzAgMDAwMDAgbiAKMDAwMDAzNzAwOSAwMDAwMCBuIAowMDAwMDM3
-	MjE1IDAwMDAwIG4gCjAwMDAwMzcxMzcgMDAwMDAgbiAKMDAwMDAzNzI5MyAwMDAwMCBu
-	IAowMDAwMDQzMzU4IDAwMDAwIG4gCjAwMDAwNDMzNzkgMDAwMDAgbiAKMDAwMDA0MzYw
-	MCAwMDAwMCBuIAp0cmFpbGVyCjw8IC9TaXplIDgyIC9Sb290IDc1IDAgUiAvSW5mbyAx
-	IDAgUiAvSUQgWyA8YzAyMjlmN2E0ZWQyMTQxYmVhMzAxMzBhYmNkYTQyNGM+CjxjMDIy
-	OWY3YTRlZDIxNDFiZWEzMDEzMGFiY2RhNDI0Yz4gXSA+PgpzdGFydHhyZWYKNDQyMTAK
-	JSVFT0YKMSAwIG9iago8PC9BdXRob3IgKEplZmZyZXkgT3ZlcmJleSkvQ3JlYXRpb25E
-	YXRlIChEOjIwMDkxMDE0MjE0MDAwWikvQ3JlYXRvciAoT21uaUdyYWZmbGUgNS4yKS9N
-	b2REYXRlIChEOjIwMDkxMDE0MjE0OTAwWikvUHJvZHVjZXIgKE1hYyBPUyBYIDEwLjUu
-	OCBRdWFydHogUERGQ29udGV4dCkvVGl0bGUgKFVudGl0bGVkKT4+CmVuZG9iagp4cmVm
-	CjEgMQowMDAwMDQ2MDA4IDAwMDAwIG4gCnRyYWlsZXIKPDwvSUQgWzxjMDIyOWY3YTRl
-	ZDIxNDFiZWEzMDEzMGFiY2RhNDI0Yz4gPGMwMjI5ZjdhNGVkMjE0MWJlYTMwMTMwYWJj
-	ZGE0MjRjPl0gL0luZm8gMSAwIFIgL1ByZXYgNDQyMTAgL1Jvb3QgNzUgMCBSIC9TaXpl
-	IDgyPj4Kc3RhcnR4cmVmCjQ2MjAyCiUlRU9GCg==
-	</data>
-	<key>QuickLookThumbnail</key>
-	<data>
-	TU0AKgAAEGSAACBQOCQWDQeEQmFQuGQ2HQ+IRGJROKRWLReMRmNRuOR2PR+QSGRSOSSW
-	TSeUSmVSuWS2IAGBgIZTMaBmbBp/zmMgGeQR/zwAv+Bv6gS6jUekUmOzmhTGmTCBUGdR
-	iiwOfzymgCiT2lV2KAKBgYUWNBlyzFsLWkMyCi0wAF24AADXMAAK7V68Xm9St/X0APrA
-	ABTYOtX63SC7WC+v4AF7HAAC5G63e95WCAaBhEpZtRq3PEWUIvRAAr6UAA3UZDJZaO0X
-	EgAB7EAATaZOwazcR/APoAPHfABYcEAGXiSlEccAFvlAAGc3VAXcxui7EBgCi5Hoa+Fg
-	uBhwl99Xd8liegdWP1WBgf1dae+jo9Kevj5cnlgj7bb3/mKPb+AByv+ABSwEACbLWw7z
-	q49L1qK9z9Iuor+HsxrHvUA78IOB6BhCzYpEyzxWhtB0RIiSMSgALUUAAB8VrkukRxeh
-	J5xkABwRqABfRwAA3x3GEeoURsgQmLwAAhIrnoQCCBhLDhLQ+GkfSggpBymAAsysAANS
-	yAAFS5KMoHlMAAG3MYAGFMwADjNMvTWP02gAL84QIm0ty6g8koEE8mQ+GSWG7P06AUAB
-	60G07UzGbYAB5RQAGBRoACBSAAF/ScaRs6gACNTIAGrTlKnAAAo1CAAJVIlo91OAAsVU
-	AAP1bQoGvYqE1v1MB5AAbVcTLM45V4ipiV/RNF1+YiC0UHlPAAXdlUA+gtoSW1oAAJVp
-	oaflrAAc9sgADtuRjGdagADdxJKOlygAMF0VZVzUVhOyBhNDhLz2lkzGFUdSnXfIAAvf
-	lJUoNeAAAS2BtI0xa4O/0AB9hcxTJCoAYWHwAHFigABzi6WjxjWCiuAAR4/V9Y1m6K3R
-	keYAG5lNGUdXg5IqSuYABgA1gBmBKoLmYAGPnYAHRnwAHJoIAB3olN06DmkAAXGl0xTU
-	/G6AAiakABg6rfd+1wbQAAxrmRHhr4ABdsQAGzsrYNkEu07Js18nWAFyjoio4bmAAw7s
-	AAQ7yAAHb4hAI3fPTPT4lZo8KAGTABtoABvxgAFfx+ZYDlJuAA0RFgARXMgAR/OAAK3P
-	gBpAOABg5agAGPUAAT/VgARPXJaO/Y45j2Qb4B2RZG3C3XBp+VmAAGWorgZLAANPjYFg
-	iCZznZj4nipx+gAAE+nLEtH764AQiAGHmH7vT9TdAwAB3pn/KwrGWsfgAH39gACH94AF
-	B+XgV6VP7ZCdv8gANX+blujdgwt4b07ZvzgDNpNcESwtwuoGGzNq+8IYABlwTAADWCxB
-	RYwZAAE+DkEoKQWBqQUXMI1sLaBVCcAANoVOwdkaVjrHwRt7b6g13Jendphd6o137wSK
-	P5HaACEYuQAA9iIz1n8IGgNCNoAR9b7VwDQig4txqgx6gAHVFcAA7ItPfBiACKA0GotT
-	cKNEv5gQFxnRUiwEEa4PDLYgwwa0cWjDVAAMqOwAESiRf8HBurd28ghhk7cg7fyBLwgO
-	vOGqL3Yh3dnDCQLuJEl7huraHLLFeyRJLDoAAHpOAABFJ+PcfYAx/keu6Qq8ZESYP0xo
-	PEjWQLskhKova4HJu+foy6WR+m5x8gBAKQEBEMIaCRMMSYTpjA4MSARA5uX2D7SOXodM
-	0TmHOOaAw/A35sInRTJwDzIYaS5K64hGqn4gxpQyYuLMW1LpFTuXmZszzomuLu2UbMol
-	1AfmnNYg8+ksEDBEcQMoh0sgaBgPmgx+VOR0BXQsvbXx4AAXBI57QOKKAAJmnxAr0nqE
-	YnQ9cfr5wAFumWfg16lztSRe0tkc8tlDsiYoOIABaQLAAPsAgvdCQAULBWbgoqXFAr8A
-	vPcADaQStba69MBJCELECnaBUQFTxKgwqkD59J+WsgABNVk/MSzem/AnV9ba3YrjqaG0
-	U7EDomEMo9GU3go63VopCTotyDCezoCrXdFpmFLkkNfPIsE3yHVVmiOkAAzrDAAooDgA
-	AvbGPbPWped576r1ZBNTwnpczMIrQzV8CdMS0zmngQU272yBgMEvacUMEAkzoPeO61y9
-	wJH5New+nwAIzncpUAACNu3xp/tcO5poRnsn9nHbaNFNW3rmnZXErJBii0GHzVirTD69
-	kjNfVwswXEjjSu47SGNZz5D4V0vZi4OQAD3vRY5C1mgAD0vdcNCRu6QWtteqS2JrK/U0
-	PvUi4x3LMIXIVaMAYp8CCqChgcKFIzWP2FS7M99dCYUmLvScgRbmfDoTkWtes6R2AAh9
-	f1lDKk2h+R8KTE0YQiM6Z5X0noL8XW6t4W69hCKOvYnRSIqZ0cGYOniT01+P8JmUImh8
-	VqHApIiGvkkAAKcmTgIbFQAEGRY4cAAJzKwAAm5ZAAIXLmJcTsPqvRlcQGwABHzNk4iG
-	SRr5Lybmgh2RMjIid7I7NxDS3G+Hjb1qGO3MiKI7fK/98jLouIvW4Ud0rKgk0VjBv+FM
-	6kNzmyDR5C84IcREYMU02gtaTIXJMAA3tQAAwIKdzDmiOM2cizTVDymAkYFFq8AEawQA
-	ALGCgAAFNcYA04QvTGmtdkJ0qZtER/xyrhXHr8g+dzf6gG8AAVGz9S5+I5acS7xXj7Up
-	AznV2sFuAdzYCkAAFdxNnPNsghOxNjZk3MQXYOR0HPlGfFzdZBdlZ52Zs7aGfSOrQFtR
-	BMKl6x6pIzq8UVYdvZM3BuICu5N5kI3hvLhpAt26XMIijTfEbmVd3tqHZ4qNokhrXdUj
-	3BODbf3DuPkXGDBcVRTxjiaDnESw4xvXT/HN86mRhyTbvJuFcM5UQPmJqeXIfzig4ZvR
-	wAAz6VyrT299R8fR7ySbnPNx6O4x0cZvSel9DM90U3PT7fyelAEnsm8y3XuHoAAcPawA
-	cks5Wy+ZF+grtIvSU2TDwdd50RozXW8xO9/pBwhYKx9OblAFpgVUxgnYJxyRa/Kl6udW
-	IWMXykXoohC8xybjD2rBtrnrNgb7iV9XywUQ8anpwAAs9URms97HRAABP7GTcnYCeSIl
-	WutdVccXNIrkAsHkcg2jIcLP4nGgABB+RunOtowE9kCSKAKn0QnRLMwggmHaFm1576Qh
-	oI5INwdGN+G9R+b84sVkRa+TiOAuKyh7rxpERzfxeqBoit+b+X2s9TP/FyCMVrugAAx2
-	q49KI0KK+wOUWcv+9sIKWG4+yklissJg99AeIO+q1ucYBuFrAuBUOpAqI6NeygqISPAU
-	dy/M4YLgC6+1BG06J0vkvQHuAAvC7gtYIu0ihiIw7sOquQv4uRBUIc/+7Cy4EKv0ptBm
-	I8Ne+w9iBOrhB6TWOmNkNeMcSGrO9s7oA8Q4E2Q+vM5+Jajy+ygIv+I4rXCK4yIw46VS
-	VWKoQSIFAksAIq+w+6WSWWDbDnC2JcEdDuSEkfDAIMnaBGlQM8hDDqJXCC18a4Awo0qS
-	RE86qAR8XA3uk0l3EEJYEDEpDzEYtqlMAABIQ4EwQ+BmJQ7mI6/+Yeqqqq/+xmIGe0q5
-	D2JED7FdDOCw5KlhDaL0jsGUhShWR6cQpak0h4IWnerW/4I2+wKKtuIbFGPWJAnerOI4
-	DtGcTeTiVanwmqSQIGTykOgSJGFVG3EQAAoc++CehKpW56XAtrBcqEFvHS7EBERuRy/+
-	0UBIAAjiGsAAB/Hs5q2a7CDPH2rgJAlYlchjFnDUNw164tEaTCquw3F8INDgOCFgSOru
-	CqisiwzGAA/iHMdCaSd7CS/GkWYsYwygVCCiAA9BIs/lG/BC52e0KLDMf4DUVuVyhOBV
-	Jga0cQ52cQ8EGnJ0/mAA7eIREil6lImAIMkIqwcCFacGJEEzKWABH2DOvavexMFIkevl
-	HgABKlBgPmfkFAAArW7+E6AA/cKEt2b/GpIuAAuyAA0MAA+c1ijYJBI8hcu8kfFoLzHO
-	v4RE08kqh2kuIOQ/HrHuuWqulqty7WHDFwRCpwv4eCeC8EIJJLG/HsB+5MaqGCcORmlg
-	iQ6wxAbEBdHkjk7Clgwu5O4WtrBCeYAADdNUITKAj8gGb6kGgMCkgRKQJIFpNuw8f0II
-	//HPEMAAmGCQAAE9OG/y+yIIcsikBuAA9OGof2f6IIGTOjOW9Qd6CnOs61E/LghaNMkc
-	gJLqLwF5PCxQRHL0T/F7L6IMzwAA2wv/LaRwF8tArXBDMMl8sQoqeHOdJfC7IEJhGkrg
-	/CGNG8bA56k/HZDg1wApK6ew56rPPoNeplKyvEXAcQDZQrNYf/Ncl/NhKJNlNpKSJKqq
-	q4II5CNkIInQnRREI3GWNWJPLjO4dqhnIGNZG2FUc8dBLyJ0d5PMkslwIWnQwhQUo+5T
-	N2oOYeIpGQqWIGqq0cNermJ7RI3KIc3u4e6miRJ/QwlHNekFQ4lPGxNrEkJTRchfRgdv
-	O/TAIlPKahPPR7TOJNNbSzQ1S2IKnakMCkXlGzTaJLH+VVFjQKm9RkLycQgmjdAu4ZGE
-	NzEc1DPelvTyJPEiDFUhLc1nKGIKQyIEBBCSD6ggCIOwAerXUaIbDgYfQguQnQl653P4
-	IzROMM/eII/KyEIEu4GkYS2LPVOASISMPe+wuKx3HPBjDhGpLJVAIarOv5HOoA5LGoIO
-	O4IELXUueMDSEQ1kBm//WGIWqq+w7fPovKgqguoG74IonQne5I9wewIQ8gNrBO+0yhDM
-	7fJERGty//RoyolgXBVTWsIUuREY9ekdQhLwIMOgIFUsVGOOEQEwhUBsCCqrXwIiNeuQ
-	v+/xUHPG//GpFQIEcUvY+wQEFKABDmDaIiE3ZCAAPExAv/YKAA7yB0jeYkIwUvCcOqNe
-	vknfGMIJNGtqlrPpMkz0pAyhU/YYIWKKq5GouW7elhRStEIHYCekysE4FIUyCMCXZ9Z+
-	IaNev+v/GMq4rWtyi/HBJpNyh+cRP9EI6nDHVdIHEYrPaOJCvzT4vgABAYp0nzSDM/Ho
-	aIB24Yv+nee1BiqralamIOvyrOtoS7CnVgIQVkAEwYFXJECjAHb+IVVer/UAIUpazUxC
-	cpQA5MSmEGy9KmxcBevGSPEYUgCAZDCYLdVWMYJ9VbcfcBIHDZcmIa5fdaKRHOGZduAA
-	//UWnRZOR7Kw/wIJWEYeovdozddneKKS5olrXm30IoWUF2AA86WmCUtgJLLWkcsperCZ
-	eQdzePe4KM6a1C6feaIecUsYF6AA+iCpcuABcy523vJkWRKtW4IY5JP81rNI+3e+lVe9
-	f2gUJ1PU3vDNfIIc+wnLLaFZgSosJmAA4enfcGUCrXfUIa50W68E57SHf8kjf7g0JS5p
-	gE5u2kImnKw+8UAA341oLG4zP8dLOTE00Xfq25gsybgxRLg7f46I0thvf+KFgC5s49gI
-	RHgq4Pho5Rhth2kTg5iQJJg/h+6g5zhliI4TiNSjiWZHiVisJDfC2ax3d7ig4LP88FQR
-	f1iyShZDZDenepjKJMLcioADIuwGwIAWmaAIQiADb8K7YcPudsH9OAHnGkH4nYH/e3jX
-	kLTaVkpsIEqCIFHiIEnwIEvuMgIG/PfBSUIGVsIFIwIEURkyIGzzkNlBe5AqUCIE4Xkg
-	IHlINmMtdUvPk8IGw6IEoeIEujlDlrdaVlaVkStIIErSOsMsKzlYvFlmIGN4IFlZltmR
-	eK+EJiQdmOKHmSP0ICAADwEAAAMAAAABAIIAAAEBAAMAAAABADoAAAECAAMAAAAEAAAR
-	HgEDAAMAAAABAAUAAAEGAAMAAAABAAIAAAERAAQAAAABAAAACAESAAMAAAABAAEAAAEV
-	AAMAAAABAAQAAAEWAAMAAAABAPwAAAEXAAQAAAABAAAQXAEcAAMAAAABAAEAAAE9AAMA
-	AAABAAIAAAFSAAMAAAABAAEAAAFTAAMAAAAEAAARJodzAAcAAAOsAAARLgAAAAAACAAI
-	AAgACAABAAEAAQABAAADrGFwcGwCAAAAbW50clJHQiBYWVogB9kACgAMAAoAKQAcYWNz
-	cEFQUEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPbWAAEAAAAA0y1hcHBs9W8oikkx
-	pnDACJ6e6PewzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOclhZWgAAASwA
-	AAAUZ1hZWgAAAUAAAAAUYlhZWgAAAVQAAAAUd3RwdAAAAWgAAAAUY2hhZAAAAXwAAAAs
-	clRSQwAAAagAAAAOZ1RSQwAAAbgAAAAOYlRSQwAAAcgAAAAOdmNndAAAAdgAAAAwbmRp
-	bgAAAggAAAA4ZGVzYwAAAkAAAABiZHNjbQAAAqQAAAC6bW1vZAAAA2AAAAAoY3BydAAA
-	A4gAAAAkWFlaIAAAAAAAAHcwAAA/RAAAApdYWVogAAAAAAAAWREAAKz2AAAWm1hZWiAA
-	AAAAAAAmlgAAE9wAALnzWFlaIAAAAAAAAPPYAAEAAAABFghzZjMyAAAAAAABC7cAAAWW
-	///zVwAABykAAP3X///7t////aYAAAPaAADA9mN1cnYAAAAAAAAAAQHNAABjdXJ2AAAA
-	AAAAAAEBzQAAY3VydgAAAAAAAAABAc0AAHZjZ3QAAAAAAAAAAQAA0IIAAAAAAAEAAAAA
-	0IIAAAAAAAEAAAAA0IIAAAAAAAEAAG5kaW4AAAAAAAAAMAAAo0AAAFeAAABLAAAAnAAA
-	ACa3AAASmwAAUEAAAFRAAAI1wwACNcMAAjXDZGVzYwAAAAAAAAAIRGlzcGxheQAAAAAA
-	AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-	AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG1sdWMAAAAAAAAABQAAAAxlblVTAAAADgAA
-	AExmckZSAAAAMAAAAFpqYUpQAAAAEgAAAIppdElUAAAADgAAAJxlc0VTAAAAEAAAAKoA
-	RABpAHMAcABsAGEAeQBNAG8AbgBpAHQAZQB1AHIAIABkAGUAIAB0AHkAcABlACAAaQBu
-	AGMAbwBuAG4AdU4NZg4wbjDHMKMwuTDXMOwwpABNAG8AbgBpAHQAbwByAFAAYQBuAHQA
-	YQBsAGwAYQAAbW1vZAAAAAAAADaYAAADAFFUnuTGMQ+AAAAAAAAAAAAAAAAAAAAAAHRl
-	eHQAAAAAQ29weXJpZ2h0IEFwcGxlLCBJbmMuLCAyMDA5AA==
-	</data>
-	<key>ReadOnly</key>
-	<string>NO</string>
-	<key>RowAlign</key>
-	<integer>1</integer>
-	<key>RowSpacing</key>
-	<real>36</real>
-	<key>SheetTitle</key>
-	<string>Canvas 1</string>
-	<key>SmartAlignmentGuidesActive</key>
-	<string>YES</string>
-	<key>SmartDistanceGuidesActive</key>
-	<string>YES</string>
-	<key>UniqueID</key>
-	<integer>1</integer>
-	<key>UseEntirePage</key>
-	<false/>
-	<key>VPages</key>
-	<integer>1</integer>
-	<key>WindowInfo</key>
-	<dict>
-		<key>CurrentSheet</key>
-		<integer>0</integer>
-		<key>ExpandedCanvases</key>
-		<array>
-			<dict>
-				<key>name</key>
-				<string>Canvas 1</string>
-			</dict>
-		</array>
-		<key>Frame</key>
-		<string>{{165, 46}, {710, 700}}</string>
-		<key>ListView</key>
-		<true/>
-		<key>OutlineWidth</key>
-		<integer>142</integer>
-		<key>RightSidebar</key>
-		<false/>
-		<key>ShowRuler</key>
-		<true/>
-		<key>Sidebar</key>
-		<true/>
-		<key>SidebarWidth</key>
-		<integer>120</integer>
-		<key>VisibleRegion</key>
-		<string>{{-108, -201}, {575, 546}}</string>
-		<key>Zoom</key>
-		<real>1</real>
-		<key>ZoomValues</key>
-		<array>
-			<array>
-				<string>Canvas 1</string>
-				<real>1</real>
-				<real>1</real>
-			</array>
-		</array>
-	</dict>
-	<key>saveQuickLookFiles</key>
-	<string>YES</string>
-</dict>
-</plist>
diff --git a/org.eclipse.rephraserengine.doc.isv/images/architecture.png b/org.eclipse.rephraserengine.doc.isv/images/architecture.png
deleted file mode 100644
index 46d2dfd..0000000
--- a/org.eclipse.rephraserengine.doc.isv/images/architecture.png
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.rephraserengine.doc.isv/plugin.xml b/org.eclipse.rephraserengine.doc.isv/plugin.xml
deleted file mode 100644
index 8b546a7..0000000
--- a/org.eclipse.rephraserengine.doc.isv/plugin.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.2"?>
-<plugin>
-
-   <extension
-         point="org.eclipse.help.toc">
-      <toc
-            file="toc.xml"
-            primary="true">
-      </toc>
-      <toc
-            file="tocconcepts.xml">
-      </toc>
-      <toc
-            file="tocsamples.xml">
-      </toc>
-   </extension>
-
-</plugin>
diff --git a/org.eclipse.rephraserengine.doc.isv/toc.xml b/org.eclipse.rephraserengine.doc.isv/toc.xml
deleted file mode 100644
index 4be38b8..0000000
--- a/org.eclipse.rephraserengine.doc.isv/toc.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?NLS TYPE="org.eclipse.help.toc"?>
-
-<toc label="Rephraser Engine Plug-in Developer Guide">
-   <topic label="Concepts">
-      <anchor id="concepts"/>
-   </topic>
-   <topic label="Samples">
-      <anchor id="samples"/>
-   </topic>
-</toc>
diff --git a/org.eclipse.rephraserengine.doc.isv/tocconcepts.xml b/org.eclipse.rephraserengine.doc.isv/tocconcepts.xml
deleted file mode 100644
index c00f10d..0000000
--- a/org.eclipse.rephraserengine.doc.isv/tocconcepts.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?NLS TYPE="org.eclipse.help.toc"?>
-
-<toc label="Concepts" link_to="toc.xml#concepts">
-    <topic label="Introduction"  href="html/concepts/introduction.html" />
-    <topic label="Contributing Refactorings"  href="html/concepts/refactorings.html" />
-    <topic label="Contributing a Virtual Program Graph"  href="html/concepts/vpg.html" />
-</toc>
diff --git a/org.eclipse.rephraserengine.doc.isv/tocsamples.xml b/org.eclipse.rephraserengine.doc.isv/tocsamples.xml
deleted file mode 100644
index 186714f..0000000
--- a/org.eclipse.rephraserengine.doc.isv/tocsamples.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?NLS TYPE="org.eclipse.help.toc"?>
-
-<toc label="Samples" link_to="toc.xml#samples">
-	<topic label="Samples"  href="html/samples/samples.html" />
-</toc>
