diff --git a/community/QClass_2024/Submissions/HW1/Yasir_Mansour_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Yasir_Mansour_HW1_QClass2024.ipynb new file mode 100644 index 00000000..506f30bd --- /dev/null +++ b/community/QClass_2024/Submissions/HW1/Yasir_Mansour_HW1_QClass2024.ipynb @@ -0,0 +1,851 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "XtC66r2Y5_eT" + }, + "source": [ + "# The Qmod Workshop - Introduction\n", + "\n", + "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", + "\n", + "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", + "\n", + "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", + "\n", + "This workshop consists of step-by-step exercises. It is structured as follows:\n", + "\n", + "- Part 1: Language Fundamentals - Exercises 1-5\n", + "- Part 2: Higher-Level Concepts - Exercises 6-10\n", + "- Part 3: Execution Flows - Exercises 11, 12\n", + "\n", + "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", + "\n", + "### Preparations\n", + "\n", + "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", + "\n", + "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", + "\n", + "### Python Qmod Exercises - General Instructions\n", + "\n", + "In order to synthesize and execute your Qmod code, you should:\n", + "1. Make sure you define a `main` function that calls functions you create.\n", + "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", + "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", + "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RatBmdhm5_e2" + }, + "source": [ + "### Exercise 0: From Model to Execution\n", + "\n", + "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install -U classiq" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "collapsed": true, + "id": "156317w1BFqw", + "outputId": "2bf3654e-05de-4dd1-f7cb-08c9b1d49011" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting classiq\n", + " Downloading classiq-0.41.1-py3-none-any.whl (398 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m398.1/398.1 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", + " Downloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", + "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", + " Downloading Pyomo-6.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m29.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting black<25.0,>=24.0 (from classiq)\n", + " Downloading black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m19.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting httpx<1,>=0.23.0 (from classiq)\n", + " Downloading httpx-0.27.0-py3-none-any.whl (75 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m3.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: keyring<24.0.0,>=23.5.0 in /usr/lib/python3/dist-packages (from classiq) (23.5.0)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (3.7.1)\n", + "Collecting networkx<3.0.0,>=2.5.1 (from classiq)\n", + " Downloading networkx-2.8.8-py3-none-any.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m29.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numexpr<3.0.0,>=2.7.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.10.0)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.25.2)\n", + "Collecting packaging<23.0,>=22.0 (from classiq)\n", + " Downloading packaging-22.0-py3-none-any.whl (42 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m2.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pandas<3.0.0,>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.0.3)\n", + "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (5.15.0)\n", + "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", + " Downloading pydantic-1.10.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m39.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.11.4)\n", + "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", + " Downloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m22.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tabulate<1,>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from classiq) (0.9.0)\n", + "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (8.1.7)\n", + "Collecting mypy-extensions>=0.4.3 (from black<25.0,>=24.0->classiq)\n", + " Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", + "Collecting pathspec>=0.9.0 (from black<25.0,>=24.0->classiq)\n", + " Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", + "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.2.2)\n", + "Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (2.0.1)\n", + "Requirement already satisfied: typing-extensions>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.11.0)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7.1)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (2024.2.2)\n", + "Collecting httpcore==1.* (from httpx<1,>=0.23.0->classiq)\n", + " Downloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n", + "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->classiq)\n", + " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m4.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.51.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2024.1)\n", + "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.3.0)\n", + "Collecting ply (from Pyomo<6.6,>=6.5->classiq)\n", + " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx<1,>=0.23.0->classiq) (1.2.1)\n", + "Installing collected packages: ply, sympy, Pyomo, pydantic, pathspec, packaging, networkx, mypy-extensions, h11, ConfigArgParse, httpcore, black, httpx, classiq\n", + " Attempting uninstall: sympy\n", + " Found existing installation: sympy 1.12\n", + " Uninstalling sympy-1.12:\n", + " Successfully uninstalled sympy-1.12\n", + " Attempting uninstall: pydantic\n", + " Found existing installation: pydantic 2.7.1\n", + " Uninstalling pydantic-2.7.1:\n", + " Successfully uninstalled pydantic-2.7.1\n", + " Attempting uninstall: packaging\n", + " Found existing installation: packaging 24.0\n", + " Uninstalling packaging-24.0:\n", + " Successfully uninstalled packaging-24.0\n", + " Attempting uninstall: networkx\n", + " Found existing installation: networkx 3.3\n", + " Uninstalling networkx-3.3:\n", + " Successfully uninstalled networkx-3.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torch 2.3.0+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.41.1 h11-0.14.0 httpcore-1.0.5 httpx-0.27.0 mypy-extensions-1.0.0 networkx-2.8.8 packaging-22.0 pathspec-0.12.1 ply-3.11 pydantic-1.10.15 sympy-1.10.1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import classiq\n", + "classiq.authenticate()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "EaDN5EkVC58C", + "outputId": "c2446774-718c-4d7c-eb0b-e8e1f676d27d" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Your user code: DJXG-DBNT\n", + "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=DJXG-DBNT\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "DpF2vKUh5_e7" + }, + "outputs": [], + "source": [ + "from classiq import *\n", + "\n", + "\n", + "# Define a quantum function using the @qfunc decorator\n", + "@qfunc\n", + "def qfn(q: QBit) -> None:\n", + " X(target=q)\n", + " H(target=q)\n", + "\n", + "\n", + "# Define a main function\n", + "@qfunc\n", + "def main(res: Output[QBit]) -> None:\n", + " allocate(1, res)\n", + " qfn(q=res)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NXh4E69A5_fC" + }, + "source": [ + "Create a model from it, and synthesize, visualize, and execute it.\n", + "\n", + "Use the General Instructions above to do so.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "UB612BIP5_fE", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "6658d861-fccb-4acb-8bf2-1b52dee5b6c4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/5c3524e1-3515-4fbe-a927-2d47b5270323?version=0.41.1\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ExecutionJob(id='18cfaed0-47cf-450f-bcaa-47a32eb60116')" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "execute(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "s3CXWd3V5_fF" + }, + "source": [ + "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", + "\n", + "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", + "\n", + "We will discuss other quantum types during the workshop.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wtQE208K5_fH" + }, + "source": [ + "# The Qmod Workshop - Part 1: Language Fundamentals\n", + "\n", + "Follow exercises 1 through 5 for the first session of the workshop." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8jM3lrC15_fI" + }, + "source": [ + "## Exercise 1 - Bell Pair\n", + "\n", + "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", + "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", + "\n", + "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "fNOTP83I5_fJ", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "4c0a03a2-6f67-4c15-957e-261b56f1ad91" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/0b923e49-912a-4b24-8492-844448a3cd0d?version=0.41.1\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ExecutionJob(id='f2788c4b-0838-4529-b650-577447a674e6')" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ], + "source": [ + "from classiq import *\n", + "# Define a quantum function using the @qfunc decorator\n", + "@qfunc\n", + "def bell(q1: QBit, q2: QBit) -> None:\n", + " H(target=q1)\n", + " CX(control=q1,target=q2)\n", + "\n", + "# Define a main function\n", + "@qfunc\n", + "def main(res1: Output[QBit], res2: Output[QBit]) -> None:\n", + " allocate(1, res1)\n", + " allocate(1, res2)\n", + " bell(q1=res1,q2=res2)\n", + "\n", + "# Your code here:\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "execute(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AY_kkbyi5_fM" + }, + "source": [ + "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", + "Change your main function to declare a single output (also an array of size 2).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "Y-c9r6OT5_fO", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "8a2a41c7-bcee-4765-8906-4b7026bf3b71" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/434f96a0-8e06-46dc-b09e-fdc7a9308cb2?version=0.41.1\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ExecutionJob(id='a42a082b-7714-4d02-84fe-cb1821e98d05')" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "# Define a quantum function using the @qfunc decorator\n", + "@qfunc\n", + "def bell(q: QArray) -> None:\n", + " H(target=q[0])\n", + " CX(control=q[0],target=q[1])\n", + "\n", + "# Define a main function\n", + "@qfunc\n", + "def main(res: Output[QArray]) -> None:\n", + " allocate(2, res)\n", + " bell(res)\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "execute(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SoXeCLcX5_fQ" + }, + "source": [ + "## Exercise 2 - Repeat\n", + "\n", + "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", + "\n", + "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", + "\n", + "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "vFrcPTqi5_fS", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "48c6573f-ba4d-4c47-b65f-dd2204818e8e" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/cb37c4e0-4286-4bbd-9f70-02abddc58c87?version=0.41.1\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ExecutionJob(id='614e1320-0f6a-48bc-bf70-302f09a46d85')" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "@qfunc\n", + "def my_hadamard(q: QArray) -> None:\n", + " repeat(count=q.len, iteration=lambda i: H(target=q[i]))\n", + "\n", + "# Define a main function\n", + "@qfunc\n", + "def main(res: Output[QArray]) -> None:\n", + " allocate(10, res)\n", + " my_hadamard(res)\n", + "\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "execute(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "98liCUg15_fT" + }, + "source": [ + "### Note: Quantum Variable Capture\n", + "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", + "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", + "\n", + "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fonXAiHP5_fU" + }, + "source": [ + "### Exercise 3 - Power\n", + "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", + "For most operations, it simply means repeating the same circuit multiple times.\n", + "\n", + "Sometimes, however, power can be simplified, thus saving computational resources.\n", + "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", + "\n", + "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", + "\n", + "Use the following code to generate a 2-qubit (real) unitary matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "tD_aBHoU5_fW" + }, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "import numpy as np\n", + "\n", + "from classiq import *\n", + "\n", + "rng = np.random.default_rng(seed=0)\n", + "random_matrix = rng.random((4, 4))\n", + "qr_unitary, _ = np.linalg.qr(random_matrix)\n", + "\n", + "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yRWVHm1O5_fY" + }, + "source": [ + "In order to reuse some classical value we can define a `QConstant` to store that value.\n", + "\n", + "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", + "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", + "3. Compare the gate count via the Classiq’s IDE in both cases.\n", + "\n", + "Note - the signature of function `unitary` is:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "bTtPgsj75_fZ" + }, + "outputs": [], + "source": [ + "def unitary(\n", + " elements: CArray[CArray[CReal]],\n", + " target: QArray[QBit],\n", + ") -> None:\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "6Js8fNbl5_fa", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "4d13cc20-3b3f-45b8-93fb-b353ab8cbea0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/94eb7893-0314-4fe6-b229-f31bf70e2808?version=0.41.1\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ExecutionJob(id='b1b283d2-0c26-46a4-8577-fa33a79255cf')" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "rng = np.random.default_rng(seed=0)\n", + "random_matrix = rng.random((4, 4))\n", + "qr_unitary, _ = np.linalg.qr(random_matrix)\n", + "\n", + "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())\n", + "\n", + "\n", + "@qfunc\n", + "def main(q: Output[QArray[QBit]]) -> None:\n", + " allocate(2, q)\n", + " power(3, lambda: unitary(unitary_matrix, q))\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "execute(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "P-jP3v9O5_fb" + }, + "source": [ + "## Exercise 4 - User-defined Operators\n", + "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", + "\n", + "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", + "\n", + "Follow these guidelines:\n", + "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", + "2. The body should apply the operand to all qubits in the argument.\n", + "\n", + "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", + "Use the same main function from exercise 2." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "vvMbP91D5_fc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "18fca5c9-3b26-4683-98c7-c17f27de698a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/b516311f-de20-43bc-828b-981b114cb3d8?version=0.41.1\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ExecutionJob(id='06c0d754-c529-4c95-b80b-5b45aeb165c0')" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "\n", + "@qfunc\n", + "def my_apply_to_all(operand: QCallable[QBit], q: QArray[QBit]) -> None:\n", + " repeat(q.len, lambda i: operand(q[i]))\n", + "\n", + "@qfunc\n", + "def my_hadamard(q: QArray[QBit]) -> None:\n", + " my_apply_to_all(lambda t: H(t), q)\n", + "\n", + "# Define a main function\n", + "@qfunc\n", + "def main(q: Output[QArray[QBit]]) -> None:\n", + " allocate(10, q)\n", + " my_hadamard(q)\n", + "\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "execute(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gh690ZGT5_fe" + }, + "source": [ + "# Exercise 5 - Quantum Conditionals\n", + "\n", + "### Exercise 5a - Control Operator\n", + "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", + "\n", + "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "00trO6SJ5_ff", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "b022f930-40a5-436c-b3af-0a4e4e5d21d7" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/f3c67563-851e-4c53-a672-c64330254cf1?version=0.41.1\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ExecutionJob(id='be6a11e8-0250-4927-a910-51895da28286')" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "from classiq.qmod.symbolic import pi\n", + "\n", + "\n", + "@qfunc\n", + "def my_controlled_ry(control_bit: QBit, target: QBit) -> None:\n", + " control(control_bit, lambda: RY(pi / 2, target))\n", + "\n", + "\n", + "@qfunc\n", + "def main(control_bit: Output[QBit], target: Output[QBit]) -> None:\n", + " allocate(1, control_bit)\n", + " allocate(1, target)\n", + " my_controlled_ry(control_bit, target)\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "execute(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GJ9y7jlY5_fh" + }, + "source": [ + "### Exercise 5b - Control (\"Quantum If\")\n", + "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", + "\n", + "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", + "\n", + "In QMOD this generalization is available as a native statement - control.\n", + "\n", + "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", + "\n", + "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", + "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", + "3. Execute the circuit and observe the results.\n", + "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "IohNdRCA5_fi", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c3d53156-d530-48b8-e31b-80990b06e66d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/5d49551d-e463-4428-b4b4-e853839c0a74?version=0.41.0\n" + ] + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "@qfunc\n", + "def main(x: Output[QNum], target: Output[QBit]) -> None:\n", + " prepare_int(9, x)\n", + " allocate(1, target)\n", + " control(x == 9, lambda: X(target))\n", + "\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + }, + "colab": { + "provenance": [] + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW2/Yasir_Mansour_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Yasir_Mansour_HW2_QClass2024.ipynb new file mode 100644 index 00000000..783f1705 --- /dev/null +++ b/community/QClass_2024/Submissions/HW2/Yasir_Mansour_HW2_QClass2024.ipynb @@ -0,0 +1,990 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NbVeWUvUOPPN" + }, + "source": [ + "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", + "\n", + "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install classiq" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "collapsed": true, + "id": "CSoLXYc-P-zb", + "outputId": "32e4c151-5e82-4ff8-df53-e9ac710f2507" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting classiq\n", + " Downloading classiq-0.41.2-py3-none-any.whl (398 kB)\n", + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/398.1 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m143.4/398.1 kB\u001b[0m \u001b[31m4.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m \u001b[32m389.1/398.1 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m398.1/398.1 kB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", + " Downloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", + "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", + " Downloading Pyomo-6.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m28.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting black<25.0,>=24.0 (from classiq)\n", + " Downloading black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m35.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting httpx<1,>=0.23.0 (from classiq)\n", + " Downloading httpx-0.27.0-py3-none-any.whl (75 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: keyring<24.0.0,>=23.5.0 in /usr/lib/python3/dist-packages (from classiq) (23.5.0)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (3.7.1)\n", + "Collecting networkx<3.0.0,>=2.5.1 (from classiq)\n", + " Downloading networkx-2.8.8-py3-none-any.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m26.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numexpr<3.0.0,>=2.7.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.10.0)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.25.2)\n", + "Collecting packaging<23.0,>=22.0 (from classiq)\n", + " Downloading packaging-22.0-py3-none-any.whl (42 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pandas<3.0.0,>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.0.3)\n", + "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (5.15.0)\n", + "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", + " Downloading pydantic-1.10.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m16.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.11.4)\n", + "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", + " Downloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m34.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tabulate<1,>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from classiq) (0.9.0)\n", + "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (8.1.7)\n", + "Collecting mypy-extensions>=0.4.3 (from black<25.0,>=24.0->classiq)\n", + " Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", + "Collecting pathspec>=0.9.0 (from black<25.0,>=24.0->classiq)\n", + " Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", + "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.2.2)\n", + "Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (2.0.1)\n", + "Requirement already satisfied: typing-extensions>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.11.0)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7.1)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (2024.2.2)\n", + "Collecting httpcore==1.* (from httpx<1,>=0.23.0->classiq)\n", + " Downloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m8.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n", + "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->classiq)\n", + " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.51.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2024.1)\n", + "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.3.0)\n", + "Collecting ply (from Pyomo<6.6,>=6.5->classiq)\n", + " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx<1,>=0.23.0->classiq) (1.2.1)\n", + "Installing collected packages: ply, sympy, Pyomo, pydantic, pathspec, packaging, networkx, mypy-extensions, h11, ConfigArgParse, httpcore, black, httpx, classiq\n", + " Attempting uninstall: sympy\n", + " Found existing installation: sympy 1.12\n", + " Uninstalling sympy-1.12:\n", + " Successfully uninstalled sympy-1.12\n", + " Attempting uninstall: pydantic\n", + " Found existing installation: pydantic 2.7.1\n", + " Uninstalling pydantic-2.7.1:\n", + " Successfully uninstalled pydantic-2.7.1\n", + " Attempting uninstall: packaging\n", + " Found existing installation: packaging 24.0\n", + " Uninstalling packaging-24.0:\n", + " Successfully uninstalled packaging-24.0\n", + " Attempting uninstall: networkx\n", + " Found existing installation: networkx 3.3\n", + " Uninstalling networkx-3.3:\n", + " Successfully uninstalled networkx-3.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torch 2.3.0+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.41.2 h11-0.14.0 httpcore-1.0.5 httpx-0.27.0 mypy-extensions-1.0.0 networkx-2.8.8 packaging-22.0 pathspec-0.12.1 ply-3.11 pydantic-1.10.15 sympy-1.10.1\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "yLmI64uHOPPX" + }, + "outputs": [], + "source": [ + "from classiq import *" + ] + }, + { + "cell_type": "code", + "source": [ + "import classiq\n", + "classiq.authenticate()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "Js5S3AMtP6LJ", + "outputId": "d3f334a9-6dcf-4e2a-f547-b68342d126ea" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Your user code: PXGV-WPZJ\n", + "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=PXGV-WPZJ\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DLFwpFN8OPPd" + }, + "source": [ + "### Exercise 6 - Exponentiation and Pauli Operators\n", + "\n", + "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", + "\n", + "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", + "\n", + "The builtin struct type `PauliTerm` is defined as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "EEjNNhY3OPPe" + }, + "outputs": [], + "source": [ + "@struct\n", + "class PauliTerm:\n", + " pauli: CArray[Pauli]\n", + " coefficient: CReal" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oOlb_yyJOPPg" + }, + "source": [ + "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", + "\n", + "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", + "\n", + "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", + "\n", + "The declaration of the `suzuki_trotter` function is:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "uO1d4ba3OPPi" + }, + "outputs": [], + "source": [ + "@qfunc(external=True)\n", + "def suzuki_trotter(\n", + " pauli_operator: CArray[PauliTerm],\n", + " evolution_coefficient: CReal,\n", + " order: CInt,\n", + " repetitions: CInt,\n", + " qbv: QArray[QBit],\n", + ") -> None:\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jGcQahGvOPPk" + }, + "source": [ + "Fill in the missing parts of the following code in order to complete this exercise:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-ZPy2HjIOPPl", + "outputId": "fc91afc7-7cfc-4efe-b1d4-c3da484dfaeb" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/695d17a9-edaa-4811-8aea-04f575daf238?version=0.41.2\n" + ] + } + ], + "source": [ + "from classiq import *\n", + "\n", + "\n", + "@qfunc\n", + "def main(q: Output[QArray[QBit]]) -> None:\n", + " allocate(4, q)\n", + " suzuki_trotter(\n", + " [\n", + " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", + " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", + " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3),\n", + " ],\n", + " #[0.5XZXX + 0.25YIZI + 0.3 XIZY],\n", + " evolution_coefficient=3,\n", + " repetitions=4,\n", + " order=2,\n", + " qbv=q,\n", + " )\n", + "\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "a2tiByHPVxIm" + } + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YVauJN06OPPr" + }, + "source": [ + "### Exercise 7 - Basic Arithmetics\n", + "\n", + "#### Exercise 7a\n", + "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", + "\n", + "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", + "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", + "\n", + "Create the following quantum programs:\n", + "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", + "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", + "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", + "\n", + "Guidance:\n", + "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", + "* To initialize the variables, use the function `prepare_int`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2Ad42tEjOPPt", + "outputId": "0e3c5195-3914-4296-b400-067df17efb67" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/f6ab280e-a2d2-4b4f-9fe6-6063ec883f5c?version=0.41.2\n" + ] + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "@qfunc\n", + "def main(res1: Output[QNum], res2: Output[QNum], res3: Output[QNum], x: Output[QNum], y: Output[QNum], z: Output[QNum]):\n", + " prepare_int(2, x)\n", + " prepare_int(7, y)\n", + " prepare_int(1, z)\n", + " res1 |= x + y\n", + " res2 |= x * y\n", + " res3 |= x * y - z\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oD9FFw0hOPPv" + }, + "source": [ + "#### Exercise 7b\n", + "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", + "\n", + "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", + "\n", + "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", + " The declaration of the `prepare_state` function is:\n", + " ```\n", + " @qfunc(external=True)\n", + " def prepare_state(\n", + " probabilities: CArray[CReal],\n", + " bound: CReal,\n", + " out: Output[QArray[QBit]],\n", + " ) -> None:\n", + " pass\n", + " ```\n", + " (Set the bound to 0 in your code)\n", + "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "J5aQnWHEOPPx", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ea1de78b-3848-4255-d430-b1ae0bcc7cd2" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/6ee76891-980f-4b54-8403-44cb5e8b590c?version=0.41.2\n" + ] + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "@qfunc\n", + "def main(res: Output[QNum], x: Output[QNum], y: Output[QNum]):\n", + " prepare_state([0.5, 0, 0.5, 0], bound=0.01, out=x)\n", + " prepare_state([0, 0.25, 0.25, 0.25, 0, 0, 0.25, 0], bound=0.01, out=y)\n", + " res |= x + y\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QguPlrPLOPPz" + }, + "source": [ + "### Exercise 8 - Within-Apply\n", + "\n", + "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", + "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", + "\n", + "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", + "\n", + "#### Exercise 8a\n", + "\n", + "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", + "\n", + "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", + "1. Add `x` and `y`\n", + "2. Add the result to `z`\n", + "3. Uncompute the result of the first operation\n", + "\n", + "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", + "\n", + "Hints:\n", + "\n", + "* Use a temporary variable.\n", + "* Wrap the arithmetic operation in a function.\n", + "\n", + "Execute the circuit and make sure you obtain the expected result." + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "kvEu55w7Ssac" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gOMBLIf7OPP1", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ee6530e4-3fa1-4d46-d151-9862ee961b5e" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/b9d46036-f719-4772-8e97-7a41269e10c1?version=0.41.2\n" + ] + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "@qfunc\n", + "def q_add(res: Output[QNum], a:QNum, b:QNum) -> None:\n", + " res |= a + b\n", + "\n", + "@qfunc\n", + "def main(res: Output[QNum], x: Output[QNum],\n", + " y: Output[QNum], z: Output[QNum]) -> None:\n", + " prepare_int(3, x)\n", + " prepare_int(5, y)\n", + " prepare_int(2, z)\n", + " aux = QNum('aux')\n", + " within_apply(compute = lambda: q_add(aux, x, y),\n", + " action = lambda: q_add(res, aux, z))\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "#13 qbits" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "umMhnAelOPP2" + }, + "source": [ + "#### Exercise 8b\n", + "\n", + "Why should we use `within-apply` and not just write three concatenated functions?\n", + "To understand the motivation, we will create another arithmetic circuit.\n", + "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", + "\n", + "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", + "\n", + "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", + "\n", + "1. Add `x` and `y` (as part of the `within_apply` operation)\n", + "2. Add the result to `z` (as part of the within_apply operation)\n", + "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", + "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", + "\n", + "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ED1iDS1aOPP5", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2260c2b1-d176-4c26-a83f-e0be9d1b6804" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/76b99051-ff09-4588-b522-435cd54c7223?version=0.41.2\n" + ] + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "@qfunc\n", + "def q_add(res: Output[QNum], a:QNum, b:QNum) -> None:\n", + " res |= a + b\n", + "\n", + "@qfunc\n", + "def main(res: Output[QNum], x: Output[QNum],\n", + " y: Output[QNum], z: Output[QNum], w: Output[QNum]) -> None:\n", + " prepare_int(3, x)\n", + " prepare_int(5, y)\n", + " prepare_int(2, z)\n", + " prepare_int(4, w)\n", + " aux1 = QNum('aux1')\n", + " aux2 = QNum('aux2')\n", + " within_apply(compute = lambda: q_add(aux1, x, y),\n", + " action = lambda: q_add(aux2, aux1, z),)\n", + " res |= aux2 + w\n", + "\n", + "\n", + "\n", + "qmod = create_model(main)\n", + "qmod = set_constraints(qmod,\n", + " Constraints(optimization_parameter='width'))\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "#16 qbits" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pIBHrEOxOPP6" + }, + "source": [ + "#### Bonus: Use a Single Arithmetic Expression\n", + "\n", + "What happens when we don't manually decompose this expression?\n", + "\n", + "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", + "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ep-Efm_oOPP8", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "258d0b91-cb7a-4a25-b80d-0492e6557fe1" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/1b073d18-c8d5-4f19-8c2d-7e2f064a18bd?version=0.41.2\n" + ] + } + ], + "source": [ + "from classiq import *\n", + "\n", + "# Your code here:\n", + "@qfunc\n", + "def q_add(res: Output[QNum], a:QNum, b:QNum) -> None:\n", + " res |= a + b\n", + "\n", + "@qfunc\n", + "def main(res: Output[QNum], x: Output[QNum],\n", + " y: Output[QNum], z: Output[QNum], w: Output[QNum]) -> None:\n", + " prepare_int(3, x)\n", + " prepare_int(5, y)\n", + " prepare_int(2, z)\n", + " prepare_int(4, w)\n", + " res |= x + y + z + w\n", + "\n", + "qmod = create_model(main)\n", + "qmod = set_constraints(qmod,\n", + " Constraints(optimization_parameter='width'))\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "#15 qbits" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZV9OGqqROPP-" + }, + "source": [ + "### Exercise 9 - In-place Arithmetics\n", + "\n", + "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", + "\n", + "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", + "\n", + "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", + "\n", + "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", + "\n", + "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", + "\n", + "$$\n", + "f(x) = \\begin{cases}\n", + " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", + " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", + " \\end{cases}\n", + "$$\n", + "\n", + "Notes:\n", + "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", + "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "P1AsWxksOPQA", + "outputId": "c56c759d-fb58-45d7-b8b6-fc801c611f11", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/d3fb232d-2ee5-4824-a49d-c7febcc4ff91?version=0.41.2\n" + ] + } + ], + "source": [ + "\n", + "from classiq import *\n", + "\n", + "\n", + "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", + " res ^= a * x + b\n", + "\n", + "\n", + "@qfunc\n", + "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", + " CX(qba[qba.len - 1], msb)\n", + "\n", + "\n", + "@qfunc\n", + "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", + " allocate(5, res)\n", + " allocate(3, x)\n", + " hadamard_transform(x)\n", + "\n", + " label = QArray(\"label\")\n", + " allocate(1, label)\n", + "\n", + " dup_msb(x, label)\n", + " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", + " X(label)\n", + " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", + "\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OOvAn02QOPQC" + }, + "source": [ + "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", + "\n", + "#### Binding\n", + "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "JCX6UMqROPQD", + "outputId": "6d35d8f5-4341-4560-b708-d70d443dab84", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/2e528279-8038-4233-b2e7-f4844d8dcaa3?version=0.41.2\n" + ] + } + ], + "source": [ + "from classiq import *\n", + "\n", + "\n", + "\n", + "from classiq import *\n", + "from math import pi\n", + "\n", + "\n", + "@qfunc\n", + "def main(res: Output[QArray[QBit]]) -> None:\n", + " x: QArray[QBit] = QArray(\"x\")\n", + " allocate(3, x)\n", + " hadamard_transform(x)\n", + "\n", + " lsb = QBit(\"lsb\")\n", + " msb = QNum(\"msb\", 2, False, 0)\n", + " bind(x, [lsb, msb])\n", + "\n", + " control(msb == 1, lambda: RY(pi / 3, lsb))\n", + " # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", + "\n", + " bind([lsb, msb], res)\n", + "\n", + "model = create_model(main)\n", + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fc5-bUyKOPQF" + }, + "source": [ + "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", + "\n", + "After the `bind` operation:\n", + "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", + "2. The register`x` is consumed and can no longer be used.\n", + "\n", + "The second `bind` operation concatenates the registers to the output register `res`.\n", + "\n", + "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", + "\n", + "The following series of gates generate it:\n", + "\n", + "Perform the Hadamard transform on all three qubits.\n", + "\n", + "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", + "\n", + "The following series of gates generate it:\n", + "1. Perform the Hadamard transform on all three qubits.\n", + "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", + "\n", + "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "nSjVMfP8OPQG", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "5ca3382b-fcf8-4901-bf77-72eb916118a0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/63674ff7-ef0f-4d21-8ffa-60b078c5de78?version=0.41.2\n" + ] + } + ], + "source": [ + "#version 1 with msb, lsb, H, RY\n", + "from classiq import *\n", + "from classiq.qmod.symbolic import sqrt\n", + "from math import pi\n", + "\n", + "prob_list= [\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8 - sqrt(3) / 16,\n", + " 1 / 8 + sqrt(3) / 16,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " ]\n", + "@qfunc\n", + "def pre_prepared_state(q: QArray[QBit]) -> None:\n", + " prepare_state(\n", + " [\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8 - sqrt(3) / 16,\n", + " 1 / 8 + sqrt(3) / 16,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " ],\n", + " 0.0,\n", + " q,\n", + " )\n", + "\n", + "@qfunc\n", + "def main(res: Output[QArray[QBit]]) -> None:\n", + " x: QArray[QBit] = QArray(\"x\")\n", + " allocate(3, x)\n", + " hadamard_transform(x)\n", + "\n", + " lsb = QBit(\"lsb\")\n", + " msb = QNum(\"msb\", 2, False, 0)\n", + " bind(x, [lsb, msb])\n", + "\n", + " control(msb == 1, lambda: RY(pi / 3, lsb))\n", + " # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", + " bind([lsb, msb], res)\n", + "\n", + " #prepare_state(probabilities=prob_list, bound=0.0, out=res)\n", + "\n", + "model = create_model(main)\n", + "qprog = synthesize(model)\n", + "show(qprog)\n", + "\n", + "# Your code here:" + ] + }, + { + "cell_type": "code", + "source": [ + "#version 2 with prepare_state\n", + "from classiq import *\n", + "from classiq.qmod.symbolic import sqrt\n", + "from math import pi\n", + "\n", + "prob_list= [\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8 - sqrt(3) / 16,\n", + " 1 / 8 + sqrt(3) / 16,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " ]\n", + "@qfunc\n", + "def pre_prepared_state(q: Output[QArray[QBit]]) -> None:\n", + " prepare_state(\n", + " [\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8 - sqrt(3) / 16,\n", + " 1 / 8 + sqrt(3) / 16,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " 1 / 8,\n", + " ],\n", + " 0.0,\n", + " q,\n", + " )\n", + "\n", + "@qfunc\n", + "def main(res: Output[QArray[QBit]]) -> None:\n", + " prepare_state(probabilities=prob_list, bound=0.0, out=res)\n", + "\n", + "model = create_model(main)\n", + "qprog = synthesize(model)\n", + "show(qprog)\n", + "\n", + "# Your code here:" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "mp0cnm12XKjo", + "outputId": "c97473fc-1b10-4bc0-b9ec-2db111726a00" + }, + "execution_count": 29, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/ea88176e-2348-4b64-b56e-4ef2921eeb51?version=0.41.2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "-TDAFwWbXVeT" + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + }, + "colab": { + "provenance": [], + "include_colab_link": true + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.ipynb new file mode 100644 index 00000000..3c3f1a50 --- /dev/null +++ b/community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.ipynb @@ -0,0 +1,576 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", + "metadata": { + "id": "fc72d98f-8993-4bd4-a545-23d122f3df71" + }, + "source": [ + "# H₂ Molecule Homework Assignment\n", + "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", + "\n", + "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", + "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." + ] + }, + { + "cell_type": "markdown", + "id": "56eda6d8-76c4-4862-b914-0c4598d67274", + "metadata": { + "id": "56eda6d8-76c4-4862-b914-0c4598d67274" + }, + "source": [ + "## Submission\n", + "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", + "- Use the Typeform link provided in the submission folder to confirm your submission.\n", + "\n", + "## Additional Resources\n", + "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", + "- The notebook from live session #3\n", + "\n", + "## Important Dates\n", + "- **Assignment Release:** 22.5.2024\n", + "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", + "\n", + "---\n", + "\n", + "Happy coding and good luck!" + ] + }, + { + "cell_type": "markdown", + "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", + "metadata": { + "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b" + }, + "source": [ + "### Part 1" + ] + }, + { + "cell_type": "markdown", + "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", + "metadata": { + "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2" + }, + "source": [ + "Given the following Hamiltonian:" + ] + }, + { + "cell_type": "markdown", + "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", + "metadata": { + "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4" + }, + "source": [ + "$$\n", + "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", + "metadata": { + "id": "736d275c-9a5a-4c08-b891-3078430dc6c1" + }, + "source": [ + "Complete the following code" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install classiq" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "DQOxbZxjrN5r", + "outputId": "7ffed65a-717f-4f7a-d969-d999a1fa6611" + }, + "id": "DQOxbZxjrN5r", + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting classiq\n", + " Downloading classiq-0.42.0-py3-none-any.whl (401 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m401.5/401.5 kB\u001b[0m \u001b[31m2.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", + " Downloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", + "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", + " Downloading Pyomo-6.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m24.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting black<25.0,>=24.0 (from classiq)\n", + " Downloading black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m14.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting httpx<1,>=0.23.0 (from classiq)\n", + " Downloading httpx-0.27.0-py3-none-any.whl (75 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: keyring<24.0.0,>=23.5.0 in /usr/lib/python3/dist-packages (from classiq) (23.5.0)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (3.7.1)\n", + "Collecting networkx<3.0.0,>=2.5.1 (from classiq)\n", + " Downloading networkx-2.8.8-py3-none-any.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m51.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numexpr<3.0.0,>=2.7.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.10.0)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.25.2)\n", + "Collecting packaging<23.0,>=22.0 (from classiq)\n", + " Downloading packaging-22.0-py3-none-any.whl (42 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m2.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pandas<3.0.0,>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.0.3)\n", + "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (5.15.0)\n", + "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", + " Downloading pydantic-1.10.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m36.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.11.4)\n", + "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", + " Downloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m51.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tabulate<1,>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from classiq) (0.9.0)\n", + "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (8.1.7)\n", + "Collecting mypy-extensions>=0.4.3 (from black<25.0,>=24.0->classiq)\n", + " Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", + "Collecting pathspec>=0.9.0 (from black<25.0,>=24.0->classiq)\n", + " Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", + "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.2.2)\n", + "Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (2.0.1)\n", + "Requirement already satisfied: typing-extensions>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.11.0)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7.1)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (2024.2.2)\n", + "Collecting httpcore==1.* (from httpx<1,>=0.23.0->classiq)\n", + " Downloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m1.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n", + "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->classiq)\n", + " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m4.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.51.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2024.1)\n", + "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.3.0)\n", + "Collecting ply (from Pyomo<6.6,>=6.5->classiq)\n", + " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx<1,>=0.23.0->classiq) (1.2.1)\n", + "Installing collected packages: ply, sympy, Pyomo, pydantic, pathspec, packaging, networkx, mypy-extensions, h11, ConfigArgParse, httpcore, black, httpx, classiq\n", + " Attempting uninstall: sympy\n", + " Found existing installation: sympy 1.12\n", + " Uninstalling sympy-1.12:\n", + " Successfully uninstalled sympy-1.12\n", + " Attempting uninstall: pydantic\n", + " Found existing installation: pydantic 2.7.1\n", + " Uninstalling pydantic-2.7.1:\n", + " Successfully uninstalled pydantic-2.7.1\n", + " Attempting uninstall: packaging\n", + " Found existing installation: packaging 24.0\n", + " Uninstalling packaging-24.0:\n", + " Successfully uninstalled packaging-24.0\n", + " Attempting uninstall: networkx\n", + " Found existing installation: networkx 3.3\n", + " Uninstalling networkx-3.3:\n", + " Successfully uninstalled networkx-3.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torch 2.3.0+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.42.0 h11-0.14.0 httpcore-1.0.5 httpx-0.27.0 mypy-extensions-1.0.0 networkx-2.8.8 packaging-22.0 pathspec-0.12.1 ply-3.11 pydantic-1.10.15 sympy-1.10.1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import classiq" + ], + "metadata": { + "id": "o13wIglSeo7y" + }, + "id": "o13wIglSeo7y", + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "classiq.authenticate()" + ], + "metadata": { + "id": "jLanwByIe4eJ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "6dec848a-472c-4dc6-8104-d8d00fbbb8e6" + }, + "id": "jLanwByIe4eJ", + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Your user code: PXSB-NCBB\n", + "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=PXSB-NCBB\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", + "metadata": { + "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8" + }, + "outputs": [], + "source": [ + "from typing import List, cast\n", + "from classiq import *\n", + "from classiq import Pauli, PauliTerm\n", + "\n", + "#TODO: Complete Hamiltonian\n", + "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [\n", + " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", + " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", + " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0bb68899-2076-45c0-8868-131f38aa3b78", + "metadata": { + "id": "0bb68899-2076-45c0-8868-131f38aa3b78" + }, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", + " # TODO: Create an ansatz which allows each qubit to have\n", + " # arbitrary rotation\n", + "\n", + " allocate(2, q)\n", + " U(angles[0], angles[1], angles[2], 0, q[0])\n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", + " #CX(q[0], q[1])\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " res = vqe(\n", + " hamiltonian=HAMILTONIAN,\n", + " maximize=False,\n", + " initial_point=[],\n", + " optimizer=Optimizer.COBYLA,\n", + " max_iteration=1000,\n", + " tolerance=0.001,\n", + " step_size=0,\n", + " skip_compute_variance=False,\n", + " alpha_cvar=1.0,\n", + " )\n", + " save({\"result\": res})\n", + "\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "#TODO: complete the line, use classical_execution_function\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", + "metadata": { + "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382" + }, + "outputs": [], + "source": [ + "execution = execute(qprog)\n", + "res = execution.result()\n", + "# execution.open_in_ide()\n", + "vqe_result = res[0].value\n", + " #TODO: complete the line" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", + "metadata": { + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", + "outputId": "67a7bccc-f67c-4dfc-aad2-7011fc51905c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Optimal energy: -1.0711231445312501\n", + "Optimal parameters: {'angles_0': -3.0914206855935538, 'angles_1': -0.23729943557563232, 'angles_2': -2.5756826635214636}\n", + "Eigenstate: {'01': (0.02209708691207961+0j), '11': (0.9997558295653994+0j)}\n" + ] + } + ], + "source": [ + "print(f\"Optimal energy: {vqe_result.energy}\")\n", + "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", + "print(f\"Eigenstate: {vqe_result.eigenstate}\")" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Optimal energy: -1.0711231445312501\n", + "Optimal parameters:\n", + "{'angles_0': -3.0914206855935538, 'angles_1': -0.23729943557563232, 'angles_2': -2.5756826635214636}\n", + "Eigenstate:\n", + "{'01': (0.02209708691207961+0j),\n", + "'11': (0.9997558295653994+0j)}" + ], + "metadata": { + "id": "Yy49RbSEytVl" + }, + "id": "Yy49RbSEytVl" + }, + { + "cell_type": "markdown", + "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", + "metadata": { + "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa" + }, + "source": [ + "Does it similar to the `optimal energy` we calculated in class? \\\n", + "Does it similar to the `total energy` we calculated in class?" + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "29J60aKnzkKl" + }, + "id": "29J60aKnzkKl", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", + "metadata": { + "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f" + }, + "source": [ + "### Part 2" + ] + }, + { + "cell_type": "markdown", + "id": "66882248-de08-4a6e-b33c-647f015f7d79", + "metadata": { + "id": "66882248-de08-4a6e-b33c-647f015f7d79" + }, + "source": [ + "**Now, we want to have a more interesting ansatz in our `main`.** \n", + "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", + "Which gate should you use?" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", + "metadata": { + "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145" + }, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", + " # TODO: Create an ansatz which allows each qubit to have\n", + " # arbitrary rotation\n", + "\n", + " allocate(2, q)\n", + " U(angles[0], angles[1], angles[2], 0, q[0])\n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", + " CX(q[0], q[1])\n", + " #H(q[0])\n", + " #X(q[1])\n", + " #CX(q[0], q[1])\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " res = vqe(\n", + " HAMILTONIAN, # TODO: complete the missing argument\n", + " False,\n", + " [],\n", + " optimizer=Optimizer.COBYLA,\n", + " max_iteration=1000,\n", + " tolerance=0.001,\n", + " step_size=0,\n", + " skip_compute_variance=False,\n", + " alpha_cvar=1.0,\n", + " )\n", + " save({\"result\": res})\n", + "\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "#TODO: complete the line, use classical_execution_function\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "112a1590-283c-4f79-8035-72936561102d", + "metadata": { + "id": "112a1590-283c-4f79-8035-72936561102d" + }, + "outputs": [], + "source": [ + "execution = execute(qprog)\n", + "res = execution.result()\n", + "# execution.open_in_ide()\n", + "vqe_result = res[0].value\n", + "#TODO: complete the line" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", + "metadata": { + "jupyter": { + "outputs_hidden": true + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", + "outputId": "dcaccb41-a8ff-4e1d-eb1e-8f110ed93820" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Optimal energy: -1.8452896484374999\n", + "Optimal parameters: {'angles_0': -2.9812026284028255, 'angles_1': 0.8040137892002661, 'angles_2': 5.77426479151465}\n", + "Eigenstate: {'11': (0.08267972847076846+0j), '10': (0.07967217989988726+0j), '01': (0.9933863328282708+0j)}\n" + ] + } + ], + "source": [ + "print(f\"Optimal energy: {vqe_result.energy}\")\n", + "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", + "print(f\"Eigenstate: {vqe_result.eigenstate}\")" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Optimal energy: -1.8452896484374999\n", + "Optimal parameters:\n", + "{'angles_0': -2.9812026284028255, 'angles_1': 0.8040137892002661, 'angles_2': 5.77426479151465}\n", + "\n", + "Eigenstate:\n", + "{'11': (0.08267972847076846+0j),\n", + "'10': (0.07967217989988726+0j),\n", + "'01': (0.9933863328282708+0j)}\n" + ], + "metadata": { + "id": "-7V3qnVRzFmJ" + }, + "id": "-7V3qnVRzFmJ" + }, + { + "cell_type": "markdown", + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", + "metadata": { + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8" + }, + "source": [ + "Does it similar to the `optimal energy` we calculated in class? \\\n", + "Does it similar to the `total energy` we calculated in class? \\\n", + "What can we learn about the provided form this result Hamiltonian?\n", + "\n", + "With entanglement one gets better results." + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "726uVxmDzYXE" + }, + "id": "726uVxmDzYXE", + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + }, + "colab": { + "provenance": [], + "include_colab_link": true + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW4/Yasir_Mansour_molecule_eigensolver_ipynb_txt.ipynb b/community/QClass_2024/Submissions/HW4/Yasir_Mansour_molecule_eigensolver_ipynb_txt.ipynb new file mode 100644 index 00000000..e8a8e412 --- /dev/null +++ b/community/QClass_2024/Submissions/HW4/Yasir_Mansour_molecule_eigensolver_ipynb_txt.ipynb @@ -0,0 +1,7462 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "id": "4fbae0f9", + "metadata": { + "id": "4fbae0f9" + }, + "source": [ + "# Molecule Eigensolver (VQE method)\n", + "\n", + "Evaluating the ground state of a molecular Hamiltonian allows us to understand the chemical properties of the molecule. In this demo, we demonstrate the usage of Variational Quantum Eigensolver (VQE) for finding the ground states and energies of several molecules: 𝐻2 , 𝐻2𝑂 and 𝐿𝑖𝐻 .\n", + "\n", + "VQE is a leading method for finding approximate values of ground state wavefuncions and energies for complicated quantum systems, and as such can give solutions for complex molecular structures. The overview of the VQE method is as following: a problem (i.e. a molecule) is defined by a Hamiltonian which ground state is sought. Then, a choice of a parameterized ansatz is made. Using a hybrid quantum-classical algorithm, a solution for the defined parameters which minimize the expectation value for the energy is found. A clever ansatz will lead to an estimated ground state solution.\n", + "\n", + "Within the scope of Classiq's VQE algorithm, the user defines a Molecule which is being translated to a concise Hamiltonian. Then, a choice between several types of well studied ansatz is given, which can be carefully picked to fit your Molecule type. In the last stage, the Hamiltonian and ansatz are sent to a classical optimizer. During this tutorial we will demonstrate the steps and user options in Classiq's VQE algorithm. Furthermore, the demonstration will present the optimization strength Classiq's VQE algorithm holds, and it's state of the art results in term of efficient quantum circuit - with ultimate combination of low depth and high accuracy, while minimizing the number of CX gates." + ] + }, + { + "cell_type": "markdown", + "source": [ + "` **RESULTS**\n", + "\n", + "Comparison of different molecules in terms of width and depth. The more atoms in a molecule, the more qubits/circuit depth are necessary. System overload when more than 3 atoms.\n", + "\n", + "## **h2**\n", + "\n", + "hw-eff ansatz: width 4/depth34\n", + "\n", + "ucc ansatz: ,\n", + "width 1/depth 6, width 4, depth 3\n", + "\n", + "total en -1.1342995783232035,\n", + "exact result: -1.8572750302023786,\n", + "vqe result: -1.854268572772183\n" + ], + "metadata": { + "id": "TWGNYMkUKh6C" + }, + "id": "TWGNYMkUKh6C" + }, + { + "cell_type": "markdown", + "source": [ + "## **h2o**\n", + "\n", + "hw-eff. ansatz: width 12/depth 375,\n", + "(conn map 0-1..10-11, reps 11)\n", + "\n", + "ucc ansatz: width 8/depth 1218, width 12/depth 1048\n", + "\n", + "total energy -71.7605079203085,\n", + "exact result: -23.544497240443615,\n", + "vqe result: -80.95442108093192" + ], + "metadata": { + "id": "XcbH8UHbKrIU" + }, + "id": "XcbH8UHbKrIU" + }, + { + "cell_type": "markdown", + "source": [ + "##**co2**\n", + "\n", + "hw-eff ansatz: width 24/depth 175\n", + "\n", + "ucc ansatz: width 20/depth 19767, width 24/depth 16968\n", + "\n", + "Error number 90001 occurred. The resources needed to execute this request are insufficient.\n", + " This may be due to computational limitations, or high load on Classiq's servers." + ], + "metadata": { + "id": "Br0-chtAKv6D" + }, + "id": "Br0-chtAKv6D" + }, + { + "cell_type": "markdown", + "id": "54d09062-1b3b-4e4b-8351-5e05a633e269", + "metadata": { + "id": "54d09062-1b3b-4e4b-8351-5e05a633e269" + }, + "source": [ + "## 0. Pre-requirments\n", + "\n", + "The model is using several Classiq's libraries." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "C3SemPUxJw4V", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "C3SemPUxJw4V", + "outputId": "b735d9f4-3d88-4b64-f115-4a9725e63811" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting classiq\n", + " Downloading classiq-0.42.1-py3-none-any.whl (401 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m401.5/401.5 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", + " Downloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", + "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", + " Downloading Pyomo-6.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m53.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting black<25.0,>=24.0 (from classiq)\n", + " Downloading black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m61.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting httpx<1,>=0.23.0 (from classiq)\n", + " Downloading httpx-0.27.0-py3-none-any.whl (75 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: keyring<24.0.0,>=23.5.0 in /usr/lib/python3/dist-packages (from classiq) (23.5.0)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (3.7.1)\n", + "Collecting networkx<3.0.0,>=2.5.1 (from classiq)\n", + " Downloading networkx-2.8.8-py3-none-any.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m72.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numexpr<3.0.0,>=2.7.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.10.0)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.25.2)\n", + "Collecting packaging<23.0,>=22.0 (from classiq)\n", + " Downloading packaging-22.0-py3-none-any.whl (42 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pandas<3.0.0,>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.0.3)\n", + "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (5.15.0)\n", + "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", + " Downloading pydantic-1.10.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m61.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.11.4)\n", + "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", + " Downloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m64.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tabulate<1,>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from classiq) (0.9.0)\n", + "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (8.1.7)\n", + "Collecting mypy-extensions>=0.4.3 (from black<25.0,>=24.0->classiq)\n", + " Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", + "Collecting pathspec>=0.9.0 (from black<25.0,>=24.0->classiq)\n", + " Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", + "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.2.2)\n", + "Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (2.0.1)\n", + "Requirement already satisfied: typing-extensions>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.12.1)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7.1)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (2024.6.2)\n", + "Collecting httpcore==1.* (from httpx<1,>=0.23.0->classiq)\n", + " Downloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m8.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n", + "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->classiq)\n", + " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.53.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2024.1)\n", + "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.3.0)\n", + "Collecting ply (from Pyomo<6.6,>=6.5->classiq)\n", + " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx<1,>=0.23.0->classiq) (1.2.1)\n", + "Installing collected packages: ply, sympy, Pyomo, pydantic, pathspec, packaging, networkx, mypy-extensions, h11, ConfigArgParse, httpcore, black, httpx, classiq\n", + " Attempting uninstall: sympy\n", + " Found existing installation: sympy 1.12.1\n", + " Uninstalling sympy-1.12.1:\n", + " Successfully uninstalled sympy-1.12.1\n", + " Attempting uninstall: pydantic\n", + " Found existing installation: pydantic 2.7.3\n", + " Uninstalling pydantic-2.7.3:\n", + " Successfully uninstalled pydantic-2.7.3\n", + " Attempting uninstall: packaging\n", + " Found existing installation: packaging 24.0\n", + " Uninstalling packaging-24.0:\n", + " Successfully uninstalled packaging-24.0\n", + " Attempting uninstall: networkx\n", + " Found existing installation: networkx 3.3\n", + " Uninstalling networkx-3.3:\n", + " Successfully uninstalled networkx-3.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torch 2.3.0+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", + "torch 2.3.0+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.42.1 h11-0.14.0 httpcore-1.0.5 httpx-0.27.0 mypy-extensions-1.0.0 networkx-2.8.8 packaging-22.0 pathspec-0.12.1 ply-3.11 pydantic-1.10.15 sympy-1.10.1\n" + ] + } + ], + "source": [ + "!pip install classiq" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "zjvfmLnXJ1Kk", + "metadata": { + "id": "zjvfmLnXJ1Kk" + }, + "outputs": [], + "source": [ + "from classiq import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "LHrqCSj2J5PC", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LHrqCSj2J5PC", + "outputId": "75c65d46-2d6a-4796-92ee-3dc517c54b93" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your user code: SGSG-NSNW\n", + "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=SGSG-NSNW\n" + ] + } + ], + "source": [ + "import classiq\n", + "classiq.authenticate()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6bbe65f-1e6a-475c-a43f-cb4cc04bbdfa", + "metadata": { + "id": "c6bbe65f-1e6a-475c-a43f-cb4cc04bbdfa" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from classiq import QuantumProgram, construct_chemistry_model, execute, show, synthesize\n", + "from classiq.applications.chemistry import (\n", + " ChemistryExecutionParameters,\n", + " HEAParameters,\n", + " Molecule,\n", + " MoleculeProblem,\n", + " UCCParameters,\n", + ")\n", + "from classiq.execution import (\n", + " ClassiqBackendPreferences,\n", + " ClassiqSimulatorBackendNames,\n", + " ExecutionPreferences,\n", + " OptimizerType,\n", + ")\n", + "from classiq.synthesis import set_execution_preferences" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "HnN_rrrOK-AI", + "metadata": { + "id": "HnN_rrrOK-AI" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "faa3c10f", + "metadata": { + "id": "faa3c10f" + }, + "source": [ + "## 1. Generate Qubit Hamiltonian\n", + "\n", + "The first step is to define the molecule we wish to simulate. We hereby declare the class Molecule and insert a list of atoms and their spacial positions. The algorithm will automatically regard relevant attributes such as the atom's mass, charge and spin.\n", + "\n", + "As mentioned above, during this tutorial, we demonstrate how to define and find the ground state and energies for 3 molecules:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "VN6XdfYfLApS", + "metadata": { + "id": "VN6XdfYfLApS" + }, + "outputs": [], + "source": [ + "#hydrogen\n", + "molecule_H2 = Molecule(atoms=[(\"H\", (0.0, 0.0, 0)), (\"H\", (0.0, 0.0, 0.735))])\n", + "\n", + "#oxygen\n", + "molecule_O2 = Molecule(atoms=[(\"O\", (0.0, 0.0, 0)), (\"O\", (0.0, 0.0, 1.16))])\n", + "\n", + "#lithium hydride\n", + "molecule_LiH = Molecule(atoms=[(\"H\", (0.0, 0.0, 0.0)), (\"Li\", (0.0, 0.0, 1.596))])\n", + "\n", + "#water\n", + "molecule_H2O = Molecule(\n", + " atoms=[(\"O\", (0.0, 0.0, 0.0)), (\"H\", (0, 0.586, 0.757)), (\"H\", (0, 0.586, -0.757))]\n", + ")\n", + "#beryllium hydride\n", + "molecule_BeH2 = Molecule(\n", + " atoms=[(\"Be\", (0.0, 0.0, 0.0)), (\"H\", (0, 0, 1.334)), (\"H\", (0, 0, -1.334))]\n", + ")\n", + "#carbon dioxide\n", + "molecule_CO2 = Molecule(atoms=[(\"C\", (0.0, 0.0, 0.0)),\n", + " (\"O\", (0, 0, 1.1693)), (\"O\", (0, 0, -1.1693))])\n", + "\n", + "#ethyne, acetylene\n", + "molecule_C2H2 = Molecule(atoms=[(\"C\", (0, 0, -0.5977)), (\"C\", (0, 0, 0.5977)),\n", + " (\"H\", (0, 0, -1.6692)), (\"H\", (0, 0, 1.6692))])\n", + "\n", + "#chloroform\n", + "molecule_CH3Cl = Molecule(atoms=[(\"C\", (0, 0, -1.1401)), (\"Cl\", (0, 0, 0.6645)),\n", + " (\"H\", (0, 1.0343, -1.4855)),\n", + " (\"H\", (0.8957, -0.5171, -1.4855)), (\"H\", (-0.8957, -0.5171, -1.4855))])\n", + "\n", + "#ethylene\n", + "molecule_C2H4 = Molecule(atoms=[(\"C\", (0, 0, 0.6673)), (\"C\", (0, 0, -0.6673)),\n", + " (\"H\", (0, 0.9239, 1.2411)), (\"H\", (0, -0.9239, 1.2411)),\n", + " (\"H\", (0, -0.9239, -1.2411)), (\"H\", (0, 0.9239, -1.2411))])\n" + ] + }, + { + "cell_type": "markdown", + "id": "ab162f48", + "metadata": { + "id": "ab162f48" + }, + "source": [ + "Similarly, the user is able to construct any valid essambly of atoms. The distances are recived in Å ($10^{-10} m$). We will continue this demonstration with a specific molecule. The user can change the `molecule` below to study other cases." + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "id": "2e77678f", + "metadata": { + "id": "2e77678f" + }, + "outputs": [], + "source": [ + "molecule = molecule_CO2" + ] + }, + { + "cell_type": "markdown", + "id": "c4a541a5", + "metadata": { + "id": "c4a541a5" + }, + "source": [ + "Next, we define the parameters of the Hamiltonian generation program. The user has a choice over the following options:\n", + "- mapping (str): the mapping between the fermionic Hamiltonian and an qubits Hamiltonian. Supported types:\n", + " - \"jordan_wigner\"\n", + " - \"parity\"\n", + " - \"bravyi_kitaev\"\n", + " - \"fast_bravyi_kitaev\"\n", + "- freeze_core (bool): remove the \"core\" orbitals of the atoms defining the molecule.\n", + "- z2_symmetries (bool): whether to perform z2 symmetries reduction. If symmetries in the molecules exist, this option will decrease the number of qubits used and will efficient the Hamiltonian and thus the calculations.\n", + "\n", + "Finally, the Hamiltonian is generated from `MoleculeProblem`." + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "2e0426d5", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "collapsed": true, + "id": "2e0426d5", + "outputId": "205584a3-ca38-4d54-ca52-dbc3f88b8bbf" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Your Hamiltonian is\n", + "-55.215 * IIIIIIIIIIIIIIIIIIII\n", + "+1.411 * ZIZZIIZZZIZIZIIZZIIZ\n", + "-0.046 * IIZZZZIZZIIZZIIIIZIX\n", + "+0.046 * ZIIIZZZIIIZZIIIZZZIX\n", + "-0.120 * IIIIIIIIIIIZXIIIIIII\n", + "+0.120 * ZIZZIIZZZIZZXIIZZIIZ\n", + "+1.413 * ZIIIZZZIIIZZIIIZZZII\n", + "-0.012 * ZIZZIIZZZIZZIZZIIXIZ\n", + "+0.012 * IIZZZZIZZIIIIZZZZXIZ\n", + "+0.109 * ZIZZIIZZZIZXZIIZZIIZ\n", + "-0.109 * IIZZZZIZZIIXZIIIIZIZ\n", + "+1.083 * IIIIIIIIIIIIIIIIIIIZ\n", + "+0.061 * IIZZZZIZZIIIYIIIIZIY\n", + "+0.061 * IIZZZZIZZIIIXIIIIZIX\n", + "+1.009 * IIZZZZIZZIIIIZZZZIZI\n", + "-0.106 * IIZZZZIZZIIIIZXIIZII\n", + "+0.106 * IIIIIIIIIIIIIIXZZZZI\n", + "-0.005 * IIZZZZIZZIIIIXIIIZII\n", + "+0.005 * IIIIIIIIIIIIIXZZZZZI\n", + "+1.009 * IIIIIIIIIIIIIIIIIIZI\n", + "-0.005 * IIIIIIIIIIIIIIYZZZYI\n", + "-0.005 * IIIIIIIIIIIIIIXZZZXI\n", + "+0.106 * IIIIIIIIIIIIIYZZZZYI\n", + "+0.106 * IIIIIIIIIIIIIXZZZZXI\n", + "+1.071 * IIIIIIIIIIIIIIIIIZII\n", + "-0.071 * IIIIIIIIIIIYZZZZZYII\n", + "-0.071 * IIIIIIIIIIIXZZZZZXII\n", + "+1.021 * IIIIIIIIIIIIIIIIZIII\n", + "+1.021 * IIIIIIIIIIIIIIIZIIII\n", + "+0.738 * IIIIIIIIIIIIIIZIIIII\n", + "+0.738 * IIIIIIIIIIIIIZIIIIII\n", + "+0.721 * IIIIIIIIIIIIZIIIIIII\n", + "+0.366 * IIIIIIIIIIIZIIIIIIII\n", + "+1.411 * ZZZZZZZZZZZIIIIIIIII\n", + "-0.046 * ZZZZZZZZZXIIIIIIIIII\n", + "+0.046 * IIIIIIIIIXZIIIIIIIII\n", + "-0.120 * ZXIIIIIIIIIIIIIIIIII\n", + "+0.120 * IXZZZZZZZZZIIIIIIIII\n", + "+1.413 * IIIIIIIIIIZIIIIIIIII\n", + "+0.012 * IIIIIIYZZZYIIIIIIIII\n", + "+0.012 * IIIIIIXZZZXIIIIIIIII\n", + "-0.109 * YZZZZZZZZZYIIIIIIIII\n", + "-0.109 * XZZZZZZZZZXIIIIIIIII\n", + "+1.083 * IIIIIIIIIZIIIIIIIIII\n", + "+0.061 * IYZZZZZZZYIIIIIIIIII\n", + "+0.061 * IXZZZZZZZXIIIIIIIIII\n", + "+1.009 * IIIIIIIIZIIIIIIIIIII\n", + "+0.106 * IIIYZZZZYIIIIIIIIIII\n", + "+0.106 * IIIXZZZZXIIIIIIIIIII\n", + "+0.005 * IIYZZZZZYIIIIIIIIIII\n", + "+0.005 * IIXZZZZZXIIIIIIIIIII\n", + "+1.009 * IIIIIIIZIIIIIIIIIIII\n", + "-0.005 * IIIYZZZYIIIIIIIIIIII\n", + "-0.005 * IIIXZZZXIIIIIIIIIIII\n", + "+0.106 * IIYZZZZYIIIIIIIIIIII\n", + "+0.106 * IIXZZZZXIIIIIIIIIIII\n", + "+1.071 * IIIIIIZIIIIIIIIIIIII\n", + "-0.071 * YZZZZZYIIIIIIIIIIIII\n", + "-0.071 * XZZZZZXIIIIIIIIIIIII\n", + "+1.021 * IIIIIZIIIIIIIIIIIIII\n", + "+1.021 * IIIIZIIIIIIIIIIIIIII\n", + "+0.738 * IIIZIIIIIIIIIIIIIIII\n", + "+0.738 * IIZIIIIIIIIIIIIIIIII\n", + "+0.721 * IZIIIIIIIIIIIIIIIIII\n", + "+0.366 * ZIIIIIIIIIIIIIIIIIII\n", + "+0.077 * IIZZZZIZZIIZZIIIIZIZ\n", + "+0.011 * IIIIIIIIIIIZZZZZZXII\n", + "-0.011 * ZIIIZZZIIIZIZZZIIXII\n", + "-0.008 * IIIIIIIIIIIXIIIIIIII\n", + "+0.008 * ZIIIZZZIIIZXIIIZZZII\n", + "+0.097 * ZIZZIIZZZIZIZIIZZIII\n", + "+0.001 * ZIIIZZZIIIZIXIIZZZIX\n", + "+0.001 * ZIIIZZZIIIZIYIIZZZIY\n", + "+0.105 * ZIIIZZZIIIZIZZZIIIZZ\n", + "+0.002 * ZIIIZZZIIIZIZZXZZZIZ\n", + "-0.002 * ZIZZIIZZZIZIZIXIIZZZ\n", + "+0.000 * ZIIIZZZIIIZIZXIZZZIZ\n", + "-0.000 * ZIZZIIZZZIZIZXZIIZZZ\n", + "+0.105 * ZIZZIIZZZIZIZIIZZIZZ\n", + "+0.000 * ZIZZIIZZZIZIZIYIIZYZ\n", + "+0.000 * ZIZZIIZZZIZIZIXIIZXZ\n", + "-0.002 * ZIZZIIZZZIZIZYZIIZYZ\n", + "-0.002 * ZIZZIIZZZIZIZXZIIZXZ\n", + "+0.105 * ZIZZIIZZZIZIZIIZZZIZ\n", + "+0.006 * ZIZZIIZZZIZYIZZIIYIZ\n", + "+0.006 * ZIZZIIZZZIZXIZZIIXIZ\n", + "+0.107 * ZIZZIIZZZIZIZIIZIIIZ\n", + "+0.107 * ZIZZIIZZZIZIZIIIZIIZ\n", + "+0.116 * ZIZZIIZZZIZIZIZZZIIZ\n", + "+0.116 * ZIZZIIZZZIZIZZIZZIIZ\n", + "+0.116 * ZIZZIIZZZIZIIIIZZIIZ\n", + "+0.130 * ZIZZIIZZZIZZZIIZZIIZ\n", + "+0.016 * ZIZZIIZZZIZIZIIZZIIX\n", + "-0.016 * IIIIIIIIIIIIIIIIIIIX\n", + "+0.008 * ZIIIZZZIIIZIXIIZZZII\n", + "-0.008 * IIZZZZIZZIIIXIIIIZIZ\n", + "+0.005 * ZIIIZZZIIIZIZZZIIYIY\n", + "+0.037 * IIIIIIIIIIIZZZZZZXIX\n", + "+0.032 * IIIIIIIIIIIZZZZZZYIY\n", + "+0.032 * IIZZZZIZZIIIIZZZZYIY\n", + "+0.037 * IIZZZZIZZIIIIZZZZXIX\n", + "+0.005 * ZIZZIIZZZIZZIZZIIYIY\n", + "-0.002 * ZIIIZZZIIIZYIIIZZZIY\n", + "+0.005 * IIIIIIIIIIIXIIIIIIIX\n", + "+0.007 * IIIIIIIIIIIYIIIIIIIY\n", + "+0.007 * IIZZZZIZZIIYZIIIIZIY\n", + "+0.005 * IIZZZZIZZIIXZIIIIZIX\n", + "-0.002 * ZIZZIIZZZIZYZIIZZIIY\n", + "-0.000 * ZIZZIIZZZIZIZIIZXZZZ\n", + "+0.001 * IIIIIIIIIIIZZZZZXIIZ\n", + "-0.001 * IIZZZZIZZIIZZIIIXIZZ\n", + "-0.001 * IIZZZZIZZIIIIZZZXZII\n", + "+0.001 * IIIIIIIIIIIIIIIIXZZI\n", + "-0.000 * ZIZZIIZZZIZZIZZIXIII\n", + "-0.003 * ZIZZIIZZZIZIZIIXIZZZ\n", + "+0.034 * IIIIIIIIIIIZZZZXIIIZ\n", + "-0.031 * IIZZZZIZZIIZZIIXZIZZ\n", + "-0.031 * IIZZZZIZZIIIIZZXIZII\n", + "+0.034 * IIIIIIIIIIIIIIIXZZZI\n", + "-0.003 * ZIZZIIZZZIZZIZZXZIII\n", + "-0.003 * ZIZZIIZZZIZIZIIZXZXZ\n", + "-0.034 * IIZZZZIZZIIZZIIIYIYZ\n", + "-0.031 * IIZZZZIZZIIZZIIIXIXZ\n", + "+0.031 * IIIIIIIIIIIIIIIIYZYI\n", + "+0.034 * IIIIIIIIIIIIIIIIXZXI\n", + "+0.003 * ZIIIZZZIIIZZIIIZYIYI\n", + "+0.000 * ZIZZIIZZZIZIZIIXIZXZ\n", + "+0.001 * IIZZZZIZZIIZZIIYZIYZ\n", + "+0.001 * IIZZZZIZZIIZZIIXZIXZ\n", + "-0.001 * IIIIIIIIIIIIIIIYZZYI\n", + "-0.001 * IIIIIIIIIIIIIIIXZZXI\n", + "-0.000 * ZIIIZZZIIIZZIIIYIIYI\n", + "+0.003 * ZIZZIIZZZIZIXZZIIXIZ\n", + "-0.021 * IIZZZZIZZIIZXZZZZXIZ\n", + "-0.017 * IIZZZZIZZIIZYZZZZYIZ\n", + "-0.017 * IIIIIIIIIIIIYZZZZYII\n", + "-0.021 * IIIIIIIIIIIIXZZZZXII\n", + "+0.003 * ZIIIZZZIIIZZXZZIIXII\n", + "+0.000 * ZIZZIIZZZIZIZIYIYIIZ\n", + "-0.001 * IIZZZZIZZIIZZIYZYZIZ\n", + "-0.001 * IIZZZZIZZIIZZIXZXZIZ\n", + "+0.001 * IIIIIIIIIIIIIIYZYIII\n", + "+0.001 * IIIIIIIIIIIIIIXZXIII\n", + "-0.000 * ZIIIZZZIIIZZIIXIXZII\n", + "-0.002 * ZIZZIIZZZIZIZYZIYIIZ\n", + "+0.031 * IIZZZZIZZIIZZYZZYZIZ\n", + "+0.029 * IIZZZZIZZIIZZXZZXZIZ\n", + "-0.029 * IIIIIIIIIIIIIYZZYIII\n", + "-0.031 * IIIIIIIIIIIIIXZZXIII\n", + "+0.002 * ZIIIZZZIIIZZIXZIXZII\n", + "-0.002 * ZIZZIIZZZIZIZIYYZIIZ\n", + "+0.031 * IIZZZZIZZIIZZIYYIZIZ\n", + "+0.029 * IIZZZZIZZIIZZIXXIZIZ\n", + "-0.029 * IIIIIIIIIIIIIIYYIIII\n", + "-0.031 * IIIIIIIIIIIIIIXXIIII\n", + "+0.002 * ZIIIZZZIIIZZIIXXZZII\n", + "-0.000 * ZIZZIIZZZIZIZYZYZIIZ\n", + "+0.001 * IIZZZZIZZIIZZYZYIZIZ\n", + "+0.001 * IIZZZZIZZIIZZXZXIZIZ\n", + "-0.001 * IIIIIIIIIIIIIYZYIIII\n", + "-0.001 * IIIIIIIIIIIIIXZXIIII\n", + "+0.000 * ZIIIZZZIIIZZIXZXZZII\n", + "-0.002 * ZIZZIIZZZIZYYIIZZIIZ\n", + "-0.032 * IIZZZZIZZIIXXIIIIZIZ\n", + "-0.030 * IIZZZZIZZIIYYIIIIZIZ\n", + "-0.030 * IIIIIIIIIIIYYIIIIIII\n", + "-0.032 * IIIIIIIIIIIXXIIIIIII\n", + "-0.002 * ZIIIZZZIIIZYYIIZZZII\n", + "-0.017 * IIIIIIIIIIIZXIIIIIIZ\n", + "+0.017 * ZIZZIIZZZIZZXIIZZIII\n", + "+0.007 * IIIIIIIIIIIZZZZZZZZX\n", + "-0.007 * ZIZZIIZZZIZZIZZIIZZX\n", + "+0.006 * IIZZZZIZZIIZZIYZZIZY\n", + "+0.010 * IIIIIIIIIIIZZZXIIIIX\n", + "-0.004 * IIZZZZIZZIIZZIXZZIZX\n", + "-0.004 * ZIZZIIZZZIZZIZXZZIIX\n", + "+0.010 * ZIIIZZZIIIZZIIXIIIZX\n", + "+0.006 * ZIZZIIZZZIZZIZYZZIIY\n", + "+0.000 * IIZZZZIZZIIZZYZZZIZY\n", + "+0.001 * IIIIIIIIIIIZZXIIIIIX\n", + "-0.000 * IIZZZZIZZIIZZXZZZIZX\n", + "-0.000 * ZIZZIIZZZIZZIXIZZIIX\n", + "+0.001 * ZIIIZZZIIIZZIXZIIIZX\n", + "+0.000 * ZIZZIIZZZIZZIYIZZIIY\n", + "+0.007 * IIZZZZIZZIIZZIIIIZZX\n", + "-0.007 * ZIIIZZZIIIZZIIIZZZZX\n", + "-0.000 * IIZZZZIZZIIZZIYZZIXY\n", + "+0.001 * IIZZZZIZZIIZZIYZZIYX\n", + "+0.000 * IIZZZZIZZIIZZIXZZIXX\n", + "-0.000 * ZIIIZZZIIIZZIIYIIIYX\n", + "-0.001 * ZIIIZZZIIIZZIIXIIIXX\n", + "-0.000 * ZIIIZZZIIIZZIIXIIIYY\n", + "+0.006 * IIZZZZIZZIIZZYZZZIXY\n", + "-0.010 * IIZZZZIZZIIZZYZZZIYX\n", + "-0.004 * IIZZZZIZZIIZZXZZZIXX\n", + "+0.004 * ZIIIZZZIIIZZIYZIIIYX\n", + "+0.010 * ZIIIZZZIIIZZIXZIIIXX\n", + "+0.006 * ZIIIZZZIIIZZIXZIIIYY\n", + "+0.004 * IIZZZZIZZIIZZIIIIIIX\n", + "-0.004 * ZIIIZZZIIIZZIIIZZIIX\n", + "-0.016 * IIZZZZIZZIIXIZZZZYIY\n", + "-0.021 * IIZZZZIZZIIXIZZZZXIX\n", + "-0.006 * IIZZZZIZZIIYIZZZZYIX\n", + "+0.006 * ZIIIZZZIIIZXZZZIIXIX\n", + "+0.021 * ZIIIZZZIIIZYZZZIIYIX\n", + "-0.016 * ZIIIZZZIIIZYZZZIIXIY\n", + "+0.001 * IIZZZZIZZIIZZIIIZZIX\n", + "-0.001 * ZIIIZZZIIIZZIIIZIZIX\n", + "+0.001 * IIZZZZIZZIIZZIIZIZIX\n", + "-0.001 * ZIIIZZZIIIZZIIIIZZIX\n", + "+0.011 * IIZZZZIZZIIZZIZIIZIX\n", + "-0.011 * ZIIIZZZIIIZZIIZZZZIX\n", + "+0.011 * IIZZZZIZZIIZZZIIIZIX\n", + "-0.011 * ZIIIZZZIIIZZIZIZZZIX\n", + "+0.005 * IIZZZZIZZIIZIIIIIZIX\n", + "-0.005 * ZIIIZZZIIIZZZIIZZZIX\n", + "+0.014 * IIZZZZIZZIIIZIIIIZIX\n", + "-0.014 * ZIIIZZZIIIZIIIIZZZIX\n", + "-0.009 * IIZZZZIZZIIZXZZZZIZI\n", + "+0.009 * ZIIIZZZIIIZZXZZIIIZZ\n", + "-0.000 * IIZZZZIZZIIZZIIIYYII\n", + "-0.000 * IIIIIIIIIIIZZZZZXXZI\n", + "+0.000 * IIIIIIIIIIIZZZZZYYZI\n", + "-0.000 * ZIIIZZZIIIZZIIIZXXIZ\n", + "+0.000 * ZIIIZZZIIIZZIIIZYYIZ\n", + "+0.000 * ZIZZIIZZZIZZIZZIXXZZ\n", + "-0.001 * IIZZZZIZZIIZZIIYZYII\n", + "-0.001 * IIIIIIIIIIIZZZZXIXZI\n", + "+0.000 * IIIIIIIIIIIZZZZYIYZI\n", + "-0.000 * ZIIIZZZIIIZZIIIXIXIZ\n", + "+0.001 * ZIIIZZZIIIZZIIIYIYIZ\n", + "+0.001 * ZIZZIIZZZIZZIZZXZXZZ\n", + "+0.000 * IIZZZZIZZIIXIZZZXZII\n", + "-0.000 * IIIIIIIIIIIXIIIIXZZI\n", + "+0.000 * IIIIIIIIIIIYIIIIYZZI\n", + "-0.000 * ZIIIZZZIIIZXZZZIXZIZ\n", + "+0.000 * ZIIIZZZIIIZYZZZIYZIZ\n", + "-0.000 * ZIZZIIZZZIZYZIIZYZZZ\n", + "+0.010 * IIZZZZIZZIIXIZZXIZII\n", + "-0.009 * IIIIIIIIIIIXIIIXZZZI\n", + "+0.002 * IIIIIIIIIIIYIIIYZZZI\n", + "-0.002 * ZIIIZZZIIIZXZZZXZZIZ\n", + "+0.009 * ZIIIZZZIIIZYZZZYZZIZ\n", + "-0.010 * ZIZZIIZZZIZYZIIYIZZZ\n", + "+0.007 * IIZZZZIZZIIZXZXIIZII\n", + "-0.001 * IIIIIIIIIIIZXIXZZZZI\n", + "+0.006 * IIIIIIIIIIIZYIYZZZZI\n", + "+0.006 * ZIIIZZZIIIZZYZYZZZIZ\n", + "-0.001 * ZIIIZZZIIIZZXZXZZZIZ\n", + "+0.007 * ZIZZIIZZZIZZXIXIIZZZ\n", + "+0.000 * IIZZZZIZZIIZXXIIIZII\n", + "-0.000 * IIIIIIIIIIIZXXZZZZZI\n", + "+0.000 * IIIIIIIIIIIZYYZZZZZI\n", + "+0.000 * ZIIIZZZIIIZZYYIZZZIZ\n", + "-0.000 * ZIIIZZZIIIZZXXIZZZIZ\n", + "+0.000 * ZIZZIIZZZIZZXXZIIZZZ\n", + "-0.009 * IIIIIIIIIIIZXIIIIIZI\n", + "+0.009 * ZIZZIIZZZIZZXIIZZIZZ\n", + "-0.001 * IIIIIIIIIIIZZZZZXYYI\n", + "-0.001 * IIIIIIIIIIIZZZZZXXXI\n", + "+0.000 * IIIIIIIIIIIZZZZZYYXI\n", + "+0.000 * ZIZZIIZZZIZZIZZIYXYZ\n", + "+0.001 * ZIZZIIZZZIZZIZZIXYYZ\n", + "+0.001 * ZIZZIIZZZIZZIZZIXXXZ\n", + "+0.000 * IIIIIIIIIIIZZZZXIYYI\n", + "+0.000 * IIIIIIIIIIIZZZZXIXXI\n", + "-0.000 * IIIIIIIIIIIZZZZYIYXI\n", + "-0.000 * ZIZZIIZZZIZZIZZYZXYZ\n", + "-0.000 * ZIZZIIZZZIZZIZZXZYYZ\n", + "-0.000 * ZIZZIIZZZIZZIZZXZXXZ\n", + "-0.010 * IIIIIIIIIIIXIIIIYZYI\n", + "-0.009 * IIIIIIIIIIIXIIIIXZXI\n", + "+0.002 * IIIIIIIIIIIYIIIIYZXI\n", + "+0.002 * ZIZZIIZZZIZXZIIZYZYZ\n", + "+0.009 * ZIZZIIZZZIZYZIIZXZYZ\n", + "-0.010 * ZIZZIIZZZIZYZIIZYZXZ\n", + "+0.000 * IIIIIIIIIIIXIIIYZZYI\n", + "+0.000 * IIIIIIIIIIIXIIIXZZXI\n", + "-0.000 * IIIIIIIIIIIYIIIYZZXI\n", + "-0.000 * ZIZZIIZZZIZXZIIYIZYZ\n", + "-0.000 * ZIZZIIZZZIZYZIIXIZYZ\n", + "+0.000 * ZIZZIIZZZIZYZIIYIZXZ\n", + "+0.000 * IIIIIIIIIIIZXIYZZZYI\n", + "+0.000 * IIIIIIIIIIIZXIXZZZXI\n", + "-0.000 * IIIIIIIIIIIZYIYZZZXI\n", + "-0.000 * ZIZZIIZZZIZZYIXIIZYZ\n", + "-0.000 * ZIZZIIZZZIZZXIYIIZYZ\n", + "-0.000 * ZIZZIIZZZIZZXIXIIZXZ\n", + "-0.007 * IIIIIIIIIIIZXYZZZZYI\n", + "-0.001 * IIIIIIIIIIIZXXZZZZXI\n", + "+0.006 * IIIIIIIIIIIZYYZZZZXI\n", + "+0.006 * ZIZZIIZZZIZZYXZIIZYZ\n", + "+0.001 * ZIZZIIZZZIZZXYZIIZYZ\n", + "+0.007 * ZIZZIIZZZIZZXXZIIZXZ\n", + "-0.013 * IIIIIIIIIIIZXIIIIZII\n", + "+0.013 * ZIZZIIZZZIZZXIIZZZIZ\n", + "-0.000 * IIIIIIIIIIIZZZXIYYII\n", + "-0.000 * IIIIIIIIIIIZZZXIXXII\n", + "-0.000 * IIIIIIIIIIIZZZYIYXII\n", + "-0.000 * ZIZZIIZZZIZZIZXZYYIZ\n", + "+0.000 * ZIZZIIZZZIZZIZYZXYIZ\n", + "-0.000 * ZIZZIIZZZIZZIZYZYXIZ\n", + "+0.002 * IIIIIIIIIIIZZXIIYYII\n", + "+0.002 * IIIIIIIIIIIZZXIIXXII\n", + "+0.000 * IIIIIIIIIIIZZYIIYXII\n", + "+0.000 * ZIZZIIZZZIZZIXIZYYIZ\n", + "-0.002 * ZIZZIIZZZIZZIYIZXYIZ\n", + "+0.002 * ZIZZIIZZZIZZIYIZYXIZ\n", + "+0.002 * IIIIIIIIIIIZZZXYZYII\n", + "+0.002 * IIIIIIIIIIIZZZXXZXII\n", + "+0.000 * IIIIIIIIIIIZZZYYZXII\n", + "+0.000 * ZIZZIIZZZIZZIZXYIYIZ\n", + "-0.002 * ZIZZIIZZZIZZIZYXIYIZ\n", + "+0.002 * ZIZZIIZZZIZZIZYYIXIZ\n", + "+0.000 * IIIIIIIIIIIZZXIYZYII\n", + "+0.000 * IIIIIIIIIIIZZXIXZXII\n", + "+0.000 * IIIIIIIIIIIZZYIYZXII\n", + "+0.000 * ZIZZIIZZZIZZIXIYIYIZ\n", + "-0.000 * ZIZZIIZZZIZZIYIXIYIZ\n", + "+0.000 * ZIZZIIZZZIZZIYIYIXIZ\n", + "+0.001 * IIIIIIIIIIIXYZZZZYII\n", + "+0.004 * IIIIIIIIIIIXXZZZZXII\n", + "+0.003 * IIIIIIIIIIIYYZZZZXII\n", + "+0.003 * ZIZZIIZZZIZXYZZIIYIZ\n", + "-0.004 * ZIZZIIZZZIZYXZZIIYIZ\n", + "+0.001 * ZIZZIIZZZIZYYZZIIXIZ\n", + "-0.011 * IIIIIIIIIIIZXIIIZIII\n", + "+0.011 * ZIZZIIZZZIZZXIIZIIIZ\n", + "-0.000 * IIIIIIIIIIIXIIYZYIII\n", + "-0.000 * IIIIIIIIIIIXIIXZXIII\n", + "+0.000 * IIIIIIIIIIIYIIYZXIII\n", + "-0.000 * ZIZZIIZZZIZXZIXIXIIZ\n", + "+0.000 * ZIZZIIZZZIZYZIYIXIIZ\n", + "-0.000 * ZIZZIIZZZIZYZIXIYIIZ\n", + "+0.009 * IIIIIIIIIIIXIYZZYIII\n", + "+0.007 * IIIIIIIIIIIXIXZZXIII\n", + "-0.003 * IIIIIIIIIIIYIYZZXIII\n", + "+0.003 * ZIZZIIZZZIZXZXZIXIIZ\n", + "-0.007 * ZIZZIIZZZIZYZYZIXIIZ\n", + "+0.009 * ZIZZIIZZZIZYZXZIYIIZ\n", + "-0.011 * IIIIIIIIIIIZXIIZIIII\n", + "+0.011 * ZIZZIIZZZIZZXIIIZIIZ\n", + "+0.009 * IIIIIIIIIIIXIIYYIIII\n", + "+0.007 * IIIIIIIIIIIXIIXXIIII\n", + "-0.003 * IIIIIIIIIIIYIIYXIIII\n", + "+0.003 * ZIZZIIZZZIZXZIXXZIIZ\n", + "-0.007 * ZIZZIIZZZIZYZIYXZIIZ\n", + "+0.009 * ZIZZIIZZZIZYZIXYZIIZ\n", + "+0.000 * IIIIIIIIIIIXIYZYIIII\n", + "+0.000 * IIIIIIIIIIIXIXZXIIII\n", + "-0.000 * IIIIIIIIIIIYIYZXIIII\n", + "+0.000 * ZIZZIIZZZIZXZXZXZIIZ\n", + "-0.000 * ZIZZIIZZZIZYZYZXZIIZ\n", + "+0.000 * ZIZZIIZZZIZYZXZYZIIZ\n", + "-0.006 * IIIIIIIIIIIZXIZIIIII\n", + "+0.006 * ZIZZIIZZZIZZXIZZZIIZ\n", + "-0.006 * IIIIIIIIIIIZXZIIIIII\n", + "+0.006 * ZIZZIIZZZIZZXZIZZIIZ\n", + "+0.003 * IIIIIIIIIIIIXIIIIIII\n", + "-0.003 * ZIZZIIZZZIZIXIIZZIIZ\n", + "+0.133 * IZIIZZIIIZIIZIIZZIIZ\n", + "+0.011 * ZZIIIIZIIZZZZIIIIZIX\n", + "-0.011 * IZZZIIIZZZIZIIIZZZIX\n", + "-0.013 * ZZZZZZZZZZZZXIIIIIII\n", + "+0.013 * IZIIZZIIIZIZXIIZZIIZ\n", + "+0.058 * ZZIIIIZIIZXZZIIIIZIZ\n", + "-0.058 * IIZZZZIZZIXZZIIIIZIZ\n", + "-0.058 * ZZZZZZZZZZXIIIIIIIII\n", + "+0.058 * IIIIIIIIIIXIIIIIIIII\n", + "+0.005 * ZZZZZZZZZZXZZZZZZXII\n", + "-0.005 * IIIIIIIIIIXZZZZZZXII\n", + "+0.005 * IZIIZZIIIZYZIZZIIYIZ\n", + "-0.005 * ZIZZIIZZZIYZIZZIIYIZ\n", + "+0.014 * ZZZZZZZZZZXXIIIIIIII\n", + "-0.014 * IIIIIIIIIIXXIIIIIIII\n", + "+0.014 * IZIIZZIIIZYYZIIZZIIZ\n", + "-0.014 * ZIZZIIZZZIYYZIIZZIIZ\n", + "+0.011 * IZIIZZIIIXZIZIIZZIIZ\n", + "-0.011 * ZIZZIIZZZXIIZIIZZIIZ\n", + "+0.016 * ZZIIIIZIIXIZZIIIIZIX\n", + "-0.016 * IIZZZZIZZXZZZIIIIZIX\n", + "-0.016 * IZZZIIIZZXZZIIIZZZIX\n", + "+0.016 * ZIIIZZZIIXIZIIIZZZIX\n", + "+0.004 * ZZZZZZZZZXIZXIIIIIII\n", + "-0.004 * IIIIIIIIIXZZXIIIIIII\n", + "-0.004 * IZIIZZIIIXZZXIIZZIIZ\n", + "+0.004 * ZIZZIIZZZXIZXIIZZIIZ\n", + "+0.018 * ZZZZZZZZXIIZZZZZZZZI\n", + "-0.018 * IIIIIIIIXZZZZZZZZZZI\n", + "-0.018 * IZZZIIIZXIZZIIIZZZIZ\n", + "+0.018 * ZIIIZZZIXZIZIIIZZZIZ\n", + "-0.001 * ZZZZZZZZXIIZZZXIIIII\n", + "+0.001 * IIIIIIIIXZZZZZXIIIII\n", + "-0.001 * IZIIZZIIYIZZIZYZZIIZ\n", + "+0.001 * ZIZZIIZZYZIZIZYZZIIZ\n", + "-0.000 * ZZZZZZZZXIIZZXIIIIII\n", + "+0.000 * IIIIIIIIXZZZZXIIIIII\n", + "-0.000 * IZIIZZIIYIZZIYIZZIIZ\n", + "+0.000 * ZIZZIIZZYZIZIYIZZIIZ\n", + "+0.018 * ZZZZZZZXIIIZZZZZZZXI\n", + "-0.018 * IIIIIIIXZZZZZZZZZZXI\n", + "+0.018 * IZIIZZIYZIZZIZZIIZYZ\n", + "-0.018 * ZIZZIIZYIZIZIZZIIZYZ\n", + "+0.000 * ZZZZZZZXIIIZZZXIIIII\n", + "-0.000 * IIIIIIIXZZZZZZXIIIII\n", + "+0.000 * IZIIZZIYZIZZIZYZZIIZ\n", + "-0.000 * ZIZZIIZYIZIZIZYZZIIZ\n", + "-0.001 * ZZZZZZZXIIIZZXIIIIII\n", + "+0.001 * IIIIIIIXZZZZZXIIIIII\n", + "-0.001 * IZIIZZIYZIZZIYIZZIIZ\n", + "+0.001 * ZIZZIIZYIZIZIYIZZIIZ\n", + "+0.005 * ZZIIIIXZZIIZZIIIIZIZ\n", + "-0.005 * IIZZZZXIIZZZZIIIIZIZ\n", + "-0.005 * ZZZZZZXIIIIIIIIIIIII\n", + "+0.005 * IIIIIIXZZZZIIIIIIIII\n", + "+0.012 * ZZZZZZXIIIIZZZZZZXII\n", + "-0.012 * IIIIIIXZZZZZZZZZZXII\n", + "+0.012 * IZIIZZYZZIZZIZZIIYIZ\n", + "-0.012 * ZIZZIIYIIZIZIZZIIYIZ\n", + "-0.001 * ZZZZZZXIIIIXIIIIIIII\n", + "+0.001 * IIIIIIXZZZZXIIIIIIII\n", + "-0.001 * IZIIZZYZZIZYZIIZZIIZ\n", + "+0.001 * ZIZZIIYIIZIYZIIZZIIZ\n", + "+0.015 * ZZZZZXIIIIIZZZZZXIII\n", + "-0.015 * IIIIIXZZZZZZZZZZXIII\n", + "-0.015 * IZIIZXZZZIZZIZZIXIIZ\n", + "+0.015 * ZIZZIXIIIZIZIZZIXIIZ\n", + "+0.015 * ZZZZXIIIIIIZZZZXIIII\n", + "-0.015 * IIIIXZZZZZZZZZZXIIII\n", + "-0.015 * IZIIXIZZZIZZIZZXZIIZ\n", + "+0.015 * ZIZZXZIIIZIZIZZXZIIZ\n", + "-0.001 * ZZZXIIIIIIIZZZZZZZZI\n", + "+0.001 * IIIXZZZZZZZZZZZZZZZI\n", + "+0.001 * IZZXZZZIIIZZIIIZZZIZ\n", + "-0.001 * ZIIXIIIZZZIZIIIZZZIZ\n", + "+0.000 * ZZZXIIIIIIIZZZZZZZXI\n", + "-0.000 * IIIXZZZZZZZZZZZZZZXI\n", + "+0.000 * IZIYIIZZZIZZIZZIIZYZ\n", + "-0.000 * ZIZYZZIIIZIZIZZIIZYZ\n", + "+0.009 * ZZZXIIIIIIIZZZXIIIII\n", + "-0.009 * IIIXZZZZZZZZZZXIIIII\n", + "+0.009 * IZIYIIZZZIZZIZYZZIIZ\n", + "-0.009 * ZIZYZZIIIZIZIZYZZIIZ\n", + "-0.000 * ZZXIIIIIIIIZZZZZZZZI\n", + "+0.000 * IIXZZZZZZZZZZZZZZZZI\n", + "+0.000 * IZXIZZZIIIZZIIIZZZIZ\n", + "-0.000 * ZIXZIIIZZZIZIIIZZZIZ\n", + "-0.001 * ZZXIIIIIIIIZZZZZZZXI\n", + "+0.001 * IIXZZZZZZZZZZZZZZZXI\n", + "-0.001 * IZYZIIZZZIZZIZZIIZYZ\n", + "+0.001 * ZIYIZZIIIZIZIZZIIZYZ\n", + "+0.009 * ZZXIIIIIIIIZZXIIIIII\n", + "-0.009 * IIXZZZZZZZZZZXIIIIII\n", + "+0.009 * IZYZIIZZZIZZIYIZZIIZ\n", + "-0.009 * ZIYIZZIIIZIZIYIZZIIZ\n", + "-0.013 * IXZZIIZZZIZIZIIZZIIZ\n", + "+0.013 * ZXIIZZIIIZIIZIIZZIIZ\n", + "+0.004 * ZXZZZZIZZIIZZIIIIZIX\n", + "-0.004 * IXIIIIZIIZZZZIIIIZIX\n", + "-0.004 * IXIIZZZIIIZZIIIZZZIX\n", + "+0.004 * ZXZZIIIZZZIZIIIZZZIX\n", + "+0.017 * ZXIIIIIIIIIZXIIIIIII\n", + "-0.017 * IXZZZZZZZZZZXIIIIIII\n", + "-0.017 * IXZZIIZZZIZZXIIZZIIZ\n", + "+0.017 * ZXIIZZIIIZIZXIIZZIIZ\n", + "+0.014 * XIZZZZIZZIIZZIIIIZIZ\n", + "-0.014 * XZIIIIZIIZZZZIIIIZIZ\n", + "-0.014 * XIIIIIIIIIIIIIIIIIII\n", + "+0.014 * XZZZZZZZZZZIIIIIIIII\n", + "-0.001 * XIIIIIIIIIIZZZZZZXII\n", + "+0.001 * XZZZZZZZZZZZZZZZZXII\n", + "-0.001 * YIZZIIZZZIZZIZZIIYIZ\n", + "+0.001 * YZIIZZIIIZIZIZZIIYIZ\n", + "+0.013 * XIIIIIIIIIIXIIIIIIII\n", + "-0.013 * XZZZZZZZZZZXIIIIIIII\n", + "+0.013 * YIZZIIZZZIZYZIIZZIIZ\n", + "-0.013 * YZIIZZIIIZIYZIIZZIIZ\n", + "+0.134 * ZIZZIIZZZIIIZIIZZIIZ\n", + "+0.008 * IIZZZZIZZIZZZIIIIZIX\n", + "-0.008 * ZIIIZZZIIIIZIIIZZZIX\n", + "-0.016 * IIIIIIIIIIZZXIIIIIII\n", + "+0.016 * ZIZZIIZZZIIZXIIZZIIZ\n", + "+0.008 * IIZZZZIZZYYZZIIIIZIZ\n", + "+0.008 * IIZZZZIZZXXZZIIIIZIZ\n", + "-0.008 * IIIIIIIIIYYIIIIIIIII\n", + "-0.008 * IIIIIIIIIXXIIIIIIIII\n", + "-0.012 * IIIIIIIIIYYZZZZZZXII\n", + "-0.012 * IIIIIIIIIXXZZZZZZXII\n", + "+0.012 * ZIZZIIZZZYXZIZZIIYIZ\n", + "-0.012 * ZIZZIIZZZXYZIZZIIYIZ\n", + "+0.005 * IIIIIIIIIYYXIIIIIIII\n", + "+0.005 * IIIIIIIIIXXXIIIIIIII\n", + "-0.005 * ZIZZIIZZZYXYZIIZZIIZ\n", + "+0.005 * ZIZZIIZZZXYYZIIZZIIZ\n", + "-0.000 * IIIIIIIIYZYZZZZZXIII\n", + "-0.000 * IIIIIIIIXZXZZZZZXIII\n", + "-0.000 * ZIZZIIZZXZXZIZZIXIIZ\n", + "-0.000 * ZIZZIIZZYZYZIZZIXIIZ\n", + "-0.014 * IIIIIIIIYZYZZZZXIIII\n", + "-0.014 * IIIIIIIIXZXZZZZXIIII\n", + "-0.014 * ZIZZIIZZXZXZIZZXZIIZ\n", + "-0.014 * ZIZZIIZZYZYZIZZXZIIZ\n", + "-0.014 * IIIIIIIYZZYZZZZZXIII\n", + "-0.014 * IIIIIIIXZZXZZZZZXIII\n", + "-0.014 * ZIZZIIZXIZXZIZZIXIIZ\n", + "-0.014 * ZIZZIIZYIZYZIZZIXIIZ\n", + "+0.000 * IIIIIIIYZZYZZZZXIIII\n", + "+0.000 * IIIIIIIXZZXZZZZXIIII\n", + "+0.000 * ZIZZIIZXIZXZIZZXZIIZ\n", + "+0.000 * ZIZZIIZYIZYZIZZXZIIZ\n", + "+0.016 * ZIZZIIXIIZXIZIIZZIIZ\n", + "+0.016 * ZIZZIIYIIZYIZIIZZIIZ\n", + "-0.016 * IIZZZZYIIZYZZIIIIZIX\n", + "-0.016 * IIZZZZXIIZXZZIIIIZIX\n", + "-0.016 * ZIIIZZXZZZXZIIIZZZIX\n", + "-0.016 * ZIIIZZYZZZYZIIIZZZIX\n", + "+0.002 * IIIIIIYZZZYZXIIIIIII\n", + "+0.002 * IIIIIIXZZZXZXIIIIIII\n", + "+0.002 * ZIZZIIXIIZXZXIIZZIIZ\n", + "+0.002 * ZIZZIIYIIZYZXIIZZIIZ\n", + "-0.001 * IIIIIYZZZZYZZZZZZZZI\n", + "-0.001 * IIIIIXZZZZXZZZZZZZZI\n", + "-0.001 * ZIIIZXIZZZXZIIIZZZIZ\n", + "-0.001 * ZIIIZYIZZZYZIIIZZZIZ\n", + "-0.016 * IIIIIYZZZZYZZZZZZZXI\n", + "-0.016 * IIIIIXZZZZXZZZZZZZXI\n", + "+0.016 * ZIZZIYIIIZXZIZZIIZYZ\n", + "-0.016 * ZIZZIXIIIZYZIZZIIZYZ\n", + "-0.000 * IIIIIYZZZZYZZZXIIIII\n", + "-0.000 * IIIIIXZZZZXZZZXIIIII\n", + "+0.000 * ZIZZIYIIIZXZIZYZZIIZ\n", + "-0.000 * ZIZZIXIIIZYZIZYZZIIZ\n", + "+0.006 * IIIIIYZZZZYZZXIIIIII\n", + "+0.006 * IIIIIXZZZZXZZXIIIIII\n", + "-0.006 * ZIZZIYIIIZXZIYIZZIIZ\n", + "+0.006 * ZIZZIXIIIZYZIYIZZIIZ\n", + "-0.016 * IIIIYZZZZZYZZZZZZZZI\n", + "-0.016 * IIIIXZZZZZXZZZZZZZZI\n", + "-0.016 * ZIIIXIIZZZXZIIIZZZIZ\n", + "-0.016 * ZIIIYIIZZZYZIIIZZZIZ\n", + "+0.001 * IIIIYZZZZZYZZZZZZZXI\n", + "+0.001 * IIIIXZZZZZXZZZZZZZXI\n", + "-0.001 * ZIZZYZIIIZXZIZZIIZYZ\n", + "+0.001 * ZIZZXZIIIZYZIZZIIZYZ\n", + "+0.006 * IIIIYZZZZZYZZZXIIIII\n", + "+0.006 * IIIIXZZZZZXZZZXIIIII\n", + "-0.006 * ZIZZYZIIIZXZIZYZZIIZ\n", + "+0.006 * ZIZZXZIIIZYZIZYZZIIZ\n", + "+0.000 * IIIIYZZZZZYZZXIIIIII\n", + "+0.000 * IIIIXZZZZZXZZXIIIIII\n", + "-0.000 * ZIZZYZIIIZXZIYIZZIIZ\n", + "+0.000 * ZIZZXZIIIZYZIYIZZIIZ\n", + "-0.000 * IIIYZZZZZZYZZZZZXIII\n", + "-0.000 * IIIXZZZZZZXZZZZZXIII\n", + "-0.000 * ZIZXZZIIIZXZIZZIXIIZ\n", + "-0.000 * ZIZYZZIIIZYZIZZIXIIZ\n", + "+0.008 * IIIYZZZZZZYZZZZXIIII\n", + "+0.008 * IIIXZZZZZZXZZZZXIIII\n", + "+0.008 * ZIZXZZIIIZXZIZZXZIIZ\n", + "+0.008 * ZIZYZZIIIZYZIZZXZIIZ\n", + "+0.008 * IIYZZZZZZZYZZZZZXIII\n", + "+0.008 * IIXZZZZZZZXZZZZZXIII\n", + "+0.008 * ZIXIZZIIIZXZIZZIXIIZ\n", + "+0.008 * ZIYIZZIIIZYZIZZIXIIZ\n", + "+0.000 * IIYZZZZZZZYZZZZXIIII\n", + "+0.000 * IIXZZZZZZZXZZZZXIIII\n", + "+0.000 * ZIXIZZIIIZXZIZZXZIIZ\n", + "+0.000 * ZIYIZZIIIZYZIZZXZIIZ\n", + "+0.024 * IYIIIIZIIZYZZIIIIZIZ\n", + "+0.024 * IXIIIIZIIZXZZIIIIZIZ\n", + "-0.024 * IYZZZZZZZZYIIIIIIIII\n", + "-0.024 * IXZZZZZZZZXIIIIIIIII\n", + "+0.005 * IYZZZZZZZZYZZZZZZXII\n", + "+0.005 * IXZZZZZZZZXZZZZZZXII\n", + "-0.005 * ZYIIZZIIIZXZIZZIIYIZ\n", + "+0.005 * ZXIIZZIIIZYZIZZIIYIZ\n", + "+0.012 * IYZZZZZZZZYXIIIIIIII\n", + "+0.012 * IXZZZZZZZZXXIIIIIIII\n", + "-0.012 * ZYIIZZIIIZXYZIIZZIIZ\n", + "+0.012 * ZXIIZZIIIZYYZIIZZIIZ\n", + "+0.006 * XZIIZZIIIZXIZIIZZIIZ\n", + "+0.006 * YZIIZZIIIZYIZIIZZIIZ\n", + "+0.007 * YZIIIIZIIZYZZIIIIZIX\n", + "+0.007 * XZIIIIZIIZXZZIIIIZIX\n", + "+0.007 * XZZZIIIZZZXZIIIZZZIX\n", + "+0.007 * YZZZIIIZZZYZIIIZZZIX\n", + "+0.014 * YZZZZZZZZZYZXIIIIIII\n", + "+0.014 * XZZZZZZZZZXZXIIIIIII\n", + "+0.014 * XZIIZZIIIZXZXIIZZIIZ\n", + "+0.014 * YZIIZZIIIZYZXIIZZIIZ\n", + "+0.113 * ZIZZIIZZZZZIZIIZZIIZ\n", + "-0.006 * IIZZZZIZZZIZZIIIIZIX\n", + "+0.006 * ZIIIZZZIIZZZIIIZZZIX\n", + "-0.005 * IIIIIIIIIZIZXIIIIIII\n", + "+0.005 * ZIZZIIZZZZZZXIIZZIIZ\n", + "-0.001 * IIIIIIIIYYIZZZZZZZZI\n", + "-0.001 * IIIIIIIIXXIZZZZZZZZI\n", + "+0.001 * ZIIIZZZIYYZZIIIZZZIZ\n", + "+0.001 * ZIIIZZZIXXZZIIIZZZIZ\n", + "-0.007 * IIIIIIIIYYIZZZXIIIII\n", + "-0.007 * IIIIIIIIXXIZZZXIIIII\n", + "+0.007 * ZIZZIIZZXYZZIZYZZIIZ\n", + "-0.007 * ZIZZIIZZYXZZIZYZZIIZ\n", + "-0.000 * IIIIIIIIYYIZZXIIIIII\n", + "-0.000 * IIIIIIIIXXIZZXIIIIII\n", + "+0.000 * ZIZZIIZZXYZZIYIZZIIZ\n", + "-0.000 * ZIZZIIZZYXZZIYIZZIIZ\n", + "-0.001 * IIIIIIIYZYIZZZZZZZXI\n", + "-0.001 * IIIIIIIXZXIZZZZZZZXI\n", + "+0.001 * ZIZZIIZXIYZZIZZIIZYZ\n", + "-0.001 * ZIZZIIZYIXZZIZZIIZYZ\n", + "+0.000 * IIIIIIIYZYIZZZXIIIII\n", + "+0.000 * IIIIIIIXZXIZZZXIIIII\n", + "-0.000 * ZIZZIIZXIYZZIZYZZIIZ\n", + "+0.000 * ZIZZIIZYIXZZIZYZZIIZ\n", + "-0.007 * IIIIIIIYZYIZZXIIIIII\n", + "-0.007 * IIIIIIIXZXIZZXIIIIII\n", + "+0.007 * ZIZZIIZXIYZZIYIZZIIZ\n", + "-0.007 * ZIZZIIZYIXZZIYIZZIIZ\n", + "-0.048 * IIZZZZYIIYIZZIIIIZIZ\n", + "-0.048 * IIZZZZXIIXIZZIIIIZIZ\n", + "+0.048 * IIIIIIYZZYIIIIIIIIII\n", + "+0.048 * IIIIIIXZZXIIIIIIIIII\n", + "+0.011 * IIIIIIYZZYIZZZZZZXII\n", + "+0.011 * IIIIIIXZZXIZZZZZZXII\n", + "-0.011 * ZIZZIIXIIYZZIZZIIYIZ\n", + "+0.011 * ZIZZIIYIIXZZIZZIIYIZ\n", + "-0.009 * IIIIIIYZZYIXIIIIIIII\n", + "-0.009 * IIIIIIXZZXIXIIIIIIII\n", + "+0.009 * ZIZZIIXIIYZYZIIZZIIZ\n", + "-0.009 * ZIZZIIYIIXZYZIIZZIIZ\n", + "+0.008 * IIIIIYZZZYIZZZZZXIII\n", + "+0.008 * IIIIIXZZZXIZZZZZXIII\n", + "-0.008 * ZIZZIYIIIYZZIZZIXIIZ\n", + "-0.008 * ZIZZIXIIIXZZIZZIXIIZ\n", + "+0.008 * IIIIYZZZZYIZZZZXIIII\n", + "+0.008 * IIIIXZZZZXIZZZZXIIII\n", + "-0.008 * ZIZZYZIIIYZZIZZXZIIZ\n", + "-0.008 * ZIZZXZIIIXZZIZZXZIIZ\n", + "-0.013 * IIIYZZZZZYIZZZZZZZZI\n", + "-0.013 * IIIXZZZZZXIZZZZZZZZI\n", + "+0.013 * ZIIYIIIZZYZZIIIZZZIZ\n", + "+0.013 * ZIIXIIIZZXZZIIIZZZIZ\n", + "+0.001 * IIIYZZZZZYIZZZZZZZXI\n", + "+0.001 * IIIXZZZZZXIZZZZZZZXI\n", + "-0.001 * ZIZXZZIIIYZZIZZIIZYZ\n", + "+0.001 * ZIZYZZIIIXZZIZZIIZYZ\n", + "-0.000 * IIIYZZZZZYIZZZXIIIII\n", + "-0.000 * IIIXZZZZZXIZZZXIIIII\n", + "+0.000 * ZIZXZZIIIYZZIZYZZIIZ\n", + "-0.000 * ZIZYZZIIIXZZIZYZZIIZ\n", + "-0.001 * IIYZZZZZZYIZZZZZZZZI\n", + "-0.001 * IIXZZZZZZXIZZZZZZZZI\n", + "+0.001 * ZIYZIIIZZYZZIIIZZZIZ\n", + "+0.001 * ZIXZIIIZZXZZIIIZZZIZ\n", + "-0.013 * IIYZZZZZZYIZZZZZZZXI\n", + "-0.013 * IIXZZZZZZXIZZZZZZZXI\n", + "+0.013 * ZIXIZZIIIYZZIZZIIZYZ\n", + "-0.013 * ZIYIZZIIIXZZIZZIIZYZ\n", + "-0.000 * IIYZZZZZZYIZZXIIIIII\n", + "-0.000 * IIXZZZZZZXIZZXIIIIII\n", + "+0.000 * ZIXIZZIIIYZZIYIZZIIZ\n", + "-0.000 * ZIYIZZIIIXZZIYIZZIIZ\n", + "-0.004 * ZYIIZZIIIYZIZIIZZIIZ\n", + "-0.004 * ZXIIZZIIIXZIZIIZZIIZ\n", + "-0.013 * IYIIIIZIIYIZZIIIIZIX\n", + "-0.013 * IXIIIIZIIXIZZIIIIZIX\n", + "+0.013 * ZYZZIIIZZYZZIIIZZZIX\n", + "+0.013 * ZXZZIIIZZXZZIIIZZZIX\n", + "-0.007 * IYZZZZZZZYIZXIIIIIII\n", + "-0.007 * IXZZZZZZZXIZXIIIIIII\n", + "+0.007 * ZYIIZZIIIYZZXIIZZIIZ\n", + "+0.007 * ZXIIZZIIIXZZXIIZZIIZ\n", + "-0.000 * YZIIIIZIIYIZZIIIIZIZ\n", + "-0.000 * XZIIIIZIIXIZZIIIIZIZ\n", + "+0.000 * YZZZZZZZZYIIIIIIIIII\n", + "+0.000 * XZZZZZZZZXIIIIIIIIII\n", + "+0.007 * YZZZZZZZZYIZZZZZZXII\n", + "+0.007 * XZZZZZZZZXIZZZZZZXII\n", + "-0.007 * XZIIZZIIIYZZIZZIIYIZ\n", + "+0.007 * YZIIZZIIIXZZIZZIIYIZ\n", + "-0.004 * YZZZZZZZZYIXIIIIIIII\n", + "-0.004 * XZZZZZZZZXIXIIIIIIII\n", + "+0.004 * XZIIZZIIIYZYZIIZZIIZ\n", + "-0.004 * YZIIZZIIIXZYZIIZZIIZ\n", + "+0.123 * ZIZZIIZZIIZIZIIZZIIZ\n", + "+0.008 * IIZZZZIZIIIZZIIIIZIX\n", + "-0.008 * ZIIIZZZIZIZZIIIZZZIX\n", + "-0.006 * IIIIIIIIZIIZXIIIIIII\n", + "+0.006 * ZIZZIIZZIIZZXIIZZIIZ\n", + "+0.000 * IIIIIIYZYIIZZZZZXIII\n", + "+0.000 * IIIIIIXZXIIZZZZZXIII\n", + "+0.000 * ZIZZIIXIXIZZIZZIXIIZ\n", + "+0.000 * ZIZZIIYIYIZZIZZIXIIZ\n", + "+0.003 * IIIIIIYZYIIZZZZXIIII\n", + "+0.003 * IIIIIIXZXIIZZZZXIIII\n", + "+0.003 * ZIZZIIXIXIZZIZZXZIIZ\n", + "+0.003 * ZIZZIIYIYIZZIZZXZIIZ\n", + "+0.002 * IIZZZXZIXIIZZIIIIZIZ\n", + "+0.002 * IIZZZYZIYIIZZIIIIZIZ\n", + "+0.002 * IIIIIYZZYIIIIIIIIIII\n", + "+0.002 * IIIIIXZZXIIIIIIIIIII\n", + "+0.000 * IIIIIYZZYIIZZZZZZXII\n", + "+0.000 * IIIIIXZZXIIZZZZZZXII\n", + "-0.000 * ZIZZIYIIXIZZIZZIIYIZ\n", + "+0.000 * ZIZZIXIIYIZZIZZIIYIZ\n", + "-0.000 * IIIIIYZZYIIXIIIIIIII\n", + "-0.000 * IIIIIXZZXIIXIIIIIIII\n", + "+0.000 * ZIZZIYIIXIZYZIIZZIIZ\n", + "-0.000 * ZIZZIXIIYIZYZIIZZIIZ\n", + "+0.047 * IIZZXIZIXIIZZIIIIZIZ\n", + "+0.047 * IIZZYIZIYIIZZIIIIZIZ\n", + "+0.047 * IIIIYZZZYIIIIIIIIIII\n", + "+0.047 * IIIIXZZZXIIIIIIIIIII\n", + "+0.004 * IIIIYZZZYIIZZZZZZXII\n", + "+0.004 * IIIIXZZZXIIZZZZZZXII\n", + "-0.004 * ZIZZYZIIXIZZIZZIIYIZ\n", + "+0.004 * ZIZZXZIIYIZZIZZIIYIZ\n", + "-0.014 * IIIIYZZZYIIXIIIIIIII\n", + "-0.014 * IIIIXZZZXIIXIIIIIIII\n", + "+0.014 * ZIZZYZIIXIZYZIIZZIIZ\n", + "-0.014 * ZIZZXZIIYIZYZIIZZIIZ\n", + "+0.001 * ZIZXZZIIXIZIZIIZZIIZ\n", + "+0.001 * ZIZYZZIIYIZIZIIZZIIZ\n", + "+0.017 * IIZXIIZIXIIZZIIIIZIX\n", + "+0.017 * IIZYIIZIYIIZZIIIIZIX\n", + "+0.017 * ZIIYIIIZYIZZIIIZZZIX\n", + "+0.017 * ZIIXIIIZXIZZIIIZZZIX\n", + "-0.014 * IIIYZZZZYIIZXIIIIIII\n", + "-0.014 * IIIXZZZZXIIZXIIIIIII\n", + "-0.014 * ZIZXZZIIXIZZXIIZZIIZ\n", + "-0.014 * ZIZYZZIIYIZZXIIZZIIZ\n", + "+0.000 * ZIXIZZIIXIZIZIIZZIIZ\n", + "+0.000 * ZIYIZZIIYIZIZIIZZIIZ\n", + "+0.001 * IIXIIIZIXIIZZIIIIZIX\n", + "+0.001 * IIYIIIZIYIIZZIIIIZIX\n", + "+0.001 * ZIYZIIIZYIZZIIIZZZIX\n", + "+0.001 * ZIXZIIIZXIZZIIIZZZIX\n", + "-0.001 * IIYZZZZZYIIZXIIIIIII\n", + "-0.001 * IIXZZZZZXIIZXIIIIIII\n", + "-0.001 * ZIXIZZIIXIZZXIIZZIIZ\n", + "-0.001 * ZIYIZZIIYIZZXIIZZIIZ\n", + "-0.003 * IYZZZZZZYIIZZZZZZZZI\n", + "-0.003 * IXZZZZZZXIIZZZZZZZZI\n", + "+0.003 * ZYZZIIIZYIZZIIIZZZIZ\n", + "+0.003 * ZXZZIIIZXIZZIIIZZZIZ\n", + "-0.007 * IYZZZZZZYIIZZZXIIIII\n", + "-0.007 * IXZZZZZZXIIZZZXIIIII\n", + "+0.007 * ZYIIZZIIXIZZIZYZZIIZ\n", + "-0.007 * ZXIIZZIIYIZZIZYZZIIZ\n", + "-0.000 * IYZZZZZZYIIZZXIIIIII\n", + "-0.000 * IXZZZZZZXIIZZXIIIIII\n", + "+0.000 * ZYIIZZIIXIZZIYIZZIIZ\n", + "-0.000 * ZXIIZZIIYIZZIYIZZIIZ\n", + "-0.000 * YZZZZZZZYIIZZZZZXIII\n", + "-0.000 * XZZZZZZZXIIZZZZZXIII\n", + "-0.000 * XZIIZZIIXIZZIZZIXIIZ\n", + "-0.000 * YZIIZZIIYIZZIZZIXIIZ\n", + "-0.004 * YZZZZZZZYIIZZZZXIIII\n", + "-0.004 * XZZZZZZZXIIZZZZXIIII\n", + "-0.004 * XZIIZZIIXIZZIZZXZIIZ\n", + "-0.004 * YZIIZZIIYIZZIZZXZIIZ\n", + "+0.123 * ZIZZIIZIZIZIZIIZZIIZ\n", + "+0.008 * IIZZZZIIZIIZZIIIIZIX\n", + "-0.008 * ZIIIZZZZIIZZIIIZZZIX\n", + "-0.006 * IIIIIIIZIIIZXIIIIIII\n", + "+0.006 * ZIZZIIZIZIZZXIIZZIIZ\n", + "+0.003 * IIIIIIYYIIIZZZZZXIII\n", + "+0.003 * IIIIIIXXIIIZZZZZXIII\n", + "+0.003 * ZIZZIIXXZIZZIZZIXIIZ\n", + "+0.003 * ZIZZIIYYZIZZIZZIXIIZ\n", + "-0.000 * IIIIIIYYIIIZZZZXIIII\n", + "-0.000 * IIIIIIXXIIIZZZZXIIII\n", + "-0.000 * ZIZZIIXXZIZZIZZXZIIZ\n", + "-0.000 * ZIZZIIYYZIZZIZZXZIIZ\n", + "+0.047 * IIZZZXZXZIIZZIIIIZIZ\n", + "+0.047 * IIZZZYZYZIIZZIIIIZIZ\n", + "+0.047 * IIIIIYZYIIIIIIIIIIII\n", + "+0.047 * IIIIIXZXIIIIIIIIIIII\n", + "+0.004 * IIIIIYZYIIIZZZZZZXII\n", + "+0.004 * IIIIIXZXIIIZZZZZZXII\n", + "-0.004 * ZIZZIYIXZIZZIZZIIYIZ\n", + "+0.004 * ZIZZIXIYZIZZIZZIIYIZ\n", + "-0.014 * IIIIIYZYIIIXIIIIIIII\n", + "-0.014 * IIIIIXZXIIIXIIIIIIII\n", + "+0.014 * ZIZZIYIXZIZYZIIZZIIZ\n", + "-0.014 * ZIZZIXIYZIZYZIIZZIIZ\n", + "-0.002 * IIZZXIZXZIIZZIIIIZIZ\n", + "-0.002 * IIZZYIZYZIIZZIIIIZIZ\n", + "-0.002 * IIIIYZZYIIIIIIIIIIII\n", + "-0.002 * IIIIXZZXIIIIIIIIIIII\n", + "-0.000 * IIIIYZZYIIIZZZZZZXII\n", + "-0.000 * IIIIXZZXIIIZZZZZZXII\n", + "+0.000 * ZIZZYZIXZIZZIZZIIYIZ\n", + "-0.000 * ZIZZXZIYZIZZIZZIIYIZ\n", + "+0.000 * IIIIYZZYIIIXIIIIIIII\n", + "+0.000 * IIIIXZZXIIIXIIIIIIII\n", + "-0.000 * ZIZZYZIXZIZYZIIZZIIZ\n", + "+0.000 * ZIZZXZIYZIZYZIIZZIIZ\n", + "-0.000 * ZIZXZZIXZIZIZIIZZIIZ\n", + "-0.000 * ZIZYZZIYZIZIZIIZZIIZ\n", + "-0.001 * IIZXIIZXZIIZZIIIIZIX\n", + "-0.001 * IIZYIIZYZIIZZIIIIZIX\n", + "-0.001 * ZIIYIIIYIIZZIIIZZZIX\n", + "-0.001 * ZIIXIIIXIIZZIIIZZZIX\n", + "+0.001 * IIIYZZZYIIIZXIIIIIII\n", + "+0.001 * IIIXZZZXIIIZXIIIIIII\n", + "+0.001 * ZIZXZZIXZIZZXIIZZIIZ\n", + "+0.001 * ZIZYZZIYZIZZXIIZZIIZ\n", + "+0.001 * ZIXIZZIXZIZIZIIZZIIZ\n", + "+0.001 * ZIYIZZIYZIZIZIIZZIIZ\n", + "+0.017 * IIXIIIZXZIIZZIIIIZIX\n", + "+0.017 * IIYIIIZYZIIZZIIIIZIX\n", + "+0.017 * ZIYZIIIYIIZZIIIZZZIX\n", + "+0.017 * ZIXZIIIXIIZZIIIZZZIX\n", + "-0.014 * IIYZZZZYIIIZXIIIIIII\n", + "-0.014 * IIXZZZZXIIIZXIIIIIII\n", + "-0.014 * ZIXIZZIXZIZZXIIZZIIZ\n", + "-0.014 * ZIYIZZIYZIZZXIIZZIIZ\n", + "-0.003 * IYZZZZZYIIIZZZZZZZXI\n", + "-0.003 * IXZZZZZXIIIZZZZZZZXI\n", + "+0.003 * ZYIIZZIXZIZZIZZIIZYZ\n", + "-0.003 * ZXIIZZIYZIZZIZZIIZYZ\n", + "+0.000 * IYZZZZZYIIIZZZXIIIII\n", + "+0.000 * IXZZZZZXIIIZZZXIIIII\n", + "-0.000 * ZYIIZZIXZIZZIZYZZIIZ\n", + "+0.000 * ZXIIZZIYZIZZIZYZZIIZ\n", + "-0.007 * IYZZZZZYIIIZZXIIIIII\n", + "-0.007 * IXZZZZZXIIIZZXIIIIII\n", + "+0.007 * ZYIIZZIXZIZZIYIZZIIZ\n", + "-0.007 * ZXIIZZIYZIZZIYIZZIIZ\n", + "-0.004 * YZZZZZZYIIIZZZZZXIII\n", + "-0.004 * XZZZZZZXIIIZZZZZXIII\n", + "-0.004 * XZIIZZIXZIZZIZZIXIIZ\n", + "-0.004 * YZIIZZIYZIZZIZZIXIIZ\n", + "+0.000 * YZZZZZZYIIIZZZZXIIII\n", + "+0.000 * XZZZZZZXIIIZZZZXIIII\n", + "+0.000 * XZIIZZIXZIZZIZZXZIIZ\n", + "+0.000 * YZIIZZIYZIZZIZZXZIIZ\n", + "+0.117 * ZIZZIIIZZIZIZIIZZIIZ\n", + "-0.006 * IIZZZZZZZIIZZIIIIZIX\n", + "+0.006 * ZIIIZZIIIIZZIIIZZZIX\n", + "-0.008 * IIIIIIZIIIIZXIIIIIII\n", + "+0.008 * ZIZZIIIZZIZZXIIZZIIZ\n", + "+0.000 * IIIIIYYIIIIZZZZZZZZI\n", + "+0.000 * IIIIIXXIIIIZZZZZZZZI\n", + "+0.000 * ZIIIZXXIIIZZIIIZZZIZ\n", + "+0.000 * ZIIIZYYIIIZZIIIZZZIZ\n", + "+0.004 * IIIIIYYIIIIZZZZZZZXI\n", + "+0.004 * IIIIIXXIIIIZZZZZZZXI\n", + "-0.004 * ZIZZIYXZZIZZIZZIIZYZ\n", + "+0.004 * ZIZZIXYZZIZZIZZIIZYZ\n", + "+0.000 * IIIIIYYIIIIZZZXIIIII\n", + "+0.000 * IIIIIXXIIIIZZZXIIIII\n", + "-0.000 * ZIZZIYXZZIZZIZYZZIIZ\n", + "+0.000 * ZIZZIXYZZIZZIZYZZIIZ\n", + "-0.005 * IIIIIYYIIIIZZXIIIIII\n", + "-0.005 * IIIIIXXIIIIZZXIIIIII\n", + "+0.005 * ZIZZIYXZZIZZIYIZZIIZ\n", + "-0.005 * ZIZZIXYZZIZZIYIZZIIZ\n", + "+0.004 * IIIIYZYIIIIZZZZZZZZI\n", + "+0.004 * IIIIXZXIIIIZZZZZZZZI\n", + "+0.004 * ZIIIXIXIIIZZIIIZZZIZ\n", + "+0.004 * ZIIIYIYIIIZZIIIZZZIZ\n", + "-0.000 * IIIIYZYIIIIZZZZZZZXI\n", + "-0.000 * IIIIXZXIIIIZZZZZZZXI\n", + "+0.000 * ZIZZYZXZZIZZIZZIIZYZ\n", + "-0.000 * ZIZZXZYZZIZZIZZIIZYZ\n", + "-0.005 * IIIIYZYIIIIZZZXIIIII\n", + "-0.005 * IIIIXZXIIIIZZZXIIIII\n", + "+0.005 * ZIZZYZXZZIZZIZYZZIIZ\n", + "-0.005 * ZIZZXZYZZIZZIZYZZIIZ\n", + "-0.000 * IIIIYZYIIIIZZXIIIIII\n", + "-0.000 * IIIIXZXIIIIZZXIIIIII\n", + "+0.000 * ZIZZYZXZZIZZIYIZZIIZ\n", + "-0.000 * ZIZZXZYZZIZZIYIZZIIZ\n", + "+0.000 * IIIYZZYIIIIZZZZZXIII\n", + "+0.000 * IIIXZZXIIIIZZZZZXIII\n", + "+0.000 * ZIZXZZXZZIZZIZZIXIIZ\n", + "+0.000 * ZIZYZZYZZIZZIZZIXIIZ\n", + "-0.006 * IIIYZZYIIIIZZZZXIIII\n", + "-0.006 * IIIXZZXIIIIZZZZXIIII\n", + "-0.006 * ZIZXZZXZZIZZIZZXZIIZ\n", + "-0.006 * ZIZYZZYZZIZZIZZXZIIZ\n", + "-0.006 * IIYZZZYIIIIZZZZZXIII\n", + "-0.006 * IIXZZZXIIIIZZZZZXIII\n", + "-0.006 * ZIXIZZXZZIZZIZZIXIIZ\n", + "-0.006 * ZIYIZZYZZIZZIZZIXIIZ\n", + "-0.000 * IIYZZZYIIIIZZZZXIIII\n", + "-0.000 * IIXZZZXIIIIZZZZXIIII\n", + "-0.000 * ZIXIZZXZZIZZIZZXZIIZ\n", + "-0.000 * ZIYIZZYZZIZZIZZXZIIZ\n", + "+0.022 * IYIIIIYZZIIZZIIIIZIZ\n", + "+0.022 * IXIIIIXZZIIZZIIIIZIZ\n", + "-0.022 * IYZZZZYIIIIIIIIIIIII\n", + "-0.022 * IXZZZZXIIIIIIIIIIIII\n", + "-0.005 * IYZZZZYIIIIZZZZZZXII\n", + "-0.005 * IXZZZZXIIIIZZZZZZXII\n", + "+0.005 * ZYIIZZXZZIZZIZZIIYIZ\n", + "-0.005 * ZXIIZZYZZIZZIZZIIYIZ\n", + "+0.008 * IYZZZZYIIIIXIIIIIIII\n", + "+0.008 * IXZZZZXIIIIXIIIIIIII\n", + "-0.008 * ZYIIZZXZZIZYZIIZZIIZ\n", + "+0.008 * ZXIIZZYZZIZYZIIZZIIZ\n", + "-0.007 * XZIIZZXZZIZIZIIZZIIZ\n", + "-0.007 * YZIIZZYZZIZIZIIZZIIZ\n", + "+0.012 * YZIIIIYZZIIZZIIIIZIX\n", + "+0.012 * XZIIIIXZZIIZZIIIIZIX\n", + "+0.012 * XZZZIIXIIIZZIIIZZZIX\n", + "+0.012 * YZZZIIYIIIZZIIIZZZIX\n", + "+0.007 * YZZZZZYIIIIZXIIIIIII\n", + "+0.007 * XZZZZZXIIIIZXIIIIIII\n", + "+0.007 * XZIIZZXZZIZZXIIZZIIZ\n", + "+0.007 * YZIIZZYZZIZZXIIZZIIZ\n", + "+0.122 * ZIZZIZZZZIZIZIIZZIIZ\n", + "-0.007 * IIZZZIIZZIIZZIIIIZIX\n", + "+0.007 * ZIIIZIZIIIZZIIIZZZIX\n", + "-0.017 * IIIIIZIIIIIZXIIIIIII\n", + "+0.017 * ZIZZIZZZZIZZXIIZZIIZ\n", + "+0.001 * IIZXIXIZZIIZZIIIIZIZ\n", + "+0.001 * IIZYIYIZZIIZZIIIIZIZ\n", + "+0.001 * IIIYZYIIIIIIIIIIIIII\n", + "+0.001 * IIIXZXIIIIIIIIIIIIII\n", + "+0.000 * IIIYZYIIIIIZZZZZZXII\n", + "+0.000 * IIIXZXIIIIIZZZZZZXII\n", + "-0.000 * ZIZXZYZZZIZZIZZIIYIZ\n", + "+0.000 * ZIZYZXZZZIZZIZZIIYIZ\n", + "-0.000 * IIIYZYIIIIIXIIIIIIII\n", + "-0.000 * IIIXZXIIIIIXIIIIIIII\n", + "+0.000 * ZIZXZYZZZIZYZIIZZIIZ\n", + "-0.000 * ZIZYZXZZZIZYZIIZZIIZ\n", + "-0.038 * IIXIIXIZZIIZZIIIIZIZ\n", + "-0.038 * IIYIIYIZZIIZZIIIIZIZ\n", + "-0.038 * IIYZZYIIIIIIIIIIIIII\n", + "-0.038 * IIXZZXIIIIIIIIIIIIII\n", + "-0.007 * IIYZZYIIIIIZZZZZZXII\n", + "-0.007 * IIXZZXIIIIIZZZZZZXII\n", + "+0.007 * ZIXIZYZZZIZZIZZIIYIZ\n", + "-0.007 * ZIYIZXZZZIZZIZZIIYIZ\n", + "+0.013 * IIYZZYIIIIIXIIIIIIII\n", + "+0.013 * IIXZZXIIIIIXIIIIIIII\n", + "-0.013 * ZIXIZYZZZIZYZIIZZIIZ\n", + "+0.013 * ZIYIZXZZZIZYZIIZZIIZ\n", + "+0.006 * IYZZZYIIIIIZZZZZXIII\n", + "+0.006 * IXZZZXIIIIIZZZZZXIII\n", + "-0.006 * ZYIIZYZZZIZZIZZIXIIZ\n", + "-0.006 * ZXIIZXZZZIZZIZZIXIIZ\n", + "-0.000 * YZZZZYIIIIIZZZZZZZZI\n", + "-0.000 * XZZZZXIIIIIZZZZZZZZI\n", + "-0.000 * XZZZIXZIIIZZIIIZZZIZ\n", + "-0.000 * YZZZIYZIIIZZIIIZZZIZ\n", + "-0.005 * YZZZZYIIIIIZZZZZZZXI\n", + "-0.005 * XZZZZXIIIIIZZZZZZZXI\n", + "+0.005 * XZIIZYZZZIZZIZZIIZYZ\n", + "-0.005 * YZIIZXZZZIZZIZZIIZYZ\n", + "-0.000 * YZZZZYIIIIIZZZXIIIII\n", + "-0.000 * XZZZZXIIIIIZZZXIIIII\n", + "+0.000 * XZIIZYZZZIZZIZYZZIIZ\n", + "-0.000 * YZIIZXZZZIZZIZYZZIIZ\n", + "+0.004 * YZZZZYIIIIIZZXIIIIII\n", + "+0.004 * XZZZZXIIIIIZZXIIIIII\n", + "-0.004 * XZIIZYZZZIZZIYIZZIIZ\n", + "+0.004 * YZIIZXZZZIZZIYIZZIIZ\n", + "+0.122 * ZIZZZIZZZIZIZIIZZIIZ\n", + "-0.007 * IIZZIZIZZIIZZIIIIZIX\n", + "+0.007 * ZIIIIZZIIIZZIIIZZZIX\n", + "-0.017 * IIIIZIIIIIIZXIIIIIII\n", + "+0.017 * ZIZZZIZZZIZZXIIZZIIZ\n", + "-0.038 * IIZXXZIZZIIZZIIIIZIZ\n", + "-0.038 * IIZYYZIZZIIZZIIIIZIZ\n", + "-0.038 * IIIYYIIIIIIIIIIIIIII\n", + "-0.038 * IIIXXIIIIIIIIIIIIIII\n", + "-0.007 * IIIYYIIIIIIZZZZZZXII\n", + "-0.007 * IIIXXIIIIIIZZZZZZXII\n", + "+0.007 * ZIZXYIZZZIZZIZZIIYIZ\n", + "-0.007 * ZIZYXIZZZIZZIZZIIYIZ\n", + "+0.013 * IIIYYIIIIIIXIIIIIIII\n", + "+0.013 * IIIXXIIIIIIXIIIIIIII\n", + "-0.013 * ZIZXYIZZZIZYZIIZZIIZ\n", + "+0.013 * ZIZYXIZZZIZYZIIZZIIZ\n", + "-0.001 * IIXIXZIZZIIZZIIIIZIZ\n", + "-0.001 * IIYIYZIZZIIZZIIIIZIZ\n", + "-0.001 * IIYZYIIIIIIIIIIIIIII\n", + "-0.001 * IIXZXIIIIIIIIIIIIIII\n", + "-0.000 * IIYZYIIIIIIZZZZZZXII\n", + "-0.000 * IIXZXIIIIIIZZZZZZXII\n", + "+0.000 * ZIXIYIZZZIZZIZZIIYIZ\n", + "-0.000 * ZIYIXIZZZIZZIZZIIYIZ\n", + "+0.000 * IIYZYIIIIIIXIIIIIIII\n", + "+0.000 * IIXZXIIIIIIXIIIIIIII\n", + "-0.000 * ZIXIYIZZZIZYZIIZZIIZ\n", + "+0.000 * ZIYIXIZZZIZYZIIZZIIZ\n", + "+0.006 * IYZZYIIIIIIZZZZXIIII\n", + "+0.006 * IXZZXIIIIIIZZZZXIIII\n", + "-0.006 * ZYIIYIZZZIZZIZZXZIIZ\n", + "-0.006 * ZXIIXIZZZIZZIZZXZIIZ\n", + "-0.005 * YZZZYIIIIIIZZZZZZZZI\n", + "-0.005 * XZZZXIIIIIIZZZZZZZZI\n", + "-0.005 * XZZZXZZIIIZZIIIZZZIZ\n", + "-0.005 * YZZZYZZIIIZZIIIZZZIZ\n", + "+0.000 * YZZZYIIIIIIZZZZZZZXI\n", + "+0.000 * XZZZXIIIIIIZZZZZZZXI\n", + "-0.000 * XZIIYIZZZIZZIZZIIZYZ\n", + "+0.000 * YZIIXIZZZIZZIZZIIZYZ\n", + "+0.004 * YZZZYIIIIIIZZZXIIIII\n", + "+0.004 * XZZZXIIIIIIZZZXIIIII\n", + "-0.004 * XZIIYIZZZIZZIZYZZIIZ\n", + "+0.004 * YZIIXIZZZIZZIZYZZIIZ\n", + "+0.000 * YZZZYIIIIIIZZXIIIIII\n", + "+0.000 * XZZZXIIIIIIZZXIIIIII\n", + "-0.000 * XZIIYIZZZIZZIYIZZIIZ\n", + "+0.000 * YZIIXIZZZIZZIYIZZIIZ\n", + "+0.125 * ZIZIIIZZZIZIZIIZZIIZ\n", + "+0.011 * IIZIZZIZZIIZZIIIIZIX\n", + "-0.011 * ZIIZZZZIIIZZIIIZZZIX\n", + "-0.001 * IIIZIIIIIIIZXIIIIIII\n", + "+0.001 * ZIZIIIZZZIZZXIIZZIIZ\n", + "-0.013 * IYZYIIIIIIIZZZZZZZZI\n", + "-0.013 * IXZXIIIIIIIZZZZZZZZI\n", + "+0.013 * ZYZYZZZIIIZZIIIZZZIZ\n", + "+0.013 * ZXZXZZZIIIZZIIIZZZIZ\n", + "+0.001 * IYZYIIIIIIIZZZZZZZXI\n", + "+0.001 * IXZXIIIIIIIZZZZZZZXI\n", + "-0.001 * ZYIXIIZZZIZZIZZIIZYZ\n", + "+0.001 * ZXIYIIZZZIZZIZZIIZYZ\n", + "-0.004 * IYZYIIIIIIIZZZXIIIII\n", + "-0.004 * IXZXIIIIIIIZZZXIIIII\n", + "+0.004 * ZYIXIIZZZIZZIZYZZIIZ\n", + "-0.004 * ZXIYIIZZZIZZIZYZZIIZ\n", + "-0.000 * YZZYIIIIIIIZZZZZXIII\n", + "-0.000 * XZZXIIIIIIIZZZZZXIII\n", + "-0.000 * XZIXIIZZZIZZIZZIXIIZ\n", + "-0.000 * YZIYIIZZZIZZIZZIXIIZ\n", + "+0.007 * YZZYIIIIIIIZZZZXIIII\n", + "+0.007 * XZZXIIIIIIIZZZZXIIII\n", + "+0.007 * XZIXIIZZZIZZIZZXZIIZ\n", + "+0.007 * YZIYIIZZZIZZIZZXZIIZ\n", + "+0.125 * ZIIZIIZZZIZIZIIZZIIZ\n", + "+0.011 * IIIZZZIZZIIZZIIIIZIX\n", + "-0.011 * ZIZIZZZIIIZZIIIZZZIX\n", + "-0.001 * IIZIIIIIIIIZXIIIIIII\n", + "+0.001 * ZIIZIIZZZIZZXIIZZIIZ\n", + "-0.001 * IYYIIIIIIIIZZZZZZZZI\n", + "-0.001 * IXXIIIIIIIIZZZZZZZZI\n", + "+0.001 * ZYYIZZZIIIZZIIIZZZIZ\n", + "+0.001 * ZXXIZZZIIIZZIIIZZZIZ\n", + "-0.013 * IYYIIIIIIIIZZZZZZZXI\n", + "-0.013 * IXXIIIIIIIIZZZZZZZXI\n", + "+0.013 * ZYXZIIZZZIZZIZZIIZYZ\n", + "-0.013 * ZXYZIIZZZIZZIZZIIZYZ\n", + "-0.004 * IYYIIIIIIIIZZXIIIIII\n", + "-0.004 * IXXIIIIIIIIZZXIIIIII\n", + "+0.004 * ZYXZIIZZZIZZIYIZZIIZ\n", + "-0.004 * ZXYZIIZZZIZZIYIZZIIZ\n", + "+0.007 * YZYIIIIIIIIZZZZZXIII\n", + "+0.007 * XZXIIIIIIIIZZZZZXIII\n", + "+0.007 * XZXZIIZZZIZZIZZIXIIZ\n", + "+0.007 * YZYZIIZZZIZZIZZIXIIZ\n", + "+0.000 * YZYIIIIIIIIZZZZXIIII\n", + "+0.000 * XZXIIIIIIIIZZZZXIIII\n", + "+0.000 * XZXZIIZZZIZZIZZXZIIZ\n", + "+0.000 * YZYZIIZZZIZZIZZXZIIZ\n", + "+0.133 * ZZZZIIZZZIZIZIIZZIIZ\n", + "+0.012 * IZZZZZIZZIIZZIIIIZIX\n", + "-0.012 * ZZIIZZZIIIZZIIIZZZIX\n", + "-0.010 * IZIIIIIIIIIZXIIIIIII\n", + "+0.010 * ZZZZIIZZZIZZXIIZZIIZ\n", + "+0.045 * YYZZZZIZZIIZZIIIIZIZ\n", + "+0.045 * XXZZZZIZZIIZZIIIIZIZ\n", + "-0.045 * YYIIIIIIIIIIIIIIIIII\n", + "-0.045 * XXIIIIIIIIIIIIIIIIII\n", + "+0.004 * YYIIIIIIIIIZZZZZZXII\n", + "+0.004 * XXIIIIIIIIIZZZZZZXII\n", + "-0.004 * XYZZIIZZZIZZIZZIIYIZ\n", + "+0.004 * YXZZIIZZZIZZIZZIIYIZ\n", + "+0.012 * YYIIIIIIIIIXIIIIIIII\n", + "+0.012 * XXIIIIIIIIIXIIIIIIII\n", + "-0.012 * XYZZIIZZZIZYZIIZZIIZ\n", + "+0.012 * YXZZIIZZZIZYZIIZZIIZ\n", + "+0.143 * IIZZIIZZZIZIZIIZZIIZ\n", + "+0.018 * ZIZZZZIZZIIZZIIIIZIX\n", + "-0.018 * IIIIZZZIIIZZIIIZZZIX\n", + "-0.009 * ZIIIIIIIIIIZXIIIIIII\n", + "+0.009 * IIZZIIZZZIZZXIIZZIIZ\n", + "+0.101 * ZIIIZZZIIIZZIIIZZZIZ\n", + "+0.000 * ZIZZIIZZZIZZYIIZZIIY\n", + "+0.000 * ZIZZIIZZZIZZXIIZZIIX\n", + "+0.109 * ZIZZIIZZZIZZIZZIIZZI\n", + "+0.003 * ZIZZIIZZZIZZIZXZZIII\n", + "-0.003 * ZIIIZZZIIIZZIIXIIIZI\n", + "+0.000 * ZIZZIIZZZIZZIXIZZIII\n", + "-0.000 * ZIIIZZZIIIZZIXZIIIZI\n", + "+0.109 * ZIIIZZZIIIZZIIIZZZZI\n", + "+0.000 * ZIIIZZZIIIZZIIYIIIYI\n", + "+0.000 * ZIIIZZZIIIZZIIXIIIXI\n", + "-0.003 * ZIIIZZZIIIZZIYZIIIYI\n", + "-0.003 * ZIIIZZZIIIZZIXZIIIXI\n", + "+0.102 * ZIIIZZZIIIZZIIIZZIII\n", + "-0.000 * ZIIIZZZIIIZXZZZIIXII\n", + "-0.000 * ZIIIZZZIIIZYZZZIIYII\n", + "+0.108 * ZIIIZZZIIIZZIIIZIZII\n", + "+0.108 * ZIIIZZZIIIZZIIIIZZII\n", + "+0.117 * ZIIIZZZIIIZZIIZZZZII\n", + "+0.117 * ZIIIZZZIIIZZIZIZZZII\n", + "+0.116 * ZIIIZZZIIIZZZIIZZZII\n", + "+0.127 * ZIIIZZZIIIZIIIIZZZII\n", + "+0.017 * ZIZZIIZZZIZZIZZIIXII\n", + "-0.017 * IIZZZZIZZIIIIZZZZXII\n", + "+0.010 * ZIZZIIZZZIZXZIIZZIII\n", + "-0.010 * IIZZZZIZZIIXZIIIIZII\n", + "+0.000 * ZIIIZZZIIIZZIIIZXIZX\n", + "+0.000 * ZIZZIIZZZIZZIZZIYIIY\n", + "-0.000 * ZIIIZZZIIIZZIIIZYIZY\n", + "+0.000 * IIZZZZIZZIIIIZZZXZIX\n", + "-0.000 * IIIIIIIIIIIIIIIIXZZX\n", + "-0.000 * IIZZZZIZZIIIIZZZYZIY\n", + "+0.003 * ZIIIZZZIIIZZIIIXIIZX\n", + "+0.011 * ZIZZIIZZZIZZIZZYZIIY\n", + "-0.008 * ZIIIZZZIIIZZIIIYIIZY\n", + "+0.008 * IIZZZZIZZIIIIZZXIZIX\n", + "-0.011 * IIIIIIIIIIIIIIIXZZZX\n", + "-0.003 * IIZZZZIZZIIIIZZYIZIY\n", + "+0.003 * ZIIIZZZIIIZZIIIZXIXX\n", + "+0.011 * ZIIIZZZIIIZZIIIZXIYY\n", + "-0.008 * ZIIIZZZIIIZZIIIZYIXY\n", + "-0.008 * IIIIIIIIIIIIIIIIYZYX\n", + "-0.011 * IIIIIIIIIIIIIIIIXZXX\n", + "-0.003 * IIIIIIIIIIIIIIIIXZYY\n", + "-0.000 * ZIIIZZZIIIZZIIIXIIXX\n", + "-0.000 * ZIIIZZZIIIZZIIIXIIYY\n", + "+0.000 * ZIIIZZZIIIZZIIIYIIXY\n", + "+0.000 * IIIIIIIIIIIIIIIYZZYX\n", + "+0.000 * IIIIIIIIIIIIIIIXZZXX\n", + "+0.000 * IIIIIIIIIIIIIIIXZZYY\n", + "+0.023 * ZIIIZZZIIIZZYZZIIYIX\n", + "-0.023 * ZIIIZZZIIIZZYZZIIXIY\n", + "-0.001 * ZIIIZZZIIIZZXZZIIYIY\n", + "-0.001 * IIIIIIIIIIIIYZZZZYIX\n", + "+0.023 * IIIIIIIIIIIIXZZZZXIX\n", + "+0.023 * IIIIIIIIIIIIXZZZZYIY\n", + "-0.000 * ZIIIZZZIIIZZIIYIYZIX\n", + "+0.000 * ZIIIZZZIIIZZIIYIXZIY\n", + "-0.000 * ZIIIZZZIIIZZIIXIYZIY\n", + "-0.000 * IIIIIIIIIIIIIIYZYIIX\n", + "-0.000 * IIIIIIIIIIIIIIXZXIIX\n", + "-0.000 * IIIIIIIIIIIIIIXZYIIY\n", + "+0.005 * ZIIIZZZIIIZZIYZIYZIX\n", + "-0.009 * ZIIIZZZIIIZZIYZIXZIY\n", + "+0.005 * ZIIIZZZIIIZZIXZIYZIY\n", + "+0.005 * IIIIIIIIIIIIIYZZYIIX\n", + "+0.009 * IIIIIIIIIIIIIXZZXIIX\n", + "+0.005 * IIIIIIIIIIIIIXZZYIIY\n", + "+0.005 * ZIIIZZZIIIZZIIYYZZIX\n", + "-0.009 * ZIIIZZZIIIZZIIYXZZIY\n", + "+0.005 * ZIIIZZZIIIZZIIXYZZIY\n", + "+0.005 * IIIIIIIIIIIIIIYYIIIX\n", + "+0.009 * IIIIIIIIIIIIIIXXIIIX\n", + "+0.005 * IIIIIIIIIIIIIIXYIIIY\n", + "+0.000 * ZIIIZZZIIIZZIYZYZZIX\n", + "-0.000 * ZIIIZZZIIIZZIYZXZZIY\n", + "+0.000 * ZIIIZZZIIIZZIXZYZZIY\n", + "+0.000 * IIIIIIIIIIIIIYZYIIIX\n", + "+0.000 * IIIIIIIIIIIIIXZXIIIX\n", + "+0.000 * IIIIIIIIIIIIIXZYIIIY\n", + "-0.007 * ZIIIZZZIIIZXXIIZZZIX\n", + "-0.014 * ZIIIZZZIIIZXYIIZZZIY\n", + "+0.007 * ZIIIZZZIIIZYXIIZZZIY\n", + "+0.007 * IIIIIIIIIIIYYIIIIIIX\n", + "+0.014 * IIIIIIIIIIIXXIIIIIIX\n", + "+0.007 * IIIIIIIIIIIXYIIIIIIY\n", + "+0.012 * ZIIIZZZIIIZZIIIZZXZZ\n", + "-0.012 * IIIIIIIIIIIIIIIIIXZZ\n", + "+0.000 * ZIIIZZZIIIZXZZZIIIZZ\n", + "-0.000 * IIIIIIIIIIIXZZZZZZZZ\n", + "+0.010 * ZIIIZZZIIIZZIIYIIYIZ\n", + "+0.002 * ZIZZIIZZZIZZIZXZZXZZ\n", + "-0.008 * ZIZZIIZZZIZZIZYZZYZZ\n", + "-0.008 * IIIIIIIIIIIIIIYZZYIZ\n", + "+0.002 * IIIIIIIIIIIIIIXZZXIZ\n", + "+0.010 * IIZZZZIZZIIIIZYIIYZZ\n", + "+0.001 * ZIIIZZZIIIZZIYZIIYIZ\n", + "+0.000 * ZIZZIIZZZIZZIXIZZXZZ\n", + "-0.000 * ZIZZIIZZZIZZIYIZZYZZ\n", + "-0.000 * IIIIIIIIIIIIIYZZZYIZ\n", + "+0.000 * IIIIIIIIIIIIIXZZZXIZ\n", + "+0.001 * IIZZZZIZZIIIIYIIIYZZ\n", + "+0.001 * ZIIIZZZIIIZZYZZIYZIZ\n", + "-0.000 * ZIZZIIZZZIZZYIIZYZZZ\n", + "+0.000 * ZIZZIIZZZIZZXIIZXZZZ\n", + "-0.000 * IIIIIIIIIIIIYZZZYIIZ\n", + "+0.000 * IIIIIIIIIIIIXZZZXIIZ\n", + "-0.001 * IIZZZZIZZIIIXIIIXIZZ\n", + "+0.017 * ZIIIZZZIIIZZYZZYZZIZ\n", + "-0.013 * ZIZZIIZZZIZZYIIYIZZZ\n", + "+0.003 * ZIZZIIZZZIZZXIIXIZZZ\n", + "-0.003 * IIIIIIIIIIIIYZZYIIIZ\n", + "+0.013 * IIIIIIIIIIIIXZZXIIIZ\n", + "-0.017 * IIZZZZIZZIIIXIIXZIZZ\n", + "-0.011 * ZIIIZZZIIIZXZZXZZZIZ\n", + "+0.008 * ZIZZIIZZZIZXZIXIIZZZ\n", + "-0.003 * ZIZZIIZZZIZYZIYIIZZZ\n", + "-0.003 * IIIIIIIIIIIYZZYIIIIZ\n", + "+0.008 * IIIIIIIIIIIXZZXIIIIZ\n", + "-0.011 * IIZZZZIZZIIXZIXZZIZZ\n", + "-0.001 * ZIIIZZZIIIZXZXIZZZIZ\n", + "+0.000 * ZIZZIIZZZIZXZXZIIZZZ\n", + "-0.000 * ZIZZIIZZZIZYZYZIIZZZ\n", + "-0.000 * IIIIIIIIIIIYZYIIIIIZ\n", + "+0.000 * IIIIIIIIIIIXZXIIIIIZ\n", + "-0.001 * IIZZZZIZZIIXZXZZZIZZ\n", + "+0.012 * ZIZZIIZZZIZZIZZIIXZZ\n", + "-0.012 * IIZZZZIZZIIIIZZZZXZZ\n", + "+0.000 * ZIZZIIZZZIZXZIIZZIZZ\n", + "-0.000 * IIZZZZIZZIIXZIIIIZZZ\n", + "-0.001 * ZIZZIIZZZIZZIZXZZYYZ\n", + "-0.000 * ZIZZIIZZZIZZIZXZZXXZ\n", + "+0.000 * ZIZZIIZZZIZZIZYZZYXZ\n", + "+0.000 * IIZZZZIZZIIIIZXIIYYZ\n", + "+0.000 * IIZZZZIZZIIIIZYIIXYZ\n", + "-0.001 * IIZZZZIZZIIIIZYIIYXZ\n", + "+0.010 * ZIZZIIZZZIZZIXIZZYYZ\n", + "+0.002 * ZIZZIIZZZIZZIXIZZXXZ\n", + "-0.008 * ZIZZIIZZZIZZIYIZZYXZ\n", + "-0.008 * IIZZZZIZZIIIIXIIIYYZ\n", + "-0.002 * IIZZZZIZZIIIIYIIIXYZ\n", + "+0.010 * IIZZZZIZZIIIIYIIIYXZ\n", + "+0.017 * ZIZZIIZZZIZZYIIZXZYZ\n", + "-0.013 * ZIZZIIZZZIZZYIIZYZXZ\n", + "+0.003 * ZIZZIIZZZIZZXIIZXZXZ\n", + "-0.003 * IIZZZZIZZIIIYIIIXIYZ\n", + "-0.013 * IIZZZZIZZIIIXIIIYIYZ\n", + "-0.017 * IIZZZZIZZIIIXIIIXIXZ\n", + "-0.001 * ZIZZIIZZZIZZYIIXIZYZ\n", + "+0.000 * ZIZZIIZZZIZZYIIYIZXZ\n", + "-0.000 * ZIZZIIZZZIZZXIIXIZXZ\n", + "+0.000 * IIZZZZIZZIIIYIIXZIYZ\n", + "+0.000 * IIZZZZIZZIIIXIIYZIYZ\n", + "+0.001 * IIZZZZIZZIIIXIIXZIXZ\n", + "-0.001 * ZIZZIIZZZIZXZIYIIZYZ\n", + "-0.000 * ZIZZIIZZZIZXZIXIIZXZ\n", + "+0.000 * ZIZZIIZZZIZYZIYIIZXZ\n", + "+0.000 * IIZZZZIZZIIYZIXZZIYZ\n", + "+0.000 * IIZZZZIZZIIXZIYZZIYZ\n", + "+0.001 * IIZZZZIZZIIXZIXZZIXZ\n", + "+0.011 * ZIZZIIZZZIZXZYZIIZYZ\n", + "+0.008 * ZIZZIIZZZIZXZXZIIZXZ\n", + "-0.003 * ZIZZIIZZZIZYZYZIIZXZ\n", + "-0.003 * IIZZZZIZZIIYZXZZZIYZ\n", + "-0.008 * IIZZZZIZZIIXZYZZZIYZ\n", + "-0.011 * IIZZZZIZZIIXZXZZZIXZ\n", + "+0.016 * ZIZZIIZZZIZXZIIZZZIZ\n", + "-0.016 * IIZZZZIZZIIXZIIIIIIZ\n", + "+0.005 * ZIZZIIZZZIZZIZZIZXIZ\n", + "-0.005 * IIZZZZIZZIIIIZZZIXIZ\n", + "+0.005 * ZIZZIIZZZIZZIZZZIXIZ\n", + "-0.005 * IIZZZZIZZIIIIZZIZXIZ\n", + "+0.015 * ZIZZIIZZZIZZIZIIIXIZ\n", + "-0.015 * IIZZZZIZZIIIIZIZZXIZ\n", + "+0.015 * ZIZZIIZZZIZZIIZIIXIZ\n", + "-0.015 * IIZZZZIZZIIIIIZZZXIZ\n", + "+0.007 * ZIZZIIZZZIZZZZZIIXIZ\n", + "-0.007 * IIZZZZIZZIIIZZZZZXIZ\n", + "+0.014 * ZIZZIIZZZIZIIZZIIXIZ\n", + "-0.014 * IIZZZZIZZIIZIZZZZXIZ\n", + "+0.007 * ZIZZIIZZZIZXZIIZIIIZ\n", + "-0.007 * IIZZZZIZZIIXZIIIZZIZ\n", + "+0.000 * ZIZZIIZZZIZZYIYIXIIZ\n", + "-0.000 * ZIZZIIZZZIZZYIXIYIIZ\n", + "-0.000 * ZIZZIIZZZIZZXIYIYIIZ\n", + "-0.000 * IIZZZZIZZIIIYIXZYZIZ\n", + "-0.000 * IIZZZZIZZIIIXIYZYZIZ\n", + "-0.000 * IIZZZZIZZIIIXIXZXZIZ\n", + "-0.012 * ZIZZIIZZZIZZYYZIXIIZ\n", + "+0.006 * ZIZZIIZZZIZZYXZIYIIZ\n", + "+0.005 * ZIZZIIZZZIZZXYZIYIIZ\n", + "+0.005 * IIZZZZIZZIIIYXZZYZIZ\n", + "+0.006 * IIZZZZIZZIIIXYZZYZIZ\n", + "+0.012 * IIZZZZIZZIIIXXZZXZIZ\n", + "+0.007 * ZIZZIIZZZIZXZIIIZIIZ\n", + "-0.007 * IIZZZZIZZIIXZIIZIZIZ\n", + "-0.012 * ZIZZIIZZZIZZYIYXZIIZ\n", + "+0.006 * ZIZZIIZZZIZZYIXYZIIZ\n", + "+0.005 * ZIZZIIZZZIZZXIYYZIIZ\n", + "+0.005 * IIZZZZIZZIIIYIXYIZIZ\n", + "+0.006 * IIZZZZIZZIIIXIYYIZIZ\n", + "+0.012 * IIZZZZIZZIIIXIXXIZIZ\n", + "-0.000 * ZIZZIIZZZIZZYYZXZIIZ\n", + "+0.000 * ZIZZIIZZZIZZYXZYZIIZ\n", + "+0.000 * ZIZZIIZZZIZZXYZYZIIZ\n", + "+0.000 * IIZZZZIZZIIIYXZYIZIZ\n", + "+0.000 * IIZZZZIZZIIIXYZYIZIZ\n", + "+0.000 * IIZZZZIZZIIIXXZXIZIZ\n", + "-0.004 * ZIZZIIZZZIZXZIZZZIIZ\n", + "+0.004 * IIZZZZIZZIIXZIZIIZIZ\n", + "-0.004 * ZIZZIIZZZIZXZZIZZIIZ\n", + "+0.004 * IIZZZZIZZIIXZZIIIZIZ\n", + "-0.015 * ZIZZIIZZZIZXIIIZZIIZ\n", + "+0.015 * IIZZZZIZZIIXIIIIIZIZ\n", + "+0.134 * IZZZIIIZZZIZIIIZZZII\n", + "+0.016 * IZIIZZIIIZIZIZZIIXIZ\n", + "-0.016 * ZZIIIIZIIZZIIZZZZXIZ\n", + "+0.006 * IZIIZZIIIZIXZIIZZIIZ\n", + "-0.006 * ZZIIIIZIIZZXZIIIIZIZ\n", + "+0.008 * IZZZIIIZZZYZIIIZZZIY\n", + "-0.008 * ZIIIZZZIIIYZIIIZZZIY\n", + "+0.008 * ZZZZZZZZZZXIIIIIIIIX\n", + "-0.008 * IIIIIIIIIIXIIIIIIIIX\n", + "+0.024 * IZIIZZIIIZYZYIIZZIIZ\n", + "-0.024 * ZIZZIIZZZIYZYIIZZIIZ\n", + "+0.024 * ZZIIIIZIIZXIXIIIIZIZ\n", + "-0.024 * IIZZZZIZZIXIXIIIIZIZ\n", + "+0.008 * IZZZIIIZZXZZIIIZZZII\n", + "-0.008 * ZIIIZZZIIXIZIIIZZZII\n", + "+0.016 * IZIIZZIIIXZZIZZIIXIZ\n", + "-0.016 * ZIZZIIZZZXIZIZZIIXIZ\n", + "-0.016 * ZZIIIIZIIXIIIZZZZXIZ\n", + "+0.016 * IIZZZZIZZXZIIZZZZXIZ\n", + "-0.007 * IZIIZZIIIXZXZIIZZIIZ\n", + "+0.007 * ZIZZIIZZZXIXZIIZZIIZ\n", + "+0.007 * ZZIIIIZIIXIXZIIIIZIZ\n", + "-0.007 * IIZZZZIZZXZXZIIIIZIZ\n", + "-0.001 * IZIIZZIIYIZZIZZIYIIZ\n", + "+0.001 * ZIZZIIZZYZIZIZZIYIIZ\n", + "+0.001 * ZZIIIIZIYIIIIZZZYZIZ\n", + "-0.001 * IIZZZZIZYZZIIZZZYZIZ\n", + "-0.016 * IZIIZZIIYIZZIZZYZIIZ\n", + "+0.016 * ZIZZIIZZYZIZIZZYZIIZ\n", + "+0.016 * ZZIIIIZIYIIIIZZYIZIZ\n", + "-0.016 * IIZZZZIZYZZIIZZYIZIZ\n", + "-0.016 * IZIIZZIYZIZZIZZIYIIZ\n", + "+0.016 * ZIZZIIZYIZIZIZZIYIIZ\n", + "+0.016 * ZZIIIIZYZIIIIZZZYZIZ\n", + "-0.016 * IIZZZZIYIZZIIZZZYZIZ\n", + "+0.001 * IZIIZZIYZIZZIZZYZIIZ\n", + "-0.001 * ZIZZIIZYIZIZIZZYZIIZ\n", + "-0.001 * ZZIIIIZYZIIIIZZYIZIZ\n", + "+0.001 * IIZZZZIYIZZIIZZYIZIZ\n", + "-0.012 * IZZZIIYIIIZZIIIZZZIY\n", + "+0.012 * ZIIIZZYZZZIZIIIZZZIY\n", + "-0.012 * ZZZZZZXIIIIIIIIIIIIX\n", + "+0.012 * IIIIIIXZZZZIIIIIIIIX\n", + "+0.005 * IZIIZZYZZIZZYIIZZIIZ\n", + "-0.005 * ZIZZIIYIIZIZYIIZZIIZ\n", + "+0.005 * ZZIIIIXZZIIIXIIIIZIZ\n", + "-0.005 * IIZZZZXIIZZIXIIIIZIZ\n", + "+0.000 * IZIIZXZZZIZZIZZIIZZZ\n", + "-0.000 * ZIZZIXIIIZIZIZZIIZZZ\n", + "-0.000 * ZZZZZXIIIIIIIIIIIIIZ\n", + "+0.000 * IIIIIXZZZZZIIIIIIIIZ\n", + "+0.014 * IZIIZXZZZIZZIZZIIZXZ\n", + "-0.014 * ZIZZIXIIIZIZIZZIIZXZ\n", + "+0.014 * ZZIIIYIZZIIIIZZZZIYZ\n", + "-0.014 * IIZZZYZIIZZIIZZZZIYZ\n", + "+0.000 * IZIIZXZZZIZZIZXZZIIZ\n", + "-0.000 * ZIZZIXIIIZIZIZXZZIIZ\n", + "+0.000 * ZZIIIYIZZIIIIZYIIZIZ\n", + "-0.000 * IIZZZYZIIZZIIZYIIZIZ\n", + "-0.008 * IZIIZXZZZIZZIXIZZIIZ\n", + "+0.008 * ZIZZIXIIIZIZIXIZZIIZ\n", + "-0.008 * ZZIIIYIZZIIIIYIIIZIZ\n", + "+0.008 * IIZZZYZIIZZIIYIIIZIZ\n", + "+0.014 * IZIIXIZZZIZZIZZIIZZZ\n", + "-0.014 * ZIZZXZIIIZIZIZZIIZZZ\n", + "-0.014 * ZZZZXIIIIIIIIIIIIIIZ\n", + "+0.014 * IIIIXZZZZZZIIIIIIIIZ\n", + "-0.000 * IZIIXIZZZIZZIZZIIZXZ\n", + "+0.000 * ZIZZXZIIIZIZIZZIIZXZ\n", + "-0.000 * ZZIIYZIZZIIIIZZZZIYZ\n", + "+0.000 * IIZZYIZIIZZIIZZZZIYZ\n", + "-0.008 * IZIIXIZZZIZZIZXZZIIZ\n", + "+0.008 * ZIZZXZIIIZIZIZXZZIIZ\n", + "-0.008 * ZZIIYZIZZIIIIZYIIZIZ\n", + "+0.008 * IIZZYIZIIZZIIZYIIZIZ\n", + "-0.000 * IZIIXIZZZIZZIXIZZIIZ\n", + "+0.000 * ZIZZXZIIIZIZIXIZZIIZ\n", + "-0.000 * ZZIIYZIZZIIIIYIIIZIZ\n", + "+0.000 * IIZZYIZIIZZIIYIIIZIZ\n", + "-0.000 * IZIYIIZZZIZZIZZIYIIZ\n", + "+0.000 * ZIZYZZIIIZIZIZZIYIIZ\n", + "+0.000 * ZZIYZZIZZIIIIZZZYZIZ\n", + "-0.000 * IIZYIIZIIZZIIZZZYZIZ\n", + "+0.006 * IZIYIIZZZIZZIZZYZIIZ\n", + "-0.006 * ZIZYZZIIIZIZIZZYZIIZ\n", + "-0.006 * ZZIYZZIZZIIIIZZYIZIZ\n", + "+0.006 * IIZYIIZIIZZIIZZYIZIZ\n", + "+0.006 * IZYZIIZZZIZZIZZIYIIZ\n", + "-0.006 * ZIYIZZIIIZIZIZZIYIIZ\n", + "-0.006 * ZZYZZZIZZIIIIZZZYZIZ\n", + "+0.006 * IIYIIIZIIZZIIZZZYZIZ\n", + "+0.000 * IZYZIIZZZIZZIZZYZIIZ\n", + "-0.000 * ZIYIZZIIIZIZIZZYZIIZ\n", + "-0.000 * ZZYZZZIZZIIIIZZYIZIZ\n", + "+0.000 * IIYIIIZIIZZIIZZYIZIZ\n", + "-0.016 * IXIIZZZIIIZZIIIZZZII\n", + "+0.016 * ZXZZIIIZZZIZIIIZZZII\n", + "-0.002 * IXZZIIZZZIZZIZZIIXIZ\n", + "+0.002 * ZXIIZZIIIZIZIZZIIXIZ\n", + "+0.002 * ZXZZZZIZZIIIIZZZZXIZ\n", + "-0.002 * IXIIIIZIIZZIIZZZZXIZ\n", + "-0.014 * IXZZIIZZZIZXZIIZZIIZ\n", + "+0.014 * ZXIIZZIIIZIXZIIZZIIZ\n", + "+0.014 * ZXZZZZIZZIIXZIIIIZIZ\n", + "-0.014 * IXIIIIZIIZZXZIIIIZIZ\n", + "+0.005 * YIIIZZZIIIZZIIIZZZIY\n", + "-0.005 * YZZZIIIZZZIZIIIZZZIY\n", + "+0.005 * XIIIIIIIIIIIIIIIIIIX\n", + "-0.005 * XZZZZZZZZZZIIIIIIIIX\n", + "+0.012 * YIZZIIZZZIZZYIIZZIIZ\n", + "-0.012 * YZIIZZIIIZIZYIIZZIIZ\n", + "+0.012 * XIZZZZIZZIIIXIIIIZIZ\n", + "-0.012 * XZIIIIZIIZZIXIIIIZIZ\n", + "+0.136 * ZIIIZZZIIIIZIIIZZZII\n", + "+0.014 * ZIZZIIZZZIIZIZZIIXIZ\n", + "-0.014 * IIZZZZIZZIZIIZZZZXIZ\n", + "+0.009 * ZIZZIIZZZIIXZIIZZIIZ\n", + "-0.009 * IIZZZZIZZIZXZIIIIZIZ\n", + "-0.014 * ZIIIZZZIIYXZIIIZZZIY\n", + "+0.014 * ZIIIZZZIIXYZIIIZZZIY\n", + "+0.014 * IIIIIIIIIYYIIIIIIIIX\n", + "+0.014 * IIIIIIIIIXXIIIIIIIIX\n", + "-0.001 * ZIZZIIZZZYXZYIIZZIIZ\n", + "+0.001 * ZIZZIIZZZXYZYIIZZIIZ\n", + "+0.001 * IIZZZZIZZYYIXIIIIZIZ\n", + "+0.001 * IIZZZZIZZXXIXIIIIZIZ\n", + "+0.013 * ZIZZIIZZXZXZIZZIIZZZ\n", + "+0.013 * ZIZZIIZZYZYZIZZIIZZZ\n", + "+0.013 * IIIIIIIIYZYIIIIIIIIZ\n", + "+0.013 * IIIIIIIIXZXIIIIIIIIZ\n", + "-0.006 * ZIZZIIZZXZXZIZXZZIIZ\n", + "-0.006 * ZIZZIIZZYZYZIZXZZIIZ\n", + "-0.006 * IIZZZZIZXZYIIZYIIZIZ\n", + "+0.006 * IIZZZZIZYZXIIZYIIZIZ\n", + "-0.000 * ZIZZIIZZXZXZIXIZZIIZ\n", + "-0.000 * ZIZZIIZZYZYZIXIZZIIZ\n", + "-0.000 * IIZZZZIZXZYIIYIIIZIZ\n", + "+0.000 * IIZZZZIZYZXIIYIIIZIZ\n", + "+0.013 * ZIZZIIZXIZXZIZZIIZXZ\n", + "+0.013 * ZIZZIIZYIZYZIZZIIZXZ\n", + "+0.013 * IIZZZZIXIZYIIZZZZIYZ\n", + "-0.013 * IIZZZZIYIZXIIZZZZIYZ\n", + "+0.000 * ZIZZIIZXIZXZIZXZZIIZ\n", + "+0.000 * ZIZZIIZYIZYZIZXZZIIZ\n", + "+0.000 * IIZZZZIXIZYIIZYIIZIZ\n", + "-0.000 * IIZZZZIYIZXIIZYIIZIZ\n", + "-0.006 * ZIZZIIZXIZXZIXIZZIIZ\n", + "-0.006 * ZIZZIIZYIZYZIXIZZIIZ\n", + "-0.006 * IIZZZZIXIZYIIYIIIZIZ\n", + "+0.006 * IIZZZZIYIZXIIYIIIZIZ\n", + "+0.014 * ZIIIZZXZZZXZIIIZZZII\n", + "+0.014 * ZIIIZZYZZZYZIIIZZZII\n", + "+0.019 * ZIZZIIXIIZXZIZZIIXIZ\n", + "+0.019 * ZIZZIIYIIZYZIZZIIXIZ\n", + "+0.019 * IIZZZZYIIZYIIZZZZXIZ\n", + "+0.019 * IIZZZZXIIZXIIZZZZXIZ\n", + "-0.004 * ZIZZIIXIIZXXZIIZZIIZ\n", + "-0.004 * ZIZZIIYIIZYXZIIZZIIZ\n", + "-0.004 * IIZZZZYIIZYXZIIIIZIZ\n", + "-0.004 * IIZZZZXIIZXXZIIIIZIZ\n", + "-0.018 * ZIZZIYIIIZXZIZZIYIIZ\n", + "+0.018 * ZIZZIXIIIZYZIZZIYIIZ\n", + "+0.018 * IIZZZXZIIZYIIZZZYZIZ\n", + "-0.018 * IIZZZYZIIZXIIZZZYZIZ\n", + "-0.018 * ZIZZYZIIIZXZIZZYZIIZ\n", + "+0.018 * ZIZZXZIIIZYZIZZYZIIZ\n", + "+0.018 * IIZZXIZIIZYIIZZYIZIZ\n", + "-0.018 * IIZZYIZIIZXIIZZYIZIZ\n", + "-0.006 * ZIZXZZIIIZXZIZZIIZZZ\n", + "-0.006 * ZIZYZZIIIZYZIZZIIZZZ\n", + "-0.006 * IIIYZZZZZZYIIIIIIIIZ\n", + "-0.006 * IIIXZZZZZZXIIIIIIIIZ\n", + "+0.000 * ZIZXZZIIIZXZIZZIIZXZ\n", + "+0.000 * ZIZYZZIIIZYZIZZIIZXZ\n", + "+0.000 * IIZXIIZIIZYIIZZZZIYZ\n", + "-0.000 * IIZYIIZIIZXIIZZZZIYZ\n", + "+0.007 * ZIZXZZIIIZXZIZXZZIIZ\n", + "+0.007 * ZIZYZZIIIZYZIZXZZIIZ\n", + "+0.007 * IIZXIIZIIZYIIZYIIZIZ\n", + "-0.007 * IIZYIIZIIZXIIZYIIZIZ\n", + "-0.000 * ZIXIZZIIIZXZIZZIIZZZ\n", + "-0.000 * ZIYIZZIIIZYZIZZIIZZZ\n", + "-0.000 * IIYZZZZZZZYIIIIIIIIZ\n", + "-0.000 * IIXZZZZZZZXIIIIIIIIZ\n", + "-0.006 * ZIXIZZIIIZXZIZZIIZXZ\n", + "-0.006 * ZIYIZZIIIZYZIZZIIZXZ\n", + "-0.006 * IIXIIIZIIZYIIZZZZIYZ\n", + "+0.006 * IIYIIIZIIZXIIZZZZIYZ\n", + "+0.007 * ZIXIZZIIIZXZIXIZZIIZ\n", + "+0.007 * ZIYIZZIIIZYZIXIZZIIZ\n", + "+0.007 * IIXIIIZIIZYIIYIIIZIZ\n", + "-0.007 * IIYIIIZIIZXIIYIIIZIZ\n", + "-0.001 * ZYZZIIIZZZXZIIIZZZIY\n", + "+0.001 * ZXZZIIIZZZYZIIIZZZIY\n", + "+0.001 * IYZZZZZZZZYIIIIIIIIX\n", + "+0.001 * IXZZZZZZZZXIIIIIIIIX\n", + "-0.016 * ZYIIZZIIIZXZYIIZZIIZ\n", + "+0.016 * ZXIIZZIIIZYZYIIZZIIZ\n", + "+0.016 * IYIIIIZIIZYIXIIIIZIZ\n", + "+0.016 * IXIIIIZIIZXIXIIIIZIZ\n", + "+0.009 * XZZZIIIZZZXZIIIZZZII\n", + "+0.009 * YZZZIIIZZZYZIIIZZZII\n", + "-0.004 * XZIIZZIIIZXZIZZIIXIZ\n", + "-0.004 * YZIIZZIIIZYZIZZIIXIZ\n", + "-0.004 * YZIIIIZIIZYIIZZZZXIZ\n", + "-0.004 * XZIIIIZIIZXIIZZZZXIZ\n", + "+0.016 * XZIIZZIIIZXXZIIZZIIZ\n", + "+0.016 * YZIIZZIIIZYXZIIZZIIZ\n", + "+0.016 * YZIIIIZIIZYXZIIIIZIZ\n", + "+0.016 * XZIIIIZIIZXXZIIIIZIZ\n", + "+0.115 * ZIIIZZZIIZZZIIIZZZII\n", + "-0.005 * ZIZZIIZZZZZZIZZIIXIZ\n", + "+0.005 * IIZZZZIZZZIIIZZZZXIZ\n", + "+0.002 * ZIZZIIZZZZZXZIIZZIIZ\n", + "-0.002 * IIZZZZIZZZIXZIIIIZIZ\n", + "+0.000 * ZIZZIIZZXYZZIZZIYIIZ\n", + "-0.000 * ZIZZIIZZYXZZIZZIYIIZ\n", + "-0.000 * IIZZZZIZXYIIIZZZYZIZ\n", + "+0.000 * IIZZZZIZYXIIIZZZYZIZ\n", + "+0.004 * ZIZZIIZZXYZZIZZYZIIZ\n", + "-0.004 * ZIZZIIZZYXZZIZZYZIIZ\n", + "-0.004 * IIZZZZIZXYIIIZZYIZIZ\n", + "+0.004 * IIZZZZIZYXIIIZZYIZIZ\n", + "+0.004 * ZIZZIIZXIYZZIZZIYIIZ\n", + "-0.004 * ZIZZIIZYIXZZIZZIYIIZ\n", + "-0.004 * IIZZZZIXIYIIIZZZYZIZ\n", + "+0.004 * IIZZZZIYIXIIIZZZYZIZ\n", + "-0.000 * ZIZZIIZXIYZZIZZYZIIZ\n", + "+0.000 * ZIZZIIZYIXZZIZZYZIIZ\n", + "+0.000 * IIZZZZIXIYIIIZZYIZIZ\n", + "-0.000 * IIZZZZIYIXIIIZZYIZIZ\n", + "+0.022 * ZIIIZZXZZYZZIIIZZZIY\n", + "-0.022 * ZIIIZZYZZXZZIIIZZZIY\n", + "-0.022 * IIIIIIYZZYIIIIIIIIIX\n", + "-0.022 * IIIIIIXZZXIIIIIIIIIX\n", + "+0.012 * ZIZZIIXIIYZZYIIZZIIZ\n", + "-0.012 * ZIZZIIYIIXZZYIIZZIIZ\n", + "-0.012 * IIZZZZYIIYIIXIIIIZIZ\n", + "-0.012 * IIZZZZXIIXIIXIIIIZIZ\n", + "+0.000 * ZIZZIYIIIYZZIZZIIZZZ\n", + "+0.000 * ZIZZIXIIIXZZIZZIIZZZ\n", + "-0.000 * IIIIIYZZZYIIIIIIIIIZ\n", + "-0.000 * IIIIIXZZZXIIIIIIIIIZ\n", + "+0.006 * ZIZZIYIIIYZZIZZIIZXZ\n", + "+0.006 * ZIZZIXIIIXZZIZZIIZXZ\n", + "-0.006 * IIZZZXZIIYIIIZZZZIYZ\n", + "+0.006 * IIZZZYZIIXIIIZZZZIYZ\n", + "+0.000 * ZIZZIYIIIYZZIZXZZIIZ\n", + "+0.000 * ZIZZIXIIIXZZIZXZZIIZ\n", + "-0.000 * IIZZZXZIIYIIIZYIIZIZ\n", + "+0.000 * IIZZZYZIIXIIIZYIIZIZ\n", + "-0.006 * ZIZZIYIIIYZZIXIZZIIZ\n", + "-0.006 * ZIZZIXIIIXZZIXIZZIIZ\n", + "+0.006 * IIZZZXZIIYIIIYIIIZIZ\n", + "-0.006 * IIZZZYZIIXIIIYIIIZIZ\n", + "+0.006 * ZIZZYZIIIYZZIZZIIZZZ\n", + "+0.006 * ZIZZXZIIIXZZIZZIIZZZ\n", + "-0.006 * IIIIYZZZZYIIIIIIIIIZ\n", + "-0.006 * IIIIXZZZZXIIIIIIIIIZ\n", + "-0.000 * ZIZZYZIIIYZZIZZIIZXZ\n", + "-0.000 * ZIZZXZIIIXZZIZZIIZXZ\n", + "+0.000 * IIZZXIZIIYIIIZZZZIYZ\n", + "-0.000 * IIZZYIZIIXIIIZZZZIYZ\n", + "-0.006 * ZIZZYZIIIYZZIZXZZIIZ\n", + "-0.006 * ZIZZXZIIIXZZIZXZZIIZ\n", + "+0.006 * IIZZXIZIIYIIIZYIIZIZ\n", + "-0.006 * IIZZYIZIIXIIIZYIIZIZ\n", + "-0.000 * ZIZZYZIIIYZZIXIZZIIZ\n", + "-0.000 * ZIZZXZIIIXZZIXIZZIIZ\n", + "+0.000 * IIZZXIZIIYIIIYIIIZIZ\n", + "-0.000 * IIZZYIZIIXIIIYIIIZIZ\n", + "+0.000 * ZIZXZZIIIYZZIZZIYIIZ\n", + "-0.000 * ZIZYZZIIIXZZIZZIYIIZ\n", + "-0.000 * IIZXIIZIIYIIIZZZYZIZ\n", + "+0.000 * IIZYIIZIIXIIIZZZYZIZ\n", + "-0.011 * ZIZXZZIIIYZZIZZYZIIZ\n", + "+0.011 * ZIZYZZIIIXZZIZZYZIIZ\n", + "+0.011 * IIZXIIZIIYIIIZZYIZIZ\n", + "-0.011 * IIZYIIZIIXIIIZZYIZIZ\n", + "-0.011 * ZIXIZZIIIYZZIZZIYIIZ\n", + "+0.011 * ZIYIZZIIIXZZIZZIYIIZ\n", + "+0.011 * IIXIIIZIIYIIIZZZYZIZ\n", + "-0.011 * IIYIIIZIIXIIIZZZYZIZ\n", + "-0.000 * ZIXIZZIIIYZZIZZYZIIZ\n", + "+0.000 * ZIYIZZIIIXZZIZZYZIIZ\n", + "+0.000 * IIXIIIZIIYIIIZZYIZIZ\n", + "-0.000 * IIYIIIZIIXIIIZZYIZIZ\n", + "-0.000 * ZYZZIIIZZYZZIIIZZZII\n", + "-0.000 * ZXZZIIIZZXZZIIIZZZII\n", + "-0.011 * ZYIIZZIIIYZZIZZIIXIZ\n", + "-0.011 * ZXIIZZIIIXZZIZZIIXIZ\n", + "+0.011 * IYIIIIZIIYIIIZZZZXIZ\n", + "+0.011 * IXIIIIZIIXIIIZZZZXIZ\n", + "+0.007 * ZYIIZZIIIYZXZIIZZIIZ\n", + "+0.007 * ZXIIZZIIIXZXZIIZZIIZ\n", + "-0.007 * IYIIIIZIIYIXZIIIIZIZ\n", + "-0.007 * IXIIIIZIIXIXZIIIIZIZ\n", + "+0.008 * XZZZIIIZZYZZIIIZZZIY\n", + "-0.008 * YZZZIIIZZXZZIIIZZZIY\n", + "-0.008 * YZZZZZZZZYIIIIIIIIIX\n", + "-0.008 * XZZZZZZZZXIIIIIIIIIX\n", + "+0.000 * XZIIZZIIIYZZYIIZZIIZ\n", + "-0.000 * YZIIZZIIIXZZYIIZZIIZ\n", + "-0.000 * YZIIIIZIIYIIXIIIIZIZ\n", + "-0.000 * XZIIIIZIIXIIXIIIIZIZ\n", + "+0.123 * ZIIIZZZIZIZZIIIZZZII\n", + "+0.011 * ZIZZIIZZIIZZIZZIIXIZ\n", + "-0.011 * IIZZZZIZIIIIIZZZZXIZ\n", + "+0.002 * ZIZZIIZZIIZXZIIZZIIZ\n", + "-0.002 * IIZZZZIZIIIXZIIIIZIZ\n", + "-0.001 * ZIZZIIXIXIZZIZZIIZZZ\n", + "-0.001 * ZIZZIIYIYIZZIZZIIZZZ\n", + "-0.001 * IIIIIIYZYIIIIIIIIIIZ\n", + "-0.001 * IIIIIIXZXIIIIIIIIIIZ\n", + "+0.004 * ZIZZIIXIXIZZIZXZZIIZ\n", + "+0.004 * ZIZZIIYIYIZZIZXZZIIZ\n", + "+0.004 * IIZZZZYIXIIIIZYIIZIZ\n", + "-0.004 * IIZZZZXIYIIIIZYIIZIZ\n", + "+0.000 * ZIZZIIXIXIZZIXIZZIIZ\n", + "+0.000 * ZIZZIIYIYIZZIXIZZIIZ\n", + "+0.000 * IIZZZZYIXIIIIYIIIZIZ\n", + "-0.000 * IIZZZZXIYIIIIYIIIZIZ\n", + "+0.001 * ZIIIZXIZYIZZIIIZZZIY\n", + "-0.001 * ZIIIZYIZXIZZIIIZZZIY\n", + "-0.001 * IIIIIYZZYIIIIIIIIIIX\n", + "-0.001 * IIIIIXZZXIIIIIIIIIIX\n", + "+0.001 * ZIZZIYIIXIZZYIIZZIIZ\n", + "-0.001 * ZIZZIXIIYIZZYIIZZIIZ\n", + "+0.001 * IIZZZXZIXIIIXIIIIZIZ\n", + "+0.001 * IIZZZYZIYIIIXIIIIZIZ\n", + "+0.015 * ZIIIXIIZYIZZIIIZZZIY\n", + "-0.015 * ZIIIYIIZXIZZIIIZZZIY\n", + "-0.015 * IIIIYZZZYIIIIIIIIIIX\n", + "-0.015 * IIIIXZZZXIIIIIIIIIIX\n", + "+0.018 * ZIZZYZIIXIZZYIIZZIIZ\n", + "-0.018 * ZIZZXZIIYIZZYIIZZIIZ\n", + "+0.018 * IIZZXIZIXIIIXIIIIZIZ\n", + "+0.018 * IIZZYIZIYIIIXIIIIZIZ\n", + "+0.004 * ZIIYIIIZYIZZIIIZZZII\n", + "+0.004 * ZIIXIIIZXIZZIIIZZZII\n", + "+0.014 * ZIZXZZIIXIZZIZZIIXIZ\n", + "+0.014 * ZIZYZZIIYIZZIZZIIXIZ\n", + "-0.014 * IIZXIIZIXIIIIZZZZXIZ\n", + "-0.014 * IIZYIIZIYIIIIZZZZXIZ\n", + "-0.015 * ZIZXZZIIXIZXZIIZZIIZ\n", + "-0.015 * ZIZYZZIIYIZXZIIZZIIZ\n", + "+0.015 * IIZXIIZIXIIXZIIIIZIZ\n", + "+0.015 * IIZYIIZIYIIXZIIIIZIZ\n", + "+0.000 * ZIYZIIIZYIZZIIIZZZII\n", + "+0.000 * ZIXZIIIZXIZZIIIZZZII\n", + "+0.001 * ZIXIZZIIXIZZIZZIIXIZ\n", + "+0.001 * ZIYIZZIIYIZZIZZIIXIZ\n", + "-0.001 * IIXIIIZIXIIIIZZZZXIZ\n", + "-0.001 * IIYIIIZIYIIIIZZZZXIZ\n", + "-0.001 * ZIXIZZIIXIZXZIIZZIIZ\n", + "-0.001 * ZIYIZZIIYIZXZIIZZIIZ\n", + "+0.001 * IIXIIIZIXIIXZIIIIZIZ\n", + "+0.001 * IIYIIIZIYIIXZIIIIZIZ\n", + "+0.000 * ZYIIZZIIXIZZIZZIYIIZ\n", + "-0.000 * ZXIIZZIIYIZZIZZIYIIZ\n", + "-0.000 * IYIIIIZIXIIIIZZZYZIZ\n", + "+0.000 * IXIIIIZIYIIIIZZZYZIZ\n", + "+0.002 * ZYIIZZIIXIZZIZZYZIIZ\n", + "-0.002 * ZXIIZZIIYIZZIZZYZIIZ\n", + "-0.002 * IYIIIIZIXIIIIZZYIZIZ\n", + "+0.002 * IXIIIIZIYIIIIZZYIZIZ\n", + "+0.002 * XZIIZZIIXIZZIZZIIZZZ\n", + "+0.002 * YZIIZZIIYIZZIZZIIZZZ\n", + "+0.002 * YZZZZZZZYIIIIIIIIIIZ\n", + "+0.002 * XZZZZZZZXIIIIIIIIIIZ\n", + "-0.004 * XZIIZZIIXIZZIZXZZIIZ\n", + "-0.004 * YZIIZZIIYIZZIZXZZIIZ\n", + "-0.004 * YZIIIIZIXIIIIZYIIZIZ\n", + "+0.004 * XZIIIIZIYIIIIZYIIZIZ\n", + "-0.000 * XZIIZZIIXIZZIXIZZIIZ\n", + "-0.000 * YZIIZZIIYIZZIXIZZIIZ\n", + "-0.000 * YZIIIIZIXIIIIYIIIZIZ\n", + "+0.000 * XZIIIIZIYIIIIYIIIZIZ\n", + "+0.123 * ZIIIZZZZIIZZIIIZZZII\n", + "+0.011 * ZIZZIIZIZIZZIZZIIXIZ\n", + "-0.011 * IIZZZZIIZIIIIZZZZXIZ\n", + "+0.002 * ZIZZIIZIZIZXZIIZZIIZ\n", + "-0.002 * IIZZZZIIZIIXZIIIIZIZ\n", + "-0.001 * ZIZZIIXXZIZZIZZIIZXZ\n", + "-0.001 * ZIZZIIYYZIZZIZZIIZXZ\n", + "-0.001 * IIZZZZYXZIIIIZZZZIYZ\n", + "+0.001 * IIZZZZXYZIIIIZZZZIYZ\n", + "-0.000 * ZIZZIIXXZIZZIZXZZIIZ\n", + "-0.000 * ZIZZIIYYZIZZIZXZZIIZ\n", + "-0.000 * IIZZZZYXZIIIIZYIIZIZ\n", + "+0.000 * IIZZZZXYZIIIIZYIIZIZ\n", + "+0.004 * ZIZZIIXXZIZZIXIZZIIZ\n", + "+0.004 * ZIZZIIYYZIZZIXIZZIIZ\n", + "+0.004 * IIZZZZYXZIIIIYIIIZIZ\n", + "-0.004 * IIZZZZXYZIIIIYIIIZIZ\n", + "+0.015 * ZIIIZXIYIIZZIIIZZZIY\n", + "-0.015 * ZIIIZYIXIIZZIIIZZZIY\n", + "-0.015 * IIIIIYZYIIIIIIIIIIIX\n", + "-0.015 * IIIIIXZXIIIIIIIIIIIX\n", + "+0.018 * ZIZZIYIXZIZZYIIZZIIZ\n", + "-0.018 * ZIZZIXIYZIZZYIIZZIIZ\n", + "+0.018 * IIZZZXZXZIIIXIIIIZIZ\n", + "+0.018 * IIZZZYZYZIIIXIIIIZIZ\n", + "-0.001 * ZIIIXIIYIIZZIIIZZZIY\n", + "+0.001 * ZIIIYIIXIIZZIIIZZZIY\n", + "+0.001 * IIIIYZZYIIIIIIIIIIIX\n", + "+0.001 * IIIIXZZXIIIIIIIIIIIX\n", + "-0.001 * ZIZZYZIXZIZZYIIZZIIZ\n", + "+0.001 * ZIZZXZIYZIZZYIIZZIIZ\n", + "-0.001 * IIZZXIZXZIIIXIIIIZIZ\n", + "-0.001 * IIZZYIZYZIIIXIIIIZIZ\n", + "-0.000 * ZIIYIIIYIIZZIIIZZZII\n", + "-0.000 * ZIIXIIIXIIZZIIIZZZII\n", + "-0.001 * ZIZXZZIXZIZZIZZIIXIZ\n", + "-0.001 * ZIZYZZIYZIZZIZZIIXIZ\n", + "+0.001 * IIZXIIZXZIIIIZZZZXIZ\n", + "+0.001 * IIZYIIZYZIIIIZZZZXIZ\n", + "+0.001 * ZIZXZZIXZIZXZIIZZIIZ\n", + "+0.001 * ZIZYZZIYZIZXZIIZZIIZ\n", + "-0.001 * IIZXIIZXZIIXZIIIIZIZ\n", + "-0.001 * IIZYIIZYZIIXZIIIIZIZ\n", + "+0.004 * ZIYZIIIYIIZZIIIZZZII\n", + "+0.004 * ZIXZIIIXIIZZIIIZZZII\n", + "+0.014 * ZIXIZZIXZIZZIZZIIXIZ\n", + "+0.014 * ZIYIZZIYZIZZIZZIIXIZ\n", + "-0.014 * IIXIIIZXZIIIIZZZZXIZ\n", + "-0.014 * IIYIIIZYZIIIIZZZZXIZ\n", + "-0.015 * ZIXIZZIXZIZXZIIZZIIZ\n", + "-0.015 * ZIYIZZIYZIZXZIIZZIIZ\n", + "+0.015 * IIXIIIZXZIIXZIIIIZIZ\n", + "+0.015 * IIYIIIZYZIIXZIIIIZIZ\n", + "+0.002 * ZYIIZZIXZIZZIZZIYIIZ\n", + "-0.002 * ZXIIZZIYZIZZIZZIYIIZ\n", + "-0.002 * IYIIIIZXZIIIIZZZYZIZ\n", + "+0.002 * IXIIIIZYZIIIIZZZYZIZ\n", + "-0.000 * ZYIIZZIXZIZZIZZYZIIZ\n", + "+0.000 * ZXIIZZIYZIZZIZZYZIIZ\n", + "+0.000 * IYIIIIZXZIIIIZZYIZIZ\n", + "-0.000 * IXIIIIZYZIIIIZZYIZIZ\n", + "+0.002 * XZIIZZIXZIZZIZZIIZXZ\n", + "+0.002 * YZIIZZIYZIZZIZZIIZXZ\n", + "+0.002 * YZIIIIZXZIIIIZZZZIYZ\n", + "-0.002 * XZIIIIZYZIIIIZZZZIYZ\n", + "+0.000 * XZIIZZIXZIZZIZXZZIIZ\n", + "+0.000 * YZIIZZIYZIZZIZXZZIIZ\n", + "+0.000 * YZIIIIZXZIIIIZYIIZIZ\n", + "-0.000 * XZIIIIZYZIIIIZYIIZIZ\n", + "-0.004 * XZIIZZIXZIZZIXIZZIIZ\n", + "-0.004 * YZIIZZIYZIZZIXIZZIIZ\n", + "-0.004 * YZIIIIZXZIIIIYIIIZIZ\n", + "+0.004 * XZIIIIZYZIIIIYIIIZIZ\n", + "+0.121 * ZIIIZZIIIIZZIIIZZZII\n", + "-0.004 * ZIZZIIIZZIZZIZZIIXIZ\n", + "+0.004 * IIZZZZZZZIIIIZZZZXIZ\n", + "+0.004 * ZIZZIIIZZIZXZIIZZIIZ\n", + "-0.004 * IIZZZZZZZIIXZIIIIZIZ\n", + "+0.006 * ZIZZIYXZZIZZIZZIYIIZ\n", + "-0.006 * ZIZZIXYZZIZZIZZIYIIZ\n", + "-0.006 * IIZZZXYZZIIIIZZZYZIZ\n", + "+0.006 * IIZZZYXZZIIIIZZZYZIZ\n", + "+0.006 * ZIZZYZXZZIZZIZZYZIIZ\n", + "-0.006 * ZIZZXZYZZIZZIZZYZIIZ\n", + "-0.006 * IIZZXIYZZIIIIZZYIZIZ\n", + "+0.006 * IIZZYIXZZIIIIZZYIZIZ\n", + "+0.006 * ZIZXZZXZZIZZIZZIIZZZ\n", + "+0.006 * ZIZYZZYZZIZZIZZIIZZZ\n", + "+0.006 * IIIYZZYIIIIIIIIIIIIZ\n", + "+0.006 * IIIXZZXIIIIIIIIIIIIZ\n", + "-0.000 * ZIZXZZXZZIZZIZZIIZXZ\n", + "-0.000 * ZIZYZZYZZIZZIZZIIZXZ\n", + "-0.000 * IIZXIIYZZIIIIZZZZIYZ\n", + "+0.000 * IIZYIIXZZIIIIZZZZIYZ\n", + "-0.003 * ZIZXZZXZZIZZIZXZZIIZ\n", + "-0.003 * ZIZYZZYZZIZZIZXZZIIZ\n", + "-0.003 * IIZXIIYZZIIIIZYIIZIZ\n", + "+0.003 * IIZYIIXZZIIIIZYIIZIZ\n", + "+0.000 * ZIXIZZXZZIZZIZZIIZZZ\n", + "+0.000 * ZIYIZZYZZIZZIZZIIZZZ\n", + "+0.000 * IIYZZZYIIIIIIIIIIIIZ\n", + "+0.000 * IIXZZZXIIIIIIIIIIIIZ\n", + "+0.006 * ZIXIZZXZZIZZIZZIIZXZ\n", + "+0.006 * ZIYIZZYZZIZZIZZIIZXZ\n", + "+0.006 * IIXIIIYZZIIIIZZZZIYZ\n", + "-0.006 * IIYIIIXZZIIIIZZZZIYZ\n", + "-0.003 * ZIXIZZXZZIZZIXIZZIIZ\n", + "-0.003 * ZIYIZZYZZIZZIXIZZIIZ\n", + "-0.003 * IIXIIIYZZIIIIYIIIZIZ\n", + "+0.003 * IIYIIIXZZIIIIYIIIZIZ\n", + "-0.010 * ZYZZIIXIIIZZIIIZZZIY\n", + "+0.010 * ZXZZIIYIIIZZIIIZZZIY\n", + "+0.010 * IYZZZZYIIIIIIIIIIIIX\n", + "+0.010 * IXZZZZXIIIIIIIIIIIIX\n", + "-0.009 * ZYIIZZXZZIZZYIIZZIIZ\n", + "+0.009 * ZXIIZZYZZIZZYIIZZIIZ\n", + "+0.009 * IYIIIIYZZIIIXIIIIZIZ\n", + "+0.009 * IXIIIIXZZIIIXIIIIZIZ\n", + "-0.004 * XZZZIIXIIIZZIIIZZZII\n", + "-0.004 * YZZZIIYIIIZZIIIZZZII\n", + "-0.012 * XZIIZZXZZIZZIZZIIXIZ\n", + "-0.012 * YZIIZZYZZIZZIZZIIXIZ\n", + "-0.012 * YZIIIIYZZIIIIZZZZXIZ\n", + "-0.012 * XZIIIIXZZIIIIZZZZXIZ\n", + "+0.011 * XZIIZZXZZIZXZIIZZIIZ\n", + "+0.011 * YZIIZZYZZIZXZIIZZIIZ\n", + "+0.011 * YZIIIIYZZIIXZIIIIZIZ\n", + "+0.011 * XZIIIIXZZIIXZIIIIZIZ\n", + "+0.126 * ZIIIZIZIIIZZIIIZZZII\n", + "-0.001 * ZIZZIZZZZIZZIZZIIXIZ\n", + "+0.001 * IIZZZIIZZIIIIZZZZXIZ\n", + "+0.015 * ZIZZIZZZZIZXZIIZZIIZ\n", + "-0.015 * IIZZZIIZZIIXZIIIIZIZ\n", + "+0.000 * ZIIYIXZIIIZZIIIZZZIY\n", + "-0.000 * ZIIXIYZIIIZZIIIZZZIY\n", + "-0.000 * IIIYZYIIIIIIIIIIIIIX\n", + "-0.000 * IIIXZXIIIIIIIIIIIIIX\n", + "+0.000 * ZIZXZYZZZIZZYIIZZIIZ\n", + "-0.000 * ZIZYZXZZZIZZYIIZZIIZ\n", + "+0.000 * IIZXIXIZZIIIXIIIIZIZ\n", + "+0.000 * IIZYIYIZZIIIXIIIIZIZ\n", + "-0.016 * ZIYZIXZIIIZZIIIZZZIY\n", + "+0.016 * ZIXZIYZIIIZZIIIZZZIY\n", + "+0.016 * IIYZZYIIIIIIIIIIIIIX\n", + "+0.016 * IIXZZXIIIIIIIIIIIIIX\n", + "-0.015 * ZIXIZYZZZIZZYIIZZIIZ\n", + "+0.015 * ZIYIZXZZZIZZYIIZZIIZ\n", + "-0.015 * IIXIIXIZZIIIXIIIIZIZ\n", + "-0.015 * IIYIIYIZZIIIXIIIIZIZ\n", + "+0.000 * ZYIIZYZZZIZZIZZIIZZZ\n", + "+0.000 * ZXIIZXZZZIZZIZZIIZZZ\n", + "-0.000 * IYZZZYIIIIIIIIIIIIIZ\n", + "-0.000 * IXZZZXIIIIIIIIIIIIIZ\n", + "+0.005 * ZYIIZYZZZIZZIZZIIZXZ\n", + "+0.005 * ZXIIZXZZZIZZIZZIIZXZ\n", + "-0.005 * IYIIIXIZZIIIIZZZZIYZ\n", + "+0.005 * IXIIIYIZZIIIIZZZZIYZ\n", + "+0.000 * ZYIIZYZZZIZZIZXZZIIZ\n", + "+0.000 * ZXIIZXZZZIZZIZXZZIIZ\n", + "-0.000 * IYIIIXIZZIIIIZYIIZIZ\n", + "+0.000 * IXIIIYIZZIIIIZYIIZIZ\n", + "-0.003 * ZYIIZYZZZIZZIXIZZIIZ\n", + "-0.003 * ZXIIZXZZZIZZIXIZZIIZ\n", + "+0.003 * IYIIIXIZZIIIIYIIIZIZ\n", + "-0.003 * IXIIIYIZZIIIIYIIIZIZ\n", + "-0.007 * XZIIZYZZZIZZIZZIYIIZ\n", + "+0.007 * YZIIZXZZZIZZIZZIYIIZ\n", + "+0.007 * YZIIIXIZZIIIIZZZYZIZ\n", + "-0.007 * XZIIIYIZZIIIIZZZYZIZ\n", + "+0.126 * ZIIIIZZIIIZZIIIZZZII\n", + "-0.001 * ZIZZZIZZZIZZIZZIIXIZ\n", + "+0.001 * IIZZIZIZZIIIIZZZZXIZ\n", + "+0.015 * ZIZZZIZZZIZXZIIZZIIZ\n", + "-0.015 * IIZZIZIZZIIXZIIIIZIZ\n", + "-0.016 * ZIIYXZZIIIZZIIIZZZIY\n", + "+0.016 * ZIIXYZZIIIZZIIIZZZIY\n", + "+0.016 * IIIYYIIIIIIIIIIIIIIX\n", + "+0.016 * IIIXXIIIIIIIIIIIIIIX\n", + "-0.015 * ZIZXYIZZZIZZYIIZZIIZ\n", + "+0.015 * ZIZYXIZZZIZZYIIZZIIZ\n", + "-0.015 * IIZXXZIZZIIIXIIIIZIZ\n", + "-0.015 * IIZYYZIZZIIIXIIIIZIZ\n", + "-0.000 * ZIYZXZZIIIZZIIIZZZIY\n", + "+0.000 * ZIXZYZZIIIZZIIIZZZIY\n", + "+0.000 * IIYZYIIIIIIIIIIIIIIX\n", + "+0.000 * IIXZXIIIIIIIIIIIIIIX\n", + "-0.000 * ZIXIYIZZZIZZYIIZZIIZ\n", + "+0.000 * ZIYIXIZZZIZZYIIZZIIZ\n", + "-0.000 * IIXIXZIZZIIIXIIIIZIZ\n", + "-0.000 * IIYIYZIZZIIIXIIIIZIZ\n", + "+0.005 * ZYIIYIZZZIZZIZZIIZZZ\n", + "+0.005 * ZXIIXIZZZIZZIZZIIZZZ\n", + "-0.005 * IYZZYIIIIIIIIIIIIIIZ\n", + "-0.005 * IXZZXIIIIIIIIIIIIIIZ\n", + "-0.000 * ZYIIYIZZZIZZIZZIIZXZ\n", + "-0.000 * ZXIIXIZZZIZZIZZIIZXZ\n", + "+0.000 * IYIIXZIZZIIIIZZZZIYZ\n", + "-0.000 * IXIIYZIZZIIIIZZZZIYZ\n", + "-0.003 * ZYIIYIZZZIZZIZXZZIIZ\n", + "-0.003 * ZXIIXIZZZIZZIZXZZIIZ\n", + "+0.003 * IYIIXZIZZIIIIZYIIZIZ\n", + "-0.003 * IXIIYZIZZIIIIZYIIZIZ\n", + "-0.000 * ZYIIYIZZZIZZIXIZZIIZ\n", + "-0.000 * ZXIIXIZZZIZZIXIZZIIZ\n", + "+0.000 * IYIIXZIZZIIIIYIIIZIZ\n", + "-0.000 * IXIIYZIZZIIIIYIIIZIZ\n", + "-0.007 * XZIIYIZZZIZZIZZYZIIZ\n", + "+0.007 * YZIIXIZZZIZZIZZYZIIZ\n", + "+0.007 * YZIIXZIZZIIIIZZYIZIZ\n", + "-0.007 * XZIIYZIZZIIIIZZYIZIZ\n", + "+0.123 * ZIIZZZZIIIZZIIIZZZII\n", + "+0.012 * ZIZIIIZZZIZZIZZIIXIZ\n", + "-0.012 * IIZIZZIZZIIIIZZZZXIZ\n", + "-0.002 * ZIZIIIZZZIZXZIIZZIIZ\n", + "+0.002 * IIZIZZIZZIIXZIIIIZIZ\n", + "+0.000 * ZYIXIIZZZIZZIZZIYIIZ\n", + "-0.000 * ZXIYIIZZZIZZIZZIYIIZ\n", + "-0.000 * IYIXZZIZZIIIIZZZYZIZ\n", + "+0.000 * IXIYZZIZZIIIIZZZYZIZ\n", + "-0.009 * ZYIXIIZZZIZZIZZYZIIZ\n", + "+0.009 * ZXIYIIZZZIZZIZZYZIIZ\n", + "+0.009 * IYIXZZIZZIIIIZZYIZIZ\n", + "-0.009 * IXIYZZIZZIIIIZZYIZIZ\n", + "-0.007 * XZIXIIZZZIZZIZZIIZZZ\n", + "-0.007 * YZIYIIZZZIZZIZZIIZZZ\n", + "-0.007 * YZZYIIIIIIIIIIIIIIIZ\n", + "-0.007 * XZZXIIIIIIIIIIIIIIIZ\n", + "+0.000 * XZIXIIZZZIZZIZZIIZXZ\n", + "+0.000 * YZIYIIZZZIZZIZZIIZXZ\n", + "+0.000 * YZIXZZIZZIIIIZZZZIYZ\n", + "-0.000 * XZIYZZIZZIIIIZZZZIYZ\n", + "+0.002 * XZIXIIZZZIZZIZXZZIIZ\n", + "+0.002 * YZIYIIZZZIZZIZXZZIIZ\n", + "+0.002 * YZIXZZIZZIIIIZYIIZIZ\n", + "-0.002 * XZIYZZIZZIIIIZYIIZIZ\n", + "+0.123 * ZIZIZZZIIIZZIIIZZZII\n", + "+0.012 * ZIIZIIZZZIZZIZZIIXIZ\n", + "-0.012 * IIIZZZIZZIIIIZZZZXIZ\n", + "-0.002 * ZIIZIIZZZIZXZIIZZIIZ\n", + "+0.002 * IIIZZZIZZIIXZIIIIZIZ\n", + "-0.009 * ZYXZIIZZZIZZIZZIYIIZ\n", + "+0.009 * ZXYZIIZZZIZZIZZIYIIZ\n", + "+0.009 * IYXZZZIZZIIIIZZZYZIZ\n", + "-0.009 * IXYZZZIZZIIIIZZZYZIZ\n", + "-0.000 * ZYXZIIZZZIZZIZZYZIIZ\n", + "+0.000 * ZXYZIIZZZIZZIZZYZIIZ\n", + "+0.000 * IYXZZZIZZIIIIZZYIZIZ\n", + "-0.000 * IXYZZZIZZIIIIZZYIZIZ\n", + "-0.000 * XZXZIIZZZIZZIZZIIZZZ\n", + "-0.000 * YZYZIIZZZIZZIZZIIZZZ\n", + "-0.000 * YZYIIIIIIIIIIIIIIIIZ\n", + "-0.000 * XZXIIIIIIIIIIIIIIIIZ\n", + "-0.007 * XZXZIIZZZIZZIZZIIZXZ\n", + "-0.007 * YZYZIIZZZIZZIZZIIZXZ\n", + "-0.007 * YZXZZZIZZIIIIZZZZIYZ\n", + "+0.007 * XZYZZZIZZIIIIZZZZIYZ\n", + "+0.002 * XZXZIIZZZIZZIXIZZIIZ\n", + "+0.002 * YZYZIIZZZIZZIXIZZIIZ\n", + "+0.002 * YZXZZZIZZIIIIYIIIZIZ\n", + "-0.002 * XZYZZZIZZIIIIYIIIZIZ\n", + "+0.132 * ZZIIZZZIIIZZIIIZZZII\n", + "+0.016 * ZZZZIIZZZIZZIZZIIXIZ\n", + "-0.016 * IZZZZZIZZIIIIZZZZXIZ\n", + "+0.005 * ZZZZIIZZZIZXZIIZZIIZ\n", + "-0.005 * IZZZZZIZZIIXZIIIIZIZ\n", + "-0.007 * XYIIZZZIIIZZIIIZZZIY\n", + "+0.007 * YXIIZZZIIIZZIIIZZZIY\n", + "+0.007 * YYIIIIIIIIIIIIIIIIIX\n", + "+0.007 * XXIIIIIIIIIIIIIIIIIX\n", + "-0.020 * XYZZIIZZZIZZYIIZZIIZ\n", + "+0.020 * YXZZIIZZZIZZYIIZZIIZ\n", + "+0.020 * YYZZZZIZZIIIXIIIIZIZ\n", + "+0.020 * XXZZZZIZZIIIXIIIIZIZ\n", + "+0.143 * IIIIZZZIIIZZIIIZZZII\n", + "+0.024 * IIZZIIZZZIZZIZZIIXIZ\n", + "-0.024 * ZIZZZZIZZIIIIZZZZXIZ\n", + "-0.002 * IIZZIIZZZIZXZIIZZIIZ\n", + "+0.002 * ZIZZZZIZZIIXZIIIIZIZ\n", + "+0.102 * IIZZZZIZZIIIIZZZZIZZ\n", + "-0.008 * IIZZZZIZZIIIIZXIIZIZ\n", + "+0.008 * IIIIIIIIIIIIIIXZZZZZ\n", + "-0.000 * IIZZZZIZZIIIIXIIIZIZ\n", + "+0.000 * IIIIIIIIIIIIIXZZZZZZ\n", + "+0.102 * IIIIIIIIIIIIIIIIIIZZ\n", + "-0.000 * IIIIIIIIIIIIIIYZZZYZ\n", + "-0.000 * IIIIIIIIIIIIIIXZZZXZ\n", + "+0.008 * IIIIIIIIIIIIIYZZZZYZ\n", + "+0.008 * IIIIIIIIIIIIIXZZZZXZ\n", + "+0.060 * IIIIIIIIIIIIIIIIIZIZ\n", + "+0.005 * IIIIIIIIIIIYZZZZZYIZ\n", + "+0.005 * IIIIIIIIIIIXZZZZZXIZ\n", + "+0.109 * IIIIIIIIIIIIIIIIZIIZ\n", + "+0.109 * IIIIIIIIIIIIIIIZIIIZ\n", + "+0.101 * IIIIIIIIIIIIIIZIIIIZ\n", + "+0.101 * IIIIIIIIIIIIIZIIIIIZ\n", + "+0.100 * IIIIIIIIIIIIZIIIIIIZ\n", + "+0.113 * IIIIIIIIIIIZIIIIIIIZ\n", + "-0.002 * IIIIIIIIIIIIYZZZZZZY\n", + "-0.002 * IIIIIIIIIIIIXZZZZZZX\n", + "+0.001 * IIIIIIIIIIIIIIIIYXIY\n", + "-0.000 * IIZZZZIZZIIIIZZZXYZY\n", + "-0.001 * IIZZZZIZZIIIIZZZYXZY\n", + "-0.001 * IIIIIIIIIIIIIIIIYYIX\n", + "+0.000 * IIIIIIIIIIIIIIIIXXIX\n", + "+0.001 * IIZZZZIZZIIIIZZZYYZX\n", + "+0.042 * IIIIIIIIIIIIIIIYZXIY\n", + "-0.000 * IIZZZZIZZIIIIZZXIYZY\n", + "-0.041 * IIZZZZIZZIIIIZZYIXZY\n", + "-0.041 * IIIIIIIIIIIIIIIYZYIX\n", + "+0.000 * IIIIIIIIIIIIIIIXZXIX\n", + "+0.042 * IIZZZZIZZIIIIZZYIYZX\n", + "-0.000 * IIIIIIIIIIIYZZZZXIIY\n", + "+0.000 * IIZZZZIZZIIYZIIIXIZY\n", + "+0.000 * IIZZZZIZZIIXZIIIYIZY\n", + "+0.000 * IIIIIIIIIIIYZZZZYIIX\n", + "-0.000 * IIIIIIIIIIIXZZZZXIIX\n", + "+0.000 * IIZZZZIZZIIXZIIIXIZX\n", + "-0.006 * IIIIIIIIIIIYZZZXIIIY\n", + "+0.005 * IIZZZZIZZIIYZIIXZIZY\n", + "+0.000 * IIZZZZIZZIIXZIIYZIZY\n", + "+0.000 * IIIIIIIIIIIYZZZYIIIX\n", + "-0.005 * IIIIIIIIIIIXZZZXIIIX\n", + "+0.006 * IIZZZZIZZIIXZIIXZIZX\n", + "-0.011 * IIIIIIIIIIIIYZXIIIIY\n", + "+0.010 * IIZZZZIZZIIIYIXZZIZY\n", + "+0.001 * IIZZZZIZZIIIXIYZZIZY\n", + "+0.001 * IIIIIIIIIIIIYZYIIIIX\n", + "-0.010 * IIIIIIIIIIIIXZXIIIIX\n", + "+0.011 * IIZZZZIZZIIIXIXZZIZX\n", + "-0.001 * IIIIIIIIIIIIYXIIIIIY\n", + "+0.001 * IIZZZZIZZIIIYXZZZIZY\n", + "+0.000 * IIZZZZIZZIIIXYZZZIZY\n", + "+0.000 * IIIIIIIIIIIIYYIIIIIX\n", + "-0.001 * IIIIIIIIIIIIXXIIIIIX\n", + "+0.001 * IIZZZZIZZIIIXXZZZIZX\n", + "-0.002 * IIZZZZIZZIIIYIIIIZZY\n", + "-0.002 * IIZZZZIZZIIIXIIIIZZX\n", + "+0.042 * IIZZZZIZZIIIIZZZXXYY\n", + "-0.000 * IIZZZZIZZIIIIZZZXYXY\n", + "-0.041 * IIZZZZIZZIIIIZZZYXXY\n", + "-0.041 * IIZZZZIZZIIIIZZZXYYX\n", + "-0.000 * IIZZZZIZZIIIIZZZYXYX\n", + "+0.042 * IIZZZZIZZIIIIZZZYYXX\n", + "-0.001 * IIZZZZIZZIIIIZZXIXYY\n", + "+0.000 * IIZZZZIZZIIIIZZXIYXY\n", + "+0.001 * IIZZZZIZZIIIIZZYIXXY\n", + "+0.001 * IIZZZZIZZIIIIZZXIYYX\n", + "+0.000 * IIZZZZIZZIIIIZZYIXYX\n", + "-0.001 * IIZZZZIZZIIIIZZYIYXX\n", + "+0.006 * IIZZZZIZZIIYZIIIYIYY\n", + "+0.005 * IIZZZZIZZIIYZIIIXIXY\n", + "+0.000 * IIZZZZIZZIIXZIIIYIXY\n", + "+0.000 * IIZZZZIZZIIYZIIIXIYX\n", + "+0.005 * IIZZZZIZZIIXZIIIYIYX\n", + "+0.006 * IIZZZZIZZIIXZIIIXIXX\n", + "-0.000 * IIZZZZIZZIIYZIIYZIYY\n", + "-0.000 * IIZZZZIZZIIYZIIXZIXY\n", + "-0.000 * IIZZZZIZZIIXZIIYZIXY\n", + "-0.000 * IIZZZZIZZIIYZIIXZIYX\n", + "-0.000 * IIZZZZIZZIIXZIIYZIYX\n", + "-0.000 * IIZZZZIZZIIXZIIXZIXX\n", + "-0.001 * IIZZZZIZZIIIYIYZZIYY\n", + "-0.001 * IIZZZZIZZIIIYIXZZIXY\n", + "-0.000 * IIZZZZIZZIIIXIYZZIXY\n", + "-0.000 * IIZZZZIZZIIIYIXZZIYX\n", + "-0.001 * IIZZZZIZZIIIXIYZZIYX\n", + "-0.001 * IIZZZZIZZIIIXIXZZIXX\n", + "+0.011 * IIZZZZIZZIIIYYZZZIYY\n", + "+0.010 * IIZZZZIZZIIIYXZZZIXY\n", + "+0.001 * IIZZZZIZZIIIXYZZZIXY\n", + "+0.001 * IIZZZZIZZIIIYXZZZIYX\n", + "+0.010 * IIZZZZIZZIIIXYZZZIYX\n", + "+0.011 * IIZZZZIZZIIIXXZZZIXX\n", + "-0.018 * IIZZZZIZZIIIYIIIIIIY\n", + "-0.018 * IIZZZZIZZIIIXIIIIIIX\n", + "+0.000 * IIZZZZIZZIIIIZXIYXIY\n", + "-0.001 * IIZZZZIZZIIIIZXIXYIY\n", + "-0.001 * IIZZZZIZZIIIIZYIYYIY\n", + "-0.001 * IIZZZZIZZIIIIZXIXXIX\n", + "-0.001 * IIZZZZIZZIIIIZYIYXIX\n", + "+0.000 * IIZZZZIZZIIIIZYIXYIX\n", + "-0.000 * IIZZZZIZZIIIIXIIYXIY\n", + "+0.036 * IIZZZZIZZIIIIXIIXYIY\n", + "+0.035 * IIZZZZIZZIIIIYIIYYIY\n", + "+0.035 * IIZZZZIZZIIIIXIIXXIX\n", + "+0.036 * IIZZZZIZZIIIIYIIYXIX\n", + "-0.000 * IIZZZZIZZIIIIYIIXYIX\n", + "-0.000 * IIZZZZIZZIIIIZXYZXIY\n", + "+0.036 * IIZZZZIZZIIIIZXXZYIY\n", + "+0.035 * IIZZZZIZZIIIIZYYZYIY\n", + "+0.035 * IIZZZZIZZIIIIZXXZXIX\n", + "+0.036 * IIZZZZIZZIIIIZYYZXIX\n", + "-0.000 * IIZZZZIZZIIIIZYXZYIX\n", + "-0.000 * IIZZZZIZZIIIIXIYZXIY\n", + "+0.001 * IIZZZZIZZIIIIXIXZYIY\n", + "+0.001 * IIZZZZIZZIIIIYIYZYIY\n", + "+0.001 * IIZZZZIZZIIIIXIXZXIX\n", + "+0.001 * IIZZZZIZZIIIIYIYZXIX\n", + "-0.000 * IIZZZZIZZIIIIYIXZYIX\n", + "-0.006 * IIZZZZIZZIIYXZZZZXIY\n", + "-0.032 * IIZZZZIZZIIYYZZZZYIY\n", + "-0.026 * IIZZZZIZZIIXXZZZZYIY\n", + "-0.026 * IIZZZZIZZIIYYZZZZXIX\n", + "-0.032 * IIZZZZIZZIIXXZZZZXIX\n", + "-0.006 * IIZZZZIZZIIXYZZZZYIX\n", + "+0.009 * IIZZZZIZZIIIYIIIZZIY\n", + "+0.009 * IIZZZZIZZIIIXIIIZZIX\n", + "+0.000 * IIZZZZIZZIIYZIYZYZIY\n", + "+0.000 * IIZZZZIZZIIYZIXZXZIY\n", + "+0.000 * IIZZZZIZZIIXZIYZXZIY\n", + "+0.000 * IIZZZZIZZIIYZIXZYZIX\n", + "+0.000 * IIZZZZIZZIIXZIYZYZIX\n", + "+0.000 * IIZZZZIZZIIXZIXZXZIX\n", + "-0.007 * IIZZZZIZZIIYZYZZYZIY\n", + "-0.007 * IIZZZZIZZIIYZXZZXZIY\n", + "-0.001 * IIZZZZIZZIIXZYZZXZIY\n", + "-0.001 * IIZZZZIZZIIYZXZZYZIX\n", + "-0.007 * IIZZZZIZZIIXZYZZYZIX\n", + "-0.007 * IIZZZZIZZIIXZXZZXZIX\n", + "+0.009 * IIZZZZIZZIIIYIIZIZIY\n", + "+0.009 * IIZZZZIZZIIIXIIZIZIX\n", + "-0.007 * IIZZZZIZZIIYZIYYIZIY\n", + "-0.007 * IIZZZZIZZIIYZIXXIZIY\n", + "-0.001 * IIZZZZIZZIIXZIYXIZIY\n", + "-0.001 * IIZZZZIZZIIYZIXYIZIX\n", + "-0.007 * IIZZZZIZZIIXZIYYIZIX\n", + "-0.007 * IIZZZZIZZIIXZIXXIZIX\n", + "-0.000 * IIZZZZIZZIIYZYZYIZIY\n", + "-0.000 * IIZZZZIZZIIYZXZXIZIY\n", + "-0.000 * IIZZZZIZZIIXZYZXIZIY\n", + "-0.000 * IIZZZZIZZIIYZXZYIZIX\n", + "-0.000 * IIZZZZIZZIIXZYZYIZIX\n", + "-0.000 * IIZZZZIZZIIXZXZXIZIX\n", + "+0.000 * IIZZZZIZZIIIYIZIIZIY\n", + "+0.000 * IIZZZZIZZIIIXIZIIZIX\n", + "+0.000 * IIZZZZIZZIIIYZIIIZIY\n", + "+0.000 * IIZZZZIZZIIIXZIIIZIX\n", + "-0.011 * IIZZZZIZZIIZYIIIIZIY\n", + "-0.011 * IIZZZZIZZIIZXIIIIZIX\n", + "+0.113 * ZZZZZZZZZZZIIIIIIIIZ\n", + "-0.004 * ZZIIIIZIIZZIYIIIIZIY\n", + "-0.004 * ZZIIIIZIIZZIXIIIIZIX\n", + "-0.048 * ZZIIIIZIIZXIIZZZZYIY\n", + "+0.048 * IIZZZZIZZIXIIZZZZYIY\n", + "-0.048 * ZZIIIIZIIZXIIZZZZXIX\n", + "+0.048 * IIZZZZIZZIXIIZZZZXIX\n", + "-0.000 * ZZIIIIZIIZXYZIIIIZIY\n", + "+0.000 * IIZZZZIZZIXYZIIIIZIY\n", + "-0.000 * ZZIIIIZIIZXXZIIIIZIX\n", + "+0.000 * IIZZZZIZZIXXZIIIIZIX\n", + "-0.006 * ZZZZZZZZZXIIIIIIIIIZ\n", + "+0.006 * IIIIIIIIIXZIIIIIIIIZ\n", + "-0.013 * ZZIIIIZIIXIIYIIIIZIY\n", + "+0.013 * IIZZZZIZZXZIYIIIIZIY\n", + "-0.013 * ZZIIIIZIIXIIXIIIIZIX\n", + "+0.013 * IIZZZZIZZXZIXIIIIZIX\n", + "-0.001 * ZZIIIIZIYIIIIZZZZIZY\n", + "+0.001 * IIZZZZIZYZZIIZZZZIZY\n", + "-0.001 * ZZZZZZZZXIIIIIIIIIIX\n", + "+0.001 * IIIIIIIIXZZIIIIIIIIX\n", + "-0.013 * ZZIIIIZIYIIIIZXIIZIY\n", + "+0.013 * IIZZZZIZYZZIIZXIIZIY\n", + "+0.013 * ZZIIIIZIYIIIIZYIIZIX\n", + "-0.013 * IIZZZZIZYZZIIZYIIZIX\n", + "-0.001 * ZZIIIIZIYIIIIXIIIZIY\n", + "+0.001 * IIZZZZIZYZZIIXIIIZIY\n", + "+0.001 * ZZIIIIZIYIIIIYIIIZIX\n", + "-0.001 * IIZZZZIZYZZIIYIIIZIX\n", + "-0.001 * ZZIIIIZYZIIIIZZZZIXY\n", + "+0.001 * IIZZZZIYIZZIIZZZZIXY\n", + "+0.001 * ZZIIIIZYZIIIIZZZZIYX\n", + "-0.001 * IIZZZZIYIZZIIZZZZIYX\n", + "+0.001 * ZZIIIIZYZIIIIZXIIZIY\n", + "-0.001 * IIZZZZIYIZZIIZXIIZIY\n", + "-0.001 * ZZIIIIZYZIIIIZYIIZIX\n", + "+0.001 * IIZZZZIYIZZIIZYIIZIX\n", + "-0.013 * ZZIIIIZYZIIIIXIIIZIY\n", + "+0.013 * IIZZZZIYIZZIIXIIIZIY\n", + "+0.013 * ZZIIIIZYZIIIIYIIIZIX\n", + "-0.013 * IIZZZZIYIZZIIYIIIZIX\n", + "+0.011 * ZZIIIIXZZIIIIZZZZYIY\n", + "-0.011 * IIZZZZXIIZZIIZZZZYIY\n", + "+0.011 * ZZIIIIXZZIIIIZZZZXIX\n", + "-0.011 * IIZZZZXIIZZIIZZZZXIX\n", + "+0.007 * ZZIIIIXZZIIYZIIIIZIY\n", + "-0.007 * IIZZZZXIIZZYZIIIIZIY\n", + "+0.007 * ZZIIIIXZZIIXZIIIIZIX\n", + "-0.007 * IIZZZZXIIZZXZIIIIZIX\n", + "+0.008 * ZZIIIYIZZIIIIZZZXZIY\n", + "-0.008 * IIZZZYZIIZZIIZZZXZIY\n", + "-0.008 * ZZIIIYIZZIIIIZZZYZIX\n", + "+0.008 * IIZZZYZIIZZIIZZZYZIX\n", + "+0.008 * ZZIIYZIZZIIIIZZXIZIY\n", + "-0.008 * IIZZYIZIIZZIIZZXIZIY\n", + "-0.008 * ZZIIYZIZZIIIIZZYIZIX\n", + "+0.008 * IIZZYIZIIZZIIZZYIZIX\n", + "-0.007 * ZZIYZZIZZIIIIZZZZIZY\n", + "+0.007 * IIZYIIZIIZZIIZZZZIZY\n", + "-0.007 * ZZZXIIIIIIIIIIIIIIIX\n", + "+0.007 * IIIXZZZZZZZIIIIIIIIX\n", + "+0.000 * ZZIYZZIZZIIIIZZZZIXY\n", + "-0.000 * IIZYIIZIIZZIIZZZZIXY\n", + "-0.000 * ZZIYZZIZZIIIIZZZZIYX\n", + "+0.000 * IIZYIIZIIZZIIZZZZIYX\n", + "-0.000 * ZZIYZZIZZIIIIZXIIZIY\n", + "+0.000 * IIZYIIZIIZZIIZXIIZIY\n", + "+0.000 * ZZIYZZIZZIIIIZYIIZIX\n", + "-0.000 * IIZYIIZIIZZIIZYIIZIX\n", + "-0.000 * ZZYZZZIZZIIIIZZZZIZY\n", + "+0.000 * IIYIIIZIIZZIIZZZZIZY\n", + "-0.000 * ZZXIIIIIIIIIIIIIIIIX\n", + "+0.000 * IIXZZZZZZZZIIIIIIIIX\n", + "-0.007 * ZZYZZZIZZIIIIZZZZIXY\n", + "+0.007 * IIYIIIZIIZZIIZZZZIXY\n", + "+0.007 * ZZYZZZIZZIIIIZZZZIYX\n", + "-0.007 * IIYIIIZIIZZIIZZZZIYX\n", + "-0.000 * ZZYZZZIZZIIIIXIIIZIY\n", + "+0.000 * IIYIIIZIIZZIIXIIIZIY\n", + "+0.000 * ZZYZZZIZZIIIIYIIIZIX\n", + "-0.000 * IIYIIIZIIZZIIYIIIZIX\n", + "-0.005 * ZXIIIIIIIIIIIIIIIIIZ\n", + "+0.005 * IXZZZZZZZZZIIIIIIIIZ\n", + "-0.007 * ZXZZZZIZZIIIYIIIIZIY\n", + "+0.007 * IXIIIIZIIZZIYIIIIZIY\n", + "-0.007 * ZXZZZZIZZIIIXIIIIZIX\n", + "+0.007 * IXIIIIZIIZZIXIIIIZIX\n", + "-0.009 * XIZZZZIZZIIIIZZZZYIY\n", + "+0.009 * XZIIIIZIIZZIIZZZZYIY\n", + "-0.009 * XIZZZZIZZIIIIZZZZXIX\n", + "+0.009 * XZIIIIZIIZZIIZZZZXIX\n", + "-0.004 * XIZZZZIZZIIYZIIIIZIY\n", + "+0.004 * XZIIIIZIIZZYZIIIIZIY\n", + "-0.004 * XIZZZZIZZIIXZIIIIZIX\n", + "+0.004 * XZIIIIZIIZZXZIIIIZIX\n", + "+0.115 * IIIIIIIIIIZIIIIIIIIZ\n", + "-0.000 * IIZZZZIZZIZIYIIIIZIY\n", + "-0.000 * IIZZZZIZZIZIXIIIIZIX\n", + "-0.022 * IIZZZZIZZYYIIZZZZYIY\n", + "-0.022 * IIZZZZIZZXXIIZZZZYIY\n", + "-0.022 * IIZZZZIZZYYIIZZZZXIX\n", + "-0.022 * IIZZZZIZZXXIIZZZZXIX\n", + "-0.008 * IIZZZZIZZYYYZIIIIZIY\n", + "-0.008 * IIZZZZIZZXXYZIIIIZIY\n", + "-0.008 * IIZZZZIZZYYXZIIIIZIX\n", + "-0.008 * IIZZZZIZZXXXZIIIIZIX\n", + "+0.000 * IIZZZZIZXZYIIZZZXZIY\n", + "-0.000 * IIZZZZIZYZXIIZZZXZIY\n", + "-0.000 * IIZZZZIZXZYIIZZZYZIX\n", + "+0.000 * IIZZZZIZYZXIIZZZYZIX\n", + "+0.006 * IIZZZZIZXZYIIZZXIZIY\n", + "-0.006 * IIZZZZIZYZXIIZZXIZIY\n", + "-0.006 * IIZZZZIZXZYIIZZYIZIX\n", + "+0.006 * IIZZZZIZYZXIIZZYIZIX\n", + "+0.006 * IIZZZZIXIZYIIZZZXZIY\n", + "-0.006 * IIZZZZIYIZXIIZZZXZIY\n", + "-0.006 * IIZZZZIXIZYIIZZZYZIX\n", + "+0.006 * IIZZZZIYIZXIIZZZYZIX\n", + "-0.000 * IIZZZZIXIZYIIZZXIZIY\n", + "+0.000 * IIZZZZIYIZXIIZZXIZIY\n", + "+0.000 * IIZZZZIXIZYIIZZYIZIX\n", + "-0.000 * IIZZZZIYIZXIIZZYIZIX\n", + "+0.005 * IIIIIIYZZZYIIIIIIIIZ\n", + "+0.005 * IIIIIIXZZZXIIIIIIIIZ\n", + "+0.011 * IIZZZZYIIZYIYIIIIZIY\n", + "+0.011 * IIZZZZXIIZXIYIIIIZIY\n", + "+0.011 * IIZZZZYIIZYIXIIIIZIX\n", + "+0.011 * IIZZZZXIIZXIXIIIIZIX\n", + "+0.000 * IIZZZXZIIZYIIZZZZIZY\n", + "-0.000 * IIZZZYZIIZXIIZZZZIZY\n", + "-0.000 * IIIIIYZZZZYIIIIIIIIX\n", + "-0.000 * IIIIIXZZZZXIIIIIIIIX\n", + "+0.004 * IIZZZXZIIZYIIZZZZIXY\n", + "-0.004 * IIZZZYZIIZXIIZZZZIXY\n", + "-0.004 * IIZZZXZIIZYIIZZZZIYX\n", + "+0.004 * IIZZZYZIIZXIIZZZZIYX\n", + "+0.000 * IIZZZXZIIZYIIZXIIZIY\n", + "-0.000 * IIZZZYZIIZXIIZXIIZIY\n", + "-0.000 * IIZZZXZIIZYIIZYIIZIX\n", + "+0.000 * IIZZZYZIIZXIIZYIIZIX\n", + "-0.011 * IIZZZXZIIZYIIXIIIZIY\n", + "+0.011 * IIZZZYZIIZXIIXIIIZIY\n", + "+0.011 * IIZZZXZIIZYIIYIIIZIX\n", + "-0.011 * IIZZZYZIIZXIIYIIIZIX\n", + "+0.004 * IIZZXIZIIZYIIZZZZIZY\n", + "-0.004 * IIZZYIZIIZXIIZZZZIZY\n", + "-0.004 * IIIIYZZZZZYIIIIIIIIX\n", + "-0.004 * IIIIXZZZZZXIIIIIIIIX\n", + "-0.000 * IIZZXIZIIZYIIZZZZIXY\n", + "+0.000 * IIZZYIZIIZXIIZZZZIXY\n", + "+0.000 * IIZZXIZIIZYIIZZZZIYX\n", + "-0.000 * IIZZYIZIIZXIIZZZZIYX\n", + "-0.011 * IIZZXIZIIZYIIZXIIZIY\n", + "+0.011 * IIZZYIZIIZXIIZXIIZIY\n", + "+0.011 * IIZZXIZIIZYIIZYIIZIX\n", + "-0.011 * IIZZYIZIIZXIIZYIIZIX\n", + "-0.000 * IIZZXIZIIZYIIXIIIZIY\n", + "+0.000 * IIZZYIZIIZXIIXIIIZIY\n", + "+0.000 * IIZZXIZIIZYIIYIIIZIX\n", + "-0.000 * IIZZYIZIIZXIIYIIIZIX\n", + "+0.000 * IIZXIIZIIZYIIZZZXZIY\n", + "-0.000 * IIZYIIZIIZXIIZZZXZIY\n", + "-0.000 * IIZXIIZIIZYIIZZZYZIX\n", + "+0.000 * IIZYIIZIIZXIIZZZYZIX\n", + "-0.006 * IIZXIIZIIZYIIZZXIZIY\n", + "+0.006 * IIZYIIZIIZXIIZZXIZIY\n", + "+0.006 * IIZXIIZIIZYIIZZYIZIX\n", + "-0.006 * IIZYIIZIIZXIIZZYIZIX\n", + "-0.006 * IIXIIIZIIZYIIZZZXZIY\n", + "+0.006 * IIYIIIZIIZXIIZZZXZIY\n", + "+0.006 * IIXIIIZIIZYIIZZZYZIX\n", + "-0.006 * IIYIIIZIIZXIIZZZYZIX\n", + "-0.000 * IIXIIIZIIZYIIZZXIZIY\n", + "+0.000 * IIYIIIZIIZXIIZZXIZIY\n", + "+0.000 * IIXIIIZIIZYIIZZYIZIX\n", + "-0.000 * IIYIIIZIIZXIIZZYIZIX\n", + "-0.012 * IYIIIIZIIZYIIZZZZYIY\n", + "-0.012 * IXIIIIZIIZXIIZZZZYIY\n", + "-0.012 * IYIIIIZIIZYIIZZZZXIX\n", + "-0.012 * IXIIIIZIIZXIIZZZZXIX\n", + "-0.000 * IYIIIIZIIZYYZIIIIZIY\n", + "-0.000 * IXIIIIZIIZXYZIIIIZIY\n", + "-0.000 * IYIIIIZIIZYXZIIIIZIX\n", + "-0.000 * IXIIIIZIIZXXZIIIIZIX\n", + "-0.002 * YZZZZZZZZZYIIIIIIIIZ\n", + "-0.002 * XZZZZZZZZZXIIIIIIIIZ\n", + "-0.007 * YZIIIIZIIZYIYIIIIZIY\n", + "-0.007 * XZIIIIZIIZXIYIIIIZIY\n", + "-0.007 * YZIIIIZIIZYIXIIIIZIX\n", + "-0.007 * XZIIIIZIIZXIXIIIIZIX\n", + "+0.125 * IIIIIIIIIZIIIIIIIIIZ\n", + "+0.010 * IIZZZZIZZZIIYIIIIZIY\n", + "+0.010 * IIZZZZIZZZIIXIIIIZIX\n", + "-0.008 * IIZZZZIZXYIIIZZZZIZY\n", + "+0.008 * IIZZZZIZYXIIIZZZZIZY\n", + "+0.008 * IIIIIIIIYYIIIIIIIIIX\n", + "+0.008 * IIIIIIIIXXIIIIIIIIIX\n", + "+0.000 * IIZZZZIZXYIIIZXIIZIY\n", + "-0.000 * IIZZZZIZYXIIIZXIIZIY\n", + "-0.000 * IIZZZZIZXYIIIZYIIZIX\n", + "+0.000 * IIZZZZIZYXIIIZYIIZIX\n", + "+0.000 * IIZZZZIZXYIIIXIIIZIY\n", + "-0.000 * IIZZZZIZYXIIIXIIIZIY\n", + "-0.000 * IIZZZZIZXYIIIYIIIZIX\n", + "+0.000 * IIZZZZIZYXIIIYIIIZIX\n", + "-0.008 * IIZZZZIXIYIIIZZZZIXY\n", + "+0.008 * IIZZZZIYIXIIIZZZZIXY\n", + "+0.008 * IIZZZZIXIYIIIZZZZIYX\n", + "-0.008 * IIZZZZIYIXIIIZZZZIYX\n", + "-0.000 * IIZZZZIXIYIIIZXIIZIY\n", + "+0.000 * IIZZZZIYIXIIIZXIIZIY\n", + "+0.000 * IIZZZZIXIYIIIZYIIZIX\n", + "-0.000 * IIZZZZIYIXIIIZYIIZIX\n", + "+0.000 * IIZZZZIXIYIIIXIIIZIY\n", + "-0.000 * IIZZZZIYIXIIIXIIIZIY\n", + "-0.000 * IIZZZZIXIYIIIYIIIZIX\n", + "+0.000 * IIZZZZIYIXIIIYIIIZIX\n", + "+0.068 * IIZZZZYIIYIIIZZZZYIY\n", + "+0.068 * IIZZZZXIIXIIIZZZZYIY\n", + "+0.068 * IIZZZZYIIYIIIZZZZXIX\n", + "+0.068 * IIZZZZXIIXIIIZZZZXIX\n", + "+0.011 * IIZZZZYIIYIYZIIIIZIY\n", + "+0.011 * IIZZZZXIIXIYZIIIIZIY\n", + "+0.011 * IIZZZZYIIYIXZIIIIZIX\n", + "+0.011 * IIZZZZXIIXIXZIIIIZIX\n", + "-0.009 * IIZZZXZIIYIIIZZZXZIY\n", + "+0.009 * IIZZZYZIIXIIIZZZXZIY\n", + "+0.009 * IIZZZXZIIYIIIZZZYZIX\n", + "-0.009 * IIZZZYZIIXIIIZZZYZIX\n", + "-0.009 * IIZZXIZIIYIIIZZXIZIY\n", + "+0.009 * IIZZYIZIIXIIIZZXIZIY\n", + "+0.009 * IIZZXIZIIYIIIZZYIZIX\n", + "-0.009 * IIZZYIZIIXIIIZZYIZIX\n", + "+0.000 * IIZXIIZIIYIIIZZZZIZY\n", + "-0.000 * IIZYIIZIIXIIIZZZZIZY\n", + "-0.000 * IIIYZZZZZYIIIIIIIIIX\n", + "-0.000 * IIIXZZZZZXIIIIIIIIIX\n", + "-0.000 * IIZXIIZIIYIIIZZZZIXY\n", + "+0.000 * IIZYIIZIIXIIIZZZZIXY\n", + "+0.000 * IIZXIIZIIYIIIZZZZIYX\n", + "-0.000 * IIZYIIZIIXIIIZZZZIYX\n", + "-0.012 * IIZXIIZIIYIIIZXIIZIY\n", + "+0.012 * IIZYIIZIIXIIIZXIIZIY\n", + "+0.012 * IIZXIIZIIYIIIZYIIZIX\n", + "-0.012 * IIZYIIZIIXIIIZYIIZIX\n", + "+0.000 * IIXIIIZIIYIIIZZZZIZY\n", + "-0.000 * IIYIIIZIIXIIIZZZZIZY\n", + "-0.000 * IIYZZZZZZYIIIIIIIIIX\n", + "-0.000 * IIXZZZZZZXIIIIIIIIIX\n", + "+0.000 * IIXIIIZIIYIIIZZZZIXY\n", + "-0.000 * IIYIIIZIIXIIIZZZZIXY\n", + "-0.000 * IIXIIIZIIYIIIZZZZIYX\n", + "+0.000 * IIYIIIZIIXIIIZZZZIYX\n", + "-0.012 * IIXIIIZIIYIIIXIIIZIY\n", + "+0.012 * IIYIIIZIIXIIIXIIIZIY\n", + "+0.012 * IIXIIIZIIYIIIYIIIZIX\n", + "-0.012 * IIYIIIZIIXIIIYIIIZIX\n", + "+0.010 * IYZZZZZZZYIIIIIIIIIZ\n", + "+0.010 * IXZZZZZZZXIIIIIIIIIZ\n", + "+0.015 * IYIIIIZIIYIIYIIIIZIY\n", + "+0.015 * IXIIIIZIIXIIYIIIIZIY\n", + "+0.015 * IYIIIIZIIYIIXIIIIZIX\n", + "+0.015 * IXIIIIZIIXIIXIIIIZIX\n", + "+0.011 * YZIIIIZIIYIIIZZZZYIY\n", + "+0.011 * XZIIIIZIIXIIIZZZZYIY\n", + "+0.011 * YZIIIIZIIYIIIZZZZXIX\n", + "+0.011 * XZIIIIZIIXIIIZZZZXIX\n", + "+0.008 * YZIIIIZIIYIYZIIIIZIY\n", + "+0.008 * XZIIIIZIIXIYZIIIIZIY\n", + "+0.008 * YZIIIIZIIYIXZIIIIZIX\n", + "+0.008 * XZIIIIZIIXIXZIIIIZIX\n", + "+0.110 * IIIIIIIIZIIIIIIIIIIZ\n", + "-0.006 * IIZZZZIZIIIIYIIIIZIY\n", + "-0.006 * IIZZZZIZIIIIXIIIIZIX\n", + "-0.000 * IIZZZZYIXIIIIZZZXZIY\n", + "+0.000 * IIZZZZXIYIIIIZZZXZIY\n", + "+0.000 * IIZZZZYIXIIIIZZZYZIX\n", + "-0.000 * IIZZZZXIYIIIIZZZYZIX\n", + "-0.006 * IIZZZZYIXIIIIZZXIZIY\n", + "+0.006 * IIZZZZXIYIIIIZZXIZIY\n", + "+0.006 * IIZZZZYIXIIIIZZYIZIX\n", + "-0.006 * IIZZZZXIYIIIIZZYIZIX\n", + "-0.002 * IIZZZXZIXIIIIZZZZYIY\n", + "-0.002 * IIZZZYZIYIIIIZZZZYIY\n", + "-0.002 * IIZZZXZIXIIIIZZZZXIX\n", + "-0.002 * IIZZZYZIYIIIIZZZZXIX\n", + "-0.000 * IIZZZXZIXIIYZIIIIZIY\n", + "-0.000 * IIZZZYZIYIIYZIIIIZIY\n", + "-0.000 * IIZZZXZIXIIXZIIIIZIX\n", + "-0.000 * IIZZZYZIYIIXZIIIIZIX\n", + "-0.048 * IIZZXIZIXIIIIZZZZYIY\n", + "-0.048 * IIZZYIZIYIIIIZZZZYIY\n", + "-0.048 * IIZZXIZIXIIIIZZZZXIX\n", + "-0.048 * IIZZYIZIYIIIIZZZZXIX\n", + "-0.004 * IIZZXIZIXIIYZIIIIZIY\n", + "-0.004 * IIZZYIZIYIIYZIIIIZIY\n", + "-0.004 * IIZZXIZIXIIXZIIIIZIX\n", + "-0.004 * IIZZYIZIYIIXZIIIIZIX\n", + "+0.009 * IIIYZZZZYIIIIIIIIIIZ\n", + "+0.009 * IIIXZZZZXIIIIIIIIIIZ\n", + "-0.016 * IIZXIIZIXIIIYIIIIZIY\n", + "-0.016 * IIZYIIZIYIIIYIIIIZIY\n", + "-0.016 * IIZXIIZIXIIIXIIIIZIX\n", + "-0.016 * IIZYIIZIYIIIXIIIIZIX\n", + "+0.000 * IIYZZZZZYIIIIIIIIIIZ\n", + "+0.000 * IIXZZZZZXIIIIIIIIIIZ\n", + "-0.001 * IIXIIIZIXIIIYIIIIZIY\n", + "-0.001 * IIYIIIZIYIIIYIIIIZIY\n", + "-0.001 * IIXIIIZIXIIIXIIIIZIX\n", + "-0.001 * IIYIIIZIYIIIXIIIIZIX\n", + "-0.004 * IYIIIIZIXIIIIZZZZIZY\n", + "+0.004 * IXIIIIZIYIIIIZZZZIZY\n", + "+0.004 * IYZZZZZZYIIIIIIIIIIX\n", + "+0.004 * IXZZZZZZXIIIIIIIIIIX\n", + "-0.005 * IYIIIIZIXIIIIZXIIZIY\n", + "+0.005 * IXIIIIZIYIIIIZXIIZIY\n", + "+0.005 * IYIIIIZIXIIIIZYIIZIX\n", + "-0.005 * IXIIIIZIYIIIIZYIIZIX\n", + "-0.000 * IYIIIIZIXIIIIXIIIZIY\n", + "+0.000 * IXIIIIZIYIIIIXIIIZIY\n", + "+0.000 * IYIIIIZIXIIIIYIIIZIX\n", + "-0.000 * IXIIIIZIYIIIIYIIIZIX\n", + "+0.000 * YZIIIIZIXIIIIZZZXZIY\n", + "-0.000 * XZIIIIZIYIIIIZZZXZIY\n", + "-0.000 * YZIIIIZIXIIIIZZZYZIX\n", + "+0.000 * XZIIIIZIYIIIIZZZYZIX\n", + "+0.002 * YZIIIIZIXIIIIZZXIZIY\n", + "-0.002 * XZIIIIZIYIIIIZZXIZIY\n", + "-0.002 * YZIIIIZIXIIIIZZYIZIX\n", + "+0.002 * XZIIIIZIYIIIIZZYIZIX\n", + "+0.110 * IIIIIIIZIIIIIIIIIIIZ\n", + "-0.006 * IIZZZZIIZIIIYIIIIZIY\n", + "-0.006 * IIZZZZIIZIIIXIIIIZIX\n", + "-0.006 * IIZZZZYXZIIIIZZZXZIY\n", + "+0.006 * IIZZZZXYZIIIIZZZXZIY\n", + "+0.006 * IIZZZZYXZIIIIZZZYZIX\n", + "-0.006 * IIZZZZXYZIIIIZZZYZIX\n", + "+0.000 * IIZZZZYXZIIIIZZXIZIY\n", + "-0.000 * IIZZZZXYZIIIIZZXIZIY\n", + "-0.000 * IIZZZZYXZIIIIZZYIZIX\n", + "+0.000 * IIZZZZXYZIIIIZZYIZIX\n", + "-0.048 * IIZZZXZXZIIIIZZZZYIY\n", + "-0.048 * IIZZZYZYZIIIIZZZZYIY\n", + "-0.048 * IIZZZXZXZIIIIZZZZXIX\n", + "-0.048 * IIZZZYZYZIIIIZZZZXIX\n", + "-0.004 * IIZZZXZXZIIYZIIIIZIY\n", + "-0.004 * IIZZZYZYZIIYZIIIIZIY\n", + "-0.004 * IIZZZXZXZIIXZIIIIZIX\n", + "-0.004 * IIZZZYZYZIIXZIIIIZIX\n", + "+0.002 * IIZZXIZXZIIIIZZZZYIY\n", + "+0.002 * IIZZYIZYZIIIIZZZZYIY\n", + "+0.002 * IIZZXIZXZIIIIZZZZXIX\n", + "+0.002 * IIZZYIZYZIIIIZZZZXIX\n", + "+0.000 * IIZZXIZXZIIYZIIIIZIY\n", + "+0.000 * IIZZYIZYZIIYZIIIIZIY\n", + "+0.000 * IIZZXIZXZIIXZIIIIZIX\n", + "+0.000 * IIZZYIZYZIIXZIIIIZIX\n", + "-0.000 * IIIYZZZYIIIIIIIIIIIZ\n", + "-0.000 * IIIXZZZXIIIIIIIIIIIZ\n", + "+0.001 * IIZXIIZXZIIIYIIIIZIY\n", + "+0.001 * IIZYIIZYZIIIYIIIIZIY\n", + "+0.001 * IIZXIIZXZIIIXIIIIZIX\n", + "+0.001 * IIZYIIZYZIIIXIIIIZIX\n", + "+0.009 * IIYZZZZYIIIIIIIIIIIZ\n", + "+0.009 * IIXZZZZXIIIIIIIIIIIZ\n", + "-0.016 * IIXIIIZXZIIIYIIIIZIY\n", + "-0.016 * IIYIIIZYZIIIYIIIIZIY\n", + "-0.016 * IIXIIIZXZIIIXIIIIZIX\n", + "-0.016 * IIYIIIZYZIIIXIIIIZIX\n", + "-0.004 * IYIIIIZXZIIIIZZZZIXY\n", + "+0.004 * IXIIIIZYZIIIIZZZZIXY\n", + "+0.004 * IYIIIIZXZIIIIZZZZIYX\n", + "-0.004 * IXIIIIZYZIIIIZZZZIYX\n", + "+0.000 * IYIIIIZXZIIIIZXIIZIY\n", + "-0.000 * IXIIIIZYZIIIIZXIIZIY\n", + "-0.000 * IYIIIIZXZIIIIZYIIZIX\n", + "+0.000 * IXIIIIZYZIIIIZYIIZIX\n", + "-0.005 * IYIIIIZXZIIIIXIIIZIY\n", + "+0.005 * IXIIIIZYZIIIIXIIIZIY\n", + "+0.005 * IYIIIIZXZIIIIYIIIZIX\n", + "-0.005 * IXIIIIZYZIIIIYIIIZIX\n", + "+0.002 * YZIIIIZXZIIIIZZZXZIY\n", + "-0.002 * XZIIIIZYZIIIIZZZXZIY\n", + "-0.002 * YZIIIIZXZIIIIZZZYZIX\n", + "+0.002 * XZIIIIZYZIIIIZZZYZIX\n", + "-0.000 * YZIIIIZXZIIIIZZXIZIY\n", + "+0.000 * XZIIIIZYZIIIIZZXIZIY\n", + "+0.000 * YZIIIIZXZIIIIZZYIZIX\n", + "-0.000 * XZIIIIZYZIIIIZZYIZIX\n", + "+0.128 * IIIIIIZIIIIIIIIIIIIZ\n", + "+0.013 * IIZZZZZZZIIIYIIIIZIY\n", + "+0.013 * IIZZZZZZZIIIXIIIIZIX\n", + "-0.000 * IIZZZXYZZIIIIZZZZIZY\n", + "+0.000 * IIZZZYXZZIIIIZZZZIZY\n", + "+0.000 * IIIIIYYIIIIIIIIIIIIX\n", + "+0.000 * IIIIIXXIIIIIIIIIIIIX\n", + "-0.006 * IIZZZXYZZIIIIZZZZIXY\n", + "+0.006 * IIZZZYXZZIIIIZZZZIXY\n", + "+0.006 * IIZZZXYZZIIIIZZZZIYX\n", + "-0.006 * IIZZZYXZZIIIIZZZZIYX\n", + "-0.000 * IIZZZXYZZIIIIZXIIZIY\n", + "+0.000 * IIZZZYXZZIIIIZXIIZIY\n", + "+0.000 * IIZZZXYZZIIIIZYIIZIX\n", + "-0.000 * IIZZZYXZZIIIIZYIIZIX\n", + "+0.006 * IIZZZXYZZIIIIXIIIZIY\n", + "-0.006 * IIZZZYXZZIIIIXIIIZIY\n", + "-0.006 * IIZZZXYZZIIIIYIIIZIX\n", + "+0.006 * IIZZZYXZZIIIIYIIIZIX\n", + "-0.006 * IIZZXIYZZIIIIZZZZIZY\n", + "+0.006 * IIZZYIXZZIIIIZZZZIZY\n", + "+0.006 * IIIIYZYIIIIIIIIIIIIX\n", + "+0.006 * IIIIXZXIIIIIIIIIIIIX\n", + "+0.000 * IIZZXIYZZIIIIZZZZIXY\n", + "-0.000 * IIZZYIXZZIIIIZZZZIXY\n", + "-0.000 * IIZZXIYZZIIIIZZZZIYX\n", + "+0.000 * IIZZYIXZZIIIIZZZZIYX\n", + "+0.006 * IIZZXIYZZIIIIZXIIZIY\n", + "-0.006 * IIZZYIXZZIIIIZXIIZIY\n", + "-0.006 * IIZZXIYZZIIIIZYIIZIX\n", + "+0.006 * IIZZYIXZZIIIIZYIIZIX\n", + "+0.000 * IIZZXIYZZIIIIXIIIZIY\n", + "-0.000 * IIZZYIXZZIIIIXIIIZIY\n", + "-0.000 * IIZZXIYZZIIIIYIIIZIX\n", + "+0.000 * IIZZYIXZZIIIIYIIIZIX\n", + "-0.000 * IIZXIIYZZIIIIZZZXZIY\n", + "+0.000 * IIZYIIXZZIIIIZZZXZIY\n", + "+0.000 * IIZXIIYZZIIIIZZZYZIX\n", + "-0.000 * IIZYIIXZZIIIIZZZYZIX\n", + "+0.006 * IIZXIIYZZIIIIZZXIZIY\n", + "-0.006 * IIZYIIXZZIIIIZZXIZIY\n", + "-0.006 * IIZXIIYZZIIIIZZYIZIX\n", + "+0.006 * IIZYIIXZZIIIIZZYIZIX\n", + "+0.006 * IIXIIIYZZIIIIZZZXZIY\n", + "-0.006 * IIYIIIXZZIIIIZZZXZIY\n", + "-0.006 * IIXIIIYZZIIIIZZZYZIX\n", + "+0.006 * IIYIIIXZZIIIIZZZYZIX\n", + "+0.000 * IIXIIIYZZIIIIZZXIZIY\n", + "-0.000 * IIYIIIXZZIIIIZZXIZIY\n", + "-0.000 * IIXIIIYZZIIIIZZYIZIX\n", + "+0.000 * IIYIIIXZZIIIIZZYIZIX\n", + "-0.031 * IYIIIIYZZIIIIZZZZYIY\n", + "-0.031 * IXIIIIXZZIIIIZZZZYIY\n", + "-0.031 * IYIIIIYZZIIIIZZZZXIX\n", + "-0.031 * IXIIIIXZZIIIIZZZZXIX\n", + "-0.008 * IYIIIIYZZIIYZIIIIZIY\n", + "-0.008 * IXIIIIXZZIIYZIIIIZIY\n", + "-0.008 * IYIIIIYZZIIXZIIIIZIX\n", + "-0.008 * IXIIIIXZZIIXZIIIIZIX\n", + "-0.006 * YZZZZZYIIIIIIIIIIIIZ\n", + "-0.006 * XZZZZZXIIIIIIIIIIIIZ\n", + "-0.014 * YZIIIIYZZIIIYIIIIZIY\n", + "-0.014 * XZIIIIXZZIIIYIIIIZIY\n", + "-0.014 * YZIIIIYZZIIIXIIIIZIX\n", + "-0.014 * XZIIIIXZZIIIXIIIIZIX\n", + "+0.118 * IIIIIZIIIIIIIIIIIIIZ\n", + "+0.008 * IIZZZIIZZIIIYIIIIZIY\n", + "+0.008 * IIZZZIIZZIIIXIIIIZIX\n", + "-0.001 * IIZXIXIZZIIIIZZZZYIY\n", + "-0.001 * IIZYIYIZZIIIIZZZZYIY\n", + "-0.001 * IIZXIXIZZIIIIZZZZXIX\n", + "-0.001 * IIZYIYIZZIIIIZZZZXIX\n", + "-0.000 * IIZXIXIZZIIYZIIIIZIY\n", + "-0.000 * IIZYIYIZZIIYZIIIIZIY\n", + "-0.000 * IIZXIXIZZIIXZIIIIZIX\n", + "-0.000 * IIZYIYIZZIIXZIIIIZIX\n", + "+0.042 * IIXIIXIZZIIIIZZZZYIY\n", + "+0.042 * IIYIIYIZZIIIIZZZZYIY\n", + "+0.042 * IIXIIXIZZIIIIZZZZXIX\n", + "+0.042 * IIYIIYIZZIIIIZZZZXIX\n", + "+0.006 * IIXIIXIZZIIYZIIIIZIY\n", + "+0.006 * IIYIIYIZZIIYZIIIIZIY\n", + "+0.006 * IIXIIXIZZIIXZIIIIZIX\n", + "+0.006 * IIYIIYIZZIIXZIIIIZIX\n", + "-0.001 * IYIIIXIZZIIIIZZZXZIY\n", + "+0.001 * IXIIIYIZZIIIIZZZXZIY\n", + "+0.001 * IYIIIXIZZIIIIZZZYZIX\n", + "-0.001 * IXIIIYIZZIIIIZZZYZIX\n", + "+0.000 * YZIIIXIZZIIIIZZZZIZY\n", + "-0.000 * XZIIIYIZZIIIIZZZZIZY\n", + "-0.000 * YZZZZYIIIIIIIIIIIIIX\n", + "-0.000 * XZZZZXIIIIIIIIIIIIIX\n", + "+0.001 * YZIIIXIZZIIIIZZZZIXY\n", + "-0.001 * XZIIIYIZZIIIIZZZZIXY\n", + "-0.001 * YZIIIXIZZIIIIZZZZIYX\n", + "+0.001 * XZIIIYIZZIIIIZZZZIYX\n", + "+0.000 * YZIIIXIZZIIIIZXIIZIY\n", + "-0.000 * XZIIIYIZZIIIIZXIIZIY\n", + "-0.000 * YZIIIXIZZIIIIZYIIZIX\n", + "+0.000 * XZIIIYIZZIIIIZYIIZIX\n", + "-0.002 * YZIIIXIZZIIIIXIIIZIY\n", + "+0.002 * XZIIIYIZZIIIIXIIIZIY\n", + "+0.002 * YZIIIXIZZIIIIYIIIZIX\n", + "-0.002 * XZIIIYIZZIIIIYIIIZIX\n", + "+0.118 * IIIIZIIIIIIIIIIIIIIZ\n", + "+0.008 * IIZZIZIZZIIIYIIIIZIY\n", + "+0.008 * IIZZIZIZZIIIXIIIIZIX\n", + "+0.042 * IIZXXZIZZIIIIZZZZYIY\n", + "+0.042 * IIZYYZIZZIIIIZZZZYIY\n", + "+0.042 * IIZXXZIZZIIIIZZZZXIX\n", + "+0.042 * IIZYYZIZZIIIIZZZZXIX\n", + "+0.006 * IIZXXZIZZIIYZIIIIZIY\n", + "+0.006 * IIZYYZIZZIIYZIIIIZIY\n", + "+0.006 * IIZXXZIZZIIXZIIIIZIX\n", + "+0.006 * IIZYYZIZZIIXZIIIIZIX\n", + "+0.001 * IIXIXZIZZIIIIZZZZYIY\n", + "+0.001 * IIYIYZIZZIIIIZZZZYIY\n", + "+0.001 * IIXIXZIZZIIIIZZZZXIX\n", + "+0.001 * IIYIYZIZZIIIIZZZZXIX\n", + "+0.000 * IIXIXZIZZIIYZIIIIZIY\n", + "+0.000 * IIYIYZIZZIIYZIIIIZIY\n", + "+0.000 * IIXIXZIZZIIXZIIIIZIX\n", + "+0.000 * IIYIYZIZZIIXZIIIIZIX\n", + "-0.001 * IYIIXZIZZIIIIZZXIZIY\n", + "+0.001 * IXIIYZIZZIIIIZZXIZIY\n", + "+0.001 * IYIIXZIZZIIIIZZYIZIX\n", + "-0.001 * IXIIYZIZZIIIIZZYIZIX\n", + "+0.001 * YZIIXZIZZIIIIZZZZIZY\n", + "-0.001 * XZIIYZIZZIIIIZZZZIZY\n", + "-0.001 * YZZZYIIIIIIIIIIIIIIX\n", + "-0.001 * XZZZXIIIIIIIIIIIIIIX\n", + "-0.000 * YZIIXZIZZIIIIZZZZIXY\n", + "+0.000 * XZIIYZIZZIIIIZZZZIXY\n", + "+0.000 * YZIIXZIZZIIIIZZZZIYX\n", + "-0.000 * XZIIYZIZZIIIIZZZZIYX\n", + "-0.002 * YZIIXZIZZIIIIZXIIZIY\n", + "+0.002 * XZIIYZIZZIIIIZXIIZIY\n", + "+0.002 * YZIIXZIZZIIIIZYIIZIX\n", + "-0.002 * XZIIYZIZZIIIIZYIIZIX\n", + "-0.000 * YZIIXZIZZIIIIXIIIZIY\n", + "+0.000 * XZIIYZIZZIIIIXIIIZIY\n", + "+0.000 * YZIIXZIZZIIIIYIIIZIX\n", + "-0.000 * XZIIYZIZZIIIIYIIIZIX\n", + "+0.113 * IIIZIIIIIIIIIIIIIIIZ\n", + "-0.009 * IIZIZZIZZIIIYIIIIZIY\n", + "-0.009 * IIZIZZIZZIIIXIIIIZIX\n", + "-0.006 * IYIXZZIZZIIIIZZZZIZY\n", + "+0.006 * IXIYZZIZZIIIIZZZZIZY\n", + "+0.006 * IYZYIIIIIIIIIIIIIIIX\n", + "+0.006 * IXZXIIIIIIIIIIIIIIIX\n", + "+0.000 * IYIXZZIZZIIIIZZZZIXY\n", + "-0.000 * IXIYZZIZZIIIIZZZZIXY\n", + "-0.000 * IYIXZZIZZIIIIZZZZIYX\n", + "+0.000 * IXIYZZIZZIIIIZZZZIYX\n", + "-0.009 * IYIXZZIZZIIIIZXIIZIY\n", + "+0.009 * IXIYZZIZZIIIIZXIIZIY\n", + "+0.009 * IYIXZZIZZIIIIZYIIZIX\n", + "-0.009 * IXIYZZIZZIIIIZYIIZIX\n", + "+0.000 * YZIXZZIZZIIIIZZZXZIY\n", + "-0.000 * XZIYZZIZZIIIIZZZXZIY\n", + "-0.000 * YZIXZZIZZIIIIZZZYZIX\n", + "+0.000 * XZIYZZIZZIIIIZZZYZIX\n", + "-0.001 * YZIXZZIZZIIIIZZXIZIY\n", + "+0.001 * XZIYZZIZZIIIIZZXIZIY\n", + "+0.001 * YZIXZZIZZIIIIZZYIZIX\n", + "-0.001 * XZIYZZIZZIIIIZZYIZIX\n", + "+0.113 * IIZIIIIIIIIIIIIIIIIZ\n", + "-0.009 * IIIZZZIZZIIIYIIIIZIY\n", + "-0.009 * IIIZZZIZZIIIXIIIIZIX\n", + "-0.000 * IYXZZZIZZIIIIZZZZIZY\n", + "+0.000 * IXYZZZIZZIIIIZZZZIZY\n", + "+0.000 * IYYIIIIIIIIIIIIIIIIX\n", + "+0.000 * IXXIIIIIIIIIIIIIIIIX\n", + "-0.006 * IYXZZZIZZIIIIZZZZIXY\n", + "+0.006 * IXYZZZIZZIIIIZZZZIXY\n", + "+0.006 * IYXZZZIZZIIIIZZZZIYX\n", + "-0.006 * IXYZZZIZZIIIIZZZZIYX\n", + "-0.009 * IYXZZZIZZIIIIXIIIZIY\n", + "+0.009 * IXYZZZIZZIIIIXIIIZIY\n", + "+0.009 * IYXZZZIZZIIIIYIIIZIX\n", + "-0.009 * IXYZZZIZZIIIIYIIIZIX\n", + "-0.001 * YZXZZZIZZIIIIZZZXZIY\n", + "+0.001 * XZYZZZIZZIIIIZZZXZIY\n", + "+0.001 * YZXZZZIZZIIIIZZZYZIX\n", + "-0.001 * XZYZZZIZZIIIIZZZYZIX\n", + "-0.000 * YZXZZZIZZIIIIZZXIZIY\n", + "+0.000 * XZYZZZIZZIIIIZZXIZIY\n", + "+0.000 * YZXZZZIZZIIIIZZYIZIX\n", + "-0.000 * XZYZZZIZZIIIIZZYIZIX\n", + "+0.115 * IZIIIIIIIIIIIIIIIIIZ\n", + "-0.005 * IZZZZZIZZIIIYIIIIZIY\n", + "-0.005 * IZZZZZIZZIIIXIIIIZIX\n", + "-0.040 * YYZZZZIZZIIIIZZZZYIY\n", + "-0.040 * XXZZZZIZZIIIIZZZZYIY\n", + "-0.040 * YYZZZZIZZIIIIZZZZXIX\n", + "-0.040 * XXZZZZIZZIIIIZZZZXIX\n", + "-0.002 * YYZZZZIZZIIYZIIIIZIY\n", + "-0.002 * XXZZZZIZZIIYZIIIIZIY\n", + "-0.002 * YYZZZZIZZIIXZIIIIZIX\n", + "-0.002 * XXZZZZIZZIIXZIIIIZIX\n", + "+0.120 * ZIIIIIIIIIIIIIIIIIIZ\n", + "-0.009 * ZIZZZZIZZIIIYIIIIZIY\n", + "-0.009 * ZIZZZZIZZIIIXIIIIZIX\n", + "+0.110 * IIZZZZIZZIIIIZZZZIII\n", + "-0.000 * IIZZZZIZZIIIIZXIIZXI\n", + "-0.000 * IIZZZZIZZIIIIZYIIZYI\n", + "+0.003 * IIZZZZIZZIIIIXIIIZXI\n", + "+0.003 * IIZZZZIZZIIIIYIIIZYI\n", + "+0.106 * IIZZZZIZZIIIIZZZZZZI\n", + "+0.006 * IIZZZZIZZIIYZIIIIYZI\n", + "+0.006 * IIZZZZIZZIIXZIIIIXZI\n", + "+0.108 * IIZZZZIZZIIIIZZZIIZI\n", + "-0.001 * IIZZZZIZZIIIIZZXXIZI\n", + "-0.001 * IIZZZZIZZIIIIZZYYIZI\n", + "+0.071 * IIZZZZIZZIIIIZZIZIZI\n", + "+0.097 * IIZZZZIZZIIIIZIZZIZI\n", + "-0.001 * IIZZZZIZZIIIIXXZZIZI\n", + "-0.001 * IIZZZZIZZIIIIYYZZIZI\n", + "+0.114 * IIZZZZIZZIIIIIZZZIZI\n", + "+0.115 * IIZZZZIZZIIIZZZZZIZI\n", + "+0.127 * IIZZZZIZZIIZIZZZZIZI\n", + "+0.003 * IIZZZZIZZIIIIZXIIZZI\n", + "-0.003 * IIIIIIIIIIIIIIXZZZII\n", + "+0.000 * IIZZZZIZZIIIIXIIIZZI\n", + "-0.000 * IIIIIIIIIIIIIXZZZZII\n", + "-0.001 * IIZZZZIZZIIIIZZZIIXI\n", + "+0.001 * IIIIIIIIIIIIIIIIZIXI\n", + "-0.038 * IIZZZZIZZIIIIZZXYIYI\n", + "-0.038 * IIZZZZIZZIIIIZZXXIXI\n", + "+0.000 * IIZZZZIZZIIIIZZYYIXI\n", + "+0.000 * IIIIIIIIIIIIIIIYYIXI\n", + "-0.038 * IIIIIIIIIIIIIIIXXIXI\n", + "-0.038 * IIIIIIIIIIIIIIIXYIYI\n", + "+0.001 * IIZZZZIZZIIIIZZIZIXI\n", + "-0.001 * IIIIIIIIIIIIIIIZIIXI\n", + "+0.001 * IIZZZZIZZIIIIZIZZIXI\n", + "-0.001 * IIIIIIIIIIIIIIZIIIXI\n", + "+0.019 * IIZZZZIZZIIIIXYZZIYI\n", + "+0.001 * IIZZZZIZZIIIIXXZZIXI\n", + "-0.018 * IIZZZZIZZIIIIYYZZIXI\n", + "-0.018 * IIIIIIIIIIIIIYYIIIXI\n", + "+0.001 * IIIIIIIIIIIIIXXIIIXI\n", + "+0.019 * IIIIIIIIIIIIIXYIIIYI\n", + "-0.001 * IIZZZZIZZIIIIIZZZIXI\n", + "+0.001 * IIIIIIIIIIIIIZIIIIXI\n", + "-0.008 * IIZZZZIZZIIIIZXIIIII\n", + "+0.008 * IIIIIIIIIIIIIIXZZIZI\n", + "-0.000 * IIZZZZIZZIIIIXIIIIII\n", + "+0.000 * IIIIIIIIIIIIIXZZZIZI\n", + "-0.001 * IIZZZZIZZIIIYIIIYXII\n", + "+0.000 * IIZZZZIZZIIIYIIIXYII\n", + "+0.001 * IIZZZZIZZIIIXIIIYYII\n", + "+0.001 * IIIIIIIIIIIIYZZZYXZI\n", + "-0.000 * IIIIIIIIIIIIXZZZXXZI\n", + "-0.001 * IIIIIIIIIIIIXZZZYYZI\n", + "-0.021 * IIZZZZIZZIIIYIIYZXII\n", + "+0.001 * IIZZZZIZZIIIYIIXZYII\n", + "+0.020 * IIZZZZIZZIIIXIIYZYII\n", + "+0.020 * IIIIIIIIIIIIYZZYIXZI\n", + "-0.001 * IIIIIIIIIIIIXZZXIXZI\n", + "-0.021 * IIIIIIIIIIIIXZZYIYZI\n", + "-0.015 * IIZZZZIZZIIYZIYZZXII\n", + "+0.001 * IIZZZZIZZIIYZIXZZYII\n", + "+0.014 * IIZZZZIZZIIXZIYZZYII\n", + "+0.014 * IIIIIIIIIIIYZZYIIXZI\n", + "-0.001 * IIIIIIIIIIIXZZXIIXZI\n", + "-0.015 * IIIIIIIIIIIXZZYIIYZI\n", + "-0.001 * IIZZZZIZZIIYZYZZZXII\n", + "+0.000 * IIZZZZIZZIIYZXZZZYII\n", + "+0.001 * IIZZZZIZZIIXZYZZZYII\n", + "+0.001 * IIIIIIIIIIIYZYIIIXZI\n", + "-0.000 * IIIIIIIIIIIXZXIIIXZI\n", + "-0.001 * IIIIIIIIIIIXZYIIIYZI\n", + "-0.013 * IIZZZZIZZIIIIZXIZZII\n", + "+0.013 * IIIIIIIIIIIIIIXZIZZI\n", + "+0.000 * IIZZZZIZZIIIIXIIZZII\n", + "-0.000 * IIIIIIIIIIIIIXZZIZZI\n", + "+0.001 * IIZZZZIZZIIIIZXYYZII\n", + "-0.001 * IIZZZZIZZIIIIZXXXZII\n", + "-0.002 * IIZZZZIZZIIIIZYYXZII\n", + "-0.002 * IIIIIIIIIIIIIIYYXZZI\n", + "-0.001 * IIIIIIIIIIIIIIXXXZZI\n", + "+0.001 * IIIIIIIIIIIIIIXYYZZI\n", + "-0.033 * IIZZZZIZZIIIIXIYYZII\n", + "-0.000 * IIZZZZIZZIIIIXIXXZII\n", + "+0.033 * IIZZZZIZZIIIIYIYXZII\n", + "+0.033 * IIIIIIIIIIIIIYZYXZZI\n", + "-0.000 * IIIIIIIIIIIIIXZXXZZI\n", + "-0.033 * IIIIIIIIIIIIIXZYYZZI\n", + "-0.000 * IIZZZZIZZIIYXZZZYZII\n", + "+0.001 * IIZZZZIZZIIYYZZZXZII\n", + "+0.001 * IIZZZZIZZIIXXZZZXZII\n", + "-0.001 * IIIIIIIIIIIYYIIIXZZI\n", + "-0.001 * IIIIIIIIIIIXXIIIXZZI\n", + "-0.000 * IIIIIIIIIIIXYIIIYZZI\n", + "+0.021 * IIZZZZIZZIIIIZXZIZII\n", + "-0.021 * IIIIIIIIIIIIIIXIZZZI\n", + "-0.000 * IIZZZZIZZIIIIXIZIZII\n", + "+0.000 * IIIIIIIIIIIIIXZIZZZI\n", + "-0.000 * IIZZZZIZZIIYXZZYIZII\n", + "+0.033 * IIZZZZIZZIIYYZZXIZII\n", + "+0.033 * IIZZZZIZZIIXXZZXIZII\n", + "-0.033 * IIIIIIIIIIIYYIIXZZZI\n", + "-0.033 * IIIIIIIIIIIXXIIXZZZI\n", + "-0.000 * IIIIIIIIIIIXYIIYZZZI\n", + "+0.000 * IIZZZZIZZIIIIXZIIZII\n", + "-0.000 * IIIIIIIIIIIIIXIZZZZI\n", + "+0.007 * IIZZZZIZZIIIIIXIIZII\n", + "-0.007 * IIIIIIIIIIIIIZXZZZZI\n", + "+0.000 * IIZZZZIZZIIIZZXIIZII\n", + "-0.000 * IIIIIIIIIIIIZIXZZZZI\n", + "+0.011 * IIZZZZIZZIIZIZXIIZII\n", + "-0.011 * IIIIIIIIIIIZIIXZZZZI\n", + "+0.000 * IIZZZZIZZIIIZXIIIZII\n", + "-0.000 * IIIIIIIIIIIIZXZZZZZI\n", + "+0.001 * IIZZZZIZZIIZIXIIIZII\n", + "-0.001 * IIIIIIIIIIIZIXZZZZZI\n", + "+0.123 * ZZIIIIZIIZZIIZZZZIZI\n", + "+0.001 * ZZIIIIZIIZZIIZXIIZII\n", + "-0.001 * ZZZZZZZZZZZIIIXZZZZI\n", + "+0.000 * ZZIIIIZIIZZIIXIIIZII\n", + "-0.000 * ZZZZZZZZZZZIIXZZZZZI\n", + "+0.002 * ZZIIIIZIIZXIIZZZXZII\n", + "-0.002 * IIZZZZIZZIXIIZZZXZII\n", + "-0.002 * ZZZZZZZZZZXIIIIIXZZI\n", + "+0.002 * IIIIIIIIIIXIIIIIXZZI\n", + "+0.047 * ZZIIIIZIIZXIIZZXIZII\n", + "-0.047 * IIZZZZIZZIXIIZZXIZII\n", + "-0.047 * ZZZZZZZZZZXIIIIXZZZI\n", + "+0.047 * IIIIIIIIIIXIIIIXZZZI\n", + "+0.008 * ZZIIIIZIIXIIIZZZZIZI\n", + "-0.008 * IIZZZZIZZXZIIZZZZIZI\n", + "+0.017 * ZZIIIIZIIXIIIZXIIZII\n", + "-0.017 * IIZZZZIZZXZIIZXIIZII\n", + "-0.017 * ZZZZZZZZZXIIIIXZZZZI\n", + "+0.017 * IIIIIIIIIXZIIIXZZZZI\n", + "+0.001 * ZZIIIIZIIXIIIXIIIZII\n", + "-0.001 * IIZZZZIZZXZIIXIIIZII\n", + "-0.001 * ZZZZZZZZZXIIIXZZZZZI\n", + "+0.001 * IIIIIIIIIXZIIXZZZZZI\n", + "-0.003 * ZZIIIIZIYIIIYIIIIZII\n", + "+0.003 * IIZZZZIZYZZIYIIIIZII\n", + "-0.003 * ZZZZZZZZXIIIXZZZZZZI\n", + "+0.003 * IIIIIIIIXZZIXZZZZZZI\n", + "-0.000 * ZZIIIIXZZIIIIZZZXZII\n", + "+0.000 * IIZZZZXIIZZIIZZZXZII\n", + "+0.000 * ZZZZZZXIIIIIIIIIXZZI\n", + "-0.000 * IIIIIIXZZZZIIIIIXZZI\n", + "-0.004 * ZZIIIIXZZIIIIZZXIZII\n", + "+0.004 * IIZZZZXIIZZIIZZXIZII\n", + "+0.004 * ZZZZZZXIIIIIIIIXZZZI\n", + "-0.004 * IIIIIIXZZZZIIIIXZZZI\n", + "+0.000 * ZZIIIYIZZIIIIZZZZYII\n", + "-0.000 * IIZZZYZIIZZIIZZZZYII\n", + "+0.000 * ZZZZZXIIIIIIIIIIIXZI\n", + "-0.000 * IIIIIXZZZZZIIIIIIXZI\n", + "-0.000 * ZZIIIYIZZIIYZIIIIZII\n", + "+0.000 * IIZZZYZIIZZYZIIIIZII\n", + "-0.000 * ZZZZZXIIIIIXZZZZZZZI\n", + "+0.000 * IIIIIXZZZZZXZZZZZZZI\n", + "+0.003 * ZZIIYZIZZIIIIZZZZYII\n", + "-0.003 * IIZZYIZIIZZIIZZZZYII\n", + "+0.003 * ZZZZXIIIIIIIIIIIIXZI\n", + "-0.003 * IIIIXZZZZZZIIIIIIXZI\n", + "-0.004 * ZZIIYZIZZIIYZIIIIZII\n", + "+0.004 * IIZZYIZIIZZYZIIIIZII\n", + "-0.004 * ZZZZXIIIIIIXZZZZZZZI\n", + "+0.004 * IIIIXZZZZZZXZZZZZZZI\n", + "-0.007 * ZZIYZZIZZIIIYIIIIZII\n", + "+0.007 * IIZYIIZIIZZIYIIIIZII\n", + "-0.007 * ZZZXIIIIIIIIXZZZZZZI\n", + "+0.007 * IIIXZZZZZZZIXZZZZZZI\n", + "-0.000 * ZZYZZZIZZIIIYIIIIZII\n", + "+0.000 * IIYIIIZIIZZIYIIIIZII\n", + "-0.000 * ZZXIIIIIIIIIXZZZZZZI\n", + "+0.000 * IIXZZZZZZZZIXZZZZZZI\n", + "-0.006 * ZXZZZZIZZIIIIZZZZIZI\n", + "+0.006 * IXIIIIZIIZZIIZZZZIZI\n", + "+0.014 * ZXZZZZIZZIIIIZXIIZII\n", + "-0.014 * IXIIIIZIIZZIIZXIIZII\n", + "-0.014 * ZXIIIIIIIIIIIIXZZZZI\n", + "+0.014 * IXZZZZZZZZZIIIXZZZZI\n", + "+0.001 * ZXZZZZIZZIIIIXIIIZII\n", + "-0.001 * IXIIIIZIIZZIIXIIIZII\n", + "-0.001 * ZXIIIIIIIIIIIXZZZZZI\n", + "+0.001 * IXZZZZZZZZZIIXZZZZZI\n", + "+0.000 * XIZZZZIZZIIIIZZZXZII\n", + "-0.000 * XZIIIIZIIZZIIZZZXZII\n", + "-0.000 * XIIIIIIIIIIIIIIIXZZI\n", + "+0.000 * XZZZZZZZZZZIIIIIXZZI\n", + "+0.014 * XIZZZZIZZIIIIZZXIZII\n", + "-0.014 * XZIIIIZIIZZIIZZXIZII\n", + "-0.014 * XIIIIIIIIIIIIIIXZZZI\n", + "+0.014 * XZZZZZZZZZZIIIIXZZZI\n", + "+0.123 * IIZZZZIZZIZIIZZZZIZI\n", + "-0.004 * IIZZZZIZZIZIIZXIIZII\n", + "+0.004 * IIIIIIIIIIZIIIXZZZZI\n", + "-0.000 * IIZZZZIZZIZIIXIIIZII\n", + "+0.000 * IIIIIIIIIIZIIXZZZZZI\n", + "+0.001 * IIZZZZIZZYYIIZZZXZII\n", + "+0.001 * IIZZZZIZZXXIIZZZXZII\n", + "-0.001 * IIIIIIIIIYYIIIIIXZZI\n", + "-0.001 * IIIIIIIIIXXIIIIIXZZI\n", + "+0.015 * IIZZZZIZZYYIIZZXIZII\n", + "+0.015 * IIZZZZIZZXXIIZZXIZII\n", + "-0.015 * IIIIIIIIIYYIIIIXZZZI\n", + "-0.015 * IIIIIIIIIXXIIIIXZZZI\n", + "+0.001 * IIZZZZIZXZYIIZZZZYII\n", + "-0.001 * IIZZZZIZYZXIIZZZZYII\n", + "-0.001 * IIIIIIIIYZYIIIIIIXZI\n", + "-0.001 * IIIIIIIIXZXIIIIIIXZI\n", + "-0.002 * IIZZZZIZXZYYZIIIIZII\n", + "+0.002 * IIZZZZIZYZXYZIIIIZII\n", + "+0.002 * IIIIIIIIYZYXZZZZZZZI\n", + "+0.002 * IIIIIIIIXZXXZZZZZZZI\n", + "-0.011 * IIZZZZYIIZYIIZZZZIZI\n", + "-0.011 * IIZZZZXIIZXIIZZZZIZI\n", + "-0.014 * IIZZZZYIIZYIIZXIIZII\n", + "-0.014 * IIZZZZXIIZXIIZXIIZII\n", + "+0.014 * IIIIIIYZZZYIIIXZZZZI\n", + "+0.014 * IIIIIIXZZZXIIIXZZZZI\n", + "-0.001 * IIZZZZYIIZYIIXIIIZII\n", + "-0.001 * IIZZZZXIIZXIIXIIIZII\n", + "+0.001 * IIIIIIYZZZYIIXZZZZZI\n", + "+0.001 * IIIIIIXZZZXIIXZZZZZI\n", + "+0.000 * IIZZZXZIIZYIYIIIIZII\n", + "-0.000 * IIZZZYZIIZXIYIIIIZII\n", + "-0.000 * IIIIIYZZZZYIXZZZZZZI\n", + "-0.000 * IIIIIXZZZZXIXZZZZZZI\n", + "+0.002 * IIZZXIZIIZYIYIIIIZII\n", + "-0.002 * IIZZYIZIIZXIYIIIIZII\n", + "-0.002 * IIIIYZZZZZYIXZZZZZZI\n", + "-0.002 * IIIIXZZZZZXIXZZZZZZI\n", + "-0.004 * IIZXIIZIIZYIIZZZZYII\n", + "+0.004 * IIZYIIZIIZXIIZZZZYII\n", + "+0.004 * IIIYZZZZZZYIIIIIIXZI\n", + "+0.004 * IIIXZZZZZZXIIIIIIXZI\n", + "+0.004 * IIZXIIZIIZYYZIIIIZII\n", + "-0.004 * IIZYIIZIIZXYZIIIIZII\n", + "-0.004 * IIIYZZZZZZYXZZZZZZZI\n", + "-0.004 * IIIXZZZZZZXXZZZZZZZI\n", + "-0.000 * IIXIIIZIIZYIIZZZZYII\n", + "+0.000 * IIYIIIZIIZXIIZZZZYII\n", + "+0.000 * IIYZZZZZZZYIIIIIIXZI\n", + "+0.000 * IIXZZZZZZZXIIIIIIXZI\n", + "+0.000 * IIXIIIZIIZYYZIIIIZII\n", + "-0.000 * IIYIIIZIIZXYZIIIIZII\n", + "-0.000 * IIYZZZZZZZYXZZZZZZZI\n", + "-0.000 * IIXZZZZZZZXXZZZZZZZI\n", + "+0.001 * IYIIIIZIIZYIIZZZXZII\n", + "+0.001 * IXIIIIZIIZXIIZZZXZII\n", + "-0.001 * IYZZZZZZZZYIIIIIXZZI\n", + "-0.001 * IXZZZZZZZZXIIIIIXZZI\n", + "+0.018 * IYIIIIZIIZYIIZZXIZII\n", + "+0.018 * IXIIIIZIIZXIIZZXIZII\n", + "-0.018 * IYZZZZZZZZYIIIIXZZZI\n", + "-0.018 * IXZZZZZZZZXIIIIXZZZI\n", + "-0.002 * YZIIIIZIIZYIIZZZZIZI\n", + "-0.002 * XZIIIIZIIZXIIZZZZIZI\n", + "+0.015 * YZIIIIZIIZYIIZXIIZII\n", + "+0.015 * XZIIIIZIIZXIIZXIIZII\n", + "-0.015 * YZZZZZZZZZYIIIXZZZZI\n", + "-0.015 * XZZZZZZZZZXIIIXZZZZI\n", + "+0.001 * YZIIIIZIIZYIIXIIIZII\n", + "+0.001 * XZIIIIZIIZXIIXIIIZII\n", + "-0.001 * YZZZZZZZZZYIIXZZZZZI\n", + "-0.001 * XZZZZZZZZZXIIXZZZZZI\n", + "+0.110 * IIZZZZIZZZIIIZZZZIZI\n", + "-0.009 * IIZZZZIZZZIIIZXIIZII\n", + "+0.009 * IIIIIIIIIZIIIIXZZZZI\n", + "-0.000 * IIZZZZIZZZIIIXIIIZII\n", + "+0.000 * IIIIIIIIIZIIIXZZZZZI\n", + "-0.004 * IIZZZZIZXYIIYIIIIZII\n", + "+0.004 * IIZZZZIZYXIIYIIIIZII\n", + "+0.004 * IIIIIIIIYYIIXZZZZZZI\n", + "+0.004 * IIIIIIIIXXIIXZZZZZZI\n", + "-0.002 * IIZZZZYIIYIIIZZZXZII\n", + "-0.002 * IIZZZZXIIXIIIZZZXZII\n", + "+0.002 * IIIIIIYZZYIIIIIIXZZI\n", + "+0.002 * IIIIIIXZZXIIIIIIXZZI\n", + "-0.048 * IIZZZZYIIYIIIZZXIZII\n", + "-0.048 * IIZZZZXIIXIIIZZXIZII\n", + "+0.048 * IIIIIIYZZYIIIIIXZZZI\n", + "+0.048 * IIIIIIXZZXIIIIIXZZZI\n", + "-0.000 * IIZZZXZIIYIIIZZZZYII\n", + "+0.000 * IIZZZYZIIXIIIZZZZYII\n", + "+0.000 * IIIIIYZZZYIIIIIIIXZI\n", + "+0.000 * IIIIIXZZZXIIIIIIIXZI\n", + "+0.000 * IIZZZXZIIYIYZIIIIZII\n", + "-0.000 * IIZZZYZIIXIYZIIIIZII\n", + "-0.000 * IIIIIYZZZYIXZZZZZZZI\n", + "-0.000 * IIIIIXZZZXIXZZZZZZZI\n", + "-0.006 * IIZZXIZIIYIIIZZZZYII\n", + "+0.006 * IIZZYIZIIXIIIZZZZYII\n", + "+0.006 * IIIIYZZZZYIIIIIIIXZI\n", + "+0.006 * IIIIXZZZZXIIIIIIIXZI\n", + "+0.002 * IIZZXIZIIYIYZIIIIZII\n", + "-0.002 * IIZZYIZIIXIYZIIIIZII\n", + "-0.002 * IIIIYZZZZYIXZZZZZZZI\n", + "-0.002 * IIIIXZZZZXIXZZZZZZZI\n", + "-0.005 * IIZXIIZIIYIIYIIIIZII\n", + "+0.005 * IIZYIIZIIXIIYIIIIZII\n", + "+0.005 * IIIYZZZZZYIIXZZZZZZI\n", + "+0.005 * IIIXZZZZZXIIXZZZZZZI\n", + "-0.000 * IIXIIIZIIYIIYIIIIZII\n", + "+0.000 * IIYIIIZIIXIIYIIIIZII\n", + "+0.000 * IIYZZZZZZYIIXZZZZZZI\n", + "+0.000 * IIXZZZZZZXIIXZZZZZZI\n", + "-0.006 * IYIIIIZIIYIIIZZZZIZI\n", + "-0.006 * IXIIIIZIIXIIIZZZZIZI\n", + "-0.016 * IYIIIIZIIYIIIZXIIZII\n", + "-0.016 * IXIIIIZIIXIIIZXIIZII\n", + "+0.016 * IYZZZZZZZYIIIIXZZZZI\n", + "+0.016 * IXZZZZZZZXIIIIXZZZZI\n", + "-0.001 * IYIIIIZIIYIIIXIIIZII\n", + "-0.001 * IXIIIIZIIXIIIXIIIZII\n", + "+0.001 * IYZZZZZZZYIIIXZZZZZI\n", + "+0.001 * IXZZZZZZZXIIIXZZZZZI\n", + "-0.000 * YZIIIIZIIYIIIZZZXZII\n", + "-0.000 * XZIIIIZIIXIIIZZZXZII\n", + "+0.000 * YZZZZZZZZYIIIIIIXZZI\n", + "+0.000 * XZZZZZZZZXIIIIIIXZZI\n", + "-0.004 * YZIIIIZIIYIIIZZXIZII\n", + "-0.004 * XZIIIIZIIXIIIZZXIZII\n", + "+0.004 * YZZZZZZZZYIIIIIXZZZI\n", + "+0.004 * XZZZZZZZZXIIIIIXZZZI\n", + "+0.122 * IIZZZZIZIIIIIZZZZIZI\n", + "+0.004 * IIZZZZIZIIIIIZXIIZII\n", + "-0.004 * IIIIIIIIZIIIIIXZZZZI\n", + "+0.000 * IIZZZZIZIIIIIXIIIZII\n", + "-0.000 * IIIIIIIIZIIIIXZZZZZI\n", + "+0.004 * IIZZZZIXXIIIIZZZZIXI\n", + "+0.004 * IIZZZZIYYIIIIZZZZIXI\n", + "+0.004 * IIIIIIIYYIIIIIIIIIXI\n", + "+0.004 * IIIIIIIXXIIIIIIIIIXI\n", + "-0.000 * IIZZZZIXXIIIIZXIIZII\n", + "-0.000 * IIZZZZIYYIIIIZXIIZII\n", + "-0.000 * IIIIIIIYYIIIIIXZZZZI\n", + "-0.000 * IIIIIIIXXIIIIIXZZZZI\n", + "+0.000 * IIZZZZIXXIIIIXIIIZII\n", + "+0.000 * IIZZZZIYYIIIIXIIIZII\n", + "+0.000 * IIIIIIIYYIIIIXZZZZZI\n", + "+0.000 * IIIIIIIXXIIIIXZZZZZI\n", + "-0.005 * IIZZZZYIXIIIIZZZZYII\n", + "+0.005 * IIZZZZXIYIIIIZZZZYII\n", + "+0.005 * IIIIIIYZYIIIIIIIIXZI\n", + "+0.005 * IIIIIIXZXIIIIIIIIXZI\n", + "+0.002 * IIZZZZYIXIIYZIIIIZII\n", + "-0.002 * IIZZZZXIYIIYZIIIIZII\n", + "-0.002 * IIIIIIYZYIIXZZZZZZZI\n", + "-0.002 * IIIIIIXZXIIXZZZZZZZI\n", + "+0.004 * IIZZZXZIXIIIIZZZXZII\n", + "+0.004 * IIZZZYZIYIIIIZZZXZII\n", + "+0.004 * IIIIIYZZYIIIIIIIXZZI\n", + "+0.004 * IIIIIXZZXIIIIIIIXZZI\n", + "+0.002 * IIZZZXZIXIIIIZZXIZII\n", + "+0.002 * IIZZZYZIYIIIIZZXIZII\n", + "+0.002 * IIIIIYZZYIIIIIIXZZZI\n", + "+0.002 * IIIIIXZZXIIIIIIXZZZI\n", + "+0.002 * IIZZXIZIXIIIIZZZXZII\n", + "+0.002 * IIZZYIZIYIIIIZZZXZII\n", + "+0.002 * IIIIYZZZYIIIIIIIXZZI\n", + "+0.002 * IIIIXZZZXIIIIIIIXZZI\n", + "+0.049 * IIZZXIZIXIIIIZZXIZII\n", + "+0.049 * IIZZYIZIYIIIIZZXIZII\n", + "+0.049 * IIIIYZZZYIIIIIIXZZZI\n", + "+0.049 * IIIIXZZZXIIIIIIXZZZI\n", + "+0.004 * IIZXIIZIXIIIIZZZZIZI\n", + "+0.004 * IIZYIIZIYIIIIZZZZIZI\n", + "-0.000 * IIZXIIZIXIIIIZZZZIXI\n", + "-0.000 * IIZYIIZIYIIIIZZZZIXI\n", + "-0.000 * IIIYZZZZYIIIIIIIIIXI\n", + "-0.000 * IIIXZZZZXIIIIIIIIIXI\n", + "+0.029 * IIZXIIZIXIIIIZXIIZII\n", + "+0.029 * IIZYIIZIYIIIIZXIIZII\n", + "+0.029 * IIIYZZZZYIIIIIXZZZZI\n", + "+0.029 * IIIXZZZZXIIIIIXZZZZI\n", + "+0.001 * IIZXIIZIXIIIIXIIIZII\n", + "+0.001 * IIZYIIZIYIIIIXIIIZII\n", + "+0.001 * IIIYZZZZYIIIIXZZZZZI\n", + "+0.001 * IIIXZZZZXIIIIXZZZZZI\n", + "+0.000 * IIXIIIZIXIIIIZZZZIZI\n", + "+0.000 * IIYIIIZIYIIIIZZZZIZI\n", + "+0.000 * IIXIIIZIXIIIIZZZZIXI\n", + "+0.000 * IIYIIIZIYIIIIZZZZIXI\n", + "+0.000 * IIYZZZZZYIIIIIIIIIXI\n", + "+0.000 * IIXZZZZZXIIIIIIIIIXI\n", + "+0.001 * IIXIIIZIXIIIIZXIIZII\n", + "+0.001 * IIYIIIZIYIIIIZXIIZII\n", + "+0.001 * IIYZZZZZYIIIIIXZZZZI\n", + "+0.001 * IIXZZZZZXIIIIIXZZZZI\n", + "+0.004 * IIXIIIZIXIIIIXIIIZII\n", + "+0.004 * IIYIIIZIYIIIIXIIIZII\n", + "+0.004 * IIYZZZZZYIIIIXZZZZZI\n", + "+0.004 * IIXZZZZZXIIIIXZZZZZI\n", + "-0.008 * IYIIIIZIXIIIYIIIIZII\n", + "+0.008 * IXIIIIZIYIIIYIIIIZII\n", + "+0.008 * IYZZZZZZYIIIXZZZZZZI\n", + "+0.008 * IXZZZZZZXIIIXZZZZZZI\n", + "+0.002 * YZIIIIZIXIIIIZZZZYII\n", + "-0.002 * XZIIIIZIYIIIIZZZZYII\n", + "-0.002 * YZZZZZZZYIIIIIIIIXZI\n", + "-0.002 * XZZZZZZZXIIIIIIIIXZI\n", + "-0.005 * YZIIIIZIXIIYZIIIIZII\n", + "+0.005 * XZIIIIZIYIIYZIIIIZII\n", + "+0.005 * YZZZZZZZYIIXZZZZZZZI\n", + "+0.005 * XZZZZZZZXIIXZZZZZZZI\n", + "+0.114 * IIZZZZIIZIIIIZZZZIZI\n", + "+0.004 * IIZZZZIIZIIIIZXIIZII\n", + "-0.004 * IIIIIIIZIIIIIIXZZZZI\n", + "+0.000 * IIZZZZIIZIIIIXIIIZII\n", + "-0.000 * IIIIIIIZIIIIIXZZZZZI\n", + "+0.002 * IIZZZXZXZIIIIZZZXZII\n", + "+0.002 * IIZZZYZYZIIIIZZZXZII\n", + "+0.002 * IIIIIYZYIIIIIIIIXZZI\n", + "+0.002 * IIIIIXZXIIIIIIIIXZZI\n", + "+0.042 * IIZZZXZXZIIIIZZXIZII\n", + "+0.042 * IIZZZYZYZIIIIZZXIZII\n", + "+0.042 * IIIIIYZYIIIIIIIXZZZI\n", + "+0.042 * IIIIIXZXIIIIIIIXZZZI\n", + "+0.003 * IIZZXIZXZIIIIZZZXZII\n", + "+0.003 * IIZZYIZYZIIIIZZZXZII\n", + "+0.003 * IIIIYZZYIIIIIIIIXZZI\n", + "+0.003 * IIIIXZZXIIIIIIIIXZZI\n", + "-0.002 * IIZZXIZXZIIIIZZXIZII\n", + "-0.002 * IIZZYIZYZIIIIZZXIZII\n", + "-0.002 * IIIIYZZYIIIIIIIXZZZI\n", + "-0.002 * IIIIXZZXIIIIIIIXZZZI\n", + "-0.000 * IIZXIIZXZIIIIZZZZIZI\n", + "-0.000 * IIZYIIZYZIIIIZZZZIZI\n", + "+0.000 * IIZXIIZXZIIIIZZZZIXI\n", + "+0.000 * IIZYIIZYZIIIIZZZZIXI\n", + "+0.000 * IIIYZZZYIIIIIIIIIIXI\n", + "+0.000 * IIIXZZZXIIIIIIIIIIXI\n", + "-0.001 * IIZXIIZXZIIIIZXIIZII\n", + "-0.001 * IIZYIIZYZIIIIZXIIZII\n", + "-0.001 * IIIYZZZYIIIIIIXZZZZI\n", + "-0.001 * IIIXZZZXIIIIIIXZZZZI\n", + "+0.003 * IIZXIIZXZIIIIXIIIZII\n", + "+0.003 * IIZYIIZYZIIIIXIIIZII\n", + "+0.003 * IIIYZZZYIIIIIXZZZZZI\n", + "+0.003 * IIIXZZZXIIIIIXZZZZZI\n", + "+0.004 * IIXIIIZXZIIIIZZZZIZI\n", + "+0.004 * IIYIIIZYZIIIIZZZZIZI\n", + "+0.000 * IIXIIIZXZIIIIZZZZIXI\n", + "+0.000 * IIYIIIZYZIIIIZZZZIXI\n", + "+0.000 * IIYZZZZYIIIIIIIIIIXI\n", + "+0.000 * IIXZZZZXIIIIIIIIIIXI\n", + "+0.023 * IIXIIIZXZIIIIZXIIZII\n", + "+0.023 * IIYIIIZYZIIIIZXIIZII\n", + "+0.023 * IIYZZZZYIIIIIIXZZZZI\n", + "+0.023 * IIXZZZZXIIIIIIXZZZZI\n", + "+0.001 * IIXIIIZXZIIIIXIIIZII\n", + "+0.001 * IIYIIIZYZIIIIXIIIZII\n", + "+0.001 * IIYZZZZYIIIIIXZZZZZI\n", + "+0.001 * IIXZZZZXIIIIIXZZZZZI\n", + "+0.111 * IIZZZZZZZIIIIZZZZIZI\n", + "-0.011 * IIZZZZZZZIIIIZXIIZII\n", + "+0.011 * IIIIIIZIIIIIIIXZZZZI\n", + "-0.001 * IIZZZZZZZIIIIXIIIZII\n", + "+0.001 * IIIIIIZIIIIIIXZZZZZI\n", + "+0.000 * IIZZZXYZZIIIYIIIIZII\n", + "-0.000 * IIZZZYXZZIIIYIIIIZII\n", + "-0.000 * IIIIIYYIIIIIXZZZZZZI\n", + "-0.000 * IIIIIXXIIIIIXZZZZZZI\n", + "+0.000 * IIZZXIYZZIIIYIIIIZII\n", + "-0.000 * IIZZYIXZZIIIYIIIIZII\n", + "-0.000 * IIIIYZYIIIIIXZZZZZZI\n", + "-0.000 * IIIIXZXIIIIIXZZZZZZI\n", + "+0.003 * IIZXIIYZZIIIIZZZZYII\n", + "-0.003 * IIZYIIXZZIIIIZZZZYII\n", + "-0.003 * IIIYZZYIIIIIIIIIIXZI\n", + "-0.003 * IIIXZZXIIIIIIIIIIXZI\n", + "+0.001 * IIZXIIYZZIIYZIIIIZII\n", + "-0.001 * IIZYIIXZZIIYZIIIIZII\n", + "-0.001 * IIIYZZYIIIIXZZZZZZZI\n", + "-0.001 * IIIXZZXIIIIXZZZZZZZI\n", + "+0.000 * IIXIIIYZZIIIIZZZZYII\n", + "-0.000 * IIYIIIXZZIIIIZZZZYII\n", + "-0.000 * IIYZZZYIIIIIIIIIIXZI\n", + "-0.000 * IIXZZZXIIIIIIIIIIXZI\n", + "+0.000 * IIXIIIYZZIIYZIIIIZII\n", + "-0.000 * IIYIIIXZZIIYZIIIIZII\n", + "-0.000 * IIYZZZYIIIIXZZZZZZZI\n", + "-0.000 * IIXZZZXIIIIXZZZZZZZI\n", + "+0.001 * IYIIIIYZZIIIIZZZXZII\n", + "+0.001 * IXIIIIXZZIIIIZZZXZII\n", + "-0.001 * IYZZZZYIIIIIIIIIXZZI\n", + "-0.001 * IXZZZZXIIIIIIIIIXZZI\n", + "+0.021 * IYIIIIYZZIIIIZZXIZII\n", + "+0.021 * IXIIIIXZZIIIIZZXIZII\n", + "-0.021 * IYZZZZYIIIIIIIIXZZZI\n", + "-0.021 * IXZZZZXIIIIIIIIXZZZI\n", + "+0.008 * YZIIIIYZZIIIIZZZZIZI\n", + "+0.008 * XZIIIIXZZIIIIZZZZIZI\n", + "+0.015 * YZIIIIYZZIIIIZXIIZII\n", + "+0.015 * XZIIIIXZZIIIIZXIIZII\n", + "-0.015 * YZZZZZYIIIIIIIXZZZZI\n", + "-0.015 * XZZZZZXIIIIIIIXZZZZI\n", + "+0.001 * YZIIIIYZZIIIIXIIIZII\n", + "+0.001 * XZIIIIXZZIIIIXIIIZII\n", + "-0.001 * YZZZZZYIIIIIIXZZZZZI\n", + "-0.001 * XZZZZZXIIIIIIXZZZZZI\n", + "+0.112 * IIZZZIIZZIIIIZZZZIZI\n", + "+0.000 * IIZZZIIZZIIIIZZZZIXI\n", + "-0.000 * IIIIIZIIIIIIIIIIIIXI\n", + "-0.016 * IIZZZIIZZIIIIZXIIZII\n", + "+0.016 * IIIIIZIIIIIIIIXZZZZI\n", + "-0.001 * IIZZZIIZZIIIIXIIIZII\n", + "+0.001 * IIIIIZIIIIIIIXZZZZZI\n", + "+0.000 * IIZZXXIZZIIIIZZZZIZI\n", + "+0.000 * IIZZYYIZZIIIIZZZZIZI\n", + "+0.004 * IIZZXXIZZIIIIZZZZIXI\n", + "+0.004 * IIZZYYIZZIIIIZZZZIXI\n", + "+0.004 * IIIIYYIIIIIIIIIIIIXI\n", + "+0.004 * IIIIXXIIIIIIIIIIIIXI\n", + "-0.000 * IIZZXXIZZIIIIZXIIZII\n", + "-0.000 * IIZZYYIZZIIIIZXIIZII\n", + "-0.000 * IIIIYYIIIIIIIIXZZZZI\n", + "-0.000 * IIIIXXIIIIIIIIXZZZZI\n", + "-0.003 * IIZZXXIZZIIIIXIIIZII\n", + "-0.003 * IIZZYYIZZIIIIXIIIZII\n", + "-0.003 * IIIIYYIIIIIIIXZZZZZI\n", + "-0.003 * IIIIXXIIIIIIIXZZZZZI\n", + "-0.003 * IIZXIXIZZIIIIZZZXZII\n", + "-0.003 * IIZYIYIZZIIIIZZZXZII\n", + "-0.003 * IIIYZYIIIIIIIIIIXZZI\n", + "-0.003 * IIIXZXIIIIIIIIIIXZZI\n", + "+0.001 * IIZXIXIZZIIIIZZXIZII\n", + "+0.001 * IIZYIYIZZIIIIZZXIZII\n", + "+0.001 * IIIYZYIIIIIIIIIXZZZI\n", + "+0.001 * IIIXZXIIIIIIIIIXZZZI\n", + "-0.001 * IIXIIXIZZIIIIZZZXZII\n", + "-0.001 * IIYIIYIZZIIIIZZZXZII\n", + "-0.001 * IIYZZYIIIIIIIIIIXZZI\n", + "-0.001 * IIXZZXIIIIIIIIIIXZZI\n", + "-0.035 * IIXIIXIZZIIIIZZXIZII\n", + "-0.035 * IIYIIYIZZIIIIZZXIZII\n", + "-0.035 * IIYZZYIIIIIIIIIXZZZI\n", + "-0.035 * IIXZZXIIIIIIIIIXZZZI\n", + "+0.000 * IYIIIXIZZIIIIZZZZYII\n", + "-0.000 * IXIIIYIZZIIIIZZZZYII\n", + "-0.000 * IYZZZYIIIIIIIIIIIXZI\n", + "-0.000 * IXZZZXIIIIIIIIIIIXZI\n", + "+0.000 * IYIIIXIZZIIYZIIIIZII\n", + "-0.000 * IXIIIYIZZIIYZIIIIZII\n", + "-0.000 * IYZZZYIIIIIXZZZZZZZI\n", + "-0.000 * IXZZZXIIIIIXZZZZZZZI\n", + "+0.000 * YZIIIXIZZIIIYIIIIZII\n", + "-0.000 * XZIIIYIZZIIIYIIIIZII\n", + "-0.000 * YZZZZYIIIIIIXZZZZZZI\n", + "-0.000 * XZZZZXIIIIIIXZZZZZZI\n", + "+0.119 * IIZZIZIZZIIIIZZZZIZI\n", + "-0.000 * IIZZIZIZZIIIIZZZZIXI\n", + "+0.000 * IIIIZIIIIIIIIIIIIIXI\n", + "-0.021 * IIZZIZIZZIIIIZXIIZII\n", + "+0.021 * IIIIZIIIIIIIIIXZZZZI\n", + "-0.001 * IIZZIZIZZIIIIXIIIZII\n", + "+0.001 * IIIIZIIIIIIIIXZZZZZI\n", + "-0.001 * IIZXXZIZZIIIIZZZXZII\n", + "-0.001 * IIZYYZIZZIIIIZZZXZII\n", + "-0.001 * IIIYYIIIIIIIIIIIXZZI\n", + "-0.001 * IIIXXIIIIIIIIIIIXZZI\n", + "-0.041 * IIZXXZIZZIIIIZZXIZII\n", + "-0.041 * IIZYYZIZZIIIIZZXIZII\n", + "-0.041 * IIIYYIIIIIIIIIIXZZZI\n", + "-0.041 * IIIXXIIIIIIIIIIXZZZI\n", + "-0.003 * IIXIXZIZZIIIIZZZXZII\n", + "-0.003 * IIYIYZIZZIIIIZZZXZII\n", + "-0.003 * IIYZYIIIIIIIIIIIXZZI\n", + "-0.003 * IIXZXIIIIIIIIIIIXZZI\n", + "-0.001 * IIXIXZIZZIIIIZZXIZII\n", + "-0.001 * IIYIYZIZZIIIIZZXIZII\n", + "-0.001 * IIYZYIIIIIIIIIIXZZZI\n", + "-0.001 * IIXZXIIIIIIIIIIXZZZI\n", + "+0.001 * IYIIXZIZZIIIIZZZZYII\n", + "-0.001 * IXIIYZIZZIIIIZZZZYII\n", + "-0.001 * IYZZYIIIIIIIIIIIIXZI\n", + "-0.001 * IXZZXIIIIIIIIIIIIXZI\n", + "+0.003 * IYIIXZIZZIIYZIIIIZII\n", + "-0.003 * IXIIYZIZZIIYZIIIIZII\n", + "-0.003 * IYZZYIIIIIIXZZZZZZZI\n", + "-0.003 * IXZZXIIIIIIXZZZZZZZI\n", + "+0.004 * YZIIXZIZZIIIYIIIIZII\n", + "-0.004 * XZIIYZIZZIIIYIIIIZII\n", + "-0.004 * YZZZYIIIIIIIXZZZZZZI\n", + "-0.004 * XZZZXIIIIIIIXZZZZZZI\n", + "+0.126 * IIZIZZIZZIIIIZZZZIZI\n", + "-0.000 * IIZIZZIZZIIIIZZZZIXI\n", + "+0.000 * IIIZIIIIIIIIIIIIIIXI\n", + "+0.011 * IIZIZZIZZIIIIZXIIZII\n", + "-0.011 * IIIZIIIIIIIIIIXZZZZI\n", + "+0.000 * IIZIZZIZZIIIIXIIIZII\n", + "-0.000 * IIIZIIIIIIIIIXZZZZZI\n", + "+0.000 * IIXXZZIZZIIIIZZZZIZI\n", + "+0.000 * IIYYZZIZZIIIIZZZZIZI\n", + "+0.004 * IIXXZZIZZIIIIZZZZIXI\n", + "+0.004 * IIYYZZIZZIIIIZZZZIXI\n", + "+0.004 * IIYYIIIIIIIIIIIIIIXI\n", + "+0.004 * IIXXIIIIIIIIIIIIIIXI\n", + "+0.000 * IIXXZZIZZIIIIZXIIZII\n", + "+0.000 * IIYYZZIZZIIIIZXIIZII\n", + "+0.000 * IIYYIIIIIIIIIIXZZZZI\n", + "+0.000 * IIXXIIIIIIIIIIXZZZZI\n", + "+0.001 * IIXXZZIZZIIIIXIIIZII\n", + "+0.001 * IIYYZZIZZIIIIXIIIZII\n", + "+0.001 * IIYYIIIIIIIIIXZZZZZI\n", + "+0.001 * IIXXIIIIIIIIIXZZZZZI\n", + "-0.006 * IYIXZZIZZIIIYIIIIZII\n", + "+0.006 * IXIYZZIZZIIIYIIIIZII\n", + "+0.006 * IYZYIIIIIIIIXZZZZZZI\n", + "+0.006 * IXZXIIIIIIIIXZZZZZZI\n", + "+0.002 * YZIXZZIZZIIIIZZZZYII\n", + "-0.002 * XZIYZZIZZIIIIZZZZYII\n", + "-0.002 * YZZYIIIIIIIIIIIIIXZI\n", + "-0.002 * XZZXIIIIIIIIIIIIIXZI\n", + "-0.000 * YZIXZZIZZIIYZIIIIZII\n", + "+0.000 * XZIYZZIZZIIYZIIIIZII\n", + "+0.000 * YZZYIIIIIIIXZZZZZZZI\n", + "+0.000 * XZZXIIIIIIIXZZZZZZZI\n", + "+0.118 * IIIZZZIZZIIIIZZZZIZI\n", + "+0.000 * IIIZZZIZZIIIIZZZZIXI\n", + "-0.000 * IIZIIIIIIIIIIIIIIIXI\n", + "+0.009 * IIIZZZIZZIIIIZXIIZII\n", + "-0.009 * IIZIIIIIIIIIIIXZZZZI\n", + "+0.001 * IIIZZZIZZIIIIXIIIZII\n", + "-0.001 * IIZIIIIIIIIIIXZZZZZI\n", + "-0.000 * IYXZZZIZZIIIYIIIIZII\n", + "+0.000 * IXYZZZIZZIIIYIIIIZII\n", + "+0.000 * IYYIIIIIIIIIXZZZZZZI\n", + "+0.000 * IXXIIIIIIIIIXZZZZZZI\n", + "+0.000 * YZXZZZIZZIIIIZZZZYII\n", + "-0.000 * XZYZZZIZZIIIIZZZZYII\n", + "-0.000 * YZYIIIIIIIIIIIIIIXZI\n", + "-0.000 * XZXIIIIIIIIIIIIIIXZI\n", + "-0.000 * YZXZZZIZZIIYZIIIIZII\n", + "+0.000 * XZYZZZIZZIIYZIIIIZII\n", + "+0.000 * YZYIIIIIIIIXZZZZZZZI\n", + "+0.000 * XZXIIIIIIIIXZZZZZZZI\n", + "+0.124 * IZZZZZIZZIIIIZZZZIZI\n", + "+0.006 * IZZZZZIZZIIIIZXIIZII\n", + "-0.006 * IZIIIIIIIIIIIIXZZZZI\n", + "+0.000 * IZZZZZIZZIIIIXIIIZII\n", + "-0.000 * IZIIIIIIIIIIIXZZZZZI\n", + "+0.001 * YYZZZZIZZIIIIZZZXZII\n", + "+0.001 * XXZZZZIZZIIIIZZZXZII\n", + "-0.001 * YYIIIIIIIIIIIIIIXZZI\n", + "-0.001 * XXIIIIIIIIIIIIIIXZZI\n", + "+0.037 * YYZZZZIZZIIIIZZXIZII\n", + "+0.037 * XXZZZZIZZIIIIZZXIZII\n", + "-0.037 * YYIIIIIIIIIIIIIXZZZI\n", + "-0.037 * XXIIIIIIIIIIIIIXZZZI\n", + "+0.132 * ZIZZZZIZZIIIIZZZZIZI\n", + "+0.011 * ZIZZZZIZZIIIIZXIIZII\n", + "-0.011 * ZIIIIIIIIIIIIIXZZZZI\n", + "+0.001 * ZIZZZZIZZIIIIXIIIZII\n", + "-0.001 * ZIIIIIIIIIIIIXZZZZZI\n", + "+0.106 * IIIIIIIIIIIIIIIIIZZI\n", + "+0.006 * IIIIIIIIIIIYZZZZZYZI\n", + "+0.006 * IIIIIIIIIIIXZZZZZXZI\n", + "+0.071 * IIIIIIIIIIIIIIIIZIZI\n", + "-0.001 * IIIIIIIIIIIIIIIYYIZI\n", + "-0.001 * IIIIIIIIIIIIIIIXXIZI\n", + "+0.108 * IIIIIIIIIIIIIIIZIIZI\n", + "+0.114 * IIIIIIIIIIIIIIZIIIZI\n", + "-0.001 * IIIIIIIIIIIIIYYIIIZI\n", + "-0.001 * IIIIIIIIIIIIIXXIIIZI\n", + "+0.097 * IIIIIIIIIIIIIZIIIIZI\n", + "+0.115 * IIIIIIIIIIIIZIIIIIZI\n", + "+0.127 * IIIIIIIIIIIZIIIIIIZI\n", + "-0.000 * IIIIIIIIIIIIIIYZZIYI\n", + "-0.000 * IIIIIIIIIIIIIIXZZIXI\n", + "+0.008 * IIIIIIIIIIIIIYZZZIYI\n", + "+0.008 * IIIIIIIIIIIIIXZZZIXI\n", + "-0.021 * IIIIIIIIIIIIYZZZXXYI\n", + "-0.001 * IIIIIIIIIIIIYZZZYYYI\n", + "+0.020 * IIIIIIIIIIIIXZZZXYYI\n", + "+0.020 * IIIIIIIIIIIIYZZZYXXI\n", + "-0.001 * IIIIIIIIIIIIXZZZXXXI\n", + "-0.021 * IIIIIIIIIIIIXZZZYYXI\n", + "+0.001 * IIIIIIIIIIIIYZZXIXYI\n", + "+0.000 * IIIIIIIIIIIIYZZYIYYI\n", + "-0.001 * IIIIIIIIIIIIXZZXIYYI\n", + "-0.001 * IIIIIIIIIIIIYZZYIXXI\n", + "+0.000 * IIIIIIIIIIIIXZZXIXXI\n", + "+0.001 * IIIIIIIIIIIIXZZYIYXI\n", + "+0.001 * IIIIIIIIIIIYZZXIIXYI\n", + "+0.000 * IIIIIIIIIIIYZZYIIYYI\n", + "-0.001 * IIIIIIIIIIIXZZXIIYYI\n", + "-0.001 * IIIIIIIIIIIYZZYIIXXI\n", + "+0.000 * IIIIIIIIIIIXZZXIIXXI\n", + "+0.001 * IIIIIIIIIIIXZZYIIYXI\n", + "-0.015 * IIIIIIIIIIIYZXIIIXYI\n", + "-0.001 * IIIIIIIIIIIYZYIIIYYI\n", + "+0.014 * IIIIIIIIIIIXZXIIIYYI\n", + "+0.014 * IIIIIIIIIIIYZYIIIXXI\n", + "-0.001 * IIIIIIIIIIIXZXIIIXXI\n", + "-0.015 * IIIIIIIIIIIXZYIIIYXI\n", + "-0.000 * IIIIIIIIIIIIIIYZIZYI\n", + "-0.000 * IIIIIIIIIIIIIIXZIZXI\n", + "-0.021 * IIIIIIIIIIIIIYZZIZYI\n", + "-0.021 * IIIIIIIIIIIIIXZZIZXI\n", + "-0.000 * IIIIIIIIIIIIIIYXXZYI\n", + "-0.033 * IIIIIIIIIIIIIIYYYZYI\n", + "-0.033 * IIIIIIIIIIIIIIXXYZYI\n", + "-0.033 * IIIIIIIIIIIIIIYYXZXI\n", + "-0.033 * IIIIIIIIIIIIIIXXXZXI\n", + "-0.000 * IIIIIIIIIIIIIIXYYZXI\n", + "+0.001 * IIIIIIIIIIIIIYZXXZYI\n", + "-0.001 * IIIIIIIIIIIIIYZYYZYI\n", + "-0.002 * IIIIIIIIIIIIIXZXYZYI\n", + "-0.002 * IIIIIIIIIIIIIYZYXZXI\n", + "-0.001 * IIIIIIIIIIIIIXZXXZXI\n", + "+0.001 * IIIIIIIIIIIIIXZYYZXI\n", + "-0.000 * IIIIIIIIIIIYXIIIXZYI\n", + "-0.033 * IIIIIIIIIIIYYIIIYZYI\n", + "-0.033 * IIIIIIIIIIIXXIIIYZYI\n", + "-0.033 * IIIIIIIIIIIYYIIIXZXI\n", + "-0.033 * IIIIIIIIIIIXXIIIXZXI\n", + "-0.000 * IIIIIIIIIIIXYIIIYZXI\n", + "+0.000 * IIIIIIIIIIIIIIYIZZYI\n", + "+0.000 * IIIIIIIIIIIIIIXIZZXI\n", + "+0.013 * IIIIIIIIIIIIIYZIZZYI\n", + "+0.013 * IIIIIIIIIIIIIXZIZZXI\n", + "+0.000 * IIIIIIIIIIIYXIIXZZYI\n", + "+0.001 * IIIIIIIIIIIYYIIYZZYI\n", + "+0.001 * IIIIIIIIIIIXXIIYZZYI\n", + "+0.001 * IIIIIIIIIIIYYIIXZZXI\n", + "+0.001 * IIIIIIIIIIIXXIIXZZXI\n", + "+0.000 * IIIIIIIIIIIXYIIYZZXI\n", + "-0.007 * IIIIIIIIIIIIIYIZZZYI\n", + "-0.007 * IIIIIIIIIIIIIXIZZZXI\n", + "+0.000 * IIIIIIIIIIIIIZYZZZYI\n", + "+0.000 * IIIIIIIIIIIIIZXZZZXI\n", + "+0.000 * IIIIIIIIIIIIZIYZZZYI\n", + "+0.000 * IIIIIIIIIIIIZIXZZZXI\n", + "+0.001 * IIIIIIIIIIIZIIYZZZYI\n", + "+0.001 * IIIIIIIIIIIZIIXZZZXI\n", + "-0.000 * IIIIIIIIIIIIZYZZZZYI\n", + "-0.000 * IIIIIIIIIIIIZXZZZZXI\n", + "-0.011 * IIIIIIIIIIIZIYZZZZYI\n", + "-0.011 * IIIIIIIIIIIZIXZZZZXI\n", + "+0.123 * ZZZZZZZZZZZIIIIIIIZI\n", + "+0.000 * ZZZZZZZZZZZIIIYZZZYI\n", + "+0.000 * ZZZZZZZZZZZIIIXZZZXI\n", + "-0.001 * ZZZZZZZZZZZIIYZZZZYI\n", + "-0.001 * ZZZZZZZZZZZIIXZZZZXI\n", + "-0.047 * ZZZZZZZZZZXIIIIIYZYI\n", + "+0.047 * IIIIIIIIIIXIIIIIYZYI\n", + "-0.047 * ZZZZZZZZZZXIIIIIXZXI\n", + "+0.047 * IIIIIIIIIIXIIIIIXZXI\n", + "+0.002 * ZZZZZZZZZZXIIIIYZZYI\n", + "-0.002 * IIIIIIIIIIXIIIIYZZYI\n", + "+0.002 * ZZZZZZZZZZXIIIIXZZXI\n", + "-0.002 * IIIIIIIIIIXIIIIXZZXI\n", + "+0.008 * ZZZZZZZZZXIIIIIIIIZI\n", + "-0.008 * IIIIIIIIIXZIIIIIIIZI\n", + "+0.001 * ZZZZZZZZZXIIIIYZZZYI\n", + "-0.001 * IIIIIIIIIXZIIIYZZZYI\n", + "+0.001 * ZZZZZZZZZXIIIIXZZZXI\n", + "-0.001 * IIIIIIIIIXZIIIXZZZXI\n", + "-0.017 * ZZZZZZZZZXIIIYZZZZYI\n", + "+0.017 * IIIIIIIIIXZIIYZZZZYI\n", + "-0.017 * ZZZZZZZZZXIIIXZZZZXI\n", + "+0.017 * IIIIIIIIIXZIIXZZZZXI\n", + "-0.003 * ZZZZZZZXIIIIYZZZZZYI\n", + "+0.003 * IIIIIIIXZZZIYZZZZZYI\n", + "-0.003 * ZZZZZZZXIIIIXZZZZZXI\n", + "+0.003 * IIIIIIIXZZZIXZZZZZXI\n", + "+0.004 * ZZZZZZXIIIIIIIIIYZYI\n", + "-0.004 * IIIIIIXZZZZIIIIIYZYI\n", + "+0.004 * ZZZZZZXIIIIIIIIIXZXI\n", + "-0.004 * IIIIIIXZZZZIIIIIXZXI\n", + "-0.000 * ZZZZZZXIIIIIIIIYZZYI\n", + "+0.000 * IIIIIIXZZZZIIIIYZZYI\n", + "-0.000 * ZZZZZZXIIIIIIIIXZZXI\n", + "+0.000 * IIIIIIXZZZZIIIIXZZXI\n", + "+0.003 * ZZZZZXIIIIIIIIIIIYYI\n", + "-0.003 * IIIIIXZZZZZIIIIIIYYI\n", + "+0.003 * ZZZZZXIIIIIIIIIIIXXI\n", + "-0.003 * IIIIIXZZZZZIIIIIIXXI\n", + "-0.004 * ZZZZZXIIIIIYZZZZZZYI\n", + "+0.004 * IIIIIXZZZZZYZZZZZZYI\n", + "-0.004 * ZZZZZXIIIIIXZZZZZZXI\n", + "+0.004 * IIIIIXZZZZZXZZZZZZXI\n", + "-0.000 * ZZZZXIIIIIIIIIIIIYYI\n", + "+0.000 * IIIIXZZZZZZIIIIIIYYI\n", + "-0.000 * ZZZZXIIIIIIIIIIIIXXI\n", + "+0.000 * IIIIXZZZZZZIIIIIIXXI\n", + "+0.000 * ZZZZXIIIIIIYZZZZZZYI\n", + "-0.000 * IIIIXZZZZZZYZZZZZZYI\n", + "+0.000 * ZZZZXIIIIIIXZZZZZZXI\n", + "-0.000 * IIIIXZZZZZZXZZZZZZXI\n", + "+0.000 * ZZZXIIIIIIIIYZZZZZYI\n", + "-0.000 * IIIXZZZZZZZIYZZZZZYI\n", + "+0.000 * ZZZXIIIIIIIIXZZZZZXI\n", + "-0.000 * IIIXZZZZZZZIXZZZZZXI\n", + "-0.007 * ZZXIIIIIIIIIYZZZZZYI\n", + "+0.007 * IIXZZZZZZZZIYZZZZZYI\n", + "-0.007 * ZZXIIIIIIIIIXZZZZZXI\n", + "+0.007 * IIXZZZZZZZZIXZZZZZXI\n", + "-0.006 * ZXIIIIIIIIIIIIIIIIZI\n", + "+0.006 * IXZZZZZZZZZIIIIIIIZI\n", + "+0.001 * ZXIIIIIIIIIIIIYZZZYI\n", + "-0.001 * IXZZZZZZZZZIIIYZZZYI\n", + "+0.001 * ZXIIIIIIIIIIIIXZZZXI\n", + "-0.001 * IXZZZZZZZZZIIIXZZZXI\n", + "-0.014 * ZXIIIIIIIIIIIYZZZZYI\n", + "+0.014 * IXZZZZZZZZZIIYZZZZYI\n", + "-0.014 * ZXIIIIIIIIIIIXZZZZXI\n", + "+0.014 * IXZZZZZZZZZIIXZZZZXI\n", + "-0.014 * XIIIIIIIIIIIIIIIYZYI\n", + "+0.014 * XZZZZZZZZZZIIIIIYZYI\n", + "-0.014 * XIIIIIIIIIIIIIIIXZXI\n", + "+0.014 * XZZZZZZZZZZIIIIIXZXI\n", + "+0.000 * XIIIIIIIIIIIIIIYZZYI\n", + "-0.000 * XZZZZZZZZZZIIIIYZZYI\n", + "+0.000 * XIIIIIIIIIIIIIIXZZXI\n", + "-0.000 * XZZZZZZZZZZIIIIXZZXI\n", + "+0.123 * IIIIIIIIIIZIIIIIIIZI\n", + "-0.000 * IIIIIIIIIIZIIIYZZZYI\n", + "-0.000 * IIIIIIIIIIZIIIXZZZXI\n", + "+0.004 * IIIIIIIIIIZIIYZZZZYI\n", + "+0.004 * IIIIIIIIIIZIIXZZZZXI\n", + "-0.015 * IIIIIIIIIYYIIIIIYZYI\n", + "-0.015 * IIIIIIIIIXXIIIIIYZYI\n", + "-0.015 * IIIIIIIIIYYIIIIIXZXI\n", + "-0.015 * IIIIIIIIIXXIIIIIXZXI\n", + "+0.001 * IIIIIIIIIYYIIIIYZZYI\n", + "+0.001 * IIIIIIIIIXXIIIIYZZYI\n", + "+0.001 * IIIIIIIIIYYIIIIXZZXI\n", + "+0.001 * IIIIIIIIIXXIIIIXZZXI\n", + "-0.001 * IIIIIIIYZZYIIIIIIYYI\n", + "-0.001 * IIIIIIIXZZXIIIIIIYYI\n", + "-0.001 * IIIIIIIYZZYIIIIIIXXI\n", + "-0.001 * IIIIIIIXZZXIIIIIIXXI\n", + "+0.002 * IIIIIIIYZZYYZZZZZZYI\n", + "+0.002 * IIIIIIIXZZXYZZZZZZYI\n", + "+0.002 * IIIIIIIYZZYXZZZZZZXI\n", + "+0.002 * IIIIIIIXZZXXZZZZZZXI\n", + "-0.011 * IIIIIIYZZZYIIIIIIIZI\n", + "-0.011 * IIIIIIXZZZXIIIIIIIZI\n", + "-0.001 * IIIIIIYZZZYIIIYZZZYI\n", + "-0.001 * IIIIIIXZZZXIIIYZZZYI\n", + "-0.001 * IIIIIIYZZZYIIIXZZZXI\n", + "-0.001 * IIIIIIXZZZXIIIXZZZXI\n", + "+0.014 * IIIIIIYZZZYIIYZZZZYI\n", + "+0.014 * IIIIIIXZZZXIIYZZZZYI\n", + "+0.014 * IIIIIIYZZZYIIXZZZZXI\n", + "+0.014 * IIIIIIXZZZXIIXZZZZXI\n", + "-0.002 * IIIIIYZZZZYIYZZZZZYI\n", + "-0.002 * IIIIIXZZZZXIYZZZZZYI\n", + "-0.002 * IIIIIYZZZZYIXZZZZZXI\n", + "-0.002 * IIIIIXZZZZXIXZZZZZXI\n", + "+0.000 * IIIIYZZZZZYIYZZZZZYI\n", + "+0.000 * IIIIXZZZZZXIYZZZZZYI\n", + "+0.000 * IIIIYZZZZZYIXZZZZZXI\n", + "+0.000 * IIIIXZZZZZXIXZZZZZXI\n", + "-0.000 * IIIYZZZZZZYIIIIIIYYI\n", + "-0.000 * IIIXZZZZZZXIIIIIIYYI\n", + "-0.000 * IIIYZZZZZZYIIIIIIXXI\n", + "-0.000 * IIIXZZZZZZXIIIIIIXXI\n", + "+0.000 * IIIYZZZZZZYYZZZZZZYI\n", + "+0.000 * IIIXZZZZZZXYZZZZZZYI\n", + "+0.000 * IIIYZZZZZZYXZZZZZZXI\n", + "+0.000 * IIIXZZZZZZXXZZZZZZXI\n", + "+0.004 * IIYZZZZZZZYIIIIIIYYI\n", + "+0.004 * IIXZZZZZZZXIIIIIIYYI\n", + "+0.004 * IIYZZZZZZZYIIIIIIXXI\n", + "+0.004 * IIXZZZZZZZXIIIIIIXXI\n", + "-0.004 * IIYZZZZZZZYYZZZZZZYI\n", + "-0.004 * IIXZZZZZZZXYZZZZZZYI\n", + "-0.004 * IIYZZZZZZZYXZZZZZZXI\n", + "-0.004 * IIXZZZZZZZXXZZZZZZXI\n", + "-0.018 * IYZZZZZZZZYIIIIIYZYI\n", + "-0.018 * IXZZZZZZZZXIIIIIYZYI\n", + "-0.018 * IYZZZZZZZZYIIIIIXZXI\n", + "-0.018 * IXZZZZZZZZXIIIIIXZXI\n", + "+0.001 * IYZZZZZZZZYIIIIYZZYI\n", + "+0.001 * IXZZZZZZZZXIIIIYZZYI\n", + "+0.001 * IYZZZZZZZZYIIIIXZZXI\n", + "+0.001 * IXZZZZZZZZXIIIIXZZXI\n", + "-0.002 * YZZZZZZZZZYIIIIIIIZI\n", + "-0.002 * XZZZZZZZZZXIIIIIIIZI\n", + "+0.001 * YZZZZZZZZZYIIIYZZZYI\n", + "+0.001 * XZZZZZZZZZXIIIYZZZYI\n", + "+0.001 * YZZZZZZZZZYIIIXZZZXI\n", + "+0.001 * XZZZZZZZZZXIIIXZZZXI\n", + "-0.015 * YZZZZZZZZZYIIYZZZZYI\n", + "-0.015 * XZZZZZZZZZXIIYZZZZYI\n", + "-0.015 * YZZZZZZZZZYIIXZZZZXI\n", + "-0.015 * XZZZZZZZZZXIIXZZZZXI\n", + "+0.110 * IIIIIIIIIZIIIIIIIIZI\n", + "-0.000 * IIIIIIIIIZIIIIYZZZYI\n", + "-0.000 * IIIIIIIIIZIIIIXZZZXI\n", + "+0.009 * IIIIIIIIIZIIIYZZZZYI\n", + "+0.009 * IIIIIIIIIZIIIXZZZZXI\n", + "+0.004 * IIIIIIIYZYIIYZZZZZYI\n", + "+0.004 * IIIIIIIXZXIIYZZZZZYI\n", + "+0.004 * IIIIIIIYZYIIXZZZZZXI\n", + "+0.004 * IIIIIIIXZXIIXZZZZZXI\n", + "+0.048 * IIIIIIYZZYIIIIIIYZYI\n", + "+0.048 * IIIIIIXZZXIIIIIIYZYI\n", + "+0.048 * IIIIIIYZZYIIIIIIXZXI\n", + "+0.048 * IIIIIIXZZXIIIIIIXZXI\n", + "-0.002 * IIIIIIYZZYIIIIIYZZYI\n", + "-0.002 * IIIIIIXZZXIIIIIYZZYI\n", + "-0.002 * IIIIIIYZZYIIIIIXZZXI\n", + "-0.002 * IIIIIIXZZXIIIIIXZZXI\n", + "+0.006 * IIIIIYZZZYIIIIIIIYYI\n", + "+0.006 * IIIIIXZZZXIIIIIIIYYI\n", + "+0.006 * IIIIIYZZZYIIIIIIIXXI\n", + "+0.006 * IIIIIXZZZXIIIIIIIXXI\n", + "-0.002 * IIIIIYZZZYIYZZZZZZYI\n", + "-0.002 * IIIIIXZZZXIYZZZZZZYI\n", + "-0.002 * IIIIIYZZZYIXZZZZZZXI\n", + "-0.002 * IIIIIXZZZXIXZZZZZZXI\n", + "-0.000 * IIIIYZZZZYIIIIIIIYYI\n", + "-0.000 * IIIIXZZZZXIIIIIIIYYI\n", + "-0.000 * IIIIYZZZZYIIIIIIIXXI\n", + "-0.000 * IIIIXZZZZXIIIIIIIXXI\n", + "+0.000 * IIIIYZZZZYIYZZZZZZYI\n", + "+0.000 * IIIIXZZZZXIYZZZZZZYI\n", + "+0.000 * IIIIYZZZZYIXZZZZZZXI\n", + "+0.000 * IIIIXZZZZXIXZZZZZZXI\n", + "-0.000 * IIIYZZZZZYIIYZZZZZYI\n", + "-0.000 * IIIXZZZZZXIIYZZZZZYI\n", + "-0.000 * IIIYZZZZZYIIXZZZZZXI\n", + "-0.000 * IIIXZZZZZXIIXZZZZZXI\n", + "+0.005 * IIYZZZZZZYIIYZZZZZYI\n", + "+0.005 * IIXZZZZZZXIIYZZZZZYI\n", + "+0.005 * IIYZZZZZZYIIXZZZZZXI\n", + "+0.005 * IIXZZZZZZXIIXZZZZZXI\n", + "-0.006 * IYZZZZZZZYIIIIIIIIZI\n", + "-0.006 * IXZZZZZZZXIIIIIIIIZI\n", + "-0.001 * IYZZZZZZZYIIIIYZZZYI\n", + "-0.001 * IXZZZZZZZXIIIIYZZZYI\n", + "-0.001 * IYZZZZZZZYIIIIXZZZXI\n", + "-0.001 * IXZZZZZZZXIIIIXZZZXI\n", + "+0.016 * IYZZZZZZZYIIIYZZZZYI\n", + "+0.016 * IXZZZZZZZXIIIYZZZZYI\n", + "+0.016 * IYZZZZZZZYIIIXZZZZXI\n", + "+0.016 * IXZZZZZZZXIIIXZZZZXI\n", + "+0.004 * YZZZZZZZZYIIIIIIYZYI\n", + "+0.004 * XZZZZZZZZXIIIIIIYZYI\n", + "+0.004 * YZZZZZZZZYIIIIIIXZXI\n", + "+0.004 * XZZZZZZZZXIIIIIIXZXI\n", + "-0.000 * YZZZZZZZZYIIIIIYZZYI\n", + "-0.000 * XZZZZZZZZXIIIIIYZZYI\n", + "-0.000 * YZZZZZZZZYIIIIIXZZXI\n", + "-0.000 * XZZZZZZZZXIIIIIXZZXI\n", + "+0.114 * IIIIIIIIZIIIIIIIIIZI\n", + "+0.000 * IIIIIIIIZIIIIIYZZZYI\n", + "+0.000 * IIIIIIIIZIIIIIXZZZXI\n", + "-0.004 * IIIIIIIIZIIIIYZZZZYI\n", + "-0.004 * IIIIIIIIZIIIIXZZZZXI\n", + "+0.000 * IIIIIIIYYIIIIIYZZZYI\n", + "+0.000 * IIIIIIIXXIIIIIYZZZYI\n", + "+0.000 * IIIIIIIYYIIIIIXZZZXI\n", + "+0.000 * IIIIIIIXXIIIIIXZZZXI\n", + "+0.000 * IIIIIIIYYIIIIYZZZZYI\n", + "+0.000 * IIIIIIIXXIIIIYZZZZYI\n", + "+0.000 * IIIIIIIYYIIIIXZZZZXI\n", + "+0.000 * IIIIIIIXXIIIIXZZZZXI\n", + "+0.002 * IIIIIYZZYIIIIIIIYZYI\n", + "+0.002 * IIIIIXZZXIIIIIIIYZYI\n", + "+0.002 * IIIIIYZZYIIIIIIIXZXI\n", + "+0.002 * IIIIIXZZXIIIIIIIXZXI\n", + "+0.003 * IIIIIYZZYIIIIIIYZZYI\n", + "+0.003 * IIIIIXZZXIIIIIIYZZYI\n", + "+0.003 * IIIIIYZZYIIIIIIXZZXI\n", + "+0.003 * IIIIIXZZXIIIIIIXZZXI\n", + "+0.042 * IIIIYZZZYIIIIIIIYZYI\n", + "+0.042 * IIIIXZZZXIIIIIIIYZYI\n", + "+0.042 * IIIIYZZZYIIIIIIIXZXI\n", + "+0.042 * IIIIXZZZXIIIIIIIXZXI\n", + "-0.002 * IIIIYZZZYIIIIIIYZZYI\n", + "-0.002 * IIIIXZZZXIIIIIIYZZYI\n", + "-0.002 * IIIIYZZZYIIIIIIXZZXI\n", + "-0.002 * IIIIXZZZXIIIIIIXZZXI\n", + "-0.004 * IIIYZZZZYIIIIIIIIIZI\n", + "-0.004 * IIIXZZZZXIIIIIIIIIZI\n", + "-0.001 * IIIYZZZZYIIIIIYZZZYI\n", + "-0.001 * IIIXZZZZXIIIIIYZZZYI\n", + "-0.001 * IIIYZZZZYIIIIIXZZZXI\n", + "-0.001 * IIIXZZZZXIIIIIXZZZXI\n", + "+0.023 * IIIYZZZZYIIIIYZZZZYI\n", + "+0.023 * IIIXZZZZXIIIIYZZZZYI\n", + "+0.023 * IIIYZZZZYIIIIXZZZZXI\n", + "+0.023 * IIIXZZZZXIIIIXZZZZXI\n", + "-0.000 * IIYZZZZZYIIIIIIIIIZI\n", + "-0.000 * IIXZZZZZXIIIIIIIIIZI\n", + "+0.003 * IIYZZZZZYIIIIIYZZZYI\n", + "+0.003 * IIXZZZZZXIIIIIYZZZYI\n", + "+0.003 * IIYZZZZZYIIIIIXZZZXI\n", + "+0.003 * IIXZZZZZXIIIIIXZZZXI\n", + "+0.001 * IIYZZZZZYIIIIYZZZZYI\n", + "+0.001 * IIXZZZZZXIIIIYZZZZYI\n", + "+0.001 * IIYZZZZZYIIIIXZZZZXI\n", + "+0.001 * IIXZZZZZXIIIIXZZZZXI\n", + "+0.122 * IIIIIIIZIIIIIIIIIIZI\n", + "+0.000 * IIIIIIIZIIIIIIYZZZYI\n", + "+0.000 * IIIIIIIZIIIIIIXZZZXI\n", + "-0.004 * IIIIIIIZIIIIIYZZZZYI\n", + "-0.004 * IIIIIIIZIIIIIXZZZZXI\n", + "+0.005 * IIIIIIYYIIIIIIIIIYYI\n", + "+0.005 * IIIIIIXXIIIIIIIIIYYI\n", + "+0.005 * IIIIIIYYIIIIIIIIIXXI\n", + "+0.005 * IIIIIIXXIIIIIIIIIXXI\n", + "-0.002 * IIIIIIYYIIIYZZZZZZYI\n", + "-0.002 * IIIIIIXXIIIYZZZZZZYI\n", + "-0.002 * IIIIIIYYIIIXZZZZZZXI\n", + "-0.002 * IIIIIIXXIIIXZZZZZZXI\n", + "+0.049 * IIIIIYZYIIIIIIIIYZYI\n", + "+0.049 * IIIIIXZXIIIIIIIIYZYI\n", + "+0.049 * IIIIIYZYIIIIIIIIXZXI\n", + "+0.049 * IIIIIXZXIIIIIIIIXZXI\n", + "-0.002 * IIIIIYZYIIIIIIIYZZYI\n", + "-0.002 * IIIIIXZXIIIIIIIYZZYI\n", + "-0.002 * IIIIIYZYIIIIIIIXZZXI\n", + "-0.002 * IIIIIXZXIIIIIIIXZZXI\n", + "-0.002 * IIIIYZZYIIIIIIIIYZYI\n", + "-0.002 * IIIIXZZXIIIIIIIIYZYI\n", + "-0.002 * IIIIYZZYIIIIIIIIXZXI\n", + "-0.002 * IIIIXZZXIIIIIIIIXZXI\n", + "+0.004 * IIIIYZZYIIIIIIIYZZYI\n", + "+0.004 * IIIIXZZXIIIIIIIYZZYI\n", + "+0.004 * IIIIYZZYIIIIIIIXZZXI\n", + "+0.004 * IIIIXZZXIIIIIIIXZZXI\n", + "+0.000 * IIIYZZZYIIIIIIIIIIZI\n", + "+0.000 * IIIXZZZXIIIIIIIIIIZI\n", + "+0.004 * IIIYZZZYIIIIIIYZZZYI\n", + "+0.004 * IIIXZZZXIIIIIIYZZZYI\n", + "+0.004 * IIIYZZZYIIIIIIXZZZXI\n", + "+0.004 * IIIXZZZXIIIIIIXZZZXI\n", + "-0.001 * IIIYZZZYIIIIIYZZZZYI\n", + "-0.001 * IIIXZZZXIIIIIYZZZZYI\n", + "-0.001 * IIIYZZZYIIIIIXZZZZXI\n", + "-0.001 * IIIXZZZXIIIIIXZZZZXI\n", + "-0.004 * IIYZZZZYIIIIIIIIIIZI\n", + "-0.004 * IIXZZZZXIIIIIIIIIIZI\n", + "-0.001 * IIYZZZZYIIIIIIYZZZYI\n", + "-0.001 * IIXZZZZXIIIIIIYZZZYI\n", + "-0.001 * IIYZZZZYIIIIIIXZZZXI\n", + "-0.001 * IIXZZZZXIIIIIIXZZZXI\n", + "+0.029 * IIYZZZZYIIIIIYZZZZYI\n", + "+0.029 * IIXZZZZXIIIIIYZZZZYI\n", + "+0.029 * IIYZZZZYIIIIIXZZZZXI\n", + "+0.029 * IIXZZZZXIIIIIXZZZZXI\n", + "+0.008 * IYZZZZZYIIIIYZZZZZYI\n", + "+0.008 * IXZZZZZXIIIIYZZZZZYI\n", + "+0.008 * IYZZZZZYIIIIXZZZZZXI\n", + "+0.008 * IXZZZZZXIIIIXZZZZZXI\n", + "-0.002 * YZZZZZZYIIIIIIIIIYYI\n", + "-0.002 * XZZZZZZXIIIIIIIIIYYI\n", + "-0.002 * YZZZZZZYIIIIIIIIIXXI\n", + "-0.002 * XZZZZZZXIIIIIIIIIXXI\n", + "+0.005 * YZZZZZZYIIIYZZZZZZYI\n", + "+0.005 * XZZZZZZXIIIYZZZZZZYI\n", + "+0.005 * YZZZZZZYIIIXZZZZZZXI\n", + "+0.005 * XZZZZZZXIIIXZZZZZZXI\n", + "+0.111 * IIIIIIZIIIIIIIIIIIZI\n", + "-0.001 * IIIIIIZIIIIIIIYZZZYI\n", + "-0.001 * IIIIIIZIIIIIIIXZZZXI\n", + "+0.011 * IIIIIIZIIIIIIYZZZZYI\n", + "+0.011 * IIIIIIZIIIIIIXZZZZXI\n", + "-0.000 * IIIIIYYIIIIIYZZZZZYI\n", + "-0.000 * IIIIIXXIIIIIYZZZZZYI\n", + "-0.000 * IIIIIYYIIIIIXZZZZZXI\n", + "-0.000 * IIIIIXXIIIIIXZZZZZXI\n", + "+0.000 * IIIIYZYIIIIIYZZZZZYI\n", + "+0.000 * IIIIXZXIIIIIYZZZZZYI\n", + "+0.000 * IIIIYZYIIIIIXZZZZZXI\n", + "+0.000 * IIIIXZXIIIIIXZZZZZXI\n", + "+0.000 * IIIYZZYIIIIIIIIIIYYI\n", + "+0.000 * IIIXZZXIIIIIIIIIIYYI\n", + "+0.000 * IIIYZZYIIIIIIIIIIXXI\n", + "+0.000 * IIIXZZXIIIIIIIIIIXXI\n", + "+0.000 * IIIYZZYIIIIYZZZZZZYI\n", + "+0.000 * IIIXZZXIIIIYZZZZZZYI\n", + "+0.000 * IIIYZZYIIIIXZZZZZZXI\n", + "+0.000 * IIIXZZXIIIIXZZZZZZXI\n", + "-0.003 * IIYZZZYIIIIIIIIIIYYI\n", + "-0.003 * IIXZZZXIIIIIIIIIIYYI\n", + "-0.003 * IIYZZZYIIIIIIIIIIXXI\n", + "-0.003 * IIXZZZXIIIIIIIIIIXXI\n", + "-0.001 * IIYZZZYIIIIYZZZZZZYI\n", + "-0.001 * IIXZZZXIIIIYZZZZZZYI\n", + "-0.001 * IIYZZZYIIIIXZZZZZZXI\n", + "-0.001 * IIXZZZXIIIIXZZZZZZXI\n", + "-0.021 * IYZZZZYIIIIIIIIIYZYI\n", + "-0.021 * IXZZZZXIIIIIIIIIYZYI\n", + "-0.021 * IYZZZZYIIIIIIIIIXZXI\n", + "-0.021 * IXZZZZXIIIIIIIIIXZXI\n", + "+0.001 * IYZZZZYIIIIIIIIYZZYI\n", + "+0.001 * IXZZZZXIIIIIIIIYZZYI\n", + "+0.001 * IYZZZZYIIIIIIIIXZZXI\n", + "+0.001 * IXZZZZXIIIIIIIIXZZXI\n", + "+0.008 * YZZZZZYIIIIIIIIIIIZI\n", + "+0.008 * XZZZZZXIIIIIIIIIIIZI\n", + "+0.001 * YZZZZZYIIIIIIIYZZZYI\n", + "+0.001 * XZZZZZXIIIIIIIYZZZYI\n", + "+0.001 * YZZZZZYIIIIIIIXZZZXI\n", + "+0.001 * XZZZZZXIIIIIIIXZZZXI\n", + "-0.015 * YZZZZZYIIIIIIYZZZZYI\n", + "-0.015 * XZZZZZXIIIIIIYZZZZYI\n", + "-0.015 * YZZZZZYIIIIIIXZZZZXI\n", + "-0.015 * XZZZZZXIIIIIIXZZZZXI\n", + "+0.119 * IIIIIZIIIIIIIIIIIIZI\n", + "-0.001 * IIIIIZIIIIIIIIYZZZYI\n", + "-0.001 * IIIIIZIIIIIIIIXZZZXI\n", + "+0.021 * IIIIIZIIIIIIIYZZZZYI\n", + "+0.021 * IIIIIZIIIIIIIXZZZZXI\n", + "+0.000 * IIIIYYIIIIIIIIIIIIZI\n", + "+0.000 * IIIIXXIIIIIIIIIIIIZI\n", + "-0.003 * IIIIYYIIIIIIIIYZZZYI\n", + "-0.003 * IIIIXXIIIIIIIIYZZZYI\n", + "-0.003 * IIIIYYIIIIIIIIXZZZXI\n", + "-0.003 * IIIIXXIIIIIIIIXZZZXI\n", + "+0.000 * IIIIYYIIIIIIIYZZZZYI\n", + "+0.000 * IIIIXXIIIIIIIYZZZZYI\n", + "+0.000 * IIIIYYIIIIIIIXZZZZXI\n", + "+0.000 * IIIIXXIIIIIIIXZZZZXI\n", + "+0.001 * IIIYZYIIIIIIIIIIYZYI\n", + "+0.001 * IIIXZXIIIIIIIIIIYZYI\n", + "+0.001 * IIIYZYIIIIIIIIIIXZXI\n", + "+0.001 * IIIXZXIIIIIIIIIIXZXI\n", + "-0.003 * IIIYZYIIIIIIIIIYZZYI\n", + "-0.003 * IIIXZXIIIIIIIIIYZZYI\n", + "-0.003 * IIIYZYIIIIIIIIIXZZXI\n", + "-0.003 * IIIXZXIIIIIIIIIXZZXI\n", + "-0.041 * IIYZZYIIIIIIIIIIYZYI\n", + "-0.041 * IIXZZXIIIIIIIIIIYZYI\n", + "-0.041 * IIYZZYIIIIIIIIIIXZXI\n", + "-0.041 * IIXZZXIIIIIIIIIIXZXI\n", + "+0.001 * IIYZZYIIIIIIIIIYZZYI\n", + "+0.001 * IIXZZXIIIIIIIIIYZZYI\n", + "+0.001 * IIYZZYIIIIIIIIIXZZXI\n", + "+0.001 * IIXZZXIIIIIIIIIXZZXI\n", + "-0.001 * IYZZZYIIIIIIIIIIIYYI\n", + "-0.001 * IXZZZXIIIIIIIIIIIYYI\n", + "-0.001 * IYZZZYIIIIIIIIIIIXXI\n", + "-0.001 * IXZZZXIIIIIIIIIIIXXI\n", + "-0.003 * IYZZZYIIIIIYZZZZZZYI\n", + "-0.003 * IXZZZXIIIIIYZZZZZZYI\n", + "-0.003 * IYZZZYIIIIIXZZZZZZXI\n", + "-0.003 * IXZZZXIIIIIXZZZZZZXI\n", + "-0.004 * YZZZZYIIIIIIYZZZZZYI\n", + "-0.004 * XZZZZXIIIIIIYZZZZZYI\n", + "-0.004 * YZZZZYIIIIIIXZZZZZXI\n", + "-0.004 * XZZZZXIIIIIIXZZZZZXI\n", + "+0.112 * IIIIZIIIIIIIIIIIIIZI\n", + "-0.001 * IIIIZIIIIIIIIIYZZZYI\n", + "-0.001 * IIIIZIIIIIIIIIXZZZXI\n", + "+0.016 * IIIIZIIIIIIIIYZZZZYI\n", + "+0.016 * IIIIZIIIIIIIIXZZZZXI\n", + "-0.035 * IIIYYIIIIIIIIIIIYZYI\n", + "-0.035 * IIIXXIIIIIIIIIIIYZYI\n", + "-0.035 * IIIYYIIIIIIIIIIIXZXI\n", + "-0.035 * IIIXXIIIIIIIIIIIXZXI\n", + "+0.001 * IIIYYIIIIIIIIIIYZZYI\n", + "+0.001 * IIIXXIIIIIIIIIIYZZYI\n", + "+0.001 * IIIYYIIIIIIIIIIXZZXI\n", + "+0.001 * IIIXXIIIIIIIIIIXZZXI\n", + "-0.001 * IIYZYIIIIIIIIIIIYZYI\n", + "-0.001 * IIXZXIIIIIIIIIIIYZYI\n", + "-0.001 * IIYZYIIIIIIIIIIIXZXI\n", + "-0.001 * IIXZXIIIIIIIIIIIXZXI\n", + "-0.003 * IIYZYIIIIIIIIIIYZZYI\n", + "-0.003 * IIXZXIIIIIIIIIIYZZYI\n", + "-0.003 * IIYZYIIIIIIIIIIXZZXI\n", + "-0.003 * IIXZXIIIIIIIIIIXZZXI\n", + "+0.000 * IYZZYIIIIIIIIIIIIYYI\n", + "+0.000 * IXZZXIIIIIIIIIIIIYYI\n", + "+0.000 * IYZZYIIIIIIIIIIIIXXI\n", + "+0.000 * IXZZXIIIIIIIIIIIIXXI\n", + "+0.000 * IYZZYIIIIIIYZZZZZZYI\n", + "+0.000 * IXZZXIIIIIIYZZZZZZYI\n", + "+0.000 * IYZZYIIIIIIXZZZZZZXI\n", + "+0.000 * IXZZXIIIIIIXZZZZZZXI\n", + "+0.000 * YZZZYIIIIIIIYZZZZZYI\n", + "+0.000 * XZZZXIIIIIIIYZZZZZYI\n", + "+0.000 * YZZZYIIIIIIIXZZZZZXI\n", + "+0.000 * XZZZXIIIIIIIXZZZZZXI\n", + "+0.118 * IIIZIIIIIIIIIIIIIIZI\n", + "+0.001 * IIIZIIIIIIIIIIYZZZYI\n", + "+0.001 * IIIZIIIIIIIIIIXZZZXI\n", + "-0.009 * IIIZIIIIIIIIIYZZZZYI\n", + "-0.009 * IIIZIIIIIIIIIXZZZZXI\n", + "+0.000 * IIYYIIIIIIIIIIIIIIZI\n", + "+0.000 * IIXXIIIIIIIIIIIIIIZI\n", + "+0.001 * IIYYIIIIIIIIIIYZZZYI\n", + "+0.001 * IIXXIIIIIIIIIIYZZZYI\n", + "+0.001 * IIYYIIIIIIIIIIXZZZXI\n", + "+0.001 * IIXXIIIIIIIIIIXZZZXI\n", + "-0.000 * IIYYIIIIIIIIIYZZZZYI\n", + "-0.000 * IIXXIIIIIIIIIYZZZZYI\n", + "-0.000 * IIYYIIIIIIIIIXZZZZXI\n", + "-0.000 * IIXXIIIIIIIIIXZZZZXI\n", + "-0.000 * IYZYIIIIIIIIYZZZZZYI\n", + "-0.000 * IXZXIIIIIIIIYZZZZZYI\n", + "-0.000 * IYZYIIIIIIIIXZZZZZXI\n", + "-0.000 * IXZXIIIIIIIIXZZZZZXI\n", + "+0.000 * YZZYIIIIIIIIIIIIIYYI\n", + "+0.000 * XZZXIIIIIIIIIIIIIYYI\n", + "+0.000 * YZZYIIIIIIIIIIIIIXXI\n", + "+0.000 * XZZXIIIIIIIIIIIIIXXI\n", + "-0.000 * YZZYIIIIIIIYZZZZZZYI\n", + "-0.000 * XZZXIIIIIIIYZZZZZZYI\n", + "-0.000 * YZZYIIIIIIIXZZZZZZXI\n", + "-0.000 * XZZXIIIIIIIXZZZZZZXI\n", + "+0.126 * IIZIIIIIIIIIIIIIIIZI\n", + "+0.000 * IIZIIIIIIIIIIIYZZZYI\n", + "+0.000 * IIZIIIIIIIIIIIXZZZXI\n", + "-0.011 * IIZIIIIIIIIIIYZZZZYI\n", + "-0.011 * IIZIIIIIIIIIIXZZZZXI\n", + "+0.006 * IYYIIIIIIIIIYZZZZZYI\n", + "+0.006 * IXXIIIIIIIIIYZZZZZYI\n", + "+0.006 * IYYIIIIIIIIIXZZZZZXI\n", + "+0.006 * IXXIIIIIIIIIXZZZZZXI\n", + "-0.002 * YZYIIIIIIIIIIIIIIYYI\n", + "-0.002 * XZXIIIIIIIIIIIIIIYYI\n", + "-0.002 * YZYIIIIIIIIIIIIIIXXI\n", + "-0.002 * XZXIIIIIIIIIIIIIIXXI\n", + "+0.000 * YZYIIIIIIIIYZZZZZZYI\n", + "+0.000 * XZXIIIIIIIIYZZZZZZYI\n", + "+0.000 * YZYIIIIIIIIXZZZZZZXI\n", + "+0.000 * XZXIIIIIIIIXZZZZZZXI\n", + "+0.124 * IZIIIIIIIIIIIIIIIIZI\n", + "+0.000 * IZIIIIIIIIIIIIYZZZYI\n", + "+0.000 * IZIIIIIIIIIIIIXZZZXI\n", + "-0.006 * IZIIIIIIIIIIIYZZZZYI\n", + "-0.006 * IZIIIIIIIIIIIXZZZZXI\n", + "-0.037 * YYIIIIIIIIIIIIIIYZYI\n", + "-0.037 * XXIIIIIIIIIIIIIIYZYI\n", + "-0.037 * YYIIIIIIIIIIIIIIXZXI\n", + "-0.037 * XXIIIIIIIIIIIIIIXZXI\n", + "+0.001 * YYIIIIIIIIIIIIIYZZYI\n", + "+0.001 * XXIIIIIIIIIIIIIYZZYI\n", + "+0.001 * YYIIIIIIIIIIIIIXZZXI\n", + "+0.001 * XXIIIIIIIIIIIIIXZZXI\n", + "+0.132 * ZIIIIIIIIIIIIIIIIIZI\n", + "+0.001 * ZIIIIIIIIIIIIIYZZZYI\n", + "+0.001 * ZIIIIIIIIIIIIIXZZZXI\n", + "-0.011 * ZIIIIIIIIIIIIYZZZZYI\n", + "-0.011 * ZIIIIIIIIIIIIXZZZZXI\n", + "+0.114 * IIIIIIIIIIIIIIIIZZII\n", + "+0.114 * IIIIIIIIIIIIIIIZIZII\n", + "+0.108 * IIIIIIIIIIIIIIZIIZII\n", + "+0.108 * IIIIIIIIIIIIIZIIIZII\n", + "+0.102 * IIIIIIIIIIIIZIIIIZII\n", + "+0.110 * IIIIIIIIIIIZIIIIIZII\n", + "-0.006 * IIIIIIIIIIIYZZZZIYII\n", + "-0.006 * IIIIIIIIIIIXZZZZIXII\n", + "+0.000 * IIIIIIIIIIIIYZXIXYII\n", + "+0.000 * IIIIIIIIIIIIYZYIYYII\n", + "-0.000 * IIIIIIIIIIIIXZXIYYII\n", + "-0.000 * IIIIIIIIIIIIYZYIXXII\n", + "+0.000 * IIIIIIIIIIIIXZXIXXII\n", + "+0.000 * IIIIIIIIIIIIXZYIYXII\n", + "-0.020 * IIIIIIIIIIIIYXIIXYII\n", + "-0.018 * IIIIIIIIIIIIYYIIYYII\n", + "+0.001 * IIIIIIIIIIIIXXIIYYII\n", + "+0.001 * IIIIIIIIIIIIYYIIXXII\n", + "-0.018 * IIIIIIIIIIIIXXIIXXII\n", + "-0.020 * IIIIIIIIIIIIXYIIYXII\n", + "-0.006 * IIIIIIIIIIIYZZZIZYII\n", + "-0.006 * IIIIIIIIIIIXZZZIZXII\n", + "-0.020 * IIIIIIIIIIIIYZXXZYII\n", + "-0.018 * IIIIIIIIIIIIYZYYZYII\n", + "+0.001 * IIIIIIIIIIIIXZXYZYII\n", + "+0.001 * IIIIIIIIIIIIYZYXZXII\n", + "-0.018 * IIIIIIIIIIIIXZXXZXII\n", + "-0.020 * IIIIIIIIIIIIXZYYZXII\n", + "-0.000 * IIIIIIIIIIIIYXIXZYII\n", + "-0.000 * IIIIIIIIIIIIYYIYZYII\n", + "+0.000 * IIIIIIIIIIIIXXIYZYII\n", + "+0.000 * IIIIIIIIIIIIYYIXZXII\n", + "-0.000 * IIIIIIIIIIIIXXIXZXII\n", + "-0.000 * IIIIIIIIIIIIXYIYZXII\n", + "+0.008 * IIIIIIIIIIIYZZIZZYII\n", + "+0.008 * IIIIIIIIIIIXZZIZZXII\n", + "+0.008 * IIIIIIIIIIIYZIZZZYII\n", + "+0.008 * IIIIIIIIIIIXZIZZZXII\n", + "+0.025 * IIIIIIIIIIIYIZZZZYII\n", + "+0.025 * IIIIIIIIIIIXIZZZZXII\n", + "+0.117 * ZZZZZZZZZZZIIIIIIZII\n", + "+0.007 * ZZZZZZZZZZZYZZZZZYII\n", + "+0.007 * ZZZZZZZZZZZXZZZZZXII\n", + "+0.022 * ZZZZZZZZZZXIYZZZZYII\n", + "-0.022 * IIIIIIIIIIXIYZZZZYII\n", + "+0.022 * ZZZZZZZZZZXIXZZZZXII\n", + "-0.022 * IIIIIIIIIIXIXZZZZXII\n", + "-0.006 * ZZZZZZZZZXIIIIIIIZII\n", + "+0.006 * IIIIIIIIIXZIIIIIIZII\n", + "+0.012 * ZZZZZZZZZXIYZZZZZYII\n", + "-0.012 * IIIIIIIIIXZYZZZZZYII\n", + "+0.012 * ZZZZZZZZZXIXZZZZZXII\n", + "-0.012 * IIIIIIIIIXZXZZZZZXII\n", + "+0.000 * ZZZZZZZZXIIIIIIIYYII\n", + "-0.000 * IIIIIIIIXZZIIIIIYYII\n", + "+0.000 * ZZZZZZZZXIIIIIIIXXII\n", + "-0.000 * IIIIIIIIXZZIIIIIXXII\n", + "+0.004 * ZZZZZZZZXIIIIIIYZYII\n", + "-0.004 * IIIIIIIIXZZIIIIYZYII\n", + "+0.004 * ZZZZZZZZXIIIIIIXZXII\n", + "-0.004 * IIIIIIIIXZZIIIIXZXII\n", + "+0.004 * ZZZZZZZXIIIIIIIIYYII\n", + "-0.004 * IIIIIIIXZZZIIIIIYYII\n", + "+0.004 * ZZZZZZZXIIIIIIIIXXII\n", + "-0.004 * IIIIIIIXZZZIIIIIXXII\n", + "-0.000 * ZZZZZZZXIIIIIIIYZYII\n", + "+0.000 * IIIIIIIXZZZIIIIYZYII\n", + "-0.000 * ZZZZZZZXIIIIIIIXZXII\n", + "+0.000 * IIIIIIIXZZZIIIIXZXII\n", + "-0.005 * ZZZZZZXIIIIIYZZZZYII\n", + "+0.005 * IIIIIIXZZZZIYZZZZYII\n", + "-0.005 * ZZZZZZXIIIIIXZZZZXII\n", + "+0.005 * IIIIIIXZZZZIXZZZZXII\n", + "+0.000 * ZZZZZXIIIIIIIIYZZYII\n", + "-0.000 * IIIIIXZZZZZIIIYZZYII\n", + "+0.000 * ZZZZZXIIIIIIIIXZZXII\n", + "-0.000 * IIIIIXZZZZZIIIXZZXII\n", + "-0.006 * ZZZZZXIIIIIIIYZZZYII\n", + "+0.006 * IIIIIXZZZZZIIYZZZYII\n", + "-0.006 * ZZZZZXIIIIIIIXZZZXII\n", + "+0.006 * IIIIIXZZZZZIIXZZZXII\n", + "-0.006 * ZZZZXIIIIIIIIIYZZYII\n", + "+0.006 * IIIIXZZZZZZIIIYZZYII\n", + "-0.006 * ZZZZXIIIIIIIIIXZZXII\n", + "+0.006 * IIIIXZZZZZZIIIXZZXII\n", + "-0.000 * ZZZZXIIIIIIIIYZZZYII\n", + "+0.000 * IIIIXZZZZZZIIYZZZYII\n", + "-0.000 * ZZZZXIIIIIIIIXZZZXII\n", + "+0.000 * IIIIXZZZZZZIIXZZZXII\n", + "+0.000 * ZZZXIIIIIIIIIIIIYYII\n", + "-0.000 * IIIXZZZZZZZIIIIIYYII\n", + "+0.000 * ZZZXIIIIIIIIIIIIXXII\n", + "-0.000 * IIIXZZZZZZZIIIIIXXII\n", + "-0.005 * ZZZXIIIIIIIIIIIYZYII\n", + "+0.005 * IIIXZZZZZZZIIIIYZYII\n", + "-0.005 * ZZZXIIIIIIIIIIIXZXII\n", + "+0.005 * IIIXZZZZZZZIIIIXZXII\n", + "-0.005 * ZZXIIIIIIIIIIIIIYYII\n", + "+0.005 * IIXZZZZZZZZIIIIIYYII\n", + "-0.005 * ZZXIIIIIIIIIIIIIXXII\n", + "+0.005 * IIXZZZZZZZZIIIIIXXII\n", + "-0.000 * ZZXIIIIIIIIIIIIYZYII\n", + "+0.000 * IIXZZZZZZZZIIIIYZYII\n", + "-0.000 * ZZXIIIIIIIIIIIIXZXII\n", + "+0.000 * IIXZZZZZZZZIIIIXZXII\n", + "-0.008 * ZXIIIIIIIIIIIIIIIZII\n", + "+0.008 * IXZZZZZZZZZIIIIIIZII\n", + "+0.007 * ZXIIIIIIIIIYZZZZZYII\n", + "-0.007 * IXZZZZZZZZZYZZZZZYII\n", + "+0.007 * ZXIIIIIIIIIXZZZZZXII\n", + "-0.007 * IXZZZZZZZZZXZZZZZXII\n", + "+0.008 * XIIIIIIIIIIIYZZZZYII\n", + "-0.008 * XZZZZZZZZZZIYZZZZYII\n", + "+0.008 * XIIIIIIIIIIIXZZZZXII\n", + "-0.008 * XZZZZZZZZZZIXZZZZXII\n", + "+0.121 * IIIIIIIIIIZIIIIIIZII\n", + "+0.004 * IIIIIIIIIIZYZZZZZYII\n", + "+0.004 * IIIIIIIIIIZXZZZZZXII\n", + "+0.010 * IIIIIIIIIYYIYZZZZYII\n", + "+0.010 * IIIIIIIIIXXIYZZZZYII\n", + "+0.010 * IIIIIIIIIYYIXZZZZXII\n", + "+0.010 * IIIIIIIIIXXIXZZZZXII\n", + "+0.006 * IIIIIIIIYZYIIIYZZYII\n", + "+0.006 * IIIIIIIIXZXIIIYZZYII\n", + "+0.006 * IIIIIIIIYZYIIIXZZXII\n", + "+0.006 * IIIIIIIIXZXIIIXZZXII\n", + "+0.000 * IIIIIIIIYZYIIYZZZYII\n", + "+0.000 * IIIIIIIIXZXIIYZZZYII\n", + "+0.000 * IIIIIIIIYZYIIXZZZXII\n", + "+0.000 * IIIIIIIIXZXIIXZZZXII\n", + "-0.000 * IIIIIIIYZZYIIIYZZYII\n", + "-0.000 * IIIIIIIXZZXIIIYZZYII\n", + "-0.000 * IIIIIIIYZZYIIIXZZXII\n", + "-0.000 * IIIIIIIXZZXIIIXZZXII\n", + "+0.006 * IIIIIIIYZZYIIYZZZYII\n", + "+0.006 * IIIIIIIXZZXIIYZZZYII\n", + "+0.006 * IIIIIIIYZZYIIXZZZXII\n", + "+0.006 * IIIIIIIXZZXIIXZZZXII\n", + "+0.004 * IIIIIIYZZZYIIIIIIZII\n", + "+0.004 * IIIIIIXZZZXIIIIIIZII\n", + "-0.012 * IIIIIIYZZZYYZZZZZYII\n", + "-0.012 * IIIIIIXZZZXYZZZZZYII\n", + "-0.012 * IIIIIIYZZZYXZZZZZXII\n", + "-0.012 * IIIIIIXZZZXXZZZZZXII\n", + "-0.006 * IIIIIYZZZZYIIIIIYYII\n", + "-0.006 * IIIIIXZZZZXIIIIIYYII\n", + "-0.006 * IIIIIYZZZZYIIIIIXXII\n", + "-0.006 * IIIIIXZZZZXIIIIIXXII\n", + "-0.006 * IIIIYZZZZZYIIIIYZYII\n", + "-0.006 * IIIIXZZZZZXIIIIYZYII\n", + "-0.006 * IIIIYZZZZZYIIIIXZXII\n", + "-0.006 * IIIIXZZZZZXIIIIXZXII\n", + "-0.003 * IIIYZZZZZZYIIIYZZYII\n", + "-0.003 * IIIXZZZZZZXIIIYZZYII\n", + "-0.003 * IIIYZZZZZZYIIIXZZXII\n", + "-0.003 * IIIXZZZZZZXIIIXZZXII\n", + "-0.003 * IIYZZZZZZZYIIYZZZYII\n", + "-0.003 * IIXZZZZZZZXIIYZZZYII\n", + "-0.003 * IIYZZZZZZZYIIXZZZXII\n", + "-0.003 * IIXZZZZZZZXIIXZZZXII\n", + "+0.009 * IYZZZZZZZZYIYZZZZYII\n", + "+0.009 * IXZZZZZZZZXIYZZZZYII\n", + "+0.009 * IYZZZZZZZZYIXZZZZXII\n", + "+0.009 * IXZZZZZZZZXIXZZZZXII\n", + "-0.004 * YZZZZZZZZZYIIIIIIZII\n", + "-0.004 * XZZZZZZZZZXIIIIIIZII\n", + "+0.011 * YZZZZZZZZZYYZZZZZYII\n", + "+0.011 * XZZZZZZZZZXYZZZZZYII\n", + "+0.011 * YZZZZZZZZZYXZZZZZXII\n", + "+0.011 * XZZZZZZZZZXXZZZZZXII\n", + "+0.128 * IIIIIIIIIZIIIIIIIZII\n", + "-0.006 * IIIIIIIIIZIYZZZZZYII\n", + "-0.006 * IIIIIIIIIZIXZZZZZXII\n", + "+0.000 * IIIIIIIIYYIIIIIIYYII\n", + "+0.000 * IIIIIIIIXXIIIIIIYYII\n", + "+0.000 * IIIIIIIIYYIIIIIIXXII\n", + "+0.000 * IIIIIIIIXXIIIIIIXXII\n", + "+0.006 * IIIIIIIIYYIIIIIYZYII\n", + "+0.006 * IIIIIIIIXXIIIIIYZYII\n", + "+0.006 * IIIIIIIIYYIIIIIXZXII\n", + "+0.006 * IIIIIIIIXXIIIIIXZXII\n", + "+0.006 * IIIIIIIYZYIIIIIIYYII\n", + "+0.006 * IIIIIIIXZXIIIIIIYYII\n", + "+0.006 * IIIIIIIYZYIIIIIIXXII\n", + "+0.006 * IIIIIIIXZXIIIIIIXXII\n", + "-0.000 * IIIIIIIYZYIIIIIYZYII\n", + "-0.000 * IIIIIIIXZXIIIIIYZYII\n", + "-0.000 * IIIIIIIYZYIIIIIXZXII\n", + "-0.000 * IIIIIIIXZXIIIIIXZXII\n", + "-0.031 * IIIIIIYZZYIIYZZZZYII\n", + "-0.031 * IIIIIIXZZXIIYZZZZYII\n", + "-0.031 * IIIIIIYZZYIIXZZZZXII\n", + "-0.031 * IIIIIIXZZXIIXZZZZXII\n", + "+0.000 * IIIIIYZZZYIIIIYZZYII\n", + "+0.000 * IIIIIXZZZXIIIIYZZYII\n", + "+0.000 * IIIIIYZZZYIIIIXZZXII\n", + "+0.000 * IIIIIXZZZXIIIIXZZXII\n", + "-0.006 * IIIIIYZZZYIIIYZZZYII\n", + "-0.006 * IIIIIXZZZXIIIYZZZYII\n", + "-0.006 * IIIIIYZZZYIIIXZZZXII\n", + "-0.006 * IIIIIXZZZXIIIXZZZXII\n", + "-0.006 * IIIIYZZZZYIIIIYZZYII\n", + "-0.006 * IIIIXZZZZXIIIIYZZYII\n", + "-0.006 * IIIIYZZZZYIIIIXZZXII\n", + "-0.006 * IIIIXZZZZXIIIIXZZXII\n", + "-0.000 * IIIIYZZZZYIIIYZZZYII\n", + "-0.000 * IIIIXZZZZXIIIYZZZYII\n", + "-0.000 * IIIIYZZZZYIIIXZZZXII\n", + "-0.000 * IIIIXZZZZXIIIXZZZXII\n", + "+0.000 * IIIYZZZZZYIIIIIIYYII\n", + "+0.000 * IIIXZZZZZXIIIIIIYYII\n", + "+0.000 * IIIYZZZZZYIIIIIIXXII\n", + "+0.000 * IIIXZZZZZXIIIIIIXXII\n", + "-0.006 * IIIYZZZZZYIIIIIYZYII\n", + "-0.006 * IIIXZZZZZXIIIIIYZYII\n", + "-0.006 * IIIYZZZZZYIIIIIXZXII\n", + "-0.006 * IIIXZZZZZXIIIIIXZXII\n", + "-0.006 * IIYZZZZZZYIIIIIIYYII\n", + "-0.006 * IIXZZZZZZXIIIIIIYYII\n", + "-0.006 * IIYZZZZZZYIIIIIIXXII\n", + "-0.006 * IIXZZZZZZXIIIIIIXXII\n", + "-0.000 * IIYZZZZZZYIIIIIYZYII\n", + "-0.000 * IIXZZZZZZXIIIIIYZYII\n", + "-0.000 * IIYZZZZZZYIIIIIXZXII\n", + "-0.000 * IIXZZZZZZXIIIIIXZXII\n", + "+0.013 * IYZZZZZZZYIIIIIIIZII\n", + "+0.013 * IXZZZZZZZXIIIIIIIZII\n", + "-0.014 * IYZZZZZZZYIYZZZZZYII\n", + "-0.014 * IXZZZZZZZXIYZZZZZYII\n", + "-0.014 * IYZZZZZZZYIXZZZZZXII\n", + "-0.014 * IXZZZZZZZXIXZZZZZXII\n", + "-0.008 * YZZZZZZZZYIIYZZZZYII\n", + "-0.008 * XZZZZZZZZXIIYZZZZYII\n", + "-0.008 * YZZZZZZZZYIIXZZZZXII\n", + "-0.008 * XZZZZZZZZXIIXZZZZXII\n", + "+0.111 * IIIIIIIIZIIIIIIIIZII\n", + "+0.008 * IIIIIIIIZIIYZZZZZYII\n", + "+0.008 * IIIIIIIIZIIXZZZZZXII\n", + "-0.003 * IIIIIIYZYIIIIIYZZYII\n", + "-0.003 * IIIIIIXZXIIIIIYZZYII\n", + "-0.003 * IIIIIIYZYIIIIIXZZXII\n", + "-0.003 * IIIIIIXZXIIIIIXZZXII\n", + "-0.000 * IIIIIIYZYIIIIYZZZYII\n", + "-0.000 * IIIIIIXZXIIIIYZZZYII\n", + "-0.000 * IIIIIIYZYIIIIXZZZXII\n", + "-0.000 * IIIIIIXZXIIIIXZZZXII\n", + "-0.001 * IIIIIYZZYIIIYZZZZYII\n", + "-0.001 * IIIIIXZZXIIIYZZZZYII\n", + "-0.001 * IIIIIYZZYIIIXZZZZXII\n", + "-0.001 * IIIIIXZZXIIIXZZZZXII\n", + "-0.021 * IIIIYZZZYIIIYZZZZYII\n", + "-0.021 * IIIIXZZZXIIIYZZZZYII\n", + "-0.021 * IIIIYZZZYIIIXZZZZXII\n", + "-0.021 * IIIIXZZZXIIIXZZZZXII\n", + "+0.011 * IIIYZZZZYIIIIIIIIZII\n", + "+0.011 * IIIXZZZZXIIIIIIIIZII\n", + "-0.015 * IIIYZZZZYIIYZZZZZYII\n", + "-0.015 * IIIXZZZZXIIYZZZZZYII\n", + "-0.015 * IIIYZZZZYIIXZZZZZXII\n", + "-0.015 * IIIXZZZZXIIXZZZZZXII\n", + "+0.001 * IIYZZZZZYIIIIIIIIZII\n", + "+0.001 * IIXZZZZZXIIIIIIIIZII\n", + "-0.001 * IIYZZZZZYIIYZZZZZYII\n", + "-0.001 * IIXZZZZZXIIYZZZZZYII\n", + "-0.001 * IIYZZZZZYIIXZZZZZXII\n", + "-0.001 * IIXZZZZZXIIXZZZZZXII\n", + "-0.000 * IYZZZZZZYIIIIIIIYYII\n", + "-0.000 * IXZZZZZZXIIIIIIIYYII\n", + "-0.000 * IYZZZZZZYIIIIIIIXXII\n", + "-0.000 * IXZZZZZZXIIIIIIIXXII\n", + "-0.000 * IYZZZZZZYIIIIIIYZYII\n", + "-0.000 * IXZZZZZZXIIIIIIYZYII\n", + "-0.000 * IYZZZZZZYIIIIIIXZXII\n", + "-0.000 * IXZZZZZZXIIIIIIXZXII\n", + "-0.001 * YZZZZZZZYIIIIIYZZYII\n", + "-0.001 * XZZZZZZZXIIIIIYZZYII\n", + "-0.001 * YZZZZZZZYIIIIIXZZXII\n", + "-0.001 * XZZZZZZZXIIIIIXZZXII\n", + "-0.000 * YZZZZZZZYIIIIYZZZYII\n", + "-0.000 * XZZZZZZZXIIIIYZZZYII\n", + "-0.000 * YZZZZZZZYIIIIXZZZXII\n", + "-0.000 * XZZZZZZZXIIIIXZZZXII\n", + "+0.111 * IIIIIIIZIIIIIIIIIZII\n", + "+0.008 * IIIIIIIZIIIYZZZZZYII\n", + "+0.008 * IIIIIIIZIIIXZZZZZXII\n", + "+0.000 * IIIIIIYYIIIIIIYZZYII\n", + "+0.000 * IIIIIIXXIIIIIIYZZYII\n", + "+0.000 * IIIIIIYYIIIIIIXZZXII\n", + "+0.000 * IIIIIIXXIIIIIIXZZXII\n", + "-0.003 * IIIIIIYYIIIIIYZZZYII\n", + "-0.003 * IIIIIIXXIIIIIYZZZYII\n", + "-0.003 * IIIIIIYYIIIIIXZZZXII\n", + "-0.003 * IIIIIIXXIIIIIXZZZXII\n", + "-0.021 * IIIIIYZYIIIIYZZZZYII\n", + "-0.021 * IIIIIXZXIIIIYZZZZYII\n", + "-0.021 * IIIIIYZYIIIIXZZZZXII\n", + "-0.021 * IIIIIXZXIIIIXZZZZXII\n", + "+0.001 * IIIIYZZYIIIIYZZZZYII\n", + "+0.001 * IIIIXZZXIIIIYZZZZYII\n", + "+0.001 * IIIIYZZYIIIIXZZZZXII\n", + "+0.001 * IIIIXZZXIIIIXZZZZXII\n", + "-0.001 * IIIYZZZYIIIIIIIIIZII\n", + "-0.001 * IIIXZZZXIIIIIIIIIZII\n", + "+0.001 * IIIYZZZYIIIYZZZZZYII\n", + "+0.001 * IIIXZZZXIIIYZZZZZYII\n", + "+0.001 * IIIYZZZYIIIXZZZZZXII\n", + "+0.001 * IIIXZZZXIIIXZZZZZXII\n", + "+0.011 * IIYZZZZYIIIIIIIIIZII\n", + "+0.011 * IIXZZZZXIIIIIIIIIZII\n", + "-0.015 * IIYZZZZYIIIYZZZZZYII\n", + "-0.015 * IIXZZZZXIIIYZZZZZYII\n", + "-0.015 * IIYZZZZYIIIXZZZZZXII\n", + "-0.015 * IIXZZZZXIIIXZZZZZXII\n", + "-0.000 * IYZZZZZYIIIIIIIIYYII\n", + "-0.000 * IXZZZZZXIIIIIIIIYYII\n", + "-0.000 * IYZZZZZYIIIIIIIIXXII\n", + "-0.000 * IXZZZZZXIIIIIIIIXXII\n", + "+0.000 * IYZZZZZYIIIIIIIYZYII\n", + "+0.000 * IXZZZZZXIIIIIIIYZYII\n", + "+0.000 * IYZZZZZYIIIIIIIXZXII\n", + "+0.000 * IXZZZZZXIIIIIIIXZXII\n", + "+0.000 * YZZZZZZYIIIIIIYZZYII\n", + "+0.000 * XZZZZZZXIIIIIIYZZYII\n", + "+0.000 * YZZZZZZYIIIIIIXZZXII\n", + "+0.000 * XZZZZZZXIIIIIIXZZXII\n", + "-0.001 * YZZZZZZYIIIIIYZZZYII\n", + "-0.001 * XZZZZZZXIIIIIYZZZYII\n", + "-0.001 * YZZZZZZYIIIIIXZZZXII\n", + "-0.001 * XZZZZZZXIIIIIXZZZXII\n", + "+0.133 * IIIIIIZIIIIIIIIIIZII\n", + "-0.007 * IIIIIIZIIIIYZZZZZYII\n", + "-0.007 * IIIIIIZIIIIXZZZZZXII\n", + "+0.008 * IIIIIYYIIIIIIIIIYYII\n", + "+0.008 * IIIIIXXIIIIIIIIIYYII\n", + "+0.008 * IIIIIYYIIIIIIIIIXXII\n", + "+0.008 * IIIIIXXIIIIIIIIIXXII\n", + "+0.008 * IIIIYZYIIIIIIIIYZYII\n", + "+0.008 * IIIIXZXIIIIIIIIYZYII\n", + "+0.008 * IIIIYZYIIIIIIIIXZXII\n", + "+0.008 * IIIIXZXIIIIIIIIXZXII\n", + "+0.006 * IIIYZZYIIIIIIIYZZYII\n", + "+0.006 * IIIXZZXIIIIIIIYZZYII\n", + "+0.006 * IIIYZZYIIIIIIIXZZXII\n", + "+0.006 * IIIXZZXIIIIIIIXZZXII\n", + "+0.006 * IIYZZZYIIIIIIYZZZYII\n", + "+0.006 * IIXZZZXIIIIIIYZZZYII\n", + "+0.006 * IIYZZZYIIIIIIXZZZXII\n", + "+0.006 * IIXZZZXIIIIIIXZZZXII\n", + "+0.017 * IYZZZZYIIIIIYZZZZYII\n", + "+0.017 * IXZZZZXIIIIIYZZZZYII\n", + "+0.017 * IYZZZZYIIIIIXZZZZXII\n", + "+0.017 * IXZZZZXIIIIIXZZZZXII\n", + "-0.007 * YZZZZZYIIIIIIIIIIZII\n", + "-0.007 * XZZZZZXIIIIIIIIIIZII\n", + "+0.016 * YZZZZZYIIIIYZZZZZYII\n", + "+0.016 * XZZZZZXIIIIYZZZZZYII\n", + "+0.016 * YZZZZZYIIIIXZZZZZXII\n", + "+0.016 * XZZZZZXIIIIXZZZZZXII\n", + "+0.122 * IIIIIZIIIIIIIIIIIZII\n", + "-0.006 * IIIIIZIIIIIYZZZZZYII\n", + "-0.006 * IIIIIZIIIIIXZZZZZXII\n", + "-0.000 * IIIYZYIIIIIIYZZZZYII\n", + "-0.000 * IIIXZXIIIIIIYZZZZYII\n", + "-0.000 * IIIYZYIIIIIIXZZZZXII\n", + "-0.000 * IIIXZXIIIIIIXZZZZXII\n", + "+0.019 * IIYZZYIIIIIIYZZZZYII\n", + "+0.019 * IIXZZXIIIIIIYZZZZYII\n", + "+0.019 * IIYZZYIIIIIIXZZZZXII\n", + "+0.019 * IIXZZXIIIIIIXZZZZXII\n", + "+0.000 * IYZZZYIIIIIIIIYZZYII\n", + "+0.000 * IXZZZXIIIIIIIIYZZYII\n", + "+0.000 * IYZZZYIIIIIIIIXZZXII\n", + "+0.000 * IXZZZXIIIIIIIIXZZXII\n", + "-0.000 * IYZZZYIIIIIIIYZZZYII\n", + "-0.000 * IXZZZXIIIIIIIYZZZYII\n", + "-0.000 * IYZZZYIIIIIIIXZZZXII\n", + "-0.000 * IXZZZXIIIIIIIXZZZXII\n", + "-0.001 * YZZZZYIIIIIIIIIIYYII\n", + "-0.001 * XZZZZXIIIIIIIIIIYYII\n", + "-0.001 * YZZZZYIIIIIIIIIIXXII\n", + "-0.001 * XZZZZXIIIIIIIIIIXXII\n", + "+0.122 * IIIIZIIIIIIIIIIIIZII\n", + "-0.006 * IIIIZIIIIIIYZZZZZYII\n", + "-0.006 * IIIIZIIIIIIXZZZZZXII\n", + "+0.019 * IIIYYIIIIIIIYZZZZYII\n", + "+0.019 * IIIXXIIIIIIIYZZZZYII\n", + "+0.019 * IIIYYIIIIIIIXZZZZXII\n", + "+0.019 * IIIXXIIIIIIIXZZZZXII\n", + "+0.000 * IIYZYIIIIIIIYZZZZYII\n", + "+0.000 * IIXZXIIIIIIIYZZZZYII\n", + "+0.000 * IIYZYIIIIIIIXZZZZXII\n", + "+0.000 * IIXZXIIIIIIIXZZZZXII\n", + "-0.000 * IYZZYIIIIIIIIIYZZYII\n", + "-0.000 * IXZZXIIIIIIIIIYZZYII\n", + "-0.000 * IYZZYIIIIIIIIIXZZXII\n", + "-0.000 * IXZZXIIIIIIIIIXZZXII\n", + "-0.000 * IYZZYIIIIIIIIYZZZYII\n", + "-0.000 * IXZZXIIIIIIIIYZZZYII\n", + "-0.000 * IYZZYIIIIIIIIXZZZXII\n", + "-0.000 * IXZZXIIIIIIIIXZZZXII\n", + "-0.001 * YZZZYIIIIIIIIIIYZYII\n", + "-0.001 * XZZZXIIIIIIIIIIYZYII\n", + "-0.001 * YZZZYIIIIIIIIIIXZXII\n", + "-0.001 * XZZZXIIIIIIIIIIXZXII\n", + "+0.113 * IIIZIIIIIIIIIIIIIZII\n", + "+0.011 * IIIZIIIIIIIYZZZZZYII\n", + "+0.011 * IIIZIIIIIIIXZZZZZXII\n", + "-0.000 * IYZYIIIIIIIIIIIIYYII\n", + "-0.000 * IXZXIIIIIIIIIIIIYYII\n", + "-0.000 * IYZYIIIIIIIIIIIIXXII\n", + "-0.000 * IXZXIIIIIIIIIIIIXXII\n", + "+0.001 * IYZYIIIIIIIIIIIYZYII\n", + "+0.001 * IXZXIIIIIIIIIIIYZYII\n", + "+0.001 * IYZYIIIIIIIIIIIXZXII\n", + "+0.001 * IXZXIIIIIIIIIIIXZXII\n", + "-0.003 * YZZYIIIIIIIIIIYZZYII\n", + "-0.003 * XZZXIIIIIIIIIIYZZYII\n", + "-0.003 * YZZYIIIIIIIIIIXZZXII\n", + "-0.003 * XZZXIIIIIIIIIIXZZXII\n", + "+0.113 * IIZIIIIIIIIIIIIIIZII\n", + "+0.011 * IIZIIIIIIIIYZZZZZYII\n", + "+0.011 * IIZIIIIIIIIXZZZZZXII\n", + "+0.001 * IYYIIIIIIIIIIIIIYYII\n", + "+0.001 * IXXIIIIIIIIIIIIIYYII\n", + "+0.001 * IYYIIIIIIIIIIIIIXXII\n", + "+0.001 * IXXIIIIIIIIIIIIIXXII\n", + "+0.000 * IYYIIIIIIIIIIIIYZYII\n", + "+0.000 * IXXIIIIIIIIIIIIYZYII\n", + "+0.000 * IYYIIIIIIIIIIIIXZXII\n", + "+0.000 * IXXIIIIIIIIIIIIXZXII\n", + "-0.003 * YZYIIIIIIIIIIYZZZYII\n", + "-0.003 * XZXIIIIIIIIIIYZZZYII\n", + "-0.003 * YZYIIIIIIIIIIXZZZXII\n", + "-0.003 * XZXIIIIIIIIIIXZZZXII\n", + "+0.118 * IZIIIIIIIIIIIIIIIZII\n", + "+0.006 * IZIIIIIIIIIYZZZZZYII\n", + "+0.006 * IZIIIIIIIIIXZZZZZXII\n", + "+0.019 * YYIIIIIIIIIIYZZZZYII\n", + "+0.019 * XXIIIIIIIIIIYZZZZYII\n", + "+0.019 * YYIIIIIIIIIIXZZZZXII\n", + "+0.019 * XXIIIIIIIIIIXZZZZXII\n", + "+0.126 * ZIIIIIIIIIIIIIIIIZII\n", + "+0.016 * ZIIIIIIIIIIYZZZZZYII\n", + "+0.016 * ZIIIIIIIIIIXZZZZZXII\n", + "+0.120 * IIIIIIIIIIIIIIIZZIII\n", + "+0.109 * IIIIIIIIIIIIIIZIZIII\n", + "-0.000 * IIIIIIIIIIIIIYYIZIII\n", + "-0.000 * IIIIIIIIIIIIIXXIZIII\n", + "+0.081 * IIIIIIIIIIIIIZIIZIII\n", + "+0.115 * IIIIIIIIIIIIZIIIZIII\n", + "+0.119 * IIIIIIIIIIIZIIIIZIII\n", + "-0.000 * IIIIIIIIIIIIIIZYYIII\n", + "-0.000 * IIIIIIIIIIIIIIZXXIII\n", + "-0.029 * IIIIIIIIIIIIIYXXYIII\n", + "-0.028 * IIIIIIIIIIIIIYYYYIII\n", + "+0.001 * IIIIIIIIIIIIIXXYYIII\n", + "+0.001 * IIIIIIIIIIIIIYYXXIII\n", + "-0.028 * IIIIIIIIIIIIIXXXXIII\n", + "-0.029 * IIIIIIIIIIIIIXYYXIII\n", + "+0.000 * IIIIIIIIIIIIIZIYYIII\n", + "+0.000 * IIIIIIIIIIIIIZIXXIII\n", + "-0.000 * IIIIIIIIIIIYXIXZYIII\n", + "-0.000 * IIIIIIIIIIIYYIYZYIII\n", + "-0.000 * IIIIIIIIIIIXXIYZYIII\n", + "-0.000 * IIIIIIIIIIIYYIXZXIII\n", + "-0.000 * IIIIIIIIIIIXXIXZXIII\n", + "-0.000 * IIIIIIIIIIIXYIYZXIII\n", + "+0.000 * IIIIIIIIIIIYXXZZYIII\n", + "+0.026 * IIIIIIIIIIIYYYZZYIII\n", + "+0.026 * IIIIIIIIIIIXXYZZYIII\n", + "+0.026 * IIIIIIIIIIIYYXZZXIII\n", + "+0.026 * IIIIIIIIIIIXXXZZXIII\n", + "+0.000 * IIIIIIIIIIIXYYZZXIII\n", + "+0.122 * ZZZZZZZZZZZIIIIIZIII\n", + "-0.001 * ZZZZZZZZZZXIIIYZYIII\n", + "+0.001 * IIIIIIIIIIXIIIYZYIII\n", + "-0.001 * ZZZZZZZZZZXIIIXZXIII\n", + "+0.001 * IIIIIIIIIIXIIIXZXIII\n", + "+0.038 * ZZZZZZZZZZXIIYZZYIII\n", + "-0.038 * IIIIIIIIIIXIIYZZYIII\n", + "+0.038 * ZZZZZZZZZZXIIXZZXIII\n", + "-0.038 * IIIIIIIIIIXIIXZZXIII\n", + "-0.007 * ZZZZZZZZZXIIIIIIZIII\n", + "+0.007 * IIIIIIIIIXZIIIIIZIII\n", + "-0.000 * ZZZZZZZZXIIYZZZZYIII\n", + "+0.000 * IIIIIIIIXZZYZZZZYIII\n", + "-0.000 * ZZZZZZZZXIIXZZZZXIII\n", + "+0.000 * IIIIIIIIXZZXZZZZXIII\n", + "-0.005 * ZZZZZZZXIIIYZZZZYIII\n", + "+0.005 * IIIIIIIXZZZYZZZZYIII\n", + "-0.005 * ZZZZZZZXIIIXZZZZXIII\n", + "+0.005 * IIIIIIIXZZZXZZZZXIII\n", + "+0.000 * ZZZZZZXIIIIIIIYZYIII\n", + "-0.000 * IIIIIIXZZZZIIIYZYIII\n", + "+0.000 * ZZZZZZXIIIIIIIXZXIII\n", + "-0.000 * IIIIIIXZZZZIIIXZXIII\n", + "-0.007 * ZZZZZZXIIIIIIYZZYIII\n", + "+0.007 * IIIIIIXZZZZIIYZZYIII\n", + "-0.007 * ZZZZZZXIIIIIIXZZXIII\n", + "+0.007 * IIIIIIXZZZZIIXZZXIII\n", + "+0.006 * ZZZZZXIIIIIIYZZZYIII\n", + "-0.006 * IIIIIXZZZZZIYZZZYIII\n", + "+0.006 * ZZZZZXIIIIIIXZZZXIII\n", + "-0.006 * IIIIIXZZZZZIXZZZXIII\n", + "-0.000 * ZZZXIIIIIIIYZZZZYIII\n", + "+0.000 * IIIXZZZZZZZYZZZZYIII\n", + "-0.000 * ZZZXIIIIIIIXZZZZXIII\n", + "+0.000 * IIIXZZZZZZZXZZZZXIII\n", + "+0.004 * ZZXIIIIIIIIYZZZZYIII\n", + "-0.004 * IIXZZZZZZZZYZZZZYIII\n", + "+0.004 * ZZXIIIIIIIIXZZZZXIII\n", + "-0.004 * IIXZZZZZZZZXZZZZXIII\n", + "-0.017 * ZXIIIIIIIIIIIIIIZIII\n", + "+0.017 * IXZZZZZZZZZIIIIIZIII\n", + "-0.000 * XIIIIIIIIIIIIIYZYIII\n", + "+0.000 * XZZZZZZZZZZIIIYZYIII\n", + "-0.000 * XIIIIIIIIIIIIIXZXIII\n", + "+0.000 * XZZZZZZZZZZIIIXZXIII\n", + "+0.013 * XIIIIIIIIIIIIYZZYIII\n", + "-0.013 * XZZZZZZZZZZIIYZZYIII\n", + "+0.013 * XIIIIIIIIIIIIXZZXIII\n", + "-0.013 * XZZZZZZZZZZIIXZZXIII\n", + "+0.126 * IIIIIIIIIIZIIIIIZIII\n", + "-0.000 * IIIIIIIIIYYIIIYZYIII\n", + "-0.000 * IIIIIIIIIXXIIIYZYIII\n", + "-0.000 * IIIIIIIIIYYIIIXZXIII\n", + "-0.000 * IIIIIIIIIXXIIIXZXIII\n", + "+0.016 * IIIIIIIIIYYIIYZZYIII\n", + "+0.016 * IIIIIIIIIXXIIYZZYIII\n", + "+0.016 * IIIIIIIIIYYIIXZZXIII\n", + "+0.016 * IIIIIIIIIXXIIXZZXIII\n", + "-0.000 * IIIIIIIIYZYIYZZZYIII\n", + "-0.000 * IIIIIIIIXZXIYZZZYIII\n", + "-0.000 * IIIIIIIIYZYIXZZZXIII\n", + "-0.000 * IIIIIIIIXZXIXZZZXIII\n", + "-0.005 * IIIIIIIYZZYIYZZZYIII\n", + "-0.005 * IIIIIIIXZZXIYZZZYIII\n", + "-0.005 * IIIIIIIYZZYIXZZZXIII\n", + "-0.005 * IIIIIIIXZZXIXZZZXIII\n", + "+0.001 * IIIIIIYZZZYIIIIIZIII\n", + "+0.001 * IIIIIIXZZZXIIIIIZIII\n", + "+0.007 * IIIIIYZZZZYYZZZZYIII\n", + "+0.007 * IIIIIXZZZZXYZZZZYIII\n", + "+0.007 * IIIIIYZZZZYXZZZZXIII\n", + "+0.007 * IIIIIXZZZZXXZZZZXIII\n", + "-0.000 * IIIYZZZZZZYIYZZZYIII\n", + "-0.000 * IIIXZZZZZZXIYZZZYIII\n", + "-0.000 * IIIYZZZZZZYIXZZZXIII\n", + "-0.000 * IIIXZZZZZZXIXZZZXIII\n", + "+0.003 * IIYZZZZZZZYIYZZZYIII\n", + "+0.003 * IIXZZZZZZZXIYZZZYIII\n", + "+0.003 * IIYZZZZZZZYIXZZZXIII\n", + "+0.003 * IIXZZZZZZZXIXZZZXIII\n", + "-0.000 * IYZZZZZZZZYIIIYZYIII\n", + "-0.000 * IXZZZZZZZZXIIIYZYIII\n", + "-0.000 * IYZZZZZZZZYIIIXZXIII\n", + "-0.000 * IXZZZZZZZZXIIIXZXIII\n", + "+0.015 * IYZZZZZZZZYIIYZZYIII\n", + "+0.015 * IXZZZZZZZZXIIYZZYIII\n", + "+0.015 * IYZZZZZZZZYIIXZZXIII\n", + "+0.015 * IXZZZZZZZZXIIXZZXIII\n", + "-0.015 * YZZZZZZZZZYIIIIIZIII\n", + "-0.015 * XZZZZZZZZZXIIIIIZIII\n", + "+0.118 * IIIIIIIIIZIIIIIIZIII\n", + "-0.000 * IIIIIIIIYYIYZZZZYIII\n", + "-0.000 * IIIIIIIIXXIYZZZZYIII\n", + "-0.000 * IIIIIIIIYYIXZZZZXIII\n", + "-0.000 * IIIIIIIIXXIXZZZZXIII\n", + "-0.001 * IIIIIIIYZYIYZZZZYIII\n", + "-0.001 * IIIIIIIXZXIYZZZZYIII\n", + "-0.001 * IIIIIIIYZYIXZZZZXIII\n", + "-0.001 * IIIIIIIXZXIXZZZZXIII\n", + "+0.001 * IIIIIIYZZYIIIIYZYIII\n", + "+0.001 * IIIIIIXZZXIIIIYZYIII\n", + "+0.001 * IIIIIIYZZYIIIIXZXIII\n", + "+0.001 * IIIIIIXZZXIIIIXZXIII\n", + "-0.042 * IIIIIIYZZYIIIYZZYIII\n", + "-0.042 * IIIIIIXZZXIIIYZZYIII\n", + "-0.042 * IIIIIIYZZYIIIXZZXIII\n", + "-0.042 * IIIIIIXZZXIIIXZZXIII\n", + "+0.001 * IIIIIYZZZYIIYZZZYIII\n", + "+0.001 * IIIIIXZZZXIIYZZZYIII\n", + "+0.001 * IIIIIYZZZYIIXZZZXIII\n", + "+0.001 * IIIIIXZZZXIIXZZZXIII\n", + "-0.000 * IIIYZZZZZYIYZZZZYIII\n", + "-0.000 * IIIXZZZZZXIYZZZZYIII\n", + "-0.000 * IIIYZZZZZYIXZZZZXIII\n", + "-0.000 * IIIXZZZZZXIXZZZZXIII\n", + "+0.002 * IIYZZZZZZYIYZZZZYIII\n", + "+0.002 * IIXZZZZZZXIYZZZZYIII\n", + "+0.002 * IIYZZZZZZYIXZZZZXIII\n", + "+0.002 * IIXZZZZZZXIXZZZZXIII\n", + "+0.008 * IYZZZZZZZYIIIIIIZIII\n", + "+0.008 * IXZZZZZZZXIIIIIIZIII\n", + "+0.000 * YZZZZZZZZYIIIIYZYIII\n", + "+0.000 * XZZZZZZZZXIIIIYZYIII\n", + "+0.000 * YZZZZZZZZYIIIIXZXIII\n", + "+0.000 * XZZZZZZZZXIIIIXZXIII\n", + "-0.006 * YZZZZZZZZYIIIYZZYIII\n", + "-0.006 * XZZZZZZZZXIIIYZZYIII\n", + "-0.006 * YZZZZZZZZYIIIXZZXIII\n", + "-0.006 * XZZZZZZZZXIIIXZZXIII\n", + "+0.112 * IIIIIIIIZIIIIIIIZIII\n", + "-0.000 * IIIIIIIIZIIIIIIYYIII\n", + "-0.000 * IIIIIIIIZIIIIIIXXIII\n", + "-0.000 * IIIIIIIYYIIIIIIIZIII\n", + "-0.000 * IIIIIIIXXIIIIIIIZIII\n", + "+0.004 * IIIIIIIYYIIIIIIYYIII\n", + "+0.004 * IIIIIIIXXIIIIIIYYIII\n", + "+0.004 * IIIIIIIYYIIIIIIXXIII\n", + "+0.004 * IIIIIIIXXIIIIIIXXIII\n", + "-0.000 * IIIIIIYZYIIIYZZZYIII\n", + "-0.000 * IIIIIIXZXIIIYZZZYIII\n", + "-0.000 * IIIIIIYZYIIIXZZZXIII\n", + "-0.000 * IIIIIIXZXIIIXZZZXIII\n", + "-0.003 * IIIIIYZZYIIIIIYZYIII\n", + "-0.003 * IIIIIXZZXIIIIIYZYIII\n", + "-0.003 * IIIIIYZZYIIIIIXZXIII\n", + "-0.003 * IIIIIXZZXIIIIIXZXIII\n", + "-0.001 * IIIIIYZZYIIIIYZZYIII\n", + "-0.001 * IIIIIXZZXIIIIYZZYIII\n", + "-0.001 * IIIIIYZZYIIIIXZZXIII\n", + "-0.001 * IIIIIXZZXIIIIXZZXIII\n", + "+0.001 * IIIIYZZZYIIIIIYZYIII\n", + "+0.001 * IIIIXZZZXIIIIIYZYIII\n", + "+0.001 * IIIIYZZZYIIIIIXZXIII\n", + "+0.001 * IIIIXZZZXIIIIIXZXIII\n", + "-0.035 * IIIIYZZZYIIIIYZZYIII\n", + "-0.035 * IIIIXZZZXIIIIYZZYIII\n", + "-0.035 * IIIIYZZZYIIIIXZZXIII\n", + "-0.035 * IIIIXZZZXIIIIXZZXIII\n", + "+0.016 * IIIYZZZZYIIIIIIIZIII\n", + "+0.016 * IIIXZZZZXIIIIIIIZIII\n", + "-0.000 * IIIYZZZZYIIIIIIYYIII\n", + "-0.000 * IIIXZZZZXIIIIIIYYIII\n", + "-0.000 * IIIYZZZZYIIIIIIXXIII\n", + "-0.000 * IIIXZZZZXIIIIIIXXIII\n", + "+0.001 * IIYZZZZZYIIIIIIIZIII\n", + "+0.001 * IIXZZZZZXIIIIIIIZIII\n", + "-0.003 * IIYZZZZZYIIIIIIYYIII\n", + "-0.003 * IIXZZZZZXIIIIIIYYIII\n", + "-0.003 * IIYZZZZZYIIIIIIXXIII\n", + "-0.003 * IIXZZZZZXIIIIIIXXIII\n", + "-0.000 * IYZZZZZZYIIYZZZZYIII\n", + "-0.000 * IXZZZZZZXIIYZZZZYIII\n", + "-0.000 * IYZZZZZZYIIXZZZZXIII\n", + "-0.000 * IXZZZZZZXIIXZZZZXIII\n", + "-0.000 * YZZZZZZZYIIIYZZZYIII\n", + "-0.000 * XZZZZZZZXIIIYZZZYIII\n", + "-0.000 * YZZZZZZZYIIIXZZZXIII\n", + "-0.000 * XZZZZZZZXIIIXZZZXIII\n", + "+0.119 * IIIIIIIZIIIIIIIIZIII\n", + "+0.000 * IIIIIIIZIIIIIIIYYIII\n", + "+0.000 * IIIIIIIZIIIIIIIXXIII\n", + "-0.001 * IIIIIIYYIIIIYZZZYIII\n", + "-0.001 * IIIIIIXXIIIIYZZZYIII\n", + "-0.001 * IIIIIIYYIIIIXZZZXIII\n", + "-0.001 * IIIIIIXXIIIIXZZZXIII\n", + "+0.001 * IIIIIYZYIIIIIIYZYIII\n", + "+0.001 * IIIIIXZXIIIIIIYZYIII\n", + "+0.001 * IIIIIYZYIIIIIIXZXIII\n", + "+0.001 * IIIIIXZXIIIIIIXZXIII\n", + "-0.041 * IIIIIYZYIIIIIYZZYIII\n", + "-0.041 * IIIIIXZXIIIIIYZZYIII\n", + "-0.041 * IIIIIYZYIIIIIXZZXIII\n", + "-0.041 * IIIIIXZXIIIIIXZZXIII\n", + "-0.003 * IIIIYZZYIIIIIIYZYIII\n", + "-0.003 * IIIIXZZXIIIIIIYZYIII\n", + "-0.003 * IIIIYZZYIIIIIIXZXIII\n", + "-0.003 * IIIIXZZXIIIIIIXZXIII\n", + "+0.001 * IIIIYZZYIIIIIYZZYIII\n", + "+0.001 * IIIIXZZXIIIIIYZZYIII\n", + "+0.001 * IIIIYZZYIIIIIXZZXIII\n", + "+0.001 * IIIIXZZXIIIIIXZZXIII\n", + "-0.001 * IIIYZZZYIIIIIIIIZIII\n", + "-0.001 * IIIXZZZXIIIIIIIIZIII\n", + "-0.003 * IIIYZZZYIIIIIIIYYIII\n", + "-0.003 * IIIXZZZXIIIIIIIYYIII\n", + "-0.003 * IIIYZZZYIIIIIIIXXIII\n", + "-0.003 * IIIXZZZXIIIIIIIXXIII\n", + "+0.021 * IIYZZZZYIIIIIIIIZIII\n", + "+0.021 * IIXZZZZXIIIIIIIIZIII\n", + "+0.000 * IIYZZZZYIIIIIIIYYIII\n", + "+0.000 * IIXZZZZXIIIIIIIYYIII\n", + "+0.000 * IIYZZZZYIIIIIIIXXIII\n", + "+0.000 * IIXZZZZXIIIIIIIXXIII\n", + "-0.004 * IYZZZZZYIIIYZZZZYIII\n", + "-0.004 * IXZZZZZXIIIYZZZZYIII\n", + "-0.004 * IYZZZZZYIIIXZZZZXIII\n", + "-0.004 * IXZZZZZXIIIXZZZZXIII\n", + "-0.003 * YZZZZZZYIIIIYZZZYIII\n", + "-0.003 * XZZZZZZXIIIIYZZZYIII\n", + "-0.003 * YZZZZZZYIIIIXZZZXIII\n", + "-0.003 * XZZZZZZXIIIIXZZZXIII\n", + "+0.122 * IIIIIIZIIIIIIIIIZIII\n", + "-0.001 * IIIIIYYIIIIYZZZZYIII\n", + "-0.001 * IIIIIXXIIIIYZZZZYIII\n", + "-0.001 * IIIIIYYIIIIXZZZZXIII\n", + "-0.001 * IIIIIXXIIIIXZZZZXIII\n", + "+0.000 * IIIYZZYIIIIIYZZZYIII\n", + "+0.000 * IIIXZZXIIIIIYZZZYIII\n", + "+0.000 * IIIYZZYIIIIIXZZZXIII\n", + "+0.000 * IIIXZZXIIIIIXZZZXIII\n", + "-0.000 * IIYZZZYIIIIIYZZZYIII\n", + "-0.000 * IIXZZZXIIIIIYZZZYIII\n", + "-0.000 * IIYZZZYIIIIIXZZZXIII\n", + "-0.000 * IIXZZZXIIIIIXZZZXIII\n", + "-0.000 * IYZZZZYIIIIIIIYZYIII\n", + "-0.000 * IXZZZZXIIIIIIIYZYIII\n", + "-0.000 * IYZZZZYIIIIIIIXZXIII\n", + "-0.000 * IXZZZZXIIIIIIIXZXIII\n", + "+0.019 * IYZZZZYIIIIIIYZZYIII\n", + "+0.019 * IXZZZZXIIIIIIYZZYIII\n", + "+0.019 * IYZZZZYIIIIIIXZZXIII\n", + "+0.019 * IXZZZZXIIIIIIXZZXIII\n", + "-0.006 * YZZZZZYIIIIIIIIIZIII\n", + "-0.006 * XZZZZZXIIIIIIIIIZIII\n", + "+0.138 * IIIIIZIIIIIIIIIIZIII\n", + "+0.006 * IIIIYYIIIIIIIIIYYIII\n", + "+0.006 * IIIIXXIIIIIIIIIYYIII\n", + "+0.006 * IIIIYYIIIIIIIIIXXIII\n", + "+0.006 * IIIIXXIIIIIIIIIXXIII\n", + "+0.003 * IIIYZYIIIIIIIIYZYIII\n", + "+0.003 * IIIXZXIIIIIIIIYZYIII\n", + "+0.003 * IIIYZYIIIIIIIIXZXIII\n", + "+0.003 * IIIXZXIIIIIIIIXZXIII\n", + "-0.001 * IIIYZYIIIIIIIYZZYIII\n", + "-0.001 * IIIXZXIIIIIIIYZZYIII\n", + "-0.001 * IIIYZYIIIIIIIXZZXIII\n", + "-0.001 * IIIXZXIIIIIIIXZZXIII\n", + "-0.001 * IIYZZYIIIIIIIIYZYIII\n", + "-0.001 * IIXZZXIIIIIIIIYZYIII\n", + "-0.001 * IIYZZYIIIIIIIIXZXIII\n", + "-0.001 * IIXZZXIIIIIIIIXZXIII\n", + "+0.037 * IIYZZYIIIIIIIYZZYIII\n", + "+0.037 * IIXZZXIIIIIIIYZZYIII\n", + "+0.037 * IIYZZYIIIIIIIXZZXIII\n", + "+0.037 * IIXZZXIIIIIIIXZZXIII\n", + "+0.005 * IYZZZYIIIIIIYZZZYIII\n", + "+0.005 * IXZZZXIIIIIIYZZZYIII\n", + "+0.005 * IYZZZYIIIIIIXZZZXIII\n", + "+0.005 * IXZZZXIIIIIIXZZZXIII\n", + "+0.005 * YZZZZYIIIIIYZZZZYIII\n", + "+0.005 * XZZZZXIIIIIYZZZZYIII\n", + "+0.005 * YZZZZYIIIIIXZZZZXIII\n", + "+0.005 * XZZZZXIIIIIXZZZZXIII\n", + "+0.126 * IIIIZIIIIIIIIIIIZIII\n", + "-0.001 * IIIYYIIIIIIIIIYZYIII\n", + "-0.001 * IIIXXIIIIIIIIIYZYIII\n", + "-0.001 * IIIYYIIIIIIIIIXZXIII\n", + "-0.001 * IIIXXIIIIIIIIIXZXIII\n", + "+0.031 * IIIYYIIIIIIIIYZZYIII\n", + "+0.031 * IIIXXIIIIIIIIYZZYIII\n", + "+0.031 * IIIYYIIIIIIIIXZZXIII\n", + "+0.031 * IIIXXIIIIIIIIXZZXIII\n", + "+0.003 * IIYZYIIIIIIIIIYZYIII\n", + "+0.003 * IIXZXIIIIIIIIIYZYIII\n", + "+0.003 * IIYZYIIIIIIIIIXZXIII\n", + "+0.003 * IIXZXIIIIIIIIIXZXIII\n", + "+0.001 * IIYZYIIIIIIIIYZZYIII\n", + "+0.001 * IIXZXIIIIIIIIYZZYIII\n", + "+0.001 * IIYZYIIIIIIIIXZZXIII\n", + "+0.001 * IIXZXIIIIIIIIXZZXIII\n", + "+0.112 * IIIZIIIIIIIIIIIIZIII\n", + "+0.000 * IIIZIIIIIIIIIIIYYIII\n", + "+0.000 * IIIZIIIIIIIIIIIXXIII\n", + "+0.000 * IIYYIIIIIIIIIIIIZIII\n", + "+0.000 * IIXXIIIIIIIIIIIIZIII\n", + "+0.003 * IIYYIIIIIIIIIIIYYIII\n", + "+0.003 * IIXXIIIIIIIIIIIYYIII\n", + "+0.003 * IIYYIIIIIIIIIIIXXIII\n", + "+0.003 * IIXXIIIIIIIIIIIXXIII\n", + "-0.000 * IYZYIIIIIIIYZZZZYIII\n", + "-0.000 * IXZXIIIIIIIYZZZZYIII\n", + "-0.000 * IYZYIIIIIIIXZZZZXIII\n", + "-0.000 * IXZXIIIIIIIXZZZZXIII\n", + "-0.000 * YZZYIIIIIIIIYZZZYIII\n", + "-0.000 * XZZXIIIIIIIIYZZZYIII\n", + "-0.000 * YZZYIIIIIIIIXZZZXIII\n", + "-0.000 * XZZXIIIIIIIIXZZZXIII\n", + "+0.118 * IIZIIIIIIIIIIIIIZIII\n", + "-0.000 * IIZIIIIIIIIIIIIYYIII\n", + "-0.000 * IIZIIIIIIIIIIIIXXIII\n", + "+0.003 * IYYIIIIIIIIYZZZZYIII\n", + "+0.003 * IXXIIIIIIIIYZZZZYIII\n", + "+0.003 * IYYIIIIIIIIXZZZZXIII\n", + "+0.003 * IXXIIIIIIIIXZZZZXIII\n", + "+0.004 * YZYIIIIIIIIIYZZZYIII\n", + "+0.004 * XZXIIIIIIIIIYZZZYIII\n", + "+0.004 * YZYIIIIIIIIIXZZZXIII\n", + "+0.004 * XZXIIIIIIIIIXZZZXIII\n", + "+0.119 * IZIIIIIIIIIIIIIIZIII\n", + "-0.001 * YYIIIIIIIIIIIIYZYIII\n", + "-0.001 * XXIIIIIIIIIIIIYZYIII\n", + "-0.001 * YYIIIIIIIIIIIIXZXIII\n", + "-0.001 * XXIIIIIIIIIIIIXZXIII\n", + "+0.030 * YYIIIIIIIIIIIYZZYIII\n", + "+0.030 * XXIIIIIIIIIIIYZZYIII\n", + "+0.030 * YYIIIIIIIIIIIXZZXIII\n", + "+0.030 * XXIIIIIIIIIIIXZZXIII\n", + "+0.124 * ZIIIIIIIIIIIIIIIZIII\n", + "+0.081 * IIIIIIIIIIIIIIZZIIII\n", + "+0.000 * IIIIIIIIIIIIIYYZIIII\n", + "+0.000 * IIIIIIIIIIIIIXXZIIII\n", + "+0.109 * IIIIIIIIIIIIIZIZIIII\n", + "+0.115 * IIIIIIIIIIIIZIIZIIII\n", + "+0.119 * IIIIIIIIIIIZIIIZIIII\n", + "+0.000 * IIIIIIIIIIIYXIXYIIII\n", + "+0.026 * IIIIIIIIIIIYYIYYIIII\n", + "+0.026 * IIIIIIIIIIIXXIYYIIII\n", + "+0.026 * IIIIIIIIIIIYYIXXIIII\n", + "+0.026 * IIIIIIIIIIIXXIXXIIII\n", + "+0.000 * IIIIIIIIIIIXYIYXIIII\n", + "+0.000 * IIIIIIIIIIIYXXZYIIII\n", + "+0.000 * IIIIIIIIIIIYYYZYIIII\n", + "+0.000 * IIIIIIIIIIIXXYZYIIII\n", + "+0.000 * IIIIIIIIIIIYYXZXIIII\n", + "+0.000 * IIIIIIIIIIIXXXZXIIII\n", + "+0.000 * IIIIIIIIIIIXYYZXIIII\n", + "+0.122 * ZZZZZZZZZZZIIIIZIIII\n", + "+0.038 * ZZZZZZZZZZXIIIYYIIII\n", + "-0.038 * IIIIIIIIIIXIIIYYIIII\n", + "+0.038 * ZZZZZZZZZZXIIIXXIIII\n", + "-0.038 * IIIIIIIIIIXIIIXXIIII\n", + "+0.001 * ZZZZZZZZZZXIIYZYIIII\n", + "-0.001 * IIIIIIIIIIXIIYZYIIII\n", + "+0.001 * ZZZZZZZZZZXIIXZXIIII\n", + "-0.001 * IIIIIIIIIIXIIXZXIIII\n", + "-0.007 * ZZZZZZZZZXIIIIIZIIII\n", + "+0.007 * IIIIIIIIIXZIIIIZIIII\n", + "-0.005 * ZZZZZZZZXIIYZZZYIIII\n", + "+0.005 * IIIIIIIIXZZYZZZYIIII\n", + "-0.005 * ZZZZZZZZXIIXZZZXIIII\n", + "+0.005 * IIIIIIIIXZZXZZZXIIII\n", + "+0.000 * ZZZZZZZXIIIYZZZYIIII\n", + "-0.000 * IIIIIIIXZZZYZZZYIIII\n", + "+0.000 * ZZZZZZZXIIIXZZZXIIII\n", + "-0.000 * IIIIIIIXZZZXZZZXIIII\n", + "-0.007 * ZZZZZZXIIIIIIIYYIIII\n", + "+0.007 * IIIIIIXZZZZIIIYYIIII\n", + "-0.007 * ZZZZZZXIIIIIIIXXIIII\n", + "+0.007 * IIIIIIXZZZZIIIXXIIII\n", + "-0.000 * ZZZZZZXIIIIIIYZYIIII\n", + "+0.000 * IIIIIIXZZZZIIYZYIIII\n", + "-0.000 * ZZZZZZXIIIIIIXZXIIII\n", + "+0.000 * IIIIIIXZZZZIIXZXIIII\n", + "+0.006 * ZZZZXIIIIIIIYZZYIIII\n", + "-0.006 * IIIIXZZZZZZIYZZYIIII\n", + "+0.006 * ZZZZXIIIIIIIXZZXIIII\n", + "-0.006 * IIIIXZZZZZZIXZZXIIII\n", + "+0.004 * ZZZXIIIIIIIYZZZYIIII\n", + "-0.004 * IIIXZZZZZZZYZZZYIIII\n", + "+0.004 * ZZZXIIIIIIIXZZZXIIII\n", + "-0.004 * IIIXZZZZZZZXZZZXIIII\n", + "+0.000 * ZZXIIIIIIIIYZZZYIIII\n", + "-0.000 * IIXZZZZZZZZYZZZYIIII\n", + "+0.000 * ZZXIIIIIIIIXZZZXIIII\n", + "-0.000 * IIXZZZZZZZZXZZZXIIII\n", + "-0.017 * ZXIIIIIIIIIIIIIZIIII\n", + "+0.017 * IXZZZZZZZZZIIIIZIIII\n", + "+0.013 * XIIIIIIIIIIIIIYYIIII\n", + "-0.013 * XZZZZZZZZZZIIIYYIIII\n", + "+0.013 * XIIIIIIIIIIIIIXXIIII\n", + "-0.013 * XZZZZZZZZZZIIIXXIIII\n", + "+0.000 * XIIIIIIIIIIIIYZYIIII\n", + "-0.000 * XZZZZZZZZZZIIYZYIIII\n", + "+0.000 * XIIIIIIIIIIIIXZXIIII\n", + "-0.000 * XZZZZZZZZZZIIXZXIIII\n", + "+0.126 * IIIIIIIIIIZIIIIZIIII\n", + "+0.016 * IIIIIIIIIYYIIIYYIIII\n", + "+0.016 * IIIIIIIIIXXIIIYYIIII\n", + "+0.016 * IIIIIIIIIYYIIIXXIIII\n", + "+0.016 * IIIIIIIIIXXIIIXXIIII\n", + "+0.000 * IIIIIIIIIYYIIYZYIIII\n", + "+0.000 * IIIIIIIIIXXIIYZYIIII\n", + "+0.000 * IIIIIIIIIYYIIXZXIIII\n", + "+0.000 * IIIIIIIIIXXIIXZXIIII\n", + "-0.005 * IIIIIIIIYZYIYZZYIIII\n", + "-0.005 * IIIIIIIIXZXIYZZYIIII\n", + "-0.005 * IIIIIIIIYZYIXZZXIIII\n", + "-0.005 * IIIIIIIIXZXIXZZXIIII\n", + "+0.000 * IIIIIIIYZZYIYZZYIIII\n", + "+0.000 * IIIIIIIXZZXIYZZYIIII\n", + "+0.000 * IIIIIIIYZZYIXZZXIIII\n", + "+0.000 * IIIIIIIXZZXIXZZXIIII\n", + "+0.001 * IIIIIIYZZZYIIIIZIIII\n", + "+0.001 * IIIIIIXZZZXIIIIZIIII\n", + "+0.007 * IIIIYZZZZZYYZZZYIIII\n", + "+0.007 * IIIIXZZZZZXYZZZYIIII\n", + "+0.007 * IIIIYZZZZZYXZZZXIIII\n", + "+0.007 * IIIIXZZZZZXXZZZXIIII\n", + "+0.003 * IIIYZZZZZZYIYZZYIIII\n", + "+0.003 * IIIXZZZZZZXIYZZYIIII\n", + "+0.003 * IIIYZZZZZZYIXZZXIIII\n", + "+0.003 * IIIXZZZZZZXIXZZXIIII\n", + "+0.000 * IIYZZZZZZZYIYZZYIIII\n", + "+0.000 * IIXZZZZZZZXIYZZYIIII\n", + "+0.000 * IIYZZZZZZZYIXZZXIIII\n", + "+0.000 * IIXZZZZZZZXIXZZXIIII\n", + "+0.015 * IYZZZZZZZZYIIIYYIIII\n", + "+0.015 * IXZZZZZZZZXIIIYYIIII\n", + "+0.015 * IYZZZZZZZZYIIIXXIIII\n", + "+0.015 * IXZZZZZZZZXIIIXXIIII\n", + "+0.000 * IYZZZZZZZZYIIYZYIIII\n", + "+0.000 * IXZZZZZZZZXIIYZYIIII\n", + "+0.000 * IYZZZZZZZZYIIXZXIIII\n", + "+0.000 * IXZZZZZZZZXIIXZXIIII\n", + "-0.015 * YZZZZZZZZZYIIIIZIIII\n", + "-0.015 * XZZZZZZZZZXIIIIZIIII\n", + "+0.118 * IIIIIIIIIZIIIIIZIIII\n", + "-0.001 * IIIIIIIIYYIYZZZYIIII\n", + "-0.001 * IIIIIIIIXXIYZZZYIIII\n", + "-0.001 * IIIIIIIIYYIXZZZXIIII\n", + "-0.001 * IIIIIIIIXXIXZZZXIIII\n", + "+0.000 * IIIIIIIYZYIYZZZYIIII\n", + "+0.000 * IIIIIIIXZXIYZZZYIIII\n", + "+0.000 * IIIIIIIYZYIXZZZXIIII\n", + "+0.000 * IIIIIIIXZXIXZZZXIIII\n", + "-0.042 * IIIIIIYZZYIIIIYYIIII\n", + "-0.042 * IIIIIIXZZXIIIIYYIIII\n", + "-0.042 * IIIIIIYZZYIIIIXXIIII\n", + "-0.042 * IIIIIIXZZXIIIIXXIIII\n", + "-0.001 * IIIIIIYZZYIIIYZYIIII\n", + "-0.001 * IIIIIIXZZXIIIYZYIIII\n", + "-0.001 * IIIIIIYZZYIIIXZXIIII\n", + "-0.001 * IIIIIIXZZXIIIXZXIIII\n", + "+0.001 * IIIIYZZZZYIIYZZYIIII\n", + "+0.001 * IIIIXZZZZXIIYZZYIIII\n", + "+0.001 * IIIIYZZZZYIIXZZXIIII\n", + "+0.001 * IIIIXZZZZXIIXZZXIIII\n", + "+0.002 * IIIYZZZZZYIYZZZYIIII\n", + "+0.002 * IIIXZZZZZXIYZZZYIIII\n", + "+0.002 * IIIYZZZZZYIXZZZXIIII\n", + "+0.002 * IIIXZZZZZXIXZZZXIIII\n", + "+0.000 * IIYZZZZZZYIYZZZYIIII\n", + "+0.000 * IIXZZZZZZXIYZZZYIIII\n", + "+0.000 * IIYZZZZZZYIXZZZXIIII\n", + "+0.000 * IIXZZZZZZXIXZZZXIIII\n", + "+0.008 * IYZZZZZZZYIIIIIZIIII\n", + "+0.008 * IXZZZZZZZXIIIIIZIIII\n", + "-0.006 * YZZZZZZZZYIIIIYYIIII\n", + "-0.006 * XZZZZZZZZXIIIIYYIIII\n", + "-0.006 * YZZZZZZZZYIIIIXXIIII\n", + "-0.006 * XZZZZZZZZXIIIIXXIIII\n", + "-0.000 * YZZZZZZZZYIIIYZYIIII\n", + "-0.000 * XZZZZZZZZXIIIYZYIIII\n", + "-0.000 * YZZZZZZZZYIIIXZXIIII\n", + "-0.000 * XZZZZZZZZXIIIXZXIIII\n", + "+0.119 * IIIIIIIIZIIIIIIZIIII\n", + "+0.000 * IIIIIIIYYIIIIIIZIIII\n", + "+0.000 * IIIIIIIXXIIIIIIZIIII\n", + "-0.001 * IIIIIIYZYIIIYZZYIIII\n", + "-0.001 * IIIIIIXZXIIIYZZYIIII\n", + "-0.001 * IIIIIIYZYIIIXZZXIIII\n", + "-0.001 * IIIIIIXZXIIIXZZXIIII\n", + "-0.001 * IIIIIYZZYIIIIIYYIIII\n", + "-0.001 * IIIIIXZZXIIIIIYYIIII\n", + "-0.001 * IIIIIYZZYIIIIIXXIIII\n", + "-0.001 * IIIIIXZZXIIIIIXXIIII\n", + "-0.003 * IIIIIYZZYIIIIYZYIIII\n", + "-0.003 * IIIIIXZZXIIIIYZYIIII\n", + "-0.003 * IIIIIYZZYIIIIXZXIIII\n", + "-0.003 * IIIIIXZZXIIIIXZXIIII\n", + "-0.041 * IIIIYZZZYIIIIIYYIIII\n", + "-0.041 * IIIIXZZZXIIIIIYYIIII\n", + "-0.041 * IIIIYZZZYIIIIIXXIIII\n", + "-0.041 * IIIIXZZZXIIIIIXXIIII\n", + "-0.001 * IIIIYZZZYIIIIYZYIIII\n", + "-0.001 * IIIIXZZZXIIIIYZYIIII\n", + "-0.001 * IIIIYZZZYIIIIXZXIIII\n", + "-0.001 * IIIIXZZZXIIIIXZXIIII\n", + "+0.021 * IIIYZZZZYIIIIIIZIIII\n", + "+0.021 * IIIXZZZZXIIIIIIZIIII\n", + "+0.001 * IIYZZZZZYIIIIIIZIIII\n", + "+0.001 * IIXZZZZZXIIIIIIZIIII\n", + "-0.004 * IYZZZZZZYIIYZZZYIIII\n", + "-0.004 * IXZZZZZZXIIYZZZYIIII\n", + "-0.004 * IYZZZZZZYIIXZZZXIIII\n", + "-0.004 * IXZZZZZZXIIXZZZXIIII\n", + "-0.003 * YZZZZZZZYIIIYZZYIIII\n", + "-0.003 * XZZZZZZZXIIIYZZYIIII\n", + "-0.003 * YZZZZZZZYIIIXZZXIIII\n", + "-0.003 * XZZZZZZZXIIIXZZXIIII\n", + "+0.112 * IIIIIIIZIIIIIIIZIIII\n", + "+0.000 * IIIIIIYYIIIIYZZYIIII\n", + "+0.000 * IIIIIIXXIIIIYZZYIIII\n", + "+0.000 * IIIIIIYYIIIIXZZXIIII\n", + "+0.000 * IIIIIIXXIIIIXZZXIIII\n", + "-0.035 * IIIIIYZYIIIIIIYYIIII\n", + "-0.035 * IIIIIXZXIIIIIIYYIIII\n", + "-0.035 * IIIIIYZYIIIIIIXXIIII\n", + "-0.035 * IIIIIXZXIIIIIIXXIIII\n", + "-0.001 * IIIIIYZYIIIIIYZYIIII\n", + "-0.001 * IIIIIXZXIIIIIYZYIIII\n", + "-0.001 * IIIIIYZYIIIIIXZXIIII\n", + "-0.001 * IIIIIXZXIIIIIXZXIIII\n", + "+0.001 * IIIIYZZYIIIIIIYYIIII\n", + "+0.001 * IIIIXZZXIIIIIIYYIIII\n", + "+0.001 * IIIIYZZYIIIIIIXXIIII\n", + "+0.001 * IIIIXZZXIIIIIIXXIIII\n", + "-0.003 * IIIIYZZYIIIIIYZYIIII\n", + "-0.003 * IIIIXZZXIIIIIYZYIIII\n", + "-0.003 * IIIIYZZYIIIIIXZXIIII\n", + "-0.003 * IIIIXZZXIIIIIXZXIIII\n", + "-0.001 * IIIYZZZYIIIIIIIZIIII\n", + "-0.001 * IIIXZZZXIIIIIIIZIIII\n", + "+0.016 * IIYZZZZYIIIIIIIZIIII\n", + "+0.016 * IIXZZZZXIIIIIIIZIIII\n", + "+0.000 * IYZZZZZYIIIYZZZYIIII\n", + "+0.000 * IXZZZZZXIIIYZZZYIIII\n", + "+0.000 * IYZZZZZYIIIXZZZXIIII\n", + "+0.000 * IXZZZZZXIIIXZZZXIIII\n", + "+0.000 * YZZZZZZYIIIIYZZYIIII\n", + "+0.000 * XZZZZZZXIIIIYZZYIIII\n", + "+0.000 * YZZZZZZYIIIIXZZXIIII\n", + "+0.000 * XZZZZZZXIIIIXZZXIIII\n", + "+0.122 * IIIIIIZIIIIIIIIZIIII\n", + "-0.001 * IIIIYZYIIIIYZZZYIIII\n", + "-0.001 * IIIIXZXIIIIYZZZYIIII\n", + "-0.001 * IIIIYZYIIIIXZZZXIIII\n", + "-0.001 * IIIIXZXIIIIXZZZXIIII\n", + "-0.000 * IIIYZZYIIIIIYZZYIIII\n", + "-0.000 * IIIXZZXIIIIIYZZYIIII\n", + "-0.000 * IIIYZZYIIIIIXZZXIIII\n", + "-0.000 * IIIXZZXIIIIIXZZXIIII\n", + "-0.000 * IIYZZZYIIIIIYZZYIIII\n", + "-0.000 * IIXZZZXIIIIIYZZYIIII\n", + "-0.000 * IIYZZZYIIIIIXZZXIIII\n", + "-0.000 * IIXZZZXIIIIIXZZXIIII\n", + "+0.019 * IYZZZZYIIIIIIIYYIIII\n", + "+0.019 * IXZZZZXIIIIIIIYYIIII\n", + "+0.019 * IYZZZZYIIIIIIIXXIIII\n", + "+0.019 * IXZZZZXIIIIIIIXXIIII\n", + "+0.000 * IYZZZZYIIIIIIYZYIIII\n", + "+0.000 * IXZZZZXIIIIIIYZYIIII\n", + "+0.000 * IYZZZZYIIIIIIXZXIIII\n", + "+0.000 * IXZZZZXIIIIIIXZXIIII\n", + "-0.006 * YZZZZZYIIIIIIIIZIIII\n", + "-0.006 * XZZZZZXIIIIIIIIZIIII\n", + "+0.126 * IIIIIZIIIIIIIIIZIIII\n", + "-0.001 * IIIYZYIIIIIIIIYYIIII\n", + "-0.001 * IIIXZXIIIIIIIIYYIIII\n", + "-0.001 * IIIYZYIIIIIIIIXXIIII\n", + "-0.001 * IIIXZXIIIIIIIIXXIIII\n", + "+0.003 * IIIYZYIIIIIIIYZYIIII\n", + "+0.003 * IIIXZXIIIIIIIYZYIIII\n", + "+0.003 * IIIYZYIIIIIIIXZXIIII\n", + "+0.003 * IIIXZXIIIIIIIXZXIIII\n", + "+0.031 * IIYZZYIIIIIIIIYYIIII\n", + "+0.031 * IIXZZXIIIIIIIIYYIIII\n", + "+0.031 * IIYZZYIIIIIIIIXXIIII\n", + "+0.031 * IIXZZXIIIIIIIIXXIIII\n", + "+0.001 * IIYZZYIIIIIIIYZYIIII\n", + "+0.001 * IIXZZXIIIIIIIYZYIIII\n", + "+0.001 * IIYZZYIIIIIIIXZXIIII\n", + "+0.001 * IIXZZXIIIIIIIXZXIIII\n", + "+0.138 * IIIIZIIIIIIIIIIZIIII\n", + "+0.037 * IIIYYIIIIIIIIIYYIIII\n", + "+0.037 * IIIXXIIIIIIIIIYYIIII\n", + "+0.037 * IIIYYIIIIIIIIIXXIIII\n", + "+0.037 * IIIXXIIIIIIIIIXXIIII\n", + "+0.001 * IIIYYIIIIIIIIYZYIIII\n", + "+0.001 * IIIXXIIIIIIIIYZYIIII\n", + "+0.001 * IIIYYIIIIIIIIXZXIIII\n", + "+0.001 * IIIXXIIIIIIIIXZXIIII\n", + "+0.001 * IIYZYIIIIIIIIIYYIIII\n", + "+0.001 * IIXZXIIIIIIIIIYYIIII\n", + "+0.001 * IIYZYIIIIIIIIIXXIIII\n", + "+0.001 * IIXZXIIIIIIIIIXXIIII\n", + "+0.003 * IIYZYIIIIIIIIYZYIIII\n", + "+0.003 * IIXZXIIIIIIIIYZYIIII\n", + "+0.003 * IIYZYIIIIIIIIXZXIIII\n", + "+0.003 * IIXZXIIIIIIIIXZXIIII\n", + "+0.005 * IYZZYIIIIIIIYZZYIIII\n", + "+0.005 * IXZZXIIIIIIIYZZYIIII\n", + "+0.005 * IYZZYIIIIIIIXZZXIIII\n", + "+0.005 * IXZZXIIIIIIIXZZXIIII\n", + "+0.005 * YZZZYIIIIIIYZZZYIIII\n", + "+0.005 * XZZZXIIIIIIYZZZYIIII\n", + "+0.005 * YZZZYIIIIIIXZZZXIIII\n", + "+0.005 * XZZZXIIIIIIXZZZXIIII\n", + "+0.118 * IIIZIIIIIIIIIIIZIIII\n", + "-0.000 * IIYYIIIIIIIIIIIZIIII\n", + "-0.000 * IIXXIIIIIIIIIIIZIIII\n", + "+0.003 * IYZYIIIIIIIYZZZYIIII\n", + "+0.003 * IXZXIIIIIIIYZZZYIIII\n", + "+0.003 * IYZYIIIIIIIXZZZXIIII\n", + "+0.003 * IXZXIIIIIIIXZZZXIIII\n", + "+0.004 * YZZYIIIIIIIIYZZYIIII\n", + "+0.004 * XZZXIIIIIIIIYZZYIIII\n", + "+0.004 * YZZYIIIIIIIIXZZXIIII\n", + "+0.004 * XZZXIIIIIIIIXZZXIIII\n", + "+0.112 * IIZIIIIIIIIIIIIZIIII\n", + "+0.000 * IYYIIIIIIIIYZZZYIIII\n", + "+0.000 * IXXIIIIIIIIYZZZYIIII\n", + "+0.000 * IYYIIIIIIIIXZZZXIIII\n", + "+0.000 * IXXIIIIIIIIXZZZXIIII\n", + "+0.000 * YZYIIIIIIIIIYZZYIIII\n", + "+0.000 * XZXIIIIIIIIIYZZYIIII\n", + "+0.000 * YZYIIIIIIIIIXZZXIIII\n", + "+0.000 * XZXIIIIIIIIIXZZXIIII\n", + "+0.119 * IZIIIIIIIIIIIIIZIIII\n", + "+0.030 * YYIIIIIIIIIIIIYYIIII\n", + "+0.030 * XXIIIIIIIIIIIIYYIIII\n", + "+0.030 * YYIIIIIIIIIIIIXXIIII\n", + "+0.030 * XXIIIIIIIIIIIIXXIIII\n", + "+0.001 * YYIIIIIIIIIIIYZYIIII\n", + "+0.001 * XXIIIIIIIIIIIYZYIIII\n", + "+0.001 * YYIIIIIIIIIIIXZXIIII\n", + "+0.001 * XXIIIIIIIIIIIXZXIIII\n", + "+0.124 * ZIIIIIIIIIIIIIIZIIII\n", + "+0.119 * IIIIIIIIIIIIIZZIIIII\n", + "+0.114 * IIIIIIIIIIIIZIZIIIII\n", + "+0.132 * IIIIIIIIIIIZIIZIIIII\n", + "+0.125 * ZZZZZZZZZZZIIIZIIIII\n", + "+0.011 * ZZZZZZZZZXIIIIZIIIII\n", + "-0.011 * IIIIIIIIIXZIIIZIIIII\n", + "-0.013 * ZZZZZZZZXIIIYZYIIIII\n", + "+0.013 * IIIIIIIIXZZIYZYIIIII\n", + "-0.013 * ZZZZZZZZXIIIXZXIIIII\n", + "+0.013 * IIIIIIIIXZZIXZXIIIII\n", + "+0.001 * ZZZZZZZXIIIIYZYIIIII\n", + "-0.001 * IIIIIIIXZZZIYZYIIIII\n", + "+0.001 * ZZZZZZZXIIIIXZXIIIII\n", + "-0.001 * IIIIIIIXZZZIXZXIIIII\n", + "-0.000 * ZZZZZXIIIIIYZZYIIIII\n", + "+0.000 * IIIIIXZZZZZYZZYIIIII\n", + "-0.000 * ZZZZZXIIIIIXZZXIIIII\n", + "+0.000 * IIIIIXZZZZZXZZXIIIII\n", + "+0.007 * ZZZZXIIIIIIYZZYIIIII\n", + "-0.007 * IIIIXZZZZZZYZZYIIIII\n", + "+0.007 * ZZZZXIIIIIIXZZXIIIII\n", + "-0.007 * IIIIXZZZZZZXZZXIIIII\n", + "-0.004 * ZZZXIIIIIIIIYZYIIIII\n", + "+0.004 * IIIXZZZZZZZIYZYIIIII\n", + "-0.004 * ZZZXIIIIIIIIXZXIIIII\n", + "+0.004 * IIIXZZZZZZZIXZXIIIII\n", + "-0.001 * ZXIIIIIIIIIIIIZIIIII\n", + "+0.001 * IXZZZZZZZZZIIIZIIIII\n", + "+0.123 * IIIIIIIIIIZIIIZIIIII\n", + "-0.007 * IIIIIIIIYZYYZZYIIIII\n", + "-0.007 * IIIIIIIIXZXYZZYIIIII\n", + "-0.007 * IIIIIIIIYZYXZZXIIIII\n", + "-0.007 * IIIIIIIIXZXXZZXIIIII\n", + "+0.000 * IIIIIIIYZZYYZZYIIIII\n", + "+0.000 * IIIIIIIXZZXYZZYIIIII\n", + "+0.000 * IIIIIIIYZZYXZZXIIIII\n", + "+0.000 * IIIIIIIXZZXXZZXIIIII\n", + "-0.012 * IIIIIIYZZZYIIIZIIIII\n", + "-0.012 * IIIIIIXZZZXIIIZIIIII\n", + "-0.000 * IIIIIYZZZZYIYZYIIIII\n", + "-0.000 * IIIIIXZZZZXIYZYIIIII\n", + "-0.000 * IIIIIYZZZZYIXZXIIIII\n", + "-0.000 * IIIIIXZZZZXIXZXIIIII\n", + "+0.009 * IIIIYZZZZZYIYZYIIIII\n", + "+0.009 * IIIIXZZZZZXIYZYIIIII\n", + "+0.009 * IIIIYZZZZZYIXZXIIIII\n", + "+0.009 * IIIIXZZZZZXIXZXIIIII\n", + "+0.002 * IIIYZZZZZZYYZZYIIIII\n", + "+0.002 * IIIXZZZZZZXYZZYIIIII\n", + "+0.002 * IIIYZZZZZZYXZZXIIIII\n", + "+0.002 * IIIXZZZZZZXXZZXIIIII\n", + "+0.002 * YZZZZZZZZZYIIIZIIIII\n", + "+0.002 * XZZZZZZZZZXIIIZIIIII\n", + "+0.113 * IIIIIIIIIZIIIIZIIIII\n", + "+0.006 * IIIIIIIIYYIIYZYIIIII\n", + "+0.006 * IIIIIIIIXXIIYZYIIIII\n", + "+0.006 * IIIIIIIIYYIIXZXIIIII\n", + "+0.006 * IIIIIIIIXXIIXZXIIIII\n", + "-0.000 * IIIIIIIYZYIIYZYIIIII\n", + "-0.000 * IIIIIIIXZXIIYZYIIIII\n", + "-0.000 * IIIIIIIYZYIIXZXIIIII\n", + "-0.000 * IIIIIIIXZXIIXZXIIIII\n", + "-0.000 * IIIIIYZZZYIYZZYIIIII\n", + "-0.000 * IIIIIXZZZXIYZZYIIIII\n", + "-0.000 * IIIIIYZZZYIXZZXIIIII\n", + "-0.000 * IIIIIXZZZXIXZZXIIIII\n", + "+0.001 * IIIIYZZZZYIYZZYIIIII\n", + "+0.001 * IIIIXZZZZXIYZZYIIIII\n", + "+0.001 * IIIIYZZZZYIXZZXIIIII\n", + "+0.001 * IIIIXZZZZXIXZZXIIIII\n", + "+0.009 * IIIYZZZZZYIIYZYIIIII\n", + "+0.009 * IIIXZZZZZXIIYZYIIIII\n", + "+0.009 * IIIYZZZZZYIIXZXIIIII\n", + "+0.009 * IIIXZZZZZXIIXZXIIIII\n", + "-0.009 * IYZZZZZZZYIIIIZIIIII\n", + "-0.009 * IXZZZZZZZXIIIIZIIIII\n", + "+0.126 * IIIIIIIIZIIIIIZIIIII\n", + "-0.000 * IIIIIIIIZIIIIYYIIIII\n", + "-0.000 * IIIIIIIIZIIIIXXIIIII\n", + "+0.000 * IIIIIIIYYIIIIIZIIIII\n", + "+0.000 * IIIIIIIXXIIIIIZIIIII\n", + "+0.004 * IIIIIIIYYIIIIYYIIIII\n", + "+0.004 * IIIIIIIXXIIIIYYIIIII\n", + "+0.004 * IIIIIIIYYIIIIXXIIIII\n", + "+0.004 * IIIIIIIXXIIIIXXIIIII\n", + "-0.002 * IIIIIIYZYIIYZZYIIIII\n", + "-0.002 * IIIIIIXZXIIYZZYIIIII\n", + "-0.002 * IIIIIIYZYIIXZZXIIIII\n", + "-0.002 * IIIIIIXZXIIXZZXIIIII\n", + "-0.011 * IIIYZZZZYIIIIIZIIIII\n", + "-0.011 * IIIXZZZZXIIIIIZIIIII\n", + "+0.000 * IIIYZZZZYIIIIYYIIIII\n", + "+0.000 * IIIXZZZZXIIIIYYIIIII\n", + "+0.000 * IIIYZZZZYIIIIXXIIIII\n", + "+0.000 * IIIXZZZZXIIIIXXIIIII\n", + "-0.000 * IIYZZZZZYIIIIIZIIIII\n", + "-0.000 * IIXZZZZZXIIIIIZIIIII\n", + "+0.001 * IIYZZZZZYIIIIYYIIIII\n", + "+0.001 * IIXZZZZZXIIIIYYIIIII\n", + "+0.001 * IIYZZZZZYIIIIXXIIIII\n", + "+0.001 * IIXZZZZZXIIIIXXIIIII\n", + "+0.006 * IYZZZZZZYIIIYZYIIIII\n", + "+0.006 * IXZZZZZZXIIIYZYIIIII\n", + "+0.006 * IYZZZZZZYIIIXZXIIIII\n", + "+0.006 * IXZZZZZZXIIIXZXIIIII\n", + "+0.000 * YZZZZZZZYIIYZZYIIIII\n", + "+0.000 * XZZZZZZZXIIYZZYIIIII\n", + "+0.000 * YZZZZZZZYIIXZZXIIIII\n", + "+0.000 * XZZZZZZZXIIXZZXIIIII\n", + "+0.118 * IIIIIIIZIIIIIIZIIIII\n", + "+0.000 * IIIIIIIZIIIIIYYIIIII\n", + "+0.000 * IIIIIIIZIIIIIXXIIIII\n", + "+0.000 * IIIIIIYYIIIYZZYIIIII\n", + "+0.000 * IIIIIIXXIIIYZZYIIIII\n", + "+0.000 * IIIIIIYYIIIXZZXIIIII\n", + "+0.000 * IIIIIIXXIIIXZZXIIIII\n", + "+0.001 * IIIYZZZYIIIIIIZIIIII\n", + "+0.001 * IIIXZZZXIIIIIIZIIIII\n", + "+0.001 * IIIYZZZYIIIIIYYIIIII\n", + "+0.001 * IIIXZZZXIIIIIYYIIIII\n", + "+0.001 * IIIYZZZYIIIIIXXIIIII\n", + "+0.001 * IIIXZZZXIIIIIXXIIIII\n", + "-0.009 * IIYZZZZYIIIIIIZIIIII\n", + "-0.009 * IIXZZZZXIIIIIIZIIIII\n", + "-0.000 * IIYZZZZYIIIIIYYIIIII\n", + "-0.000 * IIXZZZZXIIIIIYYIIIII\n", + "-0.000 * IIYZZZZYIIIIIXXIIIII\n", + "-0.000 * IIXZZZZXIIIIIXXIIIII\n", + "-0.000 * IYZZZZZYIIIIYZYIIIII\n", + "-0.000 * IXZZZZZXIIIIYZYIIIII\n", + "-0.000 * IYZZZZZYIIIIXZXIIIII\n", + "-0.000 * IXZZZZZXIIIIXZXIIIII\n", + "-0.000 * YZZZZZZYIIIYZZYIIIII\n", + "-0.000 * XZZZZZZXIIIYZZYIIIII\n", + "-0.000 * YZZZZZZYIIIXZZXIIIII\n", + "-0.000 * XZZZZZZXIIIXZZXIIIII\n", + "+0.113 * IIIIIIZIIIIIIIZIIIII\n", + "-0.000 * IIIIIYYIIIIIYZYIIIII\n", + "-0.000 * IIIIIXXIIIIIYZYIIIII\n", + "-0.000 * IIIIIYYIIIIIXZXIIIII\n", + "-0.000 * IIIIIXXIIIIIXZXIIIII\n", + "+0.001 * IIIIYZYIIIIIYZYIIIII\n", + "+0.001 * IIIIXZXIIIIIYZYIIIII\n", + "+0.001 * IIIIYZYIIIIIXZXIIIII\n", + "+0.001 * IIIIXZXIIIIIXZXIIIII\n", + "-0.003 * IIIYZZYIIIIYZZYIIIII\n", + "-0.003 * IIIXZZXIIIIYZZYIIIII\n", + "-0.003 * IIIYZZYIIIIXZZXIIIII\n", + "-0.003 * IIIXZZXIIIIXZZXIIIII\n", + "+0.011 * YZZZZZYIIIIIIIZIIIII\n", + "+0.011 * XZZZZZXIIIIIIIZIIIII\n", + "+0.112 * IIIIIZIIIIIIIIZIIIII\n", + "+0.000 * IIIIIZIIIIIIIYYIIIII\n", + "+0.000 * IIIIIZIIIIIIIXXIIIII\n", + "+0.000 * IIIIYYIIIIIIIIZIIIII\n", + "+0.000 * IIIIXXIIIIIIIIZIIIII\n", + "+0.003 * IIIIYYIIIIIIIYYIIIII\n", + "+0.003 * IIIIXXIIIIIIIYYIIIII\n", + "+0.003 * IIIIYYIIIIIIIXXIIIII\n", + "+0.003 * IIIIXXIIIIIIIXXIIIII\n", + "-0.000 * IYZZZYIIIIIYZZYIIIII\n", + "-0.000 * IXZZZXIIIIIYZZYIIIII\n", + "-0.000 * IYZZZYIIIIIXZZXIIIII\n", + "-0.000 * IXZZZXIIIIIXZZXIIIII\n", + "-0.000 * YZZZZYIIIIIIYZYIIIII\n", + "-0.000 * XZZZZXIIIIIIYZYIIIII\n", + "-0.000 * YZZZZYIIIIIIXZXIIIII\n", + "-0.000 * XZZZZXIIIIIIXZXIIIII\n", + "+0.118 * IIIIZIIIIIIIIIZIIIII\n", + "-0.000 * IIIIZIIIIIIIIYYIIIII\n", + "-0.000 * IIIIZIIIIIIIIXXIIIII\n", + "+0.004 * IYZZYIIIIIIYZZYIIIII\n", + "+0.004 * IXZZXIIIIIIYZZYIIIII\n", + "+0.004 * IYZZYIIIIIIXZZXIIIII\n", + "+0.004 * IXZZXIIIIIIXZZXIIIII\n", + "+0.003 * YZZZYIIIIIIIYZYIIIII\n", + "+0.003 * XZZZXIIIIIIIYZYIIIII\n", + "+0.003 * YZZZYIIIIIIIXZXIIIII\n", + "+0.003 * XZZZXIIIIIIIXZXIIIII\n", + "+0.134 * IIIZIIIIIIIIIIZIIIII\n", + "+0.005 * IIYYIIIIIIIIIYYIIIII\n", + "+0.005 * IIXXIIIIIIIIIYYIIIII\n", + "+0.005 * IIYYIIIIIIIIIXXIIIII\n", + "+0.005 * IIXXIIIIIIIIIXXIIIII\n", + "+0.015 * IYZYIIIIIIIIYZYIIIII\n", + "+0.015 * IXZXIIIIIIIIYZYIIIII\n", + "+0.015 * IYZYIIIIIIIIXZXIIIII\n", + "+0.015 * IXZXIIIIIIIIXZXIIIII\n", + "+0.007 * YZZYIIIIIIIYZZYIIIII\n", + "+0.007 * XZZXIIIIIIIYZZYIIIII\n", + "+0.007 * YZZYIIIIIIIXZZXIIIII\n", + "+0.007 * XZZXIIIIIIIXZZXIIIII\n", + "+0.124 * IIZIIIIIIIIIIIZIIIII\n", + "+0.129 * IZIIIIIIIIIIIIZIIIII\n", + "+0.139 * ZIIIIIIIIIIIIIZIIIII\n", + "+0.114 * IIIIIIIIIIIIZZIIIIII\n", + "+0.132 * IIIIIIIIIIIZIZIIIIII\n", + "+0.125 * ZZZZZZZZZZZIIZIIIIII\n", + "+0.011 * ZZZZZZZZZXIIIZIIIIII\n", + "-0.011 * IIIIIIIIIXZIIZIIIIII\n", + "-0.001 * ZZZZZZZZXIIIYYIIIIII\n", + "+0.001 * IIIIIIIIXZZIYYIIIIII\n", + "-0.001 * ZZZZZZZZXIIIXXIIIIII\n", + "+0.001 * IIIIIIIIXZZIXXIIIIII\n", + "-0.013 * ZZZZZZZXIIIIYYIIIIII\n", + "+0.013 * IIIIIIIXZZZIYYIIIIII\n", + "-0.013 * ZZZZZZZXIIIIXXIIIIII\n", + "+0.013 * IIIIIIIXZZZIXXIIIIII\n", + "+0.007 * ZZZZZXIIIIIYZYIIIIII\n", + "-0.007 * IIIIIXZZZZZYZYIIIIII\n", + "+0.007 * ZZZZZXIIIIIXZXIIIIII\n", + "-0.007 * IIIIIXZZZZZXZXIIIIII\n", + "+0.000 * ZZZZXIIIIIIYZYIIIIII\n", + "-0.000 * IIIIXZZZZZZYZYIIIIII\n", + "+0.000 * ZZZZXIIIIIIXZXIIIIII\n", + "-0.000 * IIIIXZZZZZZXZXIIIIII\n", + "-0.004 * ZZXIIIIIIIIIYYIIIIII\n", + "+0.004 * IIXZZZZZZZZIYYIIIIII\n", + "-0.004 * ZZXIIIIIIIIIXXIIIIII\n", + "+0.004 * IIXZZZZZZZZIXXIIIIII\n", + "-0.001 * ZXIIIIIIIIIIIZIIIIII\n", + "+0.001 * IXZZZZZZZZZIIZIIIIII\n", + "+0.123 * IIIIIIIIIIZIIZIIIIII\n", + "-0.000 * IIIIIIIIYZYYZYIIIIII\n", + "-0.000 * IIIIIIIIXZXYZYIIIIII\n", + "-0.000 * IIIIIIIIYZYXZXIIIIII\n", + "-0.000 * IIIIIIIIXZXXZXIIIIII\n", + "-0.007 * IIIIIIIYZZYYZYIIIIII\n", + "-0.007 * IIIIIIIXZZXYZYIIIIII\n", + "-0.007 * IIIIIIIYZZYXZXIIIIII\n", + "-0.007 * IIIIIIIXZZXXZXIIIIII\n", + "-0.012 * IIIIIIYZZZYIIZIIIIII\n", + "-0.012 * IIIIIIXZZZXIIZIIIIII\n", + "+0.009 * IIIIIYZZZZYIYYIIIIII\n", + "+0.009 * IIIIIXZZZZXIYYIIIIII\n", + "+0.009 * IIIIIYZZZZYIXXIIIIII\n", + "+0.009 * IIIIIXZZZZXIXXIIIIII\n", + "+0.000 * IIIIYZZZZZYIYYIIIIII\n", + "+0.000 * IIIIXZZZZZXIYYIIIIII\n", + "+0.000 * IIIIYZZZZZYIXXIIIIII\n", + "+0.000 * IIIIXZZZZZXIXXIIIIII\n", + "+0.002 * IIYZZZZZZZYYZYIIIIII\n", + "+0.002 * IIXZZZZZZZXYZYIIIIII\n", + "+0.002 * IIYZZZZZZZYXZXIIIIII\n", + "+0.002 * IIXZZZZZZZXXZXIIIIII\n", + "+0.002 * YZZZZZZZZZYIIZIIIIII\n", + "+0.002 * XZZZZZZZZZXIIZIIIIII\n", + "+0.113 * IIIIIIIIIZIIIZIIIIII\n", + "+0.000 * IIIIIIIIYYIIYYIIIIII\n", + "+0.000 * IIIIIIIIXXIIYYIIIIII\n", + "+0.000 * IIIIIIIIYYIIXXIIIIII\n", + "+0.000 * IIIIIIIIXXIIXXIIIIII\n", + "+0.006 * IIIIIIIYZYIIYYIIIIII\n", + "+0.006 * IIIIIIIXZXIIYYIIIIII\n", + "+0.006 * IIIIIIIYZYIIXXIIIIII\n", + "+0.006 * IIIIIIIXZXIIXXIIIIII\n", + "+0.001 * IIIIIYZZZYIYZYIIIIII\n", + "+0.001 * IIIIIXZZZXIYZYIIIIII\n", + "+0.001 * IIIIIYZZZYIXZXIIIIII\n", + "+0.001 * IIIIIXZZZXIXZXIIIIII\n", + "+0.000 * IIIIYZZZZYIYZYIIIIII\n", + "+0.000 * IIIIXZZZZXIYZYIIIIII\n", + "+0.000 * IIIIYZZZZYIXZXIIIIII\n", + "+0.000 * IIIIXZZZZXIXZXIIIIII\n", + "+0.009 * IIYZZZZZZYIIYYIIIIII\n", + "+0.009 * IIXZZZZZZXIIYYIIIIII\n", + "+0.009 * IIYZZZZZZYIIXXIIIIII\n", + "+0.009 * IIXZZZZZZXIIXXIIIIII\n", + "-0.009 * IYZZZZZZZYIIIZIIIIII\n", + "-0.009 * IXZZZZZZZXIIIZIIIIII\n", + "+0.118 * IIIIIIIIZIIIIZIIIIII\n", + "-0.000 * IIIIIIIYYIIIIZIIIIII\n", + "-0.000 * IIIIIIIXXIIIIZIIIIII\n", + "-0.000 * IIIIIIYZYIIYZYIIIIII\n", + "-0.000 * IIIIIIXZXIIYZYIIIIII\n", + "-0.000 * IIIIIIYZYIIXZXIIIIII\n", + "-0.000 * IIIIIIXZXIIXZXIIIIII\n", + "-0.009 * IIIYZZZZYIIIIZIIIIII\n", + "-0.009 * IIIXZZZZXIIIIZIIIIII\n", + "-0.001 * IIYZZZZZYIIIIZIIIIII\n", + "-0.001 * IIXZZZZZXIIIIZIIIIII\n", + "+0.000 * IYZZZZZZYIIIYYIIIIII\n", + "+0.000 * IXZZZZZZXIIIYYIIIIII\n", + "+0.000 * IYZZZZZZYIIIXXIIIIII\n", + "+0.000 * IXZZZZZZXIIIXXIIIIII\n", + "+0.000 * YZZZZZZZYIIYZYIIIIII\n", + "+0.000 * XZZZZZZZXIIYZYIIIIII\n", + "+0.000 * YZZZZZZZYIIXZXIIIIII\n", + "+0.000 * XZZZZZZZXIIXZXIIIIII\n", + "+0.126 * IIIIIIIZIIIIIZIIIIII\n", + "-0.002 * IIIIIIYYIIIYZYIIIIII\n", + "-0.002 * IIIIIIXXIIIYZYIIIIII\n", + "-0.002 * IIIIIIYYIIIXZXIIIIII\n", + "-0.002 * IIIIIIXXIIIXZXIIIIII\n", + "+0.000 * IIIYZZZYIIIIIZIIIIII\n", + "+0.000 * IIIXZZZXIIIIIZIIIIII\n", + "-0.011 * IIYZZZZYIIIIIZIIIIII\n", + "-0.011 * IIXZZZZXIIIIIZIIIIII\n", + "+0.006 * IYZZZZZYIIIIYYIIIIII\n", + "+0.006 * IXZZZZZXIIIIYYIIIIII\n", + "+0.006 * IYZZZZZYIIIIXXIIIIII\n", + "+0.006 * IXZZZZZXIIIIXXIIIIII\n", + "+0.000 * YZZZZZZYIIIYZYIIIIII\n", + "+0.000 * XZZZZZZXIIIYZYIIIIII\n", + "+0.000 * YZZZZZZYIIIXZXIIIIII\n", + "+0.000 * XZZZZZZXIIIXZXIIIIII\n", + "+0.113 * IIIIIIZIIIIIIZIIIIII\n", + "+0.001 * IIIIIYYIIIIIYYIIIIII\n", + "+0.001 * IIIIIXXIIIIIYYIIIIII\n", + "+0.001 * IIIIIYYIIIIIXXIIIIII\n", + "+0.001 * IIIIIXXIIIIIXXIIIIII\n", + "+0.000 * IIIIYZYIIIIIYYIIIIII\n", + "+0.000 * IIIIXZXIIIIIYYIIIIII\n", + "+0.000 * IIIIYZYIIIIIXXIIIIII\n", + "+0.000 * IIIIXZXIIIIIXXIIIIII\n", + "-0.003 * IIYZZZYIIIIYZYIIIIII\n", + "-0.003 * IIXZZZXIIIIYZYIIIIII\n", + "-0.003 * IIYZZZYIIIIXZXIIIIII\n", + "-0.003 * IIXZZZXIIIIXZXIIIIII\n", + "+0.011 * YZZZZZYIIIIIIZIIIIII\n", + "+0.011 * XZZZZZXIIIIIIZIIIIII\n", + "+0.118 * IIIIIZIIIIIIIZIIIIII\n", + "-0.000 * IIIIYYIIIIIIIZIIIIII\n", + "-0.000 * IIIIXXIIIIIIIZIIIIII\n", + "+0.004 * IYZZZYIIIIIYZYIIIIII\n", + "+0.004 * IXZZZXIIIIIYZYIIIIII\n", + "+0.004 * IYZZZYIIIIIXZXIIIIII\n", + "+0.004 * IXZZZXIIIIIXZXIIIIII\n", + "+0.003 * YZZZZYIIIIIIYYIIIIII\n", + "+0.003 * XZZZZXIIIIIIYYIIIIII\n", + "+0.003 * YZZZZYIIIIIIXXIIIIII\n", + "+0.003 * XZZZZXIIIIIIXXIIIIII\n", + "+0.112 * IIIIZIIIIIIIIZIIIIII\n", + "+0.000 * IYZZYIIIIIIYZYIIIIII\n", + "+0.000 * IXZZXIIIIIIYZYIIIIII\n", + "+0.000 * IYZZYIIIIIIXZXIIIIII\n", + "+0.000 * IXZZXIIIIIIXZXIIIIII\n", + "+0.000 * YZZZYIIIIIIIYYIIIIII\n", + "+0.000 * XZZZXIIIIIIIYYIIIIII\n", + "+0.000 * YZZZYIIIIIIIXXIIIIII\n", + "+0.000 * XZZZXIIIIIIIXXIIIIII\n", + "+0.124 * IIIZIIIIIIIIIZIIIIII\n", + "+0.134 * IIZIIIIIIIIIIZIIIIII\n", + "+0.015 * IYYIIIIIIIIIYYIIIIII\n", + "+0.015 * IXXIIIIIIIIIYYIIIIII\n", + "+0.015 * IYYIIIIIIIIIXXIIIIII\n", + "+0.015 * IXXIIIIIIIIIXXIIIIII\n", + "+0.007 * YZYIIIIIIIIYZYIIIIII\n", + "+0.007 * XZXIIIIIIIIYZYIIIIII\n", + "+0.007 * YZYIIIIIIIIXZXIIIIII\n", + "+0.007 * XZXIIIIIIIIXZXIIIIII\n", + "+0.129 * IZIIIIIIIIIIIZIIIIII\n", + "+0.139 * ZIIIIIIIIIIIIZIIIIII\n", + "+0.108 * IIIIIIIIIIIZZIIIIIII\n", + "+0.133 * ZZZZZZZZZZZIZIIIIIII\n", + "+0.045 * ZZZZZZZZZZXYYIIIIIII\n", + "-0.045 * IIIIIIIIIIXYYIIIIIII\n", + "+0.045 * ZZZZZZZZZZXXXIIIIIII\n", + "-0.045 * IIIIIIIIIIXXXIIIIIII\n", + "+0.012 * ZZZZZZZZZXIIZIIIIIII\n", + "-0.012 * IIIIIIIIIXZIZIIIIIII\n", + "+0.004 * ZZZZZZXIIIIYYIIIIIII\n", + "-0.004 * IIIIIIXZZZZYYIIIIIII\n", + "+0.004 * ZZZZZZXIIIIXXIIIIIII\n", + "-0.004 * IIIIIIXZZZZXXIIIIIII\n", + "-0.010 * ZXIIIIIIIIIIZIIIIIII\n", + "+0.010 * IXZZZZZZZZZIZIIIIIII\n", + "+0.012 * XIIIIIIIIIIYYIIIIIII\n", + "-0.012 * XZZZZZZZZZZYYIIIIIII\n", + "+0.012 * XIIIIIIIIIIXXIIIIIII\n", + "-0.012 * XZZZZZZZZZZXXIIIIIII\n", + "+0.132 * IIIIIIIIIIZIZIIIIIII\n", + "+0.007 * IIIIIIIIIYYYYIIIIIII\n", + "+0.007 * IIIIIIIIIXXYYIIIIIII\n", + "+0.007 * IIIIIIIIIYYXXIIIIIII\n", + "+0.007 * IIIIIIIIIXXXXIIIIIII\n", + "-0.016 * IIIIIIYZZZYIZIIIIIII\n", + "-0.016 * IIIIIIXZZZXIZIIIIIII\n", + "+0.020 * IYZZZZZZZZYYYIIIIIII\n", + "+0.020 * IXZZZZZZZZXYYIIIIIII\n", + "+0.020 * IYZZZZZZZZYXXIIIIIII\n", + "+0.020 * IXZZZZZZZZXXXIIIIIII\n", + "-0.005 * YZZZZZZZZZYIZIIIIIII\n", + "-0.005 * XZZZZZZZZZXIZIIIIIII\n", + "+0.115 * IIIIIIIIIZIIZIIIIIII\n", + "-0.040 * IIIIIIYZZYIYYIIIIIII\n", + "-0.040 * IIIIIIXZZXIYYIIIIIII\n", + "-0.040 * IIIIIIYZZYIXXIIIIIII\n", + "-0.040 * IIIIIIXZZXIXXIIIIIII\n", + "-0.005 * IYZZZZZZZYIIZIIIIIII\n", + "-0.005 * IXZZZZZZZXIIZIIIIIII\n", + "-0.002 * YZZZZZZZZYIYYIIIIIII\n", + "-0.002 * XZZZZZZZZXIYYIIIIIII\n", + "-0.002 * YZZZZZZZZYIXXIIIIIII\n", + "-0.002 * XZZZZZZZZXIXXIIIIIII\n", + "+0.124 * IIIIIIIIZIIIZIIIIIII\n", + "-0.001 * IIIIIYZZYIIYYIIIIIII\n", + "-0.001 * IIIIIXZZXIIYYIIIIIII\n", + "-0.001 * IIIIIYZZYIIXXIIIIIII\n", + "-0.001 * IIIIIXZZXIIXXIIIIIII\n", + "-0.037 * IIIIYZZZYIIYYIIIIIII\n", + "-0.037 * IIIIXZZZXIIYYIIIIIII\n", + "-0.037 * IIIIYZZZYIIXXIIIIIII\n", + "-0.037 * IIIIXZZZXIIXXIIIIIII\n", + "-0.006 * IIIYZZZZYIIIZIIIIIII\n", + "-0.006 * IIIXZZZZXIIIZIIIIIII\n", + "-0.000 * IIYZZZZZYIIIZIIIIIII\n", + "-0.000 * IIXZZZZZXIIIZIIIIIII\n", + "+0.124 * IIIIIIIZIIIIZIIIIIII\n", + "-0.037 * IIIIIYZYIIIYYIIIIIII\n", + "-0.037 * IIIIIXZXIIIYYIIIIIII\n", + "-0.037 * IIIIIYZYIIIXXIIIIIII\n", + "-0.037 * IIIIIXZXIIIXXIIIIIII\n", + "+0.001 * IIIIYZZYIIIYYIIIIIII\n", + "+0.001 * IIIIXZZXIIIYYIIIIIII\n", + "+0.001 * IIIIYZZYIIIXXIIIIIII\n", + "+0.001 * IIIIXZZXIIIXXIIIIIII\n", + "+0.000 * IIIYZZZYIIIIZIIIIIII\n", + "+0.000 * IIIXZZZXIIIIZIIIIIII\n", + "-0.006 * IIYZZZZYIIIIZIIIIIII\n", + "-0.006 * IIXZZZZXIIIIZIIIIIII\n", + "+0.118 * IIIIIIZIIIIIZIIIIIII\n", + "+0.019 * IYZZZZYIIIIYYIIIIIII\n", + "+0.019 * IXZZZZXIIIIYYIIIIIII\n", + "+0.019 * IYZZZZYIIIIXXIIIIIII\n", + "+0.019 * IXZZZZXIIIIXXIIIIIII\n", + "+0.006 * YZZZZZYIIIIIZIIIIIII\n", + "+0.006 * XZZZZZXIIIIIZIIIIIII\n", + "+0.119 * IIIIIZIIIIIIZIIIIIII\n", + "-0.001 * IIIYZYIIIIIYYIIIIIII\n", + "-0.001 * IIIXZXIIIIIYYIIIIIII\n", + "-0.001 * IIIYZYIIIIIXXIIIIIII\n", + "-0.001 * IIIXZXIIIIIXXIIIIIII\n", + "+0.030 * IIYZZYIIIIIYYIIIIIII\n", + "+0.030 * IIXZZXIIIIIYYIIIIIII\n", + "+0.030 * IIYZZYIIIIIXXIIIIIII\n", + "+0.030 * IIXZZXIIIIIXXIIIIIII\n", + "+0.119 * IIIIZIIIIIIIZIIIIIII\n", + "+0.030 * IIIYYIIIIIIYYIIIIIII\n", + "+0.030 * IIIXXIIIIIIYYIIIIIII\n", + "+0.030 * IIIYYIIIIIIXXIIIIIII\n", + "+0.030 * IIIXXIIIIIIXXIIIIIII\n", + "+0.001 * IIYZYIIIIIIYYIIIIIII\n", + "+0.001 * IIXZXIIIIIIYYIIIIIII\n", + "+0.001 * IIYZYIIIIIIXXIIIIIII\n", + "+0.001 * IIXZXIIIIIIXXIIIIIII\n", + "+0.129 * IIIZIIIIIIIIZIIIIIII\n", + "+0.129 * IIZIIIIIIIIIZIIIIIII\n", + "+0.138 * IZIIIIIIIIIIZIIIIIII\n", + "+0.039 * YYIIIIIIIIIYYIIIIIII\n", + "+0.039 * XXIIIIIIIIIYYIIIIIII\n", + "+0.039 * YYIIIIIIIIIXXIIIIIII\n", + "+0.039 * XXIIIIIIIIIXXIIIIIII\n", + "+0.147 * ZIIIIIIIIIIIZIIIIIII\n", + "+0.143 * ZZZZZZZZZZZZIIIIIIII\n", + "+0.018 * ZZZZZZZZZXIZIIIIIIII\n", + "-0.018 * IIIIIIIIIXZZIIIIIIII\n", + "-0.009 * ZXIIIIIIIIIZIIIIIIII\n", + "+0.009 * IXZZZZZZZZZZIIIIIIII\n", + "+0.143 * IIIIIIIIIIZZIIIIIIII\n", + "-0.024 * IIIIIIYZZZYZIIIIIIII\n", + "-0.024 * IIIIIIXZZZXZIIIIIIII\n", + "+0.002 * YZZZZZZZZZYZIIIIIIII\n", + "+0.002 * XZZZZZZZZZXZIIIIIIII\n", + "+0.120 * IIIIIIIIIZIZIIIIIIII\n", + "-0.009 * IYZZZZZZZYIZIIIIIIII\n", + "-0.009 * IXZZZZZZZXIZIIIIIIII\n", + "+0.132 * IIIIIIIIZIIZIIIIIIII\n", + "-0.011 * IIIYZZZZYIIZIIIIIIII\n", + "-0.011 * IIIXZZZZXIIZIIIIIIII\n", + "-0.001 * IIYZZZZZYIIZIIIIIIII\n", + "-0.001 * IIXZZZZZXIIZIIIIIIII\n", + "+0.132 * IIIIIIIZIIIZIIIIIIII\n", + "+0.001 * IIIYZZZYIIIZIIIIIIII\n", + "+0.001 * IIIXZZZXIIIZIIIIIIII\n", + "-0.011 * IIYZZZZYIIIZIIIIIIII\n", + "-0.011 * IIXZZZZXIIIZIIIIIIII\n", + "+0.126 * IIIIIIZIIIIZIIIIIIII\n", + "+0.016 * YZZZZZYIIIIZIIIIIIII\n", + "+0.016 * XZZZZZXIIIIZIIIIIIII\n", + "+0.124 * IIIIIZIIIIIZIIIIIIII\n", + "+0.124 * IIIIZIIIIIIZIIIIIIII\n", + "+0.139 * IIIZIIIIIIIZIIIIIIII\n", + "+0.139 * IIZIIIIIIIIZIIIIIIII\n", + "+0.147 * IZIIIIIIIIIZIIIIIIII\n", + "+0.171 * ZIIIIIIIIIIZIIIIIIII\n", + "+0.077 * ZZZZZZZZZZIIIIIIIIII\n", + "+0.011 * ZZZZZZXIIIXIIIIIIIII\n", + "+0.011 * ZZZZZZYIIIYIIIIIIIII\n", + "-0.008 * XIIIIIIIIIXIIIIIIIII\n", + "-0.008 * YIIIIIIIIIYIIIIIIIII\n", + "+0.097 * ZZZZZZZZZIZIIIIIIIII\n", + "+0.001 * ZXIIIIIIIXZIIIIIIIII\n", + "+0.001 * ZYIIIIIIIYZIIIIIIIII\n", + "+0.105 * ZZZZZZZZIZZIIIIIIIII\n", + "+0.002 * ZZZXIIIIXZZIIIIIIIII\n", + "+0.002 * ZZZYIIIIYZZIIIIIIIII\n", + "+0.000 * ZZXIIIIIXZZIIIIIIIII\n", + "+0.000 * ZZYIIIIIYZZIIIIIIIII\n", + "+0.105 * ZZZZZZZIZZZIIIIIIIII\n", + "-0.000 * ZZZXIIIXZZZIIIIIIIII\n", + "-0.000 * ZZZYIIIYZZZIIIIIIIII\n", + "+0.002 * ZZXIIIIXZZZIIIIIIIII\n", + "+0.002 * ZZYIIIIYZZZIIIIIIIII\n", + "+0.105 * ZZZZZZIZZZZIIIIIIIII\n", + "-0.006 * XIIIIIXZZZZIIIIIIIII\n", + "-0.006 * YIIIIIYZZZZIIIIIIIII\n", + "+0.107 * ZZZZZIZZZZZIIIIIIIII\n", + "+0.107 * ZZZZIZZZZZZIIIIIIIII\n", + "+0.116 * ZZZIZZZZZZZIIIIIIIII\n", + "+0.116 * ZZIZZZZZZZZIIIIIIIII\n", + "+0.116 * ZIZZZZZZZZZIIIIIIIII\n", + "+0.130 * IZZZZZZZZZZIIIIIIIII\n", + "+0.016 * ZZZZZZZZZXZIIIIIIIII\n", + "-0.016 * IIIIIIIIIXIIIIIIIIII\n", + "+0.008 * ZXIIIIIIIIZIIIIIIIII\n", + "-0.008 * IXZZZZZZZZIIIIIIIIII\n", + "+0.005 * ZZZZZZXIIYYIIIIIIIII\n", + "+0.037 * ZZZZZZXIIXXIIIIIIIII\n", + "+0.032 * ZZZZZZYIIYXIIIIIIIII\n", + "+0.032 * IIIIIIYZZYXIIIIIIIII\n", + "+0.037 * IIIIIIXZZXXIIIIIIIII\n", + "+0.005 * IIIIIIXZZYYIIIIIIIII\n", + "-0.002 * XIIIIIIIIYYIIIIIIIII\n", + "+0.005 * XIIIIIIIIXXIIIIIIIII\n", + "+0.007 * YIIIIIIIIYXIIIIIIIII\n", + "+0.007 * YZZZZZZZZYXIIIIIIIII\n", + "+0.005 * XZZZZZZZZXXIIIIIIIII\n", + "-0.002 * XZZZZZZZZYYIIIIIIIII\n", + "+0.000 * ZZZZZXIIYZYIIIIIIIII\n", + "+0.001 * ZZZZZXIIXZXIIIIIIIII\n", + "+0.001 * ZZZZZYIIYZXIIIIIIIII\n", + "+0.001 * IIIIIYZZYIXIIIIIIIII\n", + "+0.001 * IIIIIXZZXIXIIIIIIIII\n", + "+0.000 * IIIIIXZZYIYIIIIIIIII\n", + "+0.003 * ZZZZXIIIYZYIIIIIIIII\n", + "+0.034 * ZZZZXIIIXZXIIIIIIIII\n", + "+0.031 * ZZZZYIIIYZXIIIIIIIII\n", + "+0.031 * IIIIYZZZYIXIIIIIIIII\n", + "+0.034 * IIIIXZZZXIXIIIIIIIII\n", + "+0.003 * IIIIXZZZYIYIIIIIIIII\n", + "+0.003 * ZZZZZXIYZZYIIIIIIIII\n", + "+0.034 * ZZZZZXIXZZXIIIIIIIII\n", + "+0.031 * ZZZZZYIYZZXIIIIIIIII\n", + "+0.031 * IIIIIYZYIIXIIIIIIIII\n", + "+0.034 * IIIIIXZXIIXIIIIIIIII\n", + "+0.003 * IIIIIXZYIIYIIIIIIIII\n", + "-0.000 * ZZZZXIIYZZYIIIIIIIII\n", + "-0.001 * ZZZZXIIXZZXIIIIIIIII\n", + "-0.001 * ZZZZYIIYZZXIIIIIIIII\n", + "-0.001 * IIIIYZZYIIXIIIIIIIII\n", + "-0.001 * IIIIXZZXIIXIIIIIIIII\n", + "-0.000 * IIIIXZZYIIYIIIIIIIII\n", + "-0.003 * ZXIIIIYZZZYIIIIIIIII\n", + "-0.021 * ZXIIIIXZZZXIIIIIIIII\n", + "-0.017 * ZYIIIIYZZZXIIIIIIIII\n", + "-0.017 * IYZZZZYIIIXIIIIIIIII\n", + "-0.021 * IXZZZZXIIIXIIIIIIIII\n", + "-0.003 * IXZZZZYIIIYIIIIIIIII\n", + "+0.000 * ZZZXIYZZZZYIIIIIIIII\n", + "+0.001 * ZZZXIXZZZZXIIIIIIIII\n", + "+0.001 * ZZZYIYZZZZXIIIIIIIII\n", + "+0.001 * IIIYZYIIIIXIIIIIIIII\n", + "+0.001 * IIIXZXIIIIXIIIIIIIII\n", + "+0.000 * IIIXZYIIIIYIIIIIIIII\n", + "-0.002 * ZZXIIYZZZZYIIIIIIIII\n", + "-0.031 * ZZXIIXZZZZXIIIIIIIII\n", + "-0.029 * ZZYIIYZZZZXIIIIIIIII\n", + "-0.029 * IIYZZYIIIIXIIIIIIIII\n", + "-0.031 * IIXZZXIIIIXIIIIIIIII\n", + "-0.002 * IIXZZYIIIIYIIIIIIIII\n", + "-0.002 * ZZZXYZZZZZYIIIIIIIII\n", + "-0.031 * ZZZXXZZZZZXIIIIIIIII\n", + "-0.029 * ZZZYYZZZZZXIIIIIIIII\n", + "-0.029 * IIIYYIIIIIXIIIIIIIII\n", + "-0.031 * IIIXXIIIIIXIIIIIIIII\n", + "-0.002 * IIIXYIIIIIYIIIIIIIII\n", + "-0.000 * ZZXIYZZZZZYIIIIIIIII\n", + "-0.001 * ZZXIXZZZZZXIIIIIIIII\n", + "-0.001 * ZZYIYZZZZZXIIIIIIIII\n", + "-0.001 * IIYZYIIIIIXIIIIIIIII\n", + "-0.001 * IIXZXIIIIIXIIIIIIIII\n", + "-0.000 * IIXZYIIIIIYIIIIIIIII\n", + "-0.002 * XYZZZZZZZZYIIIIIIIII\n", + "-0.032 * XXZZZZZZZZXIIIIIIIII\n", + "-0.030 * YYZZZZZZZZXIIIIIIIII\n", + "-0.030 * YYIIIIIIIIXIIIIIIIII\n", + "-0.032 * XXIIIIIIIIXIIIIIIIII\n", + "-0.002 * XYIIIIIIIIYIIIIIIIII\n", + "-0.017 * ZXIIIIIIIZIIIIIIIIII\n", + "+0.017 * IXZZZZZZZIZIIIIIIIII\n", + "+0.007 * ZZZZZZZZIXIIIIIIIIII\n", + "-0.007 * IIIIIIIIZXZIIIIIIIII\n", + "+0.006 * ZZZXIIIIYYIIIIIIIIII\n", + "+0.010 * ZZZXIIIIXXIIIIIIIIII\n", + "+0.004 * ZZZYIIIIYXIIIIIIIIII\n", + "+0.004 * IIIYZZZZYXZIIIIIIIII\n", + "+0.010 * IIIXZZZZXXZIIIIIIIII\n", + "+0.006 * IIIXZZZZYYZIIIIIIIII\n", + "+0.000 * ZZXIIIIIYYIIIIIIIIII\n", + "+0.001 * ZZXIIIIIXXIIIIIIIIII\n", + "+0.000 * ZZYIIIIIYXIIIIIIIIII\n", + "+0.000 * IIYZZZZZYXZIIIIIIIII\n", + "+0.001 * IIXZZZZZXXZIIIIIIIII\n", + "+0.000 * IIXZZZZZYYZIIIIIIIII\n", + "+0.007 * ZZZZZZZIZXIIIIIIIIII\n", + "-0.007 * IIIIIIIZIXZIIIIIIIII\n", + "-0.000 * ZZZXIIIYZYIIIIIIIIII\n", + "-0.001 * ZZZXIIIXZXIIIIIIIIII\n", + "-0.000 * ZZZYIIIYZXIIIIIIIIII\n", + "-0.000 * IIIYZZZYIXZIIIIIIIII\n", + "-0.001 * IIIXZZZXIXZIIIIIIIII\n", + "-0.000 * IIIXZZZYIYZIIIIIIIII\n", + "+0.006 * ZZXIIIIYZYIIIIIIIIII\n", + "+0.010 * ZZXIIIIXZXIIIIIIIIII\n", + "+0.004 * ZZYIIIIYZXIIIIIIIIII\n", + "+0.004 * IIYZZZZYIXZIIIIIIIII\n", + "+0.010 * IIXZZZZXIXZIIIIIIIII\n", + "+0.006 * IIXZZZZYIYZIIIIIIIII\n", + "+0.004 * ZZZZZZIZZXIIIIIIIIII\n", + "-0.004 * IIIIIIZIIXZIIIIIIIII\n", + "-0.016 * XIIIIIYZZYIIIIIIIIII\n", + "-0.021 * XIIIIIXZZXIIIIIIIIII\n", + "-0.006 * YIIIIIYZZXIIIIIIIIII\n", + "-0.006 * YZZZZZYIIXZIIIIIIIII\n", + "-0.021 * XZZZZZXIIXZIIIIIIIII\n", + "-0.016 * XZZZZZYIIYZIIIIIIIII\n", + "+0.001 * ZZZZZIZZZXIIIIIIIIII\n", + "-0.001 * IIIIIZIIIXZIIIIIIIII\n", + "+0.001 * ZZZZIZZZZXIIIIIIIIII\n", + "-0.001 * IIIIZIIIIXZIIIIIIIII\n", + "+0.011 * ZZZIZZZZZXIIIIIIIIII\n", + "-0.011 * IIIZIIIIIXZIIIIIIIII\n", + "+0.011 * ZZIZZZZZZXIIIIIIIIII\n", + "-0.011 * IIZIIIIIIXZIIIIIIIII\n", + "+0.005 * ZIZZZZZZZXIIIIIIIIII\n", + "-0.005 * IZIIIIIIIXZIIIIIIIII\n", + "+0.014 * IZZZZZZZZXIIIIIIIIII\n", + "-0.014 * ZIIIIIIIIXZIIIIIIIII\n", + "-0.009 * ZXIIIIIIZIIIIIIIIIII\n", + "+0.009 * IXZZZZZZIZZIIIIIIIII\n", + "-0.000 * ZZZZZXYZYIIIIIIIIIII\n", + "-0.000 * ZZZZZXXZXIIIIIIIIIII\n", + "+0.000 * ZZZZZYYZXIIIIIIIIIII\n", + "+0.000 * IIIIIYYIXZZIIIIIIIII\n", + "-0.000 * IIIIIXXIXZZIIIIIIIII\n", + "-0.000 * IIIIIXYIYZZIIIIIIIII\n", + "-0.001 * ZZZZXIYZYIIIIIIIIIII\n", + "-0.001 * ZZZZXIXZXIIIIIIIIIII\n", + "+0.000 * ZZZZYIYZXIIIIIIIIIII\n", + "+0.000 * IIIIYZYIXZZIIIIIIIII\n", + "-0.001 * IIIIXZXIXZZIIIIIIIII\n", + "-0.001 * IIIIXZYIYZZIIIIIIIII\n", + "-0.000 * XIIIIYZZYIIIIIIIIIII\n", + "-0.000 * XIIIIXZZXIIIIIIIIIII\n", + "+0.000 * YIIIIYZZXIIIIIIIIIII\n", + "+0.000 * YZZZZYIIXZZIIIIIIIII\n", + "-0.000 * XZZZZXIIXZZIIIIIIIII\n", + "-0.000 * XZZZZYIIYZZIIIIIIIII\n", + "-0.010 * XIIIYZZZYIIIIIIIIIII\n", + "-0.009 * XIIIXZZZXIIIIIIIIIII\n", + "+0.002 * YIIIYZZZXIIIIIIIIIII\n", + "+0.002 * YZZZYIIIXZZIIIIIIIII\n", + "-0.009 * XZZZXIIIXZZIIIIIIIII\n", + "-0.010 * XZZZYIIIYZZIIIIIIIII\n", + "-0.007 * ZXIYZZZZYIIIIIIIIIII\n", + "-0.001 * ZXIXZZZZXIIIIIIIIIII\n", + "+0.006 * ZYIYZZZZXIIIIIIIIIII\n", + "+0.006 * IYZYIIIIXZZIIIIIIIII\n", + "-0.001 * IXZXIIIIXZZIIIIIIIII\n", + "-0.007 * IXZYIIIIYZZIIIIIIIII\n", + "-0.000 * ZXYZZZZZYIIIIIIIIIII\n", + "-0.000 * ZXXZZZZZXIIIIIIIIIII\n", + "+0.000 * ZYYZZZZZXIIIIIIIIIII\n", + "+0.000 * IYYIIIIIXZZIIIIIIIII\n", + "-0.000 * IXXIIIIIXZZIIIIIIIII\n", + "-0.000 * IXYIIIIIYZZIIIIIIIII\n", + "-0.009 * ZXIIIIIZIIIIIIIIIIII\n", + "+0.009 * IXZZZZZIZZZIIIIIIIII\n", + "-0.001 * ZZZZZXYYIIIIIIIIIIII\n", + "-0.001 * ZZZZZXXXIIIIIIIIIIII\n", + "+0.000 * ZZZZZYYXIIIIIIIIIIII\n", + "+0.000 * IIIIIYYXZZZIIIIIIIII\n", + "-0.001 * IIIIIXXXZZZIIIIIIIII\n", + "-0.001 * IIIIIXYYZZZIIIIIIIII\n", + "+0.000 * ZZZZXIYYIIIIIIIIIIII\n", + "+0.000 * ZZZZXIXXIIIIIIIIIIII\n", + "-0.000 * ZZZZYIYXIIIIIIIIIIII\n", + "-0.000 * IIIIYZYXZZZIIIIIIIII\n", + "+0.000 * IIIIXZXXZZZIIIIIIIII\n", + "+0.000 * IIIIXZYYZZZIIIIIIIII\n", + "-0.010 * XIIIIYZYIIIIIIIIIIII\n", + "-0.009 * XIIIIXZXIIIIIIIIIIII\n", + "+0.002 * YIIIIYZXIIIIIIIIIIII\n", + "+0.002 * YZZZZYIXZZZIIIIIIIII\n", + "-0.009 * XZZZZXIXZZZIIIIIIIII\n", + "-0.010 * XZZZZYIYZZZIIIIIIIII\n", + "+0.000 * XIIIYZZYIIIIIIIIIIII\n", + "+0.000 * XIIIXZZXIIIIIIIIIIII\n", + "-0.000 * YIIIYZZXIIIIIIIIIIII\n", + "-0.000 * YZZZYIIXZZZIIIIIIIII\n", + "+0.000 * XZZZXIIXZZZIIIIIIIII\n", + "+0.000 * XZZZYIIYZZZIIIIIIIII\n", + "+0.000 * ZXIYZZZYIIIIIIIIIIII\n", + "+0.000 * ZXIXZZZXIIIIIIIIIIII\n", + "-0.000 * ZYIYZZZXIIIIIIIIIIII\n", + "-0.000 * IYZYIIIXZZZIIIIIIIII\n", + "+0.000 * IXZXIIIXZZZIIIIIIIII\n", + "+0.000 * IXZYIIIYZZZIIIIIIIII\n", + "-0.007 * ZXYZZZZYIIIIIIIIIIII\n", + "-0.001 * ZXXZZZZXIIIIIIIIIIII\n", + "+0.006 * ZYYZZZZXIIIIIIIIIIII\n", + "+0.006 * IYYIIIIXZZZIIIIIIIII\n", + "-0.001 * IXXIIIIXZZZIIIIIIIII\n", + "-0.007 * IXYIIIIYZZZIIIIIIIII\n", + "-0.013 * ZXIIIIZIIIIIIIIIIIII\n", + "+0.013 * IXZZZZIZZZZIIIIIIIII\n", + "-0.000 * ZZZXIYYIIIIIIIIIIIII\n", + "-0.000 * ZZZXIXXIIIIIIIIIIIII\n", + "-0.000 * ZZZYIYXIIIIIIIIIIIII\n", + "-0.000 * IIIYZYXZZZZIIIIIIIII\n", + "-0.000 * IIIXZXXZZZZIIIIIIIII\n", + "-0.000 * IIIXZYYZZZZIIIIIIIII\n", + "+0.002 * ZZXIIYYIIIIIIIIIIIII\n", + "+0.002 * ZZXIIXXIIIIIIIIIIIII\n", + "+0.000 * ZZYIIYXIIIIIIIIIIIII\n", + "+0.000 * IIYZZYXZZZZIIIIIIIII\n", + "+0.002 * IIXZZXXZZZZIIIIIIIII\n", + "+0.002 * IIXZZYYZZZZIIIIIIIII\n", + "+0.002 * ZZZXYZYIIIIIIIIIIIII\n", + "+0.002 * ZZZXXZXIIIIIIIIIIIII\n", + "+0.000 * ZZZYYZXIIIIIIIIIIIII\n", + "+0.000 * IIIYYIXZZZZIIIIIIIII\n", + "+0.002 * IIIXXIXZZZZIIIIIIIII\n", + "+0.002 * IIIXYIYZZZZIIIIIIIII\n", + "+0.000 * ZZXIYZYIIIIIIIIIIIII\n", + "+0.000 * ZZXIXZXIIIIIIIIIIIII\n", + "+0.000 * ZZYIYZXIIIIIIIIIIIII\n", + "+0.000 * IIYZYIXZZZZIIIIIIIII\n", + "+0.000 * IIXZXIXZZZZIIIIIIIII\n", + "+0.000 * IIXZYIYZZZZIIIIIIIII\n", + "+0.001 * XYZZZZYIIIIIIIIIIIII\n", + "+0.004 * XXZZZZXIIIIIIIIIIIII\n", + "+0.003 * YYZZZZXIIIIIIIIIIIII\n", + "+0.003 * YYIIIIXZZZZIIIIIIIII\n", + "+0.004 * XXIIIIXZZZZIIIIIIIII\n", + "+0.001 * XYIIIIYZZZZIIIIIIIII\n", + "-0.011 * ZXIIIZIIIIIIIIIIIIII\n", + "+0.011 * IXZZZIZZZZZIIIIIIIII\n", + "-0.000 * XIIYZYIIIIIIIIIIIIII\n", + "-0.000 * XIIXZXIIIIIIIIIIIIII\n", + "+0.000 * YIIYZXIIIIIIIIIIIIII\n", + "+0.000 * YZZYIXZZZZZIIIIIIIII\n", + "-0.000 * XZZXIXZZZZZIIIIIIIII\n", + "-0.000 * XZZYIYZZZZZIIIIIIIII\n", + "+0.009 * XIYZZYIIIIIIIIIIIIII\n", + "+0.007 * XIXZZXIIIIIIIIIIIIII\n", + "-0.003 * YIYZZXIIIIIIIIIIIIII\n", + "-0.003 * YZYIIXZZZZZIIIIIIIII\n", + "+0.007 * XZXIIXZZZZZIIIIIIIII\n", + "+0.009 * XZYIIYZZZZZIIIIIIIII\n", + "-0.011 * ZXIIZIIIIIIIIIIIIIII\n", + "+0.011 * IXZZIZZZZZZIIIIIIIII\n", + "+0.009 * XIIYYIIIIIIIIIIIIIII\n", + "+0.007 * XIIXXIIIIIIIIIIIIIII\n", + "-0.003 * YIIYXIIIIIIIIIIIIIII\n", + "-0.003 * YZZYXZZZZZZIIIIIIIII\n", + "+0.007 * XZZXXZZZZZZIIIIIIIII\n", + "+0.009 * XZZYYZZZZZZIIIIIIIII\n", + "+0.000 * XIYZYIIIIIIIIIIIIIII\n", + "+0.000 * XIXZXIIIIIIIIIIIIIII\n", + "-0.000 * YIYZXIIIIIIIIIIIIIII\n", + "-0.000 * YZYIXZZZZZZIIIIIIIII\n", + "+0.000 * XZXIXZZZZZZIIIIIIIII\n", + "+0.000 * XZYIYZZZZZZIIIIIIIII\n", + "-0.006 * ZXIZIIIIIIIIIIIIIIII\n", + "+0.006 * IXZIZZZZZZZIIIIIIIII\n", + "-0.006 * ZXZIIIIIIIIIIIIIIIII\n", + "+0.006 * IXIZZZZZZZZIIIIIIIII\n", + "+0.003 * IXIIIIIIIIIIIIIIIIII\n", + "-0.003 * ZXZZZZZZZZZIIIIIIIII\n", + "+0.101 * IIIIIIIIIZZIIIIIIIII\n", + "+0.000 * IYZZZZZZZYZIIIIIIIII\n", + "+0.000 * IXZZZZZZZXZIIIIIIIII\n", + "+0.109 * IIIIIIIIZIZIIIIIIIII\n", + "-0.003 * IIIYZZZZYIZIIIIIIIII\n", + "-0.003 * IIIXZZZZXIZIIIIIIIII\n", + "-0.000 * IIYZZZZZYIZIIIIIIIII\n", + "-0.000 * IIXZZZZZXIZIIIIIIIII\n", + "+0.109 * IIIIIIIZIIZIIIIIIIII\n", + "+0.000 * IIIYZZZYIIZIIIIIIIII\n", + "+0.000 * IIIXZZZXIIZIIIIIIIII\n", + "-0.003 * IIYZZZZYIIZIIIIIIIII\n", + "-0.003 * IIXZZZZXIIZIIIIIIIII\n", + "+0.102 * IIIIIIZIIIZIIIIIIIII\n", + "+0.000 * YZZZZZYIIIZIIIIIIIII\n", + "+0.000 * XZZZZZXIIIZIIIIIIIII\n", + "+0.108 * IIIIIZIIIIZIIIIIIIII\n", + "+0.108 * IIIIZIIIIIZIIIIIIIII\n", + "+0.117 * IIIZIIIIIIZIIIIIIIII\n", + "+0.117 * IIZIIIIIIIZIIIIIIIII\n", + "+0.116 * IZIIIIIIIIZIIIIIIIII\n", + "+0.127 * ZIIIIIIIIIZIIIIIIIII\n", + "-0.017 * IIIIIIYZZIYIIIIIIIII\n", + "-0.017 * IIIIIIXZZIXIIIIIIIII\n", + "-0.010 * YZZZZZZZZIYIIIIIIIII\n", + "-0.010 * XZZZZZZZZIXIIIIIIIII\n", + "-0.000 * IIIIIYZZXXYIIIIIIIII\n", + "-0.000 * IIIIIYZZYYYIIIIIIIII\n", + "-0.000 * IIIIIXZZXYYIIIIIIIII\n", + "-0.000 * IIIIIYZZYXXIIIIIIIII\n", + "-0.000 * IIIIIXZZXXXIIIIIIIII\n", + "-0.000 * IIIIIXZZYYXIIIIIIIII\n", + "-0.003 * IIIIYZZZXXYIIIIIIIII\n", + "-0.011 * IIIIYZZZYYYIIIIIIIII\n", + "-0.008 * IIIIXZZZXYYIIIIIIIII\n", + "-0.008 * IIIIYZZZYXXIIIIIIIII\n", + "-0.011 * IIIIXZZZXXXIIIIIIIII\n", + "-0.003 * IIIIXZZZYYXIIIIIIIII\n", + "-0.003 * IIIIIYZXIXYIIIIIIIII\n", + "-0.011 * IIIIIYZYIYYIIIIIIIII\n", + "-0.008 * IIIIIXZXIYYIIIIIIIII\n", + "-0.008 * IIIIIYZYIXXIIIIIIIII\n", + "-0.011 * IIIIIXZXIXXIIIIIIIII\n", + "-0.003 * IIIIIXZYIYXIIIIIIIII\n", + "+0.000 * IIIIYZZXIXYIIIIIIIII\n", + "+0.000 * IIIIYZZYIYYIIIIIIIII\n", + "+0.000 * IIIIXZZXIYYIIIIIIIII\n", + "+0.000 * IIIIYZZYIXXIIIIIIIII\n", + "+0.000 * IIIIXZZXIXXIIIIIIIII\n", + "+0.000 * IIIIXZZYIYXIIIIIIIII\n", + "+0.023 * IYZZZZXIIXYIIIIIIIII\n", + "+0.023 * IYZZZZYIIYYIIIIIIIII\n", + "-0.001 * IXZZZZXIIYYIIIIIIIII\n", + "-0.001 * IYZZZZYIIXXIIIIIIIII\n", + "+0.023 * IXZZZZXIIXXIIIIIIIII\n", + "+0.023 * IXZZZZYIIYXIIIIIIIII\n", + "-0.000 * IIIYZXIIIXYIIIIIIIII\n", + "-0.000 * IIIYZYIIIYYIIIIIIIII\n", + "-0.000 * IIIXZXIIIYYIIIIIIIII\n", + "-0.000 * IIIYZYIIIXXIIIIIIIII\n", + "-0.000 * IIIXZXIIIXXIIIIIIIII\n", + "-0.000 * IIIXZYIIIYXIIIIIIIII\n", + "+0.005 * IIYZZXIIIXYIIIIIIIII\n", + "+0.009 * IIYZZYIIIYYIIIIIIIII\n", + "+0.005 * IIXZZXIIIYYIIIIIIIII\n", + "+0.005 * IIYZZYIIIXXIIIIIIIII\n", + "+0.009 * IIXZZXIIIXXIIIIIIIII\n", + "+0.005 * IIXZZYIIIYXIIIIIIIII\n", + "+0.005 * IIIYXIIIIXYIIIIIIIII\n", + "+0.009 * IIIYYIIIIYYIIIIIIIII\n", + "+0.005 * IIIXXIIIIYYIIIIIIIII\n", + "+0.005 * IIIYYIIIIXXIIIIIIIII\n", + "+0.009 * IIIXXIIIIXXIIIIIIIII\n", + "+0.005 * IIIXYIIIIYXIIIIIIIII\n", + "+0.000 * IIYZXIIIIXYIIIIIIIII\n", + "+0.000 * IIYZYIIIIYYIIIIIIIII\n", + "+0.000 * IIXZXIIIIYYIIIIIIIII\n", + "+0.000 * IIYZYIIIIXXIIIIIIIII\n", + "+0.000 * IIXZXIIIIXXIIIIIIIII\n", + "+0.000 * IIXZYIIIIYXIIIIIIIII\n", + "+0.007 * YXIIIIIIIXYIIIIIIIII\n", + "+0.014 * YYIIIIIIIYYIIIIIIIII\n", + "+0.007 * XXIIIIIIIYYIIIIIIIII\n", + "+0.007 * YYIIIIIIIXXIIIIIIIII\n", + "+0.014 * XXIIIIIIIXXIIIIIIIII\n", + "+0.007 * XYIIIIIIIYXIIIIIIIII\n", + "-0.012 * IIIIIIYZIZYIIIIIIIII\n", + "-0.012 * IIIIIIXZIZXIIIIIIIII\n", + "-0.000 * YZZZZZZZIZYIIIIIIIII\n", + "-0.000 * XZZZZZZZIZXIIIIIIIII\n", + "+0.010 * IIIYZZXIXZYIIIIIIIII\n", + "+0.002 * IIIYZZYIYZYIIIIIIIII\n", + "-0.008 * IIIXZZXIYZYIIIIIIIII\n", + "-0.008 * IIIYZZYIXZXIIIIIIIII\n", + "+0.002 * IIIXZZXIXZXIIIIIIIII\n", + "+0.010 * IIIXZZYIYZXIIIIIIIII\n", + "+0.001 * IIYZZZXIXZYIIIIIIIII\n", + "+0.000 * IIYZZZYIYZYIIIIIIIII\n", + "-0.000 * IIXZZZXIYZYIIIIIIIII\n", + "-0.000 * IIYZZZYIXZXIIIIIIIII\n", + "+0.000 * IIXZZZXIXZXIIIIIIIII\n", + "+0.001 * IIXZZZYIYZXIIIIIIIII\n", + "+0.001 * IYZZZXIIXZYIIIIIIIII\n", + "+0.000 * IYZZZYIIYZYIIIIIIIII\n", + "-0.000 * IXZZZXIIYZYIIIIIIIII\n", + "-0.000 * IYZZZYIIXZXIIIIIIIII\n", + "+0.000 * IXZZZXIIXZXIIIIIIIII\n", + "+0.001 * IXZZZYIIYZXIIIIIIIII\n", + "+0.017 * IYZZXIIIXZYIIIIIIIII\n", + "+0.013 * IYZZYIIIYZYIIIIIIIII\n", + "-0.003 * IXZZXIIIYZYIIIIIIIII\n", + "-0.003 * IYZZYIIIXZXIIIIIIIII\n", + "+0.013 * IXZZXIIIXZXIIIIIIIII\n", + "+0.017 * IXZZYIIIYZXIIIIIIIII\n", + "+0.011 * YZZXIIIIXZYIIIIIIIII\n", + "+0.008 * YZZYIIIIYZYIIIIIIIII\n", + "-0.003 * XZZXIIIIYZYIIIIIIIII\n", + "-0.003 * YZZYIIIIXZXIIIIIIIII\n", + "+0.008 * XZZXIIIIXZXIIIIIIIII\n", + "+0.011 * XZZYIIIIYZXIIIIIIIII\n", + "+0.001 * YZXIIIIIXZYIIIIIIIII\n", + "+0.000 * YZYIIIIIYZYIIIIIIIII\n", + "-0.000 * XZXIIIIIYZYIIIIIIIII\n", + "-0.000 * YZYIIIIIXZXIIIIIIIII\n", + "+0.000 * XZXIIIIIXZXIIIIIIIII\n", + "+0.001 * XZYIIIIIYZXIIIIIIIII\n", + "-0.012 * IIIIIIYIZZYIIIIIIIII\n", + "-0.012 * IIIIIIXIZZXIIIIIIIII\n", + "-0.000 * YZZZZZZIZZYIIIIIIIII\n", + "-0.000 * XZZZZZZIZZXIIIIIIIII\n", + "-0.001 * IIIYZZXXZZYIIIIIIIII\n", + "-0.000 * IIIYZZYYZZYIIIIIIIII\n", + "+0.000 * IIIXZZXYZZYIIIIIIIII\n", + "+0.000 * IIIYZZYXZZXIIIIIIIII\n", + "-0.000 * IIIXZZXXZZXIIIIIIIII\n", + "-0.001 * IIIXZZYYZZXIIIIIIIII\n", + "+0.010 * IIYZZZXXZZYIIIIIIIII\n", + "+0.002 * IIYZZZYYZZYIIIIIIIII\n", + "-0.008 * IIXZZZXYZZYIIIIIIIII\n", + "-0.008 * IIYZZZYXZZXIIIIIIIII\n", + "+0.002 * IIXZZZXXZZXIIIIIIIII\n", + "+0.010 * IIXZZZYYZZXIIIIIIIII\n", + "+0.017 * IYZZZXIXZZYIIIIIIIII\n", + "+0.013 * IYZZZYIYZZYIIIIIIIII\n", + "-0.003 * IXZZZXIYZZYIIIIIIIII\n", + "-0.003 * IYZZZYIXZZXIIIIIIIII\n", + "+0.013 * IXZZZXIXZZXIIIIIIIII\n", + "+0.017 * IXZZZYIYZZXIIIIIIIII\n", + "-0.001 * IYZZXIIXZZYIIIIIIIII\n", + "-0.000 * IYZZYIIYZZYIIIIIIIII\n", + "+0.000 * IXZZXIIYZZYIIIIIIIII\n", + "+0.000 * IYZZYIIXZZXIIIIIIIII\n", + "-0.000 * IXZZXIIXZZXIIIIIIIII\n", + "-0.001 * IXZZYIIYZZXIIIIIIIII\n", + "-0.001 * YZZXIIIXZZYIIIIIIIII\n", + "-0.000 * YZZYIIIYZZYIIIIIIIII\n", + "+0.000 * XZZXIIIYZZYIIIIIIIII\n", + "+0.000 * YZZYIIIXZZXIIIIIIIII\n", + "-0.000 * XZZXIIIXZZXIIIIIIIII\n", + "-0.001 * XZZYIIIYZZXIIIIIIIII\n", + "+0.011 * YZXIIIIXZZYIIIIIIIII\n", + "+0.008 * YZYIIIIYZZYIIIIIIIII\n", + "-0.003 * XZXIIIIYZZYIIIIIIIII\n", + "-0.003 * YZYIIIIXZZXIIIIIIIII\n", + "+0.008 * XZXIIIIXZZXIIIIIIIII\n", + "+0.011 * XZYIIIIYZZXIIIIIIIII\n", + "-0.016 * YZZZZZIZZZYIIIIIIIII\n", + "-0.016 * XZZZZZIZZZXIIIIIIIII\n", + "-0.005 * IIIIIZYZZZYIIIIIIIII\n", + "-0.005 * IIIIIZXZZZXIIIIIIIII\n", + "-0.005 * IIIIZIYZZZYIIIIIIIII\n", + "-0.005 * IIIIZIXZZZXIIIIIIIII\n", + "-0.015 * IIIZIIYZZZYIIIIIIIII\n", + "-0.015 * IIIZIIXZZZXIIIIIIIII\n", + "-0.015 * IIZIIIYZZZYIIIIIIIII\n", + "-0.015 * IIZIIIXZZZXIIIIIIIII\n", + "-0.007 * IZIIIIYZZZYIIIIIIIII\n", + "-0.007 * IZIIIIXZZZXIIIIIIIII\n", + "-0.014 * ZIIIIIYZZZYIIIIIIIII\n", + "-0.014 * ZIIIIIXZZZXIIIIIIIII\n", + "-0.007 * YZZZZIZZZZYIIIIIIIII\n", + "-0.007 * XZZZZIZZZZXIIIIIIIII\n", + "+0.000 * IYZXIXZZZZYIIIIIIIII\n", + "+0.000 * IYZYIYZZZZYIIIIIIIII\n", + "-0.000 * IXZXIYZZZZYIIIIIIIII\n", + "-0.000 * IYZYIXZZZZXIIIIIIIII\n", + "+0.000 * IXZXIXZZZZXIIIIIIIII\n", + "+0.000 * IXZYIYZZZZXIIIIIIIII\n", + "-0.012 * IYXIIXZZZZYIIIIIIIII\n", + "-0.006 * IYYIIYZZZZYIIIIIIIII\n", + "+0.005 * IXXIIYZZZZYIIIIIIIII\n", + "+0.005 * IYYIIXZZZZXIIIIIIIII\n", + "-0.006 * IXXIIXZZZZXIIIIIIIII\n", + "-0.012 * IXYIIYZZZZXIIIIIIIII\n", + "-0.007 * YZZZIZZZZZYIIIIIIIII\n", + "-0.007 * XZZZIZZZZZXIIIIIIIII\n", + "-0.012 * IYZXXZZZZZYIIIIIIIII\n", + "-0.006 * IYZYYZZZZZYIIIIIIIII\n", + "+0.005 * IXZXYZZZZZYIIIIIIIII\n", + "+0.005 * IYZYXZZZZZXIIIIIIIII\n", + "-0.006 * IXZXXZZZZZXIIIIIIIII\n", + "-0.012 * IXZYYZZZZZXIIIIIIIII\n", + "-0.000 * IYXIXZZZZZYIIIIIIIII\n", + "-0.000 * IYYIYZZZZZYIIIIIIIII\n", + "+0.000 * IXXIYZZZZZYIIIIIIIII\n", + "+0.000 * IYYIXZZZZZXIIIIIIIII\n", + "-0.000 * IXXIXZZZZZXIIIIIIIII\n", + "-0.000 * IXYIYZZZZZXIIIIIIIII\n", + "+0.004 * YZZIZZZZZZYIIIIIIIII\n", + "+0.004 * XZZIZZZZZZXIIIIIIIII\n", + "+0.004 * YZIZZZZZZZYIIIIIIIII\n", + "+0.004 * XZIZZZZZZZXIIIIIIIII\n", + "+0.015 * YIZZZZZZZZYIIIIIIIII\n", + "+0.015 * XIZZZZZZZZXIIIIIIIII\n", + "+0.102 * IIIIIIIIZZIIIIIIIIII\n", + "+0.008 * IIIYZZZZYZIIIIIIIIII\n", + "+0.008 * IIIXZZZZXZIIIIIIIIII\n", + "+0.000 * IIYZZZZZYZIIIIIIIIII\n", + "+0.000 * IIXZZZZZXZIIIIIIIIII\n", + "+0.102 * IIIIIIIZIZIIIIIIIIII\n", + "-0.000 * IIIYZZZYIZIIIIIIIIII\n", + "-0.000 * IIIXZZZXIZIIIIIIIIII\n", + "+0.008 * IIYZZZZYIZIIIIIIIIII\n", + "+0.008 * IIXZZZZXIZIIIIIIIIII\n", + "+0.060 * IIIIIIZIIZIIIIIIIIII\n", + "+0.005 * YZZZZZYIIZIIIIIIIIII\n", + "+0.005 * XZZZZZXIIZIIIIIIIIII\n", + "+0.109 * IIIIIZIIIZIIIIIIIIII\n", + "+0.109 * IIIIZIIIIZIIIIIIIIII\n", + "+0.101 * IIIZIIIIIZIIIIIIIIII\n", + "+0.101 * IIZIIIIIIZIIIIIIIIII\n", + "+0.100 * IZIIIIIIIZIIIIIIIIII\n", + "+0.113 * ZIIIIIIIIZIIIIIIIIII\n", + "-0.002 * IYZZZZZZIYIIIIIIIIII\n", + "-0.002 * IXZZZZZZIXIIIIIIIIII\n", + "+0.001 * IIIIIYXIXYIIIIIIIIII\n", + "+0.000 * IIIIIYYIYYIIIIIIIIII\n", + "-0.001 * IIIIIXXIYYIIIIIIIIII\n", + "-0.001 * IIIIIYYIXXIIIIIIIIII\n", + "+0.000 * IIIIIXXIXXIIIIIIIIII\n", + "+0.001 * IIIIIXYIYXIIIIIIIIII\n", + "+0.042 * IIIIYZXIXYIIIIIIIIII\n", + "+0.000 * IIIIYZYIYYIIIIIIIIII\n", + "-0.041 * IIIIXZXIYYIIIIIIIIII\n", + "-0.041 * IIIIYZYIXXIIIIIIIIII\n", + "+0.000 * IIIIXZXIXXIIIIIIIIII\n", + "+0.042 * IIIIXZYIYXIIIIIIIIII\n", + "-0.000 * YZZZZXIIXYIIIIIIIIII\n", + "-0.000 * YZZZZYIIYYIIIIIIIIII\n", + "+0.000 * XZZZZXIIYYIIIIIIIIII\n", + "+0.000 * YZZZZYIIXXIIIIIIIIII\n", + "-0.000 * XZZZZXIIXXIIIIIIIIII\n", + "-0.000 * XZZZZYIIYXIIIIIIIIII\n", + "-0.006 * YZZZXIIIXYIIIIIIIIII\n", + "-0.005 * YZZZYIIIYYIIIIIIIIII\n", + "+0.000 * XZZZXIIIYYIIIIIIIIII\n", + "+0.000 * YZZZYIIIXXIIIIIIIIII\n", + "-0.005 * XZZZXIIIXXIIIIIIIIII\n", + "-0.006 * XZZZYIIIYXIIIIIIIIII\n", + "-0.011 * IYZXIIIIXYIIIIIIIIII\n", + "-0.010 * IYZYIIIIYYIIIIIIIIII\n", + "+0.001 * IXZXIIIIYYIIIIIIIIII\n", + "+0.001 * IYZYIIIIXXIIIIIIIIII\n", + "-0.010 * IXZXIIIIXXIIIIIIIIII\n", + "-0.011 * IXZYIIIIYXIIIIIIIIII\n", + "-0.001 * IYXIIIIIXYIIIIIIIIII\n", + "-0.001 * IYYIIIIIYYIIIIIIIIII\n", + "+0.000 * IXXIIIIIYYIIIIIIIIII\n", + "+0.000 * IYYIIIIIXXIIIIIIIIII\n", + "-0.001 * IXXIIIIIXXIIIIIIIIII\n", + "-0.001 * IXYIIIIIYXIIIIIIIIII\n", + "-0.002 * IYZZZZZIZYIIIIIIIIII\n", + "-0.002 * IXZZZZZIZXIIIIIIIIII\n", + "+0.042 * IIIIIYXXZYIIIIIIIIII\n", + "+0.000 * IIIIIYYYZYIIIIIIIIII\n", + "-0.041 * IIIIIXXYZYIIIIIIIIII\n", + "-0.041 * IIIIIYYXZXIIIIIIIIII\n", + "+0.000 * IIIIIXXXZXIIIIIIIIII\n", + "+0.042 * IIIIIXYYZXIIIIIIIIII\n", + "-0.001 * IIIIYZXXZYIIIIIIIIII\n", + "-0.000 * IIIIYZYYZYIIIIIIIIII\n", + "+0.001 * IIIIXZXYZYIIIIIIIIII\n", + "+0.001 * IIIIYZYXZXIIIIIIIIII\n", + "-0.000 * IIIIXZXXZXIIIIIIIIII\n", + "-0.001 * IIIIXZYYZXIIIIIIIIII\n", + "-0.006 * YZZZZXIXZYIIIIIIIIII\n", + "-0.005 * YZZZZYIYZYIIIIIIIIII\n", + "+0.000 * XZZZZXIYZYIIIIIIIIII\n", + "+0.000 * YZZZZYIXZXIIIIIIIIII\n", + "-0.005 * XZZZZXIXZXIIIIIIIIII\n", + "-0.006 * XZZZZYIYZXIIIIIIIIII\n", + "+0.000 * YZZZXIIXZYIIIIIIIIII\n", + "+0.000 * YZZZYIIYZYIIIIIIIIII\n", + "-0.000 * XZZZXIIYZYIIIIIIIIII\n", + "-0.000 * YZZZYIIXZXIIIIIIIIII\n", + "+0.000 * XZZZXIIXZXIIIIIIIIII\n", + "+0.000 * XZZZYIIYZXIIIIIIIIII\n", + "+0.001 * IYZXIIIXZYIIIIIIIIII\n", + "+0.001 * IYZYIIIYZYIIIIIIIIII\n", + "-0.000 * IXZXIIIYZYIIIIIIIIII\n", + "-0.000 * IYZYIIIXZXIIIIIIIIII\n", + "+0.001 * IXZXIIIXZXIIIIIIIIII\n", + "+0.001 * IXZYIIIYZXIIIIIIIIII\n", + "-0.011 * IYXIIIIXZYIIIIIIIIII\n", + "-0.010 * IYYIIIIYZYIIIIIIIIII\n", + "+0.001 * IXXIIIIYZYIIIIIIIIII\n", + "+0.001 * IYYIIIIXZXIIIIIIIIII\n", + "-0.010 * IXXIIIIXZXIIIIIIIIII\n", + "-0.011 * IXYIIIIYZXIIIIIIIIII\n", + "-0.018 * IYZZZZIZZYIIIIIIIIII\n", + "-0.018 * IXZZZZIZZXIIIIIIIIII\n", + "+0.000 * IIIYZXXZZYIIIIIIIIII\n", + "+0.001 * IIIYZYYZZYIIIIIIIIII\n", + "+0.001 * IIIXZXYZZYIIIIIIIIII\n", + "+0.001 * IIIYZYXZZXIIIIIIIIII\n", + "+0.001 * IIIXZXXZZXIIIIIIIIII\n", + "+0.000 * IIIXZYYZZXIIIIIIIIII\n", + "-0.000 * IIYZZXXZZYIIIIIIIIII\n", + "-0.036 * IIYZZYYZZYIIIIIIIIII\n", + "-0.035 * IIXZZXYZZYIIIIIIIIII\n", + "-0.035 * IIYZZYXZZXIIIIIIIIII\n", + "-0.036 * IIXZZXXZZXIIIIIIIIII\n", + "-0.000 * IIXZZYYZZXIIIIIIIIII\n", + "-0.000 * IIIYXIXZZYIIIIIIIIII\n", + "-0.036 * IIIYYIYZZYIIIIIIIIII\n", + "-0.035 * IIIXXIYZZYIIIIIIIIII\n", + "-0.035 * IIIYYIXZZXIIIIIIIIII\n", + "-0.036 * IIIXXIXZZXIIIIIIIIII\n", + "-0.000 * IIIXYIYZZXIIIIIIIIII\n", + "-0.000 * IIYZXIXZZYIIIIIIIIII\n", + "-0.001 * IIYZYIYZZYIIIIIIIIII\n", + "-0.001 * IIXZXIYZZYIIIIIIIIII\n", + "-0.001 * IIYZYIXZZXIIIIIIIIII\n", + "-0.001 * IIXZXIXZZXIIIIIIIIII\n", + "-0.000 * IIXZYIYZZXIIIIIIIIII\n", + "-0.006 * YXIIIIXZZYIIIIIIIIII\n", + "-0.032 * YYIIIIYZZYIIIIIIIIII\n", + "-0.026 * XXIIIIYZZYIIIIIIIIII\n", + "-0.026 * YYIIIIXZZXIIIIIIIIII\n", + "-0.032 * XXIIIIXZZXIIIIIIIIII\n", + "-0.006 * XYIIIIYZZXIIIIIIIIII\n", + "+0.009 * IYZZZIZZZYIIIIIIIIII\n", + "+0.009 * IXZZZIZZZXIIIIIIIIII\n", + "-0.000 * YZZXIXZZZYIIIIIIIIII\n", + "-0.000 * YZZYIYZZZYIIIIIIIIII\n", + "+0.000 * XZZXIYZZZYIIIIIIIIII\n", + "+0.000 * YZZYIXZZZXIIIIIIIIII\n", + "-0.000 * XZZXIXZZZXIIIIIIIIII\n", + "-0.000 * XZZYIYZZZXIIIIIIIIII\n", + "+0.007 * YZXIIXZZZYIIIIIIIIII\n", + "+0.007 * YZYIIYZZZYIIIIIIIIII\n", + "-0.001 * XZXIIYZZZYIIIIIIIIII\n", + "-0.001 * YZYIIXZZZXIIIIIIIIII\n", + "+0.007 * XZXIIXZZZXIIIIIIIIII\n", + "+0.007 * XZYIIYZZZXIIIIIIIIII\n", + "+0.009 * IYZZIZZZZYIIIIIIIIII\n", + "+0.009 * IXZZIZZZZXIIIIIIIIII\n", + "+0.007 * YZZXXZZZZYIIIIIIIIII\n", + "+0.007 * YZZYYZZZZYIIIIIIIIII\n", + "-0.001 * XZZXYZZZZYIIIIIIIIII\n", + "-0.001 * YZZYXZZZZXIIIIIIIIII\n", + "+0.007 * XZZXXZZZZXIIIIIIIIII\n", + "+0.007 * XZZYYZZZZXIIIIIIIIII\n", + "+0.000 * YZXIXZZZZYIIIIIIIIII\n", + "+0.000 * YZYIYZZZZYIIIIIIIIII\n", + "-0.000 * XZXIYZZZZYIIIIIIIIII\n", + "-0.000 * YZYIXZZZZXIIIIIIIIII\n", + "+0.000 * XZXIXZZZZXIIIIIIIIII\n", + "+0.000 * XZYIYZZZZXIIIIIIIIII\n", + "+0.000 * IYZIZZZZZYIIIIIIIIII\n", + "+0.000 * IXZIZZZZZXIIIIIIIIII\n", + "+0.000 * IYIZZZZZZYIIIIIIIIII\n", + "+0.000 * IXIZZZZZZXIIIIIIIIII\n", + "-0.011 * ZYZZZZZZZYIIIIIIIIII\n", + "-0.011 * ZXZZZZZZZXIIIIIIIIII\n", + "+0.110 * IIIIIIIZZIIIIIIIIIII\n", + "+0.000 * IIIYZZZYZIIIIIIIIIII\n", + "+0.000 * IIIXZZZXZIIIIIIIIIII\n", + "-0.003 * IIYZZZZYZIIIIIIIIIII\n", + "-0.003 * IIXZZZZXZIIIIIIIIIII\n", + "+0.106 * IIIIIIZIZIIIIIIIIIII\n", + "+0.006 * YZZZZZYIZIIIIIIIIIII\n", + "+0.006 * XZZZZZXIZIIIIIIIIIII\n", + "+0.108 * IIIIIZIIZIIIIIIIIIII\n", + "+0.001 * IIIIYYIIZIIIIIIIIIII\n", + "+0.001 * IIIIXXIIZIIIIIIIIIII\n", + "+0.071 * IIIIZIIIZIIIIIIIIIII\n", + "+0.097 * IIIZIIIIZIIIIIIIIIII\n", + "+0.001 * IIYYIIIIZIIIIIIIIIII\n", + "+0.001 * IIXXIIIIZIIIIIIIIIII\n", + "+0.114 * IIZIIIIIZIIIIIIIIIII\n", + "+0.115 * IZIIIIIIZIIIIIIIIIII\n", + "+0.127 * ZIIIIIIIZIIIIIIIIIII\n", + "-0.003 * IIIYZZZIYIIIIIIIIIII\n", + "-0.003 * IIIXZZZIXIIIIIIIIIII\n", + "-0.000 * IIYZZZZIYIIIIIIIIIII\n", + "-0.000 * IIXZZZZIXIIIIIIIIIII\n", + "+0.001 * IIIIIZIYYIIIIIIIIIII\n", + "+0.001 * IIIIIZIXXIIIIIIIIIII\n", + "-0.038 * IIIIYXIXYIIIIIIIIIII\n", + "-0.038 * IIIIYYIYYIIIIIIIIIII\n", + "+0.000 * IIIIXXIYYIIIIIIIIIII\n", + "+0.000 * IIIIYYIXXIIIIIIIIIII\n", + "-0.038 * IIIIXXIXXIIIIIIIIIII\n", + "-0.038 * IIIIXYIYXIIIIIIIIIII\n", + "-0.001 * IIIIZIIYYIIIIIIIIIII\n", + "-0.001 * IIIIZIIXXIIIIIIIIIII\n", + "-0.001 * IIIZIIIYYIIIIIIIIIII\n", + "-0.001 * IIIZIIIXXIIIIIIIIIII\n", + "+0.019 * IIYXIIIXYIIIIIIIIIII\n", + "+0.001 * IIYYIIIYYIIIIIIIIIII\n", + "-0.018 * IIXXIIIYYIIIIIIIIIII\n", + "-0.018 * IIYYIIIXXIIIIIIIIIII\n", + "+0.001 * IIXXIIIXXIIIIIIIIIII\n", + "+0.019 * IIXYIIIYXIIIIIIIIIII\n", + "+0.001 * IIZIIIIYYIIIIIIIIIII\n", + "+0.001 * IIZIIIIXXIIIIIIIIIII\n", + "+0.008 * IIIYZZIZYIIIIIIIIIII\n", + "+0.008 * IIIXZZIZXIIIIIIIIIII\n", + "+0.000 * IIYZZZIZYIIIIIIIIIII\n", + "+0.000 * IIXZZZIZXIIIIIIIIIII\n", + "-0.001 * IYZZZXXZYIIIIIIIIIII\n", + "-0.000 * IYZZZYYZYIIIIIIIIIII\n", + "+0.001 * IXZZZXYZYIIIIIIIIIII\n", + "+0.001 * IYZZZYXZXIIIIIIIIIII\n", + "-0.000 * IXZZZXXZXIIIIIIIIIII\n", + "-0.001 * IXZZZYYZXIIIIIIIIIII\n", + "-0.021 * IYZZXIXZYIIIIIIIIIII\n", + "-0.001 * IYZZYIYZYIIIIIIIIIII\n", + "+0.020 * IXZZXIYZYIIIIIIIIIII\n", + "+0.020 * IYZZYIXZXIIIIIIIIIII\n", + "-0.001 * IXZZXIXZXIIIIIIIIIII\n", + "-0.021 * IXZZYIYZXIIIIIIIIIII\n", + "-0.015 * YZZXIIXZYIIIIIIIIIII\n", + "-0.001 * YZZYIIYZYIIIIIIIIIII\n", + "+0.014 * XZZXIIYZYIIIIIIIIIII\n", + "+0.014 * YZZYIIXZXIIIIIIIIIII\n", + "-0.001 * XZZXIIXZXIIIIIIIIIII\n", + "-0.015 * XZZYIIYZXIIIIIIIIIII\n", + "-0.001 * YZXIIIXZYIIIIIIIIIII\n", + "-0.000 * YZYIIIYZYIIIIIIIIIII\n", + "+0.001 * XZXIIIYZYIIIIIIIIIII\n", + "+0.001 * YZYIIIXZXIIIIIIIIIII\n", + "-0.000 * XZXIIIXZXIIIIIIIIIII\n", + "-0.001 * XZYIIIYZXIIIIIIIIIII\n", + "+0.013 * IIIYZIZZYIIIIIIIIIII\n", + "+0.013 * IIIXZIZZXIIIIIIIIIII\n", + "-0.000 * IIYZZIZZYIIIIIIIIIII\n", + "-0.000 * IIXZZIZZXIIIIIIIIIII\n", + "+0.001 * IIIYXXZZYIIIIIIIIIII\n", + "-0.001 * IIIYYYZZYIIIIIIIIIII\n", + "-0.002 * IIIXXYZZYIIIIIIIIIII\n", + "-0.002 * IIIYYXZZXIIIIIIIIIII\n", + "-0.001 * IIIXXXZZXIIIIIIIIIII\n", + "+0.001 * IIIXYYZZXIIIIIIIIIII\n", + "-0.033 * IIYZXXZZYIIIIIIIIIII\n", + "-0.000 * IIYZYYZZYIIIIIIIIIII\n", + "+0.033 * IIXZXYZZYIIIIIIIIIII\n", + "+0.033 * IIYZYXZZXIIIIIIIIIII\n", + "-0.000 * IIXZXXZZXIIIIIIIIIII\n", + "-0.033 * IIXZYYZZXIIIIIIIIIII\n", + "-0.000 * YXIIIXZZYIIIIIIIIIII\n", + "-0.001 * YYIIIYZZYIIIIIIIIIII\n", + "-0.001 * XXIIIYZZYIIIIIIIIIII\n", + "-0.001 * YYIIIXZZXIIIIIIIIIII\n", + "-0.001 * XXIIIXZZXIIIIIIIIIII\n", + "-0.000 * XYIIIYZZXIIIIIIIIIII\n", + "-0.021 * IIIYIZZZYIIIIIIIIIII\n", + "-0.021 * IIIXIZZZXIIIIIIIIIII\n", + "+0.000 * IIYZIZZZYIIIIIIIIIII\n", + "+0.000 * IIXZIZZZXIIIIIIIIIII\n", + "-0.000 * YXIIXZZZYIIIIIIIIIII\n", + "-0.033 * YYIIYZZZYIIIIIIIIIII\n", + "-0.033 * XXIIYZZZYIIIIIIIIIII\n", + "-0.033 * YYIIXZZZXIIIIIIIIIII\n", + "-0.033 * XXIIXZZZXIIIIIIIIIII\n", + "-0.000 * XYIIYZZZXIIIIIIIIIII\n", + "-0.000 * IIYIZZZZYIIIIIIIIIII\n", + "-0.000 * IIXIZZZZXIIIIIIIIIII\n", + "-0.007 * IIZYZZZZYIIIIIIIIIII\n", + "-0.007 * IIZXZZZZXIIIIIIIIIII\n", + "-0.000 * IZIYZZZZYIIIIIIIIIII\n", + "-0.000 * IZIXZZZZXIIIIIIIIIII\n", + "-0.011 * ZIIYZZZZYIIIIIIIIIII\n", + "-0.011 * ZIIXZZZZXIIIIIIIIIII\n", + "-0.000 * IZYZZZZZYIIIIIIIIIII\n", + "-0.000 * IZXZZZZZXIIIIIIIIIII\n", + "-0.001 * ZIYZZZZZYIIIIIIIIIII\n", + "-0.001 * ZIXZZZZZXIIIIIIIIIII\n", + "+0.106 * IIIIIIZZIIIIIIIIIIII\n", + "+0.006 * YZZZZZYZIIIIIIIIIIII\n", + "+0.006 * XZZZZZXZIIIIIIIIIIII\n", + "+0.071 * IIIIIZIZIIIIIIIIIIII\n", + "-0.001 * IIIIYYIZIIIIIIIIIIII\n", + "-0.001 * IIIIXXIZIIIIIIIIIIII\n", + "+0.108 * IIIIZIIZIIIIIIIIIIII\n", + "+0.114 * IIIZIIIZIIIIIIIIIIII\n", + "-0.001 * IIYYIIIZIIIIIIIIIIII\n", + "-0.001 * IIXXIIIZIIIIIIIIIIII\n", + "+0.097 * IIZIIIIZIIIIIIIIIIII\n", + "+0.115 * IZIIIIIZIIIIIIIIIIII\n", + "+0.127 * ZIIIIIIZIIIIIIIIIIII\n", + "-0.000 * IIIYZZIYIIIIIIIIIIII\n", + "-0.000 * IIIXZZIXIIIIIIIIIIII\n", + "+0.008 * IIYZZZIYIIIIIIIIIIII\n", + "+0.008 * IIXZZZIXIIIIIIIIIIII\n", + "-0.021 * IYZZZXXYIIIIIIIIIIII\n", + "-0.001 * IYZZZYYYIIIIIIIIIIII\n", + "+0.020 * IXZZZXYYIIIIIIIIIIII\n", + "+0.020 * IYZZZYXXIIIIIIIIIIII\n", + "-0.001 * IXZZZXXXIIIIIIIIIIII\n", + "-0.021 * IXZZZYYXIIIIIIIIIIII\n", + "+0.001 * IYZZXIXYIIIIIIIIIIII\n", + "+0.000 * IYZZYIYYIIIIIIIIIIII\n", + "-0.001 * IXZZXIYYIIIIIIIIIIII\n", + "-0.001 * IYZZYIXXIIIIIIIIIIII\n", + "+0.000 * IXZZXIXXIIIIIIIIIIII\n", + "+0.001 * IXZZYIYXIIIIIIIIIIII\n", + "+0.001 * YZZXIIXYIIIIIIIIIIII\n", + "+0.000 * YZZYIIYYIIIIIIIIIIII\n", + "-0.001 * XZZXIIYYIIIIIIIIIIII\n", + "-0.001 * YZZYIIXXIIIIIIIIIIII\n", + "+0.000 * XZZXIIXXIIIIIIIIIIII\n", + "+0.001 * XZZYIIYXIIIIIIIIIIII\n", + "-0.015 * YZXIIIXYIIIIIIIIIIII\n", + "-0.001 * YZYIIIYYIIIIIIIIIIII\n", + "+0.014 * XZXIIIYYIIIIIIIIIIII\n", + "+0.014 * YZYIIIXXIIIIIIIIIIII\n", + "-0.001 * XZXIIIXXIIIIIIIIIIII\n", + "-0.015 * XZYIIIYXIIIIIIIIIIII\n", + "-0.000 * IIIYZIZYIIIIIIIIIIII\n", + "-0.000 * IIIXZIZXIIIIIIIIIIII\n", + "-0.021 * IIYZZIZYIIIIIIIIIIII\n", + "-0.021 * IIXZZIZXIIIIIIIIIIII\n", + "-0.000 * IIIYXXZYIIIIIIIIIIII\n", + "-0.033 * IIIYYYZYIIIIIIIIIIII\n", + "-0.033 * IIIXXYZYIIIIIIIIIIII\n", + "-0.033 * IIIYYXZXIIIIIIIIIIII\n", + "-0.033 * IIIXXXZXIIIIIIIIIIII\n", + "-0.000 * IIIXYYZXIIIIIIIIIIII\n", + "+0.001 * IIYZXXZYIIIIIIIIIIII\n", + "-0.001 * IIYZYYZYIIIIIIIIIIII\n", + "-0.002 * IIXZXYZYIIIIIIIIIIII\n", + "-0.002 * IIYZYXZXIIIIIIIIIIII\n", + "-0.001 * IIXZXXZXIIIIIIIIIIII\n", + "+0.001 * IIXZYYZXIIIIIIIIIIII\n", + "-0.000 * YXIIIXZYIIIIIIIIIIII\n", + "-0.033 * YYIIIYZYIIIIIIIIIIII\n", + "-0.033 * XXIIIYZYIIIIIIIIIIII\n", + "-0.033 * YYIIIXZXIIIIIIIIIIII\n", + "-0.033 * XXIIIXZXIIIIIIIIIIII\n", + "-0.000 * XYIIIYZXIIIIIIIIIIII\n", + "+0.000 * IIIYIZZYIIIIIIIIIIII\n", + "+0.000 * IIIXIZZXIIIIIIIIIIII\n", + "+0.013 * IIYZIZZYIIIIIIIIIIII\n", + "+0.013 * IIXZIZZXIIIIIIIIIIII\n", + "+0.000 * YXIIXZZYIIIIIIIIIIII\n", + "+0.001 * YYIIYZZYIIIIIIIIIIII\n", + "+0.001 * XXIIYZZYIIIIIIIIIIII\n", + "+0.001 * YYIIXZZXIIIIIIIIIIII\n", + "+0.001 * XXIIXZZXIIIIIIIIIIII\n", + "+0.000 * XYIIYZZXIIIIIIIIIIII\n", + "-0.007 * IIYIZZZYIIIIIIIIIIII\n", + "-0.007 * IIXIZZZXIIIIIIIIIIII\n", + "+0.000 * IIZYZZZYIIIIIIIIIIII\n", + "+0.000 * IIZXZZZXIIIIIIIIIIII\n", + "+0.000 * IZIYZZZYIIIIIIIIIIII\n", + "+0.000 * IZIXZZZXIIIIIIIIIIII\n", + "+0.001 * ZIIYZZZYIIIIIIIIIIII\n", + "+0.001 * ZIIXZZZXIIIIIIIIIIII\n", + "-0.000 * IZYZZZZYIIIIIIIIIIII\n", + "-0.000 * IZXZZZZXIIIIIIIIIIII\n", + "-0.011 * ZIYZZZZYIIIIIIIIIIII\n", + "-0.011 * ZIXZZZZXIIIIIIIIIIII\n", + "+0.114 * IIIIIZZIIIIIIIIIIIII\n", + "+0.114 * IIIIZIZIIIIIIIIIIIII\n", + "+0.108 * IIIZIIZIIIIIIIIIIIII\n", + "+0.108 * IIZIIIZIIIIIIIIIIIII\n", + "+0.102 * IZIIIIZIIIIIIIIIIIII\n", + "+0.110 * ZIIIIIZIIIIIIIIIIIII\n", + "-0.006 * YZZZZIYIIIIIIIIIIIII\n", + "-0.006 * XZZZZIXIIIIIIIIIIIII\n", + "+0.000 * IYZXIXYIIIIIIIIIIIII\n", + "+0.000 * IYZYIYYIIIIIIIIIIIII\n", + "-0.000 * IXZXIYYIIIIIIIIIIIII\n", + "-0.000 * IYZYIXXIIIIIIIIIIIII\n", + "+0.000 * IXZXIXXIIIIIIIIIIIII\n", + "+0.000 * IXZYIYXIIIIIIIIIIIII\n", + "-0.020 * IYXIIXYIIIIIIIIIIIII\n", + "-0.018 * IYYIIYYIIIIIIIIIIIII\n", + "+0.001 * IXXIIYYIIIIIIIIIIIII\n", + "+0.001 * IYYIIXXIIIIIIIIIIIII\n", + "-0.018 * IXXIIXXIIIIIIIIIIIII\n", + "-0.020 * IXYIIYXIIIIIIIIIIIII\n", + "-0.006 * YZZZIZYIIIIIIIIIIIII\n", + "-0.006 * XZZZIZXIIIIIIIIIIIII\n", + "-0.020 * IYZXXZYIIIIIIIIIIIII\n", + "-0.018 * IYZYYZYIIIIIIIIIIIII\n", + "+0.001 * IXZXYZYIIIIIIIIIIIII\n", + "+0.001 * IYZYXZXIIIIIIIIIIIII\n", + "-0.018 * IXZXXZXIIIIIIIIIIIII\n", + "-0.020 * IXZYYZXIIIIIIIIIIIII\n", + "-0.000 * IYXIXZYIIIIIIIIIIIII\n", + "-0.000 * IYYIYZYIIIIIIIIIIIII\n", + "+0.000 * IXXIYZYIIIIIIIIIIIII\n", + "+0.000 * IYYIXZXIIIIIIIIIIIII\n", + "-0.000 * IXXIXZXIIIIIIIIIIIII\n", + "-0.000 * IXYIYZXIIIIIIIIIIIII\n", + "+0.008 * YZZIZZYIIIIIIIIIIIII\n", + "+0.008 * XZZIZZXIIIIIIIIIIIII\n", + "+0.008 * YZIZZZYIIIIIIIIIIIII\n", + "+0.008 * XZIZZZXIIIIIIIIIIIII\n", + "+0.025 * YIZZZZYIIIIIIIIIIIII\n", + "+0.025 * XIZZZZXIIIIIIIIIIIII\n", + "+0.120 * IIIIZZIIIIIIIIIIIIII\n", + "+0.109 * IIIZIZIIIIIIIIIIIIII\n", + "-0.000 * IIYYIZIIIIIIIIIIIIII\n", + "-0.000 * IIXXIZIIIIIIIIIIIIII\n", + "+0.081 * IIZIIZIIIIIIIIIIIIII\n", + "+0.115 * IZIIIZIIIIIIIIIIIIII\n", + "+0.119 * ZIIIIZIIIIIIIIIIIIII\n", + "-0.000 * IIIZYYIIIIIIIIIIIIII\n", + "-0.000 * IIIZXXIIIIIIIIIIIIII\n", + "-0.029 * IIYXXYIIIIIIIIIIIIII\n", + "-0.028 * IIYYYYIIIIIIIIIIIIII\n", + "+0.001 * IIXXYYIIIIIIIIIIIIII\n", + "+0.001 * IIYYXXIIIIIIIIIIIIII\n", + "-0.028 * IIXXXXIIIIIIIIIIIIII\n", + "-0.029 * IIXYYXIIIIIIIIIIIIII\n", + "+0.000 * IIZIYYIIIIIIIIIIIIII\n", + "+0.000 * IIZIXXIIIIIIIIIIIIII\n", + "-0.000 * YXIXZYIIIIIIIIIIIIII\n", + "-0.000 * YYIYZYIIIIIIIIIIIIII\n", + "-0.000 * XXIYZYIIIIIIIIIIIIII\n", + "-0.000 * YYIXZXIIIIIIIIIIIIII\n", + "-0.000 * XXIXZXIIIIIIIIIIIIII\n", + "-0.000 * XYIYZXIIIIIIIIIIIIII\n", + "+0.000 * YXXZZYIIIIIIIIIIIIII\n", + "+0.026 * YYYZZYIIIIIIIIIIIIII\n", + "+0.026 * XXYZZYIIIIIIIIIIIIII\n", + "+0.026 * YYXZZXIIIIIIIIIIIIII\n", + "+0.026 * XXXZZXIIIIIIIIIIIIII\n", + "+0.000 * XYYZZXIIIIIIIIIIIIII\n", + "+0.081 * IIIZZIIIIIIIIIIIIIII\n", + "+0.000 * IIYYZIIIIIIIIIIIIIII\n", + "+0.000 * IIXXZIIIIIIIIIIIIIII\n", + "+0.109 * IIZIZIIIIIIIIIIIIIII\n", + "+0.115 * IZIIZIIIIIIIIIIIIIII\n", + "+0.119 * ZIIIZIIIIIIIIIIIIIII\n", + "+0.000 * YXIXYIIIIIIIIIIIIIII\n", + "+0.026 * YYIYYIIIIIIIIIIIIIII\n", + "+0.026 * XXIYYIIIIIIIIIIIIIII\n", + "+0.026 * YYIXXIIIIIIIIIIIIIII\n", + "+0.026 * XXIXXIIIIIIIIIIIIIII\n", + "+0.000 * XYIYXIIIIIIIIIIIIIII\n", + "+0.000 * YXXZYIIIIIIIIIIIIIII\n", + "+0.000 * YYYZYIIIIIIIIIIIIIII\n", + "+0.000 * XXYZYIIIIIIIIIIIIIII\n", + "+0.000 * YYXZXIIIIIIIIIIIIIII\n", + "+0.000 * XXXZXIIIIIIIIIIIIIII\n", + "+0.000 * XYYZXIIIIIIIIIIIIIII\n", + "+0.119 * IIZZIIIIIIIIIIIIIIII\n", + "+0.114 * IZIZIIIIIIIIIIIIIIII\n", + "+0.132 * ZIIZIIIIIIIIIIIIIIII\n", + "+0.114 * IZZIIIIIIIIIIIIIIIII\n", + "+0.132 * ZIZIIIIIIIIIIIIIIIII\n", + "+0.108 * ZZIIIIIIIIIIIIIIIIII\n" + ] + } + ], + "source": [ + "chemistry_problem = MoleculeProblem(\n", + " molecule=molecule,\n", + " mapping=\"jordan_wigner\", #'bravyi_kitaev'\n", + " z2_symmetries=True,\n", + " freeze_core=True,\n", + ")\n", + "\n", + "operator = chemistry_problem.generate_hamiltonian()\n", + "gs_problem = chemistry_problem.update_problem(operator.num_qubits)\n", + "print(\"Your Hamiltonian is\", operator.show(), sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "67a124c2-33fc-420c-8cb3-0002f18f4e77", + "metadata": { + "id": "67a124c2-33fc-420c-8cb3-0002f18f4e77" + }, + "source": [ + "The output of the above code lines is the Hamiltonian presented as a superposition of Pauli matrices multiplication.\n", + "One can easily confirm that using z2*symmetries=True, the number of qubits are reduced (compered to z2_symmetries=False): for $H_2$ - from 4 to 1, for $LiH$ from 12 to 8, and for $H*{2}O$ from 14 to 10." + ] + }, + { + "cell_type": "markdown", + "id": "8abe3e3d-1b01-4fab-b86a-feaab3851950", + "metadata": { + "id": "8abe3e3d-1b01-4fab-b86a-feaab3851950" + }, + "source": [ + "## 2. Constructing and Synthesizing a Ground State Solver\n", + "\n", + "A ground state solver model consists of a parameterized eigenfunction (\"the ansatz\"), on which we run a VQE. In addition, a post-process of the result allows to return the total energy (combining the ground state energy of the Hamiltonian, the nuclear repulsion and the static nuclear energy).\n", + "\n", + "Once we've specified an Hamiltonian and a desired Ansatz, we send them to the VQE algorithm in order to find the Hamiltonian's ground state. In the process, the algorithm will send requests to a classical server, which task is to minimize the energy expectation value and return the optimized parameters. The simulator and optimizing parameters are defined as part of the VQE part of the model. The user should control the `max_iteration` value in a manner so the solution has reached a stable convergence. In addition, the value `num_shots` sets the number of measurements performed after each iteration, thus influence the accuracy of the solutions.\n", + "\n", + "We demonstrate two different proposal for the wavefunction solution ansatz: (1) Hardware (HW) efficient, and (2) Unitary Coupled Cluster (UCC). For groundstate solvers it is typical to initialize the Ansatz with the Hartree-Fock state." + ] + }, + { + "cell_type": "markdown", + "id": "07ed8f8e-485b-4f0f-93b7-78e7fd6fbe39", + "metadata": { + "id": "07ed8f8e-485b-4f0f-93b7-78e7fd6fbe39" + }, + "source": [ + "### 2.1 HW-Efficient Ansatz\n", + "\n", + "Hardware-efficient ansatz is a suggested solution that is generated to fit a specific hardware [1]. The ansatz creates a state with given number of parameters by user choice (number of qubits, that should fit the Hamiltonian), and creates entanglement between the qubits by the inputed connectivity map. In this example, a 4 qubit map is given, which is specifically made of $H_2$ with z2_symmetries=False.\n", + "\n", + "After constructing the model, we can synthesize it and view the outputted circuit, in charged on creating the state with an interactive interface." + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "90b20061-8dbd-4136-adba-28ddacb1f583", + "metadata": { + "id": "90b20061-8dbd-4136-adba-28ddacb1f583" + }, + "outputs": [], + "source": [ + "chemistry_problem = MoleculeProblem(\n", + " molecule=molecule,\n", + " mapping=\"jordan_wigner\", #'bravyi_kitaev'\n", + " z2_symmetries=False,\n", + " freeze_core=True,\n", + ")\n", + "\n", + "hwea_params = HEAParameters(\n", + " num_qubits=24,\n", + " connectivity_map=[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8),\n", + " (8, 9), (9, 10)],\n", + " reps=3,\n", + " one_qubit_gates=[\"x\", \"ry\"],\n", + " two_qubit_gates=[\"cx\"],\n", + ")\n", + "\n", + "qmod = construct_chemistry_model(\n", + " chemistry_problem=chemistry_problem,\n", + " use_hartree_fock=True,\n", + " ansatz_parameters=hwea_params,\n", + " execution_parameters=ChemistryExecutionParameters(\n", + " optimizer=OptimizerType.COBYLA,\n", + " max_iteration=30,\n", + " initial_point=None,\n", + " ),\n", + ")\n", + "\n", + "backend_preferences = ClassiqBackendPreferences(\n", + " backend_name=ClassiqSimulatorBackendNames.SIMULATOR\n", + ")\n", + "\n", + "qmod = set_execution_preferences(\n", + " qmod,\n", + " execution_preferences=ExecutionPreferences(\n", + " num_shots=1000, backend_preferences=backend_preferences\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "id": "f13599d2-e8e7-4165-aa26-8ae8d4bdafaa", + "metadata": { + "id": "f13599d2-e8e7-4165-aa26-8ae8d4bdafaa" + }, + "outputs": [], + "source": [ + "from classiq import write_qmod\n", + "\n", + "write_qmod(qmod, name=\"molecule_eigensolver\")" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "22cd12d1-2c87-400a-a983-b2f24e40fa45", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "22cd12d1-2c87-400a-a983-b2f24e40fa45", + "outputId": "d48d0740-4851-4943-f54b-325303b4838a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/3bc0b6ac-4cbc-46e6-8238-227db5ab0a79?version=0.42.1\n" + ] + } + ], + "source": [ + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "id": "7fb92cdc", + "metadata": { + "id": "7fb92cdc" + }, + "source": [ + "### 2.2. UCC Ansatz\n", + "\n", + "Next, we show how to create the commonly used chemistry-inspired UCC ansatz, which is a unitary version of the classical coupled cluster (CC) method [2] .\n", + "\n", + "The parameter that defines the UCC ansatz is:\n", + "- excitations (List[int] or List[str]): list of desired excitations. Allowed excitations:\n", + " - 1 for singles\n", + " - 2 for doubles\n", + " - 3 for triples\n", + " - 4 for quadruples\n", + "\n", + "Once again, after the code lines bellow run, the user is able to view the outputted circuit, in charged on creating the state with an interactive interface. In addition, the depth of the circuit is printed.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "id": "1f520673", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "1f520673", + "outputId": "fd4a3467-c48b-483c-b156-0a0cde9e2189" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/ce59181f-b6f0-4cff-8be5-4f5d9aa0cc9f?version=0.42.1\n", + "circuit depth: 16968\n" + ] + } + ], + "source": [ + "chemistry_problem = MoleculeProblem(\n", + " molecule=molecule,\n", + " mapping=\"jordan_wigner\", #'bravyi_kitaev'\n", + " z2_symmetries=True,\n", + " freeze_core=True,\n", + ")\n", + "\n", + "serialized_chemistry_model = construct_chemistry_model(\n", + " chemistry_problem=chemistry_problem,\n", + " use_hartree_fock=True,\n", + " ansatz_parameters=UCCParameters(excitations=[1, 2]),\n", + " execution_parameters=ChemistryExecutionParameters(\n", + " optimizer=OptimizerType.COBYLA,\n", + " max_iteration=30,\n", + " initial_point=None,\n", + " ),\n", + ")\n", + "\n", + "backend_preferences = ClassiqBackendPreferences(\n", + " backend_name=ClassiqSimulatorBackendNames.SIMULATOR\n", + ")\n", + "\n", + "serialized_chemistry_model = set_execution_preferences(\n", + " serialized_chemistry_model,\n", + " execution_preferences=ExecutionPreferences(\n", + " num_shots=1000, backend_preferences=backend_preferences\n", + " ),\n", + ")\n", + "\n", + "qprog = synthesize(serialized_chemistry_model)\n", + "show(qprog)\n", + "\n", + "circuit = QuantumProgram.from_qprog(qprog)\n", + "print(f\"circuit depth: {circuit.transpiled_circuit.depth}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f12c9a32-f271-4892-8515-bd9e6b9fcf8b", + "metadata": { + "id": "f12c9a32-f271-4892-8515-bd9e6b9fcf8b" + }, + "source": [ + "Classiq's UCC algorithm provides an highly efficient solution in aspects of circuit depth and number of CX gates. Those ultimately reduce the gate's time and amount of resources needed for its operation." + ] + }, + { + "cell_type": "markdown", + "id": "ef36661f", + "metadata": { + "id": "ef36661f" + }, + "source": [ + "## 3. Execute to Find Ground State\n", + "\n", + "Once we've synthesized the model we can execute it." + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "1a66d377", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 477 + }, + "id": "1a66d377", + "outputId": "1c93e68e-1300-4fde-ec56-e6e2d377a96e" + }, + "outputs": [ + { + "output_type": "error", + "ename": "ClassiqAPIError", + "evalue": "Error number 90001 occurred. The resources needed to execute this request are insufficient.\n This may be due to computational limitations, or high load on Classiq's servers.\n We suggest trying with alternative parameters, or reducing the resource consumption.\n\n\nError identifier: E581A0475-26BA-4C43-A7AB-BFFCF3EAF1CC.\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mClassiqAPIError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqprog\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mchemistry_result_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/classiq/_internals/async_utils.py\u001b[0m in \u001b[0;36masync_wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mfunctools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0masync_func\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0masync_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0masync_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;31m# patch `functools.wraps` work on `name` and `qualname`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/classiq/_internals/async_utils.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(coro)\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;31m# Never use asyncio.run in library code.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0mloop\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_event_loop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mloop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_until_complete\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcoro\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/nest_asyncio.py\u001b[0m in \u001b[0;36mrun_until_complete\u001b[0;34m(self, future)\u001b[0m\n\u001b[1;32m 96\u001b[0m raise RuntimeError(\n\u001b[1;32m 97\u001b[0m 'Event loop stopped before Future completed.')\n\u001b[0;32m---> 98\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 99\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 100\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_run_once\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.10/asyncio/futures.py\u001b[0m in \u001b[0;36mresult\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 199\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__log_traceback\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_exception\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 201\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_exception\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_exception_tb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 202\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 203\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.10/asyncio/tasks.py\u001b[0m in \u001b[0;36m__step\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 230\u001b[0m \u001b[0;31m# We use the `send` method directly, because coroutines\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 231\u001b[0m \u001b[0;31m# don't have `__iter__` and `__next__` methods.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 232\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcoro\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 233\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 234\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcoro\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mthrow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/classiq/execution/jobs.py\u001b[0m in \u001b[0;36mresult_async\u001b[0;34m(self, timeout_sec)\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mJobStatus\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFAILED\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 98\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mClassiqAPIError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merror\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 99\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mJobStatus\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCANCELLED\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 100\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mClassiqAPIError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Job has been cancelled.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mClassiqAPIError\u001b[0m: Error number 90001 occurred. The resources needed to execute this request are insufficient.\n This may be due to computational limitations, or high load on Classiq's servers.\n We suggest trying with alternative parameters, or reducing the resource consumption.\n\n\nError identifier: E581A0475-26BA-4C43-A7AB-BFFCF3EAF1CC.\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support" + ] + } + ], + "source": [ + "result = execute(qprog).result()\n", + "chemistry_result_dict = result[1].value" + ] + }, + { + "cell_type": "markdown", + "id": "f72ceeb5-bc71-46d8-a390-31ec874700f3", + "metadata": { + "id": "f72ceeb5-bc71-46d8-a390-31ec874700f3" + }, + "source": [ + "Execution of the quantum program returns several useful outputs:\n", + "- energy : the output of the VQE algorithm - the electronic energy simulated.\n", + "- nuclear_repulsion : the electrostatic energy generated by the atom's nuclei.\n", + "- hartree_fock_energy : the Hartree Fock energy.\n", + "- total_energy : this is the ground state energy of the Hamiltonian (combining the energy, the nuclear repulsion and the static nuclear energy).\n", + "\n", + "It also contains the full VQE result from which we can get, for example:\n", + "- optimal_parameters : gives the results for the anzats parameters minimizing that expectation value.\n", + "- eigenstate : gives the ground state wave function.\n", + "\n", + "Note the all energy are presented in units of Hartree." + ] + }, + { + "cell_type": "markdown", + "id": "6VG1iSvMpb8M", + "metadata": { + "id": "6VG1iSvMpb8M" + }, + "source": [] + }, + { + "cell_type": "markdown", + "id": "aGkNxwqpX1Yz", + "metadata": { + "id": "aGkNxwqpX1Yz" + }, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "437b3211", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "437b3211", + "outputId": "dbe14152-d540-4cd0-f294-b17824883a4c" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "-71.7605079203085" + ] + }, + "metadata": {}, + "execution_count": 138 + } + ], + "source": [ + "chemistry_result_dict[\"total_energy\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "9a537d3c", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "collapsed": true, + "id": "9a537d3c", + "outputId": "bbb38543-5586-41d0-80a4-32ce72e3fa1b" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'param_0': 4.297574618367516,\n", + " 'param_1': -1.504633061740663,\n", + " 'param_10': -3.6437416361959856,\n", + " 'param_11': 0.06857537289766391,\n", + " 'param_12': -0.36346685952612656,\n", + " 'param_13': -0.7519018401777506,\n", + " 'param_14': -2.8118598605968717,\n", + " 'param_15': 1.307451081841208,\n", + " 'param_16': -4.4156026166000935,\n", + " 'param_17': 2.1175446665800237,\n", + " 'param_18': 5.580438616773936,\n", + " 'param_19': -3.08318244300614,\n", + " 'param_2': 3.6622861342765347,\n", + " 'param_20': 5.726122176829751,\n", + " 'param_21': 3.65873933961565,\n", + " 'param_22': -5.530192925838418,\n", + " 'param_23': 3.063438649255726,\n", + " 'param_24': 0.5301345737711989,\n", + " 'param_25': -3.31817327605338,\n", + " 'param_26': -4.998839006910894,\n", + " 'param_27': -6.2474777669575765,\n", + " 'param_28': -2.8845513153540208,\n", + " 'param_29': -3.1405109604973145,\n", + " 'param_3': -4.53110966026628,\n", + " 'param_4': 4.748304331159153,\n", + " 'param_5': -5.219454727089838,\n", + " 'param_6': 2.8281186713622386,\n", + " 'param_7': -1.9088614011539669,\n", + " 'param_8': 6.121290432401807,\n", + " 'param_9': -2.7335067577998275}" + ] + }, + "metadata": {}, + "execution_count": 139 + } + ], + "source": [ + "chemistry_result_dict[\"vqe_result\"][\"optimal_parameters\"]" + ] + }, + { + "cell_type": "markdown", + "id": "2375f3c3", + "metadata": { + "id": "2375f3c3" + }, + "source": [ + "Finally, we can compare the VQE solution to the classical solution by employing exact diagonalization:" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "5c896576", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "5c896576", + "outputId": "f6ada73d-6bd4-440d-98c1-d17e70b57cde" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "exact result: -23.544497240443615\n", + "vqe result: -80.95442108093188\n" + ] + } + ], + "source": [ + "mat = operator.to_matrix()\n", + "w, v = np.linalg.eig(mat)\n", + "print(\"exact result:\", np.real(min(w)))\n", + "print(\"vqe result:\", chemistry_result_dict[\"energy\"])" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## **h2**\n", + "\n", + "hw-eff: width 4/depth34\n", + "\n", + "ucc: width 1/depth 6, width 4, depth 3\n", + "\n", + "total en -1.1342995783232035,\n", + "exact result: -1.8572750302023786,\n", + "vqe result: -1.854268572772183\n" + ], + "metadata": { + "id": "TXF-IJT59B7j" + }, + "id": "TXF-IJT59B7j" + }, + { + "cell_type": "markdown", + "id": "2qTUaxbEX5IF", + "metadata": { + "id": "2qTUaxbEX5IF" + }, + "source": [ + "## **h2o**\n", + "\n", + "hw-eff.: width 12/depth 375,\n", + "(conn map 0-1..10-11, reps 11)\n", + "\n", + "ucc: width 8/depth 1218, width 12/depth 1048\n", + "\n", + "total energy -71.7605079203085,\n", + "exact result: -23.544497240443615,\n", + "vqe result: -80.95442108093192" + ] + }, + { + "cell_type": "markdown", + "id": "bxRq_3-Jb4_0", + "metadata": { + "id": "bxRq_3-Jb4_0" + }, + "source": [ + "##**co2**\n", + "\n", + "hw-eff: width 24/depth 175\n", + "\n", + "ucc: width 20/depth 19767, width 24/depth 16968\n", + "\n", + "Error number 90001 occurred. The resources needed to execute this request are insufficient.\n", + " This may be due to computational limitations, or high load on Classiq's servers." + ] + }, + { + "cell_type": "markdown", + "id": "b998e321", + "metadata": { + "id": "b998e321" + }, + "source": [ + "[1] Abhinav Kandala, Antonio Mezzacapo, Kristan Temme, Maika Takita, Markus Brink, Jerry M. Chow, Jay M. Gambetta Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets. Nature 549, 242 (2017)\n", + "\n", + "[2] Panagiotis Kl. Barkoutsos, Jerome F. Gonthier, Igor Sokolov, Nikolaj Moll, Gian Salis, Andreas Fuhrer, Marc Ganzhorn, Daniel J. Egger, Matthias Troyer, Antonio Mezzacapo, Stefan Filipp, and Ivano Tavernelli Quantum algorithms for electronic structure calculations: Particle-hole Hamiltonian and optimized wave-function expansions Phys. Rev. A 98, 022322 (2018)\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file