1_Linear_Systems.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Linear Systems"
      ],
      "metadata": {
        "id": "Nt9uS-m0eX_x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Matrices and Norms"
      ],
      "metadata": {
        "id": "-AD5PEjoexgP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "VVqjpm7OeWxN"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = 2\n",
        "A = np.array([[1, 2], [0.499, 1.001]])"
      ],
      "metadata": {
        "id": "fvh9VS6ve34q"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "norm1 = np.linalg.norm(A, ord=1)\n",
        "norm2 = np.linalg.norm(A, ord=2)\n",
        "normfro = np.linalg.norm(A, ord='fro')\n",
        "norminf = np.linalg.norm(A, ord=np.inf)\n",
        "\n",
        "print ('Norm of A:')\n",
        "print('Norm 1:', norm1)\n",
        "print('Norm 2:', norm2)\n",
        "print('Frobenius Norm:', normfro)\n",
        "print('Infinity Norm:', norminf)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NlLdQJ3-e5TQ",
        "outputId": "a559d85b-aeb8-4b5a-e3c1-ecc5ac4c01b1"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Norm of A:\n",
            "Norm 1: 3.001\n",
            "Norm 2: 2.500200104037774\n",
            "Frobenius Norm: 2.5002003919686118\n",
            "Infinity Norm: 3.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cond1 = np.linalg.cond(A, p=1)\n",
        "cond2 = np.linalg.cond(A, p=2)\n",
        "condfro = np.linalg.cond(A, p='fro')\n",
        "condinf = np.linalg.cond(A, p=np.inf)\n",
        "\n",
        "print ('Condition number of A:')\n",
        "print ('K(A)_1 =', cond1)\n",
        "print ('K(A)_2 =', cond2)\n",
        "print ('K(A)_fro =', condfro)\n",
        "print ('K(A)_inf =', condinf)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yMWj1UH-e8F6",
        "outputId": "9200538e-15a9-45c4-872b-d3675183fc10"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Condition number of A:\n",
            "K(A)_1 = 3001.0000000001082\n",
            "K(A)_2 = 2083.666853410337\n",
            "K(A)_fro = 2083.6673333334084\n",
            "K(A)_inf = 3001.0000000001082\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.ones((2,1))\n",
        "b = A @ x\n",
        "print(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LOEUPJtifC16",
        "outputId": "b6449f5e-c3e4-4946-dc40-0ef5467bd036"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[3. ]\n",
            " [1.5]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "btilde = np.array([[3], [1.4985]])\n",
        "xtilde = np.array([[2, 0.5]]).T"
      ],
      "metadata": {
        "id": "7Yau76-ufuw3"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Verifying that xtilde is solution of the system A xtilde = btilde (Axtilde)\n",
        "my_btilde = A @ xtilde\n",
        "print ('A*xtilde =', btilde)\n",
        "print(f\"Frobenius norm of btilde - my_btilde = {np.linalg.norm(btilde-my_btilde,'fro')}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LPzj5EB3fwwy",
        "outputId": "39be0664-78d1-4fc0-c359-0a5ab61e3634"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A*xtilde = [[3.    ]\n",
            " [1.4985]]\n",
            "Frobenius norm of btilde - my_btilde = 0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "deltax = np.linalg.norm(x - xtilde, ord=2)\n",
        "deltab = np.linalg.norm(b - btilde, ord=2)\n",
        "\n",
        "print ('delta x =', deltax)\n",
        "print ('delta b =', deltab)\n",
        "print(\"delta x / delta b =\", deltax / deltab)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u_BjRvfTgYm2",
        "outputId": "befb73bb-be8c-4813-85fc-8379022922c8"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "delta x = 1.118033988749895\n",
            "delta b = 0.0015000000000000568\n",
            "delta x / delta b = 745.3559924999017\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.1 LU Factorization"
      ],
      "metadata": {
        "id": "EcS_9kRtg1zT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import scipy\n",
        "import scipy.linalg\n",
        "from scipy.linalg import lu_factor as LUdec\n",
        "from scipy.linalg import lu as LUfull"
      ],
      "metadata": {
        "id": "l4bP8LTChHiL"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# creation of data and test problem\n",
        "A = np.array ([ [3,-1, 1,-2], [0, 2, 5, -1], [1, 0, -7, 1], [0, 2, 1, 1]  ])\n",
        "x = np.ones((4,1))\n",
        "b = A @ x\n",
        "condA = np.linalg.cond(A)"
      ],
      "metadata": {
        "id": "3UV9xeEBhDqk"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('x: \\n', x , '\\n')\n",
        "print('x.shape: ', x.shape, '\\n' )\n",
        "print('b: \\n', b , '\\n')\n",
        "print('b.shape: ', b.shape, '\\n' )\n",
        "print('A: \\n', A, '\\n')\n",
        "print('A.shape: ', A.shape, '\\n' )\n",
        "print('K(A)=', condA, '\\n')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CDY1EYHqhLAI",
        "outputId": "2b93cc56-8ec1-453e-9528-2f333990bfae"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x: \n",
            " [[1.]\n",
            " [1.]\n",
            " [1.]\n",
            " [1.]] \n",
            "\n",
            "x.shape:  (4, 1) \n",
            "\n",
            "b: \n",
            " [[ 1.]\n",
            " [ 6.]\n",
            " [-5.]\n",
            " [ 4.]] \n",
            "\n",
            "b.shape:  (4, 1) \n",
            "\n",
            "A: \n",
            " [[ 3 -1  1 -2]\n",
            " [ 0  2  5 -1]\n",
            " [ 1  0 -7  1]\n",
            " [ 0  2  1  1]] \n",
            "\n",
            "A.shape:  (4, 4) \n",
            "\n",
            "K(A)= 14.208370392921381 \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lu, piv = scipy.linalg.lu_factor(A)\n",
        "print('lu',lu,'\\n')\n",
        "print('piv',piv,'\\n')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6_LxTpwHhkyK",
        "outputId": "547e68ac-85f4-47f7-843c-2e1c40470678"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lu [[ 3.         -1.          1.         -2.        ]\n",
            " [ 0.          2.          5.         -1.        ]\n",
            " [ 0.33333333  0.16666667 -8.16666667  1.83333333]\n",
            " [ 0.          1.          0.48979592  1.10204082]] \n",
            "\n",
            "piv [0 1 2 3] \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# solving Ax = b   <--->  PLUx = b\n",
        "my_x = scipy.linalg.lu_solve((lu, piv), b)\n",
        "\n",
        "print('my_x = \\n', my_x)\n",
        "print('norm =', scipy.linalg.norm(x-my_x, 'fro'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zcHbziuShqtE",
        "outputId": "5a6cbd82-84db-44ab-dbb4-d9840673e403"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "my_x = \n",
            " [[1.]\n",
            " [1.]\n",
            " [1.]\n",
            " [1.]]\n",
            "norm = 7.021666937153402e-16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Alternative implementation"
      ],
      "metadata": {
        "id": "W2IU01Iyhzds"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "P, L, U = scipy.linalg.lu(A)\n",
        "\n",
        "print (f'A = \\n {A} \\n')\n",
        "print (f'P = \\n {P} \\n')\n",
        "print (f'L = \\n {L} \\n')\n",
        "print (f'U = \\n {U} \\n')\n",
        "\n",
        "print (f'P*L*U = \\n {np.matmul(P , np.matmul(L, U))} \\n')\n",
        "print ('diff = ',   np.linalg.norm(A - np.matmul(P , np.matmul(L, U)), 'fro'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aPrBv-GBhvgq",
        "outputId": "e7ba503f-16b5-4a8d-e85e-1a691558d2df"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A = \n",
            " [[ 3 -1  1 -2]\n",
            " [ 0  2  5 -1]\n",
            " [ 1  0 -7  1]\n",
            " [ 0  2  1  1]] \n",
            "\n",
            "P = \n",
            " [[1. 0. 0. 0.]\n",
            " [0. 1. 0. 0.]\n",
            " [0. 0. 1. 0.]\n",
            " [0. 0. 0. 1.]] \n",
            "\n",
            "L = \n",
            " [[1.         0.         0.         0.        ]\n",
            " [0.         1.         0.         0.        ]\n",
            " [0.33333333 0.16666667 1.         0.        ]\n",
            " [0.         1.         0.48979592 1.        ]] \n",
            "\n",
            "U = \n",
            " [[ 3.         -1.          1.         -2.        ]\n",
            " [ 0.          2.          5.         -1.        ]\n",
            " [ 0.          0.         -8.16666667  1.83333333]\n",
            " [ 0.          0.          0.          1.10204082]] \n",
            "\n",
            "P*L*U = \n",
            " [[ 3. -1.  1. -2.]\n",
            " [ 0.  2.  5. -1.]\n",
            " [ 1.  0. -7.  1.]\n",
            " [ 0.  2.  1.  1.]] \n",
            "\n",
            "diff =  1.5700924586837752e-16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following two cases can both be applied in this case since P = identity matrix."
      ],
      "metadata": {
        "id": "GygJ2Uiq0c0H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# if P != np.eye(n):\n",
        "# Ax = b   <--->  PLUx = b  <--->  LUx = inv(P)b  <--->  Ly=inv(P)b & Ux=y\n",
        "invP = np.linalg.inv(P)\n",
        "y = scipy.linalg.solve_triangular(L, invP@b, lower=True, unit_diagonal=True)\n",
        "my_x = scipy.linalg.solve_triangular(U, y, lower=False)\n",
        "\n",
        "print('Calculated solution:\\n: ', my_x)\n",
        "print('norm =', scipy.linalg.norm(x-my_x, 'fro'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ik2A_JnXliOM",
        "outputId": "60c7139e-d013-4d90-9c77-3ac423da2643"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Calculated solution:\n",
            ":  [[1.]\n",
            " [1.]\n",
            " [1.]\n",
            " [1.]]\n",
            "norm = 5.438959822042073e-16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# if P == np.eye(n):\n",
        "# Ax = b   <--->  PLUx = b  <--->  PLy=b & Ux=y\n",
        "y = scipy.linalg.solve_triangular(np.matmul(P,L) , b, lower=True, unit_diagonal=True)\n",
        "my_x = scipy.linalg.solve_triangular(U, y, lower=False)\n",
        "\n",
        "print('Calculated solution:\\n', my_x)\n",
        "print('norm =', scipy.linalg.norm(x-my_x, 'fro'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3jJ4YEXVloH6",
        "outputId": "1ec17e03-7e63-489e-bc0f-21fde8321b9e"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Calculated solution:\n",
            " [[1.]\n",
            " [1.]\n",
            " [1.]\n",
            " [1.]]\n",
            "norm = 5.438959822042073e-16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.2 Choleski factorizaion with Hilbert matrix\n",
        "\n"
      ],
      "metadata": {
        "id": "qXRYjXYaiC0Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "1LqlFGLeiICE"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# creation of data and test problem\n",
        "n = 5\n",
        "A = scipy.linalg.hilbert(n)\n",
        "x = np.ones((n,1))\n",
        "b = A @ x\n",
        "condA = np.linalg.cond(A)"
      ],
      "metadata": {
        "id": "roZbPrAIiOVl"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('x: \\n', x , '\\n')\n",
        "print('x.shape: ', x.shape, '\\n' )\n",
        "print('b: \\n', b , '\\n')\n",
        "print('b.shape: ', b.shape, '\\n' )\n",
        "print('A: \\n', A, '\\n')\n",
        "print('A.shape: ', A.shape, '\\n' )\n",
        "print('K(A) =', condA, '\\n')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T5XcZyBYiXUq",
        "outputId": "cfe85357-5f60-48b5-f1ca-d17b5c6be3ea"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x: \n",
            " [[1.]\n",
            " [1.]\n",
            " [1.]\n",
            " [1.]\n",
            " [1.]] \n",
            "\n",
            "x.shape:  (5, 1) \n",
            "\n",
            "b: \n",
            " [[2.28333333]\n",
            " [1.45      ]\n",
            " [1.09285714]\n",
            " [0.88452381]\n",
            " [0.74563492]] \n",
            "\n",
            "b.shape:  (5, 1) \n",
            "\n",
            "A: \n",
            " [[1.         0.5        0.33333333 0.25       0.2       ]\n",
            " [0.5        0.33333333 0.25       0.2        0.16666667]\n",
            " [0.33333333 0.25       0.2        0.16666667 0.14285714]\n",
            " [0.25       0.2        0.16666667 0.14285714 0.125     ]\n",
            " [0.2        0.16666667 0.14285714 0.125      0.11111111]] \n",
            "\n",
            "A.shape:  (5, 5) \n",
            "\n",
            "K(A) = 476607.2502425855 \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Choleski factorization\n",
        "L = scipy.linalg.cholesky(A, lower=True)\n",
        "print('L:', L, '\\n')\n",
        "print('L.T*L =', L@L.T)\n",
        "print('err = ', scipy.linalg.norm(A-L@L.T, 'fro'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IDRjRTyZieXW",
        "outputId": "448e725b-4000-46b8-b6ba-878e9010298d"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "L: [[1.         0.         0.         0.         0.        ]\n",
            " [0.5        0.28867513 0.         0.         0.        ]\n",
            " [0.33333333 0.28867513 0.0745356  0.         0.        ]\n",
            " [0.25       0.25980762 0.1118034  0.01889822 0.        ]\n",
            " [0.2        0.23094011 0.12777531 0.03779645 0.0047619 ]] \n",
            "\n",
            "L.T*L = [[1.         0.5        0.33333333 0.25       0.2       ]\n",
            " [0.5        0.33333333 0.25       0.2        0.16666667]\n",
            " [0.33333333 0.25       0.2        0.16666667 0.14285714]\n",
            " [0.25       0.2        0.16666667 0.14285714 0.125     ]\n",
            " [0.2        0.16666667 0.14285714 0.125      0.11111111]]\n",
            "err =  2.7755575615628914e-17\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# solving the system\n",
        "y = scipy.linalg.solve_triangular(L, b, lower=True)\n",
        "my_x = scipy.linalg.solve_triangular(L.T, y, lower=False)\n",
        "print('my_x = ', my_x)\n",
        "print('norm =', scipy.linalg.norm(x-my_x, 'fro'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e08DZASui2Mn",
        "outputId": "ed417729-9de4-4596-df6a-2605693ad1eb"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "my_x =  [[1.]\n",
            " [1.]\n",
            " [1.]\n",
            " [1.]\n",
            " [1.]]\n",
            "norm = 2.6732599660997558e-12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2.2.1 Choleski factorizaion with Hilbert matrices of increasing sizes\n"
      ],
      "metadata": {
        "id": "oZT1wwnUi8xC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "xmin, xmax = 5, 11\n",
        "\n",
        "K_A = np.zeros((xmax - xmin,1))\n",
        "Err = np.zeros((xmax - xmin,1))\n",
        "xplot = np.arange(xmin, xmax)"
      ],
      "metadata": {
        "id": "xj3Rhejwi-3a"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for n in xplot:\n",
        "    # creation of data and test problem\n",
        "    A = scipy.linalg.hilbert(n)\n",
        "    x = np.ones((n,1))\n",
        "    b = A @ x\n",
        "\n",
        "    # condition number\n",
        "    K_A[n-xmin] = np.linalg.cond(A)\n",
        "\n",
        "    # factorization\n",
        "    L = scipy.linalg.cholesky(A)\n",
        "    y = scipy.linalg.solve_triangular(L, b, lower=True)\n",
        "    my_x = scipy.linalg.solve_triangular(L.T, y, lower=False)\n",
        "\n",
        "    # relative error\n",
        "    Err[n-xmin] = np.linalg.norm(x-my_x, ord=2)/np.linalg.norm(x, ord=2)\n"
      ],
      "metadata": {
        "id": "vB8r1JaRjadk"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# graph of condition number vs matrix dimension\n",
        "plt.semilogy(xplot, K_A)\n",
        "plt.title('Condition number of A ')\n",
        "plt.xlabel('Dimension of A (n)')\n",
        "plt.ylabel('K(A)')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "f0TnDKVrjG0e",
        "outputId": "85a1551c-5ab8-4b27-809f-0a0589e7a926"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfD0lEQVR4nO3dd1RU19oG8GeGMhQBRZQiTbGBKMWCJSZqSBAVK8YWg/Xem6CoGP00RZOoMdUYZRKvuZZExR41sSYSS4wYC8USFVFULDSlIwPM7O8Pr3ODgIICB2ae31qslbPnzDnPTIy82e8+58iEEAJEREREekQudQAiIiKi2sYCiIiIiPQOCyAiIiLSOyyAiIiISO+wACIiIiK9wwKIiIiI9A4LICIiItI7LICIiIhI77AAIiIiIr3DAoiIyli7di1kMhmuX7+uHevVqxd69epVqfePGzcOrq6uNZKtPpLJZJgyZYrUMSqlpKQEs2fPhpOTE+RyOQYPHix1JKIawQKIqA64evUq/vnPf6JFixYwMTGBpaUlevToga+//hoPHjyQOl657ty5gw8++ABxcXFSR6FqtHr1anz++ecIDg7G999/jxkzZlTqfV26dIFMJsO3335bwwmJqoeh1AGI9N2ePXswfPhwKBQKvPHGG/D09ERRURGOHTuGWbNm4cKFC1i5cqXUMfHLL7+U2r5z5w4+/PBDuLq6wtvbu9Rr3333HTQaTS2mo+ry22+/oVmzZvjqq68q/Z4rV67g1KlTcHV1xYYNG/Dmm2/WYEKi6sECiEhCSUlJGDlyJFxcXPDbb7/B3t5e+1poaCgSExOxZ88eCRP+j7GxcaX3NTIyqsEkVJ7CwkIYGxtDLn++if20tDQ0bNiwSu9Zv349mjZtii+//BLBwcG4fv06W6BU57EFRiShzz77DHl5eVi1alWp4ueRli1bYtq0adrtkpISLFiwAG5ublAoFHB1dcU777wDlUpV6n2urq4YMGAAjh07hi5dusDExAQtWrTADz/8UOYcFy5cQJ8+fWBqagpHR0csXLiw3Nmbv68BOnz4MDp37gwAGD9+PGQyGWQyGdauXQug/DVA+fn5mDlzJpycnKBQKNCmTRt88cUXEEKU2u/RepmdO3fC09MTCoUC7dq1w/79+5/6fR4+fBgymQxbtmzBokWL4OjoCBMTE7z88stITEws8x2NGzfuiZ/z8WN++OGHaNasGSwsLBAcHIzs7GyoVCpMnz4dTZs2RYMGDTB+/Pgy/z4e2bBhA9q0aQMTExN07NgRR48eLbPP7du3MWHCBNja2mo/++rVq8v9nJs2bcJ7772HZs2awczMDDk5ORV+N0/7/q9fvw6ZTIZDhw7hwoUL2n+nhw8frvCYj0RGRiI4OBgDBgyAlZUVIiMjn/oeIqlxBohIQj///DNatGiB7t27V2r/SZMm4fvvv0dwcDBmzpyJP//8E4sXL8bFixexY8eOUvsmJiYiODgYEydOREhICFavXo1x48ahY8eOaNeuHQAgJSUFvXv3RklJCebMmQNzc3OsXLkSpqamT8zh7u6Ojz76CPPmzcM//vEP9OzZEwAq/BxCCAwcOBCHDh3CxIkT4e3tjQMHDmDWrFm4fft2mXbLsWPH8OOPP+Ktt96ChYUFli1bhmHDhuHmzZto3LjxU7+nTz75BHK5HG+//Tays7Px2WefYcyYMfjzzz+f+t6KLF68GKamppgzZw4SExOxfPlyGBkZQS6XIzMzEx988AFOnDiBtWvXonnz5pg3b16p9x85cgSbN29GWFgYFAoFvvnmG/Tt2xcnT56Ep6cnACA1NRVdu3bVFoFNmjTBvn37MHHiROTk5GD69OmljrlgwQIYGxvj7bffhkqlqnCWrjLff5MmTbBu3TosWrQIeXl5WLx4MYCH/66f5M8//0RiYiLWrFkDY2NjDB06FBs2bMA777zzjN80US0RRCSJ7OxsAUAMGjSoUvvHxcUJAGLSpEmlxt9++20BQPz222/aMRcXFwFAHD16VDuWlpYmFAqFmDlzpnZs+vTpAoD4888/S+1nZWUlAIikpCTt+EsvvSReeukl7fapU6cEALFmzZoyWUNCQoSLi4t2e+fOnQKAWLhwYan9goODhUwmE4mJidoxAMLY2LjUWHx8vAAgli9fXvEXJIQ4dOiQACDc3d2FSqXSjn/99dcCgDh37lyp7ygkJKTMMR7/nI+O6enpKYqKirTjo0aNEjKZTAQGBpZ6f7du3Up99kefCYA4ffq0duzGjRvCxMREDBkyRDs2ceJEYW9vLzIyMkq9f+TIkcLKykoUFBSUytSiRQvt2JNU5ft/6aWXRLt27Z56zEemTJkinJychEajEUII8csvvwgAIjY2ttLHIJICW2BEEnnUrrCwsKjU/nv37gUAhIeHlxqfOXMmAJRZK+Th4aGdmQGAJk2aoE2bNrh27VqpY3bt2hVdunQptd+YMWOq8Ekql93AwABhYWFlsgshsG/fvlLj/v7+cHNz02536NABlpaWpbI/yfjx40vNhjz6Hir7/vK88cYbpdY2+fn5QQiBCRMmlNrPz88PycnJKCkpKTXerVs3dOzYUbvt7OyMQYMG4cCBA1Cr1RBCYPv27QgKCoIQAhkZGdqfgIAAZGdnIyYmptQxQ0JCnjpbB1T9+6+skpISbN68GSNGjIBMJgMA9OnTB02bNsWGDRue6ZhEtYUtMCKJWFpaAgByc3Mrtf+NGzcgl8vRsmXLUuN2dnZo2LAhbty4UWrc2dm5zDEaNWqEzMzMUsf08/Mrs1+bNm0qlamybty4AQcHhzLF3qP2yrNkf5LH39+oUSMAqPT7K3NMKysrAICTk1OZcY1Gg+zs7FLtulatWpU5ZuvWrVFQUID09HTI5XJkZWVh5cqVFV71l5aWVmq7efPmlcpe1e+/sn755Rekp6ejS5cupdZY9e7dGxs3bsSnn3763IuyiWoKCyAiiVhaWsLBwQHnz5+v0vse/Z/20xgYGJQ7Lh5bdFwXPW/2yry/ou9RrVaX+/6Kjlld3/Ojheevv/46QkJCyt2nQ4cOpbYrM/tTkx7N8rz22mvlvn7kyBH07t27NiMRVRoLICIJDRgwACtXrkR0dDS6dev2xH1dXFyg0Whw5cqVUgtTU1NTkZWVBRcXlyqf38XFBVeuXCkzfvny5ae+t7KF2KPzHDx4ELm5uaVmIS5duqR9vbY1atQIWVlZZcZv3LiBFi1aVPv5yvueExISYGZmhiZNmgB42A5Vq9Xw9/ev1nPXxPefn5+PXbt2YcSIEQgODi7zelhYGDZs2MACiOoszk0SSWj27NkwNzfHpEmTkJqaWub1q1ev4uuvvwYA9OvXDwCwdOnSUvssWbIEANC/f/8qn79fv344ceIETp48qR1LT0+v1PoNc3NzACi3iCjvPGq1GhEREaXGv/rqK8hkMgQGBlYteDVwc3PDiRMnUFRUpB3bvXs3kpOTa+R80dHRpdbwJCcnY9euXXj11VdhYGAAAwMDDBs2DNu3by93VjA9Pf2Zz10T3/+OHTuQn5+P0NBQBAcHl/kZMGAAtm/fXuEtAYikxhkgIgm5ubkhMjISI0aMgLu7e6k7QR8/fhxbt27V3qvGy8sLISEhWLlyJbKysvDSSy/h5MmT+P777zF48OBn+j/t2bNnY926dejbty+mTZumvQzexcUFZ8+efWr2hg0bYsWKFbCwsIC5uTn8/PzKXZcSFBSE3r17491338X169fh5eWFX375Bbt27cL06dNLLXiuLZMmTcK2bdvQt29fvPbaa7h69SrWr19fY1k8PT0REBBQ6jJ4APjwww+1+3zyySc4dOgQ/Pz8MHnyZHh4eOD+/fuIiYnBwYMHcf/+/Wc6d018/xs2bEDjxo0rvPXBwIED8d1332HPnj0YOnToM+UmqlGSXX9GRFoJCQli8uTJwtXVVRgbGwsLCwvRo0cPsXz5clFYWKjdr7i4WHz44YeiefPmwsjISDg5OYm5c+eW2keIh5d49+/fv8x5Hr/EWwghzp49K1566SVhYmIimjVrJhYsWCBWrVr11MvghRBi165dwsPDQxgaGpa6JP7xy+CFECI3N1fMmDFDODg4CCMjI9GqVSvx+eefay+ffgSACA0NLZO9osvW/+7R5eFbt24tNZ6UlFTuJftffvmlaNasmVAoFKJHjx7i9OnTFV4G//gx16xZIwCIU6dOlRqfP3++ACDS09PLfKb169eLVq1aCYVCIXx8fMShQ4fKfIbU1FQRGhoqnJychJGRkbCzsxMvv/yyWLly5VMzPUllv//KXAafmpoqDA0NxdixYyvcp6CgQJiZmZW6zJ+oLpEJUQ9WRBIRERFVI64BIiIiIr3DAoiIiIj0DgsgIiIi0jssgIiIiEjvsAAiIiIivcMCiIiIiPQOb4RYAY1Ggzt37sDCwqJKt/wnIiIi6QghkJubCwcHhyc+jJcFUAXu3LlT5inPREREVD8kJyfD0dGxwtdZAFXg0QMDk5OTYWlpKXEaIiIiqoycnBw4OTmVevBveVgAVeBR28vS0pIFEBERUT3ztOUrXARNREREeocFEBEREekdFkCPUSqV8PDwQOfOnaWOQkRERDWET4OvQE5ODqysrJCdnc01QERERPVEZX9/cwaIiIiI9A4LICIiItI7LICIiIhI77AAIiIiIr3DAoiIiIj0DgsgIiIi0jssgB7D+wARERHpPt4HqAK8DxAREVH9w/sAERERUZ1UWKzG71fSJc3AAoiIiIhqTWJaHgYr/8D4NacQezNTshyGkp2ZiIiI9MrO2Nt4Z8c5FBSpYdPAGIXFGsmysAAiIiKiGvWgSI0PfrqAzaeTAQDdWjTG1yO90dTSRLJMLICIiIioxiSm5SF0Qwwup+ZCJgPC+rRC2MutYCCXSZpLJ9YADRkyBI0aNUJwcLB2LCsrC506dYK3tzc8PT3x3XffSZiQiIhI//wYcwsDI47hcmoubBoosH6iH2a80lry4gfQkcvgDx8+jNzcXHz//ffYtm0bAECtVkOlUsHMzAz5+fnw9PTE6dOn0bhx40odk5fBExERPZsHRWrM/+k8tpy+BQDo7tYYS0d6o6lFzbe8Kvv7WydaYL169cLhw4dLjRkYGMDMzAwAoFKpIISADtR6REREddqV1FyERsYgITUPchkw7eXWmNKnZZ2Y9fk7yVtgR48eRVBQEBwcHCCTybBz584y+yiVSri6usLExAR+fn44efJkpY6dlZUFLy8vODo6YtasWbCxsanm9ERERPTI9jO3MDDiDySk5qGJhQLrJ/lhmr/0633KI3kBlJ+fDy8vLyiVynJf37x5M8LDwzF//nzExMTAy8sLAQEBSEtLe+qxGzZsiPj4eCQlJSEyMhKpqanVHZ+IiEjvFRSV4O2t8Zi5NR4PitV4oaUN9ob1RHe3ujvxIHkBFBgYiIULF2LIkCHlvr5kyRJMnjwZ48ePh4eHB1asWAEzMzOsXr260uewtbWFl5cXfv/99wr3UalUyMnJKfVDRERET3YlNReDIv7AtjO3IJcBM19pje8ndEETC4XU0Z5I8gLoSYqKinDmzBn4+/trx+RyOfz9/REdHf3E96ampiI3NxcAkJ2djaNHj6JNmzYV7r948WJYWVlpf5ycnKrnQxAREemoraeTMTDiD1xJy0NTCwUiJ3fF1DpwiXtl1OlF0BkZGVCr1bC1tS01bmtri0uXLmm3/f39ER8fj/z8fDg6OmLr1q0wMDDAP/7xD+3i56lTp6J9+/YVnmvu3LkIDw/Xbufk5LAIIiIiKkdBUQne33kB22MeXuXVs5UNvhrhDZsGdXvW5+/qdAFUWQcPHix3PC4urtLHUCgUUCgUUCqVUCqVUKvV1ZSOiIhId1xOeXiVV2Law6u8Zr7aBm++5AZ5PZj1+bs6XQDZ2NjAwMCgzOLl1NRU2NnZ1cg5Q0NDERoaqr2PABEREQFCCGw9fQvzfjqPwmINbC0VWDbSB34tKnd/vbqmTq8BMjY2RseOHREVFaUd02g0iIqKQrdu3WrknEqlEh4eHujcuXONHJ+IiKi+yVeVYOaWeMzefhaFxRq82LoJ9ob1rLfFD1AHZoDy8vKQmJio3U5KSkJcXBysra3h7OyM8PBwhISEoFOnTujSpQuWLl2K/Px8jB8/vkbycAaIiIjofy6l5CB0QwyupufX65bX4yQvgE6fPo3evXtrtx8tRA4JCcHatWsxYsQIpKenY968eUhJSYG3tzf2799fZmE0ERERVR8hBLacTsa8XRegKtHAztIEy0b5oEtza6mjVQudeBZYdfr7IuiEhAQ+C4yIiPROvqoE7+44h51xdwAAL7VugiWveaFxPbjKq7LPAmMBVAE+DJWIiPTRxbs5CI2MwbX0fBjIZXj71Tb454st6k3LS68ehkpERETPRwiBTaeS8cFPD1te9lYPW16dXXWj5fU4FkCP4X2AiIhI3+T9t+W1678tr95tmuDL17xhbW4scbKawxZYBdgCIyIiffDXnRxMiYzBtYyHLa/ZAW0wuWf9aXk9ji0wIiIiqpAQAhtPJuODny+gqEQDBysTLB/tg44uutnyehwLICIiIj2TW1iMd3acx8/xD1tefdo2xZfDvdBIh1tej2MB9BiuASIiIl124U42pkTGIikjH4ZyGWb3bYNJL9Tfltez4hqgCnANEBER6RIhBNb/eRMLdv/1t5aXLzq6NJI6WrXiGiAiIiIC8LDlNefHc9hz9i4AwN+9Kb4Y7oWGZvrT8nocCyAiIiIddv52NkIjY3DjXgEM5TLMCWyLiS80h0ymXy2vx7EAegzXABERkS4QQmD9iRtYsPsiitQaNGtoiuWjfeDrrFstr2fFNUAV4BogIiKqr3IKizFn+1nsPZcCAPB3t8UXwzvoRcuLa4CIiIj00LlbD1teN++z5fUkLICIiIh0gBACP0TfwKI9/2t5RYz2gQ9bXuViAURERFTP5RQW4/+2ncW+8w9bXq962OLzYC9YmRlJnKzuYgH0GC6CJiKi+uTsrSxMiYzFzfsFMDKQ4Z1+7hjX3ZUtr6fgIugKcBE0ERHVZUIIfH/8OhbtvYhitYBjI1MoR/vCy6mh1NEkxUXQREREOir7wcOW1/4LD1tefdvZ4dPgDrAyZcurslgAERER1SPxyVmYsjEGyfcfwMhAhnf7uSOELa8qYwFERERUDwghsOaP61i872HLy8n6Ycurg2NDqaPVSyyAiIiI6rjsgmLM2haPX/5KBQAEetrhk2FseT0PFkBERER1WFxyFkI3xOB21gMYG8jx3gB3jO3qwpbXc2IBREREVAcJIbDqWBI+2XcJJRoBZ2szKEf7or2jldTRdAILoMfwPkBERCS1rIIivL31LA5efNjy6t/eHouHtYelCVte1YX3AaoA7wNERERSiLmZiamRsdqW1/sD3PE6W16VxvsAERER1SOPt7xcGj9seXk2Y8urJrAAIiIiktjDllc8Dl5MAwD072CPT4a2hwVbXjWGBRAREZGEztzIRNjG/7a8DOWYN8ADY/yc2fKqYSyAiIiIJKDRCPzn2DV8tv8ySjQCzW3METHaB+0c2PKqDSyAiIiIallm/sOWV9Slhy2vIC8HfDzEky2vWsQCiIiIqBaduXEfUyNjcSe7EMaGcnwQ1A6jujix5VXL5FIHqA5DhgxBo0aNEBwcrB1LTk5Gr1694OHhgQ4dOmDr1q0SJiQiIn2n0Qj8+8hVvPbvE7iTXYgWNubY+VYPjOZ6H0noxH2ADh8+jNzcXHz//ffYtm0bAODu3btITU2Ft7c3UlJS0LFjRyQkJMDc3LxSx+R9gIiIqLrczy/CzC1xOHQ5HQAw0MsBHw9tjwYKNmKqm17dB6hXr144fPhwqTF7e3vY29sDAOzs7GBjY4P79+9XugAiIiKqDqeuP2x5peQUQmEoxwcD22FkZ7a8pCZ5C+zo0aMICgqCg4MDZDIZdu7cWWYfpVIJV1dXmJiYwM/PDydPnqzSOc6cOQO1Wg0nJ6dqSk1ERPRkGo3AN4cTMXLlCaTk/LflFdoDo7qw5VUXSF4A5efnw8vLC0qlstzXN2/ejPDwcMyfPx8xMTHw8vJCQEAA0tLSKnX8+/fv44033sDKlSurMzYREVGF7uWpMH7tKXy2/zLUGoHB3g74aeoLcLfnkoq6QvIWWGBgIAIDAyt8fcmSJZg8eTLGjx8PAFixYgX27NmD1atXY86cOU88tkqlwuDBgzFnzhx07979qfuqVCrtdk5OThU+BRER0UMnk+4jbOP/Wl4fDWqH1zqx5VXXSD4D9CRFRUU4c+YM/P39tWNyuRz+/v6Ijo5+4nuFEBg3bhz69OmDsWPHPvVcixcvhpWVlfaH7TIiIqoKjUZAeSgRo7572PJya2KOXVN6YERntrzqIslngJ4kIyMDarUatra2pcZtbW1x6dIl7ba/vz/i4+ORn58PR0dHbN26FWq1Gps3b0aHDh2064rWrVuH9u3bl3uuuXPnIjw8XLudk5PDIoiIiCrlXp4KM7bE42jCw6u8hvg0w8LBnjDnVV51lk78mzl48GC54xqNptLHUCgUUCgUUCqVUCqVUKvV1RWPiIh02J/X7iFsUyxSc1QwMZLjo4GeGN7JkbM+dVydLoBsbGxgYGCA1NTUUuOpqamws7OrkXOGhoYiNDRUex8BIiKi8jy6ymvJrwnQCKBl0wZQjvZFGzsLqaNRJdTpNUDGxsbo2LEjoqKitGMajQZRUVHo1q1bjZxTqVTCw8MDnTt3rpHjExFR/ZeRp0LImpP44peHxc8wX0f8NKUHi596RPIZoLy8PCQmJmq3k5KSEBcXB2trazg7OyM8PBwhISHo1KkTunTpgqVLlyI/P197VVh14wwQERE9yYlr9xC2MRZpuQ9bXgsGeWJ4J64ZrW8kL4BOnz6N3r17a7cfLUQOCQnB2rVrMWLECKSnp2PevHlISUmBt7c39u/fX2ZhNBERUU1SawS+OZSIrw4+nPVp1bQBlGN80dqWsz71kU48C6w6/X0RdEJCAp8FRkRESM9VYcbmOBxLzAAADO/oiA8HtYOZseTzCPSYyj4LjAVQBfgwVCIiAoDjVzMwbVMc0nNVMDUywILBngju6Ch1LKqAXj0MlYiIqLqpNQIRvyXi66iHLa/Wtg+v8mrFlpdOYAH0GN4HiIiI0nILMX1THI5fvQcAeK2TIz4c6AlTYwOJk1F1YQusAmyBERHpp+OJGQjbFIeMvIctr0VDPDHUly2v+oItMCIioipQawSWRV3Bst+uQAigja0FlGN80LIpW166iAXQY9gCIyLSP2k5hZi2KQ7R1x62vEZ2dsL8oHZseekwtsAqwBYYEZF+OHYlA9M3xyIjrwhmxg9bXkN82PKqr9gCIyIieoIStQZfR11BxKFECAG0tbOAcowv3Jo0kDoa1QIWQEREpHdScwoxdWMsTibdBwCM6uKM+UEeMDFiy0tfsAB6DNcAERHptiMJ6QjfHId7+UUwNzbA4mEdMNDLQepYVMu4BqgCXANERKRbStQaLPk1Ad8cvgoAcLe3xDdjfNHcxlziZFSduAaIiIjov+5mP0DYxlicup4JAHi9qzPe68+Wlz5jAURERDrt0OU0hG+OQ2ZBMRooDPHJsPYY0IEtL33HAoiIiHRSsVqDL365jH8fuQYA8GxmiYhRvnBly4vAAoiIiHTQnawHmLoxFmduPGx5hXRzwTv93aEwZMuLHmIB9BheBUZEVL9FXUzFzK3xyCoohoXCEJ8Fd0Bge3upY1Edw6vAKsCrwIiI6pditQaf7b+E735PAgB0cLRCxChfODc2kzgZ1SZeBUZERHrjVmYBpm6MRezNLADA+B6umBPYli0vqhALICIiqtd+uZCCWdvOIvtBMSxNDPFZsBf6etpJHYvqOBZARERULxWVaPDp/ktYdexhy8vLqSEiRvnAyZotL3o6FkBERFTvJN8vwJSNsYhPzgIATHqhOWb3bQtjQ7m0wajeYAFERET1yv7zKZi1LR65hSWwMjXCF8O98IqHrdSxqJ5hAURERPWCqkSNxXsvYe3x6wAAH+eGWD7KB46N2PKiqmMB9BjeB4iIqO65ea8AoZExOHc7GwDwjxdbYFZAGxgZsOVFz4b3AaoA7wNERFQ37D13F/+37SxyVSVoaGaEJa95oU9btryofLwPEBER1WuFxWp8vPcifoi+AQDo6NIIy0f5wKGhqcTJSBewACIiojrnekY+QiNjcOFODgDgXy+5YearrdnyomrDAoiIiOqUn+PvYO6P55CnKkEjMyMsGeGN3m2aSh2LdAwLICIiqhMKi9VYsPsvbPjzJgCgs2sjLBvlA3srtryo+rEAIiIiyV1Lz0NoZCwu3s2BTAa81csNM/xbw5AtL6ohOvEna8iQIWjUqBGCg4MrNU5ERHXHrrjbCFp+DBfv5qCxuTG+H98FswLasvihGqUTf7qmTZuGH374odLjREQkvcJiNeb+eBbTNsUhv0gNv+bW2DutJ15s3UTqaKQHdKIA6tWrFywsLCo9TkRE0kpMy8Ng5R/YeDIZMhkQ1qclNkzyg62lidTRSE9IXgAdPXoUQUFBcHBwgEwmw86dO8vso1Qq4erqChMTE/j5+eHkyZO1H5SIiKrFjthbGBhxDJdScmHTwBjrJvgh/NU2bHlRrZL8T1t+fj68vLygVCrLfX3z5s0IDw/H/PnzERMTAy8vLwQEBCAtLa2WkxIR0fN4UKTG7G3xmLE5HgVFanRr0Rh7w3rihVY2UkcjPST5VWCBgYEIDAys8PUlS5Zg8uTJGD9+PABgxYoV2LNnD1avXo05c+ZUWw6VSgWVSqXdzsnJqbZjExHpuyupuQiNjEFCah5kMmDay60wtU8rGMhlUkcjPSX5DNCTFBUV4cyZM/D399eOyeVy+Pv7Izo6ulrPtXjxYlhZWWl/nJycqvX4RET6atuZWxgY8QcSUvPQxEKBDRP9MN2/NYsfklSdLoAyMjKgVqtha1v6oXe2trZISUnRbvv7+2P48OHYu3cvHB0dtcVRRePlmTt3LrKzs7U/ycnJNfOhiIj0REFRCWZuicfbW+PxoFiNF1raYG9YT3RvyZYXSU/yFlh1OHjwYJXGy6NQKKBQKKBUKqFUKqFWq6srHhGR3klIzcVbG2KQmJYHuQyY4d8ab/VuyVkfqjPqdAFkY2MDAwMDpKamlhpPTU2FnZ1djZwzNDQUoaGhyMnJgZWVVY2cg4hIVwkhsPX0Lcz76TwKizVoaqHAslE+6NqisdTRiEqp0y0wY2NjdOzYEVFRUdoxjUaDqKgodOvWTcJkRET0uHxVCcK3xGP29rMoLNagZysb7J3Wk8UP1UmSzwDl5eUhMTFRu52UlIS4uDhYW1vD2dkZ4eHhCAkJQadOndClSxcsXboU+fn52qvCqhtbYEREVXcpJQdvbYjBtfR8yGXAzFfb4M2X3CBny4vqKJkQQkgZ4PDhw+jdu3eZ8ZCQEKxduxYAEBERgc8//xwpKSnw9vbGsmXL4OfnV6O5HrXAsrOzYWlpWaPnIiKqr4QQ2HQqGR/8dAGqEg3sLE2wbJQPujS3ljoa6anK/v6WvACqa/4+A5SQkMACiIioAnmqEry74xx2xd0BAPRq0wRLXvOGtbmxxMlIn7EAek6cASIiqthfd3IwJTIG1zLyYSCX4e1X2+CfL7Zgy4skV9nf35KvASIiovpDCIENf97ER7v/QlGJBvZWJlg+ygedXNnyovqFBdBjuAiaiKh8uYXFmPvjOew+excA0KdtU3w53AuN2PKieogtsAqwBUZE9D/nb2djSmQMrt8rgKFchtl922DSC2x5Ud3DFhgRET03IQTWnbiBhbsvokitQbOGplg+2ge+zo2kjkb0XFgAERFRuXIKizFn+1nsPffw2Yv+7rb4YngHNDRjy4vqPxZAj+EaICIi4OytLEyJjMXN+w9bXnMC22LiC80hk7HlRbqBa4AqwDVARKSPhBD4/vh1LNp7EcVqgWYNTREx2gc+bHlRPcE1QEREVCXZD4rxf9vOYv+Fhy2vVz1s8XmwF6zMjCRORlT9WAARERHikrMwJTIGtzIfwMhAhnf6uWNcd1e2vEhnsQB6DNcAEZE+EUJg9R/X8cm+hy0vJ2tTRIzyhZdTQ6mjEdUorgGqANcAEZGuyyoowqxtZ/HrX6kAgEBPO3wyrAOsTNnyovqLa4CIiKhCMTczMTUyFrezHsDYQI73BrhjbFcXtrxIb7AAIiLSI0II/Of3JHy6/xJKNAIujc2gHO0Lz2ZWUkcjqlUsgIiI9ERmfhHe3hqPqEtpAID+HezxydD2sDBhy4v0DwsgIiI9cObGfUyNjMWd7EIYG8oxb4AHxvg5s+VFeosF0GN4FRgR6RKNRmDl79fw+YHLUGsEmtuYI2K0D9o5sOVF+o1XgVWAV4ERUX13P78I4VvicPhyOgBgoJcDPh7aHg0U/H9f0l28CoyISI+duv6w5ZWSUwiFoRwfDGyHkZ2d2PIi+i8WQEREOkSjEfj2yFUs+TUBao1ACxtzKMf4wt2eM9lEf8cCiIhIR2TkqRC+JR5HEx62vIb4NMPCwZ4wZ8uLqAz+V0FEpANOXLuHsI2xSMtVQWEox4JBnhjeyZEtL6IKsAAiIqrH1BqBbw4l4quDCdAIwK2JOb4Z0xFt7CykjkZUp7EAIiKqp9JzVZixOQ7HEjMAAMN8HbFgcDuYGfOvdqKn4X8lj+F9gIioPjh+NQPTNsUhPVcFE6NHLS8nqWMR1Ru8D1AFeB8gIqqL1BqB5b9dwbKoK9AIoFXTBvhmjC9a2bLlRQTwPkBERDonLbcQ0zfF4fjVewCA4R0d8eEgtryIngX/qyEiqgf+SHzY8srIU8HUyACLhnhiqK+j1LGI6i0WQEREdZhaI/D1wQQsP5QIIYA2thZQjvFFy6YNpI5GVK+xACIiqqNScwoRtjEWfybdBwCM7OyE+UHtYGpsIHEyovqPBRARUR10JCEd4ZvjcC+/CObGBvh4aHsM8m4mdSwinSGXOkB1GDJkCBo1aoTg4OBS47t370abNm3QqlUr/Oc//5EoHRFR5ZWoNfh0/yWErD6Je/lFcLe3xM9TX2DxQ1TNdKIAmjZtGn744YdSYyUlJQgPD8dvv/2G2NhYfP7557h3755ECYmInu5u9gOM+u4Evj18FQAwxs8ZO97qjhZNuN6HqLrpRAHUq1cvWFiUvgfGyZMn0a5dOzRr1gwNGjRAYGAgfvnlF4kSEhE92W+XUtHv699x6nomGigMETHaB4uGtIeJEdf7ENUEyQugo0ePIigoCA4ODpDJZNi5c2eZfZRKJVxdXWFiYgI/Pz+cPHnyqce9c+cOmjX735Rxs2bNcPv27eqMTkT03IrVGny89yImrD2NzIJieDazxJ6wFzCgg4PU0Yh0muQFUH5+Pry8vKBUKst9ffPmzQgPD8f8+fMRExMDLy8vBAQEIC0trZaTEhFVr1uZBXjt39FYefQaAGBcd1dsf7M7XBqbS5yMSPdJfhVYYGAgAgMDK3x9yZIlmDx5MsaPHw8AWLFiBfbs2YPVq1djzpw5Fb7PwcGh1IzP7du30aVLlwr3V6lUUKlU2u2cnJyqfAwioir55UIKZm07i+wHxbAwMcTnwR3Q19Ne6lhEekPyGaAnKSoqwpkzZ+Dv768dk8vl8Pf3R3R09BPf26VLF5w/fx63b99GXl4e9u3bh4CAgAr3X7x4MaysrLQ/Tk58qCARVb+iEg0++vkv/GPdGWQ/KIaXoxX2hvVk8UNUyySfAXqSjIwMqNVq2Nralhq3tbXFpUuXtNv+/v6Ij49Hfn4+HB0dsXXrVnTr1g1ffvklevfuDY1Gg9mzZ6Nx48YVnmvu3LkIDw/Xbufk5LAIIqJqlXy/AFMiYxB/KxsAMPGF5vi/vm1hbFin/1+USCfV6QKosg4ePFju+MCBAzFw4MBKHUOhUEChUECpVEKpVEKtVldnRCLSc/vP38WsbWeRW1gCK1MjfDHcC6942D79jURUI+p0AWRjYwMDAwOkpqaWGk9NTYWdnV2NnDM0NBShoaHIycmBlZVVjZyDiPRHYbEai/dexPfRNwAAvs4NsWyUDxwbmUmcjEi/1el5V2NjY3Ts2BFRUVHaMY1Gg6ioKHTr1q1GzqlUKuHh4YHOnTvXyPGJSH9cz8jHsG+Pa4uff77UApv/2Y3FD1EdIPkMUF5eHhITE7XbSUlJiIuLg7W1NZydnREeHo6QkBB06tQJXbp0wdKlS5Gfn6+9Kqy6cQaIiKrDz/F3MPfHc8hTlaCRmRGWvOaN3m2bSh2LiP5L8gLo9OnT6N27t3b70ULkkJAQrF27FiNGjEB6ejrmzZuHlJQUeHt7Y//+/WUWRhMR1QWFxWp8tPsvRP55EwDQ2bURlo3ygb2VqcTJiOjvZEIIIXWIuuTvi6ATEhKQnZ0NS0tLqWMRUT1wNT0PoRticCklFzIZ8FYvN8zwbw1Dgzq92oBIpzzq4Dzt9zcLoApU9gskIgKAnbG38c6OcygoUqOxuTG+GuGNF1s3kToWkd6p7O9vyVtgRET12YMiNT746QI2n04GAHRtYY2vR/rA1tJE4mRE9CQsgB7D+wARUWVdSc1FaGQMElLzIJMBU/u0wrSXW8FALpM6GhE9BVtgFWALjIieZOvpZMzbdQEPitWwaaDAspHe6N7SRupYRHqPLTAiohpQUFSC93aex48xDx+23KNlY3w1whtNLdjyIqpPWAA9hi0wIqrI5ZRcvLXhDK6m50MuA2b4t8ZbvVuy5UVUDz1XC6y4uBgpKSkoKChAkyZNYG1tXZ3ZJMUWGBE9IoTA5lPJmP/TBahKNLC1VODrkT7o2qLiBywTkTRqrAWWm5uL9evXY9OmTTh58iSKiooghIBMJoOjoyNeffVV/OMf/+CjJIhIJ+SpSvDujnPYFXcHAPBi6yb46jUvNG6gkDgZET2PKhVAS5YswaJFi+Dm5oagoCC88847cHBwgKmpKe7fv4/z58/j999/x6uvvgo/Pz8sX74crVq1qqnsREQ16q87OZgSGYNrGfkwkMsw89XW+NeLbpCz5UVU71WpBTZq1Ci89957aNeu3RP3KywsxNq1a2FsbIwJEyY8d0gpsAVGpL+EENjw5018tPsvFJVoYG9lgmWjfNDZVXfa/ES6ineCfkZ8FAaRfsspLMbcH89hz9m7AIA+bZviy+FeaGRuLHEyIqoMSQogIQT279+PVatWYdu2bdV1WElwBohI/5y7lY0pG2Nw414BDOUyzO7bBpNeaMGWF1E9Uqv3AUpKSsLq1auxdu1apKenw9/fvzoOS0RUK4QQ+CH6BhbtuYgitQbNGppi+Wgf+Do3kjoaEdWQZy6AVCoVtm3bhlWrVuHYsWNQq9X44osvMHHiRM6YEFG9kf2gGP+37Sz2X0gBALziYYsvgr1gZWYkcTIiqknyqr7hzJkzeOutt2BnZ4elS5di8ODBSE5OhlwuR0BAAIsfIqo34pKz0H/Z79h/IQVGBjLMG+CBlWM7svgh0gNVngHy8/PD1KlTceLECbRp06YmMkmKd4Im0n1CCKw6loRP919CsVrAydoUEaN84eXUUOpoRFRLqrwIOiAgANHR0QgKCsLYsWMREBAAmUwGIyMjxMfHw8PDo6ay1iougibSTVkFRXh761kcvJgKAAj0tMMnwzrAypSzPkS6oMYWQR84cADJyclYs2YN3nzzTTx48AAjRowAAMhkvFKCiOquMzcyMTUyBneyC2FsIMd7A9wxtqsL/+4i0kPPfRn8r7/+ijVr1mDHjh1wcnJCcHAwgoOD4evrW10ZJcEZICLdodEIfPf7NXx+4DJKNAIujc2gHO0Lz2ZWUkcjompW6/cByszMxPr167F69WqcPXu23q+hYQFEpBvu5xdh5pY4HLqcDgAY0MEei4e2h4UJW15EukjSO0HHxMRwBoiIJHcy6T7CNsYiJacQxoZyfBDUDqO6OLHlRaTDKvv7u0qXwd+8ebNS+z0qfm7fvl2VwxMRVQuNRkB5KBGjvjuBlJxCtLAxx67QHhjt58zih4gAVLEA6ty5M/75z3/i1KlTFe6TnZ2N7777Dp6enti+fftzByQiqoqMPBVC1pzE5wcuQ60RGOLTDD9PfQHu9pzJJaL/qdJVYH/99RcWLVqEV155BSYmJujYsSMcHBxgYmKCzMxM/PXXX7hw4QJ8fX3x2WefoV+/fjWVu8bwPkBE9Vf01XuYtikWabkqmBjJ8dFATwzv5MhZHyIq45nWAD148AB79uzBsWPHcOPGDTx48AA2Njbw8fFBQEAAXFxcYGFhURN5aw3XABHVH2qNQMRvifg6KgEaAbRs2gDfjPFFa9v6/fcQEVVdjS2C/uqrrzBjxowKX8/NzUXfvn3xxx9/VOWwdQ4LIKL6IS23ENM3xeH41XsAgOCOjvhoUDuYGVfLs56JqJ6psRshvvPOO2jcuDHeeOONMq/l5+ejb9++uHfvXlUPS0RUZceuZGD65jhk5KlgamSAhYM9Mayjo9SxiKgeqHIBtG7dOowdOxYNGzbEwIEDteN5eXno27cv0tPTceTIkWoNSUT0dyVqDb6OuoKIQ4kQAmhjawHlGF+0bNpA6mhEVE9UuQAKDg5GVlYWRo0ahT179qBXr17Iz89HYGAgUlNTceTIEdjb29dEViIipOYUYurGWJxMug8AGNXFCfOD2sHEyEDiZERUnzxTk3zSpEm4f/8+Bg0ahF27dmHevHm4c+cOjhw5AgcHh+rOSEQEADiSkI4Zm+NwP78I5sYG+HhoewzybiZ1LCKqh555leDs2bNx//59vPzyy3B1dcXhw4fh6MjeOxFVvxK1Bl/+moBvD18FALjbW0I52gctmrDlRUTPpsoF0NChQ0ttGxkZwcbGBtOmTSs1/uOPPz5fsmrwxRdfYM2aNZDJZJgzZw5ef/11qSMRURXdyXqAsI2xOH0jEwDweldnvNffgy0vInouVS6ArKxKPz151KhR1RamOp07dw6RkZE4c+YMhBDo3bs3BgwYgIYNG0odjYgq6bdLqQjfEo+sgmI0UBjik2HtMaAD2+xE9PyqXACtWbOmJnJUu4sXL6Jbt24wMTEBAHh5eWH//v0YOXKkxMmI6GmK1Rp8fuAyVh69BgBo38wKEaN94NLYXOJkRKQrqvQssNp09OhRBAUFwcHBATKZDDt37iyzj1KphKurK0xMTODn54eTJ09qX/P09MThw4eRlZWFzMxMHD58mA9nJaoHbmUWYPiKaG3xM667K7a92Y3FDxFVqzpbAOXn58PLywtKpbLc1zdv3ozw8HDMnz8fMTEx8PLyQkBAANLS0gAAHh4eCAsLQ58+fTB06FB07doVBgZcM0BUl/1yIQX9vv4dcclZsDAxxIrXffHBwHZQGPK/XSKqXs/0LLDaJpPJsGPHDgwePFg75ufnh86dOyMiIgIAoNFo4OTkhKlTp2LOnDlljjFp0iQMGTIE/fv3L/ccKpUKKpVKu52TkwMnJyc+CoOoFhSVaLB430Ws+eM6AMDL0QoRo33hZG0mbTAiqncq+yiMOjsD9CRFRUU4c+YM/P39tWNyuRz+/v6Ijo7Wjj2aDbp8+TJOnjyJgICACo+5ePFiWFlZaX+cnJxq7gMQkdbNewUIXnFcW/xMeqE5tv6rO4sfIqpR9fJpgRkZGVCr1bC1tS01bmtri0uXLmm3Bw0ahOzsbJibm2PNmjUwNKz4486dOxfh4eHa7UczQERUc/adu4vZ284iV1UCK1MjfDncC/4etk9/IxHRc6qXBVBl/X026GkUCgUUCgWUSiWUSiXUanUNJiPSb4XFany89yJ+iL4BAPB1bojlo33RrKGpxMmISF/UywLIxsYGBgYGSE1NLTWempoKOzu75zp2aGgoQkNDtT1EIqpe1zPyERoZgwt3cgAA/3ypBd5+tQ2MDOplR56I6ql6+TeOsbExOnbsiKioKO2YRqNBVFQUunXr9lzHViqV8PDwQOfOnZ83JhE95qf4Oxiw/Bgu3MlBIzMjrBnXGXMD3Vn8EFGtq7MzQHl5eUhMTNRuJyUlIS4uDtbW1nB2dkZ4eDhCQkLQqVMndOnSBUuXLkV+fj7Gjx//XOflDBBR9SssVuOj3X8h8s+bAIDOro2wbJQP7K3Y8iIiadTZAuj06dPo3bu3dvvRAuWQkBCsXbsWI0aMQHp6OubNm4eUlBR4e3tj//79ZRZGE5G0rqbnIXRDDC6l5EImA97q5YYZ/q1hyFkfIpJQvbgPUG36+yLohIQE3geI6DnsiL2Fd3ecR0GRGo3NjfHVCG+82LqJ1LGISIdV9j5ALIAqUNkvkIjKelCkxvyfzmPL6VsAgK4trLFspA+aWppInIyIdF1lf3/X2RYYEdVPV1JzERoZg4TUPMhkQFifVgh7uRUM5DKpoxERabEAegzvA0T07LaeTsa8XRfwoFiNJhYKfD3CG91b2kgdi4ioDLbAKsAWGFHl5atK8P6u8/gx5jYA4IWWNvhqhDeaWCgkTkZE+oYtMCKqFZdSchC6IQZX0/MhlwEz/Fvjrd4t2fIiojqNBdBj2AIjqhwhBDafSsb8ny5AVaKBraUCX4/0QdcWjaWORkT0VGyBVYAtMKKK5alK8M6P5/BT/B0AwIutm+Cr17zQuAFbXkQkLbbAiKhGnL+djSmRMbh+rwAGchnefrUN/vliC8jZ8iKieoQFEBFVihAC607cwMLdF1Gk1sDBygTLR/ugo4u11NGIiKqMBdBjuAaIqKzsB8WYs/0s9p1PAQD4uzfF58FeaGRuLHEyIqJnwzVAFeAaIKKH4pKzMCUyBrcyH8DIQIY5ge6Y0MMVMhlbXkRU93ANEBE9FyEEVh1Lwqf7L6FYLeBkbYqIUb7wcmoodTQioufGAoiIysjML8KsbfE4eDENABDoaYdPhnWAlamRxMmIiKoHCyAiKuX09fsI2xiLO9mFMDaQ4/0B7ni9qwtbXkSkU1gAEREAQKMRWHH0Kr78JQFqjUBzG3MsH+UDz2ZWUkcjIqp2LIAew6vASB9l5KkQviUeRxPSAQCDvB2waEh7NFDwrwgi0k28CqwCvAqM9EX01XuYtikWabkqKAzl+GhQO7zWyYktLyKql3gVGBE9kVojsPy3K1gWdQUaAbRs2gDK0b5oY2chdTQiohrHAohID6XlFGL65jgcv3oPABDc0REfDWoHM2P+lUBE+oF/2xHpmd+vpGPG5jhk5BXBzNgACwZ5YlhHR6ljERHVKhZARHqiRK3BVwcT8M3hqxACaGtngYjRvmjZtIHU0YiIah0LICI9cDf7AcI2xuLU9UwAwGg/Z8wb4AETIwOJkxERSYMFEJGO++1SKmZuiUdmQTEaKAzx8dD2GOjlIHUsIiJJsQB6DO8DRLqiWK3B5wcuY+XRawAAz2aWiBjlC1cbc4mTERFJj/cBqgDvA0T1WfL9AkzdGIu45CwAwLjurpjbry0Uhmx5EZFu432AiPTU/vMpmL0tHjmFJbA0McRnwV7o62kndSwiojqFBRCRjlCVqLF47yWsPX4dAODl1BARo3zgZG0mbTAiojqIBRCRDriekY8pG2Nw/nYOAGByz+aYFdAWxoZyiZMREdVNLICI6rndZ+9gzvZzyFOVoKGZEb4c7oWX3W2ljkVEVKexACKqpwqL1fho91+I/PMmAKCzayMsG+UDeytTiZMREdV9Oj0//tVXX6Fdu3bw8PBAWFgYeMEb6YrEtDwMVv6ByD9vQiYDQnu7YePkrix+iIgqSWdngNLT0xEREYELFy7AyMgIL774Ik6cOIFu3bpJHY3oufwYcwvv7TyPgiI1Gpsb46sR3nixdROpYxER1Ss6WwABQElJCQoLCwEAxcXFaNq0qcSJiJ5dQVEJ5u26gG1nbgEAurVojK9HeqOppYnEyYiI6p862wI7evQogoKC4ODgAJlMhp07d5bZR6lUwtXVFSYmJvDz88PJkye1rzVp0gRvv/02nJ2d4eDgAH9/f7i5udXiJyCqPgmpuRgU8Qe2nbkFuQyY4d8a6yf5sfghInpGdbYAys/Ph5eXF5RKZbmvb968GeHh4Zg/fz5iYmLg5eWFgIAApKWlAQAyMzOxe/duXL9+Hbdv38bx48dx9OjR2vwIRM9NCIHNp25iYMQxXEnLQ1MLBTZM6opp/q1gIJdJHY+IqN6qsy2wwMBABAYGVvj6kiVLMHnyZIwfPx4AsGLFCuzZswerV6/GnDlzcPDgQbRs2RLW1tYAgP79++PEiRN48cUXyz2eSqWCSqXSbufk5FTjpyGqujxVCd7dcQ674u4AAHq2ssFXI7xh00AhcTIiovqvzs4APUlRURHOnDkDf39/7ZhcLoe/vz+io6MBAE5OTjh+/DgKCwuhVqtx+PBhtGnTpsJjLl68GFZWVtofJyenGv8cRBW5cCcbQcuPYVfcHRjIZZjdtw2+H9+FxQ8RUTWplwVQRkYG1Go1bG1L3+zN1tYWKSkpAICuXbuiX79+8PHxQYcOHeDm5oaBAwdWeMy5c+ciOztb+5OcnFyjn4GoPEIIrIu+jiHfHEdSRj7srUyw+R9d8VavlpCz5UVEVG3qbAusOixatAiLFi2q1L4KhQIKhQJKpRJKpRJqtbqG0xGVlv2gGHN/PIu95x4W8S+3bYovhnuhkbmxxMmIiHRPvSyAbGxsYGBggNTU1FLjqampsLN7vqdeh4aGIjQ0FDk5ObCysnquYxFVVnxyFqZsjEHy/QcwlMswJ7AtJr7QHDIZZ32IiGpCvWyBGRsbo2PHjoiKitKOaTQaREVF8UaHVK8IIbDqWBKCVxxH8v0HcGxkim1vdsekni1Y/BAR1aA6OwOUl5eHxMRE7XZSUhLi4uJgbW0NZ2dnhIeHIyQkBJ06dUKXLl2wdOlS5Ofna68Ke1ZsgVFtySoowttbz+LgxYczmX3b2eHT4A6wMjWSOBkRke6TiTr6gKzDhw+jd+/eZcZDQkKwdu1aAEBERAQ+//xzpKSkwNvbG8uWLYOfn1+1nP9RCyw7OxuWlpbVckyiR87cuI+pkbG4k10IYwM53hvgjrFdXTjrQ0T0nCr7+7vOFkBS+fsMUEJCAgsgqlYajcC/j17DF79chloj4NrYDBGjfeHZjOvNiIiqAwug58QZIKpu9/JUCN8SjyMJ6QCAIC8HfDzEExYmbHkREVWXyv7+rrNrgIh0yYlr9zBtUyxSc1RQGMrxwcB2GNnZiS0vIiKJsAB6DBdBU3VSawSUhxKx9GACNAJwa2IO5RhftLXjrCIRkZTYAqsAW2D0vNJyCzFjcxz+SLwHABjm64gFg9vBzJj/30FEVFPYAiOS0LErGZi+ORYZeUUwNTLAgsGeCO7oKHUsIiL6LxZARNWoRK3B0oNXoDycCCGANrYWUI7xQcumFlJHIyKiv2EB9BiuAaJndTf7AaZtjMPJ6/cBAKO6OGN+kAdMjAwkTkZERI/jGqAKcA0QVcWhS2kI3xKHzIJimBsbYPGwDhjo5SB1LCIivcM1QES1oFitwRcHLuPfR68BANo5WCJitC+a25hLnIyIiJ6EBRDRM7qVWYCpG2MRezMLABDSzQVz+7mz5UVEVA+wAHoM1wBRZRy4kIJZW+ORU1gCCxNDfDasAwLb20sdi4iIKolrgCrANUBUHlWJGp/su4Q1f1wHAHg5NUTEKB84WZtJG4yIiABwDRBRtbtxLx9TImNx7nY2AGByz+aYFdAWxoZyiZMREVFVsQAiqoTdZ+9gzvZzyFOVoKGZEb4I9oK/h63UsYiI6BmxACJ6gsJiNRbs/gsb/rwJAOjk0gjLRvnAoaGpxMmIiOh5sAAiqsDV9DyEbojBpZRcAMBbvdww45XWMDJgy4uIqL5jAfQYXgVGALAj9hbe3XEeBUVqNDY3xpIR3nipdROpYxERUTXhVWAV4FVg+qmgqATzd13A1jO3AABdW1jj65E+sLU0kTgZERFVBq8CI6qihNRchG6IwZW0PMhkQFifVgh7uRUM5DKpoxERUTVjAUR6TwiBradvYd5P51FYrEETCwW+HuGN7i1tpI5GREQ1hAUQ6bU8VQne23EOO+PuAAB6trLBkte80cRCIXEyIiKqSSyASG9duJONqZGxuJaRDwO5DOGvtMabL7lBzpYXEZHOYwFEekcIgfV/3sSC3X+hqEQDO0sTLB/tg86u1lJHIyKiWsIC6DG8DF635RQWY+72c9hz7i4AoE/bpvhiuBeszY0lTkZERLWJl8FXgJfB656zt7IwJTIWN+8XwFAuw//1bYuJLzRny4uISIfwMnii/xJCYM0f17F430UUqwWaNTRFxGgf+Dg3kjoaERFJhAUQ6bSsgiK8vfUsDl5MBQAEtLPFZ8O8YGVmJHEyIiKSEgsg0llnbmQibGMsbmc9gLGBHO/2d8cb3Vwgk7HlRUSk71gAkc7RaARW/n4NXxy4jBKNgEtjM0SM8kV7RyupoxERUR3BAoh0yr08FcK3xONIQjoAYEAHeywe2h4WJmx5ERHR/7AAIp0RffUepm2KRVquCgpDOT4Y2A4jOzux5UVERGXIpQ5QUy5fvgxvb2/tj6mpKXbu3Cl1LKoBao3A0oMJGPOfE0jLVcGtiTl2TemBUV2cWfwQEVG5dHYGqE2bNoiLiwMA5OXlwdXVFa+88oq0oajapeYUYtqmWJy4dh8AMLyjIz4c1A5mxjr7R5uIiKqBXvyW+Omnn/Dyyy/D3Nxc6ihUjQ5fTsPMLfG4l18EM2MDLBzsiaG+jlLHIiKieqDOtsCOHj2KoKAgODg4QCaTldu+UiqVcHV1hYmJCfz8/HDy5Mlyj7VlyxaMGDGihhNTbSlWa7B430WMW3MK9/KL4G5viZ+nvsDih4iIKq3OFkD5+fnw8vKCUqks9/XNmzcjPDwc8+fPR0xMDLy8vBAQEIC0tLRS++Xk5OD48ePo169fbcSmGnYrswCv/Tsa/z5yDQAwtqsLdrzVHW5NGkicjIiI6pN68SwwmUyGHTt2YPDgwdoxPz8/dO7cGREREQAAjUYDJycnTJ06FXPmzNHut27dOhw4cADr169/4jlUKhVUKpV2OycnB05OTnwWWB1y4EIKZm2NR05hCSxMDPHZsA4IbG8vdSwiIqpDKvsssDo7A/QkRUVFOHPmDPz9/bVjcrkc/v7+iI6OLrVvZdtfixcvhpWVlfbHycmp2nPTs1GVqPHBTxfwz3VnkFNYAi+nhtgb1pPFDxERPbN6WQBlZGRArVbD1ta21LitrS1SUlK029nZ2Th58iQCAgKeesy5c+ciOztb+5OcnFztuanqkjLyMezb41h7/DoAYHLP5tj6z25wsjaTNhgREdVrOn0VmJWVFVJTUyu1r0KhgEKhgFKphFKphFqtruF09DS74m7jnR/PIb9IjUZmRvjyNS/0aWv79DcSERE9Rb0sgGxsbGBgYFCmuElNTYWdnd1zHTs0NBShoaHaHiLVvgdFanz48wVsOvVwFq6LqzW+HuUNeytTiZMREZGuqJctMGNjY3Ts2BFRUVHaMY1Gg6ioKHTr1u25jq1UKuHh4YHOnTs/b0x6BgmpuRikPIZNp5IhkwFhfVoicrIfix8iIqpWdXYGKC8vD4mJidrtpKQkxMXFwdraGs7OzggPD0dISAg6deqELl26YOnSpcjPz8f48eOf67ycAZKGEAJbT9/CvJ/Oo7BYgyYWCiwd4Y0eLW2kjkZERDqozhZAp0+fRu/evbXb4eHhAICQkBCsXbsWI0aMQHp6OubNm4eUlBR4e3tj//79ZRZGU92XpyrBuzvOYVfcHQBAz1Y2WPKaN5pYKCRORkREuqpe3AeoNv19EXRCQgLvA1TDzt/OxpTIGFy/VwADuQwzX22Nf73oBrmcDzElIqKqq+x9gFgAVaCyXyA9GyEEfoi+gUV7LqJIrYGDlQmWjfJBJ1drqaMREVE9Vtnf33W2BUa6K7ugGLO3x+PAhYdX8fm72+KL4R3Q0MxY4mRERKQvWAA9hvcBqlkxNzMxNTIWt7MewMhAhrmB7hjfwxUyGVteRERUe9gCqwBbYNVLoxH47vdr+PzAZZRoBJytzRAx2gcdHBtKHY2IiHQIW2BUZ9zLU2Hm1ngcvpwOAOjfwR6Lh7aHpYmRxMmIiEhfsQB6DFtg1Sv66j1M3xyL1BwVFIZyzA9qh1FdnNjyIiIiSbEFVgG2wJ6PWiOw/LcrWBZ1BRoBuDUxh3KML9ra8bskIqKawxYYSSY1pxDTN8Uh+to9AEBwR0d8NKgdzIz5x42IiOoG/kaianUkIR3hm+NwL78IZsYGWDjYE0N9HaWORUREVAoLIKoWxWoNvvwlASuOXAUAuNtbImK0D9yaNJA4GRERUVksgB7DRdBVdyuzAGEbYxFzMwsAMLarC97t7w4TIwNpgxEREVWAi6ArwEXQlXPgQgpmbY1HTmEJLBSG+DS4A/q1t5c6FhER6SkugqYapSpRY/HeS1h7/DoAwMupISJG+cDJ2kzaYERERJXAAoiq7HpGPqZsjMH52zkAgMk9m2NWQFsYG8olTkZERFQ5LICoSnbF3ca7O84jT1WCRmZG+PI1L/Rpayt1LCIioiphAfQYLoIu34MiNT78+QI2nUoGAHRxtcbXo7xhb2UqcTIiIqKq4yLoCnAR9P9cSc1FaGQMElLzIJMBU3u3RNjLrWBowJYXERHVLVwETc9NCIGtp29h3k/nUVisgU0DBb4e6Y0eLW2kjkZERPRcWABRufJUJXhvxznsjLsDAOjZygZLXvNGEwuFxMmIiIieHwsgKuP87WxM3RiLpIx8GMhlCH+lNd58yQ1yOZ/gTkREuoEFEGkJIbDuxA0s3H0RRWoNHKxMsGyUDzq5WksdjYiIqFqxACIAQPaDYvzftrPYfyEFAODv3hSfB3uhkbmxxMmIiIiqHwsgQszNTEyNjMXtrAcwMpBhTqA7JvRwhUzGlhcREekmFkCP0af7AGk0At/9fg2fH7iMEo2As7UZIkb7oINjQ6mjERER1SjeB6gCun4foHt5KszcGo/Dl9MBAP072GPx0PawNDGSOBkREdGz432AqEInrt3DtE2xSM1RQWEox/ygdhjVxYktLyIi0hssgPSIWiMQ8Vsivo5KgEYAbk3MoRzji7Z2ujfDRURE9CQsgPREWk4hpm2KQ/S1ewCA4I6O+GhQO5gZ848AERHpH/720wNHEtIRvjkO9/KLYGZsgIWDPTHU11HqWERERJJhAaTDitUaLPk1Ad8evgoAaGtnAeUYX7g1aSBxMiIiImmxANJRtzILELYxFjE3swAAY7u64N3+7jAxMpA2GBERUR2g0wVQUlISJkyYgNTUVBgYGODEiRMwNzeXOlaN++VCCmZtO4vsB8WwUBji0+AO6NfeXupYREREdYZOF0Djxo3DwoUL0bNnT9y/fx8KhW4/yVxVosbivZew9vh1AICXU0NEjPKBk7WZtMGIiIjqGJ0tgC5cuAAjIyP07NkTAGBtrdsP9LyekY8pG2Nw/nYOAGByz+aYFdAWxoZyiZMRERHVPXX2t+PRo0cRFBQEBwcHyGQy7Ny5s8w+SqUSrq6uMDExgZ+fH06ePKl97cqVK2jQoAGCgoLg6+uLjz/+uBbT166f4u9gwPJjOH87B43MjLB6XCe829+DxQ8REVEF6uxvyPz8fHh5eUGpVJb7+ubNmxEeHo758+cjJiYGXl5eCAgIQFpaGgCgpKQEv//+O7755htER0fj119/xa+//lqbH6HGPShSY+6PZxG2MRZ5qhJ0cbXG3mk90aetrdTRiIiI6rQ62wILDAxEYGBgha8vWbIEkydPxvjx4wEAK1aswJ49e7B69WrMmTMHzZo1Q6dOneDk5AQA6NevH+Li4vDKK6+UezyVSgWVSqXdzsnJqcZPU/2upOYiNDIGCal5kMmAKb1bYtrLrWBoUGdrWiIiojqjXv62LCoqwpkzZ+Dv768dk8vl8Pf3R3R0NACgc+fOSEtLQ2ZmJjQaDY4ePQp3d/cKj7l48WJYWVlpfx4VTnWNEAJbTicjKOIYElLzYNNAgfUT/TDz1TYsfoiIiCqpXv7GzMjIgFqthq1t6VaPra0tUlJSAACGhob4+OOP8eKLL6JDhw5o1aoVBgwYUOEx586di+zsbO1PcnJyjX6GZ5GnKsGMzXGYve0sCos16NnKBvum9USPljZSRyMiIqpX6mwLrDo8rY32dwqFAgqFAkqlEkqlEmq1uobTVc2FO9mYEhmLpIx8GMhlCH+lNd58yQ1yOZ/gTkREVFX1sgCysbGBgYEBUlNTS42npqbCzs7uuY4dGhqK0NBQ5OTkwMrK6rmOVR2EEFh34gYW7r6IIrUG9lYmWD7KB51cdfuyfiIioppUL1tgxsbG6NixI6KiorRjGo0GUVFR6Nat23MdW6lUwsPDA507d37emM8t+0Ex3lwfg3m7LqBIrYG/e1PsDevJ4oeIiOg51dkZoLy8PCQmJmq3k5KSEBcXB2trazg7OyM8PBwhISHo1KkTunTpgqVLlyI/P197VdizqiszQLE3MzF1YyxuZT6AkYEMcwLdMaGHK2QytryIiIieV50tgE6fPo3evXtrt8PDwwEAISEhWLt2LUaMGIH09HTMmzcPKSkp8Pb2xv79+8ssjK4qqdcAaTQC/zl2DZ/tv4wSjYCztRkiRvugg2NDSfIQERHpIpkQQkgdoi56NAOUnZ0NS0vLWjnn/fwizNwSh0OX0wEA/TvYY/HQ9rA0MaqV8xMREdV3lf39XWdngPTNiWv3MG1TLFJzVFAYyjEvyAOjuziz5UVERFQDWAA9prZbYGqNgPJQIpYeTIBGAG5NzKEc44u2drUz60RERKSP2AKrQG20wNJyCjF9cxyOX70HAAju6IiPBrWDmTHrUiIiomfBFlgddyQhHeGb43AvvwhmxgZYONgTQ30dpY5FRESkF1gA1bJitQZLfk3At4evAgDa2llAOcYXbk0aSJyMiIhIf7AAekxNrgFSlagx5rs/cfpGJgDg9a7OeK+/B0yMDKr9XERERFQxrgGqQE2tAZq/6zx+jLmNT4M7oF97+2o7LhEREVX+9zcLoArUVAFUWKxGeq4KTtZm1XZMIiIieqiyv7/r5bPA6jMTIwMWP0RERBJjAfSYuvQwVCIiIqoZbIFVQIpHYRAREdHzYQuMiIiIqAIsgIiIiEjvsAAiIiIivcMCiIiIiPQOC6DH8CowIiIi3cerwCrAq8CIiIjqH14FRkRERFQBFkBERESkd1gAERERkd5hAURERER6hwUQERER6R1DqQPUVY8ujsvJyZE4CREREVXWo9/bT7vInQVQBXJzcwEATk5OEichIiKiqsrNzYWVlVWFr/M+QBXQaDS4c+cOLCwsIJPJqu24OTk5cHJyQnJyMu8vVIP4Pdcefte1g99z7eD3XDtq8nsWQiA3NxcODg6Qyyte6cMZoArI5XI4OjrW2PEtLS35H1ct4Pdce/hd1w5+z7WD33PtqKnv+UkzP49wETQRERHpHRZAREREpHdYANUyhUKB+fPnQ6FQSB1Fp/F7rj38rmsHv+fawe+5dtSF75mLoImIiEjvcAaIiIiI9A4LICIiItI7LICIiIhI77AAIiIiIr3DAqiWfPDBB5DJZKV+2rZtK3UsnXT79m28/vrraNy4MUxNTdG+fXucPn1a6lg6xdXVtcyfZ5lMhtDQUKmj6RS1Wo33338fzZs3h6mpKdzc3LBgwYKnPuOIqi43NxfTp0+Hi4sLTE1N0b17d5w6dUrqWPXe0aNHERQUBAcHB8hkMuzcubPU60IIzJs3D/b29jA1NYW/vz+uXLlSK9lYANWidu3a4e7du9qfY8eOSR1J52RmZqJHjx4wMjLCvn378Ndff+HLL79Eo0aNpI6mU06dOlXqz/Kvv/4KABg+fLjEyXTLp59+im+//RYRERG4ePEiPv30U3z22WdYvny51NF0zqRJk/Drr79i3bp1OHfuHF599VX4+/vj9u3bUker1/Lz8+Hl5QWlUlnu65999hmWLVuGFStW4M8//4S5uTkCAgJQWFhY49l4GXwt+eCDD7Bz507ExcVJHUWnzZkzB3/88Qd+//13qaPolenTp2P37t24cuVKtT47T98NGDAAtra2WLVqlXZs2LBhMDU1xfr16yVMplsePHgACwsL7Nq1C/3799eOd+zYEYGBgVi4cKGE6XSHTCbDjh07MHjwYAAPZ38cHBwwc+ZMvP322wCA7Oxs2NraYu3atRg5cmSN5uEMUC26cuUKHBwc0KJFC4wZMwY3b96UOpLO+emnn9CpUycMHz4cTZs2hY+PD7777jupY+m0oqIirF+/HhMmTGDxU826d++OqKgoJCQkAADi4+Nx7NgxBAYGSpxMt5SUlECtVsPExKTUuKmpKWfqa1BSUhJSUlLg7++vHbOysoKfnx+io6Nr/PwsgGqJn58f1q5di/379+Pbb79FUlISevbsidzcXKmj6ZRr167h22+/RatWrXDgwAG8+eabCAsLw/fffy91NJ21c+dOZGVlYdy4cVJH0Tlz5szByJEj0bZtWxgZGcHHxwfTp0/HmDFjpI6mUywsLNCtWzcsWLAAd+7cgVqtxvr16xEdHY27d+9KHU9npaSkAABsbW1Ljdva2mpfq0l8Gnwt+fv/sXXo0AF+fn5wcXHBli1bMHHiRAmT6RaNRoNOnTrh448/BgD4+Pjg/PnzWLFiBUJCQiROp5tWrVqFwMBAODg4SB1F52zZsgUbNmxAZGQk2rVrh7i4OEyfPh0ODg7881zN1q1bhwkTJqBZs2YwMDCAr68vRo0ahTNnzkgdjWoIZ4Ak0rBhQ7Ru3RqJiYlSR9Ep9vb28PDwKDXm7u7OdmMNuXHjBg4ePIhJkyZJHUUnzZo1SzsL1L59e4wdOxYzZszA4sWLpY6mc9zc3HDkyBHk5eUhOTkZJ0+eRHFxMVq0aCF1NJ1lZ2cHAEhNTS01npqaqn2tJrEAkkheXh6uXr0Ke3t7qaPolB49euDy5culxhISEuDi4iJRIt22Zs0aNG3atNTCUao+BQUFkMtL/zVtYGAAjUYjUSLdZ25uDnt7e2RmZuLAgQMYNGiQ1JF0VvPmzWFnZ4eoqCjtWE5ODv78809069atxs/PFlgtefvttxEUFAQXFxfcuXMH8+fPh4GBAUaNGiV1NJ0yY8YMdO/eHR9//DFee+01nDx5EitXrsTKlSuljqZzNBoN1qxZg5CQEBga8q+SmhAUFIRFixbB2dkZ7dq1Q2xsLJYsWYIJEyZIHU3nHDhwAEIItGnTBomJiZg1axbatm2L8ePHSx2tXsvLyyvV6UhKSkJcXBysra3h7OyM6dOnY+HChWjVqhWaN2+O999/Hw4ODtorxWqUoFoxYsQIYW9vL4yNjUWzZs3EiBEjRGJiotSxdNLPP/8sPD09hUKhEG3bthUrV66UOpJOOnDggAAgLl++LHUUnZWTkyOmTZsmnJ2dhYmJiWjRooV49913hUqlkjqaztm8ebNo0aKFMDY2FnZ2diI0NFRkZWVJHaveO3TokABQ5ickJEQIIYRGoxHvv/++sLW1FQqFQrz88su19ncK7wNEREREeodrgIiIiEjvsAAiIiIivcMCiIiIiPQOCyAiIiLSOyyAiIiISO+wACIiIiK9wwKIiIiI9A4LICIiItI7LICI6KlkMhl27twpdYwnOnz4MGQyGbKysqSOgj/++APt27eHkZFRjdzSPyoqCu7u7lCr1ZV+z8iRI/Hll19Wexai+ooFEJGeGjduHGQyGWQyGYyMjGBra4tXXnkFq1evLvOwzbt37yIwMFCipJXTvXt33L17F1ZWVlJHQXh4OLy9vZGUlIS1a9c+cd+NGzfCwMAAoaGhlT7+7Nmz8d5778HAwKDS73nvvfewaNEiZGdnV/o9RLqMBRCRHuvbty/u3r2L69evY9++fejduzemTZuGAQMGoKSkRLufnZ0dFAqFhEmfztjYGHZ2dpDJZFJHwdWrV9GnTx84OjqiYcOGT9x31apVmD17NjZu3IjCwsKnHvvYsWO4evUqhg0bVqVMnp6ecHNzw/r166v0PiJdxQKISI8pFArY2dmhWbNm8PX1xTvvvINdu3Zh3759pWYu/t4Cu379OmQyGbZs2YKePXvC1NQUnTt3RkJCAk6dOoVOnTqhQYMGCAwMRHp6eqnz/ec//4G7uztMTEzQtm1bfPPNN9rXHh33xx9/RO/evWFmZgYvLy9ER0dr97lx4waCgoLQqFEjmJubo127dti7dy+A8ltg27dvR7t27aBQKODq6lqmBeTq6oqPP/4YEyZMgIWFBZydnbFy5confmcqlQphYWFo2rQpTExM8MILL+DUqVOlPsO9e/cwYcIEyGSyJ84AJSUl4fjx45gzZw5at26NH3/88YnnBoBNmzbhlVdegYmJiXbsgw8+gLe3N9atWwdXV1dYWVlh5MiRyM3NLfXeoKAgbNq06annINILtfLIVSKqc0JCQsSgQYPKfc3Ly0sEBgZqtwGIHTt2CCGESEpKEgBE27Ztxf79+8Vff/0lunbtKjp27Ch69eoljh07JmJiYkTLli3Fv/71L+0x1q9fL+zt7cX27dvFtWvXxPbt24W1tbVYu3ZtmePu3r1bXL58WQQHBwsXFxdRXFwshBCif//+4pVXXhFnz54VV69eFT///LM4cuSIEOJ/T53OzMwUQghx+vRpIZfLxUcffSQuX74s1qxZI0xNTcWaNWu0mVxcXIS1tbVQKpXiypUrYvHixUIul4tLly5V+L2FhYUJBwcHsXfvXnHhwgUREhIiGjVqJO7duydKSkrE3bt3haWlpVi6dKm4e/euKCgoqPBY77//vggODhZCCLF8+XLRp0+fCvd9pEOHDuKTTz4pNTZ//nzRoEEDMXToUHHu3Dlx9OhRYWdnJ955551S++3bt08YGxuLwsLCp56HSNexACLSU08qgEaMGCHc3d212+UVQP/5z3+0r2/cuFEAEFFRUdqxxYsXizZt2mi33dzcRGRkZKnzLFiwQHTr1q3C4164cEEAEBcvXhRCCNG+fXvxwQcflJv58QJo9OjR4pVXXim1z6xZs4SHh4d228XFRbz++uvabY1GI5o2bSq+/fbbcs+Rl5cnjIyMxIYNG7RjRUVFwsHBQXz22WfaMSsrq1KFVnnUarVwcnISO3fuFEIIkZ6eLoyNjcW1a9ee+D4rKyvxww8/lBqbP3++MDMzEzk5OaU+q5+fX6n94uPjBQBx/fr1J56DSB+wBUZEZQghnrqWpkOHDtp/trW1BQC0b9++1FhaWhoAID8/H1evXsXEiRPRoEED7c/ChQtx9erVCo9rb28PANrjhIWFYeHChejRowfmz5+Ps2fPVpjv4sWL6NGjR6mxHj164MqVK6Wunvr7+WQyGezs7LTne9zVq1dRXFxc6rhGRkbo0qULLl68WGGW8vz666/Iz89Hv379AAA2NjbaRehP8uDBg1Ltr0dcXV1hYWGh3ba3ty/zOUxNTQEABQUFVcpKpItYABFRGRcvXkTz5s2fuI+RkZH2nx8VS4+PPbqaLC8vDwDw3XffIS4uTvtz/vx5nDhx4qnHfXScSZMm4dq1axg7dizOnTuHTp06Yfny5c/6Mcuc7/HcNWnVqlW4f/8+TE1NYWhoCENDQ+zduxfff//9E89vY2ODzMzMMuOV+Rz3798HADRp0qQaPgFR/cYCiIhK+e2333Du3LkqX2X0JLa2tnBwcMC1a9fQsmXLUj9PK7Qe5+TkhH/961/48ccfMXPmTHz33Xfl7ufu7o4//vij1Ngff/yB1q1bV+ny8b9zc3ODsbFxqeMWFxfj1KlT8PDwqPRx7t27h127dmHTpk2lCsLY2FhkZmbil19+qfC9Pj4++Ouvv54p//nz5+Ho6AgbG5tnej+RLjGUOgARSUelUiElJQVqtRqpqanYv38/Fi9ejAEDBuCNN96o1nN9+OGHCAsLg5WVFfr27QuVSoXTp08jMzMT4eHhlTrG9OnTERgYiNatWyMzMxOHDh2Cu7t7ufvOnDkTnTt3xoIFCzBixAhER0cjIiKi1JVnVWVubo4333wTs2bNgrW1NZydnfHZZ5+hoKAAEydOrPRx1q1bh8aNG+O1114r02rs168fVq1ahb59+5b73oCAAHz//ffPlP/333/Hq6+++kzvJdI1LICI9Nj+/fthb28PQ0NDNGrUCF5eXli2bBlCQkIgl1fvBPGkSZNgZmaGzz//HLNmzYK5uTnat2+P6dOnV/oYarUaoaGhuHXrFiwtLdG3b1989dVX5e7r6+uLLVu2YN68eViwYAHs7e3x0UcfYdy4cc/1OT755BNoNBqMHTsWubm56NSpEw4cOIBGjRpV+hirV6/GkCFDyl1nNWzYMIwdOxYZGRnlztSMGTMGs2fPxuXLl9GmTZtKn7OwsBA7d+7E/v37K/0eIl0mE0IIqUMQEVHlzZo1Czk5Ofj3v/9d6fd8++232LFjxxPba0T6hGuAiIjqmXfffRcuLi5VWqxtZGT03AvGiXQJZ4CIiIhI73AGiIiIiPQOCyAiIiLSOyyAiIiISO+wACIiIiK9wwKIiIiI9A4LICIiItI7LICIiIhI77AAIiIiIr3DAoiIiIj0zv8DRLIv6anir/EAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# graph of solution relative error vs matrix dimension\n",
        "plt.semilogy(xplot, Err)\n",
        "plt.title('Relative error')\n",
        "plt.xlabel('Dimension of A: n')\n",
        "plt.ylabel('Err = ||my_x-x||/||x||')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "-dKc66LRjJpr",
        "outputId": "56f5d973-dcdd-4574-c240-516ee76dcea4"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2.2.2 Failed Cholesky factorization due to rounding and algorithmic errors"
      ],
      "metadata": {
        "id": "mw8gQIgvkMs-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for n in range(5, 20):\n",
        "  A = scipy.linalg.hilbert(n)\n",
        "  try:\n",
        "    L = scipy.linalg.cholesky(A)\n",
        "  except:\n",
        "    print('Factorization failed for n =', n)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4eEemeRekLvA",
        "outputId": "00ccbe40-17e3-4f35-da20-fa918a3a6f23"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Factorization failed for n = 14\n",
            "Factorization failed for n = 15\n",
            "Factorization failed for n = 16\n",
            "Factorization failed for n = 17\n",
            "Factorization failed for n = 18\n",
            "Factorization failed for n = 19\n"
          ]
        }
      ]
    }
  ]
}